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


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