Linguaggi Di Programmazione Caso Di Studio

CASO DI STUDIO:

LINGUAGGI

DI

PROGRAMMAZIONE

ANNO 2006/07

Pag. 1 di 15

Documentazione Caso di studio Linguaggi di programmazione

Data la grammatica di un (frammento di un) linguaggio di programmazione, mediante strumenti

automatici (ANTLR o JavaCC), realizzare in linguaggio Java un programma che implementi:

uno scanner per un linguaggio di programmazione di cui viene documentato formalmente

il vocabolario

un parser ricorsivo discendente per un frammento di linguaggio di programmazione

ANALISI

L’obiettivo è scrivere una grammatica dalla quale generare attraverso JavaCC le classi Lexer e

Parser che compongono l’analizzatore sintattico del linguaggio di programmazione che si propone.

Si parte dalla scelta del linguaggio di programmazione oggetto del caso di studio e si fornisce

l’alfabeto.

Il linguaggio di programmazione posto all’attenzione è il Pascal con alcuni richiami di Java.

Il linguaggi da implementare sarà una forma italianizzata dei linguaggi di programmazione appena

menzionati.

Tutte le parole chiave sono in lingua italiana per un più facile utilizzo dello strumento stesso.

I costrutti utilizzati sono :

• begin … end che italianizzato diverrà inizio … fine ; questo è preso dal linguaggio pascal ed

è utile al fine di rendere più chiara la lettura del codice ed eliminare l’ambiguità legata al

costrutto if … then … else.

Pag. 2 di 15

https://javacc.dev.java.net/

http://www.antlr.org/

• If… then … else italianizzato se … allora … altrimenti ; costrutto di selezione .

• while… do che diverrà fintanto che(condizione) fai… seguita dal costrutto inizio … fine

costrutto di ciclo a controllo in testa. La sua sintassi è presa dal linguaggio Java.

• repeat … until(condizione) che diverrà ripeti … finchè (condizione) ; costrutto a ciclo a

controllo in coda. Anche questo è preso dal linguaggio java.

• for (inizializzazione, condizione, passo) …. ; sarà scritto come Per (inizializzazione,

condizione, passo). Sintassi dal linguaggio Java.

Per implementare la sintassi delle espressioni matematiche varrà la seguente forma :

variabile = variabile | numero reale | espressione matematica, dove l’espressione aritmetica è

formata da operazioni aritmetiche tra variabili. Per definire l’ordine delle operazioni si potranno

usare le parentesi tonde.

Saranno previsti inoltre comandi per le operazioni base di un linguaggio di programmazione quale

la stampa a video di una variabile e l’acquisizione da tastiera di una variabile .

Le variabili che il compilatore progettato tratterà saranno dei seguenti tipi:

• Interi

• Reali

• Reali a singola precisione

• Reali a doppia precisione

• Carattere

• Stringa

• Booleano

• Puntatore

Un identificatore sarà formato da un insieme di caratteri. Tutte le lettere devono essere

maiuscole.

Le parole chiave invece dovranno essere scritte interamente in minuscolo poiché il linguaggio sarà

case sensitive.

Inoltre la sintassi di un programma sarà divisa in 2 parti:

• Dichiarazione delle variabili

Pag. 3 di 15

• Operazioni da eseguire (assegnazioni, espressioni matematiche, cicli, stampe,

acquisizioni,condizioni)

Nella prima parte avremo, dopo aver dichiarato l’inizio del programma con la parola chiave inizio

del costrutto inizio … fine, la dichiarazione delle variabili. In questo spazio potranno essere

dichiarate tutte le variabili da utilizzare fino a che non verrà digitata la prima istruzione accettata

dal linguaggio che non sia una dichiarazione di variabile.

Avvenuto questo inizierà la seconda parte del programma dove se ci sarà una dichiarazione di

variabile il parser rileverà un errore e terminerà. In caso contrario continuerà a controllare la

sintassi di tutte le istruzioni digitate e dopo l’ultima istruzione deve essere presente la parola

chiave fine del costrutto inizio … fine. Se tutte le istruzioni digitate sono accettabili secondo la

grammatica il parser terminerà la scansione con successo.

Se nelle istruzioni digitate ci saranno delle condizioni o dei cicli, al loro interno sarà possibile

dichiarare altre variabili che verranno considerate locali al blocco di istruzioni.

Per concludere, quando si verificherà un errore la sua gestione sarà disponibile in lingua italiana.

PROGETTAZIONE

Grammatica del linguaggio in notazione (E)BNF:

<START> ::= inizio; [ <CODICE> ] fine;

<CODICE> ::= [ <DICHIARAZIONE> ] <CODICE1>

<DICHIARAZIONE> ::= <TIPO> <IDENTIFICATORE>; [ <DICHIARAZIONE> ]

<TIPO> ::= intero | reale | stringa | doppiaprecisione | singolaprecisione | carattere | booleano |

puntatore

Pag. 4 di 15

<CODICE1> ::= <CALCOLO> ; [<CODICE1>] | per ( [ <INIZIALIZZAZIONE> ;] <CONDIZIONE> ;

<CALCOLO> ) <START> [<CODICE1>] | ripeti <START> finche ( <CONDIZIONE> ) [<CODICE1>] |

fintanto che ( <CONDIZIONE> ) fai <START> [<CODICE1>] | se ( <CONDIZIONE> ) allora <START>

[ altrimenti <START> ] [ <CODICE1> ] | stampa( <IDENTIFICATORE> ) ; [ <CODICE1> ] | leggi

<IDENTIFICATORE> ; [ <CODICE1> ]

-ESPRESSIONI MATEMATICHE-

<CALCOLO>::= <IDENTIFICATORE> = <CALCOLO1>

<CALCOLO1>::= ( <CALCOLO1> ) [ <OPERAZIONI> <CALCOLO1> ] | <CALCOLO2>

<CALCOLO2>::= <IDENTIFICATORE> [ <OPERAZIONI> <CALCOLO1> ]| <REALE> [ <OPERAZIONI>

<CALCOLO1> ]

<OPERAZIONI>::= / | + | - | *

-NUMERI REALE-

<REALE>::= (<NUM>)+ [ , (<NUM>)+ ]

-COSTRUTTI-

<INIZIALIZZAZIONE>::= <TIPO> <IDENTIFICATORE>

<CONDIZIONE>::= <IDENTIFICATORE> <RAPPORTO> <CALCOLO1>

<RAPPORTO>::= <= | < | > | >= | == | != | => | =<

<IDENTIFICATORE>::= ( [ “A” - ”Z” ] )+

<NUM>::= ( [ “0” - ”9” ] )+

Pag. 5 di 15

CODIFICA:

/* Caso di studio di linguaggi di programmazione*/

options

{

STATIC = false; // default TRUE

LOOKAHEAD = 2; // default 1

IGNORE_CASE = true; // default false

}

Pag. 6 di 15

PARSER_BEGIN (casodistudio)

// eventuale dichiarazione di package

// eventuale lista di import

public class casodistudio {

public static void main(String args[]) throws ParseException {

casodistudio parser = new casodistudio(System.in);

parser.start();

}

}

PARSER_END (casodistudio)

SKIP : { " " | "\t" | "\n" | "\r" }

SKIP:

{

<"/*"> : COMMENTO //gestione dei commenti

}

<COMMENTO>

SKIP:

{ <"/*"> : DEFAULT //ritorno dalla gestione dei commenti

| <~[ ]>

}

TOKEN :

{

<NUM: (["0"-"9"])+> //token dei numeri

| <PIU: "+"> //token della somma

| <MENO: "-"> //token della sottrazione

| <PER: "*"> //token della moltiplicazione

| <DIV: "/"> //token della divisione

Pag. 7 di 15

| <VIR: ","> //token per la virgola

| <IDENTIFICATORE: (["A"-"Z"])+>//token per la gestione delle variabili

}

void start() :

{}

{ <INIZIO> <SEMICOLON> [codice()] <FINE> <SEMICOLON> } //regola che definisce

come deve iniziare un programma

void codice() :

{}

{ [dichiarazione()] codice1() } //regola che definisce che il programma deve essere diviso in

2 parti una destinata alla dichiarazione e uno destinato al codice

void dichiarazione() :

{}

{ tipo() <IDENTIFICATORE> <SEMICOLON> [dichiarazione()] } //regola che definisce la

dichiarazione

void tipo() :

{}

{ <INT> | <REAL> | <STRING> | <CHAR> | <BOOLEAN> | <FLOAT> | <DOUBLE> | <POINTER>

} //regola che definisce i tipi

void codice1() :

{}

Pag. 9 di 15

{ calcolo() <SEMICOLON> [codice1()] | <FOR> <PARAP> [inizializzazione() <SEMICOLON>]

condizione() <SEMICOLON> calcolo() <PARCH> start() [codice1()] | <REPEAT> start() <UNTIL>

<PARAP> condizione() <PARCH> [codice1()] | <WHILE> <PARAP> condizione() <PARCH> <DO>

start() [codice1()] | <IF> <PARAP> condizione() <PARCH> <THEN> start() [<ELSE> start()] [codice1()]

| <STAMPA> <PARAP> <IDENTIFICATORE> <PARCH> <SEMICOLON> [ codice1() ] | <LEGGI>

<IDENTIFICATORE> <SEMICOLON> [codice1()] } //regole che definiscono i costrutti del

linguaggio di programmazione

//regole per il calcolo

void calcolo() :

{}

{ <IDENTIFICATORE> <UGUALE> calcolo1() } //regola che definisce l'inizio di

una espressione matematica

void calcolo1() :

{}

{ <PARAP> calcolo1() <PARCH> [ operazioni() calcolo1() ] | calcolo2() } //regola che

definisce la regolarità delle parentesi tonde

void calcolo2() :

{}

{ <IDENTIFICATORE> [ operazioni() calcolo1() ] | reale() [ operazioni() calcolo1() ] } //regola

che definisce una espressione matematica semplice

void operazioni() :

{}

{ <DIV> | <PIU> | <MENO> | <PER> } //regola che definisce il tipo di

operazione che si possono compiere nelle operazioni matematiche

//regole per i numeri reali

Pag. 10 di 15

void reale():

{}

{ (<NUM>)+[<VIR>(<NUM>)+]} //regole che definiscono come

creare un numero reale

//regole per i costrutti

void inizializzazione() :

{}

{ tipo() <IDENTIFICATORE> } //regola che definisce la dichiarazione di

una variabile

void condizione() :

{}

{ <IDENTIFICATORE> rapporto() calcolo1() } //regola che definisce la forma della

condizione

void rapporto() :

{}

{ <MAGGIORESR> | <MINORESR> | <MAGGIORE> | <MINORE> | <DIVERSO> |

<EQUIVALENTE> }//regola che definisce il tipo di condizione

TEST:

Primo test:

-inserisco una funzione matematica all ' interno del codice con utilizzo di parentesi per definire le

precedenze tra le varie operazioni:

Pag. 11 di 15

Secondo test:

-inserisco il costrutto for all' interno del codice definendo le variabili e chiudendo il corpo del

costrutto all'interno di inizio e fine;

Terzo test:

-inserisco il costrutto repeat-until all' interno del codice definendo le variabili e chiudendo il corpo

del costrutto all'interno di inizio e fine;

Pag. 12 di 15

Quarto test:

-inserisco il costrutto while do all' interno del codice definendo le variabili e chiudendo il corpo del

costrutto all'interno di inizio e fine;

Quinto test:

-inserisco le operazioni di stampa e di lettura di una variabile all' interno del corpo di un

programma;

Pag. 13 di 15

Sesto test:

-inserisco il costrutto if then else all' interno del codice definendo le variabili e chiudendo il corpo

del ramo vero e falso del costrutto all'interno di inizio e fine;

Settimo test:

-in caso di presenza di un errore viene mostrato un messaggio in lingua italiana che indica quale

errore è stato individuato e le coordinate di tale errore.

Pag. 14 di 15

Viene anche mostrato un messaggio che cosa ci si sarebbe aspettato al posto dell'errore

commesso.

Pag. 15 di 15

Linguaggi Di Programmazione Caso Di Studio

Documents

Transcript of Linguaggi Di Programmazione Caso Di Studio