Skip to content
CppUtils
Welcome to the new CppUtils documentation!
import CppUtils.Language.Lexer;orimport CppUtils;

Functions & utilities

FUNCTIONS

Namespace: CppUtils::Language::Lexer

Public enums

Section titled “Public enums”

RecurrenceType

Section titled “RecurrenceType”
enum class RecurrenceType {
    Optional,
    EqualTo,
    MoreThan,
    MoreOrEqualTo
};

Public types

Section titled “Public types”

ParsingFunction

Section titled “ParsingFunction”
using CppUtils::Language::Lexer::ParsingFunction = typedef std::function<bool(Context<Types...>&)>;

BreakPointLexeme

Section titled “BreakPointLexeme”
using CppUtils::Language::Lexer::BreakPointLexeme = typedef Typed<BreakPointLexemeType, void>;

StringLexeme

Section titled “StringLexeme”
using CppUtils::Language::Lexer::StringLexeme = typedef Typed<StringLexemeType, std::string>;

ParserLexeme

Section titled “ParserLexeme”
using CppUtils::Language::Lexer::ParserLexeme = typedef Typed<ParserLexemeType, NamedParser<Types...> >;

TokenLexeme

Section titled “TokenLexeme”
using CppUtils::Language::Lexer::TokenLexeme = typedef Typed<TokenLexemeType, Type::Token>;

TagLexeme

Section titled “TagLexeme”
using CppUtils::Language::Lexer::TagLexeme = typedef Typed<TagLexemeType, std::unique_ptr<ILexeme> >;

MutedLexeme

Section titled “MutedLexeme”
using CppUtils::Language::Lexer::MutedLexeme = typedef Typed<MutedLexemeType, std::unique_ptr<ILexeme> >;

RecurrentLexeme

Section titled “RecurrentLexeme”
using CppUtils::Language::Lexer::RecurrentLexeme = typedef Typed<RecurrentLexemeType, Recurrence>;

AlternativeLexeme

Section titled “AlternativeLexeme”
using CppUtils::Language::Lexer::AlternativeLexeme = typedef Typed<AlternativeLexemeType, Alternative>;

ExcludeLexeme

Section titled “ExcludeLexeme”
using CppUtils::Language::Lexer::ExcludeLexeme = typedef Typed<ExcludeLexemeType, Exclusion>;

Public methods & functions

Section titled “Public methods & functions”
template <class Element = char>
auto parseLexeme(String::Cursor<std::basic_string_view<Element>> &cursor, std::reference_wrapper<Container::ASTNode<Element>> &parentNode, Container::AST<Element> &ast, const Container::ASTNode<Element> &lexeme, const Container::AST<Element> &grammar, std::vector<Container::ASTNode<Element>> &memory) -> bool;
template <class Element = char>
auto parseLexemes(String::Cursor<std::basic_string_view<Element>> &cursor, std::reference_wrapper<Container::ASTNode<Element>> &parentNode, Container::AST<Element> &ast, const Container::ASTNode<Element> &lexeme, const Container::AST<Element> &grammar, std::vector<Container::ASTNode<Element>> &memory) -> bool;
template <class Element = char>
auto parseDeclaration(String::Cursor<std::basic_string_view<Element>> &cursor, std::reference_wrapper<Container::ASTNode<Element>> &parentNode, Container::AST<Element> &ast, const Container::ASTNode<Element> &declaration, const Container::AST<Element> &grammar, std::vector<Container::ASTNode<Element>> &memory) -> bool;
template <class Element = char>
auto parseMultipleDeclaration(String::Cursor<std::basic_string_view<Element>> &cursor, std::reference_wrapper<Container::ASTNode<Element>> &parentNode, Container::AST<Element> &ast, const Container::ASTNode<Element> &declarationLexeme, const Container::AST<Element> &grammar, std::vector<Container::ASTNode<Element>> &memory) -> bool;
template <class CharT = char>
auto parse(std::basic_string_view<CharT> src, const Container::AST<CharT> &grammar) -> Container::AST<CharT>;
template <class TargetType>
auto ensureType(const std::unique_ptr<ILexeme> &lexeme) -> TargetType &;
template <class... Types>
NamedParser(std::string, ParsingFunction<Types...>) -> NamedParser<Types...>;
template <class... Types>
NamedParser(std::string, bool(Context<Types...> &)) -> NamedParser<Types...>;
template <class... Types>
auto spaceParser(Context<Types...> &context) -> bool;
template <class... Types>
or(std::same_as<std::string, Types> or ...) inline auto keywordParser(Context<Types...> &context) -> bool;
template <class... Types>
auto charParser(Context<Types...> &context) -> bool;
template <class... Types>
auto escapeCharParser(Context<Types...> &context) -> bool;
template <class... Types>
auto delimiterParser(Context<Types...> &context, std::string_view delimiter, std::type_identity_t<ParsingFunction<Types...>> contentParsingFunction, bool multipleContent, bool skipDelimiter) -> bool;
template <class... Types>
auto stringParser(Context<Types...> &context, std::string_view delimiter, bool skipDelimiter) -> bool;
template <class... Types>
auto uintParser(Context<Types...> &context) -> bool;
template <class... Types>
auto intParser(Context<Types...> &context) -> bool;
template <class... Types>
auto floatParser(Context<Types...> &context) -> bool;
template <class... Types>
auto booleanParser(Context<Types...> &context) -> bool;
template <class... Types>
auto trimModifier(Context<Types...> &context) -> bool;
template <class... Types>
and(std::same_as<Type::Token, Types> or ...) inline auto stringToTokenModifier(Context<Types...> &context) -> bool;

Constants & variables

Section titled “Constants & variables”

BreakPointLexemeType

Section titled “BreakPointLexemeType”
constexpr auto CppUtils::Language::Lexer::BreakPointLexemeType;

StringLexemeType

Section titled “StringLexemeType”
constexpr auto CppUtils::Language::Lexer::StringLexemeType;

ParserLexemeType

Section titled “ParserLexemeType”
constexpr auto CppUtils::Language::Lexer::ParserLexemeType;

TokenLexemeType

Section titled “TokenLexemeType”
constexpr auto CppUtils::Language::Lexer::TokenLexemeType;

TagLexemeType

Section titled “TagLexemeType”
constexpr auto CppUtils::Language::Lexer::TagLexemeType;

MutedLexemeType

Section titled “MutedLexemeType”
constexpr auto CppUtils::Language::Lexer::MutedLexemeType;

RecurrentLexemeType

Section titled “RecurrentLexemeType”
constexpr auto CppUtils::Language::Lexer::RecurrentLexemeType;

AlternativeLexemeType

Section titled “AlternativeLexemeType”
constexpr auto CppUtils::Language::Lexer::AlternativeLexemeType;

ExcludeLexemeType

Section titled “ExcludeLexemeType”
constexpr auto CppUtils::Language::Lexer::ExcludeLexemeType;