Kea 2.0.0
agent_parser.h
Go to the documentation of this file.
1// A Bison parser, made by GNU Bison 3.7.6.
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#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
136/* Suppress an incorrect diagnostic about yylval being uninitialized. */
137# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
138 _Pragma ("GCC diagnostic push") \
139 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
140 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
141# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
142 _Pragma ("GCC diagnostic pop")
143#else
144# define YY_INITIAL_VALUE(Value) Value
145#endif
146#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
147# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
148# define YY_IGNORE_MAYBE_UNINITIALIZED_END
149#endif
150#ifndef YY_INITIAL_VALUE
151# define YY_INITIAL_VALUE(Value) /* Nothing. */
152#endif
153
154#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
155# define YY_IGNORE_USELESS_CAST_BEGIN \
156 _Pragma ("GCC diagnostic push") \
157 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
158# define YY_IGNORE_USELESS_CAST_END \
159 _Pragma ("GCC diagnostic pop")
160#endif
161#ifndef YY_IGNORE_USELESS_CAST_BEGIN
162# define YY_IGNORE_USELESS_CAST_BEGIN
163# define YY_IGNORE_USELESS_CAST_END
164#endif
165
166# ifndef YY_CAST
167# ifdef __cplusplus
168# define YY_CAST(Type, Val) static_cast<Type> (Val)
169# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
170# else
171# define YY_CAST(Type, Val) ((Type) (Val))
172# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
173# endif
174# endif
175# ifndef YY_NULLPTR
176# if defined __cplusplus
177# if 201103L <= __cplusplus
178# define YY_NULLPTR nullptr
179# else
180# define YY_NULLPTR 0
181# endif
182# else
183# define YY_NULLPTR ((void*)0)
184# endif
185# endif
186
187/* Debug traces. */
188#ifndef AGENT_DEBUG
189# if defined YYDEBUG
190#if YYDEBUG
191# define AGENT_DEBUG 1
192# else
193# define AGENT_DEBUG 0
194# endif
195# else /* ! defined YYDEBUG */
196# define AGENT_DEBUG 1
197# endif /* ! defined YYDEBUG */
198#endif /* ! defined AGENT_DEBUG */
199
200#line 14 "agent_parser.yy"
201namespace isc { namespace agent {
202#line 203 "agent_parser.h"
203
204
205
206
209 {
210 public:
211#ifndef AGENT_STYPE
218 {
219 public:
222
225 : yybuffer_ ()
226 , yytypeid_ (YY_NULLPTR)
227 {}
228
230 template <typename T>
232 : yytypeid_ (&typeid (T))
233 {
234 AGENT__ASSERT (sizeof (T) <= size);
235 new (yyas_<T> ()) T (YY_MOVE (t));
236 }
237
238#if 201103L <= YY_CPLUSPLUS
240 semantic_type (const self_type&) = delete;
242 self_type& operator= (const self_type&) = delete;
243#endif
244
247 {
248 AGENT__ASSERT (!yytypeid_);
249 }
250
251# if 201103L <= YY_CPLUSPLUS
253 template <typename T, typename... U>
254 T&
255 emplace (U&&... u)
256 {
257 AGENT__ASSERT (!yytypeid_);
258 AGENT__ASSERT (sizeof (T) <= size);
259 yytypeid_ = & typeid (T);
260 return *new (yyas_<T> ()) T (std::forward <U>(u)...);
261 }
262# else
264 template <typename T>
265 T&
267 {
268 AGENT__ASSERT (!yytypeid_);
269 AGENT__ASSERT (sizeof (T) <= size);
270 yytypeid_ = & typeid (T);
271 return *new (yyas_<T> ()) T ();
272 }
273
275 template <typename T>
276 T&
277 emplace (const T& t)
278 {
279 AGENT__ASSERT (!yytypeid_);
280 AGENT__ASSERT (sizeof (T) <= size);
281 yytypeid_ = & typeid (T);
282 return *new (yyas_<T> ()) T (t);
283 }
284# endif
285
288 template <typename T>
289 T&
291 {
292 return emplace<T> ();
293 }
294
297 template <typename T>
298 T&
299 build (const T& t)
300 {
301 return emplace<T> (t);
302 }
303
305 template <typename T>
306 T&
308 {
309 AGENT__ASSERT (yytypeid_);
310 AGENT__ASSERT (*yytypeid_ == typeid (T));
311 AGENT__ASSERT (sizeof (T) <= size);
312 return *yyas_<T> ();
313 }
314
316 template <typename T>
317 const T&
319 {
320 AGENT__ASSERT (yytypeid_);
321 AGENT__ASSERT (*yytypeid_ == typeid (T));
322 AGENT__ASSERT (sizeof (T) <= size);
323 return *yyas_<T> ();
324 }
325
334 template <typename T>
335 void
337 {
338 AGENT__ASSERT (yytypeid_);
339 AGENT__ASSERT (*yytypeid_ == *that.yytypeid_);
340 std::swap (as<T> (), that.as<T> ());
341 }
342
346 template <typename T>
347 void
349 {
350# if 201103L <= YY_CPLUSPLUS
351 emplace<T> (std::move (that.as<T> ()));
352# else
353 emplace<T> ();
354 swap<T> (that);
355# endif
356 that.destroy<T> ();
357 }
358
359# if 201103L <= YY_CPLUSPLUS
361 template <typename T>
362 void
363 move (self_type&& that)
364 {
365 emplace<T> (std::move (that.as<T> ()));
366 that.destroy<T> ();
367 }
368#endif
369
371 template <typename T>
372 void
373 copy (const self_type& that)
374 {
375 emplace<T> (that.as<T> ());
376 }
377
379 template <typename T>
380 void
382 {
383 as<T> ().~T ();
384 yytypeid_ = YY_NULLPTR;
385 }
386
387 private:
388#if YY_CPLUSPLUS < 201103L
390 semantic_type (const self_type&);
392 self_type& operator= (const self_type&);
393#endif
394
396 template <typename T>
397 T*
398 yyas_ () YY_NOEXCEPT
399 {
400 void *yyp = yybuffer_.yyraw;
401 return static_cast<T*> (yyp);
402 }
403
405 template <typename T>
406 const T*
407 yyas_ () const YY_NOEXCEPT
408 {
409 const void *yyp = yybuffer_.yyraw;
410 return static_cast<const T*> (yyp);
411 }
412
414 union union_type
415 {
416 // value
417 // map_value
418 // socket_type_value
419 // auth_type_value
420 char dummy1[sizeof (ElementPtr)];
421
422 // "boolean"
423 char dummy2[sizeof (bool)];
424
425 // "floating point"
426 char dummy3[sizeof (double)];
427
428 // "integer"
429 char dummy4[sizeof (int64_t)];
430
431 // "constant string"
432 char dummy5[sizeof (std::string)];
433 };
434
436 enum { size = sizeof (union_type) };
437
439 union
440 {
442 long double yyalign_me;
444 char yyraw[size];
445 } yybuffer_;
446
448 const std::type_info *yytypeid_;
449 };
450
451#else
452 typedef AGENT_STYPE semantic_type;
453#endif
455 typedef location location_type;
456
458 struct syntax_error : std::runtime_error
459 {
460 syntax_error (const location_type& l, const std::string& m)
461 : std::runtime_error (m)
462 , location (l)
463 {}
464
466 : std::runtime_error (s.what ())
467 , location (s.location)
468 {}
469
471
473 };
474
476 struct token
477 {
479 {
480 TOKEN_AGENT_EMPTY = -2,
481 TOKEN_END = 0, // "end of file"
482 TOKEN_AGENT_error = 256, // error
483 TOKEN_AGENT_UNDEF = 257, // "invalid token"
484 TOKEN_COMMA = 258, // ","
485 TOKEN_COLON = 259, // ":"
486 TOKEN_LSQUARE_BRACKET = 260, // "["
487 TOKEN_RSQUARE_BRACKET = 261, // "]"
488 TOKEN_LCURLY_BRACKET = 262, // "{"
489 TOKEN_RCURLY_BRACKET = 263, // "}"
490 TOKEN_NULL_TYPE = 264, // "null"
491 TOKEN_CONTROL_AGENT = 265, // "Control-agent"
492 TOKEN_HTTP_HOST = 266, // "http-host"
493 TOKEN_HTTP_PORT = 267, // "http-port"
494 TOKEN_USER_CONTEXT = 268, // "user-context"
495 TOKEN_COMMENT = 269, // "comment"
496 TOKEN_AUTHENTICATION = 270, // "authentication"
497 TOKEN_TYPE = 271, // "type"
498 TOKEN_BASIC = 272, // "basic"
499 TOKEN_REALM = 273, // "realm"
500 TOKEN_CLIENTS = 274, // "clients"
501 TOKEN_USER = 275, // "user"
502 TOKEN_PASSWORD = 276, // "password"
503 TOKEN_TRUST_ANCHOR = 277, // "trust-anchor"
504 TOKEN_CERT_FILE = 278, // "cert-file"
505 TOKEN_KEY_FILE = 279, // "key-file"
506 TOKEN_CERT_REQUIRED = 280, // "cert-required"
507 TOKEN_CONTROL_SOCKETS = 281, // "control-sockets"
508 TOKEN_DHCP4_SERVER = 282, // "dhcp4"
509 TOKEN_DHCP6_SERVER = 283, // "dhcp6"
510 TOKEN_D2_SERVER = 284, // "d2"
511 TOKEN_SOCKET_NAME = 285, // "socket-name"
512 TOKEN_SOCKET_TYPE = 286, // "socket-type"
513 TOKEN_UNIX = 287, // "unix"
514 TOKEN_HOOKS_LIBRARIES = 288, // "hooks-libraries"
515 TOKEN_LIBRARY = 289, // "library"
516 TOKEN_PARAMETERS = 290, // "parameters"
517 TOKEN_LOGGERS = 291, // "loggers"
518 TOKEN_NAME = 292, // "name"
519 TOKEN_OUTPUT_OPTIONS = 293, // "output_options"
520 TOKEN_OUTPUT = 294, // "output"
521 TOKEN_DEBUGLEVEL = 295, // "debuglevel"
522 TOKEN_SEVERITY = 296, // "severity"
523 TOKEN_FLUSH = 297, // "flush"
524 TOKEN_MAXSIZE = 298, // "maxsize"
525 TOKEN_MAXVER = 299, // "maxver"
526 TOKEN_PATTERN = 300, // "pattern"
527 TOKEN_START_JSON = 301, // START_JSON
528 TOKEN_START_AGENT = 302, // START_AGENT
529 TOKEN_START_SUB_AGENT = 303, // START_SUB_AGENT
530 TOKEN_STRING = 304, // "constant string"
531 TOKEN_INTEGER = 305, // "integer"
532 TOKEN_FLOAT = 306, // "floating point"
533 TOKEN_BOOLEAN = 307 // "boolean"
534 };
537 };
538
541
544
547 {
549 {
551 S_YYEMPTY = -2,
552 S_YYEOF = 0, // "end of file"
553 S_YYerror = 1, // error
554 S_YYUNDEF = 2, // "invalid token"
555 S_COMMA = 3, // ","
556 S_COLON = 4, // ":"
557 S_LSQUARE_BRACKET = 5, // "["
558 S_RSQUARE_BRACKET = 6, // "]"
559 S_LCURLY_BRACKET = 7, // "{"
560 S_RCURLY_BRACKET = 8, // "}"
561 S_NULL_TYPE = 9, // "null"
562 S_CONTROL_AGENT = 10, // "Control-agent"
563 S_HTTP_HOST = 11, // "http-host"
564 S_HTTP_PORT = 12, // "http-port"
565 S_USER_CONTEXT = 13, // "user-context"
566 S_COMMENT = 14, // "comment"
567 S_AUTHENTICATION = 15, // "authentication"
568 S_TYPE = 16, // "type"
569 S_BASIC = 17, // "basic"
570 S_REALM = 18, // "realm"
571 S_CLIENTS = 19, // "clients"
572 S_USER = 20, // "user"
573 S_PASSWORD = 21, // "password"
574 S_TRUST_ANCHOR = 22, // "trust-anchor"
575 S_CERT_FILE = 23, // "cert-file"
576 S_KEY_FILE = 24, // "key-file"
577 S_CERT_REQUIRED = 25, // "cert-required"
578 S_CONTROL_SOCKETS = 26, // "control-sockets"
579 S_DHCP4_SERVER = 27, // "dhcp4"
580 S_DHCP6_SERVER = 28, // "dhcp6"
581 S_D2_SERVER = 29, // "d2"
582 S_SOCKET_NAME = 30, // "socket-name"
583 S_SOCKET_TYPE = 31, // "socket-type"
584 S_UNIX = 32, // "unix"
585 S_HOOKS_LIBRARIES = 33, // "hooks-libraries"
586 S_LIBRARY = 34, // "library"
587 S_PARAMETERS = 35, // "parameters"
588 S_LOGGERS = 36, // "loggers"
589 S_NAME = 37, // "name"
590 S_OUTPUT_OPTIONS = 38, // "output_options"
591 S_OUTPUT = 39, // "output"
592 S_DEBUGLEVEL = 40, // "debuglevel"
593 S_SEVERITY = 41, // "severity"
594 S_FLUSH = 42, // "flush"
595 S_MAXSIZE = 43, // "maxsize"
596 S_MAXVER = 44, // "maxver"
597 S_PATTERN = 45, // "pattern"
598 S_START_JSON = 46, // START_JSON
599 S_START_AGENT = 47, // START_AGENT
600 S_START_SUB_AGENT = 48, // START_SUB_AGENT
601 S_STRING = 49, // "constant string"
602 S_INTEGER = 50, // "integer"
603 S_FLOAT = 51, // "floating point"
604 S_BOOLEAN = 52, // "boolean"
605 S_YYACCEPT = 53, // $accept
606 S_start = 54, // start
607 S_55_1 = 55, // $@1
608 S_56_2 = 56, // $@2
609 S_57_3 = 57, // $@3
610 S_sub_agent = 58, // sub_agent
611 S_59_4 = 59, // $@4
612 S_json = 60, // json
613 S_value = 61, // value
614 S_map = 62, // map
615 S_63_5 = 63, // $@5
616 S_map_value = 64, // map_value
617 S_map_content = 65, // map_content
618 S_not_empty_map = 66, // not_empty_map
619 S_list_generic = 67, // list_generic
620 S_68_6 = 68, // $@6
621 S_list_content = 69, // list_content
622 S_not_empty_list = 70, // not_empty_list
623 S_unknown_map_entry = 71, // unknown_map_entry
624 S_agent_syntax_map = 72, // agent_syntax_map
625 S_73_7 = 73, // $@7
626 S_global_object = 74, // global_object
627 S_75_8 = 75, // $@8
628 S_global_params = 76, // global_params
629 S_global_param = 77, // global_param
630 S_http_host = 78, // http_host
631 S_79_9 = 79, // $@9
632 S_http_port = 80, // http_port
633 S_trust_anchor = 81, // trust_anchor
634 S_82_10 = 82, // $@10
635 S_cert_file = 83, // cert_file
636 S_84_11 = 84, // $@11
637 S_key_file = 85, // key_file
638 S_86_12 = 86, // $@12
639 S_cert_required = 87, // cert_required
640 S_user_context = 88, // user_context
641 S_89_13 = 89, // $@13
642 S_comment = 90, // comment
643 S_91_14 = 91, // $@14
644 S_hooks_libraries = 92, // hooks_libraries
645 S_93_15 = 93, // $@15
646 S_hooks_libraries_list = 94, // hooks_libraries_list
647 S_not_empty_hooks_libraries_list = 95, // not_empty_hooks_libraries_list
648 S_hooks_library = 96, // hooks_library
649 S_97_16 = 97, // $@16
650 S_hooks_params = 98, // hooks_params
651 S_hooks_param = 99, // hooks_param
652 S_library = 100, // library
653 S_101_17 = 101, // $@17
654 S_parameters = 102, // parameters
655 S_103_18 = 103, // $@18
656 S_control_sockets = 104, // control_sockets
657 S_105_19 = 105, // $@19
658 S_control_sockets_params = 106, // control_sockets_params
659 S_control_socket = 107, // control_socket
660 S_dhcp4_server_socket = 108, // dhcp4_server_socket
661 S_109_20 = 109, // $@20
662 S_dhcp6_server_socket = 110, // dhcp6_server_socket
663 S_111_21 = 111, // $@21
664 S_d2_server_socket = 112, // d2_server_socket
665 S_113_22 = 113, // $@22
666 S_control_socket_params = 114, // control_socket_params
667 S_control_socket_param = 115, // control_socket_param
668 S_socket_name = 116, // socket_name
669 S_117_23 = 117, // $@23
670 S_socket_type = 118, // socket_type
671 S_119_24 = 119, // $@24
672 S_socket_type_value = 120, // socket_type_value
673 S_authentication = 121, // authentication
674 S_122_25 = 122, // $@25
675 S_auth_params = 123, // auth_params
676 S_auth_param = 124, // auth_param
677 S_auth_type = 125, // auth_type
678 S_126_26 = 126, // $@26
679 S_auth_type_value = 127, // auth_type_value
680 S_realm = 128, // realm
681 S_129_27 = 129, // $@27
682 S_clients = 130, // clients
683 S_131_28 = 131, // $@28
684 S_clients_list = 132, // clients_list
685 S_not_empty_clients_list = 133, // not_empty_clients_list
686 S_basic_auth = 134, // basic_auth
687 S_135_29 = 135, // $@29
688 S_clients_params = 136, // clients_params
689 S_clients_param = 137, // clients_param
690 S_user = 138, // user
691 S_139_30 = 139, // $@30
692 S_password = 140, // password
693 S_141_31 = 141, // $@31
694 S_loggers = 142, // loggers
695 S_143_32 = 143, // $@32
696 S_loggers_entries = 144, // loggers_entries
697 S_logger_entry = 145, // logger_entry
698 S_146_33 = 146, // $@33
699 S_logger_params = 147, // logger_params
700 S_logger_param = 148, // logger_param
701 S_name = 149, // name
702 S_150_34 = 150, // $@34
703 S_debuglevel = 151, // debuglevel
704 S_severity = 152, // severity
705 S_153_35 = 153, // $@35
706 S_output_options_list = 154, // output_options_list
707 S_155_36 = 155, // $@36
708 S_output_options_list_content = 156, // output_options_list_content
709 S_output_entry = 157, // output_entry
710 S_158_37 = 158, // $@37
711 S_output_params_list = 159, // output_params_list
712 S_output_params = 160, // output_params
713 S_output = 161, // output
714 S_162_38 = 162, // $@38
715 S_flush = 163, // flush
716 S_maxsize = 164, // maxsize
717 S_maxver = 165, // maxver
718 S_pattern = 166, // pattern
719 S_167_39 = 167 // $@39
720 };
721 };
722
725
728
735 template <typename Base>
736 struct basic_symbol : Base
737 {
739 typedef Base super_type;
740
743 : value ()
744 , location ()
745 {}
746
747#if 201103L <= YY_CPLUSPLUS
750 : Base (std::move (that))
751 , value ()
752 , location (std::move (that.location))
753 {
754 switch (this->kind ())
755 {
756 case symbol_kind::S_value: // value
757 case symbol_kind::S_map_value: // map_value
758 case symbol_kind::S_socket_type_value: // socket_type_value
759 case symbol_kind::S_auth_type_value: // auth_type_value
760 value.move< ElementPtr > (std::move (that.value));
761 break;
762
763 case symbol_kind::S_BOOLEAN: // "boolean"
764 value.move< bool > (std::move (that.value));
765 break;
766
767 case symbol_kind::S_FLOAT: // "floating point"
768 value.move< double > (std::move (that.value));
769 break;
770
771 case symbol_kind::S_INTEGER: // "integer"
772 value.move< int64_t > (std::move (that.value));
773 break;
774
775 case symbol_kind::S_STRING: // "constant string"
776 value.move< std::string > (std::move (that.value));
777 break;
778
779 default:
780 break;
781 }
782
783 }
784#endif
785
788
790#if 201103L <= YY_CPLUSPLUS
791 basic_symbol (typename Base::kind_type t, location_type&& l)
792 : Base (t)
793 , location (std::move (l))
794 {}
795#else
796 basic_symbol (typename Base::kind_type t, const location_type& l)
797 : Base (t)
798 , location (l)
799 {}
800#endif
801
802#if 201103L <= YY_CPLUSPLUS
803 basic_symbol (typename Base::kind_type t, ElementPtr&& v, location_type&& l)
804 : Base (t)
805 , value (std::move (v))
806 , location (std::move (l))
807 {}
808#else
809 basic_symbol (typename Base::kind_type t, const ElementPtr& v, const location_type& l)
810 : Base (t)
811 , value (v)
812 , location (l)
813 {}
814#endif
815
816#if 201103L <= YY_CPLUSPLUS
817 basic_symbol (typename Base::kind_type t, bool&& v, location_type&& l)
818 : Base (t)
819 , value (std::move (v))
820 , location (std::move (l))
821 {}
822#else
823 basic_symbol (typename Base::kind_type t, const bool& v, const location_type& l)
824 : Base (t)
825 , value (v)
826 , location (l)
827 {}
828#endif
829
830#if 201103L <= YY_CPLUSPLUS
831 basic_symbol (typename Base::kind_type t, double&& v, location_type&& l)
832 : Base (t)
833 , value (std::move (v))
834 , location (std::move (l))
835 {}
836#else
837 basic_symbol (typename Base::kind_type t, const double& v, const location_type& l)
838 : Base (t)
839 , value (v)
840 , location (l)
841 {}
842#endif
843
844#if 201103L <= YY_CPLUSPLUS
845 basic_symbol (typename Base::kind_type t, int64_t&& v, location_type&& l)
846 : Base (t)
847 , value (std::move (v))
848 , location (std::move (l))
849 {}
850#else
851 basic_symbol (typename Base::kind_type t, const int64_t& v, const location_type& l)
852 : Base (t)
853 , value (v)
854 , location (l)
855 {}
856#endif
857
858#if 201103L <= YY_CPLUSPLUS
859 basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l)
860 : Base (t)
861 , value (std::move (v))
862 , location (std::move (l))
863 {}
864#else
865 basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l)
866 : Base (t)
867 , value (v)
868 , location (l)
869 {}
870#endif
871
874 {
875 clear ();
876 }
877
880 {
881 // User destructor.
882 symbol_kind_type yykind = this->kind ();
883 basic_symbol<Base>& yysym = *this;
884 (void) yysym;
885 switch (yykind)
886 {
887 default:
888 break;
889 }
890
891 // Value type destructor.
892switch (yykind)
893 {
894 case symbol_kind::S_value: // value
895 case symbol_kind::S_map_value: // map_value
896 case symbol_kind::S_socket_type_value: // socket_type_value
897 case symbol_kind::S_auth_type_value: // auth_type_value
898 value.template destroy< ElementPtr > ();
899 break;
900
901 case symbol_kind::S_BOOLEAN: // "boolean"
902 value.template destroy< bool > ();
903 break;
904
905 case symbol_kind::S_FLOAT: // "floating point"
906 value.template destroy< double > ();
907 break;
908
909 case symbol_kind::S_INTEGER: // "integer"
910 value.template destroy< int64_t > ();
911 break;
912
913 case symbol_kind::S_STRING: // "constant string"
914 value.template destroy< std::string > ();
915 break;
916
917 default:
918 break;
919 }
920
921 Base::clear ();
922 }
923
925 std::string name () const YY_NOEXCEPT
926 {
927 return AgentParser::symbol_name (this->kind ());
928 }
929
932
934 bool empty () const YY_NOEXCEPT;
935
937 void move (basic_symbol& s);
938
941
944
945 private:
946#if YY_CPLUSPLUS < 201103L
948 basic_symbol& operator= (const basic_symbol& that);
949#endif
950 };
951
953 struct by_kind
954 {
956 by_kind ();
957
958#if 201103L <= YY_CPLUSPLUS
960 by_kind (by_kind&& that);
961#endif
962
964 by_kind (const by_kind& that);
965
968
970 by_kind (kind_type t);
971
973 void clear () YY_NOEXCEPT;
974
976 void move (by_kind& that);
977
980 symbol_kind_type kind () const YY_NOEXCEPT;
981
983 symbol_kind_type type_get () const YY_NOEXCEPT;
984
988 };
989
992
995 {
998
1001
1003#if 201103L <= YY_CPLUSPLUS
1004 symbol_type (int tok, location_type l)
1005 : super_type(token_type (tok), std::move (l))
1006#else
1007 symbol_type (int tok, const location_type& l)
1008 : super_type(token_type (tok), l)
1009#endif
1010 {
1013 }
1014#if 201103L <= YY_CPLUSPLUS
1015 symbol_type (int tok, bool v, location_type l)
1016 : super_type(token_type (tok), std::move (v), std::move (l))
1017#else
1018 symbol_type (int tok, const bool& v, const location_type& l)
1019 : super_type(token_type (tok), v, l)
1020#endif
1021 {
1023 }
1024#if 201103L <= YY_CPLUSPLUS
1025 symbol_type (int tok, double v, location_type l)
1026 : super_type(token_type (tok), std::move (v), std::move (l))
1027#else
1028 symbol_type (int tok, const double& v, const location_type& l)
1029 : super_type(token_type (tok), v, l)
1030#endif
1031 {
1033 }
1034#if 201103L <= YY_CPLUSPLUS
1035 symbol_type (int tok, int64_t v, location_type l)
1036 : super_type(token_type (tok), std::move (v), std::move (l))
1037#else
1038 symbol_type (int tok, const int64_t& v, const location_type& l)
1039 : super_type(token_type (tok), v, l)
1040#endif
1041 {
1043 }
1044#if 201103L <= YY_CPLUSPLUS
1045 symbol_type (int tok, std::string v, location_type l)
1046 : super_type(token_type (tok), std::move (v), std::move (l))
1047#else
1048 symbol_type (int tok, const std::string& v, const location_type& l)
1049 : super_type(token_type (tok), v, l)
1050#endif
1051 {
1053 }
1054 };
1055
1058 virtual ~AgentParser ();
1059
1060#if 201103L <= YY_CPLUSPLUS
1062 AgentParser (const AgentParser&) = delete;
1064 AgentParser& operator= (const AgentParser&) = delete;
1065#endif
1066
1069 int operator() ();
1070
1073 virtual int parse ();
1074
1075#if AGENT_DEBUG
1077 std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
1079 void set_debug_stream (std::ostream &);
1080
1082 typedef int debug_level_type;
1087#endif
1088
1092 virtual void error (const location_type& loc, const std::string& msg);
1093
1095 void error (const syntax_error& err);
1096
1099 static std::string symbol_name (symbol_kind_type yysymbol);
1100
1101 // Implementation of make_symbol for each symbol type.
1102#if 201103L <= YY_CPLUSPLUS
1103 static
1106 {
1107 return symbol_type (token::TOKEN_END, std::move (l));
1108 }
1109#else
1110 static
1111 symbol_type
1113 {
1114 return symbol_type (token::TOKEN_END, l);
1115 }
1116#endif
1117#if 201103L <= YY_CPLUSPLUS
1118 static
1119 symbol_type
1121 {
1122 return symbol_type (token::TOKEN_AGENT_error, std::move (l));
1123 }
1124#else
1125 static
1126 symbol_type
1128 {
1130 }
1131#endif
1132#if 201103L <= YY_CPLUSPLUS
1133 static
1134 symbol_type
1136 {
1137 return symbol_type (token::TOKEN_AGENT_UNDEF, std::move (l));
1138 }
1139#else
1140 static
1141 symbol_type
1143 {
1145 }
1146#endif
1147#if 201103L <= YY_CPLUSPLUS
1148 static
1149 symbol_type
1151 {
1152 return symbol_type (token::TOKEN_COMMA, std::move (l));
1153 }
1154#else
1155 static
1156 symbol_type
1158 {
1159 return symbol_type (token::TOKEN_COMMA, l);
1160 }
1161#endif
1162#if 201103L <= YY_CPLUSPLUS
1163 static
1164 symbol_type
1166 {
1167 return symbol_type (token::TOKEN_COLON, std::move (l));
1168 }
1169#else
1170 static
1171 symbol_type
1173 {
1174 return symbol_type (token::TOKEN_COLON, l);
1175 }
1176#endif
1177#if 201103L <= YY_CPLUSPLUS
1178 static
1179 symbol_type
1181 {
1182 return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
1183 }
1184#else
1185 static
1186 symbol_type
1188 {
1190 }
1191#endif
1192#if 201103L <= YY_CPLUSPLUS
1193 static
1194 symbol_type
1196 {
1197 return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
1198 }
1199#else
1200 static
1201 symbol_type
1203 {
1205 }
1206#endif
1207#if 201103L <= YY_CPLUSPLUS
1208 static
1209 symbol_type
1211 {
1212 return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
1213 }
1214#else
1215 static
1216 symbol_type
1218 {
1220 }
1221#endif
1222#if 201103L <= YY_CPLUSPLUS
1223 static
1224 symbol_type
1226 {
1227 return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
1228 }
1229#else
1230 static
1231 symbol_type
1233 {
1235 }
1236#endif
1237#if 201103L <= YY_CPLUSPLUS
1238 static
1239 symbol_type
1241 {
1242 return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
1243 }
1244#else
1245 static
1246 symbol_type
1248 {
1250 }
1251#endif
1252#if 201103L <= YY_CPLUSPLUS
1253 static
1254 symbol_type
1256 {
1257 return symbol_type (token::TOKEN_CONTROL_AGENT, std::move (l));
1258 }
1259#else
1260 static
1261 symbol_type
1263 {
1265 }
1266#endif
1267#if 201103L <= YY_CPLUSPLUS
1268 static
1269 symbol_type
1271 {
1272 return symbol_type (token::TOKEN_HTTP_HOST, std::move (l));
1273 }
1274#else
1275 static
1276 symbol_type
1278 {
1280 }
1281#endif
1282#if 201103L <= YY_CPLUSPLUS
1283 static
1284 symbol_type
1286 {
1287 return symbol_type (token::TOKEN_HTTP_PORT, std::move (l));
1288 }
1289#else
1290 static
1291 symbol_type
1293 {
1295 }
1296#endif
1297#if 201103L <= YY_CPLUSPLUS
1298 static
1299 symbol_type
1301 {
1302 return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
1303 }
1304#else
1305 static
1306 symbol_type
1308 {
1310 }
1311#endif
1312#if 201103L <= YY_CPLUSPLUS
1313 static
1314 symbol_type
1316 {
1317 return symbol_type (token::TOKEN_COMMENT, std::move (l));
1318 }
1319#else
1320 static
1321 symbol_type
1323 {
1325 }
1326#endif
1327#if 201103L <= YY_CPLUSPLUS
1328 static
1329 symbol_type
1331 {
1332 return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
1333 }
1334#else
1335 static
1336 symbol_type
1338 {
1340 }
1341#endif
1342#if 201103L <= YY_CPLUSPLUS
1343 static
1344 symbol_type
1346 {
1347 return symbol_type (token::TOKEN_TYPE, std::move (l));
1348 }
1349#else
1350 static
1351 symbol_type
1353 {
1354 return symbol_type (token::TOKEN_TYPE, l);
1355 }
1356#endif
1357#if 201103L <= YY_CPLUSPLUS
1358 static
1359 symbol_type
1361 {
1362 return symbol_type (token::TOKEN_BASIC, std::move (l));
1363 }
1364#else
1365 static
1366 symbol_type
1368 {
1369 return symbol_type (token::TOKEN_BASIC, l);
1370 }
1371#endif
1372#if 201103L <= YY_CPLUSPLUS
1373 static
1374 symbol_type
1376 {
1377 return symbol_type (token::TOKEN_REALM, std::move (l));
1378 }
1379#else
1380 static
1381 symbol_type
1383 {
1384 return symbol_type (token::TOKEN_REALM, l);
1385 }
1386#endif
1387#if 201103L <= YY_CPLUSPLUS
1388 static
1389 symbol_type
1391 {
1392 return symbol_type (token::TOKEN_CLIENTS, std::move (l));
1393 }
1394#else
1395 static
1396 symbol_type
1398 {
1400 }
1401#endif
1402#if 201103L <= YY_CPLUSPLUS
1403 static
1404 symbol_type
1406 {
1407 return symbol_type (token::TOKEN_USER, std::move (l));
1408 }
1409#else
1410 static
1411 symbol_type
1413 {
1414 return symbol_type (token::TOKEN_USER, l);
1415 }
1416#endif
1417#if 201103L <= YY_CPLUSPLUS
1418 static
1419 symbol_type
1421 {
1422 return symbol_type (token::TOKEN_PASSWORD, std::move (l));
1423 }
1424#else
1425 static
1426 symbol_type
1428 {
1430 }
1431#endif
1432#if 201103L <= YY_CPLUSPLUS
1433 static
1434 symbol_type
1436 {
1437 return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
1438 }
1439#else
1440 static
1441 symbol_type
1443 {
1445 }
1446#endif
1447#if 201103L <= YY_CPLUSPLUS
1448 static
1449 symbol_type
1451 {
1452 return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
1453 }
1454#else
1455 static
1456 symbol_type
1458 {
1460 }
1461#endif
1462#if 201103L <= YY_CPLUSPLUS
1463 static
1464 symbol_type
1466 {
1467 return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
1468 }
1469#else
1470 static
1471 symbol_type
1473 {
1475 }
1476#endif
1477#if 201103L <= YY_CPLUSPLUS
1478 static
1479 symbol_type
1481 {
1482 return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
1483 }
1484#else
1485 static
1486 symbol_type
1488 {
1490 }
1491#endif
1492#if 201103L <= YY_CPLUSPLUS
1493 static
1494 symbol_type
1496 {
1497 return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
1498 }
1499#else
1500 static
1501 symbol_type
1503 {
1505 }
1506#endif
1507#if 201103L <= YY_CPLUSPLUS
1508 static
1509 symbol_type
1511 {
1512 return symbol_type (token::TOKEN_DHCP4_SERVER, std::move (l));
1513 }
1514#else
1515 static
1516 symbol_type
1518 {
1520 }
1521#endif
1522#if 201103L <= YY_CPLUSPLUS
1523 static
1524 symbol_type
1526 {
1527 return symbol_type (token::TOKEN_DHCP6_SERVER, std::move (l));
1528 }
1529#else
1530 static
1531 symbol_type
1533 {
1535 }
1536#endif
1537#if 201103L <= YY_CPLUSPLUS
1538 static
1539 symbol_type
1541 {
1542 return symbol_type (token::TOKEN_D2_SERVER, std::move (l));
1543 }
1544#else
1545 static
1546 symbol_type
1548 {
1550 }
1551#endif
1552#if 201103L <= YY_CPLUSPLUS
1553 static
1554 symbol_type
1556 {
1557 return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
1558 }
1559#else
1560 static
1561 symbol_type
1563 {
1565 }
1566#endif
1567#if 201103L <= YY_CPLUSPLUS
1568 static
1569 symbol_type
1571 {
1572 return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
1573 }
1574#else
1575 static
1576 symbol_type
1578 {
1580 }
1581#endif
1582#if 201103L <= YY_CPLUSPLUS
1583 static
1584 symbol_type
1586 {
1587 return symbol_type (token::TOKEN_UNIX, std::move (l));
1588 }
1589#else
1590 static
1591 symbol_type
1593 {
1594 return symbol_type (token::TOKEN_UNIX, l);
1595 }
1596#endif
1597#if 201103L <= YY_CPLUSPLUS
1598 static
1599 symbol_type
1601 {
1602 return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
1603 }
1604#else
1605 static
1606 symbol_type
1608 {
1610 }
1611#endif
1612#if 201103L <= YY_CPLUSPLUS
1613 static
1614 symbol_type
1616 {
1617 return symbol_type (token::TOKEN_LIBRARY, std::move (l));
1618 }
1619#else
1620 static
1621 symbol_type
1623 {
1625 }
1626#endif
1627#if 201103L <= YY_CPLUSPLUS
1628 static
1629 symbol_type
1631 {
1632 return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
1633 }
1634#else
1635 static
1636 symbol_type
1638 {
1640 }
1641#endif
1642#if 201103L <= YY_CPLUSPLUS
1643 static
1644 symbol_type
1646 {
1647 return symbol_type (token::TOKEN_LOGGERS, std::move (l));
1648 }
1649#else
1650 static
1651 symbol_type
1653 {
1655 }
1656#endif
1657#if 201103L <= YY_CPLUSPLUS
1658 static
1659 symbol_type
1661 {
1662 return symbol_type (token::TOKEN_NAME, std::move (l));
1663 }
1664#else
1665 static
1666 symbol_type
1668 {
1669 return symbol_type (token::TOKEN_NAME, l);
1670 }
1671#endif
1672#if 201103L <= YY_CPLUSPLUS
1673 static
1674 symbol_type
1676 {
1677 return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
1678 }
1679#else
1680 static
1681 symbol_type
1683 {
1685 }
1686#endif
1687#if 201103L <= YY_CPLUSPLUS
1688 static
1689 symbol_type
1691 {
1692 return symbol_type (token::TOKEN_OUTPUT, std::move (l));
1693 }
1694#else
1695 static
1696 symbol_type
1698 {
1699 return symbol_type (token::TOKEN_OUTPUT, l);
1700 }
1701#endif
1702#if 201103L <= YY_CPLUSPLUS
1703 static
1704 symbol_type
1706 {
1707 return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
1708 }
1709#else
1710 static
1711 symbol_type
1713 {
1715 }
1716#endif
1717#if 201103L <= YY_CPLUSPLUS
1718 static
1719 symbol_type
1721 {
1722 return symbol_type (token::TOKEN_SEVERITY, std::move (l));
1723 }
1724#else
1725 static
1726 symbol_type
1728 {
1730 }
1731#endif
1732#if 201103L <= YY_CPLUSPLUS
1733 static
1734 symbol_type
1736 {
1737 return symbol_type (token::TOKEN_FLUSH, std::move (l));
1738 }
1739#else
1740 static
1741 symbol_type
1743 {
1744 return symbol_type (token::TOKEN_FLUSH, l);
1745 }
1746#endif
1747#if 201103L <= YY_CPLUSPLUS
1748 static
1749 symbol_type
1751 {
1752 return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
1753 }
1754#else
1755 static
1756 symbol_type
1758 {
1760 }
1761#endif
1762#if 201103L <= YY_CPLUSPLUS
1763 static
1764 symbol_type
1766 {
1767 return symbol_type (token::TOKEN_MAXVER, std::move (l));
1768 }
1769#else
1770 static
1771 symbol_type
1773 {
1774 return symbol_type (token::TOKEN_MAXVER, l);
1775 }
1776#endif
1777#if 201103L <= YY_CPLUSPLUS
1778 static
1779 symbol_type
1781 {
1782 return symbol_type (token::TOKEN_PATTERN, std::move (l));
1783 }
1784#else
1785 static
1786 symbol_type
1788 {
1790 }
1791#endif
1792#if 201103L <= YY_CPLUSPLUS
1793 static
1794 symbol_type
1796 {
1797 return symbol_type (token::TOKEN_START_JSON, std::move (l));
1798 }
1799#else
1800 static
1801 symbol_type
1803 {
1805 }
1806#endif
1807#if 201103L <= YY_CPLUSPLUS
1808 static
1809 symbol_type
1811 {
1812 return symbol_type (token::TOKEN_START_AGENT, std::move (l));
1813 }
1814#else
1815 static
1816 symbol_type
1818 {
1820 }
1821#endif
1822#if 201103L <= YY_CPLUSPLUS
1823 static
1824 symbol_type
1826 {
1827 return symbol_type (token::TOKEN_START_SUB_AGENT, std::move (l));
1828 }
1829#else
1830 static
1831 symbol_type
1833 {
1835 }
1836#endif
1837#if 201103L <= YY_CPLUSPLUS
1838 static
1839 symbol_type
1840 make_STRING (std::string v, location_type l)
1841 {
1842 return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
1843 }
1844#else
1845 static
1846 symbol_type
1847 make_STRING (const std::string& v, const location_type& l)
1848 {
1849 return symbol_type (token::TOKEN_STRING, v, l);
1850 }
1851#endif
1852#if 201103L <= YY_CPLUSPLUS
1853 static
1854 symbol_type
1855 make_INTEGER (int64_t v, location_type l)
1856 {
1857 return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
1858 }
1859#else
1860 static
1861 symbol_type
1862 make_INTEGER (const int64_t& v, const location_type& l)
1863 {
1864 return symbol_type (token::TOKEN_INTEGER, v, l);
1865 }
1866#endif
1867#if 201103L <= YY_CPLUSPLUS
1868 static
1869 symbol_type
1870 make_FLOAT (double v, location_type l)
1871 {
1872 return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
1873 }
1874#else
1875 static
1876 symbol_type
1877 make_FLOAT (const double& v, const location_type& l)
1878 {
1879 return symbol_type (token::TOKEN_FLOAT, v, l);
1880 }
1881#endif
1882#if 201103L <= YY_CPLUSPLUS
1883 static
1884 symbol_type
1885 make_BOOLEAN (bool v, location_type l)
1886 {
1887 return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
1888 }
1889#else
1890 static
1891 symbol_type
1892 make_BOOLEAN (const bool& v, const location_type& l)
1893 {
1894 return symbol_type (token::TOKEN_BOOLEAN, v, l);
1895 }
1896#endif
1897
1898
1900 {
1901 public:
1902 context (const AgentParser& yyparser, const symbol_type& yyla);
1903 const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; }
1904 symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }
1905 const location_type& location () const YY_NOEXCEPT { return yyla_.location; }
1906
1910 int expected_tokens (symbol_kind_type yyarg[], int yyargn) const;
1911
1912 private:
1913 const AgentParser& yyparser_;
1914 const symbol_type& yyla_;
1915 };
1916
1917 private:
1918#if YY_CPLUSPLUS < 201103L
1920 AgentParser (const AgentParser&);
1922 AgentParser& operator= (const AgentParser&);
1923#endif
1924
1925
1927 typedef short state_type;
1928
1930 int yy_syntax_error_arguments_ (const context& yyctx,
1931 symbol_kind_type yyarg[], int yyargn) const;
1932
1935 virtual std::string yysyntax_error_ (const context& yyctx) const;
1939 static state_type yy_lr_goto_state_ (state_type yystate, int yysym);
1940
1943 static bool yy_pact_value_is_default_ (int yyvalue);
1944
1947 static bool yy_table_value_is_error_ (int yyvalue);
1948
1949 static const short yypact_ninf_;
1950 static const signed char yytable_ninf_;
1951
1955 static symbol_kind_type yytranslate_ (int t);
1956
1958 static std::string yytnamerr_ (const char *yystr);
1959
1961 static const char* const yytname_[];
1962
1963
1964 // Tables.
1965 // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1966 // STATE-NUM.
1967 static const short yypact_[];
1968
1969 // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1970 // Performed when YYTABLE does not specify something else to do. Zero
1971 // means the default is an error.
1972 static const unsigned char yydefact_[];
1973
1974 // YYPGOTO[NTERM-NUM].
1975 static const short yypgoto_[];
1976
1977 // YYDEFGOTO[NTERM-NUM].
1978 static const short yydefgoto_[];
1979
1980 // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1981 // positive, shift that token. If negative, reduce the rule whose
1982 // number is the opposite. If YYTABLE_NINF, syntax error.
1983 static const short yytable_[];
1984
1985 static const short yycheck_[];
1986
1987 // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1988 // symbol of state STATE-NUM.
1989 static const unsigned char yystos_[];
1990
1991 // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
1992 static const unsigned char yyr1_[];
1993
1994 // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
1995 static const signed char yyr2_[];
1996
1997
1998#if AGENT_DEBUG
1999 // YYRLINE[YYN] -- Source line where rule number YYN was defined.
2000 static const short yyrline_[];
2002 virtual void yy_reduce_print_ (int r) const;
2004 virtual void yy_stack_print_ () const;
2005
2007 int yydebug_;
2009 std::ostream* yycdebug_;
2010
2014 template <typename Base>
2015 void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
2016#endif
2017
2022 template <typename Base>
2023 void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
2024
2025 private:
2027 struct by_state
2028 {
2030 by_state () YY_NOEXCEPT;
2031
2033 typedef state_type kind_type;
2034
2036 by_state (kind_type s) YY_NOEXCEPT;
2037
2039 by_state (const by_state& that) YY_NOEXCEPT;
2040
2042 void clear () YY_NOEXCEPT;
2043
2045 void move (by_state& that);
2046
2049 symbol_kind_type kind () const YY_NOEXCEPT;
2050
2053 enum { empty_state = 0 };
2054
2057 state_type state;
2058 };
2059
2061 struct stack_symbol_type : basic_symbol<by_state>
2062 {
2064 typedef basic_symbol<by_state> super_type;
2066 stack_symbol_type ();
2068 stack_symbol_type (YY_RVREF (stack_symbol_type) that);
2070 stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
2071#if YY_CPLUSPLUS < 201103L
2074 stack_symbol_type& operator= (stack_symbol_type& that);
2075
2078 stack_symbol_type& operator= (const stack_symbol_type& that);
2079#endif
2080 };
2081
2083 template <typename T, typename S = std::vector<T> >
2084 class stack
2085 {
2086 public:
2087 // Hide our reversed order.
2088 typedef typename S::iterator iterator;
2089 typedef typename S::const_iterator const_iterator;
2090 typedef typename S::size_type size_type;
2091 typedef typename std::ptrdiff_t index_type;
2092
2093 stack (size_type n = 200)
2094 : seq_ (n)
2095 {}
2096
2097#if 201103L <= YY_CPLUSPLUS
2099 stack (const stack&) = delete;
2101 stack& operator= (const stack&) = delete;
2102#endif
2103
2107 const T&
2108 operator[] (index_type i) const
2109 {
2110 return seq_[size_type (size () - 1 - i)];
2111 }
2112
2116 T&
2117 operator[] (index_type i)
2118 {
2119 return seq_[size_type (size () - 1 - i)];
2120 }
2121
2125 void
2126 push (YY_MOVE_REF (T) t)
2127 {
2128 seq_.push_back (T ());
2129 operator[] (0).move (t);
2130 }
2131
2133 void
2134 pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2135 {
2136 for (; 0 < n; --n)
2137 seq_.pop_back ();
2138 }
2139
2141 void
2142 clear () YY_NOEXCEPT
2143 {
2144 seq_.clear ();
2145 }
2146
2148 index_type
2149 size () const YY_NOEXCEPT
2150 {
2151 return index_type (seq_.size ());
2152 }
2153
2155 const_iterator
2156 begin () const YY_NOEXCEPT
2157 {
2158 return seq_.begin ();
2159 }
2160
2162 const_iterator
2163 end () const YY_NOEXCEPT
2164 {
2165 return seq_.end ();
2166 }
2167
2169 class slice
2170 {
2171 public:
2172 slice (const stack& stack, index_type range)
2173 : stack_ (stack)
2174 , range_ (range)
2175 {}
2176
2177 const T&
2178 operator[] (index_type i) const
2179 {
2180 return stack_[range_ - i];
2181 }
2182
2183 private:
2184 const stack& stack_;
2185 index_type range_;
2186 };
2187
2188 private:
2189#if YY_CPLUSPLUS < 201103L
2191 stack (const stack&);
2193 stack& operator= (const stack&);
2194#endif
2196 S seq_;
2197 };
2198
2199
2201 typedef stack<stack_symbol_type> stack_type;
2202
2204 stack_type yystack_;
2205
2211 void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2212
2219 void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
2220
2222 void yypop_ (int n = 1);
2223
2225 enum
2226 {
2227 yylast_ = 239,
2228 yynnts_ = 115,
2229 yyfinal_ = 8
2230 };
2231
2232
2233 // User arguments.
2235
2236 };
2237
2238 inline
2240 AgentParser::yytranslate_ (int t)
2241 {
2242 // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to
2243 // TOKEN-NUM as returned by yylex.
2244 static
2245 const signed char
2246 translate_table[] =
2247 {
2248 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2249 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2250 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2251 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2252 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2253 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2254 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2255 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2256 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2257 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2258 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2259 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2260 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2261 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2262 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2263 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2264 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2265 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2266 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2267 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2268 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2269 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2270 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2271 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2272 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2273 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2274 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2275 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2276 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2277 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2278 45, 46, 47, 48, 49, 50, 51, 52
2279 };
2280 // Last valid token kind.
2281 const int code_max = 307;
2282
2283 if (t <= 0)
2284 return symbol_kind::S_YYEOF;
2285 else if (t <= code_max)
2286 return YY_CAST (symbol_kind_type, translate_table[t]);
2287 else
2289 }
2290
2291 // basic_symbol.
2292 template <typename Base>
2294 : Base (that)
2295 , value ()
2296 , location (that.location)
2297 {
2298 switch (this->kind ())
2299 {
2300 case symbol_kind::S_value: // value
2301 case symbol_kind::S_map_value: // map_value
2302 case symbol_kind::S_socket_type_value: // socket_type_value
2303 case symbol_kind::S_auth_type_value: // auth_type_value
2304 value.copy< ElementPtr > (YY_MOVE (that.value));
2305 break;
2306
2307 case symbol_kind::S_BOOLEAN: // "boolean"
2308 value.copy< bool > (YY_MOVE (that.value));
2309 break;
2310
2311 case symbol_kind::S_FLOAT: // "floating point"
2312 value.copy< double > (YY_MOVE (that.value));
2313 break;
2314
2315 case symbol_kind::S_INTEGER: // "integer"
2316 value.copy< int64_t > (YY_MOVE (that.value));
2317 break;
2318
2319 case symbol_kind::S_STRING: // "constant string"
2320 value.copy< std::string > (YY_MOVE (that.value));
2321 break;
2322
2323 default:
2324 break;
2325 }
2326
2327 }
2328
2329
2330
2331 template <typename Base>
2334 {
2335 return this->kind ();
2336 }
2337
2338 template <typename Base>
2339 bool
2341 {
2342 return this->kind () == symbol_kind::S_YYEMPTY;
2343 }
2344
2345 template <typename Base>
2346 void
2348 {
2349 super_type::move (s);
2350 switch (this->kind ())
2351 {
2352 case symbol_kind::S_value: // value
2353 case symbol_kind::S_map_value: // map_value
2354 case symbol_kind::S_socket_type_value: // socket_type_value
2355 case symbol_kind::S_auth_type_value: // auth_type_value
2356 value.move< ElementPtr > (YY_MOVE (s.value));
2357 break;
2358
2359 case symbol_kind::S_BOOLEAN: // "boolean"
2360 value.move< bool > (YY_MOVE (s.value));
2361 break;
2362
2363 case symbol_kind::S_FLOAT: // "floating point"
2364 value.move< double > (YY_MOVE (s.value));
2365 break;
2366
2367 case symbol_kind::S_INTEGER: // "integer"
2368 value.move< int64_t > (YY_MOVE (s.value));
2369 break;
2370
2371 case symbol_kind::S_STRING: // "constant string"
2372 value.move< std::string > (YY_MOVE (s.value));
2373 break;
2374
2375 default:
2376 break;
2377 }
2378
2379 location = YY_MOVE (s.location);
2380 }
2381
2382 // by_kind.
2383 inline
2385 : kind_ (symbol_kind::S_YYEMPTY)
2386 {}
2387
2388#if 201103L <= YY_CPLUSPLUS
2389 inline
2391 : kind_ (that.kind_)
2392 {
2393 that.clear ();
2394 }
2395#endif
2396
2397 inline
2399 : kind_ (that.kind_)
2400 {}
2401
2402 inline
2404 : kind_ (yytranslate_ (t))
2405 {}
2406
2407 inline
2408 void
2410 {
2411 kind_ = symbol_kind::S_YYEMPTY;
2412 }
2413
2414 inline
2415 void
2417 {
2418 kind_ = that.kind_;
2419 that.clear ();
2420 }
2421
2422 inline
2425 {
2426 return kind_;
2427 }
2428
2429 inline
2432 {
2433 return this->kind ();
2434 }
2435
2436#line 14 "agent_parser.yy"
2437} } // isc::agent
2438#line 2439 "agent_parser.h"
2439
2440
2441
2442
2443#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_CAST(Type, Val)
Definition: agent_parser.h:171
#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
A buffer to store and retrieve objects.
Definition: agent_parser.h:218
char yyraw[size]
A buffer large enough to store any of the semantic values.
Definition: agent_parser.h:444
T & build(const T &t)
Instantiate a T in here from t.
Definition: agent_parser.h:299
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
Definition: agent_parser.h:318
T & build()
Instantiate an empty T in here.
Definition: agent_parser.h:290
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
Definition: agent_parser.h:336
void destroy()
Destroy the stored T.
Definition: agent_parser.h:381
void move(self_type &that)
Move the content of that to this.
Definition: agent_parser.h:348
void copy(const self_type &that)
Copy the content of that to this.
Definition: agent_parser.h:373
T & as() YY_NOEXCEPT
Accessor to a built T.
Definition: agent_parser.h:307
T & emplace(const T &t)
Instantiate a T in here from t.
Definition: agent_parser.h:277
semantic_type(YY_RVREF(T) t)
Construct and fill.
Definition: agent_parser.h:231
semantic_type self_type
Type of *this.
Definition: agent_parser.h:221
long double yyalign_me
Strongest alignment constraints.
Definition: agent_parser.h:442
T & emplace()
Instantiate an empty T in here.
Definition: agent_parser.h:266
semantic_type() YY_NOEXCEPT
Empty construction.
Definition: agent_parser.h:224
~semantic_type() YY_NOEXCEPT
Destruction, allowed only if empty.
Definition: agent_parser.h:246
Present a slice of the top of a stack.
slice(const stack &stack, index_type range)
static symbol_type make_D2_SERVER(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)
void set_debug_level(debug_level_type l)
Set the current debugging level.
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)
virtual void error(const location_type &loc, const std::string &msg)
Report a syntax error.
static symbol_type make_RSQUARE_BRACKET(const location_type &l)
static symbol_type make_COLON(const location_type &l)
AgentParser(isc::agent::ParserContext &ctx_yyarg)
Build a parser object.
static symbol_type make_BASIC(const location_type &l)
static symbol_type make_PATTERN(const location_type &l)
int debug_level_type
Type for debugging levels.
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:455
token::yytokentype token_kind_type
Token kind, as returned by yylex.
Definition: agent_parser.h:540
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)
virtual int parse()
Parse.
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)
void set_debug_stream(std::ostream &)
Set the current debugging stream.
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)
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
Definition: agent_parser.h:724
static const symbol_kind_type YYNTOKENS
The number of tokens.
Definition: agent_parser.h:727
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)
std::ostream & debug_stream() const YY_ATTRIBUTE_PURE
The current debugging stream.
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_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:543
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)
debug_level_type debug_level() const YY_ATTRIBUTE_PURE
The current debugging level.
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:24
Defines the logger used by the top-level component of kea-lfc.
semantic_type value
The semantic value.
Definition: agent_parser.h:940
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:851
location_type location
The location.
Definition: agent_parser.h:943
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:796
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
Definition: agent_parser.h:865
void clear() YY_NOEXCEPT
Destroy contents, and record that is empty.
Definition: agent_parser.h:879
bool empty() const YY_NOEXCEPT
Whether empty.
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:809
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
Definition: agent_parser.h:837
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
Definition: agent_parser.h:925
basic_symbol()
Default constructor.
Definition: agent_parser.h:742
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
Definition: agent_parser.h:823
Type access provider for token (enum) based symbols.
Definition: agent_parser.h:954
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
by_kind()
Default constructor.
token_kind_type kind_type
The symbol kind as needed by the constructor.
Definition: agent_parser.h:967
symbol_kind_type kind_
The symbol kind.
Definition: agent_parser.h:987
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.
Definition: agent_parser.h:995
basic_symbol< by_kind > super_type
Superclass.
Definition: agent_parser.h:997
Syntax errors thrown from user actions.
Definition: agent_parser.h:459
~syntax_error() YY_NOEXCEPT YY_NOTHROW
syntax_error(const syntax_error &s)
Definition: agent_parser.h:465
syntax_error(const location_type &l, const std::string &m)
Definition: agent_parser.h:460
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).
Definition: agent_parser.h:536