cddl/contrib/opensolaris/lib/libdtrace/common/dt_lex.l

   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 (the "License").
   7  * You may not use this file except in compliance with the License.
   8  *
   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.
  13  *
  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]
  19  *
  20  * CDDL HEADER END
  21  */
  22
  23 /*
  24  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  25  */
  26 /*
  27  * Copyright (c) 2013 by Delphix. All rights reserved.
  28  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
  29  */
  30
  31 #include <string.h>
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <assert.h>
  35 #include <ctype.h>
  36 #include <errno.h>
  37
  38 #include <dt_impl.h>
  39 #include <dt_grammar.h>
  40 #include <dt_parser.h>
  41 #include <dt_string.h>
  42
  43 /*
  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.
  46  */
  47 #if defined(sun)
  48 #undef input
  49 #undef unput
  50 #else
  51 /*
  52  * Define YY_INPUT for flex since input() can't be re-defined.
  53  */
  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); \
  59         } else { \
  60                 int n; \
  61                 for (n = 0; n < max_size && \
  62                     yypcb->pcb_strptr < yypcb->pcb_string + yypcb->pcb_strlen; n++) \
  63                         buf[n] = *yypcb->pcb_strptr++; \
  64                 result = n; \
  65         }
  66 /*
  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.
  71  */
  72 #undef  unput
  73 #define unput(c)                                        \
  74         do {                                            \
  75                 int _c = c;                             \
  76                 if (_c != EOF)                          \
  77                         yyunput(_c, yytext_ptr);        \
  78         } while(0)
  79 #endif
  80
  81 static int id_or_type(const char *);
  82 #if defined(sun)
  83 static int input(void);
  84 static void unput(int);
  85 #endif
  86
  87 /*
  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:
  90  *
  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)
  96  */
  97 %}
  98
  99 %e 1500         /* maximum nodes */
 100 %p 4900         /* maximum positions */
 101 %n 600          /* maximum states */
 102 %a 3000         /* maximum transitions */
 103
 104 %s S0 S1 S2 S3 S4
 105
 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]?
 114 RGX_WS          [\f\n\r\t\v ]
 115 RGX_STR         ([^"\\\n]|\\[^"\n]|\\\")*
 116 RGX_CHR         ([^'\\\n]|\\[^'\n]|\\')*
 117 RGX_INTERP      ^[\f\t\v ]*#!.*
 118 RGX_CTL         ^[\f\t\v ]*#
 119
 120 %%
 121
 122 %{
 123
 124 /*
 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.
 130  */
 131 if (yypcb->pcb_token != 0) {
 132         int tok = yypcb->pcb_token;
 133         yypcb->pcb_token = 0;
 134         return (tok);
 135 }
 136
 137 %}
 138
 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);
 185
 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); }
 214
 215 <S0>"$$"[0-9]+  {
 216                         int i = atoi(yytext + 2);
 217                         char *v = "";
 218
 219                         /*
 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.
 226                          */
 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);
 231                         }
 232
 233                         if (i < yypcb->pcb_sargc) {
 234                                 v = yypcb->pcb_sargv[i]; /* get val from pcb */
 235                                 yypcb->pcb_sflagv[i] |= DT_IDFLG_REF;
 236                         }
 237
 238                         if ((yylval.l_str = strdup(v)) == NULL)
 239                                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 240
 241                         (void) stresc2chr(yylval.l_str);
 242                         return (DT_TOK_STRING);
 243                 }
 244
 245 <S0>"$"[0-9]+   {
 246                         int i = atoi(yytext + 1);
 247                         char *p, *v = "0";
 248
 249                         /*
 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.
 256                          */
 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);
 261                         }
 262
 263                         if (i < yypcb->pcb_sargc) {
 264                                 v = yypcb->pcb_sargv[i]; /* get val from pcb */
 265                                 yypcb->pcb_sflagv[i] |= DT_IDFLG_REF;
 266                         }
 267
 268                         /*
 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.
 272                          */
 273                         if (strbadidnum(v)) {
 274                                 size_t len = strlen(v);
 275
 276                                 if (len != 1 && *v == '"' && v[len - 1] == '"')
 277                                         yylval.l_str = strndup(v + 1, len - 2);
 278                                 else
 279                                         yylval.l_str = strndup(v, len);
 280
 281                                 if (yylval.l_str == NULL)
 282                                         longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 283
 284                                 (void) stresc2chr(yylval.l_str);
 285                                 return (DT_TOK_STRING);
 286                         }
 287
 288                         /*
 289                          * If the macro text is not a string an begins with a
 290                          * digit or a +/- sign, process it as an integer token.
 291                          */
 292                         if (isdigit(v[0]) || v[0] == '-' || v[0] == '+') {
 293                                 if (isdigit(v[0]))
 294                                         yyintprefix = 0;
 295                                 else
 296                                         yyintprefix = *v++;
 297
 298                                 errno = 0;
 299                                 yylval.l_int = strtoull(v, &p, 0);
 300                                 (void) strncpy(yyintsuffix, p,
 301                                     sizeof (yyintsuffix));
 302                                 yyintdecimal = *v != '0';
 303
 304                                 if (errno == ERANGE) {
 305                                         xyerror(D_MACRO_OFLOW, "macro argument"
 306                                             " %s constant %s results in integer"
 307                                             " overflow\n", yytext, v);
 308                                 }
 309
 310                                 return (DT_TOK_INT);
 311                         }
 312
 313                         return (id_or_type(v));
 314                 }
 315
 316 <S0>"$$"{RGX_IDENT} {
 317                         dt_ident_t *idp = dt_idhash_lookup(
 318                             yypcb->pcb_hdl->dt_macros, yytext + 2);
 319
 320                         char s[16]; /* enough for UINT_MAX + \0 */
 321
 322                         if (idp == NULL) {
 323                                 xyerror(D_MACRO_UNDEF, "macro variable %s "
 324                                     "is not defined\n", yytext);
 325                         }
 326
 327                         /*
 328                          * For the moment, all current macro variables are of
 329                          * type id_t (refer to dtrace_update() for details).
 330                          */
 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);
 334
 335                         return (DT_TOK_STRING);
 336                 }
 337
 338 <S0>"$"{RGX_IDENT} {
 339                         dt_ident_t *idp = dt_idhash_lookup(
 340                             yypcb->pcb_hdl->dt_macros, yytext + 1);
 341
 342                         if (idp == NULL) {
 343                                 xyerror(D_MACRO_UNDEF, "macro variable %s "
 344                                     "is not defined\n", yytext);
 345                         }
 346
 347                         /*
 348                          * For the moment, all current macro variables are of
 349                          * type id_t (refer to dtrace_update() for details).
 350                          */
 351                         yylval.l_int = (intmax_t)(int)idp->di_id;
 352                         yyintprefix = 0;
 353                         yyintsuffix[0] = '\0';
 354                         yyintdecimal = 1;
 355
 356                         return (DT_TOK_INT);
 357                 }
 358
 359 <S0>{RGX_IDENT} |
 360 <S0>{RGX_MOD_IDENT}{RGX_IDENT} |
 361 <S0>{RGX_MOD_IDENT} {
 362                         return (id_or_type(yytext));
 363                 }
 364
 365 <S0>{RGX_AGG}   {
 366                         if ((yylval.l_str = strdup(yytext)) == NULL)
 367                                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 368                         return (DT_TOK_AGG);
 369                 }
 370
 371 <S0>"@"         {
 372                         if ((yylval.l_str = strdup("@_")) == NULL)
 373                                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 374                         return (DT_TOK_AGG);
 375                 }
 376
 377 <S0>{RGX_INT}   |
 378 <S2>{RGX_INT}   |
 379 <S3>{RGX_INT}   {
 380                         char *p;
 381
 382                         errno = 0;
 383                         yylval.l_int = strtoull(yytext, &p, 0);
 384                         yyintprefix = 0;
 385                         (void) strncpy(yyintsuffix, p, sizeof (yyintsuffix));
 386                         yyintdecimal = yytext[0] != '0';
 387
 388                         if (errno == ERANGE) {
 389                                 xyerror(D_INT_OFLOW, "constant %s results in "
 390                                     "integer overflow\n", yytext);
 391                         }
 392
 393                         if (*p != '\0' && strchr("uUlL", *p) == NULL) {
 394                                 xyerror(D_INT_DIGIT, "constant %s contains "
 395                                     "invalid digit %c\n", yytext, *p);
 396                         }
 397
 398                         if ((YYSTATE) != S3)
 399                                 return (DT_TOK_INT);
 400
 401                         yypragma = dt_node_link(yypragma,
 402                             dt_node_int(yylval.l_int));
 403                 }
 404
 405 <S0>{RGX_FP}    yyerror("floating-point constants are not permitted\n");
 406
 407 <S0>\"{RGX_STR}$ |
 408 <S3>\"{RGX_STR}$ xyerror(D_STR_NL, "newline encountered in string literal");
 409
 410 <S0>\"{RGX_STR}\" |
 411 <S3>\"{RGX_STR}\" {
 412                         /*
 413                          * Quoted string -- convert C escape sequences and
 414                          * return the string as a token.
 415                          */
 416                         yylval.l_str = strndup(yytext + 1, yyleng - 2);
 417
 418                         if (yylval.l_str == NULL)
 419                                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 420
 421                         (void) stresc2chr(yylval.l_str);
 422                         if ((YYSTATE) != S3)
 423                                 return (DT_TOK_STRING);
 424
 425                         yypragma = dt_node_link(yypragma,
 426                             dt_node_string(yylval.l_str));
 427                 }
 428
 429 <S0>'{RGX_CHR}$ xyerror(D_CHR_NL, "newline encountered in character constant");
 430
 431 <S0>'{RGX_CHR}' {
 432                         char *s, *p, *q;
 433                         size_t nbytes;
 434
 435                         /*
 436                          * Character constant -- convert C escape sequences and
 437                          * return the character as an integer immediate value.
 438                          */
 439                         if (yyleng == 2)
 440                                 xyerror(D_CHR_NULL, "empty character constant");
 441
 442                         s = yytext + 1;
 443                         yytext[yyleng - 1] = '\0';
 444                         nbytes = stresc2chr(s);
 445                         yylval.l_int = 0;
 446                         yyintprefix = 0;
 447                         yyintsuffix[0] = '\0';
 448                         yyintdecimal = 1;
 449
 450                         if (nbytes > sizeof (yylval.l_int)) {
 451                                 xyerror(D_CHR_OFLOW, "character constant is "
 452                                     "too long");
 453                         }
 454 #if BYTE_ORDER == _LITTLE_ENDIAN
 455                         p = ((char *)&yylval.l_int) + nbytes - 1;
 456                         for (q = s; nbytes != 0; nbytes--)
 457                                 *p-- = *q++;
 458 #else
 459                         bcopy(s, ((char *)&yylval.l_int) +
 460                             sizeof (yylval.l_int) - nbytes, nbytes);
 461 #endif
 462                         return (DT_TOK_INT);
 463                 }
 464
 465 <S0>"/*"        |
 466 <S2>"/*"        {
 467                         yypcb->pcb_cstate = (YYSTATE);
 468                         BEGIN(S1);
 469                 }
 470
 471 <S0>{RGX_INTERP} |
 472 <S2>{RGX_INTERP} ;      /* discard any #! lines */
 473
 474 <S0>{RGX_CTL}   |
 475 <S2>{RGX_CTL}   |
 476 <S4>{RGX_CTL}   {
 477                         assert(yypragma == NULL);
 478                         yypcb->pcb_cstate = (YYSTATE);
 479                         BEGIN(S3);
 480                 }
 481
 482 <S4>.           ;       /* discard */
 483 <S4>"\n"        ;       /* discard */
 484
 485 <S0>"/"         {
 486                         int c, tok;
 487
 488                         /*
 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.
 496                          */
 497                         while ((c = input()) != 0) {
 498                                 if (strchr("\f\n\r\t\v ", c) == NULL)
 499                                         break;
 500                         }
 501
 502                         if (c == 0 || c == ';' || c == '{' || c == '/') {
 503                                 if (yypcb->pcb_parens != 0) {
 504                                         yyerror("closing ) expected in "
 505                                             "predicate before /\n");
 506                                 }
 507                                 if (yypcb->pcb_brackets != 0) {
 508                                         yyerror("closing ] expected in "
 509                                             "predicate before /\n");
 510                                 }
 511                                 tok = DT_TOK_EPRED;
 512                         } else
 513                                 tok = DT_TOK_DIV;
 514
 515                         unput(c);
 516                         return (tok);
 517                 }
 518
 519 <S0>"("         {
 520                         yypcb->pcb_parens++;
 521                         return (DT_TOK_LPAR);
 522                 }
 523
 524 <S0>")"         {
 525                         if (--yypcb->pcb_parens < 0)
 526                                 yyerror("extra ) in input stream\n");
 527                         return (DT_TOK_RPAR);
 528                 }
 529
 530 <S0>"["         {
 531                         yypcb->pcb_brackets++;
 532                         return (DT_TOK_LBRAC);
 533                 }
 534
 535 <S0>"]"         {
 536                         if (--yypcb->pcb_brackets < 0)
 537                                 yyerror("extra ] in input stream\n");
 538                         return (DT_TOK_RBRAC);
 539                 }
 540
 541 <S0>"{"         |
 542 <S2>"{"         {
 543                         yypcb->pcb_braces++;
 544                         return ('{');
 545                 }
 546
 547 <S0>"}"         {
 548                         if (--yypcb->pcb_braces < 0)
 549                                 yyerror("extra } in input stream\n");
 550                         return ('}');
 551                 }
 552
 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]);
 596
 597 <S1>"/*"        yyerror("/* encountered inside a comment\n");
 598 <S1>"*/"        BEGIN(yypcb->pcb_cstate);
 599 <S1>.|\n        ; /* discard */
 600
 601 <S2>{RGX_PSPEC} {
 602                         /*
 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.
 617                          */
 618                         if (!(yypcb->pcb_cflags & DTRACE_C_PSPEC) &&
 619                             strchr(yytext, ':') == NULL) {
 620
 621                                 char *p = strchr(yytext, '*');
 622                                 char *q = yytext + yyleng - 1;
 623
 624                                 if (p != NULL && p > yytext)
 625                                         *p = '\0'; /* prune yytext */
 626
 627                                 if (dt_type_lookup(yytext, NULL) == 0) {
 628                                         yylval.l_str = strdup(yytext);
 629
 630                                         if (yylval.l_str == NULL) {
 631                                                 longjmp(yypcb->pcb_jmpbuf,
 632                                                     EDT_NOMEM);
 633                                         }
 634
 635                                         if (p != NULL && p > yytext) {
 636                                                 for (*p = '*'; q >= p; q--)
 637                                                         unput(*q);
 638                                         }
 639
 640                                         yybegin(YYS_EXPR);
 641                                         return (DT_TOK_TNAME);
 642                                 }
 643
 644                                 if (p != NULL && p > yytext)
 645                                         *p = '*'; /* restore yytext */
 646                         }
 647
 648                         if ((yylval.l_str = strdup(yytext)) == NULL)
 649                                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 650
 651                         return (DT_TOK_PSPEC);
 652                 }
 653
 654 <S2>"/"         return (DT_TOK_DIV);
 655 <S2>","         return (DT_TOK_COMMA);
 656
 657 <S2>{RGX_WS}    ; /* discard */
 658 <S2>.           yyerror("syntax error near \"%c\"\n", yytext[0]);
 659
 660 <S3>\n          {
 661                         dt_pragma(yypragma);
 662                         yypragma = NULL;
 663                         BEGIN(yypcb->pcb_cstate);
 664                 }
 665
 666 <S3>[\f\t\v ]+  ; /* discard */
 667
 668 <S3>[^\f\n\t\v "]+ {
 669                         dt_node_t *dnp;
 670
 671                         if ((yylval.l_str = strdup(yytext)) == NULL)
 672                                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 673
 674                         /*
 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.
 680                          */
 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);
 685                 }
 686
 687 <S3>.           yyerror("syntax error near \"%c\"\n", yytext[0]);
 688
 689 %%
 690
 691 /*
 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.
 698  */
 699 void
 700 yybegin(yystate_t state)
 701 {
 702 #ifdef  YYDEBUG
 703         yydebug = _dtrace_debug;
 704 #endif
 705         if (yypcb->pcb_yystate == state)
 706                 return; /* nothing to do if we're in the state already */
 707
 708         if (yypcb->pcb_yystate == YYS_DEFINE) {
 709                 yypcb->pcb_list = yypcb->pcb_hold;
 710                 yypcb->pcb_hold = NULL;
 711         }
 712
 713         switch (state) {
 714         case YYS_CLAUSE:
 715                 BEGIN(S2);
 716                 break;
 717         case YYS_DEFINE:
 718                 assert(yypcb->pcb_hold == NULL);
 719                 yypcb->pcb_hold = yypcb->pcb_list;
 720                 yypcb->pcb_list = NULL;
 721                 /*FALLTHRU*/
 722         case YYS_EXPR:
 723                 BEGIN(S0);
 724                 break;
 725         case YYS_DONE:
 726                 break;
 727         case YYS_CONTROL:
 728                 BEGIN(S4);
 729                 break;
 730         default:
 731                 xyerror(D_UNKNOWN, "internal error -- bad yystate %d\n", state);
 732         }
 733
 734         yypcb->pcb_yystate = state;
 735 }
 736
 737 void
 738 yyinit(dt_pcb_t *pcb)
 739 {
 740         yypcb = pcb;
 741         yylineno = 1;
 742         yypragma = NULL;
 743 #if defined(sun)
 744         yysptr = yysbuf;
 745 #endif
 746         YY_FLUSH_BUFFER;
 747 }
 748
 749 /*
 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.
 756  */
 757 static int
 758 id_or_type(const char *s)
 759 {
 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;
 763         dt_ident_t *idp;
 764
 765         if ((s = yylval.l_str = strdup(s)) == NULL)
 766                 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 767
 768         /*
 769          * If the lexeme is a global variable or likely identifier or *not* a
 770          * type_name, then it is an identifier token.
 771          */
 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);
 776
 777         /*
 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:
 781          *
 782          * typedef int foo;
 783          * struct s { foo foo; };
 784          *
 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().
 788          */
 789         if (ddp != NULL && ddp->dd_name != NULL)
 790                 return (DT_TOK_IDENT);
 791
 792         /*
 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.
 795          */
 796         if ((YYSTATE) != S0)
 797                 return (DT_TOK_TNAME);
 798
 799         /*
 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.
 806          */
 807         while ((c0 = input()) != 0) {
 808                 if (strchr("\f\n\r\t\v ", c0) == NULL)
 809                         break;
 810         }
 811
 812         switch (c0) {
 813         case '+':
 814         case '-':
 815                 if ((c1 = input()) == c0)
 816                         ttok = DT_TOK_IDENT;
 817                 unput(c1);
 818                 break;
 819
 820         case '=':
 821                 if ((c1 = input()) != c0)
 822                         ttok = DT_TOK_IDENT;
 823                 unput(c1);
 824                 break;
 825         case '[':
 826                 ttok = DT_TOK_IDENT;
 827                 break;
 828         }
 829
 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);
 833
 834                 if (idp == NULL)
 835                         longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
 836         }
 837
 838         unput(c0);
 839         return (ttok);
 840 }
 841
 842 #if defined(sun)
 843 static int
 844 input(void)
 845 {
 846         int c;
 847
 848         if (yysptr > yysbuf)
 849                 c = *--yysptr;
 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++);
 854         else
 855                 c = EOF;
 856
 857         if (c == '\n')
 858                 yylineno++;
 859
 860         if (c != EOF)
 861                 return (c);
 862
 863         if ((YYSTATE) == S1)
 864                 yyerror("end-of-file encountered before matching */\n");
 865
 866         if ((YYSTATE) == S3)
 867                 yyerror("end-of-file encountered before end of control line\n");
 868
 869         if (yypcb->pcb_fileptr != NULL && ferror(yypcb->pcb_fileptr))
 870                 longjmp(yypcb->pcb_jmpbuf, EDT_FIO);
 871
 872         return (0); /* EOF */
 873 }
 874
 875 static void
 876 unput(int c)
 877 {
 878         if (c == '\n')
 879                 yylineno--;
 880
 881         *yysptr++ = c;
 882         yytchar = c;
 883 }
 884 #endif