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__)
30 #define TOKEN_PREFIX PSI_T
31 #define TOKEN_STRUCT struct psi_token *
34 # define DEF(dn, dv) dn dv
35 # define PASS(nt, rule) nt ::= rule.
36 # define PARSE(nt, rule) nt ::= rule.
37 # define PARSE_NAMED(nt, nt_name, rule) NAMED(nt, nt_name) ::= rule.
38 # define PARSE_TYPED(nt, nt_name, rule) TYPED(nt, nt_name) ::= rule.
40 # define NAMED(t, name) t(name)
41 # define TYPED(t, name) t(name)
42 # define TOKEN_TYPE(token, type_) %type token {type_}
43 # define TOKEN_DTOR(token, dtor) %destructor token {dtor}
44 # define T(token) token
45 # define TOKEN_CLASS(type, tokens) DEF(%token_class, type##_token tokens .)
52 # define PASS(nt, rule) \
53 static void COUNTED(nt) (struct psi_parser *P) { \
56 # define PARSE(nt, rule) \
57 static void COUNTED(nt) (struct psi_parser *P rule)
58 # define PARSE_NAMED(nt, nt_name, rule) \
59 static void COUNTED(nt) (struct psi_parser *P NAMED(nt, nt_name) rule)
60 # define PARSE_TYPED(nt, nt_name, rule) \
61 static void COUNTED(nt) (struct psi_parser *P TYPED(nt, nt_name) rule)
63 # define NAMED(t, name) , struct psi_token *name
64 # define TYPED(t, name) , TOKEN_TYPE_NAME(t) name
65 # define TOKEN_TYPE_NAME(token) token##_parse_t
66 # define TOKEN_TYPE(token, type) typedef type TOKEN_TYPE_NAME(token);
67 # define TOKEN_DTOR(token, dtor)
68 # define T(token) CONCAT1(TOKEN_PREFIX, _ ##token ),
69 # define TOKEN_CLASS(type, tokens) static token_t type##_token[] = { tokens 0 };
72 DEF(%token_prefix
, CONCAT1(TOKEN_PREFIX
,_
))
73 DEF(%token_type
, {TOKEN_STRUCT
})
74 DEF(%token_destructor
, {free($$
);})
75 DEF(%default_destructor
, {(void)P
;})
76 DEF(%extra_argument
, {struct psi_parser
*P
})
78 /* TOKEN is defined inside syntax_error */
81 if (TOKEN
&& TOKEN
->type
!= PSI_T_EOF
) {
82 psi_error(PSI_WARNING
, TOKEN
->file
, TOKEN
->line
, "PSI syntax error: Unexpected token '%s' at pos %u", TOKEN
->text
, TOKEN
->col
);
84 psi_error(PSI_WARNING
, P
->file
.fn
, P
->line
, "PSI syntax error: Unexpected end of input");
88 TOKEN_CLASS(const_type
, T(BOOL
) T(INT
) T(FLOAT
) T(STRING
))
89 TOKEN_CLASS(decl_type
, T(FLOAT
) T(DOUBLE
) T(INT8
) T(UINT8
) T(INT16
) T(UINT16
) T(INT32
) T(UINT32
) T(INT64
) T(UINT64
) T(NAME
))
90 TOKEN_CLASS(impl_def_val
, T(NULL
) T(NUMBER
) T(TRUE
) T(FALSE
) T(QUOTED_STRING
))
91 TOKEN_CLASS(number
, T(NUMBER
) T(NSNAME
))
92 TOKEN_CLASS(num_exp_binary_op
, T(PIPE
) T(CARET
) T(AMPERSAND
) T(LSHIFT
) T(RSHIFT
) T(PLUS
) T(MINUS
) T(ASTERISK
) T(SLASH
) T(MODULO
))
93 TOKEN_CLASS(num_exp_unary_op
, T(TILDE
) T(NOT
) T(PLUS
) T(MINUS
))
94 TOKEN_CLASS(let_func
, T(ZVAL
) T(OBJVAL
) T(ARRVAL
) T(PATHVAL
) T(STRLEN
) T(STRVAL
) T(FLOATVAL
) T(INTVAL
) T(BOOLVAL
) T(COUNT
))
95 TOKEN_CLASS(set_func
, T(TO_OBJECT
) T(TO_ARRAY
) T(TO_STRING
) T(TO_INT
) T(TO_FLOAT
) T(TO_BOOL
) T(ZVAL
) T(VOID
))
96 TOKEN_CLASS(impl_type
, T(VOID
) T(MIXED
) T(BOOL
) T(INT
) T(FLOAT
) T(STRING
) T(ARRAY
) T(OBJECT
) T(CALLABLE
))
99 DEF(%right
, NOT TILDE
.)
102 DEF(%left
, AMPERSAND
.)
103 DEF(%left
, LSHIFT RSHIFT
.)
104 DEF(%left
, PLUS MINUS
.)
105 DEF(%left
, ASTERISK SLASH MODULO
.)
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
;
883 PARSE_TYPED(decl_args
, args
, ) {
890 PARSE_TYPED(decl_args
, args
,
896 * decl_args: decl_arg
898 PARSE_TYPED(decl_args
, args
,
899 TYPED(decl_arg
, arg
)) {
900 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
905 * decl_args: decl_args , decl_arg
907 PARSE_TYPED(decl_args
, args
,
908 TYPED(decl_args
, args_
)
910 TYPED(decl_arg
, arg
)) {
911 args
= psi_plist_add(args_
, &arg
);
915 * struct_args: struct_arg
917 PARSE_TYPED(struct_args
, args
,
918 TYPED(struct_arg
, arg
)) {
919 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
924 * struct_args: struct_args , struct_arg
926 PARSE_TYPED(struct_args
, args
,
927 TYPED(struct_args
, args_
)
928 TYPED(struct_arg
, arg
)) {
929 args
= psi_plist_add(args_
, &arg
);
933 * struct_arg: decl_typedef_body_ex ;
935 PARSE_TYPED(struct_arg
, arg_
,
936 TYPED(decl_typedef_body_ex
, def
)
939 switch (def
->type
->type
) {
941 if (def
->type
->real
.strct
) {
943 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
945 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
949 if (def
->type
->real
.unn
) {
951 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
953 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
957 if (def
->type
->real
.enm
) {
959 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
961 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
968 * struct_arg: decl_arg decl_layout ;
970 PARSE_TYPED(struct_arg
, arg
,
971 TYPED(decl_arg
, arg_
)
972 TYPED(decl_layout
, layout_
)
974 arg_
->layout
= layout_
;
979 * decl_layout: <empty>
981 PARSE_TYPED(decl_layout
, layout
, ) {
986 * decl_layout: :: ( NUMBER , NUMBER )
988 PARSE_TYPED(decl_layout
, layout
,
996 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
1001 /* un/signed, urgh */
1003 * decl_scalar_type: CHAR
1005 PARSE_NAMED(decl_scalar_type
, type_
,
1011 * decl_scalar_type: SHORT decl_scalar_type_short
1013 PARSE_NAMED(decl_scalar_type
, type_
,
1015 NAMED(decl_scalar_type_short
, s
)) {
1017 type_
= psi_token_cat(2, S
, s
);
1026 * decl_scalar_type_short: <empty>
1028 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1033 * decl_scalar_type_short: INT
1035 PARSE_NAMED(decl_scalar_type_short
, s
,
1041 * decl_sclara_type: INT
1043 PARSE_NAMED(decl_scalar_type
, type_
,
1049 * decl_scalar_type: LONG decl_scalar_type_long
1051 PARSE_NAMED(decl_scalar_type
, type_
,
1053 NAMED(decl_scalar_type_long
, l
)) {
1055 type_
= psi_token_cat(2, L
, l
);
1064 * decl_scalar_type_long: <empty>
1066 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1071 * decl_scalar_type_long: DOUBLE
1073 PARSE_NAMED(decl_scalar_type_long
, l
,
1079 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1081 PARSE_NAMED(decl_scalar_type_long
, l
,
1083 NAMED(decl_scalar_type_long_long
, ll
)) {
1085 l
= psi_token_cat(2, L
, ll
);
1094 * decl_scalar_type_long_long: <empty>
1096 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1101 * decl_scalar_type_long_long: INT
1103 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1109 * decl_type: UNSIGNED decl_scalar_type
1111 PARSE_TYPED(decl_type
, type_
,
1113 NAMED(decl_scalar_type
, N
)) {
1114 struct psi_token
*T
= psi_token_cat(2, U
, N
);
1115 type_
= psi_decl_type_init(T
->type
, T
->text
);
1122 * decl_type: SIGNED decl_scalar_type
1124 PARSE_TYPED(decl_type
, type_
,
1126 NAMED(decl_scalar_type
, N
)) {
1127 struct psi_token
*T
= psi_token_cat(2, S
, N
);
1128 type_
= psi_decl_type_init(T
->type
, T
->text
);
1135 * decl_type: UNSIGNED
1137 PARSE_TYPED(decl_type
, type_
,
1138 NAMED(UNSIGNED
, U
)) {
1139 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1146 PARSE_TYPED(decl_type
, type_
,
1148 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1153 * decl_type: decl_scalar_type
1155 PARSE_TYPED(decl_type
, type_
,
1156 NAMED(decl_scalar_type
, N
)) {
1157 type_
= psi_decl_type_init(N
->type
, N
->text
);
1163 * decl_type: STRUCT NAME
1165 PARSE_TYPED(decl_type
, type_
,
1168 type_
= psi_decl_type_init(S
->type
, T
->text
);
1174 * decl_type: UNION NAME
1176 PARSE_TYPED(decl_type
, type_
,
1179 type_
= psi_decl_type_init(U
->type
, T
->text
);
1185 * decl_type: ENUM NAME
1187 PARSE_TYPED(decl_type
, type_
,
1190 type_
= psi_decl_type_init(E
->type
, T
->text
);
1196 * decl_type: decl_type_token
1198 PARSE_TYPED(decl_type
, type_
,
1199 NAMED(decl_type_token
, T
)) {
1200 type_
= psi_decl_type_init(T
->type
, T
->text
);
1205 * const_decl_type: decl_type
1207 PARSE_TYPED(const_decl_type
, type
,
1208 TYPED(decl_type
, type_
)) {
1213 * const_decl_type: CONST decl_type
1215 PARSE_TYPED(const_decl_type
, type
,
1217 TYPED(decl_type
, type_
)) {
1222 * impl: impl_func { impl_stmts }
1224 PARSE_TYPED(impl
, impl
,
1225 TYPED(impl_func
, func
)
1227 TYPED(impl_stmts
, stmts
)
1229 impl
= psi_impl_init(func
, stmts
);
1233 * impl: STATIC impl_func { impl_stmts }
1235 PARSE_TYPED(impl
, impl
,
1237 TYPED(impl_func
, func
)
1239 TYPED(impl_stmts
, stmts
)
1241 func
->static_memory
= 1;
1242 impl
= psi_impl_init(func
, stmts
);
1246 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1248 PARSE_TYPED(impl_func
, func
,
1255 TYPED(impl_type
, type
)) {
1256 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1258 func
->return_reference
= r
;
1262 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1264 PARSE_TYPED(impl_func
, func
,
1269 TYPED(impl_args
, args
)
1272 TYPED(impl_type
, type
)) {
1273 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1275 func
->return_reference
= r
;
1279 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1281 PARSE_TYPED(impl_func
, func
,
1283 TYPED(reference
, func_r
)
1286 TYPED(impl_args
, args
)
1288 TYPED(impl_type
, va_type
)
1289 TYPED(reference
, va_r
)
1291 NAMED(DOLLAR_NAME
, T
)
1294 TYPED(impl_type
, func_type
)) {
1295 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1297 func
->return_reference
= func_r
;
1298 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1303 * impl_def_val: impl_def_val_token
1305 PARSE_TYPED(impl_def_val
, def
,
1306 NAMED(impl_def_val_token
, T
)) {
1307 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1312 * impl_var: reference DOLLAR_NAME
1314 PARSE_TYPED(impl_var
, var
,
1316 NAMED(DOLLAR_NAME
, T
)) {
1317 var
= psi_impl_var_init(T
->text
, r
);
1322 * impl_type: impl_type_token
1324 PARSE_TYPED(impl_type
, type_
,
1325 NAMED(impl_type_token
, T
)) {
1326 type_
= psi_impl_type_init(T
->type
, T
->text
);
1331 * impl_arg: impl_type impl_var
1333 PARSE_TYPED(impl_arg
, arg
,
1334 TYPED(impl_type
, type
)
1335 TYPED(impl_var
, var
)) {
1336 arg
= psi_impl_arg_init(type
, var
, NULL
);
1340 * impl_arg: impl_type impl_var = impl_def_val
1342 PARSE_TYPED(impl_arg
, arg
,
1343 TYPED(impl_type
, type
)
1344 TYPED(impl_var
, var
)
1346 TYPED(impl_def_val
, def
)) {
1347 arg
= psi_impl_arg_init(type
, var
, def
);
1351 * impl_args: impl_arg
1353 PARSE_TYPED(impl_args
, args
,
1354 TYPED(impl_arg
, arg
)) {
1355 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1360 * impl_args: impl_args , impl_arg
1362 PARSE_TYPED(impl_args
, args
,
1363 TYPED(impl_args
, args_
)
1365 TYPED(impl_arg
, arg
)) {
1366 args
= psi_plist_add(args_
, &arg
);
1370 * impl_stmts: impl_stmt
1372 PARSE_TYPED(impl_stmts
, stmts
,
1373 TYPED(impl_stmt
, stmt
)) {
1374 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1379 * impl_stmts: impl_stmts , impl_stmt
1381 PARSE_TYPED(impl_stmts
, stmts
,
1382 TYPED(impl_stmts
, stmts_
)
1383 TYPED(impl_stmt
, stmt
)) {
1384 stmts
= psi_plist_add(stmts_
, &stmt
);
1388 * impl_stmt: return_stmt
1390 PARSE_TYPED(impl_stmt
, i
,
1391 TYPED(return_stmt
, r
)) {
1392 i
= (struct psi_token
**) r
;
1396 * impl_stmt: let_stmt
1398 PARSE_TYPED(impl_stmt
, i
,
1399 TYPED(let_stmt
, l
)) {
1400 i
= (struct psi_token
**) l
;
1404 * impl_stmt: set_stmt
1406 PARSE_TYPED(impl_stmt
, i
,
1407 TYPED(set_stmt
, s
)) {
1408 i
= (struct psi_token
**) s
;
1412 * impl_stmt: free_stmt
1414 PARSE_TYPED(impl_stmt
, i
,
1415 TYPED(free_stmt
, f
)) {
1416 i
= (struct psi_token
**) f
;
1420 * number: number_token
1422 PARSE_TYPED(number
, exp
,
1423 NAMED(number_token
, tok
)) {
1424 exp
= psi_number_init(tok
->type
, tok
->text
);
1431 PARSE_TYPED(number
, exp
,
1432 TYPED(decl_var
, var
)) {
1433 exp
= psi_number_init(PSI_T_NAME
, var
);
1434 exp
->token
= psi_token_copy(var
->token
);
1440 PARSE_TYPED(num_exp
, exp
,
1441 TYPED(number
, num
)) {
1442 exp
= psi_num_exp_init_num(num
);
1443 exp
->token
= psi_token_copy(num
->token
);
1447 * num_exp: ( num_exp )
1449 PARSE_TYPED(num_exp
, exp
,
1451 TYPED(num_exp
, exp_
)
1453 exp
= psi_num_exp_init_unary(PSI_T_LPAREN
, exp_
);
1458 * num_exp: num_exp num_exp_binary_op_token num_exp
1460 PARSE_TYPED(num_exp
, exp
,
1461 TYPED(num_exp
, lhs_
)
1462 NAMED(num_exp_binary_op_token
, OP
)
1463 TYPED(num_exp
, rhs_
)) {
1464 exp
= psi_num_exp_init_binary(OP
->type
, lhs_
, rhs_
);
1469 * num_exp: num_exp_unary_op_token num_exp
1471 PARSE_TYPED(num_exp
, exp
,
1472 NAMED(num_exp_unary_op_token
, OP
)
1473 TYPED(num_exp
, exp_
)) {
1474 exp
= psi_num_exp_init_unary(OP
->type
, exp_
);
1481 PARSE_TYPED(let_exp
, val
,
1483 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1489 PARSE_TYPED(let_exp
, val
,
1492 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1493 val
->is_reference
= 1;
1499 PARSE_TYPED(let_exp
, val
,
1500 TYPED(let_callback
, cb
)) {
1501 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1507 PARSE_TYPED(let_exp
, val
,
1508 TYPED(let_calloc
, ca
)) {
1509 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1515 PARSE_TYPED(let_exp
, val
,
1517 TYPED(let_calloc
, ca
)) {
1518 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1519 val
->is_reference
= 1;
1525 PARSE_TYPED(let_exp
, val
,
1526 TYPED(let_func
, fn
)) {
1527 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1533 PARSE_TYPED(let_exp
, val
,
1535 TYPED(let_func
, fn
)) {
1536 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1537 val
->is_reference
= 1;
1543 PARSE_TYPED(let_exp
, val
,
1544 TYPED(num_exp
, exp
)) {
1545 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1549 * let_exp: & num_exp
1551 PARSE_TYPED(let_exp
, val
,
1553 TYPED(num_exp
, exp
)) {
1554 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1555 val
->is_reference
= 1;
1559 * let_exp: decl_var = let_exp
1561 PARSE_TYPED(let_exp
, exp
,
1562 TYPED(decl_var
, var_
)
1564 TYPED(let_exp
, val
)) {
1570 * let_stmt: LET let_exp ;
1572 PARSE_TYPED(let_stmt
, let
,
1576 let
= psi_let_stmt_init(val
);
1581 * let_stmt: TEMP decl_var = reference decl_var ;
1583 PARSE_TYPED(let_stmt
, let
,
1585 TYPED(decl_var
, var
)
1588 TYPED(decl_var
, val_
)
1590 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1592 let
->exp
->is_reference
= r
? 1 : 0;
1596 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1598 PARSE_TYPED(let_callback
, cb
,
1600 NAMED(callback_rval
, F
)
1602 TYPED(impl_var
, var
)
1604 TYPED(callback_arg_list
, args_
)
1607 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1613 * let_calloc: CALLOC ( num_exp , num_exp )
1615 PARSE_TYPED(let_calloc
, alloc
,
1618 TYPED(num_exp
, nmemb
)
1620 TYPED(num_exp
, size
)
1622 alloc
= psi_let_calloc_init(nmemb
, size
);
1627 * let_func: let_func_token ( impl_var )
1629 PARSE_TYPED(let_func
, func
,
1630 NAMED(let_func_token
, T
)
1632 TYPED(impl_var
, var
)
1634 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1638 * let_func: let_func_token ( impl_var , let_exps )
1640 PARSE_TYPED(let_func
, func
,
1641 NAMED(let_func_token
, T
)
1643 TYPED(impl_var
, var
)
1645 TYPED(let_exps
, vals
)
1647 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1654 PARSE_TYPED(let_exps
, exps
,
1655 TYPED(let_exp
, exp
)) {
1656 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1660 * let_exps: let_exps , let_exp
1662 PARSE_TYPED(let_exps
, exps
,
1663 TYPED(let_exps
, exps_
)
1665 TYPED(let_exp
, exp
)) {
1666 exps
= psi_plist_add(exps_
, &exp
);
1670 * callback_arg_list: <empty>
1672 PARSE_TYPED(callback_arg_list
, args
, ) {
1677 * callback_arg_list: callback_args
1679 PARSE_TYPED(callback_arg_list
, args
,
1680 TYPED(callback_args
, args_
)) {
1685 * callback_args: set_exp
1687 PARSE_TYPED(callback_args
, args
,
1688 TYPED(set_exp
, val
)) {
1689 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1694 * callback_args: callback_args , set_exp
1696 PARSE_TYPED(callback_args
, args
,
1697 TYPED(callback_args
, args_
)
1699 TYPED(set_exp
, val
)) {
1700 args
= psi_plist_add(args_
, &val
);
1704 * callback_rval: let_func_token
1706 PARSE_NAMED(callback_rval
, rval
,
1707 NAMED(let_func_token
, F
)) {
1712 * callback_rval: VOID
1714 PARSE_NAMED(callback_rval
, rval
,
1721 * set_func: set_func_token ( decl_var )
1723 PARSE_TYPED(set_func
, func
,
1724 NAMED(set_func_token
, T
)
1726 TYPED(decl_var
, var
)
1728 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1733 * set_func: set_func_token ( decl_var , set_exps )
1735 PARSE_TYPED(set_func
, func
,
1736 NAMED(set_func_token
, T
)
1738 TYPED(decl_var
, var
)
1740 TYPED(set_exps
, vals
)
1742 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1748 * set_func: set_func_token ( decl_var , ... )
1750 PARSE_TYPED(set_func
, func
,
1751 NAMED(set_func_token
, T
)
1753 TYPED(decl_var
, var
)
1757 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1759 func
->recursive
= 1;
1765 PARSE_TYPED(set_exp
, val
,
1766 TYPED(set_func
, fn
)) {
1767 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
1773 PARSE_TYPED(set_exp
, val
,
1774 TYPED(num_exp
, num
)) {
1775 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
1781 PARSE_TYPED(set_exps
, exps
,
1782 TYPED(set_exp
, exp
)) {
1783 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1788 * set_exps: set_exps , set_exp
1790 PARSE_TYPED(set_exps
, exps
,
1791 TYPED(set_exps
, exps_
)
1793 TYPED(set_exp
, exp
)) {
1794 exps
= psi_plist_add(exps_
, &exp
);
1798 * set_exp: impl_var = set_exp
1800 PARSE_TYPED(set_exp
, exp
,
1801 TYPED(impl_var
, var_
)
1803 TYPED(set_exp
, val
)) {
1809 * set_stmt: SET set_exp ;
1811 PARSE_TYPED(set_stmt
, set
,
1815 set
= psi_set_stmt_init(exp
);
1820 * return_stmt: RETURN set_exp ;
1822 PARSE_TYPED(return_stmt
, ret
,
1824 TYPED(set_func
, func
)
1826 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
1831 * free_stmt: FREE free_exps ;
1833 PARSE_TYPED(free_stmt
, free
,
1835 TYPED(free_exps
, calls
)
1837 free
= psi_free_stmt_init(calls
);
1842 * free_exps: free_exp
1844 PARSE_TYPED(free_exps
, calls
,
1845 TYPED(free_exp
, call
)) {
1846 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
1851 * free_exps: free_exps , free_exp
1853 PARSE_TYPED(free_exps
, calls
,
1854 TYPED(free_exps
, calls_
)
1856 TYPED(free_exp
, call
)) {
1857 calls
= psi_plist_add(calls_
, &call
);
1861 * free_exp: NAME ( decl_vars )
1863 PARSE_TYPED(free_exp
, call
,
1866 TYPED(decl_vars
, vars
)
1868 call
= psi_free_exp_init(F
->text
, vars
);
1873 * reference: <empty>
1875 PARSE_TYPED(reference
, r
, ) {
1882 PARSE_TYPED(reference
, r
,
1888 * indirection: <empty>
1890 PARSE_TYPED(indirection
, i
, ){
1895 * indirection: pointers
1897 PARSE_TYPED(indirection
, i
,
1898 TYPED(pointers
, p
)) {
1905 PARSE_TYPED(pointers
, p
,
1911 * pointers: pointers *
1913 PARSE_TYPED(pointers
, p
,