SIMPLE C Grammar

     ----------------------------------------------------------------------

The BNF rules for SIMPLE C

  Statements

   all_stmts
           : stmtlist stop_stmt
           | stmtlist

   stmtlist
           : stmtlist stmt
           | stmt

   stmt
           : compstmt
           | expr ';'
           | IF '(' condexpr ')' stmt
           | IF '(' condexpr ')' stmt ELSE stmt
           | WHILE '(' condexpr ')' stmt
           | DO stmt WHILE '(' condexpr ')'
           | FOR '('exprseq ';' condexpr ';'exprseq ')' stmt
           | SWITCH '(' val ')' casestmts
           | ';'

   compsmt
           : '{' all_stmts '}'
           | '{' '}'
           | '{' decls all_stmts '}'
           | '{' decls '}'

  Declarations

   All the possible C declarations. The only difference is that in SIMPLE the
   declarations are not allowed to have initializations in them.

  Expressions

   exprseq
           : exprseq ',' expr
           | expr

   stop_stmt
           : BREAK ';'
           | CONTINUE ';'
           | RETURN ';'
           | RETURN val ';'
           | RETURN '(' val ')' ';'

   casestmts
           : '{' cases default'}'
           | ';'
           | '{' '}'

   cases
           : cases case
           | case

   case
           : CASE CONST':' stmtlist stop_stmt

   default
           : DEFAULT ':' stmtlist stop_stmt

   expr
           : rhs
           | modify_expr

   call_expr
           : ID '(' arglist ')'

   arglist
           : arglist ',' val
           | val

   modify_expr
           : varname '=' rhs
           | '*' ID '=' rhs

   rhs
           : binary_expr
           | unary_expr

   unary_expr
           : simp_expr
           | '*' ID
           | '&' varname
           |call_expr
           | unop val
           | '(' cast ')' varname

           (cast here stands for all valid C typecasts)

   binary_expr
           : val binop val

   unop
           : '+'
           | '-'

   binop
           : relop
           | '-'
           | '+'
           ....

   relop
           : '<'
           | '<='
           ...

   condexpr
           : val
           | val relop val

   simp_expr
           : varname
           | CONST

   val
           : ID
           | CONST

   varname
           : arrayref
           | compref
           | ID

   arrayref
           : ID reflist

   reflist
           : '[' val ']'
           | reflist '[' val ']'

   idlist
           : idlist '.' ID
           | ID

   compref
           : '(' '*' ID ')' '.' idlist
           | idlist

     ----------------------------------------------------------------------

    ACAPS lab / mcadmin@acaps.cs.mcgill.ca
    (Christopher Lapkowski)
    February 1995