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


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