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