mirror of
https://gitlab.com/kicad/code/kicad.git
synced 2025-09-14 18:23:15 +02:00
638 lines
22 KiB
C++
638 lines
22 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright The KiCad Developers, see AUTHORS.txt for contributors.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation, either version 3 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <text_eval/text_eval_parser.h>
|
|
#include <fmt/format.h>
|
|
#include <array>
|
|
#include <cctype>
|
|
|
|
namespace calc_parser
|
|
{
|
|
thread_local ERROR_COLLECTOR* g_errorCollector = nullptr;
|
|
|
|
class DATE_UTILS
|
|
{
|
|
private:
|
|
static constexpr int epochYear = 1970;
|
|
static constexpr std::array<int, 12> daysInMonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
|
static constexpr std::array<const char*, 12> monthNames = {
|
|
"January", "February", "March", "April", "May", "June",
|
|
"July", "August", "September", "October", "November", "December"
|
|
};
|
|
static constexpr std::array<const char*, 12> monthAbbrev = {
|
|
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
|
|
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
|
|
};
|
|
static constexpr std::array<const char*, 7> weekdayNames = {
|
|
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
|
|
};
|
|
|
|
static auto isLeapYear( int aYear ) -> bool
|
|
{
|
|
return ( aYear % 4 == 0 && aYear % 100 != 0 ) || ( aYear % 400 == 0 );
|
|
}
|
|
|
|
static auto daysInYear( int aYear ) -> int
|
|
{
|
|
return isLeapYear( aYear ) ? 366 : 365;
|
|
}
|
|
|
|
static auto daysInMonthForYear( int aMonth, int aYear ) -> int
|
|
{
|
|
if( aMonth == 2 && isLeapYear( aYear ) )
|
|
return 29;
|
|
|
|
return daysInMonth[aMonth - 1];
|
|
}
|
|
|
|
public:
|
|
static auto DaysToYmd( int aDaysSinceEpoch ) -> std::tuple<int, int, int>
|
|
{
|
|
int year = epochYear;
|
|
int remainingDays = aDaysSinceEpoch;
|
|
|
|
if( remainingDays >= 0 )
|
|
{
|
|
while( remainingDays >= daysInYear( year ) )
|
|
{
|
|
remainingDays -= daysInYear( year );
|
|
year++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while( remainingDays < 0 )
|
|
{
|
|
year--;
|
|
remainingDays += daysInYear( year );
|
|
}
|
|
}
|
|
|
|
int month = 1;
|
|
while( month <= 12 && remainingDays >= daysInMonthForYear( month, year ) )
|
|
{
|
|
remainingDays -= daysInMonthForYear( month, year );
|
|
month++;
|
|
}
|
|
|
|
int day = remainingDays + 1;
|
|
return {year, month, day};
|
|
}
|
|
|
|
static auto YmdToDays( int aYear, int aMonth, int aDay ) -> int
|
|
{
|
|
int totalDays = 0;
|
|
|
|
if( aYear >= epochYear )
|
|
{
|
|
for( int y = epochYear; y < aYear; ++y )
|
|
totalDays += daysInYear( y );
|
|
}
|
|
else
|
|
{
|
|
for( int y = aYear; y < epochYear; ++y )
|
|
totalDays -= daysInYear( y );
|
|
}
|
|
|
|
for( int m = 1; m < aMonth; ++m )
|
|
totalDays += daysInMonthForYear( m, aYear );
|
|
|
|
totalDays += aDay - 1;
|
|
return totalDays;
|
|
}
|
|
|
|
static auto ParseDate( const std::string& aDateStr ) -> std::optional<int>
|
|
{
|
|
std::istringstream iss( aDateStr );
|
|
std::string token;
|
|
std::vector<int> parts;
|
|
|
|
char separator = 0;
|
|
bool isCjkFormat = false;
|
|
|
|
// Check for CJK date formats first (Chinese, Korean, or mixed)
|
|
bool hasChineseYear = aDateStr.find( "年" ) != std::string::npos;
|
|
bool hasChineseMonth = aDateStr.find( "月" ) != std::string::npos;
|
|
bool hasChineseDay = aDateStr.find( "日" ) != std::string::npos;
|
|
bool hasKoreanYear = aDateStr.find( "년" ) != std::string::npos;
|
|
bool hasKoreanMonth = aDateStr.find( "월" ) != std::string::npos;
|
|
bool hasKoreanDay = aDateStr.find( "일" ) != std::string::npos;
|
|
|
|
// Check if we have any CJK date format (pure or mixed)
|
|
if( (hasChineseYear || hasKoreanYear) &&
|
|
(hasChineseMonth || hasKoreanMonth) &&
|
|
(hasChineseDay || hasKoreanDay) )
|
|
{
|
|
// CJK format: Support pure Chinese, pure Korean, or mixed formats
|
|
isCjkFormat = true;
|
|
|
|
size_t yearPos, monthPos, dayPos;
|
|
|
|
// Find year position and marker
|
|
if( hasChineseYear )
|
|
yearPos = aDateStr.find( "年" );
|
|
else
|
|
yearPos = aDateStr.find( "년" );
|
|
|
|
// Find month position and marker
|
|
if( hasChineseMonth )
|
|
monthPos = aDateStr.find( "月" );
|
|
else
|
|
monthPos = aDateStr.find( "월" );
|
|
|
|
// Find day position and marker
|
|
if( hasChineseDay )
|
|
dayPos = aDateStr.find( "日" );
|
|
else
|
|
dayPos = aDateStr.find( "일" );
|
|
|
|
try
|
|
{
|
|
int year = std::stoi( aDateStr.substr( 0, yearPos ) );
|
|
int month = std::stoi( aDateStr.substr( yearPos + 3, monthPos - yearPos - 3 ) ); // 3 bytes for CJK year marker
|
|
int day = std::stoi( aDateStr.substr( monthPos + 3, dayPos - monthPos - 3 ) ); // 3 bytes for CJK month marker
|
|
|
|
parts = { year, month, day };
|
|
}
|
|
catch( ... )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
else if( aDateStr.find( '-' ) != std::string::npos )
|
|
separator = '-';
|
|
else if( aDateStr.find( '/' ) != std::string::npos )
|
|
separator = '/';
|
|
else if( aDateStr.find( '.' ) != std::string::npos )
|
|
separator = '.';
|
|
|
|
if( separator )
|
|
{
|
|
while( std::getline( iss, token, separator ) )
|
|
{
|
|
try
|
|
{
|
|
parts.push_back( std::stoi( token ) );
|
|
}
|
|
catch( ... )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
}
|
|
else if( !isCjkFormat && aDateStr.length() == 8 )
|
|
{
|
|
try
|
|
{
|
|
int dateNum = std::stoi( aDateStr );
|
|
int year = dateNum / 10000;
|
|
int month = ( dateNum / 100 ) % 100;
|
|
int day = dateNum % 100;
|
|
return YmdToDays( year, month, day );
|
|
}
|
|
catch( ... )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
else if( !isCjkFormat )
|
|
{
|
|
return std::nullopt;
|
|
}
|
|
|
|
if( parts.empty() || parts.size() > 3 )
|
|
return std::nullopt;
|
|
|
|
int year, month, day;
|
|
|
|
if( parts.size() == 1 )
|
|
{
|
|
year = parts[0];
|
|
month = 1;
|
|
day = 1;
|
|
}
|
|
else if( parts.size() == 2 )
|
|
{
|
|
year = parts[0];
|
|
month = parts[1];
|
|
day = 1;
|
|
}
|
|
else
|
|
{
|
|
if( isCjkFormat )
|
|
{
|
|
// CJK formats are always in YYYY年MM月DD日 or YYYY년 MM월 DD일 order
|
|
year = parts[0];
|
|
month = parts[1];
|
|
day = parts[2];
|
|
}
|
|
else if( separator == '/' && parts[0] <= 12 && parts[1] <= 31 )
|
|
{
|
|
month = parts[0];
|
|
day = parts[1];
|
|
year = parts[2];
|
|
}
|
|
else if( separator == '/' && parts[1] <= 12 )
|
|
{
|
|
day = parts[0];
|
|
month = parts[1];
|
|
year = parts[2];
|
|
}
|
|
else
|
|
{
|
|
year = parts[0];
|
|
month = parts[1];
|
|
day = parts[2];
|
|
}
|
|
}
|
|
|
|
if( month < 1 || month > 12 )
|
|
return std::nullopt;
|
|
if( day < 1 || day > daysInMonthForYear( month, year ) )
|
|
return std::nullopt;
|
|
|
|
return YmdToDays( year, month, day );
|
|
}
|
|
|
|
static auto FormatDate( int aDaysSinceEpoch, const std::string& aFormat ) -> std::string
|
|
{
|
|
auto [year, month, day] = DaysToYmd( aDaysSinceEpoch );
|
|
|
|
if( aFormat == "ISO" || aFormat == "iso" )
|
|
return fmt::format( "{:04d}-{:02d}-{:02d}", year, month, day );
|
|
else if( aFormat == "US" || aFormat == "us" )
|
|
return fmt::format( "{:02d}/{:02d}/{:04d}", month, day, year );
|
|
else if( aFormat == "EU" || aFormat == "european" )
|
|
return fmt::format( "{:02d}/{:02d}/{:04d}", day, month, year );
|
|
else if( aFormat == "long" )
|
|
return fmt::format( "{} {}, {}", monthNames[month-1], day, year );
|
|
else if( aFormat == "short" )
|
|
return fmt::format( "{} {}, {}", monthAbbrev[month-1], day, year );
|
|
else if( aFormat == "Chinese" || aFormat == "chinese" || aFormat == "CN" || aFormat == "cn" || aFormat == "中文" )
|
|
return fmt::format( "{}年{:02d}月{:02d}日", year, month, day );
|
|
else if( aFormat == "Japanese" || aFormat == "japanese" || aFormat == "JP" || aFormat == "jp" || aFormat == "日本語" )
|
|
return fmt::format( "{}年{:02d}月{:02d}日", year, month, day );
|
|
else if( aFormat == "Korean" || aFormat == "korean" || aFormat == "KR" || aFormat == "kr" || aFormat == "한국어" )
|
|
return fmt::format( "{}년 {:02d}월 {:02d}일", year, month, day );
|
|
else
|
|
return fmt::format( "{:04d}-{:02d}-{:02d}", year, month, day );
|
|
}
|
|
|
|
static auto GetWeekdayName( int aDaysSinceEpoch ) -> std::string
|
|
{
|
|
int weekday = ( ( aDaysSinceEpoch + 3 ) % 7 ); // +3 because epoch was Thursday (Monday = 0)
|
|
|
|
if( weekday < 0 )
|
|
weekday += 7;
|
|
|
|
return std::string{ weekdayNames[weekday] };
|
|
}
|
|
|
|
static auto GetCurrentDays() -> int
|
|
{
|
|
auto now = std::chrono::system_clock::now();
|
|
auto timeT = std::chrono::system_clock::to_time_t( now );
|
|
return static_cast<int>( timeT / ( 24 * 3600 ) );
|
|
}
|
|
|
|
static auto GetCurrentTimestamp() -> double
|
|
{
|
|
auto now = std::chrono::system_clock::now();
|
|
auto timeT = std::chrono::system_clock::to_time_t( now );
|
|
return static_cast<double>( timeT );
|
|
}
|
|
};
|
|
|
|
EVAL_VISITOR::EVAL_VISITOR( VariableCallback aVariableCallback, ERROR_COLLECTOR& aErrorCollector ) :
|
|
m_variableCallback( std::move( aVariableCallback ) ),
|
|
m_errors( aErrorCollector ),
|
|
m_gen( m_rd() )
|
|
{}
|
|
|
|
auto EVAL_VISITOR::operator()( const NODE& aNode ) const -> Result<Value>
|
|
{
|
|
switch( aNode.type )
|
|
{
|
|
case NodeType::Number:
|
|
return MakeValue<Value>( std::get<double>( aNode.data ) );
|
|
|
|
case NodeType::String:
|
|
return MakeValue<Value>( std::get<std::string>( aNode.data ) );
|
|
|
|
case NodeType::Var:
|
|
{
|
|
const auto& varName = std::get<std::string>( aNode.data );
|
|
|
|
// Use callback to resolve variable
|
|
if( m_variableCallback )
|
|
return m_variableCallback( varName );
|
|
|
|
return MakeError<Value>( fmt::format( "No variable resolver configured for: {}", varName ) );
|
|
}
|
|
|
|
case NodeType::BinOp:
|
|
{
|
|
const auto& binop = std::get<BIN_OP_DATA>( aNode.data );
|
|
auto leftResult = binop.left->Accept( *this );
|
|
if( !leftResult )
|
|
return leftResult;
|
|
|
|
auto rightResult = binop.right ?
|
|
binop.right->Accept( *this ) : MakeValue<Value>( 0.0 );
|
|
if( !rightResult )
|
|
return rightResult;
|
|
|
|
// Special handling for string concatenation with +
|
|
if( binop.op == '+' )
|
|
{
|
|
const auto& leftVal = leftResult.GetValue();
|
|
const auto& rightVal = rightResult.GetValue();
|
|
|
|
// If either operand is a string, concatenate
|
|
if( std::holds_alternative<std::string>( leftVal ) ||
|
|
std::holds_alternative<std::string>( rightVal ) )
|
|
{
|
|
return MakeValue<Value>( VALUE_UTILS::ConcatStrings( leftVal, rightVal ) );
|
|
}
|
|
}
|
|
|
|
// Otherwise, perform arithmetic
|
|
return VALUE_UTILS::ArithmeticOp( leftResult.GetValue(), rightResult.GetValue(), binop.op );
|
|
}
|
|
|
|
case NodeType::Function:
|
|
{
|
|
const auto& func = std::get<FUNC_DATA>( aNode.data );
|
|
return evaluateFunction( func );
|
|
}
|
|
|
|
default:
|
|
return MakeError<Value>( "Cannot evaluate this node type" );
|
|
}
|
|
}
|
|
|
|
auto EVAL_VISITOR::evaluateFunction( const FUNC_DATA& aFunc ) const -> Result<Value>
|
|
{
|
|
const auto& name = aFunc.name;
|
|
const auto& args = aFunc.args;
|
|
|
|
// Zero-argument functions
|
|
if( args.empty() )
|
|
{
|
|
if( name == "today" )
|
|
return MakeValue<Value>( static_cast<double>( DATE_UTILS::GetCurrentDays() ) );
|
|
else if( name == "now" )
|
|
return MakeValue<Value>( DATE_UTILS::GetCurrentTimestamp() );
|
|
else if( name == "random" )
|
|
{
|
|
std::uniform_real_distribution<double> dis( 0.0, 1.0 );
|
|
return MakeValue<Value>( dis( m_gen ) );
|
|
}
|
|
}
|
|
|
|
// Evaluate arguments to mixed types
|
|
std::vector<Value> argValues;
|
|
argValues.reserve( args.size() );
|
|
|
|
for( const auto& arg : args )
|
|
{
|
|
auto result = arg->Accept( *this );
|
|
if( !result )
|
|
return result;
|
|
|
|
argValues.push_back( result.GetValue() );
|
|
}
|
|
|
|
const auto argc = argValues.size();
|
|
|
|
// String formatting functions (return strings!)
|
|
if( name == "format" && argc >= 1 )
|
|
{
|
|
auto numResult = VALUE_UTILS::ToDouble( argValues[0] );
|
|
if( !numResult )
|
|
return MakeError<Value>( numResult.GetError() );
|
|
|
|
const auto value = numResult.GetValue();
|
|
int decimals = 2;
|
|
if( argc > 1 )
|
|
{
|
|
auto decResult = VALUE_UTILS::ToDouble( argValues[1] );
|
|
if( decResult )
|
|
decimals = static_cast<int>( decResult.GetValue() );
|
|
}
|
|
|
|
return MakeValue<Value>( fmt::format( "{:.{}f}", value, decimals ) );
|
|
}
|
|
else if( name == "currency" && argc >= 1 )
|
|
{
|
|
auto numResult = VALUE_UTILS::ToDouble( argValues[0] );
|
|
if( !numResult )
|
|
return MakeError<Value>( numResult.GetError() );
|
|
|
|
const auto amount = numResult.GetValue();
|
|
const auto symbol = argc > 1 ? VALUE_UTILS::ToString( argValues[1] ) : "$";
|
|
|
|
return MakeValue<Value>( fmt::format( "{}{:.2f}", symbol, amount ) );
|
|
}
|
|
else if( name == "fixed" && argc >= 1 )
|
|
{
|
|
auto numResult = VALUE_UTILS::ToDouble( argValues[0] );
|
|
if( !numResult )
|
|
return MakeError<Value>( numResult.GetError() );
|
|
|
|
const auto value = numResult.GetValue();
|
|
int decimals = 2;
|
|
if( argc > 1 )
|
|
{
|
|
auto decResult = VALUE_UTILS::ToDouble( argValues[1] );
|
|
if( decResult )
|
|
decimals = static_cast<int>( decResult.GetValue() );
|
|
}
|
|
|
|
return MakeValue<Value>( fmt::format( "{:.{}f}", value, decimals ) );
|
|
}
|
|
|
|
// Date formatting functions (return strings!)
|
|
else if( name == "dateformat" && argc >= 1 )
|
|
{
|
|
auto dateResult = VALUE_UTILS::ToDouble( argValues[0] );
|
|
if( !dateResult )
|
|
return MakeError<Value>( dateResult.GetError() );
|
|
|
|
const auto days = static_cast<int>( dateResult.GetValue() );
|
|
const auto format = argc > 1 ? VALUE_UTILS::ToString( argValues[1] ) : "ISO";
|
|
|
|
return MakeValue<Value>( DATE_UTILS::FormatDate( days, format ) );
|
|
}
|
|
else if( name == "datestring" && argc == 1 )
|
|
{
|
|
auto dateStr = VALUE_UTILS::ToString( argValues[0] );
|
|
auto daysResult = DATE_UTILS::ParseDate( dateStr );
|
|
|
|
if( !daysResult )
|
|
return MakeError<Value>( "Invalid date format: " + dateStr );
|
|
|
|
return MakeValue<Value>( static_cast<double>( daysResult.value() ) );
|
|
}
|
|
else if( name == "weekdayname" && argc == 1 )
|
|
{
|
|
auto dateResult = VALUE_UTILS::ToDouble( argValues[0] );
|
|
if( !dateResult )
|
|
return MakeError<Value>( dateResult.GetError() );
|
|
|
|
const auto days = static_cast<int>( dateResult.GetValue() );
|
|
return MakeValue<Value>( DATE_UTILS::GetWeekdayName( days ) );
|
|
}
|
|
|
|
// String functions (return strings!)
|
|
else if( name == "upper" && argc == 1 )
|
|
{
|
|
auto str = VALUE_UTILS::ToString( argValues[0] );
|
|
std::transform( str.begin(), str.end(), str.begin(), ::toupper );
|
|
return MakeValue<Value>( str );
|
|
}
|
|
else if( name == "lower" && argc == 1 )
|
|
{
|
|
auto str = VALUE_UTILS::ToString( argValues[0] );
|
|
std::transform( str.begin(), str.end(), str.begin(), ::tolower );
|
|
return MakeValue<Value>( str );
|
|
}
|
|
else if( name == "concat" && argc >= 2 )
|
|
{
|
|
std::string result;
|
|
for( const auto& val : argValues )
|
|
result += VALUE_UTILS::ToString( val );
|
|
|
|
return MakeValue<Value>( result );
|
|
}
|
|
|
|
// Conditional functions (handle mixed types)
|
|
if( name == "if" && argc == 3 )
|
|
{
|
|
// Convert only the condition to a number
|
|
auto conditionResult = VALUE_UTILS::ToDouble( argValues[0] );
|
|
if( !conditionResult )
|
|
return MakeError<Value>( conditionResult.GetError() );
|
|
|
|
const auto condition = conditionResult.GetValue() != 0.0;
|
|
return MakeValue<Value>( condition ? argValues[1] : argValues[2] );
|
|
}
|
|
|
|
// Mathematical functions (return numbers) - convert args to doubles first
|
|
std::vector<double> numArgs;
|
|
for( const auto& val : argValues )
|
|
{
|
|
auto numResult = VALUE_UTILS::ToDouble( val );
|
|
if( !numResult )
|
|
return MakeError<Value>( numResult.GetError() );
|
|
|
|
numArgs.push_back( numResult.GetValue() );
|
|
}
|
|
|
|
// Mathematical function implementations
|
|
if( name == "abs" && argc == 1 )
|
|
return MakeValue<Value>( std::abs( numArgs[0] ) );
|
|
else if( name == "sum" && argc >= 1 )
|
|
return MakeValue<Value>( std::accumulate( numArgs.begin(), numArgs.end(), 0.0 ) );
|
|
else if( name == "round" && argc >= 1 )
|
|
{
|
|
const auto value = numArgs[0];
|
|
const auto precision = argc > 1 ? static_cast<int>( numArgs[1] ) : 0;
|
|
const auto multiplier = std::pow( 10.0, precision );
|
|
return MakeValue<Value>( std::round( value * multiplier ) / multiplier );
|
|
}
|
|
else if( name == "sqrt" && argc == 1 )
|
|
{
|
|
if( numArgs[0] < 0 )
|
|
return MakeError<Value>( "Square root of negative number" );
|
|
|
|
return MakeValue<Value>( std::sqrt( numArgs[0] ) );
|
|
}
|
|
else if( name == "pow" && argc == 2 )
|
|
return MakeValue<Value>( std::pow( numArgs[0], numArgs[1] ) );
|
|
else if( name == "floor" && argc == 1 )
|
|
return MakeValue<Value>( std::floor( numArgs[0] ) );
|
|
else if( name == "ceil" && argc == 1 )
|
|
return MakeValue<Value>( std::ceil( numArgs[0] ) );
|
|
else if( name == "min" && argc >= 1 )
|
|
return MakeValue<Value>( *std::min_element( numArgs.begin(), numArgs.end() ) );
|
|
else if( name == "max" && argc >= 1 )
|
|
return MakeValue<Value>( *std::max_element( numArgs.begin(), numArgs.end() ) );
|
|
else if( name == "avg" && argc >= 1 )
|
|
{
|
|
const auto sum = std::accumulate( numArgs.begin(), numArgs.end(), 0.0 );
|
|
return MakeValue<Value>( sum / static_cast<double>( argc ) );
|
|
}
|
|
|
|
return MakeError<Value>( fmt::format( "Unknown function: {} with {} arguments", name, argc ) );
|
|
}
|
|
|
|
auto DOC_PROCESSOR::Process( const DOC& aDoc, VariableCallback aVariableCallback )
|
|
-> std::pair<std::string, bool>
|
|
{
|
|
std::string result;
|
|
auto localErrors = ERROR_COLLECTOR{};
|
|
EVAL_VISITOR evaluator{ std::move( aVariableCallback ), localErrors };
|
|
bool hadErrors = aDoc.HasErrors();
|
|
|
|
for( const auto& node : aDoc.GetNodes() )
|
|
{
|
|
switch( node->type )
|
|
{
|
|
case NodeType::Text:
|
|
result += std::get<std::string>( node->data );
|
|
break;
|
|
|
|
case NodeType::Calc:
|
|
{
|
|
const auto& calcData = std::get<BIN_OP_DATA>( node->data );
|
|
auto evalResult = calcData.left->Accept( evaluator );
|
|
|
|
if( evalResult )
|
|
result += VALUE_UTILS::ToString( evalResult.GetValue() );
|
|
else
|
|
{
|
|
// Don't add error formatting to result - errors go to error vector only
|
|
// The higher level will return original input unchanged if there are errors
|
|
hadErrors = true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
result += "[Unknown node type]";
|
|
hadErrors = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return { std::move( result ), hadErrors || localErrors.HasErrors() };
|
|
}
|
|
|
|
auto DOC_PROCESSOR::ProcessWithDetails( const DOC& aDoc, VariableCallback aVariableCallback )
|
|
-> std::tuple<std::string, std::vector<std::string>, bool>
|
|
{
|
|
auto [result, hadErrors] = Process( aDoc, std::move( aVariableCallback ) );
|
|
auto allErrors = aDoc.GetErrors();
|
|
|
|
return { std::move( result ), std::move( allErrors ), hadErrors };
|
|
}
|
|
|
|
} // namespace calc_parser
|