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 }
1255 ;
1256
1257 decl_anon_functor_body[decl]:
1258         decl_anon_functor[func] LPAREN decl_args[args] RPAREN array_size[as] {
1259         $decl = psi_decl_init($func, $args);
1260         if ($as) {
1261                 $decl->func->var->pointer_level += 1;
1262                 $decl->func->var->array_size = $as;
1263         }
1264 }
1265 |       decl_anon_functor[func] LPAREN decl_args[args] COMMA ELLIPSIS RPAREN array_size[as] {
1266         $decl = psi_decl_init($func, $args);
1267         $decl->varargs = 1;
1268         if ($as) {
1269                 $decl->func->var->pointer_level += 1;
1270                 $decl->func->var->array_size = $as;
1271         }
1272 }
1273 ;
1274
1275 decl_functor[arg]:
1276         qualified_decl_type[type] indirection[i] LPAREN indirection[unused1] name_token[NAME] RPAREN {
1277         (void) $unused1;
1278         $NAME->type = PSI_T_NAME;
1279         $arg = psi_decl_arg_init($type, psi_decl_var_init($NAME->text, $i, 0));
1280         $arg->var->token = psi_token_copy($NAME);
1281         $arg->token = psi_token_copy($NAME);
1282 }
1283
1284 /*
1285 |       CONST VOID pointers LPAREN indirection[unused1] name_token[NAME] RPAREN {
1286         (void) $unused1;
1287         $NAME->type = PSI_T_NAME;
1288         $arg = psi_decl_arg_init(
1289                 psi_decl_type_init($VOID->type, $VOID->text),
1290                 psi_decl_var_init($NAME->text, $pointers, 0)
1291         );
1292         $arg->type->token = psi_token_copy($VOID);
1293         $arg->var->token = psi_token_copy($NAME);
1294         $arg->token = psi_token_copy($NAME);
1295 }
1296 |       VOID pointers LPAREN indirection[unused1] name_token[NAME] RPAREN {
1297         (void) $unused1;
1298         $NAME->type = PSI_T_NAME;
1299         $arg = psi_decl_arg_init(
1300                 psi_decl_type_init($VOID->type, $VOID->text),
1301                 psi_decl_var_init($NAME->text, $pointers, 0)
1302         );
1303         $arg->type->token = psi_token_copy($VOID);
1304         $arg->var->token = psi_token_copy($NAME);
1305         $arg->token = psi_token_copy($NAME);
1306 }
1307 |       VOID LPAREN indirection[unused1] name_token[NAME] RPAREN {
1308         (void) $unused1;
1309         $NAME->type = PSI_T_NAME;
1310         $arg = psi_decl_arg_init(
1311                 psi_decl_type_init($VOID->type, $VOID->text),
1312                 psi_decl_var_init($NAME->text, 0, 0)
1313         );
1314         $arg->type->token = psi_token_copy($VOID);
1315         $arg->var->token = psi_token_copy($NAME);
1316         $arg->token = psi_token_copy($NAME);
1317 }
1318 */
1319 ;
1320
1321 decl_anon_functor[arg]:
1322         qualified_decl_type[type] indirection[i] LPAREN indirection[unused1] RPAREN {
1323         (void) $unused1;
1324         $arg = psi_decl_arg_init($type, psi_decl_var_init(NULL, $i, 0));
1325         $arg->var->token = psi_token_copy($LPAREN);
1326         $arg->token = psi_token_copy($LPAREN);
1327 }
1328 /*
1329 |       CONST VOID pointers LPAREN indirection[unused1] RPAREN {
1330         (void) $unused1;
1331         $arg = psi_decl_arg_init(
1332                 psi_decl_type_init($VOID->type, $VOID->text),
1333                 psi_decl_var_init(NULL, $pointers, 0)
1334         );
1335         $arg->type->token = psi_token_copy($VOID);
1336         $arg->var->token = psi_token_copy($VOID);
1337         $arg->token = psi_token_copy($VOID);
1338 }
1339 |       VOID pointers LPAREN indirection[unused1] RPAREN {
1340         (void) $unused1;
1341         $arg = psi_decl_arg_init(
1342                 psi_decl_type_init($VOID->type, $VOID->text),
1343                 psi_decl_var_init(NULL, $pointers, 0)
1344         );
1345         $arg->type->token = psi_token_copy($VOID);
1346         $arg->var->token = psi_token_copy($VOID);
1347         $arg->token = psi_token_copy($VOID);
1348 }
1349 |       VOID LPAREN indirection[unused1] RPAREN {
1350         (void) $unused1;
1351         $arg = psi_decl_arg_init(
1352                 psi_decl_type_init($VOID->type, $VOID->text),
1353                 psi_decl_var_init(NULL, 0, 0)
1354         );
1355         $arg->type->token = psi_token_copy($VOID);
1356         $arg->var->token = psi_token_copy($VOID);
1357         $arg->token = psi_token_copy($VOID);
1358 }
1359 */
1360 ;
1361
1362 decl_func[func]:
1363         decl_arg
1364         /*
1365 |       VOID name_token[NAME] {
1366         $func = psi_decl_arg_init(
1367                 psi_decl_type_init($VOID->type, $VOID->text),
1368                 psi_decl_var_init($NAME->text, 0, 0)
1369         );
1370         $func->type->token = psi_token_copy($VOID);
1371         $func->var->token = psi_token_copy($NAME);
1372         $func->token = psi_token_copy($NAME);
1373 }
1374 */
1375 ;
1376
1377 decl_args[args]:
1378         %empty {
1379         $args = NULL;
1380 }
1381 |       VOID %dprec 2 {
1382         $args = NULL;
1383 }
1384 |       decl_arg_list[args_] %dprec 1 {
1385         $args = $args_;
1386 }
1387 ;
1388
1389 decl_arg_list[args]:
1390         decl_anon_arg[arg] {
1391         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free), &$arg);
1392 }
1393 |       decl_arg_list[args_] COMMA decl_anon_arg[arg] {
1394         $args = psi_plist_add($args_, &$arg);
1395 }
1396 ;
1397
1398 decl_anon_arg[arg]:
1399         decl_anon_functor_body[decl] {
1400         char digest[17];
1401         struct psi_token *name;
1402
1403         psi_token_hash($decl->func      ->token, digest);
1404         name = psi_token_append("@", psi_token_copy($decl->func->token), 2, "funct", digest);
1405
1406         $arg = psi_decl_arg_init(
1407                 psi_decl_type_init(PSI_T_FUNCTION, name->text),
1408                 psi_decl_var_copy($decl->func->var)
1409         );
1410         $arg->token = name;
1411         $arg->type->token = psi_token_copy($decl->func->token);
1412         $arg->type->real.func = $decl;
1413 }
1414 |       decl_arg %dprec 2 {
1415         $arg = $decl_arg;
1416 }
1417 |       qualified_decl_type[type] indirection %dprec 1 {
1418         $arg = psi_decl_arg_init(
1419                 $type,
1420                 psi_decl_var_init(NULL, $indirection, 0)
1421         );
1422 }
1423 /*
1424 |       CONST VOID pointers {
1425         $arg = psi_decl_arg_init(
1426                 psi_decl_type_init($VOID->type, $VOID->text),
1427                 psi_decl_var_init(NULL, $pointers, 0)
1428         );
1429         $arg->type->token = psi_token_copy($VOID);
1430         $arg->var->token = psi_token_copy($VOID);
1431         $arg->token = psi_token_copy($VOID);
1432 }
1433 |       VOID pointers {
1434         $arg = psi_decl_arg_init(
1435                 psi_decl_type_init($VOID->type, $VOID->text),
1436                 psi_decl_var_init(NULL, $pointers, 0)
1437         );
1438         $arg->type->token = psi_token_copy($VOID);
1439         $arg->var->token = psi_token_copy($VOID);
1440         $arg->token = psi_token_copy($VOID);
1441 }
1442 */
1443 ;
1444
1445 decl_arg[arg]:
1446         decl_functor_body[decl] {
1447         $arg = psi_decl_arg_init(
1448                 psi_decl_type_init(PSI_T_FUNCTION, $decl->func->var->name),
1449                 psi_decl_var_copy($decl->func->var)
1450         );
1451         $arg->type->token = psi_token_copy($decl->func->token);
1452         $arg->type->real.func = $decl;
1453 }
1454 |       qualified_decl_type[type] decl_var[var] {
1455         $arg = psi_decl_arg_init($type, $var);
1456 }
1457 /*
1458 |       CONST VOID pointers name_token[NAME] {
1459         $NAME->type = PSI_T_NAME;
1460         $arg = psi_decl_arg_init(
1461                 psi_decl_type_init($VOID->type, $VOID->text),
1462                 psi_decl_var_init($NAME->text, $pointers, 0)
1463         );
1464         $arg->type->token = psi_token_copy($VOID);
1465         $arg->var->token = psi_token_copy($NAME);
1466         $arg->token = psi_token_copy($NAME);
1467 }
1468 |       VOID pointers name_token[NAME] {
1469         $NAME->type = PSI_T_NAME;
1470         $arg = psi_decl_arg_init(
1471                 psi_decl_type_init($VOID->type, $VOID->text),
1472                 psi_decl_var_init($NAME->text, $pointers, 0)
1473         );
1474         $arg->type->token = psi_token_copy($VOID);
1475         $arg->var->token = psi_token_copy($NAME);
1476         $arg->token = psi_token_copy($NAME);
1477 }
1478 */
1479 ;
1480
1481 decl_var[var]:
1482         pointers name_token array_size {
1483         $name_token->type = PSI_T_NAME;
1484         $var = psi_decl_var_init($name_token->text, $pointers + !! $array_size, $array_size);
1485         $var->token = psi_token_copy($name_token);
1486 }
1487 |       name_token array_size {
1488         $name_token->type = PSI_T_NAME;
1489         $var = psi_decl_var_init($name_token->text, !! $array_size, $array_size);
1490         $var->token = psi_token_copy($name_token);
1491 }
1492 ;
1493
1494 decl_union[union]:
1495         UNION name_token align_and_size[as] decl_struct_args[args] {
1496         $name_token->type = PSI_T_NAME;
1497         $union = psi_decl_union_init($name_token->text, $args);
1498         $union->align = $as.pos;
1499         $union->size = $as.len;
1500         $union->token = psi_token_copy($name_token);
1501 }
1502 ;
1503
1504 decl_struct[struct]:
1505         STRUCT name_token align_and_size[as] decl_struct_args[args] {
1506         $name_token->type = PSI_T_NAME;
1507         $struct = psi_decl_struct_init($name_token->text, $args);
1508         $struct->align = $as.pos;
1509         $struct->size = $as.len;
1510         $struct->token = psi_token_copy($name_token);
1511 }
1512 ;
1513
1514 decl_struct_args[args]:
1515         EOS {
1516         $args = NULL;
1517 }
1518 |       struct_args_block
1519 ;
1520
1521 struct_args_block[args]:
1522         LBRACE struct_args RBRACE {
1523         $args = $struct_args;
1524 }
1525 ;
1526
1527 struct_args[args]:
1528         typedef_anon[arg] decl_layout[layout] struct_arg_var_list[vars] EOS {
1529         $arg->layout = $layout;
1530         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free), &$arg);
1531         if ($vars) {
1532                 size_t i = 0;
1533                 struct psi_decl_arg *arg;
1534
1535                 while (psi_plist_get($vars, i++, &arg)) {
1536                         arg->type = psi_decl_type_copy($arg->type);
1537                         $args = psi_plist_add($args, &arg);
1538                 }
1539                 free($vars);
1540         }
1541 }
1542 |       struct_args[args_] typedef_anon[arg] decl_layout[layout] struct_arg_var_list[vars] EOS {
1543         $arg->layout = $layout;
1544         $args = psi_plist_add($args_, &$arg);
1545         if ($vars) {
1546                 size_t i = 0;
1547                 struct psi_decl_arg *arg;
1548
1549                 while (psi_plist_get($vars, i++, &arg)) {
1550                         arg->type = psi_decl_type_copy($arg->type);
1551                         $args = psi_plist_add($args, &arg);
1552                 }
1553                 free($vars);
1554         }
1555 }
1556 ;
1557
1558 struct_arg_var_list[vars]:
1559         %empty {
1560         $vars = NULL;
1561 }
1562 |       COMMA decl_vars_with_layout[vars_] {
1563         $vars = $vars_;
1564 }
1565 ;
1566
1567 decl_vars_with_layout[vars]:
1568         decl_var[var] decl_layout[layout] {
1569         {
1570                 struct psi_decl_arg *arg = psi_decl_arg_init(NULL, $var);
1571                 arg->layout = $layout;
1572                 $vars = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free), &arg);
1573         }
1574 }
1575 |       decl_vars_with_layout[vars_] COMMA decl_var[var] decl_layout[layout] {
1576         {
1577                 struct psi_decl_arg *arg = psi_decl_arg_init(NULL, $var);
1578                 arg->layout = $layout;
1579                 $vars = psi_plist_add($vars_, &arg);
1580         }
1581 }
1582 ;
1583
1584 decl_enum[enum]:
1585         enum_name LBRACE decl_enum_items[list] optional_comma RBRACE {
1586         $enum = psi_decl_enum_init($enum_name->text, $list);
1587         $enum->token = $enum_name;
1588 }
1589 ;
1590
1591 decl_enum_items[list]:
1592         decl_enum_item[i] {
1593         $list = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_enum_item_free), &$i);
1594 }
1595 |       decl_enum_items[list_] COMMA decl_enum_item[i] {
1596         $list = psi_plist_add($list_, &$i);
1597 }
1598 ;
1599
1600 decl_enum_item[i]:
1601         name_token {
1602         $name_token->type = PSI_T_NAME;
1603         $i = psi_decl_enum_item_init($name_token->text, NULL);
1604         $i->token = psi_token_copy($name_token);
1605 }
1606 |       name_token EQUALS num_exp {
1607         $name_token->type = PSI_T_NAME;
1608         $i = psi_decl_enum_item_init($name_token->text, $num_exp);
1609         $i->token = psi_token_copy($name_token);
1610 }
1611 ;
1612
1613 num_exp[exp]:
1614         number {
1615         $exp = psi_num_exp_init_num($number);
1616         $exp->token = psi_token_copy($number->token);
1617 }
1618 |       LPAREN qualified_decl_type[type] RPAREN num_exp[exp_] %prec UNARY {
1619         $exp = psi_num_exp_init_cast($type, $exp_);
1620         $exp->token = psi_token_copy($type->token);
1621 }
1622 |       LPAREN num_exp[exp_] RPAREN {
1623         $exp = psi_num_exp_init_unary(PSI_T_LPAREN, $exp_);
1624         $exp->token = psi_token_copy($LPAREN);
1625 }
1626 |       num_exp[lhs] binary_op_token[op] num_exp[rhs] %prec BINARY {
1627         $exp = psi_num_exp_init_binary($op->type, $lhs, $rhs);
1628         $exp->token = psi_token_copy($op);
1629 }
1630 |       unary_op_token[op] num_exp[exp_] %prec UNARY {
1631         $exp = psi_num_exp_init_unary($op->type, $exp_);
1632         $exp->token = psi_token_copy($op);
1633 }
1634 |       num_exp[cond] IIF num_exp[truthy] COLON num_exp[falsy] {
1635         $exp = psi_num_exp_init_ternary($IIF->type, $cond, $truthy, $falsy);
1636         $exp->token = psi_token_copy($IIF);
1637 }
1638 ;
1639
1640 number[num]:
1641         NUMBER[token] {
1642         $num = psi_number_init($token->type, $token->text, $token->flags);
1643         $num->token = psi_token_copy($token);
1644 }
1645 |       NSNAME[token] {
1646         $num = psi_number_init($token->type, $token->text, 0);
1647         $num->token = psi_token_copy($token);
1648 }
1649 |       QUOTED_CHAR[token] {
1650         $num = psi_number_init($token->type, $token->text, 0);
1651         $num->token = psi_token_copy($token);
1652 }
1653 |       NULL[token] {
1654         $num = psi_number_init($token->type, $token->text, 0);
1655         $num->token = psi_token_copy($token);
1656 }
1657 |       decl_var {
1658         $num = psi_number_init(PSI_T_NAME, $decl_var, 0);
1659         $num->token = psi_token_copy($decl_var->token);
1660 }
1661 |       sizeof {
1662         $num = $sizeof;
1663 }
1664 ;
1665
1666 sizeof:
1667         SIZEOF LPAREN sizeof_body[sizeof_] RPAREN {
1668         $sizeof = $sizeof_;
1669         $sizeof->token = psi_token_copy($SIZEOF);
1670 }
1671 |       SIZEOF sizeof_body_notypes[sizeof_] {
1672         $sizeof = $sizeof_;
1673         $sizeof->token = psi_token_copy($SIZEOF);
1674 }
1675 ;
1676
1677 sizeof_body[sizeof]:
1678         sizeof_body_notypes[sizeof_] {
1679         $sizeof = $sizeof_;
1680 }
1681 |       decl_type indirection {
1682         if ($indirection) {
1683                 int8_t sizeof_void_p = sizeof(void *);
1684                 $sizeof = psi_number_init(PSI_T_INT8, &sizeof_void_p, 0);
1685                 psi_decl_type_free(&$decl_type);
1686         } else {
1687                 $sizeof = psi_number_init(PSI_T_SIZEOF, $decl_type, 0);
1688         }
1689 }
1690 ;
1691
1692 sizeof_body_notypes[sizeof]:
1693         AMPERSAND NAME {
1694         int8_t sizeof_void_p = sizeof(void *);
1695         $sizeof = psi_number_init(PSI_T_INT8, &sizeof_void_p, 0);
1696 }
1697 |       QUOTED_CHAR {
1698         int8_t sizeof_a = sizeof('a');
1699         $sizeof = psi_number_init(PSI_T_INT8, &sizeof_a, 0);
1700 }
1701 |       QUOTED_STRING {
1702         uint64_t len = $QUOTED_STRING->size + 1;
1703         $sizeof = psi_number_init(PSI_T_UINT64, &len, 0);
1704 }
1705 ;
1706
1707 enum_name[name]:
1708         ENUM optional_name[name_] {
1709         if ($name_) {
1710                 $name = psi_token_copy($name_);
1711         } else {
1712                 char digest[17];
1713
1714                 psi_token_hash($ENUM, digest);
1715                 $name = psi_token_append("@", psi_token_copy($ENUM), 1, digest);
1716         }
1717 }
1718 ;
1719
1720 union_name[name]:
1721         UNION optional_name[name_] {
1722         if ($name_) {
1723                 $name = psi_token_copy($name_);
1724         } else {
1725                 char digest[17];
1726
1727                 psi_token_hash($UNION, digest);
1728                 $name = psi_token_append("@", psi_token_copy($UNION), 1, digest);
1729         }
1730 }
1731 ;
1732
1733 struct_name[name]:
1734         STRUCT optional_name[name_] {
1735         if ($name_) {
1736                 $name = psi_token_copy($name_);
1737         } else {
1738                 char digest[17];
1739
1740                 psi_token_hash($STRUCT, digest);
1741                 $name = psi_token_append("@", psi_token_copy($STRUCT), 1, digest);
1742         }
1743 }
1744 ;
1745
1746 optional_name[name]:
1747         %empty {
1748         $name = NULL;
1749 }
1750 |       name_token {
1751         $name = $name_token;
1752         $name->type = PSI_T_NAME;
1753 }
1754 ;
1755
1756 optional_comma:
1757         %empty
1758 |       COMMA
1759 ;
1760
1761 decl_layout[l]:
1762         %empty {
1763         $l = NULL;
1764 }
1765 |       COLON NUMBER[width] {
1766         $l = psi_layout_init(0, 0, psi_layout_init(0, atol($width->text), NULL));
1767 }
1768 |       COLON COLON LPAREN NUMBER[align] COMMA NUMBER[size] RPAREN {
1769         $l = psi_layout_init(atol($align->text), atol($size->text), NULL);
1770 }
1771 |       COLON NUMBER[width] COLON COLON LPAREN NUMBER[align] COMMA NUMBER[size] RPAREN {
1772         $l = psi_layout_init(atol($align->text), atol($size->text), psi_layout_init(0, atol($width->text), NULL));
1773 }
1774 ;
1775
1776 align_and_size[as]:
1777         %empty {
1778         $as.pos = 0;
1779         $as.len = 0;
1780 }
1781 |       COLON COLON LPAREN NUMBER[align] COMMA NUMBER[size] RPAREN {
1782         $as.pos = atol($align->text);
1783         $as.len = atol($size->text);
1784 }
1785 ;
1786
1787 array_size[as]:
1788         %empty {
1789         $as = 0;
1790 }
1791 |       LBRACKET array_qualifier_token RBRACKET {
1792         $as = 0;
1793 }
1794 |       LBRACKET num_exp RBRACKET {
1795         struct psi_validate_scope scope = {0};
1796         psi_validate_scope_ctor(&scope);
1797         scope.defs = &P->preproc->defs;
1798         if (psi_num_exp_validate(PSI_DATA(P), $num_exp, &scope)) {
1799                 $as = psi_num_exp_get_long($num_exp, NULL, &P->preproc->defs);
1800         } else {
1801                 $as = 0;
1802         }
1803         psi_num_exp_free(&$num_exp);
1804         psi_validate_scope_dtor(&scope);
1805 }
1806 ;
1807
1808 array_qualifier_token:
1809         %empty
1810 |       CPP_RESTRICT
1811 |       VOLATILE
1812 |       CONST
1813 ;
1814
1815 indirection[i]:
1816         %empty {
1817         $i = 0;
1818 }
1819 |       pointers[p] %prec UNARY {
1820         $i = $p;
1821 }
1822 ;
1823
1824 pointers[p]:
1825         asterisks
1826 |       asterisks[a] CPP_RESTRICT {
1827         $p = $a;
1828 }
1829 ;
1830
1831 asterisks[a]:
1832         asterisk {
1833         $a = 1;
1834 }
1835 |       asterisks[a_] asterisk {
1836         $a = $a_ + 1;
1837 }
1838 ;
1839
1840 asterisk:
1841         ASTERISK
1842 |       ASTERISK pointer_qualifier_token
1843 ;
1844
1845 pointer_qualifier_token:
1846         CONST
1847 |       VOLATILE
1848 ;
1849
1850 /*
1851  *
1852  * impl
1853  *
1854  */
1855
1856 impl:
1857         impl_func[func] LBRACE impl_stmts[stmts] RBRACE {
1858         $impl = psi_impl_init($func, $stmts);
1859 }
1860 |       STATIC impl_func[func] LBRACE impl_stmts[stmts] RBRACE {
1861         $impl = psi_impl_init($func, $stmts);
1862         $func->static_memory = 1;
1863 }
1864 ;
1865
1866 impl_func[func]:
1867         FUNCTION reference[r] NSNAME LPAREN RPAREN COLON impl_type[type] {
1868         $func = psi_impl_func_init($NSNAME->text, NULL, $type);
1869         $func->token = psi_token_copy($NSNAME);
1870         $func->return_reference = $r;
1871 }
1872 |       FUNCTION reference[r] NSNAME LPAREN impl_args[args] RPAREN COLON impl_type[type] {
1873         $func = psi_impl_func_init($NSNAME->text, $args, $type);
1874         $func->token = psi_token_copy($NSNAME);
1875         $func->return_reference = $r;
1876 }
1877 |       FUNCTION reference[r] NSNAME LPAREN impl_args[args] COMMA impl_type[va_type] reference[va_r] ELLIPSIS DOLLAR_NAME RPAREN COLON impl_type[type] {
1878         $func = psi_impl_func_init($NSNAME->text, $args, $type);
1879         $func->token = psi_token_copy($NSNAME);
1880         $func->return_reference = $r;
1881         $func->vararg = psi_impl_arg_init($va_type, psi_impl_var_init($DOLLAR_NAME->text, $va_r), NULL);
1882         $func->vararg->var->token = psi_token_copy($DOLLAR_NAME);
1883 }
1884 ;
1885
1886 impl_args[args]:
1887         impl_arg[arg] {
1888         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_arg_free), &$arg);
1889 }
1890 |       impl_args[args_] COMMA impl_arg[arg] {
1891         $args = psi_plist_add($args_, &$arg);
1892 }
1893 ;
1894
1895 impl_arg[arg]:
1896         impl_type[type] impl_var[var] {
1897         $arg = psi_impl_arg_init($type, $var, NULL);
1898 }
1899 |       impl_type[type] impl_var[var] EQUALS impl_def_val[val] {
1900         $arg = psi_impl_arg_init($type, $var, $val);
1901 }
1902 ;
1903
1904 impl_var[var]:
1905         reference DOLLAR_NAME {
1906         $var = psi_impl_var_init($DOLLAR_NAME->text, $reference);
1907         $var->token = psi_token_copy($DOLLAR_NAME);
1908 }
1909 ;
1910
1911 impl_type[type]:
1912         impl_type_token[token] {
1913         $type = psi_impl_type_init($token->type, $token->text);
1914         $type->token = psi_token_copy($token);
1915 }
1916 ;
1917
1918 impl_type_restricted[type]:
1919         impl_type_restricted_token[token] {
1920         $type = psi_impl_type_init($token->type, $token->text);
1921         $type->token = psi_token_copy($token);
1922 }
1923 ;
1924
1925 impl_type_token:
1926         impl_type_restricted_token
1927 |       impl_type_extended_token
1928 ;
1929
1930 impl_type_restricted_token:
1931         BOOL
1932 |       INT
1933 |       FLOAT
1934 |       STRING
1935 ;
1936
1937 impl_type_extended_token:
1938         VOID
1939 |       MIXED
1940 |       ARRAY
1941 |       OBJECT
1942 |       CALLABLE
1943 ;
1944
1945 impl_stmts[stmts]:
1946         impl_stmt[stmt] {
1947         $stmts = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_stmt_free), &$stmt);
1948 }
1949 |       impl_stmts[stmts_] impl_stmt[stmt] {
1950         $stmts = psi_plist_add($stmts_, &$stmt);
1951 }
1952 ;
1953
1954 impl_stmt[stmt]:
1955         return_stmt[s] {
1956         $stmt = (struct psi_token **) $s;
1957 }
1958 |       let_stmt[s] {
1959         $stmt = (struct psi_token **) $s;
1960 }
1961 |       set_stmt[s] {
1962         $stmt = (struct psi_token **) $s;
1963 }
1964 |       assert_stmt[s] {
1965         $stmt = (struct psi_token **) $s;
1966 }
1967 |       free_stmt[s] {
1968         $stmt = (struct psi_token **) $s;
1969 }
1970 ;
1971
1972 let_stmt[let]:
1973         LET let_exp_assign[exp] EOS {
1974         $let = psi_let_stmt_init($exp);
1975         $let->token = psi_token_copy($LET);
1976 }
1977 |       TEMP decl_var[var] EQUALS reference decl_var[val] EOS {
1978         $let = psi_let_stmt_init(psi_let_exp_init_ex($var, PSI_LET_TMP, $val));
1979         $let->token = psi_token_copy($TEMP);
1980         $let->exp->is_reference = $reference;
1981 }
1982 ;
1983
1984 let_exp[exp]:
1985         let_exp_assign
1986 |       byref let_exp_byref[exp_] {
1987         $exp = $exp_;
1988         $exp->is_reference = true;
1989 }
1990 |       let_exp_byref[exp_] {
1991         $exp = $exp_;
1992         $exp->is_reference = false;
1993 }
1994 ;
1995
1996 let_exp_byref[exp]:
1997         NULL %dprec 2 {
1998         $exp = psi_let_exp_init(PSI_LET_NULL, NULL);
1999 }
2000 |       num_exp[num] %dprec 1 {
2001         $exp = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, $num);
2002 }
2003 |       let_calloc[calloc] {
2004         $exp = psi_let_exp_init(PSI_LET_CALLOC, $calloc);
2005 }
2006 |       STATIC let_calloc[calloc] {
2007         $exp = psi_let_exp_init(PSI_LET_CALLOC, $calloc);
2008         $calloc->static_memory = 1;
2009 }
2010 |       let_callback[callback] {
2011         $exp = psi_let_exp_init(PSI_LET_CALLBACK, $callback);
2012 }
2013 |       let_func[func] {
2014         $exp = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, $func);
2015 }
2016 ;
2017
2018 let_exp_assign[exp]:
2019         decl_var[var] EQUALS let_exp_byref[exp_] {
2020         $exp = $exp_;
2021         $exp->var = $var;
2022 }
2023 |       decl_var[var] EQUALS byref let_exp_byref[exp_] {
2024         $exp = $exp_;
2025         $exp->is_reference = 1;
2026         $exp->var = $var;
2027 }
2028 ;
2029
2030 let_calloc[calloc]:
2031         CALLOC LPAREN num_exp[nmemb] COMMA num_exp[size] RPAREN {
2032         $calloc = psi_let_calloc_init($nmemb, $size);
2033         $calloc->token = psi_token_copy($CALLOC);
2034 }
2035 ;
2036
2037 let_callback[callback]:
2038         CALLBACK callback_rval[func] LPAREN impl_var[var] LPAREN callback_arg_list[args] RPAREN RPAREN {
2039         $callback = psi_let_callback_init(psi_let_func_init($func->type, $func->text, $var), $args, NULL);
2040         $callback->func->token = psi_token_copy($func);
2041         $callback->token = psi_token_copy($CALLBACK);
2042 }
2043 |       CALLBACK LPAREN call_decl_vars[cb_args] RPAREN AS callback_rval[func] LPAREN impl_var[var] LPAREN callback_arg_list[args] RPAREN RPAREN {
2044         $callback = psi_let_callback_init(psi_let_func_init($func->type, $func->text, $var), $args, $cb_args);
2045         $callback->func->token = psi_token_copy($func);
2046         $callback->token = psi_token_copy($CALLBACK);
2047 }
2048 ;
2049
2050 let_func[func]:
2051         let_func_token[token] LPAREN impl_var[var] let_func_exps[exps] RPAREN {
2052         $func = psi_let_func_init($token->type, $token->text, $var);
2053         $func->token = psi_token_copy($token);
2054         $func->inner = $exps;
2055 }
2056 ;
2057
2058 let_func_token:
2059         ZVAL
2060 |       OBJVAL
2061 |       ARRVAL
2062 |       PATHVAL
2063 |       STRLEN
2064 |       STRVAL
2065 |       FLOATVAL
2066 |       INTVAL
2067 |       BOOLVAL
2068 |       COUNT
2069 ;
2070
2071 let_func_exps[exps]:
2072         %empty {
2073         $exps = NULL;
2074 }
2075 |       COMMA let_exps[exps_] {
2076         $exps = $exps_;
2077 }
2078 ;
2079
2080 let_exps[exps]:
2081         let_exp[exp] {
2082         $exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_let_exp_free), &$exp);
2083 }
2084 |       let_exps[exps_] COMMA let_exp[exp] {
2085         $exps = psi_plist_add($exps_, &$exp);
2086 }
2087 ;
2088
2089 callback_rval[rval]:
2090         VOID
2091 |       let_func_token
2092 ;
2093
2094 callback_arg_list[list]:
2095         %empty {
2096         $list = NULL;
2097 }
2098 |       callback_args[args] {
2099         $list = $args;
2100 }
2101 ;
2102
2103 callback_args[args]:
2104         set_exp[exp] {
2105         $args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free), &$exp);
2106 }
2107 |       callback_args[args_] COMMA set_exp[exp] {
2108         $args = psi_plist_add($args_, &$exp);
2109 }
2110 ;
2111
2112 return_stmt[return]:
2113         RETURN return_exp EOS {
2114         $return = psi_return_stmt_init($return_exp);
2115         $return->token = psi_token_copy($RETURN);
2116 }
2117 ;
2118
2119 return_exp:
2120         decl_var[func] LPAREN call_decl_vars[args] RPAREN AS set_func {
2121         $return_exp = psi_return_exp_init($func, $args, psi_set_exp_init(PSI_SET_FUNC, $set_func));
2122         $return_exp->token = psi_token_copy($func->token);
2123 }
2124 |       set_func {
2125         $return_exp = psi_return_exp_init(NULL, NULL, psi_set_exp_init(PSI_SET_FUNC, $set_func));
2126         $return_exp->token = psi_token_copy($set_func->token);
2127 }
2128 ;
2129
2130 call_decl_vars[args]:
2131         %empty {
2132         $args = NULL;
2133 }
2134 |       VOID {
2135         $args = NULL;
2136 }
2137 |       decl_vars[vars] {
2138         $args = $vars;
2139 }
2140 ;
2141
2142 set_stmt[set]:
2143         SET set_exp[exp] EOS {
2144         $set = psi_set_stmt_init($exp);
2145         $set->token = psi_token_copy($SET);
2146 }
2147 ;
2148
2149 set_exp[exp]:
2150         set_func[func] {
2151         $exp = psi_set_exp_init(PSI_SET_FUNC, $func);
2152 }
2153 |       num_exp[num] {
2154         $exp = psi_set_exp_init(PSI_SET_NUMEXP, $num);
2155 }
2156 |       impl_var[var] EQUALS set_exp[exp_] {
2157         $exp = $exp_;
2158         $exp->var = $var;
2159 }
2160 ;
2161
2162 set_func[func]:
2163         set_func_token[token] LPAREN decl_var[var] set_func_exps[exps] RPAREN {
2164         $func = psi_set_func_init($token->type, $token->text, $var);
2165         $func->token = psi_token_copy($token);
2166         $func->inner = $exps;
2167 }
2168 |       set_func_token[token] LPAREN decl_var[var] COMMA ELLIPSIS RPAREN {
2169         $func = psi_set_func_init($token->type, $token->text, $var);
2170         $func->token = psi_token_copy($token);
2171         $func->recursive = 1;
2172 }
2173 ;
2174
2175 set_func_token:
2176         TO_OBJECT
2177 |       TO_ARRAY
2178 |       TO_STRING
2179 |       TO_INT
2180 |       TO_FLOAT
2181 |       TO_BOOL
2182 |       ZVAL
2183 |       VOID
2184 ;
2185
2186 set_func_exps[exps]:
2187         %empty {
2188         $exps = NULL;
2189 }
2190 |       COMMA set_exps[exps_] {
2191         $exps = $exps_;
2192 }
2193 ;
2194
2195 set_exps[exps]:
2196         set_exp[exp] {
2197         $exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free), &$exp);
2198 }
2199 |       set_exps[exps_] COMMA set_exp[exp] {
2200         $exps = psi_plist_add($exps_, &$exp);
2201 }
2202 ;
2203
2204 assert_stmt[assert]:
2205         assert_stmt_token[token] num_exp[exp] EOS {
2206         $assert = psi_assert_stmt_init((enum psi_assert_kind) $token->type, $exp);
2207         $assert->token = psi_token_copy($token);
2208 }
2209 ;
2210
2211 assert_stmt_token:
2212         PRE_ASSERT
2213 |       POST_ASSERT
2214 ;
2215
2216 free_stmt[free]:
2217         FREE free_exps[exps] EOS {
2218         $free = psi_free_stmt_init($exps);
2219         $free->token = psi_token_copy($FREE);
2220 }
2221 ;
2222
2223 free_exps[exps]:
2224         free_exp[exp] {
2225         $exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_free_exp_free), &$exp);
2226 }
2227 |       free_exps[exps_] COMMA free_exp[exp] {
2228         $exps = psi_plist_add($exps_, &$exp);
2229 }
2230 ;
2231
2232 free_exp[exp]:
2233         name_token[NAME] LPAREN decl_vars[vars] RPAREN {
2234         $NAME->type = PSI_T_NAME;
2235         $exp = psi_free_exp_init($NAME->text, $vars);
2236         $exp->token = psi_token_copy($NAME);
2237 }
2238 ;
2239
2240 reference:
2241         %empty {
2242         $reference = false;
2243 }
2244 |       byref {
2245         $reference = true;
2246 }
2247 ;
2248
2249 byref:
2250         AMPERSAND %prec UNARY
2251 ;
2252
2253 %%
2254
2255 /* epilogue */
2256
2257 static int psi_parser_proc_lex(YYSTYPE *lvalp, struct psi_parser *P, struct psi_plist *tokens, size_t *index)
2258 {
2259         struct psi_token *token;
2260
2261         if (psi_plist_get(tokens, (*index)++, &token)) {
2262                 if (P->flags & PSI_DEBUG) {
2263                         psi_token_dump(2, token);
2264                 }
2265
2266                 *((struct psi_token **)lvalp) = token;
2267                 return token->type;
2268         } else {
2269                 (*index)--;
2270                 PSI_DEBUG_PRINT(P, "EOF(%d)\n", PSI_T_EOF);
2271         }
2272
2273         return PSI_T_EOF;
2274 }
2275
2276 static void psi_parser_proc_error(struct psi_parser *P, struct psi_plist *tokens, size_t *index, const char *msg)
2277 {
2278         struct psi_token *T = NULL;
2279         size_t last;
2280
2281         if (*index == 0) {
2282                 last = 0;
2283         } else {
2284                 last = --(*index);
2285         }
2286
2287         psi_plist_get(tokens, last, &T);
2288         if (T) {
2289                 P->error(PSI_DATA(P), T, PSI_WARNING, "PSI %s at col %u", msg, T->col);
2290         } else {
2291                 P->error(PSI_DATA(P), NULL, PSI_WARNING, "PSI %s", msg);
2292         }
2293         P->errors++;
2294 }
2295