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 <Var> = <Start> TO <End> [STEP <Size>]
<Ciclo>
NEXT [<Var>]

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 <Condizione> THEN <Istruzione> or
IF <Condizione> GOTO <NrLinea> or
IF <Condizione> THEN <NrLinea>

Esempio:
100 IF A < B THEN MN = A: GOTO 120
110 MN = B
120 ....

GOTO oppure GO TO - Salto incondizionale

Sintassi:
GOTO <NrLinea> oppure
GO TO <NrLinea>

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 <NrLinea>

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 <EspressioneIntera> GOTO <NrLinea1>, <NrLinea2> …
oppure ON <EspressioneIntera> GOSUB <NrLinea1>, <NrLinea2> …

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 <Nome>(<Param>) = <Espressione a Linea Singola>

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 <NomeVariabile>

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 [<Prompt>;] <NomeVariabile> [, <NomeVariabile> ...]

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 <Dati> oppure
? <Dati>

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(<Cnt>)

Esempio:
SPC(6)

TAB- Muove in avanti il cursore ad una specifica posizione

Sintassi:
TAB(<Posizione>)

Esempio:
TAB(6)

POS - Indica la posizione corrente del cursore

Sintassi (Dummy = valore non rilevante) ;
POS(<Dummy>)

Esempio:
POS(6)

Files

LOAD- Carica un programma da disco o nastro

Sintassi:
LOAD <FileName> [, <Dispositivo> [, <SecondoDisp>]]

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 <FileName> [, <Dispositivo> [, <SecondoDisp>]]

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 <FileName> [, <Dispositivo> [, <SecondoDisp>]]

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 <FileID>, <Dispositivo> [, <SecondoDisp> [, <FNameMode>]]
Il parametro <SecondoDisp> è 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.
<FNameMode> usa il formato format: “<NomeFile> [,<TipoFile> [,<ModoAccesso>]]" dove <TipoFile> può essere uno tra: P (Programma), S (Sequenziale), L (Relativo) or U (Utente)

<ModoAccesso> 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 <FileID>

Esempio:
CLOSE 1

GET# - Legge un singolo carattere da un file

Sintassi:
GET# <FileID>, <VarName>

Esempio:
GET#1, A$

Notare che NON c’è spazio tra ‘GET‘ e ‘#‘.

INPUT# - Recupera dati da un File

Sintassi:
INPUT# <FileID>, <VarName> [, <VarName>...]

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

Notare che NON c’è spazio tra ’INPUT‘ e ‘#‘.

PRINT# - Stampa dati su un File 

Sintassi:
PRINT# <FileID>, <Dati>

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 <FileID> [, <Messaggio>]

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 <Var> [, <Var>...]

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 <Dati> [, <Dati>...]

Esempio:
Vedi READ

Funzioni Matematiche

LET - assegna valore a un variabile

Sintassi:
LET <Variabile> = <Valore>

Esempio:

LET A = 6.25

Notare che il comando LET è innecessario e ridondante. <Variabile> = <Valore> è tutto ciò che serve per assegnare un valore a una variabile. LET rallenta l’intero processo, quindi NON USATELO!

DIM - Dichiarazione Array

Sintassi:
DIM <Nome>(<Dimensione1> [, <Dimensione2>...])

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(<Valore>)

Esempio:
SIN(π/3) -> 0.866025404

COS - Coseno (Argomenti in Radianti)

Sintassi:
COS(<Valore>)

Esempio:
COS(π/3) -> 0.5

TAN - Tangente (Argomenti in Radianti)

Sintassi:
TAN(<Valore>)

Esempio:
TAN(π/3) -> 1.73205081

ATN - Arco Tangente (Risultato in [-π/2 .. π/2])

Sintassi:
ATN(<Valore>)

Esempio:
ATN(1) -> 0.785398163 ( = π/4)

EXP - Esponentr (e^x dove e = 2.71828183…)

Sintassi:
EXP(<Valore>)

Esempio:
EXP(6.25) -> 518.012825

LOG - Logaritmo Naturale

Sintassi:

LOG(<Value>)

Esempio:
LOG(6.25) -> 1.83258146

SQR - Radice quadrata

Sintassi:
SQR(<Valore>)

Esempio:
SQR(6.25) -> 2.5

ABS - Valore Assoluto

Sintassi:
ABS(<Valore>)

Esempi:
ABS(-6.25) -> 6.25
ABS(0) -> 0
ABS(6.25) -> 6.25

SGN - Segno

Sintassi:
SGN(<Valore>)

Esempi:
SGN(-6.25) -> -1
SGN(0) -> 0
SGN(6.25) -> 1

INT - Intero (Arrotonda all’intero minore o uguale all’argomento.)

Sintassi:
INT(<Valore>)

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(<Seed>)
Se (<Seed> < 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:
<Expr> AND <Expr>

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:
<Expr> OR <Expr>

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 <Expr>

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(<Stringa>)

Esempio:
LEN("Power64") -> 7

LEFT$ - Parte sinistra della stringa

Sintassi:
LEFT$(<String>, <Lung>)

Esempio:
LEFT$("Power64", 5) -> "Power"

RIGHT$ - Parte destra della stringa

Sintassi:
RIGHT$(<String>, <Lung>)

Esempio:
RIGHT$("Power64", 5) -> "wer64"

MID$ - Parte centrale della stringa

Sintassi:
MID$(<String>, <Inizio>, <Lung>)

Esempio:
MID$("Power64 per Macintosh", 13, 3) -> "Mac"
/* -- 123456789012345678901 -- */

STR$ - Converte un numero in una stringa

Sintassi:
STR$(<Valore>)

Esempi:
STR$(6.25) -> " 6.25"
STR$(-6.25) -> "-6.25"

VAL - Converte una stringa in numero

Sintassi:
VAL(<String>)

Esempi:
VAL("6.25") -> 6.25
VAL("6xx25") -> 6
VAL("x6x25") -> 0

ASC- Codice ASCII del primo carattere di una stringa

Sintassi:
ASC(<String>)

Esempio:
ASC("P") -> 80
ASC("Power64") -> 80

CHR$ - Carattere corrispondente ad uno specifico codice ASCII

Sintassi:
CHR$(<Valore>)

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

Accesso alla Memoria

PEEK - Legge un byte dalla locazione di memoria

Sintassi:
PEEK(<Loc>)

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 <Loc>, <Valore>

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 <Loc>, <Maschera> [, <Inverti>]
WAIT il programma si arresterà fino a che ((PEEK(<Loc>) EXOR <Inverti>) AND <Maschera>) != 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 <Loc> [, <Param> ...]

Il numero di parametri dipende dal programma chiamato.

USR- Comando utente

Sintassi:
USR(<Param>)

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 [<Linea>]

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 <Linea> .

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 <Testo>

Esempio:
REM Questa linea è un commento

LIST - Mostra il listato del programma BASIC corrente

Sintassi:
LIST [<Linea> | <Da>- | -<A> | <Da>-<A>]
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(<Dummy>)

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%)

Sapete…qui nella redazione di The Retrogames Machine, nonostante il nome, non siamo appassionati solo di giochini ma siamo amanti della retro-informatica in generale.

Tempo permettendo traffichiamo sui nostri macinini anche per tirare fuori qualche (piú o meno utile) esercizio di programmazione e ci vantiamo pure di avere dei “BEI” programmatori  (sottile gioco di parole…) nel nostro staff.

Sappiamo che tanti lettori vorrebbero avvicinarsi (o RI-avvicinarsi) alla programmazione dei loro computer preferiti ma magari dopo tanti anni si ritrovano un po’arrugginiti e hanno bisogno di uno stimolo per andare in bagn… cominciare a darsi da fare con il proprio gingil… AAARGH!!!! Vabbé insomma, ci siamo capiti… passimo oltre….

In redazione siamo convinti sostenitori dell’importanza della diffusione della cultura retroinformatica non solo come memoria storica ma anche come “approccio” alla soluzione dei problemi in quanto tale pratica sviluppa elementi di analisi in condizioni di non abbondanza di risorse.
Un approccio quindi votato all’ottimizzazione, alla creatività e contrario allo spreco e alla pratica routinaria.

Per questo vi informiamo che, per perseguire i nostri propositi di preservazione e mettere in moto un certo  discorso “divulgativo”, pubblicheremo, con cadenza ASSOLUTAMENTE CASUALE ED APERIODICA, delle risorse di programmazione principalmente dedicate, ovviamente, alle macchine classiche (o come  si dice oggi: retroprogrammazione) senza però disdegnare alcune digressioni in tema “”GGiovini” ma sempre con un occhio alla old-school che tanto ci è cara.

I contributi che proporremo saranno i più vari: tutorial mirati, soluzioni di problemi specifici, articoli tecnici, eccetera.
Il progetto che però forse più ci è caro e al contempo ambizioso è realizzare una sorta di diario di sviluppo tenuto da un singolo redattore, o gruppo di redattori, impegnati nella realizzazione di un progetto specifico o nello studio di una determinata materia, nel quale tenere traccia dei progressi, i fallimenti, gli ostacoli e le soluzioni… insomma, della vita di un programmatore più o meno provetto e condividerla con la nostra comunità.

Speriamo che apprezzerete le iniziative che metteremo in moto in questo senso.

Approfittando del fine settimana ho cercato di mettere un po’ di ordine nel marasma di documentazione retroinformatica che ho accumulato nei miei hard disk. Sscansioni di documenti, manuali e libri vari affollavano i miei supporti magnetici senza una minima catalogazione e spesso capitava di ignorare persino ciò che avevo o l’ubicazione di ciò che ero sicuro di avere. L’idea era di organizzare uno “spazio di lavoro” per poter approfondire la programmazione di alcune macchine in maniera più ragionata.

Lungi dall’aver terminato di sistemare il caos imperante (la lotta in questo senso sarà lunga) devo dire che i frutti che tuttavia ho ottenuto da questo lavoro sono stati davvero piacevolmente sorprendenti!

Ho scoperto infatti di avere  già da tempo immagazzinato tra la varia documentazione, le scansioni dell’edizione italiana del libro MSX2 Basic + MSX DOS di A. Sickler e A. Van Utteren, l’edizione distribuita da Philips coi suoi MSX2.

Sembra sia un libro abbastanza ricercato nella nostra lingua, io stesso, ignorando fin’ora di averlo, avevo precedentemente contattato diversi utenti MSX molto più navigati di me per trovarlo ma sembra che fosse proprio difficile ottenerlo.

E invece, quando mi ero rassegnato a usare il PDF dell’edizione francese e stavo valutando l’acquisto di una copia spagnola, frugando in un bell’archivione MSX che avevo già da diverso tempo tra i libri italiani guarda un po’ cosa ti salta fuori!

La scansione proprio di quest’oggettino del desiderio (almeno mio).

Lesto monto un PDF dalle scan delle singole pagine e subito mi balena l’idea che forse anche qualcun altro potrebbe esserne alla ricerca, e quindi lo metto a disposizione di tutti tramite il link alla fine di quest’articolo che potrete incontrare anche nella sezione “Download” del blog.

Spero che vi possa essere utile, fatemi sapere.
Link: (Libri – MSX) MSX2 Basic + MSX DOS Philips (A. Sickler – A. Van Utteren)