Breve prontuario dei comandi Commodore Basic V2

MetalRedStar — Thu, 19 Dec 2013 13:21:11 +0000

Nell’ambito della nostra iniziativa votata a riaccendere nei nostri lettori la fiamma dell’interesse nei confronti della programmazione cominciamo con le basi.

Un breve riassunto dei comandi del Commodore Basic V2 utilizzato dal Commodore64 (oltre che dal VIC20 e i Commodore PET). Attenzione! Questo non è un tutorial sul Commodore Basic ma una sorta di guida di riferimento per riaccendere in neuroni spenti (o mai accesi…).

Nel basic V2 sono disponibili unicamente i seguenti tipi di variabili:

Float: È il tipo usato più frequentemente ed indica i numeri positivi e negativi dotati di parte intera e decimale. Non hanno indicatore di tipo nella loro dichiarazione.
Valori possibili: +/- [2.94E-39 ... 1.70E+38] (+/- [2^-128 ... 2¹²⁷])
Precisione: mantissa a 32 bit (approx. 9.6 decimali) + esponente a 8 bit
Interi (16 Bit): Tipo di tati raramente utilizzato. Le variabili ntere si caratterizzano per un ‘%’ alla fine della loro ‘etichetta’ (es. X%). È bene notare che tutti i calcoli computazionali sono effettuati con precisione FLOAT e la conversione a Intero è effettuata solo quando il valore è assegnato alla variabile. Quindi la matematica di tipo intero è PIÙ LENTA che quella di tipo float!
Booleani: I risultati sono espressi con interi. FALSO è rappresentato da 0 (0×0000) mentre VERO da -1 (0xFFFF) o qualunque risultato NON-ZERO
Stringhe: Le variabili “stringa” si identificano per il simbolo ‘$’ posto dopo l’etichetta identificativa (es. X$). Le stringhe non possono essere più lunghe di 255 caratteri.

Solo i primi DUE caratteri dell’etichetta di una variabile sono presi in considerazione dall’interprete BASIC. Quindi ‘CO’, ‘COCCO’ e ‘COLOSSEO’ sono nomi equivalenti di una singola variabile (ma non ‘C’ o ‘CA’).

L’identificatore di tipo, invece, identifica e distingue variabili con la stessa etichetta. Quindi ‘CO’, ‘CO%’ e ‘CO$’ sono TRE variabili diverse.

Controllo del flusso del programma

FOR...TO...STEP...NEXT - L’unico costrutto di ciclo del BASIC V2: Sintassi:
FOR = TO [STEP ] NEXT []

Esempi:

FOR I=1 TO 5: PRINT I;: NEXT -> 1 2 3 4 5 FOR I=1 TO 5 STEP 2: PRINT I;: NEXT -> 1 3 5 FOR I=5 TO 1 STEP -2: PRINT I;: NEXT I -> 5 3 1 FOR I=3 TO 1: PRINT I;: NEXT -> 3 (!)
IF...THEN - Esecuzione condizionale: Nota: Non esiste nulla di similare ai costrutti ELSE o ENDIF. (tra l’altro NESSUN BASIC eccetto l’MSX BASIC implementa l’ELSE)

Sintassi:
IF THEN or
IF GOTO or
IF THEN

Esempio:
100 IF A < B THEN MN = A: GOTO 120 110 MN = B 120 ....
GOTO oppure GO TO - Salto incondizionale: Sintassi:
GOTO oppure
GO TO
GOSUB - Salto incondizionale a Subroutine: Notare che non è possibile passare parametri formali ad una subroutine. Tutto deve essere gestito con l’uso di variabili globali.; Sintassi:
GOSUB

Esempio:
10 PRINT "Programma principale" 20 GOSUB 100 30 PRINT "Ritorno a Programma principale" 40 GOSUB 100 50 PRINT "Di nuovo Programma principale" 60 END 100 PRINT "Questa è la Subroutine" 110 RETURN
RETURN - Ritorno dalla Subroutine: Sintassi:
RETURN

Esempio:
Vedi: GOSUB
ON...GOTO oppure ON...GOSUB - Salto multi direzionale: Sintassi:
ON GOTO , …
oppure ON GOSUB , …

Esempio:
ON X GOTO 100, 200, 300
È equivalente a :
IF X = 1 THEN GOTO 100 IF X = 2 THEN GOTO 200 IF X = 3 THEN GOTO 300
DEF FN- Definisce una Funzione/Subroutine in BASIC: Sintassi:
DEF FN () =

Esempio:
DEF FN SI(X) = SIN(X)/X FN SI(π/3) -> 0.816993343

Input/Output

GET - Legge un singolo carattere dallo standard input (normalmente tastiera) senza attendere: Sintassi:
GET

Esempio:
100 GET A$: IF A$ = "" THEN GOTO 100 -> Attende la pressione di un tasto
INPUT -Legge i dati dallo standard input (normalmente tastiera): Sintassi:
INPUT [;] [, ...]

Esempi:
INPUT "LOGIN:"; LG$ INPUT "Introdurre valori di A, B e C"; A, B, C INPUT A
PRINT - Scrive sullo standard output (normalmente schermo): Sintassi:
PRINT oppure
?

Esempi:
PRINT "Ciao Mondo" PRINT "Queste", "sono", "Tabulazioni" -> Notare le ',' PRINT "Prima Linea"; -> Notare il ';' PRINT "Still the same line" PRINT "Risultato="; 2*32
SPC - Muove in avanti il cursore di un determinato numero di spazi: Sintassi:
SPC()

Esempio:
SPC(6)
TAB- Muove in avanti il cursore ad una specifica posizione: Sintassi:
TAB()

Esempio:
TAB(6)
POS - Indica la posizione corrente del cursore: Sintassi (Dummy = valore non rilevante) ;
POS()

Esempio:
POS(6)

Files

LOAD- Carica un programma da disco o nastro: Sintassi:
LOAD [, [, ]]

Esempi:
LOAD "SuperGame", 8, 1 -> Carica il programma da disco #8 LOAD "*", 9 -> Carica il primo programma da disco #9 LOAD "", 1 -> Carica il primo programma da nastro(#1)
SAVE - Salva un programma su disco o nastro: Sintassi:
SAVE [, [, ]]

Esempi:
SAVE "SuperGame", 8 -> Salva su disco #8
Per sovrascrivere un file esistente su disko, far precedere il nome del file dal carattere ‘@’

Esempio:
SAVE "@SuperGame",8 -> Salva su disco #8, sovrascrive vecchio file
VERIFY - Controlla se il programma in memoria e quello registrato su disco o nastro coincidono. Non modifica nulla.: Sintassi:
VERIFY [, [, ]]

Examples:
VERIFY "SuperGame", 8 -> Verifica SuperGame da disco #8 VERIFY "*", 9 -> Verifica il primo programma da disco #9 VERIFY "", 1 -> Verifica il primo programma da nastro #1
OPEN- Apre un flusso dati (File): Sintassi:
OPEN , [, [, ]]
Il parametro è un intero opzionale compreso tra 0-15 che,secondo il valore assegnato ,assume i seguenti significati:
0..Utilizzato per LOAD, 1..Utilizzto per SAVE, 2-14..Liberamente utilizzabile per accesso a file utente, 15..Canale di Comando/Errore.
usa il formato format: “ [, [,]]" dove può essere uno tra: P (Programma), S (Sequenziale), L (Relativo) or U (Utente)

può essere uno tra: R (Lettura),W (Scrittura), A (Aggiunta) o il numero di Bytes/Record di un file relativo.

Esempi:
OPEN 1, 4 -> Apre un file di output sulla stampante #4 OPEN 1, 8, 2, "My File,P,R" -> Apre un programma, per la lettura, da disco #8 OPEN 1, 8, 2, "My File,S,W" -> Apre un file sequenziale, per la scrittura su disco #8 OPEN 1, 8, 2, "My File,L,"+CHR$(40) -> Apre un file relativo con 40 Bytes/Record su disco #8 OPEN 1, 8, 15 -> Apre il canale Comando/Errore su disco #8
CLOSE - Chiude un flusso dati (File): Sintassi:
CLOSE

Esempio:
CLOSE 1
GET# - Legge un singolo carattere da un file: Sintassi:
GET# ,

Esempio:
GET#1, A$

Notare che NON c’è spazio tra ‘GET‘ e ‘#‘.
INPUT# - Recupera dati da un File: Sintassi:
INPUT# , [, ...]

Esempio:
INPUT#1, EN$, ER$, TR$, SC$

Notare che NON c’è spazio tra ’INPUT‘ e ‘#‘.
PRINT# - Stampa dati su un File: Sintassi:
PRINT# ,

Esempio:
PRINT#1, "Power64"

Notare che NON c’è spazio tra ‘PRINT‘ e ’#‘. Notare anche che ?# NON è PRINT# anche se appaiono uguali in un listato.
CMD - Redireziona lo standard output (Input non è modificato ) e scrive messaggi su esso: Sintassi:
CMD [, ]

Esempio:
OPEN 1, 4 ; Apre un File#1 su Stampante#4 CMD 1 ; Rende #1 lo standard output PRINT "Messaggio" PRINT "Messaggio2" PRINT#1 CLOSE 1
ST - Stato di un dispositivo (Variabile interna): ST = 0 .. Dispositivo Ok
Bit 6: 1 .. Fine del File
Bit 7: 1 .. Dispositivo non presente
READ - Legge dati statici dalle istruzioni DATA nel programma: Sintassi:
READ [, ...]

Esempio:
10 RESTORE 20 READ X$ 30 PRINT X$; 40 S = 0 50 FOR I=1 TO 3 60 READ X 70 S = S + X 80 NEXT I 90 PRINT S 100 DATA "Power", 12, 34, 18
L’output dell’esempio sarebbe Power 64
RESTORE - Resetta al primo elemento DATA del programma il puntatore a DATA.: Sintassi:
RESTORE

Esempio:
Vedi READ
DATA- Immagazzina dati statici: Sintassi:
DATA [, ...]

Esempio:
Vedi READ

Funzioni Matematiche

LET - assegna valore a un variabile: Sintassi:
LET =

Esempio:

LET A = 6.25

Notare che il comando LET è innecessario e ridondante. = è tutto ciò che serve per assegnare un valore a una variabile. LET rallenta l’intero processo, quindi NON USATELO!
DIM - Dichiarazione Array: Sintassi:
DIM ( [, ...])

Esempi:
DIM A(7) -> Array di 8(!) elementi indicizzati [0..7]
DIM B$(4,5) -> Array di 30(!) stringhe [0..5 x 0..6]
Uso degli elementi: A(3) = 17 : B$(2,3) = "Power64"
+, -, *, /, ^ - Operatori Aritmetici: Esempio:
9 + 5 * (15 - 1) / 7 + 2^4 -> 35
<, <=, =, <>, >=, > - Operatori di confronto: Esempio:
3 <> 6 -> -1 (VERO)
3 > 4 -> 0 (FALSO)
SIN - Seno (Argomenti in Radianti): Sintassi:
SIN()

Esempio:
SIN(π/3) -> 0.866025404
COS - Coseno (Argomenti in Radianti): Sintassi:
COS()

Esempio:
COS(π/3) -> 0.5
TAN - Tangente (Argomenti in Radianti): Sintassi:
TAN()

Esempio:
TAN(π/3) -> 1.73205081
ATN - Arco Tangente (Risultato in [-π/2 .. π/2]): Sintassi:
ATN()

Esempio:
ATN(1) -> 0.785398163 ( = π/4)
EXP - Esponentr (e^x dove e = 2.71828183…): Sintassi:
EXP()

Esempio:
EXP(6.25) -> 518.012825
LOG - Logaritmo Naturale: Sintassi:

LOG()

Esempio:
LOG(6.25) -> 1.83258146
SQR - Radice quadrata: Sintassi:
SQR()

Esempio:
SQR(6.25) -> 2.5
ABS - Valore Assoluto: Sintassi:
ABS()

Esempi:
ABS(-6.25) -> 6.25 ABS(0) -> 0 ABS(6.25) -> 6.25
SGN - Segno: Sintassi:
SGN()

Esempi:
SGN(-6.25) -> -1 SGN(0) -> 0 SGN(6.25) -> 1
INT - Intero (Arrotonda all’intero minore o uguale all’argomento.): Sintassi:
INT()

Esempi:
INT(-6.25) -> -7 (!) INT(-5) -> -5 INT(0) -> 0 INT(5) -> 5 INT(6.25) -> 6
RND - Numero casuale tra [0.0 .. 1.0]: Sintassi:
RND()
Se ( < 0) il generatore di numeri casuali viene inizializzato.

Esempi:
RND(-625) -> 3.85114436E-06 RND(0) -> 0.464844882 RND(0) -> 0.0156260729

Operatori Logici e Binari

Ricordiamo la codifica dei valori Booleani
FALSO <--> 0 (0x0000) e VERO <--> -1 (0xFFFF) or o qualunque valore non-zero.

AND- AND logico e binario: Sintassi:
AND

Esempi:
A>5 AND X<=Y 12 AND 10 -> 8 (%1100 AND %1010 = %1000) - operazione di confronto sui bit
OR - OR logico e binario: Sintassi:
OR

Esempi:
A>5 OR X<=Y 12 OR 10 -> 14 (%1100 OR %1010 = %1110) - operazione di confronto sui bit
NOT- NOT logico e binario: Sintassi:
NOT

Esempi:
NOT A>5 NOT 2 -> -3 (NOT $0002 = $FFFD) - operazione di confronto sui bit

Manipolazione di Caratteri e Stringhe

+ - Concatena Stringhe: Esempio:
"Pow" + "er64" -> "Power64"
<, <=, =, <>, >=, > - Operatori di confronto: Esempi:
"C64" < "Power64" -> -1 (VERO) "Alpha" > "Omega" -> 0 (FALSO)
LEN - Lunghezza stringa: Sintassi:
LEN()

Esempio:
LEN("Power64") -> 7
LEFT$ - Parte sinistra della stringa: Sintassi:
LEFT$(, )

Esempio:
LEFT$("Power64", 5) -> "Power"
RIGHT$ - Parte destra della stringa: Sintassi:
RIGHT$(, )

Esempio:
RIGHT$("Power64", 5) -> "wer64"
MID$ - Parte centrale della stringa: Sintassi:
MID$(, , )

Esempio:
MID$("Power64 per Macintosh", 13, 3) -> "Mac"
/* -- 123456789012345678901 -- */
STR$ - Converte un numero in una stringa: Sintassi:
STR$()

Esempi:
STR$(6.25) -> " 6.25" STR$(-6.25) -> "-6.25"
VAL - Converte una stringa in numero: Sintassi:
VAL()

Esempi:
VAL("6.25") -> 6.25 VAL("6xx25") -> 6 VAL("x6x25") -> 0
ASC- Codice ASCII del primo carattere di una stringa: Sintassi:
ASC()

Esempio:
ASC("P") -> 80 ASC("Power64") -> 80
CHR$ - Carattere corrispondente ad uno specifico codice ASCII: Sintassi:
CHR$()

Esempio:
CHR$(80) -> "P"

Accesso alla Memoria

PEEK - Legge un byte dalla locazione di memoria: Sintassi:
PEEK()

Esempio:
PEEK(53280) -> Valore corrente del byte che determina il colore del bordo dello schermo
POKE - Scrive un byte in una locazione di memoria: Sintassi:
POKE ,

Esempio:
POKE 53280, 7 -> Imposta a 7 il valore del che determina il colore del bordo dello schermo, ottenendo il bordo giallo
WAIT - Attende finché il byte di una locazione di memoria assume un certo valore: Sintassi:
WAIT , [, ]
WAIT il programma si arresterà fino a che ((PEEK() EXOR ) AND ) != 0
Se <Inverti> non è specificato assume valore di default 0.

Esempio:
WAIT 198, 255 -> Attende la pressione di un tasto nel buffer tastiera.

Interfaccia a programmi in Assembly

SYS - System – Richiama un programma assembler da una locazione di memoria: Sintassi:
SYS [, ...]

Il numero di parametri dipende dal programma chiamato.
USR- Comando utente: Sintassi:
USR()

Simile a SYS ma la locazione di memoria <Loc>a cui si punta è fissa a $0310 ed il primo ed unico parametro <Param> è sempre valutato e memorizzato nel FloatAccu1 (FAC1) quando il programma assembly viene chiamato. Meno flessibile di SYS e quindi raramente utilizzato.

Esecuzione Programmi

RUN - Avvia un programma BASIC: Sintassi:
RUN []

Se <Linea> non è specificato il programma inizia dalla prima linea.

Esempio:
RUN
STOP- Arresta l’esecuzione di un programma: Sintassi:
STOP

STOP è simile ad END, ma stampa il messaggio BREAK IN .
END - Conclude l’esecuzione di un programma: Sintassi:
END
CONT - Continua l’esecuzione di un program: Sintassi:
CONT

Quando l’esecuzione di un programma è interrotta da by STOP, END o dalla pressione del tasto Run/Stop il comando CONT viene usato per riprendere l’esecuzione.

Vari

REM - Commento: Sintassi:
REM

Esempio:
REM Questa linea è un commento
LIST - Mostra il listato del programma BASIC corrente: Sintassi:
LIST [ | - | - | -]
Senza parametri l’intero programma viene listato.

Esempi:
LIST LIST -40 LIST 100-200
NEW - Cancella il programma corrente e tutte le variabili dalla memoria: Sintassi:
NEW
CLR - Cancella tutte le variabili: Sintassi:
CLR
FRE - Indica la memoria disponibili: Sintassi:
FRE()

Esempio:
FRE(0) -> -26627 (immediatamente dopo l’accensione)

Restituisce il numero di Bytes liberi per i programmi BASIC come un intero a 16 bit con segno. Se la memoria libera eccede i 38KByte viene indicato un numero negativo. Quindi -26627 dovrebbe essere interpretato come 65536-26627 = 38909.
π - Pi = 3.14159265
TI - Timer Ticks trascorsi dall’accensione (1 Tick = 1/60 Second)
TI$ - Timer dall’accensione in Ore/Minuti/Secondi
A TI$ (ma non a TI) può essere assegnato un valore!: La precisione del timer è piuttosto scarsa (scarto >1%)

the Retrogames Machine » commodore basic