PseudoC grammar (.gram)

    public cf text grammar pseudo_c
    {
            options
            {
                    Axiom = "IMPORT_STMT";
                    Separator = "SEPARATOR";
            }
            terminals {
                    LETTER -> [a-z] | [A-Z] ;
                    LETTERS -> LETTER+ ;
                    NUMBER -> [0-9] ;
                    NUMBERS -> NUMBER+ ;
                    ALPHANUMS -> (LETTER | NUMBER)+ ;
                    ASCII_VAL -> ALPHANUMS | 0x003A .. 0x003F | 0x005B .. 0x005F ;
                    ASCII_LIST -> ASCII_VAL+ ;
                    NEWLINE -> '\n' ;
                    ESCAPE_CHR -> NEWLINE | '\\' | '\'' | '\a' | '\b'  ;
                    CHAR -> ASCII_VAL | ESCAPE_CHR ;
                    CHARS -> CHAR+ ;

                    CONSTANT_ID -> LETTERS ALPHANUMS ;
                    SIGN -> 0x002B | 0x002D  ;
                    INTEGER -> (SIGN) (NUMBERS) | NUMBERS ;
                    DECIMAL_NUM -> NUMBERS '.' NUMBERS | NUMBERS '.' | '.' NUMBERS ;
                    FLOAT -> DECIMAL_NUM ;
                    CHARVAL -> 0x0027 LETTER 0x0027 | 0x0027 LETTER 0x0027 ;
                    STRING -> 0x0022 ASCII_LIST 0x0022 ;
                    CONST_VALUE -> INTEGER | FLOAT | CHARVAL | STRING ;

                    EXT -> 'hd' ;
                    FILE -> CHARS '.' EXT ;

                    SCANNER_TYPE -> 'scanInt' | 'scanDecimal' | 'scanString' ;

                    DATA_TYPE -> 'int' | 'float' | 'char' | 'String' ;
                    ARRAY_INDEX -> 0x005B NUMBERS 0x005D ;
                    VAR_ID -> LETTER ALPHANUMS ARRAY_INDEX | LETTER ALPHANUMS ;

                    BOOLEAN_ID -> VAR_ID ;
                    STRING_ID -> VAR_ID ;
                    NUMBER_ID -> VAR_ID ;

                    RELATION_OP -> 'is equal to' | 'is not equal to' | 'less than' | 'greater than' | 'less than or equal to' | 'greater than or equal to' ;

                    WHITE_SPACE -> 0x0020 | 0x0009 | 0x000B | 0x000C ;
                    SEPARATOR -> (WHITE_SPACE | NEWLINE)+ ;

            }
            rules {
                    IMPORT_STMT -> 'using' FILE ';' '\n' {OnRule};
                    IMPORTS -> IMPORT_STMT+ {OnRule};

                    STRING_EXPR -> 'not ->' STRING {OnRule}| STRING_ID {OnRule}| STRING {OnRule};
                    STRING_EXPR_AUX -> STRING_ID '+' STRING_EXPR {OnRule}| STRING '+' STRING_EXPR {OnRule};

                    INCREMENT_POST -> VAR_ID'++' {OnRule};
                    DECREMENT_POST -> VAR_ID'--' {OnRule};
                    INCREMENT_PRE  -> '++'VAR_ID {OnRule};
                    DECREMENT_PRE  -> '--'VAR_ID {OnRule};

                    N_FCTR -> CHAR {OnRule}| INTEGER {OnRule}| FLOAT {OnRule}| NUMBER_ID {OnRule};
                    N_TERM -> N_FCTR {OnRule};
                    N_TERM_AUX -> N_FCTR '*' N_TERM {OnRule}| N_FCTR '/' N_TERM {OnRule}| N_FCTR 'mod' N_TERM {OnRule};
                    NUMBER_EXPR -> N_TERM {OnRule};
                    NUMBER_EXPR_AUX -> N_TERM '+' NUMBER_EXPR {OnRule}| N_TERM '-' NUMBER_EXPR {OnRule};
                    N_PARENTH_FCTR -> '0x0028' NUMBER_EXPR_AUX '0x0029' {OnRule}| '0x0028' NUMBER_EXPR '0x0029' {OnRule};

                    BOOLEAN_FCTR -> BOOLEAN_ID {OnRule};
                    BOOLEAN_TERM -> BOOLEAN_FCTR {OnRule};
                    BOOLEAN_TERM_AUX -> BOOLEAN_FCTR 'and' BOOLEAN_TERM {OnRule} ;
                    LOGICAL_BOOL -> BOOLEAN_TERM_AUX {OnRule}| BOOLEAN_TERM {OnRule} ;
                    LOGICAL_BOOL_AUX -> BOOLEAN_TERM 'or' LOGICAL_BOOL {OnRule};
                    BOOLEAN_EXPR -> NUMBER_EXPR RELATION_OP NUMBER_EXPR {OnRule}| STRING_EXPR 'is' 'equal' 'to' STRING_EXPR {OnRule}| STRING_EXPR 'is' 'not' 'equal' 'to' STRING_EXPR  {OnRule}| LOGICAL_BOOL {OnRule}| LOGICAL_BOOL_AUX {OnRule};
                    BOOLEAN_EXPR_AUX -> LOGICAL_BOOL 'is' 'equal' 'to' BOOLEAN_EXPR {OnRule}| LOGICAL_BOOL 'is' 'not' 'equal' 'to' BOOLEAN_EXPR  {OnRule};
                    BOOLEAN_FCTR_AUX -> '0x0028' LOGICAL_BOOL '0x0029' {OnRule}| '0x0028' LOGICAL_BOOL_AUX '0x0029' {OnRule}| 'not ->' LOGICAL_BOOL {OnRule} | 'not ->' LOGICAL_BOOL_AUX {OnRule};

                    EXPR -> STRING_EXPR {OnRule} | NUMBER_EXPR {OnRule} | BOOLEAN_EXPR {OnRule} | RETFUNCT_NAME '(' PARAM_VAL ')' ';' {OnRule} ;

                    VAR_ID_LIST -> VAR_ID {OnRule} | (VAR_ID ',')+ {OnRule} ;
                    DECLARE_VAR -> DATA_TYPE VAR_ID_LIST {OnRule} ;
                    VAR_DECLS -> DECLARE_VAR ';' {OnRule} ;
                    VAR_DECLS_AUX -> DECLARE_VAR ';' VAR_DECLS {OnRule} ;

                    ASSIGN_STMT -> VAR_ID 'equal' 'to' EXPR ';' {OnRule} ;

                    RET_STMT -> 'return' EXPR ';' {OnRule}  ;

                    IF_STMT -> 'when' '<' BOOLEAN_EXPR '>' 'do' STMT {OnRule} | 'when' '<' BOOLEAN_EXPR '>' 'do' STMT 'or' 'else' STMT {OnRule} ;

                    DEFAULT -> 'when' 'default' 'do' STMT_ENUM {OnRule} ;
                    CASES -> 'case' EXPR 'do' STMT_ENUM {OnRule} ;
                    CASE_AUX -> 'case' EXPR 'do' STMT_ENUM CASES* {OnRule} ;
                    SWITCH_STMT -> 'using' '<' EXPR '>' 'and' 'with' '{' CASE_AUX DEFAULT '}' {OnRule} | 'using' '<' EXPR '>' 'and' 'with' '{' CASES DEFAULT '}' {OnRule} | 'using' '<' EXPR '>' 'and' 'with' '{' DEFAULT '}' {OnRule} | 'using' '<' EXPR '>' 'and' 'with' '{' CASE_AUX '}' {OnRule} ;

                    WHILE_LOOP -> 'as' 'long' 'as' '<' BOOLEAN_EXPR '>' 'do' STMT  {OnRule} ;
                    DO_WHILE_LOOP -> 'perform' STMT 'as' 'long' 'as' '<' BOOLEAN_EXPR '>' ';' {OnRule} ;
                    FOR_LOOP -> 'where' ASSIGN_STMT 'until' BOOLEAN_EXPR 'and' ASSIGN_STMT 'do' STMT {OnRule} ;

                    INPUT_STMT -> SCANNER_TYPE '(' VAR_ID ')' ';' {OnRule} ;

                    OUT_STREAM -> '0x0022' CHARS '0x0022' {OnRule} | VAR_ID {OnRule} | EXPR {OnRule} | CONSTANT_ID {OnRule} | FUNCT_NAME '(' PARAM_VAL ')' {OnRule} ;
                    OUTPUT_STMT -> 'printing' '(' OUT_STREAM ')' ';'  {OnRule} ;

                    STMT -> ASSIGN_STMT {OnRule} | IF_STMT {OnRule} | RET_STMT {OnRule} | SWITCH_STMT {OnRule} | WHILE_LOOP {OnRule} | DO_WHILE_LOOP {OnRule} | INPUT_STMT {OnRule} | OUTPUT_STMT {OnRule} | FOR_LOOP {OnRule} | '{' STMT_ENUM '}' {OnRule} | 'break' ';' {OnRule} | 'continue' ';' {OnRule} ;

                    FUNCTION -> '{' VAR_DECLS_AUX STMT_ENUM '}' {OnRule} ;
                    PARAMETER -> DATA_TYPE DECLARE_VAR {OnRule} ;
                    PARAM_LIST -> PARAMETER {OnRule}| (PARAMETER ',')+ {OnRule} ;
                    FUNCT_NAME -> LETTERS {OnRule} ;
                    RETFUNCT_NAME -> FUNCT_NAME {OnRule} ;

                    NONRET_FUNCT -> 'void' FUNCT_NAME '(' PARAM_LIST ')' FUNCTION {OnRule} | 'void' FUNCT_NAME '(' ')' FUNCTION {OnRule} ;
                    RET_FUNCTION -> DATA_TYPE RETFUNCT_NAME '(' PARAM_LIST ')' FUNCTION {OnRule} | DATA_TYPE RETFUNCT_NAME '(' ')' FUNCTION {OnRule} ;

                    DECLARE_FUNCT -> RET_FUNCTION {OnRule} | NONRET_FUNCT {OnRule} ;
                    FUNCTS -> DECLARE_FUNCT {OnRule} ;
                    FUNCTS_AUX -> DECLARE_FUNCT FUNCTS+ {OnRule} ;

                    CALL_FUNCT -> FUNCT_NAME '(' PARAM_VAL ')' ';' {OnRule} ;
                    PARAM_VAL -> REAL_PARAM {OnRule} ;
                    REAL_PARAM -> VAR_ID | (VAR_ID ',')+  {OnRule} ;

                    STMT_AUX -> CALL_FUNCT {OnRule} | STMT {OnRule} ;
                    STMT_ENUM -> STMT_AUX+ {OnRule} ;

                    MAIN -> 'void' 'main' '(' ')' {OnRule} FUNCTION {OnRule} ;
            }
    }