4 #ifndef LEXY_DSL_LITERAL_HPP_INCLUDED
5 #define LEXY_DSL_LITERAL_HPP_INCLUDED
18 template <std::size_t CurCharIndex,
typename CharT, CharT... Cs,
typename Reader>
22 if constexpr (CurCharIndex >=
sizeof...(Cs))
25 return std::true_type{};
28 else if constexpr (is_swar_reader<Reader> &&
sizeof...(Cs) >= swar_length<char_type>)
32 constexpr
auto pack = swar_pack<CurCharIndex>(transcode_char<char_type>(Cs)...);
35 if ((reader.peek_swar() & pack.mask) == pack.value)
37 reader.bump_swar(pack.count);
40 return bool(match_literal<CurCharIndex + pack.count, CharT, Cs...>(reader));
44 auto partial = swar_find_difference<CharT>(reader.peek_swar() & pack.mask, pack.value);
45 reader.bump_swar(partial);
51 static_assert(CurCharIndex == 0);
54 return ((reader.peek() == transcode_int<typename Reader::encoding>(Cs)
55 ? (reader.bump(),
true)
65 template <
typename Encoding,
template <
typename>
typename CaseFolding, std::size_t MaxCharCount,
66 typename... CharClasses>
72 template <
typename Reader>
98 template <
typename CharT>
101 auto c = transcode_char<char_type>(_c);
126 template <
typename CharT, CharT... C>
129 return ((pos =
insert(pos, C)), ...);
144 result.index[result.length] = i;
152 template <
typename... CharClasses>
155 template <
typename Encoding,
template <
typename>
typename CaseFolding, std::size_t N>
158 static constexpr
auto size =
sizeof...(CharClasses);
160 template <
typename... T>
167 template <
typename CurrentCaseFolding,
typename... Literals>
172 template <
typename Reader>
175 template <
typename CurrentCaseFolding>
178 template <
typename Reader>
179 using case_folding =
typename CurrentCaseFolding::template reader<Reader>;
181 template <
typename CurrentCaseFolding,
typename H,
typename... T>
184 typename H::lit_case_folding, CurrentCaseFolding>,
188 std::is_same_v<CurrentCaseFolding,
189 typename H::lit_case_folding>
190 || std::is_void_v<CurrentCaseFolding> || std::is_void_v<typename H::lit_case_folding>,
191 "cannot mix literals with different case foldings in a literal_set");
194 template <
typename Reader>
197 template <
typename Encoding,
typename... Literals>
200 constexpr
auto max_char_count = (0 + ... + Literals::lit_max_char_count);
203 constexpr
auto char_classes
207 return typename decltype(char_classes)::
template trie_type<
210 template <
typename Encoding,
typename... Literals>
211 using lit_trie_for = decltype(make_empty_trie<Encoding, Literals...>());
213 template <std::size_t CharClassIdx, bool,
typename...>
216 template <
typename Reader>
222 template <
typename H,
typename... T>
225 template <
typename Reader>
231 template <std::size_t Idx,
typename H,
typename... T>
234 template <std::size_t CharClassIdx,
typename... CharClasses>
238 template <const auto& Trie, std::
size_t CurNode>
240 template <
typename Encoding,
template <
typename>
typename CaseFolding, std::size_t N,
241 typename... CharClasses,
const lit_trie<Encoding, CaseFolding, N, CharClasses...>& Trie,
245 template <std::
size_t TransIdx,
typename Reader,
typename IntT>
249 static_assert(Trie.transition_from[TransIdx] == CurNode);
251 using encoding =
typename Reader::encoding;
252 constexpr
auto trans_char = Trie.transition_char[TransIdx];
253 if (cur != encoding::to_int_type(trans_char))
261 static constexpr
auto transitions = Trie.node_transitions(CurNode);
265 template <std::size_t... Idx>
268 template <
typename Reader>
271 constexpr
auto cur_value = Trie.node_value[CurNode];
273 if constexpr (
sizeof...(Idx) > 0)
275 auto cur_pos = reader.position();
276 auto cur_char = reader.peek();
278 auto next_value = Trie.node_no_match;
279 (
void)(_try_transition<transitions.index[Idx]>(next_value, reader, cur_char)
281 if (next_value != Trie.node_no_match)
286 reader.set_position(cur_pos);
290 constexpr
auto char_class = Trie.node_char_class[CurNode];
291 if constexpr (cur_value == Trie.node_no_match || char_class >=
sizeof...(CharClasses))
298 return Trie.node_no_match;
305 template <
typename Reader>
308 if constexpr (std::is_same_v<CaseFolding<Reader>, Reader>)
310 return _impl<>::try_match(_reader);
314 CaseFolding<Reader> reader{_reader};
315 auto result = _impl<>::try_match(reader);
316 _reader.set_position(reader.position());
326 template <
typename CharT, CharT... C>
328 : token_base<_lit<CharT, C...>,
329 std::conditional_t<sizeof...(C) == 0, unconditional_branch_base, branch_base>>,
336 template <
typename Encoding>
344 template <
typename Trie>
347 return ((pos = trie.insert(pos, C)), ...);
350 template <
typename Reader>
353 typename Reader::iterator
end;
360 end = reader.position();
364 template <
typename Context>
370 auto begin = reader.position();
381 template <
unsigned char... C>
385 template <lexy::_detail::
string_literal Str>
387 constexpr
auto lit = lexy::_detail::to_type_string<_lit, Str>{};
390 #define LEXY_LIT(Str) \
391 LEXY_NTTP_STRING(::lexyd::_lit, Str) {}
396 template <
typename CharT, CharT... C>
403 template <char32_t... Cp>
404 struct _lcp : token_base<_lcp<Cp...>>, _lit_base
406 template <
typename Encoding>
414 ((
length += lexy::_detail::encode_code_point<Encoding>(Cp,
data +
length, 4)), ...);
417 template <
typename Encoding>
424 template <
typename Encoding>
427 return _string<Encoding>.data[0];
430 template <
typename Trie>
433 using encoding =
typename Trie::encoding;
435 for (
auto i = 0u; i != _string<encoding>.length; ++i)
436 pos = trie.insert(pos, _string<encoding>.data[i]);
441 template <
typename Reader,
445 template <
typename Reader, std::size_t... Idx>
448 typename Reader::iterator
end;
454 using encoding =
typename Reader::encoding;
457 _string<encoding>.data[Idx]...>(reader);
458 end = reader.position();
462 template <
typename Context>
465 using encoding =
typename Reader::encoding;
467 auto begin = reader.position();
470 index, _string<encoding>.length);
476 template <char32_t... CodePoint>
482 template <char32_t... Cp>
489 template <
typename T,
template <
typename>
typename CaseFolding,
typename... Strings>
496 return "expected literal set";
503 template <
typename Literal,
template <
typename>
typename CaseFolding>
506 template <
template <
typename>
typename CaseFolding,
typename CharT, CharT... C>
509 if constexpr (std::is_same_v<CaseFolding<lexy::_pr8>, lexy::_pr8>)
510 return _lit<CharT, C...>{};
512 return _cfl<
_lit<CharT, C...>, CaseFolding>{};
515 template <
typename... Literals>
520 template <
typename Encoding>
525 [[maybe_unused]]
auto char_class = std::size_t(0);
526 ((result.node_value[Literals::lit_insert(result, 0, char_class)] = 0,
528 char_class += Literals::lit_char_classes.size),
533 template <
typename Encoding>
535 = _build_trie<Encoding>();
537 template <
typename Reader>
540 typename Reader::iterator
end;
546 using encoding =
typename Reader::encoding;
549 auto result = matcher::try_match(reader);
550 end = reader.position();
551 return result != _t<encoding>.node_no_match;
554 template <
typename Context>
563 template <
typename Lit>
566 if constexpr (lexy::is_literal_rule<Lit>)
568 return _lset<Literals..., Lit>{};
570 else if constexpr (
sizeof...(Literals) == 0)
573 static_assert(lexy::is_literal_set_rule<Lit>);
579 static_assert(lexy::is_literal_set_rule<Lit>);
580 return *
this /
typename Lit::as_lset{};
583 template <
typename... Lit>
586 return _lset<Literals..., Lit...>{};
591 template <
typename... Literals>
594 static_assert((lexy::is_literal_rule<Literals> && ...));
595 return _lset<Literals...>{};
599 template <
typename T,
template <
typename>
typename CaseFolding,
typename... Strings>
606 #define LEXY_LITERAL_SET(...) \
608 using impl = decltype(::lexyd::literal_set(__VA_ARGS__)); \
611 using impl::operator/; \
618 template <
typename... Literals>
622 #endif // LEXY_DSL_LITERAL_HPP_INCLUDED