dhcp6_lexer.ll 37.7 KB
Newer Older
1
/* Copyright (C) 2016-2017 Internet Systems Consortium, Inc. ("ISC")
2 3 4 5 6 7 8 9 10 11 12 13 14

   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 <dhcp6/parser_context.h>
#include <asiolink/io_address.h>
#include <boost/lexical_cast.hpp>
Tomek Mrugalski's avatar
Tomek Mrugalski committed
15
#include <exceptions/exceptions.h>
16 17 18 19 20 21 22 23

// 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>.
# undef yywrap
# define yywrap() 1

Francis Dupont's avatar
Francis Dupont committed
24 25 26 27 28
namespace {

bool start_token_flag = false;

isc::dhcp::Parser6Context::ParserType start_token_value;
29
unsigned int comment_start_line = 0;
Francis Dupont's avatar
Francis Dupont committed
30 31

};
32

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
// To avoid the call to exit... oops!
#define YY_FATAL_ERROR(msg) isc::dhcp::Parser6Context::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

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

53 54 55 56 57 58 59 60 61
/* 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

Tomek Mrugalski's avatar
Tomek Mrugalski committed
62
%x COMMENT
Francis Dupont's avatar
Francis Dupont committed
63
%x DIR_ENTER DIR_INCLUDE DIR_EXIT
Tomek Mrugalski's avatar
Tomek Mrugalski committed
64

65 66 67 68
/* 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]+
69
blank [ \t\r]
70

71 72 73 74 75 76
UnicodeEscapeSequence           u[0-9A-Fa-f]{4}
JSONEscapeCharacter             ["\\/bfnrt]
JSONEscapeSequence              {JSONEscapeCharacter}|{UnicodeEscapeSequence}
JSONStandardCharacter           [^\x00-\x1f"\\]
JSONStringCharacter             {JSONStandardCharacter}|\\{JSONEscapeSequence}
JSONString                      \"{JSONStringCharacter}*\"
77

78 79 80 81 82 83
/* for errors */

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

%{
// 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.
89
#define YY_USER_ACTION  driver.loc_.columns(yyleng);
90 91 92 93 94
%}

%%

%{
95 96 97 98
    // 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

99
    // Code run each time yylex is called.
100
    driver.loc_.step();
Tomek Mrugalski's avatar
Tomek Mrugalski committed
101

102 103 104
    if (start_token_flag) {
        start_token_flag = false;
        switch (start_token_value) {
105
        case Parser6Context::PARSER_JSON:
106
        default:
107
            return isc::dhcp::Dhcp6Parser::make_TOPLEVEL_JSON(driver.loc_);
108
        case Parser6Context::PARSER_DHCP6:
109
            return isc::dhcp::Dhcp6Parser::make_TOPLEVEL_DHCP6(driver.loc_);
110 111
        case Parser6Context::SUBPARSER_DHCP6:
            return isc::dhcp::Dhcp6Parser::make_SUB_DHCP6(driver.loc_);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
112
        case Parser6Context::PARSER_INTERFACES:
113
            return isc::dhcp::Dhcp6Parser::make_SUB_INTERFACES6(driver.loc_);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
114
        case Parser6Context::PARSER_SUBNET6:
115
            return isc::dhcp::Dhcp6Parser::make_SUB_SUBNET6(driver.loc_);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
116
        case Parser6Context::PARSER_POOL6:
117
            return isc::dhcp::Dhcp6Parser::make_SUB_POOL6(driver.loc_);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
118
        case Parser6Context::PARSER_PD_POOL:
119
            return isc::dhcp::Dhcp6Parser::make_SUB_PD_POOL(driver.loc_);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
120
        case Parser6Context::PARSER_HOST_RESERVATION:
121
            return isc::dhcp::Dhcp6Parser::make_SUB_RESERVATION(driver.loc_);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
122
        case Parser6Context::PARSER_OPTION_DATA:
123
            return isc::dhcp::Dhcp6Parser::make_SUB_OPTION_DATA(driver.loc_);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
124
        case Parser6Context::PARSER_HOOKS_LIBRARY:
125
            return isc::dhcp::Dhcp6Parser::make_SUB_HOOKS_LIBRARY(driver.loc_);
126 127
        }
    }
128 129
%}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
130 131 132 133 134 135
#.* ;

"//"(.*) ;

"/*" {
  BEGIN(COMMENT);
136
  comment_start_line = driver.loc_.end.line;;
Tomek Mrugalski's avatar
Tomek Mrugalski committed
137 138 139
}

<COMMENT>"*/" BEGIN(INITIAL);
140
<COMMENT>. ;
Tomek Mrugalski's avatar
Tomek Mrugalski committed
141
<COMMENT><<EOF>> {
142
    isc_throw(Dhcp6ParseError, "Comment not closed. (/* in line " << comment_start_line);
Tomek Mrugalski's avatar
Tomek Mrugalski committed
143 144
}

Francis Dupont's avatar
Francis Dupont committed
145 146 147 148 149 150 151 152 153
"<?" BEGIN(DIR_ENTER);
<DIR_ENTER>"include" BEGIN(DIR_INCLUDE);
<DIR_INCLUDE>\"([^\"\n])+\" {
    // Include directive.

    // Extract the filename.
    std::string tmp(yytext+1);
    tmp.resize(tmp.size() - 1);

154
    driver.includeFile(tmp);
Francis Dupont's avatar
Francis Dupont committed
155
}
156
<DIR_ENTER,DIR_INCLUDE,DIR_EXIT><<EOF>> {
157
    isc_throw(Dhcp6ParseError, "Directive not closed.");
158
}
Francis Dupont's avatar
Francis Dupont committed
159
<DIR_EXIT>"?>" BEGIN(INITIAL);
160

Francis Dupont's avatar
Francis Dupont committed
161

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

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

173

174 175 176
\"Dhcp6\"  {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::CONFIG:
177
        return isc::dhcp::Dhcp6Parser::make_DHCP6(driver.loc_);
178
    default:
179
        return isc::dhcp::Dhcp6Parser::make_STRING("Dhcp6", driver.loc_);
180 181 182 183 184 185
    }
}

\"interfaces-config\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
186
        return  isc::dhcp::Dhcp6Parser::make_INTERFACES_CONFIG(driver.loc_);
187
    default:
188
        return isc::dhcp::Dhcp6Parser::make_STRING("interfaces-config", driver.loc_);
189 190 191 192 193 194
    }
}

\"interfaces\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::INTERFACES_CONFIG:
195
        return  isc::dhcp::Dhcp6Parser::make_INTERFACES(driver.loc_);
196
    default:
197
        return isc::dhcp::Dhcp6Parser::make_STRING("interfaces", driver.loc_);
198 199 200 201 202 203
    }
}

\"lease-database\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
204
        return isc::dhcp::Dhcp6Parser::make_LEASE_DATABASE(driver.loc_);
205
    default:
206
        return isc::dhcp::Dhcp6Parser::make_STRING("lease-database", driver.loc_);
207 208 209 210 211 212
    }
}

\"hosts-database\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
213
        return isc::dhcp::Dhcp6Parser::make_HOSTS_DATABASE(driver.loc_);
214
    default:
215
        return isc::dhcp::Dhcp6Parser::make_STRING("hosts-database", driver.loc_);
216 217 218
    }
}

219 220 221 222 223 224 225 226 227
\"readonly\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
        return isc::dhcp::Dhcp6Parser::make_READONLY(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("readonly", driver.loc_);
    }
}

228 229
\"type\" {
    switch(driver.ctx_) {
230 231
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
232
    case isc::dhcp::Parser6Context::OPTION_DEF:
233
    case isc::dhcp::Parser6Context::SERVER_ID:
234
        return isc::dhcp::Dhcp6Parser::make_TYPE(driver.loc_);
235
    default:
236
        return isc::dhcp::Dhcp6Parser::make_STRING("type", driver.loc_);
237 238 239
    }
}

240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
\"memfile\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DATABASE_TYPE:
        return isc::dhcp::Dhcp6Parser::make_MEMFILE(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("memfile", driver.loc_);
    }
}

\"mysql\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DATABASE_TYPE:
        return isc::dhcp::Dhcp6Parser::make_MYSQL(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("mysql", driver.loc_);
    }
}

\"postgresql\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DATABASE_TYPE:
        return isc::dhcp::Dhcp6Parser::make_POSTGRESQL(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("postgresql", driver.loc_);
    }
}

267 268
\"user\" {
    switch(driver.ctx_) {
269 270
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
271
        return isc::dhcp::Dhcp6Parser::make_USER(driver.loc_);
272
    default:
273
        return isc::dhcp::Dhcp6Parser::make_STRING("user", driver.loc_);
274 275 276 277 278
    }
}

\"password\" {
    switch(driver.ctx_) {
279 280
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
281
        return isc::dhcp::Dhcp6Parser::make_PASSWORD(driver.loc_);
282
    default:
283
        return isc::dhcp::Dhcp6Parser::make_STRING("password", driver.loc_);
284 285 286 287 288
    }
}

\"host\" {
    switch(driver.ctx_) {
289 290
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
291
        return isc::dhcp::Dhcp6Parser::make_HOST(driver.loc_);
292
    default:
293
        return isc::dhcp::Dhcp6Parser::make_STRING("host", driver.loc_);
294 295 296 297 298
    }
}

\"persist\" {
    switch(driver.ctx_) {
299 300
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
301
    case isc::dhcp::Parser6Context::SERVER_ID:
302
        return isc::dhcp::Dhcp6Parser::make_PERSIST(driver.loc_);
303
    default:
304
        return isc::dhcp::Dhcp6Parser::make_STRING("persist", driver.loc_);
305 306 307 308 309
    }
}

\"lfc-interval\" {
    switch(driver.ctx_) {
310 311
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
312
        return isc::dhcp::Dhcp6Parser::make_LFC_INTERVAL(driver.loc_);
313
    default:
314
        return isc::dhcp::Dhcp6Parser::make_STRING("lfc-interval", driver.loc_);
315 316 317
    }
}

318 319 320 321 322 323 324 325 326 327
\"connect-timeout\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
        return isc::dhcp::Dhcp6Parser::make_CONNECT_TIMEOUT(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("connect-timeout", driver.loc_);
    }
}

328 329 330
\"preferred-lifetime\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
331
    case isc::dhcp::Parser6Context::SUBNET6:
332
        return isc::dhcp::Dhcp6Parser::make_PREFERRED_LIFETIME(driver.loc_);
333
    default:
334
        return isc::dhcp::Dhcp6Parser::make_STRING("preferred-lifetime", driver.loc_);
335 336 337 338 339 340
    }
}

\"valid-lifetime\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
341
    case isc::dhcp::Parser6Context::SUBNET6:
342
        return isc::dhcp::Dhcp6Parser::make_VALID_LIFETIME(driver.loc_);
343
    default:
344
        return isc::dhcp::Dhcp6Parser::make_STRING("valid-lifetime", driver.loc_);
345 346 347 348 349 350
    }
}

\"renew-timer\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
351
    case isc::dhcp::Parser6Context::SUBNET6:
352
        return isc::dhcp::Dhcp6Parser::make_RENEW_TIMER(driver.loc_);
353
    default:
354
        return isc::dhcp::Dhcp6Parser::make_STRING("renew-timer", driver.loc_);
355 356 357 358 359 360
    }
}

\"rebind-timer\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
361
    case isc::dhcp::Parser6Context::SUBNET6:
362
        return isc::dhcp::Dhcp6Parser::make_REBIND_TIMER(driver.loc_);
363
    default:
364
        return isc::dhcp::Dhcp6Parser::make_STRING("rebind-timer", driver.loc_);
365 366 367
    }
}

368 369 370 371 372 373 374 375 376
\"decline-probation-period\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
        return isc::dhcp::Dhcp6Parser::make_DECLINE_PROBATION_PERIOD(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("decline-probation-period", driver.loc_);
    }
}

377 378 379
\"subnet6\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
380
        return isc::dhcp::Dhcp6Parser::make_SUBNET6(driver.loc_);
381
    default:
382
        return isc::dhcp::Dhcp6Parser::make_STRING("subnet6", driver.loc_);
383 384 385
    }
}

386 387 388 389 390 391 392 393 394
\"option-def\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
        return isc::dhcp::Dhcp6Parser::make_OPTION_DEF(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("option-def", driver.loc_);
    }
}

395 396 397 398 399 400 401 402 403
\"option-data\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
    case isc::dhcp::Parser6Context::SUBNET6:
    case isc::dhcp::Parser6Context::POOLS:
    case isc::dhcp::Parser6Context::PD_POOLS:
    case isc::dhcp::Parser6Context::RESERVATIONS:
    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
    case isc::dhcp::Parser6Context::CLIENT_CLASS:
404
        return isc::dhcp::Dhcp6Parser::make_OPTION_DATA(driver.loc_);
405
    default:
406
        return isc::dhcp::Dhcp6Parser::make_STRING("option-data", driver.loc_);
407 408 409 410 411
    }
}

\"name\" {
    switch(driver.ctx_) {
412 413
    case isc::dhcp::Parser6Context::LEASE_DATABASE:
    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
414
    case isc::dhcp::Parser6Context::OPTION_DEF:
415 416 417 418
    case isc::dhcp::Parser6Context::OPTION_DATA:
    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
    case isc::dhcp::Parser6Context::CLIENT_CLASS:
    case isc::dhcp::Parser6Context::LOGGERS:
419
        return isc::dhcp::Dhcp6Parser::make_NAME(driver.loc_);
420
    default:
421
        return isc::dhcp::Dhcp6Parser::make_STRING("name", driver.loc_);
422 423 424 425 426 427
    }
}

\"data\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::OPTION_DATA:
428
        return isc::dhcp::Dhcp6Parser::make_DATA(driver.loc_);
429
    default:
430
        return isc::dhcp::Dhcp6Parser::make_STRING("data", driver.loc_);
431 432 433 434 435 436
    }
}

\"pools\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
437
        return isc::dhcp::Dhcp6Parser::make_POOLS(driver.loc_);
438
    default:
439
        return isc::dhcp::Dhcp6Parser::make_STRING("pools", driver.loc_);
440 441 442 443 444 445
    }
}

\"pd-pools\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
446
        return isc::dhcp::Dhcp6Parser::make_PD_POOLS(driver.loc_);
447
    default:
448
        return isc::dhcp::Dhcp6Parser::make_STRING("pd-pools", driver.loc_);
449 450 451 452 453 454
    }
}

\"prefix\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::PD_POOLS:
455
        return isc::dhcp::Dhcp6Parser::make_PREFIX(driver.loc_);
456
    default:
457
        return isc::dhcp::Dhcp6Parser::make_STRING("prefix", driver.loc_);
458 459 460 461 462 463
    }
}

\"prefix-len\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::PD_POOLS:
464
        return isc::dhcp::Dhcp6Parser::make_PREFIX_LEN(driver.loc_);
465
    default:
466
        return isc::dhcp::Dhcp6Parser::make_STRING("prefix-len", driver.loc_);
467 468 469
    }
}

470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
\"excluded-prefix\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::PD_POOLS:
        return isc::dhcp::Dhcp6Parser::make_EXCLUDED_PREFIX(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("excluded-prefix", driver.loc_);
    }
}

\"excluded-prefix-len\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::PD_POOLS:
        return isc::dhcp::Dhcp6Parser::make_EXCLUDED_PREFIX_LEN(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("excluded-prefix-len", driver.loc_);
    }
}

488 489 490
\"delegated-len\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::PD_POOLS:
491
        return isc::dhcp::Dhcp6Parser::make_DELEGATED_LEN(driver.loc_);
492
    default:
493
        return isc::dhcp::Dhcp6Parser::make_STRING("delegated-len", driver.loc_);
494 495 496 497 498 499
    }
}

\"pool\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::POOLS:
500
        return isc::dhcp::Dhcp6Parser::make_POOL(driver.loc_);
501
    default:
502
        return isc::dhcp::Dhcp6Parser::make_STRING("pool", driver.loc_);
503 504 505 506 507 508
    }
}

\"subnet\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
509
        return isc::dhcp::Dhcp6Parser::make_SUBNET(driver.loc_);
510
    default:
511
        return isc::dhcp::Dhcp6Parser::make_STRING("subnet", driver.loc_);
512 513 514 515 516 517
    }
}

\"interface\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
518
        return isc::dhcp::Dhcp6Parser::make_INTERFACE(driver.loc_);
519
    default:
520
        return isc::dhcp::Dhcp6Parser::make_STRING("interface", driver.loc_);
521 522 523
    }
}

524 525 526 527 528 529 530 531 532
\"interface-id\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
        return isc::dhcp::Dhcp6Parser::make_INTERFACE_ID(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("interface-id", driver.loc_);
    }
}

533 534 535
\"id\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
536
        return isc::dhcp::Dhcp6Parser::make_ID(driver.loc_);
537
    default:
538
        return isc::dhcp::Dhcp6Parser::make_STRING("id", driver.loc_);
539 540 541
    }
}

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
\"rapid-commit\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
        return isc::dhcp::Dhcp6Parser::make_RAPID_COMMIT(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("rapid-commit", driver.loc_);
    }
}

\"reservation-mode\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
        return isc::dhcp::Dhcp6Parser::make_RESERVATION_MODE(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("reservation-mode", driver.loc_);
    }
}

560 561
\"code\" {
    switch(driver.ctx_) {
562
    case isc::dhcp::Parser6Context::OPTION_DEF:
563
    case isc::dhcp::Parser6Context::OPTION_DATA:
564
        return isc::dhcp::Dhcp6Parser::make_CODE(driver.loc_);
565
    default:
566
        return isc::dhcp::Dhcp6Parser::make_STRING("code", driver.loc_);
567 568 569 570 571 572
    }
}

\"mac-sources\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
573
        return isc::dhcp::Dhcp6Parser::make_MAC_SOURCES(driver.loc_);
574
    default:
575
        return isc::dhcp::Dhcp6Parser::make_STRING("mac-sources", driver.loc_);
576 577 578 579 580 581
    }
}

\"relay-supplied-options\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
582
        return isc::dhcp::Dhcp6Parser::make_RELAY_SUPPLIED_OPTIONS(driver.loc_);
583
    default:
584
        return isc::dhcp::Dhcp6Parser::make_STRING("relay-supplied-options", driver.loc_);
585 586 587 588 589 590
    }
}

\"host-reservation-identifiers\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
591
        return isc::dhcp::Dhcp6Parser::make_HOST_RESERVATION_IDENTIFIERS(driver.loc_);
592
    default:
593
        return isc::dhcp::Dhcp6Parser::make_STRING("host-reservation-identifiers", driver.loc_);
594 595 596 597 598 599
    }
}

\"Logging\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::CONFIG:
600
        return isc::dhcp::Dhcp6Parser::make_LOGGING(driver.loc_);
601
    default:
602
        return isc::dhcp::Dhcp6Parser::make_STRING("Logging", driver.loc_);
603 604 605 606 607 608
    }
}

\"loggers\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::LOGGING:
609
        return isc::dhcp::Dhcp6Parser::make_LOGGERS(driver.loc_);
610
    default:
611
        return isc::dhcp::Dhcp6Parser::make_STRING("loggers", driver.loc_);
612 613 614 615 616 617
    }
}

\"output_options\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::LOGGERS:
618
        return isc::dhcp::Dhcp6Parser::make_OUTPUT_OPTIONS(driver.loc_);
619
    default:
620
        return isc::dhcp::Dhcp6Parser::make_STRING("output_options", driver.loc_);
621 622 623 624 625 626
    }
}

\"output\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::OUTPUT_OPTIONS:
627
        return isc::dhcp::Dhcp6Parser::make_OUTPUT(driver.loc_);
628
    default:
629
        return isc::dhcp::Dhcp6Parser::make_STRING("output", driver.loc_);
630 631 632 633 634 635
    }
}

\"debuglevel\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::LOGGERS:
636
        return isc::dhcp::Dhcp6Parser::make_DEBUGLEVEL(driver.loc_);
637
    default:
638
        return isc::dhcp::Dhcp6Parser::make_STRING("debuglevel", driver.loc_);
639 640 641 642 643 644
    }
}

\"severity\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::LOGGERS:
645
        return isc::dhcp::Dhcp6Parser::make_SEVERITY(driver.loc_);
646
    default:
647
        return isc::dhcp::Dhcp6Parser::make_STRING("severity", driver.loc_);
648 649 650 651 652 653 654
    }
}

\"client-classes\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
    case isc::dhcp::Parser6Context::RESERVATIONS:
655
        return isc::dhcp::Dhcp6Parser::make_CLIENT_CLASSES(driver.loc_);
656
    default:
657
        return isc::dhcp::Dhcp6Parser::make_STRING("client-classes", driver.loc_);
658 659 660 661 662 663 664
    }
}

\"client-class\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
665
        return isc::dhcp::Dhcp6Parser::make_CLIENT_CLASS(driver.loc_);
666
    default:
667
        return isc::dhcp::Dhcp6Parser::make_STRING("client-class", driver.loc_);
668 669 670 671 672 673 674
    }
}

\"test\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
    case isc::dhcp::Parser6Context::CLIENT_CLASS:
675
        return isc::dhcp::Dhcp6Parser::make_TEST(driver.loc_);
676
    default:
677
        return isc::dhcp::Dhcp6Parser::make_STRING("test", driver.loc_);
678 679 680 681 682 683
    }
}

\"reservations\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
684
        return isc::dhcp::Dhcp6Parser::make_RESERVATIONS(driver.loc_);
685
    default:
686
        return isc::dhcp::Dhcp6Parser::make_STRING("reservations", driver.loc_);
687 688 689 690 691 692
    }
}

\"ip-addresses\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::RESERVATIONS:
693
        return isc::dhcp::Dhcp6Parser::make_IP_ADDRESSES(driver.loc_);
694
    default:
695
        return isc::dhcp::Dhcp6Parser::make_STRING("ip-addresses", driver.loc_);
696 697 698 699 700 701
    }
}

\"prefixes\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::RESERVATIONS:
702
        return isc::dhcp::Dhcp6Parser::make_PREFIXES(driver.loc_);
703
    default:
704
        return isc::dhcp::Dhcp6Parser::make_STRING("prefixes", driver.loc_);
705 706 707 708 709 710 711 712
    }
}

\"duid\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::MAC_SOURCES:
    case isc::dhcp::Parser6Context::HOST_RESERVATION_IDENTIFIERS:
    case isc::dhcp::Parser6Context::RESERVATIONS:
713
        return isc::dhcp::Dhcp6Parser::make_DUID(driver.loc_);
714
    default:
715
        return isc::dhcp::Dhcp6Parser::make_STRING("duid", driver.loc_);
716 717 718 719 720 721 722
    }
}

\"hw-address\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::HOST_RESERVATION_IDENTIFIERS:
    case isc::dhcp::Parser6Context::RESERVATIONS:
723
        return isc::dhcp::Dhcp6Parser::make_HW_ADDRESS(driver.loc_);
724
    default:
725
        return isc::dhcp::Dhcp6Parser::make_STRING("hw-address", driver.loc_);
726 727 728 729 730 731
    }
}

\"hostname\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::RESERVATIONS:
732
        return isc::dhcp::Dhcp6Parser::make_HOSTNAME(driver.loc_);
733
    default:
734
        return isc::dhcp::Dhcp6Parser::make_STRING("hostname", driver.loc_);
735 736 737 738 739
    }
}

\"space\" {
    switch(driver.ctx_) {
740
    case isc::dhcp::Parser6Context::OPTION_DEF:
741
    case isc::dhcp::Parser6Context::OPTION_DATA:
742
        return isc::dhcp::Dhcp6Parser::make_SPACE(driver.loc_);
743
    default:
744
        return isc::dhcp::Dhcp6Parser::make_STRING("space", driver.loc_);
745 746 747 748 749 750
    }
}

\"csv-format\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::OPTION_DATA:
751
        return isc::dhcp::Dhcp6Parser::make_CSV_FORMAT(driver.loc_);
752
    default:
753
        return isc::dhcp::Dhcp6Parser::make_STRING("csv-format", driver.loc_);
754 755 756
    }
}

757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
\"record-types\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::OPTION_DEF:
        return isc::dhcp::Dhcp6Parser::make_RECORD_TYPES(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("record-types", driver.loc_);
    }
}

\"encapsulate\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::OPTION_DEF:
        return isc::dhcp::Dhcp6Parser::make_ENCAPSULATE(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("encapsulate", driver.loc_);
    }
}

\"array\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::OPTION_DEF:
        return isc::dhcp::Dhcp6Parser::make_ARRAY(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("array", driver.loc_);
    }
}

\"relay\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SUBNET6:
        return isc::dhcp::Dhcp6Parser::make_RELAY(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("relay", driver.loc_);
    }
}

\"ip-address\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::RELAY:
    return isc::dhcp::Dhcp6Parser::make_IP_ADDRESS(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("ip-address", driver.loc_);
    }
}

802 803 804
\"hooks-libraries\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
805
        return isc::dhcp::Dhcp6Parser::make_HOOKS_LIBRARIES(driver.loc_);
806
    default:
807
        return isc::dhcp::Dhcp6Parser::make_STRING("hooks-libraries", driver.loc_);
808 809 810
    }
}

811 812 813 814 815 816 817 818 819 820

\"parameters\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::HOOKS_LIBRARIES:
        return isc::dhcp::Dhcp6Parser::make_PARAMETERS(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("parameters", driver.loc_);
    }
}

821 822 823
\"library\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::HOOKS_LIBRARIES:
824
        return isc::dhcp::Dhcp6Parser::make_LIBRARY(driver.loc_);
825
    default:
826
        return isc::dhcp::Dhcp6Parser::make_STRING("library", driver.loc_);
827 828 829 830 831 832
    }
}

\"server-id\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
833
        return isc::dhcp::Dhcp6Parser::make_SERVER_ID(driver.loc_);
834
    default:
835
        return isc::dhcp::Dhcp6Parser::make_STRING("server-id", driver.loc_);
836 837 838
    }
}

839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
\"LLT\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DUID_TYPE:
        return isc::dhcp::Dhcp6Parser::make_LLT(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("LLT", driver.loc_);
    }
}

\"EN\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DUID_TYPE:
        return isc::dhcp::Dhcp6Parser::make_EN(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("EN", driver.loc_);
    }
}

\"LL\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DUID_TYPE:
        return isc::dhcp::Dhcp6Parser::make_LL(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("LL", driver.loc_);
    }
}

866 867 868
\"identifier\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SERVER_ID:
869
        return isc::dhcp::Dhcp6Parser::make_IDENTIFIER(driver.loc_);
870
    default:
871
        return isc::dhcp::Dhcp6Parser::make_STRING("identifier", driver.loc_);
872 873 874 875 876 877
    }
}

\"htype\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SERVER_ID:
878
        return isc::dhcp::Dhcp6Parser::make_HTYPE(driver.loc_);
879
    default:
880
        return isc::dhcp::Dhcp6Parser::make_STRING("htype", driver.loc_);
881 882 883 884 885 886
    }
}

\"time\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SERVER_ID:
887
        return isc::dhcp::Dhcp6Parser::make_TIME(driver.loc_);
888
    default:
889
        return isc::dhcp::Dhcp6Parser::make_STRING("time", driver.loc_);
890 891 892 893 894 895
    }
}

\"enterprise-id\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::SERVER_ID:
896
        return isc::dhcp::Dhcp6Parser::make_ENTERPRISE_ID(driver.loc_);
897
    default:
898
        return isc::dhcp::Dhcp6Parser::make_STRING("enterprise-id", driver.loc_);
899 900 901 902 903 904
    }
}

\"expired-leases-processing\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
905
        return isc::dhcp::Dhcp6Parser::make_EXPIRED_LEASES_PROCESSING(driver.loc_);
906
    default:
907
        return isc::dhcp::Dhcp6Parser::make_STRING("expired-leases-processing", driver.loc_);
908 909 910 911 912 913
    }
}

\"dhcp4o6-port\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
914
        return isc::dhcp::Dhcp6Parser::make_DHCP4O6_PORT(driver.loc_);
915
    default:
916
        return isc::dhcp::Dhcp6Parser::make_STRING("dhcp4o6-port", driver.loc_);
917 918 919
    }
}

920 921 922 923 924 925
\"control-socket\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
        return isc::dhcp::Dhcp6Parser::make_CONTROL_SOCKET(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("control-socket", driver.loc_);
926 927 928
    }
}

929
\"socket-type\" {
930
    switch(driver.ctx_) {
931 932
    case isc::dhcp::Parser6Context::CONTROL_SOCKET:
        return isc::dhcp::Dhcp6Parser::make_SOCKET_TYPE(driver.loc_);
933
    default:
934
        return isc::dhcp::Dhcp6Parser::make_STRING("socket-type", driver.loc_);
935 936 937
    }
}

938
\"socket-name\" {
939
    switch(driver.ctx_) {
940 941
    case isc::dhcp::Parser6Context::CONTROL_SOCKET:
        return isc::dhcp::Dhcp6Parser::make_SOCKET_NAME(driver.loc_);
942
    default:
943 944 945 946 947 948 949 950 951 952
        return isc::dhcp::Dhcp6Parser::make_STRING("socket-name", driver.loc_);
    }
}

\"dhcp-ddns\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::DHCP6:
        return isc::dhcp::Dhcp6Parser::make_DHCP_DDNS(driver.loc_);
    default:
        return isc::dhcp::Dhcp6Parser::make_STRING("dhcp-ddns", driver.loc_);
953 954
    }
}
955

956 957 958
\"Dhcp4\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::CONFIG:
959
        return isc::dhcp::Dhcp6Parser::make_DHCP4(driver.loc_);
960
    default:
961
        return isc::dhcp::Dhcp6Parser::make_STRING("Dhcp4", driver.loc_);
962 963 964 965 966 967
    }
}

\"DhcpDdns\" {
    switch(driver.ctx_) {
    case isc::dhcp::Parser6Context::CONFIG:
968
        return isc::dhcp::Dhcp6Parser::make_DHCPDDNS(driver.loc_);
969
    default:
970
        return isc::dhcp::Dhcp6Parser::make_STRING("DhcpDdns", driver.loc_);
971 972
    }
}
973

974 975 976 977
{JSONString} {
    // 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
978 979 980 981 982 983
    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) {
984
        int b = 0;
985 986 987 988
        char c = raw[pos];
        switch (c) {
        case '"':
            // impossible condition
989
            driver.error(driver.loc_, "Bad quote in \"" + raw + "\"");
990 991 992 993
        case '\\':
            ++pos;
            if (pos >= len) {
                // impossible condition
994
                driver.error(driver.loc_, "Overflow escape in \"" + raw + "\"");
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
            }
            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':
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
                // support only \u0000 to \u00ff
                ++pos;
                if (pos + 4 > len) {
                    // impossible condition
                    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 {
                    // impossible condition
                    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 {
                    // impossible condition
                    driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
                }
                decoded.push_back(static_cast<char>(b & 0xff));
                break;
1055 1056
            default:
                // impossible condition
1057
                driver.error(driver.loc_, "Bad escape in \"" + raw + "\"");
1058 1059 1060
            }
            break;
        default:
1061
            if ((c >= 0) && (c < 0x20)) {
1062
                // impossible condition
1063
                driver.error(driver.loc_, "Invalid control in \"" + raw + "\"");
1064 1065 1066 1067
            }
            decoded.push_back(c);
        }
    }
1068

1069
    return isc::dhcp::Dhcp6Parser::make_STRING(decoded, driver.loc_);
1070 1071 1072 1073
}

\"{JSONStringCharacter}*{ControlCharacter}{ControlCharacterFill}*\" {
    // Bad string with a forbidden control character inside
1074
    driver.error(driver.loc_, "Invalid control in " + std::string(yytext));
1075 1076 1077 1078
}

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

1082 1083
\"{JSONStringCharacter}*\\\" {
    // Bad string with an open escape at the end
1084
    driver.error(driver.loc_, "Overflow escape in " + std::string(yytext));
1085 1086
}

1087 1088 1089 1090 1091 1092
"["    { return isc::dhcp::Dhcp6Parser::make_LSQUARE_BRACKET(driver.loc_); }
"]"    { return isc::dhcp::Dhcp6Parser::make_RSQUARE_BRACKET(driver.loc_); }
"{"    { return isc::dhcp::Dhcp6Parser::make_LCURLY_BRACKET(driver.loc_); }
"}"    { return isc::dhcp::Dhcp6Parser::make_RCURLY_BRACKET(driver.loc_); }
","    { return isc::dhcp::Dhcp6Parser::make_COMMA(driver.loc_); }
":"    { return isc::dhcp::Dhcp6Parser::make_COLON(driver.loc_); }