Method parseUnit

src/App/Expression.cpp:3785–3830

}

std::unique_ptr<UnitExpression> ExpressionParser::parseUnit(
    const App::DocumentObject* owner,
    const char* buffer
)
{
    // parse from buffer
    ExpressionParser::YY_BUFFER_STATE my_string_buffer = ExpressionParser::ExpressionParser_scan_string (buffer);
    ExpressionParser::StringBufferCleaner cleaner(my_string_buffer);

    initParser(owner);

    // run the parser
    int result = ExpressionParser::ExpressionParser_yyparse ();

    if (result != 0)
        throw ParserError("Failed to parse expression.");

    if (!ScanResult)
        throw ParserError("Unknown error in expression");

    // Simplify expression
    ExpressionPtr simplified = ScanResult->simplify();

    if (!unitExpression) {
        auto* fraction = freecad_cast<OperatorExpression*>(ScanResult.get());

        if (fraction && fraction->getOperator() == OperatorExpression::DIV) {
            NumberExpression * nom = freecad_cast<NumberExpression*>(fraction->getLeft());
            UnitExpression * denom = freecad_cast<UnitExpression*>(fraction->getRight());

            // If not initially a unit expression, but value is equal to 1, it means the expression is something like 1/unit
            if (denom && nom && essentiallyEqual(nom->getValue(), 1.0))
                unitExpression = true;
        }
    }
    ScanResult.reset();

    if (!unitExpression) {
        throw Expression::Exception("Expression is not a unit.");
    }

    if (auto num = freecad_cast<NumberExpression*>(simplified.get()); num) {
        return std::make_unique<UnitExpression>(num->getOwner(), num->getQuantity());
    }
    return std::unique_ptr<UnitExpression>(freecad_cast<UnitExpression*>(simplified.release()));
}

namespace {
std::tuple<int, int> getTokenAndStatus(const std::string & str)