#include </home/runner/work/docs/docs/LMCAS/src/internal/expr_parser.hpp>

LMCAS::ExprParser 的协作图:

Public 成员函数
	ExprParser (std::string source)
ExprResult	parse ()

Private 成员函数
ExprResult	apply_atan2 (const std::vector< ExprPtr > &arguments)
ExprResult	apply_clamp (const std::vector< ExprPtr > &arguments)
ExprResult	apply_function (const std::string &name, const std::vector< ExprPtr > &arguments)
ExprResult	apply_integral (const std::vector< ExprPtr > &arguments)
ExprResult	apply_limit (const std::vector< ExprPtr > &arguments)
ExprResult	apply_log (const std::vector< ExprPtr > &arguments)
ExprResult	apply_rootof (const std::vector< ExprPtr > &arguments)
bool	eof () const noexcept
ExprResult	fail (std::string message) const
ExprResult	finite_set (const std::vector< ExprPtr > &elements)
ExprResult	function_node (const std::string &name, const std::vector< ExprPtr > &arguments, FunctionNode::FuncType type)
ExprResult	interval (const ExprPtr &lower, const ExprPtr &upper, bool lower_closed, bool upper_closed)
ExprResult	logical (const ExprPtr &lhs, const ExprPtr &rhs, LogicalNode::Op op)
bool	match (char c)
bool	match_keyword (const char *text)
bool	match_text (const char *text)
ExprResult	membership (const ExprPtr &element, const ExprPtr &set, bool negated)
ExprResult	parse_additive ()
ExprResult	parse_approx_literal ()
ExprResult	parse_call (const std::string &name)
ExprResult	parse_equality ()
std::string	parse_identifier ()
ExprResult	parse_identifier_or_call ()
ExprResult	parse_interval_literal (bool lower_closed)
ExprResult	parse_logical_and ()
ExprResult	parse_logical_not ()
ExprResult	parse_logical_or ()
ExprResult	parse_membership ()
ExprResult	parse_multiplicative ()
ExprResult	parse_number ()
ExprResult	parse_power ()
ExprResult	parse_primary ()
ExprResult	parse_relational ()
ExprResult	parse_set_literal ()
ExprResult	parse_unary ()
char	peek () const noexcept
ExprResult	relational (const ExprPtr &lhs, const ExprPtr &rhs, RelationOp op)
void	skip_space () noexcept
ExprResult	uninterpreted_function (const std::string &name, const std::vector< ExprPtr > &arguments)

静态 Private 成员函数
static bool	is_ident_continue (unsigned char c) noexcept
static bool	is_ident_start (unsigned char c) noexcept

Private 属性
std::size_t	pos_ = 0
std::string	source_

详细描述

在文件 expr_parser.hpp 第 14 行定义.

构造及析构函数说明

◆ ExprParser()

LMCAS::expr_detail::ExprParser::ExprParser ( std::string source )

inlineexplicit

在文件 expr_parser.hpp 第 16 行定义.

16: source_(std::move(source)) {}

LMCAS::ExprParser::source_

std::string source_

定义 expr_parser.hpp:20

被这些函数引用 LMCAS::parse_expr().

这是这个函数的调用关系图:

成员函数说明

◆ apply_atan2()

ExprResult LMCAS::expr_detail::ExprParser::apply_atan2 ( const std::vector< ExprPtr > & arguments )

private

在文件 expr_parser_functions.cpp 第 61 行定义.

                                                                      {
    try {
        auto result = SymbolicExpr::atan2(arguments[0], arguments[1]);
        return ExprResult::success(std::move(result));
    } catch (const std::bad_alloc&) {
        return expr_detail::expr_common::expression_failure(CasErrc::ResourceLimit,
                                  "atan2 expression allocation failed",
                                  kParseOperation);
    } catch (const std::exception& error) {
        return expr_detail::expr_common::expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kParseOperation);
    }
}

◆ apply_clamp()

ExprResult LMCAS::expr_detail::ExprParser::apply_clamp ( const std::vector< ExprPtr > & arguments )

private

在文件 expr_parser_functions.cpp 第 161 行定义.

                                                                      {
    return clamp(arguments[0], arguments[1], arguments[2]);
}

◆ apply_function()

ExprResult LMCAS::expr_detail::ExprParser::apply_function	(	const std::string &	name,
		const std::vector< ExprPtr > &	arguments )

private

在文件 expr_parser_functions.cpp 第 165 行定义.

                                                                         {
    if (auto unary = find_unary_function(name)) {
        if (arguments.size() == 1) {
            return unary(arguments[0]);
        }
        if (name == "log" && arguments.size() == 2) {
            return apply_log(arguments);
        }
        return fail("invalid argument count for function '" + name + "'");
    }
    using Constructor = ExprResult (ExprParser::*)(const std::vector<ExprPtr>&);
    static const struct {
        const char* name;
        Constructor construct;
        std::size_t arity;
        std::size_t alternative_arity;
    } functions[] = {
        {"atan2", &ExprParser::apply_atan2, 2, 2},
        {"clamp", &ExprParser::apply_clamp, 3, 3},
        {"Integral", &ExprParser::apply_integral, 2, 4},
        {"integral", &ExprParser::apply_integral, 2, 4},
        {"Limit", &ExprParser::apply_limit, 4, 4},
        {"limit", &ExprParser::apply_limit, 4, 4},
        {"RootOf", &ExprParser::apply_rootof, 3, 3},
        {"rootof", &ExprParser::apply_rootof, 3, 3}
    };
    for (const auto& entry : functions) {
        if (name == entry.name) {
            if (arguments.size() != entry.arity &&
                arguments.size() != entry.alternative_arity) {
                return fail("invalid argument count for function '" + name + "'");
            }
            return (this->*entry.construct)(arguments);
        }
    }
    if (!arguments.empty() && (name == "max" || name == "min")) {
        return function_node(name, arguments,
            name == "max" ? FunctionNode::FuncType::Max : FunctionNode::FuncType::Min);
    }
    return uninterpreted_function(name, arguments);
}

◆ apply_integral()

ExprResult LMCAS::expr_detail::ExprParser::apply_integral ( const std::vector< ExprPtr > & arguments )

private

在文件 expr_parser_functions.cpp 第 75 行定义.

                                                                         {
    auto variable = std::dynamic_pointer_cast<const VariableNode>(
        LMCAS::detail::node(arguments[1]));
    if (!variable || variable->is_constant()) {
        return fail("Integral variable must be a symbol");
    }
    try {
        auto node = LMCAS::detail::make_node<IntegralNode>(
            LMCAS::detail::node(arguments[0]), variable->name(),
            arguments.size() == 4
                ? LMCAS::detail::node(arguments[2])
                : nullptr,
            arguments.size() == 4
                ? LMCAS::detail::node(arguments[3])
                : nullptr);
        return ExprResult::success(
            LMCAS::detail::make_expression_ptr(std::move(node)));
    } catch (const std::bad_alloc&) {
        return expr_detail::expr_common::expression_failure(CasErrc::ResourceLimit,
        "Integral expression allocation failed",
        kParseOperation);
    } catch (const std::exception& error) {
        return expr_detail::expr_common::expression_failure(CasErrc::InternalInvariant, error.what(), kParseOperation);
    }
}

◆ apply_limit()

ExprResult LMCAS::expr_detail::ExprParser::apply_limit ( const std::vector< ExprPtr > & arguments )

private

在文件 expr_parser_functions.cpp 第 101 行定义.

                                                                      {
    auto variable = std::dynamic_pointer_cast<const VariableNode>(
        LMCAS::detail::node(arguments[1]));
    auto direction = std::dynamic_pointer_cast<const VariableNode>(
        LMCAS::detail::node(arguments[3]));
    if (!variable || variable->is_constant() ||
        !direction || direction->is_constant()) {
        return fail("limit variable and direction must be symbols");
    }
    LimitDirection parsed_direction;
    if (direction->name() == "both") {
        parsed_direction = LimitDirection::Both;
    } else if (direction->name() == "below" ||
               direction->name() == "left" ||
               direction->name() == "from_below") {
        parsed_direction = LimitDirection::FromBelow;
    } else if (direction->name() == "above" ||
               direction->name() == "right" ||
               direction->name() == "from_above") {
        parsed_direction = LimitDirection::FromAbove;
    } else {
        return fail("invalid limit direction");
    }
    return ExprResult::success(LMCAS::detail::make_expression_ptr(
        LMCAS::detail::make_node<LimitNode>(
            LMCAS::detail::node(arguments[0]), variable->name(),
            LMCAS::detail::node(arguments[2]), parsed_direction)));
}

◆ apply_log()

ExprResult LMCAS::expr_detail::ExprParser::apply_log ( const std::vector< ExprPtr > & arguments )

private

在文件 expr_parser_functions.cpp 第 47 行定义.

                                                                    {
    try {
        auto result = SymbolicExpr::log(arguments[0], arguments[1]);
        return ExprResult::success(std::move(result));
    } catch (const std::bad_alloc&) {
        return expr_detail::expr_common::expression_failure(CasErrc::ResourceLimit,
                                  "log expression allocation failed",
                                  kParseOperation);
    } catch (const std::exception& error) {
        return expr_detail::expr_common::expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kParseOperation);
    }
}

◆ apply_rootof()

ExprResult LMCAS::expr_detail::ExprParser::apply_rootof ( const std::vector< ExprPtr > & arguments )

private

在文件 expr_parser_functions.cpp 第 130 行定义.

                                                                       {
    auto variable = std::dynamic_pointer_cast<const VariableNode>(
        LMCAS::detail::node(arguments[1]));
    auto index = std::dynamic_pointer_cast<const NumberNode>(
        LMCAS::detail::node(arguments[2]));
    if (!variable || variable->is_constant() || !index) {
        return fail("RootOf variable and index are invalid");
    }
    BigInt index_value;
    if (std::holds_alternative<BigInt>(index->value())) {
        index_value = std::get<BigInt>(index->value());
    } else {
        const auto& rational = std::get<Rational>(index->value());
        if (!rational.is_integer()) {
            return fail("RootOf index must be an integer");
        }
        index_value = rational.to_bigint();
    }
    const auto converted = index_value.try_to_int64();
    if (!converted || *converted < 0) {
        return fail("RootOf index is negative or too large");
    }
    auto root = make_rootof_checked(
        arguments[0], variable->name(),
        static_cast<std::size_t>(*converted));
    if (!root) {
        return ExprResult::failure(root.error());
    }
    return ExprResult::success(std::move(root.value()));
}

◆ eof()

bool LMCAS::expr_detail::ExprParser::eof ( ) const

privatenoexcept

在文件 expr_parsing.cpp 第 28 行定义.

28{ return pos_ >= source_.size(); }

LMCAS::ExprParser::pos_

std::size_t pos_

定义 expr_parser.hpp:21

◆ fail()

ExprResult LMCAS::expr_detail::ExprParser::fail ( std::string message ) const

private

在文件 expr_parsing.cpp 第 72 行定义.

                                                   {
    return expr_detail::expr_common::expression_failure(CasErrc::ParseError,
    std::move(message) + " at byte " + std::to_string(pos_),
    kParseOperation);
}

◆ finite_set()

ExprResult LMCAS::expr_detail::ExprParser::finite_set ( const std::vector< ExprPtr > & elements )

private

在文件 expr_parser_construction.cpp 第 60 行定义.

                                                                    {
    for (const auto& element : elements) {
        if (!element || !LMCAS::detail::node(element)) {
            return invalid_construction("set elements cannot be null");
        }
    }
    return construct_expression(
        "set expression allocation failed", [&] {
            std::vector<std::shared_ptr<const SymbolicNode>> nodes;
            nodes.reserve(elements.size());
            for (const auto& element : elements) {
                nodes.push_back(LMCAS::detail::node(element));
            }
            return LMCAS::detail::make_node<FiniteSetNode>(std::move(nodes));
        });
}

◆ function_node()

ExprResult LMCAS::expr_detail::ExprParser::function_node	(	const std::string &	name,
		const std::vector< ExprPtr > &	arguments,
		FunctionNode::FuncType	type )

private

在文件 expr_parser_construction.cpp 第 109 行定义.

                               {
    for (const auto& argument : arguments) {
        if (!argument || !LMCAS::detail::node(argument)) {
            return invalid_construction("function arguments cannot be null");
        }
    }
    return construct_expression(
        name + " expression allocation failed", [&] {
            std::vector<std::shared_ptr<const SymbolicNode>> nodes;
            nodes.reserve(arguments.size());
            for (const auto& argument : arguments) {
                nodes.push_back(LMCAS::detail::node(argument));
            }
            return LMCAS::detail::make_node<FunctionNode>(
                type, std::move(nodes));
        });
}

◆ interval()

ExprResult LMCAS::expr_detail::ExprParser::interval	(	const ExprPtr &	lower,
		const ExprPtr &	upper,
		bool	lower_closed,
		bool	upper_closed )

private

在文件 expr_parser_construction.cpp 第 77 行定义.

                                          {
    if (!lower || !upper) {
        return invalid_construction("interval bounds cannot be null");
    }
    return construct_expression(
        "interval expression allocation failed", [&] {
            return LMCAS::detail::make_node<IntervalNode>(
                LMCAS::detail::node(lower), LMCAS::detail::node(upper),
                lower_closed, upper_closed);
        });
}

◆ is_ident_continue()

bool LMCAS::expr_detail::ExprParser::is_ident_continue ( unsigned char c )

staticprivatenoexcept

在文件 expr_parsing.cpp 第 82 行定义.

                                                           {
    return std::isalnum(c) || c == '_' || c >= 0x80;
}

◆ is_ident_start()

bool LMCAS::expr_detail::ExprParser::is_ident_start ( unsigned char c )

staticprivatenoexcept

在文件 expr_parsing.cpp 第 78 行定义.

                                                        {
    return std::isalpha(c) || c == '_' || c >= 0x80;
}

◆ logical()

ExprResult LMCAS::expr_detail::ExprParser::logical	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		LogicalNode::Op	op )

private

在文件 expr_parser_construction.cpp 第 47 行定义.

                                                              {
    if (!lhs || (op != LogicalNode::Op::Not && !rhs)) {
        return invalid_construction("logical operands cannot be null");
    }
    return construct_expression(
        "logical expression allocation failed", [&] {
            return LMCAS::detail::make_node<LogicalNode>(
                LMCAS::detail::node(lhs),
                rhs ? LMCAS::detail::node(rhs) : nullptr, op);
        });
}

◆ match()

bool LMCAS::expr_detail::ExprParser::match ( char c )

private

在文件 expr_parsing.cpp 第 34 行定义.

                             {
    skip_space();
    if (peek() != c) { return false; }
    ++pos_;
    return true;
}

◆ match_keyword()

bool LMCAS::expr_detail::ExprParser::match_keyword ( const char * text )

private

在文件 expr_parsing.cpp 第 54 行定义.

                                               {
    skip_space();
    const std::size_t start = pos_;
    if (!match_text(text)) { return false; }
    if (is_ident_continue(static_cast<unsigned char>(peek()))) {
        pos_ = start;
        return false;
    }
    return true;
}

◆ match_text()

bool LMCAS::expr_detail::ExprParser::match_text ( const char * text )

private

在文件 expr_parsing.cpp 第 41 行定义.

                                            {
    skip_space();
    const std::size_t start = pos_;
    for (const char* p = text; *p; ++p) {
        if (pos_ >= source_.size() || source_[pos_] != *p) {
            pos_ = start;
            return false;
        }
        ++pos_;
    }
    return true;
}

◆ membership()

ExprResult LMCAS::expr_detail::ExprParser::membership	(	const ExprPtr &	element,
		const ExprPtr &	set,
		bool	negated )

private

在文件 expr_parser_construction.cpp 第 91 行定义.

                                                              {
    if (!element || !set) {
        return invalid_construction("membership operands cannot be null");
    }
    return construct_expression(
        "membership expression allocation failed", [&] {
            std::shared_ptr<const SymbolicNode> node =
                LMCAS::detail::make_node<MembershipNode>(
                    LMCAS::detail::node(element), LMCAS::detail::node(set));
            if (negated) {
                node = LMCAS::detail::make_node<LogicalNode>(
                    std::move(node), nullptr, LogicalNode::Op::Not);
            }
            return node;
        });
}

◆ parse()

ExprResult LMCAS::expr_detail::ExprParser::parse ( )

在文件 expr_parsing.cpp 第 14 行定义.

                             {
    skip_space();
    if (eof()) {
        return fail("empty expression");
    }
    auto result = parse_logical_or();
    if (!result) { return result; }
    skip_space();
    if (!eof()) {
        return fail("unexpected token '" + std::string(1, peek()) + "'");
    }
    return result;
}

◆ parse_additive()

ExprResult LMCAS::expr_detail::ExprParser::parse_additive ( )

private

在文件 expr_parsing.cpp 第 181 行定义.

                                      {
    auto lhs = parse_multiplicative();
    if (!lhs) { return lhs; }
    while (true) {
        if (match('+')) {
            auto rhs = parse_multiplicative();
            if (!rhs) { return rhs; }
            lhs = add(lhs.value(), rhs.value());
        } else if (match('-')) {
            auto rhs = parse_multiplicative();
            if (!rhs) { return rhs; }
            lhs = sub(lhs.value(), rhs.value());
        } else {
            return lhs;
        }
        if (!lhs) { return lhs; }
    }
}

◆ parse_approx_literal()

ExprResult LMCAS::expr_detail::ExprParser::parse_approx_literal ( )

private

在文件 expr_parsing.cpp 第 358 行定义.

                                            {
    skip_space();
    const auto start = pos_;
    while (!eof() && peek() != ')' &&
           !std::isspace(static_cast<unsigned char>(peek()))) ++pos_;
    const std::string_view token(source_.data() + start, pos_ - start);
    if (!match(')')) return fail("expected ')' after approximate decimal");
    auto value = detail::parse_finite_decimal(token);
    if (!value) return fail(value.error().message);
    return approx_real(value.value());
}

◆ parse_call()

ExprResult LMCAS::expr_detail::ExprParser::parse_call ( const std::string & name )

private

在文件 expr_parsing.cpp 第 370 行定义.

                                                       {
    if (name == "approx") return parse_approx_literal();
    std::vector<ExprPtr> arguments;
    bool closed = match(')');
    if (!closed) {
        do {
            auto argument = parse_logical_or();
            if (!argument) {
                return argument;
            }
            arguments.push_back(argument.value());
            if (match(')')) {
                closed = true;
                break;
            }
        } while (match(','));
    }
    if (!closed) {
        return fail("expected ')'");
    }
    return apply_function(name, arguments);
}

◆ parse_equality()

ExprResult LMCAS::expr_detail::ExprParser::parse_equality ( )

private

在文件 expr_parsing.cpp 第 139 行定义.

                                      {
    auto lhs = parse_relational();
    if (!lhs) { return lhs; }
    while (true) {
        RelationOp op;
        if (match_text("==")) {
            op = RelationOp::EQ;
        } else if (match_text("!=")) {
            op = RelationOp::NEQ;
        } else {
            return lhs;
        }
        auto rhs = parse_relational();
        if (!rhs) { return rhs; }
        lhs = relational(lhs.value(), rhs.value(), op);
        if (!lhs) { return lhs; }
    }
}

◆ parse_identifier()

std::string LMCAS::expr_detail::ExprParser::parse_identifier ( )

private

在文件 expr_parsing.cpp 第 349 行定义.

                                       {
    skip_space();
    const std::size_t start = pos_;
    if (!is_ident_start(static_cast<unsigned char>(peek()))) { return {}; }
    ++pos_;
    while (is_ident_continue(static_cast<unsigned char>(peek()))) ++pos_;
    return source_.substr(start, pos_ - start);
}

◆ parse_identifier_or_call()

ExprResult LMCAS::expr_detail::ExprParser::parse_identifier_or_call ( )

private

在文件 expr_parsing.cpp 第 393 行定义.

                                                {
    auto name = parse_identifier();
    if (name.empty()) {
        return fail("expected identifier");
    }
    skip_space();
    if (match('(')) {
        return parse_call(name);
    }
    if (name == "pi" || name == "π") {
        return pi();
    }
    if (name == "e") {
        return e();
    }
    if (name == "phi") {
        return phi();
    }
    if (detail::is_imaginary_unit_name(name)) {
        return imaginary_unit();
    }
    return sym(name);
}

◆ parse_interval_literal()

ExprResult LMCAS::expr_detail::ExprParser::parse_interval_literal ( bool lower_closed )

private

在文件 expr_parsing.cpp 第 288 行定义.

                                                               {
    auto lower = parse_logical_or();
    if (!lower) { return lower; }
    if (!match(',')) { return fail("expected ',' in interval literal"); }
    auto upper = parse_logical_or();
    if (!upper) { return upper; }
    bool upper_closed;
    if (match(']')) {
        upper_closed = true;
    } else if (match(')')) {
        upper_closed = false;
    } else {
        return fail("expected ']' or ')' after interval literal");
    }
    return interval(lower.value(), upper.value(), lower_closed, upper_closed);
}

◆ parse_logical_and()

ExprResult LMCAS::expr_detail::ExprParser::parse_logical_and ( )

private

在文件 expr_parsing.cpp 第 98 行定义.

                                         {
    auto lhs = parse_logical_not();
    if (!lhs) { return lhs; }
    while (match_keyword("and")) {
        auto rhs = parse_logical_not();
        if (!rhs) { return rhs; }
        lhs = logical(lhs.value(), rhs.value(), LogicalNode::Op::And);
        if (!lhs) { return lhs; }
    }
    return lhs;
}

◆ parse_logical_not()

ExprResult LMCAS::expr_detail::ExprParser::parse_logical_not ( )

private

在文件 expr_parsing.cpp 第 110 行定义.

                                         {
    if (match_keyword("not") || match('!')) {
        auto operand = parse_logical_not();
        if (!operand) { return operand; }
        return logical(operand.value(), nullptr, LogicalNode::Op::Not);
    }
    return parse_membership();
}

◆ parse_logical_or()

ExprResult LMCAS::expr_detail::ExprParser::parse_logical_or ( )

private

在文件 expr_parsing.cpp 第 86 行定义.

                                        {
    auto lhs = parse_logical_and();
    if (!lhs) { return lhs; }
    while (match_keyword("or")) {
        auto rhs = parse_logical_and();
        if (!rhs) { return rhs; }
        lhs = logical(lhs.value(), rhs.value(), LogicalNode::Op::Or);
        if (!lhs) { return lhs; }
    }
    return lhs;
}

◆ parse_membership()

ExprResult LMCAS::expr_detail::ExprParser::parse_membership ( )

private

在文件 expr_parsing.cpp 第 119 行定义.

                                        {
    auto lhs = parse_equality();
    if (!lhs) { return lhs; }
    if (match_keyword("in")) {
        auto rhs = parse_equality();
        if (!rhs) { return rhs; }
        return membership(lhs.value(), rhs.value(), false);
    }
    const auto save = pos_;
    if (match_keyword("not")) {
        if (match_keyword("in")) {
            auto rhs = parse_equality();
            if (!rhs) { return rhs; }
            return membership(lhs.value(), rhs.value(), true);
        }
        pos_ = save;
    }
    return lhs;
}

◆ parse_multiplicative()

ExprResult LMCAS::expr_detail::ExprParser::parse_multiplicative ( )

private

在文件 expr_parsing.cpp 第 200 行定义.

                                            {
    auto lhs = parse_power();
    if (!lhs) { return lhs; }
    while (true) {
        if (match_text("**")) {
            return fail("operator '**' is not supported; use '^'");
        } else if (match('*')) {
            auto rhs = parse_power();
            if (!rhs) { return rhs; }
            lhs = mul(lhs.value(), rhs.value());
        } else if (match('/')) {
            auto rhs = parse_power();
            if (!rhs) { return rhs; }
            lhs = div(lhs.value(), rhs.value());
        } else {
            return lhs;
        }
        if (!lhs) { return lhs; }
    }
}

◆ parse_number()

ExprResult LMCAS::expr_detail::ExprParser::parse_number ( )

private

在文件 expr_parsing.cpp 第 305 行定义.

                                    {
    skip_space();
    const std::size_t start = pos_;
    bool saw_digit = false;
    while (std::isdigit(static_cast<unsigned char>(peek()))) {
        saw_digit = true;
        ++pos_;
    }
    if (peek() == '.') {
        ++pos_;
        while (std::isdigit(static_cast<unsigned char>(peek()))) {
            saw_digit = true;
            ++pos_;
        }
    }
    if (!saw_digit) { return fail("invalid number literal"); }
    if (peek() == 'e' || peek() == 'E') {
        ++pos_;
        if (peek() == '+' || peek() == '-') ++pos_;
        bool saw_exp_digit = false;
        while (std::isdigit(static_cast<unsigned char>(peek()))) {
            saw_exp_digit = true;
            ++pos_;
        }
        if (!saw_exp_digit) { return fail("invalid number exponent"); }
    }
    try {
        return rational(Rational(source_.substr(start, pos_ - start)));
    } catch (const std::bad_alloc&) {
        return expr_detail::expr_common::expression_failure(CasErrc::ResourceLimit,
                                  "number literal allocation failed",
                                  kParseOperation);
    } catch (const std::invalid_argument& error) {
        return expr_detail::expr_common::expression_failure(
            CasErrc::ParseError, error.what(), kParseOperation);
    } catch (const std::out_of_range& error) {
        return expr_detail::expr_common::expression_failure(
            CasErrc::ParseError, error.what(), kParseOperation);
    } catch (const std::exception& error) {
        return expr_detail::expr_common::expression_failure(
            CasErrc::InternalInvariant, error.what(), kParseOperation);
    }
}

◆ parse_power()

ExprResult LMCAS::expr_detail::ExprParser::parse_power ( )

private

在文件 expr_parsing.cpp 第 221 行定义.

                                   {
    auto base = parse_unary();
    if (!base) { return base; }
    if (match_text("**")) {
        return fail("operator '**' is not supported; use '^'");
    }
    if (match('^')) {
        auto exponent = parse_power();
        if (!exponent) { return exponent; }
        return pow(base.value(), exponent.value());
    }
    return base;
}

◆ parse_primary()

ExprResult LMCAS::expr_detail::ExprParser::parse_primary ( )

private

在文件 expr_parsing.cpp 第 245 行定义.

                                     {
    skip_space();
    if (match('(')) {
        auto inner = parse_logical_or();
        if (!inner) { return inner; }
        if (match(',')) {
            auto rhs = parse_logical_or();
            if (!rhs) { return rhs; }
            if (!match(')')) { return fail("expected ')' after interval"); }
            return interval(inner.value(), rhs.value(), false, false);
        }
        if (!match(')')) { return fail("expected ')'"); }
        return inner;
    }
    if (match('{')) {
        return parse_set_literal();
    }
    if (match('[')) {
        return parse_interval_literal(true);
    }
    if (std::isdigit(static_cast<unsigned char>(peek())) || peek() == '.') {
        return parse_number();
    }
    if (is_ident_start(static_cast<unsigned char>(peek()))) {
        return parse_identifier_or_call();
    }
    return fail("expected expression");
}

◆ parse_relational()

ExprResult LMCAS::expr_detail::ExprParser::parse_relational ( )

private

在文件 expr_parsing.cpp 第 158 行定义.

                                        {
    auto lhs = parse_additive();
    if (!lhs) { return lhs; }
    while (true) {
        RelationOp op;
        if (match_text("<=")) {
            op = RelationOp::LEQ;
        } else if (match_text(">=")) {
            op = RelationOp::GEQ;
        } else if (match('<')) {
            op = RelationOp::LT;
        } else if (match('>')) {
            op = RelationOp::GT;
        } else {
            return lhs;
        }
        auto rhs = parse_additive();
        if (!rhs) { return rhs; }
        lhs = relational(lhs.value(), rhs.value(), op);
        if (!lhs) { return lhs; }
    }
}

◆ parse_set_literal()

ExprResult LMCAS::expr_detail::ExprParser::parse_set_literal ( )

private

在文件 expr_parsing.cpp 第 274 行定义.

                                         {
    std::vector<ExprPtr> elements;
    if (!match('}')) {
        while (true) {
            auto element = parse_logical_or();
            if (!element) { return element; }
            elements.push_back(element.value());
            if (match('}')) break;
            if (!match(',')) { return fail("expected ',' or '}' in set literal"); }
        }
    }
    return finite_set(elements);
}

◆ parse_unary()

ExprResult LMCAS::expr_detail::ExprParser::parse_unary ( )

private

在文件 expr_parsing.cpp 第 235 行定义.

                                   {
    if (match('+')) { return parse_unary(); }
    if (match('-')) {
        auto operand = parse_unary();
        if (!operand) { return operand; }
        return neg(operand.value());
    }
    return parse_primary();
}

◆ peek()

char LMCAS::expr_detail::ExprParser::peek ( ) const

privatenoexcept

在文件 expr_parsing.cpp 第 30 行定义.

                                     {
    return eof() ? '\0' : source_[pos_];
}

◆ relational()

ExprResult LMCAS::expr_detail::ExprParser::relational	(	const ExprPtr &	lhs,
		const ExprPtr &	rhs,
		RelationOp	op )

private

在文件 expr_parser_construction.cpp 第 35 行定义.

                                                           {
    if (!lhs || !rhs) {
        return invalid_construction("relational operands cannot be null");
    }
    return construct_expression(
        "relational expression allocation failed", [&] {
            return LMCAS::detail::make_node<RelationalNode>(
                LMCAS::detail::node(lhs), LMCAS::detail::node(rhs), op);
        });
}

◆ skip_space()

void LMCAS::expr_detail::ExprParser::skip_space ( )

privatenoexcept

在文件 expr_parsing.cpp 第 65 行定义.

                                     {
    while (!eof() &&
           std::isspace(static_cast<unsigned char>(source_[pos_]))) {
        ++pos_;
    }
}

◆ uninterpreted_function()

ExprResult LMCAS::expr_detail::ExprParser::uninterpreted_function	(	const std::string &	name,
		const std::vector< ExprPtr > &	arguments )

private

在文件 expr_parser_functions.cpp 第 208 行定义.

                                                                {
    try {
        std::vector<std::shared_ptr<const SymbolicNode>> nodes;
        nodes.reserve(arguments.size());
        for (const auto& argument : arguments) {
            if (!argument || !LMCAS::detail::node(argument)) {
                return expr_detail::expr_common::expression_failure(CasErrc::InvalidArgument,
                                          "function arguments cannot be null",
                                          kParseOperation);
            }
            nodes.push_back(LMCAS::detail::node(argument));
        }
        auto node = LMCAS::detail::make_node<UninterpretedFunctionNode>(
            name, std::move(nodes));
        return ExprResult::success(LMCAS::detail::make_expression_ptr(std::move(node)));
    } catch (const std::bad_alloc&) {
        return expr_detail::expr_common::expression_failure(CasErrc::ResourceLimit,
                                  "function expression allocation failed",
                                  kParseOperation);
    } catch (const std::exception& error) {
        return expr_detail::expr_common::expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kParseOperation);
    }
}

类成员变量说明

◆ pos_

std::size_t LMCAS::expr_detail::ExprParser::pos_ = 0

private

在文件 expr_parser.hpp 第 21 行定义.

◆ source_

std::string LMCAS::expr_detail::ExprParser::source_

private

在文件 expr_parser.hpp 第 20 行定义.

该类的文档由以下文件生成:

Public 成员函数

Private 成员函数

静态 Private 成员函数

Private 属性

详细描述

构造及析构函数说明

◆ ExprParser()

成员函数说明

◆ apply_atan2()

◆ apply_clamp()

◆ apply_function()

◆ apply_integral()

◆ apply_limit()

◆ apply_log()

◆ apply_rootof()

◆ eof()

◆ fail()

◆ finite_set()

◆ function_node()

◆ interval()

◆ is_ident_continue()

◆ is_ident_start()

◆ logical()

◆ match()

◆ match_keyword()

◆ match_text()

◆ membership()

◆ parse()

◆ parse_additive()

◆ parse_approx_literal()

◆ parse_call()

◆ parse_equality()

◆ parse_identifier()

◆ parse_identifier_or_call()

◆ parse_interval_literal()

◆ parse_logical_and()

◆ parse_logical_not()

◆ parse_logical_or()

◆ parse_membership()

◆ parse_multiplicative()

◆ parse_number()

◆ parse_power()

◆ parse_primary()

◆ parse_relational()

◆ parse_set_literal()

◆ parse_unary()

◆ peek()

◆ relational()

◆ skip_space()

◆ uninterpreted_function()

类成员变量说明

◆ pos_

◆ source_