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