1 // A Bison parser, made by GNU Bison 3.8.2.
2
3 // Skeleton implementation for Bison LALR(1) parsers in C++
4
5 // Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc.
6
7 // This program is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation, either version 3 of the License, or
10 // (at your option) any later version.
11
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License
18 // along with this program. If not, see <https://www.gnu.org/licenses/>.
19
20 // As a special exception, you may create a larger work that contains
21 // part or all of the Bison parser skeleton and distribute that work
22 // under terms of your choice, so long as that work isn't itself a
23 // parser generator using the skeleton or a modified version thereof
24 // as a parser skeleton. Alternatively, if you modify or redistribute
25 // the parser skeleton itself, you may (at your option) remove this
26 // special exception, which will cause the skeleton and the resulting
27 // Bison output files to be licensed under the GNU General Public
28 // License without this special exception.
29
30 // This special exception was added by the Free Software Foundation in
31 // version 2.2 of Bison.
32
33 // DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
34 // especially those whose name start with YY_ or yy_. They are
35 // private implementation details that can be changed or removed.
36
37
38 // Take the name prefix into account.
39 #define yylex parser4_lex
40
41
42
43 #include "dhcp4_parser.h"
44
45
46 // Unqualified %code blocks.
47 #line 34 "dhcp4_parser.yy"
48
49 #include <dhcp4/parser_context.h>
50
51 #line 52 "dhcp4_parser.cc"
52
53
54 #ifndef YY_
55 # if defined YYENABLE_NLS && YYENABLE_NLS
56 # if ENABLE_NLS
57 # include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
58 # define YY_(msgid) dgettext ("bison-runtime", msgid)
59 # endif
60 # endif
61 # ifndef YY_
62 # define YY_(msgid) msgid
63 # endif
64 #endif
65
66
67 // Whether we are compiled with exception support.
68 #ifndef YY_EXCEPTIONS
69 # if defined __GNUC__ && !defined __EXCEPTIONS
70 # define YY_EXCEPTIONS 0
71 # else
72 # define YY_EXCEPTIONS 1
73 # endif
74 #endif
75
76 #define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
77 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
78 If N is 0, then set CURRENT to the empty location which ends
79 the previous symbol: RHS[0] (always defined). */
80
81 # ifndef YYLLOC_DEFAULT
82 # define YYLLOC_DEFAULT(Current, Rhs, N) \
83 do \
84 if (N) \
85 { \
86 (Current).begin = YYRHSLOC (Rhs, 1).begin; \
87 (Current).end = YYRHSLOC (Rhs, N).end; \
88 } \
89 else \
90 { \
91 (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
92 } \
93 while (false)
94 # endif
95
96
97 // Enable debugging if requested.
98 #if PARSER4_DEBUG
99
100 // A pseudo ostream that takes yydebug_ into account.
101 # define YYCDEBUG if (yydebug_) (*yycdebug_)
102
103 # define YY_SYMBOL_PRINT(Title, Symbol) \
104 do { \
105 if (yydebug_) \
106 { \
107 *yycdebug_ << Title << ' '; \
108 yy_print_ (*yycdebug_, Symbol); \
109 *yycdebug_ << '\n'; \
110 } \
111 } while (false)
112
113 # define YY_REDUCE_PRINT(Rule) \
114 do { \
115 if (yydebug_) \
116 yy_reduce_print_ (Rule); \
117 } while (false)
118
119 # define YY_STACK_PRINT() \
120 do { \
121 if (yydebug_) \
122 yy_stack_print_ (); \
123 } while (false)
124
125 #else // !PARSER4_DEBUG
126
127 # define YYCDEBUG if (false) std::cerr
128 # define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol)
129 # define YY_REDUCE_PRINT(Rule) static_cast<void> (0)
130 # define YY_STACK_PRINT() static_cast<void> (0)
131
132 #endif // !PARSER4_DEBUG
133
134 #define yyerrok (yyerrstatus_ = 0)
135 #define yyclearin (yyla.clear ())
136
137 #define YYACCEPT goto yyacceptlab
138 #define YYABORT goto yyabortlab
139 #define YYERROR goto yyerrorlab
140 #define YYRECOVERING() (!!yyerrstatus_)
141
142 #line 14 "dhcp4_parser.yy"
143 namespace isc { namespace dhcp {
144 #line 145 "dhcp4_parser.cc"
145
146 /// Build a parser object.
Dhcp4Parser(isc::dhcp::Parser4Context & ctx_yyarg)147 Dhcp4Parser::Dhcp4Parser (isc::dhcp::Parser4Context& ctx_yyarg)
148 #if PARSER4_DEBUG
149 : yydebug_ (false),
150 yycdebug_ (&std::cerr),
151 #else
152 :
153 #endif
154 ctx (ctx_yyarg)
155 {}
156
~Dhcp4Parser()157 Dhcp4Parser::~Dhcp4Parser ()
158 {}
159
~syntax_error()160 Dhcp4Parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW
161 {}
162
163 /*---------.
164 | symbol. |
165 `---------*/
166
167
168
169 // by_state.
by_state()170 Dhcp4Parser::by_state::by_state () YY_NOEXCEPT
171 : state (empty_state)
172 {}
173
by_state(const by_state & that)174 Dhcp4Parser::by_state::by_state (const by_state& that) YY_NOEXCEPT
175 : state (that.state)
176 {}
177
178 void
clear()179 Dhcp4Parser::by_state::clear () YY_NOEXCEPT
180 {
181 state = empty_state;
182 }
183
184 void
move(by_state & that)185 Dhcp4Parser::by_state::move (by_state& that)
186 {
187 state = that.state;
188 that.clear ();
189 }
190
by_state(state_type s)191 Dhcp4Parser::by_state::by_state (state_type s) YY_NOEXCEPT
192 : state (s)
193 {}
194
195 Dhcp4Parser::symbol_kind_type
kind() const196 Dhcp4Parser::by_state::kind () const YY_NOEXCEPT
197 {
198 if (state == empty_state)
199 return symbol_kind::S_YYEMPTY;
200 else
201 return YY_CAST (symbol_kind_type, yystos_[+state]);
202 }
203
stack_symbol_type()204 Dhcp4Parser::stack_symbol_type::stack_symbol_type ()
205 {}
206
stack_symbol_type(YY_RVREF (stack_symbol_type)that)207 Dhcp4Parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
208 : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
209 {
210 switch (that.kind ())
211 {
212 case symbol_kind::S_value: // value
213 case symbol_kind::S_map_value: // map_value
214 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
215 case symbol_kind::S_socket_type: // socket_type
216 case symbol_kind::S_outbound_interface_value: // outbound_interface_value
217 case symbol_kind::S_db_type: // db_type
218 case symbol_kind::S_on_fail_mode: // on_fail_mode
219 case symbol_kind::S_hr_mode: // hr_mode
220 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
221 value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value));
222 break;
223
224 case symbol_kind::S_BOOLEAN: // "boolean"
225 value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
226 break;
227
228 case symbol_kind::S_FLOAT: // "floating point"
229 value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value));
230 break;
231
232 case symbol_kind::S_INTEGER: // "integer"
233 value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value));
234 break;
235
236 case symbol_kind::S_STRING: // "constant string"
237 value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
238 break;
239
240 default:
241 break;
242 }
243
244 #if 201103L <= YY_CPLUSPLUS
245 // that is emptied.
246 that.state = empty_state;
247 #endif
248 }
249
stack_symbol_type(state_type s,YY_MOVE_REF (symbol_type)that)250 Dhcp4Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
251 : super_type (s, YY_MOVE (that.location))
252 {
253 switch (that.kind ())
254 {
255 case symbol_kind::S_value: // value
256 case symbol_kind::S_map_value: // map_value
257 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
258 case symbol_kind::S_socket_type: // socket_type
259 case symbol_kind::S_outbound_interface_value: // outbound_interface_value
260 case symbol_kind::S_db_type: // db_type
261 case symbol_kind::S_on_fail_mode: // on_fail_mode
262 case symbol_kind::S_hr_mode: // hr_mode
263 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
264 value.move< ElementPtr > (YY_MOVE (that.value));
265 break;
266
267 case symbol_kind::S_BOOLEAN: // "boolean"
268 value.move< bool > (YY_MOVE (that.value));
269 break;
270
271 case symbol_kind::S_FLOAT: // "floating point"
272 value.move< double > (YY_MOVE (that.value));
273 break;
274
275 case symbol_kind::S_INTEGER: // "integer"
276 value.move< int64_t > (YY_MOVE (that.value));
277 break;
278
279 case symbol_kind::S_STRING: // "constant string"
280 value.move< std::string > (YY_MOVE (that.value));
281 break;
282
283 default:
284 break;
285 }
286
287 // that is emptied.
288 that.kind_ = symbol_kind::S_YYEMPTY;
289 }
290
291 #if YY_CPLUSPLUS < 201103L
292 Dhcp4Parser::stack_symbol_type&
operator =(const stack_symbol_type & that)293 Dhcp4Parser::stack_symbol_type::operator= (const stack_symbol_type& that)
294 {
295 state = that.state;
296 switch (that.kind ())
297 {
298 case symbol_kind::S_value: // value
299 case symbol_kind::S_map_value: // map_value
300 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
301 case symbol_kind::S_socket_type: // socket_type
302 case symbol_kind::S_outbound_interface_value: // outbound_interface_value
303 case symbol_kind::S_db_type: // db_type
304 case symbol_kind::S_on_fail_mode: // on_fail_mode
305 case symbol_kind::S_hr_mode: // hr_mode
306 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
307 value.copy< ElementPtr > (that.value);
308 break;
309
310 case symbol_kind::S_BOOLEAN: // "boolean"
311 value.copy< bool > (that.value);
312 break;
313
314 case symbol_kind::S_FLOAT: // "floating point"
315 value.copy< double > (that.value);
316 break;
317
318 case symbol_kind::S_INTEGER: // "integer"
319 value.copy< int64_t > (that.value);
320 break;
321
322 case symbol_kind::S_STRING: // "constant string"
323 value.copy< std::string > (that.value);
324 break;
325
326 default:
327 break;
328 }
329
330 location = that.location;
331 return *this;
332 }
333
334 Dhcp4Parser::stack_symbol_type&
operator =(stack_symbol_type & that)335 Dhcp4Parser::stack_symbol_type::operator= (stack_symbol_type& that)
336 {
337 state = that.state;
338 switch (that.kind ())
339 {
340 case symbol_kind::S_value: // value
341 case symbol_kind::S_map_value: // map_value
342 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
343 case symbol_kind::S_socket_type: // socket_type
344 case symbol_kind::S_outbound_interface_value: // outbound_interface_value
345 case symbol_kind::S_db_type: // db_type
346 case symbol_kind::S_on_fail_mode: // on_fail_mode
347 case symbol_kind::S_hr_mode: // hr_mode
348 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
349 value.move< ElementPtr > (that.value);
350 break;
351
352 case symbol_kind::S_BOOLEAN: // "boolean"
353 value.move< bool > (that.value);
354 break;
355
356 case symbol_kind::S_FLOAT: // "floating point"
357 value.move< double > (that.value);
358 break;
359
360 case symbol_kind::S_INTEGER: // "integer"
361 value.move< int64_t > (that.value);
362 break;
363
364 case symbol_kind::S_STRING: // "constant string"
365 value.move< std::string > (that.value);
366 break;
367
368 default:
369 break;
370 }
371
372 location = that.location;
373 // that is emptied.
374 that.state = empty_state;
375 return *this;
376 }
377 #endif
378
379 template <typename Base>
380 void
yy_destroy_(const char * yymsg,basic_symbol<Base> & yysym) const381 Dhcp4Parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
382 {
383 if (yymsg)
384 YY_SYMBOL_PRINT (yymsg, yysym);
385 }
386
387 #if PARSER4_DEBUG
388 template <typename Base>
389 void
yy_print_(std::ostream & yyo,const basic_symbol<Base> & yysym) const390 Dhcp4Parser::yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const
391 {
392 std::ostream& yyoutput = yyo;
393 YY_USE (yyoutput);
394 if (yysym.empty ())
395 yyo << "empty symbol";
396 else
397 {
398 symbol_kind_type yykind = yysym.kind ();
399 yyo << (yykind < YYNTOKENS ? "token" : "nterm")
400 << ' ' << yysym.name () << " ("
401 << yysym.location << ": ";
402 switch (yykind)
403 {
404 case symbol_kind::S_STRING: // "constant string"
405 #line 285 "dhcp4_parser.yy"
406 { yyoutput << yysym.value.template as < std::string > (); }
407 #line 408 "dhcp4_parser.cc"
408 break;
409
410 case symbol_kind::S_INTEGER: // "integer"
411 #line 285 "dhcp4_parser.yy"
412 { yyoutput << yysym.value.template as < int64_t > (); }
413 #line 414 "dhcp4_parser.cc"
414 break;
415
416 case symbol_kind::S_FLOAT: // "floating point"
417 #line 285 "dhcp4_parser.yy"
418 { yyoutput << yysym.value.template as < double > (); }
419 #line 420 "dhcp4_parser.cc"
420 break;
421
422 case symbol_kind::S_BOOLEAN: // "boolean"
423 #line 285 "dhcp4_parser.yy"
424 { yyoutput << yysym.value.template as < bool > (); }
425 #line 426 "dhcp4_parser.cc"
426 break;
427
428 case symbol_kind::S_value: // value
429 #line 285 "dhcp4_parser.yy"
430 { yyoutput << yysym.value.template as < ElementPtr > (); }
431 #line 432 "dhcp4_parser.cc"
432 break;
433
434 case symbol_kind::S_map_value: // map_value
435 #line 285 "dhcp4_parser.yy"
436 { yyoutput << yysym.value.template as < ElementPtr > (); }
437 #line 438 "dhcp4_parser.cc"
438 break;
439
440 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
441 #line 285 "dhcp4_parser.yy"
442 { yyoutput << yysym.value.template as < ElementPtr > (); }
443 #line 444 "dhcp4_parser.cc"
444 break;
445
446 case symbol_kind::S_socket_type: // socket_type
447 #line 285 "dhcp4_parser.yy"
448 { yyoutput << yysym.value.template as < ElementPtr > (); }
449 #line 450 "dhcp4_parser.cc"
450 break;
451
452 case symbol_kind::S_outbound_interface_value: // outbound_interface_value
453 #line 285 "dhcp4_parser.yy"
454 { yyoutput << yysym.value.template as < ElementPtr > (); }
455 #line 456 "dhcp4_parser.cc"
456 break;
457
458 case symbol_kind::S_db_type: // db_type
459 #line 285 "dhcp4_parser.yy"
460 { yyoutput << yysym.value.template as < ElementPtr > (); }
461 #line 462 "dhcp4_parser.cc"
462 break;
463
464 case symbol_kind::S_on_fail_mode: // on_fail_mode
465 #line 285 "dhcp4_parser.yy"
466 { yyoutput << yysym.value.template as < ElementPtr > (); }
467 #line 468 "dhcp4_parser.cc"
468 break;
469
470 case symbol_kind::S_hr_mode: // hr_mode
471 #line 285 "dhcp4_parser.yy"
472 { yyoutput << yysym.value.template as < ElementPtr > (); }
473 #line 474 "dhcp4_parser.cc"
474 break;
475
476 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
477 #line 285 "dhcp4_parser.yy"
478 { yyoutput << yysym.value.template as < ElementPtr > (); }
479 #line 480 "dhcp4_parser.cc"
480 break;
481
482 default:
483 break;
484 }
485 yyo << ')';
486 }
487 }
488 #endif
489
490 void
yypush_(const char * m,YY_MOVE_REF (stack_symbol_type)sym)491 Dhcp4Parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
492 {
493 if (m)
494 YY_SYMBOL_PRINT (m, sym);
495 yystack_.push (YY_MOVE (sym));
496 }
497
498 void
yypush_(const char * m,state_type s,YY_MOVE_REF (symbol_type)sym)499 Dhcp4Parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
500 {
501 #if 201103L <= YY_CPLUSPLUS
502 yypush_ (m, stack_symbol_type (s, std::move (sym)));
503 #else
504 stack_symbol_type ss (s, sym);
505 yypush_ (m, ss);
506 #endif
507 }
508
509 void
yypop_(int n)510 Dhcp4Parser::yypop_ (int n) YY_NOEXCEPT
511 {
512 yystack_.pop (n);
513 }
514
515 #if PARSER4_DEBUG
516 std::ostream&
debug_stream() const517 Dhcp4Parser::debug_stream () const
518 {
519 return *yycdebug_;
520 }
521
522 void
set_debug_stream(std::ostream & o)523 Dhcp4Parser::set_debug_stream (std::ostream& o)
524 {
525 yycdebug_ = &o;
526 }
527
528
529 Dhcp4Parser::debug_level_type
debug_level() const530 Dhcp4Parser::debug_level () const
531 {
532 return yydebug_;
533 }
534
535 void
set_debug_level(debug_level_type l)536 Dhcp4Parser::set_debug_level (debug_level_type l)
537 {
538 yydebug_ = l;
539 }
540 #endif // PARSER4_DEBUG
541
542 Dhcp4Parser::state_type
yy_lr_goto_state_(state_type yystate,int yysym)543 Dhcp4Parser::yy_lr_goto_state_ (state_type yystate, int yysym)
544 {
545 int yyr = yypgoto_[yysym - YYNTOKENS] + yystate;
546 if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
547 return yytable_[yyr];
548 else
549 return yydefgoto_[yysym - YYNTOKENS];
550 }
551
552 bool
yy_pact_value_is_default_(int yyvalue)553 Dhcp4Parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT
554 {
555 return yyvalue == yypact_ninf_;
556 }
557
558 bool
yy_table_value_is_error_(int yyvalue)559 Dhcp4Parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT
560 {
561 return yyvalue == yytable_ninf_;
562 }
563
564 int
operator ()()565 Dhcp4Parser::operator() ()
566 {
567 return parse ();
568 }
569
570 int
parse()571 Dhcp4Parser::parse ()
572 {
573 int yyn;
574 /// Length of the RHS of the rule being reduced.
575 int yylen = 0;
576
577 // Error handling.
578 int yynerrs_ = 0;
579 int yyerrstatus_ = 0;
580
581 /// The lookahead symbol.
582 symbol_type yyla;
583
584 /// The locations where the error started and ended.
585 stack_symbol_type yyerror_range[3];
586
587 /// The return value of parse ().
588 int yyresult;
589
590 #if YY_EXCEPTIONS
591 try
592 #endif // YY_EXCEPTIONS
593 {
594 YYCDEBUG << "Starting parse\n";
595
596
597 /* Initialize the stack. The initial state will be set in
598 yynewstate, since the latter expects the semantical and the
599 location values to have been already stored, initialize these
600 stacks with a primary value. */
601 yystack_.clear ();
602 yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla));
603
604 /*-----------------------------------------------.
605 | yynewstate -- push a new symbol on the stack. |
606 `-----------------------------------------------*/
607 yynewstate:
608 YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n';
609 YY_STACK_PRINT ();
610
611 // Accept?
612 if (yystack_[0].state == yyfinal_)
613 YYACCEPT;
614
615 goto yybackup;
616
617
618 /*-----------.
619 | yybackup. |
620 `-----------*/
621 yybackup:
622 // Try to take a decision without lookahead.
623 yyn = yypact_[+yystack_[0].state];
624 if (yy_pact_value_is_default_ (yyn))
625 goto yydefault;
626
627 // Read a lookahead token.
628 if (yyla.empty ())
629 {
630 YYCDEBUG << "Reading a token\n";
631 #if YY_EXCEPTIONS
632 try
633 #endif // YY_EXCEPTIONS
634 {
635 symbol_type yylookahead (yylex (ctx));
636 yyla.move (yylookahead);
637 }
638 #if YY_EXCEPTIONS
639 catch (const syntax_error& yyexc)
640 {
641 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
642 error (yyexc);
643 goto yyerrlab1;
644 }
645 #endif // YY_EXCEPTIONS
646 }
647 YY_SYMBOL_PRINT ("Next token is", yyla);
648
649 if (yyla.kind () == symbol_kind::S_YYerror)
650 {
651 // The scanner already issued an error message, process directly
652 // to error recovery. But do not keep the error token as
653 // lookahead, it is too special and may lead us to an endless
654 // loop in error recovery. */
655 yyla.kind_ = symbol_kind::S_YYUNDEF;
656 goto yyerrlab1;
657 }
658
659 /* If the proper action on seeing token YYLA.TYPE is to reduce or
660 to detect an error, take that action. */
661 yyn += yyla.kind ();
662 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ())
663 {
664 goto yydefault;
665 }
666
667 // Reduce or error.
668 yyn = yytable_[yyn];
669 if (yyn <= 0)
670 {
671 if (yy_table_value_is_error_ (yyn))
672 goto yyerrlab;
673 yyn = -yyn;
674 goto yyreduce;
675 }
676
677 // Count tokens shifted since error; after three, turn off error status.
678 if (yyerrstatus_)
679 --yyerrstatus_;
680
681 // Shift the lookahead token.
682 yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla));
683 goto yynewstate;
684
685
686 /*-----------------------------------------------------------.
687 | yydefault -- do the default action for the current state. |
688 `-----------------------------------------------------------*/
689 yydefault:
690 yyn = yydefact_[+yystack_[0].state];
691 if (yyn == 0)
692 goto yyerrlab;
693 goto yyreduce;
694
695
696 /*-----------------------------.
697 | yyreduce -- do a reduction. |
698 `-----------------------------*/
699 yyreduce:
700 yylen = yyr2_[yyn];
701 {
702 stack_symbol_type yylhs;
703 yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);
704 /* Variants are always initialized to an empty instance of the
705 correct type. The default '$$ = $1' action is NOT applied
706 when using variants. */
707 switch (yyr1_[yyn])
708 {
709 case symbol_kind::S_value: // value
710 case symbol_kind::S_map_value: // map_value
711 case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
712 case symbol_kind::S_socket_type: // socket_type
713 case symbol_kind::S_outbound_interface_value: // outbound_interface_value
714 case symbol_kind::S_db_type: // db_type
715 case symbol_kind::S_on_fail_mode: // on_fail_mode
716 case symbol_kind::S_hr_mode: // hr_mode
717 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
718 yylhs.value.emplace< ElementPtr > ();
719 break;
720
721 case symbol_kind::S_BOOLEAN: // "boolean"
722 yylhs.value.emplace< bool > ();
723 break;
724
725 case symbol_kind::S_FLOAT: // "floating point"
726 yylhs.value.emplace< double > ();
727 break;
728
729 case symbol_kind::S_INTEGER: // "integer"
730 yylhs.value.emplace< int64_t > ();
731 break;
732
733 case symbol_kind::S_STRING: // "constant string"
734 yylhs.value.emplace< std::string > ();
735 break;
736
737 default:
738 break;
739 }
740
741
742 // Default location.
743 {
744 stack_type::slice range (yystack_, yylen);
745 YYLLOC_DEFAULT (yylhs.location, range, yylen);
746 yyerror_range[1].location = yylhs.location;
747 }
748
749 // Perform the reduction.
750 YY_REDUCE_PRINT (yyn);
751 #if YY_EXCEPTIONS
752 try
753 #endif // YY_EXCEPTIONS
754 {
755 switch (yyn)
756 {
757 case 2: // $@1: %empty
758 #line 294 "dhcp4_parser.yy"
759 { ctx.ctx_ = ctx.NO_KEYWORD; }
760 #line 761 "dhcp4_parser.cc"
761 break;
762
763 case 4: // $@2: %empty
764 #line 295 "dhcp4_parser.yy"
765 { ctx.ctx_ = ctx.CONFIG; }
766 #line 767 "dhcp4_parser.cc"
767 break;
768
769 case 6: // $@3: %empty
770 #line 296 "dhcp4_parser.yy"
771 { ctx.ctx_ = ctx.DHCP4; }
772 #line 773 "dhcp4_parser.cc"
773 break;
774
775 case 8: // $@4: %empty
776 #line 297 "dhcp4_parser.yy"
777 { ctx.ctx_ = ctx.INTERFACES_CONFIG; }
778 #line 779 "dhcp4_parser.cc"
779 break;
780
781 case 10: // $@5: %empty
782 #line 298 "dhcp4_parser.yy"
783 { ctx.ctx_ = ctx.SUBNET4; }
784 #line 785 "dhcp4_parser.cc"
785 break;
786
787 case 12: // $@6: %empty
788 #line 299 "dhcp4_parser.yy"
789 { ctx.ctx_ = ctx.POOLS; }
790 #line 791 "dhcp4_parser.cc"
791 break;
792
793 case 14: // $@7: %empty
794 #line 300 "dhcp4_parser.yy"
795 { ctx.ctx_ = ctx.RESERVATIONS; }
796 #line 797 "dhcp4_parser.cc"
797 break;
798
799 case 16: // $@8: %empty
800 #line 301 "dhcp4_parser.yy"
801 { ctx.ctx_ = ctx.DHCP4; }
802 #line 803 "dhcp4_parser.cc"
803 break;
804
805 case 18: // $@9: %empty
806 #line 302 "dhcp4_parser.yy"
807 { ctx.ctx_ = ctx.OPTION_DEF; }
808 #line 809 "dhcp4_parser.cc"
809 break;
810
811 case 20: // $@10: %empty
812 #line 303 "dhcp4_parser.yy"
813 { ctx.ctx_ = ctx.OPTION_DATA; }
814 #line 815 "dhcp4_parser.cc"
815 break;
816
817 case 22: // $@11: %empty
818 #line 304 "dhcp4_parser.yy"
819 { ctx.ctx_ = ctx.HOOKS_LIBRARIES; }
820 #line 821 "dhcp4_parser.cc"
821 break;
822
823 case 24: // $@12: %empty
824 #line 305 "dhcp4_parser.yy"
825 { ctx.ctx_ = ctx.DHCP_DDNS; }
826 #line 827 "dhcp4_parser.cc"
827 break;
828
829 case 26: // $@13: %empty
830 #line 306 "dhcp4_parser.yy"
831 { ctx.ctx_ = ctx.CONFIG_CONTROL; }
832 #line 833 "dhcp4_parser.cc"
833 break;
834
835 case 28: // value: "integer"
836 #line 314 "dhcp4_parser.yy"
837 { yylhs.value.as < ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); }
838 #line 839 "dhcp4_parser.cc"
839 break;
840
841 case 29: // value: "floating point"
842 #line 315 "dhcp4_parser.yy"
843 { yylhs.value.as < ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); }
844 #line 845 "dhcp4_parser.cc"
845 break;
846
847 case 30: // value: "boolean"
848 #line 316 "dhcp4_parser.yy"
849 { yylhs.value.as < ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); }
850 #line 851 "dhcp4_parser.cc"
851 break;
852
853 case 31: // value: "constant string"
854 #line 317 "dhcp4_parser.yy"
855 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); }
856 #line 857 "dhcp4_parser.cc"
857 break;
858
859 case 32: // value: "null"
860 #line 318 "dhcp4_parser.yy"
861 { yylhs.value.as < ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); }
862 #line 863 "dhcp4_parser.cc"
863 break;
864
865 case 33: // value: map2
866 #line 319 "dhcp4_parser.yy"
867 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
868 #line 869 "dhcp4_parser.cc"
869 break;
870
871 case 34: // value: list_generic
872 #line 320 "dhcp4_parser.yy"
873 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
874 #line 875 "dhcp4_parser.cc"
875 break;
876
877 case 35: // sub_json: value
878 #line 323 "dhcp4_parser.yy"
879 {
880 // Push back the JSON value on the stack
881 ctx.stack_.push_back(yystack_[0].value.as < ElementPtr > ());
882 }
883 #line 884 "dhcp4_parser.cc"
884 break;
885
886 case 36: // $@14: %empty
887 #line 328 "dhcp4_parser.yy"
888 {
889 // This code is executed when we're about to start parsing
890 // the content of the map
891 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
892 ctx.stack_.push_back(m);
893 }
894 #line 895 "dhcp4_parser.cc"
895 break;
896
897 case 37: // map2: "{" $@14 map_content "}"
898 #line 333 "dhcp4_parser.yy"
899 {
900 // map parsing completed. If we ever want to do any wrap up
901 // (maybe some sanity checking), this would be the best place
902 // for it.
903 }
904 #line 905 "dhcp4_parser.cc"
905 break;
906
907 case 38: // map_value: map2
908 #line 339 "dhcp4_parser.yy"
909 { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
910 #line 911 "dhcp4_parser.cc"
911 break;
912
913 case 41: // not_empty_map: "constant string" ":" value
914 #line 346 "dhcp4_parser.yy"
915 {
916 // map containing a single entry
917 ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
918 ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
919 }
920 #line 921 "dhcp4_parser.cc"
921 break;
922
923 case 42: // not_empty_map: not_empty_map "," "constant string" ":" value
924 #line 351 "dhcp4_parser.yy"
925 {
926 // map consisting of a shorter map followed by
927 // comma and string:value
928 ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
929 ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
930 }
931 #line 932 "dhcp4_parser.cc"
932 break;
933
934 case 43: // $@15: %empty
935 #line 359 "dhcp4_parser.yy"
936 {
937 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
938 ctx.stack_.push_back(l);
939 }
940 #line 941 "dhcp4_parser.cc"
941 break;
942
943 case 44: // list_generic: "[" $@15 list_content "]"
944 #line 362 "dhcp4_parser.yy"
945 {
946 // list parsing complete. Put any sanity checking here
947 }
948 #line 949 "dhcp4_parser.cc"
949 break;
950
951 case 47: // not_empty_list: value
952 #line 370 "dhcp4_parser.yy"
953 {
954 // List consisting of a single element.
955 ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
956 }
957 #line 958 "dhcp4_parser.cc"
958 break;
959
960 case 48: // not_empty_list: not_empty_list "," value
961 #line 374 "dhcp4_parser.yy"
962 {
963 // List ending with , and a value.
964 ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
965 }
966 #line 967 "dhcp4_parser.cc"
967 break;
968
969 case 49: // $@16: %empty
970 #line 381 "dhcp4_parser.yy"
971 {
972 // List parsing about to start
973 }
974 #line 975 "dhcp4_parser.cc"
975 break;
976
977 case 50: // list_strings: "[" $@16 list_strings_content "]"
978 #line 383 "dhcp4_parser.yy"
979 {
980 // list parsing complete. Put any sanity checking here
981 //ctx.stack_.pop_back();
982 }
983 #line 984 "dhcp4_parser.cc"
984 break;
985
986 case 53: // not_empty_list_strings: "constant string"
987 #line 392 "dhcp4_parser.yy"
988 {
989 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
990 ctx.stack_.back()->add(s);
991 }
992 #line 993 "dhcp4_parser.cc"
993 break;
994
995 case 54: // not_empty_list_strings: not_empty_list_strings "," "constant string"
996 #line 396 "dhcp4_parser.yy"
997 {
998 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
999 ctx.stack_.back()->add(s);
1000 }
1001 #line 1002 "dhcp4_parser.cc"
1002 break;
1003
1004 case 55: // unknown_map_entry: "constant string" ":"
1005 #line 407 "dhcp4_parser.yy"
1006 {
1007 const std::string& where = ctx.contextName();
1008 const std::string& keyword = yystack_[1].value.as < std::string > ();
1009 error(yystack_[1].location,
1010 "got unexpected keyword \"" + keyword + "\" in " + where + " map.");
1011 }
1012 #line 1013 "dhcp4_parser.cc"
1013 break;
1014
1015 case 56: // $@17: %empty
1016 #line 416 "dhcp4_parser.yy"
1017 {
1018 // This code is executed when we're about to start parsing
1019 // the content of the map
1020 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1021 ctx.stack_.push_back(m);
1022 }
1023 #line 1024 "dhcp4_parser.cc"
1024 break;
1025
1026 case 57: // syntax_map: "{" $@17 global_object "}"
1027 #line 421 "dhcp4_parser.yy"
1028 {
1029 // map parsing completed. If we ever want to do any wrap up
1030 // (maybe some sanity checking), this would be the best place
1031 // for it.
1032
1033 // Dhcp4 is required
1034 ctx.require("Dhcp4", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
1035 }
1036 #line 1037 "dhcp4_parser.cc"
1037 break;
1038
1039 case 58: // $@18: %empty
1040 #line 431 "dhcp4_parser.yy"
1041 {
1042 // This code is executed when we're about to start parsing
1043 // the content of the map
1044 // Prevent against duplicate.
1045 ctx.unique("Dhcp4", ctx.loc2pos(yystack_[0].location));
1046 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1047 ctx.stack_.back()->set("Dhcp4", m);
1048 ctx.stack_.push_back(m);
1049 ctx.enter(ctx.DHCP4);
1050 }
1051 #line 1052 "dhcp4_parser.cc"
1052 break;
1053
1054 case 59: // global_object: "Dhcp4" $@18 ":" "{" global_params "}"
1055 #line 440 "dhcp4_parser.yy"
1056 {
1057 // No global parameter is required
1058 ctx.stack_.pop_back();
1059 ctx.leave();
1060 }
1061 #line 1062 "dhcp4_parser.cc"
1062 break;
1063
1064 case 60: // $@19: %empty
1065 #line 448 "dhcp4_parser.yy"
1066 {
1067 // Parse the Dhcp4 map
1068 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1069 ctx.stack_.push_back(m);
1070 }
1071 #line 1072 "dhcp4_parser.cc"
1072 break;
1073
1074 case 61: // sub_dhcp4: "{" $@19 global_params "}"
1075 #line 452 "dhcp4_parser.yy"
1076 {
1077 // No global parameter is required
1078 // parsing completed
1079 }
1080 #line 1081 "dhcp4_parser.cc"
1081 break;
1082
1083 case 126: // valid_lifetime: "valid-lifetime" ":" "integer"
1084 #line 527 "dhcp4_parser.yy"
1085 {
1086 ctx.unique("valid-lifetime", ctx.loc2pos(yystack_[2].location));
1087 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1088 ctx.stack_.back()->set("valid-lifetime", prf);
1089 }
1090 #line 1091 "dhcp4_parser.cc"
1091 break;
1092
1093 case 127: // min_valid_lifetime: "min-valid-lifetime" ":" "integer"
1094 #line 533 "dhcp4_parser.yy"
1095 {
1096 ctx.unique("min-valid-lifetime", ctx.loc2pos(yystack_[2].location));
1097 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1098 ctx.stack_.back()->set("min-valid-lifetime", prf);
1099 }
1100 #line 1101 "dhcp4_parser.cc"
1101 break;
1102
1103 case 128: // max_valid_lifetime: "max-valid-lifetime" ":" "integer"
1104 #line 539 "dhcp4_parser.yy"
1105 {
1106 ctx.unique("max-valid-lifetime", ctx.loc2pos(yystack_[2].location));
1107 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1108 ctx.stack_.back()->set("max-valid-lifetime", prf);
1109 }
1110 #line 1111 "dhcp4_parser.cc"
1111 break;
1112
1113 case 129: // renew_timer: "renew-timer" ":" "integer"
1114 #line 545 "dhcp4_parser.yy"
1115 {
1116 ctx.unique("renew-timer", ctx.loc2pos(yystack_[2].location));
1117 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1118 ctx.stack_.back()->set("renew-timer", prf);
1119 }
1120 #line 1121 "dhcp4_parser.cc"
1121 break;
1122
1123 case 130: // rebind_timer: "rebind-timer" ":" "integer"
1124 #line 551 "dhcp4_parser.yy"
1125 {
1126 ctx.unique("rebind-timer", ctx.loc2pos(yystack_[2].location));
1127 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1128 ctx.stack_.back()->set("rebind-timer", prf);
1129 }
1130 #line 1131 "dhcp4_parser.cc"
1131 break;
1132
1133 case 131: // calculate_tee_times: "calculate-tee-times" ":" "boolean"
1134 #line 557 "dhcp4_parser.yy"
1135 {
1136 ctx.unique("calculate-tee-times", ctx.loc2pos(yystack_[2].location));
1137 ElementPtr ctt(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1138 ctx.stack_.back()->set("calculate-tee-times", ctt);
1139 }
1140 #line 1141 "dhcp4_parser.cc"
1141 break;
1142
1143 case 132: // t1_percent: "t1-percent" ":" "floating point"
1144 #line 563 "dhcp4_parser.yy"
1145 {
1146 ctx.unique("t1-percent", ctx.loc2pos(yystack_[2].location));
1147 ElementPtr t1(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
1148 ctx.stack_.back()->set("t1-percent", t1);
1149 }
1150 #line 1151 "dhcp4_parser.cc"
1151 break;
1152
1153 case 133: // t2_percent: "t2-percent" ":" "floating point"
1154 #line 569 "dhcp4_parser.yy"
1155 {
1156 ctx.unique("t2-percent", ctx.loc2pos(yystack_[2].location));
1157 ElementPtr t2(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
1158 ctx.stack_.back()->set("t2-percent", t2);
1159 }
1160 #line 1161 "dhcp4_parser.cc"
1161 break;
1162
1163 case 134: // cache_threshold: "cache-threshold" ":" "floating point"
1164 #line 575 "dhcp4_parser.yy"
1165 {
1166 ctx.unique("cache-threshold", ctx.loc2pos(yystack_[2].location));
1167 ElementPtr ct(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
1168 ctx.stack_.back()->set("cache-threshold", ct);
1169 }
1170 #line 1171 "dhcp4_parser.cc"
1171 break;
1172
1173 case 135: // cache_max_age: "cache-max-age" ":" "integer"
1174 #line 581 "dhcp4_parser.yy"
1175 {
1176 ctx.unique("cache-max-age", ctx.loc2pos(yystack_[2].location));
1177 ElementPtr cm(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1178 ctx.stack_.back()->set("cache-max-age", cm);
1179 }
1180 #line 1181 "dhcp4_parser.cc"
1181 break;
1182
1183 case 136: // decline_probation_period: "decline-probation-period" ":" "integer"
1184 #line 587 "dhcp4_parser.yy"
1185 {
1186 ctx.unique("decline-probation-period", ctx.loc2pos(yystack_[2].location));
1187 ElementPtr dpp(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1188 ctx.stack_.back()->set("decline-probation-period", dpp);
1189 }
1190 #line 1191 "dhcp4_parser.cc"
1191 break;
1192
1193 case 137: // $@20: %empty
1194 #line 593 "dhcp4_parser.yy"
1195 {
1196 ctx.unique("server-tag", ctx.loc2pos(yystack_[0].location));
1197 ctx.enter(ctx.NO_KEYWORD);
1198 }
1199 #line 1200 "dhcp4_parser.cc"
1200 break;
1201
1202 case 138: // server_tag: "server-tag" $@20 ":" "constant string"
1203 #line 596 "dhcp4_parser.yy"
1204 {
1205 ElementPtr stag(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1206 ctx.stack_.back()->set("server-tag", stag);
1207 ctx.leave();
1208 }
1209 #line 1210 "dhcp4_parser.cc"
1210 break;
1211
1212 case 139: // parked_packet_limit: "parked-packet-limit" ":" "integer"
1213 #line 602 "dhcp4_parser.yy"
1214 {
1215 ctx.unique("parked-packet-limit", ctx.loc2pos(yystack_[2].location));
1216 ElementPtr ppl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1217 ctx.stack_.back()->set("parked-packet-limit", ppl);
1218 }
1219 #line 1220 "dhcp4_parser.cc"
1220 break;
1221
1222 case 140: // echo_client_id: "echo-client-id" ":" "boolean"
1223 #line 608 "dhcp4_parser.yy"
1224 {
1225 ctx.unique("echo-client-id", ctx.loc2pos(yystack_[2].location));
1226 ElementPtr echo(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1227 ctx.stack_.back()->set("echo-client-id", echo);
1228 }
1229 #line 1230 "dhcp4_parser.cc"
1230 break;
1231
1232 case 141: // match_client_id: "match-client-id" ":" "boolean"
1233 #line 614 "dhcp4_parser.yy"
1234 {
1235 ctx.unique("match-client-id", ctx.loc2pos(yystack_[2].location));
1236 ElementPtr match(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1237 ctx.stack_.back()->set("match-client-id", match);
1238 }
1239 #line 1240 "dhcp4_parser.cc"
1240 break;
1241
1242 case 142: // authoritative: "authoritative" ":" "boolean"
1243 #line 620 "dhcp4_parser.yy"
1244 {
1245 ctx.unique("authoritative", ctx.loc2pos(yystack_[2].location));
1246 ElementPtr prf(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1247 ctx.stack_.back()->set("authoritative", prf);
1248 }
1249 #line 1250 "dhcp4_parser.cc"
1250 break;
1251
1252 case 143: // ddns_send_updates: "ddns-send-updates" ":" "boolean"
1253 #line 626 "dhcp4_parser.yy"
1254 {
1255 ctx.unique("ddns-send-updates", ctx.loc2pos(yystack_[2].location));
1256 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1257 ctx.stack_.back()->set("ddns-send-updates", b);
1258 }
1259 #line 1260 "dhcp4_parser.cc"
1260 break;
1261
1262 case 144: // ddns_override_no_update: "ddns-override-no-update" ":" "boolean"
1263 #line 632 "dhcp4_parser.yy"
1264 {
1265 ctx.unique("ddns-override-no-update", ctx.loc2pos(yystack_[2].location));
1266 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1267 ctx.stack_.back()->set("ddns-override-no-update", b);
1268 }
1269 #line 1270 "dhcp4_parser.cc"
1270 break;
1271
1272 case 145: // ddns_override_client_update: "ddns-override-client-update" ":" "boolean"
1273 #line 638 "dhcp4_parser.yy"
1274 {
1275 ctx.unique("ddns-override-client-update", ctx.loc2pos(yystack_[2].location));
1276 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1277 ctx.stack_.back()->set("ddns-override-client-update", b);
1278 }
1279 #line 1280 "dhcp4_parser.cc"
1280 break;
1281
1282 case 146: // $@21: %empty
1283 #line 644 "dhcp4_parser.yy"
1284 {
1285 ctx.enter(ctx.REPLACE_CLIENT_NAME);
1286 ctx.unique("ddns-replace-client-name", ctx.loc2pos(yystack_[0].location));
1287 }
1288 #line 1289 "dhcp4_parser.cc"
1289 break;
1290
1291 case 147: // ddns_replace_client_name: "ddns-replace-client-name" $@21 ":" ddns_replace_client_name_value
1292 #line 647 "dhcp4_parser.yy"
1293 {
1294 ctx.stack_.back()->set("ddns-replace-client-name", yystack_[0].value.as < ElementPtr > ());
1295 ctx.leave();
1296 }
1297 #line 1298 "dhcp4_parser.cc"
1298 break;
1299
1300 case 148: // ddns_replace_client_name_value: "when-present"
1301 #line 653 "dhcp4_parser.yy"
1302 {
1303 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-present", ctx.loc2pos(yystack_[0].location)));
1304 }
1305 #line 1306 "dhcp4_parser.cc"
1306 break;
1307
1308 case 149: // ddns_replace_client_name_value: "never"
1309 #line 656 "dhcp4_parser.yy"
1310 {
1311 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("never", ctx.loc2pos(yystack_[0].location)));
1312 }
1313 #line 1314 "dhcp4_parser.cc"
1314 break;
1315
1316 case 150: // ddns_replace_client_name_value: "always"
1317 #line 659 "dhcp4_parser.yy"
1318 {
1319 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("always", ctx.loc2pos(yystack_[0].location)));
1320 }
1321 #line 1322 "dhcp4_parser.cc"
1322 break;
1323
1324 case 151: // ddns_replace_client_name_value: "when-not-present"
1325 #line 662 "dhcp4_parser.yy"
1326 {
1327 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-not-present", ctx.loc2pos(yystack_[0].location)));
1328 }
1329 #line 1330 "dhcp4_parser.cc"
1330 break;
1331
1332 case 152: // ddns_replace_client_name_value: "boolean"
1333 #line 665 "dhcp4_parser.yy"
1334 {
1335 error(yystack_[0].location, "boolean values for the replace-client-name are "
1336 "no longer supported");
1337 }
1338 #line 1339 "dhcp4_parser.cc"
1339 break;
1340
1341 case 153: // $@22: %empty
1342 #line 671 "dhcp4_parser.yy"
1343 {
1344 ctx.unique("ddns-generated-prefix", ctx.loc2pos(yystack_[0].location));
1345 ctx.enter(ctx.NO_KEYWORD);
1346 }
1347 #line 1348 "dhcp4_parser.cc"
1348 break;
1349
1350 case 154: // ddns_generated_prefix: "ddns-generated-prefix" $@22 ":" "constant string"
1351 #line 674 "dhcp4_parser.yy"
1352 {
1353 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1354 ctx.stack_.back()->set("ddns-generated-prefix", s);
1355 ctx.leave();
1356 }
1357 #line 1358 "dhcp4_parser.cc"
1358 break;
1359
1360 case 155: // $@23: %empty
1361 #line 680 "dhcp4_parser.yy"
1362 {
1363 ctx.unique("ddns-qualifying-suffix", ctx.loc2pos(yystack_[0].location));
1364 ctx.enter(ctx.NO_KEYWORD);
1365 }
1366 #line 1367 "dhcp4_parser.cc"
1367 break;
1368
1369 case 156: // ddns_qualifying_suffix: "ddns-qualifying-suffix" $@23 ":" "constant string"
1370 #line 683 "dhcp4_parser.yy"
1371 {
1372 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1373 ctx.stack_.back()->set("ddns-qualifying-suffix", s);
1374 ctx.leave();
1375 }
1376 #line 1377 "dhcp4_parser.cc"
1377 break;
1378
1379 case 157: // ddns_update_on_renew: "ddns-update-on-renew" ":" "boolean"
1380 #line 689 "dhcp4_parser.yy"
1381 {
1382 ctx.unique("ddns-update-on-renew", ctx.loc2pos(yystack_[2].location));
1383 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1384 ctx.stack_.back()->set("ddns-update-on-renew", b);
1385 }
1386 #line 1387 "dhcp4_parser.cc"
1387 break;
1388
1389 case 158: // ddns_use_conflict_resolution: "ddns-use-conflict-resolution" ":" "boolean"
1390 #line 695 "dhcp4_parser.yy"
1391 {
1392 ctx.unique("ddns-use-conflict-resolution", ctx.loc2pos(yystack_[2].location));
1393 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1394 ctx.stack_.back()->set("ddns-use-conflict-resolution", b);
1395 }
1396 #line 1397 "dhcp4_parser.cc"
1397 break;
1398
1399 case 159: // $@24: %empty
1400 #line 701 "dhcp4_parser.yy"
1401 {
1402 ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location));
1403 ctx.enter(ctx.NO_KEYWORD);
1404 }
1405 #line 1406 "dhcp4_parser.cc"
1406 break;
1407
1408 case 160: // hostname_char_set: "hostname-char-set" $@24 ":" "constant string"
1409 #line 704 "dhcp4_parser.yy"
1410 {
1411 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1412 ctx.stack_.back()->set("hostname-char-set", s);
1413 ctx.leave();
1414 }
1415 #line 1416 "dhcp4_parser.cc"
1416 break;
1417
1418 case 161: // $@25: %empty
1419 #line 710 "dhcp4_parser.yy"
1420 {
1421 ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location));
1422 ctx.enter(ctx.NO_KEYWORD);
1423 }
1424 #line 1425 "dhcp4_parser.cc"
1425 break;
1426
1427 case 162: // hostname_char_replacement: "hostname-char-replacement" $@25 ":" "constant string"
1428 #line 713 "dhcp4_parser.yy"
1429 {
1430 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1431 ctx.stack_.back()->set("hostname-char-replacement", s);
1432 ctx.leave();
1433 }
1434 #line 1435 "dhcp4_parser.cc"
1435 break;
1436
1437 case 163: // store_extended_info: "store-extended-info" ":" "boolean"
1438 #line 719 "dhcp4_parser.yy"
1439 {
1440 ctx.unique("store-extended-info", ctx.loc2pos(yystack_[2].location));
1441 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1442 ctx.stack_.back()->set("store-extended-info", b);
1443 }
1444 #line 1445 "dhcp4_parser.cc"
1445 break;
1446
1447 case 164: // statistic_default_sample_count: "statistic-default-sample-count" ":" "integer"
1448 #line 725 "dhcp4_parser.yy"
1449 {
1450 ctx.unique("statistic-default-sample-count", ctx.loc2pos(yystack_[2].location));
1451 ElementPtr count(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1452 ctx.stack_.back()->set("statistic-default-sample-count", count);
1453 }
1454 #line 1455 "dhcp4_parser.cc"
1455 break;
1456
1457 case 165: // statistic_default_sample_age: "statistic-default-sample-age" ":" "integer"
1458 #line 731 "dhcp4_parser.yy"
1459 {
1460 ctx.unique("statistic-default-sample-age", ctx.loc2pos(yystack_[2].location));
1461 ElementPtr age(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1462 ctx.stack_.back()->set("statistic-default-sample-age", age);
1463 }
1464 #line 1465 "dhcp4_parser.cc"
1465 break;
1466
1467 case 166: // ip_reservations_unique: "ip-reservations-unique" ":" "boolean"
1468 #line 737 "dhcp4_parser.yy"
1469 {
1470 ctx.unique("ip-reservations-unique", ctx.loc2pos(yystack_[2].location));
1471 ElementPtr unique(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1472 ctx.stack_.back()->set("ip-reservations-unique", unique);
1473 }
1474 #line 1475 "dhcp4_parser.cc"
1475 break;
1476
1477 case 167: // $@26: %empty
1478 #line 743 "dhcp4_parser.yy"
1479 {
1480 ctx.unique("interfaces-config", ctx.loc2pos(yystack_[0].location));
1481 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
1482 ctx.stack_.back()->set("interfaces-config", i);
1483 ctx.stack_.push_back(i);
1484 ctx.enter(ctx.INTERFACES_CONFIG);
1485 }
1486 #line 1487 "dhcp4_parser.cc"
1487 break;
1488
1489 case 168: // interfaces_config: "interfaces-config" $@26 ":" "{" interfaces_config_params "}"
1490 #line 749 "dhcp4_parser.yy"
1491 {
1492 // No interfaces config param is required
1493 ctx.stack_.pop_back();
1494 ctx.leave();
1495 }
1496 #line 1497 "dhcp4_parser.cc"
1497 break;
1498
1499 case 178: // $@27: %empty
1500 #line 768 "dhcp4_parser.yy"
1501 {
1502 // Parse the interfaces-config map
1503 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1504 ctx.stack_.push_back(m);
1505 }
1506 #line 1507 "dhcp4_parser.cc"
1507 break;
1508
1509 case 179: // sub_interfaces4: "{" $@27 interfaces_config_params "}"
1510 #line 772 "dhcp4_parser.yy"
1511 {
1512 // No interfaces config param is required
1513 // parsing completed
1514 }
1515 #line 1516 "dhcp4_parser.cc"
1516 break;
1517
1518 case 180: // $@28: %empty
1519 #line 777 "dhcp4_parser.yy"
1520 {
1521 ctx.unique("interfaces", ctx.loc2pos(yystack_[0].location));
1522 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1523 ctx.stack_.back()->set("interfaces", l);
1524 ctx.stack_.push_back(l);
1525 ctx.enter(ctx.NO_KEYWORD);
1526 }
1527 #line 1528 "dhcp4_parser.cc"
1528 break;
1529
1530 case 181: // interfaces_list: "interfaces" $@28 ":" list_strings
1531 #line 783 "dhcp4_parser.yy"
1532 {
1533 ctx.stack_.pop_back();
1534 ctx.leave();
1535 }
1536 #line 1537 "dhcp4_parser.cc"
1537 break;
1538
1539 case 182: // $@29: %empty
1540 #line 788 "dhcp4_parser.yy"
1541 {
1542 ctx.unique("dhcp-socket-type", ctx.loc2pos(yystack_[0].location));
1543 ctx.enter(ctx.DHCP_SOCKET_TYPE);
1544 }
1545 #line 1546 "dhcp4_parser.cc"
1546 break;
1547
1548 case 183: // dhcp_socket_type: "dhcp-socket-type" $@29 ":" socket_type
1549 #line 791 "dhcp4_parser.yy"
1550 {
1551 ctx.stack_.back()->set("dhcp-socket-type", yystack_[0].value.as < ElementPtr > ());
1552 ctx.leave();
1553 }
1554 #line 1555 "dhcp4_parser.cc"
1555 break;
1556
1557 case 184: // socket_type: "raw"
1558 #line 796 "dhcp4_parser.yy"
1559 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("raw", ctx.loc2pos(yystack_[0].location))); }
1560 #line 1561 "dhcp4_parser.cc"
1561 break;
1562
1563 case 185: // socket_type: "udp"
1564 #line 797 "dhcp4_parser.yy"
1565 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("udp", ctx.loc2pos(yystack_[0].location))); }
1566 #line 1567 "dhcp4_parser.cc"
1567 break;
1568
1569 case 186: // $@30: %empty
1570 #line 800 "dhcp4_parser.yy"
1571 {
1572 ctx.unique("outbound-interface", ctx.loc2pos(yystack_[0].location));
1573 ctx.enter(ctx.OUTBOUND_INTERFACE);
1574 }
1575 #line 1576 "dhcp4_parser.cc"
1576 break;
1577
1578 case 187: // outbound_interface: "outbound-interface" $@30 ":" outbound_interface_value
1579 #line 803 "dhcp4_parser.yy"
1580 {
1581 ctx.stack_.back()->set("outbound-interface", yystack_[0].value.as < ElementPtr > ());
1582 ctx.leave();
1583 }
1584 #line 1585 "dhcp4_parser.cc"
1585 break;
1586
1587 case 188: // outbound_interface_value: "same-as-inbound"
1588 #line 808 "dhcp4_parser.yy"
1589 {
1590 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("same-as-inbound", ctx.loc2pos(yystack_[0].location)));
1591 }
1592 #line 1593 "dhcp4_parser.cc"
1593 break;
1594
1595 case 189: // outbound_interface_value: "use-routing"
1596 #line 810 "dhcp4_parser.yy"
1597 {
1598 yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("use-routing", ctx.loc2pos(yystack_[0].location)));
1599 }
1600 #line 1601 "dhcp4_parser.cc"
1601 break;
1602
1603 case 190: // re_detect: "re-detect" ":" "boolean"
1604 #line 814 "dhcp4_parser.yy"
1605 {
1606 ctx.unique("re-detect", ctx.loc2pos(yystack_[2].location));
1607 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1608 ctx.stack_.back()->set("re-detect", b);
1609 }
1610 #line 1611 "dhcp4_parser.cc"
1611 break;
1612
1613 case 191: // $@31: %empty
1614 #line 821 "dhcp4_parser.yy"
1615 {
1616 ctx.unique("lease-database", ctx.loc2pos(yystack_[0].location));
1617 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
1618 ctx.stack_.back()->set("lease-database", i);
1619 ctx.stack_.push_back(i);
1620 ctx.enter(ctx.LEASE_DATABASE);
1621 }
1622 #line 1623 "dhcp4_parser.cc"
1623 break;
1624
1625 case 192: // lease_database: "lease-database" $@31 ":" "{" database_map_params "}"
1626 #line 827 "dhcp4_parser.yy"
1627 {
1628 // The type parameter is required
1629 ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
1630 ctx.stack_.pop_back();
1631 ctx.leave();
1632 }
1633 #line 1634 "dhcp4_parser.cc"
1634 break;
1635
1636 case 193: // $@32: %empty
1637 #line 834 "dhcp4_parser.yy"
1638 {
1639 ctx.unique("sanity-checks", ctx.loc2pos(yystack_[0].location));
1640 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1641 ctx.stack_.back()->set("sanity-checks", m);
1642 ctx.stack_.push_back(m);
1643 ctx.enter(ctx.SANITY_CHECKS);
1644 }
1645 #line 1646 "dhcp4_parser.cc"
1646 break;
1647
1648 case 194: // sanity_checks: "sanity-checks" $@32 ":" "{" sanity_checks_params "}"
1649 #line 840 "dhcp4_parser.yy"
1650 {
1651 ctx.stack_.pop_back();
1652 ctx.leave();
1653 }
1654 #line 1655 "dhcp4_parser.cc"
1655 break;
1656
1657 case 198: // $@33: %empty
1658 #line 850 "dhcp4_parser.yy"
1659 {
1660 ctx.unique("lease-checks", ctx.loc2pos(yystack_[0].location));
1661 ctx.enter(ctx.NO_KEYWORD);
1662 }
1663 #line 1664 "dhcp4_parser.cc"
1664 break;
1665
1666 case 199: // lease_checks: "lease-checks" $@33 ":" "constant string"
1667 #line 853 "dhcp4_parser.yy"
1668 {
1669
1670 if ( (string(yystack_[0].value.as < std::string > ()) == "none") ||
1671 (string(yystack_[0].value.as < std::string > ()) == "warn") ||
1672 (string(yystack_[0].value.as < std::string > ()) == "fix") ||
1673 (string(yystack_[0].value.as < std::string > ()) == "fix-del") ||
1674 (string(yystack_[0].value.as < std::string > ()) == "del")) {
1675 ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1676 ctx.stack_.back()->set("lease-checks", user);
1677 ctx.leave();
1678 } else {
1679 error(yystack_[0].location, "Unsupported 'lease-checks value: " + string(yystack_[0].value.as < std::string > ()) +
1680 ", supported values are: none, warn, fix, fix-del, del");
1681 }
1682 }
1683 #line 1684 "dhcp4_parser.cc"
1684 break;
1685
1686 case 200: // $@34: %empty
1687 #line 869 "dhcp4_parser.yy"
1688 {
1689 ctx.unique("hosts-database", ctx.loc2pos(yystack_[0].location));
1690 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
1691 ctx.stack_.back()->set("hosts-database", i);
1692 ctx.stack_.push_back(i);
1693 ctx.enter(ctx.HOSTS_DATABASE);
1694 }
1695 #line 1696 "dhcp4_parser.cc"
1696 break;
1697
1698 case 201: // hosts_database: "hosts-database" $@34 ":" "{" database_map_params "}"
1699 #line 875 "dhcp4_parser.yy"
1700 {
1701 // The type parameter is required
1702 ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
1703 ctx.stack_.pop_back();
1704 ctx.leave();
1705 }
1706 #line 1707 "dhcp4_parser.cc"
1707 break;
1708
1709 case 202: // $@35: %empty
1710 #line 882 "dhcp4_parser.yy"
1711 {
1712 ctx.unique("hosts-databases", ctx.loc2pos(yystack_[0].location));
1713 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
1714 ctx.stack_.back()->set("hosts-databases", l);
1715 ctx.stack_.push_back(l);
1716 ctx.enter(ctx.HOSTS_DATABASE);
1717 }
1718 #line 1719 "dhcp4_parser.cc"
1719 break;
1720
1721 case 203: // hosts_databases: "hosts-databases" $@35 ":" "[" database_list "]"
1722 #line 888 "dhcp4_parser.yy"
1723 {
1724 ctx.stack_.pop_back();
1725 ctx.leave();
1726 }
1727 #line 1728 "dhcp4_parser.cc"
1728 break;
1729
1730 case 208: // $@36: %empty
1731 #line 901 "dhcp4_parser.yy"
1732 {
1733 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
1734 ctx.stack_.back()->add(m);
1735 ctx.stack_.push_back(m);
1736 }
1737 #line 1738 "dhcp4_parser.cc"
1738 break;
1739
1740 case 209: // database: "{" $@36 database_map_params "}"
1741 #line 905 "dhcp4_parser.yy"
1742 {
1743 // The type parameter is required
1744 ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
1745 ctx.stack_.pop_back();
1746 }
1747 #line 1748 "dhcp4_parser.cc"
1748 break;
1749
1750 case 234: // $@37: %empty
1751 #line 939 "dhcp4_parser.yy"
1752 {
1753 ctx.unique("type", ctx.loc2pos(yystack_[0].location));
1754 ctx.enter(ctx.DATABASE_TYPE);
1755 }
1756 #line 1757 "dhcp4_parser.cc"
1757 break;
1758
1759 case 235: // database_type: "type" $@37 ":" db_type
1760 #line 942 "dhcp4_parser.yy"
1761 {
1762 ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ());
1763 ctx.leave();
1764 }
1765 #line 1766 "dhcp4_parser.cc"
1766 break;
1767
1768 case 236: // db_type: "memfile"
1769 #line 947 "dhcp4_parser.yy"
1770 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("memfile", ctx.loc2pos(yystack_[0].location))); }
1771 #line 1772 "dhcp4_parser.cc"
1772 break;
1773
1774 case 237: // db_type: "mysql"
1775 #line 948 "dhcp4_parser.yy"
1776 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("mysql", ctx.loc2pos(yystack_[0].location))); }
1777 #line 1778 "dhcp4_parser.cc"
1778 break;
1779
1780 case 238: // db_type: "postgresql"
1781 #line 949 "dhcp4_parser.yy"
1782 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("postgresql", ctx.loc2pos(yystack_[0].location))); }
1783 #line 1784 "dhcp4_parser.cc"
1784 break;
1785
1786 case 239: // db_type: "cql"
1787 #line 950 "dhcp4_parser.yy"
1788 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("cql", ctx.loc2pos(yystack_[0].location))); }
1789 #line 1790 "dhcp4_parser.cc"
1790 break;
1791
1792 case 240: // $@38: %empty
1793 #line 953 "dhcp4_parser.yy"
1794 {
1795 ctx.unique("user", ctx.loc2pos(yystack_[0].location));
1796 ctx.enter(ctx.NO_KEYWORD);
1797 }
1798 #line 1799 "dhcp4_parser.cc"
1799 break;
1800
1801 case 241: // user: "user" $@38 ":" "constant string"
1802 #line 956 "dhcp4_parser.yy"
1803 {
1804 ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1805 ctx.stack_.back()->set("user", user);
1806 ctx.leave();
1807 }
1808 #line 1809 "dhcp4_parser.cc"
1809 break;
1810
1811 case 242: // $@39: %empty
1812 #line 962 "dhcp4_parser.yy"
1813 {
1814 ctx.unique("password", ctx.loc2pos(yystack_[0].location));
1815 ctx.enter(ctx.NO_KEYWORD);
1816 }
1817 #line 1818 "dhcp4_parser.cc"
1818 break;
1819
1820 case 243: // password: "password" $@39 ":" "constant string"
1821 #line 965 "dhcp4_parser.yy"
1822 {
1823 ElementPtr pwd(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1824 ctx.stack_.back()->set("password", pwd);
1825 ctx.leave();
1826 }
1827 #line 1828 "dhcp4_parser.cc"
1828 break;
1829
1830 case 244: // $@40: %empty
1831 #line 971 "dhcp4_parser.yy"
1832 {
1833 ctx.unique("host", ctx.loc2pos(yystack_[0].location));
1834 ctx.enter(ctx.NO_KEYWORD);
1835 }
1836 #line 1837 "dhcp4_parser.cc"
1837 break;
1838
1839 case 245: // host: "host" $@40 ":" "constant string"
1840 #line 974 "dhcp4_parser.yy"
1841 {
1842 ElementPtr h(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1843 ctx.stack_.back()->set("host", h);
1844 ctx.leave();
1845 }
1846 #line 1847 "dhcp4_parser.cc"
1847 break;
1848
1849 case 246: // port: "port" ":" "integer"
1850 #line 980 "dhcp4_parser.yy"
1851 {
1852 ctx.unique("port", ctx.loc2pos(yystack_[2].location));
1853 ElementPtr p(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1854 ctx.stack_.back()->set("port", p);
1855 }
1856 #line 1857 "dhcp4_parser.cc"
1857 break;
1858
1859 case 247: // $@41: %empty
1860 #line 986 "dhcp4_parser.yy"
1861 {
1862 ctx.unique("name", ctx.loc2pos(yystack_[0].location));
1863 ctx.enter(ctx.NO_KEYWORD);
1864 }
1865 #line 1866 "dhcp4_parser.cc"
1866 break;
1867
1868 case 248: // name: "name" $@41 ":" "constant string"
1869 #line 989 "dhcp4_parser.yy"
1870 {
1871 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1872 ctx.stack_.back()->set("name", name);
1873 ctx.leave();
1874 }
1875 #line 1876 "dhcp4_parser.cc"
1876 break;
1877
1878 case 249: // persist: "persist" ":" "boolean"
1879 #line 995 "dhcp4_parser.yy"
1880 {
1881 ctx.unique("persist", ctx.loc2pos(yystack_[2].location));
1882 ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1883 ctx.stack_.back()->set("persist", n);
1884 }
1885 #line 1886 "dhcp4_parser.cc"
1886 break;
1887
1888 case 250: // lfc_interval: "lfc-interval" ":" "integer"
1889 #line 1001 "dhcp4_parser.yy"
1890 {
1891 ctx.unique("lfc-interval", ctx.loc2pos(yystack_[2].location));
1892 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1893 ctx.stack_.back()->set("lfc-interval", n);
1894 }
1895 #line 1896 "dhcp4_parser.cc"
1896 break;
1897
1898 case 251: // readonly: "readonly" ":" "boolean"
1899 #line 1007 "dhcp4_parser.yy"
1900 {
1901 ctx.unique("readonly", ctx.loc2pos(yystack_[2].location));
1902 ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1903 ctx.stack_.back()->set("readonly", n);
1904 }
1905 #line 1906 "dhcp4_parser.cc"
1906 break;
1907
1908 case 252: // connect_timeout: "connect-timeout" ":" "integer"
1909 #line 1013 "dhcp4_parser.yy"
1910 {
1911 ctx.unique("connect-timeout", ctx.loc2pos(yystack_[2].location));
1912 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1913 ctx.stack_.back()->set("connect-timeout", n);
1914 }
1915 #line 1916 "dhcp4_parser.cc"
1916 break;
1917
1918 case 253: // request_timeout: "request-timeout" ":" "integer"
1919 #line 1019 "dhcp4_parser.yy"
1920 {
1921 ctx.unique("request-timeout", ctx.loc2pos(yystack_[2].location));
1922 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1923 ctx.stack_.back()->set("request-timeout", n);
1924 }
1925 #line 1926 "dhcp4_parser.cc"
1926 break;
1927
1928 case 254: // tcp_keepalive: "tcp-keepalive" ":" "integer"
1929 #line 1025 "dhcp4_parser.yy"
1930 {
1931 ctx.unique("tcp-keepalive", ctx.loc2pos(yystack_[2].location));
1932 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
1933 ctx.stack_.back()->set("tcp-keepalive", n);
1934 }
1935 #line 1936 "dhcp4_parser.cc"
1936 break;
1937
1938 case 255: // tcp_nodelay: "tcp-nodelay" ":" "boolean"
1939 #line 1031 "dhcp4_parser.yy"
1940 {
1941 ctx.unique("tcp-nodelay", ctx.loc2pos(yystack_[2].location));
1942 ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
1943 ctx.stack_.back()->set("tcp-nodelay", n);
1944 }
1945 #line 1946 "dhcp4_parser.cc"
1946 break;
1947
1948 case 256: // $@42: %empty
1949 #line 1037 "dhcp4_parser.yy"
1950 {
1951 ctx.unique("contact-points", ctx.loc2pos(yystack_[0].location));
1952 ctx.enter(ctx.NO_KEYWORD);
1953 }
1954 #line 1955 "dhcp4_parser.cc"
1955 break;
1956
1957 case 257: // contact_points: "contact-points" $@42 ":" "constant string"
1958 #line 1040 "dhcp4_parser.yy"
1959 {
1960 ElementPtr cp(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1961 ctx.stack_.back()->set("contact-points", cp);
1962 ctx.leave();
1963 }
1964 #line 1965 "dhcp4_parser.cc"
1965 break;
1966
1967 case 258: // $@43: %empty
1968 #line 1046 "dhcp4_parser.yy"
1969 {
1970 ctx.unique("keyspace", ctx.loc2pos(yystack_[0].location));
1971 ctx.enter(ctx.NO_KEYWORD);
1972 }
1973 #line 1974 "dhcp4_parser.cc"
1974 break;
1975
1976 case 259: // keyspace: "keyspace" $@43 ":" "constant string"
1977 #line 1049 "dhcp4_parser.yy"
1978 {
1979 ElementPtr ks(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1980 ctx.stack_.back()->set("keyspace", ks);
1981 ctx.leave();
1982 }
1983 #line 1984 "dhcp4_parser.cc"
1984 break;
1985
1986 case 260: // $@44: %empty
1987 #line 1055 "dhcp4_parser.yy"
1988 {
1989 ctx.unique("consistency", ctx.loc2pos(yystack_[0].location));
1990 ctx.enter(ctx.NO_KEYWORD);
1991 }
1992 #line 1993 "dhcp4_parser.cc"
1993 break;
1994
1995 case 261: // consistency: "consistency" $@44 ":" "constant string"
1996 #line 1058 "dhcp4_parser.yy"
1997 {
1998 ElementPtr c(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
1999 ctx.stack_.back()->set("consistency", c);
2000 ctx.leave();
2001 }
2002 #line 2003 "dhcp4_parser.cc"
2003 break;
2004
2005 case 262: // $@45: %empty
2006 #line 1064 "dhcp4_parser.yy"
2007 {
2008 ctx.unique("serial-consistency", ctx.loc2pos(yystack_[0].location));
2009 ctx.enter(ctx.NO_KEYWORD);
2010 }
2011 #line 2012 "dhcp4_parser.cc"
2012 break;
2013
2014 case 263: // serial_consistency: "serial-consistency" $@45 ":" "constant string"
2015 #line 1067 "dhcp4_parser.yy"
2016 {
2017 ElementPtr c(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2018 ctx.stack_.back()->set("serial-consistency", c);
2019 ctx.leave();
2020 }
2021 #line 2022 "dhcp4_parser.cc"
2022 break;
2023
2024 case 264: // max_reconnect_tries: "max-reconnect-tries" ":" "integer"
2025 #line 1073 "dhcp4_parser.yy"
2026 {
2027 ctx.unique("max-reconnect-tries", ctx.loc2pos(yystack_[2].location));
2028 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2029 ctx.stack_.back()->set("max-reconnect-tries", n);
2030 }
2031 #line 2032 "dhcp4_parser.cc"
2032 break;
2033
2034 case 265: // reconnect_wait_time: "reconnect-wait-time" ":" "integer"
2035 #line 1079 "dhcp4_parser.yy"
2036 {
2037 ctx.unique("reconnect-wait-time", ctx.loc2pos(yystack_[2].location));
2038 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2039 ctx.stack_.back()->set("reconnect-wait-time", n);
2040 }
2041 #line 2042 "dhcp4_parser.cc"
2042 break;
2043
2044 case 266: // $@46: %empty
2045 #line 1085 "dhcp4_parser.yy"
2046 {
2047 ctx.unique("on-fail", ctx.loc2pos(yystack_[0].location));
2048 ctx.enter(ctx.DATABASE_ON_FAIL);
2049 }
2050 #line 2051 "dhcp4_parser.cc"
2051 break;
2052
2053 case 267: // on_fail: "on-fail" $@46 ":" on_fail_mode
2054 #line 1088 "dhcp4_parser.yy"
2055 {
2056 ctx.stack_.back()->set("on-fail", yystack_[0].value.as < ElementPtr > ());
2057 ctx.leave();
2058 }
2059 #line 2060 "dhcp4_parser.cc"
2060 break;
2061
2062 case 268: // on_fail_mode: "stop-retry-exit"
2063 #line 1093 "dhcp4_parser.yy"
2064 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("stop-retry-exit", ctx.loc2pos(yystack_[0].location))); }
2065 #line 2066 "dhcp4_parser.cc"
2066 break;
2067
2068 case 269: // on_fail_mode: "serve-retry-exit"
2069 #line 1094 "dhcp4_parser.yy"
2070 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-exit", ctx.loc2pos(yystack_[0].location))); }
2071 #line 2072 "dhcp4_parser.cc"
2072 break;
2073
2074 case 270: // on_fail_mode: "serve-retry-continue"
2075 #line 1095 "dhcp4_parser.yy"
2076 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-continue", ctx.loc2pos(yystack_[0].location))); }
2077 #line 2078 "dhcp4_parser.cc"
2078 break;
2079
2080 case 271: // max_row_errors: "max-row-errors" ":" "integer"
2081 #line 1098 "dhcp4_parser.yy"
2082 {
2083 ctx.unique("max-row-errors", ctx.loc2pos(yystack_[2].location));
2084 ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2085 ctx.stack_.back()->set("max-row-errors", n);
2086 }
2087 #line 2088 "dhcp4_parser.cc"
2088 break;
2089
2090 case 272: // $@47: %empty
2091 #line 1105 "dhcp4_parser.yy"
2092 {
2093 ctx.unique("host-reservation-identifiers", ctx.loc2pos(yystack_[0].location));
2094 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2095 ctx.stack_.back()->set("host-reservation-identifiers", l);
2096 ctx.stack_.push_back(l);
2097 ctx.enter(ctx.HOST_RESERVATION_IDENTIFIERS);
2098 }
2099 #line 2100 "dhcp4_parser.cc"
2100 break;
2101
2102 case 273: // host_reservation_identifiers: "host-reservation-identifiers" $@47 ":" "[" host_reservation_identifiers_list "]"
2103 #line 1111 "dhcp4_parser.yy"
2104 {
2105 ctx.stack_.pop_back();
2106 ctx.leave();
2107 }
2108 #line 2109 "dhcp4_parser.cc"
2109 break;
2110
2111 case 281: // duid_id: "duid"
2112 #line 1127 "dhcp4_parser.yy"
2113 {
2114 ElementPtr duid(new StringElement("duid", ctx.loc2pos(yystack_[0].location)));
2115 ctx.stack_.back()->add(duid);
2116 }
2117 #line 2118 "dhcp4_parser.cc"
2118 break;
2119
2120 case 282: // hw_address_id: "hw-address"
2121 #line 1132 "dhcp4_parser.yy"
2122 {
2123 ElementPtr hwaddr(new StringElement("hw-address", ctx.loc2pos(yystack_[0].location)));
2124 ctx.stack_.back()->add(hwaddr);
2125 }
2126 #line 2127 "dhcp4_parser.cc"
2127 break;
2128
2129 case 283: // circuit_id: "circuit-id"
2130 #line 1137 "dhcp4_parser.yy"
2131 {
2132 ElementPtr circuit(new StringElement("circuit-id", ctx.loc2pos(yystack_[0].location)));
2133 ctx.stack_.back()->add(circuit);
2134 }
2135 #line 2136 "dhcp4_parser.cc"
2136 break;
2137
2138 case 284: // client_id: "client-id"
2139 #line 1142 "dhcp4_parser.yy"
2140 {
2141 ElementPtr client(new StringElement("client-id", ctx.loc2pos(yystack_[0].location)));
2142 ctx.stack_.back()->add(client);
2143 }
2144 #line 2145 "dhcp4_parser.cc"
2145 break;
2146
2147 case 285: // flex_id: "flex-id"
2148 #line 1147 "dhcp4_parser.yy"
2149 {
2150 ElementPtr flex_id(new StringElement("flex-id", ctx.loc2pos(yystack_[0].location)));
2151 ctx.stack_.back()->add(flex_id);
2152 }
2153 #line 2154 "dhcp4_parser.cc"
2154 break;
2155
2156 case 286: // $@48: %empty
2157 #line 1154 "dhcp4_parser.yy"
2158 {
2159 ctx.unique("multi-threading", ctx.loc2pos(yystack_[0].location));
2160 ElementPtr mt(new MapElement(ctx.loc2pos(yystack_[0].location)));
2161 ctx.stack_.back()->set("multi-threading", mt);
2162 ctx.stack_.push_back(mt);
2163 ctx.enter(ctx.DHCP_MULTI_THREADING);
2164 }
2165 #line 2166 "dhcp4_parser.cc"
2166 break;
2167
2168 case 287: // dhcp_multi_threading: "multi-threading" $@48 ":" "{" multi_threading_params "}"
2169 #line 1160 "dhcp4_parser.yy"
2170 {
2171 // The enable parameter is required.
2172 ctx.require("enable-multi-threading", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
2173 ctx.stack_.pop_back();
2174 ctx.leave();
2175 }
2176 #line 2177 "dhcp4_parser.cc"
2177 break;
2178
2179 case 296: // enable_multi_threading: "enable-multi-threading" ":" "boolean"
2180 #line 1179 "dhcp4_parser.yy"
2181 {
2182 ctx.unique("enable-multi-threading", ctx.loc2pos(yystack_[2].location));
2183 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2184 ctx.stack_.back()->set("enable-multi-threading", b);
2185 }
2186 #line 2187 "dhcp4_parser.cc"
2187 break;
2188
2189 case 297: // thread_pool_size: "thread-pool-size" ":" "integer"
2190 #line 1185 "dhcp4_parser.yy"
2191 {
2192 ctx.unique("thread-pool-size", ctx.loc2pos(yystack_[2].location));
2193 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2194 ctx.stack_.back()->set("thread-pool-size", prf);
2195 }
2196 #line 2197 "dhcp4_parser.cc"
2197 break;
2198
2199 case 298: // packet_queue_size: "packet-queue-size" ":" "integer"
2200 #line 1191 "dhcp4_parser.yy"
2201 {
2202 ctx.unique("packet-queue-size", ctx.loc2pos(yystack_[2].location));
2203 ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2204 ctx.stack_.back()->set("packet-queue-size", prf);
2205 }
2206 #line 2207 "dhcp4_parser.cc"
2207 break;
2208
2209 case 299: // $@49: %empty
2210 #line 1197 "dhcp4_parser.yy"
2211 {
2212 ctx.unique("hooks-libraries", ctx.loc2pos(yystack_[0].location));
2213 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2214 ctx.stack_.back()->set("hooks-libraries", l);
2215 ctx.stack_.push_back(l);
2216 ctx.enter(ctx.HOOKS_LIBRARIES);
2217 }
2218 #line 2219 "dhcp4_parser.cc"
2219 break;
2220
2221 case 300: // hooks_libraries: "hooks-libraries" $@49 ":" "[" hooks_libraries_list "]"
2222 #line 1203 "dhcp4_parser.yy"
2223 {
2224 ctx.stack_.pop_back();
2225 ctx.leave();
2226 }
2227 #line 2228 "dhcp4_parser.cc"
2228 break;
2229
2230 case 305: // $@50: %empty
2231 #line 1216 "dhcp4_parser.yy"
2232 {
2233 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2234 ctx.stack_.back()->add(m);
2235 ctx.stack_.push_back(m);
2236 }
2237 #line 2238 "dhcp4_parser.cc"
2238 break;
2239
2240 case 306: // hooks_library: "{" $@50 hooks_params "}"
2241 #line 1220 "dhcp4_parser.yy"
2242 {
2243 // The library hooks parameter is required
2244 ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2245 ctx.stack_.pop_back();
2246 }
2247 #line 2248 "dhcp4_parser.cc"
2248 break;
2249
2250 case 307: // $@51: %empty
2251 #line 1226 "dhcp4_parser.yy"
2252 {
2253 // Parse the hooks-libraries list entry map
2254 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2255 ctx.stack_.push_back(m);
2256 }
2257 #line 2258 "dhcp4_parser.cc"
2258 break;
2259
2260 case 308: // sub_hooks_library: "{" $@51 hooks_params "}"
2261 #line 1230 "dhcp4_parser.yy"
2262 {
2263 // The library hooks parameter is required
2264 ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2265 // parsing completed
2266 }
2267 #line 2268 "dhcp4_parser.cc"
2268 break;
2269
2270 case 314: // $@52: %empty
2271 #line 1245 "dhcp4_parser.yy"
2272 {
2273 ctx.unique("library", ctx.loc2pos(yystack_[0].location));
2274 ctx.enter(ctx.NO_KEYWORD);
2275 }
2276 #line 2277 "dhcp4_parser.cc"
2277 break;
2278
2279 case 315: // library: "library" $@52 ":" "constant string"
2280 #line 1248 "dhcp4_parser.yy"
2281 {
2282 ElementPtr lib(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2283 ctx.stack_.back()->set("library", lib);
2284 ctx.leave();
2285 }
2286 #line 2287 "dhcp4_parser.cc"
2287 break;
2288
2289 case 316: // $@53: %empty
2290 #line 1254 "dhcp4_parser.yy"
2291 {
2292 ctx.unique("parameters", ctx.loc2pos(yystack_[0].location));
2293 ctx.enter(ctx.NO_KEYWORD);
2294 }
2295 #line 2296 "dhcp4_parser.cc"
2296 break;
2297
2298 case 317: // parameters: "parameters" $@53 ":" map_value
2299 #line 1257 "dhcp4_parser.yy"
2300 {
2301 ctx.stack_.back()->set("parameters", yystack_[0].value.as < ElementPtr > ());
2302 ctx.leave();
2303 }
2304 #line 2305 "dhcp4_parser.cc"
2305 break;
2306
2307 case 318: // $@54: %empty
2308 #line 1263 "dhcp4_parser.yy"
2309 {
2310 ctx.unique("expired-leases-processing", ctx.loc2pos(yystack_[0].location));
2311 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2312 ctx.stack_.back()->set("expired-leases-processing", m);
2313 ctx.stack_.push_back(m);
2314 ctx.enter(ctx.EXPIRED_LEASES_PROCESSING);
2315 }
2316 #line 2317 "dhcp4_parser.cc"
2317 break;
2318
2319 case 319: // expired_leases_processing: "expired-leases-processing" $@54 ":" "{" expired_leases_params "}"
2320 #line 1269 "dhcp4_parser.yy"
2321 {
2322 // No expired lease parameter is required
2323 ctx.stack_.pop_back();
2324 ctx.leave();
2325 }
2326 #line 2327 "dhcp4_parser.cc"
2327 break;
2328
2329 case 328: // reclaim_timer_wait_time: "reclaim-timer-wait-time" ":" "integer"
2330 #line 1287 "dhcp4_parser.yy"
2331 {
2332 ctx.unique("reclaim-timer-wait-time", ctx.loc2pos(yystack_[2].location));
2333 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2334 ctx.stack_.back()->set("reclaim-timer-wait-time", value);
2335 }
2336 #line 2337 "dhcp4_parser.cc"
2337 break;
2338
2339 case 329: // flush_reclaimed_timer_wait_time: "flush-reclaimed-timer-wait-time" ":" "integer"
2340 #line 1293 "dhcp4_parser.yy"
2341 {
2342 ctx.unique("flush-reclaimed-timer-wait-time", ctx.loc2pos(yystack_[2].location));
2343 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2344 ctx.stack_.back()->set("flush-reclaimed-timer-wait-time", value);
2345 }
2346 #line 2347 "dhcp4_parser.cc"
2347 break;
2348
2349 case 330: // hold_reclaimed_time: "hold-reclaimed-time" ":" "integer"
2350 #line 1299 "dhcp4_parser.yy"
2351 {
2352 ctx.unique("hold-reclaimed-time", ctx.loc2pos(yystack_[2].location));
2353 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2354 ctx.stack_.back()->set("hold-reclaimed-time", value);
2355 }
2356 #line 2357 "dhcp4_parser.cc"
2357 break;
2358
2359 case 331: // max_reclaim_leases: "max-reclaim-leases" ":" "integer"
2360 #line 1305 "dhcp4_parser.yy"
2361 {
2362 ctx.unique("max-reclaim-leases", ctx.loc2pos(yystack_[2].location));
2363 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2364 ctx.stack_.back()->set("max-reclaim-leases", value);
2365 }
2366 #line 2367 "dhcp4_parser.cc"
2367 break;
2368
2369 case 332: // max_reclaim_time: "max-reclaim-time" ":" "integer"
2370 #line 1311 "dhcp4_parser.yy"
2371 {
2372 ctx.unique("max-reclaim-time", ctx.loc2pos(yystack_[2].location));
2373 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2374 ctx.stack_.back()->set("max-reclaim-time", value);
2375 }
2376 #line 2377 "dhcp4_parser.cc"
2377 break;
2378
2379 case 333: // unwarned_reclaim_cycles: "unwarned-reclaim-cycles" ":" "integer"
2380 #line 1317 "dhcp4_parser.yy"
2381 {
2382 ctx.unique("unwarned-reclaim-cycles", ctx.loc2pos(yystack_[2].location));
2383 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2384 ctx.stack_.back()->set("unwarned-reclaim-cycles", value);
2385 }
2386 #line 2387 "dhcp4_parser.cc"
2387 break;
2388
2389 case 334: // $@55: %empty
2390 #line 1326 "dhcp4_parser.yy"
2391 {
2392 ctx.unique("subnet4", ctx.loc2pos(yystack_[0].location));
2393 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2394 ctx.stack_.back()->set("subnet4", l);
2395 ctx.stack_.push_back(l);
2396 ctx.enter(ctx.SUBNET4);
2397 }
2398 #line 2399 "dhcp4_parser.cc"
2399 break;
2400
2401 case 335: // subnet4_list: "subnet4" $@55 ":" "[" subnet4_list_content "]"
2402 #line 1332 "dhcp4_parser.yy"
2403 {
2404 ctx.stack_.pop_back();
2405 ctx.leave();
2406 }
2407 #line 2408 "dhcp4_parser.cc"
2408 break;
2409
2410 case 340: // $@56: %empty
2411 #line 1352 "dhcp4_parser.yy"
2412 {
2413 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2414 ctx.stack_.back()->add(m);
2415 ctx.stack_.push_back(m);
2416 }
2417 #line 2418 "dhcp4_parser.cc"
2418 break;
2419
2420 case 341: // subnet4: "{" $@56 subnet4_params "}"
2421 #line 1356 "dhcp4_parser.yy"
2422 {
2423 // Once we reached this place, the subnet parsing is now complete.
2424 // If we want to, we can implement default values here.
2425 // In particular we can do things like this:
2426 // if (!ctx.stack_.back()->get("interface")) {
2427 // ctx.stack_.back()->set("interface", StringElement("loopback"));
2428 // }
2429 //
2430 // We can also stack up one level (Dhcp4) and copy over whatever
2431 // global parameters we want to:
2432 // if (!ctx.stack_.back()->get("renew-timer")) {
2433 // ElementPtr renew = ctx_stack_[...].get("renew-timer");
2434 // if (renew) {
2435 // ctx.stack_.back()->set("renew-timer", renew);
2436 // }
2437 // }
2438
2439 // The subnet subnet4 parameter is required
2440 ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2441 ctx.stack_.pop_back();
2442 }
2443 #line 2444 "dhcp4_parser.cc"
2444 break;
2445
2446 case 342: // $@57: %empty
2447 #line 1378 "dhcp4_parser.yy"
2448 {
2449 // Parse the subnet4 list entry map
2450 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2451 ctx.stack_.push_back(m);
2452 }
2453 #line 2454 "dhcp4_parser.cc"
2454 break;
2455
2456 case 343: // sub_subnet4: "{" $@57 subnet4_params "}"
2457 #line 1382 "dhcp4_parser.yy"
2458 {
2459 // The subnet subnet4 parameter is required
2460 ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2461 // parsing completed
2462 }
2463 #line 2464 "dhcp4_parser.cc"
2464 break;
2465
2466 case 391: // $@58: %empty
2467 #line 1441 "dhcp4_parser.yy"
2468 {
2469 ctx.unique("subnet", ctx.loc2pos(yystack_[0].location));
2470 ctx.enter(ctx.NO_KEYWORD);
2471 }
2472 #line 2473 "dhcp4_parser.cc"
2473 break;
2474
2475 case 392: // subnet: "subnet" $@58 ":" "constant string"
2476 #line 1444 "dhcp4_parser.yy"
2477 {
2478 ElementPtr subnet(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2479 ctx.stack_.back()->set("subnet", subnet);
2480 ctx.leave();
2481 }
2482 #line 2483 "dhcp4_parser.cc"
2483 break;
2484
2485 case 393: // $@59: %empty
2486 #line 1450 "dhcp4_parser.yy"
2487 {
2488 ctx.unique("4o6-interface", ctx.loc2pos(yystack_[0].location));
2489 ctx.enter(ctx.NO_KEYWORD);
2490 }
2491 #line 2492 "dhcp4_parser.cc"
2492 break;
2493
2494 case 394: // subnet_4o6_interface: "4o6-interface" $@59 ":" "constant string"
2495 #line 1453 "dhcp4_parser.yy"
2496 {
2497 ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2498 ctx.stack_.back()->set("4o6-interface", iface);
2499 ctx.leave();
2500 }
2501 #line 2502 "dhcp4_parser.cc"
2502 break;
2503
2504 case 395: // $@60: %empty
2505 #line 1459 "dhcp4_parser.yy"
2506 {
2507 ctx.unique("4o6-interface-id", ctx.loc2pos(yystack_[0].location));
2508 ctx.enter(ctx.NO_KEYWORD);
2509 }
2510 #line 2511 "dhcp4_parser.cc"
2511 break;
2512
2513 case 396: // subnet_4o6_interface_id: "4o6-interface-id" $@60 ":" "constant string"
2514 #line 1462 "dhcp4_parser.yy"
2515 {
2516 ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2517 ctx.stack_.back()->set("4o6-interface-id", iface);
2518 ctx.leave();
2519 }
2520 #line 2521 "dhcp4_parser.cc"
2521 break;
2522
2523 case 397: // $@61: %empty
2524 #line 1468 "dhcp4_parser.yy"
2525 {
2526 ctx.unique("4o6-subnet", ctx.loc2pos(yystack_[0].location));
2527 ctx.enter(ctx.NO_KEYWORD);
2528 }
2529 #line 2530 "dhcp4_parser.cc"
2530 break;
2531
2532 case 398: // subnet_4o6_subnet: "4o6-subnet" $@61 ":" "constant string"
2533 #line 1471 "dhcp4_parser.yy"
2534 {
2535 ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2536 ctx.stack_.back()->set("4o6-subnet", iface);
2537 ctx.leave();
2538 }
2539 #line 2540 "dhcp4_parser.cc"
2540 break;
2541
2542 case 399: // $@62: %empty
2543 #line 1477 "dhcp4_parser.yy"
2544 {
2545 ctx.unique("interface", ctx.loc2pos(yystack_[0].location));
2546 ctx.enter(ctx.NO_KEYWORD);
2547 }
2548 #line 2549 "dhcp4_parser.cc"
2549 break;
2550
2551 case 400: // interface: "interface" $@62 ":" "constant string"
2552 #line 1480 "dhcp4_parser.yy"
2553 {
2554 ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2555 ctx.stack_.back()->set("interface", iface);
2556 ctx.leave();
2557 }
2558 #line 2559 "dhcp4_parser.cc"
2559 break;
2560
2561 case 401: // $@63: %empty
2562 #line 1486 "dhcp4_parser.yy"
2563 {
2564 ctx.unique("client-class", ctx.loc2pos(yystack_[0].location));
2565 ctx.enter(ctx.NO_KEYWORD);
2566 }
2567 #line 2568 "dhcp4_parser.cc"
2568 break;
2569
2570 case 402: // client_class: "client-class" $@63 ":" "constant string"
2571 #line 1489 "dhcp4_parser.yy"
2572 {
2573 ElementPtr cls(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2574 ctx.stack_.back()->set("client-class", cls);
2575 ctx.leave();
2576 }
2577 #line 2578 "dhcp4_parser.cc"
2578 break;
2579
2580 case 403: // $@64: %empty
2581 #line 1495 "dhcp4_parser.yy"
2582 {
2583 ctx.unique("require-client-classes", ctx.loc2pos(yystack_[0].location));
2584 ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
2585 ctx.stack_.back()->set("require-client-classes", c);
2586 ctx.stack_.push_back(c);
2587 ctx.enter(ctx.NO_KEYWORD);
2588 }
2589 #line 2590 "dhcp4_parser.cc"
2590 break;
2591
2592 case 404: // require_client_classes: "require-client-classes" $@64 ":" list_strings
2593 #line 1501 "dhcp4_parser.yy"
2594 {
2595 ctx.stack_.pop_back();
2596 ctx.leave();
2597 }
2598 #line 2599 "dhcp4_parser.cc"
2599 break;
2600
2601 case 405: // reservations_global: "reservations-global" ":" "boolean"
2602 #line 1506 "dhcp4_parser.yy"
2603 {
2604 ctx.unique("reservations-global", ctx.loc2pos(yystack_[2].location));
2605 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2606 ctx.stack_.back()->set("reservations-global", b);
2607 }
2608 #line 2609 "dhcp4_parser.cc"
2609 break;
2610
2611 case 406: // reservations_in_subnet: "reservations-in-subnet" ":" "boolean"
2612 #line 1512 "dhcp4_parser.yy"
2613 {
2614 ctx.unique("reservations-in-subnet", ctx.loc2pos(yystack_[2].location));
2615 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2616 ctx.stack_.back()->set("reservations-in-subnet", b);
2617 }
2618 #line 2619 "dhcp4_parser.cc"
2619 break;
2620
2621 case 407: // reservations_out_of_pool: "reservations-out-of-pool" ":" "boolean"
2622 #line 1518 "dhcp4_parser.yy"
2623 {
2624 ctx.unique("reservations-out-of-pool", ctx.loc2pos(yystack_[2].location));
2625 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2626 ctx.stack_.back()->set("reservations-out-of-pool", b);
2627 }
2628 #line 2629 "dhcp4_parser.cc"
2629 break;
2630
2631 case 408: // $@65: %empty
2632 #line 1524 "dhcp4_parser.yy"
2633 {
2634 ctx.unique("reservation-mode", ctx.loc2pos(yystack_[0].location));
2635 ctx.enter(ctx.RESERVATION_MODE);
2636 }
2637 #line 2638 "dhcp4_parser.cc"
2638 break;
2639
2640 case 409: // reservation_mode: "reservation-mode" $@65 ":" hr_mode
2641 #line 1527 "dhcp4_parser.yy"
2642 {
2643 ctx.stack_.back()->set("reservation-mode", yystack_[0].value.as < ElementPtr > ());
2644 ctx.leave();
2645 }
2646 #line 2647 "dhcp4_parser.cc"
2647 break;
2648
2649 case 410: // hr_mode: "disabled"
2650 #line 1532 "dhcp4_parser.yy"
2651 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("disabled", ctx.loc2pos(yystack_[0].location))); }
2652 #line 2653 "dhcp4_parser.cc"
2653 break;
2654
2655 case 411: // hr_mode: "out-of-pool"
2656 #line 1533 "dhcp4_parser.yy"
2657 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("out-of-pool", ctx.loc2pos(yystack_[0].location))); }
2658 #line 2659 "dhcp4_parser.cc"
2659 break;
2660
2661 case 412: // hr_mode: "global"
2662 #line 1534 "dhcp4_parser.yy"
2663 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("global", ctx.loc2pos(yystack_[0].location))); }
2664 #line 2665 "dhcp4_parser.cc"
2665 break;
2666
2667 case 413: // hr_mode: "all"
2668 #line 1535 "dhcp4_parser.yy"
2669 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("all", ctx.loc2pos(yystack_[0].location))); }
2670 #line 2671 "dhcp4_parser.cc"
2671 break;
2672
2673 case 414: // id: "id" ":" "integer"
2674 #line 1538 "dhcp4_parser.yy"
2675 {
2676 ctx.unique("id", ctx.loc2pos(yystack_[2].location));
2677 ElementPtr id(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2678 ctx.stack_.back()->set("id", id);
2679 }
2680 #line 2681 "dhcp4_parser.cc"
2681 break;
2682
2683 case 415: // $@66: %empty
2684 #line 1546 "dhcp4_parser.yy"
2685 {
2686 ctx.unique("shared-networks", ctx.loc2pos(yystack_[0].location));
2687 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2688 ctx.stack_.back()->set("shared-networks", l);
2689 ctx.stack_.push_back(l);
2690 ctx.enter(ctx.SHARED_NETWORK);
2691 }
2692 #line 2693 "dhcp4_parser.cc"
2693 break;
2694
2695 case 416: // shared_networks: "shared-networks" $@66 ":" "[" shared_networks_content "]"
2696 #line 1552 "dhcp4_parser.yy"
2697 {
2698 ctx.stack_.pop_back();
2699 ctx.leave();
2700 }
2701 #line 2702 "dhcp4_parser.cc"
2702 break;
2703
2704 case 421: // $@67: %empty
2705 #line 1567 "dhcp4_parser.yy"
2706 {
2707 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2708 ctx.stack_.back()->add(m);
2709 ctx.stack_.push_back(m);
2710 }
2711 #line 2712 "dhcp4_parser.cc"
2712 break;
2713
2714 case 422: // shared_network: "{" $@67 shared_network_params "}"
2715 #line 1571 "dhcp4_parser.yy"
2716 {
2717 ctx.stack_.pop_back();
2718 }
2719 #line 2720 "dhcp4_parser.cc"
2720 break;
2721
2722 case 465: // $@68: %empty
2723 #line 1625 "dhcp4_parser.yy"
2724 {
2725 ctx.unique("option-def", ctx.loc2pos(yystack_[0].location));
2726 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2727 ctx.stack_.back()->set("option-def", l);
2728 ctx.stack_.push_back(l);
2729 ctx.enter(ctx.OPTION_DEF);
2730 }
2731 #line 2732 "dhcp4_parser.cc"
2732 break;
2733
2734 case 466: // option_def_list: "option-def" $@68 ":" "[" option_def_list_content "]"
2735 #line 1631 "dhcp4_parser.yy"
2736 {
2737 ctx.stack_.pop_back();
2738 ctx.leave();
2739 }
2740 #line 2741 "dhcp4_parser.cc"
2741 break;
2742
2743 case 467: // $@69: %empty
2744 #line 1639 "dhcp4_parser.yy"
2745 {
2746 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2747 ctx.stack_.push_back(m);
2748 }
2749 #line 2750 "dhcp4_parser.cc"
2750 break;
2751
2752 case 468: // sub_option_def_list: "{" $@69 option_def_list "}"
2753 #line 1642 "dhcp4_parser.yy"
2754 {
2755 // parsing completed
2756 }
2757 #line 2758 "dhcp4_parser.cc"
2758 break;
2759
2760 case 473: // $@70: %empty
2761 #line 1658 "dhcp4_parser.yy"
2762 {
2763 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2764 ctx.stack_.back()->add(m);
2765 ctx.stack_.push_back(m);
2766 }
2767 #line 2768 "dhcp4_parser.cc"
2768 break;
2769
2770 case 474: // option_def_entry: "{" $@70 option_def_params "}"
2771 #line 1662 "dhcp4_parser.yy"
2772 {
2773 // The name, code and type option def parameters are required.
2774 ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2775 ctx.require("code", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2776 ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2777 ctx.stack_.pop_back();
2778 }
2779 #line 2780 "dhcp4_parser.cc"
2780 break;
2781
2782 case 475: // $@71: %empty
2783 #line 1673 "dhcp4_parser.yy"
2784 {
2785 // Parse the option-def list entry map
2786 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2787 ctx.stack_.push_back(m);
2788 }
2789 #line 2790 "dhcp4_parser.cc"
2790 break;
2791
2792 case 476: // sub_option_def: "{" $@71 option_def_params "}"
2793 #line 1677 "dhcp4_parser.yy"
2794 {
2795 // The name, code and type option def parameters are required.
2796 ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2797 ctx.require("code", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2798 ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
2799 // parsing completed
2800 }
2801 #line 2802 "dhcp4_parser.cc"
2802 break;
2803
2804 case 492: // code: "code" ":" "integer"
2805 #line 1709 "dhcp4_parser.yy"
2806 {
2807 ctx.unique("code", ctx.loc2pos(yystack_[2].location));
2808 ElementPtr code(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
2809 ctx.stack_.back()->set("code", code);
2810 }
2811 #line 2812 "dhcp4_parser.cc"
2812 break;
2813
2814 case 494: // $@72: %empty
2815 #line 1717 "dhcp4_parser.yy"
2816 {
2817 ctx.unique("type", ctx.loc2pos(yystack_[0].location));
2818 ctx.enter(ctx.NO_KEYWORD);
2819 }
2820 #line 2821 "dhcp4_parser.cc"
2821 break;
2822
2823 case 495: // option_def_type: "type" $@72 ":" "constant string"
2824 #line 1720 "dhcp4_parser.yy"
2825 {
2826 ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2827 ctx.stack_.back()->set("type", prf);
2828 ctx.leave();
2829 }
2830 #line 2831 "dhcp4_parser.cc"
2831 break;
2832
2833 case 496: // $@73: %empty
2834 #line 1726 "dhcp4_parser.yy"
2835 {
2836 ctx.unique("record-types", ctx.loc2pos(yystack_[0].location));
2837 ctx.enter(ctx.NO_KEYWORD);
2838 }
2839 #line 2840 "dhcp4_parser.cc"
2840 break;
2841
2842 case 497: // option_def_record_types: "record-types" $@73 ":" "constant string"
2843 #line 1729 "dhcp4_parser.yy"
2844 {
2845 ElementPtr rtypes(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2846 ctx.stack_.back()->set("record-types", rtypes);
2847 ctx.leave();
2848 }
2849 #line 2850 "dhcp4_parser.cc"
2850 break;
2851
2852 case 498: // $@74: %empty
2853 #line 1735 "dhcp4_parser.yy"
2854 {
2855 ctx.unique("space", ctx.loc2pos(yystack_[0].location));
2856 ctx.enter(ctx.NO_KEYWORD);
2857 }
2858 #line 2859 "dhcp4_parser.cc"
2859 break;
2860
2861 case 499: // space: "space" $@74 ":" "constant string"
2862 #line 1738 "dhcp4_parser.yy"
2863 {
2864 ElementPtr space(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2865 ctx.stack_.back()->set("space", space);
2866 ctx.leave();
2867 }
2868 #line 2869 "dhcp4_parser.cc"
2869 break;
2870
2871 case 501: // $@75: %empty
2872 #line 1746 "dhcp4_parser.yy"
2873 {
2874 ctx.unique("encapsulate", ctx.loc2pos(yystack_[0].location));
2875 ctx.enter(ctx.NO_KEYWORD);
2876 }
2877 #line 2878 "dhcp4_parser.cc"
2878 break;
2879
2880 case 502: // option_def_encapsulate: "encapsulate" $@75 ":" "constant string"
2881 #line 1749 "dhcp4_parser.yy"
2882 {
2883 ElementPtr encap(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2884 ctx.stack_.back()->set("encapsulate", encap);
2885 ctx.leave();
2886 }
2887 #line 2888 "dhcp4_parser.cc"
2888 break;
2889
2890 case 503: // option_def_array: "array" ":" "boolean"
2891 #line 1755 "dhcp4_parser.yy"
2892 {
2893 ctx.unique("array", ctx.loc2pos(yystack_[2].location));
2894 ElementPtr array(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2895 ctx.stack_.back()->set("array", array);
2896 }
2897 #line 2898 "dhcp4_parser.cc"
2898 break;
2899
2900 case 504: // $@76: %empty
2901 #line 1765 "dhcp4_parser.yy"
2902 {
2903 ctx.unique("option-data", ctx.loc2pos(yystack_[0].location));
2904 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
2905 ctx.stack_.back()->set("option-data", l);
2906 ctx.stack_.push_back(l);
2907 ctx.enter(ctx.OPTION_DATA);
2908 }
2909 #line 2910 "dhcp4_parser.cc"
2910 break;
2911
2912 case 505: // option_data_list: "option-data" $@76 ":" "[" option_data_list_content "]"
2913 #line 1771 "dhcp4_parser.yy"
2914 {
2915 ctx.stack_.pop_back();
2916 ctx.leave();
2917 }
2918 #line 2919 "dhcp4_parser.cc"
2919 break;
2920
2921 case 510: // $@77: %empty
2922 #line 1790 "dhcp4_parser.yy"
2923 {
2924 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2925 ctx.stack_.back()->add(m);
2926 ctx.stack_.push_back(m);
2927 }
2928 #line 2929 "dhcp4_parser.cc"
2929 break;
2930
2931 case 511: // option_data_entry: "{" $@77 option_data_params "}"
2932 #line 1794 "dhcp4_parser.yy"
2933 {
2934 /// @todo: the code or name parameters are required.
2935 ctx.stack_.pop_back();
2936 }
2937 #line 2938 "dhcp4_parser.cc"
2938 break;
2939
2940 case 512: // $@78: %empty
2941 #line 1802 "dhcp4_parser.yy"
2942 {
2943 // Parse the option-data list entry map
2944 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
2945 ctx.stack_.push_back(m);
2946 }
2947 #line 2948 "dhcp4_parser.cc"
2948 break;
2949
2950 case 513: // sub_option_data: "{" $@78 option_data_params "}"
2951 #line 1806 "dhcp4_parser.yy"
2952 {
2953 /// @todo: the code or name parameters are required.
2954 // parsing completed
2955 }
2956 #line 2957 "dhcp4_parser.cc"
2957 break;
2958
2959 case 528: // $@79: %empty
2960 #line 1839 "dhcp4_parser.yy"
2961 {
2962 ctx.unique("data", ctx.loc2pos(yystack_[0].location));
2963 ctx.enter(ctx.NO_KEYWORD);
2964 }
2965 #line 2966 "dhcp4_parser.cc"
2966 break;
2967
2968 case 529: // option_data_data: "data" $@79 ":" "constant string"
2969 #line 1842 "dhcp4_parser.yy"
2970 {
2971 ElementPtr data(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
2972 ctx.stack_.back()->set("data", data);
2973 ctx.leave();
2974 }
2975 #line 2976 "dhcp4_parser.cc"
2976 break;
2977
2978 case 532: // option_data_csv_format: "csv-format" ":" "boolean"
2979 #line 1852 "dhcp4_parser.yy"
2980 {
2981 ctx.unique("csv-format", ctx.loc2pos(yystack_[2].location));
2982 ElementPtr space(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2983 ctx.stack_.back()->set("csv-format", space);
2984 }
2985 #line 2986 "dhcp4_parser.cc"
2986 break;
2987
2988 case 533: // option_data_always_send: "always-send" ":" "boolean"
2989 #line 1858 "dhcp4_parser.yy"
2990 {
2991 ctx.unique("always-send", ctx.loc2pos(yystack_[2].location));
2992 ElementPtr persist(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
2993 ctx.stack_.back()->set("always-send", persist);
2994 }
2995 #line 2996 "dhcp4_parser.cc"
2996 break;
2997
2998 case 534: // $@80: %empty
2999 #line 1867 "dhcp4_parser.yy"
3000 {
3001 ctx.unique("pools", ctx.loc2pos(yystack_[0].location));
3002 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3003 ctx.stack_.back()->set("pools", l);
3004 ctx.stack_.push_back(l);
3005 ctx.enter(ctx.POOLS);
3006 }
3007 #line 3008 "dhcp4_parser.cc"
3008 break;
3009
3010 case 535: // pools_list: "pools" $@80 ":" "[" pools_list_content "]"
3011 #line 1873 "dhcp4_parser.yy"
3012 {
3013 ctx.stack_.pop_back();
3014 ctx.leave();
3015 }
3016 #line 3017 "dhcp4_parser.cc"
3017 break;
3018
3019 case 540: // $@81: %empty
3020 #line 1888 "dhcp4_parser.yy"
3021 {
3022 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3023 ctx.stack_.back()->add(m);
3024 ctx.stack_.push_back(m);
3025 }
3026 #line 3027 "dhcp4_parser.cc"
3027 break;
3028
3029 case 541: // pool_list_entry: "{" $@81 pool_params "}"
3030 #line 1892 "dhcp4_parser.yy"
3031 {
3032 // The pool parameter is required.
3033 ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3034 ctx.stack_.pop_back();
3035 }
3036 #line 3037 "dhcp4_parser.cc"
3037 break;
3038
3039 case 542: // $@82: %empty
3040 #line 1898 "dhcp4_parser.yy"
3041 {
3042 // Parse the pool list entry map
3043 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3044 ctx.stack_.push_back(m);
3045 }
3046 #line 3047 "dhcp4_parser.cc"
3047 break;
3048
3049 case 543: // sub_pool4: "{" $@82 pool_params "}"
3050 #line 1902 "dhcp4_parser.yy"
3051 {
3052 // The pool parameter is required.
3053 ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3054 // parsing completed
3055 }
3056 #line 3057 "dhcp4_parser.cc"
3057 break;
3058
3059 case 553: // $@83: %empty
3060 #line 1921 "dhcp4_parser.yy"
3061 {
3062 ctx.unique("pool", ctx.loc2pos(yystack_[0].location));
3063 ctx.enter(ctx.NO_KEYWORD);
3064 }
3065 #line 3066 "dhcp4_parser.cc"
3066 break;
3067
3068 case 554: // pool_entry: "pool" $@83 ":" "constant string"
3069 #line 1924 "dhcp4_parser.yy"
3070 {
3071 ElementPtr pool(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3072 ctx.stack_.back()->set("pool", pool);
3073 ctx.leave();
3074 }
3075 #line 3076 "dhcp4_parser.cc"
3076 break;
3077
3078 case 555: // $@84: %empty
3079 #line 1930 "dhcp4_parser.yy"
3080 {
3081 ctx.enter(ctx.NO_KEYWORD);
3082 }
3083 #line 3084 "dhcp4_parser.cc"
3084 break;
3085
3086 case 556: // user_context: "user-context" $@84 ":" map_value
3087 #line 1932 "dhcp4_parser.yy"
3088 {
3089 ElementPtr parent = ctx.stack_.back();
3090 ElementPtr user_context = yystack_[0].value.as < ElementPtr > ();
3091 ConstElementPtr old = parent->get("user-context");
3092
3093 // Handle already existing user context
3094 if (old) {
3095 // Check if it was a comment or a duplicate
3096 if ((old->size() != 1) || !old->contains("comment")) {
3097 std::stringstream msg;
3098 msg << "duplicate user-context entries (previous at "
3099 << old->getPosition().str() << ")";
3100 error(yystack_[3].location, msg.str());
3101 }
3102 // Merge the comment
3103 user_context->set("comment", old->get("comment"));
3104 }
3105
3106 // Set the user context
3107 parent->set("user-context", user_context);
3108 ctx.leave();
3109 }
3110 #line 3111 "dhcp4_parser.cc"
3111 break;
3112
3113 case 557: // $@85: %empty
3114 #line 1955 "dhcp4_parser.yy"
3115 {
3116 ctx.enter(ctx.NO_KEYWORD);
3117 }
3118 #line 3119 "dhcp4_parser.cc"
3119 break;
3120
3121 case 558: // comment: "comment" $@85 ":" "constant string"
3122 #line 1957 "dhcp4_parser.yy"
3123 {
3124 ElementPtr parent = ctx.stack_.back();
3125 ElementPtr user_context(new MapElement(ctx.loc2pos(yystack_[3].location)));
3126 ElementPtr comment(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3127 user_context->set("comment", comment);
3128
3129 // Handle already existing user context
3130 ConstElementPtr old = parent->get("user-context");
3131 if (old) {
3132 // Check for duplicate comment
3133 if (old->contains("comment")) {
3134 std::stringstream msg;
3135 msg << "duplicate user-context/comment entries (previous at "
3136 << old->getPosition().str() << ")";
3137 error(yystack_[3].location, msg.str());
3138 }
3139 // Merge the user context in the comment
3140 merge(user_context, old);
3141 }
3142
3143 // Set the user context
3144 parent->set("user-context", user_context);
3145 ctx.leave();
3146 }
3147 #line 3148 "dhcp4_parser.cc"
3148 break;
3149
3150 case 559: // $@86: %empty
3151 #line 1985 "dhcp4_parser.yy"
3152 {
3153 ctx.unique("reservations", ctx.loc2pos(yystack_[0].location));
3154 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3155 ctx.stack_.back()->set("reservations", l);
3156 ctx.stack_.push_back(l);
3157 ctx.enter(ctx.RESERVATIONS);
3158 }
3159 #line 3160 "dhcp4_parser.cc"
3160 break;
3161
3162 case 560: // reservations: "reservations" $@86 ":" "[" reservations_list "]"
3163 #line 1991 "dhcp4_parser.yy"
3164 {
3165 ctx.stack_.pop_back();
3166 ctx.leave();
3167 }
3168 #line 3169 "dhcp4_parser.cc"
3169 break;
3170
3171 case 565: // $@87: %empty
3172 #line 2004 "dhcp4_parser.yy"
3173 {
3174 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3175 ctx.stack_.back()->add(m);
3176 ctx.stack_.push_back(m);
3177 }
3178 #line 3179 "dhcp4_parser.cc"
3179 break;
3180
3181 case 566: // reservation: "{" $@87 reservation_params "}"
3182 #line 2008 "dhcp4_parser.yy"
3183 {
3184 /// @todo: an identifier parameter is required.
3185 ctx.stack_.pop_back();
3186 }
3187 #line 3188 "dhcp4_parser.cc"
3188 break;
3189
3190 case 567: // $@88: %empty
3191 #line 2013 "dhcp4_parser.yy"
3192 {
3193 // Parse the reservations list entry map
3194 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3195 ctx.stack_.push_back(m);
3196 }
3197 #line 3198 "dhcp4_parser.cc"
3198 break;
3199
3200 case 568: // sub_reservation: "{" $@88 reservation_params "}"
3201 #line 2017 "dhcp4_parser.yy"
3202 {
3203 /// @todo: an identifier parameter is required.
3204 // parsing completed
3205 }
3206 #line 3207 "dhcp4_parser.cc"
3207 break;
3208
3209 case 588: // $@89: %empty
3210 #line 2048 "dhcp4_parser.yy"
3211 {
3212 ctx.unique("next-server", ctx.loc2pos(yystack_[0].location));
3213 ctx.enter(ctx.NO_KEYWORD);
3214 }
3215 #line 3216 "dhcp4_parser.cc"
3216 break;
3217
3218 case 589: // next_server: "next-server" $@89 ":" "constant string"
3219 #line 2051 "dhcp4_parser.yy"
3220 {
3221 ElementPtr next_server(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3222 ctx.stack_.back()->set("next-server", next_server);
3223 ctx.leave();
3224 }
3225 #line 3226 "dhcp4_parser.cc"
3226 break;
3227
3228 case 590: // $@90: %empty
3229 #line 2057 "dhcp4_parser.yy"
3230 {
3231 ctx.unique("server-hostname", ctx.loc2pos(yystack_[0].location));
3232 ctx.enter(ctx.NO_KEYWORD);
3233 }
3234 #line 3235 "dhcp4_parser.cc"
3235 break;
3236
3237 case 591: // server_hostname: "server-hostname" $@90 ":" "constant string"
3238 #line 2060 "dhcp4_parser.yy"
3239 {
3240 ElementPtr srv(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3241 ctx.stack_.back()->set("server-hostname", srv);
3242 ctx.leave();
3243 }
3244 #line 3245 "dhcp4_parser.cc"
3245 break;
3246
3247 case 592: // $@91: %empty
3248 #line 2066 "dhcp4_parser.yy"
3249 {
3250 ctx.unique("boot-file-name", ctx.loc2pos(yystack_[0].location));
3251 ctx.enter(ctx.NO_KEYWORD);
3252 }
3253 #line 3254 "dhcp4_parser.cc"
3254 break;
3255
3256 case 593: // boot_file_name: "boot-file-name" $@91 ":" "constant string"
3257 #line 2069 "dhcp4_parser.yy"
3258 {
3259 ElementPtr bootfile(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3260 ctx.stack_.back()->set("boot-file-name", bootfile);
3261 ctx.leave();
3262 }
3263 #line 3264 "dhcp4_parser.cc"
3264 break;
3265
3266 case 594: // $@92: %empty
3267 #line 2075 "dhcp4_parser.yy"
3268 {
3269 ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location));
3270 ctx.enter(ctx.NO_KEYWORD);
3271 }
3272 #line 3273 "dhcp4_parser.cc"
3273 break;
3274
3275 case 595: // ip_address: "ip-address" $@92 ":" "constant string"
3276 #line 2078 "dhcp4_parser.yy"
3277 {
3278 ElementPtr addr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3279 ctx.stack_.back()->set("ip-address", addr);
3280 ctx.leave();
3281 }
3282 #line 3283 "dhcp4_parser.cc"
3283 break;
3284
3285 case 596: // $@93: %empty
3286 #line 2084 "dhcp4_parser.yy"
3287 {
3288 ctx.unique("ip-addresses", ctx.loc2pos(yystack_[0].location));
3289 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3290 ctx.stack_.back()->set("ip-addresses", l);
3291 ctx.stack_.push_back(l);
3292 ctx.enter(ctx.NO_KEYWORD);
3293 }
3294 #line 3295 "dhcp4_parser.cc"
3295 break;
3296
3297 case 597: // ip_addresses: "ip-addresses" $@93 ":" list_strings
3298 #line 2090 "dhcp4_parser.yy"
3299 {
3300 ctx.stack_.pop_back();
3301 ctx.leave();
3302 }
3303 #line 3304 "dhcp4_parser.cc"
3304 break;
3305
3306 case 598: // $@94: %empty
3307 #line 2095 "dhcp4_parser.yy"
3308 {
3309 ctx.unique("duid", ctx.loc2pos(yystack_[0].location));
3310 ctx.enter(ctx.NO_KEYWORD);
3311 }
3312 #line 3313 "dhcp4_parser.cc"
3313 break;
3314
3315 case 599: // duid: "duid" $@94 ":" "constant string"
3316 #line 2098 "dhcp4_parser.yy"
3317 {
3318 ElementPtr d(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3319 ctx.stack_.back()->set("duid", d);
3320 ctx.leave();
3321 }
3322 #line 3323 "dhcp4_parser.cc"
3323 break;
3324
3325 case 600: // $@95: %empty
3326 #line 2104 "dhcp4_parser.yy"
3327 {
3328 ctx.unique("hw-address", ctx.loc2pos(yystack_[0].location));
3329 ctx.enter(ctx.NO_KEYWORD);
3330 }
3331 #line 3332 "dhcp4_parser.cc"
3332 break;
3333
3334 case 601: // hw_address: "hw-address" $@95 ":" "constant string"
3335 #line 2107 "dhcp4_parser.yy"
3336 {
3337 ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3338 ctx.stack_.back()->set("hw-address", hw);
3339 ctx.leave();
3340 }
3341 #line 3342 "dhcp4_parser.cc"
3342 break;
3343
3344 case 602: // $@96: %empty
3345 #line 2113 "dhcp4_parser.yy"
3346 {
3347 ctx.unique("client-id", ctx.loc2pos(yystack_[0].location));
3348 ctx.enter(ctx.NO_KEYWORD);
3349 }
3350 #line 3351 "dhcp4_parser.cc"
3351 break;
3352
3353 case 603: // client_id_value: "client-id" $@96 ":" "constant string"
3354 #line 2116 "dhcp4_parser.yy"
3355 {
3356 ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3357 ctx.stack_.back()->set("client-id", hw);
3358 ctx.leave();
3359 }
3360 #line 3361 "dhcp4_parser.cc"
3361 break;
3362
3363 case 604: // $@97: %empty
3364 #line 2122 "dhcp4_parser.yy"
3365 {
3366 ctx.unique("circuit-id", ctx.loc2pos(yystack_[0].location));
3367 ctx.enter(ctx.NO_KEYWORD);
3368 }
3369 #line 3370 "dhcp4_parser.cc"
3370 break;
3371
3372 case 605: // circuit_id_value: "circuit-id" $@97 ":" "constant string"
3373 #line 2125 "dhcp4_parser.yy"
3374 {
3375 ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3376 ctx.stack_.back()->set("circuit-id", hw);
3377 ctx.leave();
3378 }
3379 #line 3380 "dhcp4_parser.cc"
3380 break;
3381
3382 case 606: // $@98: %empty
3383 #line 2131 "dhcp4_parser.yy"
3384 {
3385 ctx.unique("flex-id", ctx.loc2pos(yystack_[0].location));
3386 ctx.enter(ctx.NO_KEYWORD);
3387 }
3388 #line 3389 "dhcp4_parser.cc"
3389 break;
3390
3391 case 607: // flex_id_value: "flex-id" $@98 ":" "constant string"
3392 #line 2134 "dhcp4_parser.yy"
3393 {
3394 ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3395 ctx.stack_.back()->set("flex-id", hw);
3396 ctx.leave();
3397 }
3398 #line 3399 "dhcp4_parser.cc"
3399 break;
3400
3401 case 608: // $@99: %empty
3402 #line 2140 "dhcp4_parser.yy"
3403 {
3404 ctx.unique("hostname", ctx.loc2pos(yystack_[0].location));
3405 ctx.enter(ctx.NO_KEYWORD);
3406 }
3407 #line 3408 "dhcp4_parser.cc"
3408 break;
3409
3410 case 609: // hostname: "hostname" $@99 ":" "constant string"
3411 #line 2143 "dhcp4_parser.yy"
3412 {
3413 ElementPtr host(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3414 ctx.stack_.back()->set("hostname", host);
3415 ctx.leave();
3416 }
3417 #line 3418 "dhcp4_parser.cc"
3418 break;
3419
3420 case 610: // $@100: %empty
3421 #line 2149 "dhcp4_parser.yy"
3422 {
3423 ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location));
3424 ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
3425 ctx.stack_.back()->set("client-classes", c);
3426 ctx.stack_.push_back(c);
3427 ctx.enter(ctx.NO_KEYWORD);
3428 }
3429 #line 3430 "dhcp4_parser.cc"
3430 break;
3431
3432 case 611: // reservation_client_classes: "client-classes" $@100 ":" list_strings
3433 #line 2155 "dhcp4_parser.yy"
3434 {
3435 ctx.stack_.pop_back();
3436 ctx.leave();
3437 }
3438 #line 3439 "dhcp4_parser.cc"
3439 break;
3440
3441 case 612: // $@101: %empty
3442 #line 2163 "dhcp4_parser.yy"
3443 {
3444 ctx.unique("relay", ctx.loc2pos(yystack_[0].location));
3445 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3446 ctx.stack_.back()->set("relay", m);
3447 ctx.stack_.push_back(m);
3448 ctx.enter(ctx.RELAY);
3449 }
3450 #line 3451 "dhcp4_parser.cc"
3451 break;
3452
3453 case 613: // relay: "relay" $@101 ":" "{" relay_map "}"
3454 #line 2169 "dhcp4_parser.yy"
3455 {
3456 ctx.stack_.pop_back();
3457 ctx.leave();
3458 }
3459 #line 3460 "dhcp4_parser.cc"
3460 break;
3461
3462 case 616: // $@102: %empty
3463 #line 2181 "dhcp4_parser.yy"
3464 {
3465 ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location));
3466 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
3467 ctx.stack_.back()->set("client-classes", l);
3468 ctx.stack_.push_back(l);
3469 ctx.enter(ctx.CLIENT_CLASSES);
3470 }
3471 #line 3472 "dhcp4_parser.cc"
3472 break;
3473
3474 case 617: // client_classes: "client-classes" $@102 ":" "[" client_classes_list "]"
3475 #line 2187 "dhcp4_parser.yy"
3476 {
3477 ctx.stack_.pop_back();
3478 ctx.leave();
3479 }
3480 #line 3481 "dhcp4_parser.cc"
3481 break;
3482
3483 case 620: // $@103: %empty
3484 #line 2196 "dhcp4_parser.yy"
3485 {
3486 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3487 ctx.stack_.back()->add(m);
3488 ctx.stack_.push_back(m);
3489 }
3490 #line 3491 "dhcp4_parser.cc"
3491 break;
3492
3493 case 621: // client_class_entry: "{" $@103 client_class_params "}"
3494 #line 2200 "dhcp4_parser.yy"
3495 {
3496 // The name client class parameter is required.
3497 ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3498 ctx.stack_.pop_back();
3499 }
3500 #line 3501 "dhcp4_parser.cc"
3501 break;
3502
3503 case 641: // $@104: %empty
3504 #line 2232 "dhcp4_parser.yy"
3505 {
3506 ctx.unique("test", ctx.loc2pos(yystack_[0].location));
3507 ctx.enter(ctx.NO_KEYWORD);
3508 }
3509 #line 3510 "dhcp4_parser.cc"
3510 break;
3511
3512 case 642: // client_class_test: "test" $@104 ":" "constant string"
3513 #line 2235 "dhcp4_parser.yy"
3514 {
3515 ElementPtr test(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3516 ctx.stack_.back()->set("test", test);
3517 ctx.leave();
3518 }
3519 #line 3520 "dhcp4_parser.cc"
3520 break;
3521
3522 case 643: // only_if_required: "only-if-required" ":" "boolean"
3523 #line 2241 "dhcp4_parser.yy"
3524 {
3525 ctx.unique("only-if-required", ctx.loc2pos(yystack_[2].location));
3526 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3527 ctx.stack_.back()->set("only-if-required", b);
3528 }
3529 #line 3530 "dhcp4_parser.cc"
3530 break;
3531
3532 case 644: // dhcp4o6_port: "dhcp4o6-port" ":" "integer"
3533 #line 2249 "dhcp4_parser.yy"
3534 {
3535 ctx.unique("dhcp4o6-port", ctx.loc2pos(yystack_[2].location));
3536 ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3537 ctx.stack_.back()->set("dhcp4o6-port", time);
3538 }
3539 #line 3540 "dhcp4_parser.cc"
3540 break;
3541
3542 case 645: // $@105: %empty
3543 #line 2257 "dhcp4_parser.yy"
3544 {
3545 ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location));
3546 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3547 ctx.stack_.back()->set("control-socket", m);
3548 ctx.stack_.push_back(m);
3549 ctx.enter(ctx.CONTROL_SOCKET);
3550 }
3551 #line 3552 "dhcp4_parser.cc"
3552 break;
3553
3554 case 646: // control_socket: "control-socket" $@105 ":" "{" control_socket_params "}"
3555 #line 2263 "dhcp4_parser.yy"
3556 {
3557 ctx.stack_.pop_back();
3558 ctx.leave();
3559 }
3560 #line 3561 "dhcp4_parser.cc"
3561 break;
3562
3563 case 654: // $@106: %empty
3564 #line 2279 "dhcp4_parser.yy"
3565 {
3566 ctx.unique("socket-type", ctx.loc2pos(yystack_[0].location));
3567 ctx.enter(ctx.NO_KEYWORD);
3568 }
3569 #line 3570 "dhcp4_parser.cc"
3570 break;
3571
3572 case 655: // control_socket_type: "socket-type" $@106 ":" "constant string"
3573 #line 2282 "dhcp4_parser.yy"
3574 {
3575 ElementPtr stype(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3576 ctx.stack_.back()->set("socket-type", stype);
3577 ctx.leave();
3578 }
3579 #line 3580 "dhcp4_parser.cc"
3580 break;
3581
3582 case 656: // $@107: %empty
3583 #line 2288 "dhcp4_parser.yy"
3584 {
3585 ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location));
3586 ctx.enter(ctx.NO_KEYWORD);
3587 }
3588 #line 3589 "dhcp4_parser.cc"
3589 break;
3590
3591 case 657: // control_socket_name: "socket-name" $@107 ":" "constant string"
3592 #line 2291 "dhcp4_parser.yy"
3593 {
3594 ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3595 ctx.stack_.back()->set("socket-name", name);
3596 ctx.leave();
3597 }
3598 #line 3599 "dhcp4_parser.cc"
3599 break;
3600
3601 case 658: // $@108: %empty
3602 #line 2300 "dhcp4_parser.yy"
3603 {
3604 ctx.unique("dhcp-queue-control", ctx.loc2pos(yystack_[0].location));
3605 ElementPtr qc(new MapElement(ctx.loc2pos(yystack_[0].location)));
3606 ctx.stack_.back()->set("dhcp-queue-control", qc);
3607 ctx.stack_.push_back(qc);
3608 ctx.enter(ctx.DHCP_QUEUE_CONTROL);
3609 }
3610 #line 3611 "dhcp4_parser.cc"
3611 break;
3612
3613 case 659: // dhcp_queue_control: "dhcp-queue-control" $@108 ":" "{" queue_control_params "}"
3614 #line 2306 "dhcp4_parser.yy"
3615 {
3616 // The enable queue parameter is required.
3617 ctx.require("enable-queue", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
3618 ctx.stack_.pop_back();
3619 ctx.leave();
3620 }
3621 #line 3622 "dhcp4_parser.cc"
3622 break;
3623
3624 case 668: // enable_queue: "enable-queue" ":" "boolean"
3625 #line 2325 "dhcp4_parser.yy"
3626 {
3627 ctx.unique("enable-queue", ctx.loc2pos(yystack_[2].location));
3628 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3629 ctx.stack_.back()->set("enable-queue", b);
3630 }
3631 #line 3632 "dhcp4_parser.cc"
3632 break;
3633
3634 case 669: // $@109: %empty
3635 #line 2331 "dhcp4_parser.yy"
3636 {
3637 ctx.unique("queue-type", ctx.loc2pos(yystack_[0].location));
3638 ctx.enter(ctx.NO_KEYWORD);
3639 }
3640 #line 3641 "dhcp4_parser.cc"
3641 break;
3642
3643 case 670: // queue_type: "queue-type" $@109 ":" "constant string"
3644 #line 2334 "dhcp4_parser.yy"
3645 {
3646 ElementPtr qt(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3647 ctx.stack_.back()->set("queue-type", qt);
3648 ctx.leave();
3649 }
3650 #line 3651 "dhcp4_parser.cc"
3651 break;
3652
3653 case 671: // capacity: "capacity" ":" "integer"
3654 #line 2340 "dhcp4_parser.yy"
3655 {
3656 ctx.unique("capacity", ctx.loc2pos(yystack_[2].location));
3657 ElementPtr c(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3658 ctx.stack_.back()->set("capacity", c);
3659 }
3660 #line 3661 "dhcp4_parser.cc"
3661 break;
3662
3663 case 672: // $@110: %empty
3664 #line 2346 "dhcp4_parser.yy"
3665 {
3666 ctx.unique(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location));
3667 ctx.enter(ctx.NO_KEYWORD);
3668 }
3669 #line 3670 "dhcp4_parser.cc"
3670 break;
3671
3672 case 673: // arbitrary_map_entry: "constant string" $@110 ":" value
3673 #line 2349 "dhcp4_parser.yy"
3674 {
3675 ctx.stack_.back()->set(yystack_[3].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
3676 ctx.leave();
3677 }
3678 #line 3679 "dhcp4_parser.cc"
3679 break;
3680
3681 case 674: // $@111: %empty
3682 #line 2356 "dhcp4_parser.yy"
3683 {
3684 ctx.unique("dhcp-ddns", ctx.loc2pos(yystack_[0].location));
3685 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3686 ctx.stack_.back()->set("dhcp-ddns", m);
3687 ctx.stack_.push_back(m);
3688 ctx.enter(ctx.DHCP_DDNS);
3689 }
3690 #line 3691 "dhcp4_parser.cc"
3691 break;
3692
3693 case 675: // dhcp_ddns: "dhcp-ddns" $@111 ":" "{" dhcp_ddns_params "}"
3694 #line 2362 "dhcp4_parser.yy"
3695 {
3696 // The enable updates DHCP DDNS parameter is required.
3697 ctx.require("enable-updates", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
3698 ctx.stack_.pop_back();
3699 ctx.leave();
3700 }
3701 #line 3702 "dhcp4_parser.cc"
3702 break;
3703
3704 case 676: // $@112: %empty
3705 #line 2369 "dhcp4_parser.yy"
3706 {
3707 // Parse the dhcp-ddns map
3708 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3709 ctx.stack_.push_back(m);
3710 }
3711 #line 3712 "dhcp4_parser.cc"
3712 break;
3713
3714 case 677: // sub_dhcp_ddns: "{" $@112 dhcp_ddns_params "}"
3715 #line 2373 "dhcp4_parser.yy"
3716 {
3717 // The enable updates DHCP DDNS parameter is required.
3718 ctx.require("enable-updates", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
3719 // parsing completed
3720 }
3721 #line 3722 "dhcp4_parser.cc"
3722 break;
3723
3724 case 698: // enable_updates: "enable-updates" ":" "boolean"
3725 #line 2403 "dhcp4_parser.yy"
3726 {
3727 ctx.unique("enable-updates", ctx.loc2pos(yystack_[2].location));
3728 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3729 ctx.stack_.back()->set("enable-updates", b);
3730 }
3731 #line 3732 "dhcp4_parser.cc"
3732 break;
3733
3734 case 699: // $@113: %empty
3735 #line 2409 "dhcp4_parser.yy"
3736 {
3737 ctx.unique("server-ip", ctx.loc2pos(yystack_[0].location));
3738 ctx.enter(ctx.NO_KEYWORD);
3739 }
3740 #line 3741 "dhcp4_parser.cc"
3741 break;
3742
3743 case 700: // server_ip: "server-ip" $@113 ":" "constant string"
3744 #line 2412 "dhcp4_parser.yy"
3745 {
3746 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3747 ctx.stack_.back()->set("server-ip", s);
3748 ctx.leave();
3749 }
3750 #line 3751 "dhcp4_parser.cc"
3751 break;
3752
3753 case 701: // server_port: "server-port" ":" "integer"
3754 #line 2418 "dhcp4_parser.yy"
3755 {
3756 ctx.unique("server-port", ctx.loc2pos(yystack_[2].location));
3757 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3758 ctx.stack_.back()->set("server-port", i);
3759 }
3760 #line 3761 "dhcp4_parser.cc"
3761 break;
3762
3763 case 702: // $@114: %empty
3764 #line 2424 "dhcp4_parser.yy"
3765 {
3766 ctx.unique("sender-ip", ctx.loc2pos(yystack_[0].location));
3767 ctx.enter(ctx.NO_KEYWORD);
3768 }
3769 #line 3770 "dhcp4_parser.cc"
3770 break;
3771
3772 case 703: // sender_ip: "sender-ip" $@114 ":" "constant string"
3773 #line 2427 "dhcp4_parser.yy"
3774 {
3775 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3776 ctx.stack_.back()->set("sender-ip", s);
3777 ctx.leave();
3778 }
3779 #line 3780 "dhcp4_parser.cc"
3780 break;
3781
3782 case 704: // sender_port: "sender-port" ":" "integer"
3783 #line 2433 "dhcp4_parser.yy"
3784 {
3785 ctx.unique("sender-port", ctx.loc2pos(yystack_[2].location));
3786 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3787 ctx.stack_.back()->set("sender-port", i);
3788 }
3789 #line 3790 "dhcp4_parser.cc"
3790 break;
3791
3792 case 705: // max_queue_size: "max-queue-size" ":" "integer"
3793 #line 2439 "dhcp4_parser.yy"
3794 {
3795 ctx.unique("max-queue-size", ctx.loc2pos(yystack_[2].location));
3796 ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
3797 ctx.stack_.back()->set("max-queue-size", i);
3798 }
3799 #line 3800 "dhcp4_parser.cc"
3800 break;
3801
3802 case 706: // $@115: %empty
3803 #line 2445 "dhcp4_parser.yy"
3804 {
3805 ctx.unique("ncr-protocol", ctx.loc2pos(yystack_[0].location));
3806 ctx.enter(ctx.NCR_PROTOCOL);
3807 }
3808 #line 3809 "dhcp4_parser.cc"
3809 break;
3810
3811 case 707: // ncr_protocol: "ncr-protocol" $@115 ":" ncr_protocol_value
3812 #line 2448 "dhcp4_parser.yy"
3813 {
3814 ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as < ElementPtr > ());
3815 ctx.leave();
3816 }
3817 #line 3818 "dhcp4_parser.cc"
3818 break;
3819
3820 case 708: // ncr_protocol_value: "udp"
3821 #line 2454 "dhcp4_parser.yy"
3822 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); }
3823 #line 3824 "dhcp4_parser.cc"
3824 break;
3825
3826 case 709: // ncr_protocol_value: "tcp"
3827 #line 2455 "dhcp4_parser.yy"
3828 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); }
3829 #line 3830 "dhcp4_parser.cc"
3830 break;
3831
3832 case 710: // $@116: %empty
3833 #line 2458 "dhcp4_parser.yy"
3834 {
3835 ctx.unique("ncr-format", ctx.loc2pos(yystack_[0].location));
3836 ctx.enter(ctx.NCR_FORMAT);
3837 }
3838 #line 3839 "dhcp4_parser.cc"
3839 break;
3840
3841 case 711: // ncr_format: "ncr-format" $@116 ":" "JSON"
3842 #line 2461 "dhcp4_parser.yy"
3843 {
3844 ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location)));
3845 ctx.stack_.back()->set("ncr-format", json);
3846 ctx.leave();
3847 }
3848 #line 3849 "dhcp4_parser.cc"
3849 break;
3850
3851 case 712: // $@117: %empty
3852 #line 2468 "dhcp4_parser.yy"
3853 {
3854 ctx.unique("qualifying-suffix", ctx.loc2pos(yystack_[0].location));
3855 ctx.enter(ctx.NO_KEYWORD);
3856 }
3857 #line 3858 "dhcp4_parser.cc"
3858 break;
3859
3860 case 713: // dep_qualifying_suffix: "qualifying-suffix" $@117 ":" "constant string"
3861 #line 2471 "dhcp4_parser.yy"
3862 {
3863 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3864 ctx.stack_.back()->set("qualifying-suffix", s);
3865 ctx.leave();
3866 }
3867 #line 3868 "dhcp4_parser.cc"
3868 break;
3869
3870 case 714: // dep_override_no_update: "override-no-update" ":" "boolean"
3871 #line 2478 "dhcp4_parser.yy"
3872 {
3873 ctx.unique("override-no-update", ctx.loc2pos(yystack_[2].location));
3874 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3875 ctx.stack_.back()->set("override-no-update", b);
3876 }
3877 #line 3878 "dhcp4_parser.cc"
3878 break;
3879
3880 case 715: // dep_override_client_update: "override-client-update" ":" "boolean"
3881 #line 2485 "dhcp4_parser.yy"
3882 {
3883 ctx.unique("override-client-update", ctx.loc2pos(yystack_[2].location));
3884 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
3885 ctx.stack_.back()->set("override-client-update", b);
3886 }
3887 #line 3888 "dhcp4_parser.cc"
3888 break;
3889
3890 case 716: // $@118: %empty
3891 #line 2492 "dhcp4_parser.yy"
3892 {
3893 ctx.unique("replace-client-name", ctx.loc2pos(yystack_[0].location));
3894 ctx.enter(ctx.REPLACE_CLIENT_NAME);
3895 }
3896 #line 3897 "dhcp4_parser.cc"
3897 break;
3898
3899 case 717: // dep_replace_client_name: "replace-client-name" $@118 ":" ddns_replace_client_name_value
3900 #line 2495 "dhcp4_parser.yy"
3901 {
3902 ctx.stack_.back()->set("replace-client-name", yystack_[0].value.as < ElementPtr > ());
3903 ctx.leave();
3904 }
3905 #line 3906 "dhcp4_parser.cc"
3906 break;
3907
3908 case 718: // $@119: %empty
3909 #line 2501 "dhcp4_parser.yy"
3910 {
3911 ctx.unique("generated-prefix", ctx.loc2pos(yystack_[0].location));
3912 ctx.enter(ctx.NO_KEYWORD);
3913 }
3914 #line 3915 "dhcp4_parser.cc"
3915 break;
3916
3917 case 719: // dep_generated_prefix: "generated-prefix" $@119 ":" "constant string"
3918 #line 2504 "dhcp4_parser.yy"
3919 {
3920 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3921 ctx.stack_.back()->set("generated-prefix", s);
3922 ctx.leave();
3923 }
3924 #line 3925 "dhcp4_parser.cc"
3925 break;
3926
3927 case 720: // $@120: %empty
3928 #line 2511 "dhcp4_parser.yy"
3929 {
3930 ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location));
3931 ctx.enter(ctx.NO_KEYWORD);
3932 }
3933 #line 3934 "dhcp4_parser.cc"
3934 break;
3935
3936 case 721: // dep_hostname_char_set: "hostname-char-set" $@120 ":" "constant string"
3937 #line 2514 "dhcp4_parser.yy"
3938 {
3939 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3940 ctx.stack_.back()->set("hostname-char-set", s);
3941 ctx.leave();
3942 }
3943 #line 3944 "dhcp4_parser.cc"
3944 break;
3945
3946 case 722: // $@121: %empty
3947 #line 2521 "dhcp4_parser.yy"
3948 {
3949 ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location));
3950 ctx.enter(ctx.NO_KEYWORD);
3951 }
3952 #line 3953 "dhcp4_parser.cc"
3953 break;
3954
3955 case 723: // dep_hostname_char_replacement: "hostname-char-replacement" $@121 ":" "constant string"
3956 #line 2524 "dhcp4_parser.yy"
3957 {
3958 ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
3959 ctx.stack_.back()->set("hostname-char-replacement", s);
3960 ctx.leave();
3961 }
3962 #line 3963 "dhcp4_parser.cc"
3963 break;
3964
3965 case 724: // $@122: %empty
3966 #line 2533 "dhcp4_parser.yy"
3967 {
3968 ctx.unique("config-control", ctx.loc2pos(yystack_[0].location));
3969 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
3970 ctx.stack_.back()->set("config-control", i);
3971 ctx.stack_.push_back(i);
3972 ctx.enter(ctx.CONFIG_CONTROL);
3973 }
3974 #line 3975 "dhcp4_parser.cc"
3975 break;
3976
3977 case 725: // config_control: "config-control" $@122 ":" "{" config_control_params "}"
3978 #line 2539 "dhcp4_parser.yy"
3979 {
3980 // No config control params are required
3981 ctx.stack_.pop_back();
3982 ctx.leave();
3983 }
3984 #line 3985 "dhcp4_parser.cc"
3985 break;
3986
3987 case 726: // $@123: %empty
3988 #line 2545 "dhcp4_parser.yy"
3989 {
3990 // Parse the config-control map
3991 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
3992 ctx.stack_.push_back(m);
3993 }
3994 #line 3995 "dhcp4_parser.cc"
3995 break;
3996
3997 case 727: // sub_config_control: "{" $@123 config_control_params "}"
3998 #line 2549 "dhcp4_parser.yy"
3999 {
4000 // No config_control params are required
4001 // parsing completed
4002 }
4003 #line 4004 "dhcp4_parser.cc"
4004 break;
4005
4006 case 732: // $@124: %empty
4007 #line 2564 "dhcp4_parser.yy"
4008 {
4009 ctx.unique("config-databases", ctx.loc2pos(yystack_[0].location));
4010 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
4011 ctx.stack_.back()->set("config-databases", l);
4012 ctx.stack_.push_back(l);
4013 ctx.enter(ctx.CONFIG_DATABASE);
4014 }
4015 #line 4016 "dhcp4_parser.cc"
4016 break;
4017
4018 case 733: // config_databases: "config-databases" $@124 ":" "[" database_list "]"
4019 #line 2570 "dhcp4_parser.yy"
4020 {
4021 ctx.stack_.pop_back();
4022 ctx.leave();
4023 }
4024 #line 4025 "dhcp4_parser.cc"
4025 break;
4026
4027 case 734: // config_fetch_wait_time: "config-fetch-wait-time" ":" "integer"
4028 #line 2575 "dhcp4_parser.yy"
4029 {
4030 ctx.unique("config-fetch-wait-time", ctx.loc2pos(yystack_[2].location));
4031 ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4032 ctx.stack_.back()->set("config-fetch-wait-time", value);
4033 }
4034 #line 4035 "dhcp4_parser.cc"
4035 break;
4036
4037 case 735: // $@125: %empty
4038 #line 2583 "dhcp4_parser.yy"
4039 {
4040 ctx.unique("loggers", ctx.loc2pos(yystack_[0].location));
4041 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
4042 ctx.stack_.back()->set("loggers", l);
4043 ctx.stack_.push_back(l);
4044 ctx.enter(ctx.LOGGERS);
4045 }
4046 #line 4047 "dhcp4_parser.cc"
4047 break;
4048
4049 case 736: // loggers: "loggers" $@125 ":" "[" loggers_entries "]"
4050 #line 2589 "dhcp4_parser.yy"
4051 {
4052 ctx.stack_.pop_back();
4053 ctx.leave();
4054 }
4055 #line 4056 "dhcp4_parser.cc"
4056 break;
4057
4058 case 739: // $@126: %empty
4059 #line 2601 "dhcp4_parser.yy"
4060 {
4061 ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location)));
4062 ctx.stack_.back()->add(l);
4063 ctx.stack_.push_back(l);
4064 }
4065 #line 4066 "dhcp4_parser.cc"
4066 break;
4067
4068 case 740: // logger_entry: "{" $@126 logger_params "}"
4069 #line 2605 "dhcp4_parser.yy"
4070 {
4071 ctx.stack_.pop_back();
4072 }
4073 #line 4074 "dhcp4_parser.cc"
4074 break;
4075
4076 case 750: // debuglevel: "debuglevel" ":" "integer"
4077 #line 2622 "dhcp4_parser.yy"
4078 {
4079 ctx.unique("debuglevel", ctx.loc2pos(yystack_[2].location));
4080 ElementPtr dl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4081 ctx.stack_.back()->set("debuglevel", dl);
4082 }
4083 #line 4084 "dhcp4_parser.cc"
4084 break;
4085
4086 case 751: // $@127: %empty
4087 #line 2628 "dhcp4_parser.yy"
4088 {
4089 ctx.unique("severity", ctx.loc2pos(yystack_[0].location));
4090 ctx.enter(ctx.NO_KEYWORD);
4091 }
4092 #line 4093 "dhcp4_parser.cc"
4093 break;
4094
4095 case 752: // severity: "severity" $@127 ":" "constant string"
4096 #line 2631 "dhcp4_parser.yy"
4097 {
4098 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4099 ctx.stack_.back()->set("severity", sev);
4100 ctx.leave();
4101 }
4102 #line 4103 "dhcp4_parser.cc"
4103 break;
4104
4105 case 753: // $@128: %empty
4106 #line 2637 "dhcp4_parser.yy"
4107 {
4108 ctx.unique("output_options", ctx.loc2pos(yystack_[0].location));
4109 ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
4110 ctx.stack_.back()->set("output_options", l);
4111 ctx.stack_.push_back(l);
4112 ctx.enter(ctx.OUTPUT_OPTIONS);
4113 }
4114 #line 4115 "dhcp4_parser.cc"
4115 break;
4116
4117 case 754: // output_options_list: "output_options" $@128 ":" "[" output_options_list_content "]"
4118 #line 2643 "dhcp4_parser.yy"
4119 {
4120 ctx.stack_.pop_back();
4121 ctx.leave();
4122 }
4123 #line 4124 "dhcp4_parser.cc"
4124 break;
4125
4126 case 757: // $@129: %empty
4127 #line 2652 "dhcp4_parser.yy"
4128 {
4129 ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
4130 ctx.stack_.back()->add(m);
4131 ctx.stack_.push_back(m);
4132 }
4133 #line 4134 "dhcp4_parser.cc"
4134 break;
4135
4136 case 758: // output_entry: "{" $@129 output_params_list "}"
4137 #line 2656 "dhcp4_parser.yy"
4138 {
4139 ctx.stack_.pop_back();
4140 }
4141 #line 4142 "dhcp4_parser.cc"
4142 break;
4143
4144 case 766: // $@130: %empty
4145 #line 2671 "dhcp4_parser.yy"
4146 {
4147 ctx.unique("output", ctx.loc2pos(yystack_[0].location));
4148 ctx.enter(ctx.NO_KEYWORD);
4149 }
4150 #line 4151 "dhcp4_parser.cc"
4151 break;
4152
4153 case 767: // output: "output" $@130 ":" "constant string"
4154 #line 2674 "dhcp4_parser.yy"
4155 {
4156 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4157 ctx.stack_.back()->set("output", sev);
4158 ctx.leave();
4159 }
4160 #line 4161 "dhcp4_parser.cc"
4161 break;
4162
4163 case 768: // flush: "flush" ":" "boolean"
4164 #line 2680 "dhcp4_parser.yy"
4165 {
4166 ctx.unique("flush", ctx.loc2pos(yystack_[2].location));
4167 ElementPtr flush(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
4168 ctx.stack_.back()->set("flush", flush);
4169 }
4170 #line 4171 "dhcp4_parser.cc"
4171 break;
4172
4173 case 769: // maxsize: "maxsize" ":" "integer"
4174 #line 2686 "dhcp4_parser.yy"
4175 {
4176 ctx.unique("maxsize", ctx.loc2pos(yystack_[2].location));
4177 ElementPtr maxsize(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4178 ctx.stack_.back()->set("maxsize", maxsize);
4179 }
4180 #line 4181 "dhcp4_parser.cc"
4181 break;
4182
4183 case 770: // maxver: "maxver" ":" "integer"
4184 #line 2692 "dhcp4_parser.yy"
4185 {
4186 ctx.unique("maxver", ctx.loc2pos(yystack_[2].location));
4187 ElementPtr maxver(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
4188 ctx.stack_.back()->set("maxver", maxver);
4189 }
4190 #line 4191 "dhcp4_parser.cc"
4191 break;
4192
4193 case 771: // $@131: %empty
4194 #line 2698 "dhcp4_parser.yy"
4195 {
4196 ctx.unique("pattern", ctx.loc2pos(yystack_[0].location));
4197 ctx.enter(ctx.NO_KEYWORD);
4198 }
4199 #line 4200 "dhcp4_parser.cc"
4200 break;
4201
4202 case 772: // pattern: "pattern" $@131 ":" "constant string"
4203 #line 2701 "dhcp4_parser.yy"
4204 {
4205 ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
4206 ctx.stack_.back()->set("pattern", sev);
4207 ctx.leave();
4208 }
4209 #line 4210 "dhcp4_parser.cc"
4210 break;
4211
4212 case 773: // $@132: %empty
4213 #line 2707 "dhcp4_parser.yy"
4214 {
4215 ctx.unique("compatibility", ctx.loc2pos(yystack_[0].location));
4216 ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
4217 ctx.stack_.back()->set("compatibility", i);
4218 ctx.stack_.push_back(i);
4219 ctx.enter(ctx.COMPATIBILITY);
4220 }
4221 #line 4222 "dhcp4_parser.cc"
4222 break;
4223
4224 case 774: // compatibility: "compatibility" $@132 ":" "{" compatibility_params "}"
4225 #line 2713 "dhcp4_parser.yy"
4226 {
4227 ctx.stack_.pop_back();
4228 ctx.leave();
4229 }
4230 #line 4231 "dhcp4_parser.cc"
4231 break;
4232
4233 case 779: // lenient_option_parsing: "lenient-option-parsing" ":" "boolean"
4234 #line 2726 "dhcp4_parser.yy"
4235 {
4236 ctx.unique("lenient-option-parsing", ctx.loc2pos(yystack_[2].location));
4237 ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
4238 ctx.stack_.back()->set("lenient-option-parsing", b);
4239 }
4240 #line 4241 "dhcp4_parser.cc"
4241 break;
4242
4243
4244 #line 4245 "dhcp4_parser.cc"
4245
4246 default:
4247 break;
4248 }
4249 }
4250 #if YY_EXCEPTIONS
4251 catch (const syntax_error& yyexc)
4252 {
4253 YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
4254 error (yyexc);
4255 YYERROR;
4256 }
4257 #endif // YY_EXCEPTIONS
4258 YY_SYMBOL_PRINT ("-> $$ =", yylhs);
4259 yypop_ (yylen);
4260 yylen = 0;
4261
4262 // Shift the result of the reduction.
4263 yypush_ (YY_NULLPTR, YY_MOVE (yylhs));
4264 }
4265 goto yynewstate;
4266
4267
4268 /*--------------------------------------.
4269 | yyerrlab -- here on detecting error. |
4270 `--------------------------------------*/
4271 yyerrlab:
4272 // If not already recovering from an error, report this error.
4273 if (!yyerrstatus_)
4274 {
4275 ++yynerrs_;
4276 context yyctx (*this, yyla);
4277 std::string msg = yysyntax_error_ (yyctx);
4278 error (yyla.location, YY_MOVE (msg));
4279 }
4280
4281
4282 yyerror_range[1].location = yyla.location;
4283 if (yyerrstatus_ == 3)
4284 {
4285 /* If just tried and failed to reuse lookahead token after an
4286 error, discard it. */
4287
4288 // Return failure if at end of input.
4289 if (yyla.kind () == symbol_kind::S_YYEOF)
4290 YYABORT;
4291 else if (!yyla.empty ())
4292 {
4293 yy_destroy_ ("Error: discarding", yyla);
4294 yyla.clear ();
4295 }
4296 }
4297
4298 // Else will try to reuse lookahead token after shifting the error token.
4299 goto yyerrlab1;
4300
4301
4302 /*---------------------------------------------------.
4303 | yyerrorlab -- error raised explicitly by YYERROR. |
4304 `---------------------------------------------------*/
4305 yyerrorlab:
4306 /* Pacify compilers when the user code never invokes YYERROR and
4307 the label yyerrorlab therefore never appears in user code. */
4308 if (false)
4309 YYERROR;
4310
4311 /* Do not reclaim the symbols of the rule whose action triggered
4312 this YYERROR. */
4313 yypop_ (yylen);
4314 yylen = 0;
4315 YY_STACK_PRINT ();
4316 goto yyerrlab1;
4317
4318
4319 /*-------------------------------------------------------------.
4320 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4321 `-------------------------------------------------------------*/
4322 yyerrlab1:
4323 yyerrstatus_ = 3; // Each real token shifted decrements this.
4324 // Pop stack until we find a state that shifts the error token.
4325 for (;;)
4326 {
4327 yyn = yypact_[+yystack_[0].state];
4328 if (!yy_pact_value_is_default_ (yyn))
4329 {
4330 yyn += symbol_kind::S_YYerror;
4331 if (0 <= yyn && yyn <= yylast_
4332 && yycheck_[yyn] == symbol_kind::S_YYerror)
4333 {
4334 yyn = yytable_[yyn];
4335 if (0 < yyn)
4336 break;
4337 }
4338 }
4339
4340 // Pop the current state because it cannot handle the error token.
4341 if (yystack_.size () == 1)
4342 YYABORT;
4343
4344 yyerror_range[1].location = yystack_[0].location;
4345 yy_destroy_ ("Error: popping", yystack_[0]);
4346 yypop_ ();
4347 YY_STACK_PRINT ();
4348 }
4349 {
4350 stack_symbol_type error_token;
4351
4352 yyerror_range[2].location = yyla.location;
4353 YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);
4354
4355 // Shift the error token.
4356 error_token.state = state_type (yyn);
4357 yypush_ ("Shifting", YY_MOVE (error_token));
4358 }
4359 goto yynewstate;
4360
4361
4362 /*-------------------------------------.
4363 | yyacceptlab -- YYACCEPT comes here. |
4364 `-------------------------------------*/
4365 yyacceptlab:
4366 yyresult = 0;
4367 goto yyreturn;
4368
4369
4370 /*-----------------------------------.
4371 | yyabortlab -- YYABORT comes here. |
4372 `-----------------------------------*/
4373 yyabortlab:
4374 yyresult = 1;
4375 goto yyreturn;
4376
4377
4378 /*-----------------------------------------------------.
4379 | yyreturn -- parsing is finished, return the result. |
4380 `-----------------------------------------------------*/
4381 yyreturn:
4382 if (!yyla.empty ())
4383 yy_destroy_ ("Cleanup: discarding lookahead", yyla);
4384
4385 /* Do not reclaim the symbols of the rule whose action triggered
4386 this YYABORT or YYACCEPT. */
4387 yypop_ (yylen);
4388 YY_STACK_PRINT ();
4389 while (1 < yystack_.size ())
4390 {
4391 yy_destroy_ ("Cleanup: popping", yystack_[0]);
4392 yypop_ ();
4393 }
4394
4395 return yyresult;
4396 }
4397 #if YY_EXCEPTIONS
4398 catch (...)
4399 {
4400 YYCDEBUG << "Exception caught: cleaning lookahead and stack\n";
4401 // Do not try to display the values of the reclaimed symbols,
4402 // as their printers might throw an exception.
4403 if (!yyla.empty ())
4404 yy_destroy_ (YY_NULLPTR, yyla);
4405
4406 while (1 < yystack_.size ())
4407 {
4408 yy_destroy_ (YY_NULLPTR, yystack_[0]);
4409 yypop_ ();
4410 }
4411 throw;
4412 }
4413 #endif // YY_EXCEPTIONS
4414 }
4415
4416 void
error(const syntax_error & yyexc)4417 Dhcp4Parser::error (const syntax_error& yyexc)
4418 {
4419 error (yyexc.location, yyexc.what ());
4420 }
4421
4422 /* Return YYSTR after stripping away unnecessary quotes and
4423 backslashes, so that it's suitable for yyerror. The heuristic is
4424 that double-quoting is unnecessary unless the string contains an
4425 apostrophe, a comma, or backslash (other than backslash-backslash).
4426 YYSTR is taken from yytname. */
4427 std::string
yytnamerr_(const char * yystr)4428 Dhcp4Parser::yytnamerr_ (const char *yystr)
4429 {
4430 if (*yystr == '"')
4431 {
4432 std::string yyr;
4433 char const *yyp = yystr;
4434
4435 for (;;)
4436 switch (*++yyp)
4437 {
4438 case '\'':
4439 case ',':
4440 goto do_not_strip_quotes;
4441
4442 case '\\':
4443 if (*++yyp != '\\')
4444 goto do_not_strip_quotes;
4445 else
4446 goto append;
4447
4448 append:
4449 default:
4450 yyr += *yyp;
4451 break;
4452
4453 case '"':
4454 return yyr;
4455 }
4456 do_not_strip_quotes: ;
4457 }
4458
4459 return yystr;
4460 }
4461
4462 std::string
symbol_name(symbol_kind_type yysymbol)4463 Dhcp4Parser::symbol_name (symbol_kind_type yysymbol)
4464 {
4465 return yytnamerr_ (yytname_[yysymbol]);
4466 }
4467
4468
4469
4470 // Dhcp4Parser::context.
context(const Dhcp4Parser & yyparser,const symbol_type & yyla)4471 Dhcp4Parser::context::context (const Dhcp4Parser& yyparser, const symbol_type& yyla)
4472 : yyparser_ (yyparser)
4473 , yyla_ (yyla)
4474 {}
4475
4476 int
expected_tokens(symbol_kind_type yyarg[],int yyargn) const4477 Dhcp4Parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const
4478 {
4479 // Actual number of expected tokens
4480 int yycount = 0;
4481
4482 const int yyn = yypact_[+yyparser_.yystack_[0].state];
4483 if (!yy_pact_value_is_default_ (yyn))
4484 {
4485 /* Start YYX at -YYN if negative to avoid negative indexes in
4486 YYCHECK. In other words, skip the first -YYN actions for
4487 this state because they are default actions. */
4488 const int yyxbegin = yyn < 0 ? -yyn : 0;
4489 // Stay within bounds of both yycheck and yytname.
4490 const int yychecklim = yylast_ - yyn + 1;
4491 const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4492 for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
4493 if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror
4494 && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
4495 {
4496 if (!yyarg)
4497 ++yycount;
4498 else if (yycount == yyargn)
4499 return 0;
4500 else
4501 yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx);
4502 }
4503 }
4504
4505 if (yyarg && yycount == 0 && 0 < yyargn)
4506 yyarg[0] = symbol_kind::S_YYEMPTY;
4507 return yycount;
4508 }
4509
4510
4511
4512
4513
4514
4515 int
yy_syntax_error_arguments_(const context & yyctx,symbol_kind_type yyarg[],int yyargn) const4516 Dhcp4Parser::yy_syntax_error_arguments_ (const context& yyctx,
4517 symbol_kind_type yyarg[], int yyargn) const
4518 {
4519 /* There are many possibilities here to consider:
4520 - If this state is a consistent state with a default action, then
4521 the only way this function was invoked is if the default action
4522 is an error action. In that case, don't check for expected
4523 tokens because there are none.
4524 - The only way there can be no lookahead present (in yyla) is
4525 if this state is a consistent state with a default action.
4526 Thus, detecting the absence of a lookahead is sufficient to
4527 determine that there is no unexpected or expected token to
4528 report. In that case, just report a simple "syntax error".
4529 - Don't assume there isn't a lookahead just because this state is
4530 a consistent state with a default action. There might have
4531 been a previous inconsistent state, consistent state with a
4532 non-default action, or user semantic action that manipulated
4533 yyla. (However, yyla is currently not documented for users.)
4534 - Of course, the expected token list depends on states to have
4535 correct lookahead information, and it depends on the parser not
4536 to perform extra reductions after fetching a lookahead from the
4537 scanner and before detecting a syntax error. Thus, state merging
4538 (from LALR or IELR) and default reductions corrupt the expected
4539 token list. However, the list is correct for canonical LR with
4540 one exception: it will still contain any token that will not be
4541 accepted due to an error action in a later state.
4542 */
4543
4544 if (!yyctx.lookahead ().empty ())
4545 {
4546 if (yyarg)
4547 yyarg[0] = yyctx.token ();
4548 int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1);
4549 return yyn + 1;
4550 }
4551 return 0;
4552 }
4553
4554 // Generate an error message.
4555 std::string
yysyntax_error_(const context & yyctx) const4556 Dhcp4Parser::yysyntax_error_ (const context& yyctx) const
4557 {
4558 // Its maximum.
4559 enum { YYARGS_MAX = 5 };
4560 // Arguments of yyformat.
4561 symbol_kind_type yyarg[YYARGS_MAX];
4562 int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX);
4563
4564 char const* yyformat = YY_NULLPTR;
4565 switch (yycount)
4566 {
4567 #define YYCASE_(N, S) \
4568 case N: \
4569 yyformat = S; \
4570 break
4571 default: // Avoid compiler warnings.
4572 YYCASE_ (0, YY_("syntax error"));
4573 YYCASE_ (1, YY_("syntax error, unexpected %s"));
4574 YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
4575 YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4576 YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4577 YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4578 #undef YYCASE_
4579 }
4580
4581 std::string yyres;
4582 // Argument number.
4583 std::ptrdiff_t yyi = 0;
4584 for (char const* yyp = yyformat; *yyp; ++yyp)
4585 if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
4586 {
4587 yyres += symbol_name (yyarg[yyi++]);
4588 ++yyp;
4589 }
4590 else
4591 yyres += *yyp;
4592 return yyres;
4593 }
4594
4595
4596 const short Dhcp4Parser::yypact_ninf_ = -958;
4597
4598 const signed char Dhcp4Parser::yytable_ninf_ = -1;
4599
4600 const short
4601 Dhcp4Parser::yypact_[] =
4602 {
4603 204, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4604 -958, -958, -958, -958, 31, 38, 48, 60, 74, 78,
4605 80, 90, 99, 114, 132, 157, 189, 200, -958, -958,
4606 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4607 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4608 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4609 -958, -958, -958, -958, 38, -130, 107, 183, 67, 612,
4610 190, 247, 11, 89, 249, -96, 418, 116, -958, 129,
4611 177, 184, 213, 220, -958, 221, -958, -958, -958, 232,
4612 285, 291, -958, -958, -958, -958, -958, -958, 306, 317,
4613 327, 331, 334, 372, 385, 401, 402, 413, 414, -958,
4614 415, 417, 419, 420, 421, -958, -958, -958, 422, 423,
4615 425, -958, -958, -958, 426, -958, -958, -958, -958, 430,
4616 431, 432, -958, -958, -958, -958, -958, 433, -958, -958,
4617 -958, -958, -958, -958, 434, -958, -958, 435, -958, 56,
4618 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4619 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4620 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4621 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4622 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4623 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4624 -958, -958, -958, -958, -958, 437, -958, 85, -958, -958,
4625 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4626 -958, 439, -958, -958, -958, -958, -958, -958, -958, -958,
4627 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4628 -958, -958, -958, -958, -958, -958, -958, -958, -958, 92,
4629 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4630 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4631 -958, -958, -958, -958, -958, -958, -958, 93, -958, -958,
4632 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4633 -958, -958, -958, -958, 266, 278, -958, -958, -958, -958,
4634 -958, -958, -958, -958, -958, -958, -958, -958, 312, -958,
4635 -958, 441, -958, -958, -958, 442, -958, -958, 443, 446,
4636 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4637 -958, -958, -958, 449, 455, -958, -958, -958, -958, 454,
4638 461, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4639 -958, -958, -958, 100, -958, -958, -958, 462, -958, -958,
4640 463, -958, 465, 466, -958, -958, 467, 472, -958, -958,
4641 -958, -958, -958, -958, -958, 110, -958, -958, -958, -958,
4642 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4643 -958, -958, -958, 474, 128, -958, -958, -958, -958, 38,
4644 38, -958, 264, 475, -958, 477, 480, 481, 218, 284,
4645 288, 485, 491, 492, 493, 496, 498, 301, 302, 304,
4646 305, 307, 310, 322, 323, 328, 308, 311, 504, 313,
4647 321, 315, 325, 329, 523, 528, 530, 333, 335, 339,
4648 540, 543, 545, 348, 547, 551, 553, 557, 358, 361,
4649 362, 563, 565, 566, 567, 568, 384, 583, 584, 585,
4650 586, 587, 590, 391, 592, 593, -958, 183, -958, 594,
4651 595, 596, 397, 67, -958, 598, 599, 600, 601, 602,
4652 603, 407, 604, 606, 608, 612, -958, 610, 190, -958,
4653 611, 613, 614, 616, 617, 618, 620, 621, -958, 247,
4654 -958, 622, 623, 428, 624, 627, 628, 429, -958, 89,
4655 630, 440, 445, -958, 249, 631, 632, -85, -958, 447,
4656 633, 639, 444, 641, 450, 451, 651, 652, 453, 456,
4657 654, 655, 657, 658, 418, -958, 663, 468, 116, -958,
4658 -958, -958, 664, 609, 662, 676, 677, -958, -958, -958,
4659 470, 484, 495, 679, 693, 697, -958, -958, -958, -958,
4660 -958, -958, -958, -958, -958, -958, -958, 502, -958, -958,
4661 -958, -958, -958, -120, 503, 509, -958, -958, -958, 700,
4662 706, 707, -958, 709, 714, 521, 236, -958, -958, -958,
4663 718, 719, 723, 724, 725, -958, 728, 729, 730, 731,
4664 538, 539, -958, 726, 735, -958, 738, 52, 142, -958,
4665 -958, 544, 546, 548, 739, 549, 550, -958, 738, 552,
4666 741, -958, 554, -958, 738, 555, 556, 558, 559, 560,
4667 561, 562, -958, 564, 569, -958, 570, 571, 572, -958,
4668 -958, 573, -958, -958, -958, 574, 714, -958, -958, 575,
4669 576, -958, 577, -958, -958, 15, 589, -958, -958, -120,
4670 578, 579, 580, -958, 747, -958, -958, 38, 183, 116,
4671 67, 722, -958, -958, -958, 108, 108, 757, -958, -958,
4672 -958, -958, -958, -958, -958, -958, -958, 759, 760, 761,
4673 762, -958, -958, -958, -958, -958, -958, -958, -958, -48,
4674 775, 776, 777, 242, 87, 121, 210, 418, -958, -958,
4675 778, -143, -958, -958, -958, -958, -958, -958, -958, -958,
4676 -958, -958, -958, 781, -958, -958, -958, -958, 173, -958,
4677 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4678 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4679 -958, -958, -958, -958, -958, -958, -958, 757, -958, 138,
4680 181, 192, -958, 235, -958, -958, -958, -958, -958, -958,
4681 750, 785, 786, 787, 788, -958, -958, -958, -958, 789,
4682 790, -958, 791, 792, 793, 794, -958, 270, -958, -958,
4683 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4684 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4685 277, -958, 795, 796, -958, -958, 797, 799, -958, -958,
4686 798, 802, -958, -958, 800, 804, -958, -958, 803, 805,
4687 -958, -958, -958, -958, -958, -958, 36, -958, -958, -958,
4688 -958, -958, -958, -958, 104, -958, -958, 806, 807, -958,
4689 -958, 808, 812, -958, 813, 814, 815, 816, 817, 818,
4690 298, -958, -958, -958, -958, -958, -958, -958, 819, 820,
4691 821, -958, 299, -958, -958, -958, -958, -958, -958, -958,
4692 -958, -958, -958, -958, 309, -958, -958, -958, 822, -958,
4693 823, -958, -958, -958, 316, -958, -958, -958, -958, -958,
4694 320, -958, 214, -958, 824, -958, 324, -958, -958, 615,
4695 -958, 825, 826, -958, -958, -958, -958, 827, 828, -958,
4696 -958, -958, 829, 722, -958, 832, 833, 834, 835, 638,
4697 607, 640, 626, 642, 837, 839, 841, 842, 645, 646,
4698 845, 648, 649, 650, 653, 108, -958, -958, 108, -958,
4699 757, 612, -958, 759, 89, -958, 760, 249, -958, 761,
4700 1228, -958, 762, -48, -958, 115, 775, -958, 247, -958,
4701 776, -96, -958, 777, 656, 659, 660, 661, 665, 666,
4702 242, -958, 667, 668, 670, 87, -958, 848, 849, 121,
4703 -958, 669, 852, 672, 853, 210, -958, -958, 21, 778,
4704 -958, 671, -143, -958, -958, 854, 856, 190, -958, 781,
4705 860, -958, -958, 675, -958, 330, 678, 680, 681, -958,
4706 -958, -958, -958, -958, 682, 683, 684, 685, -958, -958,
4707 332, -958, -958, -958, -958, -958, 326, -958, 346, -958,
4708 857, -958, 858, -958, -958, -958, -958, -958, -958, -958,
4709 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4710 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4711 -958, -958, -958, -958, -958, -958, -958, 382, -958, -958,
4712 -958, -958, -958, -958, -958, -958, -958, -958, -958, 865,
4713 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4714 -958, -958, 869, 875, -958, -958, -958, -958, -958, 872,
4715 -958, 404, -958, -958, -958, -958, -958, -958, -958, -958,
4716 -958, -958, -958, -958, 686, 687, -958, -958, 688, -958,
4717 38, -958, -958, 886, -958, -958, -958, -958, -958, 405,
4718 -958, -958, -958, -958, -958, -958, -958, -958, 690, 406,
4719 -958, 738, -958, -958, -958, -958, -958, -958, -958, -958,
4720 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4721 -958, -958, -958, 1228, -958, 888, 689, -958, 115, -958,
4722 -958, -958, -958, -958, -958, 891, 694, 894, 21, -958,
4723 -958, -958, -958, -958, 698, -958, -958, 896, -958, 701,
4724 -958, -958, 900, -958, -958, 224, -958, -10, 900, -958,
4725 -958, 905, 908, 913, -958, 412, -958, -958, -958, -958,
4726 -958, -958, -958, 914, 732, 737, 749, 929, -10, -958,
4727 767, -958, -958, -958, 768, -958, -958, -958
4728 };
4729
4730 const short
4731 Dhcp4Parser::yydefact_[] =
4732 {
4733 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
4734 20, 22, 24, 26, 0, 0, 0, 0, 0, 0,
4735 0, 0, 0, 0, 0, 0, 0, 0, 1, 43,
4736 36, 32, 31, 28, 29, 30, 35, 3, 33, 34,
4737 56, 5, 60, 7, 178, 9, 342, 11, 542, 13,
4738 567, 15, 467, 17, 475, 19, 512, 21, 307, 23,
4739 676, 25, 726, 27, 45, 39, 0, 0, 0, 0,
4740 0, 569, 0, 477, 514, 0, 0, 0, 47, 0,
4741 46, 0, 0, 40, 58, 0, 724, 167, 193, 0,
4742 0, 0, 588, 590, 592, 191, 200, 202, 0, 0,
4743 0, 0, 0, 0, 0, 0, 0, 0, 0, 137,
4744 0, 0, 0, 0, 0, 146, 153, 155, 0, 0,
4745 0, 334, 465, 504, 0, 415, 555, 557, 408, 0,
4746 0, 0, 272, 616, 559, 299, 318, 0, 286, 645,
4747 658, 674, 159, 161, 0, 735, 773, 0, 125, 0,
4748 62, 64, 65, 66, 67, 68, 102, 103, 104, 105,
4749 106, 69, 97, 124, 86, 87, 88, 110, 111, 112,
4750 113, 114, 115, 116, 117, 108, 109, 118, 119, 120,
4751 122, 72, 73, 94, 74, 75, 76, 121, 80, 81,
4752 70, 99, 100, 101, 98, 71, 78, 79, 92, 93,
4753 95, 89, 90, 91, 77, 82, 83, 84, 85, 96,
4754 107, 123, 180, 182, 186, 0, 177, 0, 169, 171,
4755 172, 173, 174, 175, 176, 393, 395, 397, 534, 391,
4756 399, 0, 403, 401, 612, 390, 346, 347, 348, 349,
4757 350, 374, 375, 376, 377, 378, 364, 365, 379, 380,
4758 381, 382, 383, 384, 385, 386, 387, 388, 389, 0,
4759 344, 353, 369, 370, 371, 354, 356, 357, 360, 361,
4760 362, 359, 355, 351, 352, 372, 373, 358, 366, 367,
4761 368, 363, 553, 552, 548, 549, 547, 0, 544, 546,
4762 550, 551, 610, 598, 600, 604, 602, 608, 606, 594,
4763 587, 581, 585, 586, 0, 570, 571, 582, 583, 584,
4764 578, 573, 579, 575, 576, 577, 580, 574, 0, 494,
4765 247, 0, 498, 496, 501, 0, 490, 491, 0, 478,
4766 479, 481, 493, 482, 483, 484, 500, 485, 486, 487,
4767 488, 489, 528, 0, 0, 526, 527, 530, 531, 0,
4768 515, 516, 518, 519, 520, 521, 522, 523, 524, 525,
4769 314, 316, 311, 0, 309, 312, 313, 0, 712, 699,
4770 0, 702, 0, 0, 706, 710, 0, 0, 716, 718,
4771 720, 722, 697, 695, 696, 0, 678, 680, 681, 682,
4772 683, 684, 685, 686, 687, 692, 688, 689, 690, 691,
4773 693, 694, 732, 0, 0, 728, 730, 731, 44, 0,
4774 0, 37, 0, 0, 57, 0, 0, 0, 0, 0,
4775 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4776 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4777 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4778 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4779 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4780 0, 0, 0, 0, 0, 0, 55, 0, 61, 0,
4781 0, 0, 0, 0, 179, 0, 0, 0, 0, 0,
4782 0, 0, 0, 0, 0, 0, 343, 0, 0, 543,
4783 0, 0, 0, 0, 0, 0, 0, 0, 568, 0,
4784 468, 0, 0, 0, 0, 0, 0, 0, 476, 0,
4785 0, 0, 0, 513, 0, 0, 0, 0, 308, 0,
4786 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4787 0, 0, 0, 0, 0, 677, 0, 0, 0, 727,
4788 48, 41, 0, 0, 0, 0, 0, 140, 141, 142,
4789 0, 0, 0, 0, 0, 0, 126, 127, 128, 129,
4790 130, 131, 132, 133, 134, 135, 136, 0, 164, 165,
4791 143, 144, 145, 0, 0, 0, 157, 158, 163, 0,
4792 0, 0, 139, 0, 0, 0, 0, 405, 406, 407,
4793 0, 0, 0, 0, 0, 644, 0, 0, 0, 0,
4794 0, 0, 166, 0, 0, 63, 0, 0, 0, 190,
4795 170, 0, 0, 0, 0, 0, 0, 414, 0, 0,
4796 0, 345, 0, 545, 0, 0, 0, 0, 0, 0,
4797 0, 0, 572, 0, 0, 492, 0, 0, 0, 503,
4798 480, 0, 532, 533, 517, 0, 0, 310, 698, 0,
4799 0, 701, 0, 704, 705, 0, 0, 714, 715, 0,
4800 0, 0, 0, 679, 0, 734, 729, 0, 0, 0,
4801 0, 0, 589, 591, 593, 0, 0, 204, 138, 148,
4802 149, 150, 151, 152, 147, 154, 156, 336, 469, 506,
4803 417, 38, 556, 558, 410, 411, 412, 413, 409, 0,
4804 0, 561, 301, 0, 0, 0, 0, 0, 160, 162,
4805 0, 0, 49, 181, 184, 185, 183, 188, 189, 187,
4806 394, 396, 398, 536, 392, 400, 404, 402, 0, 554,
4807 611, 599, 601, 605, 603, 609, 607, 595, 495, 248,
4808 499, 497, 502, 529, 315, 317, 713, 700, 703, 708,
4809 709, 707, 711, 717, 719, 721, 723, 204, 42, 0,
4810 0, 0, 198, 0, 195, 197, 234, 240, 242, 244,
4811 0, 0, 0, 0, 0, 256, 258, 260, 262, 0,
4812 0, 266, 0, 0, 0, 0, 233, 0, 210, 212,
4813 213, 214, 215, 216, 217, 218, 219, 220, 221, 226,
4814 227, 228, 222, 229, 230, 231, 223, 224, 225, 232,
4815 0, 208, 0, 205, 206, 340, 0, 337, 338, 473,
4816 0, 470, 471, 510, 0, 507, 508, 421, 0, 418,
4817 419, 281, 282, 283, 284, 285, 0, 274, 276, 277,
4818 278, 279, 280, 620, 0, 618, 565, 0, 562, 563,
4819 305, 0, 302, 303, 0, 0, 0, 0, 0, 0,
4820 0, 320, 322, 323, 324, 325, 326, 327, 0, 0,
4821 0, 295, 0, 288, 290, 291, 292, 293, 294, 654,
4822 656, 653, 651, 652, 0, 647, 649, 650, 0, 669,
4823 0, 672, 665, 666, 0, 660, 662, 663, 664, 667,
4824 0, 739, 0, 737, 0, 778, 0, 775, 777, 51,
4825 540, 0, 537, 538, 596, 614, 615, 0, 0, 59,
4826 725, 168, 0, 0, 194, 0, 0, 0, 0, 0,
4827 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4828 0, 0, 0, 0, 0, 0, 192, 201, 0, 203,
4829 0, 0, 335, 0, 477, 466, 0, 514, 505, 0,
4830 0, 416, 0, 0, 273, 622, 0, 617, 569, 560,
4831 0, 0, 300, 0, 0, 0, 0, 0, 0, 0,
4832 0, 319, 0, 0, 0, 0, 287, 0, 0, 0,
4833 646, 0, 0, 0, 0, 0, 659, 675, 0, 0,
4834 736, 0, 0, 774, 53, 0, 52, 0, 535, 0,
4835 0, 613, 733, 0, 196, 0, 0, 0, 0, 246,
4836 249, 250, 251, 252, 0, 0, 0, 0, 264, 265,
4837 0, 253, 254, 255, 271, 211, 0, 207, 0, 339,
4838 0, 472, 0, 509, 464, 443, 444, 445, 428, 429,
4839 448, 449, 450, 451, 452, 431, 432, 453, 454, 455,
4840 456, 457, 458, 459, 460, 461, 462, 463, 425, 426,
4841 427, 441, 442, 438, 439, 440, 437, 0, 423, 430,
4842 446, 447, 433, 434, 435, 436, 420, 275, 641, 0,
4843 636, 637, 638, 639, 640, 629, 630, 634, 635, 631,
4844 632, 633, 0, 623, 624, 626, 627, 628, 619, 0,
4845 564, 0, 304, 328, 329, 330, 331, 332, 333, 321,
4846 296, 297, 298, 289, 0, 0, 648, 668, 0, 671,
4847 0, 661, 753, 0, 751, 749, 743, 747, 748, 0,
4848 741, 745, 746, 744, 738, 779, 776, 50, 0, 0,
4849 539, 0, 199, 236, 237, 238, 239, 235, 241, 243,
4850 245, 257, 259, 261, 263, 268, 269, 270, 267, 209,
4851 341, 474, 511, 0, 422, 0, 0, 621, 0, 566,
4852 306, 655, 657, 670, 673, 0, 0, 0, 0, 740,
4853 54, 541, 597, 424, 0, 643, 625, 0, 750, 0,
4854 742, 642, 0, 752, 757, 0, 755, 0, 0, 754,
4855 766, 0, 0, 0, 771, 0, 759, 761, 762, 763,
4856 764, 765, 756, 0, 0, 0, 0, 0, 0, 758,
4857 0, 768, 769, 770, 0, 760, 767, 772
4858 };
4859
4860 const short
4861 Dhcp4Parser::yypgoto_[] =
4862 {
4863 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4864 -958, -958, -958, -958, -958, -54, -958, -566, -958, 144,
4865 -958, -958, -958, -958, -958, -958, -607, -958, -958, -958,
4866 -67, -958, -958, -958, -958, -958, -958, 154, 499, 4,
4867 10, 23, -40, -23, -12, 22, 25, 29, 33, -958,
4868 -958, -958, -958, -958, 35, 40, 43, 45, 46, 47,
4869 -958, 292, 50, -958, 51, -958, 53, 57, 58, -958,
4870 61, -958, 63, -958, -958, -958, -958, -958, 297, 489,
4871 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4872 -958, -958, -958, -958, -958, -958, 55, -958, -958, -958,
4873 -958, -958, -958, 222, -958, 42, -958, -674, 77, -958,
4874 -958, -958, -958, -958, -958, -958, -958, -958, -958, -33,
4875 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4876 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4877 -958, -958, -958, -958, -958, 71, -958, -958, -958, -958,
4878 -958, -958, -958, -958, 41, -958, -958, -958, -958, -958,
4879 -958, -958, 54, -958, -958, -958, 62, 514, -958, -958,
4880 -958, -958, -958, -958, -958, 59, -958, -958, -958, -958,
4881 -958, -958, -957, -958, -958, -958, 79, -958, -958, -958,
4882 84, 581, -958, -958, -958, -958, -958, -958, -958, -958,
4883 -955, -958, -65, -958, 70, -958, 64, 65, 68, 69,
4884 -958, -958, -958, -958, -958, -958, -958, 75, -958, -958,
4885 -137, -46, -958, -958, -958, -958, -958, 82, -958, -958,
4886 -958, 86, -958, 532, -958, -63, -958, -958, -958, -958,
4887 -958, -42, -958, -958, -958, -958, -958, -35, -958, -958,
4888 -958, 83, -958, -958, -958, 88, -958, 529, -958, -958,
4889 -958, -958, -958, -958, -958, -958, -958, -958, -958, 37,
4890 -958, -958, -958, 44, 582, -958, -958, -51, -958, -8,
4891 -958, -39, -958, -958, -958, 91, -958, -958, -958, 76,
4892 -958, 588, -55, -958, -15, -958, 3, -958, 319, -958,
4893 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4894 -958, -958, -958, -958, -958, -958, -946, -958, -958, -958,
4895 -958, -958, 94, -958, -958, -958, -129, -958, -958, -958,
4896 -958, -958, -958, -958, -958, 66, -958, -958, -958, -958,
4897 -958, -958, -958, 72, -958, -958, -958, -958, -958, -958,
4898 -958, -958, -958, -958, 341, 516, -958, -958, -958, -958,
4899 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4900 -958, -958, -958, -958, -958, -958, -958, -958, -958, -958,
4901 -958, -958, -958, -958, -958, 383, 515, -958, -958, -958,
4902 -958, -958, -958, 73, -958, -958, -134, -958, -958, -958,
4903 -958, -958, -958, -152, -958, -958, -171, -958, -958, -958,
4904 -958, -958, -958, -958, -958, -958, -958, 81, -958
4905 };
4906
4907 const short
4908 Dhcp4Parser::yydefgoto_[] =
4909 {
4910 0, 14, 15, 16, 17, 18, 19, 20, 21, 22,
4911 23, 24, 25, 26, 27, 36, 37, 38, 65, 702,
4912 82, 83, 39, 64, 79, 80, 723, 919, 1015, 1016,
4913 796, 41, 66, 85, 413, 43, 67, 149, 150, 151,
4914 152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
4915 162, 438, 163, 164, 165, 166, 167, 168, 169, 170,
4916 444, 694, 171, 445, 172, 446, 173, 174, 175, 471,
4917 176, 472, 177, 178, 179, 180, 181, 416, 217, 218,
4918 45, 68, 219, 479, 220, 480, 726, 221, 481, 729,
4919 222, 182, 424, 183, 417, 773, 774, 775, 932, 184,
4920 425, 185, 426, 822, 823, 824, 958, 797, 798, 799,
4921 935, 1167, 800, 936, 801, 937, 802, 938, 803, 804,
4922 512, 805, 806, 807, 808, 809, 810, 811, 812, 944,
4923 813, 945, 814, 946, 815, 947, 816, 817, 818, 950,
4924 1178, 819, 186, 461, 846, 847, 848, 849, 850, 851,
4925 852, 187, 467, 882, 883, 884, 885, 886, 188, 464,
4926 861, 862, 863, 981, 59, 75, 363, 364, 365, 525,
4927 366, 526, 189, 465, 870, 871, 872, 873, 874, 875,
4928 876, 877, 190, 450, 826, 827, 828, 961, 47, 69,
4929 259, 260, 261, 489, 262, 485, 263, 486, 264, 487,
4930 265, 490, 266, 493, 267, 492, 191, 192, 193, 194,
4931 457, 708, 272, 195, 454, 838, 839, 840, 970, 1087,
4932 1088, 196, 451, 53, 72, 830, 831, 832, 964, 55,
4933 73, 328, 329, 330, 331, 332, 333, 334, 511, 335,
4934 515, 336, 514, 337, 338, 516, 339, 197, 452, 834,
4935 835, 836, 967, 57, 74, 349, 350, 351, 352, 353,
4936 520, 354, 355, 356, 357, 274, 488, 921, 922, 923,
4937 1017, 49, 70, 287, 288, 289, 497, 198, 455, 199,
4938 456, 200, 463, 857, 858, 859, 978, 51, 71, 304,
4939 305, 306, 201, 421, 202, 422, 203, 423, 310, 507,
4940 926, 1020, 311, 501, 312, 502, 313, 504, 314, 503,
4941 315, 506, 316, 505, 317, 500, 281, 494, 927, 204,
4942 462, 854, 855, 975, 1112, 1113, 1114, 1115, 1116, 1185,
4943 1117, 205, 206, 468, 894, 895, 896, 997, 897, 998,
4944 207, 469, 904, 905, 906, 907, 1002, 908, 909, 1004,
4945 208, 470, 61, 76, 385, 386, 387, 388, 531, 389,
4946 390, 533, 391, 392, 393, 536, 761, 394, 537, 395,
4947 530, 396, 397, 398, 540, 399, 541, 400, 542, 401,
4948 543, 209, 415, 63, 77, 404, 405, 406, 546, 407,
4949 210, 474, 912, 913, 1008, 1149, 1150, 1151, 1152, 1197,
4950 1153, 1195, 1215, 1216, 1217, 1225, 1226, 1227, 1233, 1228,
4951 1229, 1230, 1231, 1237, 211, 475, 916, 917, 918
4952 };
4953
4954 const short
4955 Dhcp4Parser::yytable_[] =
4956 {
4957 148, 216, 235, 283, 300, 284, 326, 345, 362, 382,
4958 78, 347, 820, 1079, 278, 1080, 307, 223, 275, 290,
4959 302, 736, 340, 358, 1095, 383, 318, 740, 701, 239,
4960 277, 28, 348, 759, 273, 286, 301, 360, 361, 973,
4961 327, 346, 974, 29, 914, 30, 240, 31, 360, 361,
4962 689, 690, 691, 692, 279, 40, 308, 241, 147, 477,
4963 224, 276, 291, 303, 478, 341, 359, 42, 384, 724,
4964 725, 81, 280, 236, 309, 841, 842, 843, 844, 237,
4965 845, 44, 212, 213, 693, 46, 214, 48, 483, 215,
4966 701, 242, 238, 484, 243, 495, 498, 50, 244, 122,
4967 496, 499, 245, 527, 246, 147, 52, 976, 528, 247,
4968 977, 320, 248, 544, 249, 250, 251, 84, 545, 252,
4969 253, 54, 254, 319, 126, 127, 255, 256, 402, 403,
4970 257, 548, 258, 268, 269, 408, 549, 270, 271, 56,
4971 285, 477, 776, 92, 93, 94, 929, 777, 778, 779,
4972 780, 781, 782, 783, 784, 785, 786, 787, 788, 789,
4973 790, 791, 727, 728, 58, 792, 793, 794, 795, 1220,
4974 126, 127, 1221, 1222, 1223, 1224, 98, 99, 100, 320,
4975 409, 321, 322, 760, 548, 323, 324, 325, 410, 930,
4976 126, 127, 126, 127, 86, 483, 60, 87, 320, 1142,
4977 931, 1143, 1144, 122, 123, 320, 88, 62, 89, 90,
4978 91, 92, 93, 94, 95, 96, 97, 1009, 126, 127,
4979 1010, 411, 147, 412, 126, 127, 1079, 1218, 1080, 414,
4980 1219, 878, 879, 880, 1098, 1099, 418, 1095, 933, 32,
4981 33, 34, 35, 934, 98, 99, 100, 101, 102, 103,
4982 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
4983 114, 115, 116, 117, 118, 119, 120, 121, 147, 889,
4984 890, 122, 123, 955, 508, 92, 93, 94, 956, 123,
4985 955, 509, 124, 125, 1046, 957, 126, 127, 147, 419,
4986 147, 128, 282, 126, 127, 420, 129, 130, 131, 132,
4987 133, 990, 995, 299, 924, 134, 991, 996, 232, 147,
4988 427, 233, 999, 126, 127, 135, 147, 1000, 136, 1005,
4989 510, 428, 147, 544, 1006, 137, 138, 1012, 1007, 955,
4990 139, 429, 1013, 140, 1179, 430, 123, 141, 431, 320,
4991 342, 321, 322, 343, 344, 704, 705, 706, 707, 495,
4992 126, 127, 126, 127, 1180, 550, 551, 142, 143, 144,
4993 145, 898, 899, 900, 292, 1163, 1164, 1165, 1166, 146,
4994 293, 294, 295, 296, 297, 298, 432, 299, 864, 865,
4995 866, 867, 868, 869, 147, 1183, 1175, 1176, 1177, 433,
4996 1184, 147, 1, 2, 3, 4, 5, 6, 7, 8,
4997 9, 10, 11, 12, 13, 434, 435, 527, 1198, 498,
4998 148, 901, 1190, 1199, 1201, 1238, 216, 436, 437, 439,
4999 1239, 440, 557, 441, 442, 443, 447, 448, 235, 449,
5000 453, 283, 223, 284, 458, 459, 460, 466, 473, 476,
5001 278, 482, 300, 491, 275, 513, 517, 290, 147, 519,
5002 147, 518, 326, 521, 307, 239, 277, 345, 302, 522,
5003 273, 347, 523, 286, 524, 552, 529, 532, 340, 534,
5004 535, 538, 240, 358, 301, 224, 539, 382, 547, 553,
5005 279, 554, 348, 241, 555, 556, 327, 276, 558, 560,
5006 291, 346, 559, 383, 308, 561, 562, 563, 280, 236,
5007 564, 303, 565, 566, 567, 237, 568, 569, 577, 570,
5008 575, 341, 309, 576, 571, 578, 359, 242, 238, 580,
5009 243, 126, 127, 579, 244, 572, 573, 583, 245, 581,
5010 246, 574, 584, 582, 585, 247, 384, 586, 248, 587,
5011 249, 250, 251, 588, 589, 252, 253, 590, 254, 591,
5012 592, 593, 255, 256, 1202, 594, 257, 595, 258, 268,
5013 269, 596, 597, 270, 271, 598, 599, 600, 285, 601,
5014 602, 603, 604, 367, 368, 369, 370, 371, 372, 373,
5015 374, 375, 376, 377, 378, 379, 605, 606, 607, 608,
5016 609, 610, 380, 381, 611, 612, 613, 614, 616, 617,
5017 618, 619, 621, 622, 623, 624, 625, 626, 628, 627,
5018 629, 148, 630, 216, 632, 634, 678, 635, 636, 147,
5019 637, 638, 639, 768, 640, 641, 643, 644, 646, 223,
5020 645, 647, 648, 649, 651, 655, 656, 659, 90, 91,
5021 92, 93, 94, 660, 652, 662, 661, 881, 891, 653,
5022 382, 658, 663, 664, 915, 665, 666, 667, 669, 670,
5023 668, 671, 672, 887, 892, 902, 383, 674, 677, 679,
5024 675, 682, 224, 98, 99, 100, 101, 102, 103, 104,
5025 105, 106, 107, 680, 681, 683, 685, 112, 113, 114,
5026 115, 116, 117, 118, 119, 120, 684, 225, 226, 227,
5027 686, 123, 687, 688, 695, 697, 888, 893, 903, 384,
5028 696, 698, 699, 228, 700, 126, 127, 229, 230, 231,
5029 128, 30, 703, 709, 710, 129, 130, 131, 711, 712,
5030 232, 720, 713, 233, 134, 714, 715, 716, 717, 718,
5031 719, 234, 721, 722, 733, 730, 772, 731, 738, 732,
5032 734, 735, 767, 737, 939, 739, 741, 742, 762, 743,
5033 744, 745, 746, 747, 821, 748, 825, 829, 833, 837,
5034 749, 750, 751, 752, 753, 754, 756, 757, 758, 764,
5035 765, 766, 853, 856, 860, 911, 142, 143, 920, 940,
5036 941, 942, 943, 948, 949, 951, 952, 953, 954, 960,
5037 755, 959, 963, 962, 965, 966, 968, 969, 972, 971,
5038 980, 1030, 979, 147, 982, 983, 1014, 984, 985, 986,
5039 987, 988, 989, 992, 993, 994, 1001, 1003, 1011, 1019,
5040 1032, 1018, 769, 1023, 1022, 1021, 1025, 1026, 1027, 1028,
5041 1029, 1034, 1031, 1035, 1033, 1036, 1037, 1038, 1039, 1040,
5042 1041, 1042, 1134, 1135, 1043, 1044, 1138, 1140, 1123, 1158,
5043 1157, 1124, 1125, 1126, 1161, 1181, 1182, 1127, 1128, 1186,
5044 1131, 1130, 1132, 1137, 1139, 1155, 1162, 1187, 1188, 1168,
5045 1189, 1169, 1170, 1171, 1172, 1173, 1174, 1191, 1192, 1193,
5046 1196, 1200, 1204, 1205, 235, 1207, 1208, 326, 1209, 1211,
5047 345, 1212, 1213, 1054, 347, 1081, 278, 1214, 1100, 1234,
5048 275, 300, 1235, 340, 362, 1092, 358, 1236, 1240, 1090,
5049 1109, 239, 277, 307, 1107, 348, 273, 302, 881, 1105,
5050 1058, 327, 891, 1244, 346, 1089, 1241, 1078, 240, 1242,
5051 1106, 1145, 1104, 301, 887, 915, 279, 1059, 892, 241,
5052 283, 1243, 284, 276, 902, 1093, 341, 1147, 1060, 359,
5053 1110, 763, 1091, 308, 280, 236, 290, 1108, 1246, 1247,
5054 303, 237, 620, 1094, 1055, 1146, 615, 771, 1111, 1101,
5055 1056, 309, 286, 242, 238, 1102, 243, 888, 1024, 928,
5056 244, 893, 1061, 1057, 245, 1062, 246, 903, 1103, 1063,
5057 1148, 247, 1047, 1064, 248, 1065, 249, 250, 251, 291,
5058 1066, 252, 253, 1067, 254, 1068, 1069, 1070, 255, 256,
5059 1071, 1072, 257, 1073, 258, 268, 269, 1074, 1075, 270,
5060 271, 1076, 1045, 1077, 1083, 1084, 1133, 1122, 1085, 1086,
5061 1082, 657, 1049, 1121, 1097, 1048, 1203, 1096, 1051, 1129,
5062 1050, 650, 1053, 654, 1119, 1052, 1160, 925, 910, 1206,
5063 673, 1159, 770, 676, 1210, 1136, 1232, 1245, 0, 0,
5064 1118, 1120, 0, 0, 0, 0, 631, 1141, 0, 0,
5065 633, 0, 1154, 0, 0, 0, 1194, 285, 0, 0,
5066 0, 0, 0, 1156, 0, 0, 0, 642, 0, 0,
5067 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5068 0, 0, 0, 0, 0, 0, 1054, 0, 1081, 0,
5069 0, 1100, 0, 0, 0, 0, 0, 0, 1092, 0,
5070 0, 1145, 1090, 1109, 0, 0, 0, 1107, 0, 0,
5071 0, 0, 1105, 1058, 0, 0, 0, 1147, 1089, 0,
5072 1078, 0, 0, 1106, 0, 1104, 0, 0, 0, 0,
5073 1059, 0, 0, 0, 0, 1146, 0, 0, 1093, 0,
5074 0, 1060, 0, 1110, 0, 1091, 0, 0, 0, 0,
5075 1108, 0, 0, 0, 0, 0, 1094, 1055, 0, 0,
5076 1148, 1111, 1101, 1056, 0, 0, 0, 0, 1102, 0,
5077 0, 0, 0, 0, 0, 1061, 1057, 0, 1062, 0,
5078 0, 1103, 1063, 0, 0, 0, 1064, 0, 1065, 0,
5079 0, 0, 0, 1066, 0, 0, 1067, 0, 1068, 1069,
5080 1070, 0, 0, 1071, 1072, 0, 1073, 0, 0, 0,
5081 1074, 1075, 0, 0, 1076, 0, 1077, 1083, 1084, 0,
5082 0, 1085, 1086, 1082, 90, 91, 92, 93, 94, 0,
5083 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5084 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5085 0, 0, 0, 0, 0, 0, 0, 0, 0, 98,
5086 99, 100, 101, 102, 103, 104, 105, 106, 107, 0,
5087 0, 0, 0, 112, 113, 114, 115, 116, 117, 118,
5088 119, 120, 121, 0, 0, 0, 0, 123, 320, 0,
5089 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5090 0, 126, 127, 0, 230, 0, 128, 0, 0, 0,
5091 0, 129, 130, 131, 0, 0, 232, 0, 0, 233,
5092 0, 0, 0, 0, 0, 0, 0, 234, 0, 0,
5093 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5094 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5095 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5096 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5097 0, 0, 142, 143, 0, 0, 0, 0, 0, 0,
5098 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5099 0, 0, 0, 0, 0, 0, 0, 0, 0, 147
5100 };
5101
5102 const short
5103 Dhcp4Parser::yycheck_[] =
5104 {
5105 67, 68, 69, 70, 71, 70, 73, 74, 75, 76,
5106 64, 74, 686, 970, 69, 970, 71, 68, 69, 70,
5107 71, 628, 73, 74, 970, 76, 72, 634, 594, 69,
5108 69, 0, 74, 18, 69, 70, 71, 133, 134, 3,
5109 73, 74, 6, 5, 187, 7, 69, 9, 133, 134,
5110 170, 171, 172, 173, 69, 7, 71, 69, 201, 3,
5111 68, 69, 70, 71, 8, 73, 74, 7, 76, 17,
5112 18, 201, 69, 69, 71, 123, 124, 125, 126, 69,
5113 128, 7, 15, 16, 204, 7, 19, 7, 3, 22,
5114 656, 69, 69, 8, 69, 3, 3, 7, 69, 88,
5115 8, 8, 69, 3, 69, 201, 7, 3, 8, 69,
5116 6, 90, 69, 3, 69, 69, 69, 10, 8, 69,
5117 69, 7, 69, 34, 103, 104, 69, 69, 12, 13,
5118 69, 3, 69, 69, 69, 6, 8, 69, 69, 7,
5119 70, 3, 34, 28, 29, 30, 8, 39, 40, 41,
5120 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
5121 52, 53, 20, 21, 7, 57, 58, 59, 60, 179,
5122 103, 104, 182, 183, 184, 185, 61, 62, 63, 90,
5123 3, 92, 93, 168, 3, 96, 97, 98, 4, 8,
5124 103, 104, 103, 104, 11, 3, 7, 14, 90, 178,
5125 8, 180, 181, 88, 89, 90, 23, 7, 25, 26,
5126 27, 28, 29, 30, 31, 32, 33, 3, 103, 104,
5127 6, 8, 201, 3, 103, 104, 1183, 3, 1183, 8,
5128 6, 144, 145, 146, 119, 120, 4, 1183, 3, 201,
5129 202, 203, 204, 8, 61, 62, 63, 64, 65, 66,
5130 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
5131 77, 78, 79, 80, 81, 82, 83, 84, 201, 148,
5132 149, 88, 89, 3, 8, 28, 29, 30, 8, 89,
5133 3, 3, 99, 100, 958, 8, 103, 104, 201, 4,
5134 201, 108, 102, 103, 104, 4, 113, 114, 115, 116,
5135 117, 3, 3, 130, 131, 122, 8, 8, 118, 201,
5136 4, 121, 3, 103, 104, 132, 201, 8, 135, 3,
5137 8, 4, 201, 3, 8, 142, 143, 3, 8, 3,
5138 147, 4, 8, 150, 8, 4, 89, 154, 4, 90,
5139 91, 92, 93, 94, 95, 109, 110, 111, 112, 3,
5140 103, 104, 103, 104, 8, 409, 410, 174, 175, 176,
5141 177, 151, 152, 153, 117, 35, 36, 37, 38, 186,
5142 123, 124, 125, 126, 127, 128, 4, 130, 136, 137,
5143 138, 139, 140, 141, 201, 3, 54, 55, 56, 4,
5144 8, 201, 188, 189, 190, 191, 192, 193, 194, 195,
5145 196, 197, 198, 199, 200, 4, 4, 3, 3, 3,
5146 477, 201, 8, 8, 8, 3, 483, 4, 4, 4,
5147 8, 4, 204, 4, 4, 4, 4, 4, 495, 4,
5148 4, 498, 483, 498, 4, 4, 4, 4, 4, 4,
5149 495, 4, 509, 4, 495, 4, 4, 498, 201, 3,
5150 201, 8, 519, 4, 509, 495, 495, 524, 509, 4,
5151 495, 524, 8, 498, 3, 201, 4, 4, 519, 4,
5152 4, 4, 495, 524, 509, 483, 4, 544, 4, 4,
5153 495, 4, 524, 495, 4, 4, 519, 495, 204, 4,
5154 498, 524, 204, 544, 509, 4, 4, 4, 495, 495,
5155 4, 509, 4, 202, 202, 495, 202, 202, 4, 202,
5156 202, 519, 509, 202, 204, 202, 524, 495, 495, 204,
5157 495, 103, 104, 202, 495, 203, 203, 4, 495, 204,
5158 495, 203, 4, 204, 4, 495, 544, 204, 495, 204,
5159 495, 495, 495, 204, 4, 495, 495, 4, 495, 4,
5160 202, 4, 495, 495, 1161, 4, 495, 4, 495, 495,
5161 495, 4, 204, 495, 495, 204, 204, 4, 498, 4,
5162 4, 4, 4, 155, 156, 157, 158, 159, 160, 161,
5163 162, 163, 164, 165, 166, 167, 202, 4, 4, 4,
5164 4, 4, 174, 175, 4, 204, 4, 4, 4, 4,
5165 4, 204, 4, 4, 4, 4, 4, 4, 4, 202,
5166 4, 678, 4, 680, 4, 4, 7, 4, 4, 201,
5167 4, 4, 4, 677, 4, 4, 4, 4, 4, 680,
5168 202, 4, 4, 204, 4, 4, 4, 4, 26, 27,
5169 28, 29, 30, 4, 204, 4, 202, 714, 715, 204,
5170 717, 204, 202, 202, 721, 4, 4, 204, 4, 4,
5171 204, 4, 4, 714, 715, 716, 717, 4, 4, 7,
5172 202, 201, 680, 61, 62, 63, 64, 65, 66, 67,
5173 68, 69, 70, 7, 7, 201, 7, 75, 76, 77,
5174 78, 79, 80, 81, 82, 83, 201, 85, 86, 87,
5175 7, 89, 5, 201, 201, 5, 714, 715, 716, 717,
5176 201, 5, 5, 101, 5, 103, 104, 105, 106, 107,
5177 108, 7, 201, 5, 5, 113, 114, 115, 5, 5,
5178 118, 5, 7, 121, 122, 7, 7, 7, 7, 201,
5179 201, 129, 7, 5, 5, 201, 24, 201, 7, 201,
5180 201, 201, 5, 201, 4, 201, 201, 201, 169, 201,
5181 201, 201, 201, 201, 7, 201, 7, 7, 7, 7,
5182 201, 201, 201, 201, 201, 201, 201, 201, 201, 201,
5183 201, 201, 7, 7, 7, 7, 174, 175, 7, 4,
5184 4, 4, 4, 4, 4, 4, 4, 4, 4, 3,
5185 656, 6, 3, 6, 6, 3, 6, 3, 3, 6,
5186 3, 204, 6, 201, 6, 3, 201, 4, 4, 4,
5187 4, 4, 4, 4, 4, 4, 4, 4, 4, 3,
5188 204, 6, 678, 4, 6, 8, 4, 4, 4, 4,
5189 202, 4, 202, 4, 202, 4, 4, 202, 202, 4,
5190 202, 202, 4, 4, 204, 202, 4, 4, 202, 3,
5191 6, 202, 202, 202, 4, 8, 8, 202, 202, 4,
5192 202, 204, 202, 204, 202, 204, 201, 8, 3, 201,
5193 8, 201, 201, 201, 201, 201, 201, 201, 201, 201,
5194 4, 201, 4, 204, 961, 4, 202, 964, 4, 201,
5195 967, 5, 201, 970, 967, 970, 961, 7, 975, 4,
5196 961, 978, 4, 964, 981, 970, 967, 4, 4, 970,
5197 975, 961, 961, 978, 975, 967, 961, 978, 995, 975,
5198 970, 964, 999, 4, 967, 970, 204, 970, 961, 202,
5199 975, 1008, 975, 978, 995, 1012, 961, 970, 999, 961,
5200 1017, 202, 1017, 961, 1005, 970, 964, 1008, 970, 967,
5201 975, 669, 970, 978, 961, 961, 1017, 975, 201, 201,
5202 978, 961, 483, 970, 970, 1008, 477, 680, 975, 975,
5203 970, 978, 1017, 961, 961, 975, 961, 995, 933, 767,
5204 961, 999, 970, 970, 961, 970, 961, 1005, 975, 970,
5205 1008, 961, 960, 970, 961, 970, 961, 961, 961, 1017,
5206 970, 961, 961, 970, 961, 970, 970, 970, 961, 961,
5207 970, 970, 961, 970, 961, 961, 961, 970, 970, 961,
5208 961, 970, 955, 970, 970, 970, 995, 983, 970, 970,
5209 970, 527, 963, 981, 973, 961, 1183, 972, 966, 990,
5210 964, 519, 969, 524, 978, 967, 1019, 738, 717, 1188,
5211 544, 1017, 679, 548, 1198, 999, 1218, 1238, -1, -1,
5212 976, 980, -1, -1, -1, -1, 495, 1005, -1, -1,
5213 498, -1, 1009, -1, -1, -1, 1140, 1017, -1, -1,
5214 -1, -1, -1, 1012, -1, -1, -1, 509, -1, -1,
5215 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5216 -1, -1, -1, -1, -1, -1, 1183, -1, 1183, -1,
5217 -1, 1188, -1, -1, -1, -1, -1, -1, 1183, -1,
5218 -1, 1198, 1183, 1188, -1, -1, -1, 1188, -1, -1,
5219 -1, -1, 1188, 1183, -1, -1, -1, 1198, 1183, -1,
5220 1183, -1, -1, 1188, -1, 1188, -1, -1, -1, -1,
5221 1183, -1, -1, -1, -1, 1198, -1, -1, 1183, -1,
5222 -1, 1183, -1, 1188, -1, 1183, -1, -1, -1, -1,
5223 1188, -1, -1, -1, -1, -1, 1183, 1183, -1, -1,
5224 1198, 1188, 1188, 1183, -1, -1, -1, -1, 1188, -1,
5225 -1, -1, -1, -1, -1, 1183, 1183, -1, 1183, -1,
5226 -1, 1188, 1183, -1, -1, -1, 1183, -1, 1183, -1,
5227 -1, -1, -1, 1183, -1, -1, 1183, -1, 1183, 1183,
5228 1183, -1, -1, 1183, 1183, -1, 1183, -1, -1, -1,
5229 1183, 1183, -1, -1, 1183, -1, 1183, 1183, 1183, -1,
5230 -1, 1183, 1183, 1183, 26, 27, 28, 29, 30, -1,
5231 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5232 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5233 -1, -1, -1, -1, -1, -1, -1, -1, -1, 61,
5234 62, 63, 64, 65, 66, 67, 68, 69, 70, -1,
5235 -1, -1, -1, 75, 76, 77, 78, 79, 80, 81,
5236 82, 83, 84, -1, -1, -1, -1, 89, 90, -1,
5237 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5238 -1, 103, 104, -1, 106, -1, 108, -1, -1, -1,
5239 -1, 113, 114, 115, -1, -1, 118, -1, -1, 121,
5240 -1, -1, -1, -1, -1, -1, -1, 129, -1, -1,
5241 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5242 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5243 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5244 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5245 -1, -1, 174, 175, -1, -1, -1, -1, -1, -1,
5246 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
5247 -1, -1, -1, -1, -1, -1, -1, -1, -1, 201
5248 };
5249
5250 const short
5251 Dhcp4Parser::yystos_[] =
5252 {
5253 0, 188, 189, 190, 191, 192, 193, 194, 195, 196,
5254 197, 198, 199, 200, 206, 207, 208, 209, 210, 211,
5255 212, 213, 214, 215, 216, 217, 218, 219, 0, 5,
5256 7, 9, 201, 202, 203, 204, 220, 221, 222, 227,
5257 7, 236, 7, 240, 7, 285, 7, 393, 7, 476,
5258 7, 492, 7, 428, 7, 434, 7, 458, 7, 369,
5259 7, 557, 7, 588, 228, 223, 237, 241, 286, 394,
5260 477, 493, 429, 435, 459, 370, 558, 589, 220, 229,
5261 230, 201, 225, 226, 10, 238, 11, 14, 23, 25,
5262 26, 27, 28, 29, 30, 31, 32, 33, 61, 62,
5263 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
5264 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
5265 83, 84, 88, 89, 99, 100, 103, 104, 108, 113,
5266 114, 115, 116, 117, 122, 132, 135, 142, 143, 147,
5267 150, 154, 174, 175, 176, 177, 186, 201, 235, 242,
5268 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
5269 253, 254, 255, 257, 258, 259, 260, 261, 262, 263,
5270 264, 267, 269, 271, 272, 273, 275, 277, 278, 279,
5271 280, 281, 296, 298, 304, 306, 347, 356, 363, 377,
5272 387, 411, 412, 413, 414, 418, 426, 452, 482, 484,
5273 486, 497, 499, 501, 524, 536, 537, 545, 555, 586,
5274 595, 619, 15, 16, 19, 22, 235, 283, 284, 287,
5275 289, 292, 295, 482, 484, 85, 86, 87, 101, 105,
5276 106, 107, 118, 121, 129, 235, 244, 245, 246, 247,
5277 248, 249, 250, 251, 252, 253, 259, 260, 261, 262,
5278 263, 264, 267, 269, 271, 272, 273, 275, 277, 395,
5279 396, 397, 399, 401, 403, 405, 407, 409, 411, 412,
5280 413, 414, 417, 452, 470, 482, 484, 486, 497, 499,
5281 501, 521, 102, 235, 407, 409, 452, 478, 479, 480,
5282 482, 484, 117, 123, 124, 125, 126, 127, 128, 130,
5283 235, 452, 482, 484, 494, 495, 496, 497, 499, 501,
5284 503, 507, 509, 511, 513, 515, 517, 519, 426, 34,
5285 90, 92, 93, 96, 97, 98, 235, 324, 436, 437,
5286 438, 439, 440, 441, 442, 444, 446, 448, 449, 451,
5287 482, 484, 91, 94, 95, 235, 324, 440, 446, 460,
5288 461, 462, 463, 464, 466, 467, 468, 469, 482, 484,
5289 133, 134, 235, 371, 372, 373, 375, 155, 156, 157,
5290 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
5291 174, 175, 235, 482, 484, 559, 560, 561, 562, 564,
5292 565, 567, 568, 569, 572, 574, 576, 577, 578, 580,
5293 582, 584, 12, 13, 590, 591, 592, 594, 6, 3,
5294 4, 8, 3, 239, 8, 587, 282, 299, 4, 4,
5295 4, 498, 500, 502, 297, 305, 307, 4, 4, 4,
5296 4, 4, 4, 4, 4, 4, 4, 4, 256, 4,
5297 4, 4, 4, 4, 265, 268, 270, 4, 4, 4,
5298 388, 427, 453, 4, 419, 483, 485, 415, 4, 4,
5299 4, 348, 525, 487, 364, 378, 4, 357, 538, 546,
5300 556, 274, 276, 4, 596, 620, 4, 3, 8, 288,
5301 290, 293, 4, 3, 8, 400, 402, 404, 471, 398,
5302 406, 4, 410, 408, 522, 3, 8, 481, 3, 8,
5303 520, 508, 510, 514, 512, 518, 516, 504, 8, 3,
5304 8, 443, 325, 4, 447, 445, 450, 4, 8, 3,
5305 465, 4, 4, 8, 3, 374, 376, 3, 8, 4,
5306 575, 563, 4, 566, 4, 4, 570, 573, 4, 4,
5307 579, 581, 583, 585, 3, 8, 593, 4, 3, 8,
5308 220, 220, 201, 4, 4, 4, 4, 204, 204, 204,
5309 4, 4, 4, 4, 4, 4, 202, 202, 202, 202,
5310 202, 204, 203, 203, 203, 202, 202, 4, 202, 202,
5311 204, 204, 204, 4, 4, 4, 204, 204, 204, 4,
5312 4, 4, 202, 4, 4, 4, 4, 204, 204, 204,
5313 4, 4, 4, 4, 4, 202, 4, 4, 4, 4,
5314 4, 4, 204, 4, 4, 243, 4, 4, 4, 204,
5315 284, 4, 4, 4, 4, 4, 4, 202, 4, 4,
5316 4, 396, 4, 479, 4, 4, 4, 4, 4, 4,
5317 4, 4, 496, 4, 4, 202, 4, 4, 4, 204,
5318 438, 4, 204, 204, 462, 4, 4, 372, 204, 4,
5319 4, 202, 4, 202, 202, 4, 4, 204, 204, 4,
5320 4, 4, 4, 560, 4, 202, 591, 4, 7, 7,
5321 7, 7, 201, 201, 201, 7, 7, 5, 201, 170,
5322 171, 172, 173, 204, 266, 201, 201, 5, 5, 5,
5323 5, 222, 224, 201, 109, 110, 111, 112, 416, 5,
5324 5, 5, 5, 7, 7, 7, 7, 7, 201, 201,
5325 5, 7, 5, 231, 17, 18, 291, 20, 21, 294,
5326 201, 201, 201, 5, 201, 201, 231, 201, 7, 201,
5327 231, 201, 201, 201, 201, 201, 201, 201, 201, 201,
5328 201, 201, 201, 201, 201, 224, 201, 201, 201, 18,
5329 168, 571, 169, 266, 201, 201, 201, 5, 220, 242,
5330 590, 283, 24, 300, 301, 302, 34, 39, 40, 41,
5331 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
5332 52, 53, 57, 58, 59, 60, 235, 312, 313, 314,
5333 317, 319, 321, 323, 324, 326, 327, 328, 329, 330,
5334 331, 332, 333, 335, 337, 339, 341, 342, 343, 346,
5335 312, 7, 308, 309, 310, 7, 389, 390, 391, 7,
5336 430, 431, 432, 7, 454, 455, 456, 7, 420, 421,
5337 422, 123, 124, 125, 126, 128, 349, 350, 351, 352,
5338 353, 354, 355, 7, 526, 527, 7, 488, 489, 490,
5339 7, 365, 366, 367, 136, 137, 138, 139, 140, 141,
5340 379, 380, 381, 382, 383, 384, 385, 386, 144, 145,
5341 146, 235, 358, 359, 360, 361, 362, 482, 484, 148,
5342 149, 235, 482, 484, 539, 540, 541, 543, 151, 152,
5343 153, 201, 482, 484, 547, 548, 549, 550, 552, 553,
5344 559, 7, 597, 598, 187, 235, 621, 622, 623, 232,
5345 7, 472, 473, 474, 131, 503, 505, 523, 308, 8,
5346 8, 8, 303, 3, 8, 315, 318, 320, 322, 4,
5347 4, 4, 4, 4, 334, 336, 338, 340, 4, 4,
5348 344, 4, 4, 4, 4, 3, 8, 8, 311, 6,
5349 3, 392, 6, 3, 433, 6, 3, 457, 6, 3,
5350 423, 6, 3, 3, 6, 528, 3, 6, 491, 6,
5351 3, 368, 6, 3, 4, 4, 4, 4, 4, 4,
5352 3, 8, 4, 4, 4, 3, 8, 542, 544, 3,
5353 8, 4, 551, 4, 554, 3, 8, 8, 599, 3,
5354 6, 4, 3, 8, 201, 233, 234, 475, 6, 3,
5355 506, 8, 6, 4, 301, 4, 4, 4, 4, 202,
5356 204, 202, 204, 202, 4, 4, 4, 4, 202, 202,
5357 4, 202, 202, 204, 202, 313, 312, 310, 395, 391,
5358 436, 432, 460, 456, 235, 244, 245, 246, 247, 248,
5359 249, 250, 251, 252, 253, 259, 260, 261, 262, 263,
5360 264, 267, 269, 271, 272, 273, 275, 277, 324, 387,
5361 405, 407, 409, 411, 412, 413, 414, 424, 425, 452,
5362 482, 484, 497, 499, 501, 521, 422, 350, 119, 120,
5363 235, 244, 245, 246, 324, 426, 452, 482, 484, 497,
5364 499, 501, 529, 530, 531, 532, 533, 535, 527, 494,
5365 490, 371, 367, 202, 202, 202, 202, 202, 202, 380,
5366 204, 202, 202, 359, 4, 4, 540, 204, 4, 202,
5367 4, 548, 178, 180, 181, 235, 324, 482, 484, 600,
5368 601, 602, 603, 605, 598, 204, 622, 6, 3, 478,
5369 474, 4, 201, 35, 36, 37, 38, 316, 201, 201,
5370 201, 201, 201, 201, 201, 54, 55, 56, 345, 8,
5371 8, 8, 8, 3, 8, 534, 4, 8, 3, 8,
5372 8, 201, 201, 201, 220, 606, 4, 604, 3, 8,
5373 201, 8, 231, 425, 4, 204, 531, 4, 202, 4,
5374 601, 201, 5, 201, 7, 607, 608, 609, 3, 6,
5375 179, 182, 183, 184, 185, 610, 611, 612, 614, 615,
5376 616, 617, 608, 613, 4, 4, 4, 618, 3, 8,
5377 4, 204, 202, 202, 4, 611, 201, 201
5378 };
5379
5380 const short
5381 Dhcp4Parser::yyr1_[] =
5382 {
5383 0, 205, 207, 206, 208, 206, 209, 206, 210, 206,
5384 211, 206, 212, 206, 213, 206, 214, 206, 215, 206,
5385 216, 206, 217, 206, 218, 206, 219, 206, 220, 220,
5386 220, 220, 220, 220, 220, 221, 223, 222, 224, 225,
5387 225, 226, 226, 228, 227, 229, 229, 230, 230, 232,
5388 231, 233, 233, 234, 234, 235, 237, 236, 239, 238,
5389 241, 240, 242, 242, 243, 243, 243, 243, 243, 243,
5390 243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
5391 243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
5392 243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
5393 243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
5394 243, 243, 243, 243, 243, 243, 243, 243, 243, 243,
5395 243, 243, 243, 243, 243, 243, 244, 245, 246, 247,
5396 248, 249, 250, 251, 252, 253, 254, 256, 255, 257,
5397 258, 259, 260, 261, 262, 263, 265, 264, 266, 266,
5398 266, 266, 266, 268, 267, 270, 269, 271, 272, 274,
5399 273, 276, 275, 277, 278, 279, 280, 282, 281, 283,
5400 283, 284, 284, 284, 284, 284, 284, 284, 286, 285,
5401 288, 287, 290, 289, 291, 291, 293, 292, 294, 294,
5402 295, 297, 296, 299, 298, 300, 300, 301, 303, 302,
5403 305, 304, 307, 306, 308, 308, 309, 309, 311, 310,
5404 312, 312, 313, 313, 313, 313, 313, 313, 313, 313,
5405 313, 313, 313, 313, 313, 313, 313, 313, 313, 313,
5406 313, 313, 313, 313, 315, 314, 316, 316, 316, 316,
5407 318, 317, 320, 319, 322, 321, 323, 325, 324, 326,
5408 327, 328, 329, 330, 331, 332, 334, 333, 336, 335,
5409 338, 337, 340, 339, 341, 342, 344, 343, 345, 345,
5410 345, 346, 348, 347, 349, 349, 350, 350, 350, 350,
5411 350, 351, 352, 353, 354, 355, 357, 356, 358, 358,
5412 359, 359, 359, 359, 359, 359, 360, 361, 362, 364,
5413 363, 365, 365, 366, 366, 368, 367, 370, 369, 371,
5414 371, 371, 372, 372, 374, 373, 376, 375, 378, 377,
5415 379, 379, 380, 380, 380, 380, 380, 380, 381, 382,
5416 383, 384, 385, 386, 388, 387, 389, 389, 390, 390,
5417 392, 391, 394, 393, 395, 395, 396, 396, 396, 396,
5418 396, 396, 396, 396, 396, 396, 396, 396, 396, 396,
5419 396, 396, 396, 396, 396, 396, 396, 396, 396, 396,
5420 396, 396, 396, 396, 396, 396, 396, 396, 396, 396,
5421 396, 396, 396, 396, 396, 396, 396, 396, 396, 396,
5422 396, 398, 397, 400, 399, 402, 401, 404, 403, 406,
5423 405, 408, 407, 410, 409, 411, 412, 413, 415, 414,
5424 416, 416, 416, 416, 417, 419, 418, 420, 420, 421,
5425 421, 423, 422, 424, 424, 425, 425, 425, 425, 425,
5426 425, 425, 425, 425, 425, 425, 425, 425, 425, 425,
5427 425, 425, 425, 425, 425, 425, 425, 425, 425, 425,
5428 425, 425, 425, 425, 425, 425, 425, 425, 425, 425,
5429 425, 425, 425, 425, 425, 427, 426, 429, 428, 430,
5430 430, 431, 431, 433, 432, 435, 434, 436, 436, 437,
5431 437, 438, 438, 438, 438, 438, 438, 438, 438, 438,
5432 438, 439, 440, 441, 443, 442, 445, 444, 447, 446,
5433 448, 450, 449, 451, 453, 452, 454, 454, 455, 455,
5434 457, 456, 459, 458, 460, 460, 461, 461, 462, 462,
5435 462, 462, 462, 462, 462, 462, 462, 463, 465, 464,
5436 466, 467, 468, 469, 471, 470, 472, 472, 473, 473,
5437 475, 474, 477, 476, 478, 478, 479, 479, 479, 479,
5438 479, 479, 479, 481, 480, 483, 482, 485, 484, 487,
5439 486, 488, 488, 489, 489, 491, 490, 493, 492, 494,
5440 494, 495, 495, 496, 496, 496, 496, 496, 496, 496,
5441 496, 496, 496, 496, 496, 496, 496, 496, 498, 497,
5442 500, 499, 502, 501, 504, 503, 506, 505, 508, 507,
5443 510, 509, 512, 511, 514, 513, 516, 515, 518, 517,
5444 520, 519, 522, 521, 523, 523, 525, 524, 526, 526,
5445 528, 527, 529, 529, 530, 530, 531, 531, 531, 531,
5446 531, 531, 531, 531, 531, 531, 531, 531, 531, 531,
5447 532, 534, 533, 535, 536, 538, 537, 539, 539, 540,
5448 540, 540, 540, 540, 542, 541, 544, 543, 546, 545,
5449 547, 547, 548, 548, 548, 548, 548, 548, 549, 551,
5450 550, 552, 554, 553, 556, 555, 558, 557, 559, 559,
5451 560, 560, 560, 560, 560, 560, 560, 560, 560, 560,
5452 560, 560, 560, 560, 560, 560, 560, 560, 561, 563,
5453 562, 564, 566, 565, 567, 568, 570, 569, 571, 571,
5454 573, 572, 575, 574, 576, 577, 579, 578, 581, 580,
5455 583, 582, 585, 584, 587, 586, 589, 588, 590, 590,
5456 591, 591, 593, 592, 594, 596, 595, 597, 597, 599,
5457 598, 600, 600, 601, 601, 601, 601, 601, 601, 601,
5458 602, 604, 603, 606, 605, 607, 607, 609, 608, 610,
5459 610, 611, 611, 611, 611, 611, 613, 612, 614, 615,
5460 616, 618, 617, 620, 619, 621, 621, 622, 622, 623
5461 };
5462
5463 const signed char
5464 Dhcp4Parser::yyr2_[] =
5465 {
5466 0, 2, 0, 3, 0, 3, 0, 3, 0, 3,
5467 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
5468 0, 3, 0, 3, 0, 3, 0, 3, 1, 1,
5469 1, 1, 1, 1, 1, 1, 0, 4, 1, 0,
5470 1, 3, 5, 0, 4, 0, 1, 1, 3, 0,
5471 4, 0, 1, 1, 3, 2, 0, 4, 0, 6,
5472 0, 4, 1, 3, 1, 1, 1, 1, 1, 1,
5473 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5474 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5475 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5476 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5477 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5478 1, 1, 1, 1, 1, 1, 3, 3, 3, 3,
5479 3, 3, 3, 3, 3, 3, 3, 0, 4, 3,
5480 3, 3, 3, 3, 3, 3, 0, 4, 1, 1,
5481 1, 1, 1, 0, 4, 0, 4, 3, 3, 0,
5482 4, 0, 4, 3, 3, 3, 3, 0, 6, 1,
5483 3, 1, 1, 1, 1, 1, 1, 1, 0, 4,
5484 0, 4, 0, 4, 1, 1, 0, 4, 1, 1,
5485 3, 0, 6, 0, 6, 1, 3, 1, 0, 4,
5486 0, 6, 0, 6, 0, 1, 1, 3, 0, 4,
5487 1, 3, 1, 1, 1, 1, 1, 1, 1, 1,
5488 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5489 1, 1, 1, 1, 0, 4, 1, 1, 1, 1,
5490 0, 4, 0, 4, 0, 4, 3, 0, 4, 3,
5491 3, 3, 3, 3, 3, 3, 0, 4, 0, 4,
5492 0, 4, 0, 4, 3, 3, 0, 4, 1, 1,
5493 1, 3, 0, 6, 1, 3, 1, 1, 1, 1,
5494 1, 1, 1, 1, 1, 1, 0, 6, 1, 3,
5495 1, 1, 1, 1, 1, 1, 3, 3, 3, 0,
5496 6, 0, 1, 1, 3, 0, 4, 0, 4, 1,
5497 3, 1, 1, 1, 0, 4, 0, 4, 0, 6,
5498 1, 3, 1, 1, 1, 1, 1, 1, 3, 3,
5499 3, 3, 3, 3, 0, 6, 0, 1, 1, 3,
5500 0, 4, 0, 4, 1, 3, 1, 1, 1, 1,
5501 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5502 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5503 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5504 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5505 1, 0, 4, 0, 4, 0, 4, 0, 4, 0,
5506 4, 0, 4, 0, 4, 3, 3, 3, 0, 4,
5507 1, 1, 1, 1, 3, 0, 6, 0, 1, 1,
5508 3, 0, 4, 1, 3, 1, 1, 1, 1, 1,
5509 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5510 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5511 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5512 1, 1, 1, 1, 1, 0, 6, 0, 4, 0,
5513 1, 1, 3, 0, 4, 0, 4, 0, 1, 1,
5514 3, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5515 1, 1, 3, 1, 0, 4, 0, 4, 0, 4,
5516 1, 0, 4, 3, 0, 6, 0, 1, 1, 3,
5517 0, 4, 0, 4, 0, 1, 1, 3, 1, 1,
5518 1, 1, 1, 1, 1, 1, 1, 1, 0, 4,
5519 1, 1, 3, 3, 0, 6, 0, 1, 1, 3,
5520 0, 4, 0, 4, 1, 3, 1, 1, 1, 1,
5521 1, 1, 1, 0, 4, 0, 4, 0, 4, 0,
5522 6, 0, 1, 1, 3, 0, 4, 0, 4, 0,
5523 1, 1, 3, 1, 1, 1, 1, 1, 1, 1,
5524 1, 1, 1, 1, 1, 1, 1, 1, 0, 4,
5525 0, 4, 0, 4, 0, 4, 0, 4, 0, 4,
5526 0, 4, 0, 4, 0, 4, 0, 4, 0, 4,
5527 0, 4, 0, 6, 1, 1, 0, 6, 1, 3,
5528 0, 4, 0, 1, 1, 3, 1, 1, 1, 1,
5529 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5530 1, 0, 4, 3, 3, 0, 6, 1, 3, 1,
5531 1, 1, 1, 1, 0, 4, 0, 4, 0, 6,
5532 1, 3, 1, 1, 1, 1, 1, 1, 3, 0,
5533 4, 3, 0, 4, 0, 6, 0, 4, 1, 3,
5534 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5535 1, 1, 1, 1, 1, 1, 1, 1, 3, 0,
5536 4, 3, 0, 4, 3, 3, 0, 4, 1, 1,
5537 0, 4, 0, 4, 3, 3, 0, 4, 0, 4,
5538 0, 4, 0, 4, 0, 6, 0, 4, 1, 3,
5539 1, 1, 0, 6, 3, 0, 6, 1, 3, 0,
5540 4, 1, 3, 1, 1, 1, 1, 1, 1, 1,
5541 3, 0, 4, 0, 6, 1, 3, 0, 4, 1,
5542 3, 1, 1, 1, 1, 1, 0, 4, 3, 3,
5543 3, 0, 4, 0, 6, 1, 3, 1, 1, 3
5544 };
5545
5546
5547 #if PARSER4_DEBUG || 1
5548 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
5549 // First, the terminals, then, starting at \a YYNTOKENS, nonterminals.
5550 const char*
5551 const Dhcp4Parser::yytname_[] =
5552 {
5553 "\"end of file\"", "error", "\"invalid token\"", "\",\"", "\":\"",
5554 "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"Dhcp4\"",
5555 "\"config-control\"", "\"config-databases\"",
5556 "\"config-fetch-wait-time\"", "\"interfaces-config\"", "\"interfaces\"",
5557 "\"dhcp-socket-type\"", "\"raw\"", "\"udp\"", "\"outbound-interface\"",
5558 "\"same-as-inbound\"", "\"use-routing\"", "\"re-detect\"",
5559 "\"sanity-checks\"", "\"lease-checks\"", "\"echo-client-id\"",
5560 "\"match-client-id\"", "\"authoritative\"", "\"next-server\"",
5561 "\"server-hostname\"", "\"boot-file-name\"", "\"lease-database\"",
5562 "\"hosts-database\"", "\"hosts-databases\"", "\"type\"", "\"memfile\"",
5563 "\"mysql\"", "\"postgresql\"", "\"cql\"", "\"user\"", "\"password\"",
5564 "\"host\"", "\"port\"", "\"persist\"", "\"lfc-interval\"",
5565 "\"readonly\"", "\"connect-timeout\"", "\"contact-points\"",
5566 "\"keyspace\"", "\"consistency\"", "\"serial-consistency\"",
5567 "\"max-reconnect-tries\"", "\"reconnect-wait-time\"", "\"on-fail\"",
5568 "\"stop-retry-exit\"", "\"serve-retry-exit\"",
5569 "\"serve-retry-continue\"", "\"request-timeout\"", "\"tcp-keepalive\"",
5570 "\"tcp-nodelay\"", "\"max-row-errors\"", "\"valid-lifetime\"",
5571 "\"min-valid-lifetime\"", "\"max-valid-lifetime\"", "\"renew-timer\"",
5572 "\"rebind-timer\"", "\"calculate-tee-times\"", "\"t1-percent\"",
5573 "\"t2-percent\"", "\"cache-threshold\"", "\"cache-max-age\"",
5574 "\"decline-probation-period\"", "\"server-tag\"",
5575 "\"statistic-default-sample-count\"", "\"statistic-default-sample-age\"",
5576 "\"ddns-send-updates\"", "\"ddns-override-no-update\"",
5577 "\"ddns-override-client-update\"", "\"ddns-replace-client-name\"",
5578 "\"ddns-generated-prefix\"", "\"ddns-qualifying-suffix\"",
5579 "\"ddns-update-on-renew\"", "\"ddns-use-conflict-resolution\"",
5580 "\"store-extended-info\"", "\"subnet4\"", "\"4o6-interface\"",
5581 "\"4o6-interface-id\"", "\"4o6-subnet\"", "\"option-def\"",
5582 "\"option-data\"", "\"name\"", "\"data\"", "\"code\"", "\"space\"",
5583 "\"csv-format\"", "\"always-send\"", "\"record-types\"",
5584 "\"encapsulate\"", "\"array\"", "\"parked-packet-limit\"",
5585 "\"shared-networks\"", "\"pools\"", "\"pool\"", "\"user-context\"",
5586 "\"comment\"", "\"subnet\"", "\"interface\"", "\"id\"",
5587 "\"reservation-mode\"", "\"disabled\"", "\"out-of-pool\"", "\"global\"",
5588 "\"all\"", "\"reservations-global\"", "\"reservations-in-subnet\"",
5589 "\"reservations-out-of-pool\"", "\"host-reservation-identifiers\"",
5590 "\"client-classes\"", "\"require-client-classes\"", "\"test\"",
5591 "\"only-if-required\"", "\"client-class\"", "\"reservations\"",
5592 "\"duid\"", "\"hw-address\"", "\"circuit-id\"", "\"client-id\"",
5593 "\"hostname\"", "\"flex-id\"", "\"relay\"", "\"ip-address\"",
5594 "\"ip-addresses\"", "\"hooks-libraries\"", "\"library\"",
5595 "\"parameters\"", "\"expired-leases-processing\"",
5596 "\"reclaim-timer-wait-time\"", "\"flush-reclaimed-timer-wait-time\"",
5597 "\"hold-reclaimed-time\"", "\"max-reclaim-leases\"",
5598 "\"max-reclaim-time\"", "\"unwarned-reclaim-cycles\"",
5599 "\"dhcp4o6-port\"", "\"multi-threading\"", "\"enable-multi-threading\"",
5600 "\"thread-pool-size\"", "\"packet-queue-size\"", "\"control-socket\"",
5601 "\"socket-type\"", "\"socket-name\"", "\"dhcp-queue-control\"",
5602 "\"enable-queue\"", "\"queue-type\"", "\"capacity\"", "\"dhcp-ddns\"",
5603 "\"enable-updates\"", "\"qualifying-suffix\"", "\"server-ip\"",
5604 "\"server-port\"", "\"sender-ip\"", "\"sender-port\"",
5605 "\"max-queue-size\"", "\"ncr-protocol\"", "\"ncr-format\"",
5606 "\"override-no-update\"", "\"override-client-update\"",
5607 "\"replace-client-name\"", "\"generated-prefix\"", "\"tcp\"", "\"JSON\"",
5608 "\"when-present\"", "\"never\"", "\"always\"", "\"when-not-present\"",
5609 "\"hostname-char-set\"", "\"hostname-char-replacement\"",
5610 "\"ip-reservations-unique\"", "\"loggers\"", "\"output_options\"",
5611 "\"output\"", "\"debuglevel\"", "\"severity\"", "\"flush\"",
5612 "\"maxsize\"", "\"maxver\"", "\"pattern\"", "\"compatibility\"",
5613 "\"lenient-option-parsing\"", "TOPLEVEL_JSON", "TOPLEVEL_DHCP4",
5614 "SUB_DHCP4", "SUB_INTERFACES4", "SUB_SUBNET4", "SUB_POOL4",
5615 "SUB_RESERVATION", "SUB_OPTION_DEFS", "SUB_OPTION_DEF",
5616 "SUB_OPTION_DATA", "SUB_HOOKS_LIBRARY", "SUB_DHCP_DDNS",
5617 "SUB_CONFIG_CONTROL", "\"constant string\"", "\"integer\"",
5618 "\"floating point\"", "\"boolean\"", "$accept", "start", "$@1", "$@2",
5619 "$@3", "$@4", "$@5", "$@6", "$@7", "$@8", "$@9", "$@10", "$@11", "$@12",
5620 "$@13", "value", "sub_json", "map2", "$@14", "map_value", "map_content",
5621 "not_empty_map", "list_generic", "$@15", "list_content",
5622 "not_empty_list", "list_strings", "$@16", "list_strings_content",
5623 "not_empty_list_strings", "unknown_map_entry", "syntax_map", "$@17",
5624 "global_object", "$@18", "sub_dhcp4", "$@19", "global_params",
5625 "global_param", "valid_lifetime", "min_valid_lifetime",
5626 "max_valid_lifetime", "renew_timer", "rebind_timer",
5627 "calculate_tee_times", "t1_percent", "t2_percent", "cache_threshold",
5628 "cache_max_age", "decline_probation_period", "server_tag", "$@20",
5629 "parked_packet_limit", "echo_client_id", "match_client_id",
5630 "authoritative", "ddns_send_updates", "ddns_override_no_update",
5631 "ddns_override_client_update", "ddns_replace_client_name", "$@21",
5632 "ddns_replace_client_name_value", "ddns_generated_prefix", "$@22",
5633 "ddns_qualifying_suffix", "$@23", "ddns_update_on_renew",
5634 "ddns_use_conflict_resolution", "hostname_char_set", "$@24",
5635 "hostname_char_replacement", "$@25", "store_extended_info",
5636 "statistic_default_sample_count", "statistic_default_sample_age",
5637 "ip_reservations_unique", "interfaces_config", "$@26",
5638 "interfaces_config_params", "interfaces_config_param", "sub_interfaces4",
5639 "$@27", "interfaces_list", "$@28", "dhcp_socket_type", "$@29",
5640 "socket_type", "outbound_interface", "$@30", "outbound_interface_value",
5641 "re_detect", "lease_database", "$@31", "sanity_checks", "$@32",
5642 "sanity_checks_params", "sanity_checks_param", "lease_checks", "$@33",
5643 "hosts_database", "$@34", "hosts_databases", "$@35", "database_list",
5644 "not_empty_database_list", "database", "$@36", "database_map_params",
5645 "database_map_param", "database_type", "$@37", "db_type", "user", "$@38",
5646 "password", "$@39", "host", "$@40", "port", "name", "$@41", "persist",
5647 "lfc_interval", "readonly", "connect_timeout", "request_timeout",
5648 "tcp_keepalive", "tcp_nodelay", "contact_points", "$@42", "keyspace",
5649 "$@43", "consistency", "$@44", "serial_consistency", "$@45",
5650 "max_reconnect_tries", "reconnect_wait_time", "on_fail", "$@46",
5651 "on_fail_mode", "max_row_errors", "host_reservation_identifiers", "$@47",
5652 "host_reservation_identifiers_list", "host_reservation_identifier",
5653 "duid_id", "hw_address_id", "circuit_id", "client_id", "flex_id",
5654 "dhcp_multi_threading", "$@48", "multi_threading_params",
5655 "multi_threading_param", "enable_multi_threading", "thread_pool_size",
5656 "packet_queue_size", "hooks_libraries", "$@49", "hooks_libraries_list",
5657 "not_empty_hooks_libraries_list", "hooks_library", "$@50",
5658 "sub_hooks_library", "$@51", "hooks_params", "hooks_param", "library",
5659 "$@52", "parameters", "$@53", "expired_leases_processing", "$@54",
5660 "expired_leases_params", "expired_leases_param",
5661 "reclaim_timer_wait_time", "flush_reclaimed_timer_wait_time",
5662 "hold_reclaimed_time", "max_reclaim_leases", "max_reclaim_time",
5663 "unwarned_reclaim_cycles", "subnet4_list", "$@55",
5664 "subnet4_list_content", "not_empty_subnet4_list", "subnet4", "$@56",
5665 "sub_subnet4", "$@57", "subnet4_params", "subnet4_param", "subnet",
5666 "$@58", "subnet_4o6_interface", "$@59", "subnet_4o6_interface_id",
5667 "$@60", "subnet_4o6_subnet", "$@61", "interface", "$@62", "client_class",
5668 "$@63", "require_client_classes", "$@64", "reservations_global",
5669 "reservations_in_subnet", "reservations_out_of_pool", "reservation_mode",
5670 "$@65", "hr_mode", "id", "shared_networks", "$@66",
5671 "shared_networks_content", "shared_networks_list", "shared_network",
5672 "$@67", "shared_network_params", "shared_network_param",
5673 "option_def_list", "$@68", "sub_option_def_list", "$@69",
5674 "option_def_list_content", "not_empty_option_def_list",
5675 "option_def_entry", "$@70", "sub_option_def", "$@71",
5676 "option_def_params", "not_empty_option_def_params", "option_def_param",
5677 "option_def_name", "code", "option_def_code", "option_def_type", "$@72",
5678 "option_def_record_types", "$@73", "space", "$@74", "option_def_space",
5679 "option_def_encapsulate", "$@75", "option_def_array", "option_data_list",
5680 "$@76", "option_data_list_content", "not_empty_option_data_list",
5681 "option_data_entry", "$@77", "sub_option_data", "$@78",
5682 "option_data_params", "not_empty_option_data_params",
5683 "option_data_param", "option_data_name", "option_data_data", "$@79",
5684 "option_data_code", "option_data_space", "option_data_csv_format",
5685 "option_data_always_send", "pools_list", "$@80", "pools_list_content",
5686 "not_empty_pools_list", "pool_list_entry", "$@81", "sub_pool4", "$@82",
5687 "pool_params", "pool_param", "pool_entry", "$@83", "user_context",
5688 "$@84", "comment", "$@85", "reservations", "$@86", "reservations_list",
5689 "not_empty_reservations_list", "reservation", "$@87", "sub_reservation",
5690 "$@88", "reservation_params", "not_empty_reservation_params",
5691 "reservation_param", "next_server", "$@89", "server_hostname", "$@90",
5692 "boot_file_name", "$@91", "ip_address", "$@92", "ip_addresses", "$@93",
5693 "duid", "$@94", "hw_address", "$@95", "client_id_value", "$@96",
5694 "circuit_id_value", "$@97", "flex_id_value", "$@98", "hostname", "$@99",
5695 "reservation_client_classes", "$@100", "relay", "$@101", "relay_map",
5696 "client_classes", "$@102", "client_classes_list", "client_class_entry",
5697 "$@103", "client_class_params", "not_empty_client_class_params",
5698 "client_class_param", "client_class_name", "client_class_test", "$@104",
5699 "only_if_required", "dhcp4o6_port", "control_socket", "$@105",
5700 "control_socket_params", "control_socket_param", "control_socket_type",
5701 "$@106", "control_socket_name", "$@107", "dhcp_queue_control", "$@108",
5702 "queue_control_params", "queue_control_param", "enable_queue",
5703 "queue_type", "$@109", "capacity", "arbitrary_map_entry", "$@110",
5704 "dhcp_ddns", "$@111", "sub_dhcp_ddns", "$@112", "dhcp_ddns_params",
5705 "dhcp_ddns_param", "enable_updates", "server_ip", "$@113", "server_port",
5706 "sender_ip", "$@114", "sender_port", "max_queue_size", "ncr_protocol",
5707 "$@115", "ncr_protocol_value", "ncr_format", "$@116",
5708 "dep_qualifying_suffix", "$@117", "dep_override_no_update",
5709 "dep_override_client_update", "dep_replace_client_name", "$@118",
5710 "dep_generated_prefix", "$@119", "dep_hostname_char_set", "$@120",
5711 "dep_hostname_char_replacement", "$@121", "config_control", "$@122",
5712 "sub_config_control", "$@123", "config_control_params",
5713 "config_control_param", "config_databases", "$@124",
5714 "config_fetch_wait_time", "loggers", "$@125", "loggers_entries",
5715 "logger_entry", "$@126", "logger_params", "logger_param", "debuglevel",
5716 "severity", "$@127", "output_options_list", "$@128",
5717 "output_options_list_content", "output_entry", "$@129",
5718 "output_params_list", "output_params", "output", "$@130", "flush",
5719 "maxsize", "maxver", "pattern", "$@131", "compatibility", "$@132",
5720 "compatibility_params", "compatibility_param", "lenient_option_parsing", YY_NULLPTR
5721 };
5722 #endif
5723
5724
5725 #if PARSER4_DEBUG
5726 const short
5727 Dhcp4Parser::yyrline_[] =
5728 {
5729 0, 294, 294, 294, 295, 295, 296, 296, 297, 297,
5730 298, 298, 299, 299, 300, 300, 301, 301, 302, 302,
5731 303, 303, 304, 304, 305, 305, 306, 306, 314, 315,
5732 316, 317, 318, 319, 320, 323, 328, 328, 339, 342,
5733 343, 346, 351, 359, 359, 366, 367, 370, 374, 381,
5734 381, 388, 389, 392, 396, 407, 416, 416, 431, 431,
5735 448, 448, 457, 458, 463, 464, 465, 466, 467, 468,
5736 469, 470, 471, 472, 473, 474, 475, 476, 477, 478,
5737 479, 480, 481, 482, 483, 484, 485, 486, 487, 488,
5738 489, 490, 491, 492, 493, 494, 495, 496, 497, 498,
5739 499, 500, 501, 502, 503, 504, 505, 506, 507, 508,
5740 509, 510, 511, 512, 513, 514, 515, 516, 517, 518,
5741 519, 520, 521, 522, 523, 524, 527, 533, 539, 545,
5742 551, 557, 563, 569, 575, 581, 587, 593, 593, 602,
5743 608, 614, 620, 626, 632, 638, 644, 644, 653, 656,
5744 659, 662, 665, 671, 671, 680, 680, 689, 695, 701,
5745 701, 710, 710, 719, 725, 731, 737, 743, 743, 755,
5746 756, 759, 760, 761, 762, 763, 764, 765, 768, 768,
5747 777, 777, 788, 788, 796, 797, 800, 800, 808, 810,
5748 814, 821, 821, 834, 834, 845, 846, 848, 850, 850,
5749 869, 869, 882, 882, 893, 894, 897, 898, 901, 901,
5750 911, 912, 915, 916, 917, 918, 919, 920, 921, 922,
5751 923, 924, 925, 926, 927, 928, 929, 930, 931, 932,
5752 933, 934, 935, 936, 939, 939, 947, 948, 949, 950,
5753 953, 953, 962, 962, 971, 971, 980, 986, 986, 995,
5754 1001, 1007, 1013, 1019, 1025, 1031, 1037, 1037, 1046, 1046,
5755 1055, 1055, 1064, 1064, 1073, 1079, 1085, 1085, 1093, 1094,
5756 1095, 1098, 1105, 1105, 1116, 1117, 1120, 1121, 1122, 1123,
5757 1124, 1127, 1132, 1137, 1142, 1147, 1154, 1154, 1167, 1168,
5758 1171, 1172, 1173, 1174, 1175, 1176, 1179, 1185, 1191, 1197,
5759 1197, 1208, 1209, 1212, 1213, 1216, 1216, 1226, 1226, 1236,
5760 1237, 1238, 1241, 1242, 1245, 1245, 1254, 1254, 1263, 1263,
5761 1275, 1276, 1279, 1280, 1281, 1282, 1283, 1284, 1287, 1293,
5762 1299, 1305, 1311, 1317, 1326, 1326, 1340, 1341, 1344, 1345,
5763 1352, 1352, 1378, 1378, 1389, 1390, 1394, 1395, 1396, 1397,
5764 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407,
5765 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417,
5766 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427,
5767 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437,
5768 1438, 1441, 1441, 1450, 1450, 1459, 1459, 1468, 1468, 1477,
5769 1477, 1486, 1486, 1495, 1495, 1506, 1512, 1518, 1524, 1524,
5770 1532, 1533, 1534, 1535, 1538, 1546, 1546, 1558, 1559, 1563,
5771 1564, 1567, 1567, 1575, 1576, 1579, 1580, 1581, 1582, 1583,
5772 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593,
5773 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603,
5774 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613,
5775 1614, 1615, 1616, 1617, 1618, 1625, 1625, 1639, 1639, 1648,
5776 1649, 1652, 1653, 1658, 1658, 1673, 1673, 1687, 1688, 1691,
5777 1692, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703,
5778 1704, 1707, 1709, 1715, 1717, 1717, 1726, 1726, 1735, 1735,
5779 1744, 1746, 1746, 1755, 1765, 1765, 1778, 1779, 1784, 1785,
5780 1790, 1790, 1802, 1802, 1814, 1815, 1820, 1821, 1826, 1827,
5781 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1837, 1839, 1839,
5782 1848, 1850, 1852, 1858, 1867, 1867, 1880, 1881, 1884, 1885,
5783 1888, 1888, 1898, 1898, 1908, 1909, 1912, 1913, 1914, 1915,
5784 1916, 1917, 1918, 1921, 1921, 1930, 1930, 1955, 1955, 1985,
5785 1985, 1996, 1997, 2000, 2001, 2004, 2004, 2013, 2013, 2022,
5786 2023, 2026, 2027, 2031, 2032, 2033, 2034, 2035, 2036, 2037,
5787 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2048, 2048,
5788 2057, 2057, 2066, 2066, 2075, 2075, 2084, 2084, 2095, 2095,
5789 2104, 2104, 2113, 2113, 2122, 2122, 2131, 2131, 2140, 2140,
5790 2149, 2149, 2163, 2163, 2174, 2175, 2181, 2181, 2192, 2193,
5791 2196, 2196, 2206, 2207, 2210, 2211, 2214, 2215, 2216, 2217,
5792 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227,
5793 2230, 2232, 2232, 2241, 2249, 2257, 2257, 2268, 2269, 2272,
5794 2273, 2274, 2275, 2276, 2279, 2279, 2288, 2288, 2300, 2300,
5795 2313, 2314, 2317, 2318, 2319, 2320, 2321, 2322, 2325, 2331,
5796 2331, 2340, 2346, 2346, 2356, 2356, 2369, 2369, 2379, 2380,
5797 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392,
5798 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2403, 2409,
5799 2409, 2418, 2424, 2424, 2433, 2439, 2445, 2445, 2454, 2455,
5800 2458, 2458, 2468, 2468, 2478, 2485, 2492, 2492, 2501, 2501,
5801 2511, 2511, 2521, 2521, 2533, 2533, 2545, 2545, 2555, 2556,
5802 2560, 2561, 2564, 2564, 2575, 2583, 2583, 2596, 2597, 2601,
5803 2601, 2609, 2610, 2613, 2614, 2615, 2616, 2617, 2618, 2619,
5804 2622, 2628, 2628, 2637, 2637, 2648, 2649, 2652, 2652, 2660,
5805 2661, 2664, 2665, 2666, 2667, 2668, 2671, 2671, 2680, 2686,
5806 2692, 2698, 2698, 2707, 2707, 2718, 2719, 2722, 2723, 2726
5807 };
5808
5809 void
yy_stack_print_() const5810 Dhcp4Parser::yy_stack_print_ () const
5811 {
5812 *yycdebug_ << "Stack now";
5813 for (stack_type::const_iterator
5814 i = yystack_.begin (),
5815 i_end = yystack_.end ();
5816 i != i_end; ++i)
5817 *yycdebug_ << ' ' << int (i->state);
5818 *yycdebug_ << '\n';
5819 }
5820
5821 void
yy_reduce_print_(int yyrule) const5822 Dhcp4Parser::yy_reduce_print_ (int yyrule) const
5823 {
5824 int yylno = yyrline_[yyrule];
5825 int yynrhs = yyr2_[yyrule];
5826 // Print the symbols being reduced, and their result.
5827 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
5828 << " (line " << yylno << "):\n";
5829 // The symbols being reduced.
5830 for (int yyi = 0; yyi < yynrhs; yyi++)
5831 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
5832 yystack_[(yynrhs) - (yyi + 1)]);
5833 }
5834 #endif // PARSER4_DEBUG
5835
5836
5837 #line 14 "dhcp4_parser.yy"
5838 } } // isc::dhcp
5839 #line 5840 "dhcp4_parser.cc"
5840
5841 #line 2732 "dhcp4_parser.yy"
5842
5843
5844 void
error(const location_type & loc,const std::string & what)5845 isc::dhcp::Dhcp4Parser::error(const location_type& loc,
5846 const std::string& what)
5847 {
5848 ctx.error(loc, what);
5849 }
5850