5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License (the "License").
7 * You may not use this file except in compliance with the License.
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
24 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
27 * Copyright (c) 2013 by Delphix. All rights reserved.
28 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
39 #include <dt_grammar.h>
40 #include <dt_parser.h>
41 #include <dt_string.h>
44 * We need to undefine lex's input and unput macros so that references to these
45 * call the functions provided at the end of this source file.
52 * Define YY_INPUT for flex since input() can't be re-defined.
54 #define YY_INPUT(buf,result,max_size) \
55 if (yypcb->pcb_fileptr != NULL) { \
56 if (((result = fread(buf, 1, max_size, yypcb->pcb_fileptr)) == 0) \
57 && ferror(yypcb->pcb_fileptr)) \
58 longjmp(yypcb->pcb_jmpbuf, EDT_FIO); \
61 for (n = 0; n < max_size && \
62 yypcb->pcb_strptr < yypcb->pcb_string + yypcb->pcb_strlen; n++) \
63 buf[n] = *yypcb->pcb_strptr++; \
67 * Do not EOF let tokens to be put back. This does not work with flex.
68 * On the other hand, leaving current buffer in same state it was when
69 * last EOF was received guarantees that input() will keep returning EOF
70 * for all subsequent invocations, which is the effect desired.
77 yyunput(_c, yytext_ptr); \
81 static int id_or_type(const char *);
83 static int input(void);
84 static void unput(int);
88 * We first define a set of labeled states for use in the D lexer and then a
89 * set of regular expressions to simplify things below. The lexer states are:
91 * S0 - D program clause and expression lexing
92 * S1 - D comments (i.e. skip everything until end of comment)
93 * S2 - D program outer scope (probe specifiers and declarations)
94 * S3 - D control line parsing (i.e. after ^# is seen but before \n)
95 * S4 - D control line scan (locate control directives only and invoke S3)
99 %e 1500 /* maximum nodes */
100 %p 4900 /* maximum positions */
101 %n 600 /* maximum states */
102 %a 3000 /* maximum transitions */
106 RGX_AGG "@"[a-zA-Z_][0-9a-zA-Z_]*
107 RGX_PSPEC [-$:a-zA-Z_.?*\\\[\]!][-$:0-9a-zA-Z_.`?*\\\[\]!]*
108 RGX_ALTIDENT [a-zA-Z_][0-9a-zA-Z_]*
109 RGX_LMID LM[0-9a-fA-F]+`
110 RGX_MOD_IDENT [a-zA-Z_`][0-9a-z.A-Z_`]*`
111 RGX_IDENT [a-zA-Z_`][0-9a-zA-Z_`]*
112 RGX_INT ([0-9]+|0[xX][0-9A-Fa-f]+)[uU]?[lL]?[lL]?
113 RGX_FP ([0-9]+("."?)[0-9]*|"."[0-9]+)((e|E)("+"|-)?[0-9]+)?[fFlL]?
115 RGX_STR ([^"\\\n]|\\[^"\n]|\\\")*
116 RGX_CHR ([^'\\\n]|\\[^'\n]|\\')*
117 RGX_INTERP ^[\f\t\v ]*#!.*
125 * We insert a special prologue into yylex() itself: if the pcb contains a
126 * context token, we return that prior to running the normal lexer. This
127 * allows libdtrace to force yacc into one of our three parsing contexts: D
128 * expression (DT_CTX_DEXPR), D program (DT_CTX_DPROG) or D type (DT_CTX_DTYPE).
129 * Once the token is returned, we clear it so this only happens once.
131 if (yypcb->pcb_token != 0) {
132 int tok = yypcb->pcb_token;
133 yypcb->pcb_token = 0;
139 <S0>auto return (DT_KEY_AUTO);
140 <S0>break return (DT_KEY_BREAK);
141 <S0>case return (DT_KEY_CASE);
142 <S0>char return (DT_KEY_CHAR);
143 <S0>const return (DT_KEY_CONST);
144 <S0>continue return (DT_KEY_CONTINUE);
145 <S0>counter return (DT_KEY_COUNTER);
146 <S0>default return (DT_KEY_DEFAULT);
147 <S0>do return (DT_KEY_DO);
148 <S0>double return (DT_KEY_DOUBLE);
149 <S0>else return (DT_KEY_ELSE);
150 <S0>enum return (DT_KEY_ENUM);
151 <S0>extern return (DT_KEY_EXTERN);
152 <S0>float return (DT_KEY_FLOAT);
153 <S0>for return (DT_KEY_FOR);
154 <S0>goto return (DT_KEY_GOTO);
155 <S0>if return (DT_KEY_IF);
156 <S0>import return (DT_KEY_IMPORT);
157 <S0>inline return (DT_KEY_INLINE);
158 <S0>int return (DT_KEY_INT);
159 <S0>long return (DT_KEY_LONG);
160 <S0>offsetof return (DT_TOK_OFFSETOF);
161 <S0>probe return (DT_KEY_PROBE);
162 <S0>provider return (DT_KEY_PROVIDER);
163 <S0>register return (DT_KEY_REGISTER);
164 <S0>restrict return (DT_KEY_RESTRICT);
165 <S0>return return (DT_KEY_RETURN);
166 <S0>self return (DT_KEY_SELF);
167 <S0>short return (DT_KEY_SHORT);
168 <S0>signed return (DT_KEY_SIGNED);
169 <S0>sizeof return (DT_TOK_SIZEOF);
170 <S0>static return (DT_KEY_STATIC);
171 <S0>string return (DT_KEY_STRING);
172 <S0>stringof return (DT_TOK_STRINGOF);
173 <S0>struct return (DT_KEY_STRUCT);
174 <S0>switch return (DT_KEY_SWITCH);
175 <S0>this return (DT_KEY_THIS);
176 <S0>translator return (DT_KEY_XLATOR);
177 <S0>typedef return (DT_KEY_TYPEDEF);
178 <S0>union return (DT_KEY_UNION);
179 <S0>unsigned return (DT_KEY_UNSIGNED);
180 <S0>userland return (DT_KEY_USERLAND);
181 <S0>void return (DT_KEY_VOID);
182 <S0>volatile return (DT_KEY_VOLATILE);
183 <S0>while return (DT_KEY_WHILE);
184 <S0>xlate return (DT_TOK_XLATE);
186 <S2>auto { yybegin(YYS_EXPR); return (DT_KEY_AUTO); }
187 <S2>char { yybegin(YYS_EXPR); return (DT_KEY_CHAR); }
188 <S2>const { yybegin(YYS_EXPR); return (DT_KEY_CONST); }
189 <S2>counter { yybegin(YYS_DEFINE); return (DT_KEY_COUNTER); }
190 <S2>double { yybegin(YYS_EXPR); return (DT_KEY_DOUBLE); }
191 <S2>enum { yybegin(YYS_EXPR); return (DT_KEY_ENUM); }
192 <S2>extern { yybegin(YYS_EXPR); return (DT_KEY_EXTERN); }
193 <S2>float { yybegin(YYS_EXPR); return (DT_KEY_FLOAT); }
194 <S2>import { yybegin(YYS_EXPR); return (DT_KEY_IMPORT); }
195 <S2>inline { yybegin(YYS_DEFINE); return (DT_KEY_INLINE); }
196 <S2>int { yybegin(YYS_EXPR); return (DT_KEY_INT); }
197 <S2>long { yybegin(YYS_EXPR); return (DT_KEY_LONG); }
198 <S2>provider { yybegin(YYS_DEFINE); return (DT_KEY_PROVIDER); }
199 <S2>register { yybegin(YYS_EXPR); return (DT_KEY_REGISTER); }
200 <S2>restrict { yybegin(YYS_EXPR); return (DT_KEY_RESTRICT); }
201 <S2>self { yybegin(YYS_EXPR); return (DT_KEY_SELF); }
202 <S2>short { yybegin(YYS_EXPR); return (DT_KEY_SHORT); }
203 <S2>signed { yybegin(YYS_EXPR); return (DT_KEY_SIGNED); }
204 <S2>static { yybegin(YYS_EXPR); return (DT_KEY_STATIC); }
205 <S2>string { yybegin(YYS_EXPR); return (DT_KEY_STRING); }
206 <S2>struct { yybegin(YYS_EXPR); return (DT_KEY_STRUCT); }
207 <S2>this { yybegin(YYS_EXPR); return (DT_KEY_THIS); }
208 <S2>translator { yybegin(YYS_DEFINE); return (DT_KEY_XLATOR); }
209 <S2>typedef { yybegin(YYS_EXPR); return (DT_KEY_TYPEDEF); }
210 <S2>union { yybegin(YYS_EXPR); return (DT_KEY_UNION); }
211 <S2>unsigned { yybegin(YYS_EXPR); return (DT_KEY_UNSIGNED); }
212 <S2>void { yybegin(YYS_EXPR); return (DT_KEY_VOID); }
213 <S2>volatile { yybegin(YYS_EXPR); return (DT_KEY_VOLATILE); }
216 int i = atoi(yytext + 2);
220 * A macro argument reference substitutes the text of
221 * an argument in place of the current token. When we
222 * see $$<d> we fetch the saved string from pcb_sargv
223 * (or use the default argument if the option has been
224 * set and the argument hasn't been specified) and
225 * return a token corresponding to this string.
227 if (i < 0 || (i >= yypcb->pcb_sargc &&
228 !(yypcb->pcb_cflags & DTRACE_C_DEFARG))) {
229 xyerror(D_MACRO_UNDEF, "macro argument %s is "
230 "not defined\n", yytext);
233 if (i < yypcb->pcb_sargc) {
234 v = yypcb->pcb_sargv[i]; /* get val from pcb */
235 yypcb->pcb_sflagv[i] |= DT_IDFLG_REF;
238 if ((yylval.l_str = strdup(v)) == NULL)
239 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
241 (void) stresc2chr(yylval.l_str);
242 return (DT_TOK_STRING);
246 int i = atoi(yytext + 1);
250 * A macro argument reference substitutes the text of
251 * one identifier or integer pattern for another. When
252 * we see $<d> we fetch the saved string from pcb_sargv
253 * (or use the default argument if the option has been
254 * set and the argument hasn't been specified) and
255 * return a token corresponding to this string.
257 if (i < 0 || (i >= yypcb->pcb_sargc &&
258 !(yypcb->pcb_cflags & DTRACE_C_DEFARG))) {
259 xyerror(D_MACRO_UNDEF, "macro argument %s is "
260 "not defined\n", yytext);
263 if (i < yypcb->pcb_sargc) {
264 v = yypcb->pcb_sargv[i]; /* get val from pcb */
265 yypcb->pcb_sflagv[i] |= DT_IDFLG_REF;
269 * If the macro text is not a valid integer or ident,
270 * then we treat it as a string. The string may be
271 * optionally enclosed in quotes, which we strip.
273 if (strbadidnum(v)) {
274 size_t len = strlen(v);
276 if (len != 1 && *v == '"' && v[len - 1] == '"')
277 yylval.l_str = strndup(v + 1, len - 2);
279 yylval.l_str = strndup(v, len);
281 if (yylval.l_str == NULL)
282 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
284 (void) stresc2chr(yylval.l_str);
285 return (DT_TOK_STRING);
289 * If the macro text is not a string an begins with a
290 * digit or a +/- sign, process it as an integer token.
292 if (isdigit(v[0]) || v[0] == '-' || v[0] == '+') {
299 yylval.l_int = strtoull(v, &p, 0);
300 (void) strncpy(yyintsuffix, p,
301 sizeof (yyintsuffix));
302 yyintdecimal = *v != '0';
304 if (errno == ERANGE) {
305 xyerror(D_MACRO_OFLOW, "macro argument"
306 " %s constant %s results in integer"
307 " overflow\n", yytext, v);
313 return (id_or_type(v));
316 <S0>"$$"{RGX_IDENT} {
317 dt_ident_t *idp = dt_idhash_lookup(
318 yypcb->pcb_hdl->dt_macros, yytext + 2);
320 char s[16]; /* enough for UINT_MAX + \0 */
323 xyerror(D_MACRO_UNDEF, "macro variable %s "
324 "is not defined\n", yytext);
328 * For the moment, all current macro variables are of
329 * type id_t (refer to dtrace_update() for details).
331 (void) snprintf(s, sizeof (s), "%u", idp->di_id);
332 if ((yylval.l_str = strdup(s)) == NULL)
333 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
335 return (DT_TOK_STRING);
339 dt_ident_t *idp = dt_idhash_lookup(
340 yypcb->pcb_hdl->dt_macros, yytext + 1);
343 xyerror(D_MACRO_UNDEF, "macro variable %s "
344 "is not defined\n", yytext);
348 * For the moment, all current macro variables are of
349 * type id_t (refer to dtrace_update() for details).
351 yylval.l_int = (intmax_t)(int)idp->di_id;
353 yyintsuffix[0] = '\0';
360 <S0>{RGX_MOD_IDENT}{RGX_IDENT} |
361 <S0>{RGX_MOD_IDENT} {
362 return (id_or_type(yytext));
366 if ((yylval.l_str = strdup(yytext)) == NULL)
367 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
372 if ((yylval.l_str = strdup("@_")) == NULL)
373 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
383 yylval.l_int = strtoull(yytext, &p, 0);
385 (void) strncpy(yyintsuffix, p, sizeof (yyintsuffix));
386 yyintdecimal = yytext[0] != '0';
388 if (errno == ERANGE) {
389 xyerror(D_INT_OFLOW, "constant %s results in "
390 "integer overflow\n", yytext);
393 if (*p != '\0' && strchr("uUlL", *p) == NULL) {
394 xyerror(D_INT_DIGIT, "constant %s contains "
395 "invalid digit %c\n", yytext, *p);
401 yypragma = dt_node_link(yypragma,
402 dt_node_int(yylval.l_int));
405 <S0>{RGX_FP} yyerror("floating-point constants are not permitted\n");
408 <S3>\"{RGX_STR}$ xyerror(D_STR_NL, "newline encountered in string literal");
413 * Quoted string -- convert C escape sequences and
414 * return the string as a token.
416 yylval.l_str = strndup(yytext + 1, yyleng - 2);
418 if (yylval.l_str == NULL)
419 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
421 (void) stresc2chr(yylval.l_str);
423 return (DT_TOK_STRING);
425 yypragma = dt_node_link(yypragma,
426 dt_node_string(yylval.l_str));
429 <S0>'{RGX_CHR}$ xyerror(D_CHR_NL, "newline encountered in character constant");
436 * Character constant -- convert C escape sequences and
437 * return the character as an integer immediate value.
440 xyerror(D_CHR_NULL, "empty character constant");
443 yytext[yyleng - 1] = '\0';
444 nbytes = stresc2chr(s);
447 yyintsuffix[0] = '\0';
450 if (nbytes > sizeof (yylval.l_int)) {
451 xyerror(D_CHR_OFLOW, "character constant is "
454 #if BYTE_ORDER == _LITTLE_ENDIAN
455 p = ((char *)&yylval.l_int) + nbytes - 1;
456 for (q = s; nbytes != 0; nbytes--)
459 bcopy(s, ((char *)&yylval.l_int) +
460 sizeof (yylval.l_int) - nbytes, nbytes);
467 yypcb->pcb_cstate = (YYSTATE);
472 <S2>{RGX_INTERP} ; /* discard any #! lines */
477 assert(yypragma == NULL);
478 yypcb->pcb_cstate = (YYSTATE);
482 <S4>. ; /* discard */
483 <S4>"\n" ; /* discard */
489 * The use of "/" as the predicate delimiter and as the
490 * integer division symbol requires special lookahead
491 * to avoid a shift/reduce conflict in the D grammar.
492 * We look ahead to the next non-whitespace character.
493 * If we encounter EOF, ";", "{", or "/", then this "/"
494 * closes the predicate and we return DT_TOK_EPRED.
495 * If we encounter anything else, it's DT_TOK_DIV.
497 while ((c = input()) != 0) {
498 if (strchr("\f\n\r\t\v ", c) == NULL)
502 if (c == 0 || c == ';' || c == '{' || c == '/') {
503 if (yypcb->pcb_parens != 0) {
504 yyerror("closing ) expected in "
505 "predicate before /\n");
507 if (yypcb->pcb_brackets != 0) {
508 yyerror("closing ] expected in "
509 "predicate before /\n");
521 return (DT_TOK_LPAR);
525 if (--yypcb->pcb_parens < 0)
526 yyerror("extra ) in input stream\n");
527 return (DT_TOK_RPAR);
531 yypcb->pcb_brackets++;
532 return (DT_TOK_LBRAC);
536 if (--yypcb->pcb_brackets < 0)
537 yyerror("extra ] in input stream\n");
538 return (DT_TOK_RBRAC);
548 if (--yypcb->pcb_braces < 0)
549 yyerror("extra } in input stream\n");
553 <S0>"|" return (DT_TOK_BOR);
554 <S0>"^" return (DT_TOK_XOR);
555 <S0>"&" return (DT_TOK_BAND);
556 <S0>"&&" return (DT_TOK_LAND);
557 <S0>"^^" return (DT_TOK_LXOR);
558 <S0>"||" return (DT_TOK_LOR);
559 <S0>"==" return (DT_TOK_EQU);
560 <S0>"!=" return (DT_TOK_NEQ);
561 <S0>"<" return (DT_TOK_LT);
562 <S0>"<=" return (DT_TOK_LE);
563 <S0>">" return (DT_TOK_GT);
564 <S0>">=" return (DT_TOK_GE);
565 <S0>"<<" return (DT_TOK_LSH);
566 <S0>">>" return (DT_TOK_RSH);
567 <S0>"+" return (DT_TOK_ADD);
568 <S0>"-" return (DT_TOK_SUB);
569 <S0>"*" return (DT_TOK_MUL);
570 <S0>"%" return (DT_TOK_MOD);
571 <S0>"~" return (DT_TOK_BNEG);
572 <S0>"!" return (DT_TOK_LNEG);
573 <S0>"?" return (DT_TOK_QUESTION);
574 <S0>":" return (DT_TOK_COLON);
575 <S0>"." return (DT_TOK_DOT);
576 <S0>"->" return (DT_TOK_PTR);
577 <S0>"=" return (DT_TOK_ASGN);
578 <S0>"+=" return (DT_TOK_ADD_EQ);
579 <S0>"-=" return (DT_TOK_SUB_EQ);
580 <S0>"*=" return (DT_TOK_MUL_EQ);
581 <S0>"/=" return (DT_TOK_DIV_EQ);
582 <S0>"%=" return (DT_TOK_MOD_EQ);
583 <S0>"&=" return (DT_TOK_AND_EQ);
584 <S0>"^=" return (DT_TOK_XOR_EQ);
585 <S0>"|=" return (DT_TOK_OR_EQ);
586 <S0>"<<=" return (DT_TOK_LSH_EQ);
587 <S0>">>=" return (DT_TOK_RSH_EQ);
588 <S0>"++" return (DT_TOK_ADDADD);
589 <S0>"--" return (DT_TOK_SUBSUB);
590 <S0>"..." return (DT_TOK_ELLIPSIS);
591 <S0>"," return (DT_TOK_COMMA);
592 <S0>";" return (';');
593 <S0>{RGX_WS} ; /* discard */
594 <S0>"\\"\n ; /* discard */
595 <S0>. yyerror("syntax error near \"%c\"\n", yytext[0]);
597 <S1>"/*" yyerror("/* encountered inside a comment\n");
598 <S1>"*/" BEGIN(yypcb->pcb_cstate);
599 <S1>.|\n ; /* discard */
603 * S2 has an ambiguity because RGX_PSPEC includes '*'
604 * as a glob character and '*' also can be DT_TOK_STAR.
605 * Since lex always matches the longest token, this
606 * rule can be matched by an input string like "int*",
607 * which could begin a global variable declaration such
608 * as "int*x;" or could begin a RGX_PSPEC with globbing
609 * such as "int* { trace(timestamp); }". If C_PSPEC is
610 * not set, we must resolve the ambiguity in favor of
611 * the type and perform lexer pushback if the fragment
612 * before '*' or entire fragment matches a type name.
613 * If C_PSPEC is set, we always return a PSPEC token.
614 * If C_PSPEC is off, the user can avoid ambiguity by
615 * including a ':' delimiter in the specifier, which
616 * they should be doing anyway to specify the provider.
618 if (!(yypcb->pcb_cflags & DTRACE_C_PSPEC) &&
619 strchr(yytext, ':') == NULL) {
621 char *p = strchr(yytext, '*');
622 char *q = yytext + yyleng - 1;
624 if (p != NULL && p > yytext)
625 *p = '\0'; /* prune yytext */
627 if (dt_type_lookup(yytext, NULL) == 0) {
628 yylval.l_str = strdup(yytext);
630 if (yylval.l_str == NULL) {
631 longjmp(yypcb->pcb_jmpbuf,
635 if (p != NULL && p > yytext) {
636 for (*p = '*'; q >= p; q--)
641 return (DT_TOK_TNAME);
644 if (p != NULL && p > yytext)
645 *p = '*'; /* restore yytext */
648 if ((yylval.l_str = strdup(yytext)) == NULL)
649 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
651 return (DT_TOK_PSPEC);
654 <S2>"/" return (DT_TOK_DIV);
655 <S2>"," return (DT_TOK_COMMA);
657 <S2>{RGX_WS} ; /* discard */
658 <S2>. yyerror("syntax error near \"%c\"\n", yytext[0]);
663 BEGIN(yypcb->pcb_cstate);
666 <S3>[\f\t\v ]+ ; /* discard */
671 if ((yylval.l_str = strdup(yytext)) == NULL)
672 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
675 * We want to call dt_node_ident() here, but we can't
676 * because it will expand inlined identifiers, which we
677 * don't want to do from #pragma context in order to
678 * support pragmas that apply to the ident itself. We
679 * call dt_node_string() and then reset dn_op instead.
681 dnp = dt_node_string(yylval.l_str);
682 dnp->dn_kind = DT_NODE_IDENT;
683 dnp->dn_op = DT_TOK_IDENT;
684 yypragma = dt_node_link(yypragma, dnp);
687 <S3>. yyerror("syntax error near \"%c\"\n", yytext[0]);
692 * yybegin provides a wrapper for use from C code around the lex BEGIN() macro.
693 * We use two main states for lexing because probe descriptions use a syntax
694 * that is incompatible with the normal D tokens (e.g. names can contain "-").
695 * yybegin also handles the job of switching between two lists of dt_nodes
696 * as we allocate persistent definitions, like inlines, and transient nodes
697 * that will be freed once we are done parsing the current program file.
700 yybegin(yystate_t state)
703 yydebug = _dtrace_debug;
705 if (yypcb->pcb_yystate == state)
706 return; /* nothing to do if we're in the state already */
708 if (yypcb->pcb_yystate == YYS_DEFINE) {
709 yypcb->pcb_list = yypcb->pcb_hold;
710 yypcb->pcb_hold = NULL;
718 assert(yypcb->pcb_hold == NULL);
719 yypcb->pcb_hold = yypcb->pcb_list;
720 yypcb->pcb_list = NULL;
731 xyerror(D_UNKNOWN, "internal error -- bad yystate %d\n", state);
734 yypcb->pcb_yystate = state;
738 yyinit(dt_pcb_t *pcb)
750 * Given a lexeme 's' (typically yytext), set yylval and return an appropriate
751 * token to the parser indicating either an identifier or a typedef name.
752 * User-defined global variables always take precedence over types, but we do
753 * use some heuristics because D programs can look at an ever-changing set of
754 * kernel types and also can implicitly instantiate variables by assignment,
755 * unlike in C. The code here is ordered carefully as lookups are not cheap.
758 id_or_type(const char *s)
760 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
761 dt_decl_t *ddp = yypcb->pcb_dstack.ds_decl;
762 int c0, c1, ttok = DT_TOK_TNAME;
765 if ((s = yylval.l_str = strdup(s)) == NULL)
766 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
769 * If the lexeme is a global variable or likely identifier or *not* a
770 * type_name, then it is an identifier token.
772 if (dt_idstack_lookup(&yypcb->pcb_globals, s) != NULL ||
773 dt_idhash_lookup(yypcb->pcb_idents, s) != NULL ||
774 dt_type_lookup(s, NULL) != 0)
775 return (DT_TOK_IDENT);
778 * If we're in the midst of parsing a declaration and a type_specifier
779 * has already been shifted, then return DT_TOK_IDENT instead of TNAME.
780 * This semantic is necessary to permit valid ISO C code such as:
783 * struct s { foo foo; };
785 * without causing shift/reduce conflicts in the direct_declarator part
786 * of the grammar. The result is that we must check for conflicting
787 * redeclarations of the same identifier as part of dt_node_decl().
789 if (ddp != NULL && ddp->dd_name != NULL)
790 return (DT_TOK_IDENT);
793 * If the lexeme is a type name and we are not in a program clause,
794 * then always interpret it as a type and return DT_TOK_TNAME.
797 return (DT_TOK_TNAME);
800 * If the lexeme matches a type name but is in a program clause, then
801 * it could be a type or it could be an undefined variable. Peek at
802 * the next token to decide. If we see ++, --, [, or =, we know there
803 * might be an assignment that is trying to create a global variable,
804 * so we optimistically return DT_TOK_IDENT. There is no harm in being
805 * wrong: a type_name followed by ++, --, [, or = is a syntax error.
807 while ((c0 = input()) != 0) {
808 if (strchr("\f\n\r\t\v ", c0) == NULL)
815 if ((c1 = input()) == c0)
821 if ((c1 = input()) != c0)
830 if (ttok == DT_TOK_IDENT) {
831 idp = dt_idhash_insert(yypcb->pcb_idents, s, DT_IDENT_SCALAR, 0,
832 0, _dtrace_defattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen);
835 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
850 else if (yypcb->pcb_fileptr != NULL)
851 c = fgetc(yypcb->pcb_fileptr);
852 else if (yypcb->pcb_strptr < yypcb->pcb_string + yypcb->pcb_strlen)
853 c = *(unsigned char *)(yypcb->pcb_strptr++);
864 yyerror("end-of-file encountered before matching */\n");
867 yyerror("end-of-file encountered before end of control line\n");
869 if (yypcb->pcb_fileptr != NULL && ferror(yypcb->pcb_fileptr))
870 longjmp(yypcb->pcb_jmpbuf, EDT_FIO);
872 return (0); /* EOF */