#include "util/util.h"
#define SYMBOLS(X)                                    \
    X(PLUS) X(MINUS) X(TIMES) X(MORE) X(LESS) X(EQUA) \
    X(LPAREN) X(RPAREN)                               \
    X(QMARK) X(COLON)                                 \
    X(NUM) X(END_INPUT)                               \
                                                      \
    X(EP) X(E)                                        \
    X(SYMBOLS_END)

#include "parts/symbol.h"
enum symbol { SYMBOLS(X_TO_ENUM) };
size_t total_symbols = SYMBOLS_END;

extern char **symbol_to_str = (char *([])){ SYMBOLS(X_TO_STR) };

IMPLEMENT_FUNCPTR(int, symbol_is_terminal, (symbol s)) { return s < EP; }
IMPLEMENT_FUNCPTR(int, symbol_is_input_end, (symbol s)) { return s == END_INPUT; }
IMPLEMENT_FUNCPTR(int, symbol_is_valid, (symbol s)) { return s < SYMBOLS_END; }

#include "parts/grammar.h"
#define PROD(LHS, _, ...) {LHS, (symbol[]){__VA_ARGS__}, sizeof((symbol[]){__VA_ARGS__})/sizeof(symbol)}
static struct production _grammar[] = {
    PROD(EP, ->, E, END_INPUT),
    PROD(E, -->, E, PLUS, E),
    PROD(E, -->, E, MINUS, E),
    PROD(E, -->, E, TIMES, E),
    PROD(E, -->, LPAREN, E, RPAREN),
    PROD(E, -->, MINUS, E),
    PROD(E, -->, E, QMARK, E, COLON, E),
    PROD(E, -->, E, QMARK, E),
    PROD(E, -->, E, MORE, E),
    PROD(E, -->, E, LESS, E),
    PROD(E, -->, E, EQUA, E),
    PROD(E, -->, NUM),
};

struct production *grammar = _grammar;
size_t total_productions = sizeof(_grammar)/sizeof(*_grammar);

// #include "???.h"
char **semantic_action_str = (char *([])){
    "v = A(0);",
    "v = A(0) + A(2);",
    "v = A(0) - A(2);",
    "v = A(0) * A(2);",
    "v = A(1);",
    "v = - A(1);",
    "v = A(0) ? A(2) : A(4);",
    "v = A(0) ? A(2) : 0;",
    "v = A(0) > A(1);",
    "v = A(0) < A(1);",
    "v = A(0) = A(1);",
    "v = A(0);",
};

#include "parts/precedence.h"
struct precedence_def {
    int flag;
    int *list;
    size_t nlist;
};
#define PREC(f, ...) {f, (int[]){__VA_ARGS__}, sizeof((int[]){__VA_ARGS__})/sizeof(int)}
#define USE_PROD(n) (~(n))
struct precedence_def _precedence_defs[] = {
    PREC(0, QMARK),
    PREC(0, USE_PROD(7)),
    PREC(PRECEDENCE_LEFT_ASSOC, MORE, LESS, EQUA),
    PREC(PRECEDENCE_LEFT_ASSOC, MINUS, PLUS),
    PREC(PRECEDENCE_LEFT_ASSOC, TIMES, USE_PROD(5)),
    PREC(PRECEDENCE_LEFT_ASSOC, LPAREN, RPAREN),
};

struct precedence_def *precedence_defs = _precedence_defs;
size_t nprecedence_defs = sizeof(_precedence_defs)/sizeof(*_precedence_defs);