git.m6w6.name Git - m6w6/ext-psi/blob - src/parser_def.h

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8      * Redistributions of source code must retain the above copyright notice,
   9        this list of conditions and the following disclaimer.
  10      * Redistributions in binary form must reproduce the above copyright
  11        notice, this list of conditions and the following disclaimer in the
  12        documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24 *******************************************************************************/
  25
  26 #define CONCAT2(x,y) x##y
  27 #define CONCAT1(x,y) CONCAT2(x,y)
  28 #define COUNTED(x) CONCAT1(parse_ ##x## _, __LINE__)
  29
  30 #ifdef GENERATE
  31 # define DEF(dn, dv) dn dv
  32 # define PASS(nt, rule) nt ::= rule.
  33 # define PARSE(nt, rule) nt ::= rule.
  34 # define PARSE_NAMED(nt, nt_name, rule) NAMED(nt, nt_name) ::= rule.
  35 # define PARSE_TYPED(nt, nt_name, rule) TYPED(nt, nt_name) ::= rule.
  36 # define TOKEN(t) t
  37 # define NAMED(t, name) t(name)
  38 # define TYPED(t, name) t(name)
  39 # define TOKEN_TYPE(token, type_) %type token {type_}
  40 # define TOKEN_DTOR(token, dtor) %destructor token {dtor}
  41 #else
  42 # ifndef TEST
  43 #  include "parser.h"
  44 #  include "plist.h"
  45 # endif
  46 # define DEF(dn, dv)
  47 # define PASS(nt, rule) \
  48         static void COUNTED(nt) (struct psi_parser *P) { \
  49                 (void) #rule; \
  50         }
  51 # define PARSE(nt, rule) \
  52         static void COUNTED(nt) (struct psi_parser *P rule)
  53 # define PARSE_NAMED(nt, nt_name, rule) \
  54         static void COUNTED(nt) (struct psi_parser *P NAMED(nt, nt_name) rule)
  55 # define PARSE_TYPED(nt, nt_name, rule) \
  56         static void COUNTED(nt) (struct psi_parser *P TYPED(nt, nt_name) rule)
  57 # define TOKEN(t)
  58 # define NAMED(t, name) , struct psi_token *name
  59 # define TYPED(t, name) , TOKEN_TYPE_NAME(t) name
  60 # define TOKEN_TYPE_NAME(token) token##_parse_t
  61 # define TOKEN_TYPE(token, type) typedef type TOKEN_TYPE_NAME(token);
  62 # define TOKEN_DTOR(token, dtor)
  63 #endif
  64
  65 DEF(%name, psi_parser_proc_)
  66 DEF(%token_prefix, PSI_T_)
  67 DEF(%token_type, {struct psi_token *})
  68 DEF(%token_destructor, {free($$);})
  69 DEF(%default_destructor, {(void)P;})
  70 DEF(%extra_argument, {struct psi_parser *P})
  71
  72 /* TOKEN is defined inside syntax_error */
  73 DEF(%syntax_error, {
  74         ++P->errors;
  75         if (TOKEN && TOKEN->type != PSI_T_EOF) {
  76                 psi_error(PSI_WARNING, TOKEN->file, TOKEN->line, "PSI syntax error: Unexpected token '%s' at pos %u", TOKEN->text, TOKEN->col);
  77         } else {
  78                 psi_error(PSI_WARNING, P->file.fn, P->line, "PSI syntax error: Unexpected end of input");
  79         }
  80 })
  81
  82 DEF(%token_class, const_type_token BOOL INT FLOAT STRING.)
  83 DEF(%token_class, decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME.)
  84 DEF(%token_class, impl_def_val_token NULL NUMBER TRUE FALSE QUOTED_STRING.)
  85 DEF(%token_class, number_token NUMBER NSNAME.)
  86 DEF(%token_class, num_exp_binary_op_token PIPE CARET AMPERSAND LSHIFT RSHIFT PLUS MINUS ASTERISK SLASH MODULO.)
  87 DEF(%token_class, num_exp_unary_op_token TILDE NOT PLUS MINUS.)
  88 DEF(%token_class, let_func_token ZVAL OBJVAL ARRVAL PATHVAL STRLEN STRVAL FLOATVAL INTVAL BOOLVAL COUNT.)
  89 DEF(%token_class, set_func_token TO_OBJECT TO_ARRAY TO_STRING TO_INT TO_FLOAT TO_BOOL ZVAL VOID.)
  90 DEF(%token_class, impl_type_token VOID MIXED BOOL INT FLOAT STRING ARRAY OBJECT CALLABLE.)
  91
  92 DEF(%nonassoc, NAME.)
  93 DEF(%right, NOT TILDE.)
  94 DEF(%left, PIPE.)
  95 DEF(%left, CARET.)
  96 DEF(%left, AMPERSAND.)
  97 DEF(%left, LSHIFT RSHIFT.)
  98 DEF(%left, PLUS MINUS.)
  99 DEF(%left, ASTERISK SLASH MODULO.)
 100 /*
 101 DEF(%left, ASTERISK SLASH MODULO.)
 102 DEF(%left, PLUS MINUS.)
 103 DEF(%left, LSHIFT RSHIFT.)
 104 DEF(%left, AMPERSAND.)
 105 DEF(%left, CARET.)
 106 DEF(%left, PIPE.)
 107 */
 108 DEF(%fallback, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT.)
 109
 110 TOKEN_TYPE(decl_enum, struct psi_decl_enum *)
 111 TOKEN_DTOR(decl_enum, psi_decl_enum_free(&$$);)
 112 TOKEN_TYPE(decl_enum_items, struct psi_plist*)
 113 TOKEN_DTOR(decl_enum_items, psi_plist_free($$);)
 114 TOKEN_TYPE(decl_enum_item, struct psi_decl_enum_item*)
 115 TOKEN_DTOR(decl_enum_item, psi_decl_enum_item_free(&$$);)
 116 TOKEN_TYPE(decl_struct_args_block, struct psi_plist*)
 117 TOKEN_DTOR(decl_struct_args_block, psi_plist_free($$);) /* there was a typo */
 118 TOKEN_TYPE(decl_struct_args, struct psi_plist*)
 119 TOKEN_DTOR(decl_struct_args, psi_plist_free($$);)
 120 TOKEN_TYPE(decl_struct, struct psi_decl_struct*)
 121 TOKEN_DTOR(decl_struct, psi_decl_struct_free(&$$);)
 122 TOKEN_TYPE(align_and_size, struct psi_layout)
 123 TOKEN_TYPE(decl_union, struct psi_decl_union*)
 124 TOKEN_DTOR(decl_union, psi_decl_union_free(&$$);)
 125 TOKEN_TYPE(const_type, struct psi_const_type*)
 126 TOKEN_DTOR(const_type, psi_const_type_free(&$$);)
 127 TOKEN_TYPE(constant, struct psi_const*)
 128 TOKEN_DTOR(constant, psi_const_free(&$$);)
 129 TOKEN_TYPE(decl_typedef, struct psi_decl_arg*)
 130 TOKEN_DTOR(decl_typedef, psi_decl_arg_free(&$$);)
 131 TOKEN_TYPE(decl_typedef_body_ex, struct psi_decl_arg*)
 132 TOKEN_DTOR(decl_typedef_body_ex, psi_decl_arg_free(&$$);)
 133 TOKEN_TYPE(decl_typedef_body, struct psi_decl_arg*)
 134 TOKEN_DTOR(decl_typedef_body, psi_decl_arg_free(&$$);)
 135 TOKEN_TYPE(decl_typedef_body_fn_args, struct psi_plist*)
 136 TOKEN_DTOR(decl_typedef_body_fn_args, psi_plist_free($$);)
 137 TOKEN_TYPE(decl, struct psi_decl*)
 138 TOKEN_DTOR(decl, psi_decl_free(&$$);)
 139 TOKEN_TYPE(decl_func, struct psi_decl_arg*)
 140 TOKEN_DTOR(decl_func, psi_decl_arg_free(&$$);)
 141 TOKEN_TYPE(decl_abi, struct psi_decl_abi*)
 142 TOKEN_DTOR(decl_abi, psi_decl_abi_free(&$$);)
 143 TOKEN_TYPE(decl_var, struct psi_decl_var*)
 144 TOKEN_DTOR(decl_var, psi_decl_var_free(&$$);)
 145 TOKEN_TYPE(decl_vars, struct psi_plist*)
 146 TOKEN_DTOR(decl_vars, psi_plist_free($$);)
 147 TOKEN_TYPE(decl_arg, struct psi_decl_arg*)
 148 TOKEN_DTOR(decl_arg, psi_decl_arg_free(&$$);)
 149 TOKEN_TYPE(decl_args, struct psi_plist*)
 150 TOKEN_DTOR(decl_args, psi_plist_free($$);)
 151 TOKEN_TYPE(struct_args, struct psi_plist*)
 152 TOKEN_DTOR(struct_args, psi_plist_free($$);)
 153 TOKEN_TYPE(struct_arg, struct psi_decl_arg*)
 154 TOKEN_DTOR(struct_arg, psi_decl_arg_free(&$$);)
 155 TOKEN_TYPE(decl_layout, struct psi_layout*)
 156 TOKEN_DTOR(decl_layout, psi_layout_free(&$$);)
 157 TOKEN_TYPE(decl_type, struct psi_decl_type*)
 158 TOKEN_DTOR(decl_type, psi_decl_type_free(&$$);)
 159 TOKEN_TYPE(const_decl_type, struct psi_decl_type*)
 160 TOKEN_DTOR(const_decl_type, psi_decl_type_free(&$$);)
 161 TOKEN_TYPE(impl, struct psi_impl*)
 162 TOKEN_DTOR(impl, psi_impl_free(&$$);)
 163 TOKEN_TYPE(impl_func, struct psi_impl_func*)
 164 TOKEN_DTOR(impl_func, psi_impl_func_free(&$$);)
 165 TOKEN_TYPE(impl_def_val, struct psi_impl_def_val*)
 166 TOKEN_DTOR(impl_def_val, psi_impl_def_val_free(&$$);)
 167 TOKEN_TYPE(impl_var, struct psi_impl_var*)
 168 TOKEN_DTOR(impl_var, psi_impl_var_free(&$$);)
 169 TOKEN_TYPE(impl_arg, struct psi_impl_arg*)
 170 TOKEN_DTOR(impl_arg, psi_impl_arg_free(&$$);)
 171 TOKEN_TYPE(impl_args, struct psi_plist*)
 172 TOKEN_DTOR(impl_args, psi_plist_free($$);)
 173 TOKEN_TYPE(impl_vararg, struct psi_impl_arg*)
 174 TOKEN_DTOR(impl_vararg, psi_impl_arg_free(&$$);)
 175 TOKEN_TYPE(impl_stmts, struct psi_plist*)
 176 TOKEN_DTOR(impl_stmts, psi_plist_free($$);)
 177 TOKEN_TYPE(impl_stmt, struct psi_token**)
 178 TOKEN_DTOR(impl_stmt, psi_impl_stmt_free(&$$);)
 179 TOKEN_TYPE(number, struct psi_number*)
 180 TOKEN_DTOR(number, psi_number_free(&$$);)
 181 TOKEN_TYPE(num_exp, struct psi_num_exp*)
 182 TOKEN_DTOR(num_exp, psi_num_exp_free(&$$);)
 183 TOKEN_TYPE(let_stmt, struct psi_let_stmt*)
 184 TOKEN_DTOR(let_stmt, psi_let_stmt_free(&$$);)
 185 TOKEN_TYPE(let_calloc, struct psi_let_calloc*)
 186 TOKEN_DTOR(let_calloc, psi_let_calloc_free(&$$);)
 187 TOKEN_TYPE(let_func, struct psi_let_func*)
 188 TOKEN_DTOR(let_func, psi_let_func_free(&$$);)
 189 TOKEN_TYPE(callback_arg_list, struct psi_plist *)
 190 TOKEN_DTOR(callback_arg_list, psi_plist_free($$);)
 191 TOKEN_TYPE(callback_args, struct psi_plist *)
 192 TOKEN_DTOR(callback_args, psi_plist_free($$);)
 193 TOKEN_TYPE(let_callback, struct psi_let_callback*)
 194 TOKEN_DTOR(let_callback, psi_let_callback_free(&$$);)
 195 TOKEN_TYPE(let_exp, struct psi_let_exp*)
 196 TOKEN_DTOR(let_exp, psi_let_exp_free(&$$);)
 197 TOKEN_TYPE(let_exps, struct psi_plist*)
 198 TOKEN_DTOR(let_exps, psi_plist_free($$);)
 199 TOKEN_TYPE(set_stmt, struct psi_set_stmt*)
 200 TOKEN_DTOR(set_stmt, psi_set_stmt_free(&$$);)
 201 TOKEN_TYPE(set_exp, struct psi_set_exp*)
 202 TOKEN_DTOR(set_exp, psi_set_exp_free(&$$);)
 203 TOKEN_TYPE(set_exps, struct psi_plist*)
 204 TOKEN_DTOR(set_exps, psi_plist_free($$);)
 205 TOKEN_TYPE(set_func, struct psi_set_func*)
 206 TOKEN_DTOR(set_func, psi_set_func_free(&$$);)
 207 TOKEN_TYPE(return_stmt, struct psi_return_stmt*)
 208 TOKEN_DTOR(return_stmt, psi_return_stmt_free(&$$);)
 209 TOKEN_TYPE(free_stmt, struct psi_free_stmt*)
 210 TOKEN_DTOR(free_stmt, psi_free_stmt_free(&$$);)
 211 TOKEN_TYPE(free_exps, struct psi_plist*)
 212 TOKEN_DTOR(free_exps, psi_plist_free($$);)
 213 TOKEN_TYPE(free_exp, struct psi_free_exp*)
 214 TOKEN_DTOR(free_exp, psi_free_exp_free(&$$);)
 215 TOKEN_TYPE(impl_type, struct psi_impl_type*)
 216 TOKEN_DTOR(impl_type, psi_impl_type_free(&$$);)
 217 TOKEN_TYPE(reference, bool)
 218 TOKEN_TYPE(indirection, unsigned)
 219 TOKEN_TYPE(pointers, unsigned)
 220
 221 PASS(file, blocks)
 222 PASS(blocks, block)
 223 PASS(blocks, blocks block)
 224
 225 PASS(block, EOF)
 226 PASS(block, EOS)
 227
 228 /*
 229  * lib: LIB "soname" ;
 230  */
 231 PARSE(block, NAMED(LIB, token) NAMED(QUOTED_STRING, libname) TOKEN(EOS)) {
 232         if (P->file.ln) {
 233                 P->error(PSI_DATA(P), token, PSI_WARNING, "Extra 'lib %s' statement has no effect", libname->text);
 234         } else {
 235                 P->file.ln = strndup(libname->text + 1, libname->size - 2);
 236         }
 237         free(libname);
 238         free(token);
 239 }
 240
 241 PARSE(block, TYPED(decl, decl)) {
 242         if (!P->decls) {
 243                 P->decls = psi_plist_init((psi_plist_dtor) psi_decl_free);
 244         }
 245         P->decls = psi_plist_add(P->decls, &decl);
 246 }
 247
 248 PARSE(block, TYPED(impl, impl)) {
 249         if (!P->impls) {
 250                 P->impls = psi_plist_init((psi_plist_dtor) psi_impl_free);
 251         }
 252         P->impls = psi_plist_add(P->impls, &impl);
 253 }
 254
 255 PARSE(block, TYPED(decl_typedef, def)) {
 256         if (!P->types) {
 257                 P->types = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
 258         }
 259         P->types = psi_plist_add(P->types, &def);
 260
 261         switch (def->type->type) {
 262         case PSI_T_STRUCT:
 263                 if (def->type->real.strct) {
 264                         if (!P->structs) {
 265                                 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
 266                         }
 267                         P->structs = psi_plist_add(P->structs, &def->type->real.strct);
 268                 }
 269                 break;
 270         case PSI_T_UNION:
 271                 if (def->type->real.unn) {
 272                         if (!P->unions) {
 273                                 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
 274                         }
 275                         P->unions = psi_plist_add(P->unions, &def->type->real.unn);
 276                 }
 277                 break;
 278         case PSI_T_ENUM:
 279                 if (def->type->real.enm) {
 280                         if (!P->enums) {
 281                                 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
 282                         }
 283                         P->enums = psi_plist_add(P->enums, &def->type->real.enm);
 284                 }
 285                 break;
 286         }
 287 }
 288
 289 PARSE(block, TYPED(constant, constant)) {
 290         if (!P->consts) {
 291                 P->consts = psi_plist_init((psi_plist_dtor) psi_const_free);
 292         }
 293         P->consts = psi_plist_add(P->consts, &constant);
 294 }
 295
 296 PARSE(block, TYPED(decl_struct, strct)) {
 297         if (!P->structs) {
 298                 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
 299         }
 300         P->structs = psi_plist_add(P->structs, &strct);
 301 }
 302
 303 PARSE(block, TYPED(decl_union, u)) {
 304         if (!P->unions) {
 305                 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
 306         }
 307         P->unions = psi_plist_add(P->unions, &u);
 308 }
 309
 310 PARSE(block, TYPED(decl_enum, e)) {
 311         if (!P->enums) {
 312                 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
 313         }
 314         P->enums = psi_plist_add(P->enums, &e);
 315 }
 316
 317 /*
 318  * optional_name: <empty>
 319  */
 320 PARSE_NAMED(optional_name, n, ) {
 321         n = NULL;
 322 }
 323
 324 /*
 325  * optional_name: NAME
 326  */
 327 PARSE_NAMED(optional_name, n,
 328                 NAMED(NAME, N)) {
 329         n = N;
 330 }
 331
 332 /*
 333  * align_and_size: <empty>
 334  */
 335 PARSE_TYPED(align_and_size, as, ) {
 336         as.pos = 0;
 337         as.len = 0;
 338 }
 339
 340 /*
 341  * align_and_size: :: ( NUMBER , NUMBER )
 342  */
 343 PARSE_TYPED(align_and_size, as,
 344                 TOKEN(COLON)
 345                 TOKEN(COLON)
 346                 TOKEN(LPAREN)
 347                 NAMED(NUMBER, A)
 348                 TOKEN(COMMA)
 349                 NAMED(NUMBER, S)
 350                 TOKEN(RPAREN)) {
 351         as.pos = atol(A->text);
 352         as.len = atol(S->text);
 353         free(A);
 354         free(S);
 355 }
 356
 357 /*
 358  * enum_name: ENUM optional_name
 359  */
 360 PARSE_NAMED(enum_name, n,
 361                 NAMED(ENUM, E)
 362                 NAMED(optional_name, N)) {
 363         if (N) {
 364                 n = N;
 365                 free(E);
 366         } else {
 367                 char digest[17];
 368
 369                 psi_token_hash(E, digest);
 370                 n = psi_token_translit(psi_token_append(E, 1, digest), " ", "@");
 371         }
 372 }
 373
 374 /*
 375  * struct_name: STRUCT optional_name
 376  */
 377 PARSE_NAMED(struct_name, n,
 378                 NAMED(STRUCT, S)
 379                 NAMED(optional_name, N)) {
 380         if (N) {
 381                 n = N;
 382                 free(S);
 383         } else {
 384                 char digest[17];
 385
 386                 psi_token_hash(S, digest);
 387                 n = psi_token_translit(psi_token_append(S, 1, digest), " ", "@");
 388         }
 389 }
 390
 391 /*
 392  * union_name: UNION optional_name
 393  */
 394 PARSE_NAMED(union_name, n,
 395                 NAMED(UNION, U)
 396                 NAMED(optional_name, N)) {
 397         if (N) {
 398                 n = N;
 399                 free(U);
 400         } else {
 401                 char digest[17];
 402
 403                 psi_token_hash(U, digest);
 404                 n = psi_token_translit(psi_token_append(U, 1, digest), " ", "@");
 405         }
 406 }
 407
 408 /*
 409  * decl_enum: enum_name { items }
 410  */
 411 PARSE_TYPED(decl_enum, e,
 412                 NAMED(enum_name, N)
 413                 TOKEN(LBRACE)
 414                 TYPED(decl_enum_items, list)
 415                 TOKEN(RBRACE)) {
 416         e = psi_decl_enum_init(N->text, list);
 417         e->token = N;
 418 }
 419
 420 /*
 421  * decl_enum_items: item
 422  */
 423 PARSE_TYPED(decl_enum_items, l,
 424                 TYPED(decl_enum_item, i)) {
 425         l = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_enum_item_free),
 426                         &i);
 427 }
 428
 429 /*
 430  * decl_enum_items: items , item
 431  */
 432 PARSE_TYPED(decl_enum_items, l,
 433                 TYPED(decl_enum_items, l_)
 434                 TOKEN(COMMA)
 435                 TYPED(decl_enum_item, i)) {
 436         l = psi_plist_add(l_, &i);
 437 }
 438
 439 /*
 440  * decl_enum_item: name = num_exp
 441  */
 442 PARSE_TYPED(decl_enum_item, i,
 443                 NAMED(NAME, N)
 444                 TOKEN(EQUALS)
 445                 TYPED(num_exp, num)) {
 446         i = psi_decl_enum_item_init(N->text, num);
 447         i->token = N;
 448 }
 449
 450 /*
 451  * decl_enum_item: name
 452  */
 453 PARSE_TYPED(decl_enum_item, i,
 454                 NAMED(NAME, N)) {
 455         i = psi_decl_enum_item_init(N->text, NULL);
 456         i->token = N;
 457 }
 458
 459
 460 /*
 461  * decl_struct_args_block: { args }
 462  */
 463 PARSE_TYPED(decl_struct_args_block, args_,
 464                 TOKEN(LBRACE)
 465                 TYPED(struct_args, args)
 466                 TOKEN(RBRACE)) {
 467         args_ = args;
 468 }
 469
 470 /*
 471  * decl_struct_args: args_block
 472  */
 473 PARSE_TYPED(decl_struct_args, args_,
 474                 TYPED(decl_struct_args_block, args)) {
 475         args_ = args;
 476 }
 477
 478 /*
 479  * decl_struct_args: ;
 480  */
 481 PARSE_TYPED(decl_struct_args, args_,
 482                 TOKEN(EOS)) {
 483         args_ = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
 484 }
 485
 486 /*
 487  * decl_struct: STRUCT name align_and_size struct_args
 488  */
 489 PARSE_TYPED(decl_struct, strct,
 490                 TOKEN(STRUCT)
 491                 NAMED(NAME, N)
 492                 TYPED(align_and_size, as)
 493                 TYPED(decl_struct_args, args)) {
 494         strct = psi_decl_struct_init(N->text, args);
 495         strct->align = as.pos;
 496         strct->size = as.len;
 497         strct->token = N;
 498 }
 499
 500 /*
 501  * decl_union: UNION name align_and_size struct_args
 502  */
 503 PARSE_TYPED(decl_union, u,
 504                 TOKEN(UNION)
 505                 NAMED(NAME, N)
 506                 TYPED(align_and_size, as)
 507                 TYPED(decl_struct_args, args)) {
 508         u = psi_decl_union_init(N->text, args);
 509         u->align = as.pos;
 510         u->size = as.len;
 511         u->token = N;
 512 }
 513
 514 /*
 515  * const_type: const_type_token
 516  */
 517 PARSE_TYPED(const_type, type_,
 518                 NAMED(const_type_token, T)) {
 519         type_ = psi_const_type_init(T->type, T->text);
 520         free(T);
 521 }
 522
 523 /*
 524  * constant: CONST const_type NSNAME = def_val ;
 525  */
 526 PARSE_TYPED(constant, constant,
 527                 TOKEN(CONST)
 528                 TYPED(const_type, type)
 529                 NAMED(NSNAME, T)
 530                 TOKEN(EQUALS)
 531                 TYPED(impl_def_val, val)
 532                 TOKEN(EOS)) {
 533         constant = psi_const_init(type, T->text, val);
 534         constant->token = T;
 535 }
 536
 537 /*
 538  * decl_typdef: TYPEDEF typedef_body ;
 539  */
 540 PARSE_TYPED(decl_typedef, def,
 541                 NAMED(TYPEDEF, T)
 542                 TYPED(decl_typedef_body, def_)
 543                 TOKEN(EOS)) {
 544         def = def_;
 545         def->token = T;
 546 }
 547
 548 /*
 549  * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
 550  */
 551 PARSE_TYPED(decl_typedef_body_ex, def,
 552                 NAMED(struct_name, N)
 553                 TYPED(align_and_size, as)
 554                 TYPED(decl_struct_args_block, args)
 555                 TYPED(decl_var, var)) {
 556         def = psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT, N->text), var);
 557         def->type->token = psi_token_copy(N);
 558         def->type->real.strct = psi_decl_struct_init(N->text, args);
 559         def->type->real.strct->token = N;
 560         def->type->real.strct->align = as.pos;
 561         def->type->real.strct->size = as.len;
 562 }
 563
 564 /*
 565  * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
 566  */
 567 PARSE_TYPED(decl_typedef_body_ex, def,
 568                 NAMED(union_name, N)
 569                 TYPED(align_and_size, as)
 570                 TYPED(decl_struct_args_block, args)
 571                 TYPED(decl_var, var)) {
 572         def = psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION, N->text), var);
 573         def->type->token = psi_token_copy(N);
 574         def->type->real.unn = psi_decl_union_init(N->text, args);
 575         def->type->real.unn->token = N;
 576         def->type->real.unn->align = as.pos;
 577         def->type->real.unn->size = as.len;
 578 }
 579
 580 /*
 581  * decl_typedef_body_ex: decl_enum NAME
 582  */
 583 PARSE_TYPED(decl_typedef_body_ex, def,
 584                 TYPED(decl_enum, e)
 585                 NAMED(NAME, ALIAS)) {
 586         def = psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM, e->name), psi_decl_var_init(ALIAS->text, 0, 0));
 587         def->var->token = ALIAS;
 588         def->type->token = psi_token_copy(e->token);
 589         def->type->real.enm = e;
 590 }
 591
 592 /*
 593  * decl_typedef_body: decl_typedef_body_ex
 594  */
 595 PARSE_TYPED(decl_typedef_body, def,
 596                 TYPED(decl_typedef_body_ex, def_)) {
 597         def = def_;
 598 }
 599
 600 /*
 601  * decl_typedef_body_fn_args: ( decl_args )
 602  */
 603 PARSE_TYPED(decl_typedef_body_fn_args, args,
 604                 TOKEN(LPAREN)
 605                 TYPED(decl_args, args_)
 606                 TOKEN(RPAREN)) {
 607         args = args_;
 608 }
 609
 610 /*
 611  * decl_typedef_body: decl_func decl_typedef_body_fn_args
 612  */
 613 PARSE_TYPED(decl_typedef_body, def,
 614                 TYPED(decl_func, func_)
 615                 TYPED(decl_typedef_body_fn_args, args)) {
 616         def = psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION, func_->var->name), psi_decl_var_copy(func_->var));
 617         def->type->token = psi_token_copy(func_->token);
 618         def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 619 }
 620
 621 /*
 622  * decl_typedef_body: decl_arg
 623  */
 624 PARSE_TYPED(decl_typedef_body, def,
 625                 TYPED(decl_arg, arg)) {
 626         def = arg;
 627 }
 628
 629 /*
 630  * decl: decl_abi decl_func ( decl_args ) ;
 631  */
 632 PARSE_TYPED(decl, decl,
 633                 TYPED(decl_abi, abi)
 634                 TYPED(decl_func, func)
 635                 TOKEN(LPAREN)
 636                 TYPED(decl_args, args)
 637                 TOKEN(RPAREN)
 638                 TOKEN(EOS)) {
 639         decl = psi_decl_init(abi, func, args);
 640 }
 641
 642 /*
 643  * decl: decl_abi decl_func ( decl_args , ... ) ;
 644  */
 645 PARSE_TYPED(decl, decl,
 646                 TYPED(decl_abi, abi)
 647                 TYPED(decl_func, func)
 648                 TOKEN(LPAREN)
 649                 TYPED(decl_args, args)
 650                 TOKEN(COMMA)
 651                 TOKEN(ELLIPSIS)
 652                 TOKEN(RPAREN)
 653                 TOKEN(EOS)) {
 654         decl = psi_decl_init(abi, func, args);
 655         decl->varargs = 1;
 656 }
 657
 658 /*
 659  * decl_func: decl_arg
 660  */
 661 PARSE_TYPED(decl_func, func,
 662                 TYPED(decl_arg, arg)) {
 663         func = arg;
 664 }
 665
 666 /* special case for void functions */
 667 /*
 668  * decl_func: VOID NAME
 669  */
 670 PARSE_TYPED(decl_func, func,
 671                 NAMED(VOID, T)
 672                 NAMED(NAME, N)) {
 673         func = psi_decl_arg_init(
 674                 psi_decl_type_init(T->type, T->text),
 675                 psi_decl_var_init(N->text, 0, 0)
 676         );
 677         func->type->token = T;
 678         func->var->token = N;
 679         func->token = N;
 680 }
 681
 682 /*
 683  * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
 684  */
 685 PARSE_TYPED(decl_typedef_body, def,
 686                 NAMED(VOID, T)
 687                 TYPED(indirection, decl_i)
 688                 TOKEN(LPAREN)
 689                 TYPED(indirection, type_i)
 690                 NAMED(NAME, N)
 691                 TOKEN(RPAREN)
 692                 TYPED(decl_typedef_body_fn_args, args)) {
 693         struct psi_decl_arg *func_ = psi_decl_arg_init(
 694                 psi_decl_type_init(T->type, T->text),
 695                 psi_decl_var_init(N->text, decl_i, 0)
 696         );
 697         func_->type->token = T;
 698         func_->var->token = N;
 699         func_->token = N;
 700
 701         def = psi_decl_arg_init(
 702                 psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
 703                 psi_decl_var_copy(func_->var)
 704         );
 705         def->var->pointer_level = type_i;
 706         def->type->token = psi_token_copy(func_->token);
 707         def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 708 }
 709
 710 /*
 711  * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
 712  */
 713 PARSE_TYPED(decl_typedef_body, def,
 714                 TOKEN(CONST)
 715                 NAMED(VOID, T)
 716                 TYPED(pointers, decl_i)
 717                 TOKEN(LPAREN)
 718                 TYPED(indirection, type_i)
 719                 NAMED(NAME, N)
 720                 TOKEN(RPAREN)
 721                 TYPED(decl_typedef_body_fn_args, args)) {
 722         struct psi_decl_arg *func_ = psi_decl_arg_init(
 723                 psi_decl_type_init(T->type, T->text),
 724                 psi_decl_var_init(N->text, decl_i, 0)
 725         );
 726         func_->type->token = T;
 727         func_->var->token = N;
 728         func_->token = N;
 729
 730         def = psi_decl_arg_init(
 731                 psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
 732                 psi_decl_var_copy(func_->var)
 733         );
 734         def->var->pointer_level = type_i;
 735         def->type->token = psi_token_copy(func_->token);
 736         def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 737 }
 738
 739 /*
 740  * decl_abi: NAME
 741  */
 742 PARSE_TYPED(decl_abi, abi,
 743                 NAMED(NAME, T)) {
 744         abi = psi_decl_abi_init(T->text);
 745         abi->token = T;
 746 }
 747
 748 /*
 749  * decl_var_array_size: <empty>
 750  */
 751 PARSE_NAMED(decl_var_array_size, as, ) {
 752         as = NULL;
 753 }
 754
 755 /*
 756  * decl_var_array_size: [ NUMBER ]
 757  */
 758 PARSE_NAMED(decl_var_array_size, as,
 759                 TOKEN(LBRACKET)
 760                 NAMED(NUMBER, D)
 761                 TOKEN(RBRACKET)) {
 762         as = D;
 763 }
 764
 765 /*
 766  * decl_var: NAME decl_var_array_size
 767  */
 768 PARSE_TYPED(decl_var, var,
 769                 NAMED(NAME, T)
 770                 NAMED(decl_var_array_size, as)) {
 771         var = psi_decl_var_init(T->text, 0, as?atol(as->text):0);
 772         var->token = T;
 773         if (as) {
 774                 free(as);
 775         }
 776 }
 777
 778 /*
 779  * decl_var: pointers NAME
 780  */
 781 PARSE_TYPED(decl_var, var,
 782                 TYPED(pointers, p)
 783                 NAMED(NAME, T)
 784                 NAMED(decl_var_array_size, as)) {
 785         var = psi_decl_var_init(T->text, p+!!as, as?atol(as->text):0);
 786         var->token = T;
 787         if (as) {
 788                 free(as);
 789         }
 790 }
 791
 792 /*
 793  * decl_vars: decl_var
 794  */
 795 PARSE_TYPED(decl_vars, vars,
 796                 TYPED(decl_var, var)) {
 797         vars = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_var_free),
 798                         &var);
 799 }
 800
 801 /*
 802  * decl_vars: decl_vars , decl_var
 803  */
 804 PARSE_TYPED(decl_vars, vars,
 805                 TYPED(decl_vars, vars_)
 806                 TOKEN(COMMA)
 807                 TYPED(decl_var, var)) {
 808         vars = psi_plist_add(vars_, &var);
 809 }
 810
 811 /*
 812  * decl_arg: const_decl_type decl_var
 813  */
 814 PARSE_TYPED(decl_arg, arg_,
 815                 TYPED(const_decl_type, type)
 816                 TYPED(decl_var, var)) {
 817         arg_ = psi_decl_arg_init(type, var);
 818 }
 819
 820 /*
 821  * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
 822  */
 823 PARSE_TYPED(decl_typedef_body, def,
 824                 TYPED(const_decl_type, type_)
 825                 TYPED(indirection, decl_i)
 826                 TOKEN(LPAREN)
 827                 TYPED(indirection, type_i)
 828                 NAMED(NAME, N)
 829                 TOKEN(RPAREN)
 830                 TYPED(decl_typedef_body_fn_args, args)) {
 831         struct psi_decl_arg *func_ = psi_decl_arg_init(
 832                 type_,
 833                 psi_decl_var_init(N->text, decl_i, 0)
 834         );
 835         func_->var->token = N;
 836         func_->token = N;
 837
 838         def = psi_decl_arg_init(
 839                 psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
 840                 psi_decl_var_copy(func_->var)
 841         );
 842         def->var->pointer_level = type_i;
 843         def->type->token = psi_token_copy(func_->token);
 844         def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
 845 }
 846
 847 /* void pointers need a specific rule */
 848 /*
 849  * decl_arg: VOID pointers NAME
 850  */
 851 PARSE_TYPED(decl_arg, arg_,
 852                 NAMED(VOID, T)
 853                 TYPED(pointers, p)
 854                 NAMED(NAME, N)) {
 855         arg_ = psi_decl_arg_init(
 856                 psi_decl_type_init(T->type, T->text),
 857                 psi_decl_var_init(N->text, p, 0)
 858         );
 859         arg_->type->token = T;
 860         arg_->var->token = N;
 861         arg_->token = N;
 862 }
 863
 864 /*
 865  * decl_args: CONST VOID pointers NAME
 866  */
 867 PARSE_TYPED(decl_arg, arg_,
 868                 TOKEN(CONST)
 869                 NAMED(VOID, T)
 870                 TYPED(pointers, p)
 871                 NAMED(NAME, N)) {
 872         arg_ = psi_decl_arg_init(
 873                 psi_decl_type_init(T->type, T->text),
 874                 psi_decl_var_init(N->text, p, 0)
 875         );
 876         arg_->type->token = T;
 877         arg_->var->token = N;
 878         arg_->token = N;
 879 }
 880
 881 /*
 882  * decl_args: <empty>
 883  */
 884 PASS(decl_args, )
 885
 886 /*
 887  * decl_args: VOID
 888  */
 889 PASS(decl_args, VOID)
 890
 891 /*
 892  * decl_args: decl_arg
 893  */
 894 PARSE_TYPED(decl_args, args,
 895                 TYPED(decl_arg, arg)) {
 896         args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
 897                         &arg);
 898 }
 899
 900 /*
 901  * decl_args: decl_args , decl_arg
 902  */
 903 PARSE_TYPED(decl_args, args,
 904                 TYPED(decl_args, args_)
 905                 TOKEN(COMMA)
 906                 TYPED(decl_arg, arg)) {
 907         args = psi_plist_add(args_, &arg);
 908 }
 909
 910 /*
 911  * struct_args: struct_arg
 912  */
 913 PARSE_TYPED(struct_args, args,
 914                 TYPED(struct_arg, arg)) {
 915         args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
 916                         &arg);
 917 }
 918
 919 /*
 920  * struct_args: struct_args , struct_arg
 921  */
 922 PARSE_TYPED(struct_args, args,
 923                 TYPED(struct_args, args_)
 924                 TYPED(struct_arg, arg)) {
 925         args = psi_plist_add(args_, &arg);
 926 }
 927
 928 /*
 929  * struct_arg: decl_typedef_body_ex ;
 930  */
 931 PARSE_TYPED(struct_arg, arg_,
 932                 TYPED(decl_typedef_body_ex, def)
 933                 TOKEN(EOS)) {
 934         arg_ = def;
 935         switch (def->type->type) {
 936         case PSI_T_STRUCT:
 937                 if (def->type->real.strct) {
 938                         if (!P->structs) {
 939                                 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
 940                         }
 941                         P->structs = psi_plist_add(P->structs, &def->type->real.strct);
 942                 }
 943                 break;
 944         case PSI_T_UNION:
 945                 if (def->type->real.unn) {
 946                         if (!P->unions) {
 947                                 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
 948                         }
 949                         P->unions = psi_plist_add(P->unions, &def->type->real.unn);
 950                 }
 951                 break;
 952         case PSI_T_ENUM:
 953                 if (def->type->real.enm) {
 954                         if (!P->enums) {
 955                                 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
 956                         }
 957                         P->enums = psi_plist_add(P->enums, &def->type->real.enm);
 958                 }
 959                 break;
 960         }
 961 }
 962
 963 /*
 964  * struct_arg: decl_arg decl_layout ;
 965  */
 966 PARSE_TYPED(struct_arg, arg,
 967                 TYPED(decl_arg, arg_)
 968                 TYPED(decl_layout, layout_)
 969                 TOKEN(EOS)) {
 970         arg_->layout = layout_;
 971         arg = arg_;
 972 }
 973
 974 /*
 975  * decl_layout: <empty>
 976  */
 977 PARSE_TYPED(decl_layout, layout, ) {
 978         layout = NULL;
 979 }
 980
 981 /*
 982  * decl_layout: :: ( NUMBER , NUMBER )
 983  */
 984 PARSE_TYPED(decl_layout, layout,
 985                 TOKEN(COLON)
 986                 TOKEN(COLON)
 987                 TOKEN(LPAREN)
 988                 NAMED(NUMBER, POS)
 989                 TOKEN(COMMA)
 990                 NAMED(NUMBER, SIZ)
 991                 TOKEN(RPAREN)) {
 992         layout = psi_layout_init(atol(POS->text), atol(SIZ->text));
 993         free(POS);
 994         free(SIZ);
 995 }
 996
 997 /* un/signed, urgh */
 998 /*
 999  * decl_scalar_type: CHAR
1000  */
1001 PARSE_NAMED(decl_scalar_type, type_,
1002                 NAMED(CHAR, C)) {
1003         type_ = C;
1004 }
1005
1006 /*
1007  * decl_scalar_type: SHORT decl_scalar_type_short
1008  */
1009 PARSE_NAMED(decl_scalar_type, type_,
1010                 NAMED(SHORT, S)
1011                 NAMED(decl_scalar_type_short, s)) {
1012         if (s) {
1013                 type_ = psi_token_cat(2, S, s);
1014                 free(S);
1015                 free(s);
1016         } else {
1017                 type_ = S;
1018         }
1019 }
1020
1021 /*
1022  * decl_scalar_type_short: <empty>
1023  */
1024 PARSE_NAMED(decl_scalar_type_short, s, ) {
1025         s = NULL;
1026 }
1027
1028 /*
1029  * decl_scalar_type_short: INT
1030  */
1031 PARSE_NAMED(decl_scalar_type_short, s,
1032                 NAMED(INT, I)) {
1033         s = I;
1034 }
1035
1036 /*
1037  * decl_sclara_type: INT
1038  */
1039 PARSE_NAMED(decl_scalar_type, type_,
1040                 NAMED(INT, I)) {
1041         type_ = I;
1042 }
1043
1044 /*
1045  * decl_scalar_type: LONG decl_scalar_type_long
1046  */
1047 PARSE_NAMED(decl_scalar_type, type_,
1048                 NAMED(LONG, L)
1049                 NAMED(decl_scalar_type_long, l)) {
1050         if (l) {
1051                 type_ = psi_token_cat(2, L, l);
1052                 free(L);
1053                 free(l);
1054         } else {
1055                 type_ = L;
1056         }
1057 }
1058
1059 /*
1060  * decl_scalar_type_long: <empty>
1061  */
1062 PARSE_NAMED(decl_scalar_type_long, l, ) {
1063         l = NULL;
1064 }
1065
1066 /*
1067  * decl_scalar_type_long: DOUBLE
1068  */
1069 PARSE_NAMED(decl_scalar_type_long, l,
1070                 NAMED(DOUBLE, D)) {
1071         l = D;
1072 }
1073
1074 /*
1075  * decl_scalar_type_long: LONG decl_scalar_type_long_long
1076  */
1077 PARSE_NAMED(decl_scalar_type_long, l,
1078                 NAMED(LONG, L)
1079                 NAMED(decl_scalar_type_long_long, ll)) {
1080         if (ll) {
1081                 l = psi_token_cat(2, L, ll);
1082                 free(L);
1083                 free(ll);
1084         } else {
1085                 l = L;
1086         }
1087 }
1088
1089 /*
1090  * decl_scalar_type_long_long: <empty>
1091  */
1092 PARSE_NAMED(decl_scalar_type_long_long, ll, ) {
1093         ll = NULL;
1094 }
1095
1096 /*
1097  * decl_scalar_type_long_long: INT
1098  */
1099 PARSE_NAMED(decl_scalar_type_long_long, ll,
1100                 NAMED(INT, I)) {
1101         ll = I;
1102 }
1103
1104 /*
1105  * decl_type: UNSIGNED decl_scalar_type
1106  */
1107 PARSE_TYPED(decl_type, type_,
1108                 NAMED(UNSIGNED, U)
1109                 NAMED(decl_scalar_type, N)) {
1110         struct psi_token *T = psi_token_cat(2, U, N);
1111         type_ = psi_decl_type_init(T->type, T->text);
1112         type_->token = T;
1113         free(U);
1114         free(N);
1115 }
1116
1117 /*
1118  * decl_type: SIGNED decl_scalar_type
1119  */
1120 PARSE_TYPED(decl_type, type_,
1121                 NAMED(SIGNED, S)
1122                 NAMED(decl_scalar_type, N)) {
1123         struct psi_token *T = psi_token_cat(2, S, N);
1124         type_ = psi_decl_type_init(T->type, T->text);
1125         type_->token = T;
1126         free(S);
1127         free(N);
1128 }
1129
1130 /*
1131  * decl_type: UNSIGNED
1132  */
1133 PARSE_TYPED(decl_type, type_,
1134                 NAMED(UNSIGNED, U)) {
1135         type_ = psi_decl_type_init(PSI_T_NAME, U->text);
1136         type_->token = U;
1137 }
1138
1139 /*
1140  * decl_type: SIGNED
1141  */
1142 PARSE_TYPED(decl_type, type_,
1143                 NAMED(SIGNED, S)) {
1144         type_ = psi_decl_type_init(PSI_T_NAME, S->text);
1145         type_->token = S;
1146 }
1147
1148 /*
1149  * decl_type: decl_scalar_type
1150  */
1151 PARSE_TYPED(decl_type, type_,
1152                 NAMED(decl_scalar_type, N)) {
1153         type_ = psi_decl_type_init(N->type, N->text);
1154         type_->token = N;
1155 }
1156
1157 /* structs ! */
1158 /*
1159  * decl_type: STRUCT NAME
1160  */
1161 PARSE_TYPED(decl_type, type_,
1162                 NAMED(STRUCT, S)
1163                 NAMED(NAME, T)) {
1164         type_ = psi_decl_type_init(S->type, T->text);
1165         type_->token = T;
1166         free(S);
1167 }
1168
1169 /*
1170  * decl_type: UNION NAME
1171  */
1172 PARSE_TYPED(decl_type, type_,
1173                 NAMED(UNION, U)
1174                 NAMED(NAME, T)) {
1175         type_ = psi_decl_type_init(U->type, T->text);
1176         type_->token = T;
1177         free(U);
1178 }
1179
1180 /*
1181  * decl_type: ENUM NAME
1182  */
1183 PARSE_TYPED(decl_type, type_,
1184                 NAMED(ENUM, E)
1185                 NAMED(NAME, T)) {
1186         type_ = psi_decl_type_init(E->type, T->text);
1187         type_->token = T;
1188         free(E);
1189 }
1190
1191 /*
1192  * decl_type: decl_type_token
1193  */
1194 PARSE_TYPED(decl_type, type_,
1195                 NAMED(decl_type_token, T)) {
1196         type_ = psi_decl_type_init(T->type, T->text);
1197         type_->token = T;
1198 }
1199
1200 /*
1201  * const_decl_type: decl_type
1202  */
1203 PARSE_TYPED(const_decl_type, type,
1204                 TYPED(decl_type, type_)) {
1205         type = type_;
1206 }
1207
1208 /*
1209  * const_decl_type: CONST decl_type
1210  */
1211 PARSE_TYPED(const_decl_type, type,
1212                 TOKEN(CONST)
1213                 TYPED(decl_type, type_)) {
1214         type = type_;
1215 }
1216
1217 /*
1218  * impl: impl_func { impl_stmts }
1219  */
1220 PARSE_TYPED(impl, impl,
1221                 TYPED(impl_func, func)
1222                 TOKEN(LBRACE)
1223                 TYPED(impl_stmts, stmts)
1224                 TOKEN(RBRACE)) {
1225         impl = psi_impl_init(func, stmts);
1226 }
1227
1228 /*
1229  * impl: STATIC impl_func { impl_stmts }
1230  */
1231 PARSE_TYPED(impl, impl,
1232                 TOKEN(STATIC)
1233                 TYPED(impl_func, func)
1234                 TOKEN(LBRACE)
1235                 TYPED(impl_stmts, stmts)
1236                 TOKEN(RBRACE)) {
1237         func->static_memory = 1;
1238         impl = psi_impl_init(func, stmts);
1239 }
1240
1241 /*
1242  * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1243  */
1244 PARSE_TYPED(impl_func, func,
1245                 TOKEN(FUNCTION)
1246                 TYPED(reference, r)
1247                 NAMED(NSNAME, NAME)
1248                 TOKEN(LPAREN)
1249                 TOKEN(RPAREN)
1250                 TOKEN(COLON)
1251                 TYPED(impl_type, type)) {
1252         func = psi_impl_func_init(NAME->text, NULL, type);
1253         func->token = NAME;
1254         func->return_reference = r;
1255 }
1256
1257 /*
1258  * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1259  */
1260 PARSE_TYPED(impl_func, func,
1261                 TOKEN(FUNCTION)
1262                 TYPED(reference, r)
1263                 NAMED(NSNAME, NAME)
1264                 TOKEN(LPAREN)
1265                 TYPED(impl_args, args)
1266                 TOKEN(RPAREN)
1267                 TOKEN(COLON)
1268                 TYPED(impl_type, type)) {
1269         func = psi_impl_func_init(NAME->text, args, type);
1270         func->token = NAME;
1271         func->return_reference = r;
1272 }
1273
1274 /*
1275  * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1276  */
1277 PARSE_TYPED(impl_func, func,
1278                 TOKEN(FUNCTION)
1279                 TYPED(reference, func_r)
1280                 NAMED(NSNAME, NAME)
1281                 TOKEN(LPAREN)
1282                 TYPED(impl_args, args)
1283                 TOKEN(COMMA)
1284                 TYPED(impl_type, va_type)
1285                 TYPED(reference, va_r)
1286                 TOKEN(ELLIPSIS)
1287                 NAMED(DOLLAR_NAME, T)
1288                 TOKEN(RPAREN)
1289                 TOKEN(COLON)
1290                 TYPED(impl_type, func_type)) {
1291         func = psi_impl_func_init(NAME->text, args, func_type);
1292         func->token = NAME;
1293         func->return_reference = func_r;
1294         func->vararg = psi_impl_arg_init(va_type, psi_impl_var_init(T->text, va_r), NULL);
1295         free(T);
1296 }
1297
1298 /*
1299  * impl_def_val: impl_def_val_token
1300  */
1301 PARSE_TYPED(impl_def_val, def,
1302                 NAMED(impl_def_val_token, T)) {
1303         def = psi_impl_def_val_init(T->type, T->text);
1304         def->token = T;
1305 }
1306
1307 /*
1308  * impl_var: reference DOLLAR_NAME
1309  */
1310 PARSE_TYPED(impl_var, var,
1311                 TYPED(reference, r)
1312                 NAMED(DOLLAR_NAME, T)) {
1313         var = psi_impl_var_init(T->text, r);
1314         var->token = T;
1315 }
1316
1317 /*
1318  * impl_type: impl_type_token
1319  */
1320 PARSE_TYPED(impl_type, type_,
1321                 NAMED(impl_type_token, T)) {
1322         type_ = psi_impl_type_init(T->type, T->text);
1323         free(T);
1324 }
1325
1326 /*
1327  * impl_arg: impl_type impl_var
1328  */
1329 PARSE_TYPED(impl_arg, arg,
1330                 TYPED(impl_type, type)
1331                 TYPED(impl_var, var)) {
1332         arg = psi_impl_arg_init(type, var, NULL);
1333 }
1334
1335 /*
1336  * impl_arg: impl_type impl_var = impl_def_val
1337  */
1338 PARSE_TYPED(impl_arg, arg,
1339                 TYPED(impl_type, type)
1340                 TYPED(impl_var, var)
1341                 TOKEN(EQUALS)
1342                 TYPED(impl_def_val, def)) {
1343         arg = psi_impl_arg_init(type, var, def);
1344 }
1345
1346 /*
1347  * impl_args: impl_arg
1348  */
1349 PARSE_TYPED(impl_args, args,
1350                 TYPED(impl_arg, arg)) {
1351         args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_arg_free),
1352                         &arg);
1353 }
1354
1355 /*
1356  * impl_args: impl_args , impl_arg
1357  */
1358 PARSE_TYPED(impl_args, args,
1359                 TYPED(impl_args, args_)
1360                 TOKEN(COMMA)
1361                 TYPED(impl_arg, arg)) {
1362         args = psi_plist_add(args_, &arg);
1363 }
1364
1365 /*
1366  * impl_stmts: impl_stmt
1367  */
1368 PARSE_TYPED(impl_stmts, stmts,
1369                 TYPED(impl_stmt, stmt)) {
1370         stmts = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_stmt_free),
1371                         &stmt);
1372 }
1373
1374 /*
1375  * impl_stmts: impl_stmts , impl_stmt
1376  */
1377 PARSE_TYPED(impl_stmts, stmts,
1378                 TYPED(impl_stmts, stmts_)
1379                 TYPED(impl_stmt, stmt)) {
1380         stmts = psi_plist_add(stmts_, &stmt);
1381 }
1382
1383 /*
1384  * impl_stmt: return_stmt
1385  */
1386 PARSE_TYPED(impl_stmt, i,
1387                 TYPED(return_stmt, r)) {
1388         i = (struct psi_token**) r;
1389 }
1390
1391 /*
1392  * impl_stmt: let_stmt
1393  */
1394 PARSE_TYPED(impl_stmt, i,
1395                 TYPED(let_stmt, l)) {
1396         i = (struct psi_token**) l;
1397 }
1398
1399 /*
1400  * impl_stmt: set_stmt
1401  */
1402 PARSE_TYPED(impl_stmt, i,
1403                 TYPED(set_stmt, s)) {
1404         i = (struct psi_token**) s;
1405 }
1406
1407 /*
1408  * impl_stmt: free_stmt
1409  */
1410 PARSE_TYPED(impl_stmt, i,
1411                 TYPED(free_stmt, f)) {
1412         i = (struct psi_token**) f;
1413 }
1414
1415 /*
1416  * number: number_token
1417  */
1418 PARSE_TYPED(number, exp,
1419                 NAMED(number_token, tok)) {
1420         exp = psi_number_init(tok->type, tok->text);
1421         exp->token = tok;
1422 }
1423
1424 /*
1425  * num_exp: decl_var
1426  */
1427 PARSE_TYPED(number, exp,
1428                 TYPED(decl_var, var)) {
1429         exp = psi_number_init(PSI_T_NAME, var);
1430         exp->token = psi_token_copy(var->token);
1431 }
1432
1433 /*
1434  * num_exp: num_exp
1435  */
1436 PARSE_TYPED(num_exp, exp,
1437                 TYPED(number, num)) {
1438         exp = psi_num_exp_init_num(num);
1439         exp->token = psi_token_copy(num->token);
1440 }
1441
1442 /*
1443  * num_exp: ( num_exp )
1444  */
1445 PARSE_TYPED(num_exp, exp,
1446                 NAMED(LPAREN, L)
1447                 TYPED(num_exp, exp_)
1448                 TOKEN(RPAREN)) {
1449         exp = psi_num_exp_init_unary(PSI_T_LPAREN, exp_);
1450         exp->token = L;
1451 }
1452
1453 /*
1454  * num_exp: num_exp num_exp_binary_op_token num_exp
1455  */
1456 PARSE_TYPED(num_exp, exp,
1457                 TYPED(num_exp, lhs_)
1458                 NAMED(num_exp_binary_op_token, OP)
1459                 TYPED(num_exp, rhs_)) {
1460         exp = psi_num_exp_init_binary(OP->type, lhs_, rhs_);
1461         exp->token = OP;
1462 }
1463
1464 /*
1465  * num_exp: num_exp_unary_op_token num_exp
1466  */
1467 PARSE_TYPED(num_exp, exp,
1468                 NAMED(num_exp_unary_op_token, OP)
1469                 TYPED(num_exp, exp_)) {
1470         exp = psi_num_exp_init_unary(OP->type, exp_);
1471         exp->token = OP;
1472 }
1473
1474 /*
1475  * let_exp: NULL
1476  */
1477 PARSE_TYPED(let_exp, val,
1478                 TOKEN(NULL)) {
1479         val = psi_let_exp_init(PSI_LET_NULL, NULL);
1480 }
1481
1482 /*
1483  * let_exp: & NULL
1484  */
1485 PARSE_TYPED(let_exp, val,
1486                 TOKEN(AMPERSAND)
1487                 TOKEN(NULL)) {
1488         val = psi_let_exp_init(PSI_LET_NULL, NULL);
1489         val->is_reference = 1;
1490 }
1491
1492 /*
1493  * let_exp: callback
1494  */
1495 PARSE_TYPED(let_exp, val,
1496                 TYPED(let_callback, cb)) {
1497         val = psi_let_exp_init(PSI_LET_CALLBACK, cb);
1498 }
1499
1500 /*
1501  * let_exp: calloc
1502  */
1503 PARSE_TYPED(let_exp, val,
1504                 TYPED(let_calloc, ca)) {
1505         val = psi_let_exp_init(PSI_LET_CALLOC, ca);
1506 }
1507
1508 /*
1509  * let_exp: & calloc
1510  */
1511 PARSE_TYPED(let_exp, val,
1512                 TOKEN(AMPERSAND)
1513                 TYPED(let_calloc, ca)) {
1514         val = psi_let_exp_init(PSI_LET_CALLOC, ca);
1515         val->is_reference = 1;
1516 }
1517
1518 /*
1519  * let_exp: func
1520  */
1521 PARSE_TYPED(let_exp, val,
1522                 TYPED(let_func, fn)) {
1523         val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
1524 }
1525
1526 /*
1527  * let_exp: & func
1528  */
1529 PARSE_TYPED(let_exp, val,
1530                 TOKEN(AMPERSAND)
1531                 TYPED(let_func, fn)) {
1532         val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
1533         val->is_reference = 1;
1534 }
1535
1536 /*
1537  * let_exp: num_exp
1538  */
1539 PARSE_TYPED(let_exp, val,
1540                 TYPED(num_exp, exp)) {
1541         val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
1542 }
1543
1544 /*
1545  * let_exp: & num_exp
1546  */
1547 PARSE_TYPED(let_exp, val,
1548                 TOKEN(AMPERSAND)
1549                 TYPED(num_exp, exp)) {
1550         val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
1551         val->is_reference = 1;
1552 }
1553
1554 /* FIXME
1555  * let_exp: decl_var = let_exp
1556  */
1557 PARSE_TYPED(let_exp, exp,
1558                 TYPED(decl_var, var_)
1559                 TOKEN(EQUALS)
1560                 TYPED(let_exp, val)) {
1561         exp = val;
1562         exp->var = var_;
1563 }
1564
1565 /*
1566  * let_stmt: LET let_exp ;
1567  */
1568 PARSE_TYPED(let_stmt, let,
1569                 NAMED(LET, T)
1570                 TYPED(let_exp, val)
1571                 TOKEN(EOS)) {
1572         let = psi_let_stmt_init(val);
1573         let->token = T;
1574 }
1575
1576 /*
1577  * let_stmt: TEMP decl_var = reference decl_var ;
1578  */
1579 PARSE_TYPED(let_stmt, let,
1580                 NAMED(TEMP, T)
1581                 TYPED(decl_var, var)
1582                 TOKEN(EQUALS)
1583                 TYPED(reference, r)
1584                 TYPED(decl_var, val_)
1585                 TOKEN(EOS)) {
1586         let = psi_let_stmt_init(psi_let_exp_init_ex(var, PSI_LET_TMP, val_));
1587         let->token = T;
1588         let->exp->is_reference = r ? 1 : 0;
1589 }
1590
1591 /*
1592  * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1593  */
1594 PARSE_TYPED(let_callback, cb,
1595                 NAMED(CALLBACK, T)
1596                 NAMED(callback_rval, F)
1597                 TOKEN(LPAREN)
1598                 TYPED(impl_var, var)
1599                 TOKEN(LPAREN)
1600                 TYPED(callback_arg_list, args_)
1601                 TOKEN(RPAREN)
1602                 TOKEN(RPAREN)) {
1603         cb = psi_let_callback_init(psi_let_func_init(F->type, F->text, var), args_);
1604         cb->token = T;
1605         free(F);
1606 }
1607
1608 /*
1609  * let_calloc: CALLOC ( num_exp , num_exp )
1610  */
1611 PARSE_TYPED(let_calloc, alloc,
1612                 NAMED(CALLOC, T)
1613                 TOKEN(LPAREN)
1614                 TYPED(num_exp, nmemb)
1615                 TOKEN(COMMA)
1616                 TYPED(num_exp, size)
1617                 TOKEN(RPAREN)) {
1618         alloc = psi_let_calloc_init(nmemb, size);
1619         alloc->token = T;
1620 }
1621
1622 /*
1623  * let_func: let_func_token ( impl_var )
1624  */
1625 PARSE_TYPED(let_func, func,
1626                 NAMED(let_func_token, T)
1627                 TOKEN(LPAREN)
1628                 TYPED(impl_var, var)
1629                 TOKEN(RPAREN)) {
1630         func = psi_let_func_init(T->type, T->text, var);
1631         func->token = T;
1632 }
1633 /*
1634  * let_func: let_func_token ( impl_var , let_exps )
1635  */
1636 PARSE_TYPED(let_func, func,
1637                 NAMED(let_func_token, T)
1638                 TOKEN(LPAREN)
1639                 TYPED(impl_var, var)
1640                 TOKEN(COMMA)
1641                 TYPED(let_exps, vals)
1642                 TOKEN(RPAREN)) {
1643         func = psi_let_func_init(T->type, T->text, var);
1644         func->token = T;
1645         func->inner = vals;
1646 }
1647 /*
1648  * let_exps: let_exp
1649  */
1650 PARSE_TYPED(let_exps, exps,
1651                 TYPED(let_exp, exp)) {
1652         exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_let_exp_free),
1653                         &exp);
1654 }
1655 /*
1656  * let_exps: let_exps , let_exp
1657  */
1658 PARSE_TYPED(let_exps, exps,
1659                 TYPED(let_exps, exps_)
1660                 TOKEN(COMMA)
1661                 TYPED(let_exp, exp)) {
1662         exps = psi_plist_add(exps_, &exp);
1663 }
1664
1665 /*
1666  * callback_arg_list: <empty>
1667  */
1668 PASS(callback_arg_list, )
1669
1670 /*
1671  * callback_arg_list: callback_args
1672  */
1673 PARSE_TYPED(callback_arg_list, args,
1674                 TYPED(callback_args, args_)) {
1675         args = args_;
1676 }
1677
1678 /*
1679  * callback_args: set_exp
1680  */
1681 PARSE_TYPED(callback_args, args,
1682                 TYPED(set_exp, val)) {
1683         args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
1684                         &val);
1685 }
1686
1687 /*
1688  * callback_args: callback_args , set_exp
1689  */
1690 PARSE_TYPED(callback_args, args,
1691                 TYPED(callback_args, args_)
1692                 TOKEN(COMMA)
1693                 TYPED(set_exp, val)) {
1694         args = psi_plist_add(args_, &val);
1695 }
1696
1697 /*
1698  * callback_rval: let_func_token
1699  */
1700 PARSE_NAMED(callback_rval, rval,
1701                 NAMED(let_func_token, F)) {
1702         rval = F;
1703 }
1704
1705 /*
1706  * callback_rval: VOID
1707  */
1708 PARSE_NAMED(callback_rval, rval,
1709                 NAMED(VOID, V)) {
1710         rval = V;
1711 }
1712
1713
1714 /*
1715  * set_func: set_func_token ( decl_var )
1716  */
1717 PARSE_TYPED(set_func, func,
1718                 NAMED(set_func_token, T)
1719                 TOKEN(LPAREN)
1720                 TYPED(decl_var, var)
1721                 TOKEN(RPAREN)) {
1722         func = psi_set_func_init(T->type, T->text, var);
1723         func->token = T;
1724 }
1725
1726 /*
1727  * set_func: set_func_token ( decl_var , set_exps )
1728  */
1729 PARSE_TYPED(set_func, func,
1730                 NAMED(set_func_token, T)
1731                 TOKEN(LPAREN)
1732                 TYPED(decl_var, var)
1733                 TOKEN(COMMA)
1734                 TYPED(set_exps, vals)
1735                 TOKEN(RPAREN)) {
1736         func = psi_set_func_init(T->type, T->text, var);
1737         func->token = T;
1738         func->inner = vals;
1739 }
1740
1741 /*
1742  * set_func: set_func_token ( decl_var , ... )
1743  */
1744 PARSE_TYPED(set_func, func,
1745                 NAMED(set_func_token, T)
1746                 TOKEN(LPAREN)
1747                 TYPED(decl_var, var)
1748                 TOKEN(COMMA)
1749                 TOKEN(ELLIPSIS)
1750                 TOKEN(RPAREN)) {
1751         func = psi_set_func_init(T->type, T->text, var);
1752         func->token = T;
1753         func->recursive = 1;
1754 }
1755
1756 /*
1757  * set_exp: set_func
1758  */
1759 PARSE_TYPED(set_exp, val,
1760                 TYPED(set_func, fn)) {
1761         val = psi_set_exp_init(PSI_SET_FUNC, fn);
1762 }
1763
1764 /*
1765  * set_exp: num_exp
1766  */
1767 PARSE_TYPED(set_exp, val,
1768                 TYPED(num_exp, num)) {
1769         val = psi_set_exp_init(PSI_SET_NUMEXP, num);
1770 }
1771
1772 /*
1773  * set_exps: set_exp
1774  */
1775 PARSE_TYPED(set_exps, exps,
1776                 TYPED(set_exp, exp)) {
1777         exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
1778                         &exp);
1779 }
1780
1781 /*
1782  * set_exps: set_exps , set_exp
1783  */
1784 PARSE_TYPED(set_exps, exps,
1785                 TYPED(set_exps, exps_)
1786                 TOKEN(COMMA)
1787                 TYPED(set_exp, exp)) {
1788         exps = psi_plist_add(exps_, &exp);
1789 }
1790
1791 /* FIXME
1792  * set_exp: impl_var = set_exp
1793  */
1794 PARSE_TYPED(set_exp, exp,
1795                 TYPED(impl_var, var_)
1796                 TOKEN(EQUALS)
1797                 TYPED(set_exp, val)) {
1798         exp = val;
1799         exp->var = var_;
1800 }
1801
1802 /*
1803  * set_stmt: SET set_exp ;
1804  */
1805 PARSE_TYPED(set_stmt, set,
1806                 NAMED(SET, T)
1807                 TYPED(set_exp, exp)
1808                 TOKEN(EOS)) {
1809         set = psi_set_stmt_init(exp);
1810         set->token = T;
1811 }
1812
1813 /*
1814  * return_stmt: RETURN set_exp ;
1815  */
1816 PARSE_TYPED(return_stmt, ret,
1817                 NAMED(RETURN, T)
1818                 TYPED(set_func, func)
1819                 TOKEN(EOS)) {
1820         ret = psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC, func));
1821         ret->token = T;
1822 }
1823
1824 /*
1825  * free_stmt: FREE free_exps ;
1826  */
1827 PARSE_TYPED(free_stmt, free,
1828                 NAMED(FREE, T)
1829                 TYPED(free_exps, calls)
1830                 TOKEN(EOS)) {
1831         free = psi_free_stmt_init(calls);
1832         free->token = T;
1833 }
1834
1835 /*
1836  * free_exps: free_exp
1837  */
1838 PARSE_TYPED(free_exps, calls,
1839                 TYPED(free_exp, call)) {
1840         calls = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_free_exp_free),
1841                         &call);
1842 }
1843
1844 /*
1845  * free_exps: free_exps , free_exp
1846  */
1847 PARSE_TYPED(free_exps, calls,
1848                 TYPED(free_exps, calls_)
1849                 TOKEN(COMMA)
1850                 TYPED(free_exp, call)) {
1851         calls = psi_plist_add(calls_, &call);
1852 }
1853
1854 /*
1855  * free_exp: NAME ( decl_vars )
1856  */
1857 PARSE_TYPED(free_exp, call,
1858                 NAMED(NAME, F)
1859                 TOKEN(LPAREN)
1860                 TYPED(decl_vars, vars)
1861                 TOKEN(RPAREN)) {
1862         call = psi_free_exp_init(F->text, vars);
1863         call->token = F;
1864 }
1865
1866 /*
1867  * reference: <empty>
1868  */
1869 PARSE_TYPED(reference, r, ) {
1870         r = false;
1871 }
1872
1873 /*
1874  * reference: &
1875  */
1876 PARSE_TYPED(reference, r,
1877                 TOKEN(AMPERSAND)) {
1878         r = true;
1879 }
1880
1881 /*
1882  * indirection: <empty>
1883  */
1884 PARSE_TYPED(indirection, i, ){
1885         i = 0;
1886 }
1887
1888 /*
1889  * indirection: pointers
1890  */
1891 PARSE_TYPED(indirection, i,
1892                 TYPED(pointers, p)) {
1893         i = p;
1894 }
1895
1896 /*
1897  * pointers: *
1898  */
1899 PARSE_TYPED(pointers, p,
1900                 TOKEN(ASTERISK)) {
1901         p = 1;
1902 }
1903
1904 /*
1905  * pointers: pointers *
1906  */
1907 PARSE_TYPED(pointers, p,
1908                 TYPED(pointers, p_)
1909                 TOKEN(ASTERISK)) {
1910         p = p_+1;
1911 }