#define CONCAT1(x,y) CONCAT2(x,y)
#define COUNTED(x) CONCAT1(parse_ ##x## _, __LINE__)
+#define TOKEN_PREFIX PSI_T
+#define TOKEN_STRUCT struct psi_token *
+
#ifdef GENERATE
# define DEF(dn, dv) dn dv
# define PASS(nt, rule) nt ::= rule.
# define TYPED(t, name) t(name)
# define TOKEN_TYPE(token, type_) %type token {type_}
# define TOKEN_DTOR(token, dtor) %destructor token {dtor}
+# define T(token) token
+# define TOKEN_CLASS(type, tokens) DEF(%token_class, type##_token tokens .)
#else
# ifndef TEST
# include "parser.h"
# define TOKEN_TYPE_NAME(token) token##_parse_t
# define TOKEN_TYPE(token, type) typedef type TOKEN_TYPE_NAME(token);
# define TOKEN_DTOR(token, dtor)
+# define T(token) CONCAT1(TOKEN_PREFIX, _ ##token ),
+# define TOKEN_CLASS(type, tokens) static token_t type##_token[] = { tokens 0 };
#endif
-DEF(%name, psi_parser_proc_)
-DEF(%token_prefix, PSI_T_)
-DEF(%token_type, {struct psi_token *})
+DEF(%token_prefix, CONCAT1(TOKEN_PREFIX,_))
+DEF(%token_type, {TOKEN_STRUCT})
DEF(%token_destructor, {free($$);})
DEF(%default_destructor, {(void)P;})
DEF(%extra_argument, {struct psi_parser *P})
}
})
+TOKEN_CLASS(const_type, T(BOOL) T(INT) T(FLOAT) T(STRING))
+TOKEN_CLASS(decl_type, T(FLOAT) T(DOUBLE) T(INT8) T(UINT8) T(INT16) T(UINT16) T(INT32) T(UINT32) T(INT64) T(UINT64) T(NAME))
+TOKEN_CLASS(impl_def_val, T(NULL) T(NUMBER) T(TRUE) T(FALSE) T(QUOTED_STRING))
+TOKEN_CLASS(number, T(NUMBER) T(NSNAME))
+TOKEN_CLASS(num_exp_binary_op, T(PIPE) T(CARET) T(AMPERSAND) T(LSHIFT) T(RSHIFT) T(PLUS) T(MINUS) T(ASTERISK) T(SLASH) T(MODULO))
+TOKEN_CLASS(num_exp_unary_op, T(TILDE) T(NOT) T(PLUS) T(MINUS))
+TOKEN_CLASS(let_func, T(ZVAL) T(OBJVAL) T(ARRVAL) T(PATHVAL) T(STRLEN) T(STRVAL) T(FLOATVAL) T(INTVAL) T(BOOLVAL) T(COUNT))
+TOKEN_CLASS(set_func, T(TO_OBJECT) T(TO_ARRAY) T(TO_STRING) T(TO_INT) T(TO_FLOAT) T(TO_BOOL) T(ZVAL) T(VOID))
+TOKEN_CLASS(impl_type, T(VOID) T(MIXED) T(BOOL) T(INT) T(FLOAT) T(STRING) T(ARRAY) T(OBJECT) T(CALLABLE))
+
DEF(%nonassoc, NAME.)
+DEF(%right, NOT TILDE.)
+DEF(%left, PIPE.)
+DEF(%left, CARET.)
+DEF(%left, AMPERSAND.)
+DEF(%left, LSHIFT RSHIFT.)
DEF(%left, PLUS MINUS.)
-DEF(%left, ASTERISK SLASH.)
-DEF(%nonassoc, AMPERSAND.)
-DEF(%fallback, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT.)
+DEF(%left, ASTERISK SLASH MODULO.)
-DEF(%token_class, const_type_token BOOL INT FLOAT STRING.)
-DEF(%token_class, decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME.)
-DEF(%token_class, impl_def_val_token NULL NUMBER TRUE FALSE QUOTED_STRING.)
-DEF(%token_class, num_exp_token NUMBER NSNAME.)
-DEF(%token_class, num_exp_op_token PLUS MINUS ASTERISK SLASH.)
-DEF(%token_class, let_func_token ZVAL OBJVAL ARRVAL PATHVAL STRLEN STRVAL FLOATVAL INTVAL BOOLVAL COUNT.)
-DEF(%token_class, set_func_token TO_OBJECT TO_ARRAY TO_STRING TO_INT TO_FLOAT TO_BOOL ZVAL VOID.)
-DEF(%token_class, impl_type_token VOID MIXED BOOL INT FLOAT STRING ARRAY OBJECT CALLABLE.)
+DEF(%fallback, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT.)
TOKEN_TYPE(decl_enum, struct psi_decl_enum *)
TOKEN_DTOR(decl_enum, psi_decl_enum_free(&$$);)
TOKEN_DTOR(impl_stmts, psi_plist_free($$);)
TOKEN_TYPE(impl_stmt, struct psi_token**)
TOKEN_DTOR(impl_stmt, psi_impl_stmt_free(&$$);)
+TOKEN_TYPE(number, struct psi_number*)
+TOKEN_DTOR(number, psi_number_free(&$$);)
TOKEN_TYPE(num_exp, struct psi_num_exp*)
TOKEN_DTOR(num_exp, psi_num_exp_free(&$$);)
TOKEN_TYPE(let_stmt, struct psi_let_stmt*)
TOKEN_DTOR(free_exp, psi_free_exp_free(&$$);)
TOKEN_TYPE(impl_type, struct psi_impl_type*)
TOKEN_DTOR(impl_type, psi_impl_type_free(&$$);)
-TOKEN_TYPE(reference, char)
+TOKEN_TYPE(reference, bool)
TOKEN_TYPE(indirection, unsigned)
TOKEN_TYPE(pointers, unsigned)
/*
* decl_args: <empty>
*/
-PASS(decl_args, )
+PARSE_TYPED(decl_args, args, ) {
+ args = NULL;
+}
/*
* decl_args: VOID
*/
-PASS(decl_args, VOID)
+PARSE_TYPED(decl_args, args,
+ TOKEN(VOID)) {
+ args = NULL;
+}
/*
* decl_args: decl_arg
}
/*
- * num_exp: num_exp_token
+ * number: number_token
*/
-PARSE_TYPED(num_exp, exp,
- NAMED(num_exp_token, tok)) {
- exp = psi_num_exp_init(tok->type, tok->text);
+PARSE_TYPED(number, exp,
+ NAMED(number_token, tok)) {
+ exp = psi_number_init(tok->type, tok->text);
exp->token = tok;
}
/*
* num_exp: decl_var
*/
-PARSE_TYPED(num_exp, exp,
+PARSE_TYPED(number, exp,
TYPED(decl_var, var)) {
- exp = psi_num_exp_init(PSI_T_NAME, var);
+ exp = psi_number_init(PSI_T_NAME, var);
exp->token = psi_token_copy(var->token);
}
/*
- * num_exp: num_exp num_exp_op_token num_exp
+ * num_exp: num_exp
+ */
+PARSE_TYPED(num_exp, exp,
+ TYPED(number, num)) {
+ exp = psi_num_exp_init_num(num);
+ exp->token = psi_token_copy(num->token);
+}
+
+/*
+ * num_exp: ( num_exp )
*/
PARSE_TYPED(num_exp, exp,
+ NAMED(LPAREN, L)
TYPED(num_exp, exp_)
- NAMED(num_exp_op_token, operator_)
- TYPED(num_exp, operand_)) {
- exp_->op = operator_->type;
- exp_->operand = operand_;
- exp = exp_;
- free(operator_);
+ TOKEN(RPAREN)) {
+ exp = psi_num_exp_init_unary(PSI_T_LPAREN, exp_);
+ exp->token = L;
+}
+
+/*
+ * num_exp: num_exp num_exp_binary_op_token num_exp
+ */
+PARSE_TYPED(num_exp, exp,
+ TYPED(num_exp, lhs_)
+ NAMED(num_exp_binary_op_token, OP)
+ TYPED(num_exp, rhs_)) {
+ exp = psi_num_exp_init_binary(OP->type, lhs_, rhs_);
+ exp->token = OP;
+}
+
+/*
+ * num_exp: num_exp_unary_op_token num_exp
+ */
+PARSE_TYPED(num_exp, exp,
+ NAMED(num_exp_unary_op_token, OP)
+ TYPED(num_exp, exp_)) {
+ exp = psi_num_exp_init_unary(OP->type, exp_);
+ exp->token = OP;
}
/*
/*
* callback_arg_list: <empty>
*/
-PASS(callback_arg_list, )
+PARSE_TYPED(callback_arg_list, args, ) {
+ args = NULL;
+}
/*
* callback_arg_list: callback_args
* free_stmt: FREE free_exps ;
*/
PARSE_TYPED(free_stmt, free,
- TOKEN(FREE)
+ NAMED(FREE, T)
TYPED(free_exps, calls)
TOKEN(EOS)) {
free = psi_free_stmt_init(calls);
+ free->token = T;
}
/*
* reference: <empty>
*/
PARSE_TYPED(reference, r, ) {
- r = 0;
+ r = false;
}
/*
*/
PARSE_TYPED(reference, r,
TOKEN(AMPERSAND)) {
- r = 1;
+ r = true;
}
/*
projects / m6w6 / ext-psi / blobdiff