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