Buongiorno a tutti
Ho da fare un progetto in Java che consiste nel realizzare una specie di compilatore che interpreti codice scritto in un linguaggio che mi sembra molto simile a Ocaml. Come specifica iniziale per la prima parte riguardante l'analizzatore sintattico mi viene fornita la seguente grammatica EBNF:
Prog ::= (fun (FunDec)+ in)? Exp
FunDec ::= Type Ident ( Params ) -> Exp
Params ::= (Type Ident (, Type Ident)*)?
Dec ::= Ident = Exp
Exp ::= BoolLit | IntLit | StringLit | Ident | UnaryOp Exp | Exp BinaryOp Exp | ( Exp )
j Ident ( Args ) j [ Type ] j if Exp then Exp else Exp ; | let (Dec)+ in Exp ;
BinaryOp ::= + | - | * | / | % | <= | < | >= | > | == | /= | & | | | : | @ | ˆ
UnaryOp ::= ~ | - | # | <: | :>
Args ::= (Exp (, Exp)*)?
Type ::= int j bool j string j Type list
E le seguenti regole di precedenza:
Quello che voglio chiedervi è se vi sembra corretta (o vagamente sensata ) la stessa grammatica posta in questo modo:
Main ::= Prog
Prog ::= Exp | fun FunDecs in Exp
FunDecs ::= FunDec | FunDec FunDecs
FunDec ::= TypeDec ( Params ) -> Exp
Params ::= TypeDecs
TypeDecs ::= TypeDec | TypeDec , TypeDecs
TypeDec ::= Type Ident
Dec ::= Ident == Exp
Exp ::= OrTerm (| OrTerm)*
OrTerm ::= AndTerm (& AndTerm)*
AndTerm ::= EqTerm (EqOp EqTerm)*
EqOp ::= == | /=
EqTerm ::= RelTerm (RelOp RelTerm)*
RelOp ::= < | <= | > | >=
RelTerm ::= ConcatTerm (@ ConcatTerm)*
ConcatTerm ::= (DecTerm :)* DecTerm
DecTerm ::= SumTerm (SumOp SumTerm)*
SumOp ::= + | - | ^
SumTerm ::= MulTerm (MulOp MulTerm)*
MulOp ::= * | / | %
MulTerm ::= (UnaryOp)? Atom
Atom ::= Lit | Ident | (Exp) | FunCall | [Type] | IfThenElse | LetIn
FunCall ::= Ident (Args)
Args ::= Exp | Exp , Args
IfThenElse ::= if Exp then Exp else Exp ;
LetIn ::= Let Decs in Exp ;
Decs :: Dec | Dec , Decs
Type ::= int | bool | string | type list
Se vi servono altre informazioni chiedetemi pure.