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