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