blob: 964c1543a65b6872d2cfe10c2dabbaa3d4b1ca94 [file] [log] [blame]
Václav Kubernát9ae8cc42020-03-25 19:17:41 +01001/*
2 * Copyright (C) 2020 CESNET, https://photonics.cesnet.cz/
3 *
4 * Written by Václav Kubernát <kubernat@cesnet.cz>
5 *
6*/
7
8#pragma once
9
10#include <boost/spirit/home/x3.hpp>
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010011#include "ast_handlers.hpp"
12#include "common_parsers.hpp"
Václav Kubernát3a99f002020-03-31 02:27:41 +020013#include "leaf_data_type.hpp"
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010014#include "schema.hpp"
15namespace x3 = boost::spirit::x3;
16
Václav Kubernát3a99f002020-03-31 02:27:41 +020017template <typename TYPE>
Václav Kubernát882174d2020-03-25 21:31:46 +010018struct leaf_data_class;
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010019
Václav Kubernát3a99f002020-03-31 02:27:41 +020020x3::rule<struct leaf_data_class<yang::IdentityRef>, identityRef_> const leaf_data_identityRef = "leaf_data_identityRef";
21x3::rule<struct leaf_data_class<yang::Binary>, binary_> const leaf_data_binary = "leaf_data_binary";
22x3::rule<struct leaf_data_class<yang::Decimal>, double> const leaf_data_decimal = "leaf_data_decimal";
23x3::rule<struct leaf_data_class<yang::String>, std::string> const leaf_data_string = "leaf_data_string";
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010024
Václav Kubernát882174d2020-03-25 21:31:46 +010025using x3::char_;
26
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010027struct bool_symbol_table : x3::symbols<bool> {
28 bool_symbol_table()
29 {
Václav Kubernát3a99f002020-03-31 02:27:41 +020030 add
31 ("true", true)
32 ("false", false);
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010033 }
Václav Kubernát882174d2020-03-25 21:31:46 +010034} const bool_symbols;
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010035
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010036auto const leaf_data_string_def =
37 '\'' >> *(char_-'\'') >> '\'' |
38 '\"' >> *(char_-'\"') >> '\"';
39
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010040auto const leaf_data_binary_def =
Václav Kubernáte118f002020-05-14 22:54:13 +020041 as<std::string>[+(x3::alnum | char_('+') | char_('/')) >> -char_('=') >> -char_('=')];
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010042
Václav Kubernát9ae8cc42020-03-25 19:17:41 +010043auto const leaf_data_identityRef_def =
Václav Kubernáte7f62ae2020-05-14 22:57:53 +020044 -module >> node_identifier;
Václav Kubernát3a99f002020-03-31 02:27:41 +020045
46template <typename It, typename Ctx, typename RCtx, typename Attr>
47struct impl_LeafData {
48 It& first;
49 It last;
50 Ctx const& ctx;
51 RCtx& rctx;
52 Attr& attr;
53 ParserContext& parserContext;
54
55 bool operator()(const yang::Binary&) const
56 {
57 return leaf_data_binary.parse(first, last, ctx, rctx, attr);
58 }
59 bool operator()(const yang::Bool&) const
60 {
61 return bool_symbols.parse(first, last, ctx, rctx, attr);
62 }
63 bool operator()(const yang::Decimal&) const
64 {
65 return x3::double_.parse(first, last, ctx, rctx, attr);
66 }
67 bool operator()(const yang::Uint8&) const
68 {
69 return x3::uint8.parse(first, last, ctx, rctx, attr);
70 }
71 bool operator()(const yang::Uint16&) const
72 {
73 return x3::uint16.parse(first, last, ctx, rctx, attr);
74 }
75 bool operator()(const yang::Uint32&) const
76 {
77 return x3::uint32.parse(first, last, ctx, rctx, attr);
78 }
79 bool operator()(const yang::Uint64&) const
80 {
81 return x3::uint64.parse(first, last, ctx, rctx, attr);
82 }
83 bool operator()(const yang::Int8&) const
84 {
85 return x3::int8.parse(first, last, ctx, rctx, attr);
86 }
87 bool operator()(const yang::Int16&) const
88 {
89 return x3::int16.parse(first, last, ctx, rctx, attr);
90 }
91 bool operator()(const yang::Int32&) const
92 {
93 return x3::int32.parse(first, last, ctx, rctx, attr);
94 }
95 bool operator()(const yang::Int64&) const
96 {
97 return x3::int64.parse(first, last, ctx, rctx, attr);
98 }
99 bool operator()(const yang::String&) const
100 {
101 return leaf_data_string.parse(first, last, ctx, rctx, attr);
102 }
Jan Kundrát379bb572020-05-07 03:23:13 +0200103 bool operator()(const yang::Empty) const
104 {
105 return x3::attr(empty_{}).parse(first, last, ctx, rctx, attr);
106 }
Václav Kubernát3a99f002020-03-31 02:27:41 +0200107 template <typename Type>
108 void createSetSuggestions(const Type& type) const
109 {
110 parserContext.m_suggestions.clear();
111 std::transform(type.m_allowedValues.begin(),
112 type.m_allowedValues.end(),
113 std::inserter(parserContext.m_suggestions, parserContext.m_suggestions.end()),
Václav Kubernát549b08f2020-05-14 22:19:36 +0200114 [](auto it) {
115 std::string res;
116 if constexpr (std::is_same<Type, yang::IdentityRef>()) {
117 res = it.m_prefix ? it.m_prefix->m_name + ":" : "";
118 }
119 res += it.m_value;
120 return Completion{res};
121 });
Václav Kubernát3a99f002020-03-31 02:27:41 +0200122 parserContext.m_completionIterator = first;
123 }
124 bool operator()(const yang::Enum& type) const
125 {
126 createSetSuggestions(type);
Václav Kubernát0af72572020-07-22 15:15:59 +0200127 x3::symbols<enum_> parser;
128 for (const auto& value : type.m_allowedValues) {
129 parser.add(value.m_value, value);
130 }
131 auto res = parser.parse(first, last, ctx, rctx, attr);
132 if (!res) {
133 parserContext.m_errorMsg = "leaf data type mismatch: Expected an enum here. Allowed values:";
134 for (const auto& it : type.m_allowedValues) {
135 parserContext.m_errorMsg += " " + it.m_value;
Václav Kubernát3a99f002020-03-31 02:27:41 +0200136 }
Václav Kubernát0af72572020-07-22 15:15:59 +0200137 }
138 return res;
Václav Kubernát3a99f002020-03-31 02:27:41 +0200139 }
140 bool operator()(const yang::IdentityRef& type) const
141 {
142 createSetSuggestions(type);
Václav Kubernáta68c0ef2020-05-07 10:32:56 +0200143 auto checkValidIdentity = [this, type] (auto& ctx) {
144 identityRef_ pair{boost::get<identityRef_>(_attr(ctx))};
145 if (!pair.m_prefix) {
146 pair.m_prefix = module_{parserContext.currentSchemaPath().m_nodes.front().m_prefix.get().m_name};
147 }
148 _pass(ctx) = type.m_allowedValues.count(pair) != 0;
149 };
150
151 return leaf_data_identityRef[checkValidIdentity].parse(first, last, ctx, rctx, attr);
Václav Kubernát3a99f002020-03-31 02:27:41 +0200152 }
153 bool operator()(const yang::LeafRef& leafRef) const
154 {
Václav Kubernát13b23d72020-04-16 21:49:51 +0200155 return std::visit(*this, leafRef.m_targetType->m_type);
Václav Kubernát3a99f002020-03-31 02:27:41 +0200156 }
Václav Kubernátdab73ca2020-10-26 23:44:43 +0100157 bool operator()(const yang::Bits& bits) const
158 {
159 parserContext.m_suggestions.clear();
160 x3::symbols<std::string> parser;
161 for (const auto& bit : bits.m_allowedValues) {
162 parser.add(bit, bit);
163 parserContext.m_suggestions.insert(Completion{bit});
164 }
165
166 std::vector<std::string> bitsRes;
167
168 do {
169 std::string bit;
170 auto pass = parser.parse(first, last, ctx, rctx, bit);
171 if (pass) {
172 bitsRes.push_back(bit);
173 parser.remove(bit);
174 parserContext.m_suggestions.erase(Completion{bit});
175 }
176 } while (space_separator.parse(first, last, ctx, rctx, x3::unused));
177
178 attr = bits_{bitsRes};
179
180 return true;
181 }
Václav Kubernát2984f442020-02-20 17:43:35 +0100182 bool operator()(const yang::Union& unionInfo) const
183 {
184 return std::any_of(unionInfo.m_unionTypes.begin(), unionInfo.m_unionTypes.end(), [this](const auto& type) {
Václav Kubernát13b23d72020-04-16 21:49:51 +0200185 return std::visit(*this, type.m_type);
Václav Kubernát2984f442020-02-20 17:43:35 +0100186 });
187 }
Václav Kubernát3a99f002020-03-31 02:27:41 +0200188};
Václav Kubernát9ae8cc42020-03-25 19:17:41 +0100189
Václav Kubernát882174d2020-03-25 21:31:46 +0100190struct LeafData : x3::parser<LeafData> {
191 using attribute_type = leaf_data_;
Václav Kubernát9ae8cc42020-03-25 19:17:41 +0100192
Václav Kubernát882174d2020-03-25 21:31:46 +0100193 // TODO: Can this be placed in a .cpp file?
194 template <typename It, typename Ctx, typename RCtx, typename Attr>
195 bool parse(It& first, It last, Ctx const& ctx, RCtx& rctx, Attr& attr) const
196 {
197 ParserContext& parserContext = x3::get<parser_context_tag>(ctx);
198 const Schema& schema = parserContext.m_schema;
Václav Kubernát13b23d72020-04-16 21:49:51 +0200199 auto type = schema.leafType(parserContext.m_tmpListKeyLeafPath.m_location, parserContext.m_tmpListKeyLeafPath.m_node).m_type;
Václav Kubernát882174d2020-03-25 21:31:46 +0100200
Václav Kubernát3a99f002020-03-31 02:27:41 +0200201 auto pass = std::visit(impl_LeafData<It, Ctx, RCtx, Attr>{first, last, ctx, rctx, attr, parserContext}, type);
Václav Kubernát882174d2020-03-25 21:31:46 +0100202
203 if (!pass) {
204 if (parserContext.m_errorMsg.empty()) {
Václav Kubernát13b23d72020-04-16 21:49:51 +0200205 parserContext.m_errorMsg = "leaf data type mismatch: Expected " + leafDataTypeToString(type) + " here:";
Václav Kubernát882174d2020-03-25 21:31:46 +0100206 }
207 }
208 return pass;
209 }
210};
211
Václav Kubernátf92724b2020-07-08 17:58:22 +0200212auto const leaf_data = x3::no_skip[LeafData()];
Václav Kubernát882174d2020-03-25 21:31:46 +0100213
Václav Kubernát9ae8cc42020-03-25 19:17:41 +0100214BOOST_SPIRIT_DEFINE(leaf_data_string)
Václav Kubernát9ae8cc42020-03-25 19:17:41 +0100215BOOST_SPIRIT_DEFINE(leaf_data_binary)
Václav Kubernát9ae8cc42020-03-25 19:17:41 +0100216BOOST_SPIRIT_DEFINE(leaf_data_identityRef)