boolean_algebra.h

Go to the documentation of this file.

 
#ifndef BALG_H
#define BALG_H
 
#include "../../include/grammar.h"
#include "../../include/rule_macros.h"
 
 
#define BALG_PRODUCTION_COUNT 17
 
#define BALG_MAX_ALTERNATIVE_COUNT 5
 
#define BALG_MAX_ALTERNATIVE_SIZE 4
 
enum balg_tk {
        /* Literals */
        TK_TRUE, TK_FALSE, TK_IDENT,
        /* Operators */
        TK_PIPE, TK_AMP, TK_EXCL,
        /* Punctuation */
        TK_LPAREN, TK_RPAREN, TK_LCURLY, TK_RCURLY,
        TK_EQ, TK_COMMA, TK_SEMI,
};
 
enum balg_nt {
        NT_BIT, NT_IDENT, NT_CALL,
        NT_CALL_OPTPARAMS,
 
        /* Expression hierarchy (precedence) */
        NT_EXPR, NT_EXPR_REST,  // level 1: OR
        NT_TERM, NT_TERM_REST,  // level 2: AND
        NT_FACTOR, NT_ATOM,     // level 3: NOT and Atoms
 
        /* Statements */
        NT_STMT, NT_STMTS, NT_ASGN,
 
        /* List helpers */
        NT_IDENT_LS, NT_IDENT_LS_REST,
        NT_EXPR_LS, NT_EXPR_LS_REST,
};
 
const char *const balg_tk_names[] = {
        "1", "0", "@ident",
        "|", "&", "!",
        "(", ")", "{", "}",
        "=", ",", ";",
};
 
const char *const balg_tk_names_escaped[] = {
        "1", "0", "@ident",
        "\\|", "&", "!",
        "(", ")", "\\{", "\\}",
        "=", ",", ";",
};
 
const char *const balg_nt_names[] = {
        "bit", "ident", "call",
        "call_optparams",
 
        "expr", "expr_rest",
        "term", "term_rest",
        "factor", "atom",
 
        "stmt", "stmts", "asgn",
 
        "ident_ls", "ident_ls_rest",
        "expr_ls", "expr_ls_rest",
};
 
static const struct rdesc_grammar_symbol
balg[BALG_PRODUCTION_COUNT]
    [BALG_MAX_ALTERNATIVE_COUNT + 1  /* +1 for end of production sentinel */]
    [BALG_MAX_ALTERNATIVE_SIZE + 1  /* +1 for end of alternative sentinel */] = {
        /* <bit> ::= */ r(
                TK(TRUE)
        alt     TK(FALSE)
        ),
        /* <ident> ::= */ r(
                TK(IDENT)
        ),
        /* <call> ::= */ r(
                TK(IDENT), TK(LPAREN), NT(CALL_OPTPARAMS), TK(RPAREN)
        ),
        /* <call_optparams> ::= */
                ropt(NT(EXPR_LS)),
 
        /* <expr> ::= */
                rrr(EXPR, (NT(TERM)), (TK(PIPE), NT(TERM))),
 
        /* <term> ::= */
                rrr(TERM, (NT(FACTOR)), (TK(AMP), NT(FACTOR))),
        /* <factor> ::= */ r(
                TK(EXCL), NT(ATOM)
        alt     NT(ATOM)
        ),
 
        /* Intentional ambiguity for stress testing. The grammar has two rules
         * starting with '(':
         *  "(" <expr> ")" Parenthesized expression
         *  "(" asgn ")" Parenthesized assignment
         *
         * The parser must consume "(", try to parse <expr>, and if it fails
         * (e.g., it encounters an "="), it must backtrack, restore the "(",
         * and try parsing <asgn>. */
        /* <atom> ::= */ r(
                TK(LPAREN), NT(EXPR), TK(RPAREN)
        alt     TK(LPAREN), NT(ASGN), TK(RPAREN) // <-- Ambiguity trigger
        alt     NT(BIT)
        alt     NT(IDENT)
        alt     NT(CALL)
        ),
 
        /* <stmt> ::= */ r(
                TK(SEMI)
        alt     NT(CALL), TK(SEMI)
        alt     NT(ASGN), TK(SEMI)
        alt     TK(LCURLY), NT(STMTS), TK(RCURLY)
        ),
 
        /* <stmts> ::= */ ropt(NT(STMT), NT(STMTS)),
 
        /* <asgn> */ r(
                NT(IDENT_LS), TK(EQ), NT(EXPR_LS)
        ),
 
        /* <ident_ls> ::= */
                rrr(IDENT_LS, (NT(IDENT)), (TK(COMMA), NT(IDENT))),
 
        /* <expr_ls> ::= */
                rrr(EXPR_LS, (NT(EXPR)), (TK(COMMA), NT(EXPR)))
};
 
 
#endif