Elementi lessicali

Ogni programma scritto in un qualsiasi linguaggio di programmazione prima di essere eseguito viene sottoposto ad un processo di compilazione o interpretazione. Lo scopo di questo processo è quello di tradurre il codice sorgente in codice macchina, generando un'eseguibile. Ogni linguaggio prevede un certo numero di categorie lessicali e in DIV possiamo distinguere in particolare le seguenti categorie:

Commenti;
Segni di punteggiatura e operatori;
Dati;
Oggetti predefiniti;
Sentenze;
Processi;
Funzioni;

Analizziamoli più in dettaglio.

Commenti.
Come in qualsiasi altro linguaggio, i commenti hanno valore soltanto per il programmatore e vengono ignorati dal compilatore. E` possibile inserirli nel proprio codice in modi diversi: a secondo della lunghezza dei commenti, si può racchiuderli tra i simboli /* e */ o facendoli precedere dal simbolo //. Nel primo caso e considerato commento tutto quello che e compreso tra /* e*/, il commento quindi si può estendere anche su più righe o trovarsi in mezzo al codice, nel secondo caso va riferito solo alla riga che lo precede:

Program prova_1;  // questo è un commento su una sola riga
Begin
load_fpg("prova.fpg");  /* questo è un commento
                           diviso su più righe */
put_screen(0,2); /* commento su una sola riga compreso tra il codice */ frame;
End

Segni di punteggiatura e operatori.
Alcuni simboli sono utilizzati da DIV per separare i vari elementi sintattici o lessicali di un programma come operatori costruire e manipolare espressioni:questi assieme alle parole chiavi definite dal linguaggio non vanno assolutamente definire nomi processi dati. piùfrequenti in DIV:

Operandi: oltre ai numeri sono tutti i datifunzioni e oggetti.
Operatori aritmetici: ( ) + - * / %
Operatori logici: NOT AND OR XOR
Operatori di comparazione: == <> > >= < <=
Operatori puntatori: OFFSET POINTER
Operatori d'incremento e decremento: ++ --
Operatori binari: >> <<

Analizziamoli più in dettaglio con degli esempi.

Program prova_1;
Global 
  albero;  // creiamo un dato di nome albero
  mele;  // un contenitore e una variabile che può contenere qualsiasi valore
  totale = 0;  /* sarebbe una buona abitudine inizializzare una variabile
     nel caso non fosse stata inizializata DIv assegnerà sempre il valore 0 */
Begin
  albero = 10;    // assegniamo 10 alla variabile albero
  mele = albero;  /* assegniamo il valore della variabile albero a mele
  mele ora vale 10 poiché albero valeva 10 */
  totale = albero*mele;  /* il segno = viene utilizzato per assegnare 
         valori o risultati di espressioni in questo caso totale vale 100 */
 totale = totale + 10; //  totale ora vale 110
End

Il DIV è un linguaggio pesantemente basato sul paradigma imperativo, questo vuol dire che un programma DIV è sostanzialmente una sequenza di assegnamenti di valori a variabili. E` quindi naturale iniziare parlando proprio dell'assegnamento. L'operatore di assegnamento è denotato dal simbolo=uguale)

Il risultato dell'assegnamento e il valore prodotto dall'espressione della parte destra e a come effetto l'assegnazione di tale valore al dato definito nella parte sinistra (Dato) = (Espressione). Si osservi che una variabile può apparire sia a destra che a sinistra di un assegnamento, se tale occorrenza si trova a destra produce il valore contenuto nella variabile, se invece si trova a sinistra essa denota la locazione di memoria cui riferisce. Ancora, poiché un identificatore di variabile può trovarsi contemporaneamente su ambo i lati di un assegnamento è necessaria una semantica non ambigua: la semantica dell'assegnamento impone che prima si valuti la parte destra e poi si esegua l'assegnamento del valore prodotto all'operando di sinistra. Poiché un assegnamento produce come risultato il valore prodotto dalla valutazione della parte destra (e cioè a sua volta una espressione), e possibile legare in cascata più assegnamenti:

totale = albero = mele = 10; //  mele  albero e totale valgono 10
es.1  totale = albero * mele + 10;     //  totale vale 110 ma albero e mele
                                          continuano ad avere il valore 10 */
es.2  totale = albero * (mele += 10);  /* partendo sempre dalla prima
                                 espressione assegniamo il valore alle
                                       variabili totale e mele
                                       totale vale 200 mele vale 20
                                albero vale 10 */
es.3 totale = albero *= (mele += 10); /* Partendo sempre dalla prima 
                   espressione assegniamo valori a tutte le variabili 
                          totale vale 200 albero vale 200 mele vale 20 */

Questi sono i simboli di assegnazione operative:

Operatori Aritmetici.
Gli operatori aritmetici anno una loro priorità di esecuzione, è importante sapere la semantica con cui vengono valutate le espressioni, un'espressione può contenere operatori di differente livello di priorità o dello stesso livello, nel caso non vi siano le parentesi che ne indicano il modo nella quale si pretende sia valutata l'espressione, verranno eseguite prima quelle di priorità 1 poi quelle di priorità 2 e così via, nel caso in un'espressione si incontrassero più di un operatore binario dello stesso livello, questo si processerà da sinistra verso destra:

Livelli di priorità degli operatori:

Facciamo qualche esempio.

totale = albero = mele = 10;  // mele  albero e totale valgono 10
binario = 3;


es.1  totale += albero * mele + 10 * 2;  /*  totale vale 130
            prima valutazione albero * mele =100 e 10 * 2 =20 dopo 
            il risultato delle due moltiplicazioni verra sommato
            +  =120 e quindi sommato e assegnato a totale += =130. */


es.2  totale = albero * ( mele + 10 * 2 ); /* partendo sempre dalla prima
      espressione; in questo caso sono state utilizzate le ( ) parentesi che 
      nella regola di priorità equivale al primo livello questi modificano 
      la sequenza della funzione in quanto prima verra eseguito ciò che si 
      trova all'interno delle parentesi 10 * 2 =20 dopo mele + R =30 e 
      successivamente albero * R =300 il nuovo valore  verrà assegnato a 
      totale = 300 */

es.3  binario &=5;   /* binario e uguale a 1.
      Per chi non avesse conoscenza sul sistema binario questo tipo di
      assegnamento non va eseguito in modo decimale ma prima i numeri
      vengono convertiti in modo binario e poi verrà verificato AND logico
      ( & ) i numeri nel modo binario vengono convertiti in questo modo:
                      1=00001
                      2=00010
                      3=00011
                      4=00100
                      5=00101
                      6=00110 ecc.. quindi se noi vogliamo  calcolare
      la nostra espressione prima convertiremo i valori decimali in binari
   binario = 00011
        5  = 00101
            ______
             00001   verifichiamo il nostro AND che ci darà come risultato 1.
      AND  OR  e XOR binario considerano Vere o False le seguenti condizioni:
  AND &                 OR | ||                     XOR ^ ^^
  1 & 1 = 1 (Vero)       1 | 1 =1 (Vero)             1 ^ 1 =0 (Falso)
  1 & 0 =0  (Falso)      1 | 0 =1 (Vero)             1 ^ 0 =1 (Vero)
  0 & 1 =0  (Falso)      0 | 1 =1 (Vero)             0 ^ 1 =1 (Vero)
  0 & 0 =0  (Falso)      0 | 0 =0 (Falso)            0 ^ 0 =0  (Falso)  */

es.4  binario <<=4;  /* se dopo es.4 binario valeva 2 ora vale 34.
      questo tipo di assegnamento ruota il dato a sinistra tante volte quanto 
      indicato dal risultato dell'espressione nel nostro caso 4 volte,
      (ciascuna rotazione a sinistra equivale a moltiplicare il dato per 2)
 1         binario * 2=4                      binario = 000010 << 000100
 2         binario * 2=8                      binario = 000100 << 001000
 3         binario * 2=16                     binario = 001000 << 010000
 4         binario * 2=34                     binario = 010000 << 100000  */

es.5  binario >>= 4;   /* se binario valeva 34 ora vale 2.
      questo tipo di assegnamento ruota il dato a destra tante volte quanto 
      indicato dal risultato dell'espressione nel nostro caso 4 volte,
     (ciascuna rotazione a destra equivale a dividere il dato per 2)
 1         binario / 2=16                    binario = 100000 >> 010000
 2         binario / 2=8                     binario = 010000 >> 001000
 3         binario / 2=4                     binario = 001000 >> 000100
 4         binario / 2=2                     binario = 000100 >> 000010  */

Dati.
I dati costituiscono la base della programmazione. Per riservarci e utilizzare una posizione di memoria dobbiamo definire un dato, i dati sono simboli definiti dal programmatore, si può utilizzare qualsivoglia nome per definire un dato, tuttavia non potranno essere dichiarati dati che utilizzano lo stesso nome per due oggetti differenti (int dato, process dato ...), non potranno essere utilizzati nomi di dati che coincidano con nessuno degli oggetti predefiniti in DIV (PROCESS, BEGIN, IF ...) non potranno iniziare con un numero (1dato, 89_dato ...) o contenere degli spazzi (mio dato, suo dato ...), tuttavia saranno considerati validi i dati che dopo il primo carattere contengano dei numeri (dato1, dato_2 ...) e vi ricordo che non vi è alcuna differenza tra la dichiarazione di un dato in lettere maiuscole o in minuscole (Dato, DATO, dato, dATO ...) per DIV sarà lo stesso nome, visto che è possibile utilizzare dei caratteri speciali ma creerebbero ulteriore confusione vi descrivo alcuni caratteri quelli più comuni e validi per definire un nome di dato in DIV.

Tutti i dati dichiarati, DIV per default gli assegnerà il valore numerico 0 (zero), importante sapere che in DIV (ver.1.0 e 2.0) non si possono utilizzare numeri reali in virgola mobile ma solo numeri interi, il valore passera da 1 a 2 direttamente senza valori intermedi e comunque tutti i numeri dovranno essere compresi tra i valori -2147483648 e +2147483647, una volta creato un dato e volessimo modificare il valore all'interno del programma, dovremmo indicare prima la posizione di memoria riservata dal nome del dato e successivamente potremmo modificare il valore di quel dato. Dati sono simboli definiti dal programmatore per riferirsi a diverse categorie di contenitori:

Variabili:
Tabelle:
Strutture:

Tutti i dati possono essere di tipo Global Local Private e allo stesso modo apparire nella sessioneCONST(costante simbolica), le sessioni sono opzionali, sebbene, nel caso che appaiano devono farlo secondo quest'ordine e comprese tra la sessione CONST e BEGIN del programma principale, l'unica sessione che può apparire più volte oltre che nel programma principale, in un qualsiasi dei blocchi PROCESS (prima del BEGIN del processo) e la sessione PRIVATE. Questo perchè in questa sessione si dichiarano i dati di ambito privato, cioè i dati che appartengono esclusivamente di quel processo.

Global:Globali, che si riferiscono a tutto il programma, questo significa il dato potrà essere utilizzato da una qualsiasi posizione all'interno del codice.

Local:Locali, che il nome non si riferisce ad un unico dato ma bensì a vari dati quanto saranno i processi che ne faranno uso.

Private:Privati, saranno quei dati utilizzati esclusivamente dal solo processo o del programma che lo avrà dichiarato.

Ad esempio l'età di una persona (età) potrebbe essere il nome di dato il quale contiene il numero di anni di quella persona, questo dato sarebbe di tipo Local in quanto tutte le persone anno una loro età con un numero di anni differenti, mentre l'anno corrente (anno) potrebbe essere un dato di tipo Global in quanto tutte le persone, nel nostro caso processi potrebbero dipendere da quel dato mentre Private potrebbe essere il titolo di studio (studio) il cui si riferirà ad una caratteristica di quella determinata persona.

Variabili:
Le variabili sono contenitori di valori di un qualche tipo, ogni variabile puo`contenere un singolo valore che puo`cambiare nel tempo, il tipo di questo valore viene comunque stabilito una sola volta e non puo` cambiare, per dichiarare una variabile all'interno di una sezione (GLOBAL, LOCAL, PRIVATE) basterà indicarne il nome seguita dal simbolo ; (punto e virgola) (dato ;), in questo caso la variabile sarà inizializzata per default sul valore 0 (zero), se si vuole sia inizializzata su un altro valore si dovrà indicarne subito dopo il nome della variabile, il simbolo = (assegnazione) e di seguito il valore costante su cui si vuole inizializzare la variabile e in fine il simbolo ;(dato = 22 ;), se si vuole specificare un tipo diverso di quello INT che per default e quello che utilizza DIV, bisogna specificare il tipo all'inizio del nome (WORD dato ;), si possono infine dichiarare variabili dello stesso tipo separate da una , (virgola) (BYTE dato_1 , dato_2 =10). In Div ver.1.0 le variabili definite potevano essere esclusivamente di tipo INT (intero), nella ver.2.0 di DIV vi è la possibilità di dichiarare variabili nei formati INT (la parola INT può essere omessa visto che tutti i dati per difetto saranno di questo tipo e compresi tra -2147483648 e +2147483647, interi di 32 bit con segno - negativo), WORD (si potranno dichiarare variabili numeriche di tipo intero compresi tra 0 e 65535, interi di 16 bit senza segno - negativo), BYTE (si dichiarano variabili di tipo intero compresi tra 0 e 255, interi 8 bit senza segno - negativo), a questo punto credo sarà più chiaro capire se utilizziamo degli esempi:

Program prova_1 


CONST  /* Inizio della sessionele variabili definite di tipo costanti
   potranno essere utilizzate in un qualsiasi punto del programma
   una volta che verràassegnato il valore ad costante numerica suonon
   potrà più modificato simboliche servono identificare
   valori cambiano nel tempo possono considerate dei contenitorima
   solo nome per valore. La sezione deve iniziare obbligatoriamente 
   con parola riservata seguita da serie dichiarazione dati a cui
   faràseguito seguito dal numerico e virgola) */

 // creiamo  variabili di tipo costante

BYTE frutta = 200;  // costante di tipo BYTE, vale 200
frutta_1 = -20;  // costante di tipo INT, vale -20
INT frutta_2 , frutta_3 = 3;  // costante di tipo INT, frutta_2=0, frutta_3=3
WORD frutta_4;  // costante di tipo WORD, vale 0

 // Fine sessione CONST

GLOBAL  /* Inizio della sessione, GLOBAL le variabili definite di tipo  
   globali potranno essere utilizzate in un qualsiasi punto del programma.
   La sezione deve iniziare obbligatoriamente con la parola riservata GLOBAL
   seguita da una serie di dichiarazione di dati a cui farà seguito il
   simbolo ; (punto e virgola) */

 // creiamo  variabili di tipo globali

BYTE mele = 200;  // variabile di tipo BYTE, iniziata a 200
mele_1 = -20;  // variabile di tipo INT, iniziata a -20
INT mele_2 , mele_3 = 3;  //  variabili di tipo INT, frutta_2=0, frutta_3=3
WORD mele_4;  // variabile di tipo WORD, iniziata a 0

 // Fine sessione GLOBAL

LOCAL  /* Inizio della sessione, LOCAL le variabili definite di tipo locali 
   potranno essere utilizzate da tutti i processi che ne faranno 
   richiesta, ogni processo avrà la sua variabile che conterrà i propri 
   valori.La sezione deve iniziare obbligatoriamente con la parola riservata 
   LOCAL seguita da una serie di dichiarazione di dati a cui farà seguito il
   simbolo ; (punto e virgola) */

 // creiamo  variabili di tipo locali

BYTE pere = 200;  // variabile di tipo BYTE, iniziata a 200
pere_1 = -20;  // variabile di tipo INT, iniziata a -20
INT pere_2 , pere_3 = 3;  // variabili di tipo INT, frutta_2=0, frutta_3=3
WORD pere_4;  // variabile di tipo WORD, iniziata a 0

 // Fine sessione LOCAL

PRIVATE  /* Inizio della sessione, PRIVATE le variabili definite
   di tipo private potranno essere utilizzate e modificate solo all'interno 
   del processo che li avrà definiti, o dal programma principale, visto che 
   anche il programma principale viene considerato un processo.
   La sezione deve iniziare obbligatoriamente con la parola riservata PRIVATE
   seguita da una serie di dichiarazione di dati a cui farà seguito il
   simbolo ; (punto e virgola) */

 // creiamo  variabili di tipo privati

BYTE pesche = 200;  // variabile di tipo BYTE, iniziata a 200
pesche_1 = -20;  // variabile di tipo INT, iniziata a -20
INT pesche_2 , pesche_3 = 3;  // variabili di tipo INT, pesche_2=0, pesche_3=3
WORD pesche_4;  // variabile di tipo WORD, iniziata a 0

 // Fine sessione PRIVATE

Begin

End