agent_lexer.ll 19.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/* Copyright (C) 2017 Internet Systems Consortium, Inc. ("ISC")

   This Source Code Form is subject to the terms of the Mozilla Public
   License, v. 2.0. If a copy of the MPL was not distributed with this
   file, You can obtain one at http://mozilla.org/MPL/2.0/. */

%{ /* -*- C++ -*- */
#include <cerrno>
#include <climits>
#include <cstdlib>
#include <string>
#include <agent/parser_context.h>
#include <asiolink/io_address.h>
#include <boost/lexical_cast.hpp>
#include <exceptions/exceptions.h>
#include <cc/dhcp_config_error.h>

18 19 20 21 22 23
/* Please avoid C++ style comments (// ... eol) as they break flex 2.6.2 */

/* Work around an incompatibility in flex (at least versions
   2.5.31 through 2.5.33): it generates code that does
   not conform to C89.  See Debian bug 333231
   <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>. */
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
# undef yywrap
# define yywrap() 1

namespace {

bool start_token_flag = false;

isc::agent::ParserContext::ParserType start_token_value;
unsigned int comment_start_line = 0;

using namespace isc;
using isc::agent::AgentParser;

};

39
/* To avoid the call to exit... oops! */
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
#define YY_FATAL_ERROR(msg) isc::agent::ParserContext::fatal(msg)
%}

/* noyywrap disables automatic rewinding for the next file to parse. Since we
   always parse only a single string, there's no need to do any wraps. And
   using yywrap requires linking with -lfl, which provides the default yywrap
   implementation that always returns 1 anyway. */
%option noyywrap

/* nounput simplifies the lexer, by removing support for putting a character
   back into the input stream. We never use such capability anyway. */
%option nounput

/* batch means that we'll never use the generated lexer interactively. */
%option batch

/* avoid to get static global variables to remain with C++. */
/* in last resort %option reentrant */

/* Enables debug mode. To see the debug messages, one needs to also set
   yy_flex_debug to 1, then the debug messages will be printed on stderr. */
%option debug

/* I have no idea what this option does, except it was specified in the bison
   examples and Postgres folks added it to remove gcc 4.3 warnings. Let's
   be on the safe side and keep it. */
%option noinput

%x COMMENT
%x DIR_ENTER DIR_INCLUDE DIR_EXIT

/* These are not token expressions yet, just convenience expressions that
   can be used during actual token definitions. Note some can match
   incorrect inputs (e.g., IP addresses) which must be checked. */
int   \-?[0-9]+
blank [ \t\r]

UnicodeEscapeSequence           u[0-9A-Fa-f]{4}
JSONEscapeCharacter             ["\\/bfnrt]
JSONEscapeSequence              {JSONEscapeCharacter}|{UnicodeEscapeSequence}
JSONStandardCharacter           [^\x00-\x1f"\\]
JSONStringCharacter             {JSONStandardCharacter}|\\{JSONEscapeSequence}
JSONString                      \"{JSONStringCharacter}*\"

/* for errors */

BadUnicodeEscapeSequence        u[0-9A-Fa-f]{0,3}[^0-9A-Fa-f]
BadJSONEscapeSequence           [^"\\/bfnrtu]|{BadUnicodeEscapeSequence}
ControlCharacter                [\x00-\x1f]
ControlCharacterFill            [^"\\]|\\{JSONEscapeSequence}

%{
92 93 94
/* This code run each time a pattern is matched. It updates the location
   by moving it ahead by yyleng bytes. yyleng specifies the length of the
   currently matched token. */
95 96 97 98 99 100
#define YY_USER_ACTION  driver.loc_.columns(yyleng);
%}

%%

%{
101 102 103
    /* This part of the code is copied over to the verbatim to the top
       of the generated yylex function. Explanation:
       http://www.gnu.org/software/bison/manual/html_node/Multiple-start_002dsymbols.html */
104

105
    /* Code run each time yylex is called. */
106 107
    driver.loc_.step();

108 109 110 111 112 113
    /* We currently have 3 points of entries defined:
       START_JSON - which expects any valid JSON
       START_AGENT - which expects full configuration (with outer map and Control-agent
                     object in it.
       START_SUB_AGENT - which expects only content of the Control-agent, this is
                         primarily useful for testing. */
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
    if (start_token_flag) {
        start_token_flag = false;
        switch (start_token_value) {
        case ParserContext::PARSER_JSON:
        default:
            return isc::agent::AgentParser::make_START_JSON(driver.loc_);
        case ParserContext::PARSER_AGENT:
            return isc::agent::AgentParser::make_START_AGENT(driver.loc_);
        case ParserContext::PARSER_SUB_AGENT:
            return isc::agent::AgentParser::make_START_SUB_AGENT(driver.loc_);
        }
    }
%}

#.* ;

"//"(.*) ;

"/*" {
  BEGIN(COMMENT);
  comment_start_line = driver.loc_.end.line;;
}

<COMMENT>"*/" BEGIN(INITIAL);
<COMMENT>. ;
<COMMENT><<EOF>> {
    isc_throw(ParseError, "Comment not closed. (/* in line " << comment_start_line);
}

"<?" BEGIN(DIR_ENTER);
<DIR_ENTER>"include" BEGIN(DIR_INCLUDE);
<DIR_INCLUDE>\"([^\"\n])+\" {
146
    /* Include directive. */
147

148
    /* Extract the filename. */
149 150 151 152 153 154 155 156 157 158 159 160
    std::string tmp(yytext+1);
    tmp.resize(tmp.size() - 1);

    driver.includeFile(tmp);
}
<DIR_ENTER,DIR_INCLUDE,DIR_EXIT><<EOF>> {
    isc_throw(ParseError, "Directive not closed.");
}
<DIR_EXIT>"?>" BEGIN(INITIAL);


<*>{blank}+   {
161
    /* Ok, we found a with space. Let's ignore it and update loc variable. */
162 163 164 165
    driver.loc_.step();
}

<*>[\n]+      {
166
    /* Newline found. Let's update the location and continue. */
167 168 169 170 171 172
    driver.loc_.lines(yyleng);
    driver.loc_.step();
}


\"Control-agent\" {
173 174
    switch(driver.ctx_) {
    case ParserContext::CONFIG:
175
        return AgentParser::make_CONTROL_AGENT(driver.loc_);
176
    default:
177 178 179 180 181
        return AgentParser::make_STRING("Control-agent", driver.loc_);
    }
}

\"http-host\" {
182 183
    switch(driver.ctx_) {
    case ParserContext::AGENT:
184
        return AgentParser::make_HTTP_HOST(driver.loc_);
185
    default:
186 187 188 189 190
        return AgentParser::make_STRING("http-host", driver.loc_);
    }
}

\"http-port\" {
191 192
    switch(driver.ctx_) {
    case ParserContext::AGENT:
193
        return AgentParser::make_HTTP_PORT(driver.loc_);
194
    default:
195 196 197 198
        return AgentParser::make_STRING("http-port", driver.loc_);
    }
}

199 200 201 202 203 204 205 206 207
\"control-sockets\" {
    switch(driver.ctx_) {
    case ParserContext::AGENT:
        return AgentParser::make_CONTROL_SOCKETS(driver.loc_);
    default:
        return AgentParser::make_STRING("control-sockets", driver.loc_);
    }
}

208
\"dhcp4\" {
209 210
    switch(driver.ctx_) {
    case ParserContext::CONTROL_SOCKETS:
211
        return AgentParser::make_DHCP4_SERVER(driver.loc_);
212
    default:
213
        return AgentParser::make_STRING("dhcp4", driver.loc_);
214 215 216
    }
}

217
\"dhcp6\" {
218 219
    switch(driver.ctx_) {
    case ParserContext::CONTROL_SOCKETS:
220
        return AgentParser::make_DHCP6_SERVER(driver.loc_);
221
    default:
222
        return AgentParser::make_STRING("dhcp6", driver.loc_);
223 224 225
    }
}

226
\"d2\" {
227 228
    switch(driver.ctx_) {
    case ParserContext::CONTROL_SOCKETS:
229
        return AgentParser::make_D2_SERVER(driver.loc_);
230
    default:
231
        return AgentParser::make_STRING("d2", driver.loc_);
232 233 234
    }
}

235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
\"socket-name\" {
    switch(driver.ctx_) {
    case ParserContext::SERVER:
        return AgentParser::make_SOCKET_NAME(driver.loc_);
    default:
        return AgentParser::make_STRING("socket-name", driver.loc_);
    }
}

\"socket-type\" {
    switch(driver.ctx_) {
    case ParserContext::SERVER:
        return AgentParser::make_SOCKET_TYPE(driver.loc_);
    default:
        return AgentParser::make_STRING("socket-type", driver.loc_);
    }
}

\"unix\" {
    switch(driver.ctx_) {
    case ParserContext::SOCKET_TYPE:
256
        return AgentParser::make_UNIX(driver.loc_);
257 258
    default:
        return AgentParser::make_STRING("unix", driver.loc_);
259 260 261
    }
}

262 263 264 265 266 267
\"hooks-libraries\" {
    switch(driver.ctx_) {
    case ParserContext::AGENT:
        return AgentParser::make_HOOKS_LIBRARIES(driver.loc_);
    default:
        return AgentParser::make_STRING("hooks-libraries", driver.loc_);
268 269 270
    }
}

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
\"library\" {
    switch(driver.ctx_) {
    case ParserContext::HOOKS_LIBRARIES:
        return AgentParser::make_LIBRARY(driver.loc_);
    default:
        return AgentParser::make_STRING("library", driver.loc_);
    }
}

\"parameters\" {
    switch(driver.ctx_) {
    case ParserContext::HOOKS_LIBRARIES:
        return AgentParser::make_PARAMETERS(driver.loc_);
    default:
        return AgentParser::make_STRING("parameters", driver.loc_);
    }
}
288 289

\"Logging\" {
290 291
    switch(driver.ctx_) {
    case ParserContext::CONFIG:
292
        return AgentParser::make_LOGGING(driver.loc_);
293
    default:
294 295 296 297 298
        return AgentParser::make_STRING("Logging", driver.loc_);
    }
}

\"loggers\" {
299 300
    switch(driver.ctx_) {
    case ParserContext::LOGGING:
301
        return AgentParser::make_LOGGERS(driver.loc_);
302
    default:
303 304 305 306
        return AgentParser::make_STRING("loggers", driver.loc_);
    }
}

307 308 309 310 311 312 313 314 315
\"name\" {
    switch(driver.ctx_) {
    case ParserContext::LOGGERS:
        return AgentParser::make_NAME(driver.loc_);
    default:
        return AgentParser::make_STRING("name", driver.loc_);
    }
}

316
\"output_options\" {
317 318
    switch(driver.ctx_) {
    case ParserContext::LOGGERS:
319
        return AgentParser::make_OUTPUT_OPTIONS(driver.loc_);
320
    default:
321 322 323 324 325
        return AgentParser::make_STRING("output_options", driver.loc_);
    }
}

\"output\" {
326 327
    switch(driver.ctx_) {
    case ParserContext::OUTPUT_OPTIONS:
328
        return AgentParser::make_OUTPUT(driver.loc_);
329
    default:
330 331 332 333
        return AgentParser::make_STRING("output", driver.loc_);
    }
}

334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
\"flush\" {
    switch(driver.ctx_) {
    case ParserContext::OUTPUT_OPTIONS:
        return AgentParser::make_FLUSH(driver.loc_);
    default:
        return AgentParser::make_STRING("flush", driver.loc_);
    }
}

\"maxsize\" {
    switch(driver.ctx_) {
    case ParserContext::OUTPUT_OPTIONS:
        return AgentParser::make_MAXSIZE(driver.loc_);
    default:
        return AgentParser::make_STRING("maxsize", driver.loc_);
    }
}

\"maxver\" {
    switch(driver.ctx_) {
    case ParserContext::OUTPUT_OPTIONS:
        return AgentParser::make_MAXVER(driver.loc_);
    default:
        return AgentParser::make_STRING("maxver", driver.loc_);
    }
}

361
\"debuglevel\" {
362 363
    switch(driver.ctx_) {
    case ParserContext::LOGGERS:
364
        return AgentParser::make_DEBUGLEVEL(driver.loc_);
365
    default:
366 367 368 369 370
        return AgentParser::make_STRING("debuglevel", driver.loc_);
    }
}

\"severity\" {
371 372
    switch(driver.ctx_) {
    case ParserContext::LOGGERS:
373
        return AgentParser::make_SEVERITY(driver.loc_);
374
    default:
375 376 377 378 379
        return AgentParser::make_STRING("severity", driver.loc_);
    }
}

\"Dhcp4\" {
380 381
    switch(driver.ctx_) {
    case ParserContext::CONFIG:
382
        return AgentParser::make_DHCP4(driver.loc_);
383
    default:
384 385 386 387 388
        return AgentParser::make_STRING("Dhcp4", driver.loc_);
    }
}

\"Dhcp6\" {
389 390 391 392 393 394 395 396 397 398 399 400 401 402
    switch(driver.ctx_) {
    case ParserContext::CONFIG:
        return AgentParser::make_DHCP6(driver.loc_);
    default:
        return AgentParser::make_STRING("Dhcp6", driver.loc_);
    }
}

\"DhcpDdns\" {
    switch(driver.ctx_) {
    case ParserContext::CONFIG:
        return AgentParser::make_DHCPDDNS(driver.loc_);
    default:
        return AgentParser::make_STRING("DhcpDdns", driver.loc_);
403 404 405 406
    }
}

{JSONString} {
407 408 409
    /* A string has been matched. It contains the actual string and single quotes.
       We need to get those quotes out of the way and just use its content, e.g.
       for 'foo' we should get foo */
410 411 412 413 414 415 416 417 418 419
    std::string raw(yytext+1);
    size_t len = raw.size() - 1;
    raw.resize(len);
    std::string decoded;
    decoded.reserve(len);
    for (size_t pos = 0; pos < len; ++pos) {
        int b = 0;
        char c = raw[pos];
        switch (c) {
        case '"':
420
            /* impossible condition */
421 422 423 424
            driver.error(driver.loc_, "Bad quote in \"" + raw + "\"");
        case '\\':
            ++pos;
            if (pos >= len) {
425
                /* impossible condition */
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
                driver.error(driver.loc_, "Overflow escape in \"" + raw + "\"");
            }
            c = raw[pos];
            switch (c) {
            case '"':
            case '\\':
            case '/':
                decoded.push_back(c);
                break;
            case 'b':
                decoded.push_back('\b');
                break;
            case 'f':
                decoded.push_back('\f');
                break;
            case 'n':
                decoded.push_back('\n');
                break;
            case 'r':
                decoded.push_back('\r');
                break;
            case 't':
                decoded.push_back('\t');
                break;
            case 'u':
451
                /* support only \u0000 to \u00ff */
452 453
                ++pos;
                if (pos + 4 > len) {
454
                    /* impossible condition */
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
                    driver.error(driver.loc_,
                                 "Overflow unicode escape in \"" + raw + "\"");
                }
                if ((raw[pos] != '0') || (raw[pos + 1] != '0')) {
                    driver.error(driver.loc_, "Unsupported unicode escape in \"" + raw + "\"");
                }
                pos += 2;
                c = raw[pos];
                if ((c >= '0') && (c <= '9')) {
                    b = (c - '0') << 4;
                } else if ((c >= 'A') && (c <= 'F')) {
                    b = (c - 'A' + 10) << 4;
                } else if ((c >= 'a') && (c <= 'f')) {
                    b = (c - 'a' + 10) << 4;
                } else {
470
                    /* impossible condition */
471 472 473 474 475 476 477 478 479 480 481
                    driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
                }
                pos++;
                c = raw[pos];
                if ((c >= '0') && (c <= '9')) {
                    b |= c - '0';
                } else if ((c >= 'A') && (c <= 'F')) {
                    b |= c - 'A' + 10;
                } else if ((c >= 'a') && (c <= 'f')) {
                    b |= c - 'a' + 10;
                } else {
482
                    /* impossible condition */
483 484 485 486 487
                    driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
                }
                decoded.push_back(static_cast<char>(b & 0xff));
                break;
            default:
488
                /* impossible condition */
489 490 491 492 493
                driver.error(driver.loc_, "Bad escape in \"" + raw + "\"");
            }
            break;
        default:
            if ((c >= 0) && (c < 0x20)) {
494
                /* impossible condition */
495 496 497 498 499 500 501 502 503 504
                driver.error(driver.loc_, "Invalid control in \"" + raw + "\"");
            }
            decoded.push_back(c);
        }
    }

    return AgentParser::make_STRING(decoded, driver.loc_);
}

\"{JSONStringCharacter}*{ControlCharacter}{ControlCharacterFill}*\" {
505
    /* Bad string with a forbidden control character inside */
506 507 508 509
    driver.error(driver.loc_, "Invalid control in " + std::string(yytext));
}

\"{JSONStringCharacter}*\\{BadJSONEscapeSequence}[^\x00-\x1f"]*\" {
510
    /* Bad string with a bad escape inside */
511 512 513 514
    driver.error(driver.loc_, "Bad escape in " + std::string(yytext));
}

\"{JSONStringCharacter}*\\\" {
515
    /* Bad string with an open escape at the end */
516 517 518 519 520 521 522 523 524 525 526
    driver.error(driver.loc_, "Overflow escape in " + std::string(yytext));
}

"["    { return AgentParser::make_LSQUARE_BRACKET(driver.loc_); }
"]"    { return AgentParser::make_RSQUARE_BRACKET(driver.loc_); }
"{"    { return AgentParser::make_LCURLY_BRACKET(driver.loc_); }
"}"    { return AgentParser::make_RCURLY_BRACKET(driver.loc_); }
","    { return AgentParser::make_COMMA(driver.loc_); }
":"    { return AgentParser::make_COLON(driver.loc_); }

{int} {
527
    /* An integer was found. */
528 529 530
    std::string tmp(yytext);
    int64_t integer = 0;
    try {
531 532 533 534
        /* In substring we want to use negative values (e.g. -1).
           In enterprise-id we need to use values up to 0xffffffff.
           To cover both of those use cases, we need at least
           int64_t. */
535 536 537 538 539
        integer = boost::lexical_cast<int64_t>(tmp);
    } catch (const boost::bad_lexical_cast &) {
        driver.error(driver.loc_, "Failed to convert " + tmp + " to an integer.");
    }

540
    /* The parser needs the string form as double conversion is no lossless */
541 542 543 544
    return AgentParser::make_INTEGER(integer, driver.loc_);
}

[-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)? {
545
    /* A floating point was found. */
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
    std::string tmp(yytext);
    double fp = 0.0;
    try {
        fp = boost::lexical_cast<double>(tmp);
    } catch (const boost::bad_lexical_cast &) {
        driver.error(driver.loc_, "Failed to convert " + tmp + " to a floating point.");
    }

    return AgentParser::make_FLOAT(fp, driver.loc_);
}

true|false {
    string tmp(yytext);
    return AgentParser::make_BOOLEAN(tmp == "true", driver.loc_);
}

null {
   return AgentParser::make_NULL_TYPE(driver.loc_);
}

(?i:true) driver.error (driver.loc_, "JSON true reserved keyword is lower case only");

(?i:false) driver.error (driver.loc_, "JSON false reserved keyword is lower case only");

(?i:null) driver.error (driver.loc_, "JSON null reserved keyword is lower case only");

<*>.   driver.error (driver.loc_, "Invalid character: " + std::string(yytext));

<<EOF>> {
    if (driver.states_.empty()) {
        return AgentParser::make_END(driver.loc_);
    }
    driver.loc_ = driver.locs_.back();
    driver.locs_.pop_back();
    driver.file_ = driver.files_.back();
    driver.files_.pop_back();
    if (driver.sfile_) {
        fclose(driver.sfile_);
        driver.sfile_ = 0;
    }
    if (!driver.sfiles_.empty()) {
        driver.sfile_ = driver.sfiles_.back();
        driver.sfiles_.pop_back();
    }
Francis Dupont's avatar
Francis Dupont committed
590 591
    agent__delete_buffer(YY_CURRENT_BUFFER);
    agent__switch_to_buffer(driver.states_.back());
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
    driver.states_.pop_back();

    BEGIN(DIR_EXIT);
}

%%

using namespace isc::dhcp;

void
ParserContext::scanStringBegin(const std::string& str, ParserType parser_type)
{
    start_token_flag = true;
    start_token_value = parser_type;

    file_ = "<string>";
    sfile_ = 0;
    loc_.initialize(&file_);
    yy_flex_debug = trace_scanning_;
    YY_BUFFER_STATE buffer;
Francis Dupont's avatar
Francis Dupont committed
612
    buffer = agent__scan_bytes(str.c_str(), str.size());
613 614
    if (!buffer) {
        fatal("cannot scan string");
615
        /* fatal() throws an exception so this can't be reached */
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
    }
}

void
ParserContext::scanFileBegin(FILE * f,
                              const std::string& filename,
                              ParserType parser_type)
{
    start_token_flag = true;
    start_token_value = parser_type;

    file_ = filename;
    sfile_ = f;
    loc_.initialize(&file_);
    yy_flex_debug = trace_scanning_;
    YY_BUFFER_STATE buffer;

633
    /* See agent_lexer.cc header for available definitions */
Francis Dupont's avatar
Francis Dupont committed
634
    buffer = agent__create_buffer(f, 65536 /*buffer size*/);
635 636 637
    if (!buffer) {
        fatal("cannot scan file " + filename);
    }
Francis Dupont's avatar
Francis Dupont committed
638
    agent__switch_to_buffer(buffer);
639 640 641 642 643 644 645
}

void
ParserContext::scanEnd() {
    if (sfile_)
        fclose(sfile_);
    sfile_ = 0;
Francis Dupont's avatar
Francis Dupont committed
646
    static_cast<void>(agent_lex_destroy());
647
    /* Close files */
648 649 650 651 652 653 654
    while (!sfiles_.empty()) {
        FILE* f = sfiles_.back();
        if (f) {
            fclose(f);
        }
        sfiles_.pop_back();
    }
655
    /* Delete states */
656
    while (!states_.empty()) {
Francis Dupont's avatar
Francis Dupont committed
657
        agent__delete_buffer(states_.back());
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677
        states_.pop_back();
    }
}

void
ParserContext::includeFile(const std::string& filename) {
    if (states_.size() > 10) {
        fatal("Too many nested include.");
    }

    FILE* f = fopen(filename.c_str(), "r");
    if (!f) {
        fatal("Can't open include file " + filename);
    }
    if (sfile_) {
        sfiles_.push_back(sfile_);
    }
    sfile_ = f;
    states_.push_back(YY_CURRENT_BUFFER);
    YY_BUFFER_STATE buffer;
Francis Dupont's avatar
Francis Dupont committed
678
    buffer = agent__create_buffer(f, 65536 /*buffer size*/);
679 680 681
    if (!buffer) {
        fatal( "Can't scan include file " + filename);
    }
Francis Dupont's avatar
Francis Dupont committed
682
    agent__switch_to_buffer(buffer);
683 684 685 686 687 688 689 690 691
    files_.push_back(file_);
    file_ = filename;
    locs_.push_back(loc_);
    loc_.initialize(&file_);

    BEGIN(INITIAL);
}

namespace {
692
/** To avoid unused function error */
693
class Dummy {
694
    /* cppcheck-suppress unusedPrivateFunction */
695 696 697
    void dummy() { yy_fatal_error("Fix me: how to disable its definition?"); }
};
}