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 #define CONCAT2(x,y) x##y
27 #define CONCAT1(x,y) CONCAT2(x,y)
28 #define COUNTED(x) CONCAT1(parse_ ##x## _, __LINE__)
31 # define DEF(dn, dv) dn dv
32 # define PASS(nt, rule) nt ::= rule.
33 # define PARSE(nt, rule) nt ::= rule.
34 # define PARSE_NAMED(nt, nt_name, rule) NAMED(nt, nt_name) ::= rule.
35 # define PARSE_TYPED(nt, nt_name, rule) TYPED(nt, nt_name) ::= rule.
37 # define NAMED(t, name) t(name)
38 # define TYPED(t, name) t(name)
39 # define TOKEN_TYPE(token, type_) %type token {type_}
40 # define TOKEN_DTOR(token, dtor) %destructor token {dtor}
47 # define PASS(nt, rule) \
48 static void COUNTED(nt) (struct psi_parser *P) { \
51 # define PARSE(nt, rule) \
52 static void COUNTED(nt) (struct psi_parser *P rule)
53 # define PARSE_NAMED(nt, nt_name, rule) \
54 static void COUNTED(nt) (struct psi_parser *P NAMED(nt, nt_name) rule)
55 # define PARSE_TYPED(nt, nt_name, rule) \
56 static void COUNTED(nt) (struct psi_parser *P TYPED(nt, nt_name) rule)
58 # define NAMED(t, name) , struct psi_token *name
59 # define TYPED(t, name) , TOKEN_TYPE_NAME(t) name
60 # define TOKEN_TYPE_NAME(token) token##_parse_t
61 # define TOKEN_TYPE(token, type) typedef type TOKEN_TYPE_NAME(token);
62 # define TOKEN_DTOR(token, dtor)
65 DEF(%name
, psi_parser_proc_
)
66 DEF(%token_prefix
, PSI_T_
)
67 DEF(%token_type
, {struct psi_token
*})
68 DEF(%token_destructor
, {free($$
);})
69 DEF(%default_destructor
, {(void)P
;})
70 DEF(%extra_argument
, {struct psi_parser
*P
})
72 /* TOKEN is defined inside syntax_error */
75 if (TOKEN
&& TOKEN
->type
!= PSI_T_EOF
) {
76 psi_error(PSI_WARNING
, TOKEN
->file
, TOKEN
->line
, "PSI syntax error: Unexpected token '%s' at pos %u", TOKEN
->text
, TOKEN
->col
);
78 psi_error(PSI_WARNING
, P
->file
.fn
, P
->line
, "PSI syntax error: Unexpected end of input");
82 DEF(%token_class
, const_type_token BOOL INT FLOAT STRING
.)
83 DEF(%token_class
, decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME
.)
84 DEF(%token_class
, impl_def_val_token NULL NUMBER TRUE FALSE QUOTED_STRING
.)
85 DEF(%token_class
, number_token NUMBER NSNAME
.)
86 DEF(%token_class
, num_exp_binary_op_token PIPE CARET AMPERSAND LSHIFT RSHIFT PLUS MINUS ASTERISK SLASH MODULO
.)
87 DEF(%token_class
, num_exp_unary_op_token TILDE NOT PLUS MINUS
.)
88 DEF(%token_class
, let_func_token ZVAL OBJVAL ARRVAL PATHVAL STRLEN STRVAL FLOATVAL INTVAL BOOLVAL COUNT
.)
89 DEF(%token_class
, set_func_token TO_OBJECT TO_ARRAY TO_STRING TO_INT TO_FLOAT TO_BOOL ZVAL VOID
.)
90 DEF(%token_class
, impl_type_token VOID MIXED BOOL INT FLOAT STRING ARRAY OBJECT CALLABLE
.)
93 DEF(%right
, NOT TILDE
.)
96 DEF(%left
, AMPERSAND
.)
97 DEF(%left
, LSHIFT RSHIFT
.)
98 DEF(%left
, PLUS MINUS
.)
99 DEF(%left
, ASTERISK SLASH MODULO
.)
101 DEF(%left, ASTERISK SLASH MODULO.)
102 DEF(%left, PLUS MINUS.)
103 DEF(%left, LSHIFT RSHIFT.)
104 DEF(%left, AMPERSAND.)
108 DEF(%fallback
, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT
.)
110 TOKEN_TYPE(decl_enum
, struct psi_decl_enum
*)
111 TOKEN_DTOR(decl_enum
, psi_decl_enum_free(&$$
);)
112 TOKEN_TYPE(decl_enum_items
, struct psi_plist
*)
113 TOKEN_DTOR(decl_enum_items
, psi_plist_free($$
);)
114 TOKEN_TYPE(decl_enum_item
, struct psi_decl_enum_item
*)
115 TOKEN_DTOR(decl_enum_item
, psi_decl_enum_item_free(&$$
);)
116 TOKEN_TYPE(decl_struct_args_block
, struct psi_plist
*)
117 TOKEN_DTOR(decl_struct_args_block
, psi_plist_free($$
);) /* there was a typo */
118 TOKEN_TYPE(decl_struct_args
, struct psi_plist
*)
119 TOKEN_DTOR(decl_struct_args
, psi_plist_free($$
);)
120 TOKEN_TYPE(decl_struct
, struct psi_decl_struct
*)
121 TOKEN_DTOR(decl_struct
, psi_decl_struct_free(&$$
);)
122 TOKEN_TYPE(align_and_size
, struct psi_layout
)
123 TOKEN_TYPE(decl_union
, struct psi_decl_union
*)
124 TOKEN_DTOR(decl_union
, psi_decl_union_free(&$$
);)
125 TOKEN_TYPE(const_type
, struct psi_const_type
*)
126 TOKEN_DTOR(const_type
, psi_const_type_free(&$$
);)
127 TOKEN_TYPE(constant
, struct psi_const
*)
128 TOKEN_DTOR(constant
, psi_const_free(&$$
);)
129 TOKEN_TYPE(decl_typedef
, struct psi_decl_arg
*)
130 TOKEN_DTOR(decl_typedef
, psi_decl_arg_free(&$$
);)
131 TOKEN_TYPE(decl_typedef_body_ex
, struct psi_decl_arg
*)
132 TOKEN_DTOR(decl_typedef_body_ex
, psi_decl_arg_free(&$$
);)
133 TOKEN_TYPE(decl_typedef_body
, struct psi_decl_arg
*)
134 TOKEN_DTOR(decl_typedef_body
, psi_decl_arg_free(&$$
);)
135 TOKEN_TYPE(decl_typedef_body_fn_args
, struct psi_plist
*)
136 TOKEN_DTOR(decl_typedef_body_fn_args
, psi_plist_free($$
);)
137 TOKEN_TYPE(decl
, struct psi_decl
*)
138 TOKEN_DTOR(decl
, psi_decl_free(&$$
);)
139 TOKEN_TYPE(decl_func
, struct psi_decl_arg
*)
140 TOKEN_DTOR(decl_func
, psi_decl_arg_free(&$$
);)
141 TOKEN_TYPE(decl_abi
, struct psi_decl_abi
*)
142 TOKEN_DTOR(decl_abi
, psi_decl_abi_free(&$$
);)
143 TOKEN_TYPE(decl_var
, struct psi_decl_var
*)
144 TOKEN_DTOR(decl_var
, psi_decl_var_free(&$$
);)
145 TOKEN_TYPE(decl_vars
, struct psi_plist
*)
146 TOKEN_DTOR(decl_vars
, psi_plist_free($$
);)
147 TOKEN_TYPE(decl_arg
, struct psi_decl_arg
*)
148 TOKEN_DTOR(decl_arg
, psi_decl_arg_free(&$$
);)
149 TOKEN_TYPE(decl_args
, struct psi_plist
*)
150 TOKEN_DTOR(decl_args
, psi_plist_free($$
);)
151 TOKEN_TYPE(struct_args
, struct psi_plist
*)
152 TOKEN_DTOR(struct_args
, psi_plist_free($$
);)
153 TOKEN_TYPE(struct_arg
, struct psi_decl_arg
*)
154 TOKEN_DTOR(struct_arg
, psi_decl_arg_free(&$$
);)
155 TOKEN_TYPE(decl_layout
, struct psi_layout
*)
156 TOKEN_DTOR(decl_layout
, psi_layout_free(&$$
);)
157 TOKEN_TYPE(decl_type
, struct psi_decl_type
*)
158 TOKEN_DTOR(decl_type
, psi_decl_type_free(&$$
);)
159 TOKEN_TYPE(const_decl_type
, struct psi_decl_type
*)
160 TOKEN_DTOR(const_decl_type
, psi_decl_type_free(&$$
);)
161 TOKEN_TYPE(impl
, struct psi_impl
*)
162 TOKEN_DTOR(impl
, psi_impl_free(&$$
);)
163 TOKEN_TYPE(impl_func
, struct psi_impl_func
*)
164 TOKEN_DTOR(impl_func
, psi_impl_func_free(&$$
);)
165 TOKEN_TYPE(impl_def_val
, struct psi_impl_def_val
*)
166 TOKEN_DTOR(impl_def_val
, psi_impl_def_val_free(&$$
);)
167 TOKEN_TYPE(impl_var
, struct psi_impl_var
*)
168 TOKEN_DTOR(impl_var
, psi_impl_var_free(&$$
);)
169 TOKEN_TYPE(impl_arg
, struct psi_impl_arg
*)
170 TOKEN_DTOR(impl_arg
, psi_impl_arg_free(&$$
);)
171 TOKEN_TYPE(impl_args
, struct psi_plist
*)
172 TOKEN_DTOR(impl_args
, psi_plist_free($$
);)
173 TOKEN_TYPE(impl_vararg
, struct psi_impl_arg
*)
174 TOKEN_DTOR(impl_vararg
, psi_impl_arg_free(&$$
);)
175 TOKEN_TYPE(impl_stmts
, struct psi_plist
*)
176 TOKEN_DTOR(impl_stmts
, psi_plist_free($$
);)
177 TOKEN_TYPE(impl_stmt
, struct psi_token
**)
178 TOKEN_DTOR(impl_stmt
, psi_impl_stmt_free(&$$
);)
179 TOKEN_TYPE(number
, struct psi_number
*)
180 TOKEN_DTOR(number
, psi_number_free(&$$
);)
181 TOKEN_TYPE(num_exp
, struct psi_num_exp
*)
182 TOKEN_DTOR(num_exp
, psi_num_exp_free(&$$
);)
183 TOKEN_TYPE(let_stmt
, struct psi_let_stmt
*)
184 TOKEN_DTOR(let_stmt
, psi_let_stmt_free(&$$
);)
185 TOKEN_TYPE(let_calloc
, struct psi_let_calloc
*)
186 TOKEN_DTOR(let_calloc
, psi_let_calloc_free(&$$
);)
187 TOKEN_TYPE(let_func
, struct psi_let_func
*)
188 TOKEN_DTOR(let_func
, psi_let_func_free(&$$
);)
189 TOKEN_TYPE(callback_arg_list
, struct psi_plist
*)
190 TOKEN_DTOR(callback_arg_list
, psi_plist_free($$
);)
191 TOKEN_TYPE(callback_args
, struct psi_plist
*)
192 TOKEN_DTOR(callback_args
, psi_plist_free($$
);)
193 TOKEN_TYPE(let_callback
, struct psi_let_callback
*)
194 TOKEN_DTOR(let_callback
, psi_let_callback_free(&$$
);)
195 TOKEN_TYPE(let_exp
, struct psi_let_exp
*)
196 TOKEN_DTOR(let_exp
, psi_let_exp_free(&$$
);)
197 TOKEN_TYPE(let_exps
, struct psi_plist
*)
198 TOKEN_DTOR(let_exps
, psi_plist_free($$
);)
199 TOKEN_TYPE(set_stmt
, struct psi_set_stmt
*)
200 TOKEN_DTOR(set_stmt
, psi_set_stmt_free(&$$
);)
201 TOKEN_TYPE(set_exp
, struct psi_set_exp
*)
202 TOKEN_DTOR(set_exp
, psi_set_exp_free(&$$
);)
203 TOKEN_TYPE(set_exps
, struct psi_plist
*)
204 TOKEN_DTOR(set_exps
, psi_plist_free($$
);)
205 TOKEN_TYPE(set_func
, struct psi_set_func
*)
206 TOKEN_DTOR(set_func
, psi_set_func_free(&$$
);)
207 TOKEN_TYPE(return_stmt
, struct psi_return_stmt
*)
208 TOKEN_DTOR(return_stmt
, psi_return_stmt_free(&$$
);)
209 TOKEN_TYPE(free_stmt
, struct psi_free_stmt
*)
210 TOKEN_DTOR(free_stmt
, psi_free_stmt_free(&$$
);)
211 TOKEN_TYPE(free_exps
, struct psi_plist
*)
212 TOKEN_DTOR(free_exps
, psi_plist_free($$
);)
213 TOKEN_TYPE(free_exp
, struct psi_free_exp
*)
214 TOKEN_DTOR(free_exp
, psi_free_exp_free(&$$
);)
215 TOKEN_TYPE(impl_type
, struct psi_impl_type
*)
216 TOKEN_DTOR(impl_type
, psi_impl_type_free(&$$
);)
217 TOKEN_TYPE(reference
, bool)
218 TOKEN_TYPE(indirection
, unsigned)
219 TOKEN_TYPE(pointers
, unsigned)
223 PASS(blocks
, blocks block
)
229 * lib: LIB "soname" ;
231 PARSE(block
, NAMED(LIB
, token
) NAMED(QUOTED_STRING
, libname
) TOKEN(EOS
)) {
233 P
->error(PSI_DATA(P
), token
, PSI_WARNING
, "Extra 'lib %s' statement has no effect", libname
->text
);
235 P
->file
.ln
= strndup(libname
->text
+ 1, libname
->size
- 2);
241 PARSE(block
, TYPED(decl
, decl
)) {
243 P
->decls
= psi_plist_init((psi_plist_dtor
) psi_decl_free
);
245 P
->decls
= psi_plist_add(P
->decls
, &decl
);
248 PARSE(block
, TYPED(impl
, impl
)) {
250 P
->impls
= psi_plist_init((psi_plist_dtor
) psi_impl_free
);
252 P
->impls
= psi_plist_add(P
->impls
, &impl
);
255 PARSE(block
, TYPED(decl_typedef
, def
)) {
257 P
->types
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
259 P
->types
= psi_plist_add(P
->types
, &def
);
261 switch (def
->type
->type
) {
263 if (def
->type
->real
.strct
) {
265 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
267 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
271 if (def
->type
->real
.unn
) {
273 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
275 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
279 if (def
->type
->real
.enm
) {
281 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
283 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
289 PARSE(block
, TYPED(constant
, constant
)) {
291 P
->consts
= psi_plist_init((psi_plist_dtor
) psi_const_free
);
293 P
->consts
= psi_plist_add(P
->consts
, &constant
);
296 PARSE(block
, TYPED(decl_struct
, strct
)) {
298 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
300 P
->structs
= psi_plist_add(P
->structs
, &strct
);
303 PARSE(block
, TYPED(decl_union
, u
)) {
305 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
307 P
->unions
= psi_plist_add(P
->unions
, &u
);
310 PARSE(block
, TYPED(decl_enum
, e
)) {
312 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
314 P
->enums
= psi_plist_add(P
->enums
, &e
);
318 * optional_name: <empty>
320 PARSE_NAMED(optional_name
, n
, ) {
325 * optional_name: NAME
327 PARSE_NAMED(optional_name
, n
,
333 * align_and_size: <empty>
335 PARSE_TYPED(align_and_size
, as
, ) {
341 * align_and_size: :: ( NUMBER , NUMBER )
343 PARSE_TYPED(align_and_size
, as
,
351 as
.pos
= atol(A
->text
);
352 as
.len
= atol(S
->text
);
358 * enum_name: ENUM optional_name
360 PARSE_NAMED(enum_name
, n
,
362 NAMED(optional_name
, N
)) {
369 psi_token_hash(E
, digest
);
370 n
= psi_token_translit(psi_token_append(E
, 1, digest
), " ", "@");
375 * struct_name: STRUCT optional_name
377 PARSE_NAMED(struct_name
, n
,
379 NAMED(optional_name
, N
)) {
386 psi_token_hash(S
, digest
);
387 n
= psi_token_translit(psi_token_append(S
, 1, digest
), " ", "@");
392 * union_name: UNION optional_name
394 PARSE_NAMED(union_name
, n
,
396 NAMED(optional_name
, N
)) {
403 psi_token_hash(U
, digest
);
404 n
= psi_token_translit(psi_token_append(U
, 1, digest
), " ", "@");
409 * decl_enum: enum_name { items }
411 PARSE_TYPED(decl_enum
, e
,
414 TYPED(decl_enum_items
, list
)
416 e
= psi_decl_enum_init(N
->text
, list
);
421 * decl_enum_items: item
423 PARSE_TYPED(decl_enum_items
, l
,
424 TYPED(decl_enum_item
, i
)) {
425 l
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_enum_item_free
),
430 * decl_enum_items: items , item
432 PARSE_TYPED(decl_enum_items
, l
,
433 TYPED(decl_enum_items
, l_
)
435 TYPED(decl_enum_item
, i
)) {
436 l
= psi_plist_add(l_
, &i
);
440 * decl_enum_item: name = num_exp
442 PARSE_TYPED(decl_enum_item
, i
,
445 TYPED(num_exp
, num
)) {
446 i
= psi_decl_enum_item_init(N
->text
, num
);
451 * decl_enum_item: name
453 PARSE_TYPED(decl_enum_item
, i
,
455 i
= psi_decl_enum_item_init(N
->text
, NULL
);
461 * decl_struct_args_block: { args }
463 PARSE_TYPED(decl_struct_args_block
, args_
,
465 TYPED(struct_args
, args
)
471 * decl_struct_args: args_block
473 PARSE_TYPED(decl_struct_args
, args_
,
474 TYPED(decl_struct_args_block
, args
)) {
479 * decl_struct_args: ;
481 PARSE_TYPED(decl_struct_args
, args_
,
483 args_
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
487 * decl_struct: STRUCT name align_and_size struct_args
489 PARSE_TYPED(decl_struct
, strct
,
492 TYPED(align_and_size
, as
)
493 TYPED(decl_struct_args
, args
)) {
494 strct
= psi_decl_struct_init(N
->text
, args
);
495 strct
->align
= as
.pos
;
496 strct
->size
= as
.len
;
501 * decl_union: UNION name align_and_size struct_args
503 PARSE_TYPED(decl_union
, u
,
506 TYPED(align_and_size
, as
)
507 TYPED(decl_struct_args
, args
)) {
508 u
= psi_decl_union_init(N
->text
, args
);
515 * const_type: const_type_token
517 PARSE_TYPED(const_type
, type_
,
518 NAMED(const_type_token
, T
)) {
519 type_
= psi_const_type_init(T
->type
, T
->text
);
524 * constant: CONST const_type NSNAME = def_val ;
526 PARSE_TYPED(constant
, constant
,
528 TYPED(const_type
, type
)
531 TYPED(impl_def_val
, val
)
533 constant
= psi_const_init(type
, T
->text
, val
);
538 * decl_typdef: TYPEDEF typedef_body ;
540 PARSE_TYPED(decl_typedef
, def
,
542 TYPED(decl_typedef_body
, def_
)
549 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
551 PARSE_TYPED(decl_typedef_body_ex
, def
,
552 NAMED(struct_name
, N
)
553 TYPED(align_and_size
, as
)
554 TYPED(decl_struct_args_block
, args
)
555 TYPED(decl_var
, var
)) {
556 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT
, N
->text
), var
);
557 def
->type
->token
= psi_token_copy(N
);
558 def
->type
->real
.strct
= psi_decl_struct_init(N
->text
, args
);
559 def
->type
->real
.strct
->token
= N
;
560 def
->type
->real
.strct
->align
= as
.pos
;
561 def
->type
->real
.strct
->size
= as
.len
;
565 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
567 PARSE_TYPED(decl_typedef_body_ex
, def
,
569 TYPED(align_and_size
, as
)
570 TYPED(decl_struct_args_block
, args
)
571 TYPED(decl_var
, var
)) {
572 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION
, N
->text
), var
);
573 def
->type
->token
= psi_token_copy(N
);
574 def
->type
->real
.unn
= psi_decl_union_init(N
->text
, args
);
575 def
->type
->real
.unn
->token
= N
;
576 def
->type
->real
.unn
->align
= as
.pos
;
577 def
->type
->real
.unn
->size
= as
.len
;
581 * decl_typedef_body_ex: decl_enum NAME
583 PARSE_TYPED(decl_typedef_body_ex
, def
,
585 NAMED(NAME
, ALIAS
)) {
586 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM
, e
->name
), psi_decl_var_init(ALIAS
->text
, 0, 0));
587 def
->var
->token
= ALIAS
;
588 def
->type
->token
= psi_token_copy(e
->token
);
589 def
->type
->real
.enm
= e
;
593 * decl_typedef_body: decl_typedef_body_ex
595 PARSE_TYPED(decl_typedef_body
, def
,
596 TYPED(decl_typedef_body_ex
, def_
)) {
601 * decl_typedef_body_fn_args: ( decl_args )
603 PARSE_TYPED(decl_typedef_body_fn_args
, args
,
605 TYPED(decl_args
, args_
)
611 * decl_typedef_body: decl_func decl_typedef_body_fn_args
613 PARSE_TYPED(decl_typedef_body
, def
,
614 TYPED(decl_func
, func_
)
615 TYPED(decl_typedef_body_fn_args
, args
)) {
616 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
), psi_decl_var_copy(func_
->var
));
617 def
->type
->token
= psi_token_copy(func_
->token
);
618 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
622 * decl_typedef_body: decl_arg
624 PARSE_TYPED(decl_typedef_body
, def
,
625 TYPED(decl_arg
, arg
)) {
630 * decl: decl_abi decl_func ( decl_args ) ;
632 PARSE_TYPED(decl
, decl
,
634 TYPED(decl_func
, func
)
636 TYPED(decl_args
, args
)
639 decl
= psi_decl_init(abi
, func
, args
);
643 * decl: decl_abi decl_func ( decl_args , ... ) ;
645 PARSE_TYPED(decl
, decl
,
647 TYPED(decl_func
, func
)
649 TYPED(decl_args
, args
)
654 decl
= psi_decl_init(abi
, func
, args
);
659 * decl_func: decl_arg
661 PARSE_TYPED(decl_func
, func
,
662 TYPED(decl_arg
, arg
)) {
666 /* special case for void functions */
668 * decl_func: VOID NAME
670 PARSE_TYPED(decl_func
, func
,
673 func
= psi_decl_arg_init(
674 psi_decl_type_init(T
->type
, T
->text
),
675 psi_decl_var_init(N
->text
, 0, 0)
677 func
->type
->token
= T
;
678 func
->var
->token
= N
;
683 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
685 PARSE_TYPED(decl_typedef_body
, def
,
687 TYPED(indirection
, decl_i
)
689 TYPED(indirection
, type_i
)
692 TYPED(decl_typedef_body_fn_args
, args
)) {
693 struct psi_decl_arg
*func_
= psi_decl_arg_init(
694 psi_decl_type_init(T
->type
, T
->text
),
695 psi_decl_var_init(N
->text
, decl_i
, 0)
697 func_
->type
->token
= T
;
698 func_
->var
->token
= N
;
701 def
= psi_decl_arg_init(
702 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
703 psi_decl_var_copy(func_
->var
)
705 def
->var
->pointer_level
= type_i
;
706 def
->type
->token
= psi_token_copy(func_
->token
);
707 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
711 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
713 PARSE_TYPED(decl_typedef_body
, def
,
716 TYPED(pointers
, decl_i
)
718 TYPED(indirection
, type_i
)
721 TYPED(decl_typedef_body_fn_args
, args
)) {
722 struct psi_decl_arg
*func_
= psi_decl_arg_init(
723 psi_decl_type_init(T
->type
, T
->text
),
724 psi_decl_var_init(N
->text
, decl_i
, 0)
726 func_
->type
->token
= T
;
727 func_
->var
->token
= N
;
730 def
= psi_decl_arg_init(
731 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
732 psi_decl_var_copy(func_
->var
)
734 def
->var
->pointer_level
= type_i
;
735 def
->type
->token
= psi_token_copy(func_
->token
);
736 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
742 PARSE_TYPED(decl_abi
, abi
,
744 abi
= psi_decl_abi_init(T
->text
);
749 * decl_var_array_size: <empty>
751 PARSE_NAMED(decl_var_array_size
, as
, ) {
756 * decl_var_array_size: [ NUMBER ]
758 PARSE_NAMED(decl_var_array_size
, as
,
766 * decl_var: NAME decl_var_array_size
768 PARSE_TYPED(decl_var
, var
,
770 NAMED(decl_var_array_size
, as
)) {
771 var
= psi_decl_var_init(T
->text
, 0, as
?atol(as
->text
):0);
779 * decl_var: pointers NAME
781 PARSE_TYPED(decl_var
, var
,
784 NAMED(decl_var_array_size
, as
)) {
785 var
= psi_decl_var_init(T
->text
, p
+!!as
, as
?atol(as
->text
):0);
793 * decl_vars: decl_var
795 PARSE_TYPED(decl_vars
, vars
,
796 TYPED(decl_var
, var
)) {
797 vars
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_var_free
),
802 * decl_vars: decl_vars , decl_var
804 PARSE_TYPED(decl_vars
, vars
,
805 TYPED(decl_vars
, vars_
)
807 TYPED(decl_var
, var
)) {
808 vars
= psi_plist_add(vars_
, &var
);
812 * decl_arg: const_decl_type decl_var
814 PARSE_TYPED(decl_arg
, arg_
,
815 TYPED(const_decl_type
, type
)
816 TYPED(decl_var
, var
)) {
817 arg_
= psi_decl_arg_init(type
, var
);
821 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
823 PARSE_TYPED(decl_typedef_body
, def
,
824 TYPED(const_decl_type
, type_
)
825 TYPED(indirection
, decl_i
)
827 TYPED(indirection
, type_i
)
830 TYPED(decl_typedef_body_fn_args
, args
)) {
831 struct psi_decl_arg
*func_
= psi_decl_arg_init(
833 psi_decl_var_init(N
->text
, decl_i
, 0)
835 func_
->var
->token
= N
;
838 def
= psi_decl_arg_init(
839 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
840 psi_decl_var_copy(func_
->var
)
842 def
->var
->pointer_level
= type_i
;
843 def
->type
->token
= psi_token_copy(func_
->token
);
844 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
847 /* void pointers need a specific rule */
849 * decl_arg: VOID pointers NAME
851 PARSE_TYPED(decl_arg
, arg_
,
855 arg_
= psi_decl_arg_init(
856 psi_decl_type_init(T
->type
, T
->text
),
857 psi_decl_var_init(N
->text
, p
, 0)
859 arg_
->type
->token
= T
;
860 arg_
->var
->token
= N
;
865 * decl_args: CONST VOID pointers NAME
867 PARSE_TYPED(decl_arg
, arg_
,
872 arg_
= psi_decl_arg_init(
873 psi_decl_type_init(T
->type
, T
->text
),
874 psi_decl_var_init(N
->text
, p
, 0)
876 arg_
->type
->token
= T
;
877 arg_
->var
->token
= N
;
889 PASS(decl_args
, VOID
)
892 * decl_args: decl_arg
894 PARSE_TYPED(decl_args
, args
,
895 TYPED(decl_arg
, arg
)) {
896 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
901 * decl_args: decl_args , decl_arg
903 PARSE_TYPED(decl_args
, args
,
904 TYPED(decl_args
, args_
)
906 TYPED(decl_arg
, arg
)) {
907 args
= psi_plist_add(args_
, &arg
);
911 * struct_args: struct_arg
913 PARSE_TYPED(struct_args
, args
,
914 TYPED(struct_arg
, arg
)) {
915 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
920 * struct_args: struct_args , struct_arg
922 PARSE_TYPED(struct_args
, args
,
923 TYPED(struct_args
, args_
)
924 TYPED(struct_arg
, arg
)) {
925 args
= psi_plist_add(args_
, &arg
);
929 * struct_arg: decl_typedef_body_ex ;
931 PARSE_TYPED(struct_arg
, arg_
,
932 TYPED(decl_typedef_body_ex
, def
)
935 switch (def
->type
->type
) {
937 if (def
->type
->real
.strct
) {
939 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
941 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
945 if (def
->type
->real
.unn
) {
947 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
949 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
953 if (def
->type
->real
.enm
) {
955 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
957 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
964 * struct_arg: decl_arg decl_layout ;
966 PARSE_TYPED(struct_arg
, arg
,
967 TYPED(decl_arg
, arg_
)
968 TYPED(decl_layout
, layout_
)
970 arg_
->layout
= layout_
;
975 * decl_layout: <empty>
977 PARSE_TYPED(decl_layout
, layout
, ) {
982 * decl_layout: :: ( NUMBER , NUMBER )
984 PARSE_TYPED(decl_layout
, layout
,
992 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
997 /* un/signed, urgh */
999 * decl_scalar_type: CHAR
1001 PARSE_NAMED(decl_scalar_type
, type_
,
1007 * decl_scalar_type: SHORT decl_scalar_type_short
1009 PARSE_NAMED(decl_scalar_type
, type_
,
1011 NAMED(decl_scalar_type_short
, s
)) {
1013 type_
= psi_token_cat(2, S
, s
);
1022 * decl_scalar_type_short: <empty>
1024 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1029 * decl_scalar_type_short: INT
1031 PARSE_NAMED(decl_scalar_type_short
, s
,
1037 * decl_sclara_type: INT
1039 PARSE_NAMED(decl_scalar_type
, type_
,
1045 * decl_scalar_type: LONG decl_scalar_type_long
1047 PARSE_NAMED(decl_scalar_type
, type_
,
1049 NAMED(decl_scalar_type_long
, l
)) {
1051 type_
= psi_token_cat(2, L
, l
);
1060 * decl_scalar_type_long: <empty>
1062 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1067 * decl_scalar_type_long: DOUBLE
1069 PARSE_NAMED(decl_scalar_type_long
, l
,
1075 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1077 PARSE_NAMED(decl_scalar_type_long
, l
,
1079 NAMED(decl_scalar_type_long_long
, ll
)) {
1081 l
= psi_token_cat(2, L
, ll
);
1090 * decl_scalar_type_long_long: <empty>
1092 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1097 * decl_scalar_type_long_long: INT
1099 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1105 * decl_type: UNSIGNED decl_scalar_type
1107 PARSE_TYPED(decl_type
, type_
,
1109 NAMED(decl_scalar_type
, N
)) {
1110 struct psi_token
*T
= psi_token_cat(2, U
, N
);
1111 type_
= psi_decl_type_init(T
->type
, T
->text
);
1118 * decl_type: SIGNED decl_scalar_type
1120 PARSE_TYPED(decl_type
, type_
,
1122 NAMED(decl_scalar_type
, N
)) {
1123 struct psi_token
*T
= psi_token_cat(2, S
, N
);
1124 type_
= psi_decl_type_init(T
->type
, T
->text
);
1131 * decl_type: UNSIGNED
1133 PARSE_TYPED(decl_type
, type_
,
1134 NAMED(UNSIGNED
, U
)) {
1135 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1142 PARSE_TYPED(decl_type
, type_
,
1144 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1149 * decl_type: decl_scalar_type
1151 PARSE_TYPED(decl_type
, type_
,
1152 NAMED(decl_scalar_type
, N
)) {
1153 type_
= psi_decl_type_init(N
->type
, N
->text
);
1159 * decl_type: STRUCT NAME
1161 PARSE_TYPED(decl_type
, type_
,
1164 type_
= psi_decl_type_init(S
->type
, T
->text
);
1170 * decl_type: UNION NAME
1172 PARSE_TYPED(decl_type
, type_
,
1175 type_
= psi_decl_type_init(U
->type
, T
->text
);
1181 * decl_type: ENUM NAME
1183 PARSE_TYPED(decl_type
, type_
,
1186 type_
= psi_decl_type_init(E
->type
, T
->text
);
1192 * decl_type: decl_type_token
1194 PARSE_TYPED(decl_type
, type_
,
1195 NAMED(decl_type_token
, T
)) {
1196 type_
= psi_decl_type_init(T
->type
, T
->text
);
1201 * const_decl_type: decl_type
1203 PARSE_TYPED(const_decl_type
, type
,
1204 TYPED(decl_type
, type_
)) {
1209 * const_decl_type: CONST decl_type
1211 PARSE_TYPED(const_decl_type
, type
,
1213 TYPED(decl_type
, type_
)) {
1218 * impl: impl_func { impl_stmts }
1220 PARSE_TYPED(impl
, impl
,
1221 TYPED(impl_func
, func
)
1223 TYPED(impl_stmts
, stmts
)
1225 impl
= psi_impl_init(func
, stmts
);
1229 * impl: STATIC impl_func { impl_stmts }
1231 PARSE_TYPED(impl
, impl
,
1233 TYPED(impl_func
, func
)
1235 TYPED(impl_stmts
, stmts
)
1237 func
->static_memory
= 1;
1238 impl
= psi_impl_init(func
, stmts
);
1242 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1244 PARSE_TYPED(impl_func
, func
,
1251 TYPED(impl_type
, type
)) {
1252 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1254 func
->return_reference
= r
;
1258 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1260 PARSE_TYPED(impl_func
, func
,
1265 TYPED(impl_args
, args
)
1268 TYPED(impl_type
, type
)) {
1269 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1271 func
->return_reference
= r
;
1275 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1277 PARSE_TYPED(impl_func
, func
,
1279 TYPED(reference
, func_r
)
1282 TYPED(impl_args
, args
)
1284 TYPED(impl_type
, va_type
)
1285 TYPED(reference
, va_r
)
1287 NAMED(DOLLAR_NAME
, T
)
1290 TYPED(impl_type
, func_type
)) {
1291 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1293 func
->return_reference
= func_r
;
1294 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1299 * impl_def_val: impl_def_val_token
1301 PARSE_TYPED(impl_def_val
, def
,
1302 NAMED(impl_def_val_token
, T
)) {
1303 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1308 * impl_var: reference DOLLAR_NAME
1310 PARSE_TYPED(impl_var
, var
,
1312 NAMED(DOLLAR_NAME
, T
)) {
1313 var
= psi_impl_var_init(T
->text
, r
);
1318 * impl_type: impl_type_token
1320 PARSE_TYPED(impl_type
, type_
,
1321 NAMED(impl_type_token
, T
)) {
1322 type_
= psi_impl_type_init(T
->type
, T
->text
);
1327 * impl_arg: impl_type impl_var
1329 PARSE_TYPED(impl_arg
, arg
,
1330 TYPED(impl_type
, type
)
1331 TYPED(impl_var
, var
)) {
1332 arg
= psi_impl_arg_init(type
, var
, NULL
);
1336 * impl_arg: impl_type impl_var = impl_def_val
1338 PARSE_TYPED(impl_arg
, arg
,
1339 TYPED(impl_type
, type
)
1340 TYPED(impl_var
, var
)
1342 TYPED(impl_def_val
, def
)) {
1343 arg
= psi_impl_arg_init(type
, var
, def
);
1347 * impl_args: impl_arg
1349 PARSE_TYPED(impl_args
, args
,
1350 TYPED(impl_arg
, arg
)) {
1351 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1356 * impl_args: impl_args , impl_arg
1358 PARSE_TYPED(impl_args
, args
,
1359 TYPED(impl_args
, args_
)
1361 TYPED(impl_arg
, arg
)) {
1362 args
= psi_plist_add(args_
, &arg
);
1366 * impl_stmts: impl_stmt
1368 PARSE_TYPED(impl_stmts
, stmts
,
1369 TYPED(impl_stmt
, stmt
)) {
1370 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1375 * impl_stmts: impl_stmts , impl_stmt
1377 PARSE_TYPED(impl_stmts
, stmts
,
1378 TYPED(impl_stmts
, stmts_
)
1379 TYPED(impl_stmt
, stmt
)) {
1380 stmts
= psi_plist_add(stmts_
, &stmt
);
1384 * impl_stmt: return_stmt
1386 PARSE_TYPED(impl_stmt
, i
,
1387 TYPED(return_stmt
, r
)) {
1388 i
= (struct psi_token
**) r
;
1392 * impl_stmt: let_stmt
1394 PARSE_TYPED(impl_stmt
, i
,
1395 TYPED(let_stmt
, l
)) {
1396 i
= (struct psi_token
**) l
;
1400 * impl_stmt: set_stmt
1402 PARSE_TYPED(impl_stmt
, i
,
1403 TYPED(set_stmt
, s
)) {
1404 i
= (struct psi_token
**) s
;
1408 * impl_stmt: free_stmt
1410 PARSE_TYPED(impl_stmt
, i
,
1411 TYPED(free_stmt
, f
)) {
1412 i
= (struct psi_token
**) f
;
1416 * number: number_token
1418 PARSE_TYPED(number
, exp
,
1419 NAMED(number_token
, tok
)) {
1420 exp
= psi_number_init(tok
->type
, tok
->text
);
1427 PARSE_TYPED(number
, exp
,
1428 TYPED(decl_var
, var
)) {
1429 exp
= psi_number_init(PSI_T_NAME
, var
);
1430 exp
->token
= psi_token_copy(var
->token
);
1436 PARSE_TYPED(num_exp
, exp
,
1437 TYPED(number
, num
)) {
1438 exp
= psi_num_exp_init_num(num
);
1439 exp
->token
= psi_token_copy(num
->token
);
1443 * num_exp: ( num_exp )
1445 PARSE_TYPED(num_exp
, exp
,
1447 TYPED(num_exp
, exp_
)
1449 exp
= psi_num_exp_init_unary(PSI_T_LPAREN
, exp_
);
1454 * num_exp: num_exp num_exp_binary_op_token num_exp
1456 PARSE_TYPED(num_exp
, exp
,
1457 TYPED(num_exp
, lhs_
)
1458 NAMED(num_exp_binary_op_token
, OP
)
1459 TYPED(num_exp
, rhs_
)) {
1460 exp
= psi_num_exp_init_binary(OP
->type
, lhs_
, rhs_
);
1465 * num_exp: num_exp_unary_op_token num_exp
1467 PARSE_TYPED(num_exp
, exp
,
1468 NAMED(num_exp_unary_op_token
, OP
)
1469 TYPED(num_exp
, exp_
)) {
1470 exp
= psi_num_exp_init_unary(OP
->type
, exp_
);
1477 PARSE_TYPED(let_exp
, val
,
1479 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1485 PARSE_TYPED(let_exp
, val
,
1488 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1489 val
->is_reference
= 1;
1495 PARSE_TYPED(let_exp
, val
,
1496 TYPED(let_callback
, cb
)) {
1497 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1503 PARSE_TYPED(let_exp
, val
,
1504 TYPED(let_calloc
, ca
)) {
1505 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1511 PARSE_TYPED(let_exp
, val
,
1513 TYPED(let_calloc
, ca
)) {
1514 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1515 val
->is_reference
= 1;
1521 PARSE_TYPED(let_exp
, val
,
1522 TYPED(let_func
, fn
)) {
1523 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1529 PARSE_TYPED(let_exp
, val
,
1531 TYPED(let_func
, fn
)) {
1532 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1533 val
->is_reference
= 1;
1539 PARSE_TYPED(let_exp
, val
,
1540 TYPED(num_exp
, exp
)) {
1541 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1545 * let_exp: & num_exp
1547 PARSE_TYPED(let_exp
, val
,
1549 TYPED(num_exp
, exp
)) {
1550 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1551 val
->is_reference
= 1;
1555 * let_exp: decl_var = let_exp
1557 PARSE_TYPED(let_exp
, exp
,
1558 TYPED(decl_var
, var_
)
1560 TYPED(let_exp
, val
)) {
1566 * let_stmt: LET let_exp ;
1568 PARSE_TYPED(let_stmt
, let
,
1572 let
= psi_let_stmt_init(val
);
1577 * let_stmt: TEMP decl_var = reference decl_var ;
1579 PARSE_TYPED(let_stmt
, let
,
1581 TYPED(decl_var
, var
)
1584 TYPED(decl_var
, val_
)
1586 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1588 let
->exp
->is_reference
= r
? 1 : 0;
1592 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1594 PARSE_TYPED(let_callback
, cb
,
1596 NAMED(callback_rval
, F
)
1598 TYPED(impl_var
, var
)
1600 TYPED(callback_arg_list
, args_
)
1603 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1609 * let_calloc: CALLOC ( num_exp , num_exp )
1611 PARSE_TYPED(let_calloc
, alloc
,
1614 TYPED(num_exp
, nmemb
)
1616 TYPED(num_exp
, size
)
1618 alloc
= psi_let_calloc_init(nmemb
, size
);
1623 * let_func: let_func_token ( impl_var )
1625 PARSE_TYPED(let_func
, func
,
1626 NAMED(let_func_token
, T
)
1628 TYPED(impl_var
, var
)
1630 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1634 * let_func: let_func_token ( impl_var , let_exps )
1636 PARSE_TYPED(let_func
, func
,
1637 NAMED(let_func_token
, T
)
1639 TYPED(impl_var
, var
)
1641 TYPED(let_exps
, vals
)
1643 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1650 PARSE_TYPED(let_exps
, exps
,
1651 TYPED(let_exp
, exp
)) {
1652 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1656 * let_exps: let_exps , let_exp
1658 PARSE_TYPED(let_exps
, exps
,
1659 TYPED(let_exps
, exps_
)
1661 TYPED(let_exp
, exp
)) {
1662 exps
= psi_plist_add(exps_
, &exp
);
1666 * callback_arg_list: <empty>
1668 PASS(callback_arg_list
, )
1671 * callback_arg_list: callback_args
1673 PARSE_TYPED(callback_arg_list
, args
,
1674 TYPED(callback_args
, args_
)) {
1679 * callback_args: set_exp
1681 PARSE_TYPED(callback_args
, args
,
1682 TYPED(set_exp
, val
)) {
1683 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1688 * callback_args: callback_args , set_exp
1690 PARSE_TYPED(callback_args
, args
,
1691 TYPED(callback_args
, args_
)
1693 TYPED(set_exp
, val
)) {
1694 args
= psi_plist_add(args_
, &val
);
1698 * callback_rval: let_func_token
1700 PARSE_NAMED(callback_rval
, rval
,
1701 NAMED(let_func_token
, F
)) {
1706 * callback_rval: VOID
1708 PARSE_NAMED(callback_rval
, rval
,
1715 * set_func: set_func_token ( decl_var )
1717 PARSE_TYPED(set_func
, func
,
1718 NAMED(set_func_token
, T
)
1720 TYPED(decl_var
, var
)
1722 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1727 * set_func: set_func_token ( decl_var , set_exps )
1729 PARSE_TYPED(set_func
, func
,
1730 NAMED(set_func_token
, T
)
1732 TYPED(decl_var
, var
)
1734 TYPED(set_exps
, vals
)
1736 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1742 * set_func: set_func_token ( decl_var , ... )
1744 PARSE_TYPED(set_func
, func
,
1745 NAMED(set_func_token
, T
)
1747 TYPED(decl_var
, var
)
1751 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1753 func
->recursive
= 1;
1759 PARSE_TYPED(set_exp
, val
,
1760 TYPED(set_func
, fn
)) {
1761 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
1767 PARSE_TYPED(set_exp
, val
,
1768 TYPED(num_exp
, num
)) {
1769 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
1775 PARSE_TYPED(set_exps
, exps
,
1776 TYPED(set_exp
, exp
)) {
1777 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1782 * set_exps: set_exps , set_exp
1784 PARSE_TYPED(set_exps
, exps
,
1785 TYPED(set_exps
, exps_
)
1787 TYPED(set_exp
, exp
)) {
1788 exps
= psi_plist_add(exps_
, &exp
);
1792 * set_exp: impl_var = set_exp
1794 PARSE_TYPED(set_exp
, exp
,
1795 TYPED(impl_var
, var_
)
1797 TYPED(set_exp
, val
)) {
1803 * set_stmt: SET set_exp ;
1805 PARSE_TYPED(set_stmt
, set
,
1809 set
= psi_set_stmt_init(exp
);
1814 * return_stmt: RETURN set_exp ;
1816 PARSE_TYPED(return_stmt
, ret
,
1818 TYPED(set_func
, func
)
1820 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
1825 * free_stmt: FREE free_exps ;
1827 PARSE_TYPED(free_stmt
, free
,
1829 TYPED(free_exps
, calls
)
1831 free
= psi_free_stmt_init(calls
);
1836 * free_exps: free_exp
1838 PARSE_TYPED(free_exps
, calls
,
1839 TYPED(free_exp
, call
)) {
1840 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
1845 * free_exps: free_exps , free_exp
1847 PARSE_TYPED(free_exps
, calls
,
1848 TYPED(free_exps
, calls_
)
1850 TYPED(free_exp
, call
)) {
1851 calls
= psi_plist_add(calls_
, &call
);
1855 * free_exp: NAME ( decl_vars )
1857 PARSE_TYPED(free_exp
, call
,
1860 TYPED(decl_vars
, vars
)
1862 call
= psi_free_exp_init(F
->text
, vars
);
1867 * reference: <empty>
1869 PARSE_TYPED(reference
, r
, ) {
1876 PARSE_TYPED(reference
, r
,
1882 * indirection: <empty>
1884 PARSE_TYPED(indirection
, i
, ){
1889 * indirection: pointers
1891 PARSE_TYPED(indirection
, i
,
1892 TYPED(pointers
, p
)) {
1899 PARSE_TYPED(pointers
, p
,
1905 * pointers: pointers *
1907 PARSE_TYPED(pointers
, p
,