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