(* BNF for TinyObe
 *
 * This is just a piece of MiniOberon (no type decls, procs)
 *
 * Extra comments added refering to semantic checking
 *
 * written by mike slattery - Apr 2005
 *)

(* ID, NUM, STRING are terminals with attribs *)
 
(* Module - the ID before and after proc_body should be "Do" *)
(*        The first and last ID's should match   *)
module -> MODULE ID ; PROCEDURE ID ; proc_body ID ;
		 END ID .

(* VarList  - Process each decl *)
var_list -> var_list var_decl ;
         -> var_decl ;
         
(* VarDecl - create symbol table entries *)
var_decl -> id_list : type
         
(* IdList *)
id_list -> id_list , ID
        -> ID
        
(* Type *)
type -> element_type
        (* ArrayType *)
     -> ARRAY NUM OF element_type
     
                (* IntegerType *)
element_type -> INTEGER
                (* BooleanType *)
             -> BOOLEAN
             
(* ProcBody - process var_list, check stmt_seq *)
proc_body -> opt_vars BEGIN stmt_seq END

(* VarList - or possibly null *)
opt_vars -> VAR var_list
         -> 
   
(* StmtList - check each stmt *)
stmt_seq -> stmt_seq ; stmt
         -> stmt
         
(* All the following are subclasses of Stmt *)
stmt -> ID := expr  (* types need to match *)
     -> ID [ expr ] := expr       (* first expr integer, second matches ID *)
     -> Out.String ( STRING )
     -> Out.Int ( expr)  (* expr needs to be type integer *)
     -> Out.Ln
     (* In FOR stmt, exprs need to be integers *)
     -> FOR ID := expr TO expr opt_by DO stmt_seq END
     (* Next three exprs need to be boolean *)
     -> IF expr THEN stmt_seq END
     -> IF expr THEN stmt_seq ELSE stmt_seq END
     -> WHILE expr DO stmt_seq END

(* Expr *)
opt_by -> BY expr  (* requires integer expr *)
       ->
       
(* All the following are subclasses of Expr *)
expr -> NUM
     (* Type of next two depends on  declared type of ID *)
     -> ID
     -> ID [ expr ]  (* ID needs type Array, expr needs integer *)
     (* Next set of exprs require integers *)
     -> expr + expr
     -> expr - expr
     -> - expr
     -> expr * expr
     -> expr DIV expr
     -> expr MOD expr
     (* These require integer exprs but return type boolean *)
     -> expr < expr
     -> expr <= expr
     -> expr > expr
     -> expr >= expr
     (* These next two need to match type - you can restrict
       to integer if desired *)
     -> expr = expr
     -> expr # expr  (* NotEqual *)
     (* Next three need booleans *)
     -> expr OR expr
     -> expr & expr  (* And *)
     -> ~ expr       (* Not *)
     -> LEN ( ID )  (* ID needs to be array type *)
     -> TRUE
     -> FALSE