1 %{
2 /*
3  * CDDL HEADER START
4  *
5  * The contents of this file are subject to the terms of the
6  * Common Development and Distribution License, Version 1.0 only
7  * (the "License").  You may not use this file except in compliance
8  * with the License.
9  *
10  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
11  * or http://www.opensolaris.org/os/licensing.
12  * See the License for the specific language governing permissions
13  * and limitations under the License.
14  *
15  * When distributing Covered Code, include this CDDL HEADER in each
16  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
17  * If applicable, add the following below this CDDL HEADER, with the
18  * fields enclosed by brackets "[]" replaced with your own identifying
19  * information: Portions Copyright [yyyy] [name of copyright owner]
20  *
21  * CDDL HEADER END
22  *
23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Copyright (c) 2014, 2016 by Delphix. All rights reserved.
29  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
30  */
31 
32 #include <dt_impl.h>
33 
34 #define	OP1(op, c)	dt_node_op1(op, c)
35 #define	OP2(op, l, r)	dt_node_op2(op, l, r)
36 #define	OP3(x, y, z)	dt_node_op3(x, y, z)
37 #define	LINK(l, r)	dt_node_link(l, r)
38 #define	DUP(s)		strdup(s)
39 
40 %}
41 
42 %union {
43 	dt_node_t *l_node;
44 	dt_decl_t *l_decl;
45 	char *l_str;
46 	uintmax_t l_int;
47 	int l_tok;
48 }
49 
50 %token	DT_TOK_COMMA DT_TOK_ELLIPSIS
51 %token	DT_TOK_ASGN DT_TOK_ADD_EQ DT_TOK_SUB_EQ DT_TOK_MUL_EQ
52 %token	DT_TOK_DIV_EQ DT_TOK_MOD_EQ DT_TOK_AND_EQ DT_TOK_XOR_EQ DT_TOK_OR_EQ
53 %token	DT_TOK_LSH_EQ DT_TOK_RSH_EQ DT_TOK_QUESTION DT_TOK_COLON
54 %token	DT_TOK_LOR DT_TOK_LXOR DT_TOK_LAND
55 %token	DT_TOK_BOR DT_TOK_XOR DT_TOK_BAND DT_TOK_EQU DT_TOK_NEQ
56 %token	DT_TOK_LT DT_TOK_LE DT_TOK_GT DT_TOK_GE DT_TOK_LSH DT_TOK_RSH
57 %token	DT_TOK_ADD DT_TOK_SUB DT_TOK_MUL DT_TOK_DIV DT_TOK_MOD
58 %token	DT_TOK_LNEG DT_TOK_BNEG DT_TOK_ADDADD DT_TOK_SUBSUB
59 %token	DT_TOK_PREINC DT_TOK_POSTINC DT_TOK_PREDEC DT_TOK_POSTDEC
60 %token	DT_TOK_IPOS DT_TOK_INEG DT_TOK_DEREF DT_TOK_ADDROF
61 %token	DT_TOK_OFFSETOF DT_TOK_SIZEOF DT_TOK_STRINGOF DT_TOK_XLATE
62 %token	DT_TOK_LPAR DT_TOK_RPAR DT_TOK_LBRAC DT_TOK_RBRAC DT_TOK_PTR DT_TOK_DOT
63 
64 %token <l_str>	DT_TOK_STRING
65 %token <l_str>	DT_TOK_IDENT
66 %token <l_str>	DT_TOK_PSPEC
67 %token <l_str>	DT_TOK_AGG
68 %token <l_str>	DT_TOK_TNAME
69 %token <l_int>	DT_TOK_INT
70 
71 %token	DT_KEY_AUTO
72 %token	DT_KEY_BREAK
73 %token	DT_KEY_CASE
74 %token	DT_KEY_CHAR
75 %token	DT_KEY_CONST
76 %token	DT_KEY_CONTINUE
77 %token	DT_KEY_COUNTER
78 %token	DT_KEY_DEFAULT
79 %token	DT_KEY_DO
80 %token	DT_KEY_DOUBLE
81 %token	DT_KEY_ELSE
82 %token	DT_KEY_ENUM
83 %token	DT_KEY_EXTERN
84 %token	DT_KEY_FLOAT
85 %token	DT_KEY_FOR
86 %token	DT_KEY_GOTO
87 %token	DT_KEY_IF
88 %token	DT_KEY_IMPORT
89 %token	DT_KEY_INLINE
90 %token	DT_KEY_INT
91 %token	DT_KEY_LONG
92 %token	DT_KEY_PROBE
93 %token	DT_KEY_PROVIDER
94 %token	DT_KEY_REGISTER
95 %token	DT_KEY_RESTRICT
96 %token	DT_KEY_RETURN
97 %token	DT_KEY_SELF
98 %token	DT_KEY_SHORT
99 %token	DT_KEY_SIGNED
100 %token	DT_KEY_STATIC
101 %token	DT_KEY_STRING
102 %token	DT_KEY_STRUCT
103 %token	DT_KEY_SWITCH
104 %token	DT_KEY_THIS
105 %token	DT_KEY_TYPEDEF
106 %token	DT_KEY_UNION
107 %token	DT_KEY_UNSIGNED
108 %token	DT_KEY_USERLAND
109 %token	DT_KEY_VOID
110 %token	DT_KEY_VOLATILE
111 %token	DT_KEY_WHILE
112 %token	DT_KEY_XLATOR
113 
114 %token	DT_TOK_EPRED
115 %token	DT_CTX_DEXPR
116 %token	DT_CTX_DPROG
117 %token	DT_CTX_DTYPE
118 %token	DT_TOK_EOF	0
119 
120 %left	DT_TOK_COMMA
121 %right	DT_TOK_ASGN DT_TOK_ADD_EQ DT_TOK_SUB_EQ DT_TOK_MUL_EQ DT_TOK_DIV_EQ
122 	DT_TOK_MOD_EQ DT_TOK_AND_EQ DT_TOK_XOR_EQ DT_TOK_OR_EQ DT_TOK_LSH_EQ
123 	DT_TOK_RSH_EQ
124 %left	DT_TOK_QUESTION DT_TOK_COLON
125 %left	DT_TOK_LOR
126 %left	DT_TOK_LXOR
127 %left	DT_TOK_LAND
128 %left	DT_TOK_BOR
129 %left	DT_TOK_XOR
130 %left	DT_TOK_BAND
131 %left	DT_TOK_EQU DT_TOK_NEQ
132 %left	DT_TOK_LT DT_TOK_LE DT_TOK_GT DT_TOK_GE
133 %left	DT_TOK_LSH DT_TOK_RSH
134 %left	DT_TOK_ADD DT_TOK_SUB
135 %left	DT_TOK_MUL DT_TOK_DIV DT_TOK_MOD
136 %right	DT_TOK_LNEG DT_TOK_BNEG DT_TOK_ADDADD DT_TOK_SUBSUB
137 	DT_TOK_IPOS DT_TOK_INEG
138 %right	DT_TOK_DEREF DT_TOK_ADDROF DT_TOK_SIZEOF DT_TOK_STRINGOF DT_TOK_XLATE
139 %left	DT_TOK_LPAR DT_TOK_RPAR DT_TOK_LBRAC DT_TOK_RBRAC DT_TOK_PTR DT_TOK_DOT
140 
141 %type	<l_node>	d_expression
142 %type	<l_node>	d_program
143 %type	<l_node>	d_type
144 
145 %type	<l_node>	translation_unit
146 %type	<l_node>	external_declaration
147 %type	<l_node>	inline_definition
148 %type	<l_node>	translator_definition
149 %type	<l_node>	translator_member_list
150 %type	<l_node>	translator_member
151 %type	<l_node>	provider_definition
152 %type	<l_node>	provider_probe_list
153 %type	<l_node>	provider_probe
154 %type	<l_node>	probe_definition
155 %type	<l_node>	probe_specifiers
156 %type	<l_node>	probe_specifier_list
157 %type	<l_node>	probe_specifier
158 %type	<l_node>	statement_list
159 %type	<l_node>	statement_list_impl
160 %type	<l_node>	statement_or_block
161 %type	<l_node>	statement
162 %type	<l_node>	declaration
163 %type	<l_node>	init_declarator_list
164 %type	<l_node>	init_declarator
165 
166 %type	<l_decl>	type_specifier
167 %type	<l_decl>	type_qualifier
168 %type	<l_decl>	struct_or_union_specifier
169 %type	<l_decl>	specifier_qualifier_list
170 %type	<l_decl>	enum_specifier
171 %type	<l_decl>	declarator
172 %type	<l_decl>	direct_declarator
173 %type	<l_decl>	pointer
174 %type	<l_decl>	type_qualifier_list
175 %type	<l_decl>	type_name
176 %type	<l_decl>	abstract_declarator
177 %type	<l_decl>	direct_abstract_declarator
178 
179 %type	<l_node>	parameter_type_list
180 %type	<l_node>	parameter_list
181 %type	<l_node>	parameter_declaration
182 
183 %type	<l_node>	array
184 %type	<l_node>	array_parameters
185 %type	<l_node>	function
186 %type	<l_node>	function_parameters
187 
188 %type	<l_node>	expression
189 %type	<l_node>	assignment_expression
190 %type	<l_node>	conditional_expression
191 %type	<l_node>	constant_expression
192 %type	<l_node>	logical_or_expression
193 %type	<l_node>	logical_xor_expression
194 %type	<l_node>	logical_and_expression
195 %type	<l_node>	inclusive_or_expression
196 %type	<l_node>	exclusive_or_expression
197 %type	<l_node>	and_expression
198 %type	<l_node>	equality_expression
199 %type	<l_node>	relational_expression
200 %type	<l_node>	shift_expression
201 %type	<l_node>	additive_expression
202 %type	<l_node>	multiplicative_expression
203 %type	<l_node>	cast_expression
204 %type	<l_node>	unary_expression
205 %type	<l_node>	postfix_expression
206 %type	<l_node>	primary_expression
207 %type	<l_node>	argument_expression_list
208 
209 %type	<l_tok>		assignment_operator
210 %type	<l_tok>		unary_operator
211 %type	<l_tok>		struct_or_union
212 
213 %%
214 
215 dtrace_program: d_expression DT_TOK_EOF { return (dt_node_root($1)); }
216 	|	d_program DT_TOK_EOF { return (dt_node_root($1)); }
217 	|	d_type DT_TOK_EOF { return (dt_node_root($1)); }
218 	;
219 
220 d_expression:	DT_CTX_DEXPR { $$ = NULL; }
221 	|	DT_CTX_DEXPR expression { $$ = $2; }
222 	;
223 
224 d_program:	DT_CTX_DPROG { $$ = dt_node_program(NULL); }
225 	|	DT_CTX_DPROG translation_unit { $$ = dt_node_program($2); }
226 	;
227 
228 d_type:		DT_CTX_DTYPE { $$ = NULL; }
229 	|	DT_CTX_DTYPE type_name { $$ = (dt_node_t *)$2; }
230 	;
231 
232 translation_unit:
233 		external_declaration
234 	|	translation_unit external_declaration { $$ = LINK($1, $2); }
235 	;
236 
237 external_declaration:
238 		inline_definition
239 	|	translator_definition
240 	|	provider_definition
241 	|	probe_definition
242 	|	declaration
243 	;
244 
245 inline_definition:
246 		DT_KEY_INLINE declaration_specifiers declarator
247 		    { dt_scope_push(NULL, CTF_ERR); } DT_TOK_ASGN
248 		    assignment_expression ';' {
249 			/*
250 			 * We push a new declaration scope before shifting the
251 			 * assignment_expression in order to preserve ds_class
252 			 * and ds_ident for use in dt_node_inline().  Once the
253 			 * entire inline_definition rule is matched, pop the
254 			 * scope and construct the inline using the saved decl.
255 			 */
256 			dt_scope_pop();
257 			$$ = dt_node_inline($6);
258 		}
259 	;
260 
261 translator_definition:
262 		DT_KEY_XLATOR type_name DT_TOK_LT type_name
263 		    DT_TOK_IDENT DT_TOK_GT '{' translator_member_list '}' ';' {
264 			$$ = dt_node_xlator($2, $4, $5, $8);
265 		}
266 	|	DT_KEY_XLATOR type_name DT_TOK_LT type_name
267 		    DT_TOK_IDENT DT_TOK_GT '{' '}' ';' {
268 			$$ = dt_node_xlator($2, $4, $5, NULL);
269 		}
270 	;
271 
272 translator_member_list:
273 		translator_member
274 	|	translator_member_list translator_member { $$ = LINK($1,$2); }
275 	;
276 
277 translator_member:
278 		DT_TOK_IDENT DT_TOK_ASGN assignment_expression ';' {
279 			$$ = dt_node_member(NULL, $1, $3);
280 		}
281 	;
282 
283 provider_definition:
284 		DT_KEY_PROVIDER DT_TOK_IDENT '{' provider_probe_list '}' ';' {
285 			$$ = dt_node_provider($2, $4);
286 		}
287 	|	DT_KEY_PROVIDER DT_TOK_IDENT '{' '}' ';' {
288 			$$ = dt_node_provider($2, NULL);
289 		}
290 	;
291 
292 provider_probe_list:
293 		provider_probe
294 	|	provider_probe_list provider_probe { $$ = LINK($1, $2); }
295 	;
296 
297 provider_probe:
298 		DT_KEY_PROBE DT_TOK_IDENT function DT_TOK_COLON function ';' {
299 			$$ = dt_node_probe($2, 2, $3, $5);
300 		}
301 	|	DT_KEY_PROBE DT_TOK_IDENT function ';' {
302 			$$ = dt_node_probe($2, 1, $3, NULL);
303 		}
304 	;
305 
306 
307 probe_definition:
308 		probe_specifiers {
309 			/*
310 			 * If the input stream is a file, do not permit a probe
311 			 * specification without / <pred> / or { <act> } after
312 			 * it.  This can only occur if the next token is EOF or
313 			 * an ambiguous predicate was slurped up as a comment.
314 			 * We cannot perform this check if input() is a string
315 			 * because dtrace(1M) [-fmnP] also use the compiler and
316 			 * things like dtrace -n BEGIN have to be accepted.
317 			 */
318 			if (yypcb->pcb_fileptr != NULL) {
319 				dnerror($1, D_SYNTAX, "expected predicate and/"
320 				    "or actions following probe description\n");
321 			}
322 			$$ = dt_node_clause($1, NULL, NULL);
323 			yybegin(YYS_CLAUSE);
324 		}
325 	|	probe_specifiers '{' statement_list '}' {
326 			$$ = dt_node_clause($1, NULL, $3);
327 			yybegin(YYS_CLAUSE);
328 		}
329 	|	probe_specifiers DT_TOK_DIV expression DT_TOK_EPRED {
330 			dnerror($3, D_SYNTAX, "expected actions { } following "
331 			    "probe description and predicate\n");
332 		}
333 	|	probe_specifiers DT_TOK_DIV expression DT_TOK_EPRED
334 		    '{' statement_list '}' {
335 			$$ = dt_node_clause($1, $3, $6);
336 			yybegin(YYS_CLAUSE);
337 		}
338 	;
339 
340 probe_specifiers:
341 		probe_specifier_list { yybegin(YYS_EXPR); $$ = $1; }
342 	;
343 
344 probe_specifier_list:
345 		probe_specifier
346 	|	probe_specifier_list DT_TOK_COMMA probe_specifier {
347 			$$ = LINK($1, $3);
348 		}
349 	;
350 
351 probe_specifier:
352 		DT_TOK_PSPEC { $$ = dt_node_pdesc_by_name($1); }
353 	|	DT_TOK_INT   { $$ = dt_node_pdesc_by_id($1); }
354 	;
355 
356 statement_list_impl: /* empty */ { $$ = NULL; }
357 	|	statement_list_impl statement { $$ = LINK($1, $2); }
358 	;
359 
360 statement_list:
361 		statement_list_impl { $$ = $1; }
362 	|	statement_list_impl expression {
363 			$$ = LINK($1, dt_node_statement($2));
364 		}
365 	;
366 
367 statement_or_block:
368 		statement
369 	|	'{' statement_list '}' { $$ = $2; }
370 
371 statement:	';' { $$ = NULL; }
372 	|	expression ';' { $$ = dt_node_statement($1); }
373 	|	DT_KEY_IF DT_TOK_LPAR expression DT_TOK_RPAR statement_or_block {
374 			$$ = dt_node_if($3, $5, NULL);
375 		}
376 	|	DT_KEY_IF DT_TOK_LPAR expression DT_TOK_RPAR
377 		statement_or_block DT_KEY_ELSE statement_or_block {
378 			$$ = dt_node_if($3, $5, $7);
379 		}
380 	;
381 
382 argument_expression_list:
383 		assignment_expression
384 	|	argument_expression_list DT_TOK_COMMA assignment_expression {
385 			$$ = LINK($1, $3);
386 		}
387 	;
388 
389 primary_expression:
390 		DT_TOK_IDENT { $$ = dt_node_ident($1); }
391 	|	DT_TOK_AGG { $$ = dt_node_ident($1); }
392 	|	DT_TOK_INT { $$ = dt_node_int($1); }
393 	|	DT_TOK_STRING { $$ = dt_node_string($1); }
394 	|	DT_KEY_SELF { $$ = dt_node_ident(DUP("self")); }
395 	|	DT_KEY_THIS { $$ = dt_node_ident(DUP("this")); }
396 	|	DT_TOK_LPAR expression DT_TOK_RPAR { $$ = $2; }
397 	;
398 
399 postfix_expression:
400 		primary_expression
401 	|	postfix_expression
402 		    DT_TOK_LBRAC argument_expression_list DT_TOK_RBRAC {
403 			$$ = OP2(DT_TOK_LBRAC, $1, $3);
404 		}
405 	|	postfix_expression DT_TOK_LPAR DT_TOK_RPAR {
406 			$$ = dt_node_func($1, NULL);
407 		}
408 	|	postfix_expression
409 		    DT_TOK_LPAR argument_expression_list DT_TOK_RPAR {
410 			$$ = dt_node_func($1, $3);
411 		}
412 	|	postfix_expression DT_TOK_DOT DT_TOK_IDENT {
413 			$$ = OP2(DT_TOK_DOT, $1, dt_node_ident($3));
414 		}
415 	|	postfix_expression DT_TOK_DOT DT_TOK_TNAME {
416 			$$ = OP2(DT_TOK_DOT, $1, dt_node_ident($3));
417 		}
418 	|	postfix_expression DT_TOK_PTR DT_TOK_IDENT {
419 			$$ = OP2(DT_TOK_PTR, $1, dt_node_ident($3));
420 		}
421 	|	postfix_expression DT_TOK_PTR DT_TOK_TNAME {
422 			$$ = OP2(DT_TOK_PTR, $1, dt_node_ident($3));
423 		}
424 	|	postfix_expression DT_TOK_ADDADD {
425 			$$ = OP1(DT_TOK_POSTINC, $1);
426 		}
427 	|	postfix_expression DT_TOK_SUBSUB {
428 			$$ = OP1(DT_TOK_POSTDEC, $1);
429 		}
430 	|	DT_TOK_OFFSETOF DT_TOK_LPAR type_name DT_TOK_COMMA
431 		    DT_TOK_IDENT DT_TOK_RPAR {
432 			$$ = dt_node_offsetof($3, $5);
433 		}
434 	|	DT_TOK_OFFSETOF DT_TOK_LPAR type_name DT_TOK_COMMA
435 		    DT_TOK_TNAME DT_TOK_RPAR {
436 			$$ = dt_node_offsetof($3, $5);
437 		}
438 	|	DT_TOK_XLATE DT_TOK_LT type_name DT_TOK_GT
439 		    DT_TOK_LPAR expression DT_TOK_RPAR {
440 			$$ = OP2(DT_TOK_XLATE, dt_node_type($3), $6);
441 		}
442 	;
443 
444 unary_expression:
445 		postfix_expression
446 	|	DT_TOK_ADDADD unary_expression { $$ = OP1(DT_TOK_PREINC, $2); }
447 	|	DT_TOK_SUBSUB unary_expression { $$ = OP1(DT_TOK_PREDEC, $2); }
448 	|	unary_operator cast_expression { $$ = OP1($1, $2); }
449 	|	DT_TOK_SIZEOF unary_expression { $$ = OP1(DT_TOK_SIZEOF, $2); }
450 	|	DT_TOK_SIZEOF DT_TOK_LPAR type_name DT_TOK_RPAR {
451 			$$ = OP1(DT_TOK_SIZEOF, dt_node_type($3));
452 		}
453 	|	DT_TOK_STRINGOF unary_expression {
454 			$$ = OP1(DT_TOK_STRINGOF, $2);
455 		}
456 	;
457 
458 unary_operator:	DT_TOK_BAND { $$ = DT_TOK_ADDROF; }
459 	|	DT_TOK_MUL { $$ = DT_TOK_DEREF; }
460 	|	DT_TOK_ADD { $$ = DT_TOK_IPOS; }
461 	|	DT_TOK_SUB { $$ = DT_TOK_INEG; }
462 	|	DT_TOK_BNEG { $$ = DT_TOK_BNEG; }
463 	|	DT_TOK_LNEG { $$ = DT_TOK_LNEG; }
464 	;
465 
466 cast_expression:
467 		unary_expression
468 	|	DT_TOK_LPAR type_name DT_TOK_RPAR cast_expression {
469 			$$ = OP2(DT_TOK_LPAR, dt_node_type($2), $4);
470 		}
471 	;
472 
473 multiplicative_expression:
474 		cast_expression
475 	|	multiplicative_expression DT_TOK_MUL cast_expression {
476 			$$ = OP2(DT_TOK_MUL, $1, $3);
477 		}
478 	|	multiplicative_expression DT_TOK_DIV cast_expression {
479 			$$ = OP2(DT_TOK_DIV, $1, $3);
480 		}
481 	|	multiplicative_expression DT_TOK_MOD cast_expression {
482 			$$ = OP2(DT_TOK_MOD, $1, $3);
483 		}
484 	;
485 
486 additive_expression:
487 		multiplicative_expression
488 	|	additive_expression DT_TOK_ADD multiplicative_expression {
489 			$$ = OP2(DT_TOK_ADD, $1, $3);
490 		}
491 	|	additive_expression DT_TOK_SUB multiplicative_expression {
492 			$$ = OP2(DT_TOK_SUB, $1, $3);
493 		}
494 	;
495 
496 shift_expression:
497 		additive_expression
498 	|	shift_expression DT_TOK_LSH additive_expression {
499 			$$ = OP2(DT_TOK_LSH, $1, $3);
500 		}
501 	|	shift_expression DT_TOK_RSH additive_expression {
502 			$$ = OP2(DT_TOK_RSH, $1, $3);
503 		}
504 	;
505 
506 relational_expression:
507 		shift_expression
508 	|	relational_expression DT_TOK_LT shift_expression {
509 			$$ = OP2(DT_TOK_LT, $1, $3);
510 		}
511 	|	relational_expression DT_TOK_GT shift_expression {
512 			$$ = OP2(DT_TOK_GT, $1, $3);
513 		}
514 	|	relational_expression DT_TOK_LE shift_expression {
515 			$$ = OP2(DT_TOK_LE, $1, $3);
516 		}
517 	|	relational_expression DT_TOK_GE shift_expression {
518 			$$ = OP2(DT_TOK_GE, $1, $3);
519 		}
520 	;
521 
522 equality_expression:
523 		relational_expression
524 	|	equality_expression DT_TOK_EQU relational_expression {
525 			$$ = OP2(DT_TOK_EQU, $1, $3);
526 		}
527 	|	equality_expression DT_TOK_NEQ relational_expression {
528 			$$ = OP2(DT_TOK_NEQ, $1, $3);
529 		}
530 	;
531 
532 and_expression:
533 		equality_expression
534 	|	and_expression DT_TOK_BAND equality_expression {
535 			$$ = OP2(DT_TOK_BAND, $1, $3);
536 		}
537 	;
538 
539 exclusive_or_expression:
540 		and_expression
541 	|	exclusive_or_expression DT_TOK_XOR and_expression {
542 			$$ = OP2(DT_TOK_XOR, $1, $3);
543 		}
544 	;
545 
546 inclusive_or_expression:
547 		exclusive_or_expression
548 	|	inclusive_or_expression DT_TOK_BOR exclusive_or_expression {
549 			$$ = OP2(DT_TOK_BOR, $1, $3);
550 		}
551 	;
552 
553 logical_and_expression:
554 		inclusive_or_expression
555 	|	logical_and_expression DT_TOK_LAND inclusive_or_expression {
556 			$$ = OP2(DT_TOK_LAND, $1, $3);
557 		}
558 	;
559 
560 logical_xor_expression:
561 		logical_and_expression
562 	|	logical_xor_expression DT_TOK_LXOR logical_and_expression {
563 			$$ = OP2(DT_TOK_LXOR, $1, $3);
564 		}
565 	;
566 
567 logical_or_expression:
568 		logical_xor_expression
569 	|	logical_or_expression DT_TOK_LOR logical_xor_expression {
570 			$$ = OP2(DT_TOK_LOR, $1, $3);
571 		}
572 	;
573 
574 constant_expression: conditional_expression
575 	;
576 
577 conditional_expression:
578 		logical_or_expression
579 	|	logical_or_expression DT_TOK_QUESTION expression DT_TOK_COLON
580 		    conditional_expression { $$ = OP3($1, $3, $5); }
581 	;
582 
583 assignment_expression:
584 		conditional_expression
585 	|	unary_expression assignment_operator assignment_expression {
586 			$$ = OP2($2, $1, $3);
587 		}
588 	;
589 
590 assignment_operator:
591 		DT_TOK_ASGN   { $$ = DT_TOK_ASGN; }
592 	|	DT_TOK_MUL_EQ { $$ = DT_TOK_MUL_EQ; }
593 	|	DT_TOK_DIV_EQ { $$ = DT_TOK_DIV_EQ; }
594 	|	DT_TOK_MOD_EQ { $$ = DT_TOK_MOD_EQ; }
595 	|	DT_TOK_ADD_EQ { $$ = DT_TOK_ADD_EQ; }
596 	|	DT_TOK_SUB_EQ { $$ = DT_TOK_SUB_EQ; }
597 	|	DT_TOK_LSH_EQ { $$ = DT_TOK_LSH_EQ; }
598 	|	DT_TOK_RSH_EQ { $$ = DT_TOK_RSH_EQ; }
599 	|	DT_TOK_AND_EQ { $$ = DT_TOK_AND_EQ; }
600 	|	DT_TOK_XOR_EQ { $$ = DT_TOK_XOR_EQ; }
601 	|	DT_TOK_OR_EQ  { $$ = DT_TOK_OR_EQ; }
602 	;
603 
604 expression:	assignment_expression
605 	|	expression DT_TOK_COMMA assignment_expression {
606 			$$ = OP2(DT_TOK_COMMA, $1, $3);
607 		}
608 	;
609 
610 declaration:	declaration_specifiers ';' {
611 			$$ = dt_node_decl();
612 			dt_decl_free(dt_decl_pop());
613 			yybegin(YYS_CLAUSE);
614 		}
615 	|	declaration_specifiers init_declarator_list ';' {
616 			$$ = $2;
617 			dt_decl_free(dt_decl_pop());
618 			yybegin(YYS_CLAUSE);
619 		}
620 	;
621 
622 declaration_specifiers:
623 		d_storage_class_specifier
624 	|	d_storage_class_specifier declaration_specifiers
625 	|	type_specifier
626 	|	type_specifier declaration_specifiers
627 	|	type_qualifier
628 	|	type_qualifier declaration_specifiers
629 	;
630 
631 parameter_declaration_specifiers:
632 		storage_class_specifier
633 	|	storage_class_specifier declaration_specifiers
634 	|	type_specifier
635 	|	type_specifier declaration_specifiers
636 	|	type_qualifier
637 	|	type_qualifier declaration_specifiers
638 	;
639 
640 storage_class_specifier:
641 		DT_KEY_AUTO { dt_decl_class(DT_DC_AUTO); }
642 	|	DT_KEY_REGISTER { dt_decl_class(DT_DC_REGISTER); }
643 	|	DT_KEY_STATIC { dt_decl_class(DT_DC_STATIC); }
644 	|	DT_KEY_EXTERN { dt_decl_class(DT_DC_EXTERN); }
645 	|	DT_KEY_TYPEDEF { dt_decl_class(DT_DC_TYPEDEF); }
646 	;
647 
648 d_storage_class_specifier:
649 		storage_class_specifier
650 	|	DT_KEY_SELF { dt_decl_class(DT_DC_SELF); }
651 	|	DT_KEY_THIS { dt_decl_class(DT_DC_THIS); }
652 	;
653 
654 type_specifier:	DT_KEY_VOID { $$ = dt_decl_spec(CTF_K_INTEGER, DUP("void")); }
655 	|	DT_KEY_CHAR { $$ = dt_decl_spec(CTF_K_INTEGER, DUP("char")); }
656 	|	DT_KEY_SHORT { $$ = dt_decl_attr(DT_DA_SHORT); }
657 	|	DT_KEY_INT { $$ = dt_decl_spec(CTF_K_INTEGER, DUP("int")); }
658 	|	DT_KEY_LONG { $$ = dt_decl_attr(DT_DA_LONG); }
659 	|	DT_KEY_FLOAT { $$ = dt_decl_spec(CTF_K_FLOAT, DUP("float")); }
660 	|	DT_KEY_DOUBLE { $$ = dt_decl_spec(CTF_K_FLOAT, DUP("double")); }
661 	|	DT_KEY_SIGNED { $$ = dt_decl_attr(DT_DA_SIGNED); }
662 	|	DT_KEY_UNSIGNED { $$ = dt_decl_attr(DT_DA_UNSIGNED); }
663 	|	DT_KEY_USERLAND { $$ = dt_decl_attr(DT_DA_USER); }
664 	|	DT_KEY_STRING {
665 			$$ = dt_decl_spec(CTF_K_TYPEDEF, DUP("string"));
666 		}
667 	|	DT_TOK_TNAME { $$ = dt_decl_spec(CTF_K_TYPEDEF, $1); }
668 	|	struct_or_union_specifier
669 	|	enum_specifier
670 	;
671 
672 type_qualifier:	DT_KEY_CONST { $$ = dt_decl_attr(DT_DA_CONST); }
673 	|	DT_KEY_RESTRICT { $$ = dt_decl_attr(DT_DA_RESTRICT); }
674 	|	DT_KEY_VOLATILE { $$ = dt_decl_attr(DT_DA_VOLATILE); }
675 	;
676 
677 struct_or_union_specifier:
678 		struct_or_union_definition struct_declaration_list '}' {
679 			$$ = dt_scope_pop();
680 		}
681 	|	struct_or_union DT_TOK_IDENT { $$ = dt_decl_spec($1, $2); }
682 	|	struct_or_union DT_TOK_TNAME { $$ = dt_decl_spec($1, $2); }
683 	;
684 
685 struct_or_union_definition:
686 		struct_or_union '{' { dt_decl_sou($1, NULL); }
687 	|	struct_or_union DT_TOK_IDENT '{' { dt_decl_sou($1, $2); }
688 	|	struct_or_union DT_TOK_TNAME '{' { dt_decl_sou($1, $2); }
689 	;
690 
691 struct_or_union:
692 		DT_KEY_STRUCT { $$ = CTF_K_STRUCT; }
693 	|	DT_KEY_UNION { $$ = CTF_K_UNION; }
694 	;
695 
696 struct_declaration_list:
697 		struct_declaration
698 	|	struct_declaration_list struct_declaration
699 	;
700 
701 init_declarator_list:
702 		init_declarator
703 	|	init_declarator_list DT_TOK_COMMA init_declarator {
704 			$$ = LINK($1, $3);
705 		}
706 	;
707 
708 init_declarator:
709 		declarator {
710 			$$ = dt_node_decl();
711 			dt_decl_reset();
712 		}
713 	;
714 
715 struct_declaration:
716 		specifier_qualifier_list struct_declarator_list ';' {
717 			dt_decl_free(dt_decl_pop());
718 		}
719 	;
720 
721 specifier_qualifier_list:
722 		type_specifier
723 	|	type_specifier specifier_qualifier_list { $$ = $2; }
724 	|	type_qualifier
725 	|	type_qualifier specifier_qualifier_list { $$ = $2; }
726 	;
727 
728 struct_declarator_list:
729 		struct_declarator
730 	|	struct_declarator_list DT_TOK_COMMA struct_declarator
731 	;
732 
733 struct_declarator:
734 		declarator { dt_decl_member(NULL); }
735 	|	DT_TOK_COLON constant_expression { dt_decl_member($2); }
736 	|	declarator DT_TOK_COLON constant_expression {
737 			dt_decl_member($3);
738 		}
739 	;
740 
741 enum_specifier:
742 		enum_definition enumerator_list '}' { $$ = dt_scope_pop(); }
743 	|	DT_KEY_ENUM DT_TOK_IDENT { $$ = dt_decl_spec(CTF_K_ENUM, $2); }
744 	|	DT_KEY_ENUM DT_TOK_TNAME { $$ = dt_decl_spec(CTF_K_ENUM, $2); }
745 	;
746 
747 enum_definition:
748 		DT_KEY_ENUM '{' { dt_decl_enum(NULL); }
749 	|	DT_KEY_ENUM DT_TOK_IDENT '{' { dt_decl_enum($2); }
750 	|	DT_KEY_ENUM DT_TOK_TNAME '{' { dt_decl_enum($2); }
751 	;
752 
753 enumerator_list:
754 		enumerator
755 	|	enumerator_list DT_TOK_COMMA enumerator
756 	;
757 
758 enumerator:	DT_TOK_IDENT { dt_decl_enumerator($1, NULL); }
759 	|	DT_TOK_IDENT DT_TOK_ASGN expression {
760 			dt_decl_enumerator($1, $3);
761 		}
762 	;
763 
764 declarator:	direct_declarator
765 	|	pointer direct_declarator
766 	;
767 
768 direct_declarator:
769 		DT_TOK_IDENT { $$ = dt_decl_ident($1); }
770 	|	lparen declarator DT_TOK_RPAR { $$ = $2; }
771 	|	direct_declarator array { dt_decl_array($2); }
772 	|	direct_declarator function { dt_decl_func($1, $2); }
773 	;
774 
775 lparen:		DT_TOK_LPAR { dt_decl_top()->dd_attr |= DT_DA_PAREN; }
776 	;
777 
778 pointer:	DT_TOK_MUL { $$ = dt_decl_ptr(); }
779 	|	DT_TOK_MUL type_qualifier_list { $$ = dt_decl_ptr(); }
780 	|	DT_TOK_MUL pointer { $$ = dt_decl_ptr(); }
781 	|	DT_TOK_MUL type_qualifier_list pointer { $$ = dt_decl_ptr(); }
782 	;
783 
784 type_qualifier_list:
785 		type_qualifier
786 	|	type_qualifier_list type_qualifier { $$ = $2; }
787 	;
788 
789 parameter_type_list:
790 		parameter_list
791 	|	DT_TOK_ELLIPSIS { $$ = dt_node_vatype(); }
792 	|	parameter_list DT_TOK_COMMA DT_TOK_ELLIPSIS {
793 			$$ = LINK($1, dt_node_vatype());
794 		}
795 	;
796 
797 parameter_list:	parameter_declaration
798 	|	parameter_list DT_TOK_COMMA parameter_declaration {
799 			$$ = LINK($1, $3);
800 		}
801 	;
802 
803 parameter_declaration:
804 		parameter_declaration_specifiers {
805 			$$ = dt_node_type(NULL);
806 		}
807 	|	parameter_declaration_specifiers declarator {
808 			$$ = dt_node_type(NULL);
809 		}
810 	|	parameter_declaration_specifiers abstract_declarator {
811 			$$ = dt_node_type(NULL);
812 		}
813 	;
814 
815 type_name:	specifier_qualifier_list {
816 			$$ = dt_decl_pop();
817 		}
818 	|	specifier_qualifier_list abstract_declarator {
819 			$$ = dt_decl_pop();
820 		}
821 	;
822 
823 abstract_declarator:
824 		pointer
825 	|	direct_abstract_declarator
826 	|	pointer direct_abstract_declarator
827 	;
828 
829 direct_abstract_declarator:
830 		lparen abstract_declarator DT_TOK_RPAR { $$ = $2; }
831 	|	direct_abstract_declarator array { dt_decl_array($2); }
832 	|	array { dt_decl_array($1); $$ = NULL; }
833 	|	direct_abstract_declarator function { dt_decl_func($1, $2); }
834 	|	function { dt_decl_func(NULL, $1); }
835 	;
836 
837 array:		DT_TOK_LBRAC { dt_scope_push(NULL, CTF_ERR); }
838 		    array_parameters DT_TOK_RBRAC {
839 			dt_scope_pop();
840 			$$ = $3;
841 		}
842 	;
843 
844 array_parameters:
845 		/* empty */ 		{ $$ = NULL; }
846 	|	constant_expression	{ $$ = $1; }
847 	|	parameter_type_list	{ $$ = $1; }
848 	;
849 
850 function:	DT_TOK_LPAR { dt_scope_push(NULL, CTF_ERR); }
851 		    function_parameters DT_TOK_RPAR {
852 			dt_scope_pop();
853 			$$ = $3;
854 		}
855 	;
856 
857 function_parameters:
858 		/* empty */ 		{ $$ = NULL; }
859 	|	parameter_type_list	{ $$ = $1; }
860 	;
861 
862 %%
863