#include "util/util.h"
#define SYMBOLS(X)                                   \
    X(TERMINAL) X(NONTERM) X(LEFT) X(RIGHT)          \
    X(COLON) X(PIPE) X(SEMICOL) X(DOT)               \
    X(IDEN) X(NUM) X(ACTION) X(END_INPUT)            \
                                                     \
    X(Sp) X(A) X(B) X(C)                             \
    X(Type) X(Prec) X(Prod) X(Preclist) X(Prodlist)  \
    X(Actionlist) X(Idenlist) X(IorNlist)            \
    X(SYMBOLS_END)                                   \

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

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

IMPLEMENT_FUNCPTR(int, symbol_is_terminal, (symbol s)) { return s < Sp; }
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)}
#define GRAMMAR_ACTION_DEF(X)                                    \
    X(PROD(Sp, -->, A, B, C, END_INPUT), "")                     \
                                                                 \
    X(PROD(A, -->, TERMINAL, Idenlist,                           \
           SEMICOL, NONTERM, Idenlist, DOT),                     \
      "handle_type(A(1), A(4))")                                 \
                                                                 \
    X(PROD(B, -->, Preclist), "handle_prec(A(0));")              \
    X(PROD(Preclist, -->, Prec, SEMICOL, Preclist),              \
      "v = list_new_head(A(2), A(0));")                          \
    X(PROD(Preclist, -->, Prec, DOT), "v = A(0);")               \
    X(PROD(Prec, -->, LEFT,  IorNlist),                          \
      "v = prec_new(A(1), PRECEDENCE_LEFT_ASSOC);")              \
    X(PROD(Prec, -->, RIGHT, IorNlist),                          \
      "v = prec_new(A(1), PRECEDENCE_RIGHT_ASSOC);")             \
                                                                 \
    X(PROD(C, -->, Prodlist), "handle_prod(A(0));")              \
    X(PROD(Prodlist, -->, Prod, SEMICOL, Prodlist),              \
      "v = list_new_head(A(2), A(0));")                          \
    X(PROD(Prodlist, -->, Prod, DOT), "v = A(0);")               \
    X(PROD(Prod, -->, IDEN, COLON, Actionlist),                  \
      "v = prod_new(A(0), A(2));")                               \
    X(PROD(Actionlist, -->, Idenlist, ACTION, PIPE, Actionlist), \
      "v = list_new_head(A(3), action_new(A(0), A(1)));")        \
    X(PROD(Actionlist, -->, Idenlist, ACTION),                   \
      "v = action_new(A(0), A(1));")                             \
                                                                 \
    X(PROD(Idenlist, -->, IDEN, Idenlist),                       \
      "v = list_new_head(A(1), ptr_new(A(0)));")                 \
    X(PROD(Idenlist, -->, IDEN), "v = ptr_new(A(0));")           \
    X(PROD(IorNlist, -->, IDEN, IorNlist),                       \
      "v = list_new_head(A(1), ptr_new(A(0)));")                 \
    X(PROD(IorNlist, -->, IDEN), "v = ptr_new(A(0));")           \
    X(PROD(IorNlist, -->, NUM, IorNlist),                        \
      "v = list_new_head(A(1), num_new(A(0)));")                 \
    X(PROD(IorNlist, -->, NUM),  "v = num_new(A(0));")           \

#define X_GRAMMAR(G, A) G,
#define X_ACTION(G, A) A,

static struct production _grammar[] = {
    GRAMMAR_ACTION_DEF(X_GRAMMAR)
};

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

// #include "???.h"
char **semantic_action_str = (char *([])){
    GRAMMAR_ACTION_DEF(X_ACTION)
};

#include "parts/precedence.h"
struct precedence_def {
    int flag;
    int *list;
    size_t nlist;
};

struct precedence_def *precedence_defs = NULL;
size_t nprecedence_defs = 0;