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(%token_prefix
, PSI_T_
)
66 DEF(%token_type
, {struct psi_token
*})
67 DEF(%token_destructor
, {free($$
);})
68 DEF(%default_destructor
, {(void)P
;})
69 DEF(%extra_argument
, {struct psi_parser
*P
})
71 /* TOKEN is defined inside syntax_error */
74 if (TOKEN
&& TOKEN
->type
!= PSI_T_EOF
) {
75 psi_error(PSI_WARNING
, TOKEN
->file
, TOKEN
->line
, "PSI syntax error: Unexpected token '%s' at pos %u", TOKEN
->text
, TOKEN
->col
);
77 psi_error(PSI_WARNING
, P
->file
.fn
, P
->line
, "PSI syntax error: Unexpected end of input");
81 DEF(%token_class
, const_type_token BOOL INT FLOAT STRING
.)
82 DEF(%token_class
, decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME
.)
83 DEF(%token_class
, impl_def_val_token NULL NUMBER TRUE FALSE QUOTED_STRING
.)
84 DEF(%token_class
, number_token NUMBER NSNAME
.)
85 DEF(%token_class
, num_exp_binary_op_token PIPE CARET AMPERSAND LSHIFT RSHIFT PLUS MINUS ASTERISK SLASH MODULO
.)
86 DEF(%token_class
, num_exp_unary_op_token TILDE NOT PLUS MINUS
.)
87 DEF(%token_class
, let_func_token ZVAL OBJVAL ARRVAL PATHVAL STRLEN STRVAL FLOATVAL INTVAL BOOLVAL COUNT
.)
88 DEF(%token_class
, set_func_token TO_OBJECT TO_ARRAY TO_STRING TO_INT TO_FLOAT TO_BOOL ZVAL VOID
.)
89 DEF(%token_class
, impl_type_token VOID MIXED BOOL INT FLOAT STRING ARRAY OBJECT CALLABLE
.)
92 DEF(%right
, NOT TILDE
.)
95 DEF(%left
, AMPERSAND
.)
96 DEF(%left
, LSHIFT RSHIFT
.)
97 DEF(%left
, PLUS MINUS
.)
98 DEF(%left
, ASTERISK SLASH MODULO
.)
100 DEF(%left, ASTERISK SLASH MODULO.)
101 DEF(%left, PLUS MINUS.)
102 DEF(%left, LSHIFT RSHIFT.)
103 DEF(%left, AMPERSAND.)
107 DEF(%fallback
, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT
.)
109 TOKEN_TYPE(decl_enum
, struct psi_decl_enum
*)
110 TOKEN_DTOR(decl_enum
, psi_decl_enum_free(&$$
);)
111 TOKEN_TYPE(decl_enum_items
, struct psi_plist
*)
112 TOKEN_DTOR(decl_enum_items
, psi_plist_free($$
);)
113 TOKEN_TYPE(decl_enum_item
, struct psi_decl_enum_item
*)
114 TOKEN_DTOR(decl_enum_item
, psi_decl_enum_item_free(&$$
);)
115 TOKEN_TYPE(decl_struct_args_block
, struct psi_plist
*)
116 TOKEN_DTOR(decl_struct_args_block
, psi_plist_free($$
);) /* there was a typo */
117 TOKEN_TYPE(decl_struct_args
, struct psi_plist
*)
118 TOKEN_DTOR(decl_struct_args
, psi_plist_free($$
);)
119 TOKEN_TYPE(decl_struct
, struct psi_decl_struct
*)
120 TOKEN_DTOR(decl_struct
, psi_decl_struct_free(&$$
);)
121 TOKEN_TYPE(align_and_size
, struct psi_layout
)
122 TOKEN_TYPE(decl_union
, struct psi_decl_union
*)
123 TOKEN_DTOR(decl_union
, psi_decl_union_free(&$$
);)
124 TOKEN_TYPE(const_type
, struct psi_const_type
*)
125 TOKEN_DTOR(const_type
, psi_const_type_free(&$$
);)
126 TOKEN_TYPE(constant
, struct psi_const
*)
127 TOKEN_DTOR(constant
, psi_const_free(&$$
);)
128 TOKEN_TYPE(decl_typedef
, struct psi_decl_arg
*)
129 TOKEN_DTOR(decl_typedef
, psi_decl_arg_free(&$$
);)
130 TOKEN_TYPE(decl_typedef_body_ex
, struct psi_decl_arg
*)
131 TOKEN_DTOR(decl_typedef_body_ex
, psi_decl_arg_free(&$$
);)
132 TOKEN_TYPE(decl_typedef_body
, struct psi_decl_arg
*)
133 TOKEN_DTOR(decl_typedef_body
, psi_decl_arg_free(&$$
);)
134 TOKEN_TYPE(decl_typedef_body_fn_args
, struct psi_plist
*)
135 TOKEN_DTOR(decl_typedef_body_fn_args
, psi_plist_free($$
);)
136 TOKEN_TYPE(decl
, struct psi_decl
*)
137 TOKEN_DTOR(decl
, psi_decl_free(&$$
);)
138 TOKEN_TYPE(decl_func
, struct psi_decl_arg
*)
139 TOKEN_DTOR(decl_func
, psi_decl_arg_free(&$$
);)
140 TOKEN_TYPE(decl_abi
, struct psi_decl_abi
*)
141 TOKEN_DTOR(decl_abi
, psi_decl_abi_free(&$$
);)
142 TOKEN_TYPE(decl_var
, struct psi_decl_var
*)
143 TOKEN_DTOR(decl_var
, psi_decl_var_free(&$$
);)
144 TOKEN_TYPE(decl_vars
, struct psi_plist
*)
145 TOKEN_DTOR(decl_vars
, psi_plist_free($$
);)
146 TOKEN_TYPE(decl_arg
, struct psi_decl_arg
*)
147 TOKEN_DTOR(decl_arg
, psi_decl_arg_free(&$$
);)
148 TOKEN_TYPE(decl_args
, struct psi_plist
*)
149 TOKEN_DTOR(decl_args
, psi_plist_free($$
);)
150 TOKEN_TYPE(struct_args
, struct psi_plist
*)
151 TOKEN_DTOR(struct_args
, psi_plist_free($$
);)
152 TOKEN_TYPE(struct_arg
, struct psi_decl_arg
*)
153 TOKEN_DTOR(struct_arg
, psi_decl_arg_free(&$$
);)
154 TOKEN_TYPE(decl_layout
, struct psi_layout
*)
155 TOKEN_DTOR(decl_layout
, psi_layout_free(&$$
);)
156 TOKEN_TYPE(decl_type
, struct psi_decl_type
*)
157 TOKEN_DTOR(decl_type
, psi_decl_type_free(&$$
);)
158 TOKEN_TYPE(const_decl_type
, struct psi_decl_type
*)
159 TOKEN_DTOR(const_decl_type
, psi_decl_type_free(&$$
);)
160 TOKEN_TYPE(impl
, struct psi_impl
*)
161 TOKEN_DTOR(impl
, psi_impl_free(&$$
);)
162 TOKEN_TYPE(impl_func
, struct psi_impl_func
*)
163 TOKEN_DTOR(impl_func
, psi_impl_func_free(&$$
);)
164 TOKEN_TYPE(impl_def_val
, struct psi_impl_def_val
*)
165 TOKEN_DTOR(impl_def_val
, psi_impl_def_val_free(&$$
);)
166 TOKEN_TYPE(impl_var
, struct psi_impl_var
*)
167 TOKEN_DTOR(impl_var
, psi_impl_var_free(&$$
);)
168 TOKEN_TYPE(impl_arg
, struct psi_impl_arg
*)
169 TOKEN_DTOR(impl_arg
, psi_impl_arg_free(&$$
);)
170 TOKEN_TYPE(impl_args
, struct psi_plist
*)
171 TOKEN_DTOR(impl_args
, psi_plist_free($$
);)
172 TOKEN_TYPE(impl_vararg
, struct psi_impl_arg
*)
173 TOKEN_DTOR(impl_vararg
, psi_impl_arg_free(&$$
);)
174 TOKEN_TYPE(impl_stmts
, struct psi_plist
*)
175 TOKEN_DTOR(impl_stmts
, psi_plist_free($$
);)
176 TOKEN_TYPE(impl_stmt
, struct psi_token
**)
177 TOKEN_DTOR(impl_stmt
, psi_impl_stmt_free(&$$
);)
178 TOKEN_TYPE(number
, struct psi_number
*)
179 TOKEN_DTOR(number
, psi_number_free(&$$
);)
180 TOKEN_TYPE(num_exp
, struct psi_num_exp
*)
181 TOKEN_DTOR(num_exp
, psi_num_exp_free(&$$
);)
182 TOKEN_TYPE(let_stmt
, struct psi_let_stmt
*)
183 TOKEN_DTOR(let_stmt
, psi_let_stmt_free(&$$
);)
184 TOKEN_TYPE(let_calloc
, struct psi_let_calloc
*)
185 TOKEN_DTOR(let_calloc
, psi_let_calloc_free(&$$
);)
186 TOKEN_TYPE(let_func
, struct psi_let_func
*)
187 TOKEN_DTOR(let_func
, psi_let_func_free(&$$
);)
188 TOKEN_TYPE(callback_arg_list
, struct psi_plist
*)
189 TOKEN_DTOR(callback_arg_list
, psi_plist_free($$
);)
190 TOKEN_TYPE(callback_args
, struct psi_plist
*)
191 TOKEN_DTOR(callback_args
, psi_plist_free($$
);)
192 TOKEN_TYPE(let_callback
, struct psi_let_callback
*)
193 TOKEN_DTOR(let_callback
, psi_let_callback_free(&$$
);)
194 TOKEN_TYPE(let_exp
, struct psi_let_exp
*)
195 TOKEN_DTOR(let_exp
, psi_let_exp_free(&$$
);)
196 TOKEN_TYPE(let_exps
, struct psi_plist
*)
197 TOKEN_DTOR(let_exps
, psi_plist_free($$
);)
198 TOKEN_TYPE(set_stmt
, struct psi_set_stmt
*)
199 TOKEN_DTOR(set_stmt
, psi_set_stmt_free(&$$
);)
200 TOKEN_TYPE(set_exp
, struct psi_set_exp
*)
201 TOKEN_DTOR(set_exp
, psi_set_exp_free(&$$
);)
202 TOKEN_TYPE(set_exps
, struct psi_plist
*)
203 TOKEN_DTOR(set_exps
, psi_plist_free($$
);)
204 TOKEN_TYPE(set_func
, struct psi_set_func
*)
205 TOKEN_DTOR(set_func
, psi_set_func_free(&$$
);)
206 TOKEN_TYPE(return_stmt
, struct psi_return_stmt
*)
207 TOKEN_DTOR(return_stmt
, psi_return_stmt_free(&$$
);)
208 TOKEN_TYPE(free_stmt
, struct psi_free_stmt
*)
209 TOKEN_DTOR(free_stmt
, psi_free_stmt_free(&$$
);)
210 TOKEN_TYPE(free_exps
, struct psi_plist
*)
211 TOKEN_DTOR(free_exps
, psi_plist_free($$
);)
212 TOKEN_TYPE(free_exp
, struct psi_free_exp
*)
213 TOKEN_DTOR(free_exp
, psi_free_exp_free(&$$
);)
214 TOKEN_TYPE(impl_type
, struct psi_impl_type
*)
215 TOKEN_DTOR(impl_type
, psi_impl_type_free(&$$
);)
216 TOKEN_TYPE(reference
, bool)
217 TOKEN_TYPE(indirection
, unsigned)
218 TOKEN_TYPE(pointers
, unsigned)
222 PASS(blocks
, blocks block
)
228 * lib: LIB "soname" ;
230 PARSE(block
, NAMED(LIB
, token
) NAMED(QUOTED_STRING
, libname
) TOKEN(EOS
)) {
232 P
->error(PSI_DATA(P
), token
, PSI_WARNING
, "Extra 'lib %s' statement has no effect", libname
->text
);
234 P
->file
.ln
= strndup(libname
->text
+ 1, libname
->size
- 2);
240 PARSE(block
, TYPED(decl
, decl
)) {
242 P
->decls
= psi_plist_init((psi_plist_dtor
) psi_decl_free
);
244 P
->decls
= psi_plist_add(P
->decls
, &decl
);
247 PARSE(block
, TYPED(impl
, impl
)) {
249 P
->impls
= psi_plist_init((psi_plist_dtor
) psi_impl_free
);
251 P
->impls
= psi_plist_add(P
->impls
, &impl
);
254 PARSE(block
, TYPED(decl_typedef
, def
)) {
256 P
->types
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
258 P
->types
= psi_plist_add(P
->types
, &def
);
260 switch (def
->type
->type
) {
262 if (def
->type
->real
.strct
) {
264 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
266 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
270 if (def
->type
->real
.unn
) {
272 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
274 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
278 if (def
->type
->real
.enm
) {
280 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
282 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
288 PARSE(block
, TYPED(constant
, constant
)) {
290 P
->consts
= psi_plist_init((psi_plist_dtor
) psi_const_free
);
292 P
->consts
= psi_plist_add(P
->consts
, &constant
);
295 PARSE(block
, TYPED(decl_struct
, strct
)) {
297 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
299 P
->structs
= psi_plist_add(P
->structs
, &strct
);
302 PARSE(block
, TYPED(decl_union
, u
)) {
304 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
306 P
->unions
= psi_plist_add(P
->unions
, &u
);
309 PARSE(block
, TYPED(decl_enum
, e
)) {
311 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
313 P
->enums
= psi_plist_add(P
->enums
, &e
);
317 * optional_name: <empty>
319 PARSE_NAMED(optional_name
, n
, ) {
324 * optional_name: NAME
326 PARSE_NAMED(optional_name
, n
,
332 * align_and_size: <empty>
334 PARSE_TYPED(align_and_size
, as
, ) {
340 * align_and_size: :: ( NUMBER , NUMBER )
342 PARSE_TYPED(align_and_size
, as
,
350 as
.pos
= atol(A
->text
);
351 as
.len
= atol(S
->text
);
357 * enum_name: ENUM optional_name
359 PARSE_NAMED(enum_name
, n
,
361 NAMED(optional_name
, N
)) {
368 psi_token_hash(E
, digest
);
369 n
= psi_token_translit(psi_token_append(E
, 1, digest
), " ", "@");
374 * struct_name: STRUCT optional_name
376 PARSE_NAMED(struct_name
, n
,
378 NAMED(optional_name
, N
)) {
385 psi_token_hash(S
, digest
);
386 n
= psi_token_translit(psi_token_append(S
, 1, digest
), " ", "@");
391 * union_name: UNION optional_name
393 PARSE_NAMED(union_name
, n
,
395 NAMED(optional_name
, N
)) {
402 psi_token_hash(U
, digest
);
403 n
= psi_token_translit(psi_token_append(U
, 1, digest
), " ", "@");
408 * decl_enum: enum_name { items }
410 PARSE_TYPED(decl_enum
, e
,
413 TYPED(decl_enum_items
, list
)
415 e
= psi_decl_enum_init(N
->text
, list
);
420 * decl_enum_items: item
422 PARSE_TYPED(decl_enum_items
, l
,
423 TYPED(decl_enum_item
, i
)) {
424 l
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_enum_item_free
),
429 * decl_enum_items: items , item
431 PARSE_TYPED(decl_enum_items
, l
,
432 TYPED(decl_enum_items
, l_
)
434 TYPED(decl_enum_item
, i
)) {
435 l
= psi_plist_add(l_
, &i
);
439 * decl_enum_item: name = num_exp
441 PARSE_TYPED(decl_enum_item
, i
,
444 TYPED(num_exp
, num
)) {
445 i
= psi_decl_enum_item_init(N
->text
, num
);
450 * decl_enum_item: name
452 PARSE_TYPED(decl_enum_item
, i
,
454 i
= psi_decl_enum_item_init(N
->text
, NULL
);
460 * decl_struct_args_block: { args }
462 PARSE_TYPED(decl_struct_args_block
, args_
,
464 TYPED(struct_args
, args
)
470 * decl_struct_args: args_block
472 PARSE_TYPED(decl_struct_args
, args_
,
473 TYPED(decl_struct_args_block
, args
)) {
478 * decl_struct_args: ;
480 PARSE_TYPED(decl_struct_args
, args_
,
482 args_
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
486 * decl_struct: STRUCT name align_and_size struct_args
488 PARSE_TYPED(decl_struct
, strct
,
491 TYPED(align_and_size
, as
)
492 TYPED(decl_struct_args
, args
)) {
493 strct
= psi_decl_struct_init(N
->text
, args
);
494 strct
->align
= as
.pos
;
495 strct
->size
= as
.len
;
500 * decl_union: UNION name align_and_size struct_args
502 PARSE_TYPED(decl_union
, u
,
505 TYPED(align_and_size
, as
)
506 TYPED(decl_struct_args
, args
)) {
507 u
= psi_decl_union_init(N
->text
, args
);
514 * const_type: const_type_token
516 PARSE_TYPED(const_type
, type_
,
517 NAMED(const_type_token
, T
)) {
518 type_
= psi_const_type_init(T
->type
, T
->text
);
523 * constant: CONST const_type NSNAME = def_val ;
525 PARSE_TYPED(constant
, constant
,
527 TYPED(const_type
, type
)
530 TYPED(impl_def_val
, val
)
532 constant
= psi_const_init(type
, T
->text
, val
);
537 * decl_typdef: TYPEDEF typedef_body ;
539 PARSE_TYPED(decl_typedef
, def
,
541 TYPED(decl_typedef_body
, def_
)
548 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
550 PARSE_TYPED(decl_typedef_body_ex
, def
,
551 NAMED(struct_name
, N
)
552 TYPED(align_and_size
, as
)
553 TYPED(decl_struct_args_block
, args
)
554 TYPED(decl_var
, var
)) {
555 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT
, N
->text
), var
);
556 def
->type
->token
= psi_token_copy(N
);
557 def
->type
->real
.strct
= psi_decl_struct_init(N
->text
, args
);
558 def
->type
->real
.strct
->token
= N
;
559 def
->type
->real
.strct
->align
= as
.pos
;
560 def
->type
->real
.strct
->size
= as
.len
;
564 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
566 PARSE_TYPED(decl_typedef_body_ex
, def
,
568 TYPED(align_and_size
, as
)
569 TYPED(decl_struct_args_block
, args
)
570 TYPED(decl_var
, var
)) {
571 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION
, N
->text
), var
);
572 def
->type
->token
= psi_token_copy(N
);
573 def
->type
->real
.unn
= psi_decl_union_init(N
->text
, args
);
574 def
->type
->real
.unn
->token
= N
;
575 def
->type
->real
.unn
->align
= as
.pos
;
576 def
->type
->real
.unn
->size
= as
.len
;
580 * decl_typedef_body_ex: decl_enum NAME
582 PARSE_TYPED(decl_typedef_body_ex
, def
,
584 NAMED(NAME
, ALIAS
)) {
585 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM
, e
->name
), psi_decl_var_init(ALIAS
->text
, 0, 0));
586 def
->var
->token
= ALIAS
;
587 def
->type
->token
= psi_token_copy(e
->token
);
588 def
->type
->real
.enm
= e
;
592 * decl_typedef_body: decl_typedef_body_ex
594 PARSE_TYPED(decl_typedef_body
, def
,
595 TYPED(decl_typedef_body_ex
, def_
)) {
600 * decl_typedef_body_fn_args: ( decl_args )
602 PARSE_TYPED(decl_typedef_body_fn_args
, args
,
604 TYPED(decl_args
, args_
)
610 * decl_typedef_body: decl_func decl_typedef_body_fn_args
612 PARSE_TYPED(decl_typedef_body
, def
,
613 TYPED(decl_func
, func_
)
614 TYPED(decl_typedef_body_fn_args
, args
)) {
615 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
), psi_decl_var_copy(func_
->var
));
616 def
->type
->token
= psi_token_copy(func_
->token
);
617 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
621 * decl_typedef_body: decl_arg
623 PARSE_TYPED(decl_typedef_body
, def
,
624 TYPED(decl_arg
, arg
)) {
629 * decl: decl_abi decl_func ( decl_args ) ;
631 PARSE_TYPED(decl
, decl
,
633 TYPED(decl_func
, func
)
635 TYPED(decl_args
, args
)
638 decl
= psi_decl_init(abi
, func
, args
);
642 * decl: decl_abi decl_func ( decl_args , ... ) ;
644 PARSE_TYPED(decl
, decl
,
646 TYPED(decl_func
, func
)
648 TYPED(decl_args
, args
)
653 decl
= psi_decl_init(abi
, func
, args
);
658 * decl_func: decl_arg
660 PARSE_TYPED(decl_func
, func
,
661 TYPED(decl_arg
, arg
)) {
665 /* special case for void functions */
667 * decl_func: VOID NAME
669 PARSE_TYPED(decl_func
, func
,
672 func
= psi_decl_arg_init(
673 psi_decl_type_init(T
->type
, T
->text
),
674 psi_decl_var_init(N
->text
, 0, 0)
676 func
->type
->token
= T
;
677 func
->var
->token
= N
;
682 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
684 PARSE_TYPED(decl_typedef_body
, def
,
686 TYPED(indirection
, decl_i
)
688 TYPED(indirection
, type_i
)
691 TYPED(decl_typedef_body_fn_args
, args
)) {
692 struct psi_decl_arg
*func_
= psi_decl_arg_init(
693 psi_decl_type_init(T
->type
, T
->text
),
694 psi_decl_var_init(N
->text
, decl_i
, 0)
696 func_
->type
->token
= T
;
697 func_
->var
->token
= N
;
700 def
= psi_decl_arg_init(
701 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
702 psi_decl_var_copy(func_
->var
)
704 def
->var
->pointer_level
= type_i
;
705 def
->type
->token
= psi_token_copy(func_
->token
);
706 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
710 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
712 PARSE_TYPED(decl_typedef_body
, def
,
715 TYPED(pointers
, decl_i
)
717 TYPED(indirection
, type_i
)
720 TYPED(decl_typedef_body_fn_args
, args
)) {
721 struct psi_decl_arg
*func_
= psi_decl_arg_init(
722 psi_decl_type_init(T
->type
, T
->text
),
723 psi_decl_var_init(N
->text
, decl_i
, 0)
725 func_
->type
->token
= T
;
726 func_
->var
->token
= N
;
729 def
= psi_decl_arg_init(
730 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
731 psi_decl_var_copy(func_
->var
)
733 def
->var
->pointer_level
= type_i
;
734 def
->type
->token
= psi_token_copy(func_
->token
);
735 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
741 PARSE_TYPED(decl_abi
, abi
,
743 abi
= psi_decl_abi_init(T
->text
);
748 * decl_var_array_size: <empty>
750 PARSE_NAMED(decl_var_array_size
, as
, ) {
755 * decl_var_array_size: [ NUMBER ]
757 PARSE_NAMED(decl_var_array_size
, as
,
765 * decl_var: NAME decl_var_array_size
767 PARSE_TYPED(decl_var
, var
,
769 NAMED(decl_var_array_size
, as
)) {
770 var
= psi_decl_var_init(T
->text
, 0, as
?atol(as
->text
):0);
778 * decl_var: pointers NAME
780 PARSE_TYPED(decl_var
, var
,
783 NAMED(decl_var_array_size
, as
)) {
784 var
= psi_decl_var_init(T
->text
, p
+!!as
, as
?atol(as
->text
):0);
792 * decl_vars: decl_var
794 PARSE_TYPED(decl_vars
, vars
,
795 TYPED(decl_var
, var
)) {
796 vars
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_var_free
),
801 * decl_vars: decl_vars , decl_var
803 PARSE_TYPED(decl_vars
, vars
,
804 TYPED(decl_vars
, vars_
)
806 TYPED(decl_var
, var
)) {
807 vars
= psi_plist_add(vars_
, &var
);
811 * decl_arg: const_decl_type decl_var
813 PARSE_TYPED(decl_arg
, arg_
,
814 TYPED(const_decl_type
, type
)
815 TYPED(decl_var
, var
)) {
816 arg_
= psi_decl_arg_init(type
, var
);
820 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
822 PARSE_TYPED(decl_typedef_body
, def
,
823 TYPED(const_decl_type
, type_
)
824 TYPED(indirection
, decl_i
)
826 TYPED(indirection
, type_i
)
829 TYPED(decl_typedef_body_fn_args
, args
)) {
830 struct psi_decl_arg
*func_
= psi_decl_arg_init(
832 psi_decl_var_init(N
->text
, decl_i
, 0)
834 func_
->var
->token
= N
;
837 def
= psi_decl_arg_init(
838 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
839 psi_decl_var_copy(func_
->var
)
841 def
->var
->pointer_level
= type_i
;
842 def
->type
->token
= psi_token_copy(func_
->token
);
843 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
846 /* void pointers need a specific rule */
848 * decl_arg: VOID pointers NAME
850 PARSE_TYPED(decl_arg
, arg_
,
854 arg_
= psi_decl_arg_init(
855 psi_decl_type_init(T
->type
, T
->text
),
856 psi_decl_var_init(N
->text
, p
, 0)
858 arg_
->type
->token
= T
;
859 arg_
->var
->token
= N
;
864 * decl_args: CONST VOID pointers NAME
866 PARSE_TYPED(decl_arg
, arg_
,
871 arg_
= psi_decl_arg_init(
872 psi_decl_type_init(T
->type
, T
->text
),
873 psi_decl_var_init(N
->text
, p
, 0)
875 arg_
->type
->token
= T
;
876 arg_
->var
->token
= N
;
888 PASS(decl_args
, VOID
)
891 * decl_args: decl_arg
893 PARSE_TYPED(decl_args
, args
,
894 TYPED(decl_arg
, arg
)) {
895 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
900 * decl_args: decl_args , decl_arg
902 PARSE_TYPED(decl_args
, args
,
903 TYPED(decl_args
, args_
)
905 TYPED(decl_arg
, arg
)) {
906 args
= psi_plist_add(args_
, &arg
);
910 * struct_args: struct_arg
912 PARSE_TYPED(struct_args
, args
,
913 TYPED(struct_arg
, arg
)) {
914 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
919 * struct_args: struct_args , struct_arg
921 PARSE_TYPED(struct_args
, args
,
922 TYPED(struct_args
, args_
)
923 TYPED(struct_arg
, arg
)) {
924 args
= psi_plist_add(args_
, &arg
);
928 * struct_arg: decl_typedef_body_ex ;
930 PARSE_TYPED(struct_arg
, arg_
,
931 TYPED(decl_typedef_body_ex
, def
)
934 switch (def
->type
->type
) {
936 if (def
->type
->real
.strct
) {
938 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
940 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
944 if (def
->type
->real
.unn
) {
946 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
948 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
952 if (def
->type
->real
.enm
) {
954 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
956 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
963 * struct_arg: decl_arg decl_layout ;
965 PARSE_TYPED(struct_arg
, arg
,
966 TYPED(decl_arg
, arg_
)
967 TYPED(decl_layout
, layout_
)
969 arg_
->layout
= layout_
;
974 * decl_layout: <empty>
976 PARSE_TYPED(decl_layout
, layout
, ) {
981 * decl_layout: :: ( NUMBER , NUMBER )
983 PARSE_TYPED(decl_layout
, layout
,
991 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
996 /* un/signed, urgh */
998 * decl_scalar_type: CHAR
1000 PARSE_NAMED(decl_scalar_type
, type_
,
1006 * decl_scalar_type: SHORT decl_scalar_type_short
1008 PARSE_NAMED(decl_scalar_type
, type_
,
1010 NAMED(decl_scalar_type_short
, s
)) {
1012 type_
= psi_token_cat(2, S
, s
);
1021 * decl_scalar_type_short: <empty>
1023 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1028 * decl_scalar_type_short: INT
1030 PARSE_NAMED(decl_scalar_type_short
, s
,
1036 * decl_sclara_type: INT
1038 PARSE_NAMED(decl_scalar_type
, type_
,
1044 * decl_scalar_type: LONG decl_scalar_type_long
1046 PARSE_NAMED(decl_scalar_type
, type_
,
1048 NAMED(decl_scalar_type_long
, l
)) {
1050 type_
= psi_token_cat(2, L
, l
);
1059 * decl_scalar_type_long: <empty>
1061 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1066 * decl_scalar_type_long: DOUBLE
1068 PARSE_NAMED(decl_scalar_type_long
, l
,
1074 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1076 PARSE_NAMED(decl_scalar_type_long
, l
,
1078 NAMED(decl_scalar_type_long_long
, ll
)) {
1080 l
= psi_token_cat(2, L
, ll
);
1089 * decl_scalar_type_long_long: <empty>
1091 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1096 * decl_scalar_type_long_long: INT
1098 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1104 * decl_type: UNSIGNED decl_scalar_type
1106 PARSE_TYPED(decl_type
, type_
,
1108 NAMED(decl_scalar_type
, N
)) {
1109 struct psi_token
*T
= psi_token_cat(2, U
, N
);
1110 type_
= psi_decl_type_init(T
->type
, T
->text
);
1117 * decl_type: SIGNED decl_scalar_type
1119 PARSE_TYPED(decl_type
, type_
,
1121 NAMED(decl_scalar_type
, N
)) {
1122 struct psi_token
*T
= psi_token_cat(2, S
, N
);
1123 type_
= psi_decl_type_init(T
->type
, T
->text
);
1130 * decl_type: UNSIGNED
1132 PARSE_TYPED(decl_type
, type_
,
1133 NAMED(UNSIGNED
, U
)) {
1134 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1141 PARSE_TYPED(decl_type
, type_
,
1143 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1148 * decl_type: decl_scalar_type
1150 PARSE_TYPED(decl_type
, type_
,
1151 NAMED(decl_scalar_type
, N
)) {
1152 type_
= psi_decl_type_init(N
->type
, N
->text
);
1158 * decl_type: STRUCT NAME
1160 PARSE_TYPED(decl_type
, type_
,
1163 type_
= psi_decl_type_init(S
->type
, T
->text
);
1169 * decl_type: UNION NAME
1171 PARSE_TYPED(decl_type
, type_
,
1174 type_
= psi_decl_type_init(U
->type
, T
->text
);
1180 * decl_type: ENUM NAME
1182 PARSE_TYPED(decl_type
, type_
,
1185 type_
= psi_decl_type_init(E
->type
, T
->text
);
1191 * decl_type: decl_type_token
1193 PARSE_TYPED(decl_type
, type_
,
1194 NAMED(decl_type_token
, T
)) {
1195 type_
= psi_decl_type_init(T
->type
, T
->text
);
1200 * const_decl_type: decl_type
1202 PARSE_TYPED(const_decl_type
, type
,
1203 TYPED(decl_type
, type_
)) {
1208 * const_decl_type: CONST decl_type
1210 PARSE_TYPED(const_decl_type
, type
,
1212 TYPED(decl_type
, type_
)) {
1217 * impl: impl_func { impl_stmts }
1219 PARSE_TYPED(impl
, impl
,
1220 TYPED(impl_func
, func
)
1222 TYPED(impl_stmts
, stmts
)
1224 impl
= psi_impl_init(func
, stmts
);
1228 * impl: STATIC impl_func { impl_stmts }
1230 PARSE_TYPED(impl
, impl
,
1232 TYPED(impl_func
, func
)
1234 TYPED(impl_stmts
, stmts
)
1236 func
->static_memory
= 1;
1237 impl
= psi_impl_init(func
, stmts
);
1241 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1243 PARSE_TYPED(impl_func
, func
,
1250 TYPED(impl_type
, type
)) {
1251 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1253 func
->return_reference
= r
;
1257 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1259 PARSE_TYPED(impl_func
, func
,
1264 TYPED(impl_args
, args
)
1267 TYPED(impl_type
, type
)) {
1268 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1270 func
->return_reference
= r
;
1274 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1276 PARSE_TYPED(impl_func
, func
,
1278 TYPED(reference
, func_r
)
1281 TYPED(impl_args
, args
)
1283 TYPED(impl_type
, va_type
)
1284 TYPED(reference
, va_r
)
1286 NAMED(DOLLAR_NAME
, T
)
1289 TYPED(impl_type
, func_type
)) {
1290 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1292 func
->return_reference
= func_r
;
1293 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1298 * impl_def_val: impl_def_val_token
1300 PARSE_TYPED(impl_def_val
, def
,
1301 NAMED(impl_def_val_token
, T
)) {
1302 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1307 * impl_var: reference DOLLAR_NAME
1309 PARSE_TYPED(impl_var
, var
,
1311 NAMED(DOLLAR_NAME
, T
)) {
1312 var
= psi_impl_var_init(T
->text
, r
);
1317 * impl_type: impl_type_token
1319 PARSE_TYPED(impl_type
, type_
,
1320 NAMED(impl_type_token
, T
)) {
1321 type_
= psi_impl_type_init(T
->type
, T
->text
);
1326 * impl_arg: impl_type impl_var
1328 PARSE_TYPED(impl_arg
, arg
,
1329 TYPED(impl_type
, type
)
1330 TYPED(impl_var
, var
)) {
1331 arg
= psi_impl_arg_init(type
, var
, NULL
);
1335 * impl_arg: impl_type impl_var = impl_def_val
1337 PARSE_TYPED(impl_arg
, arg
,
1338 TYPED(impl_type
, type
)
1339 TYPED(impl_var
, var
)
1341 TYPED(impl_def_val
, def
)) {
1342 arg
= psi_impl_arg_init(type
, var
, def
);
1346 * impl_args: impl_arg
1348 PARSE_TYPED(impl_args
, args
,
1349 TYPED(impl_arg
, arg
)) {
1350 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1355 * impl_args: impl_args , impl_arg
1357 PARSE_TYPED(impl_args
, args
,
1358 TYPED(impl_args
, args_
)
1360 TYPED(impl_arg
, arg
)) {
1361 args
= psi_plist_add(args_
, &arg
);
1365 * impl_stmts: impl_stmt
1367 PARSE_TYPED(impl_stmts
, stmts
,
1368 TYPED(impl_stmt
, stmt
)) {
1369 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1374 * impl_stmts: impl_stmts , impl_stmt
1376 PARSE_TYPED(impl_stmts
, stmts
,
1377 TYPED(impl_stmts
, stmts_
)
1378 TYPED(impl_stmt
, stmt
)) {
1379 stmts
= psi_plist_add(stmts_
, &stmt
);
1383 * impl_stmt: return_stmt
1385 PARSE_TYPED(impl_stmt
, i
,
1386 TYPED(return_stmt
, r
)) {
1387 i
= (struct psi_token
**) r
;
1391 * impl_stmt: let_stmt
1393 PARSE_TYPED(impl_stmt
, i
,
1394 TYPED(let_stmt
, l
)) {
1395 i
= (struct psi_token
**) l
;
1399 * impl_stmt: set_stmt
1401 PARSE_TYPED(impl_stmt
, i
,
1402 TYPED(set_stmt
, s
)) {
1403 i
= (struct psi_token
**) s
;
1407 * impl_stmt: free_stmt
1409 PARSE_TYPED(impl_stmt
, i
,
1410 TYPED(free_stmt
, f
)) {
1411 i
= (struct psi_token
**) f
;
1415 * number: number_token
1417 PARSE_TYPED(number
, exp
,
1418 NAMED(number_token
, tok
)) {
1419 exp
= psi_number_init(tok
->type
, tok
->text
);
1426 PARSE_TYPED(number
, exp
,
1427 TYPED(decl_var
, var
)) {
1428 exp
= psi_number_init(PSI_T_NAME
, var
);
1429 exp
->token
= psi_token_copy(var
->token
);
1435 PARSE_TYPED(num_exp
, exp
,
1436 TYPED(number
, num
)) {
1437 exp
= psi_num_exp_init_num(num
);
1438 exp
->token
= psi_token_copy(num
->token
);
1442 * num_exp: ( num_exp )
1444 PARSE_TYPED(num_exp
, exp
,
1446 TYPED(num_exp
, exp_
)
1448 exp
= psi_num_exp_init_unary(PSI_T_LPAREN
, exp_
);
1453 * num_exp: num_exp num_exp_binary_op_token num_exp
1455 PARSE_TYPED(num_exp
, exp
,
1456 TYPED(num_exp
, lhs_
)
1457 NAMED(num_exp_binary_op_token
, OP
)
1458 TYPED(num_exp
, rhs_
)) {
1459 exp
= psi_num_exp_init_binary(OP
->type
, lhs_
, rhs_
);
1464 * num_exp: num_exp_unary_op_token num_exp
1466 PARSE_TYPED(num_exp
, exp
,
1467 NAMED(num_exp_unary_op_token
, OP
)
1468 TYPED(num_exp
, exp_
)) {
1469 exp
= psi_num_exp_init_unary(OP
->type
, exp_
);
1476 PARSE_TYPED(let_exp
, val
,
1478 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1484 PARSE_TYPED(let_exp
, val
,
1487 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1488 val
->is_reference
= 1;
1494 PARSE_TYPED(let_exp
, val
,
1495 TYPED(let_callback
, cb
)) {
1496 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1502 PARSE_TYPED(let_exp
, val
,
1503 TYPED(let_calloc
, ca
)) {
1504 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1510 PARSE_TYPED(let_exp
, val
,
1512 TYPED(let_calloc
, ca
)) {
1513 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1514 val
->is_reference
= 1;
1520 PARSE_TYPED(let_exp
, val
,
1521 TYPED(let_func
, fn
)) {
1522 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1528 PARSE_TYPED(let_exp
, val
,
1530 TYPED(let_func
, fn
)) {
1531 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1532 val
->is_reference
= 1;
1538 PARSE_TYPED(let_exp
, val
,
1539 TYPED(num_exp
, exp
)) {
1540 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1544 * let_exp: & num_exp
1546 PARSE_TYPED(let_exp
, val
,
1548 TYPED(num_exp
, exp
)) {
1549 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1550 val
->is_reference
= 1;
1554 * let_exp: decl_var = let_exp
1556 PARSE_TYPED(let_exp
, exp
,
1557 TYPED(decl_var
, var_
)
1559 TYPED(let_exp
, val
)) {
1565 * let_stmt: LET let_exp ;
1567 PARSE_TYPED(let_stmt
, let
,
1571 let
= psi_let_stmt_init(val
);
1576 * let_stmt: TEMP decl_var = reference decl_var ;
1578 PARSE_TYPED(let_stmt
, let
,
1580 TYPED(decl_var
, var
)
1583 TYPED(decl_var
, val_
)
1585 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1587 let
->exp
->is_reference
= r
? 1 : 0;
1591 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1593 PARSE_TYPED(let_callback
, cb
,
1595 NAMED(callback_rval
, F
)
1597 TYPED(impl_var
, var
)
1599 TYPED(callback_arg_list
, args_
)
1602 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1608 * let_calloc: CALLOC ( num_exp , num_exp )
1610 PARSE_TYPED(let_calloc
, alloc
,
1613 TYPED(num_exp
, nmemb
)
1615 TYPED(num_exp
, size
)
1617 alloc
= psi_let_calloc_init(nmemb
, size
);
1622 * let_func: let_func_token ( impl_var )
1624 PARSE_TYPED(let_func
, func
,
1625 NAMED(let_func_token
, T
)
1627 TYPED(impl_var
, var
)
1629 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1633 * let_func: let_func_token ( impl_var , let_exps )
1635 PARSE_TYPED(let_func
, func
,
1636 NAMED(let_func_token
, T
)
1638 TYPED(impl_var
, var
)
1640 TYPED(let_exps
, vals
)
1642 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1649 PARSE_TYPED(let_exps
, exps
,
1650 TYPED(let_exp
, exp
)) {
1651 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1655 * let_exps: let_exps , let_exp
1657 PARSE_TYPED(let_exps
, exps
,
1658 TYPED(let_exps
, exps_
)
1660 TYPED(let_exp
, exp
)) {
1661 exps
= psi_plist_add(exps_
, &exp
);
1665 * callback_arg_list: <empty>
1667 PASS(callback_arg_list
, )
1670 * callback_arg_list: callback_args
1672 PARSE_TYPED(callback_arg_list
, args
,
1673 TYPED(callback_args
, args_
)) {
1678 * callback_args: set_exp
1680 PARSE_TYPED(callback_args
, args
,
1681 TYPED(set_exp
, val
)) {
1682 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1687 * callback_args: callback_args , set_exp
1689 PARSE_TYPED(callback_args
, args
,
1690 TYPED(callback_args
, args_
)
1692 TYPED(set_exp
, val
)) {
1693 args
= psi_plist_add(args_
, &val
);
1697 * callback_rval: let_func_token
1699 PARSE_NAMED(callback_rval
, rval
,
1700 NAMED(let_func_token
, F
)) {
1705 * callback_rval: VOID
1707 PARSE_NAMED(callback_rval
, rval
,
1714 * set_func: set_func_token ( decl_var )
1716 PARSE_TYPED(set_func
, func
,
1717 NAMED(set_func_token
, T
)
1719 TYPED(decl_var
, var
)
1721 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1726 * set_func: set_func_token ( decl_var , set_exps )
1728 PARSE_TYPED(set_func
, func
,
1729 NAMED(set_func_token
, T
)
1731 TYPED(decl_var
, var
)
1733 TYPED(set_exps
, vals
)
1735 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1741 * set_func: set_func_token ( decl_var , ... )
1743 PARSE_TYPED(set_func
, func
,
1744 NAMED(set_func_token
, T
)
1746 TYPED(decl_var
, var
)
1750 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1752 func
->recursive
= 1;
1758 PARSE_TYPED(set_exp
, val
,
1759 TYPED(set_func
, fn
)) {
1760 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
1766 PARSE_TYPED(set_exp
, val
,
1767 TYPED(num_exp
, num
)) {
1768 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
1774 PARSE_TYPED(set_exps
, exps
,
1775 TYPED(set_exp
, exp
)) {
1776 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1781 * set_exps: set_exps , set_exp
1783 PARSE_TYPED(set_exps
, exps
,
1784 TYPED(set_exps
, exps_
)
1786 TYPED(set_exp
, exp
)) {
1787 exps
= psi_plist_add(exps_
, &exp
);
1791 * set_exp: impl_var = set_exp
1793 PARSE_TYPED(set_exp
, exp
,
1794 TYPED(impl_var
, var_
)
1796 TYPED(set_exp
, val
)) {
1802 * set_stmt: SET set_exp ;
1804 PARSE_TYPED(set_stmt
, set
,
1808 set
= psi_set_stmt_init(exp
);
1813 * return_stmt: RETURN set_exp ;
1815 PARSE_TYPED(return_stmt
, ret
,
1817 TYPED(set_func
, func
)
1819 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
1824 * free_stmt: FREE free_exps ;
1826 PARSE_TYPED(free_stmt
, free
,
1828 TYPED(free_exps
, calls
)
1830 free
= psi_free_stmt_init(calls
);
1835 * free_exps: free_exp
1837 PARSE_TYPED(free_exps
, calls
,
1838 TYPED(free_exp
, call
)) {
1839 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
1844 * free_exps: free_exps , free_exp
1846 PARSE_TYPED(free_exps
, calls
,
1847 TYPED(free_exps
, calls_
)
1849 TYPED(free_exp
, call
)) {
1850 calls
= psi_plist_add(calls_
, &call
);
1854 * free_exp: NAME ( decl_vars )
1856 PARSE_TYPED(free_exp
, call
,
1859 TYPED(decl_vars
, vars
)
1861 call
= psi_free_exp_init(F
->text
, vars
);
1866 * reference: <empty>
1868 PARSE_TYPED(reference
, r
, ) {
1875 PARSE_TYPED(reference
, r
,
1881 * indirection: <empty>
1883 PARSE_TYPED(indirection
, i
, ){
1888 * indirection: pointers
1890 PARSE_TYPED(indirection
, i
,
1891 TYPED(pointers
, p
)) {
1898 PARSE_TYPED(pointers
, p
,
1904 * pointers: pointers *
1906 PARSE_TYPED(pointers
, p
,