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