La sintassi (parte prima)

L'Object Pascal usa il set di caratteri ASCII, comprendente le lettere dalla A
alla Z e dalla a a alla z, le cifre da 0 a 9 e gli
altri caratteri standard. Non fa distinzione tra maiuscole e minuscole, come il C++ o il
Java o Javascript. Tutti i caratteri quali lo spazio (ASCII 32) ed i caratteri di
controllo, come il carattere di ritorno o di fine riga etc. (ASCII 0 a 31), vengono
chiamati Blank. La più piccola unità significativa di testo in un programma è il token.
Questo è composto da una istruzione o da un'espressione o da una dichiarazione. Quindi un
programma è una sequenza di token separati da separatori (spazio o commento). È
quindi legale scrivere nel codice

Pippo:=1;Pluto:=2;

Per motivi di leggibilità e di convenzione, però, si preferisce utilizzare il formato
seguente:

Pippo := 1; Pluto : = 2;

I token si suddividono in simboli speciali, identificatori, parole
riservate, direttive, numerali, etichette, stringhe di
caratteri.

Quelli che seguono sono simboli speciali:

# $ & ' ( ) * + , - . / : ; < > = @ [ ] ^ { }

Anche la combinazione di alcuni di essi rientra nei simboli speciali:

.. // (* (. *) .) := <> <= >=

Non fanno parte dei simboli speciali i seguenti caratteri:

! "(doppio apostrofo) ? % _(sottolineatura)| (pipe)~ (tilde)

Identificatori

Gli identificatori indicano variabili, costanti, procedure, funzioni, tipi, etc.
Possono avere una lunghezza qualunque e devono iniziare con una lettera o con un carattere
di sottolineatura (_) e non possono contenere spazi. Se è necessario, per una maggiore
leggibilità del codice, si può utilizzare il carattere sottolineatura (_).

Alcuni esempi di identificatori:

Count / Count / cOunt / counT / _Pippo / _pippo / Items_Count / Items_count / Search_for

Numerali

In Object Pascal i numeri reali ed interi possono essere rappresentati sia in forma
decimale che in forma esadecimale. La prima forma è composta da sequenze di numeri
separati o no da punti e possono essere precedute dai segni + o - per indicarne il segno.
Per i numeri interi non è possibile utilizzare il punto (ovviamente, se sono interi!). Un
esempio di numero intero è 23989, +23989 oppure -56739. I numeri reali possono altresì
essere rappresentati in forma esponenziale inserendo all'interno della sequenze di numeri
il carattere E o e seguito da un numero (positivo o negativo). Questo
carattere sta ad indicare che il numero alla sua sinistra va moltiplicato per 10 elevato
al numero alla sua destra. Per esempio:

7E-2 equivale a 7 x 10^-2

12.25e6 e 12.25E+6 equivalgono entrambi a 12.25 x 10⁶

Stringhe di caratteri

In Object Pascal le stringhe di caratteri sono racchiuse tra apostrofi ('). Due
apostrofi che non racchiudono alcuna carattere identificano una stringa null. Ad
esempio '' (occhio, sono due apostrofi adiacenti non le virgolette, quelle sopra il
2 nella tastiera!). Alcuni si chiederanno come è possibile rappresentare all'interno di
una stringa il carattere apostrofo visto che quest'ultimo delimita la stringa stessa.
Bene, per rappresentare un apostrofo all'interno di una stringa basta ripeterlo due volte,
per esempio 'L''anno scorso'. Una stringa composta solamente da un apostrofo appare così
''''. Uno spazio, invece, apparirà così ' '. È possibile inserire all'interno di una
stringa di caratteri, sequenze di caratteri di controllo utilizzando il simbolo #
seguito dal codice ASCII del codice stesso. Ad esempio, la stringa 'Questa stringa termina
con un a capo ed avanzamento riga.'#13#10.

Commenti

Come in quasi tutti i linguaggi di programmazione, per documentare o
"commentare" il codice sorgente, è possibile inserire, tramite particolari
costrutti, dei commenti. In Pascal esistono vari modi per inserire commenti all'interno
del codice sorgente. Si può far precedere il commento da //. Per esempio

Var Pippo : Integer; //Commento

In questo caso il commento terminerà con la fine della riga del codice. Per utilizzare
commenti su più righe, si possono impiegare le parentesi graffe {}. Ad esempio

Unit Unit1;

{ Questo commento

si sviluppa

su più righe }

...

Direttive del compilatore

Le direttive del compilatore sono particolari direttive che non influiscono
sull'esecuzione del programma ma sulla compilazione del codice sorgente. Queste sono dei
commenti che hanno come primo carattere, all'interno delle parentesi graffe {} o dei
simboli (* *), il carattere $ (dollaro). Un esempio di direttiva lo abbiamo già visto nel
primo esempio di programma all'inizio del corso

{$APPTYPE CONSOLE}

In questo caso la direttiva indica al compilatore che il programma dovrà essere
compilato per essere eseguito dalla console e non nell'ambiente grafico di windows.

Esistono molte direttive per il compilatore e per un elenco completo si rimanda ai
manuali del linguaggio od alla guida in linea.

Operatori

Un operatore si comporta come le funzioni che fanno parte del linguaggio. Per esempio
se sia ha qualcosa del tipo (X + Y), che è composta da due operandi (X , Y) e da un
operatore (+), nel caso in cui X ed Y rappresentino dei numeri, l'espressione restituirà
la loro somma.

In Object Pascal esistono vari tipi e categorie di operatori. Ci sono operatori
aritmetici, per logica booleana, per la manipolazione logica a livello di bit, di stringa,
di puntatore, per i set, relazionali e classe.

Operatori aritmetici

Segue un elenco degli operatori aritmetici definiti in Object Pascal:

Come è facilmente comprensibile, tutti gli operatori sopra riportati sono operatori
binari, accettano cioè due operandi.

Per i prime quattro operandi non si sono problemi. Vediamo invece come si comporta
l'operatore div. Questo operatore effettua la divisione tra operandi di tipo
integer e restituisce un integer. In pratica questo operando restituisce il risultato di X
/ Y arrotondandolo all'intero per difetto.

Vediamo un esempio:

X / Y (con X = 9 e Y = 2) resituisce 4,5

X div Y (con X = 9 e Y = 2) resituisce 4

L'operatore mod restituisce il resto della divisione intera dei suoi operandi.
Accetta operandi di tipo integer e il risultato è di tipo integer. Con riferimento
all'esempio precedente abbiamo che

X mod Y (con X = 9 e Y = 2) resituisce 1

perché equivale a

X - (X div Y) * Y = 9 - (9 div 2) * 2 = 1 (N.B. l'operatore di
moltiplicazione, come altre che vedremo di seguito, ha la precedenza rispetto alla
sottrazione quindi prima viene risolto il contenuto tra parentesi, poi viene effettuata la
moltiplicazione tra il risultato precedente e 2 ed infine viene sottratto a 9 il risultato
delle operazioni precedenti: 9 div 2 = 4; 4 * 2 = 8; 9 - 8 = 1)

IMPORTANTE: da segnalare che nelle espressioni X / Y, X div Y, X mod
Y, ove Y sia uguale a 0 (zero) si verifica un errore di divisione per zero

L'operatore + e l'operatore - sono impiegati anche come operatori unari ovvero si
applicano ad un solo operando. Essi servono a definire il segno di una espressione. Si
applicano ad operandi di tipo integer o real e il risultato restituito è dello stesso
tipo dell'operando a cui si è applicano ma con il segno opportunamente cambiato.