Scrittura grammatica compilatore Java

[Deviad]

Salve a tutti,
sto scrivendo la grammatica LR Libera da Contesto in EBNF per un compilatore che dovrebbe leggere i costrutti basilari del Java ma mi sono arenato su una "questione filosofica".



program = {instruction-flow};

instruction-flow = var-declaration | if-statement | while-statement | do-while-statement | for-statement | simple-statement;





var-declaration = var-declaration-inline | var-declaration-non-inline;
var-declaration-inline = Type, id, “=”, value, “;” | “public”, type, id, “=”, value, “;” | “public”, “static,”, id, “=”, value, “;” | “private”, type, id, “=”, value, “;” | “private”, “static,”, id, “=”, value, “;” | id, “=”, value, “;”;

var-declaration-nonline = var-declaration-down;

var-declaration-top = Var-declaration-inline = Type, id, “;” | “public”, type, id, “;” | “public”, “static,”, id, “;” | “private”, type, id, “;” | “private”, “static,”, id, “;”;

var-declaration-down = var-declaration-top, id “=” value, “;” | var-declaration, {instruction-flow}, id “=” value, “;”;


if-statement = “if”, “(“, expr, “)”, “{“, {instruction-flow}, “}”, [{instruction-flow}];

while-statement = “while”, “(“, expr, “)”, “{“, {instruction-flow}, “}”;

do-while-statement = do, “{“, {instruction-flow}, “}”, while, “(“ expr, ”)”;

for-statement = for “(“, {var-declaration}, “;” “id”, operatore-relazionale, value; id (++ | --) “)”, “{“, {instruction-flow}, ”}”;

simple-statement = id, “=”, value, ";" | id, ”(“, [id], “)”, “;”;

La ricorsione di instruction-flow indicata con {instruction-flow} dove la metto?
La devo mettere solo sopra?
Oppure va bene come ho fatto, cioè ripetere {block} lì dove è indispensabile, cioè all'interno delle graffe dei costrutti if e nell'opzionalità dell'else?
Infatti filosoficamente il do while non ha bisogno del block opzionale (che sta per l'else) perchè il controllo viene eseguito dopo l'esecuzione dell'istruzione.
Quindi l'istruzione viene eseguita prima del controllo.
Quindi 1 else non ha ragion d'essere.

P.S.: il for devo ancora crearlo e poi devo creare expression.

Ah e poi va bene se considero programma, che è lo scopo della grammatica, come ricorsione per n volte di block?

[Kaldais]

Bè, dovrebbe esser giusto così, non ho capito cosa intendi con il block opzionale per il do while. Non viene fatto in questo modo?


do
System.out.println("figa")
while
(1 == 1);

Per il tuo modo di definire il programma dipende da come sarà strutturata la grammatica, pensi di includere anche le classi?

[Deviad]

Bè, dovrebbe esser giusto così, non ho capito cosa intendi con il block opzionale per il do while. Non viene fatto in questo modo?


do
System.out.println("figa")
while
(1 == 1);

Per il tuo modo di definire il programma dipende da come sarà strutturata la grammatica, pensi di includere anche le classi?

Penso che scriverò una menata del tipo:
"per ragioni di semplicità il programma riconosce solo le seguenti strutture bla bla bla" e non ci metterò le classi.
Tanto da quello che mi hanno detto il prof è contento se l'analizzatore lessicale riconosce while, for, if...
Adesso devo definire operatore relazionale, value, type.

[Kaldais]

Curiosità: il parser te lo stai facendo tutto tu? Io c'ho provato ma alla fine mi son arreso ed ho usato Coco / R (http://www.ssw.uni-linz.ac.at/Coco/), anche perchè le pretese del mio linguaggio erano veramente minime.

[Deviad]

Curiosità: il parser te lo stai facendo tutto tu? Io c'ho provato ma alla fine mi son arreso ed ho usato Coco / R (http://www.ssw.uni-linz.ac.at/Coco/), anche perchè le pretese del mio linguaggio erano veramente minime.

Sì...
che poi io devo fare il lexer il parser credo lo abbozzerò solamente, visto che cmq se lo fai il voto aumenta...

Tutta sta roba mi serve alla fine per dire quali sono i simboli terminali, quelli non terminali della grammatica del linguaggio, ecc., ecc.

Oltre alle classi devo specificare nella relazione, che non riconosce gli oggetti come le stringhe.

Quindi presenterò il linguaggio generato dalla grammatica in questione come un sottolinguaggio del linguaggio Java, magari chiedo qualche help a qualcuno per fare pure la dimostrazione di questa cosa.

Adesso c'è solo un problema: il "-" in questo punto

simple-statement = id, “=”, value, ";" | id, ”(“, [id], “)”, “;”;

Cioè -5 in realtà è un numero, quindi meno non dovrei considerarlo come una operazione qui:
operation = “+” | “-” | “*” | “/”;

Perchè in realtà quando faccio 5 - 1, faccio 5 + (-1)
Credo di essermi risposto da solo.

La soluzione quindi dovrebbe essere questa:
value = [“-”](id | const) | [“-”](id | const), {operation, [“-”](id | const)};

operation = “+” | “*” | “/”;


Adesso devo capire come far riconoscere gli identificatori...

[Deviad]

OK, adesso mi manca solo da definire expr.



program = {instruction-flow};

instruction-flow = var-declaration | if-statement | while-statement | do-while-statement | for-statement | simple-statement;

var-declaration = var-declaration-inline | var-declaration-non-inline;
var-declaration-inline = Type, id, “=”, value, “;” | “public”, type, id, “=”, value, “;” | “public”, “static,”, id, “=”, value, “;” | “private”, type, id, “=”, value, “;” | “private”, “static,”, id, “=”, value, “;” | id, “=”, value, “;”;

var-declaration-non-inline = var-declaration-down;

var-declaration-top = Var-declaration-inline = Type, {id, [“,”]}, “;” | “public”, type, {id, [“,”]}, “;” | “public”, “static,”, {id, [“,”]}, “;” | “private”, type, {id, [“,”]}, “;” | “private”, “static,”, {id, [“,”]}, “;”;

var-declaration-down = var-declaration-top, {id, “=”, value | id, “=”, value, “,”}, “;” | var-declaration, {instruction-flow}, {id, “=”, value | id, “=”, value, “,”}, “;”;


if-statement = “if”, “(“, expr, “)”, “{“, {instruction-flow}, “}”, [{instruction-flow}];

while-statement = “while”, “(“, expr, “)”, [“{“], {instruction-flow}, [“;”] [“}”];

do-while-statement = do, “{“, {instruction-flow}, “}”, while, “(“, expr, ”)”;

expr = id, operatore-relazionale, (id | const) | “!”id

for-statement = for “(“, {var-declaration}, “;”, “id”, operatore-relazionale, value; id (++ | --) “)”, “{“, {instruction-flow}, ”}”;

simple-statement = id, “=”, value, ";" | id, ”(“, [id], “)”, “;”;

type = “byte” | “short” | “int” | “long” | “float” | “double” | “char” | “boolean”

operatore-relazionale = “>” | “>=” | “<” | “<=” | “==” | “!=”;

value = [“-”](id | const) | [“-”](id | const), {operation, [“-”](id | const)};

operation = “+” | “*” | “/”;

id = [ “_”| “$”]{“A” | “B” | “C” | “D” | “E” | “F” | “G” | “H” | “I” | “K” | “L” | “M” | “N” | “O” | “P” | “Q” | “R” | “S” | “T” | “U” | “V” | “W” | “X” | “Y” | “Z” | “a” | “b” | “c” | “d” | “e” | “f” | “g” | “h” | “i” | “k” | “l” | “m” | “n” | “o” | “p” | “q” | “r” | “s” | “t” | “u” | “v” | “w” | “x” | “y” | “z” | “0” | “1” | “2” | “3” | “4” | “5” | “6”| “7” | “8” | “9”};
const = {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9};


Ho corretto un paio di cose.

Allora la roba in grassetto non sono sicuro se metterla come opzionale oppure no e se si devo metterla anche altrove.

Dimmi se sta bene così Kaldais.


Questa invece è la grammatica che ha fatto un mio amico che si chiama Daniele (dico il nome perchè la grammatica "è sotto licenza GPL"):


S = {CLASSE}
P = { <CLASSE> ::== class <IDENTIFICATORE>{<PROCEDURA>}
<PROCEDURA> ::== <MODIFICATORE><TIPOCONV>main(String [ ]arg){[BLOCCO_ISTR]}
<ISTRUZIONE> ::==<DICHIARAZIONE_VARIABILE>|<ASSEGNAMENTO>|<IF>|
<WHILE>
<DICHIARAZIONE_VARIABILE>::==<TIPO> <IDENTIFICATORE>[=][<ESPRESSIONE>]
<ASSEGNAMENTO>::==<IDENTIFICATORE><OP_ASSEGNAMENTO><ESPRESSIONE>
<IF>::=if<CONDIZIONE><BLOCCO_ISTR>else<BLOCCO_ISTR>
<CONDIZIONE>::==<ESP_PARAGONE>|
<ESP_PARAGONE><OP_LOGICO><CONDIZIONE>
<ESP_PARAGONE>::==<ESPRESSIONE><OP_PARAGONE><ESPRESSIONE>
<ESPRESSIONE>::==<IDENTIFICATORE>|<NUMERO_I>|<NUMERO_R>|
[(]<ESPRESSIONE>[)]<OP_ARITMETICO>[(]<ESPRESSIONE>[)]
<BLOCCO_ISTR>::=={[<ISTRUZIONE>]}
<TIPO>::==boolean|char|byte|int|short|long|float|double
<TIPOCONV>::== void|boolean|char|byte|int|short|long|float|double
<OP_PARAGONE>::==!=|==|<|<=|>|>=|
<OP_ASSEGNAMENTO>::== =|+=|-=|*=|/=
<OP_LOGICO>::==&|&& o anche | o anche ||
}

[Kaldais]

Non penso sia giusta la soluzione per i numeri negativi, l'operazione 'meno' come la fai? Da quel che ho capito con la tua grammatica sarei costretto a scrivere questo codice


int a = -5
int b = 10

int c = b+a

... se voglio fare 10-5. O sbaglio?

[Deviad]

Non penso sia giusta la soluzione per i numeri negativi, l'operazione 'meno' come la fai? Da quel che ho capito con la tua grammatica sarei costretto a scrivere questo codice


int a = -5
int b = 10

int c = b+a

... se voglio fare 10-5. O sbaglio?
no
fai 10 + (-5)

in quel caso quindi -5 + 10 normalmente.
Cioè alla fine il - fa parte del numero, come è giusto che sia.
Va che il complemento a due esiste per quello.
Cmq vedo di risolvere meglio.

[Deviad]

program = {instruction-flow};

instruction-flow = var-declaration | if-statement | while-statement | do-while-statement | for-statement | simple-statement;

var-declaration = var-declaration-inline | var-declaration-non-inline;
var-declaration-inline = Type, id, “=”, value, “;” | “public”, type, id, “=”, value, “;” | “public”, “static,”, id, “=”, value, “;” | “private”, type, id, “=”, value, “;” | “private”, “static,”, id, “=”, value, “;” | id, “=”, value, “;”;

var-declaration-non-inline = var-declaration-down;

var-declaration-top = Type, {id, [“,”]}, “;” | “public”, type, {id, [“,”]}, “;” | “public”, “static,”, {id, [“,”]}, “;” | “private”, type, {id, [“,”]}, “;” | “private”, “static,”, {id, [“,”]}, “;”;

var-declaration-down = var-declaration-top, {id, “=”, value | id, “=”, value, “,”}, “;” | var-declaration, {instruction-flow}, {id, “=”, value | id, “=”, value, “,”}, “;”;


if-statement = “if”, “(“, expr, “)”, “{“, {instruction-flow}, “}”, [{instruction-flow}];

while-statement = “while”, “(“, expr, “)”, [“{“], {instruction-flow}, [“;”] [“}”];

do-while-statement = do, “{“, {instruction-flow}, “}”, while, “(“, expr, ”)”;

expr = id, operatore-relazionale, (id | const) | “!”id;

for-statement = for “(“, {var-declaration}, “;”, “id”, operatore-relazionale, value; id (++ | --) “)”, “{“, {instruction-flow}, ”}”;

simple-statement = id, “=”, value, ";" | id, ”(“, [id], “)”, “;”;

type = “byte” | “short” | “int” | “long” | “float” | “double” | “char” | “boolean”

operatore-relazionale = “>” | “>=” | “<” | “<=” | “==” | “!=”;

value = [“-”](id | const) | [“-”](id | const), {operation, [“-”] (id | const)};

operation = “+” | “*” | “/”| subtraction;

subtraction = (id | const), “-”, (id | const)

id = [ “_”| “$”]{“A” | “B” | “C” | “D” | “E” | “F” | “G” | “H” | “I” | “K” | “L” | “M” | “N” | “O” | “P” | “Q” | “R” | “S” | “T” | “U” | “V” | “W” | “X” | “Y” | “Z” | “a” | “b” | “c” | “d” | “e” | “f” | “g” | “h” | “i” | “k” | “l” | “m” | “n” | “o” | “p” | “q” | “r” | “s” | “t” | “u” | “v” | “w” | “x” | “y” | “z” | “0” | “1” | “2” | “3” | “4” | “5” | “6”| “7” | “8” | “9”};
const = {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9};


Non riesco a trovare una soluzione per il meno, perchè rimane sempre ambiguo.
Come si fa a fargli capire quando è -a è quando deve fare l'operazione di sottrazione?
Help.

[Deviad]

Allora, dopo aver riaperto un libro e gli appunti di Java del primo anno ho buttato giù questa grammatica che mi sembra fatta meglio:


S = {Classe}

Classe = specificatoreDiAccesso, “class”, nomeClasse, “{“, {metodo}, “}”;
metodo = specificatoreDiAccesso, tipoRestituito, nomeMetodo, “(“, [parametro], “)”, “{“,[bloccoIstr],”}”;
bloccoIstr = {[istruzione]};
istruzione = dichiarazioneVariabile | assegnamento | selBinaria | cicloWhile;
dichiarazioneVariabile = tipo, identificatore, [“=”], [espressione];
assegnamento = identificatore, opAssegnamento, espressione;
espressione = identificatore | sequenzaNumeriInteri | sequnzaNumeriDecimali | [“(“], espressione, [“)“], opAritmetico, [“(“], espressione, [“)“];

selBinaria = “if”, condizione, bloccoIstr, [“else”, “{“, bloccoIstr, “}”];
cicloWhile = “while”, condizione, “{“, bloccoIstr, “}”;
condizione = {espParagone | espParagone, opLogico};
espParagone = espressione, opParagone, espressione;
tipo = “boolean” | “char” | ”byte“ | “int” | “short” | “long” | “float” | “double”;
tipoRestituito = “void” | “boolean” | “char” | ”byte“ | “int” | “short” | “long” | “float” | “double”;
nomeMetodo = sequenzaLettere;
opParagone = “!=” | “==” | “<” | “<=” | “>” | “>=”;
opAssegnamento = “=” | “+=” | “-=” | “*=” | “/=”;
opLogico = “&” | “&&”| “|” | “||”;
opAritmetico = “+” | “-” | “*” | “/”;
identificatore = [“_” | “$”] {sequenzaLettere | sequenzaNumeri};
sequenzaLettere = {“A” | “B” | “C” | “D” | “E” | “F” | “G” | “H” | “I” | “K” | “L” | “M” | “N” | “O” | “P” | “Q” | “R” | “S” | “T” | “U” | “V” | “W” | “X” | “Y” | “Z” | “a” | “b” | “c” | “d” | “e” | “f” | “g” | “h” | “i” | “k” | “l” | “m” | “n” | “o” | “p” | “q” | “r” | “s” | “t” | “u” | “v” | “w” | “x” | “y” | “z”};
sequenzaNumeriInteri = {“0” | “1” | “2” | “3” | “4” | “5” | “6” | “7” | “8” | “9”};
sequenzaNumeriDecimali = {sequenzaNumeriInteri}, “.”, {sequenzaNumeriInteri};
nomeMetodo = sequenzaLettere;
nomeClasse = sequenzaLettere;
specificatoreDiAccesso = “public” | “protected” | “private” | “static” | “abstract” | “final” | “native “ | “synchrnoized” | “transient” | “volatile” | “strictfp”


Questa è una grammatica che ho trovato sul sito del programma che devo utilizzare per generare il mio automa accettore.
Questo programma per la grammatica usa un mix tra il linguaggio usato dallo yacc e la EBNF.
Quello che mi lascia perplesso è che nel costrutto dell'if non mensiona l'opzionalità delle "{" "}".
Chiedo a Kaldais aiuto :(
Perchè sto tizio non ha mensionato l'opzionalità delle graffe?
[code]
statement
: block
| 'assert' expression (':' expression)? ';'
| 'if' parExpression statement ('else' statement)?
| 'for' '(' forControl ')' statement
| 'while' parExpression statement
| 'do' statement 'while' parExpression ';'
| 'try' block
( catches 'finally' block
| catches
| 'finally' block
)
| 'switch' parExpression '{' switchBlockStatementGroups '}'
| 'synchronized' parExpression block
| 'return' expression? ';'
| 'throw' expression ';'
| 'break' Identifier? ';'
| 'continue' Identifier? ';'
| ';'
| statementExpression ';'
| Identifier ':' statement
;
[code]

[Deviad]

Allora, dopo aver riaperto un libro e gli appunti di Java del primo anno ho buttato giù questa grammatica che mi sembra fatta meglio:


S = {Classe}

Classe = specificatoreDiAccesso, “class”, nomeClasse, “{“, {metodo}, “}”;
metodo = specificatoreDiAccesso, tipoRestituito, nomeMetodo, “(“, [parametro], “)”, “{“,[bloccoIstr],”}”;
bloccoIstr = {[istruzione]};
istruzione = dichiarazioneVariabile | assegnamento | selBinaria | cicloWhile;
dichiarazioneVariabile = tipo, identificatore, [“=”], [espressione];
assegnamento = identificatore, opAssegnamento, espressione;
espressione = identificatore | sequenzaNumeriInteri | sequnzaNumeriDecimali | [“(“], espressione, [“)“], opAritmetico, [“(“], espressione, [“)“];

selBinaria = “if”, condizione, bloccoIstr, [“else”, “{“, bloccoIstr, “}”];
cicloWhile = “while”, condizione, “{“, bloccoIstr, “}”;
condizione = {espParagone | espParagone, opLogico};
espParagone = espressione, opParagone, espressione;
tipo = “boolean” | “char” | ”byte“ | “int” | “short” | “long” | “float” | “double”;
tipoRestituito = “void” | “boolean” | “char” | ”byte“ | “int” | “short” | “long” | “float” | “double”;
nomeMetodo = sequenzaLettere;
opParagone = “!=” | “==” | “<” | “<=” | “>” | “>=”;
opAssegnamento = “=” | “+=” | “-=” | “*=” | “/=”;
opLogico = “&” | “&&”| “|” | “||”;
opAritmetico = “+” | “-” | “*” | “/”;
identificatore = [“_” | “$”] {sequenzaLettere | sequenzaNumeri};
sequenzaLettere = {“A” | “B” | “C” | “D” | “E” | “F” | “G” | “H” | “I” | “K” | “L” | “M” | “N” | “O” | “P” | “Q” | “R” | “S” | “T” | “U” | “V” | “W” | “X” | “Y” | “Z” | “a” | “b” | “c” | “d” | “e” | “f” | “g” | “h” | “i” | “k” | “l” | “m” | “n” | “o” | “p” | “q” | “r” | “s” | “t” | “u” | “v” | “w” | “x” | “y” | “z”};
sequenzaNumeriInteri = {“0” | “1” | “2” | “3” | “4” | “5” | “6” | “7” | “8” | “9”};
sequenzaNumeriDecimali = {sequenzaNumeriInteri}, “.”, {sequenzaNumeriInteri};
nomeMetodo = sequenzaLettere;
nomeClasse = sequenzaLettere;
specificatoreDiAccesso = “public” | “protected” | “private” | “static” | “abstract” | “final” | “native “ | “synchrnoized” | “transient” | “volatile” | “strictfp”


Questa è una grammatica che ho trovato sul sito del programma che devo utilizzare per generare il mio automa accettore.
Questo programma per la grammatica usa un mix tra il linguaggio usato dallo yacc e la EBNF.
Quello che mi lascia perplesso è che nel costrutto dell'if non mensiona l'opzionalità delle "{" "}".
Chiedo a Kaldais aiuto :(
Perchè sto tizio non ha mensionato l'opzionalità delle graffe?


statement
: block
| 'assert' expression (':' expression)? ';'
| 'if' parExpression statement ('else' statement)?
| 'for' '(' forControl ')' statement
| 'while' parExpression statement
| 'do' statement 'while' parExpression ';'
| 'try' block
( catches 'finally' block
| catches
| 'finally' block
)
| 'switch' parExpression '{' switchBlockStatementGroups '}'
| 'synchronized' parExpression block
| 'return' expression? ';'
| 'throw' expression ';'
| 'break' Identifier? ';'
| 'continue' Identifier? ';'
| ';'
| statementExpression ';'
| Identifier ':' statement
;

[Deviad]

Credo di aver risolto:


S = {Classe}

Classe = specificatoreDiAccesso, “class”, nomeClasse, “{“, {metodo}, “}”;
metodo = specificatoreDiAccesso, tipoRestituito, nomeMetodo, “(“, [parametro], “)”, “{“,[bloccoIstr],”}”;
bloccoIstr = “{“, {[istruzione]}, ”}”;
istruzione = dichiarazioneVariabile | assegnamento | selBinaria | cicloWhile;
dichiarazioneVariabile = tipo, identificatore, [“=”], [espressione];
assegnamento = identificatore, opAssegnamento, espressione;
espressione = identificatore | sequenzaNumeriInteri | sequnzaNumeriDecimali | [“(“], espressione, [“)“], opAritmetico, [“(“], espressione, [“)“];
selBinaria = “if”, condizione, bloccoIstr, [“else”, bloccoIstr];
cicloWhile = “while”, condizione, bloccoIstr;
condizione = {espParagone | espParagone, opLogico};
espParagone = espressione, opParagone, espressione;
tipo = “boolean” | “char” | ”byte“ | “int” | “short” | “long” | “float” | “double”;
tipoRestituito = “void” | “boolean” | “char” | ”byte“ | “int” | “short” | “long” | “float” | “double”;
opParagone = “!=” | “==” | “<” | “<=” | “>” | “>=”;
opAssegnamento = “=” | “+=” | “-=” | “*=” | “/=”;
opLogico = “&” | “&&”| “|” | “||”;
opAritmetico = “+” | “-” | “*” | “/”;
identificatore = [“_” | “$”] {sequenzaLettere | sequenzaNumeri};
sequenzaLettere = {“A” | “B” | “C” | “D” | “E” | “F” | “G” | “H” | “I” | “K” | “L” | “M” | “N” | “O” | “P” | “Q” | “R” | “S” | “T” | “U” | “V” | “W” | “X” | “Y” | “Z” | “a” | “b” | “c” | “d” | “e” | “f” | “g” | “h” | “i” | “k” | “l” | “m” | “n” | “o” | “p” | “q” | “r” | “s” | “t” | “u” | “v” | “w” | “x” | “y” | “z”};
sequenzaNumeriInteri = {“0” | “1” | “2” | “3” | “4” | “5” | “6” | “7” | “8” | “9”};
sequenzaNumeriDecimali = {sequenzaNumeriInteri}, “.”, {sequenzaNumeriInteri};
nomeMetodo = {sequenzaLettere};
nomeClasse = sequenzaLettere;
specificatoreDiAccesso = “public” | “protected” | “private” | “static” | “abstract” | “final” | “native “ | “synchrnoized” | “transient” | “volatile” | “strictfp”;

[PuGNolo]

Complimenti per aver scritto un topic con 9 post tuoi su 12. Quasi quasi mi apro un topic e cerco di battere il tuo record :sbav:

P.S. secondo me in tutto il codice sbagli il routing del polpettone

[Capitan USop]

Complimenti per aver scritto un topic con 9 post tuoi su 12. Quasi quasi mi apro un topic e cerco di battere il tuo record :sbav:

P.S. secondo me in tutto il codice sbagli il routing del polpettone

sei un coglione.

[PuGNolo]

Ti reportizzo

[Kaldais]

E' stupido reportizzare un post, quando (tra l'altro il primo) quello precedente era una futile provocazione. Capitan USop, anche se pur volgare, ha pienamente ragione.

Inutile dire che il thread è chiuso.

Mi scuso con Deviad, sia per non aver visto il tuo ultimo post che per interrompere qui la discussione. Se vuoi riaprirla mandami pure un PM.