Gramatica.grm

"Case Sensitive" = True
"Start Symbol"   = <Program>

{id head} = {letter} + [_]
{id tail} = {id head} + {digit}
{string}  = {printable} - ["]
                 
id        = {id head} {id tail}*           
num       = {digit}+ | {digit}+'.'{digit}+          
str       = '"' ( {string} | '\'{printable} )* '"'
log       = true | false

Comment Start = '/*'
Comment End   = '*/'
Comment Line  = '//'

!-----------------------------------------------------------------------
!Start

    <Program>     ::= <Global Decls> <Decls> <Start Block> <Decls>              !first = {struct, const}                 
               
    <Start Block> ::= start '(' ')' <Func Block>                                !first = {start}

    <Global Decls> ::= const '{' <Const Decls> '}' <Var Block>
                    | var '{' <Var Decls> '}' <Const Block>
                    |
    
    <Decls>       ::= <Decl> <Decls>                                            !first = {function, procedure, struct, typedef}
                    |
              
    <Decl>        ::= <Func Decl>                                               !first = {function}
                    | <Proc Decl>                                               !first = {procedure}
                    | <Struct Block>                                            !first = {struct, typedef}   

!-----------------------------------------------------------------------
!Struct

    <Struct Block> ::= struct id <Extends> '{' <Var Decls> '}'                  !first = {struct, typedef}
                     | typedef struct <Extends> '{' <Var Decls> '}' id ';'
    
    <Extends>      ::= extends struct id                                        !first = {extends}
                     |    

!-----------------------------------------------------------------------
!Constants and Variables Block

    <Const Block> ::= const '{' <Const Decls> '}'                               !first = {const}                  
                    |

    <Var Block>   ::= var '{' <Var Decls> '}'                                   !first = {var}
                    |

!-----------------------------------------------------------------------
!Variables Type and Typedef

    <Type>    ::= int                                                           !first = {int}
                | real                                                          !first = {real}
                | boolean                                                       !first = {boolean}
                | string                                                        !first = {string}
                | struct id                                                     !first = {struct}                      

    <Typedef> ::= typedef <Type> id ';'                                         !first = {typedef}

!-----------------------------------------------------------------------
!Variable Declarations

    <Var Decls> ::= <Var Decl> <Var Decls>                                      !first = {int, real, boolean, string, struct, typedef, id}
                  | 

    <Var Decl>  ::= <Type> <Var> <Var List>                                     !first = {int, real, boolean, string, struct}
                  | <Typedef>                                                   !first = {typedef}
                  | id <Var> <Var List>                                         !first = {id}
                  

    <Var>       ::= id <Arrays>                                                 !first = {id}

    <Var List>  ::= ',' <Var> <Var List>                                        !first = {',', '=', ';'}
                  | '=' <Decl Atribute> <Var List>
                  | ';'                                                      
    
!-----------------------------------------------------------------------
!Constant Declarations

    <Const Decls> ::= <Const Decl> <Const Decls>                                !first = {int, real, boolean, string, struct, typedef, id, local, global}
                    | 

    <Const Decl>  ::= <Type> <Const> <Const List>                               !first = {int, real, boolean, string, struct}
                    | <Typedef>                                                 !first = {typedef}
                    | id <Const> <Const List>                                   !first = {id}
                  

    <Const>       ::= id <Arrays> '=' <Decl Atribute>                           !first = {id}

    <Const List>  ::= ',' <Const> <Const List>                                  !first = {','}
                    |';'                                                        !first = {';'}


    <Decl Atribute> ::= <Array Decl>                                            !first = {'{'}
                      |  <Expr>                                                 !first = {'!', num, str, log, id, '('}

!-----------------------------------------------------------------------
!Arrays Atributes

    <Array Decl>   ::= '{' <Array Def> '}'                                      !first = {'{'} 
                
    <Array Def>    ::= <Expr> <Array Expr>                                      !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Array Expr>   ::= ',' <Array Def>                                          !first = {','}
                     | 
 
!-----------------------------------------------------------------------
!Arrays

    <Array>  ::= '[' <Index> ']'                                                !first = {'['}

    <Index>  ::= id                                                             !first = {num, id}
               | num                                                               
               |
    <Arrays> ::= <Array> <Arrays>                                               !first = {'['}
               |

!-----------------------------------------------------------------------
!Assign and Access

    <Assign>   ::= '=' <Expr> ';'                                               !first = {'='}
                 | '++' ';'                                                     !first = {'++'}
                 | '--' ';'                                                     !first = {'--'}

    <Access>   ::= '.' id <Arrays>                                              !first = {'.'}

    <Accesses> ::= <Access> <Accesses>                                          !first = {'.'}
                 |

!-----------------------------------------------------------------------
!Arguments

    <Args>      ::= <Expr> <Args List>                                          !first = {'!', num, str, log, id '('}
                  |

    <Args List> ::= ',' <Expr> <Args List>                                      !first = {','}
                  |

!-----------------------------------------------------------------------
!Function Declaration

    <Func Decl> ::= function <Param Type> id '(' <Params> ')' <Func Block>      !first{function}

!-----------------------------------------------------------------------
!Procedure Declaration

    <Proc Decl> ::= procedure id '(' <Params> ')' <Proc Block>                  !first{procedure}

!-----------------------------------------------------------------------
!Parameters

    <Param Type>   ::= <Type>                                                   !first = {int, real, boolean, string, struct}
                     | id                                                       !first = {id}

    <Params>       ::= <Param> <Params List>                                    !first = {int, real, boolean, string, struct, id}
                     |

    <Param>        ::= <Param Type> id <Param Arrays>                           !first = {int, real, boolean, string, struct, id}

    <Params List>  ::= ',' <Param> <Params List>                                !first = {','}
                     |

    <Param Arrays> ::= '[' ']' <Param Mult Arrays>                              !first = {'['}
                     |

    <Param Mult Arrays> ::= '[' num ']' <Param Mult Arrays>                     !first = {'['}
                          |

!-----------------------------------------------------------------------
!Function Block

    <Func Block>      ::= '{' <Var Block> <Func Stms> '}'                                 !first = {'{'}

    <Func Stms>       ::= <Func Stm> <Func Stms>                                          !first = {if, while, '{', id, local, global, print, read, ';', return}
                        |
                   
    <Func Stm>        ::= <If Stm>                                                        !first = {if}
                        | <While Stm>                                                     !first = {while}
                        | <Var Stm>                                                       !first = {id, local, global, print, read}
                        | return <Expr> ';'                                               !first = {return}

    <Else Stm>        ::= else '{' <Func Stms> '}'                                         !first = {else}
                        | 
                   
    <If Stm>          ::= if '(' <Log Expr> ')' then '{' <Func Stms> '}' <Else Stm>       !first = {if}

    <While Stm>       ::= while '(' <Log Expr> ')' '{' <Func Stms> '}'                    !first = {while}

!-----------------------------------------------------------------------
!Procedure Block

    <Proc Block>      ::= '{' <Var Block> <Proc Stms> '}'                                 !first = {'{'}

    <Proc Stms>       ::= <Proc Stm> <Proc Stms>                                          !first = {if, while, '{', id, local, global, print, read, ';', return}
                        |
                   
    <Proc Stm>        ::= <If Proc Stm>                                                        !first = {if}
                        | <While Proc Stm>                                                     !first = {while}
                        | <Var Stm>                                                       !first = {id, local, global, print, read}

    <Else Proc Stm>        ::= else '{' <Proc Stms> '}'                                         !first = {else}
                        | 
                   
    <If Proc Stm>          ::= if '(' <Log Expr> ')' then '{' <Proc Stms> '}' <Else Stm>       !first = {if}

    <While Proc Stm>       ::= while '(' <Log Expr> ')' '{' <Proc Stms> '}'                    !first = {while}

!-----------------------------------------------------------------------
!Variable Statements

    <Var Stm>   ::= <Stm Scope>                                                           !first = {local, global}
                  | id <Stm Id>                                                           !first = {id}
                  | <Stm Cmd>                                                             !first = {print, read}

    <Stm Id>    ::= <Assign>                                                              !first = {'=', '+', '-'}
                  | <Array> <Arrays> <Accesses> <Assign>                                  !first = {'['}
                  | <Access> <Accesses> <Assign>                                          !first = {'.'}
                  | '(' <Args> ')' ';'                                                    !first = {'('}

    <Stm Scope> ::= local <Access> <Accesses> <Assign>                                    !first = {local}
                  | global <Access> <Accesses> <Assign>                                   !first = {global}

    <Stm Cmd>   ::= print '(' <Args> ')' ';'                                              !first = {print}
                  | read '(' <Args> ')' ';'                                               !first = {read}

!-----------------------------------------------------------------------
!Expressions  
    
    <Expr>     ::= <And> <Or>                                                            !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Or>      ::= '||' <And> <Or>                                                       !first = {'||'}
                 | 

    <And>      ::= <Equate> <And Aux>                                                        !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <And Aux>     ::= '&&' <Equate> <And Aux>                                                   !first = {'&&'}
                 | 

    <Equate>   ::= <Compare> <Equate Aux>                                                    !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Equate Aux>  ::= '==' <Compare> <Equate Aux>                                               !first = {'=='}
                 | '!=' <Compare> <Equate Aux>                                               !first = {'!='}
                 | 

    <Compare>  ::= <Add> <Compare Aux>                                                       !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Compare Aux> ::= '<'  <Add> <Compare Aux>                                                  !first = {'>'}
                 | '>' <Add> <Compare Aux>                                                   !first = {'<'}
                 | '<=' <Add> <Compare Aux>                                                  !first = {'<='}
                 | '>=' <Add> <Compare Aux>                                                  !first = {'>='}
                 | 

    <Add>      ::= <Mult> <Add Aux>                                                          !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Add Aux>     ::= '+' <Mult> <Add Aux>                                                      !first = {'+'}
                 | '-' <Mult> <Add Aux>                                                      !first = {'-'}
                 | 
                   
    <Mult>     ::= <Unary> <Mult Aux>                                                        !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Mult Aux>    ::= '*' <Unary> <Mult Aux>                                                    !first = {'*'}
                 | '/' <Unary> <Mult Aux>                                                    !first = {'/'}
                 | 

    <Unary>    ::= '!' <Unary>                                                            !first = {'!'}
                 | <Value>                                                                !first = {num, str, log, id '('}

    <Value>    ::= '-'  <Value>
                 | num                                                                    !first = {num}
                 | str                                                                    !first = {str}
                 | log                                                                    !first = {log}
                 | local <Access> <Accesses>                                              !first = {local}
                 | global <Access> <Accesses>                                             !first = {global}
                 | id <Id Value>                                                          !first = {id}
                 | '(' <Expr> ')'                                                         !first = {'('}

    <Id Value> ::= <Arrays> <Accesses>                                                    !first = {'[', '.'}
                 | '(' <Args> ')'                                                         !first = {'('}

!----------------------------------------------------------------------
!Logic Expression
                
    <Log Expr>       ::= <Log And> <Log Or>                                                !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Log Or>      ::= '||' <Log And> <Log Or>                                           !first = {'||'}
                     | 

    <Log And>      ::= <Log Equate> <Log And Aux>                                            !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Log And Aux>     ::= '&&' <Log Equate> <Log And Aux>                                       !first = {'&&'}
                     | 

    <Log Equate>   ::= <Log Compare> <Log Equate Aux>                                        !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Log Equate Aux>  ::= '==' <Log Compare> <Log Equate Aux>                                   !first = {'=='}
                     | '!=' <Log Compare> <Log Equate Aux>                                   !first = {'!='}
                     | 

    <Log Compare>  ::= <Log Unary> <Log Compare Aux>                                         !first = {'!', num, str, log, id, '(', 'global', 'local'}
    <Log Compare Aux> ::= '<' <Log Unary> <Log Compare Aux>                                     !first = {'>'}
                     | '>' <Log Unary> <Log Compare Aux>                                     !first = {'<'}
                     | '<=' <Log Unary> <Log Compare Aux>                                    !first = {'<='}
                     | '>=' <Log Unary> <Log Compare Aux>                                    !first = {'>='}
                     | 

    <Log Unary>    ::= '!' <Log Unary>                                                    !first = {'!'}
                     | <Log Value>                                                        !first = {num, str, log, id '('}

    <Log Value>    ::= num                                                                !first = {num}
                     | str                                                                !first = {str}
                     | log                                                                !first = {log}
                     | local <Access> <Accesses>                                          !first = {local}
                     | global <Access> <Accesses>                                         !first = {global}
                     | id <Id Value>                                                      !first = {id}
                     | '(' <Log Expr> ')'                                                 !first = {'('}