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");
83 DEF(%left
, PLUS MINUS
.)
84 DEF(%left
, ASTERISK SLASH
.)
85 DEF(%nonassoc
, AMPERSAND
.)
86 DEF(%fallback
, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT
.)
88 DEF(%token_class
, const_type_token BOOL INT FLOAT STRING
.)
89 DEF(%token_class
, decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME
.)
90 DEF(%token_class
, impl_def_val_token NULL NUMBER TRUE FALSE QUOTED_STRING
.)
91 DEF(%token_class
, num_exp_token NUMBER NSNAME
.)
92 DEF(%token_class
, num_exp_op_token PLUS MINUS ASTERISK SLASH
.)
93 DEF(%token_class
, let_func_token ZVAL OBJVAL ARRVAL PATHVAL STRLEN STRVAL FLOATVAL INTVAL BOOLVAL COUNT
.)
94 DEF(%token_class
, set_func_token TO_OBJECT TO_ARRAY TO_STRING TO_INT TO_FLOAT TO_BOOL ZVAL VOID
.)
95 DEF(%token_class
, impl_type_token VOID MIXED BOOL INT FLOAT STRING ARRAY OBJECT CALLABLE
.)
97 TOKEN_TYPE(decl_enum
, struct psi_decl_enum
*)
98 TOKEN_DTOR(decl_enum
, psi_decl_enum_free(&$$
);)
99 TOKEN_TYPE(decl_enum_items
, struct psi_plist
*)
100 TOKEN_DTOR(decl_enum_items
, psi_plist_free($$
);)
101 TOKEN_TYPE(decl_enum_item
, struct psi_decl_enum_item
*)
102 TOKEN_DTOR(decl_enum_item
, psi_decl_enum_item_free(&$$
);)
103 TOKEN_TYPE(decl_struct_args_block
, struct psi_plist
*)
104 TOKEN_DTOR(decl_struct_args_block
, psi_plist_free($$
);) /* there was a typo */
105 TOKEN_TYPE(decl_struct_args
, struct psi_plist
*)
106 TOKEN_DTOR(decl_struct_args
, psi_plist_free($$
);)
107 TOKEN_TYPE(decl_struct
, struct psi_decl_struct
*)
108 TOKEN_DTOR(decl_struct
, psi_decl_struct_free(&$$
);)
109 TOKEN_TYPE(align_and_size
, struct psi_layout
)
110 TOKEN_TYPE(decl_union
, struct psi_decl_union
*)
111 TOKEN_DTOR(decl_union
, psi_decl_union_free(&$$
);)
112 TOKEN_TYPE(const_type
, struct psi_const_type
*)
113 TOKEN_DTOR(const_type
, psi_const_type_free(&$$
);)
114 TOKEN_TYPE(constant
, struct psi_const
*)
115 TOKEN_DTOR(constant
, psi_const_free(&$$
);)
116 TOKEN_TYPE(decl_typedef
, struct psi_decl_arg
*)
117 TOKEN_DTOR(decl_typedef
, psi_decl_arg_free(&$$
);)
118 TOKEN_TYPE(decl_typedef_body_ex
, struct psi_decl_arg
*)
119 TOKEN_DTOR(decl_typedef_body_ex
, psi_decl_arg_free(&$$
);)
120 TOKEN_TYPE(decl_typedef_body
, struct psi_decl_arg
*)
121 TOKEN_DTOR(decl_typedef_body
, psi_decl_arg_free(&$$
);)
122 TOKEN_TYPE(decl_typedef_body_fn_args
, struct psi_plist
*)
123 TOKEN_DTOR(decl_typedef_body_fn_args
, psi_plist_free($$
);)
124 TOKEN_TYPE(decl
, struct psi_decl
*)
125 TOKEN_DTOR(decl
, psi_decl_free(&$$
);)
126 TOKEN_TYPE(decl_func
, struct psi_decl_arg
*)
127 TOKEN_DTOR(decl_func
, psi_decl_arg_free(&$$
);)
128 TOKEN_TYPE(decl_abi
, struct psi_decl_abi
*)
129 TOKEN_DTOR(decl_abi
, psi_decl_abi_free(&$$
);)
130 TOKEN_TYPE(decl_var
, struct psi_decl_var
*)
131 TOKEN_DTOR(decl_var
, psi_decl_var_free(&$$
);)
132 TOKEN_TYPE(decl_vars
, struct psi_plist
*)
133 TOKEN_DTOR(decl_vars
, psi_plist_free($$
);)
134 TOKEN_TYPE(decl_arg
, struct psi_decl_arg
*)
135 TOKEN_DTOR(decl_arg
, psi_decl_arg_free(&$$
);)
136 TOKEN_TYPE(decl_args
, struct psi_plist
*)
137 TOKEN_DTOR(decl_args
, psi_plist_free($$
);)
138 TOKEN_TYPE(struct_args
, struct psi_plist
*)
139 TOKEN_DTOR(struct_args
, psi_plist_free($$
);)
140 TOKEN_TYPE(struct_arg
, struct psi_decl_arg
*)
141 TOKEN_DTOR(struct_arg
, psi_decl_arg_free(&$$
);)
142 TOKEN_TYPE(decl_layout
, struct psi_layout
*)
143 TOKEN_DTOR(decl_layout
, psi_layout_free(&$$
);)
144 TOKEN_TYPE(decl_type
, struct psi_decl_type
*)
145 TOKEN_DTOR(decl_type
, psi_decl_type_free(&$$
);)
146 TOKEN_TYPE(const_decl_type
, struct psi_decl_type
*)
147 TOKEN_DTOR(const_decl_type
, psi_decl_type_free(&$$
);)
148 TOKEN_TYPE(impl
, struct psi_impl
*)
149 TOKEN_DTOR(impl
, psi_impl_free(&$$
);)
150 TOKEN_TYPE(impl_func
, struct psi_impl_func
*)
151 TOKEN_DTOR(impl_func
, psi_impl_func_free(&$$
);)
152 TOKEN_TYPE(impl_def_val
, struct psi_impl_def_val
*)
153 TOKEN_DTOR(impl_def_val
, psi_impl_def_val_free(&$$
);)
154 TOKEN_TYPE(impl_var
, struct psi_impl_var
*)
155 TOKEN_DTOR(impl_var
, psi_impl_var_free(&$$
);)
156 TOKEN_TYPE(impl_arg
, struct psi_impl_arg
*)
157 TOKEN_DTOR(impl_arg
, psi_impl_arg_free(&$$
);)
158 TOKEN_TYPE(impl_args
, struct psi_plist
*)
159 TOKEN_DTOR(impl_args
, psi_plist_free($$
);)
160 TOKEN_TYPE(impl_vararg
, struct psi_impl_arg
*)
161 TOKEN_DTOR(impl_vararg
, psi_impl_arg_free(&$$
);)
162 TOKEN_TYPE(impl_stmts
, struct psi_plist
*)
163 TOKEN_DTOR(impl_stmts
, psi_plist_free($$
);)
164 TOKEN_TYPE(impl_stmt
, struct psi_token
**)
165 TOKEN_DTOR(impl_stmt
, psi_impl_stmt_free(&$$
);)
166 TOKEN_TYPE(num_exp
, struct psi_num_exp
*)
167 TOKEN_DTOR(num_exp
, psi_num_exp_free(&$$
);)
168 TOKEN_TYPE(let_stmt
, struct psi_let_stmt
*)
169 TOKEN_DTOR(let_stmt
, psi_let_stmt_free(&$$
);)
170 TOKEN_TYPE(let_calloc
, struct psi_let_calloc
*)
171 TOKEN_DTOR(let_calloc
, psi_let_calloc_free(&$$
);)
172 TOKEN_TYPE(let_func
, struct psi_let_func
*)
173 TOKEN_DTOR(let_func
, psi_let_func_free(&$$
);)
174 TOKEN_TYPE(callback_arg_list
, struct psi_plist
*)
175 TOKEN_DTOR(callback_arg_list
, psi_plist_free($$
);)
176 TOKEN_TYPE(callback_args
, struct psi_plist
*)
177 TOKEN_DTOR(callback_args
, psi_plist_free($$
);)
178 TOKEN_TYPE(let_callback
, struct psi_let_callback
*)
179 TOKEN_DTOR(let_callback
, psi_let_callback_free(&$$
);)
180 TOKEN_TYPE(let_exp
, struct psi_let_exp
*)
181 TOKEN_DTOR(let_exp
, psi_let_exp_free(&$$
);)
182 TOKEN_TYPE(let_exps
, struct psi_plist
*)
183 TOKEN_DTOR(let_exps
, psi_plist_free($$
);)
184 TOKEN_TYPE(set_stmt
, struct psi_set_stmt
*)
185 TOKEN_DTOR(set_stmt
, psi_set_stmt_free(&$$
);)
186 TOKEN_TYPE(set_exp
, struct psi_set_exp
*)
187 TOKEN_DTOR(set_exp
, psi_set_exp_free(&$$
);)
188 TOKEN_TYPE(set_exps
, struct psi_plist
*)
189 TOKEN_DTOR(set_exps
, psi_plist_free($$
);)
190 TOKEN_TYPE(set_func
, struct psi_set_func
*)
191 TOKEN_DTOR(set_func
, psi_set_func_free(&$$
);)
192 TOKEN_TYPE(return_stmt
, struct psi_return_stmt
*)
193 TOKEN_DTOR(return_stmt
, psi_return_stmt_free(&$$
);)
194 TOKEN_TYPE(free_stmt
, struct psi_free_stmt
*)
195 TOKEN_DTOR(free_stmt
, psi_free_stmt_free(&$$
);)
196 TOKEN_TYPE(free_exps
, struct psi_plist
*)
197 TOKEN_DTOR(free_exps
, psi_plist_free($$
);)
198 TOKEN_TYPE(free_exp
, struct psi_free_exp
*)
199 TOKEN_DTOR(free_exp
, psi_free_exp_free(&$$
);)
200 TOKEN_TYPE(impl_type
, struct psi_impl_type
*)
201 TOKEN_DTOR(impl_type
, psi_impl_type_free(&$$
);)
202 TOKEN_TYPE(reference
, bool)
203 TOKEN_TYPE(indirection
, unsigned)
204 TOKEN_TYPE(pointers
, unsigned)
208 PASS(blocks
, blocks block
)
214 * lib: LIB "soname" ;
216 PARSE(block
, NAMED(LIB
, token
) NAMED(QUOTED_STRING
, libname
) TOKEN(EOS
)) {
218 P
->error(PSI_DATA(P
), token
, PSI_WARNING
, "Extra 'lib %s' statement has no effect", libname
->text
);
220 P
->file
.ln
= strndup(libname
->text
+ 1, libname
->size
- 2);
226 PARSE(block
, TYPED(decl
, decl
)) {
228 P
->decls
= psi_plist_init((psi_plist_dtor
) psi_decl_free
);
230 P
->decls
= psi_plist_add(P
->decls
, &decl
);
233 PARSE(block
, TYPED(impl
, impl
)) {
235 P
->impls
= psi_plist_init((psi_plist_dtor
) psi_impl_free
);
237 P
->impls
= psi_plist_add(P
->impls
, &impl
);
240 PARSE(block
, TYPED(decl_typedef
, def
)) {
242 P
->types
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
244 P
->types
= psi_plist_add(P
->types
, &def
);
246 switch (def
->type
->type
) {
248 if (def
->type
->real
.strct
) {
250 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
252 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
256 if (def
->type
->real
.unn
) {
258 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
260 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
264 if (def
->type
->real
.enm
) {
266 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
268 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
274 PARSE(block
, TYPED(constant
, constant
)) {
276 P
->consts
= psi_plist_init((psi_plist_dtor
) psi_const_free
);
278 P
->consts
= psi_plist_add(P
->consts
, &constant
);
281 PARSE(block
, TYPED(decl_struct
, strct
)) {
283 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
285 P
->structs
= psi_plist_add(P
->structs
, &strct
);
288 PARSE(block
, TYPED(decl_union
, u
)) {
290 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
292 P
->unions
= psi_plist_add(P
->unions
, &u
);
295 PARSE(block
, TYPED(decl_enum
, e
)) {
297 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
299 P
->enums
= psi_plist_add(P
->enums
, &e
);
303 * optional_name: <empty>
305 PARSE_NAMED(optional_name
, n
, ) {
310 * optional_name: NAME
312 PARSE_NAMED(optional_name
, n
,
318 * align_and_size: <empty>
320 PARSE_TYPED(align_and_size
, as
, ) {
326 * align_and_size: :: ( NUMBER , NUMBER )
328 PARSE_TYPED(align_and_size
, as
,
336 as
.pos
= atol(A
->text
);
337 as
.len
= atol(S
->text
);
343 * enum_name: ENUM optional_name
345 PARSE_NAMED(enum_name
, n
,
347 NAMED(optional_name
, N
)) {
354 psi_token_hash(E
, digest
);
355 n
= psi_token_translit(psi_token_append(E
, 1, digest
), " ", "@");
360 * struct_name: STRUCT optional_name
362 PARSE_NAMED(struct_name
, n
,
364 NAMED(optional_name
, N
)) {
371 psi_token_hash(S
, digest
);
372 n
= psi_token_translit(psi_token_append(S
, 1, digest
), " ", "@");
377 * union_name: UNION optional_name
379 PARSE_NAMED(union_name
, n
,
381 NAMED(optional_name
, N
)) {
388 psi_token_hash(U
, digest
);
389 n
= psi_token_translit(psi_token_append(U
, 1, digest
), " ", "@");
394 * decl_enum: enum_name { items }
396 PARSE_TYPED(decl_enum
, e
,
399 TYPED(decl_enum_items
, list
)
401 e
= psi_decl_enum_init(N
->text
, list
);
406 * decl_enum_items: item
408 PARSE_TYPED(decl_enum_items
, l
,
409 TYPED(decl_enum_item
, i
)) {
410 l
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_enum_item_free
),
415 * decl_enum_items: items , item
417 PARSE_TYPED(decl_enum_items
, l
,
418 TYPED(decl_enum_items
, l_
)
420 TYPED(decl_enum_item
, i
)) {
421 l
= psi_plist_add(l_
, &i
);
425 * decl_enum_item: name = num_exp
427 PARSE_TYPED(decl_enum_item
, i
,
430 TYPED(num_exp
, num
)) {
431 i
= psi_decl_enum_item_init(N
->text
, num
);
436 * decl_enum_item: name
438 PARSE_TYPED(decl_enum_item
, i
,
440 i
= psi_decl_enum_item_init(N
->text
, NULL
);
446 * decl_struct_args_block: { args }
448 PARSE_TYPED(decl_struct_args_block
, args_
,
450 TYPED(struct_args
, args
)
456 * decl_struct_args: args_block
458 PARSE_TYPED(decl_struct_args
, args_
,
459 TYPED(decl_struct_args_block
, args
)) {
464 * decl_struct_args: ;
466 PARSE_TYPED(decl_struct_args
, args_
,
468 args_
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
472 * decl_struct: STRUCT name align_and_size struct_args
474 PARSE_TYPED(decl_struct
, strct
,
477 TYPED(align_and_size
, as
)
478 TYPED(decl_struct_args
, args
)) {
479 strct
= psi_decl_struct_init(N
->text
, args
);
480 strct
->align
= as
.pos
;
481 strct
->size
= as
.len
;
486 * decl_union: UNION name align_and_size struct_args
488 PARSE_TYPED(decl_union
, u
,
491 TYPED(align_and_size
, as
)
492 TYPED(decl_struct_args
, args
)) {
493 u
= psi_decl_union_init(N
->text
, args
);
500 * const_type: const_type_token
502 PARSE_TYPED(const_type
, type_
,
503 NAMED(const_type_token
, T
)) {
504 type_
= psi_const_type_init(T
->type
, T
->text
);
509 * constant: CONST const_type NSNAME = def_val ;
511 PARSE_TYPED(constant
, constant
,
513 TYPED(const_type
, type
)
516 TYPED(impl_def_val
, val
)
518 constant
= psi_const_init(type
, T
->text
, val
);
523 * decl_typdef: TYPEDEF typedef_body ;
525 PARSE_TYPED(decl_typedef
, def
,
527 TYPED(decl_typedef_body
, def_
)
534 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
536 PARSE_TYPED(decl_typedef_body_ex
, def
,
537 NAMED(struct_name
, N
)
538 TYPED(align_and_size
, as
)
539 TYPED(decl_struct_args_block
, args
)
540 TYPED(decl_var
, var
)) {
541 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT
, N
->text
), var
);
542 def
->type
->token
= psi_token_copy(N
);
543 def
->type
->real
.strct
= psi_decl_struct_init(N
->text
, args
);
544 def
->type
->real
.strct
->token
= N
;
545 def
->type
->real
.strct
->align
= as
.pos
;
546 def
->type
->real
.strct
->size
= as
.len
;
550 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
552 PARSE_TYPED(decl_typedef_body_ex
, def
,
554 TYPED(align_and_size
, as
)
555 TYPED(decl_struct_args_block
, args
)
556 TYPED(decl_var
, var
)) {
557 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION
, N
->text
), var
);
558 def
->type
->token
= psi_token_copy(N
);
559 def
->type
->real
.unn
= psi_decl_union_init(N
->text
, args
);
560 def
->type
->real
.unn
->token
= N
;
561 def
->type
->real
.unn
->align
= as
.pos
;
562 def
->type
->real
.unn
->size
= as
.len
;
566 * decl_typedef_body_ex: decl_enum NAME
568 PARSE_TYPED(decl_typedef_body_ex
, def
,
570 NAMED(NAME
, ALIAS
)) {
571 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM
, e
->name
), psi_decl_var_init(ALIAS
->text
, 0, 0));
572 def
->var
->token
= ALIAS
;
573 def
->type
->token
= psi_token_copy(e
->token
);
574 def
->type
->real
.enm
= e
;
578 * decl_typedef_body: decl_typedef_body_ex
580 PARSE_TYPED(decl_typedef_body
, def
,
581 TYPED(decl_typedef_body_ex
, def_
)) {
586 * decl_typedef_body_fn_args: ( decl_args )
588 PARSE_TYPED(decl_typedef_body_fn_args
, args
,
590 TYPED(decl_args
, args_
)
596 * decl_typedef_body: decl_func decl_typedef_body_fn_args
598 PARSE_TYPED(decl_typedef_body
, def
,
599 TYPED(decl_func
, func_
)
600 TYPED(decl_typedef_body_fn_args
, args
)) {
601 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
), psi_decl_var_copy(func_
->var
));
602 def
->type
->token
= psi_token_copy(func_
->token
);
603 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
607 * decl_typedef_body: decl_arg
609 PARSE_TYPED(decl_typedef_body
, def
,
610 TYPED(decl_arg
, arg
)) {
615 * decl: decl_abi decl_func ( decl_args ) ;
617 PARSE_TYPED(decl
, decl
,
619 TYPED(decl_func
, func
)
621 TYPED(decl_args
, args
)
624 decl
= psi_decl_init(abi
, func
, args
);
628 * decl: decl_abi decl_func ( decl_args , ... ) ;
630 PARSE_TYPED(decl
, decl
,
632 TYPED(decl_func
, func
)
634 TYPED(decl_args
, args
)
639 decl
= psi_decl_init(abi
, func
, args
);
644 * decl_func: decl_arg
646 PARSE_TYPED(decl_func
, func
,
647 TYPED(decl_arg
, arg
)) {
651 /* special case for void functions */
653 * decl_func: VOID NAME
655 PARSE_TYPED(decl_func
, func
,
658 func
= psi_decl_arg_init(
659 psi_decl_type_init(T
->type
, T
->text
),
660 psi_decl_var_init(N
->text
, 0, 0)
662 func
->type
->token
= T
;
663 func
->var
->token
= N
;
668 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
670 PARSE_TYPED(decl_typedef_body
, def
,
672 TYPED(indirection
, decl_i
)
674 TYPED(indirection
, type_i
)
677 TYPED(decl_typedef_body_fn_args
, args
)) {
678 struct psi_decl_arg
*func_
= psi_decl_arg_init(
679 psi_decl_type_init(T
->type
, T
->text
),
680 psi_decl_var_init(N
->text
, decl_i
, 0)
682 func_
->type
->token
= T
;
683 func_
->var
->token
= N
;
686 def
= psi_decl_arg_init(
687 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
688 psi_decl_var_copy(func_
->var
)
690 def
->var
->pointer_level
= type_i
;
691 def
->type
->token
= psi_token_copy(func_
->token
);
692 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
696 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
698 PARSE_TYPED(decl_typedef_body
, def
,
701 TYPED(pointers
, decl_i
)
703 TYPED(indirection
, type_i
)
706 TYPED(decl_typedef_body_fn_args
, args
)) {
707 struct psi_decl_arg
*func_
= psi_decl_arg_init(
708 psi_decl_type_init(T
->type
, T
->text
),
709 psi_decl_var_init(N
->text
, decl_i
, 0)
711 func_
->type
->token
= T
;
712 func_
->var
->token
= N
;
715 def
= psi_decl_arg_init(
716 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
717 psi_decl_var_copy(func_
->var
)
719 def
->var
->pointer_level
= type_i
;
720 def
->type
->token
= psi_token_copy(func_
->token
);
721 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
727 PARSE_TYPED(decl_abi
, abi
,
729 abi
= psi_decl_abi_init(T
->text
);
734 * decl_var_array_size: <empty>
736 PARSE_NAMED(decl_var_array_size
, as
, ) {
741 * decl_var_array_size: [ NUMBER ]
743 PARSE_NAMED(decl_var_array_size
, as
,
751 * decl_var: NAME decl_var_array_size
753 PARSE_TYPED(decl_var
, var
,
755 NAMED(decl_var_array_size
, as
)) {
756 var
= psi_decl_var_init(T
->text
, 0, as
?atol(as
->text
):0);
764 * decl_var: pointers NAME
766 PARSE_TYPED(decl_var
, var
,
769 NAMED(decl_var_array_size
, as
)) {
770 var
= psi_decl_var_init(T
->text
, p
+!!as
, as
?atol(as
->text
):0);
778 * decl_vars: decl_var
780 PARSE_TYPED(decl_vars
, vars
,
781 TYPED(decl_var
, var
)) {
782 vars
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_var_free
),
787 * decl_vars: decl_vars , decl_var
789 PARSE_TYPED(decl_vars
, vars
,
790 TYPED(decl_vars
, vars_
)
792 TYPED(decl_var
, var
)) {
793 vars
= psi_plist_add(vars_
, &var
);
797 * decl_arg: const_decl_type decl_var
799 PARSE_TYPED(decl_arg
, arg_
,
800 TYPED(const_decl_type
, type
)
801 TYPED(decl_var
, var
)) {
802 arg_
= psi_decl_arg_init(type
, var
);
806 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
808 PARSE_TYPED(decl_typedef_body
, def
,
809 TYPED(const_decl_type
, type_
)
810 TYPED(indirection
, decl_i
)
812 TYPED(indirection
, type_i
)
815 TYPED(decl_typedef_body_fn_args
, args
)) {
816 struct psi_decl_arg
*func_
= psi_decl_arg_init(
818 psi_decl_var_init(N
->text
, decl_i
, 0)
820 func_
->var
->token
= N
;
823 def
= psi_decl_arg_init(
824 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
825 psi_decl_var_copy(func_
->var
)
827 def
->var
->pointer_level
= type_i
;
828 def
->type
->token
= psi_token_copy(func_
->token
);
829 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
832 /* void pointers need a specific rule */
834 * decl_arg: VOID pointers NAME
836 PARSE_TYPED(decl_arg
, arg_
,
840 arg_
= psi_decl_arg_init(
841 psi_decl_type_init(T
->type
, T
->text
),
842 psi_decl_var_init(N
->text
, p
, 0)
844 arg_
->type
->token
= T
;
845 arg_
->var
->token
= N
;
850 * decl_args: CONST VOID pointers NAME
852 PARSE_TYPED(decl_arg
, arg_
,
857 arg_
= psi_decl_arg_init(
858 psi_decl_type_init(T
->type
, T
->text
),
859 psi_decl_var_init(N
->text
, p
, 0)
861 arg_
->type
->token
= T
;
862 arg_
->var
->token
= N
;
874 PASS(decl_args
, VOID
)
877 * decl_args: decl_arg
879 PARSE_TYPED(decl_args
, args
,
880 TYPED(decl_arg
, arg
)) {
881 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
886 * decl_args: decl_args , decl_arg
888 PARSE_TYPED(decl_args
, args
,
889 TYPED(decl_args
, args_
)
891 TYPED(decl_arg
, arg
)) {
892 args
= psi_plist_add(args_
, &arg
);
896 * struct_args: struct_arg
898 PARSE_TYPED(struct_args
, args
,
899 TYPED(struct_arg
, arg
)) {
900 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
905 * struct_args: struct_args , struct_arg
907 PARSE_TYPED(struct_args
, args
,
908 TYPED(struct_args
, args_
)
909 TYPED(struct_arg
, arg
)) {
910 args
= psi_plist_add(args_
, &arg
);
914 * struct_arg: decl_typedef_body_ex ;
916 PARSE_TYPED(struct_arg
, arg_
,
917 TYPED(decl_typedef_body_ex
, def
)
920 switch (def
->type
->type
) {
922 if (def
->type
->real
.strct
) {
924 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
926 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
930 if (def
->type
->real
.unn
) {
932 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
934 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
938 if (def
->type
->real
.enm
) {
940 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
942 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
949 * struct_arg: decl_arg decl_layout ;
951 PARSE_TYPED(struct_arg
, arg
,
952 TYPED(decl_arg
, arg_
)
953 TYPED(decl_layout
, layout_
)
955 arg_
->layout
= layout_
;
960 * decl_layout: <empty>
962 PARSE_TYPED(decl_layout
, layout
, ) {
967 * decl_layout: :: ( NUMBER , NUMBER )
969 PARSE_TYPED(decl_layout
, layout
,
977 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
982 /* un/signed, urgh */
984 * decl_scalar_type: CHAR
986 PARSE_NAMED(decl_scalar_type
, type_
,
992 * decl_scalar_type: SHORT decl_scalar_type_short
994 PARSE_NAMED(decl_scalar_type
, type_
,
996 NAMED(decl_scalar_type_short
, s
)) {
998 type_
= psi_token_cat(2, S
, s
);
1007 * decl_scalar_type_short: <empty>
1009 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1014 * decl_scalar_type_short: INT
1016 PARSE_NAMED(decl_scalar_type_short
, s
,
1022 * decl_sclara_type: INT
1024 PARSE_NAMED(decl_scalar_type
, type_
,
1030 * decl_scalar_type: LONG decl_scalar_type_long
1032 PARSE_NAMED(decl_scalar_type
, type_
,
1034 NAMED(decl_scalar_type_long
, l
)) {
1036 type_
= psi_token_cat(2, L
, l
);
1045 * decl_scalar_type_long: <empty>
1047 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1052 * decl_scalar_type_long: DOUBLE
1054 PARSE_NAMED(decl_scalar_type_long
, l
,
1060 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1062 PARSE_NAMED(decl_scalar_type_long
, l
,
1064 NAMED(decl_scalar_type_long_long
, ll
)) {
1066 l
= psi_token_cat(2, L
, ll
);
1075 * decl_scalar_type_long_long: <empty>
1077 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1082 * decl_scalar_type_long_long: INT
1084 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1090 * decl_type: UNSIGNED decl_scalar_type
1092 PARSE_TYPED(decl_type
, type_
,
1094 NAMED(decl_scalar_type
, N
)) {
1095 struct psi_token
*T
= psi_token_cat(2, U
, N
);
1096 type_
= psi_decl_type_init(T
->type
, T
->text
);
1103 * decl_type: SIGNED decl_scalar_type
1105 PARSE_TYPED(decl_type
, type_
,
1107 NAMED(decl_scalar_type
, N
)) {
1108 struct psi_token
*T
= psi_token_cat(2, S
, N
);
1109 type_
= psi_decl_type_init(T
->type
, T
->text
);
1116 * decl_type: UNSIGNED
1118 PARSE_TYPED(decl_type
, type_
,
1119 NAMED(UNSIGNED
, U
)) {
1120 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1127 PARSE_TYPED(decl_type
, type_
,
1129 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1134 * decl_type: decl_scalar_type
1136 PARSE_TYPED(decl_type
, type_
,
1137 NAMED(decl_scalar_type
, N
)) {
1138 type_
= psi_decl_type_init(N
->type
, N
->text
);
1144 * decl_type: STRUCT NAME
1146 PARSE_TYPED(decl_type
, type_
,
1149 type_
= psi_decl_type_init(S
->type
, T
->text
);
1155 * decl_type: UNION NAME
1157 PARSE_TYPED(decl_type
, type_
,
1160 type_
= psi_decl_type_init(U
->type
, T
->text
);
1166 * decl_type: ENUM NAME
1168 PARSE_TYPED(decl_type
, type_
,
1171 type_
= psi_decl_type_init(E
->type
, T
->text
);
1177 * decl_type: decl_type_token
1179 PARSE_TYPED(decl_type
, type_
,
1180 NAMED(decl_type_token
, T
)) {
1181 type_
= psi_decl_type_init(T
->type
, T
->text
);
1186 * const_decl_type: decl_type
1188 PARSE_TYPED(const_decl_type
, type
,
1189 TYPED(decl_type
, type_
)) {
1194 * const_decl_type: CONST decl_type
1196 PARSE_TYPED(const_decl_type
, type
,
1198 TYPED(decl_type
, type_
)) {
1203 * impl: impl_func { impl_stmts }
1205 PARSE_TYPED(impl
, impl
,
1206 TYPED(impl_func
, func
)
1208 TYPED(impl_stmts
, stmts
)
1210 impl
= psi_impl_init(func
, stmts
);
1214 * impl: STATIC impl_func { impl_stmts }
1216 PARSE_TYPED(impl
, impl
,
1218 TYPED(impl_func
, func
)
1220 TYPED(impl_stmts
, stmts
)
1222 func
->static_memory
= 1;
1223 impl
= psi_impl_init(func
, stmts
);
1227 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1229 PARSE_TYPED(impl_func
, func
,
1236 TYPED(impl_type
, type
)) {
1237 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1239 func
->return_reference
= r
;
1243 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1245 PARSE_TYPED(impl_func
, func
,
1250 TYPED(impl_args
, args
)
1253 TYPED(impl_type
, type
)) {
1254 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1256 func
->return_reference
= r
;
1260 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1262 PARSE_TYPED(impl_func
, func
,
1264 TYPED(reference
, func_r
)
1267 TYPED(impl_args
, args
)
1269 TYPED(impl_type
, va_type
)
1270 TYPED(reference
, va_r
)
1272 NAMED(DOLLAR_NAME
, T
)
1275 TYPED(impl_type
, func_type
)) {
1276 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1278 func
->return_reference
= func_r
;
1279 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1284 * impl_def_val: impl_def_val_token
1286 PARSE_TYPED(impl_def_val
, def
,
1287 NAMED(impl_def_val_token
, T
)) {
1288 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1293 * impl_var: reference DOLLAR_NAME
1295 PARSE_TYPED(impl_var
, var
,
1297 NAMED(DOLLAR_NAME
, T
)) {
1298 var
= psi_impl_var_init(T
->text
, r
);
1303 * impl_type: impl_type_token
1305 PARSE_TYPED(impl_type
, type_
,
1306 NAMED(impl_type_token
, T
)) {
1307 type_
= psi_impl_type_init(T
->type
, T
->text
);
1312 * impl_arg: impl_type impl_var
1314 PARSE_TYPED(impl_arg
, arg
,
1315 TYPED(impl_type
, type
)
1316 TYPED(impl_var
, var
)) {
1317 arg
= psi_impl_arg_init(type
, var
, NULL
);
1321 * impl_arg: impl_type impl_var = impl_def_val
1323 PARSE_TYPED(impl_arg
, arg
,
1324 TYPED(impl_type
, type
)
1325 TYPED(impl_var
, var
)
1327 TYPED(impl_def_val
, def
)) {
1328 arg
= psi_impl_arg_init(type
, var
, def
);
1332 * impl_args: impl_arg
1334 PARSE_TYPED(impl_args
, args
,
1335 TYPED(impl_arg
, arg
)) {
1336 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1341 * impl_args: impl_args , impl_arg
1343 PARSE_TYPED(impl_args
, args
,
1344 TYPED(impl_args
, args_
)
1346 TYPED(impl_arg
, arg
)) {
1347 args
= psi_plist_add(args_
, &arg
);
1351 * impl_stmts: impl_stmt
1353 PARSE_TYPED(impl_stmts
, stmts
,
1354 TYPED(impl_stmt
, stmt
)) {
1355 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1360 * impl_stmts: impl_stmts , impl_stmt
1362 PARSE_TYPED(impl_stmts
, stmts
,
1363 TYPED(impl_stmts
, stmts_
)
1364 TYPED(impl_stmt
, stmt
)) {
1365 stmts
= psi_plist_add(stmts_
, &stmt
);
1369 * impl_stmt: return_stmt
1371 PARSE_TYPED(impl_stmt
, i
,
1372 TYPED(return_stmt
, r
)) {
1373 i
= (struct psi_token
**) r
;
1377 * impl_stmt: let_stmt
1379 PARSE_TYPED(impl_stmt
, i
,
1380 TYPED(let_stmt
, l
)) {
1381 i
= (struct psi_token
**) l
;
1385 * impl_stmt: set_stmt
1387 PARSE_TYPED(impl_stmt
, i
,
1388 TYPED(set_stmt
, s
)) {
1389 i
= (struct psi_token
**) s
;
1393 * impl_stmt: free_stmt
1395 PARSE_TYPED(impl_stmt
, i
,
1396 TYPED(free_stmt
, f
)) {
1397 i
= (struct psi_token
**) f
;
1401 * num_exp: num_exp_token
1403 PARSE_TYPED(num_exp
, exp
,
1404 NAMED(num_exp_token
, tok
)) {
1405 exp
= psi_num_exp_init(tok
->type
, tok
->text
);
1412 PARSE_TYPED(num_exp
, exp
,
1413 TYPED(decl_var
, var
)) {
1414 exp
= psi_num_exp_init(PSI_T_NAME
, var
);
1415 exp
->token
= psi_token_copy(var
->token
);
1419 * num_exp: num_exp num_exp_op_token num_exp
1421 PARSE_TYPED(num_exp
, exp
,
1422 TYPED(num_exp
, exp_
)
1423 NAMED(num_exp_op_token
, operator_
)
1424 TYPED(num_exp
, operand_
)) {
1425 exp_
->op
= operator_
->type
;
1426 exp_
->operand
= operand_
;
1434 PARSE_TYPED(let_exp
, val
,
1436 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1442 PARSE_TYPED(let_exp
, val
,
1445 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1446 val
->is_reference
= 1;
1452 PARSE_TYPED(let_exp
, val
,
1453 TYPED(let_callback
, cb
)) {
1454 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1460 PARSE_TYPED(let_exp
, val
,
1461 TYPED(let_calloc
, ca
)) {
1462 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1468 PARSE_TYPED(let_exp
, val
,
1470 TYPED(let_calloc
, ca
)) {
1471 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1472 val
->is_reference
= 1;
1478 PARSE_TYPED(let_exp
, val
,
1479 TYPED(let_func
, fn
)) {
1480 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1486 PARSE_TYPED(let_exp
, val
,
1488 TYPED(let_func
, fn
)) {
1489 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1490 val
->is_reference
= 1;
1496 PARSE_TYPED(let_exp
, val
,
1497 TYPED(num_exp
, exp
)) {
1498 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1502 * let_exp: & num_exp
1504 PARSE_TYPED(let_exp
, val
,
1506 TYPED(num_exp
, exp
)) {
1507 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1508 val
->is_reference
= 1;
1512 * let_exp: decl_var = let_exp
1514 PARSE_TYPED(let_exp
, exp
,
1515 TYPED(decl_var
, var_
)
1517 TYPED(let_exp
, val
)) {
1523 * let_stmt: LET let_exp ;
1525 PARSE_TYPED(let_stmt
, let
,
1529 let
= psi_let_stmt_init(val
);
1534 * let_stmt: TEMP decl_var = reference decl_var ;
1536 PARSE_TYPED(let_stmt
, let
,
1538 TYPED(decl_var
, var
)
1541 TYPED(decl_var
, val_
)
1543 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1545 let
->exp
->is_reference
= r
? 1 : 0;
1549 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1551 PARSE_TYPED(let_callback
, cb
,
1553 NAMED(callback_rval
, F
)
1555 TYPED(impl_var
, var
)
1557 TYPED(callback_arg_list
, args_
)
1560 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1566 * let_calloc: CALLOC ( num_exp , num_exp )
1568 PARSE_TYPED(let_calloc
, alloc
,
1571 TYPED(num_exp
, nmemb
)
1573 TYPED(num_exp
, size
)
1575 alloc
= psi_let_calloc_init(nmemb
, size
);
1580 * let_func: let_func_token ( impl_var )
1582 PARSE_TYPED(let_func
, func
,
1583 NAMED(let_func_token
, T
)
1585 TYPED(impl_var
, var
)
1587 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1591 * let_func: let_func_token ( impl_var , let_exps )
1593 PARSE_TYPED(let_func
, func
,
1594 NAMED(let_func_token
, T
)
1596 TYPED(impl_var
, var
)
1598 TYPED(let_exps
, vals
)
1600 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1607 PARSE_TYPED(let_exps
, exps
,
1608 TYPED(let_exp
, exp
)) {
1609 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1613 * let_exps: let_exps , let_exp
1615 PARSE_TYPED(let_exps
, exps
,
1616 TYPED(let_exps
, exps_
)
1618 TYPED(let_exp
, exp
)) {
1619 exps
= psi_plist_add(exps_
, &exp
);
1623 * callback_arg_list: <empty>
1625 PASS(callback_arg_list
, )
1628 * callback_arg_list: callback_args
1630 PARSE_TYPED(callback_arg_list
, args
,
1631 TYPED(callback_args
, args_
)) {
1636 * callback_args: set_exp
1638 PARSE_TYPED(callback_args
, args
,
1639 TYPED(set_exp
, val
)) {
1640 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1645 * callback_args: callback_args , set_exp
1647 PARSE_TYPED(callback_args
, args
,
1648 TYPED(callback_args
, args_
)
1650 TYPED(set_exp
, val
)) {
1651 args
= psi_plist_add(args_
, &val
);
1655 * callback_rval: let_func_token
1657 PARSE_NAMED(callback_rval
, rval
,
1658 NAMED(let_func_token
, F
)) {
1663 * callback_rval: VOID
1665 PARSE_NAMED(callback_rval
, rval
,
1672 * set_func: set_func_token ( decl_var )
1674 PARSE_TYPED(set_func
, func
,
1675 NAMED(set_func_token
, T
)
1677 TYPED(decl_var
, var
)
1679 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1684 * set_func: set_func_token ( decl_var , set_exps )
1686 PARSE_TYPED(set_func
, func
,
1687 NAMED(set_func_token
, T
)
1689 TYPED(decl_var
, var
)
1691 TYPED(set_exps
, vals
)
1693 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1699 * set_func: set_func_token ( decl_var , ... )
1701 PARSE_TYPED(set_func
, func
,
1702 NAMED(set_func_token
, T
)
1704 TYPED(decl_var
, var
)
1708 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1710 func
->recursive
= 1;
1716 PARSE_TYPED(set_exp
, val
,
1717 TYPED(set_func
, fn
)) {
1718 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
1724 PARSE_TYPED(set_exp
, val
,
1725 TYPED(num_exp
, num
)) {
1726 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
1732 PARSE_TYPED(set_exps
, exps
,
1733 TYPED(set_exp
, exp
)) {
1734 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1739 * set_exps: set_exps , set_exp
1741 PARSE_TYPED(set_exps
, exps
,
1742 TYPED(set_exps
, exps_
)
1744 TYPED(set_exp
, exp
)) {
1745 exps
= psi_plist_add(exps_
, &exp
);
1749 * set_exp: impl_var = set_exp
1751 PARSE_TYPED(set_exp
, exp
,
1752 TYPED(impl_var
, var_
)
1754 TYPED(set_exp
, val
)) {
1760 * set_stmt: SET set_exp ;
1762 PARSE_TYPED(set_stmt
, set
,
1766 set
= psi_set_stmt_init(exp
);
1771 * return_stmt: RETURN set_exp ;
1773 PARSE_TYPED(return_stmt
, ret
,
1775 TYPED(set_func
, func
)
1777 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
1782 * free_stmt: FREE free_exps ;
1784 PARSE_TYPED(free_stmt
, free
,
1786 TYPED(free_exps
, calls
)
1788 free
= psi_free_stmt_init(calls
);
1792 * free_exps: free_exp
1794 PARSE_TYPED(free_exps
, calls
,
1795 TYPED(free_exp
, call
)) {
1796 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
1801 * free_exps: free_exps , free_exp
1803 PARSE_TYPED(free_exps
, calls
,
1804 TYPED(free_exps
, calls_
)
1806 TYPED(free_exp
, call
)) {
1807 calls
= psi_plist_add(calls_
, &call
);
1811 * free_exp: NAME ( decl_vars )
1813 PARSE_TYPED(free_exp
, call
,
1816 TYPED(decl_vars
, vars
)
1818 call
= psi_free_exp_init(F
->text
, vars
);
1823 * reference: <empty>
1825 PARSE_TYPED(reference
, r
, ) {
1832 PARSE_TYPED(reference
, r
,
1838 * indirection: <empty>
1840 PARSE_TYPED(indirection
, i
, ){
1845 * indirection: pointers
1847 PARSE_TYPED(indirection
, i
,
1848 TYPED(pointers
, p
)) {
1855 PARSE_TYPED(pointers
, p
,
1861 * pointers: pointers *
1863 PARSE_TYPED(pointers
, p
,