Kea 1.9.11
netconf_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_NETCONF_NETCONF_PARSER_H_INCLUDED
46# define YY_NETCONF_NETCONF_PARSER_H_INCLUDED
47// "%code requires" blocks.
48#line 17 "netconf_parser.yy"
49
50#include <string>
51#include <cc/data.h>
52#include <boost/lexical_cast.hpp>
54
55using namespace isc::netconf;
56using namespace isc::data;
57using namespace std;
58
59#line 60 "netconf_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 NETCONF__ASSERT
107# include <cassert>
108# define NETCONF__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 NETCONF_DEBUG
189# if defined YYDEBUG
190#if YYDEBUG
191# define NETCONF_DEBUG 1
192# else
193# define NETCONF_DEBUG 0
194# endif
195# else /* ! defined YYDEBUG */
196# define NETCONF_DEBUG 1
197# endif /* ! defined YYDEBUG */
198#endif /* ! defined NETCONF_DEBUG */
199
200#line 14 "netconf_parser.yy"
201namespace isc { namespace netconf {
202#line 203 "netconf_parser.h"
203
204
205
206
209 {
210 public:
211#ifndef NETCONF_STYPE
218 {
219 public:
222
225 : yybuffer_ ()
226 , yytypeid_ (YY_NULLPTR)
227 {}
228
230 template <typename T>
232 : yytypeid_ (&typeid (T))
233 {
234 NETCONF__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 NETCONF__ASSERT (!yytypeid_);
249 }
250
251# if 201103L <= YY_CPLUSPLUS
253 template <typename T, typename... U>
254 T&
255 emplace (U&&... u)
256 {
257 NETCONF__ASSERT (!yytypeid_);
258 NETCONF__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 NETCONF__ASSERT (!yytypeid_);
269 NETCONF__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 NETCONF__ASSERT (!yytypeid_);
280 NETCONF__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 NETCONF__ASSERT (yytypeid_);
310 NETCONF__ASSERT (*yytypeid_ == typeid (T));
311 NETCONF__ASSERT (sizeof (T) <= size);
312 return *yyas_<T> ();
313 }
314
316 template <typename T>
317 const T&
319 {
320 NETCONF__ASSERT (yytypeid_);
321 NETCONF__ASSERT (*yytypeid_ == typeid (T));
322 NETCONF__ASSERT (sizeof (T) <= size);
323 return *yyas_<T> ();
324 }
325
334 template <typename T>
335 void
337 {
338 NETCONF__ASSERT (yytypeid_);
339 NETCONF__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 char dummy1[sizeof (ElementPtr)];
420
421 // "boolean"
422 char dummy2[sizeof (bool)];
423
424 // "floating point"
425 char dummy3[sizeof (double)];
426
427 // "integer"
428 char dummy4[sizeof (int64_t)];
429
430 // "constant string"
431 char dummy5[sizeof (std::string)];
432 };
433
435 enum { size = sizeof (union_type) };
436
438 union
439 {
441 long double yyalign_me;
443 char yyraw[size];
444 } yybuffer_;
445
447 const std::type_info *yytypeid_;
448 };
449
450#else
451 typedef NETCONF_STYPE semantic_type;
452#endif
454 typedef location location_type;
455
457 struct syntax_error : std::runtime_error
458 {
459 syntax_error (const location_type& l, const std::string& m)
460 : std::runtime_error (m)
461 , location (l)
462 {}
463
465 : std::runtime_error (s.what ())
466 , location (s.location)
467 {}
468
470
472 };
473
475 struct token
476 {
478 {
479 TOKEN_NETCONF_EMPTY = -2,
480 TOKEN_END = 0, // "end of file"
481 TOKEN_NETCONF_error = 256, // error
482 TOKEN_NETCONF_UNDEF = 257, // "invalid token"
483 TOKEN_COMMA = 258, // ","
484 TOKEN_COLON = 259, // ":"
485 TOKEN_LSQUARE_BRACKET = 260, // "["
486 TOKEN_RSQUARE_BRACKET = 261, // "]"
487 TOKEN_LCURLY_BRACKET = 262, // "{"
488 TOKEN_RCURLY_BRACKET = 263, // "}"
489 TOKEN_NULL_TYPE = 264, // "null"
490 TOKEN_NETCONF = 265, // "Netconf"
491 TOKEN_USER_CONTEXT = 266, // "user-context"
492 TOKEN_COMMENT = 267, // "comment"
493 TOKEN_BOOT_UPDATE = 268, // "boot-update"
494 TOKEN_SUBSCRIBE_CHANGES = 269, // "subscribe-changes"
495 TOKEN_VALIDATE_CHANGES = 270, // "validate-changes"
496 TOKEN_MANAGED_SERVERS = 271, // "managed-servers"
497 TOKEN_DHCP4_SERVER = 272, // "dhcp4"
498 TOKEN_DHCP6_SERVER = 273, // "dhcp6"
499 TOKEN_D2_SERVER = 274, // "d2"
500 TOKEN_CA_SERVER = 275, // "ca"
501 TOKEN_MODEL = 276, // "model"
502 TOKEN_CONTROL_SOCKET = 277, // "control-socket"
503 TOKEN_SOCKET_TYPE = 278, // "socket-type"
504 TOKEN_UNIX = 279, // "unix"
505 TOKEN_HTTP = 280, // "http"
506 TOKEN_STDOUT = 281, // "stdout"
507 TOKEN_SOCKET_NAME = 282, // "socket-name"
508 TOKEN_SOCKET_URL = 283, // "socket-url"
509 TOKEN_HOOKS_LIBRARIES = 284, // "hooks-libraries"
510 TOKEN_LIBRARY = 285, // "library"
511 TOKEN_PARAMETERS = 286, // "parameters"
512 TOKEN_LOGGERS = 287, // "loggers"
513 TOKEN_NAME = 288, // "name"
514 TOKEN_OUTPUT_OPTIONS = 289, // "output_options"
515 TOKEN_OUTPUT = 290, // "output"
516 TOKEN_DEBUGLEVEL = 291, // "debuglevel"
517 TOKEN_SEVERITY = 292, // "severity"
518 TOKEN_FLUSH = 293, // "flush"
519 TOKEN_MAXSIZE = 294, // "maxsize"
520 TOKEN_MAXVER = 295, // "maxver"
521 TOKEN_PATTERN = 296, // "pattern"
522 TOKEN_START_JSON = 297, // START_JSON
523 TOKEN_START_NETCONF = 298, // START_NETCONF
524 TOKEN_START_SUB_NETCONF = 299, // START_SUB_NETCONF
525 TOKEN_STRING = 300, // "constant string"
526 TOKEN_INTEGER = 301, // "integer"
527 TOKEN_FLOAT = 302, // "floating point"
528 TOKEN_BOOLEAN = 303 // "boolean"
529 };
532 };
533
536
539
542 {
544 {
546 S_YYEMPTY = -2,
547 S_YYEOF = 0, // "end of file"
548 S_YYerror = 1, // error
549 S_YYUNDEF = 2, // "invalid token"
550 S_COMMA = 3, // ","
551 S_COLON = 4, // ":"
552 S_LSQUARE_BRACKET = 5, // "["
553 S_RSQUARE_BRACKET = 6, // "]"
554 S_LCURLY_BRACKET = 7, // "{"
555 S_RCURLY_BRACKET = 8, // "}"
556 S_NULL_TYPE = 9, // "null"
557 S_NETCONF = 10, // "Netconf"
558 S_USER_CONTEXT = 11, // "user-context"
559 S_COMMENT = 12, // "comment"
560 S_BOOT_UPDATE = 13, // "boot-update"
561 S_SUBSCRIBE_CHANGES = 14, // "subscribe-changes"
562 S_VALIDATE_CHANGES = 15, // "validate-changes"
563 S_MANAGED_SERVERS = 16, // "managed-servers"
564 S_DHCP4_SERVER = 17, // "dhcp4"
565 S_DHCP6_SERVER = 18, // "dhcp6"
566 S_D2_SERVER = 19, // "d2"
567 S_CA_SERVER = 20, // "ca"
568 S_MODEL = 21, // "model"
569 S_CONTROL_SOCKET = 22, // "control-socket"
570 S_SOCKET_TYPE = 23, // "socket-type"
571 S_UNIX = 24, // "unix"
572 S_HTTP = 25, // "http"
573 S_STDOUT = 26, // "stdout"
574 S_SOCKET_NAME = 27, // "socket-name"
575 S_SOCKET_URL = 28, // "socket-url"
576 S_HOOKS_LIBRARIES = 29, // "hooks-libraries"
577 S_LIBRARY = 30, // "library"
578 S_PARAMETERS = 31, // "parameters"
579 S_LOGGERS = 32, // "loggers"
580 S_NAME = 33, // "name"
581 S_OUTPUT_OPTIONS = 34, // "output_options"
582 S_OUTPUT = 35, // "output"
583 S_DEBUGLEVEL = 36, // "debuglevel"
584 S_SEVERITY = 37, // "severity"
585 S_FLUSH = 38, // "flush"
586 S_MAXSIZE = 39, // "maxsize"
587 S_MAXVER = 40, // "maxver"
588 S_PATTERN = 41, // "pattern"
589 S_START_JSON = 42, // START_JSON
590 S_START_NETCONF = 43, // START_NETCONF
591 S_START_SUB_NETCONF = 44, // START_SUB_NETCONF
592 S_STRING = 45, // "constant string"
593 S_INTEGER = 46, // "integer"
594 S_FLOAT = 47, // "floating point"
595 S_BOOLEAN = 48, // "boolean"
596 S_YYACCEPT = 49, // $accept
597 S_start = 50, // start
598 S_51_1 = 51, // $@1
599 S_52_2 = 52, // $@2
600 S_53_3 = 53, // $@3
601 S_sub_netconf = 54, // sub_netconf
602 S_55_4 = 55, // $@4
603 S_json = 56, // json
604 S_value = 57, // value
605 S_map = 58, // map
606 S_59_5 = 59, // $@5
607 S_map_value = 60, // map_value
608 S_map_content = 61, // map_content
609 S_not_empty_map = 62, // not_empty_map
610 S_list_generic = 63, // list_generic
611 S_64_6 = 64, // $@6
612 S_list_content = 65, // list_content
613 S_not_empty_list = 66, // not_empty_list
614 S_unknown_map_entry = 67, // unknown_map_entry
615 S_netconf_syntax_map = 68, // netconf_syntax_map
616 S_69_7 = 69, // $@7
617 S_global_object = 70, // global_object
618 S_71_8 = 71, // $@8
619 S_global_params = 72, // global_params
620 S_not_empty_global_params = 73, // not_empty_global_params
621 S_global_param = 74, // global_param
622 S_boot_update = 75, // boot_update
623 S_subscribe_changes = 76, // subscribe_changes
624 S_validate_changes = 77, // validate_changes
625 S_user_context = 78, // user_context
626 S_79_9 = 79, // $@9
627 S_comment = 80, // comment
628 S_81_10 = 81, // $@10
629 S_hooks_libraries = 82, // hooks_libraries
630 S_83_11 = 83, // $@11
631 S_hooks_libraries_list = 84, // hooks_libraries_list
632 S_not_empty_hooks_libraries_list = 85, // not_empty_hooks_libraries_list
633 S_hooks_library = 86, // hooks_library
634 S_87_12 = 87, // $@12
635 S_hooks_params = 88, // hooks_params
636 S_hooks_param = 89, // hooks_param
637 S_library = 90, // library
638 S_91_13 = 91, // $@13
639 S_parameters = 92, // parameters
640 S_93_14 = 93, // $@14
641 S_managed_servers = 94, // managed_servers
642 S_95_15 = 95, // $@15
643 S_servers_entries = 96, // servers_entries
644 S_not_empty_servers_entries = 97, // not_empty_servers_entries
645 S_server_entry = 98, // server_entry
646 S_dhcp4_server = 99, // dhcp4_server
647 S_100_16 = 100, // $@16
648 S_dhcp6_server = 101, // dhcp6_server
649 S_102_17 = 102, // $@17
650 S_d2_server = 103, // d2_server
651 S_104_18 = 104, // $@18
652 S_ca_server = 105, // ca_server
653 S_106_19 = 106, // $@19
654 S_managed_server_params = 107, // managed_server_params
655 S_managed_server_param = 108, // managed_server_param
656 S_model = 109, // model
657 S_110_20 = 110, // $@20
658 S_control_socket = 111, // control_socket
659 S_112_21 = 112, // $@21
660 S_control_socket_params = 113, // control_socket_params
661 S_control_socket_param = 114, // control_socket_param
662 S_socket_type = 115, // socket_type
663 S_116_22 = 116, // $@22
664 S_socket_type_value = 117, // socket_type_value
665 S_socket_name = 118, // socket_name
666 S_119_23 = 119, // $@23
667 S_socket_url = 120, // socket_url
668 S_121_24 = 121, // $@24
669 S_loggers = 122, // loggers
670 S_123_25 = 123, // $@25
671 S_loggers_entries = 124, // loggers_entries
672 S_logger_entry = 125, // logger_entry
673 S_126_26 = 126, // $@26
674 S_logger_params = 127, // logger_params
675 S_logger_param = 128, // logger_param
676 S_name = 129, // name
677 S_130_27 = 130, // $@27
678 S_debuglevel = 131, // debuglevel
679 S_severity = 132, // severity
680 S_133_28 = 133, // $@28
681 S_output_options_list = 134, // output_options_list
682 S_135_29 = 135, // $@29
683 S_output_options_list_content = 136, // output_options_list_content
684 S_output_entry = 137, // output_entry
685 S_138_30 = 138, // $@30
686 S_output_params_list = 139, // output_params_list
687 S_output_params = 140, // output_params
688 S_output = 141, // output
689 S_142_31 = 142, // $@31
690 S_flush = 143, // flush
691 S_maxsize = 144, // maxsize
692 S_maxver = 145, // maxver
693 S_pattern = 146, // pattern
694 S_147_32 = 147 // $@32
695 };
696 };
697
700
703
710 template <typename Base>
711 struct basic_symbol : Base
712 {
714 typedef Base super_type;
715
718 : value ()
719 , location ()
720 {}
721
722#if 201103L <= YY_CPLUSPLUS
725 : Base (std::move (that))
726 , value ()
727 , location (std::move (that.location))
728 {
729 switch (this->kind ())
730 {
731 case symbol_kind::S_value: // value
732 case symbol_kind::S_map_value: // map_value
733 case symbol_kind::S_socket_type_value: // socket_type_value
734 value.move< ElementPtr > (std::move (that.value));
735 break;
736
737 case symbol_kind::S_BOOLEAN: // "boolean"
738 value.move< bool > (std::move (that.value));
739 break;
740
741 case symbol_kind::S_FLOAT: // "floating point"
742 value.move< double > (std::move (that.value));
743 break;
744
745 case symbol_kind::S_INTEGER: // "integer"
746 value.move< int64_t > (std::move (that.value));
747 break;
748
749 case symbol_kind::S_STRING: // "constant string"
750 value.move< std::string > (std::move (that.value));
751 break;
752
753 default:
754 break;
755 }
756
757 }
758#endif
759
761 basic_symbol (const basic_symbol& that);
762
764#if 201103L <= YY_CPLUSPLUS
765 basic_symbol (typename Base::kind_type t, location_type&& l)
766 : Base (t)
767 , location (std::move (l))
768 {}
769#else
770 basic_symbol (typename Base::kind_type t, const location_type& l)
771 : Base (t)
772 , location (l)
773 {}
774#endif
775
776#if 201103L <= YY_CPLUSPLUS
777 basic_symbol (typename Base::kind_type t, ElementPtr&& v, location_type&& l)
778 : Base (t)
779 , value (std::move (v))
780 , location (std::move (l))
781 {}
782#else
783 basic_symbol (typename Base::kind_type t, const ElementPtr& v, const location_type& l)
784 : Base (t)
785 , value (v)
786 , location (l)
787 {}
788#endif
789
790#if 201103L <= YY_CPLUSPLUS
791 basic_symbol (typename Base::kind_type t, bool&& v, location_type&& l)
792 : Base (t)
793 , value (std::move (v))
794 , location (std::move (l))
795 {}
796#else
797 basic_symbol (typename Base::kind_type t, const bool& v, const location_type& l)
798 : Base (t)
799 , value (v)
800 , location (l)
801 {}
802#endif
803
804#if 201103L <= YY_CPLUSPLUS
805 basic_symbol (typename Base::kind_type t, double&& v, location_type&& l)
806 : Base (t)
807 , value (std::move (v))
808 , location (std::move (l))
809 {}
810#else
811 basic_symbol (typename Base::kind_type t, const double& v, const location_type& l)
812 : Base (t)
813 , value (v)
814 , location (l)
815 {}
816#endif
817
818#if 201103L <= YY_CPLUSPLUS
819 basic_symbol (typename Base::kind_type t, int64_t&& v, location_type&& l)
820 : Base (t)
821 , value (std::move (v))
822 , location (std::move (l))
823 {}
824#else
825 basic_symbol (typename Base::kind_type t, const int64_t& v, const location_type& l)
826 : Base (t)
827 , value (v)
828 , location (l)
829 {}
830#endif
831
832#if 201103L <= YY_CPLUSPLUS
833 basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l)
834 : Base (t)
835 , value (std::move (v))
836 , location (std::move (l))
837 {}
838#else
839 basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l)
840 : Base (t)
841 , value (v)
842 , location (l)
843 {}
844#endif
845
848 {
849 clear ();
850 }
851
854 {
855 // User destructor.
856 symbol_kind_type yykind = this->kind ();
857 basic_symbol<Base>& yysym = *this;
858 (void) yysym;
859 switch (yykind)
860 {
861 default:
862 break;
863 }
864
865 // Value type destructor.
866switch (yykind)
867 {
868 case symbol_kind::S_value: // value
869 case symbol_kind::S_map_value: // map_value
870 case symbol_kind::S_socket_type_value: // socket_type_value
871 value.template destroy< ElementPtr > ();
872 break;
873
874 case symbol_kind::S_BOOLEAN: // "boolean"
875 value.template destroy< bool > ();
876 break;
877
878 case symbol_kind::S_FLOAT: // "floating point"
879 value.template destroy< double > ();
880 break;
881
882 case symbol_kind::S_INTEGER: // "integer"
883 value.template destroy< int64_t > ();
884 break;
885
886 case symbol_kind::S_STRING: // "constant string"
887 value.template destroy< std::string > ();
888 break;
889
890 default:
891 break;
892 }
893
894 Base::clear ();
895 }
896
898 std::string name () const YY_NOEXCEPT
899 {
900 return NetconfParser::symbol_name (this->kind ());
901 }
902
904 symbol_kind_type type_get () const YY_NOEXCEPT;
905
907 bool empty () const YY_NOEXCEPT;
908
910 void move (basic_symbol& s);
911
914
917
918 private:
919#if YY_CPLUSPLUS < 201103L
921 basic_symbol& operator= (const basic_symbol& that);
922#endif
923 };
924
926 struct by_kind
927 {
929 by_kind ();
930
931#if 201103L <= YY_CPLUSPLUS
933 by_kind (by_kind&& that);
934#endif
935
937 by_kind (const by_kind& that);
938
941
943 by_kind (kind_type t);
944
946 void clear () YY_NOEXCEPT;
947
949 void move (by_kind& that);
950
953 symbol_kind_type kind () const YY_NOEXCEPT;
954
956 symbol_kind_type type_get () const YY_NOEXCEPT;
957
961 };
962
965
968 {
971
974
976#if 201103L <= YY_CPLUSPLUS
977 symbol_type (int tok, location_type l)
978 : super_type(token_type (tok), std::move (l))
979#else
980 symbol_type (int tok, const location_type& l)
981 : super_type(token_type (tok), l)
982#endif
983 {
986 }
987#if 201103L <= YY_CPLUSPLUS
988 symbol_type (int tok, bool v, location_type l)
989 : super_type(token_type (tok), std::move (v), std::move (l))
990#else
991 symbol_type (int tok, const bool& v, const location_type& l)
992 : super_type(token_type (tok), v, l)
993#endif
994 {
996 }
997#if 201103L <= YY_CPLUSPLUS
998 symbol_type (int tok, double v, location_type l)
999 : super_type(token_type (tok), std::move (v), std::move (l))
1000#else
1001 symbol_type (int tok, const double& v, const location_type& l)
1002 : super_type(token_type (tok), v, l)
1003#endif
1004 {
1006 }
1007#if 201103L <= YY_CPLUSPLUS
1008 symbol_type (int tok, int64_t v, location_type l)
1009 : super_type(token_type (tok), std::move (v), std::move (l))
1010#else
1011 symbol_type (int tok, const int64_t& v, const location_type& l)
1012 : super_type(token_type (tok), v, l)
1013#endif
1014 {
1016 }
1017#if 201103L <= YY_CPLUSPLUS
1018 symbol_type (int tok, std::string v, location_type l)
1019 : super_type(token_type (tok), std::move (v), std::move (l))
1020#else
1021 symbol_type (int tok, const std::string& v, const location_type& l)
1022 : super_type(token_type (tok), v, l)
1023#endif
1024 {
1026 }
1027 };
1028
1031 virtual ~NetconfParser ();
1032
1033#if 201103L <= YY_CPLUSPLUS
1035 NetconfParser (const NetconfParser&) = delete;
1037 NetconfParser& operator= (const NetconfParser&) = delete;
1038#endif
1039
1042 int operator() ();
1043
1046 virtual int parse ();
1047
1048#if NETCONF_DEBUG
1050 std::ostream& debug_stream () const YY_ATTRIBUTE_PURE;
1052 void set_debug_stream (std::ostream &);
1053
1055 typedef int debug_level_type;
1060#endif
1061
1065 virtual void error (const location_type& loc, const std::string& msg);
1066
1068 void error (const syntax_error& err);
1069
1072 static std::string symbol_name (symbol_kind_type yysymbol);
1073
1074 // Implementation of make_symbol for each symbol type.
1075#if 201103L <= YY_CPLUSPLUS
1076 static
1079 {
1080 return symbol_type (token::TOKEN_END, std::move (l));
1081 }
1082#else
1083 static
1084 symbol_type
1086 {
1087 return symbol_type (token::TOKEN_END, l);
1088 }
1089#endif
1090#if 201103L <= YY_CPLUSPLUS
1091 static
1092 symbol_type
1094 {
1095 return symbol_type (token::TOKEN_NETCONF_error, std::move (l));
1096 }
1097#else
1098 static
1099 symbol_type
1101 {
1103 }
1104#endif
1105#if 201103L <= YY_CPLUSPLUS
1106 static
1107 symbol_type
1109 {
1110 return symbol_type (token::TOKEN_NETCONF_UNDEF, std::move (l));
1111 }
1112#else
1113 static
1114 symbol_type
1116 {
1118 }
1119#endif
1120#if 201103L <= YY_CPLUSPLUS
1121 static
1122 symbol_type
1124 {
1125 return symbol_type (token::TOKEN_COMMA, std::move (l));
1126 }
1127#else
1128 static
1129 symbol_type
1131 {
1132 return symbol_type (token::TOKEN_COMMA, l);
1133 }
1134#endif
1135#if 201103L <= YY_CPLUSPLUS
1136 static
1137 symbol_type
1139 {
1140 return symbol_type (token::TOKEN_COLON, std::move (l));
1141 }
1142#else
1143 static
1144 symbol_type
1146 {
1147 return symbol_type (token::TOKEN_COLON, l);
1148 }
1149#endif
1150#if 201103L <= YY_CPLUSPLUS
1151 static
1152 symbol_type
1154 {
1155 return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
1156 }
1157#else
1158 static
1159 symbol_type
1161 {
1163 }
1164#endif
1165#if 201103L <= YY_CPLUSPLUS
1166 static
1167 symbol_type
1169 {
1170 return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
1171 }
1172#else
1173 static
1174 symbol_type
1176 {
1178 }
1179#endif
1180#if 201103L <= YY_CPLUSPLUS
1181 static
1182 symbol_type
1184 {
1185 return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
1186 }
1187#else
1188 static
1189 symbol_type
1191 {
1193 }
1194#endif
1195#if 201103L <= YY_CPLUSPLUS
1196 static
1197 symbol_type
1199 {
1200 return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
1201 }
1202#else
1203 static
1204 symbol_type
1206 {
1208 }
1209#endif
1210#if 201103L <= YY_CPLUSPLUS
1211 static
1212 symbol_type
1214 {
1215 return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
1216 }
1217#else
1218 static
1219 symbol_type
1221 {
1223 }
1224#endif
1225#if 201103L <= YY_CPLUSPLUS
1226 static
1227 symbol_type
1229 {
1230 return symbol_type (token::TOKEN_NETCONF, std::move (l));
1231 }
1232#else
1233 static
1234 symbol_type
1236 {
1238 }
1239#endif
1240#if 201103L <= YY_CPLUSPLUS
1241 static
1242 symbol_type
1244 {
1245 return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
1246 }
1247#else
1248 static
1249 symbol_type
1251 {
1253 }
1254#endif
1255#if 201103L <= YY_CPLUSPLUS
1256 static
1257 symbol_type
1259 {
1260 return symbol_type (token::TOKEN_COMMENT, std::move (l));
1261 }
1262#else
1263 static
1264 symbol_type
1266 {
1268 }
1269#endif
1270#if 201103L <= YY_CPLUSPLUS
1271 static
1272 symbol_type
1274 {
1275 return symbol_type (token::TOKEN_BOOT_UPDATE, std::move (l));
1276 }
1277#else
1278 static
1279 symbol_type
1281 {
1283 }
1284#endif
1285#if 201103L <= YY_CPLUSPLUS
1286 static
1287 symbol_type
1289 {
1290 return symbol_type (token::TOKEN_SUBSCRIBE_CHANGES, std::move (l));
1291 }
1292#else
1293 static
1294 symbol_type
1296 {
1298 }
1299#endif
1300#if 201103L <= YY_CPLUSPLUS
1301 static
1302 symbol_type
1304 {
1305 return symbol_type (token::TOKEN_VALIDATE_CHANGES, std::move (l));
1306 }
1307#else
1308 static
1309 symbol_type
1311 {
1313 }
1314#endif
1315#if 201103L <= YY_CPLUSPLUS
1316 static
1317 symbol_type
1319 {
1320 return symbol_type (token::TOKEN_MANAGED_SERVERS, std::move (l));
1321 }
1322#else
1323 static
1324 symbol_type
1326 {
1328 }
1329#endif
1330#if 201103L <= YY_CPLUSPLUS
1331 static
1332 symbol_type
1334 {
1335 return symbol_type (token::TOKEN_DHCP4_SERVER, std::move (l));
1336 }
1337#else
1338 static
1339 symbol_type
1341 {
1343 }
1344#endif
1345#if 201103L <= YY_CPLUSPLUS
1346 static
1347 symbol_type
1349 {
1350 return symbol_type (token::TOKEN_DHCP6_SERVER, std::move (l));
1351 }
1352#else
1353 static
1354 symbol_type
1356 {
1358 }
1359#endif
1360#if 201103L <= YY_CPLUSPLUS
1361 static
1362 symbol_type
1364 {
1365 return symbol_type (token::TOKEN_D2_SERVER, std::move (l));
1366 }
1367#else
1368 static
1369 symbol_type
1371 {
1373 }
1374#endif
1375#if 201103L <= YY_CPLUSPLUS
1376 static
1377 symbol_type
1379 {
1380 return symbol_type (token::TOKEN_CA_SERVER, std::move (l));
1381 }
1382#else
1383 static
1384 symbol_type
1386 {
1388 }
1389#endif
1390#if 201103L <= YY_CPLUSPLUS
1391 static
1392 symbol_type
1394 {
1395 return symbol_type (token::TOKEN_MODEL, std::move (l));
1396 }
1397#else
1398 static
1399 symbol_type
1401 {
1402 return symbol_type (token::TOKEN_MODEL, l);
1403 }
1404#endif
1405#if 201103L <= YY_CPLUSPLUS
1406 static
1407 symbol_type
1409 {
1410 return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
1411 }
1412#else
1413 static
1414 symbol_type
1416 {
1418 }
1419#endif
1420#if 201103L <= YY_CPLUSPLUS
1421 static
1422 symbol_type
1424 {
1425 return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
1426 }
1427#else
1428 static
1429 symbol_type
1431 {
1433 }
1434#endif
1435#if 201103L <= YY_CPLUSPLUS
1436 static
1437 symbol_type
1439 {
1440 return symbol_type (token::TOKEN_UNIX, std::move (l));
1441 }
1442#else
1443 static
1444 symbol_type
1446 {
1447 return symbol_type (token::TOKEN_UNIX, l);
1448 }
1449#endif
1450#if 201103L <= YY_CPLUSPLUS
1451 static
1452 symbol_type
1454 {
1455 return symbol_type (token::TOKEN_HTTP, std::move (l));
1456 }
1457#else
1458 static
1459 symbol_type
1461 {
1462 return symbol_type (token::TOKEN_HTTP, l);
1463 }
1464#endif
1465#if 201103L <= YY_CPLUSPLUS
1466 static
1467 symbol_type
1469 {
1470 return symbol_type (token::TOKEN_STDOUT, std::move (l));
1471 }
1472#else
1473 static
1474 symbol_type
1476 {
1477 return symbol_type (token::TOKEN_STDOUT, l);
1478 }
1479#endif
1480#if 201103L <= YY_CPLUSPLUS
1481 static
1482 symbol_type
1484 {
1485 return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
1486 }
1487#else
1488 static
1489 symbol_type
1491 {
1493 }
1494#endif
1495#if 201103L <= YY_CPLUSPLUS
1496 static
1497 symbol_type
1499 {
1500 return symbol_type (token::TOKEN_SOCKET_URL, std::move (l));
1501 }
1502#else
1503 static
1504 symbol_type
1506 {
1508 }
1509#endif
1510#if 201103L <= YY_CPLUSPLUS
1511 static
1512 symbol_type
1514 {
1515 return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
1516 }
1517#else
1518 static
1519 symbol_type
1521 {
1523 }
1524#endif
1525#if 201103L <= YY_CPLUSPLUS
1526 static
1527 symbol_type
1529 {
1530 return symbol_type (token::TOKEN_LIBRARY, std::move (l));
1531 }
1532#else
1533 static
1534 symbol_type
1536 {
1538 }
1539#endif
1540#if 201103L <= YY_CPLUSPLUS
1541 static
1542 symbol_type
1544 {
1545 return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
1546 }
1547#else
1548 static
1549 symbol_type
1551 {
1553 }
1554#endif
1555#if 201103L <= YY_CPLUSPLUS
1556 static
1557 symbol_type
1559 {
1560 return symbol_type (token::TOKEN_LOGGERS, std::move (l));
1561 }
1562#else
1563 static
1564 symbol_type
1566 {
1568 }
1569#endif
1570#if 201103L <= YY_CPLUSPLUS
1571 static
1572 symbol_type
1574 {
1575 return symbol_type (token::TOKEN_NAME, std::move (l));
1576 }
1577#else
1578 static
1579 symbol_type
1581 {
1582 return symbol_type (token::TOKEN_NAME, l);
1583 }
1584#endif
1585#if 201103L <= YY_CPLUSPLUS
1586 static
1587 symbol_type
1589 {
1590 return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
1591 }
1592#else
1593 static
1594 symbol_type
1596 {
1598 }
1599#endif
1600#if 201103L <= YY_CPLUSPLUS
1601 static
1602 symbol_type
1604 {
1605 return symbol_type (token::TOKEN_OUTPUT, std::move (l));
1606 }
1607#else
1608 static
1609 symbol_type
1611 {
1612 return symbol_type (token::TOKEN_OUTPUT, l);
1613 }
1614#endif
1615#if 201103L <= YY_CPLUSPLUS
1616 static
1617 symbol_type
1619 {
1620 return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
1621 }
1622#else
1623 static
1624 symbol_type
1626 {
1628 }
1629#endif
1630#if 201103L <= YY_CPLUSPLUS
1631 static
1632 symbol_type
1634 {
1635 return symbol_type (token::TOKEN_SEVERITY, std::move (l));
1636 }
1637#else
1638 static
1639 symbol_type
1641 {
1643 }
1644#endif
1645#if 201103L <= YY_CPLUSPLUS
1646 static
1647 symbol_type
1649 {
1650 return symbol_type (token::TOKEN_FLUSH, std::move (l));
1651 }
1652#else
1653 static
1654 symbol_type
1656 {
1657 return symbol_type (token::TOKEN_FLUSH, l);
1658 }
1659#endif
1660#if 201103L <= YY_CPLUSPLUS
1661 static
1662 symbol_type
1664 {
1665 return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
1666 }
1667#else
1668 static
1669 symbol_type
1671 {
1673 }
1674#endif
1675#if 201103L <= YY_CPLUSPLUS
1676 static
1677 symbol_type
1679 {
1680 return symbol_type (token::TOKEN_MAXVER, std::move (l));
1681 }
1682#else
1683 static
1684 symbol_type
1686 {
1687 return symbol_type (token::TOKEN_MAXVER, l);
1688 }
1689#endif
1690#if 201103L <= YY_CPLUSPLUS
1691 static
1692 symbol_type
1694 {
1695 return symbol_type (token::TOKEN_PATTERN, std::move (l));
1696 }
1697#else
1698 static
1699 symbol_type
1701 {
1703 }
1704#endif
1705#if 201103L <= YY_CPLUSPLUS
1706 static
1707 symbol_type
1709 {
1710 return symbol_type (token::TOKEN_START_JSON, std::move (l));
1711 }
1712#else
1713 static
1714 symbol_type
1716 {
1718 }
1719#endif
1720#if 201103L <= YY_CPLUSPLUS
1721 static
1722 symbol_type
1724 {
1725 return symbol_type (token::TOKEN_START_NETCONF, std::move (l));
1726 }
1727#else
1728 static
1729 symbol_type
1731 {
1733 }
1734#endif
1735#if 201103L <= YY_CPLUSPLUS
1736 static
1737 symbol_type
1739 {
1740 return symbol_type (token::TOKEN_START_SUB_NETCONF, std::move (l));
1741 }
1742#else
1743 static
1744 symbol_type
1746 {
1748 }
1749#endif
1750#if 201103L <= YY_CPLUSPLUS
1751 static
1752 symbol_type
1753 make_STRING (std::string v, location_type l)
1754 {
1755 return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
1756 }
1757#else
1758 static
1759 symbol_type
1760 make_STRING (const std::string& v, const location_type& l)
1761 {
1762 return symbol_type (token::TOKEN_STRING, v, l);
1763 }
1764#endif
1765#if 201103L <= YY_CPLUSPLUS
1766 static
1767 symbol_type
1768 make_INTEGER (int64_t v, location_type l)
1769 {
1770 return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
1771 }
1772#else
1773 static
1774 symbol_type
1775 make_INTEGER (const int64_t& v, const location_type& l)
1776 {
1777 return symbol_type (token::TOKEN_INTEGER, v, l);
1778 }
1779#endif
1780#if 201103L <= YY_CPLUSPLUS
1781 static
1782 symbol_type
1783 make_FLOAT (double v, location_type l)
1784 {
1785 return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
1786 }
1787#else
1788 static
1789 symbol_type
1790 make_FLOAT (const double& v, const location_type& l)
1791 {
1792 return symbol_type (token::TOKEN_FLOAT, v, l);
1793 }
1794#endif
1795#if 201103L <= YY_CPLUSPLUS
1796 static
1797 symbol_type
1798 make_BOOLEAN (bool v, location_type l)
1799 {
1800 return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
1801 }
1802#else
1803 static
1804 symbol_type
1805 make_BOOLEAN (const bool& v, const location_type& l)
1806 {
1807 return symbol_type (token::TOKEN_BOOLEAN, v, l);
1808 }
1809#endif
1810
1811
1813 {
1814 public:
1815 context (const NetconfParser& yyparser, const symbol_type& yyla);
1816 const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; }
1817 symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); }
1818 const location_type& location () const YY_NOEXCEPT { return yyla_.location; }
1819
1823 int expected_tokens (symbol_kind_type yyarg[], int yyargn) const;
1824
1825 private:
1826 const NetconfParser& yyparser_;
1827 const symbol_type& yyla_;
1828 };
1829
1830 private:
1831#if YY_CPLUSPLUS < 201103L
1835 NetconfParser& operator= (const NetconfParser&);
1836#endif
1837
1838
1840 typedef short state_type;
1841
1843 int yy_syntax_error_arguments_ (const context& yyctx,
1844 symbol_kind_type yyarg[], int yyargn) const;
1845
1848 virtual std::string yysyntax_error_ (const context& yyctx) const;
1852 static state_type yy_lr_goto_state_ (state_type yystate, int yysym);
1853
1856 static bool yy_pact_value_is_default_ (int yyvalue);
1857
1860 static bool yy_table_value_is_error_ (int yyvalue);
1861
1862 static const signed char yypact_ninf_;
1863 static const signed char yytable_ninf_;
1864
1868 static symbol_kind_type yytranslate_ (int t);
1869
1871 static std::string yytnamerr_ (const char *yystr);
1872
1874 static const char* const yytname_[];
1875
1876
1877 // Tables.
1878 // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1879 // STATE-NUM.
1880 static const short yypact_[];
1881
1882 // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1883 // Performed when YYTABLE does not specify something else to do. Zero
1884 // means the default is an error.
1885 static const unsigned char yydefact_[];
1886
1887 // YYPGOTO[NTERM-NUM].
1888 static const short yypgoto_[];
1889
1890 // YYDEFGOTO[NTERM-NUM].
1891 static const short yydefgoto_[];
1892
1893 // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1894 // positive, shift that token. If negative, reduce the rule whose
1895 // number is the opposite. If YYTABLE_NINF, syntax error.
1896 static const short yytable_[];
1897
1898 static const short yycheck_[];
1899
1900 // YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1901 // symbol of state STATE-NUM.
1902 static const unsigned char yystos_[];
1903
1904 // YYR1[YYN] -- Symbol number of symbol that rule YYN derives.
1905 static const unsigned char yyr1_[];
1906
1907 // YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.
1908 static const signed char yyr2_[];
1909
1910
1911#if NETCONF_DEBUG
1912 // YYRLINE[YYN] -- Source line where rule number YYN was defined.
1913 static const short yyrline_[];
1915 virtual void yy_reduce_print_ (int r) const;
1917 virtual void yy_stack_print_ () const;
1918
1920 int yydebug_;
1922 std::ostream* yycdebug_;
1923
1927 template <typename Base>
1928 void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
1929#endif
1930
1935 template <typename Base>
1936 void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
1937
1938 private:
1940 struct by_state
1941 {
1943 by_state () YY_NOEXCEPT;
1944
1946 typedef state_type kind_type;
1947
1949 by_state (kind_type s) YY_NOEXCEPT;
1950
1952 by_state (const by_state& that) YY_NOEXCEPT;
1953
1955 void clear () YY_NOEXCEPT;
1956
1958 void move (by_state& that);
1959
1962 symbol_kind_type kind () const YY_NOEXCEPT;
1963
1966 enum { empty_state = 0 };
1967
1970 state_type state;
1971 };
1972
1974 struct stack_symbol_type : basic_symbol<by_state>
1975 {
1977 typedef basic_symbol<by_state> super_type;
1979 stack_symbol_type ();
1981 stack_symbol_type (YY_RVREF (stack_symbol_type) that);
1983 stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym);
1984#if YY_CPLUSPLUS < 201103L
1987 stack_symbol_type& operator= (stack_symbol_type& that);
1988
1991 stack_symbol_type& operator= (const stack_symbol_type& that);
1992#endif
1993 };
1994
1996 template <typename T, typename S = std::vector<T> >
1997 class stack
1998 {
1999 public:
2000 // Hide our reversed order.
2001 typedef typename S::iterator iterator;
2002 typedef typename S::const_iterator const_iterator;
2003 typedef typename S::size_type size_type;
2004 typedef typename std::ptrdiff_t index_type;
2005
2006 stack (size_type n = 200)
2007 : seq_ (n)
2008 {}
2009
2010#if 201103L <= YY_CPLUSPLUS
2012 stack (const stack&) = delete;
2014 stack& operator= (const stack&) = delete;
2015#endif
2016
2020 const T&
2021 operator[] (index_type i) const
2022 {
2023 return seq_[size_type (size () - 1 - i)];
2024 }
2025
2029 T&
2030 operator[] (index_type i)
2031 {
2032 return seq_[size_type (size () - 1 - i)];
2033 }
2034
2038 void
2039 push (YY_MOVE_REF (T) t)
2040 {
2041 seq_.push_back (T ());
2042 operator[] (0).move (t);
2043 }
2044
2046 void
2047 pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
2048 {
2049 for (; 0 < n; --n)
2050 seq_.pop_back ();
2051 }
2052
2054 void
2055 clear () YY_NOEXCEPT
2056 {
2057 seq_.clear ();
2058 }
2059
2061 index_type
2062 size () const YY_NOEXCEPT
2063 {
2064 return index_type (seq_.size ());
2065 }
2066
2068 const_iterator
2069 begin () const YY_NOEXCEPT
2070 {
2071 return seq_.begin ();
2072 }
2073
2075 const_iterator
2076 end () const YY_NOEXCEPT
2077 {
2078 return seq_.end ();
2079 }
2080
2082 class slice
2083 {
2084 public:
2085 slice (const stack& stack, index_type range)
2086 : stack_ (stack)
2087 , range_ (range)
2088 {}
2089
2090 const T&
2091 operator[] (index_type i) const
2092 {
2093 return stack_[range_ - i];
2094 }
2095
2096 private:
2097 const stack& stack_;
2098 index_type range_;
2099 };
2100
2101 private:
2102#if YY_CPLUSPLUS < 201103L
2104 stack (const stack&);
2106 stack& operator= (const stack&);
2107#endif
2109 S seq_;
2110 };
2111
2112
2114 typedef stack<stack_symbol_type> stack_type;
2115
2117 stack_type yystack_;
2118
2124 void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym);
2125
2132 void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym);
2133
2135 void yypop_ (int n = 1);
2136
2138 enum
2139 {
2140 yylast_ = 219,
2141 yynnts_ = 99,
2142 yyfinal_ = 8
2143 };
2144
2145
2146 // User arguments.
2148
2149 };
2150
2151 inline
2153 NetconfParser::yytranslate_ (int t)
2154 {
2155 // YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to
2156 // TOKEN-NUM as returned by yylex.
2157 static
2158 const signed char
2159 translate_table[] =
2160 {
2161 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2162 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2163 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2164 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2165 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2166 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2167 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2168 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2169 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2170 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2171 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2172 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2173 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2174 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2175 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2176 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2177 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2178 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2179 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2180 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2181 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2182 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2183 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2184 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2185 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2186 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
2187 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2188 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2189 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
2190 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
2191 45, 46, 47, 48
2192 };
2193 // Last valid token kind.
2194 const int code_max = 303;
2195
2196 if (t <= 0)
2197 return symbol_kind::S_YYEOF;
2198 else if (t <= code_max)
2199 return YY_CAST (symbol_kind_type, translate_table[t]);
2200 else
2202 }
2203
2204 // basic_symbol.
2205 template <typename Base>
2207 : Base (that)
2208 , value ()
2209 , location (that.location)
2210 {
2211 switch (this->kind ())
2212 {
2213 case symbol_kind::S_value: // value
2214 case symbol_kind::S_map_value: // map_value
2215 case symbol_kind::S_socket_type_value: // socket_type_value
2216 value.copy< ElementPtr > (YY_MOVE (that.value));
2217 break;
2218
2219 case symbol_kind::S_BOOLEAN: // "boolean"
2220 value.copy< bool > (YY_MOVE (that.value));
2221 break;
2222
2223 case symbol_kind::S_FLOAT: // "floating point"
2224 value.copy< double > (YY_MOVE (that.value));
2225 break;
2226
2227 case symbol_kind::S_INTEGER: // "integer"
2228 value.copy< int64_t > (YY_MOVE (that.value));
2229 break;
2230
2231 case symbol_kind::S_STRING: // "constant string"
2232 value.copy< std::string > (YY_MOVE (that.value));
2233 break;
2234
2235 default:
2236 break;
2237 }
2238
2239 }
2240
2241
2242
2243 template <typename Base>
2246 {
2247 return this->kind ();
2248 }
2249
2250 template <typename Base>
2251 bool
2253 {
2254 return this->kind () == symbol_kind::S_YYEMPTY;
2255 }
2256
2257 template <typename Base>
2258 void
2260 {
2261 super_type::move (s);
2262 switch (this->kind ())
2263 {
2264 case symbol_kind::S_value: // value
2265 case symbol_kind::S_map_value: // map_value
2266 case symbol_kind::S_socket_type_value: // socket_type_value
2267 value.move< ElementPtr > (YY_MOVE (s.value));
2268 break;
2269
2270 case symbol_kind::S_BOOLEAN: // "boolean"
2271 value.move< bool > (YY_MOVE (s.value));
2272 break;
2273
2274 case symbol_kind::S_FLOAT: // "floating point"
2275 value.move< double > (YY_MOVE (s.value));
2276 break;
2277
2278 case symbol_kind::S_INTEGER: // "integer"
2279 value.move< int64_t > (YY_MOVE (s.value));
2280 break;
2281
2282 case symbol_kind::S_STRING: // "constant string"
2283 value.move< std::string > (YY_MOVE (s.value));
2284 break;
2285
2286 default:
2287 break;
2288 }
2289
2290 location = YY_MOVE (s.location);
2291 }
2292
2293 // by_kind.
2294 inline
2296 : kind_ (symbol_kind::S_YYEMPTY)
2297 {}
2298
2299#if 201103L <= YY_CPLUSPLUS
2300 inline
2302 : kind_ (that.kind_)
2303 {
2304 that.clear ();
2305 }
2306#endif
2307
2308 inline
2310 : kind_ (that.kind_)
2311 {}
2312
2313 inline
2315 : kind_ (yytranslate_ (t))
2316 {}
2317
2318 inline
2319 void
2321 {
2322 kind_ = symbol_kind::S_YYEMPTY;
2323 }
2324
2325 inline
2326 void
2328 {
2329 kind_ = that.kind_;
2330 that.clear ();
2331 }
2332
2333 inline
2336 {
2337 return kind_;
2338 }
2339
2340 inline
2343 {
2344 return this->kind ();
2345 }
2346
2347#line 14 "netconf_parser.yy"
2348} } // isc::netconf
2349#line 2350 "netconf_parser.h"
2350
2351
2352
2353
2354#endif // !YY_NETCONF_NETCONF_PARSER_H_INCLUDED
const location_type & location() const YY_NOEXCEPT
symbol_kind_type token() const YY_NOEXCEPT
const symbol_type & lookahead() const YY_NOEXCEPT
A buffer to store and retrieve objects.
char yyraw[size]
A buffer large enough to store any of the semantic values.
semantic_type() YY_NOEXCEPT
Empty construction.
T & emplace(const T &t)
Instantiate a T in here from t.
const T & as() const YY_NOEXCEPT
Const accessor to a built T (for printer).
semantic_type self_type
Type of *this.
void move(self_type &that)
Move the content of that to this.
T & emplace()
Instantiate an empty T in here.
semantic_type(YY_RVREF(T) t)
Construct and fill.
void swap(self_type &that) YY_NOEXCEPT
Swap the content with that, of same type.
T & build()
Instantiate an empty T in here.
T & as() YY_NOEXCEPT
Accessor to a built T.
void copy(const self_type &that)
Copy the content of that to this.
T & build(const T &t)
Instantiate a T in here from t.
long double yyalign_me
Strongest alignment constraints.
~semantic_type() YY_NOEXCEPT
Destruction, allowed only if empty.
Present a slice of the top of a stack.
slice(const stack &stack, index_type range)
static symbol_type make_NETCONF(const location_type &l)
static symbol_type make_SOCKET_URL(const location_type &l)
static symbol_type make_MAXVER(const location_type &l)
static symbol_type make_OUTPUT_OPTIONS(const location_type &l)
static symbol_type make_MAXSIZE(const location_type &l)
static symbol_type make_INTEGER(const int64_t &v, const location_type &l)
virtual int parse()
Parse.
static symbol_type make_HOOKS_LIBRARIES(const location_type &l)
static symbol_type make_CONTROL_SOCKET(const location_type &l)
void set_debug_stream(std::ostream &)
Set the current debugging stream.
static symbol_type make_OUTPUT(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_BOOT_UPDATE(const location_type &l)
static symbol_type make_NETCONF_UNDEF(const location_type &l)
static symbol_type make_NULL_TYPE(const location_type &l)
static symbol_type make_DEBUGLEVEL(const location_type &l)
static symbol_type make_HTTP(const location_type &l)
static std::string symbol_name(symbol_kind_type yysymbol)
The user-facing name of the symbol whose (internal) number is YYSYMBOL.
static symbol_type make_VALIDATE_CHANGES(const location_type &l)
static symbol_type make_END(const location_type &l)
static symbol_type make_LIBRARY(const location_type &l)
static symbol_type make_LOGGERS(const location_type &l)
static symbol_type make_NETCONF_error(const location_type &l)
static symbol_type make_LCURLY_BRACKET(const location_type &l)
token::yytokentype token_kind_type
Token kind, as returned by yylex.
token_kind_type token_type
Backward compatibility alias (Bison 3.6).
NetconfParser(isc::netconf::ParserContext &ctx_yyarg)
Build a parser object.
static symbol_type make_STDOUT(const location_type &l)
virtual void error(const location_type &loc, const std::string &msg)
Report a syntax error.
static symbol_type make_SOCKET_TYPE(const location_type &l)
symbol_kind::symbol_kind_type symbol_kind_type
(Internal) symbol kind.
static symbol_type make_LSQUARE_BRACKET(const location_type &l)
static symbol_type make_DHCP4_SERVER(const location_type &l)
int debug_level_type
Type for debugging levels.
static symbol_type make_D2_SERVER(const location_type &l)
static symbol_type make_PARAMETERS(const location_type &l)
static symbol_type make_NAME(const location_type &l)
static symbol_type make_FLUSH(const location_type &l)
static symbol_type make_START_JSON(const location_type &l)
static symbol_type make_UNIX(const location_type &l)
static symbol_type make_PATTERN(const location_type &l)
static symbol_type make_STRING(const std::string &v, const location_type &l)
static const symbol_kind_type YYNTOKENS
The number of tokens.
static symbol_type make_COMMENT(const location_type &l)
static symbol_type make_SEVERITY(const location_type &l)
static symbol_type make_MANAGED_SERVERS(const location_type &l)
location location_type
Symbol locations.
static symbol_type make_SUBSCRIBE_CHANGES(const location_type &l)
static symbol_type make_CA_SERVER(const location_type &l)
static symbol_type make_COLON(const location_type &l)
static symbol_type make_RCURLY_BRACKET(const location_type &l)
void set_debug_level(debug_level_type l)
Set the current debugging level.
static symbol_type make_USER_CONTEXT(const location_type &l)
static symbol_type make_COMMA(const location_type &l)
static symbol_type make_RSQUARE_BRACKET(const location_type &l)
static symbol_type make_START_NETCONF(const location_type &l)
static symbol_type make_MODEL(const location_type &l)
debug_level_type debug_level() const YY_ATTRIBUTE_PURE
The current debugging level.
static symbol_type make_START_SUB_NETCONF(const location_type &l)
static symbol_type make_BOOLEAN(const bool &v, const location_type &l)
static symbol_type make_FLOAT(const double &v, const location_type &l)
static symbol_type make_SOCKET_NAME(const location_type &l)
Parser context is a wrapper around flex/bison instances dedicated to Netconf-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.
Forward declaration of the ParserContext class.
#define YY_RVREF(Type)
#define NETCONF__ASSERT
#define YY_CAST(Type, Val)
#define YY_MOVE_REF(Type)
#define YY_NOEXCEPT
#define YY_ATTRIBUTE_PURE
#define YY_MOVE
#define YY_NOTHROW
bool empty() const YY_NOEXCEPT
Whether empty.
basic_symbol(typename Base::kind_type t, const bool &v, const location_type &l)
semantic_type value
The semantic value.
basic_symbol(typename Base::kind_type t, const double &v, const location_type &l)
void move(basic_symbol &s)
Destructive move, s is emptied into this.
basic_symbol(typename Base::kind_type t, const ElementPtr &v, const location_type &l)
basic_symbol(typename Base::kind_type t, const location_type &l)
Constructors for typed symbols.
basic_symbol(typename Base::kind_type t, const std::string &v, const location_type &l)
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
basic_symbol(typename Base::kind_type t, const int64_t &v, const location_type &l)
std::string name() const YY_NOEXCEPT
The user-facing name of this symbol.
void clear() YY_NOEXCEPT
Destroy contents, and record that is empty.
Type access provider for token (enum) based symbols.
token_kind_type kind_type
The symbol kind as needed by the constructor.
symbol_kind_type type_get() const YY_NOEXCEPT
Backward compatibility (Bison 3.6).
symbol_kind_type kind() const YY_NOEXCEPT
The (internal) type number (corresponding to type).
symbol_kind_type kind_
The symbol kind.
void move(by_kind &that)
Steal the symbol kind from that.
void clear() YY_NOEXCEPT
Record that this symbol is empty.
"External" symbols: returned by the scanner.
basic_symbol< by_kind > super_type
Superclass.
Syntax errors thrown from user actions.
syntax_error(const location_type &l, const std::string &m)
token_kind_type yytokentype
Backward compatibility alias (Bison 3.6).