Kea  2.3.4-git
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 
55 using namespace isc::agent;
56 using namespace isc::data;
57 using 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"
207 namespace 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
223  class value_type
229  {
230  public:
232  typedef value_type self_type;
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
250  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
263  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
274  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&
301  build ()
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&
329  as () const YY_NOEXCEPT
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
347  swap (self_type& that) YY_NOEXCEPT
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
359  move (self_type& that)
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
371  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
400  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
463  typedef value_type semantic_type;
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 
484  location_type location;
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 
558  typedef token_kind_type token_type;
559 
561  struct symbol_kind
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 
752  static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS;
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
773  basic_symbol (basic_symbol&& that)
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 
812  basic_symbol (const basic_symbol& that);
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.
919 switch (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 
958  symbol_kind_type type_get () const YY_NOEXCEPT;
959 
961  bool empty () const YY_NOEXCEPT;
962 
964  void move (basic_symbol& s);
965 
967  value_type value;
968 
970  location_type location;
971 
972  private:
973 #if YY_CPLUSPLUS < 201103L
974  basic_symbol& operator= (const basic_symbol& that);
976 #endif
977  };
978 
980  struct by_kind
981  {
983  typedef token_kind_type kind_type;
984 
986  by_kind () YY_NOEXCEPT;
987 
988 #if 201103L <= YY_CPLUSPLUS
989  by_kind (by_kind&& that) YY_NOEXCEPT;
991 #endif
992 
994  by_kind (const by_kind& that) YY_NOEXCEPT;
995 
997  by_kind (kind_type t) YY_NOEXCEPT;
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 
1016  symbol_kind_type kind_;
1017  };
1018 
1020  typedef by_kind by_type;
1021 
1024  {
1027 
1029  symbol_type () YY_NOEXCEPT {}
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
1100  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
1115  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
1151  make_END (const location_type& l)
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
1166  make_AGENT_error (const location_type& l)
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
1181  make_AGENT_UNDEF (const location_type& l)
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
1196  make_COMMA (const location_type& l)
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
1211  make_COLON (const location_type& l)
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
1226  make_LSQUARE_BRACKET (const location_type& l)
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
1241  make_RSQUARE_BRACKET (const location_type& l)
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
1256  make_LCURLY_BRACKET (const location_type& l)
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
1271  make_RCURLY_BRACKET (const location_type& l)
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
1286  make_NULL_TYPE (const location_type& l)
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
1301  make_CONTROL_AGENT (const location_type& l)
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
1316  make_HTTP_HOST (const location_type& l)
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
1331  make_HTTP_PORT (const location_type& l)
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
1346  make_USER_CONTEXT (const location_type& l)
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
1361  make_COMMENT (const location_type& l)
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
1376  make_AUTHENTICATION (const location_type& l)
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
1391  make_TYPE (const location_type& l)
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
1406  make_BASIC (const location_type& l)
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
1421  make_REALM (const location_type& l)
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
1436  make_DIRECTORY (const location_type& l)
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
1451  make_CLIENTS (const location_type& l)
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
1466  make_USER (const location_type& l)
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
1481  make_USER_FILE (const location_type& l)
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
1496  make_PASSWORD (const location_type& l)
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
1511  make_PASSWORD_FILE (const location_type& l)
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
1526  make_TRUST_ANCHOR (const location_type& l)
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
1541  make_CERT_FILE (const location_type& l)
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
1556  make_KEY_FILE (const location_type& l)
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
1571  make_CERT_REQUIRED (const location_type& l)
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
1586  make_CONTROL_SOCKETS (const location_type& l)
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
1601  make_DHCP4_SERVER (const location_type& l)
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
1616  make_DHCP6_SERVER (const location_type& l)
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
1631  make_D2_SERVER (const location_type& l)
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
1646  make_SOCKET_NAME (const location_type& l)
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
1661  make_SOCKET_TYPE (const location_type& l)
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
1676  make_UNIX (const location_type& l)
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
1691  make_HOOKS_LIBRARIES (const location_type& l)
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
1706  make_LIBRARY (const location_type& l)
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
1721  make_PARAMETERS (const location_type& l)
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
1736  make_LOGGERS (const location_type& l)
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
1751  make_NAME (const location_type& l)
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
1766  make_OUTPUT_OPTIONS (const location_type& l)
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
1781  make_OUTPUT (const location_type& l)
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
1796  make_DEBUGLEVEL (const location_type& l)
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
1811  make_SEVERITY (const location_type& l)
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
1826  make_FLUSH (const location_type& l)
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
1841  make_MAXSIZE (const location_type& l)
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
1856  make_MAXVER (const location_type& l)
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
1871  make_PATTERN (const location_type& l)
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
1886  make_START_JSON (const location_type& l)
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
1901  make_START_AGENT (const location_type& l)
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
1916  make_START_SUB_AGENT (const location_type& l)
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 
1983  class context
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
2003  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
2156  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
2182  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
2274  stack (const stack&);
2277  stack& operator= (const stack&);
2278 #endif
2279  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
2373  return symbol_kind::S_YYUNDEF;
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
2471  AgentParser::by_kind::by_kind () YY_NOEXCEPT
2472  : kind_ (symbol_kind::S_YYEMPTY)
2473  {}
2474 
2475 #if 201103L <= YY_CPLUSPLUS
2476  inline
2477  AgentParser::by_kind::by_kind (by_kind&& that) YY_NOEXCEPT
2478  : kind_ (that.kind_)
2479  {
2480  that.clear ();
2481  }
2482 #endif
2483 
2484  inline
2485  AgentParser::by_kind::by_kind (const by_kind& that) YY_NOEXCEPT
2486  : kind_ (that.kind_)
2487  {}
2488 
2489  inline
2490  AgentParser::by_kind::by_kind (token_kind_type t) YY_NOEXCEPT
2491  : kind_ (yytranslate_ (t))
2492  {}
2493 
2494 
2495 
2496  inline
2497  void
2498  AgentParser::by_kind::clear () YY_NOEXCEPT
2499  {
2500  kind_ = symbol_kind::S_YYEMPTY;
2501  }
2502 
2503  inline
2504  void
2505  AgentParser::by_kind::move (by_kind& that)
2506  {
2507  kind_ = that.kind_;
2508  that.clear ();
2509  }
2510 
2511  inline
2513  AgentParser::by_kind::kind () const YY_NOEXCEPT
2514  {
2515  return kind_;
2516  }
2517 
2518 
2519  inline
2521  AgentParser::by_kind::type_get () const YY_NOEXCEPT
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
static symbol_type make_AUTHENTICATION(const location_type &l)
token::token_kind_type token_kind_type
Token kind, as returned by yylex.
Definition: agent_parser.h:555
static symbol_type make_BOOLEAN(const bool &v, const location_type &l)
symbol_type(int tok, const int64_t &v, const location_type &l)
static symbol_type make_MAXSIZE(const location_type &l)
basic_symbol() YY_NOEXCEPT
Default constructor.
Definition: agent_parser.h:767
static symbol_type make_STRING(const std::string &v, const location_type &l)
symbol_type(int tok, const location_type &l)
Constructor for valueless symbols, and symbols from each type.
symbol_type(int tok, const bool &v, const location_type &l)
~basic_symbol()
Destroy the symbol.
Definition: agent_parser.h:898
static symbol_type make_INTEGER(const int64_t &v, const location_type &l)
value_type(YY_RVREF(T) t)
Construct and fill.
Definition: agent_parser.h:242
static symbol_type make_LCURLY_BRACKET(const location_type &l)
static symbol_type make_START_AGENT(const location_type &l)
static symbol_type make_CONTROL_SOCKETS(const location_type &l)
static symbol_type make_LIBRARY(const location_type &l)
#define AGENT__ASSERT
Definition: agent_parser.h:108
static symbol_type make_RSQUARE_BRACKET(const location_type &l)
static symbol_type make_START_JSON(const location_type &l)
syntax_error(const syntax_error &s)
Definition: agent_parser.h:477
symbol_type(int tok, const double &v, const location_type &l)
static symbol_type make_BASIC(const location_type &l)
T & emplace(const T &t)
Instantiate a T in here from t.
Definition: agent_parser.h:288
#define YY_MOVE_REF(Type)
Definition: agent_parser.h:84
syntax_error(const location_type &l, const std::string &m)
Definition: agent_parser.h:472
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
Definition: agent_parser.h:749
boost::shared_ptr< Element > ElementPtr
Definition: data.h:24
STL namespace.
Syntax errors thrown from user actions.
Definition: agent_parser.h:470
basic_symbol(typename Base::kind_type t, const ElementPtr &v, const location_type &l)
Definition: agent_parser.h:834
#define YY_RVREF(Type)
Definition: agent_parser.h:85
static symbol_type make_USER_CONTEXT(const location_type &l)
#define YY_MOVE
Definition: agent_parser.h:82
value_type value
The semantic value.
Definition: agent_parser.h:967
static symbol_type make_NAME(const location_type &l)
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
Definition: agent_parser.h:848
const location_type & location() const YY_NOEXCEPT
static symbol_type make_USER(const location_type &l)
Forward declaration of the ParserContext class.
static symbol_type make_PATTERN(const location_type &l)
static symbol_type make_TYPE(const location_type &l)
static symbol_type make_CONTROL_AGENT(const location_type &l)
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
Definition: agent_parser.h:952
static symbol_type make_END(const location_type &l)
location_type location
The location.
Definition: agent_parser.h:970
static symbol_type make_DHCP4_SERVER(const location_type &l)
static symbol_type make_AGENT_UNDEF(const location_type &l)
Present a slice of the top of a stack.
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
static symbol_type make_LSQUARE_BRACKET(const location_type &l)
static symbol_type make_RCURLY_BRACKET(const location_type &l)
static symbol_type make_HOOKS_LIBRARIES(const location_type &l)
static symbol_type make_START_SUB_AGENT(const location_type &l)
symbol_kind_type kind_
The symbol kind.
T & as() YY_NOEXCEPT
Accessor to a built T.
Definition: agent_parser.h:318
static symbol_type make_FLOAT(const double &v, const location_type &l)
static symbol_type make_COLON(const location_type &l)
value_type self_type
Type of *this.
Definition: agent_parser.h:232
T & emplace()
Instantiate an empty T in here.
Definition: agent_parser.h:277
Type access provider for token (enum) based symbols.
Definition: agent_parser.h:980
#define YY_NOTHROW
Definition: agent_parser.h:95
Defines the logger used by the top-level component of kea-lfc.
~value_type() YY_NOEXCEPT
Destruction, allowed only if empty.
Definition: agent_parser.h:257
static symbol_type make_HTTP_HOST(const location_type &l)
static symbol_type make_REALM(const location_type &l)
static symbol_type make_SEVERITY(const location_type &l)
void clear() YY_NOEXCEPT
Record that this symbol is empty.
static std::string symbol_name(symbol_kind_type yysymbol)
The user-facing name of the symbol whose (internal) number is YYSYMBOL.
const symbol_type & lookahead() const YY_NOEXCEPT
static symbol_type make_CLIENTS(const location_type &l)
token_kind_type kind_type
The symbol kind as needed by the constructor.
Definition: agent_parser.h:983
static symbol_type make_PARAMETERS(const location_type &l)
static symbol_type make_DHCP6_SERVER(const location_type &l)
void move(self_type &that)
Move the content of that to this.
Definition: agent_parser.h:359
static symbol_type make_AGENT_error(const location_type &l)
static symbol_type make_SOCKET_NAME(const location_type &l)
static symbol_type make_COMMA(const location_type &l)
void destroy()
Destroy the stored T.
Definition: agent_parser.h:392
static symbol_type make_HTTP_PORT(const location_type &l)
void clear() YY_NOEXCEPT
Destroy contents, and record that is empty.
Definition: agent_parser.h:906
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
Definition: agent_parser.h:890
static symbol_type make_DEBUGLEVEL(const location_type &l)
int debug_level_type
Type for debugging levels.
symbol_type(int tok, const std::string &v, const location_type &l)
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).
Definition: agent_parser.h:551
static symbol_type make_PASSWORD(const location_type &l)
value_type() YY_NOEXCEPT
Empty construction.
Definition: agent_parser.h:235
basic_symbol(typename Base::kind_type t, const int64_t &v, const location_type &l)
Definition: agent_parser.h:876
static symbol_type make_DIRECTORY(const location_type &l)
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
Definition: agent_parser.h:821
#define YY_NOEXCEPT
Definition: agent_parser.h:94
location location_type
Symbol locations.
Definition: agent_parser.h:467
A buffer to store and retrieve objects.
Definition: agent_parser.h:228
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)
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
Definition: agent_parser.h:862
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
Definition: agent_parser.h:347
static symbol_type make_USER_FILE(const location_type &l)
#define YY_ATTRIBUTE_PURE
Definition: agent_parser.h:116
static symbol_type make_OUTPUT(const location_type &l)
"External" symbols: returned by the scanner.
static symbol_type make_PASSWORD_FILE(const location_type &l)
static symbol_type make_NULL_TYPE(const location_type &l)
symbol_type() YY_NOEXCEPT
Empty symbol.
basic_symbol< by_kind > super_type
Superclass.
T & build()
Instantiate an empty T in here.
Definition: agent_parser.h:301
long double yyalign_me_
Strongest alignment constraints.
Definition: agent_parser.h:453
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
Definition: agent_parser.h:329
slice(const stack &stack, index_type range) YY_NOEXCEPT
void copy(const self_type &that)
Copy the content of that to this.
Definition: agent_parser.h:384
static symbol_type make_OUTPUT_OPTIONS(const location_type &l)
A Bison parser.
Definition: agent_parser.h:214
static symbol_type make_TRUST_ANCHOR(const location_type &l)
static symbol_type make_COMMENT(const location_type &l)
static symbol_type make_CERT_FILE(const location_type &l)
static symbol_type make_FLUSH(const location_type &l)
static symbol_type make_D2_SERVER(const location_type &l)
Parser context is a wrapper around flex/bison instances dedicated to Control-agent config file parser...
static symbol_type make_LOGGERS(const location_type &l)
static symbol_type make_UNIX(const location_type &l)
symbol_kind_type token() const YY_NOEXCEPT
T & build(const T &t)
Instantiate a T in here from t.
Definition: agent_parser.h:310
static symbol_type make_SOCKET_TYPE(const location_type &l)
static symbol_type make_CERT_REQUIRED(const location_type &l)
static symbol_type make_MAXVER(const location_type &l)