LMCAS::expr_detail::ExprParser类 参考

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

LMCAS::expr_detail::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 行定义.

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

引用了 source_.

被这些函数引用 apply_function().

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

成员函数说明

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);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::InternalInvariant, LMCAS::expr_detail::kParseOperation, LMCAS::ResourceLimit , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 apply_function().

函数调用图:

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

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]);
}

引用了 LMCAS::clamp().

被这些函数引用 apply_function().

函数调用图:

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

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);
}

引用了 ExprParser(), apply_atan2(), apply_clamp(), apply_integral(), apply_limit(), apply_log(), apply_rootof(), fail(), function_node(), LMCAS::FunctionNode::Max, LMCAS::FunctionNode::Min, LMCAS::name , 以及 uninterpreted_function().

被这些函数引用 parse_call().

函数调用图:

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

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);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), fail(), LMCAS::InternalInvariant, LMCAS::expr_detail::kParseOperation, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::ResourceLimit, LMCAS::Result< ExprPtr >::success() , 以及 LMCAS::variable.

被这些函数引用 apply_function().

函数调用图:

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

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)));
}

引用了 LMCAS::Both, LMCAS::direction, fail(), LMCAS::FromAbove, LMCAS::FromBelow, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::Result< ExprPtr >::success() , 以及 LMCAS::variable.

被这些函数引用 apply_function().

函数调用图:

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

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);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::InternalInvariant, LMCAS::expr_detail::kParseOperation, LMCAS::ResourceLimit , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 apply_function().

函数调用图:

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

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()));
}

引用了 fail(), LMCAS::Result< ExprPtr >::failure(), LMCAS::make_rootof_checked(), LMCAS::detail::node(), LMCAS::rational(), LMCAS::Result< ExprPtr >::success() , 以及 LMCAS::variable.

被这些函数引用 apply_function().

函数调用图:

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

eof()

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

privatenoexcept

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

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

引用了 pos_ , 以及 source_.

被这些函数引用 parse(), parse_approx_literal(), peek() , 以及 skip_space().

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

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);
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::expr_detail::kParseOperation, LMCAS::ParseError , 以及 pos_.

被这些函数引用 apply_function(), apply_integral(), apply_limit(), apply_rootof(), parse(), parse_approx_literal(), parse_call(), parse_identifier_or_call(), parse_interval_literal(), parse_multiplicative(), parse_number(), parse_power(), parse_primary() , 以及 parse_set_literal().

函数调用图:

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

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));
        });
}

引用了 LMCAS::element, LMCAS::detail::make_node() , 以及 LMCAS::detail::node().

被这些函数引用 parse_set_literal().

函数调用图:

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

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));
        });
}

引用了 LMCAS::detail::make_node(), LMCAS::name , 以及 LMCAS::detail::node().

被这些函数引用 apply_function().

函数调用图:

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

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);
        });
}

引用了 LMCAS::lower, LMCAS::lower_closed, LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::upper , 以及 LMCAS::upper_closed.

被这些函数引用 parse_interval_literal() , 以及 parse_primary().

函数调用图:

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

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;
}

引用了 LMCAS::c.

被这些函数引用 match_keyword() , 以及 parse_identifier().

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

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;
}

引用了 LMCAS::c.

被这些函数引用 parse_identifier() , 以及 parse_primary().

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

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);
        });
}

引用了 LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::LogicalNode::Not, LMCAS::op , 以及 LMCAS::rhs.

被这些函数引用 parse_logical_and(), parse_logical_not() , 以及 parse_logical_or().

函数调用图:

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

match()

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

private

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

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

引用了 LMCAS::c, peek(), pos_ , 以及 skip_space().

被这些函数引用 parse_additive(), parse_approx_literal(), parse_call(), parse_identifier_or_call(), parse_interval_literal(), parse_logical_not(), parse_multiplicative(), parse_power(), parse_primary(), parse_relational(), parse_set_literal() , 以及 parse_unary().

函数调用图:

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

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;
}

引用了 is_ident_continue(), match_text(), peek(), pos_ , 以及 skip_space().

被这些函数引用 parse_logical_and(), parse_logical_not(), parse_logical_or() , 以及 parse_membership().

函数调用图:

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

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;
}

引用了 pos_, skip_space() , 以及 source_.

被这些函数引用 match_keyword(), parse_equality(), parse_multiplicative(), parse_power() , 以及 parse_relational().

函数调用图:

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

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;
        });
}

引用了 LMCAS::element, LMCAS::detail::make_node(), LMCAS::negated, LMCAS::detail::node(), LMCAS::LogicalNode::Not , 以及 LMCAS::set.

被这些函数引用 parse_membership().

函数调用图:

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

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;
}

引用了 eof(), fail(), parse_logical_or(), peek() , 以及 skip_space().

函数调用图:

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; }
    }
}

引用了 LMCAS::add(), match(), parse_multiplicative(), LMCAS::rhs , 以及 LMCAS::sub().

被这些函数引用 parse_relational().

函数调用图:

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

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());
}

引用了 LMCAS::approx_real(), eof(), fail(), match(), LMCAS::detail::parse_finite_decimal(), peek(), pos_, skip_space(), source_ , 以及 LMCAS::value.

被这些函数引用 parse_call().

函数调用图:

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

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);
}

引用了 apply_function(), fail(), match(), LMCAS::name, parse_approx_literal() , 以及 parse_logical_or().

被这些函数引用 parse_identifier_or_call().

函数调用图:

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

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; }
    }
}

引用了 LMCAS::EQ, match_text(), LMCAS::NEQ, LMCAS::op, parse_relational(), relational() , 以及 LMCAS::rhs.

被这些函数引用 parse_membership().

函数调用图:

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

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);
}

引用了 is_ident_continue(), is_ident_start(), peek(), pos_, skip_space() , 以及 source_.

被这些函数引用 parse_identifier_or_call().

函数调用图:

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

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);
}

引用了 LMCAS::e(), fail(), LMCAS::imaginary_unit(), LMCAS::detail::is_imaginary_unit_name(), match(), LMCAS::name, parse_call(), parse_identifier(), LMCAS::phi(), LMCAS::pi(), skip_space() , 以及 LMCAS::sym().

被这些函数引用 parse_primary().

函数调用图:

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

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);
}

引用了 fail(), interval(), LMCAS::lower, LMCAS::lower_closed, match(), parse_logical_or(), LMCAS::upper, LMCAS::upper_closed , 以及 LMCAS::Result< T >::value().

被这些函数引用 parse_primary().

函数调用图:

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

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;
}

引用了 LMCAS::LogicalNode::And, logical(), match_keyword(), parse_logical_not() , 以及 LMCAS::rhs.

被这些函数引用 parse_logical_or().

函数调用图:

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

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();
}

引用了 logical(), match(), match_keyword(), LMCAS::LogicalNode::Not, parse_logical_not() , 以及 parse_membership().

被这些函数引用 parse_logical_and() , 以及 parse_logical_not().

函数调用图:

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

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;
}

引用了 logical(), match_keyword(), LMCAS::LogicalNode::Or, parse_logical_and() , 以及 LMCAS::rhs.

被这些函数引用 parse(), parse_call(), parse_interval_literal(), parse_primary() , 以及 parse_set_literal().

函数调用图:

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

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;
}

引用了 match_keyword(), membership(), parse_equality(), pos_ , 以及 LMCAS::rhs.

被这些函数引用 parse_logical_not().

函数调用图:

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

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; }
    }
}

引用了 LMCAS::div(), fail(), match(), match_text(), LMCAS::mul(), parse_power() , 以及 LMCAS::rhs.

被这些函数引用 parse_additive().

函数调用图:

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

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);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), fail(), LMCAS::InternalInvariant, LMCAS::expr_detail::kParseOperation, LMCAS::ParseError, peek(), pos_, LMCAS::rational(), LMCAS::ResourceLimit, skip_space() , 以及 source_.

被这些函数引用 parse_primary().

函数调用图:

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

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;
}

引用了 LMCAS::exponent, fail(), match(), match_text(), parse_power(), parse_unary() , 以及 LMCAS::pow().

被这些函数引用 parse_multiplicative() , 以及 parse_power().

函数调用图:

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

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");
}

引用了 fail(), interval(), is_ident_start(), match(), parse_identifier_or_call(), parse_interval_literal(), parse_logical_or(), parse_number(), parse_set_literal(), peek(), LMCAS::rhs , 以及 skip_space().

被这些函数引用 parse_unary().

函数调用图:

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

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; }
    }
}

引用了 LMCAS::GEQ, LMCAS::GT, LMCAS::LEQ, LMCAS::LT, match(), match_text(), LMCAS::op, parse_additive(), relational() , 以及 LMCAS::rhs.

被这些函数引用 parse_equality().

函数调用图:

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

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);
}

引用了 LMCAS::element, fail(), finite_set(), match() , 以及 parse_logical_or().

被这些函数引用 parse_primary().

函数调用图:

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

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();
}

引用了 match(), LMCAS::neg(), parse_primary() , 以及 parse_unary().

被这些函数引用 parse_power() , 以及 parse_unary().

函数调用图:

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

peek()

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

privatenoexcept

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

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

引用了 eof(), pos_ , 以及 source_.

被这些函数引用 match(), match_keyword(), parse(), parse_approx_literal(), parse_identifier(), parse_number() , 以及 parse_primary().

函数调用图:

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

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);
        });
}

引用了 LMCAS::detail::make_node(), LMCAS::detail::node(), LMCAS::op , 以及 LMCAS::rhs.

被这些函数引用 parse_equality() , 以及 parse_relational().

函数调用图:

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

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_;
    }
}

引用了 eof(), pos_ , 以及 source_.

被这些函数引用 match(), match_keyword(), match_text(), parse(), parse_approx_literal(), parse_identifier(), parse_identifier_or_call(), parse_number() , 以及 parse_primary().

函数调用图:

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

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);
    }
}

引用了 LMCAS::expr_detail::expr_common::expression_failure(), LMCAS::InternalInvariant, LMCAS::InvalidArgument, LMCAS::expr_detail::kParseOperation, LMCAS::detail::make_expression_ptr(), LMCAS::detail::make_node(), LMCAS::name, LMCAS::detail::node(), LMCAS::ResourceLimit , 以及 LMCAS::Result< ExprPtr >::success().

被这些函数引用 apply_function().

函数调用图:

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

类成员变量说明

pos_

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

private

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

被这些函数引用 eof(), fail(), match(), match_keyword(), match_text(), parse_approx_literal(), parse_identifier(), parse_membership(), parse_number(), peek() , 以及 skip_space().

source_

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

private

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

被这些函数引用 ExprParser(), eof(), match_text(), parse_approx_literal(), parse_identifier(), parse_number(), peek() , 以及 skip_space().

---

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

• src/internal/expr_parser.hpp
• src/expr_parser_construction.cpp
• src/expr_parser_functions.cpp
• src/expr_parsing.cpp