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

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