frontends/verilog/verilog_lexer.l

   1 /*
   2  *  yosys -- Yosys Open SYnthesis Suite
   3  *
   4  *  Copyright (C) 2012  Clifford Wolf <clifford@clifford.at>
   5  *
   6  *  Permission to use, copy, modify, and/or distribute this software for any
   7  *  purpose with or without fee is hereby granted, provided that the above
   8  *  copyright notice and this permission notice appear in all copies.
   9  *
  10  *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  *
  18  *  ---
  19  *
  20  *  The Verilog frontend.
  21  *
  22  *  This frontend is using the AST frontend library (see frontends/ast/).
  23  *  Thus this frontend does not generate RTLIL code directly but creates an
  24  *  AST directly from the Verilog parse tree and then passes this AST to
  25  *  the AST frontend library.
  26  *
  27  *  ---
  28  *
  29  *  A simple lexer for Verilog code. Non-preprocessor compiler directives are
  30  *  handled here. The preprocessor stuff is handled in preproc.cc. Everything
  31  *  else is left to the bison parser (see verilog_parser.y).
  32  *
  33  */
  34
  35 %{
  36
  37 #ifdef __clang__
  38 // bison generates code using the 'register' storage class specifier
  39 #pragma clang diagnostic ignored "-Wdeprecated-register"
  40 #endif
  41
  42 #include "kernel/log.h"
  43 #include "frontends/verilog/verilog_frontend.h"
  44 #include "frontends/ast/ast.h"
  45 #include "verilog_parser.tab.hh"
  46
  47 USING_YOSYS_NAMESPACE
  48 using namespace AST;
  49 using namespace VERILOG_FRONTEND;
  50
  51 YOSYS_NAMESPACE_BEGIN
  52 namespace VERILOG_FRONTEND {
  53         std::vector<std::string> fn_stack;
  54         std::vector<int> ln_stack;
  55 }
  56 YOSYS_NAMESPACE_END
  57
  58 #define YYSTYPE FRONTEND_VERILOG_YYSTYPE
  59 #define YYLTYPE FRONTEND_VERILOG_YYLTYPE
  60
  61 #define SV_KEYWORD(_tok) \
  62         if (sv_mode) return _tok; \
  63         log("Lexer warning: The SystemVerilog keyword `%s' (at %s:%d) is not "\
  64                         "recognized unless read_verilog is called with -sv!\n", yytext, \
  65                         AST::current_filename.c_str(), frontend_verilog_yyget_lineno()); \
  66         yylval->string = new std::string(std::string("\\") + yytext); \
  67         return TOK_ID;
  68
  69 #define NON_KEYWORD() \
  70         yylval->string = new std::string(std::string("\\") + yytext); \
  71         return TOK_ID;
  72
  73 #define YY_INPUT(buf,result,max_size) \
  74         result = readsome(*VERILOG_FRONTEND::lexin, buf, max_size)
  75
  76 YYLTYPE real_location;
  77 YYLTYPE old_location;
  78
  79 #define YY_USER_ACTION \
  80        old_location = real_location; \
  81        real_location.first_line = real_location.last_line; \
  82        real_location.first_column = real_location.last_column; \
  83        for(int i = 0; yytext[i] != '\0'; ++i){ \
  84                if(yytext[i] == '\n') { \
  85                        real_location.last_line++; \
  86                        real_location.last_column = 1; \
  87                } \
  88                else { \
  89                        real_location.last_column++; \
  90                } \
  91        } \
  92     (*yylloc) = real_location;
  93
  94 #define YY_BREAK \
  95     (*yylloc) = old_location; \
  96     break;
  97
  98 #undef YY_BUF_SIZE
  99 #define YY_BUF_SIZE 65536
 100
 101 extern int frontend_verilog_yylex(YYSTYPE *yylval_param, YYLTYPE *yyloc_param);
 102
 103 static bool isUserType(std::string &s)
 104 {
 105         // check current scope then outer scopes for a name
 106         for (auto it = user_type_stack.rbegin(); it != user_type_stack.rend(); ++it) {
 107                 if ((*it)->count(s) > 0) {
 108                         return true;
 109                 }
 110         }
 111         return false;
 112 }
 113
 114 %}
 115
 116 %option yylineno
 117 %option noyywrap
 118 %option nounput
 119 %option bison-locations
 120 %option bison-bridge
 121 %option prefix="frontend_verilog_yy"
 122
 123 %x COMMENT
 124 %x STRING
 125 %x SYNOPSYS_TRANSLATE_OFF
 126 %x SYNOPSYS_FLAGS
 127 %x IMPORT_DPI
 128 %x BASED_CONST
 129
 130 %%
 131         int comment_caller;
 132
 133 <INITIAL,SYNOPSYS_TRANSLATE_OFF>"`file_push "[^\n]* {
 134         fn_stack.push_back(current_filename);
 135         ln_stack.push_back(frontend_verilog_yyget_lineno());
 136         current_filename = yytext+11;
 137         if (!current_filename.empty() && current_filename.front() == '"')
 138                 current_filename = current_filename.substr(1);
 139         if (!current_filename.empty() && current_filename.back() == '"')
 140                 current_filename = current_filename.substr(0, current_filename.size()-1);
 141         frontend_verilog_yyset_lineno(0);
 142         yylloc->first_line = yylloc->last_line = 0;
 143         real_location.first_line = real_location.last_line = 0;
 144 }
 145
 146 <INITIAL,SYNOPSYS_TRANSLATE_OFF>"`file_pop"[^\n]*\n {
 147         current_filename = fn_stack.back();
 148         fn_stack.pop_back();
 149         frontend_verilog_yyset_lineno(ln_stack.back());
 150         yylloc->first_line = yylloc->last_line = ln_stack.back();
 151         real_location.first_line = real_location.last_line = ln_stack.back();
 152         ln_stack.pop_back();
 153 }
 154
 155 <INITIAL,SYNOPSYS_TRANSLATE_OFF>"`line"[ \t]+[^ \t\r\n]+[ \t]+\"[^ \r\n]+\"[^\r\n]*\n {
 156         char *p = yytext + 5;
 157         while (*p == ' ' || *p == '\t') p++;
 158         frontend_verilog_yyset_lineno(atoi(p));
 159         yylloc->first_line = yylloc->last_line = atoi(p);
 160         real_location.first_line = real_location.last_line = atoi(p);
 161         while (*p && *p != ' ' && *p != '\t') p++;
 162         while (*p == ' ' || *p == '\t') p++;
 163         char *q = *p ? p + 1 : p;
 164         while (*q && *q != '"') q++;
 165         current_filename = std::string(p).substr(1, q-p-1);
 166 }
 167
 168 "`file_notfound "[^\n]* {
 169         log_error("Can't open include file `%s'!\n", yytext + 15);
 170 }
 171
 172 "`timescale"[ \t]+[^ \t\r\n/]+[ \t]*"/"[ \t]*[^ \t\r\n]* /* ignore timescale directive */
 173
 174 "`celldefine"[^\n]* /* ignore `celldefine */
 175 "`endcelldefine"[^\n]* /* ignore `endcelldefine */
 176
 177 "`default_nettype"[ \t]+[^ \t\r\n/]+ {
 178         char *p = yytext;
 179         while (*p != 0 && *p != ' ' && *p != '\t') p++;
 180         while (*p == ' ' || *p == '\t') p++;
 181         if (!strcmp(p, "none"))
 182                 VERILOG_FRONTEND::default_nettype_wire = false;
 183         else if (!strcmp(p, "wire"))
 184                 VERILOG_FRONTEND::default_nettype_wire = true;
 185         else
 186                 frontend_verilog_yyerror("Unsupported default nettype: %s", p);
 187 }
 188
 189 "`protect"[^\n]* /* ignore `protect*/
 190 "`endprotect"[^\n]* /* ignore `endprotect*/
 191
 192 "`"[a-zA-Z_$][a-zA-Z0-9_$]* {
 193         frontend_verilog_yyerror("Unimplemented compiler directive or undefined macro %s.", yytext);
 194 }
 195
 196 "module"       { return TOK_MODULE; }
 197 "endmodule"    { return TOK_ENDMODULE; }
 198 "function"     { return TOK_FUNCTION; }
 199 "endfunction"  { return TOK_ENDFUNCTION; }
 200 "task"         { return TOK_TASK; }
 201 "endtask"      { return TOK_ENDTASK; }
 202 "specify"      { return specify_mode ? TOK_SPECIFY : TOK_IGNORED_SPECIFY; }
 203 "endspecify"   { return TOK_ENDSPECIFY; }
 204 "specparam"    { return TOK_SPECPARAM; }
 205 "package"      { SV_KEYWORD(TOK_PACKAGE); }
 206 "endpackage"   { SV_KEYWORD(TOK_ENDPACKAGE); }
 207 "interface"    { SV_KEYWORD(TOK_INTERFACE); }
 208 "endinterface" { SV_KEYWORD(TOK_ENDINTERFACE); }
 209 "modport"      { SV_KEYWORD(TOK_MODPORT); }
 210 "parameter"    { return TOK_PARAMETER; }
 211 "localparam"   { return TOK_LOCALPARAM; }
 212 "defparam"     { return TOK_DEFPARAM; }
 213 "assign"       { return TOK_ASSIGN; }
 214 "always"       { return TOK_ALWAYS; }
 215 "initial"      { return TOK_INITIAL; }
 216 "begin"        { return TOK_BEGIN; }
 217 "end"          { return TOK_END; }
 218 "if"           { return TOK_IF; }
 219 "else"         { return TOK_ELSE; }
 220 "for"          { return TOK_FOR; }
 221 "posedge"      { return TOK_POSEDGE; }
 222 "negedge"      { return TOK_NEGEDGE; }
 223 "or"           { return TOK_OR; }
 224 "case"         { return TOK_CASE; }
 225 "casex"        { return TOK_CASEX; }
 226 "casez"        { return TOK_CASEZ; }
 227 "endcase"      { return TOK_ENDCASE; }
 228 "default"      { return TOK_DEFAULT; }
 229 "generate"     { return TOK_GENERATE; }
 230 "endgenerate"  { return TOK_ENDGENERATE; }
 231 "while"        { return TOK_WHILE; }
 232 "repeat"       { return TOK_REPEAT; }
 233 "automatic"    { return TOK_AUTOMATIC; }
 234
 235 "unique"       { SV_KEYWORD(TOK_UNIQUE); }
 236 "unique0"      { SV_KEYWORD(TOK_UNIQUE); }
 237 "priority"     { SV_KEYWORD(TOK_PRIORITY); }
 238
 239 "always_comb"  { SV_KEYWORD(TOK_ALWAYS_COMB); }
 240 "always_ff"    { SV_KEYWORD(TOK_ALWAYS_FF); }
 241 "always_latch" { SV_KEYWORD(TOK_ALWAYS_LATCH); }
 242
 243  /* use special token for labels on assert, assume, cover, and restrict because it's insanley complex
 244     to fix parsing of cells otherwise. (the current cell parser forces a reduce very early to update some
 245     global state.. its a mess) */
 246 [a-zA-Z_$][a-zA-Z0-9_$]*/[ \t\r\n]*:[ \t\r\n]*(assert|assume|cover|restrict)[^a-zA-Z0-9_$\.] {
 247         if (!strcmp(yytext, "default"))
 248                 return TOK_DEFAULT;
 249         yylval->string = new std::string(std::string("\\") + yytext);
 250         return TOK_SVA_LABEL;
 251 }
 252
 253 "assert"     { if (formal_mode) return TOK_ASSERT; SV_KEYWORD(TOK_ASSERT); }
 254 "assume"     { if (formal_mode) return TOK_ASSUME; SV_KEYWORD(TOK_ASSUME); }
 255 "cover"      { if (formal_mode) return TOK_COVER; SV_KEYWORD(TOK_COVER); }
 256 "restrict"   { if (formal_mode) return TOK_RESTRICT; SV_KEYWORD(TOK_RESTRICT); }
 257 "property"   { if (formal_mode) return TOK_PROPERTY; SV_KEYWORD(TOK_PROPERTY); }
 258 "rand"       { if (formal_mode) return TOK_RAND; SV_KEYWORD(TOK_RAND); }
 259 "const"      { if (formal_mode) return TOK_CONST; SV_KEYWORD(TOK_CONST); }
 260 "checker"    { if (formal_mode) return TOK_CHECKER; SV_KEYWORD(TOK_CHECKER); }
 261 "endchecker" { if (formal_mode) return TOK_ENDCHECKER; SV_KEYWORD(TOK_ENDCHECKER); }
 262 "final"      { SV_KEYWORD(TOK_FINAL); }
 263 "logic"      { SV_KEYWORD(TOK_LOGIC); }
 264 "var"        { SV_KEYWORD(TOK_VAR); }
 265 "bit"        { SV_KEYWORD(TOK_REG); }
 266
 267 "eventually"   { if (formal_mode) return TOK_EVENTUALLY; SV_KEYWORD(TOK_EVENTUALLY); }
 268 "s_eventually" { if (formal_mode) return TOK_EVENTUALLY; SV_KEYWORD(TOK_EVENTUALLY); }
 269
 270 "input"   { return TOK_INPUT; }
 271 "output"  { return TOK_OUTPUT; }
 272 "inout"   { return TOK_INOUT; }
 273 "wire"    { return TOK_WIRE; }
 274 "wor"     { return TOK_WOR; }
 275 "wand"    { return TOK_WAND; }
 276 "reg"     { return TOK_REG; }
 277 "integer" { return TOK_INTEGER; }
 278 "signed"  { return TOK_SIGNED; }
 279 "genvar"  { return TOK_GENVAR; }
 280 "real"    { return TOK_REAL; }
 281
 282 "enum"    { SV_KEYWORD(TOK_ENUM); }
 283 "typedef" { SV_KEYWORD(TOK_TYPEDEF); }
 284
 285 [0-9][0-9_]* {
 286         yylval->string = new std::string(yytext);
 287         return TOK_CONSTVAL;
 288 }
 289
 290 \'[01zxZX] {
 291         yylval->string = new std::string(yytext);
 292         return TOK_UNBASED_UNSIZED_CONSTVAL;
 293 }
 294
 295 \'[sS]?[bodhBODH] {
 296         BEGIN(BASED_CONST);
 297         yylval->string = new std::string(yytext);
 298         return TOK_BASE;
 299 }
 300
 301 <BASED_CONST>[0-9a-fA-FzxZX?][0-9a-fA-FzxZX?_]* {
 302         BEGIN(0);
 303         yylval->string = new std::string(yytext);
 304         return TOK_BASED_CONSTVAL;
 305 }
 306
 307 [0-9][0-9_]*\.[0-9][0-9_]*([eE][-+]?[0-9_]+)? {
 308         yylval->string = new std::string(yytext);
 309         return TOK_REALVAL;
 310 }
 311
 312 [0-9][0-9_]*[eE][-+]?[0-9_]+ {
 313         yylval->string = new std::string(yytext);
 314         return TOK_REALVAL;
 315 }
 316
 317 \"              { BEGIN(STRING); }
 318 <STRING>\\.     { yymore(); real_location = old_location; }
 319 <STRING>\"      {
 320         BEGIN(0);
 321         char *yystr = strdup(yytext);
 322         yystr[strlen(yytext) - 1] = 0;
 323         int i = 0, j = 0;
 324         while (yystr[i]) {
 325                 if (yystr[i] == '\\' && yystr[i + 1]) {
 326                         i++;
 327                         if (yystr[i] == 'a')
 328                                 yystr[i] = '\a';
 329                         else if (yystr[i] == 'f')
 330                                 yystr[i] = '\f';
 331                         else if (yystr[i] == 'n')
 332                                 yystr[i] = '\n';
 333                         else if (yystr[i] == 'r')
 334                                 yystr[i] = '\r';
 335                         else if (yystr[i] == 't')
 336                                 yystr[i] = '\t';
 337                         else if (yystr[i] == 'v')
 338                                 yystr[i] = '\v';
 339                         else if ('0' <= yystr[i] && yystr[i] <= '7') {
 340                                 yystr[i] = yystr[i] - '0';
 341                                 if ('0' <= yystr[i + 1] && yystr[i + 1] <= '7') {
 342                                         yystr[i + 1] = yystr[i] * 8 + yystr[i + 1] - '0';
 343                                         i++;
 344                                 }
 345                                 if ('0' <= yystr[i + 1] && yystr[i + 1] <= '7') {
 346                                         yystr[i + 1] = yystr[i] * 8 + yystr[i + 1] - '0';
 347                                         i++;
 348                                 }
 349                         }
 350                 }
 351                 yystr[j++] = yystr[i++];
 352         }
 353         yystr[j] = 0;
 354         yylval->string = new std::string(yystr, j);
 355         free(yystr);
 356         return TOK_STRING;
 357 }
 358 <STRING>.       { yymore(); real_location = old_location; }
 359
 360 and|nand|or|nor|xor|xnor|not|buf|bufif0|bufif1|notif0|notif1 {
 361         yylval->string = new std::string(yytext);
 362         return TOK_PRIMITIVE;
 363 }
 364
 365 supply0 { return TOK_SUPPLY0; }
 366 supply1 { return TOK_SUPPLY1; }
 367
 368 "$"(display|write|strobe|monitor|time|stop|finish|dumpfile|dumpvars|dumpon|dumpoff|dumpall) {
 369         yylval->string = new std::string(yytext);
 370         return TOK_ID;
 371 }
 372
 373 "$"(setup|hold|setuphold|removal|recovery|recrem|skew|timeskew|fullskew|nochange) {
 374         if (!specify_mode) REJECT;
 375         yylval->string = new std::string(yytext);
 376         return TOK_ID;
 377 }
 378
 379 "$"(info|warning|error|fatal) {
 380         yylval->string = new std::string(yytext);
 381         return TOK_MSG_TASKS;
 382 }
 383
 384 "$signed"   { return TOK_TO_SIGNED; }
 385 "$unsigned" { return TOK_TO_UNSIGNED; }
 386
 387 [a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_$][a-zA-Z0-9_$]* {
 388         // package qualifier
 389         auto s = std::string("\\") + yytext;
 390         if (pkg_user_types.count(s) > 0) {
 391                 // package qualified typedefed name
 392                 yylval->string = new std::string(s);
 393                 return TOK_PKG_USER_TYPE;
 394         }
 395         else {
 396                 // backup before :: just return first part
 397                 size_t len = strchr(yytext, ':') - yytext;
 398                 yyless(len);
 399                 yylval->string = new std::string(std::string("\\") + yytext);
 400                 return TOK_ID;
 401         }
 402 }
 403
 404 [a-zA-Z_$][a-zA-Z0-9_$]* {
 405         auto s = std::string("\\") + yytext;
 406         if (isUserType(s)) {
 407                 // previously typedefed name
 408                 yylval->string = new std::string(s);
 409                 return TOK_USER_TYPE;
 410         }
 411         else {
 412                 yylval->string = new std::string(std::string("\\") + yytext);
 413                 return TOK_ID;
 414         }
 415 }
 416
 417 [a-zA-Z_$][a-zA-Z0-9_$\.]* {
 418         yylval->string = new std::string(std::string("\\") + yytext);
 419         return TOK_ID;
 420 }
 421
 422 "/*"[ \t]*(synopsys|synthesis)[ \t]*translate_off[ \t]*"*/" {
 423         static bool printed_warning = false;
 424         if (!printed_warning) {
 425                 log_warning("Found one of those horrible `(synopsys|synthesis) translate_off' comments.\n"
 426                                 "Yosys does support them but it is recommended to use `ifdef constructs instead!\n");
 427                 printed_warning = true;
 428         }
 429         BEGIN(SYNOPSYS_TRANSLATE_OFF);
 430 }
 431 <SYNOPSYS_TRANSLATE_OFF>.    /* ignore synopsys translate_off body */
 432 <SYNOPSYS_TRANSLATE_OFF>\n   /* ignore synopsys translate_off body */
 433 <SYNOPSYS_TRANSLATE_OFF>"/*"[ \t]*(synopsys|synthesis)[ \t]*"translate_on"[ \t]*"*/" { BEGIN(0); }
 434
 435 "/*"[ \t]*(synopsys|synthesis)[ \t]+ {
 436         BEGIN(SYNOPSYS_FLAGS);
 437 }
 438 <SYNOPSYS_FLAGS>full_case {
 439         static bool printed_warning = false;
 440         if (!printed_warning) {
 441                 log_warning("Found one of those horrible `(synopsys|synthesis) full_case' comments.\n"
 442                                 "Yosys does support them but it is recommended to use Verilog `full_case' attributes instead!\n");
 443                 printed_warning = true;
 444         }
 445         return TOK_SYNOPSYS_FULL_CASE;
 446 }
 447 <SYNOPSYS_FLAGS>parallel_case {
 448         static bool printed_warning = false;
 449         if (!printed_warning) {
 450                 log_warning("Found one of those horrible `(synopsys|synthesis) parallel_case' comments.\n"
 451                                 "Yosys does support them but it is recommended to use Verilog `parallel_case' attributes instead!\n");
 452                 printed_warning = true;
 453         }
 454         return TOK_SYNOPSYS_PARALLEL_CASE;
 455 }
 456 <SYNOPSYS_FLAGS>. /* ignore everything else */
 457 <SYNOPSYS_FLAGS>"*/" { BEGIN(0); }
 458
 459 import[ \t\r\n]+\"(DPI|DPI-C)\"[ \t\r\n]+function[ \t\r\n]+ {
 460         BEGIN(IMPORT_DPI);
 461         return TOK_DPI_FUNCTION;
 462 }
 463
 464 <IMPORT_DPI>[a-zA-Z_$][a-zA-Z0-9_$]* {
 465         yylval->string = new std::string(std::string("\\") + yytext);
 466         return TOK_ID;
 467 }
 468
 469 <IMPORT_DPI>[ \t\r\n] /* ignore whitespaces */
 470
 471 <IMPORT_DPI>";" {
 472         BEGIN(0);
 473         return *yytext;
 474 }
 475
 476 <IMPORT_DPI>. {
 477         return *yytext;
 478 }
 479
 480 "\\"[^ \t\r\n]+ {
 481         yylval->string = new std::string(yytext);
 482         return TOK_ID;
 483 }
 484
 485 "(*" { return ATTR_BEGIN; }
 486 "*)" { return ATTR_END; }
 487
 488 "{*"  { return DEFATTR_BEGIN; }
 489 "*}"  { return DEFATTR_END; }
 490
 491 "**" { return OP_POW; }
 492 "||" { return OP_LOR; }
 493 "&&" { return OP_LAND; }
 494 "==" { return OP_EQ; }
 495 "!=" { return OP_NE; }
 496 "<=" { return OP_LE; }
 497 ">=" { return OP_GE; }
 498
 499 "===" { return OP_EQX; }
 500 "!==" { return OP_NEX; }
 501
 502 "~&" { return OP_NAND; }
 503 "~|" { return OP_NOR;  }
 504 "~^" { return OP_XNOR; }
 505 "^~" { return OP_XNOR; }
 506
 507 "<<"  { return OP_SHL; }
 508 ">>"  { return OP_SHR; }
 509 "<<<" { return OP_SSHL; }
 510 ">>>" { return OP_SSHR; }
 511
 512 "::"  { return TOK_PACKAGESEP; }
 513 "++"  { return TOK_INCREMENT; }
 514 "--"  { return TOK_DECREMENT; }
 515
 516 "+:" { return TOK_POS_INDEXED; }
 517 "-:" { return TOK_NEG_INDEXED; }
 518
 519 ".*" { return TOK_WILDCARD_CONNECT; }
 520
 521 [-+]?[=*]> {
 522         if (!specify_mode) REJECT;
 523         yylval->string = new std::string(yytext);
 524         return TOK_SPECIFY_OPER;
 525 }
 526
 527 "&&&" {
 528         if (!specify_mode) return TOK_IGNORED_SPECIFY_AND;
 529         return TOK_SPECIFY_AND;
 530 }
 531
 532 <INITIAL,BASED_CONST>"/*" { comment_caller=YY_START; BEGIN(COMMENT); }
 533 <COMMENT>.    /* ignore comment body */
 534 <COMMENT>\n   /* ignore comment body */
 535 <COMMENT>"*/" { BEGIN(comment_caller); }
 536
 537 <INITIAL,BASED_CONST>[ \t\r\n]          /* ignore whitespaces */
 538 <INITIAL,BASED_CONST>\\[\r\n]           /* ignore continuation sequence */
 539 <INITIAL,BASED_CONST>"//"[^\r\n]*       /* ignore one-line comments */
 540
 541 <INITIAL>. { return *yytext; }
 542 <*>. { BEGIN(0); return *yytext; }
 543
 544 %%
 545
 546 // this is a hack to avoid the 'yyinput defined but not used' error msgs
 547 void *frontend_verilog_avoid_input_warnings() {
 548         return (void*)&yyinput;
 549 }
 550