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
, LSHIFT RSHIFT
.)
84 DEF(%left
, PLUS MINUS
.)
85 DEF(%left
, ASTERISK SLASH
.)
86 DEF(%nonassoc
, AMPERSAND
.)
87 DEF(%nonassoc
, CARET
.)
89 DEF(%fallback
, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT
.)
91 DEF(%token_class
, const_type_token BOOL INT FLOAT STRING
.)
92 DEF(%token_class
, decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME
.)
93 DEF(%token_class
, impl_def_val_token NULL NUMBER TRUE FALSE QUOTED_STRING
.)
94 DEF(%token_class
, num_exp_token NUMBER NSNAME
.)
95 DEF(%token_class
, num_exp_op_token LSHIFT RSHIFT PLUS MINUS ASTERISK SLASH AMPERSAND CARET PIPE
.)
96 DEF(%token_class
, let_func_token ZVAL OBJVAL ARRVAL PATHVAL STRLEN STRVAL FLOATVAL INTVAL BOOLVAL COUNT
.)
97 DEF(%token_class
, set_func_token TO_OBJECT TO_ARRAY TO_STRING TO_INT TO_FLOAT TO_BOOL ZVAL VOID
.)
98 DEF(%token_class
, impl_type_token VOID MIXED BOOL INT FLOAT STRING ARRAY OBJECT CALLABLE
.)
100 TOKEN_TYPE(decl_enum
, struct psi_decl_enum
*)
101 TOKEN_DTOR(decl_enum
, psi_decl_enum_free(&$$
);)
102 TOKEN_TYPE(decl_enum_items
, struct psi_plist
*)
103 TOKEN_DTOR(decl_enum_items
, psi_plist_free($$
);)
104 TOKEN_TYPE(decl_enum_item
, struct psi_decl_enum_item
*)
105 TOKEN_DTOR(decl_enum_item
, psi_decl_enum_item_free(&$$
);)
106 TOKEN_TYPE(decl_struct_args_block
, struct psi_plist
*)
107 TOKEN_DTOR(decl_struct_args_block
, psi_plist_free($$
);) /* there was a typo */
108 TOKEN_TYPE(decl_struct_args
, struct psi_plist
*)
109 TOKEN_DTOR(decl_struct_args
, psi_plist_free($$
);)
110 TOKEN_TYPE(decl_struct
, struct psi_decl_struct
*)
111 TOKEN_DTOR(decl_struct
, psi_decl_struct_free(&$$
);)
112 TOKEN_TYPE(align_and_size
, struct psi_layout
)
113 TOKEN_TYPE(decl_union
, struct psi_decl_union
*)
114 TOKEN_DTOR(decl_union
, psi_decl_union_free(&$$
);)
115 TOKEN_TYPE(const_type
, struct psi_const_type
*)
116 TOKEN_DTOR(const_type
, psi_const_type_free(&$$
);)
117 TOKEN_TYPE(constant
, struct psi_const
*)
118 TOKEN_DTOR(constant
, psi_const_free(&$$
);)
119 TOKEN_TYPE(decl_typedef
, struct psi_decl_arg
*)
120 TOKEN_DTOR(decl_typedef
, psi_decl_arg_free(&$$
);)
121 TOKEN_TYPE(decl_typedef_body_ex
, struct psi_decl_arg
*)
122 TOKEN_DTOR(decl_typedef_body_ex
, psi_decl_arg_free(&$$
);)
123 TOKEN_TYPE(decl_typedef_body
, struct psi_decl_arg
*)
124 TOKEN_DTOR(decl_typedef_body
, psi_decl_arg_free(&$$
);)
125 TOKEN_TYPE(decl_typedef_body_fn_args
, struct psi_plist
*)
126 TOKEN_DTOR(decl_typedef_body_fn_args
, psi_plist_free($$
);)
127 TOKEN_TYPE(decl
, struct psi_decl
*)
128 TOKEN_DTOR(decl
, psi_decl_free(&$$
);)
129 TOKEN_TYPE(decl_func
, struct psi_decl_arg
*)
130 TOKEN_DTOR(decl_func
, psi_decl_arg_free(&$$
);)
131 TOKEN_TYPE(decl_abi
, struct psi_decl_abi
*)
132 TOKEN_DTOR(decl_abi
, psi_decl_abi_free(&$$
);)
133 TOKEN_TYPE(decl_var
, struct psi_decl_var
*)
134 TOKEN_DTOR(decl_var
, psi_decl_var_free(&$$
);)
135 TOKEN_TYPE(decl_vars
, struct psi_plist
*)
136 TOKEN_DTOR(decl_vars
, psi_plist_free($$
);)
137 TOKEN_TYPE(decl_arg
, struct psi_decl_arg
*)
138 TOKEN_DTOR(decl_arg
, psi_decl_arg_free(&$$
);)
139 TOKEN_TYPE(decl_args
, struct psi_plist
*)
140 TOKEN_DTOR(decl_args
, psi_plist_free($$
);)
141 TOKEN_TYPE(struct_args
, struct psi_plist
*)
142 TOKEN_DTOR(struct_args
, psi_plist_free($$
);)
143 TOKEN_TYPE(struct_arg
, struct psi_decl_arg
*)
144 TOKEN_DTOR(struct_arg
, psi_decl_arg_free(&$$
);)
145 TOKEN_TYPE(decl_layout
, struct psi_layout
*)
146 TOKEN_DTOR(decl_layout
, psi_layout_free(&$$
);)
147 TOKEN_TYPE(decl_type
, struct psi_decl_type
*)
148 TOKEN_DTOR(decl_type
, psi_decl_type_free(&$$
);)
149 TOKEN_TYPE(const_decl_type
, struct psi_decl_type
*)
150 TOKEN_DTOR(const_decl_type
, psi_decl_type_free(&$$
);)
151 TOKEN_TYPE(impl
, struct psi_impl
*)
152 TOKEN_DTOR(impl
, psi_impl_free(&$$
);)
153 TOKEN_TYPE(impl_func
, struct psi_impl_func
*)
154 TOKEN_DTOR(impl_func
, psi_impl_func_free(&$$
);)
155 TOKEN_TYPE(impl_def_val
, struct psi_impl_def_val
*)
156 TOKEN_DTOR(impl_def_val
, psi_impl_def_val_free(&$$
);)
157 TOKEN_TYPE(impl_var
, struct psi_impl_var
*)
158 TOKEN_DTOR(impl_var
, psi_impl_var_free(&$$
);)
159 TOKEN_TYPE(impl_arg
, struct psi_impl_arg
*)
160 TOKEN_DTOR(impl_arg
, psi_impl_arg_free(&$$
);)
161 TOKEN_TYPE(impl_args
, struct psi_plist
*)
162 TOKEN_DTOR(impl_args
, psi_plist_free($$
);)
163 TOKEN_TYPE(impl_vararg
, struct psi_impl_arg
*)
164 TOKEN_DTOR(impl_vararg
, psi_impl_arg_free(&$$
);)
165 TOKEN_TYPE(impl_stmts
, struct psi_plist
*)
166 TOKEN_DTOR(impl_stmts
, psi_plist_free($$
);)
167 TOKEN_TYPE(impl_stmt
, struct psi_token
**)
168 TOKEN_DTOR(impl_stmt
, psi_impl_stmt_free(&$$
);)
169 TOKEN_TYPE(num_exp
, struct psi_num_exp
*)
170 TOKEN_DTOR(num_exp
, psi_num_exp_free(&$$
);)
171 TOKEN_TYPE(let_stmt
, struct psi_let_stmt
*)
172 TOKEN_DTOR(let_stmt
, psi_let_stmt_free(&$$
);)
173 TOKEN_TYPE(let_calloc
, struct psi_let_calloc
*)
174 TOKEN_DTOR(let_calloc
, psi_let_calloc_free(&$$
);)
175 TOKEN_TYPE(let_func
, struct psi_let_func
*)
176 TOKEN_DTOR(let_func
, psi_let_func_free(&$$
);)
177 TOKEN_TYPE(callback_arg_list
, struct psi_plist
*)
178 TOKEN_DTOR(callback_arg_list
, psi_plist_free($$
);)
179 TOKEN_TYPE(callback_args
, struct psi_plist
*)
180 TOKEN_DTOR(callback_args
, psi_plist_free($$
);)
181 TOKEN_TYPE(let_callback
, struct psi_let_callback
*)
182 TOKEN_DTOR(let_callback
, psi_let_callback_free(&$$
);)
183 TOKEN_TYPE(let_exp
, struct psi_let_exp
*)
184 TOKEN_DTOR(let_exp
, psi_let_exp_free(&$$
);)
185 TOKEN_TYPE(let_exps
, struct psi_plist
*)
186 TOKEN_DTOR(let_exps
, psi_plist_free($$
);)
187 TOKEN_TYPE(set_stmt
, struct psi_set_stmt
*)
188 TOKEN_DTOR(set_stmt
, psi_set_stmt_free(&$$
);)
189 TOKEN_TYPE(set_exp
, struct psi_set_exp
*)
190 TOKEN_DTOR(set_exp
, psi_set_exp_free(&$$
);)
191 TOKEN_TYPE(set_exps
, struct psi_plist
*)
192 TOKEN_DTOR(set_exps
, psi_plist_free($$
);)
193 TOKEN_TYPE(set_func
, struct psi_set_func
*)
194 TOKEN_DTOR(set_func
, psi_set_func_free(&$$
);)
195 TOKEN_TYPE(return_stmt
, struct psi_return_stmt
*)
196 TOKEN_DTOR(return_stmt
, psi_return_stmt_free(&$$
);)
197 TOKEN_TYPE(free_stmt
, struct psi_free_stmt
*)
198 TOKEN_DTOR(free_stmt
, psi_free_stmt_free(&$$
);)
199 TOKEN_TYPE(free_exps
, struct psi_plist
*)
200 TOKEN_DTOR(free_exps
, psi_plist_free($$
);)
201 TOKEN_TYPE(free_exp
, struct psi_free_exp
*)
202 TOKEN_DTOR(free_exp
, psi_free_exp_free(&$$
);)
203 TOKEN_TYPE(impl_type
, struct psi_impl_type
*)
204 TOKEN_DTOR(impl_type
, psi_impl_type_free(&$$
);)
205 TOKEN_TYPE(reference
, bool)
206 TOKEN_TYPE(indirection
, unsigned)
207 TOKEN_TYPE(pointers
, unsigned)
211 PASS(blocks
, blocks block
)
217 * lib: LIB "soname" ;
219 PARSE(block
, NAMED(LIB
, token
) NAMED(QUOTED_STRING
, libname
) TOKEN(EOS
)) {
221 P
->error(PSI_DATA(P
), token
, PSI_WARNING
, "Extra 'lib %s' statement has no effect", libname
->text
);
223 P
->file
.ln
= strndup(libname
->text
+ 1, libname
->size
- 2);
229 PARSE(block
, TYPED(decl
, decl
)) {
231 P
->decls
= psi_plist_init((psi_plist_dtor
) psi_decl_free
);
233 P
->decls
= psi_plist_add(P
->decls
, &decl
);
236 PARSE(block
, TYPED(impl
, impl
)) {
238 P
->impls
= psi_plist_init((psi_plist_dtor
) psi_impl_free
);
240 P
->impls
= psi_plist_add(P
->impls
, &impl
);
243 PARSE(block
, TYPED(decl_typedef
, def
)) {
245 P
->types
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
247 P
->types
= psi_plist_add(P
->types
, &def
);
249 switch (def
->type
->type
) {
251 if (def
->type
->real
.strct
) {
253 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
255 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
259 if (def
->type
->real
.unn
) {
261 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
263 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
267 if (def
->type
->real
.enm
) {
269 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
271 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
277 PARSE(block
, TYPED(constant
, constant
)) {
279 P
->consts
= psi_plist_init((psi_plist_dtor
) psi_const_free
);
281 P
->consts
= psi_plist_add(P
->consts
, &constant
);
284 PARSE(block
, TYPED(decl_struct
, strct
)) {
286 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
288 P
->structs
= psi_plist_add(P
->structs
, &strct
);
291 PARSE(block
, TYPED(decl_union
, u
)) {
293 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
295 P
->unions
= psi_plist_add(P
->unions
, &u
);
298 PARSE(block
, TYPED(decl_enum
, e
)) {
300 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
302 P
->enums
= psi_plist_add(P
->enums
, &e
);
306 * optional_name: <empty>
308 PARSE_NAMED(optional_name
, n
, ) {
313 * optional_name: NAME
315 PARSE_NAMED(optional_name
, n
,
321 * align_and_size: <empty>
323 PARSE_TYPED(align_and_size
, as
, ) {
329 * align_and_size: :: ( NUMBER , NUMBER )
331 PARSE_TYPED(align_and_size
, as
,
339 as
.pos
= atol(A
->text
);
340 as
.len
= atol(S
->text
);
346 * enum_name: ENUM optional_name
348 PARSE_NAMED(enum_name
, n
,
350 NAMED(optional_name
, N
)) {
357 psi_token_hash(E
, digest
);
358 n
= psi_token_translit(psi_token_append(E
, 1, digest
), " ", "@");
363 * struct_name: STRUCT optional_name
365 PARSE_NAMED(struct_name
, n
,
367 NAMED(optional_name
, N
)) {
374 psi_token_hash(S
, digest
);
375 n
= psi_token_translit(psi_token_append(S
, 1, digest
), " ", "@");
380 * union_name: UNION optional_name
382 PARSE_NAMED(union_name
, n
,
384 NAMED(optional_name
, N
)) {
391 psi_token_hash(U
, digest
);
392 n
= psi_token_translit(psi_token_append(U
, 1, digest
), " ", "@");
397 * decl_enum: enum_name { items }
399 PARSE_TYPED(decl_enum
, e
,
402 TYPED(decl_enum_items
, list
)
404 e
= psi_decl_enum_init(N
->text
, list
);
409 * decl_enum_items: item
411 PARSE_TYPED(decl_enum_items
, l
,
412 TYPED(decl_enum_item
, i
)) {
413 l
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_enum_item_free
),
418 * decl_enum_items: items , item
420 PARSE_TYPED(decl_enum_items
, l
,
421 TYPED(decl_enum_items
, l_
)
423 TYPED(decl_enum_item
, i
)) {
424 l
= psi_plist_add(l_
, &i
);
428 * decl_enum_item: name = num_exp
430 PARSE_TYPED(decl_enum_item
, i
,
433 TYPED(num_exp
, num
)) {
434 i
= psi_decl_enum_item_init(N
->text
, num
);
439 * decl_enum_item: name
441 PARSE_TYPED(decl_enum_item
, i
,
443 i
= psi_decl_enum_item_init(N
->text
, NULL
);
449 * decl_struct_args_block: { args }
451 PARSE_TYPED(decl_struct_args_block
, args_
,
453 TYPED(struct_args
, args
)
459 * decl_struct_args: args_block
461 PARSE_TYPED(decl_struct_args
, args_
,
462 TYPED(decl_struct_args_block
, args
)) {
467 * decl_struct_args: ;
469 PARSE_TYPED(decl_struct_args
, args_
,
471 args_
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
475 * decl_struct: STRUCT name align_and_size struct_args
477 PARSE_TYPED(decl_struct
, strct
,
480 TYPED(align_and_size
, as
)
481 TYPED(decl_struct_args
, args
)) {
482 strct
= psi_decl_struct_init(N
->text
, args
);
483 strct
->align
= as
.pos
;
484 strct
->size
= as
.len
;
489 * decl_union: UNION name align_and_size struct_args
491 PARSE_TYPED(decl_union
, u
,
494 TYPED(align_and_size
, as
)
495 TYPED(decl_struct_args
, args
)) {
496 u
= psi_decl_union_init(N
->text
, args
);
503 * const_type: const_type_token
505 PARSE_TYPED(const_type
, type_
,
506 NAMED(const_type_token
, T
)) {
507 type_
= psi_const_type_init(T
->type
, T
->text
);
512 * constant: CONST const_type NSNAME = def_val ;
514 PARSE_TYPED(constant
, constant
,
516 TYPED(const_type
, type
)
519 TYPED(impl_def_val
, val
)
521 constant
= psi_const_init(type
, T
->text
, val
);
526 * decl_typdef: TYPEDEF typedef_body ;
528 PARSE_TYPED(decl_typedef
, def
,
530 TYPED(decl_typedef_body
, def_
)
537 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
539 PARSE_TYPED(decl_typedef_body_ex
, def
,
540 NAMED(struct_name
, N
)
541 TYPED(align_and_size
, as
)
542 TYPED(decl_struct_args_block
, args
)
543 TYPED(decl_var
, var
)) {
544 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT
, N
->text
), var
);
545 def
->type
->token
= psi_token_copy(N
);
546 def
->type
->real
.strct
= psi_decl_struct_init(N
->text
, args
);
547 def
->type
->real
.strct
->token
= N
;
548 def
->type
->real
.strct
->align
= as
.pos
;
549 def
->type
->real
.strct
->size
= as
.len
;
553 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
555 PARSE_TYPED(decl_typedef_body_ex
, def
,
557 TYPED(align_and_size
, as
)
558 TYPED(decl_struct_args_block
, args
)
559 TYPED(decl_var
, var
)) {
560 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION
, N
->text
), var
);
561 def
->type
->token
= psi_token_copy(N
);
562 def
->type
->real
.unn
= psi_decl_union_init(N
->text
, args
);
563 def
->type
->real
.unn
->token
= N
;
564 def
->type
->real
.unn
->align
= as
.pos
;
565 def
->type
->real
.unn
->size
= as
.len
;
569 * decl_typedef_body_ex: decl_enum NAME
571 PARSE_TYPED(decl_typedef_body_ex
, def
,
573 NAMED(NAME
, ALIAS
)) {
574 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM
, e
->name
), psi_decl_var_init(ALIAS
->text
, 0, 0));
575 def
->var
->token
= ALIAS
;
576 def
->type
->token
= psi_token_copy(e
->token
);
577 def
->type
->real
.enm
= e
;
581 * decl_typedef_body: decl_typedef_body_ex
583 PARSE_TYPED(decl_typedef_body
, def
,
584 TYPED(decl_typedef_body_ex
, def_
)) {
589 * decl_typedef_body_fn_args: ( decl_args )
591 PARSE_TYPED(decl_typedef_body_fn_args
, args
,
593 TYPED(decl_args
, args_
)
599 * decl_typedef_body: decl_func decl_typedef_body_fn_args
601 PARSE_TYPED(decl_typedef_body
, def
,
602 TYPED(decl_func
, func_
)
603 TYPED(decl_typedef_body_fn_args
, args
)) {
604 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
), psi_decl_var_copy(func_
->var
));
605 def
->type
->token
= psi_token_copy(func_
->token
);
606 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
610 * decl_typedef_body: decl_arg
612 PARSE_TYPED(decl_typedef_body
, def
,
613 TYPED(decl_arg
, arg
)) {
618 * decl: decl_abi decl_func ( decl_args ) ;
620 PARSE_TYPED(decl
, decl
,
622 TYPED(decl_func
, func
)
624 TYPED(decl_args
, args
)
627 decl
= psi_decl_init(abi
, func
, args
);
631 * decl: decl_abi decl_func ( decl_args , ... ) ;
633 PARSE_TYPED(decl
, decl
,
635 TYPED(decl_func
, func
)
637 TYPED(decl_args
, args
)
642 decl
= psi_decl_init(abi
, func
, args
);
647 * decl_func: decl_arg
649 PARSE_TYPED(decl_func
, func
,
650 TYPED(decl_arg
, arg
)) {
654 /* special case for void functions */
656 * decl_func: VOID NAME
658 PARSE_TYPED(decl_func
, func
,
661 func
= psi_decl_arg_init(
662 psi_decl_type_init(T
->type
, T
->text
),
663 psi_decl_var_init(N
->text
, 0, 0)
665 func
->type
->token
= T
;
666 func
->var
->token
= N
;
671 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
673 PARSE_TYPED(decl_typedef_body
, def
,
675 TYPED(indirection
, decl_i
)
677 TYPED(indirection
, type_i
)
680 TYPED(decl_typedef_body_fn_args
, args
)) {
681 struct psi_decl_arg
*func_
= psi_decl_arg_init(
682 psi_decl_type_init(T
->type
, T
->text
),
683 psi_decl_var_init(N
->text
, decl_i
, 0)
685 func_
->type
->token
= T
;
686 func_
->var
->token
= N
;
689 def
= psi_decl_arg_init(
690 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
691 psi_decl_var_copy(func_
->var
)
693 def
->var
->pointer_level
= type_i
;
694 def
->type
->token
= psi_token_copy(func_
->token
);
695 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
699 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
701 PARSE_TYPED(decl_typedef_body
, def
,
704 TYPED(pointers
, decl_i
)
706 TYPED(indirection
, type_i
)
709 TYPED(decl_typedef_body_fn_args
, args
)) {
710 struct psi_decl_arg
*func_
= psi_decl_arg_init(
711 psi_decl_type_init(T
->type
, T
->text
),
712 psi_decl_var_init(N
->text
, decl_i
, 0)
714 func_
->type
->token
= T
;
715 func_
->var
->token
= N
;
718 def
= psi_decl_arg_init(
719 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
720 psi_decl_var_copy(func_
->var
)
722 def
->var
->pointer_level
= type_i
;
723 def
->type
->token
= psi_token_copy(func_
->token
);
724 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
730 PARSE_TYPED(decl_abi
, abi
,
732 abi
= psi_decl_abi_init(T
->text
);
737 * decl_var_array_size: <empty>
739 PARSE_NAMED(decl_var_array_size
, as
, ) {
744 * decl_var_array_size: [ NUMBER ]
746 PARSE_NAMED(decl_var_array_size
, as
,
754 * decl_var: NAME decl_var_array_size
756 PARSE_TYPED(decl_var
, var
,
758 NAMED(decl_var_array_size
, as
)) {
759 var
= psi_decl_var_init(T
->text
, 0, as
?atol(as
->text
):0);
767 * decl_var: pointers NAME
769 PARSE_TYPED(decl_var
, var
,
772 NAMED(decl_var_array_size
, as
)) {
773 var
= psi_decl_var_init(T
->text
, p
+!!as
, as
?atol(as
->text
):0);
781 * decl_vars: decl_var
783 PARSE_TYPED(decl_vars
, vars
,
784 TYPED(decl_var
, var
)) {
785 vars
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_var_free
),
790 * decl_vars: decl_vars , decl_var
792 PARSE_TYPED(decl_vars
, vars
,
793 TYPED(decl_vars
, vars_
)
795 TYPED(decl_var
, var
)) {
796 vars
= psi_plist_add(vars_
, &var
);
800 * decl_arg: const_decl_type decl_var
802 PARSE_TYPED(decl_arg
, arg_
,
803 TYPED(const_decl_type
, type
)
804 TYPED(decl_var
, var
)) {
805 arg_
= psi_decl_arg_init(type
, var
);
809 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
811 PARSE_TYPED(decl_typedef_body
, def
,
812 TYPED(const_decl_type
, type_
)
813 TYPED(indirection
, decl_i
)
815 TYPED(indirection
, type_i
)
818 TYPED(decl_typedef_body_fn_args
, args
)) {
819 struct psi_decl_arg
*func_
= psi_decl_arg_init(
821 psi_decl_var_init(N
->text
, decl_i
, 0)
823 func_
->var
->token
= N
;
826 def
= psi_decl_arg_init(
827 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
828 psi_decl_var_copy(func_
->var
)
830 def
->var
->pointer_level
= type_i
;
831 def
->type
->token
= psi_token_copy(func_
->token
);
832 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
835 /* void pointers need a specific rule */
837 * decl_arg: VOID pointers NAME
839 PARSE_TYPED(decl_arg
, arg_
,
843 arg_
= psi_decl_arg_init(
844 psi_decl_type_init(T
->type
, T
->text
),
845 psi_decl_var_init(N
->text
, p
, 0)
847 arg_
->type
->token
= T
;
848 arg_
->var
->token
= N
;
853 * decl_args: CONST VOID pointers NAME
855 PARSE_TYPED(decl_arg
, arg_
,
860 arg_
= psi_decl_arg_init(
861 psi_decl_type_init(T
->type
, T
->text
),
862 psi_decl_var_init(N
->text
, p
, 0)
864 arg_
->type
->token
= T
;
865 arg_
->var
->token
= N
;
877 PASS(decl_args
, VOID
)
880 * decl_args: decl_arg
882 PARSE_TYPED(decl_args
, args
,
883 TYPED(decl_arg
, arg
)) {
884 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
889 * decl_args: decl_args , decl_arg
891 PARSE_TYPED(decl_args
, args
,
892 TYPED(decl_args
, args_
)
894 TYPED(decl_arg
, arg
)) {
895 args
= psi_plist_add(args_
, &arg
);
899 * struct_args: struct_arg
901 PARSE_TYPED(struct_args
, args
,
902 TYPED(struct_arg
, arg
)) {
903 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
908 * struct_args: struct_args , struct_arg
910 PARSE_TYPED(struct_args
, args
,
911 TYPED(struct_args
, args_
)
912 TYPED(struct_arg
, arg
)) {
913 args
= psi_plist_add(args_
, &arg
);
917 * struct_arg: decl_typedef_body_ex ;
919 PARSE_TYPED(struct_arg
, arg_
,
920 TYPED(decl_typedef_body_ex
, def
)
923 switch (def
->type
->type
) {
925 if (def
->type
->real
.strct
) {
927 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
929 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
933 if (def
->type
->real
.unn
) {
935 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
937 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
941 if (def
->type
->real
.enm
) {
943 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
945 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
952 * struct_arg: decl_arg decl_layout ;
954 PARSE_TYPED(struct_arg
, arg
,
955 TYPED(decl_arg
, arg_
)
956 TYPED(decl_layout
, layout_
)
958 arg_
->layout
= layout_
;
963 * decl_layout: <empty>
965 PARSE_TYPED(decl_layout
, layout
, ) {
970 * decl_layout: :: ( NUMBER , NUMBER )
972 PARSE_TYPED(decl_layout
, layout
,
980 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
985 /* un/signed, urgh */
987 * decl_scalar_type: CHAR
989 PARSE_NAMED(decl_scalar_type
, type_
,
995 * decl_scalar_type: SHORT decl_scalar_type_short
997 PARSE_NAMED(decl_scalar_type
, type_
,
999 NAMED(decl_scalar_type_short
, s
)) {
1001 type_
= psi_token_cat(2, S
, s
);
1010 * decl_scalar_type_short: <empty>
1012 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1017 * decl_scalar_type_short: INT
1019 PARSE_NAMED(decl_scalar_type_short
, s
,
1025 * decl_sclara_type: INT
1027 PARSE_NAMED(decl_scalar_type
, type_
,
1033 * decl_scalar_type: LONG decl_scalar_type_long
1035 PARSE_NAMED(decl_scalar_type
, type_
,
1037 NAMED(decl_scalar_type_long
, l
)) {
1039 type_
= psi_token_cat(2, L
, l
);
1048 * decl_scalar_type_long: <empty>
1050 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1055 * decl_scalar_type_long: DOUBLE
1057 PARSE_NAMED(decl_scalar_type_long
, l
,
1063 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1065 PARSE_NAMED(decl_scalar_type_long
, l
,
1067 NAMED(decl_scalar_type_long_long
, ll
)) {
1069 l
= psi_token_cat(2, L
, ll
);
1078 * decl_scalar_type_long_long: <empty>
1080 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1085 * decl_scalar_type_long_long: INT
1087 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1093 * decl_type: UNSIGNED decl_scalar_type
1095 PARSE_TYPED(decl_type
, type_
,
1097 NAMED(decl_scalar_type
, N
)) {
1098 struct psi_token
*T
= psi_token_cat(2, U
, N
);
1099 type_
= psi_decl_type_init(T
->type
, T
->text
);
1106 * decl_type: SIGNED decl_scalar_type
1108 PARSE_TYPED(decl_type
, type_
,
1110 NAMED(decl_scalar_type
, N
)) {
1111 struct psi_token
*T
= psi_token_cat(2, S
, N
);
1112 type_
= psi_decl_type_init(T
->type
, T
->text
);
1119 * decl_type: UNSIGNED
1121 PARSE_TYPED(decl_type
, type_
,
1122 NAMED(UNSIGNED
, U
)) {
1123 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1130 PARSE_TYPED(decl_type
, type_
,
1132 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1137 * decl_type: decl_scalar_type
1139 PARSE_TYPED(decl_type
, type_
,
1140 NAMED(decl_scalar_type
, N
)) {
1141 type_
= psi_decl_type_init(N
->type
, N
->text
);
1147 * decl_type: STRUCT NAME
1149 PARSE_TYPED(decl_type
, type_
,
1152 type_
= psi_decl_type_init(S
->type
, T
->text
);
1158 * decl_type: UNION NAME
1160 PARSE_TYPED(decl_type
, type_
,
1163 type_
= psi_decl_type_init(U
->type
, T
->text
);
1169 * decl_type: ENUM NAME
1171 PARSE_TYPED(decl_type
, type_
,
1174 type_
= psi_decl_type_init(E
->type
, T
->text
);
1180 * decl_type: decl_type_token
1182 PARSE_TYPED(decl_type
, type_
,
1183 NAMED(decl_type_token
, T
)) {
1184 type_
= psi_decl_type_init(T
->type
, T
->text
);
1189 * const_decl_type: decl_type
1191 PARSE_TYPED(const_decl_type
, type
,
1192 TYPED(decl_type
, type_
)) {
1197 * const_decl_type: CONST decl_type
1199 PARSE_TYPED(const_decl_type
, type
,
1201 TYPED(decl_type
, type_
)) {
1206 * impl: impl_func { impl_stmts }
1208 PARSE_TYPED(impl
, impl
,
1209 TYPED(impl_func
, func
)
1211 TYPED(impl_stmts
, stmts
)
1213 impl
= psi_impl_init(func
, stmts
);
1217 * impl: STATIC impl_func { impl_stmts }
1219 PARSE_TYPED(impl
, impl
,
1221 TYPED(impl_func
, func
)
1223 TYPED(impl_stmts
, stmts
)
1225 func
->static_memory
= 1;
1226 impl
= psi_impl_init(func
, stmts
);
1230 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1232 PARSE_TYPED(impl_func
, func
,
1239 TYPED(impl_type
, type
)) {
1240 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1242 func
->return_reference
= r
;
1246 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1248 PARSE_TYPED(impl_func
, func
,
1253 TYPED(impl_args
, args
)
1256 TYPED(impl_type
, type
)) {
1257 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1259 func
->return_reference
= r
;
1263 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1265 PARSE_TYPED(impl_func
, func
,
1267 TYPED(reference
, func_r
)
1270 TYPED(impl_args
, args
)
1272 TYPED(impl_type
, va_type
)
1273 TYPED(reference
, va_r
)
1275 NAMED(DOLLAR_NAME
, T
)
1278 TYPED(impl_type
, func_type
)) {
1279 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1281 func
->return_reference
= func_r
;
1282 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1287 * impl_def_val: impl_def_val_token
1289 PARSE_TYPED(impl_def_val
, def
,
1290 NAMED(impl_def_val_token
, T
)) {
1291 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1296 * impl_var: reference DOLLAR_NAME
1298 PARSE_TYPED(impl_var
, var
,
1300 NAMED(DOLLAR_NAME
, T
)) {
1301 var
= psi_impl_var_init(T
->text
, r
);
1306 * impl_type: impl_type_token
1308 PARSE_TYPED(impl_type
, type_
,
1309 NAMED(impl_type_token
, T
)) {
1310 type_
= psi_impl_type_init(T
->type
, T
->text
);
1315 * impl_arg: impl_type impl_var
1317 PARSE_TYPED(impl_arg
, arg
,
1318 TYPED(impl_type
, type
)
1319 TYPED(impl_var
, var
)) {
1320 arg
= psi_impl_arg_init(type
, var
, NULL
);
1324 * impl_arg: impl_type impl_var = impl_def_val
1326 PARSE_TYPED(impl_arg
, arg
,
1327 TYPED(impl_type
, type
)
1328 TYPED(impl_var
, var
)
1330 TYPED(impl_def_val
, def
)) {
1331 arg
= psi_impl_arg_init(type
, var
, def
);
1335 * impl_args: impl_arg
1337 PARSE_TYPED(impl_args
, args
,
1338 TYPED(impl_arg
, arg
)) {
1339 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1344 * impl_args: impl_args , impl_arg
1346 PARSE_TYPED(impl_args
, args
,
1347 TYPED(impl_args
, args_
)
1349 TYPED(impl_arg
, arg
)) {
1350 args
= psi_plist_add(args_
, &arg
);
1354 * impl_stmts: impl_stmt
1356 PARSE_TYPED(impl_stmts
, stmts
,
1357 TYPED(impl_stmt
, stmt
)) {
1358 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1363 * impl_stmts: impl_stmts , impl_stmt
1365 PARSE_TYPED(impl_stmts
, stmts
,
1366 TYPED(impl_stmts
, stmts_
)
1367 TYPED(impl_stmt
, stmt
)) {
1368 stmts
= psi_plist_add(stmts_
, &stmt
);
1372 * impl_stmt: return_stmt
1374 PARSE_TYPED(impl_stmt
, i
,
1375 TYPED(return_stmt
, r
)) {
1376 i
= (struct psi_token
**) r
;
1380 * impl_stmt: let_stmt
1382 PARSE_TYPED(impl_stmt
, i
,
1383 TYPED(let_stmt
, l
)) {
1384 i
= (struct psi_token
**) l
;
1388 * impl_stmt: set_stmt
1390 PARSE_TYPED(impl_stmt
, i
,
1391 TYPED(set_stmt
, s
)) {
1392 i
= (struct psi_token
**) s
;
1396 * impl_stmt: free_stmt
1398 PARSE_TYPED(impl_stmt
, i
,
1399 TYPED(free_stmt
, f
)) {
1400 i
= (struct psi_token
**) f
;
1404 * num_exp: num_exp_token
1406 PARSE_TYPED(num_exp
, exp
,
1407 NAMED(num_exp_token
, tok
)) {
1408 exp
= psi_num_exp_init(tok
->type
, tok
->text
);
1415 PARSE_TYPED(num_exp
, exp
,
1416 TYPED(decl_var
, var
)) {
1417 exp
= psi_num_exp_init(PSI_T_NAME
, var
);
1418 exp
->token
= psi_token_copy(var
->token
);
1422 * num_exp: num_exp num_exp_op_token num_exp
1424 PARSE_TYPED(num_exp
, exp
,
1425 TYPED(num_exp
, exp1
)
1426 NAMED(num_exp_op_token
, operator_
)
1427 TYPED(num_exp
, exp2
)) {
1430 struct psi_num_exp
*op
= exp1
;
1431 while (op
->operand
) {
1434 op
->op
= operator_
->type
;
1443 PARSE_TYPED(let_exp
, val
,
1445 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1451 PARSE_TYPED(let_exp
, val
,
1454 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1455 val
->is_reference
= 1;
1461 PARSE_TYPED(let_exp
, val
,
1462 TYPED(let_callback
, cb
)) {
1463 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1469 PARSE_TYPED(let_exp
, val
,
1470 TYPED(let_calloc
, ca
)) {
1471 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1477 PARSE_TYPED(let_exp
, val
,
1479 TYPED(let_calloc
, ca
)) {
1480 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1481 val
->is_reference
= 1;
1487 PARSE_TYPED(let_exp
, val
,
1488 TYPED(let_func
, fn
)) {
1489 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1495 PARSE_TYPED(let_exp
, val
,
1497 TYPED(let_func
, fn
)) {
1498 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1499 val
->is_reference
= 1;
1505 PARSE_TYPED(let_exp
, val
,
1506 TYPED(num_exp
, exp
)) {
1507 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1511 * let_exp: & num_exp
1513 PARSE_TYPED(let_exp
, val
,
1515 TYPED(num_exp
, exp
)) {
1516 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1517 val
->is_reference
= 1;
1521 * let_exp: decl_var = let_exp
1523 PARSE_TYPED(let_exp
, exp
,
1524 TYPED(decl_var
, var_
)
1526 TYPED(let_exp
, val
)) {
1532 * let_stmt: LET let_exp ;
1534 PARSE_TYPED(let_stmt
, let
,
1538 let
= psi_let_stmt_init(val
);
1543 * let_stmt: TEMP decl_var = reference decl_var ;
1545 PARSE_TYPED(let_stmt
, let
,
1547 TYPED(decl_var
, var
)
1550 TYPED(decl_var
, val_
)
1552 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1554 let
->exp
->is_reference
= r
? 1 : 0;
1558 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1560 PARSE_TYPED(let_callback
, cb
,
1562 NAMED(callback_rval
, F
)
1564 TYPED(impl_var
, var
)
1566 TYPED(callback_arg_list
, args_
)
1569 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1575 * let_calloc: CALLOC ( num_exp , num_exp )
1577 PARSE_TYPED(let_calloc
, alloc
,
1580 TYPED(num_exp
, nmemb
)
1582 TYPED(num_exp
, size
)
1584 alloc
= psi_let_calloc_init(nmemb
, size
);
1589 * let_func: let_func_token ( impl_var )
1591 PARSE_TYPED(let_func
, func
,
1592 NAMED(let_func_token
, T
)
1594 TYPED(impl_var
, var
)
1596 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1600 * let_func: let_func_token ( impl_var , let_exps )
1602 PARSE_TYPED(let_func
, func
,
1603 NAMED(let_func_token
, T
)
1605 TYPED(impl_var
, var
)
1607 TYPED(let_exps
, vals
)
1609 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1616 PARSE_TYPED(let_exps
, exps
,
1617 TYPED(let_exp
, exp
)) {
1618 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1622 * let_exps: let_exps , let_exp
1624 PARSE_TYPED(let_exps
, exps
,
1625 TYPED(let_exps
, exps_
)
1627 TYPED(let_exp
, exp
)) {
1628 exps
= psi_plist_add(exps_
, &exp
);
1632 * callback_arg_list: <empty>
1634 PASS(callback_arg_list
, )
1637 * callback_arg_list: callback_args
1639 PARSE_TYPED(callback_arg_list
, args
,
1640 TYPED(callback_args
, args_
)) {
1645 * callback_args: set_exp
1647 PARSE_TYPED(callback_args
, args
,
1648 TYPED(set_exp
, val
)) {
1649 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1654 * callback_args: callback_args , set_exp
1656 PARSE_TYPED(callback_args
, args
,
1657 TYPED(callback_args
, args_
)
1659 TYPED(set_exp
, val
)) {
1660 args
= psi_plist_add(args_
, &val
);
1664 * callback_rval: let_func_token
1666 PARSE_NAMED(callback_rval
, rval
,
1667 NAMED(let_func_token
, F
)) {
1672 * callback_rval: VOID
1674 PARSE_NAMED(callback_rval
, rval
,
1681 * set_func: set_func_token ( decl_var )
1683 PARSE_TYPED(set_func
, func
,
1684 NAMED(set_func_token
, T
)
1686 TYPED(decl_var
, var
)
1688 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1693 * set_func: set_func_token ( decl_var , set_exps )
1695 PARSE_TYPED(set_func
, func
,
1696 NAMED(set_func_token
, T
)
1698 TYPED(decl_var
, var
)
1700 TYPED(set_exps
, vals
)
1702 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1708 * set_func: set_func_token ( decl_var , ... )
1710 PARSE_TYPED(set_func
, func
,
1711 NAMED(set_func_token
, T
)
1713 TYPED(decl_var
, var
)
1717 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1719 func
->recursive
= 1;
1725 PARSE_TYPED(set_exp
, val
,
1726 TYPED(set_func
, fn
)) {
1727 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
1733 PARSE_TYPED(set_exp
, val
,
1734 TYPED(num_exp
, num
)) {
1735 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
1741 PARSE_TYPED(set_exps
, exps
,
1742 TYPED(set_exp
, exp
)) {
1743 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1748 * set_exps: set_exps , set_exp
1750 PARSE_TYPED(set_exps
, exps
,
1751 TYPED(set_exps
, exps_
)
1753 TYPED(set_exp
, exp
)) {
1754 exps
= psi_plist_add(exps_
, &exp
);
1758 * set_exp: impl_var = set_exp
1760 PARSE_TYPED(set_exp
, exp
,
1761 TYPED(impl_var
, var_
)
1763 TYPED(set_exp
, val
)) {
1769 * set_stmt: SET set_exp ;
1771 PARSE_TYPED(set_stmt
, set
,
1775 set
= psi_set_stmt_init(exp
);
1780 * return_stmt: RETURN set_exp ;
1782 PARSE_TYPED(return_stmt
, ret
,
1784 TYPED(set_func
, func
)
1786 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
1791 * free_stmt: FREE free_exps ;
1793 PARSE_TYPED(free_stmt
, free
,
1795 TYPED(free_exps
, calls
)
1797 free
= psi_free_stmt_init(calls
);
1802 * free_exps: free_exp
1804 PARSE_TYPED(free_exps
, calls
,
1805 TYPED(free_exp
, call
)) {
1806 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
1811 * free_exps: free_exps , free_exp
1813 PARSE_TYPED(free_exps
, calls
,
1814 TYPED(free_exps
, calls_
)
1816 TYPED(free_exp
, call
)) {
1817 calls
= psi_plist_add(calls_
, &call
);
1821 * free_exp: NAME ( decl_vars )
1823 PARSE_TYPED(free_exp
, call
,
1826 TYPED(decl_vars
, vars
)
1828 call
= psi_free_exp_init(F
->text
, vars
);
1833 * reference: <empty>
1835 PARSE_TYPED(reference
, r
, ) {
1842 PARSE_TYPED(reference
, r
,
1848 * indirection: <empty>
1850 PARSE_TYPED(indirection
, i
, ){
1855 * indirection: pointers
1857 PARSE_TYPED(indirection
, i
,
1858 TYPED(pointers
, p
)) {
1865 PARSE_TYPED(pointers
, p
,
1871 * pointers: pointers *
1873 PARSE_TYPED(pointers
, p
,