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


ab0ba7347c5c960aa2e541135416c5fc649a1fda
[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(num_exp_binary_op, T(PIPE) T(CARET) T(AMPERSAND) T(LSHIFT) T(RSHIFT) T(PLUS) T(MINUS) T(ASTERISK) T(SLASH) T(MODULO))
93 TOKEN_CLASS(num_exp_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, PIPE.)
101 DEF(%left, CARET.)
102 DEF(%left, AMPERSAND.)
103 DEF(%left, LSHIFT RSHIFT.)
104 DEF(%left, PLUS MINUS.)
105 DEF(%left, ASTERISK SLASH MODULO.)
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 PARSE_TYPED(decl_args, args, ) {
884 args = NULL;
885 }
886
887 /*
888 * decl_args: VOID
889 */
890 PARSE_TYPED(decl_args, args,
891 TOKEN(VOID)) {
892 args = NULL;
893 }
894
895 /*
896 * decl_args: decl_arg
897 */
898 PARSE_TYPED(decl_args, args,
899 TYPED(decl_arg, arg)) {
900 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
901 &arg);
902 }
903
904 /*
905 * decl_args: decl_args , decl_arg
906 */
907 PARSE_TYPED(decl_args, args,
908 TYPED(decl_args, args_)
909 TOKEN(COMMA)
910 TYPED(decl_arg, arg)) {
911 args = psi_plist_add(args_, &arg);
912 }
913
914 /*
915 * struct_args: struct_arg
916 */
917 PARSE_TYPED(struct_args, args,
918 TYPED(struct_arg, arg)) {
919 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_decl_arg_free),
920 &arg);
921 }
922
923 /*
924 * struct_args: struct_args , struct_arg
925 */
926 PARSE_TYPED(struct_args, args,
927 TYPED(struct_args, args_)
928 TYPED(struct_arg, arg)) {
929 args = psi_plist_add(args_, &arg);
930 }
931
932 /*
933 * struct_arg: decl_typedef_body_ex ;
934 */
935 PARSE_TYPED(struct_arg, arg_,
936 TYPED(decl_typedef_body_ex, def)
937 TOKEN(EOS)) {
938 arg_ = def;
939 switch (def->type->type) {
940 case PSI_T_STRUCT:
941 if (def->type->real.strct) {
942 if (!P->structs) {
943 P->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
944 }
945 P->structs = psi_plist_add(P->structs, &def->type->real.strct);
946 }
947 break;
948 case PSI_T_UNION:
949 if (def->type->real.unn) {
950 if (!P->unions) {
951 P->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
952 }
953 P->unions = psi_plist_add(P->unions, &def->type->real.unn);
954 }
955 break;
956 case PSI_T_ENUM:
957 if (def->type->real.enm) {
958 if (!P->enums) {
959 P->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
960 }
961 P->enums = psi_plist_add(P->enums, &def->type->real.enm);
962 }
963 break;
964 }
965 }
966
967 /*
968 * struct_arg: decl_arg decl_layout ;
969 */
970 PARSE_TYPED(struct_arg, arg,
971 TYPED(decl_arg, arg_)
972 TYPED(decl_layout, layout_)
973 TOKEN(EOS)) {
974 arg_->layout = layout_;
975 arg = arg_;
976 }
977
978 /*
979 * decl_layout: <empty>
980 */
981 PARSE_TYPED(decl_layout, layout, ) {
982 layout = NULL;
983 }
984
985 /*
986 * decl_layout: :: ( NUMBER , NUMBER )
987 */
988 PARSE_TYPED(decl_layout, layout,
989 TOKEN(COLON)
990 TOKEN(COLON)
991 TOKEN(LPAREN)
992 NAMED(NUMBER, POS)
993 TOKEN(COMMA)
994 NAMED(NUMBER, SIZ)
995 TOKEN(RPAREN)) {
996 layout = psi_layout_init(atol(POS->text), atol(SIZ->text));
997 free(POS);
998 free(SIZ);
999 }
1000
1001 /* un/signed, urgh */
1002 /*
1003 * decl_scalar_type: CHAR
1004 */
1005 PARSE_NAMED(decl_scalar_type, type_,
1006 NAMED(CHAR, C)) {
1007 type_ = C;
1008 }
1009
1010 /*
1011 * decl_scalar_type: SHORT decl_scalar_type_short
1012 */
1013 PARSE_NAMED(decl_scalar_type, type_,
1014 NAMED(SHORT, S)
1015 NAMED(decl_scalar_type_short, s)) {
1016 if (s) {
1017 type_ = psi_token_cat(2, S, s);
1018 free(S);
1019 free(s);
1020 } else {
1021 type_ = S;
1022 }
1023 }
1024
1025 /*
1026 * decl_scalar_type_short: <empty>
1027 */
1028 PARSE_NAMED(decl_scalar_type_short, s, ) {
1029 s = NULL;
1030 }
1031
1032 /*
1033 * decl_scalar_type_short: INT
1034 */
1035 PARSE_NAMED(decl_scalar_type_short, s,
1036 NAMED(INT, I)) {
1037 s = I;
1038 }
1039
1040 /*
1041 * decl_sclara_type: INT
1042 */
1043 PARSE_NAMED(decl_scalar_type, type_,
1044 NAMED(INT, I)) {
1045 type_ = I;
1046 }
1047
1048 /*
1049 * decl_scalar_type: LONG decl_scalar_type_long
1050 */
1051 PARSE_NAMED(decl_scalar_type, type_,
1052 NAMED(LONG, L)
1053 NAMED(decl_scalar_type_long, l)) {
1054 if (l) {
1055 type_ = psi_token_cat(2, L, l);
1056 free(L);
1057 free(l);
1058 } else {
1059 type_ = L;
1060 }
1061 }
1062
1063 /*
1064 * decl_scalar_type_long: <empty>
1065 */
1066 PARSE_NAMED(decl_scalar_type_long, l, ) {
1067 l = NULL;
1068 }
1069
1070 /*
1071 * decl_scalar_type_long: DOUBLE
1072 */
1073 PARSE_NAMED(decl_scalar_type_long, l,
1074 NAMED(DOUBLE, D)) {
1075 l = D;
1076 }
1077
1078 /*
1079 * decl_scalar_type_long: LONG decl_scalar_type_long_long
1080 */
1081 PARSE_NAMED(decl_scalar_type_long, l,
1082 NAMED(LONG, L)
1083 NAMED(decl_scalar_type_long_long, ll)) {
1084 if (ll) {
1085 l = psi_token_cat(2, L, ll);
1086 free(L);
1087 free(ll);
1088 } else {
1089 l = L;
1090 }
1091 }
1092
1093 /*
1094 * decl_scalar_type_long_long: <empty>
1095 */
1096 PARSE_NAMED(decl_scalar_type_long_long, ll, ) {
1097 ll = NULL;
1098 }
1099
1100 /*
1101 * decl_scalar_type_long_long: INT
1102 */
1103 PARSE_NAMED(decl_scalar_type_long_long, ll,
1104 NAMED(INT, I)) {
1105 ll = I;
1106 }
1107
1108 /*
1109 * decl_type: UNSIGNED decl_scalar_type
1110 */
1111 PARSE_TYPED(decl_type, type_,
1112 NAMED(UNSIGNED, U)
1113 NAMED(decl_scalar_type, N)) {
1114 struct psi_token *T = psi_token_cat(2, U, N);
1115 type_ = psi_decl_type_init(T->type, T->text);
1116 type_->token = T;
1117 free(U);
1118 free(N);
1119 }
1120
1121 /*
1122 * decl_type: SIGNED decl_scalar_type
1123 */
1124 PARSE_TYPED(decl_type, type_,
1125 NAMED(SIGNED, S)
1126 NAMED(decl_scalar_type, N)) {
1127 struct psi_token *T = psi_token_cat(2, S, N);
1128 type_ = psi_decl_type_init(T->type, T->text);
1129 type_->token = T;
1130 free(S);
1131 free(N);
1132 }
1133
1134 /*
1135 * decl_type: UNSIGNED
1136 */
1137 PARSE_TYPED(decl_type, type_,
1138 NAMED(UNSIGNED, U)) {
1139 type_ = psi_decl_type_init(PSI_T_NAME, U->text);
1140 type_->token = U;
1141 }
1142
1143 /*
1144 * decl_type: SIGNED
1145 */
1146 PARSE_TYPED(decl_type, type_,
1147 NAMED(SIGNED, S)) {
1148 type_ = psi_decl_type_init(PSI_T_NAME, S->text);
1149 type_->token = S;
1150 }
1151
1152 /*
1153 * decl_type: decl_scalar_type
1154 */
1155 PARSE_TYPED(decl_type, type_,
1156 NAMED(decl_scalar_type, N)) {
1157 type_ = psi_decl_type_init(N->type, N->text);
1158 type_->token = N;
1159 }
1160
1161 /* structs ! */
1162 /*
1163 * decl_type: STRUCT NAME
1164 */
1165 PARSE_TYPED(decl_type, type_,
1166 NAMED(STRUCT, S)
1167 NAMED(NAME, T)) {
1168 type_ = psi_decl_type_init(S->type, T->text);
1169 type_->token = T;
1170 free(S);
1171 }
1172
1173 /*
1174 * decl_type: UNION NAME
1175 */
1176 PARSE_TYPED(decl_type, type_,
1177 NAMED(UNION, U)
1178 NAMED(NAME, T)) {
1179 type_ = psi_decl_type_init(U->type, T->text);
1180 type_->token = T;
1181 free(U);
1182 }
1183
1184 /*
1185 * decl_type: ENUM NAME
1186 */
1187 PARSE_TYPED(decl_type, type_,
1188 NAMED(ENUM, E)
1189 NAMED(NAME, T)) {
1190 type_ = psi_decl_type_init(E->type, T->text);
1191 type_->token = T;
1192 free(E);
1193 }
1194
1195 /*
1196 * decl_type: decl_type_token
1197 */
1198 PARSE_TYPED(decl_type, type_,
1199 NAMED(decl_type_token, T)) {
1200 type_ = psi_decl_type_init(T->type, T->text);
1201 type_->token = T;
1202 }
1203
1204 /*
1205 * const_decl_type: decl_type
1206 */
1207 PARSE_TYPED(const_decl_type, type,
1208 TYPED(decl_type, type_)) {
1209 type = type_;
1210 }
1211
1212 /*
1213 * const_decl_type: CONST decl_type
1214 */
1215 PARSE_TYPED(const_decl_type, type,
1216 TOKEN(CONST)
1217 TYPED(decl_type, type_)) {
1218 type = type_;
1219 }
1220
1221 /*
1222 * impl: impl_func { impl_stmts }
1223 */
1224 PARSE_TYPED(impl, impl,
1225 TYPED(impl_func, func)
1226 TOKEN(LBRACE)
1227 TYPED(impl_stmts, stmts)
1228 TOKEN(RBRACE)) {
1229 impl = psi_impl_init(func, stmts);
1230 }
1231
1232 /*
1233 * impl: STATIC impl_func { impl_stmts }
1234 */
1235 PARSE_TYPED(impl, impl,
1236 TOKEN(STATIC)
1237 TYPED(impl_func, func)
1238 TOKEN(LBRACE)
1239 TYPED(impl_stmts, stmts)
1240 TOKEN(RBRACE)) {
1241 func->static_memory = 1;
1242 impl = psi_impl_init(func, stmts);
1243 }
1244
1245 /*
1246 * impl_func: FUNCTION reference NSNAME ( ) : impl_type
1247 */
1248 PARSE_TYPED(impl_func, func,
1249 TOKEN(FUNCTION)
1250 TYPED(reference, r)
1251 NAMED(NSNAME, NAME)
1252 TOKEN(LPAREN)
1253 TOKEN(RPAREN)
1254 TOKEN(COLON)
1255 TYPED(impl_type, type)) {
1256 func = psi_impl_func_init(NAME->text, NULL, type);
1257 func->token = NAME;
1258 func->return_reference = r;
1259 }
1260
1261 /*
1262 * impl_func: FUNCTION reference NSNAME ( impl_args ) : impl_type
1263 */
1264 PARSE_TYPED(impl_func, func,
1265 TOKEN(FUNCTION)
1266 TYPED(reference, r)
1267 NAMED(NSNAME, NAME)
1268 TOKEN(LPAREN)
1269 TYPED(impl_args, args)
1270 TOKEN(RPAREN)
1271 TOKEN(COLON)
1272 TYPED(impl_type, type)) {
1273 func = psi_impl_func_init(NAME->text, args, type);
1274 func->token = NAME;
1275 func->return_reference = r;
1276 }
1277
1278 /*
1279 * impl_func: FUNCTION reference NSNAME ( impl_args , impl_type reference ... DOLLAR_NAME ) : impl_type
1280 */
1281 PARSE_TYPED(impl_func, func,
1282 TOKEN(FUNCTION)
1283 TYPED(reference, func_r)
1284 NAMED(NSNAME, NAME)
1285 TOKEN(LPAREN)
1286 TYPED(impl_args, args)
1287 TOKEN(COMMA)
1288 TYPED(impl_type, va_type)
1289 TYPED(reference, va_r)
1290 TOKEN(ELLIPSIS)
1291 NAMED(DOLLAR_NAME, T)
1292 TOKEN(RPAREN)
1293 TOKEN(COLON)
1294 TYPED(impl_type, func_type)) {
1295 func = psi_impl_func_init(NAME->text, args, func_type);
1296 func->token = NAME;
1297 func->return_reference = func_r;
1298 func->vararg = psi_impl_arg_init(va_type, psi_impl_var_init(T->text, va_r), NULL);
1299 free(T);
1300 }
1301
1302 /*
1303 * impl_def_val: impl_def_val_token
1304 */
1305 PARSE_TYPED(impl_def_val, def,
1306 NAMED(impl_def_val_token, T)) {
1307 def = psi_impl_def_val_init(T->type, T->text);
1308 def->token = T;
1309 }
1310
1311 /*
1312 * impl_var: reference DOLLAR_NAME
1313 */
1314 PARSE_TYPED(impl_var, var,
1315 TYPED(reference, r)
1316 NAMED(DOLLAR_NAME, T)) {
1317 var = psi_impl_var_init(T->text, r);
1318 var->token = T;
1319 }
1320
1321 /*
1322 * impl_type: impl_type_token
1323 */
1324 PARSE_TYPED(impl_type, type_,
1325 NAMED(impl_type_token, T)) {
1326 type_ = psi_impl_type_init(T->type, T->text);
1327 free(T);
1328 }
1329
1330 /*
1331 * impl_arg: impl_type impl_var
1332 */
1333 PARSE_TYPED(impl_arg, arg,
1334 TYPED(impl_type, type)
1335 TYPED(impl_var, var)) {
1336 arg = psi_impl_arg_init(type, var, NULL);
1337 }
1338
1339 /*
1340 * impl_arg: impl_type impl_var = impl_def_val
1341 */
1342 PARSE_TYPED(impl_arg, arg,
1343 TYPED(impl_type, type)
1344 TYPED(impl_var, var)
1345 TOKEN(EQUALS)
1346 TYPED(impl_def_val, def)) {
1347 arg = psi_impl_arg_init(type, var, def);
1348 }
1349
1350 /*
1351 * impl_args: impl_arg
1352 */
1353 PARSE_TYPED(impl_args, args,
1354 TYPED(impl_arg, arg)) {
1355 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_arg_free),
1356 &arg);
1357 }
1358
1359 /*
1360 * impl_args: impl_args , impl_arg
1361 */
1362 PARSE_TYPED(impl_args, args,
1363 TYPED(impl_args, args_)
1364 TOKEN(COMMA)
1365 TYPED(impl_arg, arg)) {
1366 args = psi_plist_add(args_, &arg);
1367 }
1368
1369 /*
1370 * impl_stmts: impl_stmt
1371 */
1372 PARSE_TYPED(impl_stmts, stmts,
1373 TYPED(impl_stmt, stmt)) {
1374 stmts = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_impl_stmt_free),
1375 &stmt);
1376 }
1377
1378 /*
1379 * impl_stmts: impl_stmts , impl_stmt
1380 */
1381 PARSE_TYPED(impl_stmts, stmts,
1382 TYPED(impl_stmts, stmts_)
1383 TYPED(impl_stmt, stmt)) {
1384 stmts = psi_plist_add(stmts_, &stmt);
1385 }
1386
1387 /*
1388 * impl_stmt: return_stmt
1389 */
1390 PARSE_TYPED(impl_stmt, i,
1391 TYPED(return_stmt, r)) {
1392 i = (struct psi_token**) r;
1393 }
1394
1395 /*
1396 * impl_stmt: let_stmt
1397 */
1398 PARSE_TYPED(impl_stmt, i,
1399 TYPED(let_stmt, l)) {
1400 i = (struct psi_token**) l;
1401 }
1402
1403 /*
1404 * impl_stmt: set_stmt
1405 */
1406 PARSE_TYPED(impl_stmt, i,
1407 TYPED(set_stmt, s)) {
1408 i = (struct psi_token**) s;
1409 }
1410
1411 /*
1412 * impl_stmt: free_stmt
1413 */
1414 PARSE_TYPED(impl_stmt, i,
1415 TYPED(free_stmt, f)) {
1416 i = (struct psi_token**) f;
1417 }
1418
1419 /*
1420 * number: number_token
1421 */
1422 PARSE_TYPED(number, exp,
1423 NAMED(number_token, tok)) {
1424 exp = psi_number_init(tok->type, tok->text);
1425 exp->token = tok;
1426 }
1427
1428 /*
1429 * num_exp: decl_var
1430 */
1431 PARSE_TYPED(number, exp,
1432 TYPED(decl_var, var)) {
1433 exp = psi_number_init(PSI_T_NAME, var);
1434 exp->token = psi_token_copy(var->token);
1435 }
1436
1437 /*
1438 * num_exp: num_exp
1439 */
1440 PARSE_TYPED(num_exp, exp,
1441 TYPED(number, num)) {
1442 exp = psi_num_exp_init_num(num);
1443 exp->token = psi_token_copy(num->token);
1444 }
1445
1446 /*
1447 * num_exp: ( num_exp )
1448 */
1449 PARSE_TYPED(num_exp, exp,
1450 NAMED(LPAREN, L)
1451 TYPED(num_exp, exp_)
1452 TOKEN(RPAREN)) {
1453 exp = psi_num_exp_init_unary(PSI_T_LPAREN, exp_);
1454 exp->token = L;
1455 }
1456
1457 /*
1458 * num_exp: num_exp num_exp_binary_op_token num_exp
1459 */
1460 PARSE_TYPED(num_exp, exp,
1461 TYPED(num_exp, lhs_)
1462 NAMED(num_exp_binary_op_token, OP)
1463 TYPED(num_exp, rhs_)) {
1464 exp = psi_num_exp_init_binary(OP->type, lhs_, rhs_);
1465 exp->token = OP;
1466 }
1467
1468 /*
1469 * num_exp: num_exp_unary_op_token num_exp
1470 */
1471 PARSE_TYPED(num_exp, exp,
1472 NAMED(num_exp_unary_op_token, OP)
1473 TYPED(num_exp, exp_)) {
1474 exp = psi_num_exp_init_unary(OP->type, exp_);
1475 exp->token = OP;
1476 }
1477
1478 /*
1479 * let_exp: NULL
1480 */
1481 PARSE_TYPED(let_exp, val,
1482 TOKEN(NULL)) {
1483 val = psi_let_exp_init(PSI_LET_NULL, NULL);
1484 }
1485
1486 /*
1487 * let_exp: & NULL
1488 */
1489 PARSE_TYPED(let_exp, val,
1490 TOKEN(AMPERSAND)
1491 TOKEN(NULL)) {
1492 val = psi_let_exp_init(PSI_LET_NULL, NULL);
1493 val->is_reference = 1;
1494 }
1495
1496 /*
1497 * let_exp: callback
1498 */
1499 PARSE_TYPED(let_exp, val,
1500 TYPED(let_callback, cb)) {
1501 val = psi_let_exp_init(PSI_LET_CALLBACK, cb);
1502 }
1503
1504 /*
1505 * let_exp: calloc
1506 */
1507 PARSE_TYPED(let_exp, val,
1508 TYPED(let_calloc, ca)) {
1509 val = psi_let_exp_init(PSI_LET_CALLOC, ca);
1510 }
1511
1512 /*
1513 * let_exp: & calloc
1514 */
1515 PARSE_TYPED(let_exp, val,
1516 TOKEN(AMPERSAND)
1517 TYPED(let_calloc, ca)) {
1518 val = psi_let_exp_init(PSI_LET_CALLOC, ca);
1519 val->is_reference = 1;
1520 }
1521
1522 /*
1523 * let_exp: func
1524 */
1525 PARSE_TYPED(let_exp, val,
1526 TYPED(let_func, fn)) {
1527 val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
1528 }
1529
1530 /*
1531 * let_exp: & func
1532 */
1533 PARSE_TYPED(let_exp, val,
1534 TOKEN(AMPERSAND)
1535 TYPED(let_func, fn)) {
1536 val = psi_let_exp_init_ex(NULL, PSI_LET_FUNC, fn);
1537 val->is_reference = 1;
1538 }
1539
1540 /*
1541 * let_exp: num_exp
1542 */
1543 PARSE_TYPED(let_exp, val,
1544 TYPED(num_exp, exp)) {
1545 val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
1546 }
1547
1548 /*
1549 * let_exp: & num_exp
1550 */
1551 PARSE_TYPED(let_exp, val,
1552 TOKEN(AMPERSAND)
1553 TYPED(num_exp, exp)) {
1554 val = psi_let_exp_init_ex(NULL, PSI_LET_NUMEXP, exp);
1555 val->is_reference = 1;
1556 }
1557
1558 /* FIXME
1559 * let_exp: decl_var = let_exp
1560 */
1561 PARSE_TYPED(let_exp, exp,
1562 TYPED(decl_var, var_)
1563 TOKEN(EQUALS)
1564 TYPED(let_exp, val)) {
1565 exp = val;
1566 exp->var = var_;
1567 }
1568
1569 /*
1570 * let_stmt: LET let_exp ;
1571 */
1572 PARSE_TYPED(let_stmt, let,
1573 NAMED(LET, T)
1574 TYPED(let_exp, val)
1575 TOKEN(EOS)) {
1576 let = psi_let_stmt_init(val);
1577 let->token = T;
1578 }
1579
1580 /*
1581 * let_stmt: TEMP decl_var = reference decl_var ;
1582 */
1583 PARSE_TYPED(let_stmt, let,
1584 NAMED(TEMP, T)
1585 TYPED(decl_var, var)
1586 TOKEN(EQUALS)
1587 TYPED(reference, r)
1588 TYPED(decl_var, val_)
1589 TOKEN(EOS)) {
1590 let = psi_let_stmt_init(psi_let_exp_init_ex(var, PSI_LET_TMP, val_));
1591 let->token = T;
1592 let->exp->is_reference = r ? 1 : 0;
1593 }
1594
1595 /*
1596 * let_callback: CALLBACK callback_rval ( impl_var ( callback_arg_lists ) )
1597 */
1598 PARSE_TYPED(let_callback, cb,
1599 NAMED(CALLBACK, T)
1600 NAMED(callback_rval, F)
1601 TOKEN(LPAREN)
1602 TYPED(impl_var, var)
1603 TOKEN(LPAREN)
1604 TYPED(callback_arg_list, args_)
1605 TOKEN(RPAREN)
1606 TOKEN(RPAREN)) {
1607 cb = psi_let_callback_init(psi_let_func_init(F->type, F->text, var), args_);
1608 cb->token = T;
1609 free(F);
1610 }
1611
1612 /*
1613 * let_calloc: CALLOC ( num_exp , num_exp )
1614 */
1615 PARSE_TYPED(let_calloc, alloc,
1616 NAMED(CALLOC, T)
1617 TOKEN(LPAREN)
1618 TYPED(num_exp, nmemb)
1619 TOKEN(COMMA)
1620 TYPED(num_exp, size)
1621 TOKEN(RPAREN)) {
1622 alloc = psi_let_calloc_init(nmemb, size);
1623 alloc->token = T;
1624 }
1625
1626 /*
1627 * let_func: let_func_token ( impl_var )
1628 */
1629 PARSE_TYPED(let_func, func,
1630 NAMED(let_func_token, T)
1631 TOKEN(LPAREN)
1632 TYPED(impl_var, var)
1633 TOKEN(RPAREN)) {
1634 func = psi_let_func_init(T->type, T->text, var);
1635 func->token = T;
1636 }
1637 /*
1638 * let_func: let_func_token ( impl_var , let_exps )
1639 */
1640 PARSE_TYPED(let_func, func,
1641 NAMED(let_func_token, T)
1642 TOKEN(LPAREN)
1643 TYPED(impl_var, var)
1644 TOKEN(COMMA)
1645 TYPED(let_exps, vals)
1646 TOKEN(RPAREN)) {
1647 func = psi_let_func_init(T->type, T->text, var);
1648 func->token = T;
1649 func->inner = vals;
1650 }
1651 /*
1652 * let_exps: let_exp
1653 */
1654 PARSE_TYPED(let_exps, exps,
1655 TYPED(let_exp, exp)) {
1656 exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_let_exp_free),
1657 &exp);
1658 }
1659 /*
1660 * let_exps: let_exps , let_exp
1661 */
1662 PARSE_TYPED(let_exps, exps,
1663 TYPED(let_exps, exps_)
1664 TOKEN(COMMA)
1665 TYPED(let_exp, exp)) {
1666 exps = psi_plist_add(exps_, &exp);
1667 }
1668
1669 /*
1670 * callback_arg_list: <empty>
1671 */
1672 PARSE_TYPED(callback_arg_list, args, ) {
1673 args = NULL;
1674 }
1675
1676 /*
1677 * callback_arg_list: callback_args
1678 */
1679 PARSE_TYPED(callback_arg_list, args,
1680 TYPED(callback_args, args_)) {
1681 args = args_;
1682 }
1683
1684 /*
1685 * callback_args: set_exp
1686 */
1687 PARSE_TYPED(callback_args, args,
1688 TYPED(set_exp, val)) {
1689 args = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
1690 &val);
1691 }
1692
1693 /*
1694 * callback_args: callback_args , set_exp
1695 */
1696 PARSE_TYPED(callback_args, args,
1697 TYPED(callback_args, args_)
1698 TOKEN(COMMA)
1699 TYPED(set_exp, val)) {
1700 args = psi_plist_add(args_, &val);
1701 }
1702
1703 /*
1704 * callback_rval: let_func_token
1705 */
1706 PARSE_NAMED(callback_rval, rval,
1707 NAMED(let_func_token, F)) {
1708 rval = F;
1709 }
1710
1711 /*
1712 * callback_rval: VOID
1713 */
1714 PARSE_NAMED(callback_rval, rval,
1715 NAMED(VOID, V)) {
1716 rval = V;
1717 }
1718
1719
1720 /*
1721 * set_func: set_func_token ( decl_var )
1722 */
1723 PARSE_TYPED(set_func, func,
1724 NAMED(set_func_token, T)
1725 TOKEN(LPAREN)
1726 TYPED(decl_var, var)
1727 TOKEN(RPAREN)) {
1728 func = psi_set_func_init(T->type, T->text, var);
1729 func->token = T;
1730 }
1731
1732 /*
1733 * set_func: set_func_token ( decl_var , set_exps )
1734 */
1735 PARSE_TYPED(set_func, func,
1736 NAMED(set_func_token, T)
1737 TOKEN(LPAREN)
1738 TYPED(decl_var, var)
1739 TOKEN(COMMA)
1740 TYPED(set_exps, vals)
1741 TOKEN(RPAREN)) {
1742 func = psi_set_func_init(T->type, T->text, var);
1743 func->token = T;
1744 func->inner = vals;
1745 }
1746
1747 /*
1748 * set_func: set_func_token ( decl_var , ... )
1749 */
1750 PARSE_TYPED(set_func, func,
1751 NAMED(set_func_token, T)
1752 TOKEN(LPAREN)
1753 TYPED(decl_var, var)
1754 TOKEN(COMMA)
1755 TOKEN(ELLIPSIS)
1756 TOKEN(RPAREN)) {
1757 func = psi_set_func_init(T->type, T->text, var);
1758 func->token = T;
1759 func->recursive = 1;
1760 }
1761
1762 /*
1763 * set_exp: set_func
1764 */
1765 PARSE_TYPED(set_exp, val,
1766 TYPED(set_func, fn)) {
1767 val = psi_set_exp_init(PSI_SET_FUNC, fn);
1768 }
1769
1770 /*
1771 * set_exp: num_exp
1772 */
1773 PARSE_TYPED(set_exp, val,
1774 TYPED(num_exp, num)) {
1775 val = psi_set_exp_init(PSI_SET_NUMEXP, num);
1776 }
1777
1778 /*
1779 * set_exps: set_exp
1780 */
1781 PARSE_TYPED(set_exps, exps,
1782 TYPED(set_exp, exp)) {
1783 exps = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_set_exp_free),
1784 &exp);
1785 }
1786
1787 /*
1788 * set_exps: set_exps , set_exp
1789 */
1790 PARSE_TYPED(set_exps, exps,
1791 TYPED(set_exps, exps_)
1792 TOKEN(COMMA)
1793 TYPED(set_exp, exp)) {
1794 exps = psi_plist_add(exps_, &exp);
1795 }
1796
1797 /* FIXME
1798 * set_exp: impl_var = set_exp
1799 */
1800 PARSE_TYPED(set_exp, exp,
1801 TYPED(impl_var, var_)
1802 TOKEN(EQUALS)
1803 TYPED(set_exp, val)) {
1804 exp = val;
1805 exp->var = var_;
1806 }
1807
1808 /*
1809 * set_stmt: SET set_exp ;
1810 */
1811 PARSE_TYPED(set_stmt, set,
1812 NAMED(SET, T)
1813 TYPED(set_exp, exp)
1814 TOKEN(EOS)) {
1815 set = psi_set_stmt_init(exp);
1816 set->token = T;
1817 }
1818
1819 /*
1820 * return_stmt: RETURN set_exp ;
1821 */
1822 PARSE_TYPED(return_stmt, ret,
1823 NAMED(RETURN, T)
1824 TYPED(set_func, func)
1825 TOKEN(EOS)) {
1826 ret = psi_return_stmt_init(psi_set_exp_init(PSI_SET_FUNC, func));
1827 ret->token = T;
1828 }
1829
1830 /*
1831 * free_stmt: FREE free_exps ;
1832 */
1833 PARSE_TYPED(free_stmt, free,
1834 NAMED(FREE, T)
1835 TYPED(free_exps, calls)
1836 TOKEN(EOS)) {
1837 free = psi_free_stmt_init(calls);
1838 free->token = T;
1839 }
1840
1841 /*
1842 * free_exps: free_exp
1843 */
1844 PARSE_TYPED(free_exps, calls,
1845 TYPED(free_exp, call)) {
1846 calls = psi_plist_add(psi_plist_init((psi_plist_dtor) psi_free_exp_free),
1847 &call);
1848 }
1849
1850 /*
1851 * free_exps: free_exps , free_exp
1852 */
1853 PARSE_TYPED(free_exps, calls,
1854 TYPED(free_exps, calls_)
1855 TOKEN(COMMA)
1856 TYPED(free_exp, call)) {
1857 calls = psi_plist_add(calls_, &call);
1858 }
1859
1860 /*
1861 * free_exp: NAME ( decl_vars )
1862 */
1863 PARSE_TYPED(free_exp, call,
1864 NAMED(NAME, F)
1865 TOKEN(LPAREN)
1866 TYPED(decl_vars, vars)
1867 TOKEN(RPAREN)) {
1868 call = psi_free_exp_init(F->text, vars);
1869 call->token = F;
1870 }
1871
1872 /*
1873 * reference: <empty>
1874 */
1875 PARSE_TYPED(reference, r, ) {
1876 r = false;
1877 }
1878
1879 /*
1880 * reference: &
1881 */
1882 PARSE_TYPED(reference, r,
1883 TOKEN(AMPERSAND)) {
1884 r = true;
1885 }
1886
1887 /*
1888 * indirection: <empty>
1889 */
1890 PARSE_TYPED(indirection, i, ){
1891 i = 0;
1892 }
1893
1894 /*
1895 * indirection: pointers
1896 */
1897 PARSE_TYPED(indirection, i,
1898 TYPED(pointers, p)) {
1899 i = p;
1900 }
1901
1902 /*
1903 * pointers: *
1904 */
1905 PARSE_TYPED(pointers, p,
1906 TOKEN(ASTERISK)) {
1907 p = 1;
1908 }
1909
1910 /*
1911 * pointers: pointers *
1912 */
1913 PARSE_TYPED(pointers, p,
1914 TYPED(pointers, p_)
1915 TOKEN(ASTERISK)) {
1916 p = p_+1;
1917 }
PHP System Interface / POSIX Standard Interface