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