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