#include <numeric_evaluator.h>

Classes
struct	Token

struct	TokenStat

Public Member Functions
	NUMERIC_EVALUATOR (EDA_UNITS aUnits)

	~NUMERIC_EVALUATOR ()

void	Clear ()

void	parseError (const char *s)

void	parseOk ()

void	parseSetResult (double)

bool	IsValid () const

wxString	Result () const

bool	Process (const wxString &aString)

wxString	OriginalText () const

void	SetVar (const wxString &aString, double aValue)

double	GetVar (const wxString &aString)

void	RemoveVar (const wxString &aString)

void	ClearVar ()

Protected Member Functions
void	newString (const wxString &aString)

Token	getToken ()

void	parse (int token, numEval::TokenType value)

Private Types
enum	Unit { Unit::Invalid, Unit::MM, Unit::CM, Unit::Inch, Unit::Mil }

Private Attributes
void *	m_parser

struct NUMERIC_EVALUATOR::TokenStat	m_token

char	m_localeDecimalSeparator

bool	m_parseError

bool	m_parseFinished

Unit	m_defaultUnits

wxString	m_originalText

std::map< wxString, double >	m_varMap

Detailed Description

Definition at line 94 of file numeric_evaluator.h.

Member Enumeration Documentation

◆ Unit

enum NUMERIC_EVALUATOR::Unit

strongprivate

Enumerator
Invalid
MM
CM
Inch
Mil

Definition at line 96 of file numeric_evaluator.h.

96 { Invalid, MM, CM, Inch, Mil };

Constructor & Destructor Documentation

◆ NUMERIC_EVALUATOR()

NUMERIC_EVALUATOR::NUMERIC_EVALUATOR ( EDA_UNITS aUnits )

Definition at line 46 of file numeric_evaluator.cpp.

 {
     struct lconv* lc = localeconv();
     m_localeDecimalSeparator = *lc->decimal_point;
 
     m_parseError = false;
     m_parseFinished = false;
 
     m_parser = numEval::ParseAlloc( malloc );
 
     switch( aUnits )
     {
     case EDA_UNITS::MILLIMETRES: m_defaultUnits = Unit::MM; break;
     case EDA_UNITS::MILS: m_defaultUnits = Unit::Mil; break;
     case EDA_UNITS::INCHES: m_defaultUnits = Unit::Inch; break;
     default: m_defaultUnits = Unit::MM; break;
     }
 }

References Inch, INCHES, m_defaultUnits, m_localeDecimalSeparator, m_parseError, m_parseFinished, m_parser, Mil, MILLIMETRES, MILS, and MM.

◆ ~NUMERIC_EVALUATOR()

NUMERIC_EVALUATOR::~NUMERIC_EVALUATOR ( )

Definition at line 66 of file numeric_evaluator.cpp.

 {
     numEval::ParseFree( m_parser, free );
 
     // Allow explicit call to destructor
     m_parser = nullptr;
 
     Clear();
 }

References Clear(), and m_parser.

Member Function Documentation

◆ Clear()

void NUMERIC_EVALUATOR::Clear ( )

Definition at line 77 of file numeric_evaluator.cpp.

 {
     free( m_token.token );
     m_token.token = nullptr;
     m_token.input = nullptr;
     m_parseError = true;
     m_originalText = wxEmptyString;
 }

References NUMERIC_EVALUATOR::TokenStat::input, m_originalText, m_parseError, m_token, and NUMERIC_EVALUATOR::TokenStat::token.

Referenced by UNIT_BINDER::ChangeValue(), newString(), TEXT_CTRL_EVAL::SetValue(), UNIT_BINDER::SetValue(), and ~NUMERIC_EVALUATOR().

◆ ClearVar()

void NUMERIC_EVALUATOR::ClearVar ( )

inline

Definition at line 137 of file numeric_evaluator.h.

137 { m_varMap.clear(); }

NUMERIC_EVALUATOR::m_varMap

std::map< wxString, double > m_varMap

Definition: numeric_evaluator.h:181

References m_varMap.

◆ getToken()

NUMERIC_EVALUATOR::Token NUMERIC_EVALUATOR::getToken ( )

protected

Definition at line 169 of file numeric_evaluator.cpp.

 {
     Token retval;
     size_t idx;
 
     retval.token = ENDS;
     retval.value.dValue = 0;
 
     if( m_token.token == nullptr )
         return retval;
 
     if( m_token.input == nullptr )
         return retval;
 
     if( m_token.pos >= m_token.inputLen )
         return retval;
 
     auto isDecimalSeparator = [ & ]( char ch ) -> bool {
         return ( ch == m_localeDecimalSeparator || ch == '.' || ch == ',' );
     };
 
     // Lambda: get value as string, store into clToken.token and update current index.
     auto extractNumber = [ & ]() {
         bool haveSeparator = false;
         idx = 0;
         auto ch = m_token.input[ m_token.pos ];
 
         do
         {
             if( isDecimalSeparator( ch ) && haveSeparator )
                 break;
 
             m_token.token[ idx++ ] = ch;
 
             if( isDecimalSeparator( ch ))
                 haveSeparator = true;
 
             ch = m_token.input[ ++m_token.pos ];
         } while( isdigit( ch ) || isDecimalSeparator( ch ));
 
         m_token.token[ idx ] = 0;
 
         // Ensure that the systems decimal separator is used
         for( int i = strlen( m_token.token ); i; i-- )
             if( isDecimalSeparator( m_token.token[ i - 1 ] ))
                 m_token.token[ i - 1 ] = m_localeDecimalSeparator;
     };
 
     // Lamda: Get unit for current token.
     // Valid units are ", in, mm, mil and thou.  Returns Unit::Invalid otherwise.
     auto checkUnit = [ this ]() -> Unit {
         char ch = m_token.input[ m_token.pos ];
 
         if( ch == '"' )
         {
             m_token.pos++;
             return Unit::Inch;
         }
 
         // Do not use strcasecmp() as it is not available on all platforms
         const char* cptr = &m_token.input[ m_token.pos ];
         const auto sizeLeft = m_token.inputLen - m_token.pos;
 
         if( sizeLeft >= 2 && ch == 'm' && cptr[ 1 ] == 'm' && !isalnum( cptr[ 2 ] ))
         {
             m_token.pos += 2;
             return Unit::MM;
         }
 
         if( sizeLeft >= 2 && ch == 'c' && cptr[ 1 ] == 'm' && !isalnum( cptr[ 2 ] ))
         {
             m_token.pos += 2;
             return Unit::CM;
         }
 
         if( sizeLeft >= 2 && ch == 'i' && cptr[ 1 ] == 'n' && !isalnum( cptr[ 2 ] ))
         {
             m_token.pos += 2;
             return Unit::Inch;
         }
 
         if( sizeLeft >= 3 && ch == 'm' && cptr[ 1 ] == 'i' && cptr[ 2 ] == 'l' && !isalnum( cptr[ 3 ] ))
         {
             m_token.pos += 3;
             return Unit::Mil;
         }
 
         if( sizeLeft >= 4 && ch == 't' && cptr[ 1 ] == 'h' && cptr[ 2 ] == 'o' && cptr[ 3 ] == 'u' && !isalnum( cptr[ 4 ] ))
         {
             m_token.pos += 4;
             return Unit::Mil;
         }
 
         return Unit::Invalid;
     };
 
     char ch;
 
     // Start processing of first/next token: Remove whitespace
     for( ;; )
     {
         ch = m_token.input[ m_token.pos ];
 
         if( ch == ' ' )
             m_token.pos++;
         else
             break;
     }
 
     Unit convertFrom;
 
     if( ch == 0 )
     {
         /* End of input */
     }
     else if( isdigit( ch ) || isDecimalSeparator( ch ))
     {
         // VALUE
         extractNumber();
         retval.token = VALUE;
         retval.value.dValue = atof( m_token.token );
     }
     else if(( convertFrom = checkUnit()) != Unit::Invalid )
     {
         // UNIT
         // Units are appended to a VALUE.
         // Determine factor to default unit if unit for value is given.
         // Example: Default is mm, unit is inch: factor is 25.4
         // The factor is assigned to the terminal UNIT. The actual
         // conversion is done within a parser action.
         retval.token = UNIT;
         if( m_defaultUnits == Unit::MM )
         {
             switch( convertFrom )
             {
             case Unit::Inch    :retval.value.dValue = 25.4;          break;
             case Unit::Mil     :retval.value.dValue = 25.4 / 1000.0; break;
             case Unit::MM      :retval.value.dValue = 1.0;           break;
             case Unit::CM      :retval.value.dValue = 10.0;          break;
             case Unit::Invalid :break;
             }
         }
         else if( m_defaultUnits == Unit::Inch )
         {
             switch( convertFrom )
             {
             case Unit::Inch    :retval.value.dValue = 1.0;          break;
             case Unit::Mil     :retval.value.dValue = 1.0 / 1000.0; break;
             case Unit::MM      :retval.value.dValue = 1.0 / 25.4;   break;
             case Unit::CM      :retval.value.dValue = 1.0 / 2.54;   break;
             case Unit::Invalid :break;
             }
         }
         else if( m_defaultUnits == Unit::Mil )
         {
             switch( convertFrom )
             {
             case Unit::Inch    :retval.value.dValue = 1.0 * 1000.0;  break;
             case Unit::Mil     :retval.value.dValue = 1.0;           break;
             case Unit::MM      :retval.value.dValue = 1000.0 / 25.4; break;
             case Unit::CM      :retval.value.dValue = 1000.0 / 2.54; break;
             case Unit::Invalid :break;
             }
         }
     }
     else if( isalpha( ch ))
     {
         // VAR
         const char* cptr = &m_token.input[ m_token.pos ];
         cptr++;
 
         while( isalnum( *cptr ))
             cptr++;
 
         retval.token = VAR;
         size_t bytesToCopy = cptr - &m_token.input[ m_token.pos ];
 
         if( bytesToCopy >= sizeof( retval.value.text ))
             bytesToCopy = sizeof( retval.value.text ) - 1;
 
         strncpy( retval.value.text, &m_token.input[ m_token.pos ], bytesToCopy );
         retval.value.text[ bytesToCopy ] = 0;
         m_token.pos += cptr - &m_token.input[ m_token.pos ];
     }
     else
     {
         // Single char tokens
         switch( ch )
         {
         case '+' :retval.token = PLUS;   break;
         case '-' :retval.token = MINUS;  break;
         case '*' :retval.token = MULT;   break;
         case '/' :retval.token = DIVIDE; break;
         case '(' :retval.token = PARENL; break;
         case ')' :retval.token = PARENR; break;
         case '=' :retval.token = ASSIGN; break;
         case ';' :retval.token = SEMCOL; break;
         default  :m_parseError = true;   break;   /* invalid character */
         }
         m_token.pos++;
     }
 
     return retval;
 }

References CM, numEval::TokenType::dValue, Inch, NUMERIC_EVALUATOR::TokenStat::input, NUMERIC_EVALUATOR::TokenStat::inputLen, Invalid, m_defaultUnits, m_localeDecimalSeparator, m_parseError, m_token, Mil, MM, NUMERIC_EVALUATOR::TokenStat::pos, numEval::TokenType::text, NUMERIC_EVALUATOR::Token::token, NUMERIC_EVALUATOR::TokenStat::token, and NUMERIC_EVALUATOR::Token::value.

Referenced by Process().

◆ GetVar()

double NUMERIC_EVALUATOR::GetVar ( const wxString & aString )

Definition at line 379 of file numeric_evaluator.cpp.

 {
     if( m_varMap[ aString ] )
         return m_varMap[ aString ];
     else
         return 0.0;
 }

References m_varMap.

◆ IsValid()

bool NUMERIC_EVALUATOR::IsValid ( ) const

inline

Definition at line 113 of file numeric_evaluator.h.

113 { return !m_parseError; }

NUMERIC_EVALUATOR::m_parseError

bool m_parseError

Definition: numeric_evaluator.h:174

References m_parseError.

◆ newString()

void NUMERIC_EVALUATOR::newString ( const wxString & aString )

protected

Definition at line 153 of file numeric_evaluator.cpp.

 {
     Clear();
 
     m_originalText = aString;
 
     m_token.token = reinterpret_cast<decltype( m_token.token )>( malloc( TokenStat::OutLen + 1 ) );
     strcpy( m_token.token, "0" );
     m_token.inputLen = aString.length();
     m_token.pos = 0;
     m_token.input = aString.mb_str();
 
     m_parseFinished = false;
 }

References Clear(), NUMERIC_EVALUATOR::TokenStat::input, NUMERIC_EVALUATOR::TokenStat::inputLen, m_originalText, m_parseFinished, m_token, NUMERIC_EVALUATOR::TokenStat::OutLen, NUMERIC_EVALUATOR::TokenStat::pos, and NUMERIC_EVALUATOR::TokenStat::token.

Referenced by Process().

◆ OriginalText()

wxString NUMERIC_EVALUATOR::OriginalText ( ) const

Definition at line 115 of file numeric_evaluator.cpp.

 {
     return m_originalText;
 }

References m_originalText.

Referenced by UNIT_BINDER::GetOriginalText(), UNIT_BINDER::onSetFocus(), and TEXT_CTRL_EVAL::onTextFocusGet().

◆ parse()

void NUMERIC_EVALUATOR::parse	(	int	token,
		numEval::TokenType	value
	)

protected

◆ parseError()

void NUMERIC_EVALUATOR::parseError ( const char * s )

Definition at line 87 of file numeric_evaluator.cpp.

 {
     m_parseError = true;
 }

References m_parseError.

◆ parseOk()

void NUMERIC_EVALUATOR::parseOk ( )

Definition at line 93 of file numeric_evaluator.cpp.

 {
     m_parseFinished = true;
 }

References m_parseFinished.

◆ parseSetResult()

void NUMERIC_EVALUATOR::parseSetResult ( double val )

Definition at line 99 of file numeric_evaluator.cpp.

 {
     if( std::isnan( val ) )
     {
         // Naively printing this with %g produces "nan" on some platforms
         // and "-nan(ind)" on others (e.g. MSVC). So force a "standard" string.
         snprintf( m_token.token, m_token.OutLen, "%s", "NaN" );
     }
     else
     {
         // Can be printed as a floating point
         snprintf( m_token.token, m_token.OutLen, "%.10g", val );
     }
 }

References m_token, NUMERIC_EVALUATOR::TokenStat::OutLen, and NUMERIC_EVALUATOR::TokenStat::token.

◆ Process()

bool NUMERIC_EVALUATOR::Process ( const wxString & aString )

Definition at line 121 of file numeric_evaluator.cpp.

 {
     // Feed parser token after token until end of input.
 
     newString( aString );
     m_parseError = false;
     m_parseFinished = false;
     Token tok;
 
     if( aString.IsEmpty() )
     {
         m_parseFinished = true;
         return true;
     }
 
     do
     {
         tok = getToken();
         numEval::Parse( m_parser, tok.token, tok.value, this );
 
         if( m_parseFinished || tok.token == ENDS )
         {
             // Reset parser by passing zero as token ID, value is ignored.
             numEval::Parse( m_parser, 0, tok.value, this );
             break;
         }
     } while( tok.token );
 
     return !m_parseError;
 }

References getToken(), m_parseError, m_parseFinished, m_parser, newString(), NUMERIC_EVALUATOR::Token::token, and NUMERIC_EVALUATOR::Token::value.

Referenced by TEXT_CTRL_EVAL::evaluate(), UNIT_BINDER::GetDoubleValue(), UNIT_BINDER::GetValue(), and UNIT_BINDER::onKillFocus().

◆ RemoveVar()

void NUMERIC_EVALUATOR::RemoveVar ( const wxString & aString )

inline

Definition at line 134 of file numeric_evaluator.h.

134 { m_varMap.erase( aString ); }

NUMERIC_EVALUATOR::m_varMap

std::map< wxString, double > m_varMap

Definition: numeric_evaluator.h:181

References m_varMap.

◆ Result()

wxString NUMERIC_EVALUATOR::Result ( ) const

inline

Definition at line 116 of file numeric_evaluator.h.

116 { return wxString::FromUTF8( m_token.token ); }

NUMERIC_EVALUATOR::m_token

struct NUMERIC_EVALUATOR::TokenStat m_token

NUMERIC_EVALUATOR::TokenStat::token

char * token

Definition: numeric_evaluator.h:165

References m_token, and NUMERIC_EVALUATOR::TokenStat::token.

Referenced by TEXT_CTRL_EVAL::evaluate(), UNIT_BINDER::GetDoubleValue(), UNIT_BINDER::GetValue(), and UNIT_BINDER::onKillFocus().

◆ SetVar()

void NUMERIC_EVALUATOR::SetVar	(	const wxString &	aString,
		double	aValue
	)

Definition at line 374 of file numeric_evaluator.cpp.

 {
     m_varMap[ aString ] = aValue;
 }

References m_varMap.

Member Data Documentation

◆ m_defaultUnits

Unit NUMERIC_EVALUATOR::m_defaultUnits

private

Definition at line 177 of file numeric_evaluator.h.

Referenced by getToken(), and NUMERIC_EVALUATOR().

◆ m_localeDecimalSeparator

char NUMERIC_EVALUATOR::m_localeDecimalSeparator

private

Definition at line 171 of file numeric_evaluator.h.

Referenced by getToken(), and NUMERIC_EVALUATOR().

◆ m_originalText

wxString NUMERIC_EVALUATOR::m_originalText

private

Definition at line 179 of file numeric_evaluator.h.

Referenced by Clear(), newString(), and OriginalText().

◆ m_parseError

bool NUMERIC_EVALUATOR::m_parseError

private

Definition at line 174 of file numeric_evaluator.h.

Referenced by Clear(), getToken(), IsValid(), NUMERIC_EVALUATOR(), parseError(), and Process().

◆ m_parseFinished

bool NUMERIC_EVALUATOR::m_parseFinished

private

Definition at line 175 of file numeric_evaluator.h.

Referenced by newString(), NUMERIC_EVALUATOR(), parseOk(), and Process().

◆ m_parser

void* NUMERIC_EVALUATOR::m_parser

private

Definition at line 157 of file numeric_evaluator.h.

Referenced by NUMERIC_EVALUATOR(), Process(), and ~NUMERIC_EVALUATOR().

◆ m_token

struct NUMERIC_EVALUATOR::TokenStat NUMERIC_EVALUATOR::m_token

private

Referenced by Clear(), getToken(), newString(), parseSetResult(), and Result().

◆ m_varMap

std::map<wxString, double> NUMERIC_EVALUATOR::m_varMap

private

Definition at line 181 of file numeric_evaluator.h.

Referenced by ClearVar(), GetVar(), RemoveVar(), and SetVar().

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ Unit

Constructor & Destructor Documentation

◆ NUMERIC_EVALUATOR()

◆ ~NUMERIC_EVALUATOR()

Member Function Documentation

◆ Clear()

◆ ClearVar()

◆ getToken()

◆ GetVar()

◆ IsValid()

◆ newString()

◆ OriginalText()

◆ parse()

◆ parseError()

◆ parseOk()

◆ parseSetResult()

◆ Process()

◆ RemoveVar()

◆ Result()

◆ SetVar()

Member Data Documentation

◆ m_defaultUnits

◆ m_localeDecimalSeparator

◆ m_originalText

◆ m_parseError

◆ m_parseFinished

◆ m_parser

◆ m_token

◆ m_varMap