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
))
97 TOKEN_CLASS(assert_stmt
, T(PRE_ASSERT
) T(POST_ASSERT
))
100 DEF(%right
, NOT TILDE
.)
104 DEF(%left
, AMPERSAND
.)
105 DEF(%left
, CMP_EQ CMP_NE
.)
106 DEF(%left
, LCHEVR CMP_LE RCHEVR CMP_GE
.)
107 DEF(%left
, LSHIFT RSHIFT
.)
108 DEF(%left
, PLUS MINUS
.)
109 DEF(%left
, ASTERISK SLASH MODULO
.)
111 DEF(%fallback
, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT
.)
113 TOKEN_TYPE(decl_enum
, struct psi_decl_enum
*)
114 TOKEN_DTOR(decl_enum
, psi_decl_enum_free(&$$
);)
115 TOKEN_TYPE(decl_enum_items
, struct psi_plist
*)
116 TOKEN_DTOR(decl_enum_items
, psi_plist_free($$
);)
117 TOKEN_TYPE(decl_enum_item
, struct psi_decl_enum_item
*)
118 TOKEN_DTOR(decl_enum_item
, psi_decl_enum_item_free(&$$
);)
119 TOKEN_TYPE(decl_struct_args_block
, struct psi_plist
*)
120 TOKEN_DTOR(decl_struct_args_block
, psi_plist_free($$
);) /* there was a typo */
121 TOKEN_TYPE(decl_struct_args
, struct psi_plist
*)
122 TOKEN_DTOR(decl_struct_args
, psi_plist_free($$
);)
123 TOKEN_TYPE(decl_struct
, struct psi_decl_struct
*)
124 TOKEN_DTOR(decl_struct
, psi_decl_struct_free(&$$
);)
125 TOKEN_TYPE(align_and_size
, struct psi_layout
)
126 TOKEN_TYPE(decl_union
, struct psi_decl_union
*)
127 TOKEN_DTOR(decl_union
, psi_decl_union_free(&$$
);)
128 TOKEN_TYPE(const_type
, struct psi_const_type
*)
129 TOKEN_DTOR(const_type
, psi_const_type_free(&$$
);)
130 TOKEN_TYPE(constant
, struct psi_const
*)
131 TOKEN_DTOR(constant
, psi_const_free(&$$
);)
132 TOKEN_TYPE(decl_typedef
, struct psi_decl_arg
*)
133 TOKEN_DTOR(decl_typedef
, psi_decl_arg_free(&$$
);)
134 TOKEN_TYPE(decl_typedef_body_ex
, struct psi_decl_arg
*)
135 TOKEN_DTOR(decl_typedef_body_ex
, psi_decl_arg_free(&$$
);)
136 TOKEN_TYPE(decl_typedef_body
, struct psi_decl_arg
*)
137 TOKEN_DTOR(decl_typedef_body
, psi_decl_arg_free(&$$
);)
138 TOKEN_TYPE(decl_typedef_body_fn_args
, struct psi_plist
*)
139 TOKEN_DTOR(decl_typedef_body_fn_args
, psi_plist_free($$
);)
140 TOKEN_TYPE(decl
, struct psi_decl
*)
141 TOKEN_DTOR(decl
, psi_decl_free(&$$
);)
142 TOKEN_TYPE(decl_func
, struct psi_decl_arg
*)
143 TOKEN_DTOR(decl_func
, psi_decl_arg_free(&$$
);)
144 TOKEN_TYPE(decl_abi
, struct psi_decl_abi
*)
145 TOKEN_DTOR(decl_abi
, psi_decl_abi_free(&$$
);)
146 TOKEN_TYPE(decl_var
, struct psi_decl_var
*)
147 TOKEN_DTOR(decl_var
, psi_decl_var_free(&$$
);)
148 TOKEN_TYPE(decl_vars
, struct psi_plist
*)
149 TOKEN_DTOR(decl_vars
, psi_plist_free($$
);)
150 TOKEN_TYPE(decl_arg
, struct psi_decl_arg
*)
151 TOKEN_DTOR(decl_arg
, psi_decl_arg_free(&$$
);)
152 TOKEN_TYPE(decl_args
, struct psi_plist
*)
153 TOKEN_DTOR(decl_args
, psi_plist_free($$
);)
154 TOKEN_TYPE(struct_args
, struct psi_plist
*)
155 TOKEN_DTOR(struct_args
, psi_plist_free($$
);)
156 TOKEN_TYPE(struct_arg
, struct psi_decl_arg
*)
157 TOKEN_DTOR(struct_arg
, psi_decl_arg_free(&$$
);)
158 TOKEN_TYPE(decl_layout
, struct psi_layout
*)
159 TOKEN_DTOR(decl_layout
, psi_layout_free(&$$
);)
160 TOKEN_TYPE(decl_type
, struct psi_decl_type
*)
161 TOKEN_DTOR(decl_type
, psi_decl_type_free(&$$
);)
162 TOKEN_TYPE(const_decl_type
, struct psi_decl_type
*)
163 TOKEN_DTOR(const_decl_type
, psi_decl_type_free(&$$
);)
164 TOKEN_TYPE(impl
, struct psi_impl
*)
165 TOKEN_DTOR(impl
, psi_impl_free(&$$
);)
166 TOKEN_TYPE(impl_func
, struct psi_impl_func
*)
167 TOKEN_DTOR(impl_func
, psi_impl_func_free(&$$
);)
168 TOKEN_TYPE(impl_def_val
, struct psi_impl_def_val
*)
169 TOKEN_DTOR(impl_def_val
, psi_impl_def_val_free(&$$
);)
170 TOKEN_TYPE(impl_var
, struct psi_impl_var
*)
171 TOKEN_DTOR(impl_var
, psi_impl_var_free(&$$
);)
172 TOKEN_TYPE(impl_arg
, struct psi_impl_arg
*)
173 TOKEN_DTOR(impl_arg
, psi_impl_arg_free(&$$
);)
174 TOKEN_TYPE(impl_args
, struct psi_plist
*)
175 TOKEN_DTOR(impl_args
, psi_plist_free($$
);)
176 TOKEN_TYPE(impl_vararg
, struct psi_impl_arg
*)
177 TOKEN_DTOR(impl_vararg
, psi_impl_arg_free(&$$
);)
178 TOKEN_TYPE(impl_stmts
, struct psi_plist
*)
179 TOKEN_DTOR(impl_stmts
, psi_plist_free($$
);)
180 TOKEN_TYPE(impl_stmt
, struct psi_token
**)
181 TOKEN_DTOR(impl_stmt
, psi_impl_stmt_free(&$$
);)
182 TOKEN_TYPE(number
, struct psi_number
*)
183 TOKEN_DTOR(number
, psi_number_free(&$$
);)
184 TOKEN_TYPE(num_exp
, struct psi_num_exp
*)
185 TOKEN_DTOR(num_exp
, psi_num_exp_free(&$$
);)
186 TOKEN_TYPE(let_stmt
, struct psi_let_stmt
*)
187 TOKEN_DTOR(let_stmt
, psi_let_stmt_free(&$$
);)
188 TOKEN_TYPE(let_calloc
, struct psi_let_calloc
*)
189 TOKEN_DTOR(let_calloc
, psi_let_calloc_free(&$$
);)
190 TOKEN_TYPE(let_func
, struct psi_let_func
*)
191 TOKEN_DTOR(let_func
, psi_let_func_free(&$$
);)
192 TOKEN_TYPE(callback_arg_list
, struct psi_plist
*)
193 TOKEN_DTOR(callback_arg_list
, psi_plist_free($$
);)
194 TOKEN_TYPE(callback_args
, struct psi_plist
*)
195 TOKEN_DTOR(callback_args
, psi_plist_free($$
);)
196 TOKEN_TYPE(let_callback
, struct psi_let_callback
*)
197 TOKEN_DTOR(let_callback
, psi_let_callback_free(&$$
);)
198 TOKEN_TYPE(let_exp
, struct psi_let_exp
*)
199 TOKEN_DTOR(let_exp
, psi_let_exp_free(&$$
);)
200 TOKEN_TYPE(let_exps
, struct psi_plist
*)
201 TOKEN_DTOR(let_exps
, psi_plist_free($$
);)
202 TOKEN_TYPE(assert_stmt
, struct psi_assert_stmt
*)
203 TOKEN_DTOR(assert_stmt
, psi_assert_stmt_free(&$$
);)
204 TOKEN_TYPE(set_stmt
, struct psi_set_stmt
*)
205 TOKEN_DTOR(set_stmt
, psi_set_stmt_free(&$$
);)
206 TOKEN_TYPE(set_exp
, struct psi_set_exp
*)
207 TOKEN_DTOR(set_exp
, psi_set_exp_free(&$$
);)
208 TOKEN_TYPE(set_exps
, struct psi_plist
*)
209 TOKEN_DTOR(set_exps
, psi_plist_free($$
);)
210 TOKEN_TYPE(set_func
, struct psi_set_func
*)
211 TOKEN_DTOR(set_func
, psi_set_func_free(&$$
);)
212 TOKEN_TYPE(return_stmt
, struct psi_return_stmt
*)
213 TOKEN_DTOR(return_stmt
, psi_return_stmt_free(&$$
);)
214 TOKEN_TYPE(free_stmt
, struct psi_free_stmt
*)
215 TOKEN_DTOR(free_stmt
, psi_free_stmt_free(&$$
);)
216 TOKEN_TYPE(free_exps
, struct psi_plist
*)
217 TOKEN_DTOR(free_exps
, psi_plist_free($$
);)
218 TOKEN_TYPE(free_exp
, struct psi_free_exp
*)
219 TOKEN_DTOR(free_exp
, psi_free_exp_free(&$$
);)
220 TOKEN_TYPE(impl_type
, struct psi_impl_type
*)
221 TOKEN_DTOR(impl_type
, psi_impl_type_free(&$$
);)
222 TOKEN_TYPE(reference
, bool)
223 TOKEN_TYPE(indirection
, unsigned)
224 TOKEN_TYPE(pointers
, unsigned)
228 PASS(blocks
, blocks block
)
234 * lib: LIB "soname" ;
236 PARSE(block
, NAMED(LIB
, token
) NAMED(QUOTED_STRING
, libname
) TOKEN(EOS
)) {
238 P
->error(PSI_DATA(P
), token
, PSI_WARNING
, "Extra 'lib %s' statement has no effect", libname
->text
);
240 P
->file
.ln
= strndup(libname
->text
+ 1, libname
->size
- 2);
246 PARSE(block
, TYPED(decl
, decl
)) {
248 P
->decls
= psi_plist_init((psi_plist_dtor
) psi_decl_free
);
250 P
->decls
= psi_plist_add(P
->decls
, &decl
);
253 PARSE(block
, TYPED(impl
, impl
)) {
255 P
->impls
= psi_plist_init((psi_plist_dtor
) psi_impl_free
);
257 P
->impls
= psi_plist_add(P
->impls
, &impl
);
260 PARSE(block
, TYPED(decl_typedef
, def
)) {
262 P
->types
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
264 P
->types
= psi_plist_add(P
->types
, &def
);
266 switch (def
->type
->type
) {
268 if (def
->type
->real
.strct
) {
270 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
272 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
276 if (def
->type
->real
.unn
) {
278 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
280 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
284 if (def
->type
->real
.enm
) {
286 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
288 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
294 PARSE(block
, TYPED(constant
, constant
)) {
296 P
->consts
= psi_plist_init((psi_plist_dtor
) psi_const_free
);
298 P
->consts
= psi_plist_add(P
->consts
, &constant
);
301 PARSE(block
, TYPED(decl_struct
, strct
)) {
303 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
305 P
->structs
= psi_plist_add(P
->structs
, &strct
);
308 PARSE(block
, TYPED(decl_union
, u
)) {
310 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
312 P
->unions
= psi_plist_add(P
->unions
, &u
);
315 PARSE(block
, TYPED(decl_enum
, e
)) {
317 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
319 P
->enums
= psi_plist_add(P
->enums
, &e
);
323 * optional_name: <empty>
325 PARSE_NAMED(optional_name
, n
, ) {
330 * optional_name: NAME
332 PARSE_NAMED(optional_name
, n
,
338 * align_and_size: <empty>
340 PARSE_TYPED(align_and_size
, as
, ) {
346 * align_and_size: :: ( NUMBER , NUMBER )
348 PARSE_TYPED(align_and_size
, as
,
356 as
.pos
= atol(A
->text
);
357 as
.len
= atol(S
->text
);
363 * enum_name: ENUM optional_name
365 PARSE_NAMED(enum_name
, n
,
367 NAMED(optional_name
, N
)) {
374 psi_token_hash(E
, digest
);
375 n
= psi_token_translit(psi_token_append(E
, 1, digest
), " ", "@");
380 * struct_name: STRUCT optional_name
382 PARSE_NAMED(struct_name
, n
,
384 NAMED(optional_name
, N
)) {
391 psi_token_hash(S
, digest
);
392 n
= psi_token_translit(psi_token_append(S
, 1, digest
), " ", "@");
397 * union_name: UNION optional_name
399 PARSE_NAMED(union_name
, n
,
401 NAMED(optional_name
, N
)) {
408 psi_token_hash(U
, digest
);
409 n
= psi_token_translit(psi_token_append(U
, 1, digest
), " ", "@");
414 * decl_enum: enum_name { items }
416 PARSE_TYPED(decl_enum
, e
,
419 TYPED(decl_enum_items
, list
)
421 e
= psi_decl_enum_init(N
->text
, list
);
426 * decl_enum_items: item
428 PARSE_TYPED(decl_enum_items
, l
,
429 TYPED(decl_enum_item
, i
)) {
430 l
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_enum_item_free
),
435 * decl_enum_items: items , item
437 PARSE_TYPED(decl_enum_items
, l
,
438 TYPED(decl_enum_items
, l_
)
440 TYPED(decl_enum_item
, i
)) {
441 l
= psi_plist_add(l_
, &i
);
445 * decl_enum_item: name = num_exp
447 PARSE_TYPED(decl_enum_item
, i
,
450 TYPED(num_exp
, num
)) {
451 i
= psi_decl_enum_item_init(N
->text
, num
);
456 * decl_enum_item: name
458 PARSE_TYPED(decl_enum_item
, i
,
460 i
= psi_decl_enum_item_init(N
->text
, NULL
);
466 * decl_struct_args_block: { args }
468 PARSE_TYPED(decl_struct_args_block
, args_
,
470 TYPED(struct_args
, args
)
476 * decl_struct_args: args_block
478 PARSE_TYPED(decl_struct_args
, args_
,
479 TYPED(decl_struct_args_block
, args
)) {
484 * decl_struct_args: ;
486 PARSE_TYPED(decl_struct_args
, args_
,
488 args_
= psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
);
492 * decl_struct: STRUCT name align_and_size struct_args
494 PARSE_TYPED(decl_struct
, strct
,
497 TYPED(align_and_size
, as
)
498 TYPED(decl_struct_args
, args
)) {
499 strct
= psi_decl_struct_init(N
->text
, args
);
500 strct
->align
= as
.pos
;
501 strct
->size
= as
.len
;
506 * decl_union: UNION name align_and_size struct_args
508 PARSE_TYPED(decl_union
, u
,
511 TYPED(align_and_size
, as
)
512 TYPED(decl_struct_args
, args
)) {
513 u
= psi_decl_union_init(N
->text
, args
);
520 * const_type: const_type_token
522 PARSE_TYPED(const_type
, type_
,
523 NAMED(const_type_token
, T
)) {
524 type_
= psi_const_type_init(T
->type
, T
->text
);
529 * constant: CONST const_type NSNAME = def_val ;
531 PARSE_TYPED(constant
, constant
,
533 TYPED(const_type
, type
)
536 TYPED(impl_def_val
, val
)
538 constant
= psi_const_init(type
, T
->text
, val
);
543 * decl_typdef: TYPEDEF typedef_body ;
545 PARSE_TYPED(decl_typedef
, def
,
547 TYPED(decl_typedef_body
, def_
)
554 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
556 PARSE_TYPED(decl_typedef_body_ex
, def
,
557 NAMED(struct_name
, N
)
558 TYPED(align_and_size
, as
)
559 TYPED(decl_struct_args_block
, args
)
560 TYPED(decl_var
, var
)) {
561 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT
, N
->text
), var
);
562 def
->type
->token
= psi_token_copy(N
);
563 def
->type
->real
.strct
= psi_decl_struct_init(N
->text
, args
);
564 def
->type
->real
.strct
->token
= N
;
565 def
->type
->real
.strct
->align
= as
.pos
;
566 def
->type
->real
.strct
->size
= as
.len
;
570 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
572 PARSE_TYPED(decl_typedef_body_ex
, def
,
574 TYPED(align_and_size
, as
)
575 TYPED(decl_struct_args_block
, args
)
576 TYPED(decl_var
, var
)) {
577 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION
, N
->text
), var
);
578 def
->type
->token
= psi_token_copy(N
);
579 def
->type
->real
.unn
= psi_decl_union_init(N
->text
, args
);
580 def
->type
->real
.unn
->token
= N
;
581 def
->type
->real
.unn
->align
= as
.pos
;
582 def
->type
->real
.unn
->size
= as
.len
;
586 * decl_typedef_body_ex: decl_enum NAME
588 PARSE_TYPED(decl_typedef_body_ex
, def
,
590 NAMED(NAME
, ALIAS
)) {
591 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM
, e
->name
), psi_decl_var_init(ALIAS
->text
, 0, 0));
592 def
->var
->token
= ALIAS
;
593 def
->type
->token
= psi_token_copy(e
->token
);
594 def
->type
->real
.enm
= e
;
598 * decl_typedef_body: decl_typedef_body_ex
600 PARSE_TYPED(decl_typedef_body
, def
,
601 TYPED(decl_typedef_body_ex
, def_
)) {
606 * decl_typedef_body_fn_args: ( decl_args )
608 PARSE_TYPED(decl_typedef_body_fn_args
, args
,
610 TYPED(decl_args
, args_
)
616 * decl_typedef_body: decl_func decl_typedef_body_fn_args
618 PARSE_TYPED(decl_typedef_body
, def
,
619 TYPED(decl_func
, func_
)
620 TYPED(decl_typedef_body_fn_args
, args
)) {
621 def
= psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
), psi_decl_var_copy(func_
->var
));
622 def
->type
->token
= psi_token_copy(func_
->token
);
623 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
627 * decl_typedef_body: decl_arg
629 PARSE_TYPED(decl_typedef_body
, def
,
630 TYPED(decl_arg
, arg
)) {
635 * decl: decl_abi decl_func ( decl_args ) ;
637 PARSE_TYPED(decl
, decl
,
639 TYPED(decl_func
, func
)
641 TYPED(decl_args
, args
)
644 decl
= psi_decl_init(abi
, func
, args
);
648 * decl: decl_abi decl_func ( decl_args , ... ) ;
650 PARSE_TYPED(decl
, decl
,
652 TYPED(decl_func
, func
)
654 TYPED(decl_args
, args
)
659 decl
= psi_decl_init(abi
, func
, args
);
664 * decl_func: decl_arg
666 PARSE_TYPED(decl_func
, func
,
667 TYPED(decl_arg
, arg
)) {
671 /* special case for void functions */
673 * decl_func: VOID NAME
675 PARSE_TYPED(decl_func
, func
,
678 func
= psi_decl_arg_init(
679 psi_decl_type_init(T
->type
, T
->text
),
680 psi_decl_var_init(N
->text
, 0, 0)
682 func
->type
->token
= T
;
683 func
->var
->token
= N
;
688 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
690 PARSE_TYPED(decl_typedef_body
, def
,
692 TYPED(indirection
, decl_i
)
694 TYPED(indirection
, type_i
)
697 TYPED(decl_typedef_body_fn_args
, args
)) {
698 struct psi_decl_arg
*func_
= psi_decl_arg_init(
699 psi_decl_type_init(T
->type
, T
->text
),
700 psi_decl_var_init(N
->text
, decl_i
, 0)
702 func_
->type
->token
= T
;
703 func_
->var
->token
= N
;
706 def
= psi_decl_arg_init(
707 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
708 psi_decl_var_copy(func_
->var
)
710 def
->var
->pointer_level
= type_i
;
711 def
->type
->token
= psi_token_copy(func_
->token
);
712 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
716 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
718 PARSE_TYPED(decl_typedef_body
, def
,
721 TYPED(pointers
, decl_i
)
723 TYPED(indirection
, type_i
)
726 TYPED(decl_typedef_body_fn_args
, args
)) {
727 struct psi_decl_arg
*func_
= psi_decl_arg_init(
728 psi_decl_type_init(T
->type
, T
->text
),
729 psi_decl_var_init(N
->text
, decl_i
, 0)
731 func_
->type
->token
= T
;
732 func_
->var
->token
= N
;
735 def
= psi_decl_arg_init(
736 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
737 psi_decl_var_copy(func_
->var
)
739 def
->var
->pointer_level
= type_i
;
740 def
->type
->token
= psi_token_copy(func_
->token
);
741 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
747 PARSE_TYPED(decl_abi
, abi
,
749 abi
= psi_decl_abi_init(T
->text
);
754 * decl_var_array_size: <empty>
756 PARSE_NAMED(decl_var_array_size
, as
, ) {
761 * decl_var_array_size: [ NUMBER ]
763 PARSE_NAMED(decl_var_array_size
, as
,
771 * decl_var: NAME decl_var_array_size
773 PARSE_TYPED(decl_var
, var
,
775 NAMED(decl_var_array_size
, as
)) {
776 var
= psi_decl_var_init(T
->text
, 0, as
?atol(as
->text
):0);
784 * decl_var: pointers NAME
786 PARSE_TYPED(decl_var
, var
,
789 NAMED(decl_var_array_size
, as
)) {
790 var
= psi_decl_var_init(T
->text
, p
+!!as
, as
?atol(as
->text
):0);
798 * decl_vars: decl_var
800 PARSE_TYPED(decl_vars
, vars
,
801 TYPED(decl_var
, var
)) {
802 vars
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_var_free
),
807 * decl_vars: decl_vars , decl_var
809 PARSE_TYPED(decl_vars
, vars
,
810 TYPED(decl_vars
, vars_
)
812 TYPED(decl_var
, var
)) {
813 vars
= psi_plist_add(vars_
, &var
);
817 * decl_arg: const_decl_type decl_var
819 PARSE_TYPED(decl_arg
, arg_
,
820 TYPED(const_decl_type
, type
)
821 TYPED(decl_var
, var
)) {
822 arg_
= psi_decl_arg_init(type
, var
);
826 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
828 PARSE_TYPED(decl_typedef_body
, def
,
829 TYPED(const_decl_type
, type_
)
830 TYPED(indirection
, decl_i
)
832 TYPED(indirection
, type_i
)
835 TYPED(decl_typedef_body_fn_args
, args
)) {
836 struct psi_decl_arg
*func_
= psi_decl_arg_init(
838 psi_decl_var_init(N
->text
, decl_i
, 0)
840 func_
->var
->token
= N
;
843 def
= psi_decl_arg_init(
844 psi_decl_type_init(PSI_T_FUNCTION
, func_
->var
->name
),
845 psi_decl_var_copy(func_
->var
)
847 def
->var
->pointer_level
= type_i
;
848 def
->type
->token
= psi_token_copy(func_
->token
);
849 def
->type
->real
.func
= psi_decl_init(psi_decl_abi_init("default"), func_
, args
);
852 /* void pointers need a specific rule */
854 * decl_arg: VOID pointers NAME
856 PARSE_TYPED(decl_arg
, arg_
,
860 arg_
= psi_decl_arg_init(
861 psi_decl_type_init(T
->type
, T
->text
),
862 psi_decl_var_init(N
->text
, p
, 0)
864 arg_
->type
->token
= T
;
865 arg_
->var
->token
= N
;
870 * decl_args: CONST VOID pointers NAME
872 PARSE_TYPED(decl_arg
, arg_
,
877 arg_
= psi_decl_arg_init(
878 psi_decl_type_init(T
->type
, T
->text
),
879 psi_decl_var_init(N
->text
, p
, 0)
881 arg_
->type
->token
= T
;
882 arg_
->var
->token
= N
;
889 PARSE_TYPED(decl_args
, args
, ) {
896 PARSE_TYPED(decl_args
, args
,
902 * decl_args: decl_arg
904 PARSE_TYPED(decl_args
, args
,
905 TYPED(decl_arg
, arg
)) {
906 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
911 * decl_args: decl_args , decl_arg
913 PARSE_TYPED(decl_args
, args
,
914 TYPED(decl_args
, args_
)
916 TYPED(decl_arg
, arg
)) {
917 args
= psi_plist_add(args_
, &arg
);
921 * struct_args: struct_arg
923 PARSE_TYPED(struct_args
, args
,
924 TYPED(struct_arg
, arg
)) {
925 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_decl_arg_free
),
930 * struct_args: struct_args , struct_arg
932 PARSE_TYPED(struct_args
, args
,
933 TYPED(struct_args
, args_
)
934 TYPED(struct_arg
, arg
)) {
935 args
= psi_plist_add(args_
, &arg
);
939 * struct_arg: decl_typedef_body_ex ;
941 PARSE_TYPED(struct_arg
, arg_
,
942 TYPED(decl_typedef_body_ex
, def
)
945 switch (def
->type
->type
) {
947 if (def
->type
->real
.strct
) {
949 P
->structs
= psi_plist_init((psi_plist_dtor
) psi_decl_struct_free
);
951 P
->structs
= psi_plist_add(P
->structs
, &def
->type
->real
.strct
);
955 if (def
->type
->real
.unn
) {
957 P
->unions
= psi_plist_init((psi_plist_dtor
) psi_decl_union_free
);
959 P
->unions
= psi_plist_add(P
->unions
, &def
->type
->real
.unn
);
963 if (def
->type
->real
.enm
) {
965 P
->enums
= psi_plist_init((psi_plist_dtor
) psi_decl_enum_free
);
967 P
->enums
= psi_plist_add(P
->enums
, &def
->type
->real
.enm
);
974 * struct_arg: decl_arg decl_layout ;
976 PARSE_TYPED(struct_arg
, arg
,
977 TYPED(decl_arg
, arg_
)
978 TYPED(decl_layout
, layout_
)
980 arg_
->layout
= layout_
;
985 * decl_layout: <empty>
987 PARSE_TYPED(decl_layout
, layout
, ) {
992 * decl_layout: :: ( NUMBER , NUMBER )
994 PARSE_TYPED(decl_layout
, layout
,
1002 layout
= psi_layout_init(atol(POS
->text
), atol(SIZ
->text
));
1007 /* un/signed, urgh */
1009 * decl_scalar_type: CHAR
1011 PARSE_NAMED(decl_scalar_type
, type_
,
1017 * decl_scalar_type: SHORT decl_scalar_type_short
1019 PARSE_NAMED(decl_scalar_type
, type_
,
1021 NAMED(decl_scalar_type_short
, s
)) {
1023 type_
= psi_token_cat(2, S
, s
);
1032 * decl_scalar_type_short: <empty>
1034 PARSE_NAMED(decl_scalar_type_short
, s
, ) {
1039 * decl_scalar_type_short: INT
1041 PARSE_NAMED(decl_scalar_type_short
, s
,
1047 * decl_sclara_type: INT
1049 PARSE_NAMED(decl_scalar_type
, type_
,
1055 * decl_scalar_type: LONG decl_scalar_type_long
1057 PARSE_NAMED(decl_scalar_type
, type_
,
1059 NAMED(decl_scalar_type_long
, l
)) {
1061 type_
= psi_token_cat(2, L
, l
);
1070 * decl_scalar_type_long: <empty>
1072 PARSE_NAMED(decl_scalar_type_long
, l
, ) {
1077 * decl_scalar_type_long: DOUBLE
1079 PARSE_NAMED(decl_scalar_type_long
, l
,
1085 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1087 PARSE_NAMED(decl_scalar_type_long
, l
,
1089 NAMED(decl_scalar_type_long_long
, ll
)) {
1091 l
= psi_token_cat(2, L
, ll
);
1100 * decl_scalar_type_long_long: <empty>
1102 PARSE_NAMED(decl_scalar_type_long_long
, ll
, ) {
1107 * decl_scalar_type_long_long: INT
1109 PARSE_NAMED(decl_scalar_type_long_long
, ll
,
1115 * decl_type: UNSIGNED decl_scalar_type
1117 PARSE_TYPED(decl_type
, type_
,
1119 NAMED(decl_scalar_type
, N
)) {
1120 struct psi_token
*T
= psi_token_cat(2, U
, N
);
1121 type_
= psi_decl_type_init(T
->type
, T
->text
);
1128 * decl_type: SIGNED decl_scalar_type
1130 PARSE_TYPED(decl_type
, type_
,
1132 NAMED(decl_scalar_type
, N
)) {
1133 struct psi_token
*T
= psi_token_cat(2, S
, N
);
1134 type_
= psi_decl_type_init(T
->type
, T
->text
);
1141 * decl_type: UNSIGNED
1143 PARSE_TYPED(decl_type
, type_
,
1144 NAMED(UNSIGNED
, U
)) {
1145 type_
= psi_decl_type_init(PSI_T_NAME
, U
->text
);
1152 PARSE_TYPED(decl_type
, type_
,
1154 type_
= psi_decl_type_init(PSI_T_NAME
, S
->text
);
1159 * decl_type: decl_scalar_type
1161 PARSE_TYPED(decl_type
, type_
,
1162 NAMED(decl_scalar_type
, N
)) {
1163 type_
= psi_decl_type_init(N
->type
, N
->text
);
1169 * decl_type: STRUCT NAME
1171 PARSE_TYPED(decl_type
, type_
,
1174 type_
= psi_decl_type_init(S
->type
, T
->text
);
1180 * decl_type: UNION NAME
1182 PARSE_TYPED(decl_type
, type_
,
1185 type_
= psi_decl_type_init(U
->type
, T
->text
);
1191 * decl_type: ENUM NAME
1193 PARSE_TYPED(decl_type
, type_
,
1196 type_
= psi_decl_type_init(E
->type
, T
->text
);
1202 * decl_type: decl_type_token
1204 PARSE_TYPED(decl_type
, type_
,
1205 NAMED(decl_type_token
, T
)) {
1206 type_
= psi_decl_type_init(T
->type
, T
->text
);
1211 * const_decl_type: decl_type
1213 PARSE_TYPED(const_decl_type
, type
,
1214 TYPED(decl_type
, type_
)) {
1219 * const_decl_type: CONST decl_type
1221 PARSE_TYPED(const_decl_type
, type
,
1223 TYPED(decl_type
, type_
)) {
1228 * impl: impl_func { impl_stmts }
1230 PARSE_TYPED(impl
, impl
,
1231 TYPED(impl_func
, func
)
1233 TYPED(impl_stmts
, stmts
)
1235 impl
= psi_impl_init(func
, stmts
);
1239 * impl: STATIC impl_func { impl_stmts }
1241 PARSE_TYPED(impl
, impl
,
1243 TYPED(impl_func
, func
)
1245 TYPED(impl_stmts
, stmts
)
1247 func
->static_memory
= 1;
1248 impl
= psi_impl_init(func
, stmts
);
1252 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1254 PARSE_TYPED(impl_func
, func
,
1261 TYPED(impl_type
, type
)) {
1262 func
= psi_impl_func_init(NAME
->text
, NULL
, type
);
1264 func
->return_reference
= r
;
1268 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1270 PARSE_TYPED(impl_func
, func
,
1275 TYPED(impl_args
, args
)
1278 TYPED(impl_type
, type
)) {
1279 func
= psi_impl_func_init(NAME
->text
, args
, type
);
1281 func
->return_reference
= r
;
1285 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1287 PARSE_TYPED(impl_func
, func
,
1289 TYPED(reference
, func_r
)
1292 TYPED(impl_args
, args
)
1294 TYPED(impl_type
, va_type
)
1295 TYPED(reference
, va_r
)
1297 NAMED(DOLLAR_NAME
, T
)
1300 TYPED(impl_type
, func_type
)) {
1301 func
= psi_impl_func_init(NAME
->text
, args
, func_type
);
1303 func
->return_reference
= func_r
;
1304 func
->vararg
= psi_impl_arg_init(va_type
, psi_impl_var_init(T
->text
, va_r
), NULL
);
1309 * impl_def_val: impl_def_val_token
1311 PARSE_TYPED(impl_def_val
, def
,
1312 NAMED(impl_def_val_token
, T
)) {
1313 def
= psi_impl_def_val_init(T
->type
, T
->text
);
1318 * impl_var: reference DOLLAR_NAME
1320 PARSE_TYPED(impl_var
, var
,
1322 NAMED(DOLLAR_NAME
, T
)) {
1323 var
= psi_impl_var_init(T
->text
, r
);
1328 * impl_type: impl_type_token
1330 PARSE_TYPED(impl_type
, type_
,
1331 NAMED(impl_type_token
, T
)) {
1332 type_
= psi_impl_type_init(T
->type
, T
->text
);
1337 * impl_arg: impl_type impl_var
1339 PARSE_TYPED(impl_arg
, arg
,
1340 TYPED(impl_type
, type
)
1341 TYPED(impl_var
, var
)) {
1342 arg
= psi_impl_arg_init(type
, var
, NULL
);
1346 * impl_arg: impl_type impl_var = impl_def_val
1348 PARSE_TYPED(impl_arg
, arg
,
1349 TYPED(impl_type
, type
)
1350 TYPED(impl_var
, var
)
1352 TYPED(impl_def_val
, def
)) {
1353 arg
= psi_impl_arg_init(type
, var
, def
);
1357 * impl_args: impl_arg
1359 PARSE_TYPED(impl_args
, args
,
1360 TYPED(impl_arg
, arg
)) {
1361 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_arg_free
),
1366 * impl_args: impl_args , impl_arg
1368 PARSE_TYPED(impl_args
, args
,
1369 TYPED(impl_args
, args_
)
1371 TYPED(impl_arg
, arg
)) {
1372 args
= psi_plist_add(args_
, &arg
);
1376 * impl_stmts: impl_stmt
1378 PARSE_TYPED(impl_stmts
, stmts
,
1379 TYPED(impl_stmt
, stmt
)) {
1380 stmts
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_impl_stmt_free
),
1385 * impl_stmts: impl_stmts , impl_stmt
1387 PARSE_TYPED(impl_stmts
, stmts
,
1388 TYPED(impl_stmts
, stmts_
)
1389 TYPED(impl_stmt
, stmt
)) {
1390 stmts
= psi_plist_add(stmts_
, &stmt
);
1394 * impl_stmt: return_stmt
1396 PARSE_TYPED(impl_stmt
, i
,
1397 TYPED(return_stmt
, r
)) {
1398 i
= (struct psi_token
**) r
;
1402 * impl_stmt: let_stmt
1404 PARSE_TYPED(impl_stmt
, i
,
1405 TYPED(let_stmt
, l
)) {
1406 i
= (struct psi_token
**) l
;
1410 * impl_stmt: set_stmt
1412 PARSE_TYPED(impl_stmt
, i
,
1413 TYPED(set_stmt
, s
)) {
1414 i
= (struct psi_token
**) s
;
1418 * impl_stmt: assert_stmt
1420 PARSE_TYPED(impl_stmt
, i
,
1421 TYPED(assert_stmt
, s
)) {
1422 i
= (struct psi_token
**) s
;
1426 * impl_stmt: free_stmt
1428 PARSE_TYPED(impl_stmt
, i
,
1429 TYPED(free_stmt
, f
)) {
1430 i
= (struct psi_token
**) f
;
1434 * number: number_token
1436 PARSE_TYPED(number
, exp
,
1437 NAMED(number_token
, tok
)) {
1438 exp
= psi_number_init(tok
->type
, tok
->text
);
1445 PARSE_TYPED(number
, exp
,
1446 TYPED(decl_var
, var
)) {
1447 exp
= psi_number_init(PSI_T_NAME
, var
);
1448 exp
->token
= psi_token_copy(var
->token
);
1454 PARSE_TYPED(num_exp
, exp
,
1455 TYPED(number
, num
)) {
1456 exp
= psi_num_exp_init_num(num
);
1457 exp
->token
= psi_token_copy(num
->token
);
1461 * num_exp: ( num_exp )
1463 PARSE_TYPED(num_exp
, exp
,
1465 TYPED(num_exp
, exp_
)
1467 exp
= psi_num_exp_init_unary(PSI_T_LPAREN
, exp_
);
1472 * num_exp: num_exp binary_op_token num_exp
1474 PARSE_TYPED(num_exp
, exp
,
1475 TYPED(num_exp
, lhs_
)
1476 NAMED(binary_op_token
, OP
)
1477 TYPED(num_exp
, rhs_
)) {
1478 exp
= psi_num_exp_init_binary(OP
->type
, lhs_
, rhs_
);
1483 * num_exp: unary_op_token num_exp
1485 PARSE_TYPED(num_exp
, exp
,
1486 NAMED(unary_op_token
, OP
)
1487 TYPED(num_exp
, exp_
)) {
1488 exp
= psi_num_exp_init_unary(OP
->type
, exp_
);
1495 PARSE_TYPED(let_exp
, val
,
1497 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1503 PARSE_TYPED(let_exp
, val
,
1506 val
= psi_let_exp_init(PSI_LET_NULL
, NULL
);
1507 val
->is_reference
= 1;
1513 PARSE_TYPED(let_exp
, val
,
1514 TYPED(let_callback
, cb
)) {
1515 val
= psi_let_exp_init(PSI_LET_CALLBACK
, cb
);
1521 PARSE_TYPED(let_exp
, val
,
1522 TYPED(let_calloc
, ca
)) {
1523 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1529 PARSE_TYPED(let_exp
, val
,
1531 TYPED(let_calloc
, ca
)) {
1532 val
= psi_let_exp_init(PSI_LET_CALLOC
, ca
);
1533 val
->is_reference
= 1;
1539 PARSE_TYPED(let_exp
, val
,
1540 TYPED(let_func
, fn
)) {
1541 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1547 PARSE_TYPED(let_exp
, val
,
1549 TYPED(let_func
, fn
)) {
1550 val
= psi_let_exp_init_ex(NULL
, PSI_LET_FUNC
, fn
);
1551 val
->is_reference
= 1;
1557 PARSE_TYPED(let_exp
, val
,
1558 TYPED(num_exp
, exp
)) {
1559 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1563 * let_exp: & num_exp
1565 PARSE_TYPED(let_exp
, val
,
1567 TYPED(num_exp
, exp
)) {
1568 val
= psi_let_exp_init_ex(NULL
, PSI_LET_NUMEXP
, exp
);
1569 val
->is_reference
= 1;
1573 * let_exp: decl_var = let_exp
1575 PARSE_TYPED(let_exp
, exp
,
1576 TYPED(decl_var
, var_
)
1578 TYPED(let_exp
, val
)) {
1584 * let_stmt: LET let_exp ;
1586 PARSE_TYPED(let_stmt
, let
,
1590 let
= psi_let_stmt_init(val
);
1595 * let_stmt: TEMP decl_var = reference decl_var ;
1597 PARSE_TYPED(let_stmt
, let
,
1599 TYPED(decl_var
, var
)
1602 TYPED(decl_var
, val_
)
1604 let
= psi_let_stmt_init(psi_let_exp_init_ex(var
, PSI_LET_TMP
, val_
));
1606 let
->exp
->is_reference
= r
? 1 : 0;
1610 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1612 PARSE_TYPED(let_callback
, cb
,
1614 NAMED(callback_rval
, F
)
1616 TYPED(impl_var
, var
)
1618 TYPED(callback_arg_list
, args_
)
1621 cb
= psi_let_callback_init(psi_let_func_init(F
->type
, F
->text
, var
), args_
);
1627 * let_calloc: CALLOC ( num_exp , num_exp )
1629 PARSE_TYPED(let_calloc
, alloc
,
1632 TYPED(num_exp
, nmemb
)
1634 TYPED(num_exp
, size
)
1636 alloc
= psi_let_calloc_init(nmemb
, size
);
1641 * let_func: let_func_token ( impl_var )
1643 PARSE_TYPED(let_func
, func
,
1644 NAMED(let_func_token
, T
)
1646 TYPED(impl_var
, var
)
1648 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1652 * let_func: let_func_token ( impl_var , let_exps )
1654 PARSE_TYPED(let_func
, func
,
1655 NAMED(let_func_token
, T
)
1657 TYPED(impl_var
, var
)
1659 TYPED(let_exps
, vals
)
1661 func
= psi_let_func_init(T
->type
, T
->text
, var
);
1668 PARSE_TYPED(let_exps
, exps
,
1669 TYPED(let_exp
, exp
)) {
1670 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_let_exp_free
),
1674 * let_exps: let_exps , let_exp
1676 PARSE_TYPED(let_exps
, exps
,
1677 TYPED(let_exps
, exps_
)
1679 TYPED(let_exp
, exp
)) {
1680 exps
= psi_plist_add(exps_
, &exp
);
1684 * callback_arg_list: <empty>
1686 PARSE_TYPED(callback_arg_list
, args
, ) {
1691 * callback_arg_list: callback_args
1693 PARSE_TYPED(callback_arg_list
, args
,
1694 TYPED(callback_args
, args_
)) {
1699 * callback_args: set_exp
1701 PARSE_TYPED(callback_args
, args
,
1702 TYPED(set_exp
, val
)) {
1703 args
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1708 * callback_args: callback_args , set_exp
1710 PARSE_TYPED(callback_args
, args
,
1711 TYPED(callback_args
, args_
)
1713 TYPED(set_exp
, val
)) {
1714 args
= psi_plist_add(args_
, &val
);
1718 * callback_rval: let_func_token
1720 PARSE_NAMED(callback_rval
, rval
,
1721 NAMED(let_func_token
, F
)) {
1726 * callback_rval: VOID
1728 PARSE_NAMED(callback_rval
, rval
,
1735 * set_func: set_func_token ( decl_var )
1737 PARSE_TYPED(set_func
, func
,
1738 NAMED(set_func_token
, T
)
1740 TYPED(decl_var
, var
)
1742 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1747 * set_func: set_func_token ( decl_var , set_exps )
1749 PARSE_TYPED(set_func
, func
,
1750 NAMED(set_func_token
, T
)
1752 TYPED(decl_var
, var
)
1754 TYPED(set_exps
, vals
)
1756 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1762 * set_func: set_func_token ( decl_var , ... )
1764 PARSE_TYPED(set_func
, func
,
1765 NAMED(set_func_token
, T
)
1767 TYPED(decl_var
, var
)
1771 func
= psi_set_func_init(T
->type
, T
->text
, var
);
1773 func
->recursive
= 1;
1779 PARSE_TYPED(set_exp
, val
,
1780 TYPED(set_func
, fn
)) {
1781 val
= psi_set_exp_init(PSI_SET_FUNC
, fn
);
1787 PARSE_TYPED(set_exp
, val
,
1788 TYPED(num_exp
, num
)) {
1789 val
= psi_set_exp_init(PSI_SET_NUMEXP
, num
);
1795 PARSE_TYPED(set_exps
, exps
,
1796 TYPED(set_exp
, exp
)) {
1797 exps
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_set_exp_free
),
1802 * set_exps: set_exps , set_exp
1804 PARSE_TYPED(set_exps
, exps
,
1805 TYPED(set_exps
, exps_
)
1807 TYPED(set_exp
, exp
)) {
1808 exps
= psi_plist_add(exps_
, &exp
);
1812 * set_exp: impl_var = set_exp
1814 PARSE_TYPED(set_exp
, exp
,
1815 TYPED(impl_var
, var_
)
1817 TYPED(set_exp
, val
)) {
1823 * set_stmt: SET set_exp ;
1825 PARSE_TYPED(set_stmt
, set
,
1829 set
= psi_set_stmt_init(exp
);
1834 * return_stmt: RETURN set_exp ;
1836 PARSE_TYPED(return_stmt
, ret
,
1838 TYPED(set_func
, func
)
1840 ret
= psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC
, func
));
1845 * free_stmt: FREE free_exps ;
1847 PARSE_TYPED(free_stmt
, free
,
1849 TYPED(free_exps
, calls
)
1851 free
= psi_free_stmt_init(calls
);
1856 * free_exps: free_exp
1858 PARSE_TYPED(free_exps
, calls
,
1859 TYPED(free_exp
, call
)) {
1860 calls
= psi_plist_add(psi_plist_init((psi_plist_dtor
) psi_free_exp_free
),
1865 * free_exps: free_exps , free_exp
1867 PARSE_TYPED(free_exps
, calls
,
1868 TYPED(free_exps
, calls_
)
1870 TYPED(free_exp
, call
)) {
1871 calls
= psi_plist_add(calls_
, &call
);
1875 * free_exp: NAME ( decl_vars )
1877 PARSE_TYPED(free_exp
, call
,
1880 TYPED(decl_vars
, vars
)
1882 call
= psi_free_exp_init(F
->text
, vars
);
1887 * assert_stmt: assert_stmt_token num_exp ;
1889 PARSE_TYPED(assert_stmt
, ass
,
1890 NAMED(assert_stmt_token
, T
)
1893 ass
= psi_assert_stmt_init(T
->type
, exp
);
1898 * reference: <empty>
1900 PARSE_TYPED(reference
, r
, ) {
1907 PARSE_TYPED(reference
, r
,
1913 * indirection: <empty>
1915 PARSE_TYPED(indirection
, i
, ){
1920 * indirection: pointers
1922 PARSE_TYPED(indirection
, i
,
1923 TYPED(pointers
, p
)) {
1930 PARSE_TYPED(pointers
, p
,
1936 * pointers: pointers *
1938 PARSE_TYPED(pointers
, p
,