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 #ifdef illumos 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 #ifdef illumos 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((unsigned char)v[0]) || v[0] == '-' || 293 v[0] == '+') { 294 if (isdigit((unsigned char)v[0])) 295 yyintprefix = 0; 296 else 297 yyintprefix = *v++; 298 299 errno = 0; 300 yylval.l_int = strtoull(v, &p, 0); 301 (void) strncpy(yyintsuffix, p, 302 sizeof (yyintsuffix)); 303 yyintdecimal = *v != '0'; 304 305 if (errno == ERANGE) { 306 xyerror(D_MACRO_OFLOW, "macro argument" 307 " %s constant %s results in integer" 308 " overflow\n", yytext, v); 309 } 310 311 return (DT_TOK_INT); 312 } 313 314 return (id_or_type(v)); 315 } 316 317 <S0>"$$"{RGX_IDENT} { 318 dt_ident_t *idp = dt_idhash_lookup( 319 yypcb->pcb_hdl->dt_macros, yytext + 2); 320 321 char s[16]; /* enough for UINT_MAX + \0 */ 322 323 if (idp == NULL) { 324 xyerror(D_MACRO_UNDEF, "macro variable %s " 325 "is not defined\n", yytext); 326 } 327 328 /* 329 * For the moment, all current macro variables are of 330 * type id_t (refer to dtrace_update() for details). 331 */ 332 (void) snprintf(s, sizeof (s), "%u", idp->di_id); 333 if ((yylval.l_str = strdup(s)) == NULL) 334 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 335 336 return (DT_TOK_STRING); 337 } 338 339 <S0>"$"{RGX_IDENT} { 340 dt_ident_t *idp = dt_idhash_lookup( 341 yypcb->pcb_hdl->dt_macros, yytext + 1); 342 343 if (idp == NULL) { 344 xyerror(D_MACRO_UNDEF, "macro variable %s " 345 "is not defined\n", yytext); 346 } 347 348 /* 349 * For the moment, all current macro variables are of 350 * type id_t (refer to dtrace_update() for details). 351 */ 352 yylval.l_int = (intmax_t)(int)idp->di_id; 353 yyintprefix = 0; 354 yyintsuffix[0] = '\0'; 355 yyintdecimal = 1; 356 357 return (DT_TOK_INT); 358 } 359 360 <S0>{RGX_IDENT} | 361 <S0>{RGX_MOD_IDENT}{RGX_IDENT} | 362 <S0>{RGX_MOD_IDENT} { 363 return (id_or_type(yytext)); 364 } 365 366 <S0>{RGX_AGG} { 367 if ((yylval.l_str = strdup(yytext)) == NULL) 368 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 369 return (DT_TOK_AGG); 370 } 371 372 <S0>"@" { 373 if ((yylval.l_str = strdup("@_")) == NULL) 374 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 375 return (DT_TOK_AGG); 376 } 377 378 <S0>{RGX_INT} | 379 <S2>{RGX_INT} | 380 <S3>{RGX_INT} { 381 char *p; 382 383 errno = 0; 384 yylval.l_int = strtoull(yytext, &p, 0); 385 yyintprefix = 0; 386 (void) strncpy(yyintsuffix, p, sizeof (yyintsuffix)); 387 yyintdecimal = yytext[0] != '0'; 388 389 if (errno == ERANGE) { 390 xyerror(D_INT_OFLOW, "constant %s results in " 391 "integer overflow\n", yytext); 392 } 393 394 if (*p != '\0' && strchr("uUlL", *p) == NULL) { 395 xyerror(D_INT_DIGIT, "constant %s contains " 396 "invalid digit %c\n", yytext, *p); 397 } 398 399 if ((YYSTATE) != S3) 400 return (DT_TOK_INT); 401 402 yypragma = dt_node_link(yypragma, 403 dt_node_int(yylval.l_int)); 404 } 405 406 <S0>{RGX_FP} yyerror("floating-point constants are not permitted\n"); 407 408 <S0>\"{RGX_STR}$ | 409 <S3>\"{RGX_STR}$ xyerror(D_STR_NL, "newline encountered in string literal"); 410 411 <S0>\"{RGX_STR}\" | 412 <S3>\"{RGX_STR}\" { 413 /* 414 * Quoted string -- convert C escape sequences and 415 * return the string as a token. 416 */ 417 yylval.l_str = strndup(yytext + 1, yyleng - 2); 418 419 if (yylval.l_str == NULL) 420 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 421 422 (void) stresc2chr(yylval.l_str); 423 if ((YYSTATE) != S3) 424 return (DT_TOK_STRING); 425 426 yypragma = dt_node_link(yypragma, 427 dt_node_string(yylval.l_str)); 428 } 429 430 <S0>'{RGX_CHR}$ xyerror(D_CHR_NL, "newline encountered in character constant"); 431 432 <S0>'{RGX_CHR}' { 433 char *s; 434 #if BYTE_ORDER == _LITTLE_ENDIAN 435 char *p, *q; 436 #endif 437 size_t nbytes; 438 439 /* 440 * Character constant -- convert C escape sequences and 441 * return the character as an integer immediate value. 442 */ 443 if (yyleng == 2) 444 xyerror(D_CHR_NULL, "empty character constant"); 445 446 s = yytext + 1; 447 yytext[yyleng - 1] = '\0'; 448 nbytes = stresc2chr(s); 449 yylval.l_int = 0; 450 yyintprefix = 0; 451 yyintsuffix[0] = '\0'; 452 yyintdecimal = 1; 453 454 if (nbytes > sizeof (yylval.l_int)) { 455 xyerror(D_CHR_OFLOW, "character constant is " 456 "too long"); 457 } 458 #if BYTE_ORDER == _LITTLE_ENDIAN 459 p = ((char *)&yylval.l_int) + nbytes - 1; 460 for (q = s; nbytes != 0; nbytes--) 461 *p-- = *q++; 462 #else 463 bcopy(s, ((char *)&yylval.l_int) + 464 sizeof (yylval.l_int) - nbytes, nbytes); 465 #endif 466 return (DT_TOK_INT); 467 } 468 469 <S0>"/*" | 470 <S2>"/*" { 471 yypcb->pcb_cstate = (YYSTATE); 472 BEGIN(S1); 473 } 474 475 <S0>{RGX_INTERP} | 476 <S2>{RGX_INTERP} ; /* discard any #! lines */ 477 478 <S0>{RGX_CTL} | 479 <S2>{RGX_CTL} | 480 <S4>{RGX_CTL} { 481 assert(yypragma == NULL); 482 yypcb->pcb_cstate = (YYSTATE); 483 BEGIN(S3); 484 } 485 486 <S4>. ; /* discard */ 487 <S4>"\n" ; /* discard */ 488 489 <S0>"/" { 490 int c, tok; 491 492 /* 493 * The use of "/" as the predicate delimiter and as the 494 * integer division symbol requires special lookahead 495 * to avoid a shift/reduce conflict in the D grammar. 496 * We look ahead to the next non-whitespace character. 497 * If we encounter EOF, ";", "{", or "/", then this "/" 498 * closes the predicate and we return DT_TOK_EPRED. 499 * If we encounter anything else, it's DT_TOK_DIV. 500 */ 501 while ((c = input()) != 0) { 502 if (strchr("\f\n\r\t\v ", c) == NULL) 503 break; 504 } 505 506 if (c == 0 || c == ';' || c == '{' || c == '/') { 507 if (yypcb->pcb_parens != 0) { 508 yyerror("closing ) expected in " 509 "predicate before /\n"); 510 } 511 if (yypcb->pcb_brackets != 0) { 512 yyerror("closing ] expected in " 513 "predicate before /\n"); 514 } 515 tok = DT_TOK_EPRED; 516 } else 517 tok = DT_TOK_DIV; 518 519 unput(c); 520 return (tok); 521 } 522 523 <S0>"(" { 524 yypcb->pcb_parens++; 525 return (DT_TOK_LPAR); 526 } 527 528 <S0>")" { 529 if (--yypcb->pcb_parens < 0) 530 yyerror("extra ) in input stream\n"); 531 return (DT_TOK_RPAR); 532 } 533 534 <S0>"[" { 535 yypcb->pcb_brackets++; 536 return (DT_TOK_LBRAC); 537 } 538 539 <S0>"]" { 540 if (--yypcb->pcb_brackets < 0) 541 yyerror("extra ] in input stream\n"); 542 return (DT_TOK_RBRAC); 543 } 544 545 <S0>"{" | 546 <S2>"{" { 547 yypcb->pcb_braces++; 548 return ('{'); 549 } 550 551 <S0>"}" { 552 if (--yypcb->pcb_braces < 0) 553 yyerror("extra } in input stream\n"); 554 return ('}'); 555 } 556 557 <S0>"|" return (DT_TOK_BOR); 558 <S0>"^" return (DT_TOK_XOR); 559 <S0>"&" return (DT_TOK_BAND); 560 <S0>"&&" return (DT_TOK_LAND); 561 <S0>"^^" return (DT_TOK_LXOR); 562 <S0>"||" return (DT_TOK_LOR); 563 <S0>"==" return (DT_TOK_EQU); 564 <S0>"!=" return (DT_TOK_NEQ); 565 <S0>"<" return (DT_TOK_LT); 566 <S0>"<=" return (DT_TOK_LE); 567 <S0>">" return (DT_TOK_GT); 568 <S0>">=" return (DT_TOK_GE); 569 <S0>"<<" return (DT_TOK_LSH); 570 <S0>">>" return (DT_TOK_RSH); 571 <S0>"+" return (DT_TOK_ADD); 572 <S0>"-" return (DT_TOK_SUB); 573 <S0>"*" return (DT_TOK_MUL); 574 <S0>"%" return (DT_TOK_MOD); 575 <S0>"~" return (DT_TOK_BNEG); 576 <S0>"!" return (DT_TOK_LNEG); 577 <S0>"?" return (DT_TOK_QUESTION); 578 <S0>":" return (DT_TOK_COLON); 579 <S0>"." return (DT_TOK_DOT); 580 <S0>"->" return (DT_TOK_PTR); 581 <S0>"=" return (DT_TOK_ASGN); 582 <S0>"+=" return (DT_TOK_ADD_EQ); 583 <S0>"-=" return (DT_TOK_SUB_EQ); 584 <S0>"*=" return (DT_TOK_MUL_EQ); 585 <S0>"/=" return (DT_TOK_DIV_EQ); 586 <S0>"%=" return (DT_TOK_MOD_EQ); 587 <S0>"&=" return (DT_TOK_AND_EQ); 588 <S0>"^=" return (DT_TOK_XOR_EQ); 589 <S0>"|=" return (DT_TOK_OR_EQ); 590 <S0>"<<=" return (DT_TOK_LSH_EQ); 591 <S0>">>=" return (DT_TOK_RSH_EQ); 592 <S0>"++" return (DT_TOK_ADDADD); 593 <S0>"--" return (DT_TOK_SUBSUB); 594 <S0>"..." return (DT_TOK_ELLIPSIS); 595 <S0>"," return (DT_TOK_COMMA); 596 <S0>";" return (';'); 597 <S0>{RGX_WS} ; /* discard */ 598 <S0>"\\"\n ; /* discard */ 599 <S0>. yyerror("syntax error near \"%c\"\n", yytext[0]); 600 601 <S1>"/*" yyerror("/* encountered inside a comment\n"); 602 <S1>"*/" BEGIN(yypcb->pcb_cstate); 603 <S1>.|\n ; /* discard */ 604 605 <S2>{RGX_PSPEC} { 606 /* 607 * S2 has an ambiguity because RGX_PSPEC includes '*' 608 * as a glob character and '*' also can be DT_TOK_STAR. 609 * Since lex always matches the longest token, this 610 * rule can be matched by an input string like "int*", 611 * which could begin a global variable declaration such 612 * as "int*x;" or could begin a RGX_PSPEC with globbing 613 * such as "int* { trace(timestamp); }". If C_PSPEC is 614 * not set, we must resolve the ambiguity in favor of 615 * the type and perform lexer pushback if the fragment 616 * before '*' or entire fragment matches a type name. 617 * If C_PSPEC is set, we always return a PSPEC token. 618 * If C_PSPEC is off, the user can avoid ambiguity by 619 * including a ':' delimiter in the specifier, which 620 * they should be doing anyway to specify the provider. 621 */ 622 if (!(yypcb->pcb_cflags & DTRACE_C_PSPEC) && 623 strchr(yytext, ':') == NULL) { 624 625 char *p = strchr(yytext, '*'); 626 char *q = yytext + yyleng - 1; 627 628 if (p != NULL && p > yytext) 629 *p = '\0'; /* prune yytext */ 630 631 if (dt_type_lookup(yytext, NULL) == 0) { 632 yylval.l_str = strdup(yytext); 633 634 if (yylval.l_str == NULL) { 635 longjmp(yypcb->pcb_jmpbuf, 636 EDT_NOMEM); 637 } 638 639 if (p != NULL && p > yytext) { 640 for (*p = '*'; q >= p; q--) 641 unput(*q); 642 } 643 644 yybegin(YYS_EXPR); 645 return (DT_TOK_TNAME); 646 } 647 648 if (p != NULL && p > yytext) 649 *p = '*'; /* restore yytext */ 650 } 651 652 if ((yylval.l_str = strdup(yytext)) == NULL) 653 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 654 655 return (DT_TOK_PSPEC); 656 } 657 658 <S2>"/" return (DT_TOK_DIV); 659 <S2>"," return (DT_TOK_COMMA); 660 661 <S2>{RGX_WS} ; /* discard */ 662 <S2>. yyerror("syntax error near \"%c\"\n", yytext[0]); 663 664 <S3>\n { 665 dt_pragma(yypragma); 666 yypragma = NULL; 667 BEGIN(yypcb->pcb_cstate); 668 } 669 670 <S3>[\f\t\v ]+ ; /* discard */ 671 672 <S3>[^\f\n\t\v "]+ { 673 dt_node_t *dnp; 674 675 if ((yylval.l_str = strdup(yytext)) == NULL) 676 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 677 678 /* 679 * We want to call dt_node_ident() here, but we can't 680 * because it will expand inlined identifiers, which we 681 * don't want to do from #pragma context in order to 682 * support pragmas that apply to the ident itself. We 683 * call dt_node_string() and then reset dn_op instead. 684 */ 685 dnp = dt_node_string(yylval.l_str); 686 dnp->dn_kind = DT_NODE_IDENT; 687 dnp->dn_op = DT_TOK_IDENT; 688 yypragma = dt_node_link(yypragma, dnp); 689 } 690 691 <S3>. yyerror("syntax error near \"%c\"\n", yytext[0]); 692 693 %% 694 695 /* 696 * yybegin provides a wrapper for use from C code around the lex BEGIN() macro. 697 * We use two main states for lexing because probe descriptions use a syntax 698 * that is incompatible with the normal D tokens (e.g. names can contain "-"). 699 * yybegin also handles the job of switching between two lists of dt_nodes 700 * as we allocate persistent definitions, like inlines, and transient nodes 701 * that will be freed once we are done parsing the current program file. 702 */ 703 void 704 yybegin(yystate_t state) 705 { 706 #ifdef YYDEBUG 707 yydebug = _dtrace_debug; 708 #endif 709 if (yypcb->pcb_yystate == state) 710 return; /* nothing to do if we're in the state already */ 711 712 if (yypcb->pcb_yystate == YYS_DEFINE) { 713 yypcb->pcb_list = yypcb->pcb_hold; 714 yypcb->pcb_hold = NULL; 715 } 716 717 switch (state) { 718 case YYS_CLAUSE: 719 BEGIN(S2); 720 break; 721 case YYS_DEFINE: 722 assert(yypcb->pcb_hold == NULL); 723 yypcb->pcb_hold = yypcb->pcb_list; 724 yypcb->pcb_list = NULL; 725 /*FALLTHRU*/ 726 case YYS_EXPR: 727 BEGIN(S0); 728 break; 729 case YYS_DONE: 730 break; 731 case YYS_CONTROL: 732 BEGIN(S4); 733 break; 734 default: 735 xyerror(D_UNKNOWN, "internal error -- bad yystate %d\n", state); 736 } 737 738 yypcb->pcb_yystate = state; 739 } 740 741 void 742 yyinit(dt_pcb_t *pcb) 743 { 744 yypcb = pcb; 745 yylineno = 1; 746 yypragma = NULL; 747 #ifdef illumos 748 yysptr = yysbuf; 749 #endif 750 YY_FLUSH_BUFFER; 751 } 752 753 /* 754 * Given a lexeme 's' (typically yytext), set yylval and return an appropriate 755 * token to the parser indicating either an identifier or a typedef name. 756 * User-defined global variables always take precedence over types, but we do 757 * use some heuristics because D programs can look at an ever-changing set of 758 * kernel types and also can implicitly instantiate variables by assignment, 759 * unlike in C. The code here is ordered carefully as lookups are not cheap. 760 */ 761 static int 762 id_or_type(const char *s) 763 { 764 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 765 dt_decl_t *ddp = yypcb->pcb_dstack.ds_decl; 766 int c0, c1, ttok = DT_TOK_TNAME; 767 dt_ident_t *idp; 768 769 if ((s = yylval.l_str = strdup(s)) == NULL) 770 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 771 772 /* 773 * If the lexeme is a global variable or likely identifier or *not* a 774 * type_name, then it is an identifier token. 775 */ 776 if (dt_idstack_lookup(&yypcb->pcb_globals, s) != NULL || 777 dt_idhash_lookup(yypcb->pcb_idents, s) != NULL || 778 dt_type_lookup(s, NULL) != 0) 779 return (DT_TOK_IDENT); 780 781 /* 782 * If we're in the midst of parsing a declaration and a type_specifier 783 * has already been shifted, then return DT_TOK_IDENT instead of TNAME. 784 * This semantic is necessary to permit valid ISO C code such as: 785 * 786 * typedef int foo; 787 * struct s { foo foo; }; 788 * 789 * without causing shift/reduce conflicts in the direct_declarator part 790 * of the grammar. The result is that we must check for conflicting 791 * redeclarations of the same identifier as part of dt_node_decl(). 792 */ 793 if (ddp != NULL && ddp->dd_name != NULL) 794 return (DT_TOK_IDENT); 795 796 /* 797 * If the lexeme is a type name and we are not in a program clause, 798 * then always interpret it as a type and return DT_TOK_TNAME. 799 */ 800 if ((YYSTATE) != S0) 801 return (DT_TOK_TNAME); 802 803 /* 804 * If the lexeme matches a type name but is in a program clause, then 805 * it could be a type or it could be an undefined variable. Peek at 806 * the next token to decide. If we see ++, --, [, or =, we know there 807 * might be an assignment that is trying to create a global variable, 808 * so we optimistically return DT_TOK_IDENT. There is no harm in being 809 * wrong: a type_name followed by ++, --, [, or = is a syntax error. 810 */ 811 while ((c0 = input()) != 0) { 812 if (strchr("\f\n\r\t\v ", c0) == NULL) 813 break; 814 } 815 816 switch (c0) { 817 case '+': 818 case '-': 819 if ((c1 = input()) == c0) 820 ttok = DT_TOK_IDENT; 821 unput(c1); 822 break; 823 824 case '=': 825 if ((c1 = input()) != c0) 826 ttok = DT_TOK_IDENT; 827 unput(c1); 828 break; 829 case '[': 830 ttok = DT_TOK_IDENT; 831 break; 832 } 833 834 if (ttok == DT_TOK_IDENT) { 835 idp = dt_idhash_insert(yypcb->pcb_idents, s, DT_IDENT_SCALAR, 0, 836 0, _dtrace_defattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen); 837 838 if (idp == NULL) 839 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 840 } 841 842 unput(c0); 843 return (ttok); 844 } 845 846 #ifdef illumos 847 static int 848 input(void) 849 { 850 int c; 851 852 if (yysptr > yysbuf) 853 c = *--yysptr; 854 else if (yypcb->pcb_fileptr != NULL) 855 c = fgetc(yypcb->pcb_fileptr); 856 else if (yypcb->pcb_strptr < yypcb->pcb_string + yypcb->pcb_strlen) 857 c = *(unsigned char *)(yypcb->pcb_strptr++); 858 else 859 c = EOF; 860 861 if (c == '\n') 862 yylineno++; 863 864 if (c != EOF) 865 return (c); 866 867 if ((YYSTATE) == S1) 868 yyerror("end-of-file encountered before matching */\n"); 869 870 if ((YYSTATE) == S3) 871 yyerror("end-of-file encountered before end of control line\n"); 872 873 if (yypcb->pcb_fileptr != NULL && ferror(yypcb->pcb_fileptr)) 874 longjmp(yypcb->pcb_jmpbuf, EDT_FIO); 875 876 return (0); /* EOF */ 877 } 878 879 static void 880 unput(int c) 881 { 882 if (c == '\n') 883 yylineno--; 884 885 *yysptr++ = c; 886 yytchar = c; 887 } 888 #endif /* illumos */ 889