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