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

   1 %code top {
   2 #include "php_psi_stdinc.h"
   3 }
   4
   5 %code {
   6 #include <assert.h>
   7 #include <stdarg.h>
   8
   9 #include "plist.h"
  10 #include "parser.h"
  11
  12 #define YYDEBUG 1
  13 #define PSI_PARSER_PROC_DEBUG 1
  14
  15 static int psi_parser_proc_lex(YYSTYPE *u, struct psi_parser *P, struct psi_plist *tokens, size_t *index);
  16 static void psi_parser_proc_error(struct psi_parser *P, struct psi_plist *tokens, size_t *index, const char *msg);
  17
  18 static inline void psi_parser_proc_add_struct(struct psi_parser *P, struct psi_decl_struct *strct)
  19 {
  20         assert(strct);
  21         if (!P->structs) {
  22                 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
  23         }
  24         P->structs = psi_plist_add(P->structs, &strct);
  25 }
  26 static inline void psi_parser_proc_add_union(struct psi_parser *P, struct psi_decl_union *u)
  27 {
  28         assert(u);
  29         if (!P->unions) {
  30                 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
  31         }
  32         P->unions = psi_plist_add(P->unions, &u);
  33 }
  34 static inline void psi_parser_proc_add_enum(struct psi_parser *P, struct psi_decl_enum *e)
  35 {
  36         assert(e);
  37         if (!P->enums) {
  38                 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
  39         }
  40         P->enums = psi_plist_add(P->enums, &e);
  41 }
  42 static inline void psi_parser_proc_deanon_typedef(struct psi_decl_arg *def)
  43 {
  44         switch (def->type->type) {
  45         case PSI_T_STRUCT:
  46                 if (!psi_decl_type_is_anon(def->type->name, "struct")) {
  47                         return;
  48                 }
  49                 break;
  50         case PSI_T_UNION:
  51                 if (!psi_decl_type_is_anon(def->type->name, "union")) {
  52                         return;
  53                 }
  54                 break;
  55         case PSI_T_ENUM:
  56                 if (!psi_decl_type_is_anon(def->type->name, "enum")) {
  57                         return;
  58                 }
  59                 break;
  60         default:
  61                 return;
  62         }
  63         free(def->type->name);
  64         def->type->name = strdup(def->var->name);
  65 }
  66 static inline void psi_parser_proc_add_typedef(struct psi_parser *P, struct psi_decl_arg *def)
  67 {
  68         assert(def);
  69         if (!P->types) {
  70                 P->types = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
  71         }
  72         //psi_parser_proc_deanon_typedef(def);
  73         P->types = psi_plist_add(P->types, &def);
  74 }
  75 static inline void psi_parser_proc_add_const(struct psi_parser *P, struct psi_const *cnst) {
  76         assert(cnst);
  77         if (!P->consts) {
  78                 P->consts = psi_plist_init((psi_plist_dtor) psi_const_free);
  79         }
  80         P->consts = psi_plist_add(P->consts, &cnst);
  81
  82 }
  83 static inline void psi_parser_proc_add_decl(struct psi_parser *P, struct psi_decl *decl) {
  84         assert(decl);
  85
  86         if (psi_decl_is_blacklisted(decl->func->var->name)) {
  87                 psi_decl_free(&decl);
  88                 return;
  89         }
  90
  91         if (!P->decls) {
  92                 P->decls = psi_plist_init((psi_plist_dtor) psi_decl_free);
  93         }
  94         P->decls = psi_plist_add(P->decls, &decl);
  95 }
  96 static inline void psi_parser_proc_add_decl_extvars(struct psi_parser *P, struct psi_plist *list) {
  97         assert(list);
  98         if (!P->vars) {
  99                 P->vars = psi_plist_init((psi_plist_dtor) psi_decl_extvar_free);
 100         }
 101         P->vars = psi_plist_add_r(P->vars, psi_plist_count(list), psi_plist_eles(list));
 102         free(list);
 103 }
 104 static inline void psi_parser_proc_add_impl(struct psi_parser *P, struct psi_impl *impl) {
 105         assert(impl);
 106         if (!P->impls) {
 107                 P->impls = psi_plist_init((psi_plist_dtor) psi_impl_free);
 108         }
 109         P->impls = psi_plist_add(P->impls, &impl);
 110 }
 111
 112 /* end code */
 113 }
 114
 115 %code requires {
 116 #include "plist.h"
 117 #include "types/layout.h"
 118
 119 #define yytokentype psi_token_type
 120
 121 #define PSI_T_CAST                      PSI_T_EQUALS
 122 #define PSI_T_POINTER           PSI_T_ASTERISK
 123
 124 struct psi_parser;
 125
 126 }
 127
 128 %require "3.0"
 129 %language "c"
 130 %name-prefix "psi_parser_proc_"
 131 %token-table
 132 %verbose
 133 %glr-parser
 134
 135 %param {struct psi_parser *P} {struct psi_plist *tokens} {size_t *index}
 136
 137 %define api.pure true
 138 %define api.token.prefix {PSI_T_}
 139 %define api.value.type union
 140
 141 %define parse.error verbose
 142 %define parse.trace true
 143
 144 %initial-action {
 145 }
 146
 147 %start file
 148
 149 %token <struct psi_token *> BOOL
 150 %token <struct psi_token *> CHAR
 151 %token <struct psi_token *> SHORT
 152 %token <struct psi_token *> INT
 153 %token <struct psi_token *> SIGNED
 154 %token <struct psi_token *> UNSIGNED
 155 %token <struct psi_token *> LONG
 156 %token <struct psi_token *> FLOAT
 157 %token <struct psi_token *> DOUBLE
 158 %token <struct psi_token *> STRING
 159 %token <struct psi_token *> MIXED
 160 %token <struct psi_token *> ARRAY
 161 %token <struct psi_token *> OBJECT
 162 %token <struct psi_token *> CALLABLE
 163 %token <struct psi_token *> VOID
 164 %token <struct psi_token *> ZVAL
 165 %token <struct psi_token *> NULL
 166 %token <struct psi_token *> TRUE
 167 %token <struct psi_token *> FALSE
 168 %token <struct psi_token *> NAME
 169 %token <struct psi_token *> NSNAME
 170 %token <struct psi_token *> DOLLAR_NAME
 171 %token <struct psi_token *> NUMBER
 172 %token <struct psi_token *> QUOTED_STRING
 173 %token <struct psi_token *> QUOTED_CHAR
 174 %token <struct psi_token *> SIZEOF
 175 %token <struct psi_token *> VOLATILE
 176
 177 %token <struct psi_token *> EOF 0               "end of file"
 178 %token <struct psi_token *> EOL                 "end of line"
 179 %token <struct psi_token *> EOS                 ";"
 180 %token <struct psi_token *> LPAREN              "("
 181 %token <struct psi_token *> RPAREN              ")"
 182 %token <struct psi_token *> COMMA               ","
 183 %token <struct psi_token *> COLON               ":"
 184 %token <struct psi_token *> LBRACE              "{"
 185 %token <struct psi_token *> RBRACE              "}"
 186 %token <struct psi_token *> LBRACKET    "["
 187 %token <struct psi_token *> RBRACKET    "]"
 188 %token <struct psi_token *> EQUALS              "="
 189 %token <struct psi_token *> HASH                "#"
 190 %token <struct psi_token *> PIPE                "|"
 191 %token <struct psi_token *> CARET               "^"
 192 %token <struct psi_token *> AMPERSAND   "&"
 193 %token <struct psi_token *> LSHIFT              "<<"
 194 %token <struct psi_token *> RSHIFT              ">>"
 195 %token <struct psi_token *> PLUS                "+"
 196 %token <struct psi_token *> MINUS               "-"
 197 %token <struct psi_token *> ASTERISK    "*"
 198 %token <struct psi_token *> SLASH               "/"
 199 %token <struct psi_token *> MODULO              "%"
 200 %token <struct psi_token *> LCHEVR              "<"
 201 %token <struct psi_token *> RCHEVR              ">"
 202 %token <struct psi_token *> CMP_GE              ">="
 203 %token <struct psi_token *> CMP_LE              "<="
 204 %token <struct psi_token *> OR                  "||"
 205 %token <struct psi_token *> AND                 "&&"
 206 %token <struct psi_token *> CMP_EQ              "=="
 207 %token <struct psi_token *> CMP_NE              "!="
 208 %token <struct psi_token *> TILDE               "~"
 209 %token <struct psi_token *> NOT                 "!"
 210 %token <struct psi_token *> PERIOD              "."
 211 %token <struct psi_token *> BACKSLASH   "\\"
 212 %token <struct psi_token *> ELLIPSIS    "..."
 213 %token <struct psi_token *> IIF                 "?"
 214
 215 %token <struct psi_token *> PRAGMA
 216 %token <struct psi_token *> PRAGMA_ONCE
 217 %token <struct psi_token *> LINE
 218 %token <struct psi_token *> ERROR
 219 %token <struct psi_token *> WARNING
 220 %token <struct psi_token *> IF
 221 %token <struct psi_token *> IFDEF
 222 %token <struct psi_token *> IFNDEF
 223 %token <struct psi_token *> ELSE
 224 %token <struct psi_token *> ELIF
 225 %token <struct psi_token *> ENDIF
 226 %token <struct psi_token *> DEFINE
 227 %token <struct psi_token *> DEFINED
 228 %token <struct psi_token *> UNDEF
 229 %token <struct psi_token *> IMPORT
 230 %token <struct psi_token *> INCLUDE
 231 %token <struct psi_token *> INCLUDE_NEXT
 232
 233 %token <struct psi_token *> TYPEDEF
 234 %token <struct psi_token *> STRUCT
 235 %token <struct psi_token *> UNION
 236 %token <struct psi_token *> ENUM
 237 %token <struct psi_token *> CONST
 238 %token <struct psi_token *> LIB
 239 %token <struct psi_token *> STATIC
 240 %token <struct psi_token *> CALLBACK
 241 %token <struct psi_token *> FUNCTION
 242 %token <struct psi_token *> LET
 243 %token <struct psi_token *> SET
 244 %token <struct psi_token *> TEMP
 245 %token <struct psi_token *> FREE
 246 %token <struct psi_token *> RETURN
 247 %token <struct psi_token *> AS
 248 %token <struct psi_token *> PRE_ASSERT
 249 %token <struct psi_token *> POST_ASSERT
 250 %token <struct psi_token *> BOOLVAL
 251 %token <struct psi_token *> INTVAL
 252 %token <struct psi_token *> STRVAL
 253 %token <struct psi_token *> PATHVAL
 254 %token <struct psi_token *> STRLEN
 255 %token <struct psi_token *> FLOATVAL
 256 %token <struct psi_token *> ARRVAL
 257 %token <struct psi_token *> OBJVAL
 258 %token <struct psi_token *> COUNT
 259 %token <struct psi_token *> CALLOC
 260 %token <struct psi_token *> TO_BOOL
 261 %token <struct psi_token *> TO_INT
 262 %token <struct psi_token *> TO_STRING
 263 %token <struct psi_token *> TO_FLOAT
 264 %token <struct psi_token *> TO_ARRAY
 265 %token <struct psi_token *> TO_OBJECT
 266
 267 %token <struct psi_token *> COMMENT
 268 %token <struct psi_token *> WHITESPACE
 269 %token <struct psi_token *> NO_WHITESPACE
 270 %token <struct psi_token *> CPP_HEADER
 271 %token <struct psi_token *> CPP_ATTRIBUTE
 272 %token <struct psi_token *> CPP_EXTENSION
 273 %token <struct psi_token *> CPP_PASTE
 274 %token <struct psi_token *> CPP_INLINE
 275 %token <struct psi_token *> CPP_RESTRICT
 276 %token <struct psi_token *> CPP_ASM
 277
 278 /* virtual tokens */
 279 %token <struct psi_token *> BSLASH
 280 %token <struct psi_token *> LONG_DOUBLE
 281 %token <struct psi_token *> INT8
 282 %token <struct psi_token *> UINT8
 283 %token <struct psi_token *> INT16
 284 %token <struct psi_token *> UINT16
 285 %token <struct psi_token *> INT32
 286 %token <struct psi_token *> UINT32
 287 %token <struct psi_token *> INT64
 288 %token <struct psi_token *> UINT64
 289 %token <struct psi_token *> INT128
 290 %token <struct psi_token *> UINT128
 291
 292
 293 %precedence IIF COLON
 294 %precedence OR
 295 %precedence AND
 296 %precedence PIPE
 297 %precedence CARET
 298 %precedence AMPERSAND
 299 %precedence CMP_EQ CMP_NE
 300 %precedence LCHEVR CMP_LE RCHEVR CMP_GE
 301 %precedence LSHIFT RSHIFT
 302 %precedence PLUS MINUS
 303 %precedence ASTERISK SLASH MODULO
 304 //%precedence NOT TILDE
 305 %precedence BINARY
 306 %precedence UNARY
 307
 308 %type           <struct psi_token *>                            lib optional_name enum_name struct_name union_name
 309 %destructor     {psi_token_free(&$$);}                          lib optional_name enum_name struct_name union_name
 310
 311 %type           <struct psi_token *>                            cpp_message_token cpp_include_token cpp_header_token cpp_no_arg_token cpp_name_arg_token cpp_exp_arg_token
 312 %destructor     {}                                                                      cpp_message_token cpp_include_token cpp_header_token cpp_no_arg_token cpp_name_arg_token cpp_exp_arg_token
 313
 314 %type           <struct psi_token *>                            name_token any_noeol_token binary_op_token unary_op_token
 315 %destructor     {}                                                                      name_token any_noeol_token binary_op_token unary_op_token
 316
 317 %type           <struct psi_token *>                            int_width int_width_types int_signed_types
 318 %destructor     {psi_token_free(&$$);}                          int_width int_width_types int_signed_types
 319
 320 %type           <struct psi_token *>                            signed_long_types signed_short_types int_signed
 321 %destructor     {}                                                                      signed_long_types signed_short_types int_signed
 322
 323 %type           <struct psi_cpp_exp *>                          cpp cpp_exp
 324 %destructor     {psi_cpp_exp_free(&$$);}                        cpp cpp_exp
 325 %type           <struct psi_cpp_macro_decl *>           cpp_macro_decl
 326 %destructor     {psi_cpp_macro_decl_free(&$$);}         cpp_macro_decl
 327 %type           <struct psi_plist *>                            cpp_macro_sig cpp_macro_sig_args cpp_macro_decl_tokens cpp_macro_decl_token_list cpp_macro_call_args cpp_macro_call_arg_list
 328 %destructor {psi_plist_free($$);}                               cpp_macro_sig cpp_macro_sig_args cpp_macro_decl_tokens cpp_macro_decl_token_list cpp_macro_call_args cpp_macro_call_arg_list
 329 %type           <struct psi_num_exp *>                          cpp_macro_exp
 330 %destructor     {psi_num_exp_free(&$$);}                        cpp_macro_exp
 331
 332 %type           <struct psi_token *>                            impl_def_val_token
 333 %destructor     {}                                                                      impl_def_val_token
 334
 335 %type           <struct psi_const *>                            constant
 336 %destructor     {psi_const_free(&$$);}                          constant
 337 %type           <struct psi_impl_def_val *>                     impl_def_val
 338 %destructor     {psi_impl_def_val_free(&$$);}           impl_def_val
 339
 340 %type           <struct psi_token *>                            decl_real_type decl_int_type decl_type_simple
 341 %destructor     {psi_token_free(&$$);}                          decl_real_type decl_int_type decl_type_simple
 342
 343 %type           <struct psi_token *>                            decl_asm quoted_strings
 344 %destructor     {psi_token_free(&$$);}                          decl_asm quoted_strings
 345
 346 %type           <struct psi_decl_type *>                        decl_type qualified_decl_type decl_type_complex
 347 %destructor     {psi_decl_type_free(&$$);}                      decl_type qualified_decl_type decl_type_complex
 348 %type           <struct psi_decl *>                                     decl_stmt decl decl_body decl_func_body decl_functor_body decl_anon_functor_body ignored_decl
 349 %destructor     {psi_decl_free(&$$);}                           decl_stmt decl decl_body decl_func_body decl_functor_body decl_anon_functor_body ignored_decl
 350 %type           <struct psi_decl_arg *>                         decl_typedef decl_func decl_functor decl_anon_functor decl_arg decl_anon_arg typedef typedef_decl typedef_anon typedef_anon_decl
 351 %destructor     {psi_decl_arg_free(&$$);}                       decl_typedef decl_func decl_functor decl_anon_functor decl_arg decl_anon_arg typedef typedef_decl typedef_anon typedef_anon_decl
 352 %type           <struct psi_decl_var *>                         decl_var
 353 %destructor     {psi_decl_var_free(&$$);}                       decl_var
 354 %type           <struct psi_decl_struct *>                      decl_struct
 355 %destructor     {psi_decl_struct_free(&$$);}            decl_struct
 356 %type           <struct psi_decl_union *>                       decl_union
 357 %destructor     {psi_decl_union_free(&$$);}                     decl_union
 358 %type           <struct psi_decl_enum *>                        decl_enum
 359 %destructor     {psi_decl_enum_free(&$$);}                      decl_enum
 360 %type           <struct psi_decl_enum_item *>           decl_enum_item
 361 %destructor     {psi_decl_enum_item_free(&$$);}         decl_enum_item
 362 %type           <struct psi_plist *>                            decl_args decl_arg_list decl_struct_args struct_args_block struct_args struct_arg_var_list decl_enum_items decl_vars decl_vars_with_layout call_decl_vars decl_extvar_stmt decl_extvar_list
 363 %destructor     {psi_plist_free($$);}                           decl_args decl_arg_list decl_struct_args struct_args_block struct_args struct_arg_var_list decl_enum_items decl_vars decl_vars_with_layout call_decl_vars decl_extvar_stmt decl_extvar_list
 364
 365 %type           <struct psi_layout>                                     align_and_size
 366 %destructor     {}                                                                      align_and_size
 367 %type           <struct psi_layout *>                           decl_layout
 368 %destructor     {psi_layout_free(&$$);}                         decl_layout
 369
 370 %type           <struct psi_number *>                           sizeof sizeof_body sizeof_body_notypes
 371 %destructor     {psi_number_free(&$$);}                         sizeof sizeof_body sizeof_body_notypes
 372
 373 %type           <struct psi_impl *>                                     impl
 374 %destructor     {psi_impl_free(&$$);}                           impl
 375 %type           <struct psi_impl_func *>                        impl_func
 376 %destructor     {psi_impl_func_free(&$$);}                      impl_func
 377 %type           <struct psi_impl_arg *>                         impl_arg
 378 %destructor     {psi_impl_arg_free(&$$);}                       impl_arg
 379 %type           <struct psi_impl_type *>                        impl_type impl_type_restricted
 380 %destructor     {psi_impl_type_free(&$$);}                      impl_type impl_type_restricted
 381 %type           <struct psi_impl_var *>                         impl_var
 382 %destructor     {psi_impl_var_free(&$$);}                       impl_var
 383
 384 %type           <struct psi_let_stmt *>                         let_stmt
 385 %destructor     {psi_let_stmt_free(&$$);}                       let_stmt
 386 %type           <struct psi_let_exp *>                          let_exp let_exp_byref let_exp_assign
 387 %destructor     {psi_let_exp_free(&$$);}                        let_exp let_exp_byref let_exp_assign
 388 %type           <struct psi_let_calloc *>                       let_calloc
 389 %destructor     {psi_let_calloc_free(&$$);}                     let_calloc
 390 %type           <struct psi_let_callback *>                     let_callback
 391 %destructor     {psi_let_callback_free(&$$);}           let_callback
 392 %type           <struct psi_let_func *>                         let_func
 393 %destructor     {psi_let_func_free(&$$);}                       let_func
 394 %type           <struct psi_set_stmt *>                         set_stmt
 395 %destructor     {psi_set_stmt_free(&$$);}                       set_stmt
 396 %type           <struct psi_set_exp *>                          set_exp
 397 %destructor     {psi_set_exp_free(&$$);}                        set_exp
 398 %type           <struct psi_set_func *>                         set_func
 399 %destructor     {psi_set_func_free(&$$);}                       set_func
 400 %type           <struct psi_assert_stmt *>                      assert_stmt
 401 %destructor     {psi_assert_stmt_free(&$$);}            assert_stmt
 402 %type           <struct psi_return_stmt *>                      return_stmt
 403 %destructor     {psi_return_stmt_free(&$$);}            return_stmt
 404 %type           <struct psi_return_exp *>                       return_exp
 405 %destructor     {psi_return_exp_free(&$$);}                     return_exp
 406 %type           <struct psi_free_stmt *>                        free_stmt
 407 %destructor     {psi_free_stmt_free(&$$);}                      free_stmt
 408 %type           <struct psi_free_exp *>                         free_exp
 409 %destructor     {psi_free_exp_free(&$$);}                       free_exp
 410
 411 %type           <struct psi_token **>                           impl_stmt
 412 %destructor     {psi_impl_stmt_free(&$$);}                      impl_stmt
 413 %type           <struct psi_token *>                            impl_type_token impl_type_restricted_token impl_type_extended_token callback_rval let_func_token set_func_token assert_stmt_token
 414 %destructor     {psi_token_free(&$$);}                          impl_type_token impl_type_restricted_token impl_type_extended_token callback_rval let_func_token set_func_token assert_stmt_token
 415 %type           <struct psi_plist *>                            impl_args impl_stmts let_exps let_func_exps callback_arg_list callback_args set_exps set_func_exps free_exps
 416 %destructor     {psi_plist_free($$);}                           impl_args impl_stmts let_exps let_func_exps callback_arg_list callback_args set_exps set_func_exps free_exps
 417
 418 %type           <struct psi_num_exp *>                          num_exp
 419 %destructor     {psi_num_exp_free(&$$);}                        num_exp
 420 %type           <struct psi_number *>                           number
 421 %destructor     {psi_number_free(&$$);}                         number
 422
 423 %type           <size_t>                                                        indirection pointers asterisks array_size
 424 %destructor     {}                                                                      indirection pointers asterisks array_size
 425 %type           <bool>                                                          reference
 426 %destructor     {}                                                                      reference
 427
 428 %%
 429
 430 /* rules */
 431
 432
 433 binary_op_token: PIPE | CARET | AMPERSAND | LSHIFT | RSHIFT | PLUS | MINUS | ASTERISK | SLASH | MODULO | RCHEVR | LCHEVR | CMP_GE | CMP_LE | OR | AND | CMP_EQ | CMP_NE ;
 434 unary_op_token: TILDE | NOT | PLUS | MINUS ;
 435 name_token: NAME | FUNCTION | TEMP | FREE | SET | LET | CALLOC | CALLBACK | LIB | BOOL | STRING | ERROR | WARNING | LINE | PRAGMA_ONCE | PRAGMA | AS | let_func_token | set_func_token;
 436 any_noeol_token: BOOL | CHAR | SHORT | INT | SIGNED | UNSIGNED | LONG | FLOAT | DOUBLE | STRING | MIXED | ARRAY | OBJECT | CALLABLE | VOID | ZVAL | NULL | TRUE | FALSE | NAME | NSNAME | DOLLAR_NAME | NUMBER | QUOTED_STRING | QUOTED_CHAR | EOF | EOS | LPAREN | RPAREN | COMMA | COLON | LBRACE | RBRACE | LBRACKET | RBRACKET | EQUALS | HASH | PIPE | CARET | AMPERSAND | LSHIFT | RSHIFT | PLUS | MINUS | ASTERISK | SLASH | MODULO | LCHEVR | RCHEVR | CMP_GE | CMP_LE | OR | AND | CMP_EQ | CMP_NE | TILDE | NOT | PERIOD | BACKSLASH | ELLIPSIS | ERROR | WARNING | LINE | PRAGMA | PRAGMA_ONCE | IIF | IF | IFDEF | IFNDEF | ELSE | ELIF | ENDIF | DEFINE | DEFINED | UNDEF | INCLUDE | TYPEDEF | STRUCT | UNION | ENUM | CONST | LIB | STATIC | CALLBACK | FUNCTION | LET | SET | TEMP | FREE | RETURN | PRE_ASSERT | POST_ASSERT | BOOLVAL | INTVAL | STRVAL | PATHVAL | STRLEN | FLOATVAL | ARRVAL | OBJVAL | COUNT | CALLOC | TO_BOOL | TO_INT | TO_STRING | TO_FLOAT | TO_ARRAY | TO_OBJECT | COMMENT | CPP_HEADER | CPP_PASTE | CPP_INLINE | CPP_RESTRICT | CPP_EXTENSION | CPP_ASM | SIZEOF | VOLATILE | AS;
 437 any_nobrace_token: BOOL | CHAR | SHORT | INT | SIGNED | UNSIGNED | LONG | FLOAT | DOUBLE | STRING | MIXED | ARRAY | OBJECT | CALLABLE | VOID | ZVAL | NULL | TRUE | FALSE | NAME | NSNAME | DOLLAR_NAME | NUMBER | QUOTED_STRING | QUOTED_CHAR | EOF | EOS | LPAREN | RPAREN | COMMA | COLON | LBRACKET | RBRACKET | EQUALS | HASH | PIPE | CARET | AMPERSAND | LSHIFT | RSHIFT | PLUS | MINUS | ASTERISK | SLASH | MODULO | LCHEVR | RCHEVR | CMP_GE | CMP_LE | OR | AND | CMP_EQ | CMP_NE | TILDE | NOT | PERIOD | BACKSLASH | ELLIPSIS | ERROR | WARNING | LINE | PRAGMA | PRAGMA_ONCE | IIF | IF | IFDEF | IFNDEF | ELSE | ELIF | ENDIF | DEFINE | DEFINED | UNDEF | INCLUDE | TYPEDEF | STRUCT | UNION | ENUM | CONST | LIB | STATIC | CALLBACK | FUNCTION | LET | SET | TEMP | FREE | RETURN | PRE_ASSERT | POST_ASSERT | BOOLVAL | INTVAL | STRVAL | PATHVAL | STRLEN | FLOATVAL | ARRVAL | OBJVAL | COUNT | CALLOC | TO_BOOL | TO_INT | TO_STRING | TO_FLOAT | TO_ARRAY | TO_OBJECT | COMMENT | CPP_HEADER | CPP_PASTE | CPP_INLINE | CPP_RESTRICT | CPP_EXTENSION | CPP_ASM | SIZEOF | VOLATILE | AS;
 438
 439
 440 file:
 441         %empty
 442 |       blocks
 443 ;
 444 blocks:
 445         block
 446 |       blocks block
 447 ;
 448 block:
 449         EOS
 450 |       EOL
 451 |       COMMENT
 452 |       cpp {
 453         if ($cpp) {
 454                 psi_cpp_exp_exec($cpp, P->preproc, PSI_DATA(P));
 455                 psi_cpp_exp_free(&$cpp);
 456         }
 457 }
 458 |       lib {
 459         if (P->file.ln) {
 460                 P->error(PSI_DATA(P), $lib, PSI_WARNING,
 461                                 "Extra 'lib \"%s\"' statement has no effect", $lib->text);
 462         } else {
 463                 P->file.ln = strndup($lib->text, $lib->size);
 464         }
 465 }
 466 |       constant {
 467         psi_parser_proc_add_const(P, $constant);
 468 }
 469 |       decl_stmt {
 470         psi_parser_proc_add_decl(P, $decl_stmt);
 471 }
 472 |       decl_extvar_stmt[list] {
 473         psi_parser_proc_add_decl_extvars(P, $list);
 474 }
 475 |       ignored_decl {
 476         if (P->flags & PSI_DEBUG) {
 477                 P->error(PSI_DATA(P), $ignored_decl->func->token, PSI_NOTICE, "Ignored decl: %s", $ignored_decl->func->var->name);
 478         }
 479         psi_decl_free(&$ignored_decl);
 480 }
 481 |       decl_typedef[def] {
 482         psi_parser_proc_add_typedef(P, $def);
 483 }
 484 |       decl_struct[struct] {
 485         psi_parser_proc_add_struct(P, $struct);
 486 }
 487 |       decl_union[union] {
 488         psi_parser_proc_add_union(P, $union);
 489 }
 490 |       decl_enum[enum] {
 491         psi_parser_proc_add_enum(P, $enum);
 492 }
 493 |       impl {
 494         psi_parser_proc_add_impl(P, $impl);
 495 }
 496 ;
 497
 498 lib:
 499         LIB QUOTED_STRING EOS {
 500         $lib = $QUOTED_STRING;
 501 }
 502 ;
 503
 504 cpp:
 505         HASH EOL {
 506         $cpp = NULL;
 507 }
 508 |       HASH cpp_exp[exp] EOL {
 509         $cpp = $exp;
 510 }
 511 ;
 512
 513 cpp_exp[exp]:
 514         cpp_message_token cpp_macro_decl_tokens[tokens] {
 515         if ($tokens) {
 516                 struct psi_token *msg = NULL;
 517
 518                 if (psi_plist_get($tokens, 0, &msg)) {
 519                         size_t index = 1;
 520                         struct psi_token *next;
 521
 522                         msg = psi_token_copy(msg);
 523                         while (psi_plist_get($tokens, index++, &next)) {
 524                                 struct psi_token *old = msg;
 525                                 msg = psi_token_cat(" ", 2, msg, next);
 526                                 free(old);
 527                         }
 528                 }
 529                 psi_plist_free($tokens);
 530
 531                 $exp = psi_cpp_exp_init($cpp_message_token->type, msg);
 532         } else {
 533                 $exp = psi_cpp_exp_init($cpp_message_token->type, NULL);
 534         }
 535         $exp->token = psi_token_copy($cpp_message_token);
 536 }
 537 |       cpp_include_token[INCLUDE] cpp_header_token {
 538         $exp = psi_cpp_exp_init($INCLUDE->type, psi_token_copy($cpp_header_token));
 539         $exp->token = psi_token_copy($INCLUDE);
 540 }
 541 |       cpp_no_arg_token {
 542         $exp = psi_cpp_exp_init($cpp_no_arg_token->type, NULL);
 543         $exp->token = psi_token_copy($cpp_no_arg_token);
 544 }
 545 |       cpp_name_arg_token any_noeol_token[name_token] {
 546         $name_token->type = PSI_T_NAME;
 547         $exp = psi_cpp_exp_init($cpp_name_arg_token->type, psi_token_copy($name_token));
 548         $exp->token = psi_token_copy($cpp_name_arg_token);
 549 }
 550 |       DEFINE cpp_macro_decl {
 551         $exp = psi_cpp_exp_init($DEFINE->type, $cpp_macro_decl);
 552         $exp->token = psi_token_copy($DEFINE);
 553 }
 554 |       cpp_exp_arg_token cpp_macro_exp {
 555         $exp = psi_cpp_exp_init($cpp_exp_arg_token->type, $cpp_macro_exp);
 556         $exp->token = psi_token_copy($cpp_exp_arg_token);
 557 }
 558 |       PRAGMA_ONCE {
 559         $exp = psi_cpp_exp_init($PRAGMA_ONCE->type, NULL);
 560         $exp->token = psi_token_copy($PRAGMA_ONCE);
 561 }
 562 |       cpp_ignored_token cpp_macro_decl_tokens[tokens] {
 563         psi_plist_free($tokens);
 564         $exp = NULL;
 565 }
 566 ;
 567
 568 cpp_ignored_token:
 569         LINE
 570 |       PRAGMA
 571 ;
 572
 573 cpp_message_token:
 574         ERROR
 575 |       WARNING
 576 ;
 577
 578 cpp_include_token:
 579         IMPORT
 580 |       INCLUDE
 581 |       INCLUDE_NEXT
 582 ;
 583
 584 cpp_header_token:
 585         QUOTED_STRING
 586 |       CPP_HEADER
 587 ;
 588
 589 cpp_no_arg_token:
 590         ELSE
 591 |       ENDIF
 592 ;
 593
 594 cpp_name_arg_token:
 595         IFDEF
 596 |       IFNDEF
 597 |       UNDEF
 598 ;
 599
 600 cpp_exp_arg_token:
 601         IF
 602 |       ELIF
 603 ;
 604
 605 cpp_macro_decl[macro]:
 606         any_noeol_token[name_token] cpp_macro_decl_tokens %dprec 1 {
 607         $name_token->type = PSI_T_NAME;
 608         $macro = psi_cpp_macro_decl_init(NULL, $cpp_macro_decl_tokens, NULL);
 609         $macro->token = psi_token_copy($name_token);
 610 }
 611 |       name_token NO_WHITESPACE LPAREN cpp_macro_sig RPAREN cpp_macro_decl_tokens %dprec 2 {
 612         $name_token->type = PSI_T_NAME;
 613         $macro = psi_cpp_macro_decl_init($cpp_macro_sig, $cpp_macro_decl_tokens, NULL);
 614         $macro->token = psi_token_copy($name_token);
 615 }
 616 |       name_token cpp_macro_exp[num_exp] %dprec 2 {
 617         $name_token->type = PSI_T_NAME;
 618         $macro = psi_cpp_macro_decl_init(NULL, psi_num_exp_tokens($num_exp, NULL), $num_exp);
 619         $macro->token = psi_token_copy($name_token);
 620 }
 621 |       name_token quoted_strings[strings] %dprec 2 {
 622         struct psi_plist *list = psi_plist_init((psi_plist_dtor) psi_token_free);
 623         $name_token->type = PSI_T_NAME;
 624         $macro = psi_cpp_macro_decl_init(NULL, psi_plist_add(list, &$strings), NULL);
 625         $macro->token = psi_token_copy($name_token);
 626 }
 627 ;
 628
 629 cpp_macro_sig[sig]:
 630         %empty {
 631         $sig = psi_plist_init(NULL);
 632 }
 633 |       ELLIPSIS {
 634         $sig = psi_plist_init(NULL); /* FIXME */
 635 }
 636 |       cpp_macro_sig_args
 637 |       cpp_macro_sig_args[args] COMMA ELLIPSIS {
 638         $sig = $args;
 639 }
 640 ;
 641
 642 cpp_macro_sig_args[args]:
 643         name_token {
 644         $name_token = psi_token_copy($name_token);
 645         $name_token->type = PSI_T_NAME;
 646         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_token_free), &$name_token);
 647 }
 648 |       cpp_macro_sig_args[args_] COMMA name_token {
 649         $name_token = psi_token_copy($name_token);
 650         $name_token->type = PSI_T_NAME;
 651         $args = psi_plist_add($args_, &$name_token);
 652 }
 653 ;
 654
 655 cpp_macro_decl_tokens[tokens]:
 656         %empty {
 657         $tokens = NULL;
 658 }
 659 | cpp_macro_decl_token_list
 660 ;
 661
 662 cpp_macro_decl_token_list[tokens]:
 663         any_noeol_token[token] {
 664         $token = psi_token_copy($token);
 665         $tokens = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_token_free), &$token);
 666 }
 667 |       cpp_macro_decl_token_list[tokens_] any_noeol_token[token] {
 668         $token = psi_token_copy($token);
 669         $tokens = psi_plist_add($tokens_, &$token);
 670 }
 671 ;
 672
 673 cpp_macro_exp[exp]:
 674         LPAREN cpp_macro_exp[exp_] RPAREN {
 675         $exp = psi_num_exp_init_unary($LPAREN->type, $exp_);
 676         $exp->token = psi_token_copy($LPAREN);
 677 }
 678 |       unary_op_token cpp_macro_exp[exp_] %prec UNARY {
 679         $exp = psi_num_exp_init_unary($unary_op_token->type, $exp_);
 680         $exp->token = psi_token_copy($unary_op_token);
 681 }
 682 |       cpp_macro_exp[lhs] binary_op_token cpp_macro_exp[rhs] %prec BINARY {
 683         $exp = psi_num_exp_init_binary($binary_op_token->type, $lhs, $rhs);
 684         $exp->token = psi_token_copy($binary_op_token);
 685 }
 686 |       cpp_macro_exp[cond] IIF cpp_macro_exp[truthy] COLON cpp_macro_exp[falsy] {
 687         $exp = psi_num_exp_init_ternary($IIF->type, $cond, $truthy, $falsy);
 688         $exp->token = psi_token_copy($IIF);
 689 }
 690
 691 |       DEFINED name_token {
 692         {
 693                 uint8_t exists;
 694
 695                 $name_token->type = PSI_T_NAME;
 696                 exists = psi_cpp_defined(P->preproc, $name_token);
 697                 $exp = psi_num_exp_init_num(psi_number_init(PSI_T_UINT8, &exists, 0));
 698                 $exp->token = psi_token_copy($DEFINED);
 699                 $exp->data.n->token = psi_token_copy($name_token);
 700         }
 701 }
 702 |       DEFINED LPAREN name_token RPAREN {
 703         {
 704                 uint8_t exists;
 705
 706                 $name_token->type = PSI_T_NAME;
 707                 exists = psi_cpp_defined(P->preproc, $name_token);
 708                 $exp = psi_num_exp_init_num(psi_number_init(PSI_T_UINT8, &exists, 0));
 709                 $exp->token = psi_token_copy($DEFINED);
 710                 $exp->data.n->token = psi_token_copy($name_token);
 711         }
 712 }
 713 |       NUMBER {
 714         $exp = psi_num_exp_init_num(psi_number_init($NUMBER->type, $NUMBER->text, $NUMBER->flags));
 715         $exp->token = psi_token_copy($NUMBER);
 716         $exp->data.n->token = psi_token_copy($NUMBER);
 717 }
 718 |       QUOTED_CHAR {
 719         $exp = psi_num_exp_init_num(psi_number_init($QUOTED_CHAR->type, $QUOTED_CHAR->text, 0));
 720         $exp->token = psi_token_copy($QUOTED_CHAR);
 721         $exp->data.n->token = psi_token_copy($QUOTED_CHAR);
 722 }
 723 |       sizeof {
 724         $exp = psi_num_exp_init_num($sizeof);
 725         $exp->token = psi_token_copy($sizeof->token);
 726 }
 727 |       name_token {
 728         $name_token->type = PSI_T_NAME;
 729         $exp = psi_num_exp_init_num(psi_number_init(PSI_T_DEFINE, $name_token->text, 0));
 730         $exp->token = psi_token_copy($name_token);
 731         $exp->data.n->token = psi_token_copy($name_token);
 732 }
 733 |       name_token LPAREN cpp_macro_call_args RPAREN {
 734         $name_token->type = PSI_T_NAME;
 735         $exp = psi_num_exp_init_num(psi_number_init(PSI_T_FUNCTION,
 736                 psi_cpp_macro_call_init($name_token->text, $cpp_macro_call_args), 0));
 737         $exp->token = psi_token_copy($name_token);
 738         $exp->data.n->token = psi_token_copy($name_token);
 739 }
 740 ;
 741
 742 cpp_macro_call_args[args]:
 743         %empty {
 744         $args = NULL;
 745 }
 746 |       cpp_macro_call_arg_list
 747 ;
 748
 749 cpp_macro_call_arg_list[args]:
 750         cpp_macro_exp {
 751         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_num_exp_free),
 752                 &$cpp_macro_exp);
 753 }
 754 |       cpp_macro_call_arg_list[args_] COMMA cpp_macro_exp {
 755         $args = psi_plist_add($args_, &$cpp_macro_exp);
 756 }
 757 ;
 758
 759 constant[const]:
 760         CONST impl_type_restricted[type] NSNAME EQUALS impl_def_val EOS {
 761         $const = psi_const_init($type, $NSNAME->text, $impl_def_val);
 762         $const->token = psi_token_copy($NSNAME);
 763 }
 764 ;
 765
 766 impl_def_val[val]:
 767         impl_def_val_token[token] %dprec 2 {
 768         $val = psi_impl_def_val_init($token->type, $token->text);
 769         $val->token = psi_token_copy($token);
 770 }
 771 |       num_exp[num] %dprec 1 {
 772         $val = psi_impl_def_val_init(PSI_T_NUMBER, $num);
 773         $val->token = psi_token_copy($num->token);
 774 }
 775 |       quoted_strings[token] {
 776         $val = psi_impl_def_val_init($token->type, $token->text);
 777         $val->token = psi_token_copy($token);
 778 }
 779 ;
 780
 781 impl_def_val_token:
 782         NULL
 783 |       TRUE
 784 |       FALSE
 785 ;
 786
 787 decl_typedef[def]:
 788         TYPEDEF typedef[def_] EOS {
 789         $def = $def_;
 790 }
 791 /*
 792 |       TYPEDEF VOID name_token EOS {
 793         $def = psi_decl_arg_init(
 794                 psi_decl_type_init(PSI_T_VOID, $VOID->text),
 795                 psi_decl_var_init($name_token->text, 0, 0)
 796         );
 797         $def->token = psi_token_copy($VOID);
 798         $def->type->token = psi_token_copy($VOID);
 799         $def->var->token = psi_token_copy($name_token);
 800 }
 801 */
 802 |       CPP_EXTENSION TYPEDEF typedef[def_] EOS {
 803         $def = $def_;
 804 }
 805 ;
 806
 807 typedef[def]:
 808         typedef_decl {
 809         $def = $typedef_decl;
 810 }
 811 |       CPP_EXTENSION typedef_decl {
 812         $def = $typedef_decl;
 813 }
 814 ;
 815
 816 typedef_anon[def]:
 817         typedef_anon_decl {
 818         $def = $typedef_anon_decl;
 819 }
 820 |       CPP_EXTENSION typedef_anon_decl {
 821         $def = $typedef_anon_decl;
 822 }
 823 ;
 824
 825 typedef_decl[def]:
 826         decl_arg
 827 |       decl_func_body[decl] {
 828         $def = psi_decl_arg_init(
 829                 psi_decl_type_init(PSI_T_FUNCTION, $decl->func->var->name),
 830                 psi_decl_var_copy($decl->func->var)
 831         );
 832         $def->type->token = psi_token_copy($decl->func->token);
 833         $def->type->real.func = $decl;
 834 }
 835 |       decl_enum[enum] name_token {
 836         $name_token->type = PSI_T_NAME;
 837         $def = psi_decl_arg_init(
 838                 psi_decl_type_init(PSI_T_ENUM, $enum->name),
 839                 psi_decl_var_init($name_token->text, 0, 0)
 840         );
 841         $def->var->token = psi_token_copy($name_token);
 842         $def->type->token = psi_token_copy($enum->token);
 843         $def->type->real.enm = $enum;
 844         psi_parser_proc_add_enum(P, $enum);
 845 }
 846 |       struct_name[struct] align_and_size[as] struct_args_block[args] decl_var[var] {
 847         $def = psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT, $struct->text), $var);
 848         $def->type->token = $struct;
 849         $def->type->real.strct = psi_decl_struct_init($struct->text, $args);
 850         $def->type->real.strct->token = psi_token_copy($struct);
 851         $def->type->real.strct->align = $as.pos;
 852         $def->type->real.strct->size = $as.len;
 853         psi_parser_proc_add_struct(P, $def->type->real.strct);
 854 }
 855 |       union_name[union] align_and_size[as] struct_args_block[args] decl_var[var] {
 856         $def = psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION, $union->text), $var);
 857         $def->type->token = $union;
 858         $def->type->real.unn = psi_decl_union_init($union->text, $args);
 859         $def->type->real.unn->token = psi_token_copy($union);
 860         $def->type->real.unn->align = $as.pos;
 861         $def->type->real.unn->size = $as.len;
 862         psi_parser_proc_add_union(P, $def->type->real.unn);
 863 }
 864 ;
 865
 866 typedef_anon_decl[def]:
 867         typedef_decl %dprec 2
 868 |       qualified_decl_type[type] %dprec 1 {
 869         $def = psi_decl_arg_init($type, psi_decl_var_init(NULL, 0, 0));
 870         $def->var->token = psi_token_copy($type->token);
 871 }
 872 |       decl_enum[enum] {
 873         $def = psi_decl_arg_init(
 874                 psi_decl_type_init(PSI_T_ENUM, $enum->name),
 875                 psi_decl_var_init(NULL, 0, 0)
 876         );
 877         $def->var->token = psi_token_copy($enum->token);
 878         $def->type->token = psi_token_copy($enum->token);
 879         $def->type->real.enm = $enum;
 880         psi_parser_proc_add_enum(P, $enum);
 881 }
 882 |       struct_name[struct] align_and_size[as] struct_args_block[args] {
 883         $def = psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT, $struct->text), psi_decl_var_init(NULL, 0, 0));
 884         $def->type->token = $struct;
 885         $def->type->real.strct = psi_decl_struct_init($struct->text, $args);
 886         $def->type->real.strct->token = psi_token_copy($struct);
 887         $def->type->real.strct->align = $as.pos;
 888         $def->type->real.strct->size = $as.len;
 889         psi_parser_proc_add_struct(P, $def->type->real.strct);
 890 }
 891 |       union_name[union] align_and_size[as] struct_args_block[args] {
 892         $def = psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION, $union->text), psi_decl_var_init(NULL, 0, 0));
 893         $def->type->token = $union;
 894         $def->type->real.unn = psi_decl_union_init($union->text, $args);
 895         $def->type->real.unn->token = psi_token_copy($union);
 896         $def->type->real.unn->align = $as.pos;
 897         $def->type->real.unn->size = $as.len;
 898         psi_parser_proc_add_union(P, $def->type->real.unn);
 899 }
 900 ;
 901
 902 qualified_decl_type[type]:
 903         decl_type
 904 |       decl_type_qualifier_token decl_type[type_] {
 905         $type = $type_;
 906 }
 907 |       qualified_decl_type[type_] decl_type_qualifier_token {
 908         $type = $type_;
 909 }
 910 ;
 911
 912 decl_type_qualifier_token:
 913         CONST
 914 |       VOLATILE
 915 ;
 916
 917 decl_type[type]:
 918         decl_type_simple[token] {
 919         $type = psi_decl_type_init($token->type, $token->text);
 920         $type->token = $token;
 921 }
 922 |       decl_type_complex
 923 ;
 924
 925 decl_type_complex[type]:
 926         STRUCT[token] name_token {
 927         $name_token->type = PSI_T_NAME;
 928         $type = psi_decl_type_init($token->type, $name_token->text);
 929         $type->token = psi_token_copy($name_token);
 930 }
 931 |       UNION[token] name_token {
 932         $name_token->type = PSI_T_NAME;
 933         $type = psi_decl_type_init($token->type, $name_token->text);
 934         $type->token = psi_token_copy($name_token);
 935 }
 936 |       ENUM[token] name_token {
 937         $name_token->type = PSI_T_NAME;
 938         $type = psi_decl_type_init($token->type, $name_token->text);
 939         $type->token = psi_token_copy($name_token);
 940 }
 941 ;
 942
 943 decl_type_simple[type]:
 944         decl_int_type
 945 |       decl_real_type
 946 |       NAME[type_] {
 947         $type = psi_token_copy($type_);
 948 }
 949 |       VOID[type_] {
 950         $type = psi_token_copy($type_);
 951 }
 952 ;
 953
 954 decl_real_type[type]:
 955         FLOAT[type_] {
 956         $type = psi_token_copy($type_);
 957 }
 958 |       DOUBLE[type_] {
 959         $type = psi_token_copy($type_);
 960 }
 961 |       LONG DOUBLE {
 962         $type = psi_token_cat(" ", 2, $LONG, $DOUBLE);
 963 }
 964 ;
 965
 966 int_signed[i]:
 967         SIGNED
 968 |       UNSIGNED
 969 ;
 970
 971 int_width[i]:
 972         SHORT {
 973         $i = psi_token_copy($SHORT);
 974 }
 975 |       LONG {
 976         $i = psi_token_copy($LONG);
 977 }
 978 |       LONG[l1] LONG[l2] {
 979         $i = psi_token_cat(" ", 2, $l1, $l2);
 980 }
 981 ;
 982
 983 decl_int_type[type]:
 984         CHAR {
 985         $type = psi_token_copy($CHAR);
 986 }
 987 |       INT {
 988         $type = psi_token_copy($INT);
 989 }
 990 |       int_signed int_signed_types {
 991         if ($2) {
 992                 $type = psi_token_cat(" ", 2, $1, $2);
 993                 free($2);
 994         } else {
 995                 $type = psi_token_copy($1);
 996         }
 997 }
 998 |       int_width int_width_types {
 999         if ($2) {
1000                 $type = psi_token_cat(" ", 2, $1, $2);
1001                 free($1);
1002                 free($2);
1003         } else {
1004                 $type = $1;
1005         }
1006 }
1007 ;
1008
1009 int_signed_types[type]:
1010         %empty {
1011         $type = NULL;
1012 }
1013 |       NAME {
1014         $type = psi_token_copy($NAME);
1015 }
1016 |       CHAR {
1017         $type = psi_token_copy($CHAR);
1018 }
1019 |       SHORT signed_short_types {
1020         if ($2) {
1021                 $type = psi_token_cat(" ", 2, $1, $2);
1022         } else {
1023                 $type = psi_token_copy($1);
1024         }
1025 }
1026 |       INT {
1027         $type = psi_token_copy($INT);
1028 }
1029 |       LONG signed_long_types {
1030         if ($2) {
1031                 $type = psi_token_cat(" ", 2, $1, $2);
1032         } else {
1033                 $type = psi_token_copy($1);
1034         }
1035 }
1036 ;
1037
1038 signed_short_types[type]:
1039         %empty {
1040         $type = NULL;
1041 }
1042 |       INT
1043 ;
1044 signed_long_types[type]:
1045         %empty {
1046         $type = NULL;
1047 }
1048 |       INT
1049 |       LONG
1050 |       LONG INT
1051 ;
1052
1053 int_width_types[type]:
1054         %empty {
1055         $type = NULL;
1056 }
1057 |       INT {
1058         $type = psi_token_copy($INT);
1059 }
1060 |       int_signed int_signed_types {
1061         if ($2) {
1062                 $type = psi_token_cat(" ", 2, $1, $2);
1063                 free($2);
1064         } else {
1065                 $type = psi_token_copy($1);
1066         }
1067 }
1068 ;
1069
1070 decl_stmt:
1071         decl decl_asm EOS {
1072         $decl_stmt = $decl;
1073         if ($decl_asm) {
1074                 $decl->redir = strdup($decl_asm->text);
1075                 free($decl_asm);
1076         }
1077 }
1078 |       CPP_EXTENSION decl decl_asm EOS {
1079         $decl_stmt = $decl;
1080         if ($decl_asm) {
1081                 $decl->redir = strdup($decl_asm->text);
1082                 free($decl_asm);
1083         }
1084 }
1085 ;
1086
1087 decl_asm:
1088         %empty {
1089         $decl_asm = NULL;
1090 }
1091 |       CPP_ASM LPAREN quoted_strings RPAREN {
1092         $decl_asm = $quoted_strings;
1093 }
1094 ;
1095
1096 quoted_strings[strings]:
1097         QUOTED_STRING {
1098         $strings = psi_token_copy($QUOTED_STRING);
1099 }
1100 |       quoted_strings[strings_] QUOTED_STRING {
1101         $strings = psi_token_cat("", 2, $strings_, $QUOTED_STRING);
1102         free($strings_);
1103 }
1104 ;
1105
1106 decl_extvar_stmt[list]:
1107         NAME decl_arg decl_extvar_list[vars] EOS {
1108         struct psi_plist *list = psi_plist_init((psi_plist_dtor) psi_decl_extvar_free);
1109
1110         if ($vars) {
1111                 size_t i = 0;
1112                 struct psi_decl_var *var;
1113
1114                 while (psi_plist_get($vars, i++, &var)) {
1115                         if (psi_decl_extvar_is_blacklisted(var->name)) {
1116                                 psi_decl_var_free(&var);
1117                         } else {
1118                                 list = psi_plist_add(list, psi_decl_extvar_init(
1119                                         psi_decl_arg_init(psi_decl_type_copy($decl_arg->type), var)));
1120                                 }
1121                 }
1122                 free($vars);
1123         }
1124
1125         if (psi_decl_extvar_is_blacklisted($decl_arg->var->name)) {
1126                 psi_decl_arg_free(&$decl_arg);
1127         } else {
1128                 struct psi_decl_extvar *evar = psi_decl_extvar_init($decl_arg);
1129                 list = psi_plist_add(list, &evar);
1130         }
1131
1132         $list = list;
1133 }
1134 ;
1135
1136 decl_extvar_list[list]:
1137         %empty {
1138         $list = NULL;
1139 }
1140 |       COMMA decl_vars {
1141         $list = $decl_vars;
1142 }
1143 ;
1144
1145 decl_vars[vars]:
1146         decl_var[var] {
1147         $vars = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_var_free), &$var);
1148 }
1149 |       decl_vars[vars_] COMMA decl_var[var] {
1150         $vars = psi_plist_add($vars_, &$var);
1151 }
1152 ;
1153
1154 ignored_decl:
1155         STATIC decl_body ignored_decl_body {
1156         $ignored_decl = $decl_body;
1157 }
1158 |       STATIC CPP_INLINE decl_body ignored_decl_body {
1159         $ignored_decl = $decl_body;
1160 }
1161 |       CPP_INLINE decl_body ignored_decl_body {
1162         $ignored_decl = $decl_body;
1163 }
1164 |       NAME CPP_INLINE decl_body ignored_decl_body {
1165         $ignored_decl = $decl_body;
1166 }
1167 ;
1168
1169 ignored_decl_body:
1170         LBRACE ignored_decl_body_stmts RBRACE
1171 ;
1172
1173 ignored_decl_body_stmts:
1174         ignored_decl_body_stmt
1175 |       ignored_decl_body_stmts ignored_decl_body_stmt
1176 ;
1177
1178 ignored_decl_body_stmt:
1179         any_nobrace_token
1180 |       ignored_decl_body
1181 ;
1182
1183 decl:
1184         decl_body
1185 |       NAME[abi] decl_body {
1186         $decl = $decl_body;
1187         $decl->abi = psi_decl_abi_init($abi->text);
1188 }
1189 ;
1190
1191 decl_body:
1192         decl_func_body
1193 |       decl_functor_body
1194 ;
1195
1196 decl_func_body[decl]:
1197         decl_func[func] LPAREN decl_args[args] RPAREN array_size[as] {
1198         $decl = psi_decl_init($func, $args);
1199         if ($as) {
1200                 $decl->func->var->pointer_level += 1;
1201                 $decl->func->var->array_size = $as;
1202         }
1203 }
1204 |       decl_func[func] LPAREN decl_args[args] COMMA ELLIPSIS RPAREN array_size[as] {
1205         $decl = psi_decl_init($func, $args);
1206         $decl->varargs = 1;
1207         if ($as) {
1208                 $decl->func->var->pointer_level += 1;
1209                 $decl->func->var->array_size = $as;
1210         }
1211 }
1212 ;
1213
1214 decl_functor_body[decl]:
1215         decl_functor[func] LPAREN decl_args[args] RPAREN array_size[as] {
1216         $decl = psi_decl_init($func, $args);
1217         if ($as) {
1218                 $decl->func->var->pointer_level += 1;
1219                 $decl->func->var->array_size = $as;
1220         }
1221 }
1222 |       decl_functor[func] LPAREN decl_args[args] COMMA ELLIPSIS RPAREN array_size[as] {
1223         $decl = psi_decl_init($func, $args);
1224         $decl->varargs = 1;
1225         if ($as) {
1226                 $decl->func->var->pointer_level += 1;
1227                 $decl->func->var->array_size = $as;
1228         }
1229 }
1230 |       qualified_decl_type[rval_type] indirection[i] LPAREN indirection[unused1] name_token[NAME] LPAREN decl_args[args] RPAREN RPAREN LPAREN decl_args[rval_args] RPAREN array_size[as] {
1231         (void) $unused1;
1232         $NAME->type = PSI_T_NAME;
1233
1234         struct psi_token *type_token = psi_token_append("@", psi_token_copy($NAME), 1, "rval");
1235         struct psi_decl_arg *rval_func = psi_decl_arg_init($rval_type, psi_decl_var_init(type_token->text, $i, 0));
1236         struct psi_decl *rval_decl = psi_decl_init(rval_func, $rval_args);
1237
1238         rval_func->var->token = psi_token_copy(type_token);
1239         rval_func->token = psi_token_copy(type_token);
1240         if ($as) {
1241                 rval_func->var->pointer_level += 1;
1242                 rval_func->var->array_size = $as;
1243         }
1244
1245         struct psi_decl_type *type = psi_decl_type_init(PSI_T_FUNCTION, type_token->text);
1246         struct psi_decl_arg *func = psi_decl_arg_init(type, psi_decl_var_init($NAME->text, 1, 0));
1247
1248         type->real.func = rval_decl;
1249         func->var->token = psi_token_copy($NAME);
1250         func->token = psi_token_copy($NAME);
1251
1252         $decl = psi_decl_init(func, $args);
1253 }
1254 |       qualified_decl_type[rval_type] indirection[i] LPAREN indirection[unused1] LPAREN indirection[unused2] name_token[NAME] RPAREN LPAREN decl_args[args] RPAREN RPAREN LPAREN decl_args[rval_args] RPAREN array_size[as] {
1255         (void) $unused1;
1256         (void) $unused2;
1257         $NAME->type = PSI_T_NAME;
1258
1259         struct psi_token *type_token = psi_token_append("@", psi_token_copy($NAME), 1, "rval");
1260         struct psi_decl_arg *rval_func = psi_decl_arg_init($rval_type, psi_decl_var_init(type_token->text, $i, 0));
1261         struct psi_decl *rval_decl = psi_decl_init(rval_func, $rval_args);
1262
1263         rval_func->var->token = psi_token_copy(type_token);
1264         rval_func->token = psi_token_copy(type_token);
1265         if ($as) {
1266                 rval_func->var->pointer_level += 1;
1267                 rval_func->var->array_size = $as;
1268         }
1269
1270         struct psi_decl_type *type = psi_decl_type_init(PSI_T_FUNCTION, type_token->text);
1271         struct psi_decl_arg *func = psi_decl_arg_init(type, psi_decl_var_init($NAME->text, 1, 0));
1272
1273         type->real.func = rval_decl;
1274         func->var->token = psi_token_copy($NAME);
1275         func->token = psi_token_copy($NAME);
1276
1277         $decl = psi_decl_init(func, $args);
1278 }
1279 ;
1280
1281 decl_anon_functor_body[decl]:
1282         decl_anon_functor[func] LPAREN decl_args[args] RPAREN array_size[as] {
1283         $decl = psi_decl_init($func, $args);
1284         if ($as) {
1285                 $decl->func->var->pointer_level += 1;
1286                 $decl->func->var->array_size = $as;
1287         }
1288 }
1289 |       decl_anon_functor[func] LPAREN decl_args[args] COMMA ELLIPSIS RPAREN array_size[as] {
1290         $decl = psi_decl_init($func, $args);
1291         $decl->varargs = 1;
1292         if ($as) {
1293                 $decl->func->var->pointer_level += 1;
1294                 $decl->func->var->array_size = $as;
1295         }
1296 }
1297 ;
1298
1299 decl_functor[arg]:
1300         qualified_decl_type[type] indirection[i] LPAREN indirection[unused1] name_token[NAME] RPAREN {
1301         (void) $unused1;
1302         $NAME->type = PSI_T_NAME;
1303         $arg = psi_decl_arg_init($type, psi_decl_var_init($NAME->text, $i, 0));
1304         $arg->var->token = psi_token_copy($NAME);
1305         $arg->token = psi_token_copy($NAME);
1306 }
1307
1308 /*
1309 |       CONST VOID pointers LPAREN indirection[unused1] name_token[NAME] RPAREN {
1310         (void) $unused1;
1311         $NAME->type = PSI_T_NAME;
1312         $arg = psi_decl_arg_init(
1313                 psi_decl_type_init($VOID->type, $VOID->text),
1314                 psi_decl_var_init($NAME->text, $pointers, 0)
1315         );
1316         $arg->type->token = psi_token_copy($VOID);
1317         $arg->var->token = psi_token_copy($NAME);
1318         $arg->token = psi_token_copy($NAME);
1319 }
1320 |       VOID pointers LPAREN indirection[unused1] name_token[NAME] RPAREN {
1321         (void) $unused1;
1322         $NAME->type = PSI_T_NAME;
1323         $arg = psi_decl_arg_init(
1324                 psi_decl_type_init($VOID->type, $VOID->text),
1325                 psi_decl_var_init($NAME->text, $pointers, 0)
1326         );
1327         $arg->type->token = psi_token_copy($VOID);
1328         $arg->var->token = psi_token_copy($NAME);
1329         $arg->token = psi_token_copy($NAME);
1330 }
1331 |       VOID LPAREN indirection[unused1] name_token[NAME] RPAREN {
1332         (void) $unused1;
1333         $NAME->type = PSI_T_NAME;
1334         $arg = psi_decl_arg_init(
1335                 psi_decl_type_init($VOID->type, $VOID->text),
1336                 psi_decl_var_init($NAME->text, 0, 0)
1337         );
1338         $arg->type->token = psi_token_copy($VOID);
1339         $arg->var->token = psi_token_copy($NAME);
1340         $arg->token = psi_token_copy($NAME);
1341 }
1342 */
1343 ;
1344
1345 decl_anon_functor[arg]:
1346         qualified_decl_type[type] indirection[i] LPAREN indirection[unused1] RPAREN {
1347         (void) $unused1;
1348         $arg = psi_decl_arg_init($type, psi_decl_var_init(NULL, $i, 0));
1349         $arg->var->token = psi_token_copy($LPAREN);
1350         $arg->token = psi_token_copy($LPAREN);
1351 }
1352 /*
1353 |       CONST VOID pointers LPAREN indirection[unused1] RPAREN {
1354         (void) $unused1;
1355         $arg = psi_decl_arg_init(
1356                 psi_decl_type_init($VOID->type, $VOID->text),
1357                 psi_decl_var_init(NULL, $pointers, 0)
1358         );
1359         $arg->type->token = psi_token_copy($VOID);
1360         $arg->var->token = psi_token_copy($VOID);
1361         $arg->token = psi_token_copy($VOID);
1362 }
1363 |       VOID pointers LPAREN indirection[unused1] RPAREN {
1364         (void) $unused1;
1365         $arg = psi_decl_arg_init(
1366                 psi_decl_type_init($VOID->type, $VOID->text),
1367                 psi_decl_var_init(NULL, $pointers, 0)
1368         );
1369         $arg->type->token = psi_token_copy($VOID);
1370         $arg->var->token = psi_token_copy($VOID);
1371         $arg->token = psi_token_copy($VOID);
1372 }
1373 |       VOID LPAREN indirection[unused1] RPAREN {
1374         (void) $unused1;
1375         $arg = psi_decl_arg_init(
1376                 psi_decl_type_init($VOID->type, $VOID->text),
1377                 psi_decl_var_init(NULL, 0, 0)
1378         );
1379         $arg->type->token = psi_token_copy($VOID);
1380         $arg->var->token = psi_token_copy($VOID);
1381         $arg->token = psi_token_copy($VOID);
1382 }
1383 */
1384 ;
1385
1386 decl_func[func]:
1387         decl_arg
1388         /*
1389 |       VOID name_token[NAME] {
1390         $func = psi_decl_arg_init(
1391                 psi_decl_type_init($VOID->type, $VOID->text),
1392                 psi_decl_var_init($NAME->text, 0, 0)
1393         );
1394         $func->type->token = psi_token_copy($VOID);
1395         $func->var->token = psi_token_copy($NAME);
1396         $func->token = psi_token_copy($NAME);
1397 }
1398 */
1399 ;
1400
1401 decl_args[args]:
1402         %empty {
1403         $args = NULL;
1404 }
1405 |       VOID %dprec 2 {
1406         $args = NULL;
1407 }
1408 |       decl_arg_list[args_] %dprec 1 {
1409         $args = $args_;
1410 }
1411 ;
1412
1413 decl_arg_list[args]:
1414         decl_anon_arg[arg] {
1415         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free), &$arg);
1416 }
1417 |       decl_arg_list[args_] COMMA decl_anon_arg[arg] {
1418         $args = psi_plist_add($args_, &$arg);
1419 }
1420 ;
1421
1422 decl_anon_arg[arg]:
1423         decl_anon_functor_body[decl] {
1424         char digest[17];
1425         struct psi_token *name;
1426
1427         psi_token_hash($decl->func      ->token, digest);
1428         name = psi_token_append("@", psi_token_copy($decl->func->token), 2, "funct", digest);
1429
1430         $arg = psi_decl_arg_init(
1431                 psi_decl_type_init(PSI_T_FUNCTION, name->text),
1432                 psi_decl_var_copy($decl->func->var)
1433         );
1434         $arg->token = name;
1435         $arg->type->token = psi_token_copy($decl->func->token);
1436         $arg->type->real.func = $decl;
1437 }
1438 |       decl_arg %dprec 2 {
1439         $arg = $decl_arg;
1440 }
1441 |       qualified_decl_type[type] indirection %dprec 1 {
1442         $arg = psi_decl_arg_init(
1443                 $type,
1444                 psi_decl_var_init(NULL, $indirection, 0)
1445         );
1446 }
1447 /*
1448 |       CONST VOID pointers {
1449         $arg = psi_decl_arg_init(
1450                 psi_decl_type_init($VOID->type, $VOID->text),
1451                 psi_decl_var_init(NULL, $pointers, 0)
1452         );
1453         $arg->type->token = psi_token_copy($VOID);
1454         $arg->var->token = psi_token_copy($VOID);
1455         $arg->token = psi_token_copy($VOID);
1456 }
1457 |       VOID pointers {
1458         $arg = psi_decl_arg_init(
1459                 psi_decl_type_init($VOID->type, $VOID->text),
1460                 psi_decl_var_init(NULL, $pointers, 0)
1461         );
1462         $arg->type->token = psi_token_copy($VOID);
1463         $arg->var->token = psi_token_copy($VOID);
1464         $arg->token = psi_token_copy($VOID);
1465 }
1466 */
1467 ;
1468
1469 decl_arg[arg]:
1470         decl_functor_body[decl] {
1471         $arg = psi_decl_arg_init(
1472                 psi_decl_type_init(PSI_T_FUNCTION, $decl->func->var->name),
1473                 psi_decl_var_copy($decl->func->var)
1474         );
1475         $arg->type->token = psi_token_copy($decl->func->token);
1476         $arg->type->real.func = $decl;
1477 }
1478 |       qualified_decl_type[type] decl_var[var] {
1479         $arg = psi_decl_arg_init($type, $var);
1480 }
1481 /*
1482 |       CONST VOID pointers name_token[NAME] {
1483         $NAME->type = PSI_T_NAME;
1484         $arg = psi_decl_arg_init(
1485                 psi_decl_type_init($VOID->type, $VOID->text),
1486                 psi_decl_var_init($NAME->text, $pointers, 0)
1487         );
1488         $arg->type->token = psi_token_copy($VOID);
1489         $arg->var->token = psi_token_copy($NAME);
1490         $arg->token = psi_token_copy($NAME);
1491 }
1492 |       VOID pointers name_token[NAME] {
1493         $NAME->type = PSI_T_NAME;
1494         $arg = psi_decl_arg_init(
1495                 psi_decl_type_init($VOID->type, $VOID->text),
1496                 psi_decl_var_init($NAME->text, $pointers, 0)
1497         );
1498         $arg->type->token = psi_token_copy($VOID);
1499         $arg->var->token = psi_token_copy($NAME);
1500         $arg->token = psi_token_copy($NAME);
1501 }
1502 */
1503 ;
1504
1505 decl_var[var]:
1506         pointers name_token array_size {
1507         $name_token->type = PSI_T_NAME;
1508         $var = psi_decl_var_init($name_token->text, $pointers + !! $array_size, $array_size);
1509         $var->token = psi_token_copy($name_token);
1510 }
1511 |       name_token array_size {
1512         $name_token->type = PSI_T_NAME;
1513         $var = psi_decl_var_init($name_token->text, !! $array_size, $array_size);
1514         $var->token = psi_token_copy($name_token);
1515 }
1516 ;
1517
1518 decl_union[union]:
1519         UNION name_token align_and_size[as] decl_struct_args[args] {
1520         $name_token->type = PSI_T_NAME;
1521         $union = psi_decl_union_init($name_token->text, $args);
1522         $union->align = $as.pos;
1523         $union->size = $as.len;
1524         $union->token = psi_token_copy($name_token);
1525 }
1526 ;
1527
1528 decl_struct[struct]:
1529         STRUCT name_token align_and_size[as] decl_struct_args[args] {
1530         $name_token->type = PSI_T_NAME;
1531         $struct = psi_decl_struct_init($name_token->text, $args);
1532         $struct->align = $as.pos;
1533         $struct->size = $as.len;
1534         $struct->token = psi_token_copy($name_token);
1535 }
1536 ;
1537
1538 decl_struct_args[args]:
1539         EOS {
1540         $args = NULL;
1541 }
1542 |       struct_args_block
1543 ;
1544
1545 struct_args_block[args]:
1546         LBRACE struct_args RBRACE {
1547         $args = $struct_args;
1548 }
1549 ;
1550
1551 struct_args[args]:
1552         typedef_anon[arg] decl_layout[layout] struct_arg_var_list[vars] EOS {
1553         $arg->layout = $layout;
1554         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free), &$arg);
1555         if ($vars) {
1556                 size_t i = 0;
1557                 struct psi_decl_arg *arg;
1558
1559                 while (psi_plist_get($vars, i++, &arg)) {
1560                         arg->type = psi_decl_type_copy($arg->type);
1561                         $args = psi_plist_add($args, &arg);
1562                 }
1563                 free($vars);
1564         }
1565 }
1566 |       struct_args[args_] typedef_anon[arg] decl_layout[layout] struct_arg_var_list[vars] EOS {
1567         $arg->layout = $layout;
1568         $args = psi_plist_add($args_, &$arg);
1569         if ($vars) {
1570                 size_t i = 0;
1571                 struct psi_decl_arg *arg;
1572
1573                 while (psi_plist_get($vars, i++, &arg)) {
1574                         arg->type = psi_decl_type_copy($arg->type);
1575                         $args = psi_plist_add($args, &arg);
1576                 }
1577                 free($vars);
1578         }
1579 }
1580 ;
1581
1582 struct_arg_var_list[vars]:
1583         %empty {
1584         $vars = NULL;
1585 }
1586 |       COMMA decl_vars_with_layout[vars_] {
1587         $vars = $vars_;
1588 }
1589 ;
1590
1591 decl_vars_with_layout[vars]:
1592         decl_var[var] decl_layout[layout] {
1593         {
1594                 struct psi_decl_arg *arg = psi_decl_arg_init(NULL, $var);
1595                 arg->layout = $layout;
1596                 $vars = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free), &arg);
1597         }
1598 }
1599 |       decl_vars_with_layout[vars_] COMMA decl_var[var] decl_layout[layout] {
1600         {
1601                 struct psi_decl_arg *arg = psi_decl_arg_init(NULL, $var);
1602                 arg->layout = $layout;
1603                 $vars = psi_plist_add($vars_, &arg);
1604         }
1605 }
1606 ;
1607
1608 decl_enum[enum]:
1609         enum_name LBRACE decl_enum_items[list] optional_comma RBRACE {
1610         $enum = psi_decl_enum_init($enum_name->text, $list);
1611         $enum->token = $enum_name;
1612 }
1613 ;
1614
1615 decl_enum_items[list]:
1616         decl_enum_item[i] {
1617         $list = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_enum_item_free), &$i);
1618 }
1619 |       decl_enum_items[list_] COMMA decl_enum_item[i] {
1620         $list = psi_plist_add($list_, &$i);
1621 }
1622 ;
1623
1624 decl_enum_item[i]:
1625         name_token {
1626         $name_token->type = PSI_T_NAME;
1627         $i = psi_decl_enum_item_init($name_token->text, NULL);
1628         $i->token = psi_token_copy($name_token);
1629 }
1630 |       name_token EQUALS num_exp {
1631         $name_token->type = PSI_T_NAME;
1632         $i = psi_decl_enum_item_init($name_token->text, $num_exp);
1633         $i->token = psi_token_copy($name_token);
1634 }
1635 ;
1636
1637 num_exp[exp]:
1638         number {
1639         $exp = psi_num_exp_init_num($number);
1640         $exp->token = psi_token_copy($number->token);
1641 }
1642 |       LPAREN qualified_decl_type[type] RPAREN num_exp[exp_] %prec UNARY {
1643         $exp = psi_num_exp_init_cast($type, $exp_);
1644         $exp->token = psi_token_copy($type->token);
1645 }
1646 |       LPAREN num_exp[exp_] RPAREN {
1647         $exp = psi_num_exp_init_unary(PSI_T_LPAREN, $exp_);
1648         $exp->token = psi_token_copy($LPAREN);
1649 }
1650 |       num_exp[lhs] binary_op_token[op] num_exp[rhs] %prec BINARY {
1651         $exp = psi_num_exp_init_binary($op->type, $lhs, $rhs);
1652         $exp->token = psi_token_copy($op);
1653 }
1654 |       unary_op_token[op] num_exp[exp_] %prec UNARY {
1655         $exp = psi_num_exp_init_unary($op->type, $exp_);
1656         $exp->token = psi_token_copy($op);
1657 }
1658 |       num_exp[cond] IIF num_exp[truthy] COLON num_exp[falsy] {
1659         $exp = psi_num_exp_init_ternary($IIF->type, $cond, $truthy, $falsy);
1660         $exp->token = psi_token_copy($IIF);
1661 }
1662 ;
1663
1664 number[num]:
1665         NUMBER[token] {
1666         $num = psi_number_init($token->type, $token->text, $token->flags);
1667         $num->token = psi_token_copy($token);
1668 }
1669 |       NSNAME[token] {
1670         $num = psi_number_init($token->type, $token->text, 0);
1671         $num->token = psi_token_copy($token);
1672 }
1673 |       QUOTED_CHAR[token] {
1674         $num = psi_number_init($token->type, $token->text, 0);
1675         $num->token = psi_token_copy($token);
1676 }
1677 |       NULL[token] {
1678         $num = psi_number_init($token->type, $token->text, 0);
1679         $num->token = psi_token_copy($token);
1680 }
1681 |       decl_var {
1682         $num = psi_number_init(PSI_T_NAME, $decl_var, 0);
1683         $num->token = psi_token_copy($decl_var->token);
1684 }
1685 |       sizeof {
1686         $num = $sizeof;
1687 }
1688 ;
1689
1690 sizeof:
1691         SIZEOF LPAREN sizeof_body[sizeof_] RPAREN {
1692         $sizeof = $sizeof_;
1693         $sizeof->token = psi_token_copy($SIZEOF);
1694 }
1695 |       SIZEOF sizeof_body_notypes[sizeof_] {
1696         $sizeof = $sizeof_;
1697         $sizeof->token = psi_token_copy($SIZEOF);
1698 }
1699 ;
1700
1701 sizeof_body[sizeof]:
1702         sizeof_body_notypes[sizeof_] {
1703         $sizeof = $sizeof_;
1704 }
1705 |       decl_type indirection {
1706         if ($indirection) {
1707                 int8_t sizeof_void_p = sizeof(void *);
1708                 $sizeof = psi_number_init(PSI_T_INT8, &sizeof_void_p, 0);
1709                 psi_decl_type_free(&$decl_type);
1710         } else {
1711                 $sizeof = psi_number_init(PSI_T_SIZEOF, $decl_type, 0);
1712         }
1713 }
1714 ;
1715
1716 sizeof_body_notypes[sizeof]:
1717         AMPERSAND NAME {
1718         int8_t sizeof_void_p = sizeof(void *);
1719         $sizeof = psi_number_init(PSI_T_INT8, &sizeof_void_p, 0);
1720 }
1721 |       QUOTED_CHAR {
1722         int8_t sizeof_a = sizeof('a');
1723         $sizeof = psi_number_init(PSI_T_INT8, &sizeof_a, 0);
1724 }
1725 |       QUOTED_STRING {
1726         uint64_t len = $QUOTED_STRING->size + 1;
1727         $sizeof = psi_number_init(PSI_T_UINT64, &len, 0);
1728 }
1729 ;
1730
1731 enum_name[name]:
1732         ENUM optional_name[name_] {
1733         if ($name_) {
1734                 $name = psi_token_copy($name_);
1735         } else {
1736                 char digest[17];
1737
1738                 psi_token_hash($ENUM, digest);
1739                 $name = psi_token_append("@", psi_token_copy($ENUM), 1, digest);
1740         }
1741 }
1742 ;
1743
1744 union_name[name]:
1745         UNION optional_name[name_] {
1746         if ($name_) {
1747                 $name = psi_token_copy($name_);
1748         } else {
1749                 char digest[17];
1750
1751                 psi_token_hash($UNION, digest);
1752                 $name = psi_token_append("@", psi_token_copy($UNION), 1, digest);
1753         }
1754 }
1755 ;
1756
1757 struct_name[name]:
1758         STRUCT optional_name[name_] {
1759         if ($name_) {
1760                 $name = psi_token_copy($name_);
1761         } else {
1762                 char digest[17];
1763
1764                 psi_token_hash($STRUCT, digest);
1765                 $name = psi_token_append("@", psi_token_copy($STRUCT), 1, digest);
1766         }
1767 }
1768 ;
1769
1770 optional_name[name]:
1771         %empty {
1772         $name = NULL;
1773 }
1774 |       name_token {
1775         $name = $name_token;
1776         $name->type = PSI_T_NAME;
1777 }
1778 ;
1779
1780 optional_comma:
1781         %empty
1782 |       COMMA
1783 ;
1784
1785 decl_layout[l]:
1786         %empty {
1787         $l = NULL;
1788 }
1789 |       COLON NUMBER[width] {
1790         $l = psi_layout_init(0, 0, psi_layout_init(0, atol($width->text), NULL));
1791 }
1792 |       COLON COLON LPAREN NUMBER[align] COMMA NUMBER[size] RPAREN {
1793         $l = psi_layout_init(atol($align->text), atol($size->text), NULL);
1794 }
1795 |       COLON NUMBER[width] COLON COLON LPAREN NUMBER[align] COMMA NUMBER[size] RPAREN {
1796         $l = psi_layout_init(atol($align->text), atol($size->text), psi_layout_init(0, atol($width->text), NULL));
1797 }
1798 ;
1799
1800 align_and_size[as]:
1801         %empty {
1802         $as.pos = 0;
1803         $as.len = 0;
1804 }
1805 |       COLON COLON LPAREN NUMBER[align] COMMA NUMBER[size] RPAREN {
1806         $as.pos = atol($align->text);
1807         $as.len = atol($size->text);
1808 }
1809 ;
1810
1811 array_size[as]:
1812         %empty {
1813         $as = 0;
1814 }
1815 |       LBRACKET array_qualifier_token RBRACKET {
1816         $as = 0;
1817 }
1818 |       LBRACKET num_exp RBRACKET {
1819         struct psi_validate_scope scope = {0};
1820         psi_validate_scope_ctor(&scope);
1821         scope.defs = &P->preproc->defs;
1822         if (psi_num_exp_validate(PSI_DATA(P), $num_exp, &scope)) {
1823                 $as = psi_num_exp_get_long($num_exp, NULL, &P->preproc->defs);
1824         } else {
1825                 $as = 0;
1826         }
1827         psi_num_exp_free(&$num_exp);
1828         psi_validate_scope_dtor(&scope);
1829 }
1830 ;
1831
1832 array_qualifier_token:
1833         %empty
1834 |       CPP_RESTRICT
1835 |       VOLATILE
1836 |       CONST
1837 ;
1838
1839 indirection[i]:
1840         %empty {
1841         $i = 0;
1842 }
1843 |       pointers[p] %prec UNARY {
1844         $i = $p;
1845 }
1846 ;
1847
1848 pointers[p]:
1849         asterisks
1850 |       asterisks[a] CPP_RESTRICT {
1851         $p = $a;
1852 }
1853 ;
1854
1855 asterisks[a]:
1856         asterisk {
1857         $a = 1;
1858 }
1859 |       asterisks[a_] asterisk {
1860         $a = $a_ + 1;
1861 }
1862 ;
1863
1864 asterisk:
1865         ASTERISK
1866 |       ASTERISK pointer_qualifier_token
1867 ;
1868
1869 pointer_qualifier_token:
1870         CONST
1871 |       VOLATILE
1872 ;
1873
1874 /*
1875  *
1876  * impl
1877  *
1878  */
1879
1880 impl:
1881         impl_func[func] LBRACE impl_stmts[stmts] RBRACE {
1882         $impl = psi_impl_init($func, $stmts);
1883 }
1884 |       STATIC impl_func[func] LBRACE impl_stmts[stmts] RBRACE {
1885         $impl = psi_impl_init($func, $stmts);
1886         $func->static_memory = 1;
1887 }
1888 ;
1889
1890 impl_func[func]:
1891         FUNCTION reference[r] NSNAME LPAREN RPAREN COLON impl_type[type] {
1892         $func = psi_impl_func_init($NSNAME->text, NULL, $type);
1893         $func->token = psi_token_copy($NSNAME);
1894         $func->return_reference = $r;
1895 }
1896 |       FUNCTION reference[r] NSNAME LPAREN impl_args[args] RPAREN COLON impl_type[type] {
1897         $func = psi_impl_func_init($NSNAME->text, $args, $type);
1898         $func->token = psi_token_copy($NSNAME);
1899         $func->return_reference = $r;
1900 }
1901 |       FUNCTION reference[r] NSNAME LPAREN impl_args[args] COMMA impl_type[va_type] reference[va_r] ELLIPSIS DOLLAR_NAME RPAREN COLON impl_type[type] {
1902         $func = psi_impl_func_init($NSNAME->text, $args, $type);
1903         $func->token = psi_token_copy($NSNAME);
1904         $func->return_reference = $r;
1905         $func->vararg = psi_impl_arg_init($va_type, psi_impl_var_init($DOLLAR_NAME->text, $va_r), NULL);
1906         $func->vararg->var->token = psi_token_copy($DOLLAR_NAME);
1907 }
1908 ;
1909
1910 impl_args[args]:
1911         impl_arg[arg] {
1912         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_arg_free), &$arg);
1913 }
1914 |       impl_args[args_] COMMA impl_arg[arg] {
1915         $args = psi_plist_add($args_, &$arg);
1916 }
1917 ;
1918
1919 impl_arg[arg]:
1920         impl_type[type] impl_var[var] {
1921         $arg = psi_impl_arg_init($type, $var, NULL);
1922 }
1923 |       impl_type[type] impl_var[var] EQUALS impl_def_val[val] {
1924         $arg = psi_impl_arg_init($type, $var, $val);
1925 }
1926 ;
1927
1928 impl_var[var]:
1929         reference DOLLAR_NAME {
1930         $var = psi_impl_var_init($DOLLAR_NAME->text, $reference);
1931         $var->token = psi_token_copy($DOLLAR_NAME);
1932 }
1933 ;
1934
1935 impl_type[type]:
1936         impl_type_token[token] {
1937         $type = psi_impl_type_init($token->type, $token->text);
1938         $type->token = psi_token_copy($token);
1939 }
1940 ;
1941
1942 impl_type_restricted[type]:
1943         impl_type_restricted_token[token] {
1944         $type = psi_impl_type_init($token->type, $token->text);
1945         $type->token = psi_token_copy($token);
1946 }
1947 ;
1948
1949 impl_type_token:
1950         impl_type_restricted_token
1951 |       impl_type_extended_token
1952 ;
1953
1954 impl_type_restricted_token:
1955         BOOL
1956 |       INT
1957 |       FLOAT
1958 |       STRING
1959 ;
1960
1961 impl_type_extended_token:
1962         VOID
1963 |       MIXED
1964 |       ARRAY
1965 |       OBJECT
1966 |       CALLABLE
1967 ;
1968
1969 impl_stmts[stmts]:
1970         impl_stmt[stmt] {
1971         $stmts = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_stmt_free), &$stmt);
1972 }
1973 |       impl_stmts[stmts_] impl_stmt[stmt] {
1974         $stmts = psi_plist_add($stmts_, &$stmt);
1975 }
1976 ;
1977
1978 impl_stmt[stmt]:
1979         return_stmt[s] {
1980         $stmt = (struct psi_token **) $s;
1981 }
1982 |       let_stmt[s] {
1983         $stmt = (struct psi_token **) $s;
1984 }
1985 |       set_stmt[s] {
1986         $stmt = (struct psi_token **) $s;
1987 }
1988 |       assert_stmt[s] {
1989         $stmt = (struct psi_token **) $s;
1990 }
1991 |       free_stmt[s] {
1992         $stmt = (struct psi_token **) $s;
1993 }
1994 ;
1995
1996 let_stmt[let]:
1997         LET let_exp_assign[exp] EOS {
1998         $let = psi_let_stmt_init($exp);
1999         $let->token = psi_token_copy($LET);
2000 }
2001 |       TEMP decl_var[var] EQUALS reference decl_var[val] EOS {
2002         $let = psi_let_stmt_init(psi_let_exp_init_ex($var, PSI_LET_TMP, $val));
2003         $let->token = psi_token_copy($TEMP);
2004         $let->exp->is_reference = $reference;
2005 }
2006 ;
2007
2008 let_exp[exp]:
2009         let_exp_assign
2010 |       byref let_exp_byref[exp_] {
2011         $exp = $exp_;
2012         $exp->is_reference = true;
2013 }
2014 |       let_exp_byref[exp_] {
2015         $exp = $exp_;
2016         $exp->is_reference = false;
2017 }
2018 ;
2019
2020 let_exp_byref[exp]:
2021         NULL %dprec 2 {
2022         $exp = psi_let_exp_init(PSI_LET_NULL, NULL);
2023 }
2024 |       num_exp[num] %dprec 1 {
2025         $exp = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, $num);
2026 }
2027 |       let_calloc[calloc] {
2028         $exp = psi_let_exp_init(PSI_LET_CALLOC, $calloc);
2029 }
2030 |       STATIC let_calloc[calloc] {
2031         $exp = psi_let_exp_init(PSI_LET_CALLOC, $calloc);
2032         $calloc->static_memory = 1;
2033 }
2034 |       let_callback[callback] {
2035         $exp = psi_let_exp_init(PSI_LET_CALLBACK, $callback);
2036 }
2037 |       let_func[func] {
2038         $exp = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, $func);
2039 }
2040 ;
2041
2042 let_exp_assign[exp]:
2043         decl_var[var] EQUALS let_exp_byref[exp_] {
2044         $exp = $exp_;
2045         $exp->var = $var;
2046 }
2047 |       decl_var[var] EQUALS byref let_exp_byref[exp_] {
2048         $exp = $exp_;
2049         $exp->is_reference = 1;
2050         $exp->var = $var;
2051 }
2052 ;
2053
2054 let_calloc[calloc]:
2055         CALLOC LPAREN num_exp[nmemb] COMMA num_exp[size] RPAREN {
2056         $calloc = psi_let_calloc_init($nmemb, $size);
2057         $calloc->token = psi_token_copy($CALLOC);
2058 }
2059 ;
2060
2061 let_callback[callback]:
2062         CALLBACK callback_rval[func] LPAREN impl_var[var] LPAREN callback_arg_list[args] RPAREN RPAREN {
2063         $callback = psi_let_callback_init(psi_let_func_init($func->type, $func->text, $var), $args, NULL);
2064         $callback->func->token = psi_token_copy($func);
2065         $callback->token = psi_token_copy($CALLBACK);
2066 }
2067 |       CALLBACK LPAREN call_decl_vars[cb_args] RPAREN AS callback_rval[func] LPAREN impl_var[var] LPAREN callback_arg_list[args] RPAREN RPAREN {
2068         $callback = psi_let_callback_init(psi_let_func_init($func->type, $func->text, $var), $args, $cb_args);
2069         $callback->func->token = psi_token_copy($func);
2070         $callback->token = psi_token_copy($CALLBACK);
2071 }
2072 ;
2073
2074 let_func[func]:
2075         let_func_token[token] LPAREN impl_var[var] let_func_exps[exps] RPAREN {
2076         $func = psi_let_func_init($token->type, $token->text, $var);
2077         $func->token = psi_token_copy($token);
2078         $func->inner = $exps;
2079 }
2080 ;
2081
2082 let_func_token:
2083         ZVAL
2084 |       OBJVAL
2085 |       ARRVAL
2086 |       PATHVAL
2087 |       STRLEN
2088 |       STRVAL
2089 |       FLOATVAL
2090 |       INTVAL
2091 |       BOOLVAL
2092 |       COUNT
2093 ;
2094
2095 let_func_exps[exps]:
2096         %empty {
2097         $exps = NULL;
2098 }
2099 |       COMMA let_exps[exps_] {
2100         $exps = $exps_;
2101 }
2102 ;
2103
2104 let_exps[exps]:
2105         let_exp[exp] {
2106         $exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_let_exp_free), &$exp);
2107 }
2108 |       let_exps[exps_] COMMA let_exp[exp] {
2109         $exps = psi_plist_add($exps_, &$exp);
2110 }
2111 ;
2112
2113 callback_rval[rval]:
2114         VOID
2115 |       let_func_token
2116 ;
2117
2118 callback_arg_list[list]:
2119         %empty {
2120         $list = NULL;
2121 }
2122 |       callback_args[args] {
2123         $list = $args;
2124 }
2125 ;
2126
2127 callback_args[args]:
2128         set_exp[exp] {
2129         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free), &$exp);
2130 }
2131 |       callback_args[args_] COMMA set_exp[exp] {
2132         $args = psi_plist_add($args_, &$exp);
2133 }
2134 ;
2135
2136 return_stmt[return]:
2137         RETURN return_exp EOS {
2138         $return = psi_return_stmt_init($return_exp);
2139         $return->token = psi_token_copy($RETURN);
2140 }
2141 ;
2142
2143 return_exp:
2144         decl_var[func] LPAREN call_decl_vars[args] RPAREN AS set_func {
2145         $return_exp = psi_return_exp_init($func, $args, psi_set_exp_init(PSI_SET_FUNC, $set_func));
2146         $return_exp->token = psi_token_copy($func->token);
2147 }
2148 |       set_func {
2149         $return_exp = psi_return_exp_init(NULL, NULL, psi_set_exp_init(PSI_SET_FUNC, $set_func));
2150         $return_exp->token = psi_token_copy($set_func->token);
2151 }
2152 ;
2153
2154 call_decl_vars[args]:
2155         %empty {
2156         $args = NULL;
2157 }
2158 |       VOID {
2159         $args = NULL;
2160 }
2161 |       decl_vars[vars] {
2162         $args = $vars;
2163 }
2164 ;
2165
2166 set_stmt[set]:
2167         SET set_exp[exp] EOS {
2168         $set = psi_set_stmt_init($exp);
2169         $set->token = psi_token_copy($SET);
2170 }
2171 ;
2172
2173 set_exp[exp]:
2174         set_func[func] {
2175         $exp = psi_set_exp_init(PSI_SET_FUNC, $func);
2176 }
2177 |       num_exp[num] {
2178         $exp = psi_set_exp_init(PSI_SET_NUMEXP, $num);
2179 }
2180 |       impl_var[var] EQUALS set_exp[exp_] {
2181         $exp = $exp_;
2182         $exp->var = $var;
2183 }
2184 ;
2185
2186 set_func[func]:
2187         set_func_token[token] LPAREN decl_var[var] set_func_exps[exps] RPAREN {
2188         $func = psi_set_func_init($token->type, $token->text, $var);
2189         $func->token = psi_token_copy($token);
2190         $func->inner = $exps;
2191 }
2192 |       set_func_token[token] LPAREN decl_var[var] COMMA ELLIPSIS RPAREN {
2193         $func = psi_set_func_init($token->type, $token->text, $var);
2194         $func->token = psi_token_copy($token);
2195         $func->recursive = 1;
2196 }
2197 ;
2198
2199 set_func_token:
2200         TO_OBJECT
2201 |       TO_ARRAY
2202 |       TO_STRING
2203 |       TO_INT
2204 |       TO_FLOAT
2205 |       TO_BOOL
2206 |       ZVAL
2207 |       VOID
2208 ;
2209
2210 set_func_exps[exps]:
2211         %empty {
2212         $exps = NULL;
2213 }
2214 |       COMMA set_exps[exps_] {
2215         $exps = $exps_;
2216 }
2217 ;
2218
2219 set_exps[exps]:
2220         set_exp[exp] {
2221         $exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free), &$exp);
2222 }
2223 |       set_exps[exps_] COMMA set_exp[exp] {
2224         $exps = psi_plist_add($exps_, &$exp);
2225 }
2226 ;
2227
2228 assert_stmt[assert]:
2229         assert_stmt_token[token] num_exp[exp] EOS {
2230         $assert = psi_assert_stmt_init((enum psi_assert_kind) $token->type, $exp);
2231         $assert->token = psi_token_copy($token);
2232 }
2233 ;
2234
2235 assert_stmt_token:
2236         PRE_ASSERT
2237 |       POST_ASSERT
2238 ;
2239
2240 free_stmt[free]:
2241         FREE free_exps[exps] EOS {
2242         $free = psi_free_stmt_init($exps);
2243         $free->token = psi_token_copy($FREE);
2244 }
2245 ;
2246
2247 free_exps[exps]:
2248         free_exp[exp] {
2249         $exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_free_exp_free), &$exp);
2250 }
2251 |       free_exps[exps_] COMMA free_exp[exp] {
2252         $exps = psi_plist_add($exps_, &$exp);
2253 }
2254 ;
2255
2256 free_exp[exp]:
2257         name_token[NAME] LPAREN decl_vars[vars] RPAREN {
2258         $NAME->type = PSI_T_NAME;
2259         $exp = psi_free_exp_init($NAME->text, $vars);
2260         $exp->token = psi_token_copy($NAME);
2261 }
2262 ;
2263
2264 reference:
2265         %empty {
2266         $reference = false;
2267 }
2268 |       byref {
2269         $reference = true;
2270 }
2271 ;
2272
2273 byref:
2274         AMPERSAND %prec UNARY
2275 ;
2276
2277 %%
2278
2279 /* epilogue */
2280
2281 static int psi_parser_proc_lex(YYSTYPE *lvalp, struct psi_parser *P, struct psi_plist *tokens, size_t *index)
2282 {
2283         struct psi_token *token;
2284
2285         if (psi_plist_get(tokens, (*index)++, &token)) {
2286                 if (P->flags & PSI_DEBUG) {
2287                         psi_token_dump(2, token);
2288                 }
2289
2290                 *((struct psi_token **)lvalp) = token;
2291                 return token->type;
2292         } else {
2293                 (*index)--;
2294                 PSI_DEBUG_PRINT(P, "EOF(%d)\n", PSI_T_EOF);
2295         }
2296
2297         return PSI_T_EOF;
2298 }
2299
2300 static void psi_parser_proc_error(struct psi_parser *P, struct psi_plist *tokens, size_t *index, const char *msg)
2301 {
2302         struct psi_token *T = NULL;
2303         size_t last;
2304
2305         if (*index == 0) {
2306                 last = 0;
2307         } else {
2308                 last = --(*index);
2309         }
2310
2311         psi_plist_get(tokens, last, &T);
2312         if (T) {
2313                 P->error(PSI_DATA(P), T, PSI_WARNING, "PSI %s at col %u", msg, T->col);
2314         } else {
2315                 P->error(PSI_DATA(P), NULL, PSI_WARNING, "PSI %s", msg);
2316         }
2317         P->errors++;
2318 }
2319