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

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