Kea 2.5.6
agent_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_AGENT_AGENT_PARSER_H_INCLUDED
46# define YY_AGENT_AGENT_PARSER_H_INCLUDED
47// "%code requires" blocks.
48#line 17 "agent_parser.yy"
49
50#include <string>
51#include <cc/data.h>
52#include <boost/lexical_cast.hpp>
54
55using namespace isc::agent;
56using namespace isc::data;
57using namespace std;
58
59#line 60 "agent_parser.h"
60
61# include <cassert>
62# include <cstdlib> // std::abort
63# include <iostream>
64# include <stdexcept>
65# include <string>
66# include <vector>
67
68#if defined __cplusplus
69# define YY_CPLUSPLUS __cplusplus
70#else
71# define YY_CPLUSPLUS 199711L
72#endif
73
74// Support move semantics when possible.
75#if 201103L <= YY_CPLUSPLUS
76# define YY_MOVE std::move
77# define YY_MOVE_OR_COPY move
78# define YY_MOVE_REF(Type) Type&&
79# define YY_RVREF(Type) Type&&
80# define YY_COPY(Type) Type
81#else
82# define YY_MOVE
83# define YY_MOVE_OR_COPY copy
84# define YY_MOVE_REF(Type) Type&
85# define YY_RVREF(Type) const Type&
86# define YY_COPY(Type) const Type&
87#endif
88
89// Support noexcept when possible.
90#if 201103L <= YY_CPLUSPLUS
91# define YY_NOEXCEPT noexcept
92# define YY_NOTHROW
93#else
94# define YY_NOEXCEPT
95# define YY_NOTHROW throw ()
96#endif
97
98// Support constexpr when possible.
99#if 201703 <= YY_CPLUSPLUS
100# define YY_CONSTEXPR constexpr
101#else
102# define YY_CONSTEXPR
103#endif
104# include "location.hh"
105#include <typeinfo>
106#ifndef AGENT__ASSERT
107# include <cassert>
108# define AGENT__ASSERT assert
109#endif
110
111
112#ifndef YY_ATTRIBUTE_PURE
113# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
114# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
115# else
116# define YY_ATTRIBUTE_PURE
117# endif
118#endif
119
120#ifndef YY_ATTRIBUTE_UNUSED
121# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
122# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
123# else
124# define YY_ATTRIBUTE_UNUSED
125# endif
126#endif
127
128/* Suppress unused-variable warnings by "using" E. */
129#if ! defined lint || defined __GNUC__
130# define YY_USE(E) ((void) (E))
131#else
132# define YY_USE(E) /* empty */
133#endif
134
135/* Suppress an incorrect diagnostic about yylval being uninitialized. */
136#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
137# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
138# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
139 _Pragma ("GCC diagnostic push") \
140 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
141# else
142# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
143 _Pragma ("GCC diagnostic push") \
144 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
145 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
146# endif
147# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
148 _Pragma ("GCC diagnostic pop")
149#else
150# define YY_INITIAL_VALUE(Value) Value
151#endif
152#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
153# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
154# define YY_IGNORE_MAYBE_UNINITIALIZED_END
155#endif
156#ifndef YY_INITIAL_VALUE
157# define YY_INITIAL_VALUE(Value) /* Nothing. */
158#endif
159
160#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
161# define YY_IGNORE_USELESS_CAST_BEGIN \
162 _Pragma ("GCC diagnostic push") \
163 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
164# define YY_IGNORE_USELESS_CAST_END \
165 _Pragma ("GCC diagnostic pop")
166#endif
167#ifndef YY_IGNORE_USELESS_CAST_BEGIN
168# define YY_IGNORE_USELESS_CAST_BEGIN
169# define YY_IGNORE_USELESS_CAST_END
170#endif
171
172# ifndef YY_CAST
173# ifdef __cplusplus
174# define YY_CAST(Type, Val) static_cast<Type> (Val)
175# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
176# else
177# define YY_CAST(Type, Val) ((Type) (Val))
178# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
179# endif
180# endif
181# ifndef YY_NULLPTR
182# if defined __cplusplus
183# if 201103L <= __cplusplus
184# define YY_NULLPTR nullptr
185# else
186# define YY_NULLPTR 0
187# endif
188# else
189# define YY_NULLPTR ((void*)0)
190# endif
191# endif
192
193/* Debug traces. */
194#ifndef AGENT_DEBUG
195# if defined YYDEBUG
196#if YYDEBUG
197# define AGENT_DEBUG 1
198# else
199# define AGENT_DEBUG 0
200# endif
201# else /* ! defined YYDEBUG */
202# define AGENT_DEBUG 1
203# endif /* ! defined YYDEBUG */
204#endif /* ! defined AGENT_DEBUG */
205
206#line 14 "agent_parser.yy"
207namespace isc { namespace agent {
208#line 209 "agent_parser.h"
209
210
211
212
215 {
216 public:
217#ifdef AGENT_STYPE
218# ifdef __GNUC__
219# pragma GCC message "bison: do not #define AGENT_STYPE in C++, use %define api.value.type"
220# endif
221 typedef AGENT_STYPE value_type;
222#else
229 {
230 public:
233
236 : yyraw_ ()
237 , yytypeid_ (YY_NULLPTR)
238 {}
239
241 template <typename T>
243 : yytypeid_ (&typeid (T))
244 {
245 AGENT__ASSERT (sizeof (T) <= size);
246 new (yyas_<T> ()) T (YY_MOVE (t));
247 }
248
249#if 201103L <= YY_CPLUSPLUS
251 value_type (const self_type&) = delete;
253 self_type& operator= (const self_type&) = delete;
254#endif
255
258 {
259 AGENT__ASSERT (!yytypeid_);
260 }
261
262# if 201103L <= YY_CPLUSPLUS
264 template <typename T, typename... U>
265 T&
266 emplace (U&&... u)
267 {
268 AGENT__ASSERT (!yytypeid_);
269 AGENT__ASSERT (sizeof (T) <= size);
270 yytypeid_ = & typeid (T);
271 return *new (yyas_<T> ()) T (std::forward <U>(u)...);
272 }
273# else
275 template <typename T>
276 T&
278 {
279 AGENT__ASSERT (!yytypeid_);
280 AGENT__ASSERT (sizeof (T) <= size);
281 yytypeid_ = & typeid (T);
282 return *new (yyas_<T> ()) T ();
283 }
284
286 template <typename T>
287 T&
288 emplace (const T& t)
289 {
290 AGENT__ASSERT (!yytypeid_);
291 AGENT__ASSERT (sizeof (T) <= size);
292 yytypeid_ = & typeid (T);
293 return *new (yyas_<T> ()) T (t);
294 }
295# endif
296
299 template <typename T>
300 T&
302 {
303 return emplace<T> ();
304 }
305
308 template <typename T>
309 T&
310 build (const T& t)
311 {
312 return emplace<T> (t);
313 }
314
316 template <typename T>
317 T&
319 {
320 AGENT__ASSERT (yytypeid_);
321 AGENT__ASSERT (*yytypeid_ == typeid (T));
322 AGENT__ASSERT (sizeof (T) <= size);
323 return *yyas_<T> ();
324 }
325
327 template <typename T>
328 const T&
330 {
331 AGENT__ASSERT (yytypeid_);
332 AGENT__ASSERT (*yytypeid_ == typeid (T));
333 AGENT__ASSERT (sizeof (T) <= size);
334 return *yyas_<T> ();
335 }
336
345 template <typename T>
346 void
348 {
349 AGENT__ASSERT (yytypeid_);
350 AGENT__ASSERT (*yytypeid_ == *that.yytypeid_);
351 std::swap (as<T> (), that.as<T> ());
352 }
353
357 template <typename T>
358 void
360 {
361# if 201103L <= YY_CPLUSPLUS
362 emplace<T> (std::move (that.as<T> ()));
363# else
364 emplace<T> ();
365 swap<T> (that);
366# endif
367 that.destroy<T> ();
368 }
369
370# if 201103L <= YY_CPLUSPLUS
372 template <typename T>
373 void
374 move (self_type&& that)
375 {
376 emplace<T> (std::move (that.as<T> ()));
377 that.destroy<T> ();
378 }
379#endif
380
382 template <typename T>
383 void
384 copy (const self_type& that)
385 {
386 emplace<T> (that.as<T> ());
387 }
388
390 template <typename T>
391 void
393 {
394 as<T> ().~T ();
395 yytypeid_ = YY_NULLPTR;
396 }
397
398 private:
399#if YY_CPLUSPLUS < 201103L
401 value_type (const self_type&);
403 self_type& operator= (const self_type&);
404#endif
405
407 template <typename T>
408 T*
409 yyas_ () YY_NOEXCEPT
410 {
411 void *yyp = yyraw_;
412 return static_cast<T*> (yyp);
413 }
414
416 template <typename T>
417 const T*
418 yyas_ () const YY_NOEXCEPT
419 {
420 const void *yyp = yyraw_;
421 return static_cast<const T*> (yyp);
422 }
423
425 union union_type
426 {
427 // value
428 // map_value
429 // socket_type_value
430 // auth_type_value
431 char dummy1[sizeof (ElementPtr)];
432
433 // "boolean"
434 char dummy2[sizeof (bool)];
435
436 // "floating point"
437 char dummy3[sizeof (double)];
438
439 // "integer"
440 char dummy4[sizeof (int64_t)];
441
442 // "constant string"
443 char dummy5[sizeof (std::string)];
444 };
445
447 enum { size = sizeof (union_type) };
448
450 union
451 {
453 long double yyalign_me_;
455 char yyraw_[size];
456 };
457
459 const std::type_info *yytypeid_;
460 };
461
462#endif
465
467 typedef location location_type;
468
470 struct syntax_error : std::runtime_error
471 {
472 syntax_error (const location_type& l, const std::string& m)
473 : std::runtime_error (m)
474 , location (l)
475 {}
476
478 : std::runtime_error (s.what ())
479 , location (s.location)
480 {}
481
483
485 };
486
488 struct token
489 {
491 {
492 TOKEN_AGENT_EMPTY = -2,
493 TOKEN_END = 0, // "end of file"
494 TOKEN_AGENT_error = 256, // error
495 TOKEN_AGENT_UNDEF = 257, // "invalid token"
496 TOKEN_COMMA = 258, // ","
497 TOKEN_COLON = 259, // ":"
498 TOKEN_LSQUARE_BRACKET = 260, // "["
499 TOKEN_RSQUARE_BRACKET = 261, // "]"
500 TOKEN_LCURLY_BRACKET = 262, // "{"
501 TOKEN_RCURLY_BRACKET = 263, // "}"
502 TOKEN_NULL_TYPE = 264, // "null"
503 TOKEN_CONTROL_AGENT = 265, // "Control-agent"
504 TOKEN_HTTP_HOST = 266, // "http-host"
505 TOKEN_HTTP_PORT = 267, // "http-port"
506 TOKEN_USER_CONTEXT = 268, // "user-context"
507 TOKEN_COMMENT = 269, // "comment"
508 TOKEN_AUTHENTICATION = 270, // "authentication"
509 TOKEN_TYPE = 271, // "type"
510 TOKEN_BASIC = 272, // "basic"
511 TOKEN_REALM = 273, // "realm"
512 TOKEN_DIRECTORY = 274, // "directory"
513 TOKEN_CLIENTS = 275, // "clients"
514 TOKEN_USER = 276, // "user"
515 TOKEN_USER_FILE = 277, // "user-file"
516 TOKEN_PASSWORD = 278, // "password"
517 TOKEN_PASSWORD_FILE = 279, // "password-file"
518 TOKEN_TRUST_ANCHOR = 280, // "trust-anchor"
519 TOKEN_CERT_FILE = 281, // "cert-file"
520 TOKEN_KEY_FILE = 282, // "key-file"
521 TOKEN_CERT_REQUIRED = 283, // "cert-required"
522 TOKEN_CONTROL_SOCKETS = 284, // "control-sockets"
523 TOKEN_DHCP4_SERVER = 285, // "dhcp4"
524 TOKEN_DHCP6_SERVER = 286, // "dhcp6"
525 TOKEN_D2_SERVER = 287, // "d2"
526 TOKEN_SOCKET_NAME = 288, // "socket-name"
527 TOKEN_SOCKET_TYPE = 289, // "socket-type"
528 TOKEN_UNIX = 290, // "unix"
529 TOKEN_HOOKS_LIBRARIES = 291, // "hooks-libraries"
530 TOKEN_LIBRARY = 292, // "library"
531 TOKEN_PARAMETERS = 293, // "parameters"
532 TOKEN_LOGGERS = 294, // "loggers"
533 TOKEN_NAME = 295, // "name"
534 TOKEN_OUTPUT_OPTIONS = 296, // "output-options"
535 TOKEN_OUTPUT = 297, // "output"
536 TOKEN_DEBUGLEVEL = 298, // "debuglevel"
537 TOKEN_SEVERITY = 299, // "severity"
538 TOKEN_FLUSH = 300, // "flush"
539 TOKEN_MAXSIZE = 301, // "maxsize"
540 TOKEN_MAXVER = 302, // "maxver"
541 TOKEN_PATTERN = 303, // "pattern"
542 TOKEN_START_JSON = 304, // START_JSON
543 TOKEN_START_AGENT = 305, // START_AGENT
544 TOKEN_START_SUB_AGENT = 306, // START_SUB_AGENT
545 TOKEN_STRING = 307, // "constant string"
546 TOKEN_INTEGER = 308, // "integer"
547 TOKEN_FLOAT = 309, // "floating point"
548 TOKEN_BOOLEAN = 310 // "boolean"
549 };
552 };
553
556
559
562 {
564 {
565 YYNTOKENS = 56,
566 S_YYEMPTY = -2,
567 S_YYEOF = 0, // "end of file"
568 S_YYerror = 1, // error
569 S_YYUNDEF = 2, // "invalid token"
570 S_COMMA = 3, // ","
571 S_COLON = 4, // ":"
572 S_LSQUARE_BRACKET = 5, // "["
573 S_RSQUARE_BRACKET = 6, // "]"
574 S_LCURLY_BRACKET = 7, // "{"
575 S_RCURLY_BRACKET = 8, // "}"
576 S_NULL_TYPE = 9, // "null"
577 S_CONTROL_AGENT = 10, // "Control-agent"
578 S_HTTP_HOST = 11, // "http-host"
579 S_HTTP_PORT = 12, // "http-port"
580 S_USER_CONTEXT = 13, // "user-context"
581 S_COMMENT = 14, // "comment"
582 S_AUTHENTICATION = 15, // "authentication"
583 S_TYPE = 16, // "type"
584 S_BASIC = 17, // "basic"
585 S_REALM = 18, // "realm"
586 S_DIRECTORY = 19, // "directory"
587 S_CLIENTS = 20, // "clients"
588 S_USER = 21, // "user"
589 S_USER_FILE = 22, // "user-file"
590 S_PASSWORD = 23, // "password"
591 S_PASSWORD_FILE = 24, // "password-file"
592 S_TRUST_ANCHOR = 25, // "trust-anchor"
593 S_CERT_FILE = 26, // "cert-file"
594 S_KEY_FILE = 27, // "key-file"
595 S_CERT_REQUIRED = 28, // "cert-required"
596 S_CONTROL_SOCKETS = 29, // "control-sockets"
597 S_DHCP4_SERVER = 30, // "dhcp4"
598 S_DHCP6_SERVER = 31, // "dhcp6"
599 S_D2_SERVER = 32, // "d2"
600 S_SOCKET_NAME = 33, // "socket-name"
601 S_SOCKET_TYPE = 34, // "socket-type"
602 S_UNIX = 35, // "unix"
603 S_HOOKS_LIBRARIES = 36, // "hooks-libraries"
604 S_LIBRARY = 37, // "library"
605 S_PARAMETERS = 38, // "parameters"
606 S_LOGGERS = 39, // "loggers"
607 S_NAME = 40, // "name"
608 S_OUTPUT_OPTIONS = 41, // "output-options"
609 S_OUTPUT = 42, // "output"
610 S_DEBUGLEVEL = 43, // "debuglevel"
611 S_SEVERITY = 44, // "severity"
612 S_FLUSH = 45, // "flush"
613 S_MAXSIZE = 46, // "maxsize"
614 S_MAXVER = 47, // "maxver"
615 S_PATTERN = 48, // "pattern"
616 S_START_JSON = 49, // START_JSON
617 S_START_AGENT = 50, // START_AGENT
618 S_START_SUB_AGENT = 51, // START_SUB_AGENT
619 S_STRING = 52, // "constant string"
620 S_INTEGER = 53, // "integer"
621 S_FLOAT = 54, // "floating point"
622 S_BOOLEAN = 55, // "boolean"
623 S_YYACCEPT = 56, // $accept
624 S_start = 57, // start
625 S_58_1 = 58, // $@1
626 S_59_2 = 59, // $@2
627 S_60_3 = 60, // $@3
628 S_sub_agent = 61, // sub_agent
629 S_62_4 = 62, // $@4
630 S_json = 63, // json
631 S_value = 64, // value
632 S_map = 65, // map
633 S_66_5 = 66, // $@5
634 S_map_value = 67, // map_value
635 S_map_content = 68, // map_content
636 S_not_empty_map = 69, // not_empty_map
637 S_list_generic = 70, // list_generic
638 S_71_6 = 71, // $@6
639 S_list_content = 72, // list_content
640 S_not_empty_list = 73, // not_empty_list
641 S_unknown_map_entry = 74, // unknown_map_entry
642 S_agent_syntax_map = 75, // agent_syntax_map
643 S_76_7 = 76, // $@7
644 S_global_object = 77, // global_object
645 S_78_8 = 78, // $@8
646 S_global_object_comma = 79, // global_object_comma
647 S_global_params = 80, // global_params
648 S_global_param = 81, // global_param
649 S_http_host = 82, // http_host
650 S_83_9 = 83, // $@9
651 S_http_port = 84, // http_port
652 S_trust_anchor = 85, // trust_anchor
653 S_86_10 = 86, // $@10
654 S_cert_file = 87, // cert_file
655 S_88_11 = 88, // $@11
656 S_key_file = 89, // key_file
657 S_90_12 = 90, // $@12
658 S_cert_required = 91, // cert_required
659 S_user_context = 92, // user_context
660 S_93_13 = 93, // $@13
661 S_comment = 94, // comment
662 S_95_14 = 95, // $@14
663 S_hooks_libraries = 96, // hooks_libraries
664 S_97_15 = 97, // $@15
665 S_hooks_libraries_list = 98, // hooks_libraries_list
666 S_not_empty_hooks_libraries_list = 99, // not_empty_hooks_libraries_list
667 S_hooks_library = 100, // hooks_library
668 S_101_16 = 101, // $@16
669 S_hooks_params = 102, // hooks_params
670 S_hooks_param = 103, // hooks_param
671 S_library = 104, // library
672 S_105_17 = 105, // $@17
673 S_parameters = 106, // parameters
674 S_107_18 = 107, // $@18
675 S_control_sockets = 108, // control_sockets
676 S_109_19 = 109, // $@19
677 S_control_sockets_params = 110, // control_sockets_params
678 S_control_socket = 111, // control_socket
679 S_dhcp4_server_socket = 112, // dhcp4_server_socket
680 S_113_20 = 113, // $@20
681 S_dhcp6_server_socket = 114, // dhcp6_server_socket
682 S_115_21 = 115, // $@21
683 S_d2_server_socket = 116, // d2_server_socket
684 S_117_22 = 117, // $@22
685 S_control_socket_params = 118, // control_socket_params
686 S_control_socket_param = 119, // control_socket_param
687 S_socket_name = 120, // socket_name
688 S_121_23 = 121, // $@23
689 S_socket_type = 122, // socket_type
690 S_123_24 = 123, // $@24
691 S_socket_type_value = 124, // socket_type_value
692 S_authentication = 125, // authentication
693 S_126_25 = 126, // $@25
694 S_auth_params = 127, // auth_params
695 S_auth_param = 128, // auth_param
696 S_auth_type = 129, // auth_type
697 S_130_26 = 130, // $@26
698 S_auth_type_value = 131, // auth_type_value
699 S_realm = 132, // realm
700 S_133_27 = 133, // $@27
701 S_directory = 134, // directory
702 S_135_28 = 135, // $@28
703 S_clients = 136, // clients
704 S_137_29 = 137, // $@29
705 S_clients_list = 138, // clients_list
706 S_not_empty_clients_list = 139, // not_empty_clients_list
707 S_basic_auth = 140, // basic_auth
708 S_141_30 = 141, // $@30
709 S_clients_params = 142, // clients_params
710 S_clients_param = 143, // clients_param
711 S_user = 144, // user
712 S_145_31 = 145, // $@31
713 S_user_file = 146, // user_file
714 S_147_32 = 147, // $@32
715 S_password = 148, // password
716 S_149_33 = 149, // $@33
717 S_password_file = 150, // password_file
718 S_151_34 = 151, // $@34
719 S_loggers = 152, // loggers
720 S_153_35 = 153, // $@35
721 S_loggers_entries = 154, // loggers_entries
722 S_logger_entry = 155, // logger_entry
723 S_156_36 = 156, // $@36
724 S_logger_params = 157, // logger_params
725 S_logger_param = 158, // logger_param
726 S_name = 159, // name
727 S_160_37 = 160, // $@37
728 S_debuglevel = 161, // debuglevel
729 S_severity = 162, // severity
730 S_163_38 = 163, // $@38
731 S_output_options_list = 164, // output_options_list
732 S_165_39 = 165, // $@39
733 S_output_options_list_content = 166, // output_options_list_content
734 S_output_entry = 167, // output_entry
735 S_168_40 = 168, // $@40
736 S_output_params_list = 169, // output_params_list
737 S_output_params = 170, // output_params
738 S_output = 171, // output
739 S_172_41 = 172, // $@41
740 S_flush = 173, // flush
741 S_maxsize = 174, // maxsize
742 S_maxver = 175, // maxver
743 S_pattern = 176, // pattern
744 S_177_42 = 177 // $@42
745 };
746 };
747
750
753
760 template <typename Base>
761 struct basic_symbol : Base
762 {
764 typedef Base super_type;
765
768 : value ()
769 , location ()
770 {}
771
772#if 201103L <= YY_CPLUSPLUS
775 : Base (std::move (that))
776 , value ()
777 , location (std::move (that.location))
778 {
779 switch (this->kind ())
780 {
781 case symbol_kind::S_value: // value
782 case symbol_kind::S_map_value: // map_value
783 case symbol_kind::S_socket_type_value: // socket_type_value
784 case symbol_kind::S_auth_type_value: // auth_type_value
785 value.move< ElementPtr > (std::move (that.value));
786 break;
787
788 case symbol_kind::S_BOOLEAN: // "boolean"
789 value.move< bool > (std::move (that.value));
790 break;
791
792 case symbol_kind::S_FLOAT: // "floating point"
793 value.move< double > (std::move (that.value));
794 break;
795
796 case symbol_kind::S_INTEGER: // "integer"
797 value.move< int64_t > (std::move (that.value));
798 break;
799
800 case symbol_kind::S_STRING: // "constant string"
801 value.move< std::string > (std::move (that.value));
802 break;
803
804 default:
805 break;
806 }
807
808 }
809#endif
810
813
815#if 201103L <= YY_CPLUSPLUS
816 basic_symbol (typename Base::kind_type t, location_type&& l)
817 : Base (t)
818 , location (std::move (l))
819 {}
820#else
821 basic_symbol (typename Base::kind_type t, const location_type& l)
822 : Base (t)
823 , location (l)
824 {}
825#endif
826
827#if 201103L <= YY_CPLUSPLUS
828 basic_symbol (typename Base::kind_type t, ElementPtr&& v, location_type&& l)
829 : Base (t)
830 , value (std::move (v))
831 , location (std::move (l))
832 {}
833#else
834 basic_symbol (typename Base::kind_type t, const ElementPtr& v, const location_type& l)
835 : Base (t)
836 , value (v)
837 , location (l)
838 {}
839#endif
840
841#if 201103L <= YY_CPLUSPLUS
842 basic_symbol (typename Base::kind_type t, bool&& v, location_type&& l)
843 : Base (t)
844 , value (std::move (v))
845 , location (std::move (l))
846 {}
847#else
848 basic_symbol (typename Base::kind_type t, const bool& v, const location_type& l)
849 : Base (t)
850 , value (v)
851 , location (l)
852 {}
853#endif
854
855#if 201103L <= YY_CPLUSPLUS
856 basic_symbol (typename Base::kind_type t, double&& v, location_type&& l)
857 : Base (t)
858 , value (std::move (v))
859 , location (std::move (l))
860 {}
861#else
862 basic_symbol (typename Base::kind_type t, const double& v, const location_type& l)
863 : Base (t)
864 , value (v)
865 , location (l)
866 {}
867#endif
868
869#if 201103L <= YY_CPLUSPLUS
870 basic_symbol (typename Base::kind_type t, int64_t&& v, location_type&& l)
871 : Base (t)
872 , value (std::move (v))
873 , location (std::move (l))
874 {}
875#else
876 basic_symbol (typename Base::kind_type t, const int64_t& v, const location_type& l)
877 : Base (t)
878 , value (v)
879 , location (l)
880 {}
881#endif
882
883#if 201103L <= YY_CPLUSPLUS
884 basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l)
885 : Base (t)
886 , value (std::move (v))
887 , location (std::move (l))
888 {}
889#else
890 basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l)
891 : Base (t)
892 , value (v)
893 , location (l)
894 {}
895#endif
896
899 {
900 clear ();
901 }
902
903
904
907 {
908 // User destructor.
909 symbol_kind_type yykind = this->kind ();
910 basic_symbol<Base>& yysym = *this;
911 (void) yysym;
912 switch (yykind)
913 {
914 default:
915 break;
916 }
917
918 // Value type destructor.
919switch (yykind)
920 {
921 case symbol_kind::S_value: // value
922 case symbol_kind::S_map_value: // map_value
923 case symbol_kind::S_socket_type_value: // socket_type_value
924 case symbol_kind::S_auth_type_value: // auth_type_value
925 value.template destroy< ElementPtr > ();
926 break;
927
928 case symbol_kind::S_BOOLEAN: // "boolean"
929 value.template destroy< bool > ();
930 break;
931
932 case symbol_kind::S_FLOAT: // "floating point"
933 value.template destroy< double > ();
934 break;
935
936 case symbol_kind::S_INTEGER: // "integer"
937 value.template destroy< int64_t > ();
938 break;
939
940 case symbol_kind::S_STRING: // "constant string"
941 value.template destroy< std::string > ();
942 break;
943
944 default:
945 break;
946 }
947
948 Base::clear ();
949 }
950
952 std::string name () const YY_NOEXCEPT
953 {
954 return AgentParser::symbol_name (this->kind ());
955 }
956
959
961 bool empty () const YY_NOEXCEPT;
962
964 void move (basic_symbol& s);
965
968
971
972 private:
973#if YY_CPLUSPLUS < 201103L
975 basic_symbol& operator= (const basic_symbol& that);
976#endif
977 };
978
980 struct by_kind
981 {
984
987
988#if 201103L <= YY_CPLUSPLUS
990 by_kind (by_kind&& that) YY_NOEXCEPT;
991#endif
992
994 by_kind (const by_kind& that) YY_NOEXCEPT;
995
998
999
1000
1002 void clear () YY_NOEXCEPT;
1003
1005 void move (by_kind& that);
1006
1009 symbol_kind_type kind () const YY_NOEXCEPT;
1010
1012 symbol_kind_type type_get () const YY_NOEXCEPT;
1013
1017 };
1018
1021
1024 {
1027
1030
1032#if 201103L <= YY_CPLUSPLUS
1033 symbol_type (int tok, location_type l)
1034 : super_type (token_kind_type (tok), std::move (l))
1035#else
1036 symbol_type (int tok, const location_type& l)
1037 : super_type (token_kind_type (tok), l)
1038#endif
1039 {
1040#if !defined _MSC_VER || defined __clang__
1041 AGENT__ASSERT (tok == token::TOKEN_END
1042 || (token::TOKEN_AGENT_error <= tok && tok <= token::TOKEN_START_SUB_AGENT));
1043#endif
1044 }
1045#if 201103L <= YY_CPLUSPLUS
1046 symbol_type (int tok, bool v, location_type l)
1047 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1048#else
1049 symbol_type (int tok, const bool& v, const location_type& l)
1050 : super_type (token_kind_type (tok), v, l)
1051#endif
1052 {
1053#if !defined _MSC_VER || defined __clang__
1054 AGENT__ASSERT (tok == token::TOKEN_BOOLEAN);
1055#endif
1056 }
1057#if 201103L <= YY_CPLUSPLUS
1058 symbol_type (int tok, double v, location_type l)
1059 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1060#else
1061 symbol_type (int tok, const double& v, const location_type& l)
1062 : super_type (token_kind_type (tok), v, l)
1063#endif
1064 {
1065#if !defined _MSC_VER || defined __clang__
1066 AGENT__ASSERT (tok == token::TOKEN_FLOAT);
1067#endif
1068 }
1069#if 201103L <= YY_CPLUSPLUS
1070 symbol_type (int tok, int64_t v, location_type l)
1071 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1072#else
1073 symbol_type (int tok, const int64_t& v, const location_type& l)
1074 : super_type (token_kind_type (tok), v, l)
1075#endif
1076 {
1077#if !defined _MSC_VER || defined __clang__
1078 AGENT__ASSERT (tok == token::TOKEN_INTEGER);
1079#endif
1080 }
1081#if 201103L <= YY_CPLUSPLUS
1082 symbol_type (int tok, std::string v, location_type l)
1083 : super_type (token_kind_type (tok), std::move (v), std::move (l))
1084#else
1085 symbol_type (int tok, const std::string& v, const location_type& l)
1086 : super_type (token_kind_type (tok), v, l)
1087#endif
1088 {
1089#if !defined _MSC_VER || defined __clang__
1090 AGENT__ASSERT (tok == token::TOKEN_STRING);
1091#endif
1092 }
1093 };
1094
1097 virtual ~AgentParser ();
1098
1099#if 201103L <= YY_CPLUSPLUS
1101 AgentParser (const AgentParser&) = delete;
1103 AgentParser& operator= (const AgentParser&) = delete;
1104#endif
1105
1108 int operator() ();
1109
1112 virtual int parse ();
1113
1114#if AGENT_DEBUG
1116 std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
1118 void set_debug_stream (std::ostream &);
1119
1121 typedef int debug_level_type;
1123 debug_level_type debug_level () const YY_ATTRIBUTE_PURE;
1125 void set_debug_level (debug_level_type l);
1126#endif
1127
1131 virtual void error (const location_type& loc, const std::string& msg);
1132
1134 void error (const syntax_error& err);
1135
1138 static std::string symbol_name (symbol_kind_type yysymbol);
1139
1140 // Implementation of make_symbol for each token kind.
1141#if 201103L <= YY_CPLUSPLUS
1142 static
1143 symbol_type
1144 make_END (location_type l)
1145 {
1146 return symbol_type (token::TOKEN_END, std::move (l));
1147 }
1148#else
1149 static
1150 symbol_type
1152 {
1153 return symbol_type (token::TOKEN_END, l);
1154 }
1155#endif
1156#if 201103L <= YY_CPLUSPLUS
1157 static
1158 symbol_type
1159 make_AGENT_error (location_type l)
1160 {
1161 return symbol_type (token::TOKEN_AGENT_error, std::move (l));
1162 }
1163#else
1164 static
1165 symbol_type
1167 {
1168 return symbol_type (token::TOKEN_AGENT_error, l);
1169 }
1170#endif
1171#if 201103L <= YY_CPLUSPLUS
1172 static
1173 symbol_type
1174 make_AGENT_UNDEF (location_type l)
1175 {
1176 return symbol_type (token::TOKEN_AGENT_UNDEF, std::move (l));
1177 }
1178#else
1179 static
1180 symbol_type
1182 {
1183 return symbol_type (token::TOKEN_AGENT_UNDEF, l);
1184 }
1185#endif
1186#if 201103L <= YY_CPLUSPLUS
1187 static
1188 symbol_type
1189 make_COMMA (location_type l)
1190 {
1191 return symbol_type (token::TOKEN_COMMA, std::move (l));
1192 }
1193#else
1194 static
1195 symbol_type
1197 {
1198 return symbol_type (token::TOKEN_COMMA, l);
1199 }
1200#endif
1201#if 201103L <= YY_CPLUSPLUS
1202 static
1203 symbol_type
1204 make_COLON (location_type l)
1205 {
1206 return symbol_type (token::TOKEN_COLON, std::move (l));
1207 }
1208#else
1209 static
1210 symbol_type
1212 {
1213 return symbol_type (token::TOKEN_COLON, l);
1214 }
1215#endif
1216#if 201103L <= YY_CPLUSPLUS
1217 static
1218 symbol_type
1219 make_LSQUARE_BRACKET (location_type l)
1220 {
1221 return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
1222 }
1223#else
1224 static
1225 symbol_type
1227 {
1228 return symbol_type (token::TOKEN_LSQUARE_BRACKET, l);
1229 }
1230#endif
1231#if 201103L <= YY_CPLUSPLUS
1232 static
1233 symbol_type
1234 make_RSQUARE_BRACKET (location_type l)
1235 {
1236 return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
1237 }
1238#else
1239 static
1240 symbol_type
1242 {
1243 return symbol_type (token::TOKEN_RSQUARE_BRACKET, l);
1244 }
1245#endif
1246#if 201103L <= YY_CPLUSPLUS
1247 static
1248 symbol_type
1249 make_LCURLY_BRACKET (location_type l)
1250 {
1251 return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
1252 }
1253#else
1254 static
1255 symbol_type
1257 {
1258 return symbol_type (token::TOKEN_LCURLY_BRACKET, l);
1259 }
1260#endif
1261#if 201103L <= YY_CPLUSPLUS
1262 static
1263 symbol_type
1264 make_RCURLY_BRACKET (location_type l)
1265 {
1266 return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
1267 }
1268#else
1269 static
1270 symbol_type
1272 {
1273 return symbol_type (token::TOKEN_RCURLY_BRACKET, l);
1274 }
1275#endif
1276#if 201103L <= YY_CPLUSPLUS
1277 static
1278 symbol_type
1279 make_NULL_TYPE (location_type l)
1280 {
1281 return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
1282 }
1283#else
1284 static
1285 symbol_type
1287 {
1288 return symbol_type (token::TOKEN_NULL_TYPE, l);
1289 }
1290#endif
1291#if 201103L <= YY_CPLUSPLUS
1292 static
1293 symbol_type
1294 make_CONTROL_AGENT (location_type l)
1295 {
1296 return symbol_type (token::TOKEN_CONTROL_AGENT, std::move (l));
1297 }
1298#else
1299 static
1300 symbol_type
1302 {
1303 return symbol_type (token::TOKEN_CONTROL_AGENT, l);
1304 }
1305#endif
1306#if 201103L <= YY_CPLUSPLUS
1307 static
1308 symbol_type
1309 make_HTTP_HOST (location_type l)
1310 {
1311 return symbol_type (token::TOKEN_HTTP_HOST, std::move (l));
1312 }
1313#else
1314 static
1315 symbol_type
1317 {
1318 return symbol_type (token::TOKEN_HTTP_HOST, l);
1319 }
1320#endif
1321#if 201103L <= YY_CPLUSPLUS
1322 static
1323 symbol_type
1324 make_HTTP_PORT (location_type l)
1325 {
1326 return symbol_type (token::TOKEN_HTTP_PORT, std::move (l));
1327 }
1328#else
1329 static
1330 symbol_type
1332 {
1333 return symbol_type (token::TOKEN_HTTP_PORT, l);
1334 }
1335#endif
1336#if 201103L <= YY_CPLUSPLUS
1337 static
1338 symbol_type
1339 make_USER_CONTEXT (location_type l)
1340 {
1341 return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
1342 }
1343#else
1344 static
1345 symbol_type
1347 {
1348 return symbol_type (token::TOKEN_USER_CONTEXT, l);
1349 }
1350#endif
1351#if 201103L <= YY_CPLUSPLUS
1352 static
1353 symbol_type
1354 make_COMMENT (location_type l)
1355 {
1356 return symbol_type (token::TOKEN_COMMENT, std::move (l));
1357 }
1358#else
1359 static
1360 symbol_type
1362 {
1363 return symbol_type (token::TOKEN_COMMENT, l);
1364 }
1365#endif
1366#if 201103L <= YY_CPLUSPLUS
1367 static
1368 symbol_type
1369 make_AUTHENTICATION (location_type l)
1370 {
1371 return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
1372 }
1373#else
1374 static
1375 symbol_type
1377 {
1378 return symbol_type (token::TOKEN_AUTHENTICATION, l);
1379 }
1380#endif
1381#if 201103L <= YY_CPLUSPLUS
1382 static
1383 symbol_type
1384 make_TYPE (location_type l)
1385 {
1386 return symbol_type (token::TOKEN_TYPE, std::move (l));
1387 }
1388#else
1389 static
1390 symbol_type
1392 {
1393 return symbol_type (token::TOKEN_TYPE, l);
1394 }
1395#endif
1396#if 201103L <= YY_CPLUSPLUS
1397 static
1398 symbol_type
1399 make_BASIC (location_type l)
1400 {
1401 return symbol_type (token::TOKEN_BASIC, std::move (l));
1402 }
1403#else
1404 static
1405 symbol_type
1407 {
1408 return symbol_type (token::TOKEN_BASIC, l);
1409 }
1410#endif
1411#if 201103L <= YY_CPLUSPLUS
1412 static
1413 symbol_type
1414 make_REALM (location_type l)
1415 {
1416 return symbol_type (token::TOKEN_REALM, std::move (l));
1417 }
1418#else
1419 static
1420 symbol_type
1422 {
1423 return symbol_type (token::TOKEN_REALM, l);
1424 }
1425#endif
1426#if 201103L <= YY_CPLUSPLUS
1427 static
1428 symbol_type
1429 make_DIRECTORY (location_type l)
1430 {
1431 return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
1432 }
1433#else
1434 static
1435 symbol_type
1437 {
1438 return symbol_type (token::TOKEN_DIRECTORY, l);
1439 }
1440#endif
1441#if 201103L <= YY_CPLUSPLUS
1442 static
1443 symbol_type
1444 make_CLIENTS (location_type l)
1445 {
1446 return symbol_type (token::TOKEN_CLIENTS, std::move (l));
1447 }
1448#else
1449 static
1450 symbol_type
1452 {
1453 return symbol_type (token::TOKEN_CLIENTS, l);
1454 }
1455#endif
1456#if 201103L <= YY_CPLUSPLUS
1457 static
1458 symbol_type
1459 make_USER (location_type l)
1460 {
1461 return symbol_type (token::TOKEN_USER, std::move (l));
1462 }
1463#else
1464 static
1465 symbol_type
1467 {
1468 return symbol_type (token::TOKEN_USER, l);
1469 }
1470#endif
1471#if 201103L <= YY_CPLUSPLUS
1472 static
1473 symbol_type
1474 make_USER_FILE (location_type l)
1475 {
1476 return symbol_type (token::TOKEN_USER_FILE, std::move (l));
1477 }
1478#else
1479 static
1480 symbol_type
1482 {
1483 return symbol_type (token::TOKEN_USER_FILE, l);
1484 }
1485#endif
1486#if 201103L <= YY_CPLUSPLUS
1487 static
1488 symbol_type
1489 make_PASSWORD (location_type l)
1490 {
1491 return symbol_type (token::TOKEN_PASSWORD, std::move (l));
1492 }
1493#else
1494 static
1495 symbol_type
1497 {
1498 return symbol_type (token::TOKEN_PASSWORD, l);
1499 }
1500#endif
1501#if 201103L <= YY_CPLUSPLUS
1502 static
1503 symbol_type
1504 make_PASSWORD_FILE (location_type l)
1505 {
1506 return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
1507 }
1508#else
1509 static
1510 symbol_type
1512 {
1513 return symbol_type (token::TOKEN_PASSWORD_FILE, l);
1514 }
1515#endif
1516#if 201103L <= YY_CPLUSPLUS
1517 static
1518 symbol_type
1519 make_TRUST_ANCHOR (location_type l)
1520 {
1521 return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
1522 }
1523#else
1524 static
1525 symbol_type
1527 {
1528 return symbol_type (token::TOKEN_TRUST_ANCHOR, l);
1529 }
1530#endif
1531#if 201103L <= YY_CPLUSPLUS
1532 static
1533 symbol_type
1534 make_CERT_FILE (location_type l)
1535 {
1536 return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
1537 }
1538#else
1539 static
1540 symbol_type
1542 {
1543 return symbol_type (token::TOKEN_CERT_FILE, l);
1544 }
1545#endif
1546#if 201103L <= YY_CPLUSPLUS
1547 static
1548 symbol_type
1549 make_KEY_FILE (location_type l)
1550 {
1551 return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
1552 }
1553#else
1554 static
1555 symbol_type
1557 {
1558 return symbol_type (token::TOKEN_KEY_FILE, l);
1559 }
1560#endif
1561#if 201103L <= YY_CPLUSPLUS
1562 static
1563 symbol_type
1564 make_CERT_REQUIRED (location_type l)
1565 {
1566 return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
1567 }
1568#else
1569 static
1570 symbol_type
1572 {
1573 return symbol_type (token::TOKEN_CERT_REQUIRED, l);
1574 }
1575#endif
1576#if 201103L <= YY_CPLUSPLUS
1577 static
1578 symbol_type
1579 make_CONTROL_SOCKETS (location_type l)
1580 {
1581 return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
1582 }
1583#else
1584 static
1585 symbol_type
1587 {
1588 return symbol_type (token::TOKEN_CONTROL_SOCKETS, l);
1589 }
1590#endif
1591#if 201103L <= YY_CPLUSPLUS
1592 static
1593 symbol_type
1594 make_DHCP4_SERVER (location_type l)
1595 {
1596 return symbol_type (token::TOKEN_DHCP4_SERVER, std::move (l));
1597 }
1598#else
1599 static
1600 symbol_type
1602 {
1603 return symbol_type (token::TOKEN_DHCP4_SERVER, l);
1604 }
1605#endif
1606#if 201103L <= YY_CPLUSPLUS
1607 static
1608 symbol_type
1609 make_DHCP6_SERVER (location_type l)
1610 {
1611 return symbol_type (token::TOKEN_DHCP6_SERVER, std::move (l));
1612 }
1613#else
1614 static
1615 symbol_type
1617 {
1618 return symbol_type (token::TOKEN_DHCP6_SERVER, l);
1619 }
1620#endif
1621#if 201103L <= YY_CPLUSPLUS
1622 static
1623 symbol_type
1624 make_D2_SERVER (location_type l)
1625 {
1626 return symbol_type (token::TOKEN_D2_SERVER, std::move (l));
1627 }
1628#else
1629 static
1630 symbol_type
1632 {
1633 return symbol_type (token::TOKEN_D2_SERVER, l);
1634 }
1635#endif
1636#if 201103L <= YY_CPLUSPLUS
1637 static
1638 symbol_type
1639 make_SOCKET_NAME (location_type l)
1640 {
1641 return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
1642 }
1643#else
1644 static
1645 symbol_type
1647 {
1648 return symbol_type (token::TOKEN_SOCKET_NAME, l);
1649 }
1650#endif
1651#if 201103L <= YY_CPLUSPLUS
1652 static
1653 symbol_type
1654 make_SOCKET_TYPE (location_type l)
1655 {
1656 return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
1657 }
1658#else
1659 static
1660 symbol_type
1662 {
1663 return symbol_type (token::TOKEN_SOCKET_TYPE, l);
1664 }
1665#endif
1666#if 201103L <= YY_CPLUSPLUS
1667 static
1668 symbol_type
1669 make_UNIX (location_type l)
1670 {
1671 return symbol_type (token::TOKEN_UNIX, std::move (l));
1672 }
1673#else
1674 static
1675 symbol_type
1677 {
1678 return symbol_type (token::TOKEN_UNIX, l);
1679 }
1680#endif
1681#if 201103L <= YY_CPLUSPLUS
1682 static
1683 symbol_type
1684 make_HOOKS_LIBRARIES (location_type l)
1685 {
1686 return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
1687 }
1688#else
1689 static
1690 symbol_type
1692 {
1693 return symbol_type (token::TOKEN_HOOKS_LIBRARIES, l);
1694 }
1695#endif
1696#if 201103L <= YY_CPLUSPLUS
1697 static
1698 symbol_type
1699 make_LIBRARY (location_type l)
1700 {
1701 return symbol_type (token::TOKEN_LIBRARY, std::move (l));
1702 }
1703#else
1704 static
1705 symbol_type
1707 {
1708 return symbol_type (token::TOKEN_LIBRARY, l);
1709 }
1710#endif
1711#if 201103L <= YY_CPLUSPLUS
1712 static
1713 symbol_type
1714 make_PARAMETERS (location_type l)
1715 {
1716 return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
1717 }
1718#else
1719 static
1720 symbol_type
1722 {
1723 return symbol_type (token::TOKEN_PARAMETERS, l);
1724 }
1725#endif
1726#if 201103L <= YY_CPLUSPLUS
1727 static
1728 symbol_type
1729 make_LOGGERS (location_type l)
1730 {
1731 return symbol_type (token::TOKEN_LOGGERS, std::move (l));
1732 }
1733#else
1734 static
1735 symbol_type
1737 {
1738 return symbol_type (token::TOKEN_LOGGERS, l);
1739 }
1740#endif
1741#if 201103L <= YY_CPLUSPLUS
1742 static
1743 symbol_type
1744 make_NAME (location_type l)
1745 {
1746 return symbol_type (token::TOKEN_NAME, std::move (l));
1747 }
1748#else
1749 static
1750 symbol_type
1752 {
1753 return symbol_type (token::TOKEN_NAME, l);
1754 }
1755#endif
1756#if 201103L <= YY_CPLUSPLUS
1757 static
1758 symbol_type
1759 make_OUTPUT_OPTIONS (location_type l)
1760 {
1761 return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
1762 }
1763#else
1764 static
1765 symbol_type
1767 {
1768 return symbol_type (token::TOKEN_OUTPUT_OPTIONS, l);
1769 }
1770#endif
1771#if 201103L <= YY_CPLUSPLUS
1772 static
1773 symbol_type
1774 make_OUTPUT (location_type l)
1775 {
1776 return symbol_type (token::TOKEN_OUTPUT, std::move (l));
1777 }
1778#else
1779 static
1780 symbol_type
1782 {
1783 return symbol_type (token::TOKEN_OUTPUT, l);
1784 }
1785#endif
1786#if 201103L <= YY_CPLUSPLUS
1787 static
1788 symbol_type
1789 make_DEBUGLEVEL (location_type l)
1790 {
1791 return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
1792 }
1793#else
1794 static
1795 symbol_type
1797 {
1798 return symbol_type (token::TOKEN_DEBUGLEVEL, l);
1799 }
1800#endif
1801#if 201103L <= YY_CPLUSPLUS
1802 static
1803 symbol_type
1804 make_SEVERITY (location_type l)
1805 {
1806 return symbol_type (token::TOKEN_SEVERITY, std::move (l));
1807 }
1808#else
1809 static
1810 symbol_type
1812 {
1813 return symbol_type (token::TOKEN_SEVERITY, l);
1814 }
1815#endif
1816#if 201103L <= YY_CPLUSPLUS
1817 static
1818 symbol_type
1819 make_FLUSH (location_type l)
1820 {
1821 return symbol_type (token::TOKEN_FLUSH, std::move (l));
1822 }
1823#else
1824 static
1825 symbol_type
1827 {
1828 return symbol_type (token::TOKEN_FLUSH, l);
1829 }
1830#endif
1831#if 201103L <= YY_CPLUSPLUS
1832 static
1833 symbol_type
1834 make_MAXSIZE (location_type l)
1835 {
1836 return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
1837 }
1838#else
1839 static
1840 symbol_type
1842 {
1843 return symbol_type (token::TOKEN_MAXSIZE, l);
1844 }
1845#endif
1846#if 201103L <= YY_CPLUSPLUS
1847 static
1848 symbol_type
1849 make_MAXVER (location_type l)
1850 {
1851 return symbol_type (token::TOKEN_MAXVER, std::move (l));
1852 }
1853#else
1854 static
1855 symbol_type
1857 {
1858 return symbol_type (token::TOKEN_MAXVER, l);
1859 }
1860#endif
1861#if 201103L <= YY_CPLUSPLUS
1862 static
1863 symbol_type
1864 make_PATTERN (location_type l)
1865 {
1866 return symbol_type (token::TOKEN_PATTERN, std::move (l));
1867 }
1868#else
1869 static
1870 symbol_type
1872 {
1873 return symbol_type (token::TOKEN_PATTERN, l);
1874 }
1875#endif
1876#if 201103L <= YY_CPLUSPLUS
1877 static
1878 symbol_type
1879 make_START_JSON (location_type l)
1880 {
1881 return symbol_type (token::TOKEN_START_JSON, std::move (l));
1882 }
1883#else
1884 static
1885 symbol_type
1887 {
1888 return symbol_type (token::TOKEN_START_JSON, l);
1889 }
1890#endif
1891#if 201103L <= YY_CPLUSPLUS
1892 static
1893 symbol_type
1894 make_START_AGENT (location_type l)
1895 {
1896 return symbol_type (token::TOKEN_START_AGENT, std::move (l));
1897 }
1898#else
1899 static
1900 symbol_type
1902 {
1903 return symbol_type (token::TOKEN_START_AGENT, l);
1904 }
1905#endif
1906#if 201103L <= YY_CPLUSPLUS
1907 static
1908 symbol_type
1909 make_START_SUB_AGENT (location_type l)
1910 {
1911 return symbol_type (token::TOKEN_START_SUB_AGENT, std::move (l));
1912 }
1913#else
1914 static
1915 symbol_type
1917 {
1918 return symbol_type (token::TOKEN_START_SUB_AGENT, l);
1919 }
1920#endif
1921#if 201103L <= YY_CPLUSPLUS
1922 static
1923 symbol_type
1924 make_STRING (std::string v, location_type l)
1925 {
1926 return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
1927 }
1928#else
1929 static
1930 symbol_type
1931 make_STRING (const std::string& v, const location_type& l)
1932 {
1933 return symbol_type (token::TOKEN_STRING, v, l);
1934 }
1935#endif
1936#if 201103L <= YY_CPLUSPLUS
1937 static
1938 symbol_type
1939 make_INTEGER (int64_t v, location_type l)
1940 {
1941 return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
1942 }
1943#else
1944 static
1945 symbol_type
1946 make_INTEGER (const int64_t& v, const location_type& l)
1947 {
1948 return symbol_type (token::TOKEN_INTEGER, v, l);
1949 }
1950#endif
1951#if 201103L <= YY_CPLUSPLUS
1952 static
1953 symbol_type
1954 make_FLOAT (double v, location_type l)
1955 {
1956 return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
1957 }
1958#else
1959 static
1960 symbol_type
1961 make_FLOAT (const double& v, const location_type& l)
1962 {
1963 return symbol_type (token::TOKEN_FLOAT, v, l);
1964 }
1965#endif
1966#if 201103L <= YY_CPLUSPLUS
1967 static
1968 symbol_type
1969 make_BOOLEAN (bool v, location_type l)
1970 {
1971 return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
1972 }
1973#else
1974 static
1975 symbol_type
1976 make_BOOLEAN (const bool& v, const location_type& l)
1977 {
1978 return symbol_type (token::TOKEN_BOOLEAN, v, l);
1979 }
1980#endif
1981
1982
1984 {
1985 public:
1986 context (const AgentParser& yyparser, const symbol_type& yyla);
1987 const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; }
1988 symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }
1989 const location_type& location () const YY_NOEXCEPT { return yyla_.location; }
1990
1994 int expected_tokens (symbol_kind_type yyarg[], int yyargn) const;
1995
1996 private:
1997 const AgentParser& yyparser_;
1998 const symbol_type& yyla_;
1999 };
2000
2001 private:
2002#if YY_CPLUSPLUS < 201103L
2004 AgentParser (const AgentParser&);
2006 AgentParser& operator= (const AgentParser&);
2007#endif
2008
2009
2011 typedef short state_type;
2012
2014 int yy_syntax_error_arguments_ (const context& yyctx,
2015 symbol_kind_type yyarg[], int yyargn) const;
2016
2019 virtual std::string yysyntax_error_ (const context& yyctx) const;
2023 static state_type yy_lr_goto_state_ (state_type yystate, int yysym);
2024
2027 static bool yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT;
2028
2031 static bool yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT;
2032
2033 static const short yypact_ninf_;
2034 static const signed char yytable_ninf_;
2035
2039 static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT;
2040
2042 static std::string yytnamerr_ (const char *yystr);
2043
2045 static const char* const yytname_[];
2046
2047
2048 // Tables.
2049 // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2050 // STATE-NUM.
2051 static const short yypact_[];
2052
2053 // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
2054 // Performed when YYTABLE does not specify something else to do. Zero
2055 // means the default is an error.
2056 static const unsigned char yydefact_[];
2057
2058 // YYPGOTO[NTERM-NUM].
2059 static const short yypgoto_[];
2060
2061 // YYDEFGOTO[NTERM-NUM].
2062 static const short yydefgoto_[];
2063
2064 // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
2065 // positive, shift that token. If negative, reduce the rule whose
2066 // number is the opposite. If YYTABLE_NINF, syntax error.
2067 static const short yytable_[];
2068
2069 static const short yycheck_[];
2070
2071 // YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
2072 // state STATE-NUM.
2073 static const unsigned char yystos_[];
2074
2075 // YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.
2076 static const unsigned char yyr1_[];
2077
2078 // YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.
2079 static const signed char yyr2_[];
2080
2081
2082#if AGENT_DEBUG
2083 // YYRLINE[YYN] -- Source line where rule number YYN was defined.
2084 static const short yyrline_[];
2086 virtual void yy_reduce_print_ (int r) const;
2088 virtual void yy_stack_print_ () const;
2089
2091 int yydebug_;
2093 std::ostream* yycdebug_;
2094
2098 template <typename Base>
2099 void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
2100#endif
2101
2106 template <typename Base>
2107 void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
2108
2109 private:
2111 struct by_state
2112 {
2114 by_state () YY_NOEXCEPT;
2115
2117 typedef state_type kind_type;
2118
2120 by_state (kind_type s) YY_NOEXCEPT;
2121
2123 by_state (const by_state& that) YY_NOEXCEPT;
2124
2126 void clear () YY_NOEXCEPT;
2127
2129 void move (by_state& that);
2130
2133 symbol_kind_type kind () const YY_NOEXCEPT;
2134
2137 enum { empty_state = 0 };
2138
2141 state_type state;
2142 };
2143
2145 struct stack_symbol_type : basic_symbol<by_state>
2146 {
2148 typedef basic_symbol<by_state> super_type;
2150 stack_symbol_type ();
2152 stack_symbol_type (YY_RVREF (stack_symbol_type) that);
2154 stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
2155#if YY_CPLUSPLUS < 201103L
2158 stack_symbol_type& operator= (stack_symbol_type& that);
2159
2162 stack_symbol_type& operator= (const stack_symbol_type& that);
2163#endif
2164 };
2165
2167 template <typename T, typename S = std::vector<T> >
2168 class stack
2169 {
2170 public:
2171 // Hide our reversed order.
2172 typedef typename S::iterator iterator;
2173 typedef typename S::const_iterator const_iterator;
2174 typedef typename S::size_type size_type;
2175 typedef typename std::ptrdiff_t index_type;
2176
2177 stack (size_type n = 200) YY_NOEXCEPT
2178 : seq_ (n)
2179 {}
2180
2181#if 201103L <= YY_CPLUSPLUS
2183 stack (const stack&) = delete;
2185 stack& operator= (const stack&) = delete;
2186#endif
2187
2191 const T&
2192 operator[] (index_type i) const
2193 {
2194 return seq_[size_type (size () - 1 - i)];
2195 }
2196
2200 T&
2201 operator[] (index_type i)
2202 {
2203 return seq_[size_type (size () - 1 - i)];
2204 }
2205
2209 void
2210 push (YY_MOVE_REF (T) t)
2211 {
2212 seq_.push_back (T ());
2213 operator[] (0).move (t);
2214 }
2215
2217 void
2218 pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2219 {
2220 for (; 0 < n; --n)
2221 seq_.pop_back ();
2222 }
2223
2225 void
2226 clear () YY_NOEXCEPT
2227 {
2228 seq_.clear ();
2229 }
2230
2232 index_type
2233 size () const YY_NOEXCEPT
2234 {
2235 return index_type (seq_.size ());
2236 }
2237
2239 const_iterator
2240 begin () const YY_NOEXCEPT
2241 {
2242 return seq_.begin ();
2243 }
2244
2246 const_iterator
2247 end () const YY_NOEXCEPT
2248 {
2249 return seq_.end ();
2250 }
2251
2253 class slice
2254 {
2255 public:
2256 slice (const stack& stack, index_type range) YY_NOEXCEPT
2257 : stack_ (stack)
2258 , range_ (range)
2259 {}
2260
2261 const T&
2262 operator[] (index_type i) const
2263 {
2264 return stack_[range_ - i];
2265 }
2266
2267 private:
2268 const stack& stack_;
2269 index_type range_;
2270 };
2271
2272 private:
2273#if YY_CPLUSPLUS < 201103L
2275 stack (const stack&);
2277 stack& operator= (const stack&);
2278#endif
2280 S seq_;
2281 };
2282
2283
2285 typedef stack<stack_symbol_type> stack_type;
2286
2288 stack_type yystack_;
2289
2295 void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2296
2303 void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
2304
2306 void yypop_ (int n = 1) YY_NOEXCEPT;
2307
2309 enum
2310 {
2311 yylast_ = 252,
2312 yynnts_ = 122,
2313 yyfinal_ = 8
2314 };
2315
2316
2317 // User arguments.
2319
2320 };
2321
2322 inline
2324 AgentParser::yytranslate_ (int t) YY_NOEXCEPT
2325 {
2326 // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to
2327 // TOKEN-NUM as returned by yylex.
2328 static
2329 const signed char
2330 translate_table[] =
2331 {
2332 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2333 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2334 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2335 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2336 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2337 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2338 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2339 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2340 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2341 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2342 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2343 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2344 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2345 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2346 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2347 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2348 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2349 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2350 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2351 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2352 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2353 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2354 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2355 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2356 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2357 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2358 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2359 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2360 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2361 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2362 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
2363 55
2364 };
2365 // Last valid token kind.
2366 const int code_max = 310;
2367
2368 if (t <= 0)
2369 return symbol_kind::S_YYEOF;
2370 else if (t <= code_max)
2371 return static_cast <symbol_kind_type> (translate_table[t]);
2372 else
2374 }
2375
2376 // basic_symbol.
2377 template <typename Base>
2379 : Base (that)
2380 , value ()
2381 , location (that.location)
2382 {
2383 switch (this->kind ())
2384 {
2385 case symbol_kind::S_value: // value
2386 case symbol_kind::S_map_value: // map_value
2387 case symbol_kind::S_socket_type_value: // socket_type_value
2388 case symbol_kind::S_auth_type_value: // auth_type_value
2389 value.copy< ElementPtr > (YY_MOVE (that.value));
2390 break;
2391
2392 case symbol_kind::S_BOOLEAN: // "boolean"
2393 value.copy< bool > (YY_MOVE (that.value));
2394 break;
2395
2396 case symbol_kind::S_FLOAT: // "floating point"
2397 value.copy< double > (YY_MOVE (that.value));
2398 break;
2399
2400 case symbol_kind::S_INTEGER: // "integer"
2401 value.copy< int64_t > (YY_MOVE (that.value));
2402 break;
2403
2404 case symbol_kind::S_STRING: // "constant string"
2405 value.copy< std::string > (YY_MOVE (that.value));
2406 break;
2407
2408 default:
2409 break;
2410 }
2411
2412 }
2413
2414
2415
2416
2417 template <typename Base>
2420 {
2421 return this->kind ();
2422 }
2423
2424
2425 template <typename Base>
2426 bool
2428 {
2429 return this->kind () == symbol_kind::S_YYEMPTY;
2430 }
2431
2432 template <typename Base>
2433 void
2435 {
2436 super_type::move (s);
2437 switch (this->kind ())
2438 {
2439 case symbol_kind::S_value: // value
2440 case symbol_kind::S_map_value: // map_value
2441 case symbol_kind::S_socket_type_value: // socket_type_value
2442 case symbol_kind::S_auth_type_value: // auth_type_value
2443 value.move< ElementPtr > (YY_MOVE (s.value));
2444 break;
2445
2446 case symbol_kind::S_BOOLEAN: // "boolean"
2447 value.move< bool > (YY_MOVE (s.value));
2448 break;
2449
2450 case symbol_kind::S_FLOAT: // "floating point"
2451 value.move< double > (YY_MOVE (s.value));
2452 break;
2453
2454 case symbol_kind::S_INTEGER: // "integer"
2455 value.move< int64_t > (YY_MOVE (s.value));
2456 break;
2457
2458 case symbol_kind::S_STRING: // "constant string"
2459 value.move< std::string > (YY_MOVE (s.value));
2460 break;
2461
2462 default:
2463 break;
2464 }
2465
2466 location = YY_MOVE (s.location);
2467 }
2468
2469 // by_kind.
2470 inline
2472 : kind_ (symbol_kind::S_YYEMPTY)
2473 {}
2474
2475#if 201103L <= YY_CPLUSPLUS
2476 inline
2478 : kind_ (that.kind_)
2479 {
2480 that.clear ();
2481 }
2482#endif
2483
2484 inline
2486 : kind_ (that.kind_)
2487 {}
2488
2489 inline
2491 : kind_ (yytranslate_ (t))
2492 {}
2493
2494
2495
2496 inline
2497 void
2499 {
2500 kind_ = symbol_kind::S_YYEMPTY;
2501 }
2502
2503 inline
2504 void
2506 {
2507 kind_ = that.kind_;
2508 that.clear ();
2509 }
2510
2511 inline
2514 {
2515 return kind_;
2516 }
2517
2518
2519 inline
2522 {
2523 return this->kind ();
2524 }
2525
2526
2527#line 14 "agent_parser.yy"
2528} } // isc::agent
2529#line 2530 "agent_parser.h"
2530
2531
2532
2533
2534#endif // !YY_AGENT_AGENT_PARSER_H_INCLUDED
Forward declaration of the ParserContext class.
#define YY_RVREF(Type)
Definition: agent_parser.h:85
#define AGENT__ASSERT
Definition: agent_parser.h:108
#define YY_MOVE_REF(Type)
Definition: agent_parser.h:84
#define YY_NOEXCEPT
Definition: agent_parser.h:94
#define YY_ATTRIBUTE_PURE
Definition: agent_parser.h:116
#define YY_MOVE
Definition: agent_parser.h:82
#define YY_NOTHROW
Definition: agent_parser.h:95
const symbol_type & lookahead() const YY_NOEXCEPT
symbol_kind_type token() const YY_NOEXCEPT
const location_type & location() const YY_NOEXCEPT
Present a slice of the top of a stack.
slice(const stack &stack, index_type range) YY_NOEXCEPT
A buffer to store and retrieve objects.
Definition: agent_parser.h:229
T & emplace()
Instantiate an empty T in here.
Definition: agent_parser.h:277
void destroy()
Destroy the stored T.
Definition: agent_parser.h:392
void copy(const self_type &that)
Copy the content of that to this.
Definition: agent_parser.h:384
value_type(YY_RVREF(T) t)
Construct and fill.
Definition: agent_parser.h:242
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
Definition: agent_parser.h:329
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
Definition: agent_parser.h:347
char yyraw_[size]
A buffer large enough to store any of the semantic values.
Definition: agent_parser.h:455
T & as() YY_NOEXCEPT
Accessor to a built T.
Definition: agent_parser.h:318
value_type self_type
Type of *this.
Definition: agent_parser.h:232
value_type() YY_NOEXCEPT
Empty construction.
Definition: agent_parser.h:235
void move(self_type &that)
Move the content of that to this.
Definition: agent_parser.h:359
long double yyalign_me_
Strongest alignment constraints.
Definition: agent_parser.h:453
T & emplace(const T &t)
Instantiate a T in here from t.
Definition: agent_parser.h:288
T & build(const T &t)
Instantiate a T in here from t.
Definition: agent_parser.h:310
~value_type() YY_NOEXCEPT
Destruction, allowed only if empty.
Definition: agent_parser.h:257
T & build()
Instantiate an empty T in here.
Definition: agent_parser.h:301
static symbol_type make_D2_SERVER(const location_type &l)
static symbol_type make_PASSWORD_FILE(const location_type &l)
static symbol_type make_SOCKET_TYPE(const location_type &l)
static symbol_type make_HTTP_HOST(const location_type &l)
static symbol_type make_END(const location_type &l)
static symbol_type make_COMMENT(const location_type &l)
static symbol_type make_NULL_TYPE(const location_type &l)
static symbol_type make_AUTHENTICATION(const location_type &l)
value_type semantic_type
Backward compatibility (Bison 3.8).
Definition: agent_parser.h:464
static symbol_type make_CERT_FILE(const location_type &l)
static symbol_type make_OUTPUT_OPTIONS(const location_type &l)
static symbol_type make_LSQUARE_BRACKET(const location_type &l)
static symbol_type make_RSQUARE_BRACKET(const location_type &l)
static symbol_type make_COLON(const location_type &l)
static symbol_type make_BASIC(const location_type &l)
static symbol_type make_PATTERN(const location_type &l)
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_FLOAT(const double &v, const location_type &l)
static symbol_type make_STRING(const std::string &v, const location_type &l)
static symbol_type make_LOGGERS(const location_type &l)
static symbol_type make_SOCKET_NAME(const location_type &l)
location location_type
Symbol locations.
Definition: agent_parser.h:467
static symbol_type make_CONTROL_AGENT(const location_type &l)
static symbol_type make_AGENT_error(const location_type &l)
static symbol_type make_RCURLY_BRACKET(const location_type &l)
static symbol_type make_DEBUGLEVEL(const location_type &l)
static symbol_type make_START_AGENT(const location_type &l)
static symbol_type make_LCURLY_BRACKET(const location_type &l)
static symbol_type make_FLUSH(const location_type &l)
static symbol_type make_CERT_REQUIRED(const location_type &l)
static symbol_type make_MAXVER(const location_type &l)
static symbol_type make_PASSWORD(const location_type &l)
static symbol_type make_START_JSON(const location_type &l)
static symbol_type make_CONTROL_SOCKETS(const location_type &l)
static symbol_type make_NAME(const location_type &l)
static symbol_type make_COMMA(const location_type &l)
static symbol_type make_HOOKS_LIBRARIES(const location_type &l)
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
Definition: agent_parser.h:555
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
Definition: agent_parser.h:749
static const symbol_kind_type YYNTOKENS
The number of tokens.
Definition: agent_parser.h:752
static symbol_type make_OUTPUT(const location_type &l)
static symbol_type make_CLIENTS(const location_type &l)
static symbol_type make_DHCP4_SERVER(const location_type &l)
static symbol_type make_DHCP6_SERVER(const location_type &l)
static symbol_type make_REALM(const location_type &l)
static symbol_type make_TRUST_ANCHOR(const location_type &l)
static symbol_type make_HTTP_PORT(const location_type &l)
static symbol_type make_PARAMETERS(const location_type &l)
static symbol_type make_SEVERITY(const location_type &l)
static symbol_type make_USER(const location_type &l)
static symbol_type make_USER_FILE(const location_type &l)
static symbol_type make_BOOLEAN(const bool &v, const location_type &l)
static symbol_type make_LIBRARY(const location_type &l)
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
Definition: agent_parser.h:558
static symbol_type make_KEY_FILE(const location_type &l)
static symbol_type make_AGENT_UNDEF(const location_type &l)
static symbol_type make_START_SUB_AGENT(const location_type &l)
static symbol_type make_DIRECTORY(const location_type &l)
static symbol_type make_UNIX(const location_type &l)
static symbol_type make_MAXSIZE(const location_type &l)
static symbol_type make_USER_CONTEXT(const location_type &l)
static symbol_type make_TYPE(const location_type &l)
static symbol_type make_INTEGER(const int64_t &v, const location_type &l)
Parser context is a wrapper around flex/bison instances dedicated to Control-agent config file parser...
boost::shared_ptr< Element > ElementPtr
Definition: data.h:28
Defines the logger used by the top-level component of kea-lfc.
basic_symbol(const basic_symbol &that)
Copy constructor.
basic_symbol(typename Base::kind_type t, const int64_t &v, const location_type &l)
Definition: agent_parser.h:876
location_type location
The location.
Definition: agent_parser.h:970
basic_symbol() YY_NOEXCEPT
Default constructor.
Definition: agent_parser.h:767
void move(basic_symbol &s)
Destructive move, s is emptied into this.
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
Definition: agent_parser.h:821
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
Definition: agent_parser.h:890
void clear() YY_NOEXCEPT
Destroy contents, and record that is empty.
Definition: agent_parser.h:906
bool empty() const YY_NOEXCEPT
Whether empty.
value_type value
The semantic value.
Definition: agent_parser.h:967
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
basic_symbol(typename Base::kind_type t, const ElementPtr &v, const location_type &l)
Definition: agent_parser.h:834
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
Definition: agent_parser.h:862
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
Definition: agent_parser.h:952
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
Definition: agent_parser.h:848
Type access provider for token (enum) based symbols.
Definition: agent_parser.h:981
by_kind() YY_NOEXCEPT
Default constructor.
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
token_kind_type kind_type
The symbol kind as needed by the constructor.
Definition: agent_parser.h:983
symbol_kind_type kind_
The symbol kind.
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
void clear() YY_NOEXCEPT
Record that this symbol is empty.
void move(by_kind &that)
Steal the symbol kind from that.
"External" symbols: returned by the scanner.
symbol_type() YY_NOEXCEPT
Empty symbol.
basic_symbol< by_kind > super_type
Superclass.
Syntax errors thrown from user actions.
Definition: agent_parser.h:471
~syntax_error() YY_NOEXCEPT YY_NOTHROW
syntax_error(const syntax_error &s)
Definition: agent_parser.h:477
syntax_error(const location_type &l, const std::string &m)
Definition: agent_parser.h:472
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).
Definition: agent_parser.h:551