1 /*******************************************************************************
2 Copyright (c) 2016, Michael Wallner <mike@php.net>.
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
8 * Redistributions of source code must retain the above copyright notice,
9 this list of conditions and the following disclaimer.
10 * Redistributions in binary form must reproduce the above copyright
11 notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
18 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *******************************************************************************/
26 #include "parser_def.h"
28 DEF(%token_prefix
, CONCAT1(TOKEN_PREFIX
,_
))
29 DEF(%token_type
, {TOKEN_STRUCT
})
30 DEF(%token_destructor
, {free($$
);})
31 DEF(%default_destructor
, {(void)P
;})
32 DEF(%extra_argument
, {struct psi_parser
*P
})
34 /* TOKEN is defined inside syntax_error */
38 psi_error(PSI_WARNING
, TOKEN
->file
, TOKEN
->line
, "PSI syntax error: Unexpected token '%s' at pos %u", TOKEN
->text
, TOKEN
->col
);
40 psi_error(PSI_WARNING
, P
->file
.fn
, P
->line
, "PSI syntax error: Unexpected end of input");
44 TOKEN_CLASS(const_type
, T(BOOL
) T(INT
) T(FLOAT
) T(STRING
))
45 TOKEN_CLASS(decl_type
, T(FLOAT
) T(DOUBLE
) T(INT8
) T(UINT8
) T(INT16
) T(UINT16
) T(INT32
) T(UINT32
) T(INT64
) T(UINT64
) T(NAME
))
46 TOKEN_CLASS(impl_def_val
, T(NULL
) T(NUMBER
) T(TRUE
) T(FALSE
) T(QUOTED_STRING
))
47 TOKEN_CLASS(number
, T(NUMBER
) T(NSNAME
))
48 TOKEN_CLASS(binary_op
, T(PIPE
) T(CARET
) T(AMPERSAND
) T(LSHIFT
) T(RSHIFT
) T(PLUS
) T(MINUS
) T(ASTERISK
) T(SLASH
) T(MODULO
) T(RCHEVR
) T(LCHEVR
) T(CMP_GE
) T(CMP_LE
) T(OR
) T(AND
) T(CMP_EQ
) T(CMP_NE
))
49 TOKEN_CLASS(unary_op
, T(TILDE
) T(NOT
) T(PLUS
) T(MINUS
))
50 TOKEN_CLASS(let_func
, T(ZVAL
) T(OBJVAL
) T(ARRVAL
) T(PATHVAL
) T(STRLEN
) T(STRVAL
) T(FLOATVAL
) T(INTVAL
) T(BOOLVAL
) T(COUNT
))
51 TOKEN_CLASS(set_func
, T(TO_OBJECT
) T(TO_ARRAY
) T(TO_STRING
) T(TO_INT
) T(TO_FLOAT
) T(TO_BOOL
) T(ZVAL
) T(VOID
))
52 TOKEN_CLASS(impl_type
, T(VOID
) T(MIXED
) T(BOOL
) T(INT
) T(FLOAT
) T(STRING
) T(ARRAY
) T(OBJECT
) T(CALLABLE
))
53 TOKEN_CLASS(assert_stmt
, T(PRE_ASSERT
) T(POST_ASSERT
))
54 TOKEN_CLASS(cpp_message
, T(ERROR
) T(WARNING
))
57 DEF(%right
, NOT TILDE
.)
61 DEF(%left
, AMPERSAND
.)
62 DEF(%left
, CMP_EQ CMP_NE
.)
63 DEF(%left
, LCHEVR CMP_LE RCHEVR CMP_GE
.)
64 DEF(%left
, LSHIFT RSHIFT
.)
65 DEF(%left
, PLUS MINUS
.)
66 DEF(%left
, ASTERISK SLASH MODULO
.)
68 DEF(%fallback
, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT ERROR WARNING
.)
71 TOKEN_TYPE(decl_enum
, struct psi_decl_enum
*)
72 TOKEN_DTOR(decl_enum
, psi_decl_enum_free(&$$
);)
73 TOKEN_TYPE(decl_enum_items
, struct psi_plist
*)
74 TOKEN_DTOR(decl_enum_items
, psi_plist_free($$
);)
75 TOKEN_TYPE(decl_enum_item
, struct psi_decl_enum_item
*)
76 TOKEN_DTOR(decl_enum_item
, psi_decl_enum_item_free(&$$
);)
77 TOKEN_TYPE(decl_struct_args_block
, struct psi_plist
*)
78 TOKEN_DTOR(decl_struct_args_block
, psi_plist_free($$
);) /* there was a typo */
79 TOKEN_TYPE(decl_struct_args
, struct psi_plist
*)
80 TOKEN_DTOR(decl_struct_args
, psi_plist_free($$
);)
81 TOKEN_TYPE(decl_struct
, struct psi_decl_struct
*)
82 TOKEN_DTOR(decl_struct
, psi_decl_struct_free(&$$
);)
83 TOKEN_TYPE(align_and_size
, struct psi_layout
)
84 TOKEN_TYPE(decl_union
, struct psi_decl_union
*)
85 TOKEN_DTOR(decl_union
, psi_decl_union_free(&$$
);)
86 TOKEN_TYPE(const_type
, struct psi_const_type
*)
87 TOKEN_DTOR(const_type
, psi_const_type_free(&$$
);)
88 TOKEN_TYPE(constant
, struct psi_const
*)
89 TOKEN_DTOR(constant
, psi_const_free(&$$
);)
90 TOKEN_TYPE(decl_typedef
, struct psi_decl_arg
*)
91 TOKEN_DTOR(decl_typedef
, psi_decl_arg_free(&$$
);)
92 TOKEN_TYPE(decl_typedef_body_ex
, struct psi_decl_arg
*)
93 TOKEN_DTOR(decl_typedef_body_ex
, psi_decl_arg_free(&$$
);)
94 TOKEN_TYPE(decl_typedef_body
, struct psi_decl_arg
*)
95 TOKEN_DTOR(decl_typedef_body
, psi_decl_arg_free(&$$
);)
96 TOKEN_TYPE(decl_typedef_body_fn_args
, struct psi_plist
*)
97 TOKEN_DTOR(decl_typedef_body_fn_args
, psi_plist_free($$
);)
98 TOKEN_TYPE(decl
, struct psi_decl
*)
99 TOKEN_DTOR(decl
, psi_decl_free(&$$
);)
100 TOKEN_TYPE(decl_func
, struct psi_decl_arg
*)
101 TOKEN_DTOR(decl_func
, psi_decl_arg_free(&$$
);)
102 TOKEN_TYPE(decl_abi
, struct psi_decl_abi
*)
103 TOKEN_DTOR(decl_abi
, psi_decl_abi_free(&$$
);)
104 TOKEN_TYPE(decl_var
, struct psi_decl_var
*)
105 TOKEN_DTOR(decl_var
, psi_decl_var_free(&$$
);)
106 TOKEN_TYPE(decl_vars
, struct psi_plist
*)
107 TOKEN_DTOR(decl_vars
, psi_plist_free($$
);)
108 TOKEN_TYPE(decl_arg
, struct psi_decl_arg
*)
109 TOKEN_DTOR(decl_arg
, psi_decl_arg_free(&$$
);)
110 TOKEN_TYPE(decl_args
, struct psi_plist
*)
111 TOKEN_DTOR(decl_args
, psi_plist_free($$
);)
112 TOKEN_TYPE(struct_args
, struct psi_plist
*)
113 TOKEN_DTOR(struct_args
, psi_plist_free($$
);)
114 TOKEN_TYPE(struct_arg
, struct psi_decl_arg
*)
115 TOKEN_DTOR(struct_arg
, psi_decl_arg_free(&$$
);)
116 TOKEN_TYPE(decl_layout
, struct psi_layout
*)
117 TOKEN_DTOR(decl_layout
, psi_layout_free(&$$
);)
118 TOKEN_TYPE(decl_type
, struct psi_decl_type
*)
119 TOKEN_DTOR(decl_type
, psi_decl_type_free(&$$
);)
120 TOKEN_TYPE(const_decl_type
, struct psi_decl_type
*)
121 TOKEN_DTOR(const_decl_type
, psi_decl_type_free(&$$
);)
122 TOKEN_TYPE(impl
, struct psi_impl
*)
123 TOKEN_DTOR(impl
, psi_impl_free(&$$
);)
124 TOKEN_TYPE(impl_func
, struct psi_impl_func
*)
125 TOKEN_DTOR(impl_func
, psi_impl_func_free(&$$
);)
126 TOKEN_TYPE(impl_def_val
, struct psi_impl_def_val
*)
127 TOKEN_DTOR(impl_def_val
, psi_impl_def_val_free(&$$
);)
128 TOKEN_TYPE(impl_var
, struct psi_impl_var
*)
129 TOKEN_DTOR(impl_var
, psi_impl_var_free(&$$
);)
130 TOKEN_TYPE(impl_arg
, struct psi_impl_arg
*)
131 TOKEN_DTOR(impl_arg
, psi_impl_arg_free(&$$
);)
132 TOKEN_TYPE(impl_args
, struct psi_plist
*)
133 TOKEN_DTOR(impl_args
, psi_plist_free($$
);)
134 TOKEN_TYPE(impl_vararg
, struct psi_impl_arg
*)
135 TOKEN_DTOR(impl_vararg
, psi_impl_arg_free(&$$
);)
136 TOKEN_TYPE(impl_stmts
, struct psi_plist
*)
137 TOKEN_DTOR(impl_stmts
, psi_plist_free($$
);)
138 TOKEN_TYPE(impl_stmt
, struct psi_token
**)
139 TOKEN_DTOR(impl_stmt
, psi_impl_stmt_free(&$$
);)
140 TOKEN_TYPE(number
, struct psi_number
*)
141 TOKEN_DTOR(number
, psi_number_free(&$$
);)
142 TOKEN_TYPE(num_exp
, struct psi_num_exp
*)
143 TOKEN_DTOR(num_exp
, psi_num_exp_free(&$$
);)
144 TOKEN_TYPE(let_stmt
, struct psi_let_stmt
*)
145 TOKEN_DTOR(let_stmt
, psi_let_stmt_free(&$$
);)
146 TOKEN_TYPE(let_calloc
, struct psi_let_calloc
*)
147 TOKEN_DTOR(let_calloc
, psi_let_calloc_free(&$$
);)
148 TOKEN_TYPE(let_func
, struct psi_let_func
*)
149 TOKEN_DTOR(let_func
, psi_let_func_free(&$$
);)
150 TOKEN_TYPE(callback_arg_list
, struct psi_plist
*)
151 TOKEN_DTOR(callback_arg_list
, psi_plist_free($$
);)
152 TOKEN_TYPE(callback_args
, struct psi_plist
*)
153 TOKEN_DTOR(callback_args
, psi_plist_free($$
);)
154 TOKEN_TYPE(let_callback
, struct psi_let_callback
*)
155 TOKEN_DTOR(let_callback
, psi_let_callback_free(&$$
);)
156 TOKEN_TYPE(let_exp
, struct psi_let_exp
*)
157 TOKEN_DTOR(let_exp
, psi_let_exp_free(&$$
);)
158 TOKEN_TYPE(let_exps
, struct psi_plist
*)
159 TOKEN_DTOR(let_exps
, psi_plist_free($$
);)
160 TOKEN_TYPE(assert_stmt
, struct psi_assert_stmt
*)
161 TOKEN_DTOR(assert_stmt
, psi_assert_stmt_free(&$$
);)
162 TOKEN_TYPE(set_stmt
, struct psi_set_stmt
*)
163 TOKEN_DTOR(set_stmt
, psi_set_stmt_free(&$$
);)
164 TOKEN_TYPE(set_exp
, struct psi_set_exp
*)
165 TOKEN_DTOR(set_exp
, psi_set_exp_free(&$$
);)
166 TOKEN_TYPE(set_exps
, struct psi_plist
*)
167 TOKEN_DTOR(set_exps
, psi_plist_free($$
);)
168 TOKEN_TYPE(set_func
, struct psi_set_func
*)
169 TOKEN_DTOR(set_func
, psi_set_func_free(&$$
);)
170 TOKEN_TYPE(return_stmt
, struct psi_return_stmt
*)
171 TOKEN_DTOR(return_stmt
, psi_return_stmt_free(&$$
);)
172 TOKEN_TYPE(free_stmt
, struct psi_free_stmt
*)
173 TOKEN_DTOR(free_stmt
, psi_free_stmt_free(&$$
);)
174 TOKEN_TYPE(free_exps
, struct psi_plist
*)
175 TOKEN_DTOR(free_exps
, psi_plist_free($$
);)
176 TOKEN_TYPE(free_exp
, struct psi_free_exp
*)
177 TOKEN_DTOR(free_exp
, psi_free_exp_free(&$$
);)
178 TOKEN_TYPE(impl_type
, struct psi_impl_type
*)
179 TOKEN_DTOR(impl_type
, psi_impl_type_free(&$$
);)
180 TOKEN_TYPE(cpp_exp
, struct psi_cpp_exp
*)
181 TOKEN_DTOR(cpp_exp
, psi_cpp_exp_free(&$$
);)
182 TOKEN_TYPE(cpp_macro_decl
, struct psi_cpp_macro_decl
*)
183 TOKEN_DTOR(cpp_macro_decl
, psi_cpp_macro_decl_free(&$$
);)
184 TOKEN_TYPE(cpp_macro_decl_tokens
, struct psi_plist
*)
185 TOKEN_DTOR(cpp_macro_decl_tokens
, psi_plist_free($$
);)
186 TOKEN_TYPE(cpp_macro_exp
, struct psi_num_exp
*)
187 TOKEN_DTOR(cpp_macro_exp
, psi_num_exp_free(&$$
);)
188 TOKEN_TYPE(cpp_macro_sig
, struct psi_plist
*)
189 TOKEN_DTOR(cpp_macro_sig
, psi_plist_free($$
);)
190 TOKEN_TYPE(cpp_macro_sig_args
, struct psi_plist
*)
191 TOKEN_DTOR(cpp_macro_sig_args
, psi_plist_free($$
);)
192 TOKEN_TYPE(cpp_macro_call
, struct psi_plist
*)
193 TOKEN_DTOR(cpp_macro_call
, psi_plist_free($$
);)
194 TOKEN_TYPE(cpp_macro_call_args
, struct psi_plist
*)
195 TOKEN_DTOR(cpp_macro_call_args
, psi_plist_free($$
);)
197 TOKEN_TYPE(reference
, bool)
198 TOKEN_TYPE(indirection
, unsigned)
199 TOKEN_TYPE(pointers
, unsigned)
203 PASS(blocks
, blocks block
)
212 PARSE(block
, TOKEN(HASH
) TYPED(cpp_exp
, exp_
) TOKEN(EOL
)) {
217 * cpp_exp: cpp_message_token QUOTED_STRING
219 PARSE_TYPED(cpp_exp
, exp
,
220 NAMED(cpp_message_token
, T
)
221 NAMED(QUOTED_STRING
, S
)) {
222 exp
= psi_cpp_exp_init(T
->type
, S
);
227 * cpp_exp: IFDEF NAME
229 PARSE_TYPED(cpp_exp
, exp
,
232 exp
= psi_cpp_exp_init(T
->type
, N
);
237 * cpp_exp: IFNDEF NAME
239 PARSE_TYPED(cpp_exp
, exp
,
242 exp
= psi_cpp_exp_init(T
->type
, N
);
249 PARSE_TYPED(cpp_exp
, exp
,
251 exp
= psi_cpp_exp_init(T
->type
, NULL
);
258 PARSE_TYPED(cpp_exp
, exp
,
260 exp
= psi_cpp_exp_init(T
->type
, NULL
);
265 * cpp_exp: UNDEF NAME
267 PARSE_TYPED(cpp_exp
, exp
,
270 exp
= psi_cpp_exp_init(T
->type
, N
);
275 * cpp_exp: DEFINE NAME cpp_macro_decl
277 PARSE_TYPED(cpp_exp
, exp
,
280 TYPED(cpp_macro_decl
, macro
)) {
281 exp
= psi_cpp_exp_init(T
->type
, macro
);
287 * cpp_macro_decl: <empty>
289 PARSE_TYPED(cpp_macro_decl
, macro
, ) {
290 macro
= psi_cpp_macro_decl_init(NULL
, NULL
, NULL
);
294 * cpp_macro_decl: cpp_macro_sig
296 PARSE_TYPED(cpp_macro_decl
, macro
,
297 TYPED(cpp_macro_sig
, sig
)) {
298 macro
= psi_cpp_macro_decl_init(sig
, NULL
, NULL
);
302 * cpp_macro_decl: cpp_macro_sig cpp_macro_decl_tokens
304 PARSE_TYPED(cpp_macro_decl
, macro
,
305 TYPED(cpp_macro_sig
, sig
)
306 TYPED(cpp_macro_decl_tokens
, tokens
)) {
307 macro
= psi_cpp_macro_decl_init(sig
, tokens
, NULL
);
311 * cpp_macro_sig: NO_WHITESPACE LPAREN cpp_macro_sig_args RPAREN
313 PARSE_TYPED(cpp_macro_sig
, sig
,
316 TYPED(cpp_macro_sig_args
, args
)
322 * cpp_macro_sig_args: <empty>
324 PARSE_TYPED(cpp_macro_sig_args
, args
, ) {
329 * cpp_macro_sig_args: NAME
331 PARSE_TYPED(cpp_macro_sig_args
, args
,
333 args
= psi_plist_add(psi_plist_init((void (*)(void *)) psi_token_free
), &arg
);
337 * cpp_macro_sig_args: cpp_macro_sig_args , NAME
339 PARSE_TYPED(cpp_macro_sig_args
, args
,
340 TYPED(cpp_macro_sig_args
, args_
)
343 args
= psi_plist_add(args_
, &arg
);
347 * cpp_macro_decl: cpp_macro_decl_tokens
349 PARSE_TYPED(cpp_macro_decl
, macro
,
350 TYPED(cpp_macro_decl_tokens
, tokens
)) {
351 macro
= psi_cpp_macro_decl_init(NULL
, tokens
, NULL
);
355 * cpp_macro_decl_tokens: ANY
357 PARSE_TYPED(cpp_macro_decl_tokens
, tokens
,
359 tokens
= psi_plist_add(psi_plist_init((void (*)(void *)) psi_token_free
), &T
);
363 * cpp_macro_decl_tokens: cpp_macro_decl_tokens ANY
365 PARSE_TYPED(cpp_macro_decl_tokens
, tokens
,
366 TYPED(cpp_macro_decl_tokens
, tokens_
)
368 tokens
= psi_plist_add(tokens_
, &T
);
372 * cpp_exp: IF cpp_macro_exp
374 PARSE_TYPED(cpp_exp
, exp
,
376 TYPED(cpp_macro_exp
, macro
)) {
377 exp
= psi_cpp_exp_init(T
->type
, macro
);
382 * cpp_exp: ELIF cpp_macro_exp
384 PARSE_TYPED(cpp_exp
, exp
,
386 TYPED(cpp_macro_exp
, macro
)) {
387 exp
= psi_cpp_exp_init(T
->type
, macro
);
392 * cpp_macro_exp: ( cpp_macro_exp )
394 PARSE_TYPED(cpp_macro_exp
, exp
,
396 TYPED(cpp_macro_exp
, exp_
)
398 exp
= psi_num_exp_init_unary(L
->type
, exp_
);
403 * cpp_macro_exp: unary_op cpp_macro_exp
405 PARSE_TYPED(cpp_macro_exp
, exp
,
406 NAMED(unary_op_token
, OP
)
407 TYPED(cpp_macro_exp
, exp_
)) {
408 exp
= psi_num_exp_init_unary(OP
->type
, exp_
);
413 * cpp_macro_exp: cpp_macro_exp binary_op cpp_macro_exp
415 PARSE_TYPED(cpp_macro_exp
, exp
,
416 TYPED(cpp_macro_exp
, lhs
)
417 NAMED(binary_op_token
, OP
)
418 TYPED(cpp_macro_exp
, rhs
)) {
419 exp
= psi_num_exp_init_binary(OP
->type
, lhs
, rhs
);
424 * cpp_macro_exp: DEFINED NAME
426 PARSE_TYPED(cpp_macro_exp
, exp
,
430 uint8_t exists
= zend_hash_str_exists(&P
->cpp
.defs
, N
->text
, N
->size
);
431 exp
= psi_num_exp_init_num(psi_number_init(PSI_T_UINT8
, &exists
));
437 * cpp_macro_exp: DEFINED ( NAME )
439 PARSE_TYPED(cpp_macro_exp
, exp
,
445 uint8_t exists
= zend_hash_str_exists(&P
->cpp
.defs
, N
->text
, N
->size
);
446 exp
= psi_num_exp_init_num(psi_number_init(PSI_T_UINT8
, &exists
));
452 * cpp_macro_exp: number
454 PARSE_TYPED(cpp_macro_exp
, exp
,
455 NAMED(number_token
, tok
)) {
456 exp
= psi_num_exp_init_num(psi_number_init(tok
->type
, tok
->text
));
458 exp
->data
.n
->token
= psi_token_copy(tok
);
462 * cpp_macro_exp: NAME
464 PARSE_TYPED(cpp_macro_exp
, exp
,
466 exp
= psi_num_exp_init_num(psi_number_init(PSI_T_DEFINE
, N
->text
));
468 exp
->data
.n
->token
= psi_token_copy(N
);
472 * cpp_macro_exp: NAME ( cpp_macro_call_args )
474 PARSE_TYPED(cpp_macro_exp
, exp
,
477 TYPED(cpp_macro_call_args
, args
)
479 exp
= psi_num_exp_init_num(psi_number_init(PSI_T_FUNCTION
,
480 psi_cpp_macro_call_init(N
->text
, args
)));
485 * cpp_macro_call_args: <empty>
487 PARSE_TYPED(cpp_macro_call_args
, args
,) {
492 * cpp_macro_call_args: cpp_macro_exp
494 PARSE_TYPED(cpp_macro_call_args
, args
,
495 TYPED(cpp_macro_exp
, arg
)) {
496 args
= psi_plist_add(psi_plist_init((void (*)(void *)) psi_num_exp_free
), &arg
);
500 * cpp_macro_call_args: cpp_macro_call_args , cpp_macro_exp
502 PARSE_TYPED(cpp_macro_call_args
, args
,
503 TYPED(cpp_macro_call_args
, args_
)
505 TYPED(cpp_macro_exp
, arg
)) {
506 args
= psi_plist_add(args_
, &arg
);
510 * lib: LIB "soname" ;
512 PARSE(block
, NAMED(LIB
, token
) NAMED(QUOTED_STRING
, libname
) TOKEN(EOS
)) {
514 P
->error(PSI_DATA(P
), token
, PSI_WARNING
, "Extra 'lib %s' statement has no effect", libname
->text
);
516 P
->file
.ln
= strndup(libname
->text
+ 1, libname
->size
- 2);
522 PARSE(block
, TYPED(decl
, decl
)) {
524 P
->decls
= psi_plist_init((psi_plist_dtor
) psi_decl_free
);
526 P
->decls
= psi_plist_add(P
->decls
, &decl
);
529 PARSE(block
, TYPED(impl
, impl
)) {
531 P
->impls
= psi_plist_init((psi_plist_dtor
) psi_impl_free
);
533 P
->impls
= psi_plist_add(P
->impls
, &impl
);
536 PARSE(block
, TYPED(decl_typedef
, def
)) {
538 P
->types
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
540 P
->types
= psi_plist_add(P
->types
, &def
);
542 switch (def
->type
->type
) {
544 if (def
->type
->real
.strct
) {
546 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
548 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
552 if (def
->type
->real
.unn
) {
554 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
556 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
560 if (def
->type
->real
.enm
) {
562 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
564 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
570 PARSE(block
, TYPED(constant
, constant
)) {
572 P
->consts
= psi_plist_init((psi_plist_dtor
) psi_const_free
);
574 P
->consts
= psi_plist_add(P
->consts
, &constant
);
577 PARSE(block
, TYPED(decl_struct
, strct
)) {
579 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
581 P
->structs
= psi_plist_add(P
->structs
, &strct
);
584 PARSE(block
, TYPED(decl_union
, u
)) {
586 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
588 P
->unions
= psi_plist_add(P
->unions
, &u
);
591 PARSE(block
, TYPED(decl_enum
, e
)) {
593 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
595 P
->enums
= psi_plist_add(P
->enums
, &e
);
599 * optional_name: <empty>
601 PARSE_NAMED(optional_name
, n
, ) {
606 * optional_name: NAME
608 PARSE_NAMED(optional_name
, n
,
614 * align_and_size: <empty>
616 PARSE_TYPED(align_and_size
, as
, ) {
622 * align_and_size: :: ( NUMBER , NUMBER )
624 PARSE_TYPED(align_and_size
, as
,
632 as
.pos
= atol(A
->text
);
633 as
.len
= atol(S
->text
);
639 * enum_name: ENUM optional_name
641 PARSE_NAMED(enum_name
, n
,
643 NAMED(optional_name
, N
)) {
650 psi_token_hash(E
, digest
);
651 n
= psi_token_append("@", E
, 1, digest
);
656 * struct_name: STRUCT optional_name
658 PARSE_NAMED(struct_name
, n
,
660 NAMED(optional_name
, N
)) {
667 psi_token_hash(S
, digest
);
668 n
= psi_token_append("@", S
, 1, digest
);
673 * union_name: UNION optional_name
675 PARSE_NAMED(union_name
, n
,
677 NAMED(optional_name
, N
)) {
684 psi_token_hash(U
, digest
);
685 n
= psi_token_append("@", U
, 1, digest
);
690 * decl_enum: enum_name { items }
692 PARSE_TYPED(decl_enum
, e
,
695 TYPED(decl_enum_items
, list
)
697 e
= psi_decl_enum_init(N
->text
, list
);
702 * decl_enum_items: item
704 PARSE_TYPED(decl_enum_items
, l
,
705 TYPED(decl_enum_item
, i
)) {
706 l
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_enum_item_free
),
711 * decl_enum_items: items , item
713 PARSE_TYPED(decl_enum_items
, l
,
714 TYPED(decl_enum_items
, l_
)
716 TYPED(decl_enum_item
, i
)) {
717 l
= psi_plist_add(l_
, &i
);
721 * decl_enum_item: name = num_exp
723 PARSE_TYPED(decl_enum_item
, i
,
726 TYPED(num_exp
, num
)) {
727 i
= psi_decl_enum_item_init(N
->text
, num
);
732 * decl_enum_item: name
734 PARSE_TYPED(decl_enum_item
, i
,
736 i
= psi_decl_enum_item_init(N
->text
, NULL
);
742 * decl_struct_args_block: { args }
744 PARSE_TYPED(decl_struct_args_block
, args_
,
746 TYPED(struct_args
, args
)
752 * decl_struct_args: args_block
754 PARSE_TYPED(decl_struct_args
, args_
,
755 TYPED(decl_struct_args_block
, args
)) {
760 * decl_struct_args: ;
762 PARSE_TYPED(decl_struct_args
, args_
,
764 args_
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
768 * decl_struct: STRUCT name align_and_size struct_args
770 PARSE_TYPED(decl_struct
, strct
,
773 TYPED(align_and_size
, as
)
774 TYPED(decl_struct_args
, args
)) {
775 strct
= psi_decl_struct_init(N
->text
, args
);
776 strct
->align
= as
.pos
;
777 strct
->size
= as
.len
;
782 * decl_union: UNION name align_and_size struct_args
784 PARSE_TYPED(decl_union
, u
,
787 TYPED(align_and_size
, as
)
788 TYPED(decl_struct_args
, args
)) {
789 u
= psi_decl_union_init(N
->text
, args
);
796 * const_type: const_type_token
798 PARSE_TYPED(const_type
, type_
,
799 NAMED(const_type_token
, T
)) {
800 type_
= psi_const_type_init(T
->type
, T
->text
);
805 * constant: CONST const_type NSNAME = def_val ;
807 PARSE_TYPED(constant
, constant
,
809 TYPED(const_type
, type
)
812 TYPED(impl_def_val
, val
)
814 constant
= psi_const_init(type
, T
->text
, val
);
819 * decl_typdef: TYPEDEF typedef_body ;
821 PARSE_TYPED(decl_typedef
, def
,
823 TYPED(decl_typedef_body
, def_
)
830 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
832 PARSE_TYPED(decl_typedef_body_ex
, def
,
833 NAMED(struct_name
, N
)
834 TYPED(align_and_size
, as
)
835 TYPED(decl_struct_args_block
, args
)
836 TYPED(decl_var
, var
)) {
837 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT
, N
->text
), var
);
838 def
->type
->token
= psi_token_copy(N
);
839 def
->type
->real
.strct
= psi_decl_struct_init(N
->text
, args
);
840 def
->type
->real
.strct
->token
= N
;
841 def
->type
->real
.strct
->align
= as
.pos
;
842 def
->type
->real
.strct
->size
= as
.len
;
846 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
848 PARSE_TYPED(decl_typedef_body_ex
, def
,
850 TYPED(align_and_size
, as
)
851 TYPED(decl_struct_args_block
, args
)
852 TYPED(decl_var
, var
)) {
853 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION
, N
->text
), var
);
854 def
->type
->token
= psi_token_copy(N
);
855 def
->type
->real
.unn
= psi_decl_union_init(N
->text
, args
);
856 def
->type
->real
.unn
->token
= N
;
857 def
->type
->real
.unn
->align
= as
.pos
;
858 def
->type
->real
.unn
->size
= as
.len
;
862 * decl_typedef_body_ex: decl_enum NAME
864 PARSE_TYPED(decl_typedef_body_ex
, def
,
866 NAMED(NAME
, ALIAS
)) {
867 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM
, e
->name
), psi_decl_var_init(ALIAS
->text
, 0, 0));
868 def
->var
->token
= ALIAS
;
869 def
->type
->token
= psi_token_copy(e
->token
);
870 def
->type
->real
.enm
= e
;
874 * decl_typedef_body: decl_typedef_body_ex
876 PARSE_TYPED(decl_typedef_body
, def
,
877 TYPED(decl_typedef_body_ex
, def_
)) {
882 * decl_typedef_body_fn_args: ( decl_args )
884 PARSE_TYPED(decl_typedef_body_fn_args
, args
,
886 TYPED(decl_args
, args_
)
892 * decl_typedef_body: decl_func decl_typedef_body_fn_args
894 PARSE_TYPED(decl_typedef_body
, def
,
895 TYPED(decl_func
, func_
)
896 TYPED(decl_typedef_body_fn_args
, args
)) {
897 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
), psi_decl_var_copy(func_
->var
));
898 def
->type
->token
= psi_token_copy(func_
->token
);
899 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
903 * decl_typedef_body: decl_arg
905 PARSE_TYPED(decl_typedef_body
, def
,
906 TYPED(decl_arg
, arg
)) {
911 * decl: decl_abi decl_func ( decl_args ) ;
913 PARSE_TYPED(decl
, decl
,
915 TYPED(decl_func
, func
)
917 TYPED(decl_args
, args
)
920 decl
= psi_decl_init(abi
, func
, args
);
924 * decl: decl_abi decl_func ( decl_args , ... ) ;
926 PARSE_TYPED(decl
, decl
,
928 TYPED(decl_func
, func
)
930 TYPED(decl_args
, args
)
935 decl
= psi_decl_init(abi
, func
, args
);
940 * decl_func: decl_arg
942 PARSE_TYPED(decl_func
, func
,
943 TYPED(decl_arg
, arg
)) {
947 /* special case for void functions */
949 * decl_func: VOID NAME
951 PARSE_TYPED(decl_func
, func
,
954 func
= psi_decl_arg_init(
955 psi_decl_type_init(T
->type
, T
->text
),
956 psi_decl_var_init(N
->text
, 0, 0)
958 func
->type
->token
= T
;
959 func
->var
->token
= N
;
964 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
966 PARSE_TYPED(decl_typedef_body
, def
,
968 TYPED(indirection
, decl_i
)
970 TYPED(indirection
, type_i
)
973 TYPED(decl_typedef_body_fn_args
, args
)) {
974 struct psi_decl_arg
*func_
= psi_decl_arg_init(
975 psi_decl_type_init(T
->type
, T
->text
),
976 psi_decl_var_init(N
->text
, decl_i
, 0)
978 func_
->type
->token
= T
;
979 func_
->var
->token
= N
;
982 def
= psi_decl_arg_init(
983 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
984 psi_decl_var_copy(func_
->var
)
986 def
->var
->pointer_level
= type_i
;
987 def
->type
->token
= psi_token_copy(func_
->token
);
988 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
992 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
994 PARSE_TYPED(decl_typedef_body
, def
,
997 TYPED(pointers
, decl_i
)
999 TYPED(indirection
, type_i
)
1002 TYPED(decl_typedef_body_fn_args
, args
)) {
1003 struct psi_decl_arg
*func_
= psi_decl_arg_init(
1004 psi_decl_type_init(T
->type
, T
->text
),
1005 psi_decl_var_init(N
->text
, decl_i
, 0)
1007 func_
->type
->token
= T
;
1008 func_
->var
->token
= N
;
1011 def
= psi_decl_arg_init(
1012 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
1013 psi_decl_var_copy(func_
->var
)
1015 def
->var
->pointer_level
= type_i
;
1016 def
->type
->token
= psi_token_copy(func_
->token
);
1017 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
1023 PARSE_TYPED(decl_abi
, abi
,
1025 abi
= psi_decl_abi_init(T
->text
);
1030 * decl_var_array_size: <empty>
1032 PARSE_NAMED(decl_var_array_size
, as
, ) {
1037 * decl_var_array_size: [ NUMBER ]
1039 PARSE_NAMED(decl_var_array_size
, as
,
1047 * decl_var: NAME decl_var_array_size
1049 PARSE_TYPED(decl_var
, var
,
1051 NAMED(decl_var_array_size
, as
)) {
1052 var
= psi_decl_var_init(T
->text
, 0, as
?atol(as
->text
):0);
1060 * decl_var: pointers NAME
1062 PARSE_TYPED(decl_var
, var
,
1065 NAMED(decl_var_array_size
, as
)) {
1066 var
= psi_decl_var_init(T
->text
, p
+!!as
, as
?atol(as
->text
):0);
1074 * decl_vars: decl_var
1076 PARSE_TYPED(decl_vars
, vars
,
1077 TYPED(decl_var
, var
)) {
1078 vars
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_var_free
),
1083 * decl_vars: decl_vars , decl_var
1085 PARSE_TYPED(decl_vars
, vars
,
1086 TYPED(decl_vars
, vars_
)
1088 TYPED(decl_var
, var
)) {
1089 vars
= psi_plist_add(vars_
, &var
);
1093 * decl_arg: const_decl_type decl_var
1095 PARSE_TYPED(decl_arg
, arg_
,
1096 TYPED(const_decl_type
, type
)
1097 TYPED(decl_var
, var
)) {
1098 arg_
= psi_decl_arg_init(type
, var
);
1102 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
1104 PARSE_TYPED(decl_typedef_body
, def
,
1105 TYPED(const_decl_type
, type_
)
1106 TYPED(indirection
, decl_i
)
1108 TYPED(indirection
, type_i
)
1111 TYPED(decl_typedef_body_fn_args
, args
)) {
1112 struct psi_decl_arg
*func_
= psi_decl_arg_init(
1114 psi_decl_var_init(N
->text
, decl_i
, 0)
1116 func_
->var
->token
= N
;
1119 def
= psi_decl_arg_init(
1120 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
1121 psi_decl_var_copy(func_
->var
)
1123 def
->var
->pointer_level
= type_i
;
1124 def
->type
->token
= psi_token_copy(func_
->token
);
1125 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
1128 /* void pointers need a specific rule */
1130 * decl_arg: VOID pointers NAME
1132 PARSE_TYPED(decl_arg
, arg_
,
1136 arg_
= psi_decl_arg_init(
1137 psi_decl_type_init(T
->type
, T
->text
),
1138 psi_decl_var_init(N
->text
, p
, 0)
1140 arg_
->type
->token
= T
;
1141 arg_
->var
->token
= N
;
1146 * decl_args: CONST VOID pointers NAME
1148 PARSE_TYPED(decl_arg
, arg_
,
1153 arg_
= psi_decl_arg_init(
1154 psi_decl_type_init(T
->type
, T
->text
),
1155 psi_decl_var_init(N
->text
, p
, 0)
1157 arg_
->type
->token
= T
;
1158 arg_
->var
->token
= N
;
1163 * decl_args: <empty>
1165 PARSE_TYPED(decl_args
, args
, ) {
1172 PARSE_TYPED(decl_args
, args
,
1178 * decl_args: decl_arg
1180 PARSE_TYPED(decl_args
, args
,
1181 TYPED(decl_arg
, arg
)) {
1182 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
1187 * decl_args: decl_args , decl_arg
1189 PARSE_TYPED(decl_args
, args
,
1190 TYPED(decl_args
, args_
)
1192 TYPED(decl_arg
, arg
)) {
1193 args
= psi_plist_add(args_
, &arg
);
1197 * struct_args: struct_arg
1199 PARSE_TYPED(struct_args
, args
,
1200 TYPED(struct_arg
, arg
)) {
1201 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
1206 * struct_args: struct_args , struct_arg
1208 PARSE_TYPED(struct_args
, args
,
1209 TYPED(struct_args
, args_
)
1210 TYPED(struct_arg
, arg
)) {
1211 args
= psi_plist_add(args_
, &arg
);
1215 * struct_arg: decl_typedef_body_ex ;
1217 PARSE_TYPED(struct_arg
, arg_
,
1218 TYPED(decl_typedef_body_ex
, def
)
1221 switch (def
->type
->type
) {
1223 if (def
->type
->real
.strct
) {
1225 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
1227 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
1231 if (def
->type
->real
.unn
) {
1233 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
1235 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
1239 if (def
->type
->real
.enm
) {
1241 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
1243 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
1250 * struct_arg: decl_arg decl_layout ;
1252 PARSE_TYPED(struct_arg
, arg
,
1253 TYPED(decl_arg
, arg_
)
1254 TYPED(decl_layout
, layout_
)
1256 arg_
->layout
= layout_
;
1261 * decl_layout: <empty>
1263 PARSE_TYPED(decl_layout
, layout
, ) {
1268 * decl_layout: :: ( NUMBER , NUMBER )
1270 PARSE_TYPED(decl_layout
, layout
,
1278 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
1283 /* un/signed, urgh */
1285 * decl_scalar_type: CHAR
1287 PARSE_NAMED(decl_scalar_type
, type_
,
1293 * decl_scalar_type: SHORT decl_scalar_type_short
1295 PARSE_NAMED(decl_scalar_type
, type_
,
1297 NAMED(decl_scalar_type_short
, s
)) {
1299 type_
= psi_token_cat(" ", 2, S
, s
);
1308 * decl_scalar_type_short: <empty>
1310 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1315 * decl_scalar_type_short: INT
1317 PARSE_NAMED(decl_scalar_type_short
, s
,
1323 * decl_sclara_type: INT
1325 PARSE_NAMED(decl_scalar_type
, type_
,
1331 * decl_scalar_type: LONG decl_scalar_type_long
1333 PARSE_NAMED(decl_scalar_type
, type_
,
1335 NAMED(decl_scalar_type_long
, l
)) {
1337 type_
= psi_token_cat(" ", 2, L
, l
);
1346 * decl_scalar_type_long: <empty>
1348 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1353 * decl_scalar_type_long: DOUBLE
1355 PARSE_NAMED(decl_scalar_type_long
, l
,
1361 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1363 PARSE_NAMED(decl_scalar_type_long
, l
,
1365 NAMED(decl_scalar_type_long_long
, ll
)) {
1367 l
= psi_token_cat(" ", 2, L
, ll
);
1376 * decl_scalar_type_long_long: <empty>
1378 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1383 * decl_scalar_type_long_long: INT
1385 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1391 * decl_type: UNSIGNED decl_scalar_type
1393 PARSE_TYPED(decl_type
, type_
,
1395 NAMED(decl_scalar_type
, N
)) {
1396 struct psi_token
*T
= psi_token_cat(" ", 2, U
, N
);
1397 type_
= psi_decl_type_init(T
->type
, T
->text
);
1404 * decl_type: SIGNED decl_scalar_type
1406 PARSE_TYPED(decl_type
, type_
,
1408 NAMED(decl_scalar_type
, N
)) {
1409 struct psi_token
*T
= psi_token_cat(" ", 2, S
, N
);
1410 type_
= psi_decl_type_init(T
->type
, T
->text
);
1417 * decl_type: UNSIGNED
1419 PARSE_TYPED(decl_type
, type_
,
1420 NAMED(UNSIGNED
, U
)) {
1421 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1428 PARSE_TYPED(decl_type
, type_
,
1430 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1435 * decl_type: decl_scalar_type
1437 PARSE_TYPED(decl_type
, type_
,
1438 NAMED(decl_scalar_type
, N
)) {
1439 type_
= psi_decl_type_init(N
->type
, N
->text
);
1445 * decl_type: STRUCT NAME
1447 PARSE_TYPED(decl_type
, type_
,
1450 type_
= psi_decl_type_init(S
->type
, T
->text
);
1456 * decl_type: UNION NAME
1458 PARSE_TYPED(decl_type
, type_
,
1461 type_
= psi_decl_type_init(U
->type
, T
->text
);
1467 * decl_type: ENUM NAME
1469 PARSE_TYPED(decl_type
, type_
,
1472 type_
= psi_decl_type_init(E
->type
, T
->text
);
1478 * decl_type: decl_type_token
1480 PARSE_TYPED(decl_type
, type_
,
1481 NAMED(decl_type_token
, T
)) {
1482 type_
= psi_decl_type_init(T
->type
, T
->text
);
1487 * const_decl_type: decl_type
1489 PARSE_TYPED(const_decl_type
, type
,
1490 TYPED(decl_type
, type_
)) {
1495 * const_decl_type: CONST decl_type
1497 PARSE_TYPED(const_decl_type
, type
,
1499 TYPED(decl_type
, type_
)) {
1504 * impl: impl_func { impl_stmts }
1506 PARSE_TYPED(impl
, impl
,
1507 TYPED(impl_func
, func
)
1509 TYPED(impl_stmts
, stmts
)
1511 impl
= psi_impl_init(func
, stmts
);
1515 * impl: STATIC impl_func { impl_stmts }
1517 PARSE_TYPED(impl
, impl
,
1519 TYPED(impl_func
, func
)
1521 TYPED(impl_stmts
, stmts
)
1523 func
->static_memory
= 1;
1524 impl
= psi_impl_init(func
, stmts
);
1528 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1530 PARSE_TYPED(impl_func
, func
,
1537 TYPED(impl_type
, type
)) {
1538 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1540 func
->return_reference
= r
;
1544 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1546 PARSE_TYPED(impl_func
, func
,
1551 TYPED(impl_args
, args
)
1554 TYPED(impl_type
, type
)) {
1555 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1557 func
->return_reference
= r
;
1561 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1563 PARSE_TYPED(impl_func
, func
,
1565 TYPED(reference
, func_r
)
1568 TYPED(impl_args
, args
)
1570 TYPED(impl_type
, va_type
)
1571 TYPED(reference
, va_r
)
1573 NAMED(DOLLAR_NAME
, T
)
1576 TYPED(impl_type
, func_type
)) {
1577 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1579 func
->return_reference
= func_r
;
1580 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1585 * impl_def_val: impl_def_val_token
1587 PARSE_TYPED(impl_def_val
, def
,
1588 NAMED(impl_def_val_token
, T
)) {
1589 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1594 * impl_var: reference DOLLAR_NAME
1596 PARSE_TYPED(impl_var
, var
,
1598 NAMED(DOLLAR_NAME
, T
)) {
1599 var
= psi_impl_var_init(T
->text
, r
);
1604 * impl_type: impl_type_token
1606 PARSE_TYPED(impl_type
, type_
,
1607 NAMED(impl_type_token
, T
)) {
1608 type_
= psi_impl_type_init(T
->type
, T
->text
);
1613 * impl_arg: impl_type impl_var
1615 PARSE_TYPED(impl_arg
, arg
,
1616 TYPED(impl_type
, type
)
1617 TYPED(impl_var
, var
)) {
1618 arg
= psi_impl_arg_init(type
, var
, NULL
);
1622 * impl_arg: impl_type impl_var = impl_def_val
1624 PARSE_TYPED(impl_arg
, arg
,
1625 TYPED(impl_type
, type
)
1626 TYPED(impl_var
, var
)
1628 TYPED(impl_def_val
, def
)) {
1629 arg
= psi_impl_arg_init(type
, var
, def
);
1633 * impl_args: impl_arg
1635 PARSE_TYPED(impl_args
, args
,
1636 TYPED(impl_arg
, arg
)) {
1637 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1642 * impl_args: impl_args , impl_arg
1644 PARSE_TYPED(impl_args
, args
,
1645 TYPED(impl_args
, args_
)
1647 TYPED(impl_arg
, arg
)) {
1648 args
= psi_plist_add(args_
, &arg
);
1652 * impl_stmts: impl_stmt
1654 PARSE_TYPED(impl_stmts
, stmts
,
1655 TYPED(impl_stmt
, stmt
)) {
1656 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1661 * impl_stmts: impl_stmts , impl_stmt
1663 PARSE_TYPED(impl_stmts
, stmts
,
1664 TYPED(impl_stmts
, stmts_
)
1665 TYPED(impl_stmt
, stmt
)) {
1666 stmts
= psi_plist_add(stmts_
, &stmt
);
1670 * impl_stmt: return_stmt
1672 PARSE_TYPED(impl_stmt
, i
,
1673 TYPED(return_stmt
, r
)) {
1674 i
= (struct psi_token
**) r
;
1678 * impl_stmt: let_stmt
1680 PARSE_TYPED(impl_stmt
, i
,
1681 TYPED(let_stmt
, l
)) {
1682 i
= (struct psi_token
**) l
;
1686 * impl_stmt: set_stmt
1688 PARSE_TYPED(impl_stmt
, i
,
1689 TYPED(set_stmt
, s
)) {
1690 i
= (struct psi_token
**) s
;
1694 * impl_stmt: assert_stmt
1696 PARSE_TYPED(impl_stmt
, i
,
1697 TYPED(assert_stmt
, s
)) {
1698 i
= (struct psi_token
**) s
;
1702 * impl_stmt: free_stmt
1704 PARSE_TYPED(impl_stmt
, i
,
1705 TYPED(free_stmt
, f
)) {
1706 i
= (struct psi_token
**) f
;
1710 * number: number_token
1712 PARSE_TYPED(number
, exp
,
1713 NAMED(number_token
, tok
)) {
1714 exp
= psi_number_init(tok
->type
, tok
->text
);
1721 PARSE_TYPED(number
, exp
,
1722 TYPED(decl_var
, var
)) {
1723 exp
= psi_number_init(PSI_T_NAME
, var
);
1724 exp
->token
= psi_token_copy(var
->token
);
1730 PARSE_TYPED(num_exp
, exp
,
1731 TYPED(number
, num
)) {
1732 exp
= psi_num_exp_init_num(num
);
1733 exp
->token
= psi_token_copy(num
->token
);
1737 * num_exp: ( num_exp )
1739 PARSE_TYPED(num_exp
, exp
,
1741 TYPED(num_exp
, exp_
)
1743 exp
= psi_num_exp_init_unary(PSI_T_LPAREN
, exp_
);
1748 * num_exp: num_exp binary_op_token num_exp
1750 PARSE_TYPED(num_exp
, exp
,
1751 TYPED(num_exp
, lhs_
)
1752 NAMED(binary_op_token
, OP
)
1753 TYPED(num_exp
, rhs_
)) {
1754 exp
= psi_num_exp_init_binary(OP
->type
, lhs_
, rhs_
);
1759 * num_exp: unary_op_token num_exp
1761 PARSE_TYPED(num_exp
, exp
,
1762 NAMED(unary_op_token
, OP
)
1763 TYPED(num_exp
, exp_
)) {
1764 exp
= psi_num_exp_init_unary(OP
->type
, exp_
);
1771 PARSE_TYPED(let_exp
, val
,
1773 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1779 PARSE_TYPED(let_exp
, val
,
1782 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1783 val
->is_reference
= 1;
1789 PARSE_TYPED(let_exp
, val
,
1790 TYPED(let_callback
, cb
)) {
1791 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1797 PARSE_TYPED(let_exp
, val
,
1798 TYPED(let_calloc
, ca
)) {
1799 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1805 PARSE_TYPED(let_exp
, val
,
1807 TYPED(let_calloc
, ca
)) {
1808 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1809 val
->is_reference
= 1;
1815 PARSE_TYPED(let_exp
, val
,
1816 TYPED(let_func
, fn
)) {
1817 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1823 PARSE_TYPED(let_exp
, val
,
1825 TYPED(let_func
, fn
)) {
1826 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1827 val
->is_reference
= 1;
1833 PARSE_TYPED(let_exp
, val
,
1834 TYPED(num_exp
, exp
)) {
1835 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1839 * let_exp: & num_exp
1841 PARSE_TYPED(let_exp
, val
,
1843 TYPED(num_exp
, exp
)) {
1844 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1845 val
->is_reference
= 1;
1849 * let_exp: decl_var = let_exp
1851 PARSE_TYPED(let_exp
, exp
,
1852 TYPED(decl_var
, var_
)
1854 TYPED(let_exp
, val
)) {
1860 * let_stmt: LET let_exp ;
1862 PARSE_TYPED(let_stmt
, let
,
1866 let
= psi_let_stmt_init(val
);
1871 * let_stmt: TEMP decl_var = reference decl_var ;
1873 PARSE_TYPED(let_stmt
, let
,
1875 TYPED(decl_var
, var
)
1878 TYPED(decl_var
, val_
)
1880 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1882 let
->exp
->is_reference
= r
? 1 : 0;
1886 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1888 PARSE_TYPED(let_callback
, cb
,
1890 NAMED(callback_rval
, F
)
1892 TYPED(impl_var
, var
)
1894 TYPED(callback_arg_list
, args_
)
1897 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1903 * let_calloc: CALLOC ( num_exp , num_exp )
1905 PARSE_TYPED(let_calloc
, alloc
,
1908 TYPED(num_exp
, nmemb
)
1910 TYPED(num_exp
, size
)
1912 alloc
= psi_let_calloc_init(nmemb
, size
);
1917 * let_func: let_func_token ( impl_var )
1919 PARSE_TYPED(let_func
, func
,
1920 NAMED(let_func_token
, T
)
1922 TYPED(impl_var
, var
)
1924 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1928 * let_func: let_func_token ( impl_var , let_exps )
1930 PARSE_TYPED(let_func
, func
,
1931 NAMED(let_func_token
, T
)
1933 TYPED(impl_var
, var
)
1935 TYPED(let_exps
, vals
)
1937 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1944 PARSE_TYPED(let_exps
, exps
,
1945 TYPED(let_exp
, exp
)) {
1946 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1950 * let_exps: let_exps , let_exp
1952 PARSE_TYPED(let_exps
, exps
,
1953 TYPED(let_exps
, exps_
)
1955 TYPED(let_exp
, exp
)) {
1956 exps
= psi_plist_add(exps_
, &exp
);
1960 * callback_arg_list: <empty>
1962 PARSE_TYPED(callback_arg_list
, args
, ) {
1967 * callback_arg_list: callback_args
1969 PARSE_TYPED(callback_arg_list
, args
,
1970 TYPED(callback_args
, args_
)) {
1975 * callback_args: set_exp
1977 PARSE_TYPED(callback_args
, args
,
1978 TYPED(set_exp
, val
)) {
1979 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1984 * callback_args: callback_args , set_exp
1986 PARSE_TYPED(callback_args
, args
,
1987 TYPED(callback_args
, args_
)
1989 TYPED(set_exp
, val
)) {
1990 args
= psi_plist_add(args_
, &val
);
1994 * callback_rval: let_func_token
1996 PARSE_NAMED(callback_rval
, rval
,
1997 NAMED(let_func_token
, F
)) {
2002 * callback_rval: VOID
2004 PARSE_NAMED(callback_rval
, rval
,
2011 * set_func: set_func_token ( decl_var )
2013 PARSE_TYPED(set_func
, func
,
2014 NAMED(set_func_token
, T
)
2016 TYPED(decl_var
, var
)
2018 func
= psi_set_func_init(T
->type
, T
->text
, var
);
2023 * set_func: set_func_token ( decl_var , set_exps )
2025 PARSE_TYPED(set_func
, func
,
2026 NAMED(set_func_token
, T
)
2028 TYPED(decl_var
, var
)
2030 TYPED(set_exps
, vals
)
2032 func
= psi_set_func_init(T
->type
, T
->text
, var
);
2038 * set_func: set_func_token ( decl_var , ... )
2040 PARSE_TYPED(set_func
, func
,
2041 NAMED(set_func_token
, T
)
2043 TYPED(decl_var
, var
)
2047 func
= psi_set_func_init(T
->type
, T
->text
, var
);
2049 func
->recursive
= 1;
2055 PARSE_TYPED(set_exp
, val
,
2056 TYPED(set_func
, fn
)) {
2057 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
2063 PARSE_TYPED(set_exp
, val
,
2064 TYPED(num_exp
, num
)) {
2065 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
2071 PARSE_TYPED(set_exps
, exps
,
2072 TYPED(set_exp
, exp
)) {
2073 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
2078 * set_exps: set_exps , set_exp
2080 PARSE_TYPED(set_exps
, exps
,
2081 TYPED(set_exps
, exps_
)
2083 TYPED(set_exp
, exp
)) {
2084 exps
= psi_plist_add(exps_
, &exp
);
2088 * set_exp: impl_var = set_exp
2090 PARSE_TYPED(set_exp
, exp
,
2091 TYPED(impl_var
, var_
)
2093 TYPED(set_exp
, val
)) {
2099 * set_stmt: SET set_exp ;
2101 PARSE_TYPED(set_stmt
, set
,
2105 set
= psi_set_stmt_init(exp
);
2110 * return_stmt: RETURN set_exp ;
2112 PARSE_TYPED(return_stmt
, ret
,
2114 TYPED(set_func
, func
)
2116 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
2121 * free_stmt: FREE free_exps ;
2123 PARSE_TYPED(free_stmt
, free
,
2125 TYPED(free_exps
, calls
)
2127 free
= psi_free_stmt_init(calls
);
2132 * free_exps: free_exp
2134 PARSE_TYPED(free_exps
, calls
,
2135 TYPED(free_exp
, call
)) {
2136 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
2141 * free_exps: free_exps , free_exp
2143 PARSE_TYPED(free_exps
, calls
,
2144 TYPED(free_exps
, calls_
)
2146 TYPED(free_exp
, call
)) {
2147 calls
= psi_plist_add(calls_
, &call
);
2151 * free_exp: NAME ( decl_vars )
2153 PARSE_TYPED(free_exp
, call
,
2156 TYPED(decl_vars
, vars
)
2158 call
= psi_free_exp_init(F
->text
, vars
);
2163 * assert_stmt: assert_stmt_token num_exp ;
2165 PARSE_TYPED(assert_stmt
, ass
,
2166 NAMED(assert_stmt_token
, T
)
2169 ass
= psi_assert_stmt_init(T
->type
, exp
);
2174 * reference: <empty>
2176 PARSE_TYPED(reference
, r
, ) {
2183 PARSE_TYPED(reference
, r
,
2189 * indirection: <empty>
2191 PARSE_TYPED(indirection
, i
, ){
2196 * indirection: pointers
2198 PARSE_TYPED(indirection
, i
,
2199 TYPED(pointers
, p
)) {
2206 PARSE_TYPED(pointers
, p
,
2212 * pointers: pointers *
2214 PARSE_TYPED(pointers
, p
,