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

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