projects / m6w6 / ext-psi / blob
? search:


ed1455a76a95c4c0cb367236256ada0b14e405e5
[m6w6/ext-psi] / src / parser_proc_def.h
1 /*******************************************************************************
2 Copyright (c) 2016, Michael Wallner <mike@php.net>.
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7
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.
13
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 *******************************************************************************/
25
26 #include "parser_def.h"
27
28 DEF(%token_prefix, CONCAT1(TOKEN_PREFIX,_))
29 DEF(%token_type, {TOKEN_STRUCT})
30 DEF(%token_destructor, {free($$);})
31 DEF(%default_destructor, {(void)P;})
32 DEF(%extra_argument, {struct psi_parser *P})
33
34 /* TOKEN is defined inside syntax_error */
35 DEF(%syntax_error, {
36 ++P->errors;
37 if (TOKEN) {
38 psi_error(PSI_WARNING, TOKEN->file, TOKEN->line, "PSI syntax error: Unexpected token '%s' at pos %u", TOKEN->text, TOKEN->col);
39 } else {
40 psi_error(PSI_WARNING, P->file.fn, P->line, "PSI syntax error: Unexpected end of input");
41 }
42 })
43
44 TOKEN_CLASS(const_type, T(BOOL) T(INT) T(FLOAT) T(STRING))
45 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))
46 TOKEN_CLASS(impl_def_val, T(NULL) T(NUMBER) T(TRUE) T(FALSE) T(QUOTED_STRING))
47 TOKEN_CLASS(number, T(NUMBER) T(NSNAME))
48 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))
49 TOKEN_CLASS(unary_op, T(TILDE) T(NOT) T(PLUS) T(MINUS))
50 TOKEN_CLASS(let_func, T(ZVAL) T(OBJVAL) T(ARRVAL) T(PATHVAL) T(STRLEN) T(STRVAL) T(FLOATVAL) T(INTVAL) T(BOOLVAL) T(COUNT))
51 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))
52 TOKEN_CLASS(impl_type, T(VOID) T(MIXED) T(BOOL) T(INT) T(FLOAT) T(STRING) T(ARRAY) T(OBJECT) T(CALLABLE))
53 TOKEN_CLASS(assert_stmt, T(PRE_ASSERT) T(POST_ASSERT))
54 TOKEN_CLASS(cpp_message, T(ERROR) T(WARNING))
55
56 DEF(%nonassoc, NAME.)
57 DEF(%right, NOT TILDE.)
58 DEF(%left, AND OR.)
59 DEF(%left, PIPE.)
60 DEF(%left, CARET.)
61 DEF(%left, AMPERSAND.)
62 DEF(%left, CMP_EQ CMP_NE.)
63 DEF(%left, LCHEVR CMP_LE RCHEVR CMP_GE.)
64 DEF(%left, LSHIFT RSHIFT.)
65 DEF(%left, PLUS MINUS.)
66 DEF(%left, ASTERISK SLASH MODULO.)
67
68 DEF(%fallback, NAME TEMP FREE SET LET RETURN CALLOC CALLBACK ZVAL LIB STRING COUNT.)
69 DEF(%wildcard, ANY.)
70
71 TOKEN_TYPE(decl_enum, struct psi_decl_enum *)
72 TOKEN_DTOR(decl_enum, psi_decl_enum_free(&$$);)
73 TOKEN_TYPE(decl_enum_items, struct psi_plist*)
74 TOKEN_DTOR(decl_enum_items, psi_plist_free($$);)
75 TOKEN_TYPE(decl_enum_item, struct psi_decl_enum_item*)
76 TOKEN_DTOR(decl_enum_item, psi_decl_enum_item_free(&$$);)
77 TOKEN_TYPE(decl_struct_args_block, struct psi_plist*)
78 TOKEN_DTOR(decl_struct_args_block, psi_plist_free($$);) /* there was a typo */
79 TOKEN_TYPE(decl_struct_args, struct psi_plist*)
80 TOKEN_DTOR(decl_struct_args, psi_plist_free($$);)
81 TOKEN_TYPE(decl_struct, struct psi_decl_struct*)
82 TOKEN_DTOR(decl_struct, psi_decl_struct_free(&$$);)
83 TOKEN_TYPE(align_and_size, struct psi_layout)
84 TOKEN_TYPE(decl_union, struct psi_decl_union*)
85 TOKEN_DTOR(decl_union, psi_decl_union_free(&$$);)
86 TOKEN_TYPE(const_type, struct psi_const_type*)
87 TOKEN_DTOR(const_type, psi_const_type_free(&$$);)
88 TOKEN_TYPE(constant, struct psi_const*)
89 TOKEN_DTOR(constant, psi_const_free(&$$);)
90 TOKEN_TYPE(decl_typedef, struct psi_decl_arg*)
91 TOKEN_DTOR(decl_typedef, psi_decl_arg_free(&$$);)
92 TOKEN_TYPE(decl_typedef_body_ex, struct psi_decl_arg*)
93 TOKEN_DTOR(decl_typedef_body_ex, psi_decl_arg_free(&$$);)
94 TOKEN_TYPE(decl_typedef_body, struct psi_decl_arg*)
95 TOKEN_DTOR(decl_typedef_body, psi_decl_arg_free(&$$);)
96 TOKEN_TYPE(decl_typedef_body_fn_args, struct psi_plist*)
97 TOKEN_DTOR(decl_typedef_body_fn_args, psi_plist_free($$);)
98 TOKEN_TYPE(decl, struct psi_decl*)
99 TOKEN_DTOR(decl, psi_decl_free(&$$);)
100 TOKEN_TYPE(decl_func, struct psi_decl_arg*)
101 TOKEN_DTOR(decl_func, psi_decl_arg_free(&$$);)
102 TOKEN_TYPE(decl_abi, struct psi_decl_abi*)
103 TOKEN_DTOR(decl_abi, psi_decl_abi_free(&$$);)
104 TOKEN_TYPE(decl_var, struct psi_decl_var*)
105 TOKEN_DTOR(decl_var, psi_decl_var_free(&$$);)
106 TOKEN_TYPE(decl_vars, struct psi_plist*)
107 TOKEN_DTOR(decl_vars, psi_plist_free($$);)
108 TOKEN_TYPE(decl_arg, struct psi_decl_arg*)
109 TOKEN_DTOR(decl_arg, psi_decl_arg_free(&$$);)
110 TOKEN_TYPE(decl_args, struct psi_plist*)
111 TOKEN_DTOR(decl_args, psi_plist_free($$);)
112 TOKEN_TYPE(struct_args, struct psi_plist*)
113 TOKEN_DTOR(struct_args, psi_plist_free($$);)
114 TOKEN_TYPE(struct_arg, struct psi_decl_arg*)
115 TOKEN_DTOR(struct_arg, psi_decl_arg_free(&$$);)
116 TOKEN_TYPE(decl_layout, struct psi_layout*)
117 TOKEN_DTOR(decl_layout, psi_layout_free(&$$);)
118 TOKEN_TYPE(decl_type, struct psi_decl_type*)
119 TOKEN_DTOR(decl_type, psi_decl_type_free(&$$);)
120 TOKEN_TYPE(const_decl_type, struct psi_decl_type*)
121 TOKEN_DTOR(const_decl_type, psi_decl_type_free(&$$);)
122 TOKEN_TYPE(impl, struct psi_impl*)
123 TOKEN_DTOR(impl, psi_impl_free(&$$);)
124 TOKEN_TYPE(impl_func, struct psi_impl_func*)
125 TOKEN_DTOR(impl_func, psi_impl_func_free(&$$);)
126 TOKEN_TYPE(impl_def_val, struct psi_impl_def_val*)
127 TOKEN_DTOR(impl_def_val, psi_impl_def_val_free(&$$);)
128 TOKEN_TYPE(impl_var, struct psi_impl_var*)
129 TOKEN_DTOR(impl_var, psi_impl_var_free(&$$);)
130 TOKEN_TYPE(impl_arg, struct psi_impl_arg*)
131 TOKEN_DTOR(impl_arg, psi_impl_arg_free(&$$);)
132 TOKEN_TYPE(impl_args, struct psi_plist*)
133 TOKEN_DTOR(impl_args, psi_plist_free($$);)
134 TOKEN_TYPE(impl_vararg, struct psi_impl_arg*)
135 TOKEN_DTOR(impl_vararg, psi_impl_arg_free(&$$);)
136 TOKEN_TYPE(impl_stmts, struct psi_plist*)
137 TOKEN_DTOR(impl_stmts, psi_plist_free($$);)
138 TOKEN_TYPE(impl_stmt, struct psi_token**)
139 TOKEN_DTOR(impl_stmt, psi_impl_stmt_free(&$$);)
140 TOKEN_TYPE(number, struct psi_number*)
141 TOKEN_DTOR(number, psi_number_free(&$$);)
142 TOKEN_TYPE(num_exp, struct psi_num_exp*)
143 TOKEN_DTOR(num_exp, psi_num_exp_free(&$$);)
144 TOKEN_TYPE(let_stmt, struct psi_let_stmt*)
145 TOKEN_DTOR(let_stmt, psi_let_stmt_free(&$$);)
146 TOKEN_TYPE(let_calloc, struct psi_let_calloc*)
147 TOKEN_DTOR(let_calloc, psi_let_calloc_free(&$$);)
148 TOKEN_TYPE(let_func, struct psi_let_func*)
149 TOKEN_DTOR(let_func, psi_let_func_free(&$$);)
150 TOKEN_TYPE(callback_arg_list, struct psi_plist *)
151 TOKEN_DTOR(callback_arg_list, psi_plist_free($$);)
152 TOKEN_TYPE(callback_args, struct psi_plist *)
153 TOKEN_DTOR(callback_args, psi_plist_free($$);)
154 TOKEN_TYPE(let_callback, struct psi_let_callback*)
155 TOKEN_DTOR(let_callback, psi_let_callback_free(&$$);)
156 TOKEN_TYPE(let_exp, struct psi_let_exp*)
157 TOKEN_DTOR(let_exp, psi_let_exp_free(&$$);)
158 TOKEN_TYPE(let_exps, struct psi_plist*)
159 TOKEN_DTOR(let_exps, psi_plist_free($$);)
160 TOKEN_TYPE(assert_stmt, struct psi_assert_stmt*)
161 TOKEN_DTOR(assert_stmt, psi_assert_stmt_free(&$$);)
162 TOKEN_TYPE(set_stmt, struct psi_set_stmt*)
163 TOKEN_DTOR(set_stmt, psi_set_stmt_free(&$$);)
164 TOKEN_TYPE(set_exp, struct psi_set_exp*)
165 TOKEN_DTOR(set_exp, psi_set_exp_free(&$$);)
166 TOKEN_TYPE(set_exps, struct psi_plist*)
167 TOKEN_DTOR(set_exps, psi_plist_free($$);)
168 TOKEN_TYPE(set_func, struct psi_set_func*)
169 TOKEN_DTOR(set_func, psi_set_func_free(&$$);)
170 TOKEN_TYPE(return_stmt, struct psi_return_stmt*)
171 TOKEN_DTOR(return_stmt, psi_return_stmt_free(&$$);)
172 TOKEN_TYPE(free_stmt, struct psi_free_stmt*)
173 TOKEN_DTOR(free_stmt, psi_free_stmt_free(&$$);)
174 TOKEN_TYPE(free_exps, struct psi_plist*)
175 TOKEN_DTOR(free_exps, psi_plist_free($$);)
176 TOKEN_TYPE(free_exp, struct psi_free_exp*)
177 TOKEN_DTOR(free_exp, psi_free_exp_free(&$$);)
178 TOKEN_TYPE(impl_type, struct psi_impl_type*)
179 TOKEN_DTOR(impl_type, psi_impl_type_free(&$$);)
180 TOKEN_TYPE(cpp_exp, struct psi_cpp_exp*)
181 TOKEN_DTOR(cpp_exp, psi_cpp_exp_free(&$$);)
182 TOKEN_TYPE(cpp_macro_decl, struct psi_cpp_macro_decl*)
183 TOKEN_DTOR(cpp_macro_decl, psi_cpp_macro_decl_free(&$$);)
184 TOKEN_TYPE(cpp_macro_decl_tokens, struct psi_plist*)
185 TOKEN_DTOR(cpp_macro_decl_tokens, psi_plist_free($$);)
186 TOKEN_TYPE(cpp_macro_exp, struct psi_num_exp*)
187 TOKEN_DTOR(cpp_macro_exp, psi_num_exp_free(&$$);)
188 TOKEN_TYPE(cpp_macro_sig, struct psi_plist*)
189 TOKEN_DTOR(cpp_macro_sig, psi_plist_free($$);)
190 TOKEN_TYPE(cpp_macro_sig_args, struct psi_plist*)
191 TOKEN_DTOR(cpp_macro_sig_args, psi_plist_free($$);)
192 TOKEN_TYPE(cpp_macro_call, struct psi_plist*)
193 TOKEN_DTOR(cpp_macro_call, psi_plist_free($$);)
194 TOKEN_TYPE(cpp_macro_call_args, struct psi_plist*)
195 TOKEN_DTOR(cpp_macro_call_args, psi_plist_free($$);)
196
197 TOKEN_TYPE(reference, bool)
198 TOKEN_TYPE(indirection, unsigned)
199 TOKEN_TYPE(pointers, unsigned)
200
201 PASS(file, blocks)
202 PASS(blocks, block)
203 PASS(blocks, blocks block)
204
205 PASS(block, EOS)
206 PASS(block, EOL)
207 PASS(block, COMMENT)
208
209 /*
210 * cpp: # cpp_exp EOL
211 */
212 PARSE(block, TOKEN(HASH) TYPED(cpp_exp, exp_) TOKEN(EOL)) {
213 P->cpp.exp = exp_;
214 }
215
216 /*
217 * cpp_exp: cpp_message_token QUOTED_STRING
218 */
219 PARSE_TYPED(cpp_exp, exp,
220 NAMED(cpp_message_token, T)
221 NAMED(QUOTED_STRING, S)) {
222 exp = psi_cpp_exp_init(T->type, S);
223 exp->token = T;
224 }
225
226 /*
227 * cpp_exp: IFDEF NAME
228 */
229 PARSE_TYPED(cpp_exp, exp,
230 NAMED(IFDEF, T)
231 NAMED(NAME, N)) {
232 exp = psi_cpp_exp_init(T->type, N);
233 exp->token = T;
234 }
235
236 /*
237 * cpp_exp: IFNDEF NAME
238 */
239 PARSE_TYPED(cpp_exp, exp,
240 NAMED(IFNDEF, T)
241 NAMED(NAME, N)) {
242 exp = psi_cpp_exp_init(T->type, N);
243 exp->token = T;
244 }
245
246 /*
247 * cpp_exp: ENDIF
248 */
249 PARSE_TYPED(cpp_exp, exp,
250 NAMED(ENDIF, T)) {
251 exp = psi_cpp_exp_init(T->type, NULL);
252 exp->token = T;
253 }
254
255 /*
256 * cpp_exp: ELSE
257 */
258 PARSE_TYPED(cpp_exp, exp,
259 NAMED(ELSE, T)) {
260 exp = psi_cpp_exp_init(T->type, NULL);
261 exp->token = T;
262 }
263
264 /*
265 * cpp_exp: UNDEF NAME
266 */
267 PARSE_TYPED(cpp_exp, exp,
268 NAMED(UNDEF, T)
269 NAMED(NAME, N)) {
270 exp = psi_cpp_exp_init(T->type, N);
271 exp->token = T;
272 }
273
274 /*
275 * cpp_exp: DEFINE NAME cpp_macro_decl
276 */
277 PARSE_TYPED(cpp_exp, exp,
278 NAMED(DEFINE, T)
279 NAMED(NAME, N)
280 TYPED(cpp_macro_decl, macro)) {
281 exp = psi_cpp_exp_init(T->type, macro);
282 exp->token = T;
283 macro->token = N;
284 }
285
286 /*
287 * cpp_macro_decl: <empty>
288 */
289 PARSE_TYPED(cpp_macro_decl, macro, ) {
290 macro = psi_cpp_macro_decl_init(NULL, NULL, NULL);
291 }
292
293 /*
294 * cpp_macro_decl: cpp_macro_sig
295 */
296 PARSE_TYPED(cpp_macro_decl, macro,
297 TYPED(cpp_macro_sig, sig)) {
298 macro = psi_cpp_macro_decl_init(sig, NULL, NULL);
299 }
300
301 /*
302 * cpp_macro_decl: cpp_macro_sig cpp_macro_decl_tokens
303 */
304 PARSE_TYPED(cpp_macro_decl, macro,
305 TYPED(cpp_macro_sig, sig)
306 TYPED(cpp_macro_decl_tokens, tokens)) {
307 macro = psi_cpp_macro_decl_init(sig, tokens, NULL);
308 }
309
310 /*
311 * cpp_macro_sig: NO_WHITESPACE LPAREN cpp_macro_sig_args RPAREN
312 */
313 PARSE_TYPED(cpp_macro_sig, sig,
314 TOKEN(NO_WHITESPACE)
315 TOKEN(LPAREN)
316 TYPED(cpp_macro_sig_args, args)
317 TOKEN(RPAREN)) {
318 sig = args;
319 }
320
321 /*
322 * cpp_macro_sig_args: <empty>
323 */
324 PARSE_TYPED(cpp_macro_sig_args, args, ) {
325 args = NULL;
326 }
327
328 /*
329 * cpp_macro_sig_args: NAME
330 */
331 PARSE_TYPED(cpp_macro_sig_args, args,
332 NAMED(NAME, arg)) {
333 args = psi_plist_add(psi_plist_init((void (*)(void *)) psi_token_free), &arg);
334 }
335
336 /*
337 * cpp_macro_sig_args: cpp_macro_sig_args , NAME
338 */
339 PARSE_TYPED(cpp_macro_sig_args, args,
340 TYPED(cpp_macro_sig_args, args_)
341 TOKEN(COMMA)
342 NAMED(NAME, arg)) {
343 args = psi_plist_add(args_, &arg);
344 }
345
346 /*
347 * cpp_macro_decl: cpp_macro_decl_tokens
348 */
349 PARSE_TYPED(cpp_macro_decl, macro,
350 TYPED(cpp_macro_decl_tokens, tokens)) {
351 macro = psi_cpp_macro_decl_init(NULL, tokens, NULL);
352 }
353
354 /*
355 * cpp_macro_decl_tokens: ANY
356 */
357 PARSE_TYPED(cpp_macro_decl_tokens, tokens,
358 NAMED(ANY, T)) {
359 tokens = psi_plist_add(psi_plist_init((void (*)(void *)) psi_token_free), &T);
360 }
361
362 /*
363 * cpp_macro_decl_tokens: cpp_macro_decl_tokens ANY
364 */
365 PARSE_TYPED(cpp_macro_decl_tokens, tokens,
366 TYPED(cpp_macro_decl_tokens, tokens_)
367 NAMED(ANY, T)) {
368 tokens = psi_plist_add(tokens_, &T);
369 }
370
371 /*
372 * cpp_exp: IF cpp_macro_exp
373 */
374 PARSE_TYPED(cpp_exp, exp,
375 NAMED(IF, T)
376 TYPED(cpp_macro_exp, macro)) {
377 exp = psi_cpp_exp_init(T->type, macro);
378 exp->token = T;
379 }
380
381 /*
382 * cpp_exp: ELIF cpp_macro_exp
383 */
384 PARSE_TYPED(cpp_exp, exp,
385 NAMED(ELIF, T)
386 TYPED(cpp_macro_exp, macro)) {
387 exp = psi_cpp_exp_init(T->type, macro);
388 exp->token = T;
389 }
390
391 /*
392 * cpp_macro_exp: ( cpp_macro_exp )
393 */
394 PARSE_TYPED(cpp_macro_exp, exp,
395 NAMED(LPAREN, L)
396 TYPED(cpp_macro_exp, exp_)
397 TOKEN(RPAREN)) {
398 exp = psi_num_exp_init_unary(L->type, exp_);
399 exp->token = L;
400 }
401
402 /*
403 * cpp_macro_exp: unary_op cpp_macro_exp
404 */
405 PARSE_TYPED(cpp_macro_exp, exp,
406 NAMED(unary_op_token, OP)
407 TYPED(cpp_macro_exp, exp_)) {
408 exp = psi_num_exp_init_unary(OP->type, exp_);
409 exp->token = OP;
410 }
411
412 /*
413 * cpp_macro_exp: cpp_macro_exp binary_op cpp_macro_exp
414 */
415 PARSE_TYPED(cpp_macro_exp, exp,
416 TYPED(cpp_macro_exp, lhs)
417 NAMED(binary_op_token, OP)
418 TYPED(cpp_macro_exp, rhs)) {
419 exp = psi_num_exp_init_binary(OP->type, lhs, rhs);
420 exp->token = OP;
421 }
422
423 /*
424 * cpp_macro_exp: DEFINED NAME
425 */
426 PARSE_TYPED(cpp_macro_exp, exp,
427 TOKEN(DEFINED)
428 NAMED(NAME, N)) {
429 {
430 uint8_t exists = zend_hash_str_exists(&P->cpp.defs, N->text, N->size);
431 exp = psi_num_exp_init_num(psi_number_init(PSI_T_UINT8, &exists));
432 exp->token = N;
433 }
434 }
435
436 /*
437 * cpp_macro_exp: DEFINED ( NAME )
438 */
439 PARSE_TYPED(cpp_macro_exp, exp,
440 TOKEN(DEFINED)
441 TOKEN(LPAREN)
442 NAMED(NAME, N)
443 TOKEN(RPAREN)) {
444 {
445 uint8_t exists = zend_hash_str_exists(&P->cpp.defs, N->text, N->size);
446 exp = psi_num_exp_init_num(psi_number_init(PSI_T_UINT8, &exists));
447 exp->token = N;
448 }
449 }
450
451 /*
452 * cpp_macro_exp: number
453 */
454 PARSE_TYPED(cpp_macro_exp, exp,
455 NAMED(number_token, tok)) {
456 exp = psi_num_exp_init_num(psi_number_init(tok->type, tok->text));
457 exp->token = tok;
458 exp->data.n->token = psi_token_copy(tok);
459 }
460
461 /*
462 * cpp_macro_exp: NAME
463 */
464 PARSE_TYPED(cpp_macro_exp, exp,
465 NAMED(NAME, N)) {
466 exp = psi_num_exp_init_num(psi_number_init(PSI_T_DEFINE, N->text));
467 exp->token = N;
468 exp->data.n->token = psi_token_copy(N);
469 }
470
471 /*
472 * cpp_macro_exp: NAME ( cpp_macro_call_args )
473 */
474 PARSE_TYPED(cpp_macro_exp, exp,
475 NAMED(NAME, N)
476 TOKEN(LPAREN)
477 TYPED(cpp_macro_call_args, args)
478 TOKEN(RPAREN)) {
479 exp = psi_num_exp_init_num(psi_number_init(PSI_T_FUNCTION,
480 psi_cpp_macro_call_init(N->text, args)));
481 exp->token = N;
482 }
483
484 /*
485 * cpp_macro_call_args: <empty>
486 */
487 PARSE_TYPED(cpp_macro_call_args, args,) {
488 args = NULL;
489 }
490
491 /*
492 * cpp_macro_call_args: cpp_macro_exp
493 */
494 PARSE_TYPED(cpp_macro_call_args, args,
495 TYPED(cpp_macro_exp, arg)) {
496 args = psi_plist_add(psi_plist_init((void (*)(void *)) psi_num_exp_free), &arg);
497 }
498
499 /*
500 * cpp_macro_call_args: cpp_macro_call_args , cpp_macro_exp
501 */
502 PARSE_TYPED(cpp_macro_call_args, args,
503 TYPED(cpp_macro_call_args, args_)
504 TOKEN(COMMA)
505 TYPED(cpp_macro_exp, arg)) {
506 args = psi_plist_add(args_, &arg);
507 }
508
509 /*
510 * lib: LIB "soname" ;
511 */
512 PARSE(block, NAMED(LIB, token) NAMED(QUOTED_STRING, libname) TOKEN(EOS)) {
513 if (P->file.ln) {
514 P->error(PSI_DATA(P), token, PSI_WARNING, "Extra 'lib %s' statement has no effect", libname->text);
515 } else {
516 P->file.ln = strndup(libname->text + 1, libname->size - 2);
517 }
518 free(libname);
519 free(token);
520 }
521
522 PARSE(block, TYPED(decl, decl)) {
523 if (!P->decls) {
524 P->decls = psi_plist_init((psi_plist_dtor) psi_decl_free);
525 }
526 P->decls = psi_plist_add(P->decls, &decl);
527 }
528
529 PARSE(block, TYPED(impl, impl)) {
530 if (!P->impls) {
531 P->impls = psi_plist_init((psi_plist_dtor) psi_impl_free);
532 }
533 P->impls = psi_plist_add(P->impls, &impl);
534 }
535
536 PARSE(block, TYPED(decl_typedef, def)) {
537 if (!P->types) {
538 P->types = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
539 }
540 P->types = psi_plist_add(P->types, &def);
541
542 switch (def->type->type) {
543 case PSI_T_STRUCT:
544 if (def->type->real.strct) {
545 if (!P->structs) {
546 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
547 }
548 P->structs = psi_plist_add(P->structs, &def->type->real.strct);
549 }
550 break;
551 case PSI_T_UNION:
552 if (def->type->real.unn) {
553 if (!P->unions) {
554 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
555 }
556 P->unions = psi_plist_add(P->unions, &def->type->real.unn);
557 }
558 break;
559 case PSI_T_ENUM:
560 if (def->type->real.enm) {
561 if (!P->enums) {
562 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
563 }
564 P->enums = psi_plist_add(P->enums, &def->type->real.enm);
565 }
566 break;
567 }
568 }
569
570 PARSE(block, TYPED(constant, constant)) {
571 if (!P->consts) {
572 P->consts = psi_plist_init((psi_plist_dtor) psi_const_free);
573 }
574 P->consts = psi_plist_add(P->consts, &constant);
575 }
576
577 PARSE(block, TYPED(decl_struct, strct)) {
578 if (!P->structs) {
579 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
580 }
581 P->structs = psi_plist_add(P->structs, &strct);
582 }
583
584 PARSE(block, TYPED(decl_union, u)) {
585 if (!P->unions) {
586 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
587 }
588 P->unions = psi_plist_add(P->unions, &u);
589 }
590
591 PARSE(block, TYPED(decl_enum, e)) {
592 if (!P->enums) {
593 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
594 }
595 P->enums = psi_plist_add(P->enums, &e);
596 }
597
598 /*
599 * optional_name: <empty>
600 */
601 PARSE_NAMED(optional_name, n, ) {
602 n = NULL;
603 }
604
605 /*
606 * optional_name: NAME
607 */
608 PARSE_NAMED(optional_name, n,
609 NAMED(NAME, N)) {
610 n = N;
611 }
612
613 /*
614 * align_and_size: <empty>
615 */
616 PARSE_TYPED(align_and_size, as, ) {
617 as.pos = 0;
618 as.len = 0;
619 }
620
621 /*
622 * align_and_size: :: ( NUMBER , NUMBER )
623 */
624 PARSE_TYPED(align_and_size, as,
625 TOKEN(COLON)
626 TOKEN(COLON)
627 TOKEN(LPAREN)
628 NAMED(NUMBER, A)
629 TOKEN(COMMA)
630 NAMED(NUMBER, S)
631 TOKEN(RPAREN)) {
632 as.pos = atol(A->text);
633 as.len = atol(S->text);
634 free(A);
635 free(S);
636 }
637
638 /*
639 * enum_name: ENUM optional_name
640 */
641 PARSE_NAMED(enum_name, n,
642 NAMED(ENUM, E)
643 NAMED(optional_name, N)) {
644 if (N) {
645 n = N;
646 free(E);
647 } else {
648 char digest[17];
649
650 psi_token_hash(E, digest);
651 n = psi_token_append("@", E, 1, digest);
652 }
653 }
654
655 /*
656 * struct_name: STRUCT optional_name
657 */
658 PARSE_NAMED(struct_name, n,
659 NAMED(STRUCT, S)
660 NAMED(optional_name, N)) {
661 if (N) {
662 n = N;
663 free(S);
664 } else {
665 char digest[17];
666
667 psi_token_hash(S, digest);
668 n = psi_token_append("@", S, 1, digest);
669 }
670 }
671
672 /*
673 * union_name: UNION optional_name
674 */
675 PARSE_NAMED(union_name, n,
676 NAMED(UNION, U)
677 NAMED(optional_name, N)) {
678 if (N) {
679 n = N;
680 free(U);
681 } else {
682 char digest[17];
683
684 psi_token_hash(U, digest);
685 n = psi_token_append("@", U, 1, digest);
686 }
687 }
688
689 /*
690 * decl_enum: enum_name { items }
691 */
692 PARSE_TYPED(decl_enum, e,
693 NAMED(enum_name, N)
694 TOKEN(LBRACE)
695 TYPED(decl_enum_items, list)
696 TOKEN(RBRACE)) {
697 e = psi_decl_enum_init(N->text, list);
698 e->token = N;
699 }
700
701 /*
702 * decl_enum_items: item
703 */
704 PARSE_TYPED(decl_enum_items, l,
705 TYPED(decl_enum_item, i)) {
706 l = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_enum_item_free),
707 &i);
708 }
709
710 /*
711 * decl_enum_items: items , item
712 */
713 PARSE_TYPED(decl_enum_items, l,
714 TYPED(decl_enum_items, l_)
715 TOKEN(COMMA)
716 TYPED(decl_enum_item, i)) {
717 l = psi_plist_add(l_, &i);
718 }
719
720 /*
721 * decl_enum_item: name = num_exp
722 */
723 PARSE_TYPED(decl_enum_item, i,
724 NAMED(NAME, N)
725 TOKEN(EQUALS)
726 TYPED(num_exp, num)) {
727 i = psi_decl_enum_item_init(N->text, num);
728 i->token = N;
729 }
730
731 /*
732 * decl_enum_item: name
733 */
734 PARSE_TYPED(decl_enum_item, i,
735 NAMED(NAME, N)) {
736 i = psi_decl_enum_item_init(N->text, NULL);
737 i->token = N;
738 }
739
740
741 /*
742 * decl_struct_args_block: { args }
743 */
744 PARSE_TYPED(decl_struct_args_block, args_,
745 TOKEN(LBRACE)
746 TYPED(struct_args, args)
747 TOKEN(RBRACE)) {
748 args_ = args;
749 }
750
751 /*
752 * decl_struct_args: args_block
753 */
754 PARSE_TYPED(decl_struct_args, args_,
755 TYPED(decl_struct_args_block, args)) {
756 args_ = args;
757 }
758
759 /*
760 * decl_struct_args: ;
761 */
762 PARSE_TYPED(decl_struct_args, args_,
763 TOKEN(EOS)) {
764 args_ = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
765 }
766
767 /*
768 * decl_struct: STRUCT name align_and_size struct_args
769 */
770 PARSE_TYPED(decl_struct, strct,
771 TOKEN(STRUCT)
772 NAMED(NAME, N)
773 TYPED(align_and_size, as)
774 TYPED(decl_struct_args, args)) {
775 strct = psi_decl_struct_init(N->text, args);
776 strct->align = as.pos;
777 strct->size = as.len;
778 strct->token = N;
779 }
780
781 /*
782 * decl_union: UNION name align_and_size struct_args
783 */
784 PARSE_TYPED(decl_union, u,
785 TOKEN(UNION)
786 NAMED(NAME, N)
787 TYPED(align_and_size, as)
788 TYPED(decl_struct_args, args)) {
789 u = psi_decl_union_init(N->text, args);
790 u->align = as.pos;
791 u->size = as.len;
792 u->token = N;
793 }
794
795 /*
796 * const_type: const_type_token
797 */
798 PARSE_TYPED(const_type, type_,
799 NAMED(const_type_token, T)) {
800 type_ = psi_const_type_init(T->type, T->text);
801 free(T);
802 }
803
804 /*
805 * constant: CONST const_type NSNAME = def_val ;
806 */
807 PARSE_TYPED(constant, constant,
808 TOKEN(CONST)
809 TYPED(const_type, type)
810 NAMED(NSNAME, T)
811 TOKEN(EQUALS)
812 TYPED(impl_def_val, val)
813 TOKEN(EOS)) {
814 constant = psi_const_init(type, T->text, val);
815 constant->token = T;
816 }
817
818 /*
819 * decl_typdef: TYPEDEF typedef_body ;
820 */
821 PARSE_TYPED(decl_typedef, def,
822 NAMED(TYPEDEF, T)
823 TYPED(decl_typedef_body, def_)
824 TOKEN(EOS)) {
825 def = def_;
826 def->token = T;
827 }
828
829 /*
830 * decl_typedef_body_ex: struct_name align_and_size struct_args_block decl_var
831 */
832 PARSE_TYPED(decl_typedef_body_ex, def,
833 NAMED(struct_name, N)
834 TYPED(align_and_size, as)
835 TYPED(decl_struct_args_block, args)
836 TYPED(decl_var, var)) {
837 def = psi_decl_arg_init(psi_decl_type_init(PSI_T_STRUCT, N->text), var);
838 def->type->token = psi_token_copy(N);
839 def->type->real.strct = psi_decl_struct_init(N->text, args);
840 def->type->real.strct->token = N;
841 def->type->real.strct->align = as.pos;
842 def->type->real.strct->size = as.len;
843 }
844
845 /*
846 * decl_typedef_body_ex: union_name align_and_size struct_args_block decl_var
847 */
848 PARSE_TYPED(decl_typedef_body_ex, def,
849 NAMED(union_name, N)
850 TYPED(align_and_size, as)
851 TYPED(decl_struct_args_block, args)
852 TYPED(decl_var, var)) {
853 def = psi_decl_arg_init(psi_decl_type_init(PSI_T_UNION, N->text), var);
854 def->type->token = psi_token_copy(N);
855 def->type->real.unn = psi_decl_union_init(N->text, args);
856 def->type->real.unn->token = N;
857 def->type->real.unn->align = as.pos;
858 def->type->real.unn->size = as.len;
859 }
860
861 /*
862 * decl_typedef_body_ex: decl_enum NAME
863 */
864 PARSE_TYPED(decl_typedef_body_ex, def,
865 TYPED(decl_enum, e)
866 NAMED(NAME, ALIAS)) {
867 def = psi_decl_arg_init(psi_decl_type_init(PSI_T_ENUM, e->name), psi_decl_var_init(ALIAS->text, 0, 0));
868 def->var->token = ALIAS;
869 def->type->token = psi_token_copy(e->token);
870 def->type->real.enm = e;
871 }
872
873 /*
874 * decl_typedef_body: decl_typedef_body_ex
875 */
876 PARSE_TYPED(decl_typedef_body, def,
877 TYPED(decl_typedef_body_ex, def_)) {
878 def = def_;
879 }
880
881 /*
882 * decl_typedef_body_fn_args: ( decl_args )
883 */
884 PARSE_TYPED(decl_typedef_body_fn_args, args,
885 TOKEN(LPAREN)
886 TYPED(decl_args, args_)
887 TOKEN(RPAREN)) {
888 args = args_;
889 }
890
891 /*
892 * decl_typedef_body: decl_func decl_typedef_body_fn_args
893 */
894 PARSE_TYPED(decl_typedef_body, def,
895 TYPED(decl_func, func_)
896 TYPED(decl_typedef_body_fn_args, args)) {
897 def = psi_decl_arg_init(psi_decl_type_init(PSI_T_FUNCTION, func_->var->name), psi_decl_var_copy(func_->var));
898 def->type->token = psi_token_copy(func_->token);
899 def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
900 }
901
902 /*
903 * decl_typedef_body: decl_arg
904 */
905 PARSE_TYPED(decl_typedef_body, def,
906 TYPED(decl_arg, arg)) {
907 def = arg;
908 }
909
910 /*
911 * decl: decl_abi decl_func ( decl_args ) ;
912 */
913 PARSE_TYPED(decl, decl,
914 TYPED(decl_abi, abi)
915 TYPED(decl_func, func)
916 TOKEN(LPAREN)
917 TYPED(decl_args, args)
918 TOKEN(RPAREN)
919 TOKEN(EOS)) {
920 decl = psi_decl_init(abi, func, args);
921 }
922
923 /*
924 * decl: decl_abi decl_func ( decl_args , ... ) ;
925 */
926 PARSE_TYPED(decl, decl,
927 TYPED(decl_abi, abi)
928 TYPED(decl_func, func)
929 TOKEN(LPAREN)
930 TYPED(decl_args, args)
931 TOKEN(COMMA)
932 TOKEN(ELLIPSIS)
933 TOKEN(RPAREN)
934 TOKEN(EOS)) {
935 decl = psi_decl_init(abi, func, args);
936 decl->varargs = 1;
937 }
938
939 /*
940 * decl_func: decl_arg
941 */
942 PARSE_TYPED(decl_func, func,
943 TYPED(decl_arg, arg)) {
944 func = arg;
945 }
946
947 /* special case for void functions */
948 /*
949 * decl_func: VOID NAME
950 */
951 PARSE_TYPED(decl_func, func,
952 NAMED(VOID, T)
953 NAMED(NAME, N)) {
954 func = psi_decl_arg_init(
955 psi_decl_type_init(T->type, T->text),
956 psi_decl_var_init(N->text, 0, 0)
957 );
958 func->type->token = T;
959 func->var->token = N;
960 func->token = N;
961 }
962
963 /*
964 * decl_typedef_body: VOID indirection ( indirection NAME ) decl_typedef_body_fn_args
965 */
966 PARSE_TYPED(decl_typedef_body, def,
967 NAMED(VOID, T)
968 TYPED(indirection, decl_i)
969 TOKEN(LPAREN)
970 TYPED(indirection, type_i)
971 NAMED(NAME, N)
972 TOKEN(RPAREN)
973 TYPED(decl_typedef_body_fn_args, args)) {
974 struct psi_decl_arg *func_ = psi_decl_arg_init(
975 psi_decl_type_init(T->type, T->text),
976 psi_decl_var_init(N->text, decl_i, 0)
977 );
978 func_->type->token = T;
979 func_->var->token = N;
980 func_->token = N;
981
982 def = psi_decl_arg_init(
983 psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
984 psi_decl_var_copy(func_->var)
985 );
986 def->var->pointer_level = type_i;
987 def->type->token = psi_token_copy(func_->token);
988 def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
989 }
990
991 /*
992 * decl_typedef_body: CONST VOID pointers ( indirection NAME ) decl_typdef_body_fn_args
993 */
994 PARSE_TYPED(decl_typedef_body, def,
995 TOKEN(CONST)
996 NAMED(VOID, T)
997 TYPED(pointers, decl_i)
998 TOKEN(LPAREN)
999 TYPED(indirection, type_i)
1000 NAMED(NAME, N)
1001 TOKEN(RPAREN)
1002 TYPED(decl_typedef_body_fn_args, args)) {
1003 struct psi_decl_arg *func_ = psi_decl_arg_init(
1004 psi_decl_type_init(T->type, T->text),
1005 psi_decl_var_init(N->text, decl_i, 0)
1006 );
1007 func_->type->token = T;
1008 func_->var->token = N;
1009 func_->token = N;
1010
1011 def = psi_decl_arg_init(
1012 psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
1013 psi_decl_var_copy(func_->var)
1014 );
1015 def->var->pointer_level = type_i;
1016 def->type->token = psi_token_copy(func_->token);
1017 def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
1018 }
1019
1020 /*
1021 * decl_abi: NAME
1022 */
1023 PARSE_TYPED(decl_abi, abi,
1024 NAMED(NAME, T)) {
1025 abi = psi_decl_abi_init(T->text);
1026 abi->token = T;
1027 }
1028
1029 /*
1030 * decl_var_array_size: <empty>
1031 */
1032 PARSE_NAMED(decl_var_array_size, as, ) {
1033 as = NULL;
1034 }
1035
1036 /*
1037 * decl_var_array_size: [ NUMBER ]
1038 */
1039 PARSE_NAMED(decl_var_array_size, as,
1040 TOKEN(LBRACKET)
1041 NAMED(NUMBER, D)
1042 TOKEN(RBRACKET)) {
1043 as = D;
1044 }
1045
1046 /*
1047 * decl_var: NAME decl_var_array_size
1048 */
1049 PARSE_TYPED(decl_var, var,
1050 NAMED(NAME, T)
1051 NAMED(decl_var_array_size, as)) {
1052 var = psi_decl_var_init(T->text, 0, as?atol(as->text):0);
1053 var->token = T;
1054 if (as) {
1055 free(as);
1056 }
1057 }
1058
1059 /*
1060 * decl_var: pointers NAME
1061 */
1062 PARSE_TYPED(decl_var, var,
1063 TYPED(pointers, p)
1064 NAMED(NAME, T)
1065 NAMED(decl_var_array_size, as)) {
1066 var = psi_decl_var_init(T->text, p+!!as, as?atol(as->text):0);
1067 var->token = T;
1068 if (as) {
1069 free(as);
1070 }
1071 }
1072
1073 /*
1074 * decl_vars: decl_var
1075 */
1076 PARSE_TYPED(decl_vars, vars,
1077 TYPED(decl_var, var)) {
1078 vars = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_var_free),
1079 &var);
1080 }
1081
1082 /*
1083 * decl_vars: decl_vars , decl_var
1084 */
1085 PARSE_TYPED(decl_vars, vars,
1086 TYPED(decl_vars, vars_)
1087 TOKEN(COMMA)
1088 TYPED(decl_var, var)) {
1089 vars = psi_plist_add(vars_, &var);
1090 }
1091
1092 /*
1093 * decl_arg: const_decl_type decl_var
1094 */
1095 PARSE_TYPED(decl_arg, arg_,
1096 TYPED(const_decl_type, type)
1097 TYPED(decl_var, var)) {
1098 arg_ = psi_decl_arg_init(type, var);
1099 }
1100
1101 /*
1102 * decl_typedef_body: const_decl_type indirection ( indirection NAME ) decl_typedef_body_fn_args
1103 */
1104 PARSE_TYPED(decl_typedef_body, def,
1105 TYPED(const_decl_type, type_)
1106 TYPED(indirection, decl_i)
1107 TOKEN(LPAREN)
1108 TYPED(indirection, type_i)
1109 NAMED(NAME, N)
1110 TOKEN(RPAREN)
1111 TYPED(decl_typedef_body_fn_args, args)) {
1112 struct psi_decl_arg *func_ = psi_decl_arg_init(
1113 type_,
1114 psi_decl_var_init(N->text, decl_i, 0)
1115 );
1116 func_->var->token = N;
1117 func_->token = N;
1118
1119 def = psi_decl_arg_init(
1120 psi_decl_type_init(PSI_T_FUNCTION, func_->var->name),
1121 psi_decl_var_copy(func_->var)
1122 );
1123 def->var->pointer_level = type_i;
1124 def->type->token = psi_token_copy(func_->token);
1125 def->type->real.func = psi_decl_init(psi_decl_abi_init("default"), func_, args);
1126 }
1127
1128 /* void pointers need a specific rule */
1129 /*
1130 * decl_arg: VOID pointers NAME
1131 */
1132 PARSE_TYPED(decl_arg, arg_,
1133 NAMED(VOID, T)
1134 TYPED(pointers, p)
1135 NAMED(NAME, N)) {
1136 arg_ = psi_decl_arg_init(
1137 psi_decl_type_init(T->type, T->text),
1138 psi_decl_var_init(N->text, p, 0)
1139 );
1140 arg_->type->token = T;
1141 arg_->var->token = N;
1142 arg_->token = N;
1143 }
1144
1145 /*
1146 * decl_args: CONST VOID pointers NAME
1147 */
1148 PARSE_TYPED(decl_arg, arg_,
1149 TOKEN(CONST)
1150 NAMED(VOID, T)
1151 TYPED(pointers, p)
1152 NAMED(NAME, N)) {
1153 arg_ = psi_decl_arg_init(
1154 psi_decl_type_init(T->type, T->text),
1155 psi_decl_var_init(N->text, p, 0)
1156 );
1157 arg_->type->token = T;
1158 arg_->var->token = N;
1159 arg_->token = N;
1160 }
1161
1162 /*
1163 * decl_args: <empty>
1164 */
1165 PARSE_TYPED(decl_args, args, ) {
1166 args = NULL;
1167 }
1168
1169 /*
1170 * decl_args: VOID
1171 */
1172 PARSE_TYPED(decl_args, args,
1173 TOKEN(VOID)) {
1174 args = NULL;
1175 }
1176
1177 /*
1178 * decl_args: decl_arg
1179 */
1180 PARSE_TYPED(decl_args, args,
1181 TYPED(decl_arg, arg)) {
1182 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
1183 &arg);
1184 }
1185
1186 /*
1187 * decl_args: decl_args , decl_arg
1188 */
1189 PARSE_TYPED(decl_args, args,
1190 TYPED(decl_args, args_)
1191 TOKEN(COMMA)
1192 TYPED(decl_arg, arg)) {
1193 args = psi_plist_add(args_, &arg);
1194 }
1195
1196 /*
1197 * struct_args: struct_arg
1198 */
1199 PARSE_TYPED(struct_args, args,
1200 TYPED(struct_arg, arg)) {
1201 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
1202 &arg);
1203 }
1204
1205 /*
1206 * struct_args: struct_args , struct_arg
1207 */
1208 PARSE_TYPED(struct_args, args,
1209 TYPED(struct_args, args_)
1210 TYPED(struct_arg, arg)) {
1211 args = psi_plist_add(args_, &arg);
1212 }
1213
1214 /*
1215 * struct_arg: decl_typedef_body_ex ;
1216 */
1217 PARSE_TYPED(struct_arg, arg_,
1218 TYPED(decl_typedef_body_ex, def)
1219 TOKEN(EOS)) {
1220 arg_ = def;
1221 switch (def->type->type) {
1222 case PSI_T_STRUCT:
1223 if (def->type->real.strct) {
1224 if (!P->structs) {
1225 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
1226 }
1227 P->structs = psi_plist_add(P->structs, &def->type->real.strct);
1228 }
1229 break;
1230 case PSI_T_UNION:
1231 if (def->type->real.unn) {
1232 if (!P->unions) {
1233 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
1234 }
1235 P->unions = psi_plist_add(P->unions, &def->type->real.unn);
1236 }
1237 break;
1238 case PSI_T_ENUM:
1239 if (def->type->real.enm) {
1240 if (!P->enums) {
1241 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
1242 }
1243 P->enums = psi_plist_add(P->enums, &def->type->real.enm);
1244 }
1245 break;
1246 }
1247 }
1248
1249 /*
1250 * struct_arg: decl_arg decl_layout ;
1251 */
1252 PARSE_TYPED(struct_arg, arg,
1253 TYPED(decl_arg, arg_)
1254 TYPED(decl_layout, layout_)
1255 TOKEN(EOS)) {
1256 arg_->layout = layout_;
1257 arg = arg_;
1258 }
1259
1260 /*
1261 * decl_layout: <empty>
1262 */
1263 PARSE_TYPED(decl_layout, layout, ) {
1264 layout = NULL;
1265 }
1266
1267 /*
1268 * decl_layout: :: ( NUMBER , NUMBER )
1269 */
1270 PARSE_TYPED(decl_layout, layout,
1271 TOKEN(COLON)
1272 TOKEN(COLON)
1273 TOKEN(LPAREN)
1274 NAMED(NUMBER, POS)
1275 TOKEN(COMMA)
1276 NAMED(NUMBER, SIZ)
1277 TOKEN(RPAREN)) {
1278 layout = psi_layout_init(atol(POS->text), atol(SIZ->text));
1279 free(POS);
1280 free(SIZ);
1281 }
1282
1283 /* un/signed, urgh */
1284 /*
1285 * decl_scalar_type: CHAR
1286 */
1287 PARSE_NAMED(decl_scalar_type, type_,
1288 NAMED(CHAR, C)) {
1289 type_ = C;
1290 }
1291
1292 /*
1293 * decl_scalar_type: SHORT decl_scalar_type_short
1294 */
1295 PARSE_NAMED(decl_scalar_type, type_,
1296 NAMED(SHORT, S)
1297 NAMED(decl_scalar_type_short, s)) {
1298 if (s) {
1299 type_ = psi_token_cat(" ", 2, S, s);
1300 free(S);
1301 free(s);
1302 } else {
1303 type_ = S;
1304 }
1305 }
1306
1307 /*
1308 * decl_scalar_type_short: <empty>
1309 */
1310 PARSE_NAMED(decl_scalar_type_short, s, ) {
1311 s = NULL;
1312 }
1313
1314 /*
1315 * decl_scalar_type_short: INT
1316 */
1317 PARSE_NAMED(decl_scalar_type_short, s,
1318 NAMED(INT, I)) {
1319 s = I;
1320 }
1321
1322 /*
1323 * decl_sclara_type: INT
1324 */
1325 PARSE_NAMED(decl_scalar_type, type_,
1326 NAMED(INT, I)) {
1327 type_ = I;
1328 }
1329
1330 /*
1331 * decl_scalar_type: LONG decl_scalar_type_long
1332 */
1333 PARSE_NAMED(decl_scalar_type, type_,
1334 NAMED(LONG, L)
1335 NAMED(decl_scalar_type_long, l)) {
1336 if (l) {
1337 type_ = psi_token_cat(" ", 2, L, l);
1338 free(L);
1339 free(l);
1340 } else {
1341 type_ = L;
1342 }
1343 }
1344
1345 /*
1346 * decl_scalar_type_long: <empty>
1347 */
1348 PARSE_NAMED(decl_scalar_type_long, l, ) {
1349 l = NULL;
1350 }
1351
1352 /*
1353 * decl_scalar_type_long: DOUBLE
1354 */
1355 PARSE_NAMED(decl_scalar_type_long, l,
1356 NAMED(DOUBLE, D)) {
1357 l = D;
1358 }
1359
1360 /*
1361 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1362 */
1363 PARSE_NAMED(decl_scalar_type_long, l,
1364 NAMED(LONG, L)
1365 NAMED(decl_scalar_type_long_long, ll)) {
1366 if (ll) {
1367 l = psi_token_cat(" ", 2, L, ll);
1368 free(L);
1369 free(ll);
1370 } else {
1371 l = L;
1372 }
1373 }
1374
1375 /*
1376 * decl_scalar_type_long_long: <empty>
1377 */
1378 PARSE_NAMED(decl_scalar_type_long_long, ll, ) {
1379 ll = NULL;
1380 }
1381
1382 /*
1383 * decl_scalar_type_long_long: INT
1384 */
1385 PARSE_NAMED(decl_scalar_type_long_long, ll,
1386 NAMED(INT, I)) {
1387 ll = I;
1388 }
1389
1390 /*
1391 * decl_type: UNSIGNED decl_scalar_type
1392 */
1393 PARSE_TYPED(decl_type, type_,
1394 NAMED(UNSIGNED, U)
1395 NAMED(decl_scalar_type, N)) {
1396 struct psi_token *T = psi_token_cat(" ", 2, U, N);
1397 type_ = psi_decl_type_init(T->type, T->text);
1398 type_->token = T;
1399 free(U);
1400 free(N);
1401 }
1402
1403 /*
1404 * decl_type: SIGNED decl_scalar_type
1405 */
1406 PARSE_TYPED(decl_type, type_,
1407 NAMED(SIGNED, S)
1408 NAMED(decl_scalar_type, N)) {
1409 struct psi_token *T = psi_token_cat(" ", 2, S, N);
1410 type_ = psi_decl_type_init(T->type, T->text);
1411 type_->token = T;
1412 free(S);
1413 free(N);
1414 }
1415
1416 /*
1417 * decl_type: UNSIGNED
1418 */
1419 PARSE_TYPED(decl_type, type_,
1420 NAMED(UNSIGNED, U)) {
1421 type_ = psi_decl_type_init(PSI_T_NAME, U->text);
1422 type_->token = U;
1423 }
1424
1425 /*
1426 * decl_type: SIGNED
1427 */
1428 PARSE_TYPED(decl_type, type_,
1429 NAMED(SIGNED, S)) {
1430 type_ = psi_decl_type_init(PSI_T_NAME, S->text);
1431 type_->token = S;
1432 }
1433
1434 /*
1435 * decl_type: decl_scalar_type
1436 */
1437 PARSE_TYPED(decl_type, type_,
1438 NAMED(decl_scalar_type, N)) {
1439 type_ = psi_decl_type_init(N->type, N->text);
1440 type_->token = N;
1441 }
1442
1443 /* structs ! */
1444 /*
1445 * decl_type: STRUCT NAME
1446 */
1447 PARSE_TYPED(decl_type, type_,
1448 NAMED(STRUCT, S)
1449 NAMED(NAME, T)) {
1450 type_ = psi_decl_type_init(S->type, T->text);
1451 type_->token = T;
1452 free(S);
1453 }
1454
1455 /*
1456 * decl_type: UNION NAME
1457 */
1458 PARSE_TYPED(decl_type, type_,
1459 NAMED(UNION, U)
1460 NAMED(NAME, T)) {
1461 type_ = psi_decl_type_init(U->type, T->text);
1462 type_->token = T;
1463 free(U);
1464 }
1465
1466 /*
1467 * decl_type: ENUM NAME
1468 */
1469 PARSE_TYPED(decl_type, type_,
1470 NAMED(ENUM, E)
1471 NAMED(NAME, T)) {
1472 type_ = psi_decl_type_init(E->type, T->text);
1473 type_->token = T;
1474 free(E);
1475 }
1476
1477 /*
1478 * decl_type: decl_type_token
1479 */
1480 PARSE_TYPED(decl_type, type_,
1481 NAMED(decl_type_token, T)) {
1482 type_ = psi_decl_type_init(T->type, T->text);
1483 type_->token = T;
1484 }
1485
1486 /*
1487 * const_decl_type: decl_type
1488 */
1489 PARSE_TYPED(const_decl_type, type,
1490 TYPED(decl_type, type_)) {
1491 type = type_;
1492 }
1493
1494 /*
1495 * const_decl_type: CONST decl_type
1496 */
1497 PARSE_TYPED(const_decl_type, type,
1498 TOKEN(CONST)
1499 TYPED(decl_type, type_)) {
1500 type = type_;
1501 }
1502
1503 /*
1504 * impl: impl_func { impl_stmts }
1505 */
1506 PARSE_TYPED(impl, impl,
1507 TYPED(impl_func, func)
1508 TOKEN(LBRACE)
1509 TYPED(impl_stmts, stmts)
1510 TOKEN(RBRACE)) {
1511 impl = psi_impl_init(func, stmts);
1512 }
1513
1514 /*
1515 * impl: STATIC impl_func { impl_stmts }
1516 */
1517 PARSE_TYPED(impl, impl,
1518 TOKEN(STATIC)
1519 TYPED(impl_func, func)
1520 TOKEN(LBRACE)
1521 TYPED(impl_stmts, stmts)
1522 TOKEN(RBRACE)) {
1523 func->static_memory = 1;
1524 impl = psi_impl_init(func, stmts);
1525 }
1526
1527 /*
1528 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1529 */
1530 PARSE_TYPED(impl_func, func,
1531 TOKEN(FUNCTION)
1532 TYPED(reference, r)
1533 NAMED(NSNAME, NAME)
1534 TOKEN(LPAREN)
1535 TOKEN(RPAREN)
1536 TOKEN(COLON)
1537 TYPED(impl_type, type)) {
1538 func = psi_impl_func_init(NAME->text, NULL, type);
1539 func->token = NAME;
1540 func->return_reference = r;
1541 }
1542
1543 /*
1544 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1545 */
1546 PARSE_TYPED(impl_func, func,
1547 TOKEN(FUNCTION)
1548 TYPED(reference, r)
1549 NAMED(NSNAME, NAME)
1550 TOKEN(LPAREN)
1551 TYPED(impl_args, args)
1552 TOKEN(RPAREN)
1553 TOKEN(COLON)
1554 TYPED(impl_type, type)) {
1555 func = psi_impl_func_init(NAME->text, args, type);
1556 func->token = NAME;
1557 func->return_reference = r;
1558 }
1559
1560 /*
1561 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1562 */
1563 PARSE_TYPED(impl_func, func,
1564 TOKEN(FUNCTION)
1565 TYPED(reference, func_r)
1566 NAMED(NSNAME, NAME)
1567 TOKEN(LPAREN)
1568 TYPED(impl_args, args)
1569 TOKEN(COMMA)
1570 TYPED(impl_type, va_type)
1571 TYPED(reference, va_r)
1572 TOKEN(ELLIPSIS)
1573 NAMED(DOLLAR_NAME, T)
1574 TOKEN(RPAREN)
1575 TOKEN(COLON)
1576 TYPED(impl_type, func_type)) {
1577 func = psi_impl_func_init(NAME->text, args, func_type);
1578 func->token = NAME;
1579 func->return_reference = func_r;
1580 func->vararg = psi_impl_arg_init(va_type, psi_impl_var_init(T->text, va_r), NULL);
1581 free(T);
1582 }
1583
1584 /*
1585 * impl_def_val: impl_def_val_token
1586 */
1587 PARSE_TYPED(impl_def_val, def,
1588 NAMED(impl_def_val_token, T)) {
1589 def = psi_impl_def_val_init(T->type, T->text);
1590 def->token = T;
1591 }
1592
1593 /*
1594 * impl_var: reference DOLLAR_NAME
1595 */
1596 PARSE_TYPED(impl_var, var,
1597 TYPED(reference, r)
1598 NAMED(DOLLAR_NAME, T)) {
1599 var = psi_impl_var_init(T->text, r);
1600 var->token = T;
1601 }
1602
1603 /*
1604 * impl_type: impl_type_token
1605 */
1606 PARSE_TYPED(impl_type, type_,
1607 NAMED(impl_type_token, T)) {
1608 type_ = psi_impl_type_init(T->type, T->text);
1609 free(T);
1610 }
1611
1612 /*
1613 * impl_arg: impl_type impl_var
1614 */
1615 PARSE_TYPED(impl_arg, arg,
1616 TYPED(impl_type, type)
1617 TYPED(impl_var, var)) {
1618 arg = psi_impl_arg_init(type, var, NULL);
1619 }
1620
1621 /*
1622 * impl_arg: impl_type impl_var = impl_def_val
1623 */
1624 PARSE_TYPED(impl_arg, arg,
1625 TYPED(impl_type, type)
1626 TYPED(impl_var, var)
1627 TOKEN(EQUALS)
1628 TYPED(impl_def_val, def)) {
1629 arg = psi_impl_arg_init(type, var, def);
1630 }
1631
1632 /*
1633 * impl_args: impl_arg
1634 */
1635 PARSE_TYPED(impl_args, args,
1636 TYPED(impl_arg, arg)) {
1637 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_arg_free),
1638 &arg);
1639 }
1640
1641 /*
1642 * impl_args: impl_args , impl_arg
1643 */
1644 PARSE_TYPED(impl_args, args,
1645 TYPED(impl_args, args_)
1646 TOKEN(COMMA)
1647 TYPED(impl_arg, arg)) {
1648 args = psi_plist_add(args_, &arg);
1649 }
1650
1651 /*
1652 * impl_stmts: impl_stmt
1653 */
1654 PARSE_TYPED(impl_stmts, stmts,
1655 TYPED(impl_stmt, stmt)) {
1656 stmts = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_stmt_free),
1657 &stmt);
1658 }
1659
1660 /*
1661 * impl_stmts: impl_stmts , impl_stmt
1662 */
1663 PARSE_TYPED(impl_stmts, stmts,
1664 TYPED(impl_stmts, stmts_)
1665 TYPED(impl_stmt, stmt)) {
1666 stmts = psi_plist_add(stmts_, &stmt);
1667 }
1668
1669 /*
1670 * impl_stmt: return_stmt
1671 */
1672 PARSE_TYPED(impl_stmt, i,
1673 TYPED(return_stmt, r)) {
1674 i = (struct psi_token**) r;
1675 }
1676
1677 /*
1678 * impl_stmt: let_stmt
1679 */
1680 PARSE_TYPED(impl_stmt, i,
1681 TYPED(let_stmt, l)) {
1682 i = (struct psi_token**) l;
1683 }
1684
1685 /*
1686 * impl_stmt: set_stmt
1687 */
1688 PARSE_TYPED(impl_stmt, i,
1689 TYPED(set_stmt, s)) {
1690 i = (struct psi_token**) s;
1691 }
1692
1693 /*
1694 * impl_stmt: assert_stmt
1695 */
1696 PARSE_TYPED(impl_stmt, i,
1697 TYPED(assert_stmt, s)) {
1698 i = (struct psi_token **) s;
1699 }
1700
1701 /*
1702 * impl_stmt: free_stmt
1703 */
1704 PARSE_TYPED(impl_stmt, i,
1705 TYPED(free_stmt, f)) {
1706 i = (struct psi_token**) f;
1707 }
1708
1709 /*
1710 * number: number_token
1711 */
1712 PARSE_TYPED(number, exp,
1713 NAMED(number_token, tok)) {
1714 exp = psi_number_init(tok->type, tok->text);
1715 exp->token = tok;
1716 }
1717
1718 /*
1719 * number: decl_var
1720 */
1721 PARSE_TYPED(number, exp,
1722 TYPED(decl_var, var)) {
1723 exp = psi_number_init(PSI_T_NAME, var);
1724 exp->token = psi_token_copy(var->token);
1725 }
1726
1727 /*
1728 * num_exp: number
1729 */
1730 PARSE_TYPED(num_exp, exp,
1731 TYPED(number, num)) {
1732 exp = psi_num_exp_init_num(num);
1733 exp->token = psi_token_copy(num->token);
1734 }
1735
1736 /*
1737 * num_exp: ( num_exp )
1738 */
1739 PARSE_TYPED(num_exp, exp,
1740 NAMED(LPAREN, L)
1741 TYPED(num_exp, exp_)
1742 TOKEN(RPAREN)) {
1743 exp = psi_num_exp_init_unary(PSI_T_LPAREN, exp_);
1744 exp->token = L;
1745 }
1746
1747 /*
1748 * num_exp: num_exp binary_op_token num_exp
1749 */
1750 PARSE_TYPED(num_exp, exp,
1751 TYPED(num_exp, lhs_)
1752 NAMED(binary_op_token, OP)
1753 TYPED(num_exp, rhs_)) {
1754 exp = psi_num_exp_init_binary(OP->type, lhs_, rhs_);
1755 exp->token = OP;
1756 }
1757
1758 /*
1759 * num_exp: unary_op_token num_exp
1760 */
1761 PARSE_TYPED(num_exp, exp,
1762 NAMED(unary_op_token, OP)
1763 TYPED(num_exp, exp_)) {
1764 exp = psi_num_exp_init_unary(OP->type, exp_);
1765 exp->token = OP;
1766 }
1767
1768 /*
1769 * let_exp: NULL
1770 */
1771 PARSE_TYPED(let_exp, val,
1772 TOKEN(NULL)) {
1773 val = psi_let_exp_init(PSI_LET_NULL, NULL);
1774 }
1775
1776 /*
1777 * let_exp: & NULL
1778 */
1779 PARSE_TYPED(let_exp, val,
1780 TOKEN(AMPERSAND)
1781 TOKEN(NULL)) {
1782 val = psi_let_exp_init(PSI_LET_NULL, NULL);
1783 val->is_reference = 1;
1784 }
1785
1786 /*
1787 * let_exp: callback
1788 */
1789 PARSE_TYPED(let_exp, val,
1790 TYPED(let_callback, cb)) {
1791 val = psi_let_exp_init(PSI_LET_CALLBACK, cb);
1792 }
1793
1794 /*
1795 * let_exp: calloc
1796 */
1797 PARSE_TYPED(let_exp, val,
1798 TYPED(let_calloc, ca)) {
1799 val = psi_let_exp_init(PSI_LET_CALLOC, ca);
1800 }
1801
1802 /*
1803 * let_exp: & calloc
1804 */
1805 PARSE_TYPED(let_exp, val,
1806 TOKEN(AMPERSAND)
1807 TYPED(let_calloc, ca)) {
1808 val = psi_let_exp_init(PSI_LET_CALLOC, ca);
1809 val->is_reference = 1;
1810 }
1811
1812 /*
1813 * let_exp: func
1814 */
1815 PARSE_TYPED(let_exp, val,
1816 TYPED(let_func, fn)) {
1817 val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
1818 }
1819
1820 /*
1821 * let_exp: & func
1822 */
1823 PARSE_TYPED(let_exp, val,
1824 TOKEN(AMPERSAND)
1825 TYPED(let_func, fn)) {
1826 val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
1827 val->is_reference = 1;
1828 }
1829
1830 /*
1831 * let_exp: num_exp
1832 */
1833 PARSE_TYPED(let_exp, val,
1834 TYPED(num_exp, exp)) {
1835 val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
1836 }
1837
1838 /*
1839 * let_exp: & num_exp
1840 */
1841 PARSE_TYPED(let_exp, val,
1842 TOKEN(AMPERSAND)
1843 TYPED(num_exp, exp)) {
1844 val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
1845 val->is_reference = 1;
1846 }
1847
1848 /* FIXME
1849 * let_exp: decl_var = let_exp
1850 */
1851 PARSE_TYPED(let_exp, exp,
1852 TYPED(decl_var, var_)
1853 TOKEN(EQUALS)
1854 TYPED(let_exp, val)) {
1855 exp = val;
1856 exp->var = var_;
1857 }
1858
1859 /*
1860 * let_stmt: LET let_exp ;
1861 */
1862 PARSE_TYPED(let_stmt, let,
1863 NAMED(LET, T)
1864 TYPED(let_exp, val)
1865 TOKEN(EOS)) {
1866 let = psi_let_stmt_init(val);
1867 let->token = T;
1868 }
1869
1870 /*
1871 * let_stmt: TEMP decl_var = reference decl_var ;
1872 */
1873 PARSE_TYPED(let_stmt, let,
1874 NAMED(TEMP, T)
1875 TYPED(decl_var, var)
1876 TOKEN(EQUALS)
1877 TYPED(reference, r)
1878 TYPED(decl_var, val_)
1879 TOKEN(EOS)) {
1880 let = psi_let_stmt_init(psi_let_exp_init_ex(var, PSI_LET_TMP, val_));
1881 let->token = T;
1882 let->exp->is_reference = r ? 1 : 0;
1883 }
1884
1885 /*
1886 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1887 */
1888 PARSE_TYPED(let_callback, cb,
1889 NAMED(CALLBACK, T)
1890 NAMED(callback_rval, F)
1891 TOKEN(LPAREN)
1892 TYPED(impl_var, var)
1893 TOKEN(LPAREN)
1894 TYPED(callback_arg_list, args_)
1895 TOKEN(RPAREN)
1896 TOKEN(RPAREN)) {
1897 cb = psi_let_callback_init(psi_let_func_init(F->type, F->text, var), args_);
1898 cb->token = T;
1899 free(F);
1900 }
1901
1902 /*
1903 * let_calloc: CALLOC ( num_exp , num_exp )
1904 */
1905 PARSE_TYPED(let_calloc, alloc,
1906 NAMED(CALLOC, T)
1907 TOKEN(LPAREN)
1908 TYPED(num_exp, nmemb)
1909 TOKEN(COMMA)
1910 TYPED(num_exp, size)
1911 TOKEN(RPAREN)) {
1912 alloc = psi_let_calloc_init(nmemb, size);
1913 alloc->token = T;
1914 }
1915
1916 /*
1917 * let_func: let_func_token ( impl_var )
1918 */
1919 PARSE_TYPED(let_func, func,
1920 NAMED(let_func_token, T)
1921 TOKEN(LPAREN)
1922 TYPED(impl_var, var)
1923 TOKEN(RPAREN)) {
1924 func = psi_let_func_init(T->type, T->text, var);
1925 func->token = T;
1926 }
1927 /*
1928 * let_func: let_func_token ( impl_var , let_exps )
1929 */
1930 PARSE_TYPED(let_func, func,
1931 NAMED(let_func_token, T)
1932 TOKEN(LPAREN)
1933 TYPED(impl_var, var)
1934 TOKEN(COMMA)
1935 TYPED(let_exps, vals)
1936 TOKEN(RPAREN)) {
1937 func = psi_let_func_init(T->type, T->text, var);
1938 func->token = T;
1939 func->inner = vals;
1940 }
1941 /*
1942 * let_exps: let_exp
1943 */
1944 PARSE_TYPED(let_exps, exps,
1945 TYPED(let_exp, exp)) {
1946 exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_let_exp_free),
1947 &exp);
1948 }
1949 /*
1950 * let_exps: let_exps , let_exp
1951 */
1952 PARSE_TYPED(let_exps, exps,
1953 TYPED(let_exps, exps_)
1954 TOKEN(COMMA)
1955 TYPED(let_exp, exp)) {
1956 exps = psi_plist_add(exps_, &exp);
1957 }
1958
1959 /*
1960 * callback_arg_list: <empty>
1961 */
1962 PARSE_TYPED(callback_arg_list, args, ) {
1963 args = NULL;
1964 }
1965
1966 /*
1967 * callback_arg_list: callback_args
1968 */
1969 PARSE_TYPED(callback_arg_list, args,
1970 TYPED(callback_args, args_)) {
1971 args = args_;
1972 }
1973
1974 /*
1975 * callback_args: set_exp
1976 */
1977 PARSE_TYPED(callback_args, args,
1978 TYPED(set_exp, val)) {
1979 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
1980 &val);
1981 }
1982
1983 /*
1984 * callback_args: callback_args , set_exp
1985 */
1986 PARSE_TYPED(callback_args, args,
1987 TYPED(callback_args, args_)
1988 TOKEN(COMMA)
1989 TYPED(set_exp, val)) {
1990 args = psi_plist_add(args_, &val);
1991 }
1992
1993 /*
1994 * callback_rval: let_func_token
1995 */
1996 PARSE_NAMED(callback_rval, rval,
1997 NAMED(let_func_token, F)) {
1998 rval = F;
1999 }
2000
2001 /*
2002 * callback_rval: VOID
2003 */
2004 PARSE_NAMED(callback_rval, rval,
2005 NAMED(VOID, V)) {
2006 rval = V;
2007 }
2008
2009
2010 /*
2011 * set_func: set_func_token ( decl_var )
2012 */
2013 PARSE_TYPED(set_func, func,
2014 NAMED(set_func_token, T)
2015 TOKEN(LPAREN)
2016 TYPED(decl_var, var)
2017 TOKEN(RPAREN)) {
2018 func = psi_set_func_init(T->type, T->text, var);
2019 func->token = T;
2020 }
2021
2022 /*
2023 * set_func: set_func_token ( decl_var , set_exps )
2024 */
2025 PARSE_TYPED(set_func, func,
2026 NAMED(set_func_token, T)
2027 TOKEN(LPAREN)
2028 TYPED(decl_var, var)
2029 TOKEN(COMMA)
2030 TYPED(set_exps, vals)
2031 TOKEN(RPAREN)) {
2032 func = psi_set_func_init(T->type, T->text, var);
2033 func->token = T;
2034 func->inner = vals;
2035 }
2036
2037 /*
2038 * set_func: set_func_token ( decl_var , ... )
2039 */
2040 PARSE_TYPED(set_func, func,
2041 NAMED(set_func_token, T)
2042 TOKEN(LPAREN)
2043 TYPED(decl_var, var)
2044 TOKEN(COMMA)
2045 TOKEN(ELLIPSIS)
2046 TOKEN(RPAREN)) {
2047 func = psi_set_func_init(T->type, T->text, var);
2048 func->token = T;
2049 func->recursive = 1;
2050 }
2051
2052 /*
2053 * set_exp: set_func
2054 */
2055 PARSE_TYPED(set_exp, val,
2056 TYPED(set_func, fn)) {
2057 val = psi_set_exp_init(PSI_SET_FUNC, fn);
2058 }
2059
2060 /*
2061 * set_exp: num_exp
2062 */
2063 PARSE_TYPED(set_exp, val,
2064 TYPED(num_exp, num)) {
2065 val = psi_set_exp_init(PSI_SET_NUMEXP, num);
2066 }
2067
2068 /*
2069 * set_exps: set_exp
2070 */
2071 PARSE_TYPED(set_exps, exps,
2072 TYPED(set_exp, exp)) {
2073 exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
2074 &exp);
2075 }
2076
2077 /*
2078 * set_exps: set_exps , set_exp
2079 */
2080 PARSE_TYPED(set_exps, exps,
2081 TYPED(set_exps, exps_)
2082 TOKEN(COMMA)
2083 TYPED(set_exp, exp)) {
2084 exps = psi_plist_add(exps_, &exp);
2085 }
2086
2087 /* FIXME
2088 * set_exp: impl_var = set_exp
2089 */
2090 PARSE_TYPED(set_exp, exp,
2091 TYPED(impl_var, var_)
2092 TOKEN(EQUALS)
2093 TYPED(set_exp, val)) {
2094 exp = val;
2095 exp->var = var_;
2096 }
2097
2098 /*
2099 * set_stmt: SET set_exp ;
2100 */
2101 PARSE_TYPED(set_stmt, set,
2102 NAMED(SET, T)
2103 TYPED(set_exp, exp)
2104 TOKEN(EOS)) {
2105 set = psi_set_stmt_init(exp);
2106 set->token = T;
2107 }
2108
2109 /*
2110 * return_stmt: RETURN set_exp ;
2111 */
2112 PARSE_TYPED(return_stmt, ret,
2113 NAMED(RETURN, T)
2114 TYPED(set_func, func)
2115 TOKEN(EOS)) {
2116 ret = psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC, func));
2117 ret->token = T;
2118 }
2119
2120 /*
2121 * free_stmt: FREE free_exps ;
2122 */
2123 PARSE_TYPED(free_stmt, free,
2124 NAMED(FREE, T)
2125 TYPED(free_exps, calls)
2126 TOKEN(EOS)) {
2127 free = psi_free_stmt_init(calls);
2128 free->token = T;
2129 }
2130
2131 /*
2132 * free_exps: free_exp
2133 */
2134 PARSE_TYPED(free_exps, calls,
2135 TYPED(free_exp, call)) {
2136 calls = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_free_exp_free),
2137 &call);
2138 }
2139
2140 /*
2141 * free_exps: free_exps , free_exp
2142 */
2143 PARSE_TYPED(free_exps, calls,
2144 TYPED(free_exps, calls_)
2145 TOKEN(COMMA)
2146 TYPED(free_exp, call)) {
2147 calls = psi_plist_add(calls_, &call);
2148 }
2149
2150 /*
2151 * free_exp: NAME ( decl_vars )
2152 */
2153 PARSE_TYPED(free_exp, call,
2154 NAMED(NAME, F)
2155 TOKEN(LPAREN)
2156 TYPED(decl_vars, vars)
2157 TOKEN(RPAREN)) {
2158 call = psi_free_exp_init(F->text, vars);
2159 call->token = F;
2160 }
2161
2162 /*
2163 * assert_stmt: assert_stmt_token num_exp ;
2164 */
2165 PARSE_TYPED(assert_stmt, ass,
2166 NAMED(assert_stmt_token, T)
2167 TYPED(num_exp, exp)
2168 TOKEN(EOS)) {
2169 ass = psi_assert_stmt_init(T->type, exp);
2170 ass->token = T;
2171 }
2172
2173 /*
2174 * reference: <empty>
2175 */
2176 PARSE_TYPED(reference, r, ) {
2177 r = false;
2178 }
2179
2180 /*
2181 * reference: &
2182 */
2183 PARSE_TYPED(reference, r,
2184 TOKEN(AMPERSAND)) {
2185 r = true;
2186 }
2187
2188 /*
2189 * indirection: <empty>
2190 */
2191 PARSE_TYPED(indirection, i, ){
2192 i = 0;
2193 }
2194
2195 /*
2196 * indirection: pointers
2197 */
2198 PARSE_TYPED(indirection, i,
2199 TYPED(pointers, p)) {
2200 i = p;
2201 }
2202
2203 /*
2204 * pointers: *
2205 */
2206 PARSE_TYPED(pointers, p,
2207 TOKEN(ASTERISK)) {
2208 p = 1;
2209 }
2210
2211 /*
2212 * pointers: pointers *
2213 */
2214 PARSE_TYPED(pointers, p,
2215 TYPED(pointers, p_)
2216 TOKEN(ASTERISK)) {
2217 p = p_+1;
2218 }
PHP System Interface / POSIX Standard Interface