Kea 2.7.7
d2_parser.h
Go to the documentation of this file.
1// A Bison parser, made by GNU Bison 3.8.2.
2
3// Skeleton interface 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
39// C++ LALR(1) parser skeleton written by Akim Demaille.
40
41// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
42// especially those whose name start with YY_ or yy_. They are
43// private implementation details that can be changed or removed.
44
45#ifndef YY_D2_PARSER_D2_PARSER_H_INCLUDED
46# define YY_D2_PARSER_D2_PARSER_H_INCLUDED
47// "%code requires" blocks.
48#line 17 "d2_parser.yy"
49
50#include <config.h>
51#include <string>
52#include <cc/data.h>
53#include <d2srv/d2_config.h>
54#include <boost/lexical_cast.hpp>
56
57using namespace isc::d2;
58using namespace isc::data;
59using namespace std;
60
61#line 62 "d2_parser.h"
62
63# include <cassert>
64# include <cstdlib> // std::abort
65# include <iostream>
66# include <stdexcept>
67# include <string>
68# include <vector>
69
70#if defined __cplusplus
71# define YY_CPLUSPLUS __cplusplus
72#else
73# define YY_CPLUSPLUS 199711L
74#endif
75
76// Support move semantics when possible.
77#if 201103L <= YY_CPLUSPLUS
78# define YY_MOVE std::move
79# define YY_MOVE_OR_COPY move
80# define YY_MOVE_REF(Type) Type&&
81# define YY_RVREF(Type) Type&&
82# define YY_COPY(Type) Type
83#else
84# define YY_MOVE
85# define YY_MOVE_OR_COPY copy
86# define YY_MOVE_REF(Type) Type&
87# define YY_RVREF(Type) const Type&
88# define YY_COPY(Type) const Type&
89#endif
90
91// Support noexcept when possible.
92#if 201103L <= YY_CPLUSPLUS
93# define YY_NOEXCEPT noexcept
94# define YY_NOTHROW
95#else
96# define YY_NOEXCEPT
97# define YY_NOTHROW throw ()
98#endif
99
100// Support constexpr when possible.
101#if 201703 <= YY_CPLUSPLUS
102# define YY_CONSTEXPR constexpr
103#else
104# define YY_CONSTEXPR
105#endif
106# include "location.hh"
107#include <typeinfo>
108#ifndef D2_PARSER__ASSERT
109# include <cassert>
110# define D2_PARSER__ASSERT assert
111#endif
112
113
114#ifndef YY_ATTRIBUTE_PURE
115# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
116# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
117# else
118# define YY_ATTRIBUTE_PURE
119# endif
120#endif
121
122#ifndef YY_ATTRIBUTE_UNUSED
123# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
124# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
125# else
126# define YY_ATTRIBUTE_UNUSED
127# endif
128#endif
129
130/* Suppress unused-variable warnings by "using" E. */
131#if ! defined lint || defined __GNUC__
132# define YY_USE(E) ((void) (E))
133#else
134# define YY_USE(E) /* empty */
135#endif
136
137/* Suppress an incorrect diagnostic about yylval being uninitialized. */
138#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
139# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
140# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
141 _Pragma ("GCC diagnostic push") \
142 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
143# else
144# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
145 _Pragma ("GCC diagnostic push") \
146 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
147 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
148# endif
149# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
150 _Pragma ("GCC diagnostic pop")
151#else
152# define YY_INITIAL_VALUE(Value) Value
153#endif
154#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
155# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
156# define YY_IGNORE_MAYBE_UNINITIALIZED_END
157#endif
158#ifndef YY_INITIAL_VALUE
159# define YY_INITIAL_VALUE(Value) /* Nothing. */
160#endif
161
162#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
163# define YY_IGNORE_USELESS_CAST_BEGIN \
164 _Pragma ("GCC diagnostic push") \
165 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
166# define YY_IGNORE_USELESS_CAST_END \
167 _Pragma ("GCC diagnostic pop")
168#endif
169#ifndef YY_IGNORE_USELESS_CAST_BEGIN
170# define YY_IGNORE_USELESS_CAST_BEGIN
171# define YY_IGNORE_USELESS_CAST_END
172#endif
173
174# ifndef YY_CAST
175# ifdef __cplusplus
176# define YY_CAST(Type, Val) static_cast<Type> (Val)
177# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
178# else
179# define YY_CAST(Type, Val) ((Type) (Val))
180# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
181# endif
182# endif
183# ifndef YY_NULLPTR
184# if defined __cplusplus
185# if 201103L <= __cplusplus
186# define YY_NULLPTR nullptr
187# else
188# define YY_NULLPTR 0
189# endif
190# else
191# define YY_NULLPTR ((void*)0)
192# endif
193# endif
194
195/* Debug traces. */
196#ifndef D2_PARSER_DEBUG
197# if defined YYDEBUG
198#if YYDEBUG
199# define D2_PARSER_DEBUG 1
200# else
201# define D2_PARSER_DEBUG 0
202# endif
203# else /* ! defined YYDEBUG */
204# define D2_PARSER_DEBUG 1
205# endif /* ! defined YYDEBUG */
206#endif /* ! defined D2_PARSER_DEBUG */
207
208#line 14 "d2_parser.yy"
209namespace isc { namespace d2 {
210#line 211 "d2_parser.h"
211
212
213
214
217 {
218 public:
219#ifdef D2_PARSER_STYPE
220# ifdef __GNUC__
221# pragma GCC message "bison: do not #define D2_PARSER_STYPE in C++, use %define api.value.type"
222# endif
223 typedef D2_PARSER_STYPE value_type;
224#else
231 {
232 public:
235
238 : yyraw_ ()
239 , yytypeid_ (YY_NULLPTR)
240 {}
241
243 template <typename T>
245 : yytypeid_ (&typeid (T))
246 {
247 D2_PARSER__ASSERT (sizeof (T) <= size);
248 new (yyas_<T> ()) T (YY_MOVE (t));
249 }
250
251#if 201103L <= YY_CPLUSPLUS
253 value_type (const self_type&) = delete;
255 self_type& operator= (const self_type&) = delete;
256#endif
257
260 {
261 D2_PARSER__ASSERT (!yytypeid_);
262 }
263
264# if 201103L <= YY_CPLUSPLUS
266 template <typename T, typename... U>
267 T&
268 emplace (U&&... u)
269 {
270 D2_PARSER__ASSERT (!yytypeid_);
271 D2_PARSER__ASSERT (sizeof (T) <= size);
272 yytypeid_ = & typeid (T);
273 return *new (yyas_<T> ()) T (std::forward <U>(u)...);
274 }
275# else
277 template <typename T>
278 T&
280 {
281 D2_PARSER__ASSERT (!yytypeid_);
282 D2_PARSER__ASSERT (sizeof (T) <= size);
283 yytypeid_ = & typeid (T);
284 return *new (yyas_<T> ()) T ();
285 }
286
288 template <typename T>
289 T&
290 emplace (const T& t)
291 {
292 D2_PARSER__ASSERT (!yytypeid_);
293 D2_PARSER__ASSERT (sizeof (T) <= size);
294 yytypeid_ = & typeid (T);
295 return *new (yyas_<T> ()) T (t);
296 }
297# endif
298
301 template <typename T>
302 T&
304 {
305 return emplace<T> ();
306 }
307
310 template <typename T>
311 T&
312 build (const T& t)
313 {
314 return emplace<T> (t);
315 }
316
318 template <typename T>
319 T&
321 {
322 D2_PARSER__ASSERT (yytypeid_);
323 D2_PARSER__ASSERT (*yytypeid_ == typeid (T));
324 D2_PARSER__ASSERT (sizeof (T) <= size);
325 return *yyas_<T> ();
326 }
327
329 template <typename T>
330 const T&
332 {
333 D2_PARSER__ASSERT (yytypeid_);
334 D2_PARSER__ASSERT (*yytypeid_ == typeid (T));
335 D2_PARSER__ASSERT (sizeof (T) <= size);
336 return *yyas_<T> ();
337 }
338
347 template <typename T>
348 void
350 {
351 D2_PARSER__ASSERT (yytypeid_);
352 D2_PARSER__ASSERT (*yytypeid_ == *that.yytypeid_);
353 std::swap (as<T> (), that.as<T> ());
354 }
355
359 template <typename T>
360 void
362 {
363# if 201103L <= YY_CPLUSPLUS
364 emplace<T> (std::move (that.as<T> ()));
365# else
366 emplace<T> ();
367 swap<T> (that);
368# endif
369 that.destroy<T> ();
370 }
371
372# if 201103L <= YY_CPLUSPLUS
374 template <typename T>
375 void
376 move (self_type&& that)
377 {
378 emplace<T> (std::move (that.as<T> ()));
379 that.destroy<T> ();
380 }
381#endif
382
384 template <typename T>
385 void
386 copy (const self_type& that)
387 {
388 emplace<T> (that.as<T> ());
389 }
390
392 template <typename T>
393 void
395 {
396 as<T> ().~T ();
397 yytypeid_ = YY_NULLPTR;
398 }
399
400 private:
401#if YY_CPLUSPLUS < 201103L
403 value_type (const self_type&);
405 self_type& operator= (const self_type&);
406#endif
407
409 template <typename T>
410 T*
411 yyas_ () YY_NOEXCEPT
412 {
413 void *yyp = yyraw_;
414 return static_cast<T*> (yyp);
415 }
416
418 template <typename T>
419 const T*
420 yyas_ () const YY_NOEXCEPT
421 {
422 const void *yyp = yyraw_;
423 return static_cast<const T*> (yyp);
424 }
425
427 union union_type
428 {
429 // value
430 // map_value
431 // ncr_protocol_value
432 // control_socket_type_value
433 // auth_type_value
434 char dummy1[sizeof (ElementPtr)];
435
436 // "boolean"
437 char dummy2[sizeof (bool)];
438
439 // "floating point"
440 char dummy3[sizeof (double)];
441
442 // "integer"
443 char dummy4[sizeof (int64_t)];
444
445 // "constant string"
446 char dummy5[sizeof (std::string)];
447 };
448
450 enum { size = sizeof (union_type) };
451
453 union
454 {
456 long double yyalign_me_;
458 char yyraw_[size];
459 };
460
462 const std::type_info *yytypeid_;
463 };
464
465#endif
468
470 typedef location location_type;
471
473 struct syntax_error : std::runtime_error
474 {
475 syntax_error (const location_type& l, const std::string& m)
476 : std::runtime_error (m)
477 , location (l)
478 {}
479
481 : std::runtime_error (s.what ())
482 , location (s.location)
483 {}
484
486
488 };
489
491 struct token
492 {
494 {
495 TOKEN_D2_PARSER_EMPTY = -2,
496 TOKEN_END = 0, // "end of file"
497 TOKEN_D2_PARSER_error = 256, // error
498 TOKEN_D2_PARSER_UNDEF = 257, // "invalid token"
499 TOKEN_COMMA = 258, // ","
500 TOKEN_COLON = 259, // ":"
501 TOKEN_LSQUARE_BRACKET = 260, // "["
502 TOKEN_RSQUARE_BRACKET = 261, // "]"
503 TOKEN_LCURLY_BRACKET = 262, // "{"
504 TOKEN_RCURLY_BRACKET = 263, // "}"
505 TOKEN_NULL_TYPE = 264, // "null"
506 TOKEN_DHCPDDNS = 265, // "DhcpDdns"
507 TOKEN_IP_ADDRESS = 266, // "ip-address"
508 TOKEN_PORT = 267, // "port"
509 TOKEN_DNS_SERVER_TIMEOUT = 268, // "dns-server-timeout"
510 TOKEN_NCR_PROTOCOL = 269, // "ncr-protocol"
511 TOKEN_UDP = 270, // "UDP"
512 TOKEN_TCP = 271, // "TCP"
513 TOKEN_NCR_FORMAT = 272, // "ncr-format"
514 TOKEN_JSON = 273, // "JSON"
515 TOKEN_USER_CONTEXT = 274, // "user-context"
516 TOKEN_COMMENT = 275, // "comment"
517 TOKEN_FORWARD_DDNS = 276, // "forward-ddns"
518 TOKEN_REVERSE_DDNS = 277, // "reverse-ddns"
519 TOKEN_DDNS_DOMAINS = 278, // "ddns-domains"
520 TOKEN_KEY_NAME = 279, // "key-name"
521 TOKEN_DNS_SERVERS = 280, // "dns-servers"
522 TOKEN_HOSTNAME = 281, // "hostname"
523 TOKEN_TSIG_KEYS = 282, // "tsig-keys"
524 TOKEN_ALGORITHM = 283, // "algorithm"
525 TOKEN_DIGEST_BITS = 284, // "digest-bits"
526 TOKEN_SECRET = 285, // "secret"
527 TOKEN_SECRET_FILE = 286, // "secret-file"
528 TOKEN_CONTROL_SOCKET = 287, // "control-socket"
529 TOKEN_CONTROL_SOCKETS = 288, // "control-sockets"
530 TOKEN_SOCKET_TYPE = 289, // "socket-type"
531 TOKEN_UNIX = 290, // "unix"
532 TOKEN_HTTP = 291, // "http"
533 TOKEN_HTTPS = 292, // "https"
534 TOKEN_SOCKET_NAME = 293, // "socket-name"
535 TOKEN_SOCKET_ADDRESS = 294, // "socket-address"
536 TOKEN_SOCKET_PORT = 295, // "socket-port"
537 TOKEN_AUTHENTICATION = 296, // "authentication"
538 TOKEN_TYPE = 297, // "type"
539 TOKEN_BASIC = 298, // "basic"
540 TOKEN_REALM = 299, // "realm"
541 TOKEN_DIRECTORY = 300, // "directory"
542 TOKEN_CLIENTS = 301, // "clients"
543 TOKEN_USER = 302, // "user"
544 TOKEN_USER_FILE = 303, // "user-file"
545 TOKEN_PASSWORD = 304, // "password"
546 TOKEN_PASSWORD_FILE = 305, // "password-file"
547 TOKEN_TRUST_ANCHOR = 306, // "trust-anchor"
548 TOKEN_CERT_FILE = 307, // "cert-file"
549 TOKEN_KEY_FILE = 308, // "key-file"
550 TOKEN_CERT_REQUIRED = 309, // "cert-required"
551 TOKEN_HOOKS_LIBRARIES = 310, // "hooks-libraries"
552 TOKEN_LIBRARY = 311, // "library"
553 TOKEN_PARAMETERS = 312, // "parameters"
554 TOKEN_LOGGERS = 313, // "loggers"
555 TOKEN_NAME = 314, // "name"
556 TOKEN_OUTPUT_OPTIONS = 315, // "output-options"
557 TOKEN_OUTPUT = 316, // "output"
558 TOKEN_DEBUGLEVEL = 317, // "debuglevel"
559 TOKEN_SEVERITY = 318, // "severity"
560 TOKEN_FLUSH = 319, // "flush"
561 TOKEN_MAXSIZE = 320, // "maxsize"
562 TOKEN_MAXVER = 321, // "maxver"
563 TOKEN_PATTERN = 322, // "pattern"
564 TOKEN_TOPLEVEL_JSON = 323, // TOPLEVEL_JSON
565 TOKEN_TOPLEVEL_DHCPDDNS = 324, // TOPLEVEL_DHCPDDNS
566 TOKEN_SUB_DHCPDDNS = 325, // SUB_DHCPDDNS
567 TOKEN_SUB_TSIG_KEY = 326, // SUB_TSIG_KEY
568 TOKEN_SUB_TSIG_KEYS = 327, // SUB_TSIG_KEYS
569 TOKEN_SUB_DDNS_DOMAIN = 328, // SUB_DDNS_DOMAIN
570 TOKEN_SUB_DDNS_DOMAINS = 329, // SUB_DDNS_DOMAINS
571 TOKEN_SUB_DNS_SERVER = 330, // SUB_DNS_SERVER
572 TOKEN_SUB_DNS_SERVERS = 331, // SUB_DNS_SERVERS
573 TOKEN_SUB_HOOKS_LIBRARY = 332, // SUB_HOOKS_LIBRARY
574 TOKEN_STRING = 333, // "constant string"
575 TOKEN_INTEGER = 334, // "integer"
576 TOKEN_FLOAT = 335, // "floating point"
577 TOKEN_BOOLEAN = 336 // "boolean"
578 };
581 };
582
585
588
591 {
593 {
594 YYNTOKENS = 82,
595 S_YYEMPTY = -2,
596 S_YYEOF = 0, // "end of file"
597 S_YYerror = 1, // error
598 S_YYUNDEF = 2, // "invalid token"
599 S_COMMA = 3, // ","
600 S_COLON = 4, // ":"
601 S_LSQUARE_BRACKET = 5, // "["
602 S_RSQUARE_BRACKET = 6, // "]"
603 S_LCURLY_BRACKET = 7, // "{"
604 S_RCURLY_BRACKET = 8, // "}"
605 S_NULL_TYPE = 9, // "null"
606 S_DHCPDDNS = 10, // "DhcpDdns"
607 S_IP_ADDRESS = 11, // "ip-address"
608 S_PORT = 12, // "port"
609 S_DNS_SERVER_TIMEOUT = 13, // "dns-server-timeout"
610 S_NCR_PROTOCOL = 14, // "ncr-protocol"
611 S_UDP = 15, // "UDP"
612 S_TCP = 16, // "TCP"
613 S_NCR_FORMAT = 17, // "ncr-format"
614 S_JSON = 18, // "JSON"
615 S_USER_CONTEXT = 19, // "user-context"
616 S_COMMENT = 20, // "comment"
617 S_FORWARD_DDNS = 21, // "forward-ddns"
618 S_REVERSE_DDNS = 22, // "reverse-ddns"
619 S_DDNS_DOMAINS = 23, // "ddns-domains"
620 S_KEY_NAME = 24, // "key-name"
621 S_DNS_SERVERS = 25, // "dns-servers"
622 S_HOSTNAME = 26, // "hostname"
623 S_TSIG_KEYS = 27, // "tsig-keys"
624 S_ALGORITHM = 28, // "algorithm"
625 S_DIGEST_BITS = 29, // "digest-bits"
626 S_SECRET = 30, // "secret"
627 S_SECRET_FILE = 31, // "secret-file"
628 S_CONTROL_SOCKET = 32, // "control-socket"
629 S_CONTROL_SOCKETS = 33, // "control-sockets"
630 S_SOCKET_TYPE = 34, // "socket-type"
631 S_UNIX = 35, // "unix"
632 S_HTTP = 36, // "http"
633 S_HTTPS = 37, // "https"
634 S_SOCKET_NAME = 38, // "socket-name"
635 S_SOCKET_ADDRESS = 39, // "socket-address"
636 S_SOCKET_PORT = 40, // "socket-port"
637 S_AUTHENTICATION = 41, // "authentication"
638 S_TYPE = 42, // "type"
639 S_BASIC = 43, // "basic"
640 S_REALM = 44, // "realm"
641 S_DIRECTORY = 45, // "directory"
642 S_CLIENTS = 46, // "clients"
643 S_USER = 47, // "user"
644 S_USER_FILE = 48, // "user-file"
645 S_PASSWORD = 49, // "password"
646 S_PASSWORD_FILE = 50, // "password-file"
647 S_TRUST_ANCHOR = 51, // "trust-anchor"
648 S_CERT_FILE = 52, // "cert-file"
649 S_KEY_FILE = 53, // "key-file"
650 S_CERT_REQUIRED = 54, // "cert-required"
651 S_HOOKS_LIBRARIES = 55, // "hooks-libraries"
652 S_LIBRARY = 56, // "library"
653 S_PARAMETERS = 57, // "parameters"
654 S_LOGGERS = 58, // "loggers"
655 S_NAME = 59, // "name"
656 S_OUTPUT_OPTIONS = 60, // "output-options"
657 S_OUTPUT = 61, // "output"
658 S_DEBUGLEVEL = 62, // "debuglevel"
659 S_SEVERITY = 63, // "severity"
660 S_FLUSH = 64, // "flush"
661 S_MAXSIZE = 65, // "maxsize"
662 S_MAXVER = 66, // "maxver"
663 S_PATTERN = 67, // "pattern"
664 S_TOPLEVEL_JSON = 68, // TOPLEVEL_JSON
665 S_TOPLEVEL_DHCPDDNS = 69, // TOPLEVEL_DHCPDDNS
666 S_SUB_DHCPDDNS = 70, // SUB_DHCPDDNS
667 S_SUB_TSIG_KEY = 71, // SUB_TSIG_KEY
668 S_SUB_TSIG_KEYS = 72, // SUB_TSIG_KEYS
669 S_SUB_DDNS_DOMAIN = 73, // SUB_DDNS_DOMAIN
670 S_SUB_DDNS_DOMAINS = 74, // SUB_DDNS_DOMAINS
671 S_SUB_DNS_SERVER = 75, // SUB_DNS_SERVER
672 S_SUB_DNS_SERVERS = 76, // SUB_DNS_SERVERS
673 S_SUB_HOOKS_LIBRARY = 77, // SUB_HOOKS_LIBRARY
674 S_STRING = 78, // "constant string"
675 S_INTEGER = 79, // "integer"
676 S_FLOAT = 80, // "floating point"
677 S_BOOLEAN = 81, // "boolean"
678 S_YYACCEPT = 82, // $accept
679 S_start = 83, // start
680 S_84_1 = 84, // $@1
681 S_85_2 = 85, // $@2
682 S_86_3 = 86, // $@3
683 S_87_4 = 87, // $@4
684 S_88_5 = 88, // $@5
685 S_89_6 = 89, // $@6
686 S_90_7 = 90, // $@7
687 S_91_8 = 91, // $@8
688 S_92_9 = 92, // $@9
689 S_93_10 = 93, // $@10
690 S_value = 94, // value
691 S_sub_json = 95, // sub_json
692 S_map2 = 96, // map2
693 S_97_11 = 97, // $@11
694 S_map_value = 98, // map_value
695 S_map_content = 99, // map_content
696 S_not_empty_map = 100, // not_empty_map
697 S_list_generic = 101, // list_generic
698 S_102_12 = 102, // $@12
699 S_list_content = 103, // list_content
700 S_not_empty_list = 104, // not_empty_list
701 S_unknown_map_entry = 105, // unknown_map_entry
702 S_syntax_map = 106, // syntax_map
703 S_107_13 = 107, // $@13
704 S_global_object = 108, // global_object
705 S_109_14 = 109, // $@14
706 S_global_object_comma = 110, // global_object_comma
707 S_sub_dhcpddns = 111, // sub_dhcpddns
708 S_112_15 = 112, // $@15
709 S_dhcpddns_params = 113, // dhcpddns_params
710 S_dhcpddns_param = 114, // dhcpddns_param
711 S_ip_address = 115, // ip_address
712 S_116_16 = 116, // $@16
713 S_port = 117, // port
714 S_dns_server_timeout = 118, // dns_server_timeout
715 S_ncr_protocol = 119, // ncr_protocol
716 S_120_17 = 120, // $@17
717 S_ncr_protocol_value = 121, // ncr_protocol_value
718 S_ncr_format = 122, // ncr_format
719 S_123_18 = 123, // $@18
720 S_user_context = 124, // user_context
721 S_125_19 = 125, // $@19
722 S_comment = 126, // comment
723 S_127_20 = 127, // $@20
724 S_forward_ddns = 128, // forward_ddns
725 S_129_21 = 129, // $@21
726 S_reverse_ddns = 130, // reverse_ddns
727 S_131_22 = 131, // $@22
728 S_ddns_mgr_params = 132, // ddns_mgr_params
729 S_not_empty_ddns_mgr_params = 133, // not_empty_ddns_mgr_params
730 S_ddns_mgr_param = 134, // ddns_mgr_param
731 S_ddns_domains = 135, // ddns_domains
732 S_136_23 = 136, // $@23
733 S_sub_ddns_domains = 137, // sub_ddns_domains
734 S_138_24 = 138, // $@24
735 S_ddns_domain_list = 139, // ddns_domain_list
736 S_not_empty_ddns_domain_list = 140, // not_empty_ddns_domain_list
737 S_ddns_domain = 141, // ddns_domain
738 S_142_25 = 142, // $@25
739 S_sub_ddns_domain = 143, // sub_ddns_domain
740 S_144_26 = 144, // $@26
741 S_ddns_domain_params = 145, // ddns_domain_params
742 S_ddns_domain_param = 146, // ddns_domain_param
743 S_ddns_domain_name = 147, // ddns_domain_name
744 S_148_27 = 148, // $@27
745 S_ddns_key_name = 149, // ddns_key_name
746 S_150_28 = 150, // $@28
747 S_dns_servers = 151, // dns_servers
748 S_152_29 = 152, // $@29
749 S_sub_dns_servers = 153, // sub_dns_servers
750 S_154_30 = 154, // $@30
751 S_dns_server_list = 155, // dns_server_list
752 S_dns_server = 156, // dns_server
753 S_157_31 = 157, // $@31
754 S_sub_dns_server = 158, // sub_dns_server
755 S_159_32 = 159, // $@32
756 S_dns_server_params = 160, // dns_server_params
757 S_dns_server_param = 161, // dns_server_param
758 S_dns_server_hostname = 162, // dns_server_hostname
759 S_163_33 = 163, // $@33
760 S_dns_server_ip_address = 164, // dns_server_ip_address
761 S_165_34 = 165, // $@34
762 S_dns_server_port = 166, // dns_server_port
763 S_tsig_keys = 167, // tsig_keys
764 S_168_35 = 168, // $@35
765 S_sub_tsig_keys = 169, // sub_tsig_keys
766 S_170_36 = 170, // $@36
767 S_tsig_keys_list = 171, // tsig_keys_list
768 S_not_empty_tsig_keys_list = 172, // not_empty_tsig_keys_list
769 S_tsig_key = 173, // tsig_key
770 S_174_37 = 174, // $@37
771 S_sub_tsig_key = 175, // sub_tsig_key
772 S_176_38 = 176, // $@38
773 S_tsig_key_params = 177, // tsig_key_params
774 S_tsig_key_param = 178, // tsig_key_param
775 S_tsig_key_name = 179, // tsig_key_name
776 S_180_39 = 180, // $@39
777 S_tsig_key_algorithm = 181, // tsig_key_algorithm
778 S_182_40 = 182, // $@40
779 S_tsig_key_digest_bits = 183, // tsig_key_digest_bits
780 S_tsig_key_secret = 184, // tsig_key_secret
781 S_185_41 = 185, // $@41
782 S_tsig_key_secret_file = 186, // tsig_key_secret_file
783 S_187_42 = 187, // $@42
784 S_control_socket = 188, // control_socket
785 S_189_43 = 189, // $@43
786 S_control_sockets = 190, // control_sockets
787 S_191_44 = 191, // $@44
788 S_control_socket_list = 192, // control_socket_list
789 S_not_empty_control_socket_list = 193, // not_empty_control_socket_list
790 S_control_socket_entry = 194, // control_socket_entry
791 S_195_45 = 195, // $@45
792 S_control_socket_params = 196, // control_socket_params
793 S_control_socket_param = 197, // control_socket_param
794 S_control_socket_type = 198, // control_socket_type
795 S_199_46 = 199, // $@46
796 S_control_socket_type_value = 200, // control_socket_type_value
797 S_control_socket_name = 201, // control_socket_name
798 S_202_47 = 202, // $@47
799 S_control_socket_address = 203, // control_socket_address
800 S_204_48 = 204, // $@48
801 S_control_socket_port = 205, // control_socket_port
802 S_trust_anchor = 206, // trust_anchor
803 S_207_49 = 207, // $@49
804 S_cert_file = 208, // cert_file
805 S_209_50 = 209, // $@50
806 S_key_file = 210, // key_file
807 S_211_51 = 211, // $@51
808 S_cert_required = 212, // cert_required
809 S_authentication = 213, // authentication
810 S_214_52 = 214, // $@52
811 S_auth_params = 215, // auth_params
812 S_auth_param = 216, // auth_param
813 S_auth_type = 217, // auth_type
814 S_218_53 = 218, // $@53
815 S_auth_type_value = 219, // auth_type_value
816 S_realm = 220, // realm
817 S_221_54 = 221, // $@54
818 S_directory = 222, // directory
819 S_223_55 = 223, // $@55
820 S_clients = 224, // clients
821 S_225_56 = 225, // $@56
822 S_clients_list = 226, // clients_list
823 S_not_empty_clients_list = 227, // not_empty_clients_list
824 S_basic_auth = 228, // basic_auth
825 S_229_57 = 229, // $@57
826 S_clients_params = 230, // clients_params
827 S_clients_param = 231, // clients_param
828 S_user = 232, // user
829 S_233_58 = 233, // $@58
830 S_user_file = 234, // user_file
831 S_235_59 = 235, // $@59
832 S_password = 236, // password
833 S_237_60 = 237, // $@60
834 S_password_file = 238, // password_file
835 S_239_61 = 239, // $@61
836 S_hooks_libraries = 240, // hooks_libraries
837 S_241_62 = 241, // $@62
838 S_hooks_libraries_list = 242, // hooks_libraries_list
839 S_not_empty_hooks_libraries_list = 243, // not_empty_hooks_libraries_list
840 S_hooks_library = 244, // hooks_library
841 S_245_63 = 245, // $@63
842 S_sub_hooks_library = 246, // sub_hooks_library
843 S_247_64 = 247, // $@64
844 S_hooks_params = 248, // hooks_params
845 S_hooks_param = 249, // hooks_param
846 S_library = 250, // library
847 S_251_65 = 251, // $@65
848 S_parameters = 252, // parameters
849 S_253_66 = 253, // $@66
850 S_loggers = 254, // loggers
851 S_255_67 = 255, // $@67
852 S_loggers_entries = 256, // loggers_entries
853 S_logger_entry = 257, // logger_entry
854 S_258_68 = 258, // $@68
855 S_logger_params = 259, // logger_params
856 S_logger_param = 260, // logger_param
857 S_name = 261, // name
858 S_262_69 = 262, // $@69
859 S_debuglevel = 263, // debuglevel
860 S_severity = 264, // severity
861 S_265_70 = 265, // $@70
862 S_output_options_list = 266, // output_options_list
863 S_267_71 = 267, // $@71
864 S_output_options_list_content = 268, // output_options_list_content
865 S_output_entry = 269, // output_entry
866 S_270_72 = 270, // $@72
867 S_output_params_list = 271, // output_params_list
868 S_output_params = 272, // output_params
869 S_output = 273, // output
870 S_274_73 = 274, // $@73
871 S_flush = 275, // flush
872 S_maxsize = 276, // maxsize
873 S_maxver = 277, // maxver
874 S_pattern = 278, // pattern
875 S_279_74 = 279 // $@74
876 };
877 };
878
881
884
891 template <typename Base>
892 struct basic_symbol : Base
893 {
895 typedef Base super_type;
896
899 : value ()
900 , location ()
901 {}
902
903#if 201103L <= YY_CPLUSPLUS
906 : Base (std::move (that))
907 , value ()
908 , location (std::move (that.location))
909 {
910 switch (this->kind ())
911 {
912 case symbol_kind::S_value: // value
913 case symbol_kind::S_map_value: // map_value
914 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
915 case symbol_kind::S_control_socket_type_value: // control_socket_type_value
916 case symbol_kind::S_auth_type_value: // auth_type_value
917 value.move< ElementPtr > (std::move (that.value));
918 break;
919
920 case symbol_kind::S_BOOLEAN: // "boolean"
921 value.move< bool > (std::move (that.value));
922 break;
923
924 case symbol_kind::S_FLOAT: // "floating point"
925 value.move< double > (std::move (that.value));
926 break;
927
928 case symbol_kind::S_INTEGER: // "integer"
929 value.move< int64_t > (std::move (that.value));
930 break;
931
932 case symbol_kind::S_STRING: // "constant string"
933 value.move< std::string > (std::move (that.value));
934 break;
935
936 default:
937 break;
938 }
939
940 }
941#endif
942
945
947#if 201103L <= YY_CPLUSPLUS
948 basic_symbol (typename Base::kind_type t, location_type&& l)
949 : Base (t)
950 , location (std::move (l))
951 {}
952#else
953 basic_symbol (typename Base::kind_type t, const location_type& l)
954 : Base (t)
955 , location (l)
956 {}
957#endif
958
959#if 201103L <= YY_CPLUSPLUS
960 basic_symbol (typename Base::kind_type t, ElementPtr&& v, location_type&& l)
961 : Base (t)
962 , value (std::move (v))
963 , location (std::move (l))
964 {}
965#else
966 basic_symbol (typename Base::kind_type t, const ElementPtr& v, const location_type& l)
967 : Base (t)
968 , value (v)
969 , location (l)
970 {}
971#endif
972
973#if 201103L <= YY_CPLUSPLUS
974 basic_symbol (typename Base::kind_type t, bool&& v, location_type&& l)
975 : Base (t)
976 , value (std::move (v))
977 , location (std::move (l))
978 {}
979#else
980 basic_symbol (typename Base::kind_type t, const bool& v, const location_type& l)
981 : Base (t)
982 , value (v)
983 , location (l)
984 {}
985#endif
986
987#if 201103L <= YY_CPLUSPLUS
988 basic_symbol (typename Base::kind_type t, double&& v, location_type&& l)
989 : Base (t)
990 , value (std::move (v))
991 , location (std::move (l))
992 {}
993#else
994 basic_symbol (typename Base::kind_type t, const double& v, const location_type& l)
995 : Base (t)
996 , value (v)
997 , location (l)
998 {}
999#endif
1000
1001#if 201103L <= YY_CPLUSPLUS
1002 basic_symbol (typename Base::kind_type t, int64_t&& v, location_type&& l)
1003 : Base (t)
1004 , value (std::move (v))
1005 , location (std::move (l))
1006 {}
1007#else
1008 basic_symbol (typename Base::kind_type t, const int64_t& v, const location_type& l)
1009 : Base (t)
1010 , value (v)
1011 , location (l)
1012 {}
1013#endif
1014
1015#if 201103L <= YY_CPLUSPLUS
1016 basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l)
1017 : Base (t)
1018 , value (std::move (v))
1019 , location (std::move (l))
1020 {}
1021#else
1022 basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l)
1023 : Base (t)
1024 , value (v)
1025 , location (l)
1026 {}
1027#endif
1028
1031 {
1032 clear ();
1033 }
1034
1035
1036
1039 {
1040 // User destructor.
1041 symbol_kind_type yykind = this->kind ();
1042 basic_symbol<Base>& yysym = *this;
1043 (void) yysym;
1044 switch (yykind)
1045 {
1046 default:
1047 break;
1048 }
1049
1050 // Value type destructor.
1051switch (yykind)
1052 {
1053 case symbol_kind::S_value: // value
1054 case symbol_kind::S_map_value: // map_value
1055 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
1056 case symbol_kind::S_control_socket_type_value: // control_socket_type_value
1057 case symbol_kind::S_auth_type_value: // auth_type_value
1058 value.template destroy< ElementPtr > ();
1059 break;
1060
1061 case symbol_kind::S_BOOLEAN: // "boolean"
1062 value.template destroy< bool > ();
1063 break;
1064
1065 case symbol_kind::S_FLOAT: // "floating point"
1066 value.template destroy< double > ();
1067 break;
1068
1069 case symbol_kind::S_INTEGER: // "integer"
1070 value.template destroy< int64_t > ();
1071 break;
1072
1073 case symbol_kind::S_STRING: // "constant string"
1074 value.template destroy< std::string > ();
1075 break;
1076
1077 default:
1078 break;
1079 }
1080
1081 Base::clear ();
1082 }
1083
1085 std::string name () const YY_NOEXCEPT
1086 {
1087 return D2Parser::symbol_name (this->kind ());
1088 }
1089
1092
1094 bool empty () const YY_NOEXCEPT;
1095
1097 void move (basic_symbol& s);
1098
1101
1104
1105 private:
1106#if YY_CPLUSPLUS < 201103L
1108 basic_symbol& operator= (const basic_symbol& that);
1109#endif
1110 };
1111
1113 struct by_kind
1114 {
1117
1120
1121#if 201103L <= YY_CPLUSPLUS
1123 by_kind (by_kind&& that) YY_NOEXCEPT;
1124#endif
1125
1127 by_kind (const by_kind& that) YY_NOEXCEPT;
1128
1131
1132
1133
1135 void clear () YY_NOEXCEPT;
1136
1138 void move (by_kind& that);
1139
1142 symbol_kind_type kind () const YY_NOEXCEPT;
1143
1145 symbol_kind_type type_get () const YY_NOEXCEPT;
1146
1150 };
1151
1154
1157 {
1160
1163
1165#if 201103L <= YY_CPLUSPLUS
1166 symbol_type (int tok, location_type l)
1167 : super_type (token_kind_type (tok), std::move (l))
1168#else
1169 symbol_type (int tok, const location_type& l)
1170 : super_type (token_kind_type (tok), l)
1171#endif
1172 {
1173#if !defined _MSC_VER || defined __clang__
1174 D2_PARSER__ASSERT (tok == token::TOKEN_END
1175 || (token::TOKEN_D2_PARSER_error <= tok && tok <= token::TOKEN_SUB_HOOKS_LIBRARY));
1176#endif
1177 }
1178#if 201103L <= YY_CPLUSPLUS
1179 symbol_type (int tok, bool v, location_type l)
1180 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1181#else
1182 symbol_type (int tok, const bool& v, const location_type& l)
1183 : super_type (token_kind_type (tok), v, l)
1184#endif
1185 {
1186#if !defined _MSC_VER || defined __clang__
1187 D2_PARSER__ASSERT (tok == token::TOKEN_BOOLEAN);
1188#endif
1189 }
1190#if 201103L <= YY_CPLUSPLUS
1191 symbol_type (int tok, double v, location_type l)
1192 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1193#else
1194 symbol_type (int tok, const double& v, const location_type& l)
1195 : super_type (token_kind_type (tok), v, l)
1196#endif
1197 {
1198#if !defined _MSC_VER || defined __clang__
1199 D2_PARSER__ASSERT (tok == token::TOKEN_FLOAT);
1200#endif
1201 }
1202#if 201103L <= YY_CPLUSPLUS
1203 symbol_type (int tok, int64_t v, location_type l)
1204 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1205#else
1206 symbol_type (int tok, const int64_t& v, const location_type& l)
1207 : super_type (token_kind_type (tok), v, l)
1208#endif
1209 {
1210#if !defined _MSC_VER || defined __clang__
1211 D2_PARSER__ASSERT (tok == token::TOKEN_INTEGER);
1212#endif
1213 }
1214#if 201103L <= YY_CPLUSPLUS
1215 symbol_type (int tok, std::string v, location_type l)
1216 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1217#else
1218 symbol_type (int tok, const std::string& v, const location_type& l)
1219 : super_type (token_kind_type (tok), v, l)
1220#endif
1221 {
1222#if !defined _MSC_VER || defined __clang__
1223 D2_PARSER__ASSERT (tok == token::TOKEN_STRING);
1224#endif
1225 }
1226 };
1227
1230 virtual ~D2Parser ();
1231
1232#if 201103L <= YY_CPLUSPLUS
1234 D2Parser (const D2Parser&) = delete;
1236 D2Parser& operator= (const D2Parser&) = delete;
1237#endif
1238
1241 int operator() ();
1242
1245 virtual int parse ();
1246
1247#if D2_PARSER_DEBUG
1249 std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
1251 void set_debug_stream (std::ostream &);
1252
1254 typedef int debug_level_type;
1256 debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
1258 void set_debug_level (debug_level_type l);
1259#endif
1260
1264 virtual void error (const location_type& loc, const std::string& msg);
1265
1267 void error (const syntax_error& err);
1268
1271 static std::string symbol_name (symbol_kind_type yysymbol);
1272
1273 // Implementation of make_symbol for each token kind.
1274#if 201103L <= YY_CPLUSPLUS
1275 static
1276 symbol_type
1277 make_END (location_type l)
1278 {
1279 return symbol_type (token::TOKEN_END, std::move (l));
1280 }
1281#else
1282 static
1283 symbol_type
1285 {
1286 return symbol_type (token::TOKEN_END, l);
1287 }
1288#endif
1289#if 201103L <= YY_CPLUSPLUS
1290 static
1291 symbol_type
1292 make_D2_PARSER_error (location_type l)
1293 {
1294 return symbol_type (token::TOKEN_D2_PARSER_error, std::move (l));
1295 }
1296#else
1297 static
1298 symbol_type
1300 {
1301 return symbol_type (token::TOKEN_D2_PARSER_error, l);
1302 }
1303#endif
1304#if 201103L <= YY_CPLUSPLUS
1305 static
1306 symbol_type
1307 make_D2_PARSER_UNDEF (location_type l)
1308 {
1309 return symbol_type (token::TOKEN_D2_PARSER_UNDEF, std::move (l));
1310 }
1311#else
1312 static
1313 symbol_type
1315 {
1316 return symbol_type (token::TOKEN_D2_PARSER_UNDEF, l);
1317 }
1318#endif
1319#if 201103L <= YY_CPLUSPLUS
1320 static
1321 symbol_type
1322 make_COMMA (location_type l)
1323 {
1324 return symbol_type (token::TOKEN_COMMA, std::move (l));
1325 }
1326#else
1327 static
1328 symbol_type
1330 {
1331 return symbol_type (token::TOKEN_COMMA, l);
1332 }
1333#endif
1334#if 201103L <= YY_CPLUSPLUS
1335 static
1336 symbol_type
1337 make_COLON (location_type l)
1338 {
1339 return symbol_type (token::TOKEN_COLON, std::move (l));
1340 }
1341#else
1342 static
1343 symbol_type
1345 {
1346 return symbol_type (token::TOKEN_COLON, l);
1347 }
1348#endif
1349#if 201103L <= YY_CPLUSPLUS
1350 static
1351 symbol_type
1352 make_LSQUARE_BRACKET (location_type l)
1353 {
1354 return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
1355 }
1356#else
1357 static
1358 symbol_type
1360 {
1361 return symbol_type (token::TOKEN_LSQUARE_BRACKET, l);
1362 }
1363#endif
1364#if 201103L <= YY_CPLUSPLUS
1365 static
1366 symbol_type
1367 make_RSQUARE_BRACKET (location_type l)
1368 {
1369 return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
1370 }
1371#else
1372 static
1373 symbol_type
1375 {
1376 return symbol_type (token::TOKEN_RSQUARE_BRACKET, l);
1377 }
1378#endif
1379#if 201103L <= YY_CPLUSPLUS
1380 static
1381 symbol_type
1382 make_LCURLY_BRACKET (location_type l)
1383 {
1384 return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
1385 }
1386#else
1387 static
1388 symbol_type
1390 {
1391 return symbol_type (token::TOKEN_LCURLY_BRACKET, l);
1392 }
1393#endif
1394#if 201103L <= YY_CPLUSPLUS
1395 static
1396 symbol_type
1397 make_RCURLY_BRACKET (location_type l)
1398 {
1399 return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
1400 }
1401#else
1402 static
1403 symbol_type
1405 {
1406 return symbol_type (token::TOKEN_RCURLY_BRACKET, l);
1407 }
1408#endif
1409#if 201103L <= YY_CPLUSPLUS
1410 static
1411 symbol_type
1412 make_NULL_TYPE (location_type l)
1413 {
1414 return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
1415 }
1416#else
1417 static
1418 symbol_type
1420 {
1421 return symbol_type (token::TOKEN_NULL_TYPE, l);
1422 }
1423#endif
1424#if 201103L <= YY_CPLUSPLUS
1425 static
1426 symbol_type
1427 make_DHCPDDNS (location_type l)
1428 {
1429 return symbol_type (token::TOKEN_DHCPDDNS, std::move (l));
1430 }
1431#else
1432 static
1433 symbol_type
1435 {
1436 return symbol_type (token::TOKEN_DHCPDDNS, l);
1437 }
1438#endif
1439#if 201103L <= YY_CPLUSPLUS
1440 static
1441 symbol_type
1442 make_IP_ADDRESS (location_type l)
1443 {
1444 return symbol_type (token::TOKEN_IP_ADDRESS, std::move (l));
1445 }
1446#else
1447 static
1448 symbol_type
1450 {
1451 return symbol_type (token::TOKEN_IP_ADDRESS, l);
1452 }
1453#endif
1454#if 201103L <= YY_CPLUSPLUS
1455 static
1456 symbol_type
1457 make_PORT (location_type l)
1458 {
1459 return symbol_type (token::TOKEN_PORT, std::move (l));
1460 }
1461#else
1462 static
1463 symbol_type
1465 {
1466 return symbol_type (token::TOKEN_PORT, l);
1467 }
1468#endif
1469#if 201103L <= YY_CPLUSPLUS
1470 static
1471 symbol_type
1472 make_DNS_SERVER_TIMEOUT (location_type l)
1473 {
1474 return symbol_type (token::TOKEN_DNS_SERVER_TIMEOUT, std::move (l));
1475 }
1476#else
1477 static
1478 symbol_type
1480 {
1481 return symbol_type (token::TOKEN_DNS_SERVER_TIMEOUT, l);
1482 }
1483#endif
1484#if 201103L <= YY_CPLUSPLUS
1485 static
1486 symbol_type
1487 make_NCR_PROTOCOL (location_type l)
1488 {
1489 return symbol_type (token::TOKEN_NCR_PROTOCOL, std::move (l));
1490 }
1491#else
1492 static
1493 symbol_type
1495 {
1496 return symbol_type (token::TOKEN_NCR_PROTOCOL, l);
1497 }
1498#endif
1499#if 201103L <= YY_CPLUSPLUS
1500 static
1501 symbol_type
1502 make_UDP (location_type l)
1503 {
1504 return symbol_type (token::TOKEN_UDP, std::move (l));
1505 }
1506#else
1507 static
1508 symbol_type
1510 {
1511 return symbol_type (token::TOKEN_UDP, l);
1512 }
1513#endif
1514#if 201103L <= YY_CPLUSPLUS
1515 static
1516 symbol_type
1517 make_TCP (location_type l)
1518 {
1519 return symbol_type (token::TOKEN_TCP, std::move (l));
1520 }
1521#else
1522 static
1523 symbol_type
1525 {
1526 return symbol_type (token::TOKEN_TCP, l);
1527 }
1528#endif
1529#if 201103L <= YY_CPLUSPLUS
1530 static
1531 symbol_type
1532 make_NCR_FORMAT (location_type l)
1533 {
1534 return symbol_type (token::TOKEN_NCR_FORMAT, std::move (l));
1535 }
1536#else
1537 static
1538 symbol_type
1540 {
1541 return symbol_type (token::TOKEN_NCR_FORMAT, l);
1542 }
1543#endif
1544#if 201103L <= YY_CPLUSPLUS
1545 static
1546 symbol_type
1547 make_JSON (location_type l)
1548 {
1549 return symbol_type (token::TOKEN_JSON, std::move (l));
1550 }
1551#else
1552 static
1553 symbol_type
1555 {
1556 return symbol_type (token::TOKEN_JSON, l);
1557 }
1558#endif
1559#if 201103L <= YY_CPLUSPLUS
1560 static
1561 symbol_type
1562 make_USER_CONTEXT (location_type l)
1563 {
1564 return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
1565 }
1566#else
1567 static
1568 symbol_type
1570 {
1571 return symbol_type (token::TOKEN_USER_CONTEXT, l);
1572 }
1573#endif
1574#if 201103L <= YY_CPLUSPLUS
1575 static
1576 symbol_type
1577 make_COMMENT (location_type l)
1578 {
1579 return symbol_type (token::TOKEN_COMMENT, std::move (l));
1580 }
1581#else
1582 static
1583 symbol_type
1585 {
1586 return symbol_type (token::TOKEN_COMMENT, l);
1587 }
1588#endif
1589#if 201103L <= YY_CPLUSPLUS
1590 static
1591 symbol_type
1592 make_FORWARD_DDNS (location_type l)
1593 {
1594 return symbol_type (token::TOKEN_FORWARD_DDNS, std::move (l));
1595 }
1596#else
1597 static
1598 symbol_type
1600 {
1601 return symbol_type (token::TOKEN_FORWARD_DDNS, l);
1602 }
1603#endif
1604#if 201103L <= YY_CPLUSPLUS
1605 static
1606 symbol_type
1607 make_REVERSE_DDNS (location_type l)
1608 {
1609 return symbol_type (token::TOKEN_REVERSE_DDNS, std::move (l));
1610 }
1611#else
1612 static
1613 symbol_type
1615 {
1616 return symbol_type (token::TOKEN_REVERSE_DDNS, l);
1617 }
1618#endif
1619#if 201103L <= YY_CPLUSPLUS
1620 static
1621 symbol_type
1622 make_DDNS_DOMAINS (location_type l)
1623 {
1624 return symbol_type (token::TOKEN_DDNS_DOMAINS, std::move (l));
1625 }
1626#else
1627 static
1628 symbol_type
1630 {
1631 return symbol_type (token::TOKEN_DDNS_DOMAINS, l);
1632 }
1633#endif
1634#if 201103L <= YY_CPLUSPLUS
1635 static
1636 symbol_type
1637 make_KEY_NAME (location_type l)
1638 {
1639 return symbol_type (token::TOKEN_KEY_NAME, std::move (l));
1640 }
1641#else
1642 static
1643 symbol_type
1645 {
1646 return symbol_type (token::TOKEN_KEY_NAME, l);
1647 }
1648#endif
1649#if 201103L <= YY_CPLUSPLUS
1650 static
1651 symbol_type
1652 make_DNS_SERVERS (location_type l)
1653 {
1654 return symbol_type (token::TOKEN_DNS_SERVERS, std::move (l));
1655 }
1656#else
1657 static
1658 symbol_type
1660 {
1661 return symbol_type (token::TOKEN_DNS_SERVERS, l);
1662 }
1663#endif
1664#if 201103L <= YY_CPLUSPLUS
1665 static
1666 symbol_type
1667 make_HOSTNAME (location_type l)
1668 {
1669 return symbol_type (token::TOKEN_HOSTNAME, std::move (l));
1670 }
1671#else
1672 static
1673 symbol_type
1675 {
1676 return symbol_type (token::TOKEN_HOSTNAME, l);
1677 }
1678#endif
1679#if 201103L <= YY_CPLUSPLUS
1680 static
1681 symbol_type
1682 make_TSIG_KEYS (location_type l)
1683 {
1684 return symbol_type (token::TOKEN_TSIG_KEYS, std::move (l));
1685 }
1686#else
1687 static
1688 symbol_type
1690 {
1691 return symbol_type (token::TOKEN_TSIG_KEYS, l);
1692 }
1693#endif
1694#if 201103L <= YY_CPLUSPLUS
1695 static
1696 symbol_type
1697 make_ALGORITHM (location_type l)
1698 {
1699 return symbol_type (token::TOKEN_ALGORITHM, std::move (l));
1700 }
1701#else
1702 static
1703 symbol_type
1705 {
1706 return symbol_type (token::TOKEN_ALGORITHM, l);
1707 }
1708#endif
1709#if 201103L <= YY_CPLUSPLUS
1710 static
1711 symbol_type
1712 make_DIGEST_BITS (location_type l)
1713 {
1714 return symbol_type (token::TOKEN_DIGEST_BITS, std::move (l));
1715 }
1716#else
1717 static
1718 symbol_type
1720 {
1721 return symbol_type (token::TOKEN_DIGEST_BITS, l);
1722 }
1723#endif
1724#if 201103L <= YY_CPLUSPLUS
1725 static
1726 symbol_type
1727 make_SECRET (location_type l)
1728 {
1729 return symbol_type (token::TOKEN_SECRET, std::move (l));
1730 }
1731#else
1732 static
1733 symbol_type
1735 {
1736 return symbol_type (token::TOKEN_SECRET, l);
1737 }
1738#endif
1739#if 201103L <= YY_CPLUSPLUS
1740 static
1741 symbol_type
1742 make_SECRET_FILE (location_type l)
1743 {
1744 return symbol_type (token::TOKEN_SECRET_FILE, std::move (l));
1745 }
1746#else
1747 static
1748 symbol_type
1750 {
1751 return symbol_type (token::TOKEN_SECRET_FILE, l);
1752 }
1753#endif
1754#if 201103L <= YY_CPLUSPLUS
1755 static
1756 symbol_type
1757 make_CONTROL_SOCKET (location_type l)
1758 {
1759 return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
1760 }
1761#else
1762 static
1763 symbol_type
1765 {
1766 return symbol_type (token::TOKEN_CONTROL_SOCKET, l);
1767 }
1768#endif
1769#if 201103L <= YY_CPLUSPLUS
1770 static
1771 symbol_type
1772 make_CONTROL_SOCKETS (location_type l)
1773 {
1774 return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
1775 }
1776#else
1777 static
1778 symbol_type
1780 {
1781 return symbol_type (token::TOKEN_CONTROL_SOCKETS, l);
1782 }
1783#endif
1784#if 201103L <= YY_CPLUSPLUS
1785 static
1786 symbol_type
1787 make_SOCKET_TYPE (location_type l)
1788 {
1789 return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
1790 }
1791#else
1792 static
1793 symbol_type
1795 {
1796 return symbol_type (token::TOKEN_SOCKET_TYPE, l);
1797 }
1798#endif
1799#if 201103L <= YY_CPLUSPLUS
1800 static
1801 symbol_type
1802 make_UNIX (location_type l)
1803 {
1804 return symbol_type (token::TOKEN_UNIX, std::move (l));
1805 }
1806#else
1807 static
1808 symbol_type
1810 {
1811 return symbol_type (token::TOKEN_UNIX, l);
1812 }
1813#endif
1814#if 201103L <= YY_CPLUSPLUS
1815 static
1816 symbol_type
1817 make_HTTP (location_type l)
1818 {
1819 return symbol_type (token::TOKEN_HTTP, std::move (l));
1820 }
1821#else
1822 static
1823 symbol_type
1825 {
1826 return symbol_type (token::TOKEN_HTTP, l);
1827 }
1828#endif
1829#if 201103L <= YY_CPLUSPLUS
1830 static
1831 symbol_type
1832 make_HTTPS (location_type l)
1833 {
1834 return symbol_type (token::TOKEN_HTTPS, std::move (l));
1835 }
1836#else
1837 static
1838 symbol_type
1840 {
1841 return symbol_type (token::TOKEN_HTTPS, l);
1842 }
1843#endif
1844#if 201103L <= YY_CPLUSPLUS
1845 static
1846 symbol_type
1847 make_SOCKET_NAME (location_type l)
1848 {
1849 return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
1850 }
1851#else
1852 static
1853 symbol_type
1855 {
1856 return symbol_type (token::TOKEN_SOCKET_NAME, l);
1857 }
1858#endif
1859#if 201103L <= YY_CPLUSPLUS
1860 static
1861 symbol_type
1862 make_SOCKET_ADDRESS (location_type l)
1863 {
1864 return symbol_type (token::TOKEN_SOCKET_ADDRESS, std::move (l));
1865 }
1866#else
1867 static
1868 symbol_type
1870 {
1871 return symbol_type (token::TOKEN_SOCKET_ADDRESS, l);
1872 }
1873#endif
1874#if 201103L <= YY_CPLUSPLUS
1875 static
1876 symbol_type
1877 make_SOCKET_PORT (location_type l)
1878 {
1879 return symbol_type (token::TOKEN_SOCKET_PORT, std::move (l));
1880 }
1881#else
1882 static
1883 symbol_type
1885 {
1886 return symbol_type (token::TOKEN_SOCKET_PORT, l);
1887 }
1888#endif
1889#if 201103L <= YY_CPLUSPLUS
1890 static
1891 symbol_type
1892 make_AUTHENTICATION (location_type l)
1893 {
1894 return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
1895 }
1896#else
1897 static
1898 symbol_type
1900 {
1901 return symbol_type (token::TOKEN_AUTHENTICATION, l);
1902 }
1903#endif
1904#if 201103L <= YY_CPLUSPLUS
1905 static
1906 symbol_type
1907 make_TYPE (location_type l)
1908 {
1909 return symbol_type (token::TOKEN_TYPE, std::move (l));
1910 }
1911#else
1912 static
1913 symbol_type
1915 {
1916 return symbol_type (token::TOKEN_TYPE, l);
1917 }
1918#endif
1919#if 201103L <= YY_CPLUSPLUS
1920 static
1921 symbol_type
1922 make_BASIC (location_type l)
1923 {
1924 return symbol_type (token::TOKEN_BASIC, std::move (l));
1925 }
1926#else
1927 static
1928 symbol_type
1930 {
1931 return symbol_type (token::TOKEN_BASIC, l);
1932 }
1933#endif
1934#if 201103L <= YY_CPLUSPLUS
1935 static
1936 symbol_type
1937 make_REALM (location_type l)
1938 {
1939 return symbol_type (token::TOKEN_REALM, std::move (l));
1940 }
1941#else
1942 static
1943 symbol_type
1945 {
1946 return symbol_type (token::TOKEN_REALM, l);
1947 }
1948#endif
1949#if 201103L <= YY_CPLUSPLUS
1950 static
1951 symbol_type
1952 make_DIRECTORY (location_type l)
1953 {
1954 return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
1955 }
1956#else
1957 static
1958 symbol_type
1960 {
1961 return symbol_type (token::TOKEN_DIRECTORY, l);
1962 }
1963#endif
1964#if 201103L <= YY_CPLUSPLUS
1965 static
1966 symbol_type
1967 make_CLIENTS (location_type l)
1968 {
1969 return symbol_type (token::TOKEN_CLIENTS, std::move (l));
1970 }
1971#else
1972 static
1973 symbol_type
1975 {
1976 return symbol_type (token::TOKEN_CLIENTS, l);
1977 }
1978#endif
1979#if 201103L <= YY_CPLUSPLUS
1980 static
1981 symbol_type
1982 make_USER (location_type l)
1983 {
1984 return symbol_type (token::TOKEN_USER, std::move (l));
1985 }
1986#else
1987 static
1988 symbol_type
1990 {
1991 return symbol_type (token::TOKEN_USER, l);
1992 }
1993#endif
1994#if 201103L <= YY_CPLUSPLUS
1995 static
1996 symbol_type
1997 make_USER_FILE (location_type l)
1998 {
1999 return symbol_type (token::TOKEN_USER_FILE, std::move (l));
2000 }
2001#else
2002 static
2003 symbol_type
2005 {
2006 return symbol_type (token::TOKEN_USER_FILE, l);
2007 }
2008#endif
2009#if 201103L <= YY_CPLUSPLUS
2010 static
2011 symbol_type
2012 make_PASSWORD (location_type l)
2013 {
2014 return symbol_type (token::TOKEN_PASSWORD, std::move (l));
2015 }
2016#else
2017 static
2018 symbol_type
2020 {
2021 return symbol_type (token::TOKEN_PASSWORD, l);
2022 }
2023#endif
2024#if 201103L <= YY_CPLUSPLUS
2025 static
2026 symbol_type
2027 make_PASSWORD_FILE (location_type l)
2028 {
2029 return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
2030 }
2031#else
2032 static
2033 symbol_type
2035 {
2036 return symbol_type (token::TOKEN_PASSWORD_FILE, l);
2037 }
2038#endif
2039#if 201103L <= YY_CPLUSPLUS
2040 static
2041 symbol_type
2042 make_TRUST_ANCHOR (location_type l)
2043 {
2044 return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
2045 }
2046#else
2047 static
2048 symbol_type
2050 {
2051 return symbol_type (token::TOKEN_TRUST_ANCHOR, l);
2052 }
2053#endif
2054#if 201103L <= YY_CPLUSPLUS
2055 static
2056 symbol_type
2057 make_CERT_FILE (location_type l)
2058 {
2059 return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
2060 }
2061#else
2062 static
2063 symbol_type
2065 {
2066 return symbol_type (token::TOKEN_CERT_FILE, l);
2067 }
2068#endif
2069#if 201103L <= YY_CPLUSPLUS
2070 static
2071 symbol_type
2072 make_KEY_FILE (location_type l)
2073 {
2074 return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
2075 }
2076#else
2077 static
2078 symbol_type
2080 {
2081 return symbol_type (token::TOKEN_KEY_FILE, l);
2082 }
2083#endif
2084#if 201103L <= YY_CPLUSPLUS
2085 static
2086 symbol_type
2087 make_CERT_REQUIRED (location_type l)
2088 {
2089 return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
2090 }
2091#else
2092 static
2093 symbol_type
2095 {
2096 return symbol_type (token::TOKEN_CERT_REQUIRED, l);
2097 }
2098#endif
2099#if 201103L <= YY_CPLUSPLUS
2100 static
2101 symbol_type
2102 make_HOOKS_LIBRARIES (location_type l)
2103 {
2104 return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
2105 }
2106#else
2107 static
2108 symbol_type
2110 {
2111 return symbol_type (token::TOKEN_HOOKS_LIBRARIES, l);
2112 }
2113#endif
2114#if 201103L <= YY_CPLUSPLUS
2115 static
2116 symbol_type
2117 make_LIBRARY (location_type l)
2118 {
2119 return symbol_type (token::TOKEN_LIBRARY, std::move (l));
2120 }
2121#else
2122 static
2123 symbol_type
2125 {
2126 return symbol_type (token::TOKEN_LIBRARY, l);
2127 }
2128#endif
2129#if 201103L <= YY_CPLUSPLUS
2130 static
2131 symbol_type
2132 make_PARAMETERS (location_type l)
2133 {
2134 return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
2135 }
2136#else
2137 static
2138 symbol_type
2140 {
2141 return symbol_type (token::TOKEN_PARAMETERS, l);
2142 }
2143#endif
2144#if 201103L <= YY_CPLUSPLUS
2145 static
2146 symbol_type
2147 make_LOGGERS (location_type l)
2148 {
2149 return symbol_type (token::TOKEN_LOGGERS, std::move (l));
2150 }
2151#else
2152 static
2153 symbol_type
2155 {
2156 return symbol_type (token::TOKEN_LOGGERS, l);
2157 }
2158#endif
2159#if 201103L <= YY_CPLUSPLUS
2160 static
2161 symbol_type
2162 make_NAME (location_type l)
2163 {
2164 return symbol_type (token::TOKEN_NAME, std::move (l));
2165 }
2166#else
2167 static
2168 symbol_type
2170 {
2171 return symbol_type (token::TOKEN_NAME, l);
2172 }
2173#endif
2174#if 201103L <= YY_CPLUSPLUS
2175 static
2176 symbol_type
2177 make_OUTPUT_OPTIONS (location_type l)
2178 {
2179 return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
2180 }
2181#else
2182 static
2183 symbol_type
2185 {
2186 return symbol_type (token::TOKEN_OUTPUT_OPTIONS, l);
2187 }
2188#endif
2189#if 201103L <= YY_CPLUSPLUS
2190 static
2191 symbol_type
2192 make_OUTPUT (location_type l)
2193 {
2194 return symbol_type (token::TOKEN_OUTPUT, std::move (l));
2195 }
2196#else
2197 static
2198 symbol_type
2200 {
2201 return symbol_type (token::TOKEN_OUTPUT, l);
2202 }
2203#endif
2204#if 201103L <= YY_CPLUSPLUS
2205 static
2206 symbol_type
2207 make_DEBUGLEVEL (location_type l)
2208 {
2209 return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
2210 }
2211#else
2212 static
2213 symbol_type
2215 {
2216 return symbol_type (token::TOKEN_DEBUGLEVEL, l);
2217 }
2218#endif
2219#if 201103L <= YY_CPLUSPLUS
2220 static
2221 symbol_type
2222 make_SEVERITY (location_type l)
2223 {
2224 return symbol_type (token::TOKEN_SEVERITY, std::move (l));
2225 }
2226#else
2227 static
2228 symbol_type
2230 {
2231 return symbol_type (token::TOKEN_SEVERITY, l);
2232 }
2233#endif
2234#if 201103L <= YY_CPLUSPLUS
2235 static
2236 symbol_type
2237 make_FLUSH (location_type l)
2238 {
2239 return symbol_type (token::TOKEN_FLUSH, std::move (l));
2240 }
2241#else
2242 static
2243 symbol_type
2245 {
2246 return symbol_type (token::TOKEN_FLUSH, l);
2247 }
2248#endif
2249#if 201103L <= YY_CPLUSPLUS
2250 static
2251 symbol_type
2252 make_MAXSIZE (location_type l)
2253 {
2254 return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
2255 }
2256#else
2257 static
2258 symbol_type
2260 {
2261 return symbol_type (token::TOKEN_MAXSIZE, l);
2262 }
2263#endif
2264#if 201103L <= YY_CPLUSPLUS
2265 static
2266 symbol_type
2267 make_MAXVER (location_type l)
2268 {
2269 return symbol_type (token::TOKEN_MAXVER, std::move (l));
2270 }
2271#else
2272 static
2273 symbol_type
2275 {
2276 return symbol_type (token::TOKEN_MAXVER, l);
2277 }
2278#endif
2279#if 201103L <= YY_CPLUSPLUS
2280 static
2281 symbol_type
2282 make_PATTERN (location_type l)
2283 {
2284 return symbol_type (token::TOKEN_PATTERN, std::move (l));
2285 }
2286#else
2287 static
2288 symbol_type
2290 {
2291 return symbol_type (token::TOKEN_PATTERN, l);
2292 }
2293#endif
2294#if 201103L <= YY_CPLUSPLUS
2295 static
2296 symbol_type
2297 make_TOPLEVEL_JSON (location_type l)
2298 {
2299 return symbol_type (token::TOKEN_TOPLEVEL_JSON, std::move (l));
2300 }
2301#else
2302 static
2303 symbol_type
2305 {
2306 return symbol_type (token::TOKEN_TOPLEVEL_JSON, l);
2307 }
2308#endif
2309#if 201103L <= YY_CPLUSPLUS
2310 static
2311 symbol_type
2312 make_TOPLEVEL_DHCPDDNS (location_type l)
2313 {
2314 return symbol_type (token::TOKEN_TOPLEVEL_DHCPDDNS, std::move (l));
2315 }
2316#else
2317 static
2318 symbol_type
2320 {
2321 return symbol_type (token::TOKEN_TOPLEVEL_DHCPDDNS, l);
2322 }
2323#endif
2324#if 201103L <= YY_CPLUSPLUS
2325 static
2326 symbol_type
2327 make_SUB_DHCPDDNS (location_type l)
2328 {
2329 return symbol_type (token::TOKEN_SUB_DHCPDDNS, std::move (l));
2330 }
2331#else
2332 static
2333 symbol_type
2335 {
2336 return symbol_type (token::TOKEN_SUB_DHCPDDNS, l);
2337 }
2338#endif
2339#if 201103L <= YY_CPLUSPLUS
2340 static
2341 symbol_type
2342 make_SUB_TSIG_KEY (location_type l)
2343 {
2344 return symbol_type (token::TOKEN_SUB_TSIG_KEY, std::move (l));
2345 }
2346#else
2347 static
2348 symbol_type
2350 {
2351 return symbol_type (token::TOKEN_SUB_TSIG_KEY, l);
2352 }
2353#endif
2354#if 201103L <= YY_CPLUSPLUS
2355 static
2356 symbol_type
2357 make_SUB_TSIG_KEYS (location_type l)
2358 {
2359 return symbol_type (token::TOKEN_SUB_TSIG_KEYS, std::move (l));
2360 }
2361#else
2362 static
2363 symbol_type
2365 {
2366 return symbol_type (token::TOKEN_SUB_TSIG_KEYS, l);
2367 }
2368#endif
2369#if 201103L <= YY_CPLUSPLUS
2370 static
2371 symbol_type
2372 make_SUB_DDNS_DOMAIN (location_type l)
2373 {
2374 return symbol_type (token::TOKEN_SUB_DDNS_DOMAIN, std::move (l));
2375 }
2376#else
2377 static
2378 symbol_type
2380 {
2381 return symbol_type (token::TOKEN_SUB_DDNS_DOMAIN, l);
2382 }
2383#endif
2384#if 201103L <= YY_CPLUSPLUS
2385 static
2386 symbol_type
2387 make_SUB_DDNS_DOMAINS (location_type l)
2388 {
2389 return symbol_type (token::TOKEN_SUB_DDNS_DOMAINS, std::move (l));
2390 }
2391#else
2392 static
2393 symbol_type
2395 {
2396 return symbol_type (token::TOKEN_SUB_DDNS_DOMAINS, l);
2397 }
2398#endif
2399#if 201103L <= YY_CPLUSPLUS
2400 static
2401 symbol_type
2402 make_SUB_DNS_SERVER (location_type l)
2403 {
2404 return symbol_type (token::TOKEN_SUB_DNS_SERVER, std::move (l));
2405 }
2406#else
2407 static
2408 symbol_type
2410 {
2411 return symbol_type (token::TOKEN_SUB_DNS_SERVER, l);
2412 }
2413#endif
2414#if 201103L <= YY_CPLUSPLUS
2415 static
2416 symbol_type
2417 make_SUB_DNS_SERVERS (location_type l)
2418 {
2419 return symbol_type (token::TOKEN_SUB_DNS_SERVERS, std::move (l));
2420 }
2421#else
2422 static
2423 symbol_type
2425 {
2426 return symbol_type (token::TOKEN_SUB_DNS_SERVERS, l);
2427 }
2428#endif
2429#if 201103L <= YY_CPLUSPLUS
2430 static
2431 symbol_type
2432 make_SUB_HOOKS_LIBRARY (location_type l)
2433 {
2434 return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, std::move (l));
2435 }
2436#else
2437 static
2438 symbol_type
2440 {
2441 return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, l);
2442 }
2443#endif
2444#if 201103L <= YY_CPLUSPLUS
2445 static
2446 symbol_type
2447 make_STRING (std::string v, location_type l)
2448 {
2449 return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
2450 }
2451#else
2452 static
2453 symbol_type
2454 make_STRING (const std::string& v, const location_type& l)
2455 {
2456 return symbol_type (token::TOKEN_STRING, v, l);
2457 }
2458#endif
2459#if 201103L <= YY_CPLUSPLUS
2460 static
2461 symbol_type
2462 make_INTEGER (int64_t v, location_type l)
2463 {
2464 return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
2465 }
2466#else
2467 static
2468 symbol_type
2469 make_INTEGER (const int64_t& v, const location_type& l)
2470 {
2471 return symbol_type (token::TOKEN_INTEGER, v, l);
2472 }
2473#endif
2474#if 201103L <= YY_CPLUSPLUS
2475 static
2476 symbol_type
2477 make_FLOAT (double v, location_type l)
2478 {
2479 return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
2480 }
2481#else
2482 static
2483 symbol_type
2484 make_FLOAT (const double& v, const location_type& l)
2485 {
2486 return symbol_type (token::TOKEN_FLOAT, v, l);
2487 }
2488#endif
2489#if 201103L <= YY_CPLUSPLUS
2490 static
2491 symbol_type
2492 make_BOOLEAN (bool v, location_type l)
2493 {
2494 return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
2495 }
2496#else
2497 static
2498 symbol_type
2499 make_BOOLEAN (const bool& v, const location_type& l)
2500 {
2501 return symbol_type (token::TOKEN_BOOLEAN, v, l);
2502 }
2503#endif
2504
2505
2507 {
2508 public:
2509 context (const D2Parser& yyparser, const symbol_type& yyla);
2510 const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; }
2511 symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }
2512 const location_type& location () const YY_NOEXCEPT { return yyla_.location; }
2513
2517 int expected_tokens (symbol_kind_type yyarg[], int yyargn) const;
2518
2519 private:
2520 const D2Parser& yyparser_;
2521 const symbol_type& yyla_;
2522 };
2523
2524 private:
2525#if YY_CPLUSPLUS < 201103L
2527 D2Parser (const D2Parser&);
2529 D2Parser& operator= (const D2Parser&);
2530#endif
2531
2532
2534 typedef short state_type;
2535
2537 int yy_syntax_error_arguments_ (const context& yyctx,
2538 symbol_kind_type yyarg[], int yyargn) const;
2539
2542 virtual std::string yysyntax_error_ (const context& yyctx) const;
2546 static state_type yy_lr_goto_state_ (state_type yystate, int yysym);
2547
2550 static bool yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT;
2551
2554 static bool yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT;
2555
2556 static const short yypact_ninf_;
2557 static const signed char yytable_ninf_;
2558
2562 static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT;
2563
2565 static std::string yytnamerr_ (const char *yystr);
2566
2568 static const char* const yytname_[];
2569
2570
2571 // Tables.
2572 // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2573 // STATE-NUM.
2574 static const short yypact_[];
2575
2576 // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
2577 // Performed when YYTABLE does not specify something else to do. Zero
2578 // means the default is an error.
2579 static const short yydefact_[];
2580
2581 // YYPGOTO[NTERM-NUM].
2582 static const short yypgoto_[];
2583
2584 // YYDEFGOTO[NTERM-NUM].
2585 static const short yydefgoto_[];
2586
2587 // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
2588 // positive, shift that token. If negative, reduce the rule whose
2589 // number is the opposite. If YYTABLE_NINF, syntax error.
2590 static const short yytable_[];
2591
2592 static const short yycheck_[];
2593
2594 // YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
2595 // state STATE-NUM.
2596 static const short yystos_[];
2597
2598 // YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.
2599 static const short yyr1_[];
2600
2601 // YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.
2602 static const signed char yyr2_[];
2603
2604
2605#if D2_PARSER_DEBUG
2606 // YYRLINE[YYN] -- Source line where rule number YYN was defined.
2607 static const short yyrline_[];
2609 virtual void yy_reduce_print_ (int r) const;
2611 virtual void yy_stack_print_ () const;
2612
2614 int yydebug_;
2616 std::ostream* yycdebug_;
2617
2621 template <typename Base>
2622 void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
2623#endif
2624
2629 template <typename Base>
2630 void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
2631
2632 private:
2634 struct by_state
2635 {
2637 by_state () YY_NOEXCEPT;
2638
2640 typedef state_type kind_type;
2641
2643 by_state (kind_type s) YY_NOEXCEPT;
2644
2646 by_state (const by_state& that) YY_NOEXCEPT;
2647
2649 void clear () YY_NOEXCEPT;
2650
2652 void move (by_state& that);
2653
2656 symbol_kind_type kind () const YY_NOEXCEPT;
2657
2660 enum { empty_state = 0 };
2661
2664 state_type state;
2665 };
2666
2668 struct stack_symbol_type : basic_symbol<by_state>
2669 {
2671 typedef basic_symbol<by_state> super_type;
2673 stack_symbol_type ();
2675 stack_symbol_type (YY_RVREF (stack_symbol_type) that);
2677 stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
2678#if YY_CPLUSPLUS < 201103L
2681 stack_symbol_type& operator= (stack_symbol_type& that);
2682
2685 stack_symbol_type& operator= (const stack_symbol_type& that);
2686#endif
2687 };
2688
2690 template <typename T, typename S = std::vector<T> >
2691 class stack
2692 {
2693 public:
2694 // Hide our reversed order.
2695 typedef typename S::iterator iterator;
2696 typedef typename S::const_iterator const_iterator;
2697 typedef typename S::size_type size_type;
2698 typedef typename std::ptrdiff_t index_type;
2699
2700 stack (size_type n = 200) YY_NOEXCEPT
2701 : seq_ (n)
2702 {}
2703
2704#if 201103L <= YY_CPLUSPLUS
2706 stack (const stack&) = delete;
2708 stack& operator= (const stack&) = delete;
2709#endif
2710
2714 const T&
2715 operator[] (index_type i) const
2716 {
2717 return seq_[size_type (size () - 1 - i)];
2718 }
2719
2723 T&
2724 operator[] (index_type i)
2725 {
2726 return seq_[size_type (size () - 1 - i)];
2727 }
2728
2732 void
2733 push (YY_MOVE_REF (T) t)
2734 {
2735 seq_.push_back (T ());
2736 operator[] (0).move (t);
2737 }
2738
2740 void
2741 pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2742 {
2743 for (; 0 < n; --n)
2744 seq_.pop_back ();
2745 }
2746
2748 void
2749 clear () YY_NOEXCEPT
2750 {
2751 seq_.clear ();
2752 }
2753
2755 index_type
2756 size () const YY_NOEXCEPT
2757 {
2758 return index_type (seq_.size ());
2759 }
2760
2762 const_iterator
2763 begin () const YY_NOEXCEPT
2764 {
2765 return seq_.begin ();
2766 }
2767
2769 const_iterator
2770 end () const YY_NOEXCEPT
2771 {
2772 return seq_.end ();
2773 }
2774
2776 class slice
2777 {
2778 public:
2779 slice (const stack& stack, index_type range) YY_NOEXCEPT
2780 : stack_ (stack)
2781 , range_ (range)
2782 {}
2783
2784 const T&
2785 operator[] (index_type i) const
2786 {
2787 return stack_[range_ - i];
2788 }
2789
2790 private:
2791 const stack& stack_;
2792 index_type range_;
2793 };
2794
2795 private:
2796#if YY_CPLUSPLUS < 201103L
2798 stack (const stack&);
2800 stack& operator= (const stack&);
2801#endif
2803 S seq_;
2804 };
2805
2806
2808 typedef stack<stack_symbol_type> stack_type;
2809
2811 stack_type yystack_;
2812
2818 void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2819
2826 void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
2827
2829 void yypop_ (int n = 1) YY_NOEXCEPT;
2830
2832 enum
2833 {
2834 yylast_ = 461,
2835 yynnts_ = 198,
2836 yyfinal_ = 22
2837 };
2838
2839
2840 // User arguments.
2842
2843 };
2844
2845 inline
2847 D2Parser::yytranslate_ (int t) YY_NOEXCEPT
2848 {
2849 // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to
2850 // TOKEN-NUM as returned by yylex.
2851 static
2852 const signed char
2853 translate_table[] =
2854 {
2855 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2856 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2857 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2858 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2859 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2860 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2861 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2862 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2863 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2864 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2865 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2866 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2867 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2868 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2869 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2870 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2871 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2872 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2873 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2874 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2875 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2876 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2877 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2878 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2879 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2880 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2881 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2882 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2883 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2884 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2885 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2886 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2887 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
2888 75, 76, 77, 78, 79, 80, 81
2889 };
2890 // Last valid token kind.
2891 const int code_max = 336;
2892
2893 if (t <= 0)
2894 return symbol_kind::S_YYEOF;
2895 else if (t <= code_max)
2896 return static_cast <symbol_kind_type> (translate_table[t]);
2897 else
2899 }
2900
2901 // basic_symbol.
2902 template <typename Base>
2904 : Base (that)
2905 , value ()
2906 , location (that.location)
2907 {
2908 switch (this->kind ())
2909 {
2910 case symbol_kind::S_value: // value
2911 case symbol_kind::S_map_value: // map_value
2912 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
2913 case symbol_kind::S_control_socket_type_value: // control_socket_type_value
2914 case symbol_kind::S_auth_type_value: // auth_type_value
2915 value.copy< ElementPtr > (YY_MOVE (that.value));
2916 break;
2917
2918 case symbol_kind::S_BOOLEAN: // "boolean"
2919 value.copy< bool > (YY_MOVE (that.value));
2920 break;
2921
2922 case symbol_kind::S_FLOAT: // "floating point"
2923 value.copy< double > (YY_MOVE (that.value));
2924 break;
2925
2926 case symbol_kind::S_INTEGER: // "integer"
2927 value.copy< int64_t > (YY_MOVE (that.value));
2928 break;
2929
2930 case symbol_kind::S_STRING: // "constant string"
2931 value.copy< std::string > (YY_MOVE (that.value));
2932 break;
2933
2934 default:
2935 break;
2936 }
2937
2938 }
2939
2940
2941
2942
2943 template <typename Base>
2946 {
2947 return this->kind ();
2948 }
2949
2950
2951 template <typename Base>
2952 bool
2954 {
2955 return this->kind () == symbol_kind::S_YYEMPTY;
2956 }
2957
2958 template <typename Base>
2959 void
2961 {
2962 super_type::move (s);
2963 switch (this->kind ())
2964 {
2965 case symbol_kind::S_value: // value
2966 case symbol_kind::S_map_value: // map_value
2967 case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
2968 case symbol_kind::S_control_socket_type_value: // control_socket_type_value
2969 case symbol_kind::S_auth_type_value: // auth_type_value
2970 value.move< ElementPtr > (YY_MOVE (s.value));
2971 break;
2972
2973 case symbol_kind::S_BOOLEAN: // "boolean"
2974 value.move< bool > (YY_MOVE (s.value));
2975 break;
2976
2977 case symbol_kind::S_FLOAT: // "floating point"
2978 value.move< double > (YY_MOVE (s.value));
2979 break;
2980
2981 case symbol_kind::S_INTEGER: // "integer"
2982 value.move< int64_t > (YY_MOVE (s.value));
2983 break;
2984
2985 case symbol_kind::S_STRING: // "constant string"
2986 value.move< std::string > (YY_MOVE (s.value));
2987 break;
2988
2989 default:
2990 break;
2991 }
2992
2993 location = YY_MOVE (s.location);
2994 }
2995
2996 // by_kind.
2997 inline
2999 : kind_ (symbol_kind::S_YYEMPTY)
3000 {}
3001
3002#if 201103L <= YY_CPLUSPLUS
3003 inline
3005 : kind_ (that.kind_)
3006 {
3007 that.clear ();
3008 }
3009#endif
3010
3011 inline
3013 : kind_ (that.kind_)
3014 {}
3015
3016 inline
3018 : kind_ (yytranslate_ (t))
3019 {}
3020
3021
3022
3023 inline
3024 void
3029
3030 inline
3031 void
3033 {
3034 kind_ = that.kind_;
3035 that.clear ();
3036 }
3037
3038 inline
3041 {
3042 return kind_;
3043 }
3044
3045
3046 inline
3049 {
3050 return this->kind ();
3051 }
3052
3053
3054#line 14 "d2_parser.yy"
3055} } // isc::d2
3056#line 3057 "d2_parser.h"
3057
3058
3059
3060
3061#endif // !YY_D2_PARSER_D2_PARSER_H_INCLUDED
#define YY_RVREF(Type)
#define YY_MOVE_REF(Type)
#define YY_NOEXCEPT
#define YY_ATTRIBUTE_PURE
#define YY_MOVE
#define YY_NOTHROW
Evaluation context, an interface to the expression evaluation.
const symbol_type & lookahead() const YY_NOEXCEPT
Definition d2_parser.h:2510
symbol_kind_type token() const YY_NOEXCEPT
Definition d2_parser.h:2511
const location_type & location() const YY_NOEXCEPT
Definition d2_parser.h:2512
Present a slice of the top of a stack.
Definition d2_parser.h:2777
slice(const stack &stack, index_type range) YY_NOEXCEPT
Definition d2_parser.h:2779
A buffer to store and retrieve objects.
Definition d2_parser.h:231
value_type self_type
Type of *this.
Definition d2_parser.h:234
T & emplace(const T &t)
Instantiate a T in here from t.
Definition d2_parser.h:290
T & emplace()
Instantiate an empty T in here.
Definition d2_parser.h:279
T & build()
Instantiate an empty T in here.
Definition d2_parser.h:303
void copy(const self_type &that)
Copy the content of that to this.
Definition d2_parser.h:386
long double yyalign_me_
Strongest alignment constraints.
Definition d2_parser.h:456
T & as() YY_NOEXCEPT
Accessor to a built T.
Definition d2_parser.h:320
value_type(YY_RVREF(T) t)
Construct and fill.
Definition d2_parser.h:244
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
Definition d2_parser.h:331
~value_type() YY_NOEXCEPT
Destruction, allowed only if empty.
Definition d2_parser.h:259
T & build(const T &t)
Instantiate a T in here from t.
Definition d2_parser.h:312
void destroy()
Destroy the stored T.
Definition d2_parser.h:394
char yyraw_[size]
A buffer large enough to store any of the semantic values.
Definition d2_parser.h:458
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
Definition d2_parser.h:349
void move(self_type &that)
Move the content of that to this.
Definition d2_parser.h:361
value_type() YY_NOEXCEPT
Empty construction.
Definition d2_parser.h:237
A Bison parser.
Definition d2_parser.h:217
static symbol_type make_COMMENT(const location_type &l)
Definition d2_parser.h:1584
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
Definition d2_parser.h:587
static symbol_type make_AUTHENTICATION(const location_type &l)
Definition d2_parser.h:1899
static symbol_type make_STRING(const std::string &v, const location_type &l)
Definition d2_parser.h:2454
static symbol_type make_SUB_DDNS_DOMAIN(const location_type &l)
Definition d2_parser.h:2379
static symbol_type make_SUB_HOOKS_LIBRARY(const location_type &l)
Definition d2_parser.h:2439
static symbol_type make_LOGGERS(const location_type &l)
Definition d2_parser.h:2154
static symbol_type make_KEY_NAME(const location_type &l)
Definition d2_parser.h:1644
static symbol_type make_PARAMETERS(const location_type &l)
Definition d2_parser.h:2139
static symbol_type make_SUB_TSIG_KEYS(const location_type &l)
Definition d2_parser.h:2364
static symbol_type make_FORWARD_DDNS(const location_type &l)
Definition d2_parser.h:1599
static symbol_type make_SUB_DNS_SERVERS(const location_type &l)
Definition d2_parser.h:2424
static symbol_type make_TOPLEVEL_DHCPDDNS(const location_type &l)
Definition d2_parser.h:2319
static symbol_type make_SOCKET_TYPE(const location_type &l)
Definition d2_parser.h:1794
static symbol_type make_SUB_DDNS_DOMAINS(const location_type &l)
Definition d2_parser.h:2394
static symbol_type make_TCP(const location_type &l)
Definition d2_parser.h:1524
static symbol_type make_NAME(const location_type &l)
Definition d2_parser.h:2169
static symbol_type make_MAXSIZE(const location_type &l)
Definition d2_parser.h:2259
static symbol_type make_PASSWORD_FILE(const location_type &l)
Definition d2_parser.h:2034
static symbol_type make_D2_PARSER_UNDEF(const location_type &l)
Definition d2_parser.h:1314
static symbol_type make_HTTPS(const location_type &l)
Definition d2_parser.h:1839
static symbol_type make_OUTPUT_OPTIONS(const location_type &l)
Definition d2_parser.h:2184
static symbol_type make_LSQUARE_BRACKET(const location_type &l)
Definition d2_parser.h:1359
static symbol_type make_PASSWORD(const location_type &l)
Definition d2_parser.h:2019
static symbol_type make_DEBUGLEVEL(const location_type &l)
Definition d2_parser.h:2214
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
Definition d2_parser.h:584
static symbol_type make_LCURLY_BRACKET(const location_type &l)
Definition d2_parser.h:1389
static symbol_type make_DIGEST_BITS(const location_type &l)
Definition d2_parser.h:1719
static symbol_type make_SOCKET_ADDRESS(const location_type &l)
Definition d2_parser.h:1869
static symbol_type make_CERT_FILE(const location_type &l)
Definition d2_parser.h:2064
static symbol_type make_TOPLEVEL_JSON(const location_type &l)
Definition d2_parser.h:2304
static symbol_type make_SOCKET_NAME(const location_type &l)
Definition d2_parser.h:1854
static symbol_type make_DNS_SERVER_TIMEOUT(const location_type &l)
Definition d2_parser.h:1479
static symbol_type make_NULL_TYPE(const location_type &l)
Definition d2_parser.h:1419
static symbol_type make_LIBRARY(const location_type &l)
Definition d2_parser.h:2124
static symbol_type make_UDP(const location_type &l)
Definition d2_parser.h:1509
static symbol_type make_HOOKS_LIBRARIES(const location_type &l)
Definition d2_parser.h:2109
static symbol_type make_COLON(const location_type &l)
Definition d2_parser.h:1344
static symbol_type make_COMMA(const location_type &l)
Definition d2_parser.h:1329
static symbol_type make_SECRET(const location_type &l)
Definition d2_parser.h:1734
static symbol_type make_SUB_TSIG_KEY(const location_type &l)
Definition d2_parser.h:2349
static symbol_type make_RCURLY_BRACKET(const location_type &l)
Definition d2_parser.h:1404
static symbol_type make_UNIX(const location_type &l)
Definition d2_parser.h:1809
static symbol_type make_OUTPUT(const location_type &l)
Definition d2_parser.h:2199
static symbol_type make_SUB_DHCPDDNS(const location_type &l)
Definition d2_parser.h:2334
static const symbol_kind_type YYNTOKENS
The number of tokens.
Definition d2_parser.h:883
static symbol_type make_INTEGER(const int64_t &v, const location_type &l)
Definition d2_parser.h:2469
static symbol_type make_DHCPDDNS(const location_type &l)
Definition d2_parser.h:1434
static symbol_type make_D2_PARSER_error(const location_type &l)
Definition d2_parser.h:1299
static symbol_type make_CONTROL_SOCKETS(const location_type &l)
Definition d2_parser.h:1779
static symbol_type make_SUB_DNS_SERVER(const location_type &l)
Definition d2_parser.h:2409
static symbol_type make_MAXVER(const location_type &l)
Definition d2_parser.h:2274
static symbol_type make_SECRET_FILE(const location_type &l)
Definition d2_parser.h:1749
static symbol_type make_DDNS_DOMAINS(const location_type &l)
Definition d2_parser.h:1629
static symbol_type make_SEVERITY(const location_type &l)
Definition d2_parser.h:2229
static symbol_type make_REALM(const location_type &l)
Definition d2_parser.h:1944
static symbol_type make_RSQUARE_BRACKET(const location_type &l)
Definition d2_parser.h:1374
static symbol_type make_HTTP(const location_type &l)
Definition d2_parser.h:1824
static symbol_type make_HOSTNAME(const location_type &l)
Definition d2_parser.h:1674
static symbol_type make_USER_CONTEXT(const location_type &l)
Definition d2_parser.h:1569
static symbol_type make_USER(const location_type &l)
Definition d2_parser.h:1989
static symbol_type make_SOCKET_PORT(const location_type &l)
Definition d2_parser.h:1884
static symbol_type make_BASIC(const location_type &l)
Definition d2_parser.h:1929
static symbol_type make_FLUSH(const location_type &l)
Definition d2_parser.h:2244
static symbol_type make_REVERSE_DDNS(const location_type &l)
Definition d2_parser.h:1614
static symbol_type make_PATTERN(const location_type &l)
Definition d2_parser.h:2289
value_type semantic_type
Backward compatibility (Bison 3.8).
Definition d2_parser.h:467
static symbol_type make_KEY_FILE(const location_type &l)
Definition d2_parser.h:2079
static symbol_type make_ALGORITHM(const location_type &l)
Definition d2_parser.h:1704
static symbol_type make_IP_ADDRESS(const location_type &l)
Definition d2_parser.h:1449
static symbol_type make_PORT(const location_type &l)
Definition d2_parser.h:1464
static symbol_type make_CLIENTS(const location_type &l)
Definition d2_parser.h:1974
static symbol_type make_CERT_REQUIRED(const location_type &l)
Definition d2_parser.h:2094
static std::string symbol_name(symbol_kind_type yysymbol)
The user-facing name of the symbol whose (internal) number is YYSYMBOL.
static symbol_type make_TYPE(const location_type &l)
Definition d2_parser.h:1914
static symbol_type make_TRUST_ANCHOR(const location_type &l)
Definition d2_parser.h:2049
static symbol_type make_FLOAT(const double &v, const location_type &l)
Definition d2_parser.h:2484
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
Definition d2_parser.h:880
static symbol_type make_BOOLEAN(const bool &v, const location_type &l)
Definition d2_parser.h:2499
static symbol_type make_DIRECTORY(const location_type &l)
Definition d2_parser.h:1959
static symbol_type make_JSON(const location_type &l)
Definition d2_parser.h:1554
location location_type
Symbol locations.
Definition d2_parser.h:470
static symbol_type make_END(const location_type &l)
Definition d2_parser.h:1284
static symbol_type make_CONTROL_SOCKET(const location_type &l)
Definition d2_parser.h:1764
static symbol_type make_NCR_PROTOCOL(const location_type &l)
Definition d2_parser.h:1494
static symbol_type make_DNS_SERVERS(const location_type &l)
Definition d2_parser.h:1659
static symbol_type make_USER_FILE(const location_type &l)
Definition d2_parser.h:2004
static symbol_type make_TSIG_KEYS(const location_type &l)
Definition d2_parser.h:1689
static symbol_type make_NCR_FORMAT(const location_type &l)
Definition d2_parser.h:1539
Forward declaration of the ParserContext class.
A collection of classes for housing and parsing the application configuration necessary for the DHCP-...
#define D2_PARSER__ASSERT
Definition d2_parser.h:110
boost::shared_ptr< Element > ElementPtr
Definition data.h:28
Defines the logger used by the top-level component of kea-lfc.
value_type value
The semantic value.
Definition d2_parser.h:1100
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
Definition d2_parser.h:1085
basic_symbol() YY_NOEXCEPT
Default constructor.
Definition d2_parser.h:898
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
Definition d2_parser.h:994
bool empty() const YY_NOEXCEPT
Whether empty.
Definition d2_parser.h:2953
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
Definition d2_parser.h:1022
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
Definition d2_parser.h:953
basic_symbol(typename Base::kind_type t, const int64_t &v, const location_type &l)
Definition d2_parser.h:1008
location_type location
The location.
Definition d2_parser.h:1103
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
Definition d2_parser.h:2945
~basic_symbol()
Destroy the symbol.
Definition d2_parser.h:1030
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
Definition d2_parser.h:980
void move(basic_symbol &s)
Destructive move, s is emptied into this.
Definition d2_parser.h:2960
void clear() YY_NOEXCEPT
Destroy contents, and record that is empty.
Definition d2_parser.h:1038
basic_symbol(const basic_symbol &that)
Copy constructor.
Definition d2_parser.h:2903
basic_symbol(typename Base::kind_type t, const ElementPtr &v, const location_type &l)
Definition d2_parser.h:966
Base super_type
Alias to Base.
Definition d2_parser.h:895
Type access provider for token (enum) based symbols.
Definition d2_parser.h:1114
void clear() YY_NOEXCEPT
Record that this symbol is empty.
Definition d2_parser.h:3025
by_kind() YY_NOEXCEPT
Default constructor.
Definition d2_parser.h:2998
token_kind_type kind_type
The symbol kind as needed by the constructor.
Definition d2_parser.h:1116
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
Definition d2_parser.h:3048
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
Definition d2_parser.h:3040
void move(by_kind &that)
Steal the symbol kind from that.
Definition d2_parser.h:3032
symbol_kind_type kind_
The symbol kind.
Definition d2_parser.h:1149
@ YYNTOKENS
Number of tokens.
Definition d2_parser.h:594
"External" symbols: returned by the scanner.
Definition d2_parser.h:1157
basic_symbol< by_kind > super_type
Superclass.
Definition d2_parser.h:1159
symbol_type() YY_NOEXCEPT
Empty symbol.
Definition d2_parser.h:1162
Syntax errors thrown from user actions.
Definition d2_parser.h:474
syntax_error(const location_type &l, const std::string &m)
Definition d2_parser.h:475
~syntax_error() YY_NOEXCEPT YY_NOTHROW
Definition d2_parser.cc:165
syntax_error(const syntax_error &s)
Definition d2_parser.h:480
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).
Definition d2_parser.h:580