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(binary_op
, T(PIPE
) T(CARET
) T(AMPERSAND
) T(LSHIFT
) T(RSHIFT
) T(PLUS
) T(MINUS
) T(ASTERISK
) T(SLASH
) T(MODULO
) T(RCHEVR
) T(LCHEVR
) T(CMP_GE
) T(CMP_LE
) T(OR
) T(AND
) T(CMP_EQ
) T(CMP_NE
))
93 TOKEN_CLASS(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
.)
103 DEF(%left
, AMPERSAND
.)
104 DEF(%left
, CMP_EQ CMP_NE
.)
105 DEF(%left
, LCHEVR CMP_LE RCHEVR CMP_GE
.)
106 DEF(%left
, LSHIFT RSHIFT
.)
107 DEF(%left
, PLUS MINUS
.)
108 DEF(%left
, ASTERISK SLASH MODULO
.)
110 DEF(%fallback
, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT
.)
112 TOKEN_TYPE(decl_enum
, struct psi_decl_enum
*)
113 TOKEN_DTOR(decl_enum
, psi_decl_enum_free(&$$
);)
114 TOKEN_TYPE(decl_enum_items
, struct psi_plist
*)
115 TOKEN_DTOR(decl_enum_items
, psi_plist_free($$
);)
116 TOKEN_TYPE(decl_enum_item
, struct psi_decl_enum_item
*)
117 TOKEN_DTOR(decl_enum_item
, psi_decl_enum_item_free(&$$
);)
118 TOKEN_TYPE(decl_struct_args_block
, struct psi_plist
*)
119 TOKEN_DTOR(decl_struct_args_block
, psi_plist_free($$
);) /* there was a typo */
120 TOKEN_TYPE(decl_struct_args
, struct psi_plist
*)
121 TOKEN_DTOR(decl_struct_args
, psi_plist_free($$
);)
122 TOKEN_TYPE(decl_struct
, struct psi_decl_struct
*)
123 TOKEN_DTOR(decl_struct
, psi_decl_struct_free(&$$
);)
124 TOKEN_TYPE(align_and_size
, struct psi_layout
)
125 TOKEN_TYPE(decl_union
, struct psi_decl_union
*)
126 TOKEN_DTOR(decl_union
, psi_decl_union_free(&$$
);)
127 TOKEN_TYPE(const_type
, struct psi_const_type
*)
128 TOKEN_DTOR(const_type
, psi_const_type_free(&$$
);)
129 TOKEN_TYPE(constant
, struct psi_const
*)
130 TOKEN_DTOR(constant
, psi_const_free(&$$
);)
131 TOKEN_TYPE(decl_typedef
, struct psi_decl_arg
*)
132 TOKEN_DTOR(decl_typedef
, psi_decl_arg_free(&$$
);)
133 TOKEN_TYPE(decl_typedef_body_ex
, struct psi_decl_arg
*)
134 TOKEN_DTOR(decl_typedef_body_ex
, psi_decl_arg_free(&$$
);)
135 TOKEN_TYPE(decl_typedef_body
, struct psi_decl_arg
*)
136 TOKEN_DTOR(decl_typedef_body
, psi_decl_arg_free(&$$
);)
137 TOKEN_TYPE(decl_typedef_body_fn_args
, struct psi_plist
*)
138 TOKEN_DTOR(decl_typedef_body_fn_args
, psi_plist_free($$
);)
139 TOKEN_TYPE(decl
, struct psi_decl
*)
140 TOKEN_DTOR(decl
, psi_decl_free(&$$
);)
141 TOKEN_TYPE(decl_func
, struct psi_decl_arg
*)
142 TOKEN_DTOR(decl_func
, psi_decl_arg_free(&$$
);)
143 TOKEN_TYPE(decl_abi
, struct psi_decl_abi
*)
144 TOKEN_DTOR(decl_abi
, psi_decl_abi_free(&$$
);)
145 TOKEN_TYPE(decl_var
, struct psi_decl_var
*)
146 TOKEN_DTOR(decl_var
, psi_decl_var_free(&$$
);)
147 TOKEN_TYPE(decl_vars
, struct psi_plist
*)
148 TOKEN_DTOR(decl_vars
, psi_plist_free($$
);)
149 TOKEN_TYPE(decl_arg
, struct psi_decl_arg
*)
150 TOKEN_DTOR(decl_arg
, psi_decl_arg_free(&$$
);)
151 TOKEN_TYPE(decl_args
, struct psi_plist
*)
152 TOKEN_DTOR(decl_args
, psi_plist_free($$
);)
153 TOKEN_TYPE(struct_args
, struct psi_plist
*)
154 TOKEN_DTOR(struct_args
, psi_plist_free($$
);)
155 TOKEN_TYPE(struct_arg
, struct psi_decl_arg
*)
156 TOKEN_DTOR(struct_arg
, psi_decl_arg_free(&$$
);)
157 TOKEN_TYPE(decl_layout
, struct psi_layout
*)
158 TOKEN_DTOR(decl_layout
, psi_layout_free(&$$
);)
159 TOKEN_TYPE(decl_type
, struct psi_decl_type
*)
160 TOKEN_DTOR(decl_type
, psi_decl_type_free(&$$
);)
161 TOKEN_TYPE(const_decl_type
, struct psi_decl_type
*)
162 TOKEN_DTOR(const_decl_type
, psi_decl_type_free(&$$
);)
163 TOKEN_TYPE(impl
, struct psi_impl
*)
164 TOKEN_DTOR(impl
, psi_impl_free(&$$
);)
165 TOKEN_TYPE(impl_func
, struct psi_impl_func
*)
166 TOKEN_DTOR(impl_func
, psi_impl_func_free(&$$
);)
167 TOKEN_TYPE(impl_def_val
, struct psi_impl_def_val
*)
168 TOKEN_DTOR(impl_def_val
, psi_impl_def_val_free(&$$
);)
169 TOKEN_TYPE(impl_var
, struct psi_impl_var
*)
170 TOKEN_DTOR(impl_var
, psi_impl_var_free(&$$
);)
171 TOKEN_TYPE(impl_arg
, struct psi_impl_arg
*)
172 TOKEN_DTOR(impl_arg
, psi_impl_arg_free(&$$
);)
173 TOKEN_TYPE(impl_args
, struct psi_plist
*)
174 TOKEN_DTOR(impl_args
, psi_plist_free($$
);)
175 TOKEN_TYPE(impl_vararg
, struct psi_impl_arg
*)
176 TOKEN_DTOR(impl_vararg
, psi_impl_arg_free(&$$
);)
177 TOKEN_TYPE(impl_stmts
, struct psi_plist
*)
178 TOKEN_DTOR(impl_stmts
, psi_plist_free($$
);)
179 TOKEN_TYPE(impl_stmt
, struct psi_token
**)
180 TOKEN_DTOR(impl_stmt
, psi_impl_stmt_free(&$$
);)
181 TOKEN_TYPE(number
, struct psi_number
*)
182 TOKEN_DTOR(number
, psi_number_free(&$$
);)
183 TOKEN_TYPE(num_exp
, struct psi_num_exp
*)
184 TOKEN_DTOR(num_exp
, psi_num_exp_free(&$$
);)
185 TOKEN_TYPE(let_stmt
, struct psi_let_stmt
*)
186 TOKEN_DTOR(let_stmt
, psi_let_stmt_free(&$$
);)
187 TOKEN_TYPE(let_calloc
, struct psi_let_calloc
*)
188 TOKEN_DTOR(let_calloc
, psi_let_calloc_free(&$$
);)
189 TOKEN_TYPE(let_func
, struct psi_let_func
*)
190 TOKEN_DTOR(let_func
, psi_let_func_free(&$$
);)
191 TOKEN_TYPE(callback_arg_list
, struct psi_plist
*)
192 TOKEN_DTOR(callback_arg_list
, psi_plist_free($$
);)
193 TOKEN_TYPE(callback_args
, struct psi_plist
*)
194 TOKEN_DTOR(callback_args
, psi_plist_free($$
);)
195 TOKEN_TYPE(let_callback
, struct psi_let_callback
*)
196 TOKEN_DTOR(let_callback
, psi_let_callback_free(&$$
);)
197 TOKEN_TYPE(let_exp
, struct psi_let_exp
*)
198 TOKEN_DTOR(let_exp
, psi_let_exp_free(&$$
);)
199 TOKEN_TYPE(let_exps
, struct psi_plist
*)
200 TOKEN_DTOR(let_exps
, psi_plist_free($$
);)
201 TOKEN_TYPE(set_stmt
, struct psi_set_stmt
*)
202 TOKEN_DTOR(set_stmt
, psi_set_stmt_free(&$$
);)
203 TOKEN_TYPE(set_exp
, struct psi_set_exp
*)
204 TOKEN_DTOR(set_exp
, psi_set_exp_free(&$$
);)
205 TOKEN_TYPE(set_exps
, struct psi_plist
*)
206 TOKEN_DTOR(set_exps
, psi_plist_free($$
);)
207 TOKEN_TYPE(set_func
, struct psi_set_func
*)
208 TOKEN_DTOR(set_func
, psi_set_func_free(&$$
);)
209 TOKEN_TYPE(return_stmt
, struct psi_return_stmt
*)
210 TOKEN_DTOR(return_stmt
, psi_return_stmt_free(&$$
);)
211 TOKEN_TYPE(free_stmt
, struct psi_free_stmt
*)
212 TOKEN_DTOR(free_stmt
, psi_free_stmt_free(&$$
);)
213 TOKEN_TYPE(free_exps
, struct psi_plist
*)
214 TOKEN_DTOR(free_exps
, psi_plist_free($$
);)
215 TOKEN_TYPE(free_exp
, struct psi_free_exp
*)
216 TOKEN_DTOR(free_exp
, psi_free_exp_free(&$$
);)
217 TOKEN_TYPE(impl_type
, struct psi_impl_type
*)
218 TOKEN_DTOR(impl_type
, psi_impl_type_free(&$$
);)
219 TOKEN_TYPE(reference
, bool)
220 TOKEN_TYPE(indirection
, unsigned)
221 TOKEN_TYPE(pointers
, unsigned)
225 PASS(blocks
, blocks block
)
231 * lib: LIB "soname" ;
233 PARSE(block
, NAMED(LIB
, token
) NAMED(QUOTED_STRING
, libname
) TOKEN(EOS
)) {
235 P
->error(PSI_DATA(P
), token
, PSI_WARNING
, "Extra 'lib %s' statement has no effect", libname
->text
);
237 P
->file
.ln
= strndup(libname
->text
+ 1, libname
->size
- 2);
243 PARSE(block
, TYPED(decl
, decl
)) {
245 P
->decls
= psi_plist_init((psi_plist_dtor
) psi_decl_free
);
247 P
->decls
= psi_plist_add(P
->decls
, &decl
);
250 PARSE(block
, TYPED(impl
, impl
)) {
252 P
->impls
= psi_plist_init((psi_plist_dtor
) psi_impl_free
);
254 P
->impls
= psi_plist_add(P
->impls
, &impl
);
257 PARSE(block
, TYPED(decl_typedef
, def
)) {
259 P
->types
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
261 P
->types
= psi_plist_add(P
->types
, &def
);
263 switch (def
->type
->type
) {
265 if (def
->type
->real
.strct
) {
267 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
269 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
273 if (def
->type
->real
.unn
) {
275 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
277 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
281 if (def
->type
->real
.enm
) {
283 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
285 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
291 PARSE(block
, TYPED(constant
, constant
)) {
293 P
->consts
= psi_plist_init((psi_plist_dtor
) psi_const_free
);
295 P
->consts
= psi_plist_add(P
->consts
, &constant
);
298 PARSE(block
, TYPED(decl_struct
, strct
)) {
300 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
302 P
->structs
= psi_plist_add(P
->structs
, &strct
);
305 PARSE(block
, TYPED(decl_union
, u
)) {
307 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
309 P
->unions
= psi_plist_add(P
->unions
, &u
);
312 PARSE(block
, TYPED(decl_enum
, e
)) {
314 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
316 P
->enums
= psi_plist_add(P
->enums
, &e
);
320 * optional_name: <empty>
322 PARSE_NAMED(optional_name
, n
, ) {
327 * optional_name: NAME
329 PARSE_NAMED(optional_name
, n
,
335 * align_and_size: <empty>
337 PARSE_TYPED(align_and_size
, as
, ) {
343 * align_and_size: :: ( NUMBER , NUMBER )
345 PARSE_TYPED(align_and_size
, as
,
353 as
.pos
= atol(A
->text
);
354 as
.len
= atol(S
->text
);
360 * enum_name: ENUM optional_name
362 PARSE_NAMED(enum_name
, n
,
364 NAMED(optional_name
, N
)) {
371 psi_token_hash(E
, digest
);
372 n
= psi_token_translit(psi_token_append(E
, 1, digest
), " ", "@");
377 * struct_name: STRUCT optional_name
379 PARSE_NAMED(struct_name
, n
,
381 NAMED(optional_name
, N
)) {
388 psi_token_hash(S
, digest
);
389 n
= psi_token_translit(psi_token_append(S
, 1, digest
), " ", "@");
394 * union_name: UNION optional_name
396 PARSE_NAMED(union_name
, n
,
398 NAMED(optional_name
, N
)) {
405 psi_token_hash(U
, digest
);
406 n
= psi_token_translit(psi_token_append(U
, 1, digest
), " ", "@");
411 * decl_enum: enum_name { items }
413 PARSE_TYPED(decl_enum
, e
,
416 TYPED(decl_enum_items
, list
)
418 e
= psi_decl_enum_init(N
->text
, list
);
423 * decl_enum_items: item
425 PARSE_TYPED(decl_enum_items
, l
,
426 TYPED(decl_enum_item
, i
)) {
427 l
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_enum_item_free
),
432 * decl_enum_items: items , item
434 PARSE_TYPED(decl_enum_items
, l
,
435 TYPED(decl_enum_items
, l_
)
437 TYPED(decl_enum_item
, i
)) {
438 l
= psi_plist_add(l_
, &i
);
442 * decl_enum_item: name = num_exp
444 PARSE_TYPED(decl_enum_item
, i
,
447 TYPED(num_exp
, num
)) {
448 i
= psi_decl_enum_item_init(N
->text
, num
);
453 * decl_enum_item: name
455 PARSE_TYPED(decl_enum_item
, i
,
457 i
= psi_decl_enum_item_init(N
->text
, NULL
);
463 * decl_struct_args_block: { args }
465 PARSE_TYPED(decl_struct_args_block
, args_
,
467 TYPED(struct_args
, args
)
473 * decl_struct_args: args_block
475 PARSE_TYPED(decl_struct_args
, args_
,
476 TYPED(decl_struct_args_block
, args
)) {
481 * decl_struct_args: ;
483 PARSE_TYPED(decl_struct_args
, args_
,
485 args_
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
489 * decl_struct: STRUCT name align_and_size struct_args
491 PARSE_TYPED(decl_struct
, strct
,
494 TYPED(align_and_size
, as
)
495 TYPED(decl_struct_args
, args
)) {
496 strct
= psi_decl_struct_init(N
->text
, args
);
497 strct
->align
= as
.pos
;
498 strct
->size
= as
.len
;
503 * decl_union: UNION name align_and_size struct_args
505 PARSE_TYPED(decl_union
, u
,
508 TYPED(align_and_size
, as
)
509 TYPED(decl_struct_args
, args
)) {
510 u
= psi_decl_union_init(N
->text
, args
);
517 * const_type: const_type_token
519 PARSE_TYPED(const_type
, type_
,
520 NAMED(const_type_token
, T
)) {
521 type_
= psi_const_type_init(T
->type
, T
->text
);
526 * constant: CONST const_type NSNAME = def_val ;
528 PARSE_TYPED(constant
, constant
,
530 TYPED(const_type
, type
)
533 TYPED(impl_def_val
, val
)
535 constant
= psi_const_init(type
, T
->text
, val
);
540 * decl_typdef: TYPEDEF typedef_body ;
542 PARSE_TYPED(decl_typedef
, def
,
544 TYPED(decl_typedef_body
, def_
)
551 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
553 PARSE_TYPED(decl_typedef_body_ex
, def
,
554 NAMED(struct_name
, N
)
555 TYPED(align_and_size
, as
)
556 TYPED(decl_struct_args_block
, args
)
557 TYPED(decl_var
, var
)) {
558 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT
, N
->text
), var
);
559 def
->type
->token
= psi_token_copy(N
);
560 def
->type
->real
.strct
= psi_decl_struct_init(N
->text
, args
);
561 def
->type
->real
.strct
->token
= N
;
562 def
->type
->real
.strct
->align
= as
.pos
;
563 def
->type
->real
.strct
->size
= as
.len
;
567 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
569 PARSE_TYPED(decl_typedef_body_ex
, def
,
571 TYPED(align_and_size
, as
)
572 TYPED(decl_struct_args_block
, args
)
573 TYPED(decl_var
, var
)) {
574 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION
, N
->text
), var
);
575 def
->type
->token
= psi_token_copy(N
);
576 def
->type
->real
.unn
= psi_decl_union_init(N
->text
, args
);
577 def
->type
->real
.unn
->token
= N
;
578 def
->type
->real
.unn
->align
= as
.pos
;
579 def
->type
->real
.unn
->size
= as
.len
;
583 * decl_typedef_body_ex: decl_enum NAME
585 PARSE_TYPED(decl_typedef_body_ex
, def
,
587 NAMED(NAME
, ALIAS
)) {
588 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM
, e
->name
), psi_decl_var_init(ALIAS
->text
, 0, 0));
589 def
->var
->token
= ALIAS
;
590 def
->type
->token
= psi_token_copy(e
->token
);
591 def
->type
->real
.enm
= e
;
595 * decl_typedef_body: decl_typedef_body_ex
597 PARSE_TYPED(decl_typedef_body
, def
,
598 TYPED(decl_typedef_body_ex
, def_
)) {
603 * decl_typedef_body_fn_args: ( decl_args )
605 PARSE_TYPED(decl_typedef_body_fn_args
, args
,
607 TYPED(decl_args
, args_
)
613 * decl_typedef_body: decl_func decl_typedef_body_fn_args
615 PARSE_TYPED(decl_typedef_body
, def
,
616 TYPED(decl_func
, func_
)
617 TYPED(decl_typedef_body_fn_args
, args
)) {
618 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
), psi_decl_var_copy(func_
->var
));
619 def
->type
->token
= psi_token_copy(func_
->token
);
620 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
624 * decl_typedef_body: decl_arg
626 PARSE_TYPED(decl_typedef_body
, def
,
627 TYPED(decl_arg
, arg
)) {
632 * decl: decl_abi decl_func ( decl_args ) ;
634 PARSE_TYPED(decl
, decl
,
636 TYPED(decl_func
, func
)
638 TYPED(decl_args
, args
)
641 decl
= psi_decl_init(abi
, func
, args
);
645 * decl: decl_abi decl_func ( decl_args , ... ) ;
647 PARSE_TYPED(decl
, decl
,
649 TYPED(decl_func
, func
)
651 TYPED(decl_args
, args
)
656 decl
= psi_decl_init(abi
, func
, args
);
661 * decl_func: decl_arg
663 PARSE_TYPED(decl_func
, func
,
664 TYPED(decl_arg
, arg
)) {
668 /* special case for void functions */
670 * decl_func: VOID NAME
672 PARSE_TYPED(decl_func
, func
,
675 func
= psi_decl_arg_init(
676 psi_decl_type_init(T
->type
, T
->text
),
677 psi_decl_var_init(N
->text
, 0, 0)
679 func
->type
->token
= T
;
680 func
->var
->token
= N
;
685 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
687 PARSE_TYPED(decl_typedef_body
, def
,
689 TYPED(indirection
, decl_i
)
691 TYPED(indirection
, type_i
)
694 TYPED(decl_typedef_body_fn_args
, args
)) {
695 struct psi_decl_arg
*func_
= psi_decl_arg_init(
696 psi_decl_type_init(T
->type
, T
->text
),
697 psi_decl_var_init(N
->text
, decl_i
, 0)
699 func_
->type
->token
= T
;
700 func_
->var
->token
= N
;
703 def
= psi_decl_arg_init(
704 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
705 psi_decl_var_copy(func_
->var
)
707 def
->var
->pointer_level
= type_i
;
708 def
->type
->token
= psi_token_copy(func_
->token
);
709 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
713 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
715 PARSE_TYPED(decl_typedef_body
, def
,
718 TYPED(pointers
, decl_i
)
720 TYPED(indirection
, type_i
)
723 TYPED(decl_typedef_body_fn_args
, args
)) {
724 struct psi_decl_arg
*func_
= psi_decl_arg_init(
725 psi_decl_type_init(T
->type
, T
->text
),
726 psi_decl_var_init(N
->text
, decl_i
, 0)
728 func_
->type
->token
= T
;
729 func_
->var
->token
= N
;
732 def
= psi_decl_arg_init(
733 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
734 psi_decl_var_copy(func_
->var
)
736 def
->var
->pointer_level
= type_i
;
737 def
->type
->token
= psi_token_copy(func_
->token
);
738 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
744 PARSE_TYPED(decl_abi
, abi
,
746 abi
= psi_decl_abi_init(T
->text
);
751 * decl_var_array_size: <empty>
753 PARSE_NAMED(decl_var_array_size
, as
, ) {
758 * decl_var_array_size: [ NUMBER ]
760 PARSE_NAMED(decl_var_array_size
, as
,
768 * decl_var: NAME decl_var_array_size
770 PARSE_TYPED(decl_var
, var
,
772 NAMED(decl_var_array_size
, as
)) {
773 var
= psi_decl_var_init(T
->text
, 0, as
?atol(as
->text
):0);
781 * decl_var: pointers NAME
783 PARSE_TYPED(decl_var
, var
,
786 NAMED(decl_var_array_size
, as
)) {
787 var
= psi_decl_var_init(T
->text
, p
+!!as
, as
?atol(as
->text
):0);
795 * decl_vars: decl_var
797 PARSE_TYPED(decl_vars
, vars
,
798 TYPED(decl_var
, var
)) {
799 vars
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_var_free
),
804 * decl_vars: decl_vars , decl_var
806 PARSE_TYPED(decl_vars
, vars
,
807 TYPED(decl_vars
, vars_
)
809 TYPED(decl_var
, var
)) {
810 vars
= psi_plist_add(vars_
, &var
);
814 * decl_arg: const_decl_type decl_var
816 PARSE_TYPED(decl_arg
, arg_
,
817 TYPED(const_decl_type
, type
)
818 TYPED(decl_var
, var
)) {
819 arg_
= psi_decl_arg_init(type
, var
);
823 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
825 PARSE_TYPED(decl_typedef_body
, def
,
826 TYPED(const_decl_type
, type_
)
827 TYPED(indirection
, decl_i
)
829 TYPED(indirection
, type_i
)
832 TYPED(decl_typedef_body_fn_args
, args
)) {
833 struct psi_decl_arg
*func_
= psi_decl_arg_init(
835 psi_decl_var_init(N
->text
, decl_i
, 0)
837 func_
->var
->token
= N
;
840 def
= psi_decl_arg_init(
841 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
842 psi_decl_var_copy(func_
->var
)
844 def
->var
->pointer_level
= type_i
;
845 def
->type
->token
= psi_token_copy(func_
->token
);
846 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
849 /* void pointers need a specific rule */
851 * decl_arg: VOID pointers NAME
853 PARSE_TYPED(decl_arg
, arg_
,
857 arg_
= psi_decl_arg_init(
858 psi_decl_type_init(T
->type
, T
->text
),
859 psi_decl_var_init(N
->text
, p
, 0)
861 arg_
->type
->token
= T
;
862 arg_
->var
->token
= N
;
867 * decl_args: CONST VOID pointers NAME
869 PARSE_TYPED(decl_arg
, arg_
,
874 arg_
= psi_decl_arg_init(
875 psi_decl_type_init(T
->type
, T
->text
),
876 psi_decl_var_init(N
->text
, p
, 0)
878 arg_
->type
->token
= T
;
879 arg_
->var
->token
= N
;
886 PARSE_TYPED(decl_args
, args
, ) {
893 PARSE_TYPED(decl_args
, args
,
899 * decl_args: decl_arg
901 PARSE_TYPED(decl_args
, args
,
902 TYPED(decl_arg
, arg
)) {
903 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
908 * decl_args: decl_args , decl_arg
910 PARSE_TYPED(decl_args
, args
,
911 TYPED(decl_args
, args_
)
913 TYPED(decl_arg
, arg
)) {
914 args
= psi_plist_add(args_
, &arg
);
918 * struct_args: struct_arg
920 PARSE_TYPED(struct_args
, args
,
921 TYPED(struct_arg
, arg
)) {
922 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
927 * struct_args: struct_args , struct_arg
929 PARSE_TYPED(struct_args
, args
,
930 TYPED(struct_args
, args_
)
931 TYPED(struct_arg
, arg
)) {
932 args
= psi_plist_add(args_
, &arg
);
936 * struct_arg: decl_typedef_body_ex ;
938 PARSE_TYPED(struct_arg
, arg_
,
939 TYPED(decl_typedef_body_ex
, def
)
942 switch (def
->type
->type
) {
944 if (def
->type
->real
.strct
) {
946 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
948 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
952 if (def
->type
->real
.unn
) {
954 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
956 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
960 if (def
->type
->real
.enm
) {
962 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
964 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
971 * struct_arg: decl_arg decl_layout ;
973 PARSE_TYPED(struct_arg
, arg
,
974 TYPED(decl_arg
, arg_
)
975 TYPED(decl_layout
, layout_
)
977 arg_
->layout
= layout_
;
982 * decl_layout: <empty>
984 PARSE_TYPED(decl_layout
, layout
, ) {
989 * decl_layout: :: ( NUMBER , NUMBER )
991 PARSE_TYPED(decl_layout
, layout
,
999 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
1004 /* un/signed, urgh */
1006 * decl_scalar_type: CHAR
1008 PARSE_NAMED(decl_scalar_type
, type_
,
1014 * decl_scalar_type: SHORT decl_scalar_type_short
1016 PARSE_NAMED(decl_scalar_type
, type_
,
1018 NAMED(decl_scalar_type_short
, s
)) {
1020 type_
= psi_token_cat(2, S
, s
);
1029 * decl_scalar_type_short: <empty>
1031 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1036 * decl_scalar_type_short: INT
1038 PARSE_NAMED(decl_scalar_type_short
, s
,
1044 * decl_sclara_type: INT
1046 PARSE_NAMED(decl_scalar_type
, type_
,
1052 * decl_scalar_type: LONG decl_scalar_type_long
1054 PARSE_NAMED(decl_scalar_type
, type_
,
1056 NAMED(decl_scalar_type_long
, l
)) {
1058 type_
= psi_token_cat(2, L
, l
);
1067 * decl_scalar_type_long: <empty>
1069 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1074 * decl_scalar_type_long: DOUBLE
1076 PARSE_NAMED(decl_scalar_type_long
, l
,
1082 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1084 PARSE_NAMED(decl_scalar_type_long
, l
,
1086 NAMED(decl_scalar_type_long_long
, ll
)) {
1088 l
= psi_token_cat(2, L
, ll
);
1097 * decl_scalar_type_long_long: <empty>
1099 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1104 * decl_scalar_type_long_long: INT
1106 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1112 * decl_type: UNSIGNED decl_scalar_type
1114 PARSE_TYPED(decl_type
, type_
,
1116 NAMED(decl_scalar_type
, N
)) {
1117 struct psi_token
*T
= psi_token_cat(2, U
, N
);
1118 type_
= psi_decl_type_init(T
->type
, T
->text
);
1125 * decl_type: SIGNED decl_scalar_type
1127 PARSE_TYPED(decl_type
, type_
,
1129 NAMED(decl_scalar_type
, N
)) {
1130 struct psi_token
*T
= psi_token_cat(2, S
, N
);
1131 type_
= psi_decl_type_init(T
->type
, T
->text
);
1138 * decl_type: UNSIGNED
1140 PARSE_TYPED(decl_type
, type_
,
1141 NAMED(UNSIGNED
, U
)) {
1142 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1149 PARSE_TYPED(decl_type
, type_
,
1151 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1156 * decl_type: decl_scalar_type
1158 PARSE_TYPED(decl_type
, type_
,
1159 NAMED(decl_scalar_type
, N
)) {
1160 type_
= psi_decl_type_init(N
->type
, N
->text
);
1166 * decl_type: STRUCT NAME
1168 PARSE_TYPED(decl_type
, type_
,
1171 type_
= psi_decl_type_init(S
->type
, T
->text
);
1177 * decl_type: UNION NAME
1179 PARSE_TYPED(decl_type
, type_
,
1182 type_
= psi_decl_type_init(U
->type
, T
->text
);
1188 * decl_type: ENUM NAME
1190 PARSE_TYPED(decl_type
, type_
,
1193 type_
= psi_decl_type_init(E
->type
, T
->text
);
1199 * decl_type: decl_type_token
1201 PARSE_TYPED(decl_type
, type_
,
1202 NAMED(decl_type_token
, T
)) {
1203 type_
= psi_decl_type_init(T
->type
, T
->text
);
1208 * const_decl_type: decl_type
1210 PARSE_TYPED(const_decl_type
, type
,
1211 TYPED(decl_type
, type_
)) {
1216 * const_decl_type: CONST decl_type
1218 PARSE_TYPED(const_decl_type
, type
,
1220 TYPED(decl_type
, type_
)) {
1225 * impl: impl_func { impl_stmts }
1227 PARSE_TYPED(impl
, impl
,
1228 TYPED(impl_func
, func
)
1230 TYPED(impl_stmts
, stmts
)
1232 impl
= psi_impl_init(func
, stmts
);
1236 * impl: STATIC impl_func { impl_stmts }
1238 PARSE_TYPED(impl
, impl
,
1240 TYPED(impl_func
, func
)
1242 TYPED(impl_stmts
, stmts
)
1244 func
->static_memory
= 1;
1245 impl
= psi_impl_init(func
, stmts
);
1249 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1251 PARSE_TYPED(impl_func
, func
,
1258 TYPED(impl_type
, type
)) {
1259 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1261 func
->return_reference
= r
;
1265 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1267 PARSE_TYPED(impl_func
, func
,
1272 TYPED(impl_args
, args
)
1275 TYPED(impl_type
, type
)) {
1276 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1278 func
->return_reference
= r
;
1282 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1284 PARSE_TYPED(impl_func
, func
,
1286 TYPED(reference
, func_r
)
1289 TYPED(impl_args
, args
)
1291 TYPED(impl_type
, va_type
)
1292 TYPED(reference
, va_r
)
1294 NAMED(DOLLAR_NAME
, T
)
1297 TYPED(impl_type
, func_type
)) {
1298 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1300 func
->return_reference
= func_r
;
1301 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1306 * impl_def_val: impl_def_val_token
1308 PARSE_TYPED(impl_def_val
, def
,
1309 NAMED(impl_def_val_token
, T
)) {
1310 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1315 * impl_var: reference DOLLAR_NAME
1317 PARSE_TYPED(impl_var
, var
,
1319 NAMED(DOLLAR_NAME
, T
)) {
1320 var
= psi_impl_var_init(T
->text
, r
);
1325 * impl_type: impl_type_token
1327 PARSE_TYPED(impl_type
, type_
,
1328 NAMED(impl_type_token
, T
)) {
1329 type_
= psi_impl_type_init(T
->type
, T
->text
);
1334 * impl_arg: impl_type impl_var
1336 PARSE_TYPED(impl_arg
, arg
,
1337 TYPED(impl_type
, type
)
1338 TYPED(impl_var
, var
)) {
1339 arg
= psi_impl_arg_init(type
, var
, NULL
);
1343 * impl_arg: impl_type impl_var = impl_def_val
1345 PARSE_TYPED(impl_arg
, arg
,
1346 TYPED(impl_type
, type
)
1347 TYPED(impl_var
, var
)
1349 TYPED(impl_def_val
, def
)) {
1350 arg
= psi_impl_arg_init(type
, var
, def
);
1354 * impl_args: impl_arg
1356 PARSE_TYPED(impl_args
, args
,
1357 TYPED(impl_arg
, arg
)) {
1358 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1363 * impl_args: impl_args , impl_arg
1365 PARSE_TYPED(impl_args
, args
,
1366 TYPED(impl_args
, args_
)
1368 TYPED(impl_arg
, arg
)) {
1369 args
= psi_plist_add(args_
, &arg
);
1373 * impl_stmts: impl_stmt
1375 PARSE_TYPED(impl_stmts
, stmts
,
1376 TYPED(impl_stmt
, stmt
)) {
1377 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1382 * impl_stmts: impl_stmts , impl_stmt
1384 PARSE_TYPED(impl_stmts
, stmts
,
1385 TYPED(impl_stmts
, stmts_
)
1386 TYPED(impl_stmt
, stmt
)) {
1387 stmts
= psi_plist_add(stmts_
, &stmt
);
1391 * impl_stmt: return_stmt
1393 PARSE_TYPED(impl_stmt
, i
,
1394 TYPED(return_stmt
, r
)) {
1395 i
= (struct psi_token
**) r
;
1399 * impl_stmt: let_stmt
1401 PARSE_TYPED(impl_stmt
, i
,
1402 TYPED(let_stmt
, l
)) {
1403 i
= (struct psi_token
**) l
;
1407 * impl_stmt: set_stmt
1409 PARSE_TYPED(impl_stmt
, i
,
1410 TYPED(set_stmt
, s
)) {
1411 i
= (struct psi_token
**) s
;
1415 * impl_stmt: free_stmt
1417 PARSE_TYPED(impl_stmt
, i
,
1418 TYPED(free_stmt
, f
)) {
1419 i
= (struct psi_token
**) f
;
1423 * number: number_token
1425 PARSE_TYPED(number
, exp
,
1426 NAMED(number_token
, tok
)) {
1427 exp
= psi_number_init(tok
->type
, tok
->text
);
1434 PARSE_TYPED(number
, exp
,
1435 TYPED(decl_var
, var
)) {
1436 exp
= psi_number_init(PSI_T_NAME
, var
);
1437 exp
->token
= psi_token_copy(var
->token
);
1443 PARSE_TYPED(num_exp
, exp
,
1444 TYPED(number
, num
)) {
1445 exp
= psi_num_exp_init_num(num
);
1446 exp
->token
= psi_token_copy(num
->token
);
1450 * num_exp: ( num_exp )
1452 PARSE_TYPED(num_exp
, exp
,
1454 TYPED(num_exp
, exp_
)
1456 exp
= psi_num_exp_init_unary(PSI_T_LPAREN
, exp_
);
1461 * num_exp: num_exp binary_op_token num_exp
1463 PARSE_TYPED(num_exp
, exp
,
1464 TYPED(num_exp
, lhs_
)
1465 NAMED(binary_op_token
, OP
)
1466 TYPED(num_exp
, rhs_
)) {
1467 exp
= psi_num_exp_init_binary(OP
->type
, lhs_
, rhs_
);
1472 * num_exp: unary_op_token num_exp
1474 PARSE_TYPED(num_exp
, exp
,
1475 NAMED(unary_op_token
, OP
)
1476 TYPED(num_exp
, exp_
)) {
1477 exp
= psi_num_exp_init_unary(OP
->type
, exp_
);
1484 PARSE_TYPED(let_exp
, val
,
1486 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1492 PARSE_TYPED(let_exp
, val
,
1495 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1496 val
->is_reference
= 1;
1502 PARSE_TYPED(let_exp
, val
,
1503 TYPED(let_callback
, cb
)) {
1504 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1510 PARSE_TYPED(let_exp
, val
,
1511 TYPED(let_calloc
, ca
)) {
1512 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1518 PARSE_TYPED(let_exp
, val
,
1520 TYPED(let_calloc
, ca
)) {
1521 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1522 val
->is_reference
= 1;
1528 PARSE_TYPED(let_exp
, val
,
1529 TYPED(let_func
, fn
)) {
1530 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1536 PARSE_TYPED(let_exp
, val
,
1538 TYPED(let_func
, fn
)) {
1539 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1540 val
->is_reference
= 1;
1546 PARSE_TYPED(let_exp
, val
,
1547 TYPED(num_exp
, exp
)) {
1548 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1552 * let_exp: & num_exp
1554 PARSE_TYPED(let_exp
, val
,
1556 TYPED(num_exp
, exp
)) {
1557 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1558 val
->is_reference
= 1;
1562 * let_exp: decl_var = let_exp
1564 PARSE_TYPED(let_exp
, exp
,
1565 TYPED(decl_var
, var_
)
1567 TYPED(let_exp
, val
)) {
1573 * let_stmt: LET let_exp ;
1575 PARSE_TYPED(let_stmt
, let
,
1579 let
= psi_let_stmt_init(val
);
1584 * let_stmt: TEMP decl_var = reference decl_var ;
1586 PARSE_TYPED(let_stmt
, let
,
1588 TYPED(decl_var
, var
)
1591 TYPED(decl_var
, val_
)
1593 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1595 let
->exp
->is_reference
= r
? 1 : 0;
1599 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1601 PARSE_TYPED(let_callback
, cb
,
1603 NAMED(callback_rval
, F
)
1605 TYPED(impl_var
, var
)
1607 TYPED(callback_arg_list
, args_
)
1610 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1616 * let_calloc: CALLOC ( num_exp , num_exp )
1618 PARSE_TYPED(let_calloc
, alloc
,
1621 TYPED(num_exp
, nmemb
)
1623 TYPED(num_exp
, size
)
1625 alloc
= psi_let_calloc_init(nmemb
, size
);
1630 * let_func: let_func_token ( impl_var )
1632 PARSE_TYPED(let_func
, func
,
1633 NAMED(let_func_token
, T
)
1635 TYPED(impl_var
, var
)
1637 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1641 * let_func: let_func_token ( impl_var , let_exps )
1643 PARSE_TYPED(let_func
, func
,
1644 NAMED(let_func_token
, T
)
1646 TYPED(impl_var
, var
)
1648 TYPED(let_exps
, vals
)
1650 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1657 PARSE_TYPED(let_exps
, exps
,
1658 TYPED(let_exp
, exp
)) {
1659 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1663 * let_exps: let_exps , let_exp
1665 PARSE_TYPED(let_exps
, exps
,
1666 TYPED(let_exps
, exps_
)
1668 TYPED(let_exp
, exp
)) {
1669 exps
= psi_plist_add(exps_
, &exp
);
1673 * callback_arg_list: <empty>
1675 PARSE_TYPED(callback_arg_list
, args
, ) {
1680 * callback_arg_list: callback_args
1682 PARSE_TYPED(callback_arg_list
, args
,
1683 TYPED(callback_args
, args_
)) {
1688 * callback_args: set_exp
1690 PARSE_TYPED(callback_args
, args
,
1691 TYPED(set_exp
, val
)) {
1692 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1697 * callback_args: callback_args , set_exp
1699 PARSE_TYPED(callback_args
, args
,
1700 TYPED(callback_args
, args_
)
1702 TYPED(set_exp
, val
)) {
1703 args
= psi_plist_add(args_
, &val
);
1707 * callback_rval: let_func_token
1709 PARSE_NAMED(callback_rval
, rval
,
1710 NAMED(let_func_token
, F
)) {
1715 * callback_rval: VOID
1717 PARSE_NAMED(callback_rval
, rval
,
1724 * set_func: set_func_token ( decl_var )
1726 PARSE_TYPED(set_func
, func
,
1727 NAMED(set_func_token
, T
)
1729 TYPED(decl_var
, var
)
1731 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1736 * set_func: set_func_token ( decl_var , set_exps )
1738 PARSE_TYPED(set_func
, func
,
1739 NAMED(set_func_token
, T
)
1741 TYPED(decl_var
, var
)
1743 TYPED(set_exps
, vals
)
1745 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1751 * set_func: set_func_token ( decl_var , ... )
1753 PARSE_TYPED(set_func
, func
,
1754 NAMED(set_func_token
, T
)
1756 TYPED(decl_var
, var
)
1760 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1762 func
->recursive
= 1;
1768 PARSE_TYPED(set_exp
, val
,
1769 TYPED(set_func
, fn
)) {
1770 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
1776 PARSE_TYPED(set_exp
, val
,
1777 TYPED(num_exp
, num
)) {
1778 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
1784 PARSE_TYPED(set_exps
, exps
,
1785 TYPED(set_exp
, exp
)) {
1786 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1791 * set_exps: set_exps , set_exp
1793 PARSE_TYPED(set_exps
, exps
,
1794 TYPED(set_exps
, exps_
)
1796 TYPED(set_exp
, exp
)) {
1797 exps
= psi_plist_add(exps_
, &exp
);
1801 * set_exp: impl_var = set_exp
1803 PARSE_TYPED(set_exp
, exp
,
1804 TYPED(impl_var
, var_
)
1806 TYPED(set_exp
, val
)) {
1812 * set_stmt: SET set_exp ;
1814 PARSE_TYPED(set_stmt
, set
,
1818 set
= psi_set_stmt_init(exp
);
1823 * return_stmt: RETURN set_exp ;
1825 PARSE_TYPED(return_stmt
, ret
,
1827 TYPED(set_func
, func
)
1829 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
1834 * free_stmt: FREE free_exps ;
1836 PARSE_TYPED(free_stmt
, free
,
1838 TYPED(free_exps
, calls
)
1840 free
= psi_free_stmt_init(calls
);
1845 * free_exps: free_exp
1847 PARSE_TYPED(free_exps
, calls
,
1848 TYPED(free_exp
, call
)) {
1849 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
1854 * free_exps: free_exps , free_exp
1856 PARSE_TYPED(free_exps
, calls
,
1857 TYPED(free_exps
, calls_
)
1859 TYPED(free_exp
, call
)) {
1860 calls
= psi_plist_add(calls_
, &call
);
1864 * free_exp: NAME ( decl_vars )
1866 PARSE_TYPED(free_exp
, call
,
1869 TYPED(decl_vars
, vars
)
1871 call
= psi_free_exp_init(F
->text
, vars
);
1876 * reference: <empty>
1878 PARSE_TYPED(reference
, r
, ) {
1885 PARSE_TYPED(reference
, r
,
1891 * indirection: <empty>
1893 PARSE_TYPED(indirection
, i
, ){
1898 * indirection: pointers
1900 PARSE_TYPED(indirection
, i
,
1901 TYPED(pointers
, p
)) {
1908 PARSE_TYPED(pointers
, p
,
1914 * pointers: pointers *
1916 PARSE_TYPED(pointers
, p
,