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#include <string.h> 28#include <stdlib.h> 29#include <stdio.h> 30#include <assert.h> 31#include <ctype.h> 32#include <errno.h> 33 34#include <dt_impl.h> 35#include <dt_grammar.h> 36#include <dt_parser.h> 37#include <dt_string.h> 38 39/* 40 * We need to undefine lex's input and unput macros so that references to these 41 * call the functions provided at the end of this source file. 42 */ 43#undef input 44#undef unput 45 46static int id_or_type(const char *); 47static int input(void); 48static void unput(int); 49 50/* 51 * We first define a set of labeled states for use in the D lexer and then a 52 * set of regular expressions to simplify things below. The lexer states are: 53 * 54 * S0 - D program clause and expression lexing 55 * S1 - D comments (i.e. skip everything until end of comment) 56 * S2 - D program outer scope (probe specifiers and declarations) 57 * S3 - D control line parsing (i.e. after ^# is seen but before \n) 58 * S4 - D control line scan (locate control directives only and invoke S3) 59 */ 60%} 61 62%e 1500 /* maximum nodes */ 63%p 3700 /* maximum positions */ 64%n 600 /* maximum states */ 65 66%s S0 S1 S2 S3 S4 67 68RGX_AGG "@"[a-zA-Z_][0-9a-zA-Z_]* 69RGX_PSPEC [-$:a-zA-Z_.?*\\\[\]!][-$:0-9a-zA-Z_.`?*\\\[\]!]* 70RGX_IDENT [a-zA-Z_`][0-9a-zA-Z_`]* 71RGX_INT ([0-9]+|0[xX][0-9A-Fa-f]+)[uU]?[lL]?[lL]? 72RGX_FP ([0-9]+("."?)[0-9]*|"."[0-9]+)((e|E)("+"|-)?[0-9]+)?[fFlL]? 73RGX_WS [\f\n\r\t\v ] 74RGX_STR ([^"\\\n]|\\[^"\n]|\\\")* 75RGX_CHR ([^'\\\n]|\\[^'\n]|\\')* 76RGX_INTERP ^[\f\t\v ]*#!.* 77RGX_CTL ^[\f\t\v ]*# 78 79%% 80 81%{ 82 83/* 84 * We insert a special prologue into yylex() itself: if the pcb contains a 85 * context token, we return that prior to running the normal lexer. This 86 * allows libdtrace to force yacc into one of our three parsing contexts: D 87 * expression (DT_CTX_DEXPR), D program (DT_CTX_DPROG) or D type (DT_CTX_DTYPE). 88 * Once the token is returned, we clear it so this only happens once. 89 */ 90if (yypcb->pcb_token != 0) { 91 int tok = yypcb->pcb_token; 92 yypcb->pcb_token = 0; 93 return (tok); 94} 95 96%} 97 98<S0>auto return (DT_KEY_AUTO); 99<S0>break return (DT_KEY_BREAK); 100<S0>case return (DT_KEY_CASE); 101<S0>char return (DT_KEY_CHAR); 102<S0>const return (DT_KEY_CONST); 103<S0>continue return (DT_KEY_CONTINUE); 104<S0>counter return (DT_KEY_COUNTER); 105<S0>default return (DT_KEY_DEFAULT); 106<S0>do return (DT_KEY_DO); 107<S0>double return (DT_KEY_DOUBLE); 108<S0>else return (DT_KEY_ELSE); 109<S0>enum return (DT_KEY_ENUM); 110<S0>extern return (DT_KEY_EXTERN); 111<S0>float return (DT_KEY_FLOAT); 112<S0>for return (DT_KEY_FOR); 113<S0>goto return (DT_KEY_GOTO); 114<S0>if return (DT_KEY_IF); 115<S0>import return (DT_KEY_IMPORT); 116<S0>inline return (DT_KEY_INLINE); 117<S0>int return (DT_KEY_INT); 118<S0>long return (DT_KEY_LONG); 119<S0>offsetof return (DT_TOK_OFFSETOF); 120<S0>probe return (DT_KEY_PROBE); 121<S0>provider return (DT_KEY_PROVIDER); 122<S0>register return (DT_KEY_REGISTER); 123<S0>restrict return (DT_KEY_RESTRICT); 124<S0>return return (DT_KEY_RETURN); 125<S0>self return (DT_KEY_SELF); 126<S0>short return (DT_KEY_SHORT); 127<S0>signed return (DT_KEY_SIGNED); 128<S0>sizeof return (DT_TOK_SIZEOF); 129<S0>static return (DT_KEY_STATIC); 130<S0>string return (DT_KEY_STRING); 131<S0>stringof return (DT_TOK_STRINGOF); 132<S0>struct return (DT_KEY_STRUCT); 133<S0>switch return (DT_KEY_SWITCH); 134<S0>this return (DT_KEY_THIS); 135<S0>translator return (DT_KEY_XLATOR); 136<S0>typedef return (DT_KEY_TYPEDEF); 137<S0>union return (DT_KEY_UNION); 138<S0>unsigned return (DT_KEY_UNSIGNED); 139<S0>void return (DT_KEY_VOID); 140<S0>volatile return (DT_KEY_VOLATILE); 141<S0>while return (DT_KEY_WHILE); 142<S0>xlate return (DT_TOK_XLATE); 143 144<S2>auto { yybegin(YYS_EXPR); return (DT_KEY_AUTO); } 145<S2>char { yybegin(YYS_EXPR); return (DT_KEY_CHAR); } 146<S2>const { yybegin(YYS_EXPR); return (DT_KEY_CONST); } 147<S2>counter { yybegin(YYS_DEFINE); return (DT_KEY_COUNTER); } 148<S2>double { yybegin(YYS_EXPR); return (DT_KEY_DOUBLE); } 149<S2>enum { yybegin(YYS_EXPR); return (DT_KEY_ENUM); } 150<S2>extern { yybegin(YYS_EXPR); return (DT_KEY_EXTERN); } 151<S2>float { yybegin(YYS_EXPR); return (DT_KEY_FLOAT); } 152<S2>import { yybegin(YYS_EXPR); return (DT_KEY_IMPORT); } 153<S2>inline { yybegin(YYS_DEFINE); return (DT_KEY_INLINE); } 154<S2>int { yybegin(YYS_EXPR); return (DT_KEY_INT); } 155<S2>long { yybegin(YYS_EXPR); return (DT_KEY_LONG); } 156<S2>provider { yybegin(YYS_DEFINE); return (DT_KEY_PROVIDER); } 157<S2>register { yybegin(YYS_EXPR); return (DT_KEY_REGISTER); } 158<S2>restrict { yybegin(YYS_EXPR); return (DT_KEY_RESTRICT); } 159<S2>self { yybegin(YYS_EXPR); return (DT_KEY_SELF); } 160<S2>short { yybegin(YYS_EXPR); return (DT_KEY_SHORT); } 161<S2>signed { yybegin(YYS_EXPR); return (DT_KEY_SIGNED); } 162<S2>static { yybegin(YYS_EXPR); return (DT_KEY_STATIC); } 163<S2>string { yybegin(YYS_EXPR); return (DT_KEY_STRING); } 164<S2>struct { yybegin(YYS_EXPR); return (DT_KEY_STRUCT); } 165<S2>this { yybegin(YYS_EXPR); return (DT_KEY_THIS); } 166<S2>translator { yybegin(YYS_DEFINE); return (DT_KEY_XLATOR); } 167<S2>typedef { yybegin(YYS_EXPR); return (DT_KEY_TYPEDEF); } 168<S2>union { yybegin(YYS_EXPR); return (DT_KEY_UNION); } 169<S2>unsigned { yybegin(YYS_EXPR); return (DT_KEY_UNSIGNED); } 170<S2>void { yybegin(YYS_EXPR); return (DT_KEY_VOID); } 171<S2>volatile { yybegin(YYS_EXPR); return (DT_KEY_VOLATILE); } 172 173<S0>"$$"[0-9]+ { 174 int i = atoi(yytext + 2); 175 char *v = ""; 176 177 /* 178 * A macro argument reference substitutes the text of 179 * an argument in place of the current token. When we 180 * see $$<d> we fetch the saved string from pcb_sargv 181 * (or use the default argument if the option has been 182 * set and the argument hasn't been specified) and 183 * return a token corresponding to this string. 184 */ 185 if (i < 0 || (i >= yypcb->pcb_sargc && 186 !(yypcb->pcb_cflags & DTRACE_C_DEFARG))) { 187 xyerror(D_MACRO_UNDEF, "macro argument %s is " 188 "not defined\n", yytext); 189 } 190 191 if (i < yypcb->pcb_sargc) { 192 v = yypcb->pcb_sargv[i]; /* get val from pcb */ 193 yypcb->pcb_sflagv[i] |= DT_IDFLG_REF; 194 } 195 196 if ((yylval.l_str = strdup(v)) == NULL) 197 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 198 199 (void) stresc2chr(yylval.l_str); 200 return (DT_TOK_STRING); 201 } 202 203<S0>"$"[0-9]+ { 204 int i = atoi(yytext + 1); 205 char *p, *v = "0"; 206 207 /* 208 * A macro argument reference substitutes the text of 209 * one identifier or integer pattern for another. When 210 * we see $<d> we fetch the saved string from pcb_sargv 211 * (or use the default argument if the option has been 212 * set and the argument hasn't been specified) and 213 * return a token corresponding to this string. 214 */ 215 if (i < 0 || (i >= yypcb->pcb_sargc && 216 !(yypcb->pcb_cflags & DTRACE_C_DEFARG))) { 217 xyerror(D_MACRO_UNDEF, "macro argument %s is " 218 "not defined\n", yytext); 219 } 220 221 if (i < yypcb->pcb_sargc) { 222 v = yypcb->pcb_sargv[i]; /* get val from pcb */ 223 yypcb->pcb_sflagv[i] |= DT_IDFLG_REF; 224 } 225 226 /* 227 * If the macro text is not a valid integer or ident, 228 * then we treat it as a string. The string may be 229 * optionally enclosed in quotes, which we strip. 230 */ 231 if (strbadidnum(v)) { 232 size_t len = strlen(v); 233 234 if (len != 1 && *v == '"' && v[len - 1] == '"') 235 yylval.l_str = strndup(v + 1, len - 2); 236 else 237 yylval.l_str = strndup(v, len); 238 239 if (yylval.l_str == NULL) 240 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 241 242 (void) stresc2chr(yylval.l_str); 243 return (DT_TOK_STRING); 244 } 245 246 /* 247 * If the macro text is not a string an begins with a 248 * digit or a +/- sign, process it as an integer token. 249 */ 250 if (isdigit(v[0]) || v[0] == '-' || v[0] == '+') { 251 if (isdigit(v[0])) 252 yyintprefix = 0; 253 else 254 yyintprefix = *v++; 255 256 errno = 0; 257 yylval.l_int = strtoull(v, &p, 0); 258 (void) strncpy(yyintsuffix, p, 259 sizeof (yyintsuffix)); 260 yyintdecimal = *v != '0'; 261 262 if (errno == ERANGE) { 263 xyerror(D_MACRO_OFLOW, "macro argument" 264 " %s constant %s results in integer" 265 " overflow\n", yytext, v); 266 } 267 268 return (DT_TOK_INT); 269 } 270 271 return (id_or_type(v)); 272 } 273 274<S0>"$$"{RGX_IDENT} { 275 dt_ident_t *idp = dt_idhash_lookup( 276 yypcb->pcb_hdl->dt_macros, yytext + 2); 277 278 char s[16]; /* enough for UINT_MAX + \0 */ 279 280 if (idp == NULL) { 281 xyerror(D_MACRO_UNDEF, "macro variable %s " 282 "is not defined\n", yytext); 283 } 284 285 /* 286 * For the moment, all current macro variables are of 287 * type id_t (refer to dtrace_update() for details). 288 */ 289 (void) snprintf(s, sizeof (s), "%u", idp->di_id); 290 if ((yylval.l_str = strdup(s)) == NULL) 291 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 292 293 return (DT_TOK_STRING); 294 } 295 296<S0>"$"{RGX_IDENT} { 297 dt_ident_t *idp = dt_idhash_lookup( 298 yypcb->pcb_hdl->dt_macros, yytext + 1); 299 300 if (idp == NULL) { 301 xyerror(D_MACRO_UNDEF, "macro variable %s " 302 "is not defined\n", yytext); 303 } 304 305 /* 306 * For the moment, all current macro variables are of 307 * type id_t (refer to dtrace_update() for details). 308 */ 309 yylval.l_int = (intmax_t)(int)idp->di_id; 310 yyintprefix = 0; 311 yyintsuffix[0] = '\0'; 312 yyintdecimal = 1; 313 314 return (DT_TOK_INT); 315 } 316 317<S0>{RGX_IDENT} { 318 return (id_or_type(yytext)); 319 } 320 321<S0>{RGX_AGG} { 322 if ((yylval.l_str = strdup(yytext)) == NULL) 323 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 324 return (DT_TOK_AGG); 325 } 326 327<S0>"@" { 328 if ((yylval.l_str = strdup("@_")) == NULL) 329 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 330 return (DT_TOK_AGG); 331 } 332 333<S0>{RGX_INT} | 334<S2>{RGX_INT} | 335<S3>{RGX_INT} { 336 char *p; 337 338 errno = 0; 339 yylval.l_int = strtoull(yytext, &p, 0); 340 yyintprefix = 0; 341 (void) strncpy(yyintsuffix, p, sizeof (yyintsuffix)); 342 yyintdecimal = yytext[0] != '0'; 343 344 if (errno == ERANGE) { 345 xyerror(D_INT_OFLOW, "constant %s results in " 346 "integer overflow\n", yytext); 347 } 348 349 if (*p != '\0' && strchr("uUlL", *p) == NULL) { 350 xyerror(D_INT_DIGIT, "constant %s contains " 351 "invalid digit %c\n", yytext, *p); 352 } 353 354 if ((YYSTATE) != S3) 355 return (DT_TOK_INT); 356 357 yypragma = dt_node_link(yypragma, 358 dt_node_int(yylval.l_int)); 359 } 360 361<S0>{RGX_FP} yyerror("floating-point constants are not permitted\n"); 362 363<S0>\"{RGX_STR}$ | 364<S3>\"{RGX_STR}$ xyerror(D_STR_NL, "newline encountered in string literal"); 365 366<S0>\"{RGX_STR}\" | 367<S3>\"{RGX_STR}\" { 368 /* 369 * Quoted string -- convert C escape sequences and 370 * return the string as a token. 371 */ 372 yylval.l_str = strndup(yytext + 1, yyleng - 2); 373 374 if (yylval.l_str == NULL) 375 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 376 377 (void) stresc2chr(yylval.l_str); 378 if ((YYSTATE) != S3) 379 return (DT_TOK_STRING); 380 381 yypragma = dt_node_link(yypragma, 382 dt_node_string(yylval.l_str)); 383 } 384 385<S0>'{RGX_CHR}$ xyerror(D_CHR_NL, "newline encountered in character constant"); 386 387<S0>'{RGX_CHR}' { 388 char *s, *p, *q; 389 size_t nbytes; 390 391 /* 392 * Character constant -- convert C escape sequences and 393 * return the character as an integer immediate value. 394 */ 395 if (yyleng == 2) 396 xyerror(D_CHR_NULL, "empty character constant"); 397 398 s = yytext + 1; 399 yytext[yyleng - 1] = '\0'; 400 nbytes = stresc2chr(s); 401 yylval.l_int = 0; 402 yyintprefix = 0; 403 yyintsuffix[0] = '\0'; 404 yyintdecimal = 1; 405 406 if (nbytes > sizeof (yylval.l_int)) { 407 xyerror(D_CHR_OFLOW, "character constant is " 408 "too long"); 409 } 410#ifdef _LITTLE_ENDIAN 411 p = ((char *)&yylval.l_int) + nbytes - 1; 412 for (q = s; nbytes != 0; nbytes--) 413 *p-- = *q++; 414#else 415 bcopy(s, ((char *)&yylval.l_int) + 416 sizeof (yylval.l_int) - nbytes, nbytes); 417#endif 418 return (DT_TOK_INT); 419 } 420 421<S0>"/*" | 422<S2>"/*" { 423 yypcb->pcb_cstate = (YYSTATE); 424 BEGIN(S1); 425 } 426 427<S0>{RGX_INTERP} | 428<S2>{RGX_INTERP} ; /* discard any #! lines */ 429 430<S0>{RGX_CTL} | 431<S2>{RGX_CTL} | 432<S4>{RGX_CTL} { 433 assert(yypragma == NULL); 434 yypcb->pcb_cstate = (YYSTATE); 435 BEGIN(S3); 436 } 437 438<S4>. ; /* discard */ 439<S4>"\n" ; /* discard */ 440 441<S0>"/" { 442 int c, tok; 443 444 /* 445 * The use of "/" as the predicate delimiter and as the 446 * integer division symbol requires special lookahead 447 * to avoid a shift/reduce conflict in the D grammar. 448 * We look ahead to the next non-whitespace character. 449 * If we encounter EOF, ";", "{", or "/", then this "/" 450 * closes the predicate and we return DT_TOK_EPRED. 451 * If we encounter anything else, it's DT_TOK_DIV. 452 */ 453 while ((c = input()) != 0) { 454 if (strchr("\f\n\r\t\v ", c) == NULL) 455 break; 456 } 457 458 if (c == 0 || c == ';' || c == '{' || c == '/') { 459 if (yypcb->pcb_parens != 0) { 460 yyerror("closing ) expected in " 461 "predicate before /\n"); 462 } 463 if (yypcb->pcb_brackets != 0) { 464 yyerror("closing ] expected in " 465 "predicate before /\n"); 466 } 467 tok = DT_TOK_EPRED; 468 } else 469 tok = DT_TOK_DIV; 470 471 unput(c); 472 return (tok); 473 } 474 475<S0>"(" { 476 yypcb->pcb_parens++; 477 return (DT_TOK_LPAR); 478 } 479 480<S0>")" { 481 if (--yypcb->pcb_parens < 0) 482 yyerror("extra ) in input stream\n"); 483 return (DT_TOK_RPAR); 484 } 485 486<S0>"[" { 487 yypcb->pcb_brackets++; 488 return (DT_TOK_LBRAC); 489 } 490 491<S0>"]" { 492 if (--yypcb->pcb_brackets < 0) 493 yyerror("extra ] in input stream\n"); 494 return (DT_TOK_RBRAC); 495 } 496 497<S0>"{" | 498<S2>"{" { 499 yypcb->pcb_braces++; 500 return ('{'); 501 } 502 503<S0>"}" { 504 if (--yypcb->pcb_braces < 0) 505 yyerror("extra } in input stream\n"); 506 return ('}'); 507 } 508 509<S0>"|" return (DT_TOK_BOR); 510<S0>"^" return (DT_TOK_XOR); 511<S0>"&" return (DT_TOK_BAND); 512<S0>"&&" return (DT_TOK_LAND); 513<S0>"^^" return (DT_TOK_LXOR); 514<S0>"||" return (DT_TOK_LOR); 515<S0>"==" return (DT_TOK_EQU); 516<S0>"!=" return (DT_TOK_NEQ); 517<S0>"<" return (DT_TOK_LT); 518<S0>"<=" return (DT_TOK_LE); 519<S0>">" return (DT_TOK_GT); 520<S0>">=" return (DT_TOK_GE); 521<S0>"<<" return (DT_TOK_LSH); 522<S0>">>" return (DT_TOK_RSH); 523<S0>"+" return (DT_TOK_ADD); 524<S0>"-" return (DT_TOK_SUB); 525<S0>"*" return (DT_TOK_MUL); 526<S0>"%" return (DT_TOK_MOD); 527<S0>"~" return (DT_TOK_BNEG); 528<S0>"!" return (DT_TOK_LNEG); 529<S0>"?" return (DT_TOK_QUESTION); 530<S0>":" return (DT_TOK_COLON); 531<S0>"." return (DT_TOK_DOT); 532<S0>"->" return (DT_TOK_PTR); 533<S0>"=" return (DT_TOK_ASGN); 534<S0>"+=" return (DT_TOK_ADD_EQ); 535<S0>"-=" return (DT_TOK_SUB_EQ); 536<S0>"*=" return (DT_TOK_MUL_EQ); 537<S0>"/=" return (DT_TOK_DIV_EQ); 538<S0>"%=" return (DT_TOK_MOD_EQ); 539<S0>"&=" return (DT_TOK_AND_EQ); 540<S0>"^=" return (DT_TOK_XOR_EQ); 541<S0>"|=" return (DT_TOK_OR_EQ); 542<S0>"<<=" return (DT_TOK_LSH_EQ); 543<S0>">>=" return (DT_TOK_RSH_EQ); 544<S0>"++" return (DT_TOK_ADDADD); 545<S0>"--" return (DT_TOK_SUBSUB); 546<S0>"..." return (DT_TOK_ELLIPSIS); 547<S0>"," return (DT_TOK_COMMA); 548<S0>";" return (';'); 549<S0>{RGX_WS} ; /* discard */ 550<S0>"\\"\n ; /* discard */ 551<S0>. yyerror("syntax error near \"%c\"\n", yytext[0]); 552 553<S1>"/*" yyerror("/* encountered inside a comment\n"); 554<S1>"*/" BEGIN(yypcb->pcb_cstate); 555<S1>.|\n ; /* discard */ 556 557<S2>{RGX_PSPEC} { 558 /* 559 * S2 has an ambiguity because RGX_PSPEC includes '*' 560 * as a glob character and '*' also can be DT_TOK_STAR. 561 * Since lex always matches the longest token, this 562 * rule can be matched by an input string like "int*", 563 * which could begin a global variable declaration such 564 * as "int*x;" or could begin a RGX_PSPEC with globbing 565 * such as "int* { trace(timestamp); }". If C_PSPEC is 566 * not set, we must resolve the ambiguity in favor of 567 * the type and perform lexer pushback if the fragment 568 * before '*' or entire fragment matches a type name. 569 * If C_PSPEC is set, we always return a PSPEC token. 570 * If C_PSPEC is off, the user can avoid ambiguity by 571 * including a ':' delimiter in the specifier, which 572 * they should be doing anyway to specify the provider. 573 */ 574 if (!(yypcb->pcb_cflags & DTRACE_C_PSPEC) && 575 strchr(yytext, ':') == NULL) { 576 577 char *p = strchr(yytext, '*'); 578 char *q = yytext + yyleng - 1; 579 580 if (p != NULL && p > yytext) 581 *p = '\0'; /* prune yytext */ 582 583 if (dt_type_lookup(yytext, NULL) == 0) { 584 yylval.l_str = strdup(yytext); 585 586 if (yylval.l_str == NULL) { 587 longjmp(yypcb->pcb_jmpbuf, 588 EDT_NOMEM); 589 } 590 591 if (p != NULL && p > yytext) { 592 for (*p = '*'; q >= p; q--) 593 unput(*q); 594 } 595 596 yybegin(YYS_EXPR); 597 return (DT_TOK_TNAME); 598 } 599 600 if (p != NULL && p > yytext) 601 *p = '*'; /* restore yytext */ 602 } 603 604 if ((yylval.l_str = strdup(yytext)) == NULL) 605 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 606 607 return (DT_TOK_PSPEC); 608 } 609 610<S2>"/" return (DT_TOK_DIV); 611<S2>"," return (DT_TOK_COMMA); 612 613<S2>{RGX_WS} ; /* discard */ 614<S2>. yyerror("syntax error near \"%c\"\n", yytext[0]); 615 616<S3>\n { 617 dt_pragma(yypragma); 618 yypragma = NULL; 619 BEGIN(yypcb->pcb_cstate); 620 } 621 622<S3>[\f\t\v ]+ ; /* discard */ 623 624<S3>[^\f\n\t\v "]+ { 625 dt_node_t *dnp; 626 627 if ((yylval.l_str = strdup(yytext)) == NULL) 628 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 629 630 /* 631 * We want to call dt_node_ident() here, but we can't 632 * because it will expand inlined identifiers, which we 633 * don't want to do from #pragma context in order to 634 * support pragmas that apply to the ident itself. We 635 * call dt_node_string() and then reset dn_op instead. 636 */ 637 dnp = dt_node_string(yylval.l_str); 638 dnp->dn_kind = DT_NODE_IDENT; 639 dnp->dn_op = DT_TOK_IDENT; 640 yypragma = dt_node_link(yypragma, dnp); 641 } 642 643<S3>. yyerror("syntax error near \"%c\"\n", yytext[0]); 644 645%% 646 647/* 648 * yybegin provides a wrapper for use from C code around the lex BEGIN() macro. 649 * We use two main states for lexing because probe descriptions use a syntax 650 * that is incompatible with the normal D tokens (e.g. names can contain "-"). 651 * yybegin also handles the job of switching between two lists of dt_nodes 652 * as we allocate persistent definitions, like inlines, and transient nodes 653 * that will be freed once we are done parsing the current program file. 654 */ 655void 656yybegin(yystate_t state) 657{ 658#ifdef YYDEBUG 659 yydebug = _dtrace_debug; 660#endif 661 if (yypcb->pcb_yystate == state) 662 return; /* nothing to do if we're in the state already */ 663 664 if (yypcb->pcb_yystate == YYS_DEFINE) { 665 yypcb->pcb_list = yypcb->pcb_hold; 666 yypcb->pcb_hold = NULL; 667 } 668 669 switch (state) { 670 case YYS_CLAUSE: 671 BEGIN(S2); 672 break; 673 case YYS_DEFINE: 674 assert(yypcb->pcb_hold == NULL); 675 yypcb->pcb_hold = yypcb->pcb_list; 676 yypcb->pcb_list = NULL; 677 /*FALLTHRU*/ 678 case YYS_EXPR: 679 BEGIN(S0); 680 break; 681 case YYS_DONE: 682 break; 683 case YYS_CONTROL: 684 BEGIN(S4); 685 break; 686 default: 687 xyerror(D_UNKNOWN, "internal error -- bad yystate %d\n", state); 688 } 689 690 yypcb->pcb_yystate = state; 691} 692 693void 694yyinit(dt_pcb_t *pcb) 695{ 696 yypcb = pcb; 697 yylineno = 1; 698 yypragma = NULL; 699 yysptr = yysbuf; 700} 701 702/* 703 * Given a lexeme 's' (typically yytext), set yylval and return an appropriate 704 * token to the parser indicating either an identifier or a typedef name. 705 * User-defined global variables always take precedence over types, but we do 706 * use some heuristics because D programs can look at an ever-changing set of 707 * kernel types and also can implicitly instantiate variables by assignment, 708 * unlike in C. The code here is ordered carefully as lookups are not cheap. 709 */ 710static int 711id_or_type(const char *s) 712{ 713 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 714 dt_decl_t *ddp = yypcb->pcb_dstack.ds_decl; 715 int c0, c1, ttok = DT_TOK_TNAME; 716 dt_ident_t *idp; 717 718 if ((s = yylval.l_str = strdup(s)) == NULL) 719 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 720 721 /* 722 * If the lexeme is a global variable or likely identifier or *not* a 723 * type_name, then it is an identifier token. 724 */ 725 if (dt_idstack_lookup(&yypcb->pcb_globals, s) != NULL || 726 dt_idhash_lookup(yypcb->pcb_idents, s) != NULL || 727 dt_type_lookup(s, NULL) != 0) 728 return (DT_TOK_IDENT); 729 730 /* 731 * If we're in the midst of parsing a declaration and a type_specifier 732 * has already been shifted, then return DT_TOK_IDENT instead of TNAME. 733 * This semantic is necessary to permit valid ISO C code such as: 734 * 735 * typedef int foo; 736 * struct s { foo foo; }; 737 * 738 * without causing shift/reduce conflicts in the direct_declarator part 739 * of the grammar. The result is that we must check for conflicting 740 * redeclarations of the same identifier as part of dt_node_decl(). 741 */ 742 if (ddp != NULL && ddp->dd_name != NULL) 743 return (DT_TOK_IDENT); 744 745 /* 746 * If the lexeme is a type name and we are not in a program clause, 747 * then always interpret it as a type and return DT_TOK_TNAME. 748 */ 749 if ((YYSTATE) != S0) 750 return (DT_TOK_TNAME); 751 752 /* 753 * If the lexeme matches a type name but is in a program clause, then 754 * it could be a type or it could be an undefined variable. Peek at 755 * the next token to decide. If we see ++, --, [, or =, we know there 756 * might be an assignment that is trying to create a global variable, 757 * so we optimistically return DT_TOK_IDENT. There is no harm in being 758 * wrong: a type_name followed by ++, --, [, or = is a syntax error. 759 */ 760 while ((c0 = input()) != 0) { 761 if (strchr("\f\n\r\t\v ", c0) == NULL) 762 break; 763 } 764 765 switch (c0) { 766 case '+': 767 case '-': 768 if ((c1 = input()) == c0) 769 ttok = DT_TOK_IDENT; 770 unput(c1); 771 break; 772 773 case '=': 774 if ((c1 = input()) != c0) 775 ttok = DT_TOK_IDENT; 776 unput(c1); 777 break; 778 case '[': 779 ttok = DT_TOK_IDENT; 780 break; 781 } 782 783 if (ttok == DT_TOK_IDENT) { 784 idp = dt_idhash_insert(yypcb->pcb_idents, s, DT_IDENT_SCALAR, 0, 785 0, _dtrace_defattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen); 786 787 if (idp == NULL) 788 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 789 } 790 791 unput(c0); 792 return (ttok); 793} 794 795static int 796input(void) 797{ 798 int c; 799 800 if (yysptr > yysbuf) 801 c = *--yysptr; 802 else if (yypcb->pcb_fileptr != NULL) 803 c = fgetc(yypcb->pcb_fileptr); 804 else if (yypcb->pcb_strptr < yypcb->pcb_string + yypcb->pcb_strlen) 805 c = *(unsigned char *)(yypcb->pcb_strptr++); 806 else 807 c = EOF; 808 809 if (c == '\n') 810 yylineno++; 811 812 if (c != EOF) 813 return (c); 814 815 if ((YYSTATE) == S1) 816 yyerror("end-of-file encountered before matching */\n"); 817 818 if ((YYSTATE) == S3) 819 yyerror("end-of-file encountered before end of control line\n"); 820 821 if (yypcb->pcb_fileptr != NULL && ferror(yypcb->pcb_fileptr)) 822 longjmp(yypcb->pcb_jmpbuf, EDT_FIO); 823 824 return (0); /* EOF */ 825} 826 827static void 828unput(int c) 829{ 830 if (c == '\n') 831 yylineno--; 832 833 *yysptr++ = c; 834 yytchar = c; 835} 836