git.m6w6.name Git - m6w6/ext-psi/blob - src/parser_proc.y

   1 %include {
   2 #include "php_psi_stdinc.h"
   3
   4 #include <assert.h>
   5 #include <stdarg.h>
   6
   7 #include "plist.h"
   8 #include "parser.h"
   9
  10 /* rename lemon symbols, works better than DEF(%name) */
  11 #define ParseAlloc psi_parser_proc_init_ex
  12 #define Parse psi_parser_proc_parse
  13 #define ParseTrace psi_parser_proc_trace
  14 #define ParseFree psi_parser_proc_free_ex
  15
  16 /* fwd decls */
  17 void *ParseAlloc(void *(*mallocProc)(size_t));
  18 void ParseFree(void *p, void (*freeProc)(void*));
  19
  20 /* wrappers */
  21 void *psi_parser_proc_init(void)
  22 {
  23         return ParseAlloc(malloc);
  24 }
  25
  26 void psi_parser_proc_free(void **parser_proc)
  27 {
  28         if (*parser_proc) {
  29                 ParseFree(*parser_proc, free);
  30                 *parser_proc = NULL;
  31         }
  32 }
  33
  34 }
  35 %token_prefix PSI_T_
  36 %token_type {struct psi_token *}
  37 %token_destructor {free($$);}
  38 %default_destructor {(void)P;}
  39 %extra_argument {struct psi_parser *P}
  40 %syntax_error { ++P->errors; if (TOKEN) { psi_error(PSI_WARNING, TOKEN->file, TOKEN->line, "PSI syntax error: Unexpected token '%s' at pos %u", TOKEN->text, TOKEN->col); } else { psi_error(PSI_WARNING, P->file.fn, P->line, "PSI syntax error: Unexpected end of input"); } }
  41 %token_class const_type_token BOOL INT FLOAT STRING .
  42 %token_class decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME .
  43 %token_class impl_def_val_token NULL NUMBER TRUE FALSE QUOTED_STRING .
  44 %token_class number_token NUMBER NSNAME .
  45 %token_class binary_op_token PIPE CARET AMPERSAND LSHIFT RSHIFT PLUS MINUS ASTERISK SLASH MODULO RCHEVR LCHEVR CMP_GE CMP_LE OR AND CMP_EQ CMP_NE .
  46 %token_class unary_op_token TILDE NOT PLUS MINUS .
  47 %token_class let_func_token ZVAL OBJVAL ARRVAL PATHVAL STRLEN STRVAL FLOATVAL INTVAL BOOLVAL COUNT .
  48 %token_class set_func_token TO_OBJECT TO_ARRAY TO_STRING TO_INT TO_FLOAT TO_BOOL ZVAL VOID .
  49 %token_class impl_type_token VOID MIXED BOOL INT FLOAT STRING ARRAY OBJECT CALLABLE .
  50 %token_class assert_stmt_token PRE_ASSERT POST_ASSERT .
  51 %token_class cpp_message_token ERROR WARNING .
  52 %nonassoc NAME.
  53 %right NOT TILDE.
  54 %left AND OR.
  55 %left PIPE.
  56 %left CARET.
  57 %left AMPERSAND.
  58 %left CMP_EQ CMP_NE.
  59 %left LCHEVR CMP_LE RCHEVR CMP_GE.
  60 %left LSHIFT RSHIFT.
  61 %left PLUS MINUS.
  62 %left ASTERISK SLASH MODULO.
  63 %fallback NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT.
  64 %wildcard ANY.
  65 %type decl_enum {struct psi_decl_enum *}
  66 %destructor decl_enum {psi_decl_enum_free(&$$);}
  67 %type decl_enum_items {struct psi_plist*}
  68 %destructor decl_enum_items {psi_plist_free($$);}
  69 %type decl_enum_item {struct psi_decl_enum_item*}
  70 %destructor decl_enum_item {psi_decl_enum_item_free(&$$);}
  71 %type decl_struct_args_block {struct psi_plist*}
  72 %destructor decl_struct_args_block {psi_plist_free($$);}
  73 %type decl_struct_args {struct psi_plist*}
  74 %destructor decl_struct_args {psi_plist_free($$);}
  75 %type decl_struct {struct psi_decl_struct*}
  76 %destructor decl_struct {psi_decl_struct_free(&$$);}
  77 %type align_and_size {struct psi_layout}
  78 %type decl_union {struct psi_decl_union*}
  79 %destructor decl_union {psi_decl_union_free(&$$);}
  80 %type const_type {struct psi_const_type*}
  81 %destructor const_type {psi_const_type_free(&$$);}
  82 %type constant {struct psi_const*}
  83 %destructor constant {psi_const_free(&$$);}
  84 %type decl_typedef {struct psi_decl_arg*}
  85 %destructor decl_typedef {psi_decl_arg_free(&$$);}
  86 %type decl_typedef_body_ex {struct psi_decl_arg*}
  87 %destructor decl_typedef_body_ex {psi_decl_arg_free(&$$);}
  88 %type decl_typedef_body {struct psi_decl_arg*}
  89 %destructor decl_typedef_body {psi_decl_arg_free(&$$);}
  90 %type decl_typedef_body_fn_args {struct psi_plist*}
  91 %destructor decl_typedef_body_fn_args {psi_plist_free($$);}
  92 %type decl {struct psi_decl*}
  93 %destructor decl {psi_decl_free(&$$);}
  94 %type decl_func {struct psi_decl_arg*}
  95 %destructor decl_func {psi_decl_arg_free(&$$);}
  96 %type decl_abi {struct psi_decl_abi*}
  97 %destructor decl_abi {psi_decl_abi_free(&$$);}
  98 %type decl_var {struct psi_decl_var*}
  99 %destructor decl_var {psi_decl_var_free(&$$);}
 100 %type decl_vars {struct psi_plist*}
 101 %destructor decl_vars {psi_plist_free($$);}
 102 %type decl_arg {struct psi_decl_arg*}
 103 %destructor decl_arg {psi_decl_arg_free(&$$);}
 104 %type decl_args {struct psi_plist*}
 105 %destructor decl_args {psi_plist_free($$);}
 106 %type struct_args {struct psi_plist*}
 107 %destructor struct_args {psi_plist_free($$);}
 108 %type struct_arg {struct psi_decl_arg*}
 109 %destructor struct_arg {psi_decl_arg_free(&$$);}
 110 %type decl_layout {struct psi_layout*}
 111 %destructor decl_layout {psi_layout_free(&$$);}
 112 %type decl_type {struct psi_decl_type*}
 113 %destructor decl_type {psi_decl_type_free(&$$);}
 114 %type const_decl_type {struct psi_decl_type*}
 115 %destructor const_decl_type {psi_decl_type_free(&$$);}
 116 %type impl {struct psi_impl*}
 117 %destructor impl {psi_impl_free(&$$);}
 118 %type impl_func {struct psi_impl_func*}
 119 %destructor impl_func {psi_impl_func_free(&$$);}
 120 %type impl_def_val {struct psi_impl_def_val*}
 121 %destructor impl_def_val {psi_impl_def_val_free(&$$);}
 122 %type impl_var {struct psi_impl_var*}
 123 %destructor impl_var {psi_impl_var_free(&$$);}
 124 %type impl_arg {struct psi_impl_arg*}
 125 %destructor impl_arg {psi_impl_arg_free(&$$);}
 126 %type impl_args {struct psi_plist*}
 127 %destructor impl_args {psi_plist_free($$);}
 128 %type impl_vararg {struct psi_impl_arg*}
 129 %destructor impl_vararg {psi_impl_arg_free(&$$);}
 130 %type impl_stmts {struct psi_plist*}
 131 %destructor impl_stmts {psi_plist_free($$);}
 132 %type impl_stmt {struct psi_token**}
 133 %destructor impl_stmt {psi_impl_stmt_free(&$$);}
 134 %type number {struct psi_number*}
 135 %destructor number {psi_number_free(&$$);}
 136 %type num_exp {struct psi_num_exp*}
 137 %destructor num_exp {psi_num_exp_free(&$$);}
 138 %type let_stmt {struct psi_let_stmt*}
 139 %destructor let_stmt {psi_let_stmt_free(&$$);}
 140 %type let_calloc {struct psi_let_calloc*}
 141 %destructor let_calloc {psi_let_calloc_free(&$$);}
 142 %type let_func {struct psi_let_func*}
 143 %destructor let_func {psi_let_func_free(&$$);}
 144 %type callback_arg_list {struct psi_plist *}
 145 %destructor callback_arg_list {psi_plist_free($$);}
 146 %type callback_args {struct psi_plist *}
 147 %destructor callback_args {psi_plist_free($$);}
 148 %type let_callback {struct psi_let_callback*}
 149 %destructor let_callback {psi_let_callback_free(&$$);}
 150 %type let_exp {struct psi_let_exp*}
 151 %destructor let_exp {psi_let_exp_free(&$$);}
 152 %type let_exps {struct psi_plist*}
 153 %destructor let_exps {psi_plist_free($$);}
 154 %type assert_stmt {struct psi_assert_stmt*}
 155 %destructor assert_stmt {psi_assert_stmt_free(&$$);}
 156 %type set_stmt {struct psi_set_stmt*}
 157 %destructor set_stmt {psi_set_stmt_free(&$$);}
 158 %type set_exp {struct psi_set_exp*}
 159 %destructor set_exp {psi_set_exp_free(&$$);}
 160 %type set_exps {struct psi_plist*}
 161 %destructor set_exps {psi_plist_free($$);}
 162 %type set_func {struct psi_set_func*}
 163 %destructor set_func {psi_set_func_free(&$$);}
 164 %type return_stmt {struct psi_return_stmt*}
 165 %destructor return_stmt {psi_return_stmt_free(&$$);}
 166 %type free_stmt {struct psi_free_stmt*}
 167 %destructor free_stmt {psi_free_stmt_free(&$$);}
 168 %type free_exps {struct psi_plist*}
 169 %destructor free_exps {psi_plist_free($$);}
 170 %type free_exp {struct psi_free_exp*}
 171 %destructor free_exp {psi_free_exp_free(&$$);}
 172 %type impl_type {struct psi_impl_type*}
 173 %destructor impl_type {psi_impl_type_free(&$$);}
 174 %type cpp_exp {struct psi_cpp_exp*}
 175 %destructor cpp_exp {psi_cpp_exp_free(&$$);}
 176 %type cpp_macro_decl {struct psi_cpp_macro_decl*}
 177 %destructor cpp_macro_decl {psi_cpp_macro_decl_free(&$$);}
 178 %type cpp_macro_decl_tokens {struct psi_plist*}
 179 %destructor cpp_macro_decl_tokens {psi_plist_free($$);}
 180 %type cpp_macro_exp {struct psi_num_exp*}
 181 %destructor cpp_macro_exp {psi_num_exp_free(&$$);}
 182 %type cpp_macro_sig {struct psi_plist*}
 183 %destructor cpp_macro_sig {psi_plist_free($$);}
 184 %type cpp_macro_sig_args {struct psi_plist*}
 185 %destructor cpp_macro_sig_args {psi_plist_free($$);}
 186 %type cpp_macro_call {struct psi_plist*}
 187 %destructor cpp_macro_call {psi_plist_free($$);}
 188 %type cpp_macro_call_args {struct psi_plist*}
 189 %destructor cpp_macro_call_args {psi_plist_free($$);}
 190 %type reference {bool}
 191 %type indirection {unsigned}
 192 %type pointers {unsigned}
 193 file ::= blocks.
 194 blocks ::= block.
 195 blocks ::= blocks block.
 196 block ::= EOS.
 197 block ::= EOL.
 198 block ::= COMMENT.
 199 block ::= HASH cpp_exp(exp_) EOL. {
 200  P->cpp.exp = exp_;
 201 }
 202 cpp_exp(exp) ::= cpp_message_token(T) QUOTED_STRING(S). {
 203  exp = psi_cpp_exp_init(T->type, S);
 204  exp->token = T;
 205 }
 206 cpp_exp(exp) ::= IFDEF(T) NAME(N). {
 207  exp = psi_cpp_exp_init(T->type, N);
 208  exp->token = T;
 209 }
 210 cpp_exp(exp) ::= IFNDEF(T) NAME(N). {
 211  exp = psi_cpp_exp_init(T->type, N);
 212  exp->token = T;
 213 }
 214 cpp_exp(exp) ::= ENDIF(T). {
 215  exp = psi_cpp_exp_init(T->type, NULL);
 216  exp->token = T;
 217 }
 218 cpp_exp(exp) ::= ELSE(T). {
 219  exp = psi_cpp_exp_init(T->type, NULL);
 220  exp->token = T;
 221 }
 222 cpp_exp(exp) ::= UNDEF(T) NAME(N). {
 223  exp = psi_cpp_exp_init(T->type, N);
 224  exp->token = T;
 225 }
 226 cpp_exp(exp) ::= DEFINE(T) NAME(N) cpp_macro_decl(macro). {
 227  exp = psi_cpp_exp_init(T->type, macro);
 228  exp->token = T;
 229  macro->token = N;
 230 }
 231 cpp_macro_decl(macro) ::= . {
 232  macro = psi_cpp_macro_decl_init(NULL, NULL, NULL);
 233 }
 234 cpp_macro_decl(macro) ::= cpp_macro_sig(sig). {
 235  macro = psi_cpp_macro_decl_init(sig, NULL, NULL);
 236 }
 237 cpp_macro_decl(macro) ::= cpp_macro_sig(sig) cpp_macro_decl_tokens(tokens). {
 238  macro = psi_cpp_macro_decl_init(sig, tokens, NULL);
 239 }
 240 cpp_macro_sig(sig) ::= NO_WHITESPACE LPAREN cpp_macro_sig_args(args) RPAREN. {
 241  sig = args;
 242 }
 243 cpp_macro_sig_args(args) ::= . {
 244  args = NULL;
 245 }
 246 cpp_macro_sig_args(args) ::= NAME(arg). {
 247  args = psi_plist_add(psi_plist_init((void (*)(void *)) psi_token_free), &arg);
 248 }
 249 cpp_macro_sig_args(args) ::= cpp_macro_sig_args(args_) COMMA NAME(arg). {
 250  args = psi_plist_add(args_, &arg);
 251 }
 252 cpp_macro_decl(macro) ::= cpp_macro_decl_tokens(tokens). {
 253  macro = psi_cpp_macro_decl_init(NULL, tokens, NULL);
 254 }
 255 cpp_macro_decl_tokens(tokens) ::= ANY(T). {
 256  tokens = psi_plist_add(psi_plist_init((void (*)(void *)) psi_token_free), &T);
 257 }
 258 cpp_macro_decl_tokens(tokens) ::= cpp_macro_decl_tokens(tokens_) ANY(T). {
 259  tokens = psi_plist_add(tokens_, &T);
 260 }
 261 cpp_exp(exp) ::= IF(T) cpp_macro_exp(macro). {
 262  exp = psi_cpp_exp_init(T->type, macro);
 263  exp->token = T;
 264 }
 265 cpp_exp(exp) ::= ELIF(T) cpp_macro_exp(macro). {
 266  exp = psi_cpp_exp_init(T->type, macro);
 267  exp->token = T;
 268 }
 269 cpp_macro_exp(exp) ::= LPAREN(L) cpp_macro_exp(exp_) RPAREN. {
 270  exp = psi_num_exp_init_unary(L->type, exp_);
 271  exp->token = L;
 272 }
 273 cpp_macro_exp(exp) ::= unary_op_token(OP) cpp_macro_exp(exp_). {
 274  exp = psi_num_exp_init_unary(OP->type, exp_);
 275  exp->token = OP;
 276 }
 277 cpp_macro_exp(exp) ::= cpp_macro_exp(lhs) binary_op_token(OP) cpp_macro_exp(rhs). {
 278  exp = psi_num_exp_init_binary(OP->type, lhs, rhs);
 279  exp->token = OP;
 280 }
 281 cpp_macro_exp(exp) ::= DEFINED NAME(N). {
 282  {
 283   uint8_t exists = zend_hash_str_exists(&P->cpp.defs, N->text, N->size);
 284   exp = psi_num_exp_init_num(psi_number_init(PSI_T_UINT8, &exists));
 285   exp->token = N;
 286  }
 287 }
 288 cpp_macro_exp(exp) ::= DEFINED LPAREN NAME(N) RPAREN. {
 289  {
 290   uint8_t exists = zend_hash_str_exists(&P->cpp.defs, N->text, N->size);
 291   exp = psi_num_exp_init_num(psi_number_init(PSI_T_UINT8, &exists));
 292   exp->token = N;
 293  }
 294 }
 295 cpp_macro_exp(exp) ::= number_token(tok). {
 296  exp = psi_num_exp_init_num(psi_number_init(tok->type, tok->text));
 297  exp->token = tok;
 298  exp->data.n->token = psi_token_copy(tok);
 299 }
 300 cpp_macro_exp(exp) ::= NAME(N). {
 301  exp = psi_num_exp_init_num(psi_number_init(PSI_T_DEFINE, N->text));
 302  exp->token = N;
 303  exp->data.n->token = psi_token_copy(N);
 304 }
 305 cpp_macro_exp(exp) ::= NAME(N) LPAREN cpp_macro_call_args(args) RPAREN. {
 306  exp = psi_num_exp_init_num(psi_number_init(PSI_T_FUNCTION,
 307    psi_cpp_macro_call_init(N->text, args)));
 308  exp->token = N;
 309 }
 310 cpp_macro_call_args(args) ::= . {
 311  args = NULL;
 312 }
 313 cpp_macro_call_args(args) ::= cpp_macro_exp(arg). {
 314  args = psi_plist_add(psi_plist_init((void (*)(void *)) psi_num_exp_free), &arg);
 315 }
 316 cpp_macro_call_args(args) ::= cpp_macro_call_args(args_) COMMA cpp_macro_exp(arg). {
 317  args = psi_plist_add(args_, &arg);
 318 }
 319 block ::= LIB(token) QUOTED_STRING(libname) EOS. {
 320  if (P->file.ln) {
 321   P->error(PSI_DATA(P), token, PSI_WARNING, "Extra 'lib %s' statement has no effect", libname->text);
 322  } else {
 323   P->file.ln = strndup(libname->text + 1, libname->size - 2);
 324  }
 325  free(libname);
 326  free(token);
 327 }
 328 block ::= decl(decl). {
 329  if (!P->decls) {
 330   P->decls = psi_plist_init((psi_plist_dtor) psi_decl_free);
 331  }
 332  P->decls = psi_plist_add(P->decls, &decl);
 333 }
 334 block ::= impl(impl). {
 335  if (!P->impls) {
 336   P->impls = psi_plist_init((psi_plist_dtor) psi_impl_free);
 337  }
 338  P->impls = psi_plist_add(P->impls, &impl);
 339 }
 340 block ::= decl_typedef(def). {
 341  if (!P->types) {
 342   P->types = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
 343  }
 344  P->types = psi_plist_add(P->types, &def);
 345  switch (def->type->type) {
 346  case PSI_T_STRUCT:
 347   if (def->type->real.strct) {
 348    if (!P->structs) {
 349     P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
 350    }
 351    P->structs = psi_plist_add(P->structs, &def->type->real.strct);
 352   }
 353   break;
 354  case PSI_T_UNION:
 355   if (def->type->real.unn) {
 356    if (!P->unions) {
 357     P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
 358    }
 359    P->unions = psi_plist_add(P->unions, &def->type->real.unn);
 360   }
 361   break;
 362  case PSI_T_ENUM:
 363   if (def->type->real.enm) {
 364    if (!P->enums) {
 365     P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
 366    }
 367    P->enums = psi_plist_add(P->enums, &def->type->real.enm);
 368   }
 369   break;
 370  }
 371 }
 372 block ::= constant(constant). {
 373  if (!P->consts) {
 374   P->consts = psi_plist_init((psi_plist_dtor) psi_const_free);
 375  }
 376  P->consts = psi_plist_add(P->consts, &constant);
 377 }
 378 block ::= decl_struct(strct). {
 379  if (!P->structs) {
 380   P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
 381  }
 382  P->structs = psi_plist_add(P->structs, &strct);
 383 }
 384 block ::= decl_union(u). {
 385  if (!P->unions) {
 386   P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
 387  }
 388  P->unions = psi_plist_add(P->unions, &u);
 389 }
 390 block ::= decl_enum(e). {
 391  if (!P->enums) {
 392   P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
 393  }
 394  P->enums = psi_plist_add(P->enums, &e);
 395 }
 396 optional_name(n) ::= . {
 397  n = NULL;
 398 }
 399 optional_name(n) ::= NAME(N). {
 400  n = N;
 401 }
 402 align_and_size(as) ::= . {
 403  as.pos = 0;
 404  as.len = 0;
 405 }
 406 align_and_size(as) ::= COLON COLON LPAREN NUMBER(A) COMMA NUMBER(S) RPAREN. {
 407  as.pos = atol(A->text);
 408  as.len = atol(S->text);
 409  free(A);
 410  free(S);
 411 }
 412 enum_name(n) ::= ENUM(E) optional_name(N). {
 413  if (N) {
 414   n = N;
 415   free(E);
 416  } else {
 417   char digest[17];
 418   psi_token_hash(E, digest);
 419   n = psi_token_append("@", E, 1, digest);
 420  }
 421 }
 422 struct_name(n) ::= STRUCT(S) optional_name(N). {
 423  if (N) {
 424   n = N;
 425   free(S);
 426  } else {
 427   char digest[17];
 428   psi_token_hash(S, digest);
 429   n = psi_token_append("@", S, 1, digest);
 430  }
 431 }
 432 union_name(n) ::= UNION(U) optional_name(N). {
 433  if (N) {
 434   n = N;
 435   free(U);
 436  } else {
 437   char digest[17];
 438   psi_token_hash(U, digest);
 439   n = psi_token_append("@", U, 1, digest);
 440  }
 441 }
 442 decl_enum(e) ::= enum_name(N) LBRACE decl_enum_items(list) RBRACE. {
 443  e = psi_decl_enum_init(N->text, list);
 444  e->token = N;
 445 }
 446 decl_enum_items(l) ::= decl_enum_item(i). {
 447  l = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_enum_item_free),
 448    &i);
 449 }
 450 decl_enum_items(l) ::= decl_enum_items(l_) COMMA decl_enum_item(i). {
 451  l = psi_plist_add(l_, &i);
 452 }
 453 decl_enum_item(i) ::= NAME(N) EQUALS num_exp(num). {
 454  i = psi_decl_enum_item_init(N->text, num);
 455  i->token = N;
 456 }
 457 decl_enum_item(i) ::= NAME(N). {
 458  i = psi_decl_enum_item_init(N->text, NULL);
 459  i->token = N;
 460 }
 461 decl_struct_args_block(args_) ::= LBRACE struct_args(args) RBRACE. {
 462  args_ = args;
 463 }
 464 decl_struct_args(args_) ::= decl_struct_args_block(args). {
 465  args_ = args;
 466 }
 467 decl_struct_args(args_) ::= EOS. {
 468  args_ = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
 469 }
 470 decl_struct(strct) ::= STRUCT NAME(N) align_and_size(as) decl_struct_args(args). {
 471  strct = psi_decl_struct_init(N->text, args);
 472  strct->align = as.pos;
 473  strct->size = as.len;
 474  strct->token = N;
 475 }
 476 decl_union(u) ::= UNION NAME(N) align_and_size(as) decl_struct_args(args). {
 477  u = psi_decl_union_init(N->text, args);
 478  u->align = as.pos;
 479  u->size = as.len;
 480  u->token = N;
 481 }
 482 const_type(type_) ::= const_type_token(T). {
 483  type_ = psi_const_type_init(T->type, T->text);
 484  free(T);
 485 }
 486 constant(constant) ::= CONST const_type(type) NSNAME(T) EQUALS impl_def_val(val) EOS. {
 487  constant = psi_const_init(type, T->text, val);
 488  constant->token = T;
 489 }
 490 decl_typedef(def) ::= TYPEDEF(T) decl_typedef_body(def_) EOS. {
 491  def = def_;
 492  def->token = T;
 493 }
 494 decl_typedef_body_ex(def) ::= struct_name(N) align_and_size(as) decl_struct_args_block(args) decl_var(var). {
 495  def = psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT, N->text), var);
 496  def->type->token = psi_token_copy(N);
 497  def->type->real.strct = psi_decl_struct_init(N->text, args);
 498  def->type->real.strct->token = N;
 499  def->type->real.strct->align = as.pos;
 500  def->type->real.strct->size = as.len;
 501 }
 502 decl_typedef_body_ex(def) ::= union_name(N) align_and_size(as) decl_struct_args_block(args) decl_var(var). {
 503  def = psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION, N->text), var);
 504  def->type->token = psi_token_copy(N);
 505  def->type->real.unn = psi_decl_union_init(N->text, args);
 506  def->type->real.unn->token = N;
 507  def->type->real.unn->align = as.pos;
 508  def->type->real.unn->size = as.len;
 509 }
 510 decl_typedef_body_ex(def) ::= decl_enum(e) NAME(ALIAS). {
 511  def = psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM, e->name), psi_decl_var_init(ALIAS->text, 0, 0));
 512  def->var->token = ALIAS;
 513  def->type->token = psi_token_copy(e->token);
 514  def->type->real.enm = e;
 515 }
 516 decl_typedef_body(def) ::= decl_typedef_body_ex(def_). {
 517  def = def_;
 518 }
 519 decl_typedef_body_fn_args(args) ::= LPAREN decl_args(args_) RPAREN. {
 520  args = args_;
 521 }
 522 decl_typedef_body(def) ::= decl_func(func_) decl_typedef_body_fn_args(args). {
 523  def = psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION, func_->var->name), psi_decl_var_copy(func_->var));
 524  def->type->token = psi_token_copy(func_->token);
 525  def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 526 }
 527 decl_typedef_body(def) ::= decl_arg(arg). {
 528  def = arg;
 529 }
 530 decl(decl) ::= decl_abi(abi) decl_func(func) LPAREN decl_args(args) RPAREN EOS. {
 531  decl = psi_decl_init(abi, func, args);
 532 }
 533 decl(decl) ::= decl_abi(abi) decl_func(func) LPAREN decl_args(args) COMMA ELLIPSIS RPAREN EOS. {
 534  decl = psi_decl_init(abi, func, args);
 535  decl->varargs = 1;
 536 }
 537 decl_func(func) ::= decl_arg(arg). {
 538  func = arg;
 539 }
 540 decl_func(func) ::= VOID(T) NAME(N). {
 541  func = psi_decl_arg_init(
 542   psi_decl_type_init(T->type, T->text),
 543   psi_decl_var_init(N->text, 0, 0)
 544  );
 545  func->type->token = T;
 546  func->var->token = N;
 547  func->token = N;
 548 }
 549 decl_typedef_body(def) ::= VOID(T) indirection(decl_i) LPAREN indirection(type_i) NAME(N) RPAREN decl_typedef_body_fn_args(args). {
 550  struct psi_decl_arg *func_ = psi_decl_arg_init(
 551   psi_decl_type_init(T->type, T->text),
 552   psi_decl_var_init(N->text, decl_i, 0)
 553  );
 554  func_->type->token = T;
 555  func_->var->token = N;
 556  func_->token = N;
 557  def = psi_decl_arg_init(
 558   psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
 559   psi_decl_var_copy(func_->var)
 560  );
 561  def->var->pointer_level = type_i;
 562  def->type->token = psi_token_copy(func_->token);
 563  def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 564 }
 565 decl_typedef_body(def) ::= CONST VOID(T) pointers(decl_i) LPAREN indirection(type_i) NAME(N) RPAREN decl_typedef_body_fn_args(args). {
 566  struct psi_decl_arg *func_ = psi_decl_arg_init(
 567   psi_decl_type_init(T->type, T->text),
 568   psi_decl_var_init(N->text, decl_i, 0)
 569  );
 570  func_->type->token = T;
 571  func_->var->token = N;
 572  func_->token = N;
 573  def = psi_decl_arg_init(
 574   psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
 575   psi_decl_var_copy(func_->var)
 576  );
 577  def->var->pointer_level = type_i;
 578  def->type->token = psi_token_copy(func_->token);
 579  def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 580 }
 581 decl_abi(abi) ::= NAME(T). {
 582  abi = psi_decl_abi_init(T->text);
 583  abi->token = T;
 584 }
 585 decl_var_array_size(as) ::= . {
 586  as = NULL;
 587 }
 588 decl_var_array_size(as) ::= LBRACKET NUMBER(D) RBRACKET. {
 589  as = D;
 590 }
 591 decl_var(var) ::= NAME(T) decl_var_array_size(as). {
 592  var = psi_decl_var_init(T->text, 0, as?atol(as->text):0);
 593  var->token = T;
 594  if (as) {
 595   free(as);
 596  }
 597 }
 598 decl_var(var) ::= pointers(p) NAME(T) decl_var_array_size(as). {
 599  var = psi_decl_var_init(T->text, p+!!as, as?atol(as->text):0);
 600  var->token = T;
 601  if (as) {
 602   free(as);
 603  }
 604 }
 605 decl_vars(vars) ::= decl_var(var). {
 606  vars = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_var_free),
 607    &var);
 608 }
 609 decl_vars(vars) ::= decl_vars(vars_) COMMA decl_var(var). {
 610  vars = psi_plist_add(vars_, &var);
 611 }
 612 decl_arg(arg_) ::= const_decl_type(type) decl_var(var). {
 613  arg_ = psi_decl_arg_init(type, var);
 614 }
 615 decl_typedef_body(def) ::= const_decl_type(type_) indirection(decl_i) LPAREN indirection(type_i) NAME(N) RPAREN decl_typedef_body_fn_args(args). {
 616  struct psi_decl_arg *func_ = psi_decl_arg_init(
 617   type_,
 618   psi_decl_var_init(N->text, decl_i, 0)
 619  );
 620  func_->var->token = N;
 621  func_->token = N;
 622  def = psi_decl_arg_init(
 623   psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
 624   psi_decl_var_copy(func_->var)
 625  );
 626  def->var->pointer_level = type_i;
 627  def->type->token = psi_token_copy(func_->token);
 628  def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 629 }
 630 decl_arg(arg_) ::= VOID(T) pointers(p) NAME(N). {
 631  arg_ = psi_decl_arg_init(
 632   psi_decl_type_init(T->type, T->text),
 633   psi_decl_var_init(N->text, p, 0)
 634  );
 635  arg_->type->token = T;
 636  arg_->var->token = N;
 637  arg_->token = N;
 638 }
 639 decl_arg(arg_) ::= CONST VOID(T) pointers(p) NAME(N). {
 640  arg_ = psi_decl_arg_init(
 641   psi_decl_type_init(T->type, T->text),
 642   psi_decl_var_init(N->text, p, 0)
 643  );
 644  arg_->type->token = T;
 645  arg_->var->token = N;
 646  arg_->token = N;
 647 }
 648 decl_args(args) ::= . {
 649  args = NULL;
 650 }
 651 decl_args(args) ::= VOID. {
 652  args = NULL;
 653 }
 654 decl_args(args) ::= decl_arg(arg). {
 655  args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
 656    &arg);
 657 }
 658 decl_args(args) ::= decl_args(args_) COMMA decl_arg(arg). {
 659  args = psi_plist_add(args_, &arg);
 660 }
 661 struct_args(args) ::= struct_arg(arg). {
 662  args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
 663    &arg);
 664 }
 665 struct_args(args) ::= struct_args(args_) struct_arg(arg). {
 666  args = psi_plist_add(args_, &arg);
 667 }
 668 struct_arg(arg_) ::= decl_typedef_body_ex(def) EOS. {
 669  arg_ = def;
 670  switch (def->type->type) {
 671  case PSI_T_STRUCT:
 672   if (def->type->real.strct) {
 673    if (!P->structs) {
 674     P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
 675    }
 676    P->structs = psi_plist_add(P->structs, &def->type->real.strct);
 677   }
 678   break;
 679  case PSI_T_UNION:
 680   if (def->type->real.unn) {
 681    if (!P->unions) {
 682     P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
 683    }
 684    P->unions = psi_plist_add(P->unions, &def->type->real.unn);
 685   }
 686   break;
 687  case PSI_T_ENUM:
 688   if (def->type->real.enm) {
 689    if (!P->enums) {
 690     P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
 691    }
 692    P->enums = psi_plist_add(P->enums, &def->type->real.enm);
 693   }
 694   break;
 695  }
 696 }
 697 struct_arg(arg) ::= decl_arg(arg_) decl_layout(layout_) EOS. {
 698  arg_->layout = layout_;
 699  arg = arg_;
 700 }
 701 decl_layout(layout) ::= . {
 702  layout = NULL;
 703 }
 704 decl_layout(layout) ::= COLON COLON LPAREN NUMBER(POS) COMMA NUMBER(SIZ) RPAREN. {
 705  layout = psi_layout_init(atol(POS->text), atol(SIZ->text));
 706  free(POS);
 707  free(SIZ);
 708 }
 709 decl_scalar_type(type_) ::= CHAR(C). {
 710  type_ = C;
 711 }
 712 decl_scalar_type(type_) ::= SHORT(S) decl_scalar_type_short(s). {
 713  if (s) {
 714   type_ = psi_token_cat(" ", 2, S, s);
 715   free(S);
 716   free(s);
 717  } else {
 718   type_ = S;
 719  }
 720 }
 721 decl_scalar_type_short(s) ::= . {
 722  s = NULL;
 723 }
 724 decl_scalar_type_short(s) ::= INT(I). {
 725  s = I;
 726 }
 727 decl_scalar_type(type_) ::= INT(I). {
 728  type_ = I;
 729 }
 730 decl_scalar_type(type_) ::= LONG(L) decl_scalar_type_long(l). {
 731  if (l) {
 732   type_ = psi_token_cat(" ", 2, L, l);
 733   free(L);
 734   free(l);
 735  } else {
 736   type_ = L;
 737  }
 738 }
 739 decl_scalar_type_long(l) ::= . {
 740  l = NULL;
 741 }
 742 decl_scalar_type_long(l) ::= DOUBLE(D). {
 743  l = D;
 744 }
 745 decl_scalar_type_long(l) ::= LONG(L) decl_scalar_type_long_long(ll). {
 746  if (ll) {
 747   l = psi_token_cat(" ", 2, L, ll);
 748   free(L);
 749   free(ll);
 750  } else {
 751   l = L;
 752  }
 753 }
 754 decl_scalar_type_long_long(ll) ::= . {
 755  ll = NULL;
 756 }
 757 decl_scalar_type_long_long(ll) ::= INT(I). {
 758  ll = I;
 759 }
 760 decl_type(type_) ::= UNSIGNED(U) decl_scalar_type(N). {
 761  struct psi_token *T = psi_token_cat(" ", 2, U, N);
 762  type_ = psi_decl_type_init(T->type, T->text);
 763  type_->token = T;
 764  free(U);
 765  free(N);
 766 }
 767 decl_type(type_) ::= SIGNED(S) decl_scalar_type(N). {
 768  struct psi_token *T = psi_token_cat(" ", 2, S, N);
 769  type_ = psi_decl_type_init(T->type, T->text);
 770  type_->token = T;
 771  free(S);
 772  free(N);
 773 }
 774 decl_type(type_) ::= UNSIGNED(U). {
 775  type_ = psi_decl_type_init(PSI_T_NAME, U->text);
 776  type_->token = U;
 777 }
 778 decl_type(type_) ::= SIGNED(S). {
 779  type_ = psi_decl_type_init(PSI_T_NAME, S->text);
 780  type_->token = S;
 781 }
 782 decl_type(type_) ::= decl_scalar_type(N). {
 783  type_ = psi_decl_type_init(N->type, N->text);
 784  type_->token = N;
 785 }
 786 decl_type(type_) ::= STRUCT(S) NAME(T). {
 787  type_ = psi_decl_type_init(S->type, T->text);
 788  type_->token = T;
 789  free(S);
 790 }
 791 decl_type(type_) ::= UNION(U) NAME(T). {
 792  type_ = psi_decl_type_init(U->type, T->text);
 793  type_->token = T;
 794  free(U);
 795 }
 796 decl_type(type_) ::= ENUM(E) NAME(T). {
 797  type_ = psi_decl_type_init(E->type, T->text);
 798  type_->token = T;
 799  free(E);
 800 }
 801 decl_type(type_) ::= decl_type_token(T). {
 802  type_ = psi_decl_type_init(T->type, T->text);
 803  type_->token = T;
 804 }
 805 const_decl_type(type) ::= decl_type(type_). {
 806  type = type_;
 807 }
 808 const_decl_type(type) ::= CONST decl_type(type_). {
 809  type = type_;
 810 }
 811 impl(impl) ::= impl_func(func) LBRACE impl_stmts(stmts) RBRACE. {
 812  impl = psi_impl_init(func, stmts);
 813 }
 814 impl(impl) ::= STATIC impl_func(func) LBRACE impl_stmts(stmts) RBRACE. {
 815  func->static_memory = 1;
 816  impl = psi_impl_init(func, stmts);
 817 }
 818 impl_func(func) ::= FUNCTION reference(r) NSNAME(NAME) LPAREN RPAREN COLON impl_type(type). {
 819  func = psi_impl_func_init(NAME->text, NULL, type);
 820  func->token = NAME;
 821  func->return_reference = r;
 822 }
 823 impl_func(func) ::= FUNCTION reference(r) NSNAME(NAME) LPAREN impl_args(args) RPAREN COLON impl_type(type). {
 824  func = psi_impl_func_init(NAME->text, args, type);
 825  func->token = NAME;
 826  func->return_reference = r;
 827 }
 828 impl_func(func) ::= FUNCTION reference(func_r) NSNAME(NAME) LPAREN impl_args(args) COMMA impl_type(va_type) reference(va_r) ELLIPSIS DOLLAR_NAME(T) RPAREN COLON impl_type(func_type). {
 829  func = psi_impl_func_init(NAME->text, args, func_type);
 830  func->token = NAME;
 831  func->return_reference = func_r;
 832  func->vararg = psi_impl_arg_init(va_type, psi_impl_var_init(T->text, va_r), NULL);
 833  free(T);
 834 }
 835 impl_def_val(def) ::= impl_def_val_token(T). {
 836  def = psi_impl_def_val_init(T->type, T->text);
 837  def->token = T;
 838 }
 839 impl_var(var) ::= reference(r) DOLLAR_NAME(T). {
 840  var = psi_impl_var_init(T->text, r);
 841  var->token = T;
 842 }
 843 impl_type(type_) ::= impl_type_token(T). {
 844  type_ = psi_impl_type_init(T->type, T->text);
 845  free(T);
 846 }
 847 impl_arg(arg) ::= impl_type(type) impl_var(var). {
 848  arg = psi_impl_arg_init(type, var, NULL);
 849 }
 850 impl_arg(arg) ::= impl_type(type) impl_var(var) EQUALS impl_def_val(def). {
 851  arg = psi_impl_arg_init(type, var, def);
 852 }
 853 impl_args(args) ::= impl_arg(arg). {
 854  args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_arg_free),
 855    &arg);
 856 }
 857 impl_args(args) ::= impl_args(args_) COMMA impl_arg(arg). {
 858  args = psi_plist_add(args_, &arg);
 859 }
 860 impl_stmts(stmts) ::= impl_stmt(stmt). {
 861  stmts = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_stmt_free),
 862    &stmt);
 863 }
 864 impl_stmts(stmts) ::= impl_stmts(stmts_) impl_stmt(stmt). {
 865  stmts = psi_plist_add(stmts_, &stmt);
 866 }
 867 impl_stmt(i) ::= return_stmt(r). {
 868  i = (struct psi_token**) r;
 869 }
 870 impl_stmt(i) ::= let_stmt(l). {
 871  i = (struct psi_token**) l;
 872 }
 873 impl_stmt(i) ::= set_stmt(s). {
 874  i = (struct psi_token**) s;
 875 }
 876 impl_stmt(i) ::= assert_stmt(s). {
 877  i = (struct psi_token **) s;
 878 }
 879 impl_stmt(i) ::= free_stmt(f). {
 880  i = (struct psi_token**) f;
 881 }
 882 number(exp) ::= number_token(tok). {
 883  exp = psi_number_init(tok->type, tok->text);
 884  exp->token = tok;
 885 }
 886 number(exp) ::= decl_var(var). {
 887  exp = psi_number_init(PSI_T_NAME, var);
 888  exp->token = psi_token_copy(var->token);
 889 }
 890 num_exp(exp) ::= number(num). {
 891  exp = psi_num_exp_init_num(num);
 892  exp->token = psi_token_copy(num->token);
 893 }
 894 num_exp(exp) ::= LPAREN(L) num_exp(exp_) RPAREN. {
 895  exp = psi_num_exp_init_unary(PSI_T_LPAREN, exp_);
 896  exp->token = L;
 897 }
 898 num_exp(exp) ::= num_exp(lhs_) binary_op_token(OP) num_exp(rhs_). {
 899  exp = psi_num_exp_init_binary(OP->type, lhs_, rhs_);
 900  exp->token = OP;
 901 }
 902 num_exp(exp) ::= unary_op_token(OP) num_exp(exp_). {
 903  exp = psi_num_exp_init_unary(OP->type, exp_);
 904  exp->token = OP;
 905 }
 906 let_exp(val) ::= NULL. {
 907  val = psi_let_exp_init(PSI_LET_NULL, NULL);
 908 }
 909 let_exp(val) ::= AMPERSAND NULL. {
 910  val = psi_let_exp_init(PSI_LET_NULL, NULL);
 911  val->is_reference = 1;
 912 }
 913 let_exp(val) ::= let_callback(cb). {
 914  val = psi_let_exp_init(PSI_LET_CALLBACK, cb);
 915 }
 916 let_exp(val) ::= let_calloc(ca). {
 917  val = psi_let_exp_init(PSI_LET_CALLOC, ca);
 918 }
 919 let_exp(val) ::= AMPERSAND let_calloc(ca). {
 920  val = psi_let_exp_init(PSI_LET_CALLOC, ca);
 921  val->is_reference = 1;
 922 }
 923 let_exp(val) ::= let_func(fn). {
 924  val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
 925 }
 926 let_exp(val) ::= AMPERSAND let_func(fn). {
 927  val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
 928  val->is_reference = 1;
 929 }
 930 let_exp(val) ::= num_exp(exp). {
 931  val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
 932 }
 933 let_exp(val) ::= AMPERSAND num_exp(exp). {
 934  val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
 935  val->is_reference = 1;
 936 }
 937 let_exp(exp) ::= decl_var(var_) EQUALS let_exp(val). {
 938  exp = val;
 939  exp->var = var_;
 940 }
 941 let_stmt(let) ::= LET(T) let_exp(val) EOS. {
 942  let = psi_let_stmt_init(val);
 943  let->token = T;
 944 }
 945 let_stmt(let) ::= TEMP(T) decl_var(var) EQUALS reference(r) decl_var(val_) EOS. {
 946  let = psi_let_stmt_init(psi_let_exp_init_ex(var, PSI_LET_TMP, val_));
 947  let->token = T;
 948  let->exp->is_reference = r ? 1 : 0;
 949 }
 950 let_callback(cb) ::= CALLBACK(T) callback_rval(F) LPAREN impl_var(var) LPAREN callback_arg_list(args_) RPAREN RPAREN. {
 951  cb = psi_let_callback_init(psi_let_func_init(F->type, F->text, var), args_);
 952  cb->token = T;
 953  free(F);
 954 }
 955 let_calloc(alloc) ::= CALLOC(T) LPAREN num_exp(nmemb) COMMA num_exp(size) RPAREN. {
 956  alloc = psi_let_calloc_init(nmemb, size);
 957  alloc->token = T;
 958 }
 959 let_func(func) ::= let_func_token(T) LPAREN impl_var(var) RPAREN. {
 960  func = psi_let_func_init(T->type, T->text, var);
 961  func->token = T;
 962 }
 963 let_func(func) ::= let_func_token(T) LPAREN impl_var(var) COMMA let_exps(vals) RPAREN. {
 964  func = psi_let_func_init(T->type, T->text, var);
 965  func->token = T;
 966  func->inner = vals;
 967 }
 968 let_exps(exps) ::= let_exp(exp). {
 969  exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_let_exp_free),
 970    &exp);
 971 }
 972 let_exps(exps) ::= let_exps(exps_) COMMA let_exp(exp). {
 973  exps = psi_plist_add(exps_, &exp);
 974 }
 975 callback_arg_list(args) ::= . {
 976  args = NULL;
 977 }
 978 callback_arg_list(args) ::= callback_args(args_). {
 979  args = args_;
 980 }
 981 callback_args(args) ::= set_exp(val). {
 982  args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
 983    &val);
 984 }
 985 callback_args(args) ::= callback_args(args_) COMMA set_exp(val). {
 986  args = psi_plist_add(args_, &val);
 987 }
 988 callback_rval(rval) ::= let_func_token(F). {
 989  rval = F;
 990 }
 991 callback_rval(rval) ::= VOID(V). {
 992  rval = V;
 993 }
 994 set_func(func) ::= set_func_token(T) LPAREN decl_var(var) RPAREN. {
 995  func = psi_set_func_init(T->type, T->text, var);
 996  func->token = T;
 997 }
 998 set_func(func) ::= set_func_token(T) LPAREN decl_var(var) COMMA set_exps(vals) RPAREN. {
 999  func = psi_set_func_init(T->type, T->text, var);
1000  func->token = T;
1001  func->inner = vals;
1002 }
1003 set_func(func) ::= set_func_token(T) LPAREN decl_var(var) COMMA ELLIPSIS RPAREN. {
1004  func = psi_set_func_init(T->type, T->text, var);
1005  func->token = T;
1006  func->recursive = 1;
1007 }
1008 set_exp(val) ::= set_func(fn). {
1009  val = psi_set_exp_init(PSI_SET_FUNC, fn);
1010 }
1011 set_exp(val) ::= num_exp(num). {
1012  val = psi_set_exp_init(PSI_SET_NUMEXP, num);
1013 }
1014 set_exps(exps) ::= set_exp(exp). {
1015  exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
1016    &exp);
1017 }
1018 set_exps(exps) ::= set_exps(exps_) COMMA set_exp(exp). {
1019  exps = psi_plist_add(exps_, &exp);
1020 }
1021 set_exp(exp) ::= impl_var(var_) EQUALS set_exp(val). {
1022  exp = val;
1023  exp->var = var_;
1024 }
1025 set_stmt(set) ::= SET(T) set_exp(exp) EOS. {
1026  set = psi_set_stmt_init(exp);
1027  set->token = T;
1028 }
1029 return_stmt(ret) ::= RETURN(T) set_func(func) EOS. {
1030  ret = psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC, func));
1031  ret->token = T;
1032 }
1033 free_stmt(free) ::= FREE(T) free_exps(calls) EOS. {
1034  free = psi_free_stmt_init(calls);
1035  free->token = T;
1036 }
1037 free_exps(calls) ::= free_exp(call). {
1038  calls = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_free_exp_free),
1039    &call);
1040 }
1041 free_exps(calls) ::= free_exps(calls_) COMMA free_exp(call). {
1042  calls = psi_plist_add(calls_, &call);
1043 }
1044 free_exp(call) ::= NAME(F) LPAREN decl_vars(vars) RPAREN. {
1045  call = psi_free_exp_init(F->text, vars);
1046  call->token = F;
1047 }
1048 assert_stmt(ass) ::= assert_stmt_token(T) num_exp(exp) EOS. {
1049  ass = psi_assert_stmt_init(T->type, exp);
1050  ass->token = T;
1051 }
1052 reference(r) ::= . {
1053  r = false;
1054 }
1055 reference(r) ::= AMPERSAND. {
1056  r = true;
1057 }
1058 indirection(i) ::= .{
1059  i = 0;
1060 }
1061 indirection(i) ::= pointers(p). {
1062  i = p;
1063 }
1064 pointers(p) ::= ASTERISK. {
1065  p = 1;
1066 }
1067 pointers(p) ::= pointers(p_) ASTERISK. {
1068  p = p_+1;
1069 }