PCB_EXPR_COMPILER Class Reference

#include <pcb_expr_evaluator.h>

Inheritance diagram for PCB_EXPR_COMPILER:

Public Member Functions
	PCB_EXPR_COMPILER (LIBEVAL::UNIT_RESOLVER *aUnitResolver)
void	Clear ()
void	parseError (const char *s)
void	parseOk ()
int	GetSourcePos () const
void	setRoot (LIBEVAL::TREE_NODE *root)
void	freeTree (LIBEVAL::TREE_NODE *tree)
bool	Compile (const wxString &aString, UCODE *aCode, CONTEXT *aPreflightContext)
void	SetErrorCallback (std::function< void(const wxString &aMessage, int aOffset)> aCallback)
bool	IsErrorPending () const
const ERROR_STATUS &	GetError () const
void	GcItem (TREE_NODE *aItem)
void	GcItem (wxString *aItem)

Protected Types
enum	LEXER_STATE { LS_DEFAULT = 0 , LS_STRING = 1 }

Protected Member Functions
bool	generateUCode (UCODE *aCode, CONTEXT *aPreflightContext)
void	reportError (COMPILATION_STAGE stage, const wxString &aErrorMsg, int aPos=-1)
void	newString (const wxString &aString)
T_TOKEN	getToken ()
bool	lexDefault (T_TOKEN &aToken)
bool	lexString (T_TOKEN &aToken)
int	resolveUnits ()

Protected Attributes
LEXER_STATE	m_lexerState
void *	m_parser
TOKENIZER	m_tokenizer
char	m_localeDecimalSeparator
std::unique_ptr< UNIT_RESOLVER >	m_unitResolver
int	m_sourcePos
bool	m_parseFinished
ERROR_STATUS	m_errorStatus
std::function< void(const wxString &aMessage, int aOffset)>	m_errorCallback
TREE_NODE *	m_tree
std::vector< TREE_NODE * >	m_gcItems
std::vector< wxString * >	m_gcStrings

Detailed Description

Definition at line 219 of file pcb_expr_evaluator.h.

Member Enumeration Documentation

LEXER_STATE

enum LIBEVAL::COMPILER::LEXER_STATE

protectedinherited

Enumerator
LS_DEFAULT
LS_STRING

Definition at line 523 of file libeval_compiler.h.

 {
 LS_DEFAULT = 0,
 LS_STRING = 1,
 };

Constructor & Destructor Documentation

PCB_EXPR_COMPILER()

PCB_EXPR_COMPILER::PCB_EXPR_COMPILER

(

LIBEVAL::UNIT_RESOLVER *

aUnitResolver

)

Definition at line 334 of file pcb_expr_evaluator.cpp.

{
 m_unitResolver.reset( aUnitResolver );
}

References LIBEVAL::COMPILER::m_unitResolver.

Member Function Documentation

Clear()

void LIBEVAL::COMPILER::Clear ( )

inherited

Definition at line 263 of file libeval_compiler.cpp.

{
 //free( current.token );
 m_tokenizer.Clear();
 
 if( m_tree )
 {
 freeTree( m_tree );
 m_tree = nullptr;
 }
 
 m_tree = nullptr;
 
 for( auto tok : m_gcItems )
 delete tok;
 
 for( auto tok: m_gcStrings )
 delete tok;
 
 m_gcItems.clear();
 m_gcStrings.clear();
}

References LIBEVAL::TOKENIZER::Clear(), LIBEVAL::COMPILER::freeTree(), LIBEVAL::COMPILER::m_gcItems, LIBEVAL::COMPILER::m_gcStrings, LIBEVAL::COMPILER::m_tokenizer, and LIBEVAL::COMPILER::m_tree.

Referenced by LIBEVAL::COMPILER::newString(), and LIBEVAL::COMPILER::~COMPILER().

Compile()

bool LIBEVAL::COMPILER::Compile ( const wxString &  aString, UCODE *  aCode, CONTEXT *  aPreflightContext  )

inherited

Definition at line 299 of file libeval_compiler.cpp.

{
 // Feed parser token after token until end of input.
 
 newString( aString );
 
 if( m_tree )
 {
 freeTree( m_tree );
 m_tree = nullptr;
 }
 
 m_tree = nullptr;
 m_parseFinished = false;
 T_TOKEN tok( defaultToken );
 
 libeval_dbg(0, "str: '%s' empty: %d\n", aString.c_str(), !!aString.empty() );
 
 if( aString.empty() )
 {
 m_parseFinished = true;
 return generateUCode( aCode, aPreflightContext );
 }
 
 do
 {
 m_sourcePos = m_tokenizer.GetPos();
 
 tok = getToken();
 
 if( tok.value.str )
 GcItem( tok.value.str );
 
 libeval_dbg(10, "parse: tok %d valstr %p\n", tok.token, tok.value.str );
 Parse( m_parser, tok.token, tok, this );
 
 if ( m_errorStatus.pendingError )
 return false;
 
 if( m_parseFinished || tok.token == G_ENDS )
 {
 // Reset parser by passing zero as token ID, value is ignored.
 Parse( m_parser, 0, tok, this );
 break;
 }
 } while( tok.token );
 
 return generateUCode( aCode, aPreflightContext );
}

References LIBEVAL::defaultToken, LIBEVAL::COMPILER::freeTree(), LIBEVAL::COMPILER::GcItem(), LIBEVAL::COMPILER::generateUCode(), LIBEVAL::TOKENIZER::GetPos(), LIBEVAL::COMPILER::getToken(), libeval_dbg, LIBEVAL::COMPILER::m_errorStatus, LIBEVAL::COMPILER::m_parseFinished, LIBEVAL::COMPILER::m_parser, LIBEVAL::COMPILER::m_sourcePos, LIBEVAL::COMPILER::m_tokenizer, LIBEVAL::COMPILER::m_tree, LIBEVAL::COMPILER::newString(), SIM_VALUE_PARSER::Parse(), LIBEVAL::ERROR_STATUS::pendingError, LIBEVAL::T_TOKEN_VALUE::str, LIBEVAL::T_TOKEN::token, and LIBEVAL::T_TOKEN::value.

Referenced by DRC_RULE_CONDITION::Compile(), PCB_EXPR_EVALUATOR::Evaluate(), and testEvalExpr().

freeTree()

void LIBEVAL::COMPILER::freeTree ( LIBEVAL::TREE_NODE *  tree )

inherited

Definition at line 690 of file libeval_compiler.cpp.

{
 if ( tree->leaf[0] )
 freeTree( tree->leaf[0] );
 
 if ( tree->leaf[1] )
 freeTree( tree->leaf[1] );
 
 delete tree->uop;
 tree->uop = nullptr;
}

References LIBEVAL::COMPILER::freeTree(), LIBEVAL::TREE_NODE::leaf, and LIBEVAL::TREE_NODE::uop.

Referenced by LIBEVAL::COMPILER::Clear(), LIBEVAL::COMPILER::Compile(), LIBEVAL::COMPILER::freeTree(), and LIBEVAL::COMPILER::~COMPILER().

GcItem() [1/2]

void LIBEVAL::COMPILER::GcItem ( TREE_NODE *  aItem )

inlineinherited

Definition at line 519 of file libeval_compiler.h.

{ m_gcItems.push_back( aItem ); }

References LIBEVAL::COMPILER::m_gcItems.

Referenced by LIBEVAL::COMPILER::Compile(), and LIBEVAL::newNode().

GcItem() [2/2]

void LIBEVAL::COMPILER::GcItem ( wxString *  aItem )

inlineinherited

Definition at line 520 of file libeval_compiler.h.

{ m_gcStrings.push_back( aItem ); }

References LIBEVAL::COMPILER::m_gcStrings.

generateUCode()

bool LIBEVAL::COMPILER::generateUCode ( UCODE *  aCode, CONTEXT *  aPreflightContext  )

protectedinherited

Definition at line 795 of file libeval_compiler.cpp.

{
 std::vector<TREE_NODE*> stack;
 wxString msg;
 
 if( !m_tree )
 {
 std::unique_ptr<VALUE> val = std::make_unique<VALUE>( 1.0 );
 // Empty expression returns true
 aCode->AddOp( new UOP( TR_UOP_PUSH_VALUE, std::move(val) ) );
 return true;
 }
 
 prepareTree( m_tree );
 
 stack.push_back( m_tree );
 
 wxString dump;
 
 dumpNode( dump, m_tree, 0 );
 libeval_dbg( 3, "Tree dump:\n%s\n\n", (const char*) dump.c_str() );
 
 while( !stack.empty() )
 {
 TREE_NODE* node = stack.back();
 
 libeval_dbg( 4, "process node %p [op %d] [stack %lu]\n",
 node, node->op, (unsigned long)stack.size() );
 
 // process terminal nodes first
 switch( node->op )
 {
 case TR_OP_FUNC_CALL:
 // Function call's uop was generated inside TR_STRUCT_REF
 if( !node->uop )
 {
 reportError( CST_CODEGEN, _( "Unknown parent of function parameters" ),
 node->srcPos );
 }
 
 node->isTerminal = true;
 break;
 
 case TR_STRUCT_REF:
 {
 // leaf[0]: object
 // leaf[1]: field (TR_IDENTIFIER) or TR_OP_FUNC_CALL
 
 if( node->leaf[0]->op != TR_IDENTIFIER )
 {
 int pos = node->leaf[0]->srcPos;
 
 if( node->leaf[0]->value.str )
 pos -= static_cast<int>( node->leaf[0]->value.str->length() );
 
 reportError( CST_CODEGEN, _( "Unknown parent of property" ), pos );
 
 node->leaf[0]->isVisited = true;
 node->leaf[1]->isVisited = true;
 
 node->SetUop( TR_UOP_PUSH_VALUE, 0.0 );
 node->isTerminal = true;
 break;
 }
 
 switch( node->leaf[1]->op )
 {
 case TR_IDENTIFIER:
 {
 // leaf[0]: object
 // leaf[1]: field
 
 wxString itemName = *node->leaf[0]->value.str;
 wxString propName = *node->leaf[1]->value.str;
 std::unique_ptr<VAR_REF> vref = aCode->CreateVarRef( itemName, propName );
 
 if( !vref )
 {
 msg.Printf( _( "Unrecognized item '%s'" ), itemName );
 reportError( CST_CODEGEN, msg,
 node->leaf[0]->srcPos - (int) itemName.length() );
 }
 else if( vref->GetType() == VT_PARSE_ERROR )
 {
 msg.Printf( _( "Unrecognized property '%s'" ), propName );
 reportError( CST_CODEGEN, msg,
 node->leaf[1]->srcPos - (int) propName.length() );
 }
 
 node->leaf[0]->isVisited = true;
 node->leaf[1]->isVisited = true;
 
 node->SetUop( TR_UOP_PUSH_VAR, std::move( vref ) );
 node->isTerminal = true;
 break;
 }
 case TR_OP_FUNC_CALL:
 {
 // leaf[0]: object
 // leaf[1]: TR_OP_FUNC_CALL
 // leaf[0]: function name
 // leaf[1]: parameter
 
 wxString itemName = *node->leaf[0]->value.str;
 std::unique_ptr<VAR_REF> vref = aCode->CreateVarRef( itemName, "" );
 
 if( !vref )
 {
 msg.Printf( _( "Unrecognized item '%s'" ), itemName );
 reportError( CST_CODEGEN, msg,
 node->leaf[0]->srcPos - (int) itemName.length() );
 }
 
 wxString functionName = *node->leaf[1]->leaf[0]->value.str;
 auto func = aCode->CreateFuncCall( functionName );
 std::vector<TREE_NODE*> params = squashParamList( node->leaf[1]->leaf[1] );
 
 libeval_dbg( 10, "emit func call: %s\n", functionName );
 
 if( !func )
 {
 msg.Printf( _( "Unrecognized function '%s'" ), functionName );
 reportError( CST_CODEGEN, msg, node->leaf[0]->srcPos + 1 );
 }
 
 if( func )
 {
 // Preflight the function call
 
 for( TREE_NODE* pnode : params )
 {
 VALUE* param = aPreflightContext->AllocValue();
 param->Set( *pnode->value.str );
 aPreflightContext->Push( param );
 }
 
 aPreflightContext->SetErrorCallback(
 [&]( const wxString& aMessage, int aOffset )
 {
 size_t loc = node->leaf[1]->leaf[1]->srcPos;
 reportError( CST_CODEGEN, aMessage, (int) loc - 1 );
 } );
 
 try
 {
 func( aPreflightContext, vref.get() );
 aPreflightContext->Pop(); // return value
 }
 catch( ... )
 {
 }
 }
 
 node->leaf[0]->isVisited = true;
 node->leaf[1]->isVisited = true;
 node->leaf[1]->leaf[0]->isVisited = true;
 node->leaf[1]->leaf[1]->isVisited = true;
 
 // Our non-terminal-node stacking algorithm can't handle doubly-nested
 // structures so we need to pop a level by replacing the TR_STRUCT_REF with
 // a TR_OP_FUNC_CALL and its function parameter
 stack.pop_back();
 stack.push_back( node->leaf[1] );
 
 for( TREE_NODE* pnode : params )
 stack.push_back( pnode );
 
 node->leaf[1]->SetUop( TR_OP_METHOD_CALL, func, std::move( vref ) );
 node->isTerminal = false;
 break;
 }
 
 default:
 // leaf[0]: object
 // leaf[1]: malformed syntax
 
 wxString itemName = *node->leaf[0]->value.str;
 wxString propName = *node->leaf[1]->value.str;
 std::unique_ptr<VAR_REF> vref = aCode->CreateVarRef( itemName, propName );
 
 if( !vref )
 {
 msg.Printf( _( "Unrecognized item '%s'" ), itemName );
 reportError( CST_CODEGEN, msg,
 node->leaf[0]->srcPos - (int) itemName.length() );
 }
 
 msg.Printf( _( "Unrecognized property '%s'" ), propName );
 reportError( CST_CODEGEN, msg, node->leaf[0]->srcPos + 1 );
 
 node->leaf[0]->isVisited = true;
 node->leaf[1]->isVisited = true;
 
 node->SetUop( TR_UOP_PUSH_VALUE, 0.0 );
 node->isTerminal = true;
 break;
 }
 
 break;
 }
 
 case TR_NUMBER:
 {
 TREE_NODE* son = node->leaf[0];
 double value;
 
 if( !node->value.str )
 {
 value = 0.0;
 }
 else if( son && son->op == TR_UNIT )
 {
 if( m_unitResolver->GetSupportedUnits().empty() )
 {
 msg.Printf( _( "Unexpected units for '%s'" ), *node->value.str );
 reportError( CST_CODEGEN, msg, node->srcPos );
 }
 
 int units = son->value.idx;
 value = m_unitResolver->Convert( *node->value.str, units );
 son->isVisited = true;
 }
 else
 {
 if( !m_unitResolver->GetSupportedUnitsMessage().empty() )
 {
 msg.Printf( _( "Missing units for '%s'| (%s)" ),
 *node->value.str,
 m_unitResolver->GetSupportedUnitsMessage() );
 reportError( CST_CODEGEN, msg, node->srcPos );
 }
 
 value = EDA_UNIT_UTILS::UI::DoubleValueFromString( *node->value.str );
 }
 
 node->SetUop( TR_UOP_PUSH_VALUE, value );
 node->isTerminal = true;
 break;
 }
 
 case TR_STRING:
 {
 wxString str = *node->value.str;
 bool isWildcard = str.Contains("?") || str.Contains("*");
 node->SetUop( TR_UOP_PUSH_VALUE, str, isWildcard );
 node->isTerminal = true;
 break;
 }
 
 case TR_IDENTIFIER:
 {
 std::unique_ptr<VAR_REF> vref = aCode->CreateVarRef( *node->value.str, "" );
 
 if( !vref )
 {
 msg.Printf( _( "Unrecognized item '%s'" ), *node->value.str );
 reportError( CST_CODEGEN, msg, node->srcPos - (int) node->value.str->length() );
 }
 
 node->SetUop( TR_UOP_PUSH_VAR, std::move( vref ) );
 node->isTerminal = true;
 break;
 }
 
 default:
 node->SetUop( node->op );
 node->isTerminal = ( !node->leaf[0] || node->leaf[0]->isVisited )
 && ( !node->leaf[1] || node->leaf[1]->isVisited );
 break;
 }
 
 if( !node->isTerminal )
 {
 if( node->leaf[0] && !node->leaf[0]->isVisited )
 {
 stack.push_back( node->leaf[0] );
 node->leaf[0]->isVisited = true;
 continue;
 }
 else if( node->leaf[1] && !node->leaf[1]->isVisited )
 {
 stack.push_back( node->leaf[1] );
 node->leaf[1]->isVisited = true;
 }
 
 continue;
 }
 
 node->isVisited = true;
 
 if( node->uop )
 {
 aCode->AddOp( node->uop );
 node->uop = nullptr;
 }
 
 stack.pop_back();
 }
 
 libeval_dbg(2,"dump: \n%s\n", aCode->Dump().c_str() );
 
 return true;
}

References _, LIBEVAL::UCODE::AddOp(), LIBEVAL::CONTEXT::AllocValue(), LIBEVAL::UCODE::CreateFuncCall(), LIBEVAL::UCODE::CreateVarRef(), LIBEVAL::CST_CODEGEN, EDA_UNIT_UTILS::UI::DoubleValueFromString(), LIBEVAL::UCODE::Dump(), dump(), LIBEVAL::dumpNode(), LIBEVAL::T_TOKEN_VALUE::idx, LIBEVAL::TREE_NODE::isTerminal, LIBEVAL::TREE_NODE::isVisited, LIBEVAL::TREE_NODE::leaf, libeval_dbg, LIBEVAL::COMPILER::m_tree, LIBEVAL::COMPILER::m_unitResolver, LIBEVAL::TREE_NODE::op, LIBEVAL::CONTEXT::Pop(), LIBEVAL::prepareTree(), LIBEVAL::CONTEXT::Push(), LIBEVAL::COMPILER::reportError(), LIBEVAL::VALUE::Set(), LIBEVAL::CONTEXT::SetErrorCallback(), LIBEVAL::TREE_NODE::SetUop(), LIBEVAL::squashParamList(), LIBEVAL::TREE_NODE::srcPos, LIBEVAL::T_TOKEN_VALUE::str, LIBEVAL::TR_IDENTIFIER, LIBEVAL::TR_NUMBER, TR_OP_FUNC_CALL, TR_OP_METHOD_CALL, LIBEVAL::TR_STRING, LIBEVAL::TR_STRUCT_REF, LIBEVAL::TR_UNIT, TR_UOP_PUSH_VALUE, TR_UOP_PUSH_VAR, LIBEVAL::TREE_NODE::uop, LIBEVAL::TREE_NODE::value, and LIBEVAL::VT_PARSE_ERROR.

Referenced by LIBEVAL::COMPILER::Compile().

GetError()

const ERROR_STATUS & LIBEVAL::COMPILER::GetError ( ) const

inlineinherited

Definition at line 517 of file libeval_compiler.h.

{ return m_errorStatus; }

References LIBEVAL::COMPILER::m_errorStatus.

Referenced by testEvalExpr().

GetSourcePos()

int LIBEVAL::COMPILER::GetSourcePos ( ) const

inlineinherited

Definition at line 504 of file libeval_compiler.h.

{ return m_sourcePos; }

References LIBEVAL::COMPILER::m_sourcePos.

Referenced by LIBEVAL::newNode().

getToken()

T_TOKEN LIBEVAL::COMPILER::getToken ( )

protectedinherited

Definition at line 360 of file libeval_compiler.cpp.

{
 T_TOKEN rv;
 rv.value = defaultTokenValue;
 
 bool done = false;
 
 do
 {
 switch( m_lexerState )
 {
 case LS_DEFAULT:
 done = lexDefault( rv );
 break;
 case LS_STRING:
 done = lexString( rv );
 break;
 }
 } while( !done );
 
 return rv;
}

References LIBEVAL::defaultTokenValue, LIBEVAL::COMPILER::lexDefault(), LIBEVAL::COMPILER::lexString(), LIBEVAL::COMPILER::LS_DEFAULT, LIBEVAL::COMPILER::LS_STRING, LIBEVAL::COMPILER::m_lexerState, and LIBEVAL::T_TOKEN::value.

Referenced by LIBEVAL::COMPILER::Compile().

IsErrorPending()

bool LIBEVAL::COMPILER::IsErrorPending ( ) const

inlineinherited

Definition at line 516 of file libeval_compiler.h.

{ return m_errorStatus.pendingError; }

References LIBEVAL::COMPILER::m_errorStatus, and LIBEVAL::ERROR_STATUS::pendingError.

lexDefault()

bool LIBEVAL::COMPILER::lexDefault ( T_TOKEN &  aToken )

protectedinherited

Definition at line 417 of file libeval_compiler.cpp.

{
 T_TOKEN retval;
 wxString current;
 int convertFrom;
 wxString msg;
 
 retval.value.str = nullptr;
 retval.value.num = 0.0;
 retval.value.idx = -1;
 retval.token = G_ENDS;
 
 if( m_tokenizer.Done() )
 {
 aToken = retval;
 return true;
 }
 
 auto isDecimalSeparator =
 [&]( wxUniChar 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;
 wxUniChar ch = m_tokenizer.GetChar();
 
 do
 {
 if( isDecimalSeparator( ch ) && haveSeparator )
 break;
 
 current.append( 1, ch );
 
 if( isDecimalSeparator( ch ) )
 haveSeparator = true;
 
 m_tokenizer.NextChar();
 ch = m_tokenizer.GetChar();
 } while( isdigit( ch ) || isDecimalSeparator( ch ) );
 
 // Ensure that the systems decimal separator is used
 for( int i = current.length(); i; i-- )
 {
 if( isDecimalSeparator( current[i - 1] ) )
 current[i - 1] = m_localeDecimalSeparator;
 }
 };
 
 
 int ch;
 
 // Start processing of first/next token: Remove whitespace
 for( ;; )
 {
 ch = m_tokenizer.GetChar();
 
 if( ch == ' ' )
 m_tokenizer.NextChar();
 else
 break;
 }
 
 libeval_dbg(10, "LEX ch '%c' pos %lu\n", ch, (unsigned long)m_tokenizer.GetPos() );
 
 if( ch == 0 )
 {
 /* End of input */
 }
 else if( isdigit( ch ) )
 {
 // VALUE
 extractNumber();
 retval.token = G_VALUE;
 retval.value.str = new wxString( current );
 }
 else if( ( convertFrom = resolveUnits() ) >= 0 )
 {
 // 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 = G_UNIT;
 retval.value.idx = convertFrom;
 }
 else if( ch == '\'' ) // string literal
 {
 m_lexerState = LS_STRING;
 m_tokenizer.NextChar();
 return false;
 }
 else if( isalpha( ch ) || ch == '_' )
 {
 current = m_tokenizer.GetChars( []( int c ) -> bool { return isalnum( c ) || c == '_'; } );
 retval.token = G_IDENTIFIER;
 retval.value.str = new wxString( current );
 m_tokenizer.NextChar( current.length() );
 }
 else if( m_tokenizer.MatchAhead( "==", []( int c ) -> bool { return c != '='; } ) )
 {
 retval.token = G_EQUAL;
 m_tokenizer.NextChar( 2 );
 }
 else if( m_tokenizer.MatchAhead( "!=", []( int c ) -> bool { return c != '='; } ) )
 {
 retval.token = G_NOT_EQUAL;
 m_tokenizer.NextChar( 2 );
 }
 else if( m_tokenizer.MatchAhead( "<=", []( int c ) -> bool { return c != '='; } ) )
 {
 retval.token = G_LESS_EQUAL_THAN;
 m_tokenizer.NextChar( 2 );
 }
 else if( m_tokenizer.MatchAhead( ">=", []( int c ) -> bool { return c != '='; } ) )
 {
 retval.token = G_GREATER_EQUAL_THAN;
 m_tokenizer.NextChar( 2 );
 }
 else if( m_tokenizer.MatchAhead( "&&", []( int c ) -> bool { return c != '&'; } ) )
 {
 retval.token = G_BOOL_AND;
 m_tokenizer.NextChar( 2 );
 }
 else if( m_tokenizer.MatchAhead( "||", []( int c ) -> bool { return c != '|'; } ) )
 {
 retval.token = G_BOOL_OR;
 m_tokenizer.NextChar( 2 );
 }
 else
 {
 // Single char tokens
 switch( ch )
 {
 case '+': retval.token = G_PLUS; break;
 case '!': retval.token = G_BOOL_NOT; break;
 case '-': retval.token = G_MINUS; break;
 case '*': retval.token = G_MULT; break;
 case '/': retval.token = G_DIVIDE; break;
 case '<': retval.token = G_LESS_THAN; break;
 case '>': retval.token = G_GREATER_THAN; break;
 case '(': retval.token = G_PARENL; break;
 case ')': retval.token = G_PARENR; break;
 case ';': retval.token = G_SEMCOL; break;
 case '.': retval.token = G_STRUCT_REF; break;
 case ',': retval.token = G_COMMA; break;
 
 default:
 reportError( CST_PARSE, wxString::Format( _( "Unrecognized character '%c'" ),
 (char) ch ) );
 break;
 }
 
 m_tokenizer.NextChar();
 }
 
 aToken = retval;
 return true;
}

References _, LIBEVAL::CST_PARSE, LIBEVAL::TOKENIZER::Done(), Format(), LIBEVAL::TOKENIZER::GetChar(), LIBEVAL::TOKENIZER::GetChars(), LIBEVAL::TOKENIZER::GetPos(), LIBEVAL::T_TOKEN_VALUE::idx, libeval_dbg, LIBEVAL::COMPILER::LS_STRING, LIBEVAL::COMPILER::m_lexerState, LIBEVAL::COMPILER::m_localeDecimalSeparator, LIBEVAL::COMPILER::m_tokenizer, LIBEVAL::TOKENIZER::MatchAhead(), LIBEVAL::TOKENIZER::NextChar(), LIBEVAL::T_TOKEN_VALUE::num, LIBEVAL::COMPILER::reportError(), LIBEVAL::COMPILER::resolveUnits(), LIBEVAL::T_TOKEN_VALUE::str, LIBEVAL::T_TOKEN::token, and LIBEVAL::T_TOKEN::value.

Referenced by LIBEVAL::COMPILER::getToken().

lexString()

bool LIBEVAL::COMPILER::lexString ( T_TOKEN &  aToken )

protectedinherited

Definition at line 384 of file libeval_compiler.cpp.

{
 wxString str = m_tokenizer.GetChars( []( int c ) -> bool { return c != '\''; } );
 
 aToken.token = G_STRING;
 aToken.value.str = new wxString( str );
 
 m_tokenizer.NextChar( str.length() + 1 );
 m_lexerState = LS_DEFAULT;
 return true;
}

References LIBEVAL::TOKENIZER::GetChars(), LIBEVAL::COMPILER::LS_DEFAULT, LIBEVAL::COMPILER::m_lexerState, LIBEVAL::COMPILER::m_tokenizer, LIBEVAL::TOKENIZER::NextChar(), LIBEVAL::T_TOKEN_VALUE::str, LIBEVAL::T_TOKEN::token, and LIBEVAL::T_TOKEN::value.

Referenced by LIBEVAL::COMPILER::getToken().

newString()

void LIBEVAL::COMPILER::newString ( const wxString &  aString )

protectedinherited

Definition at line 350 of file libeval_compiler.cpp.

{
 Clear();
 
 m_lexerState = LS_DEFAULT;
 m_tokenizer.Restart( aString );
 m_parseFinished = false;
}

References LIBEVAL::COMPILER::Clear(), LIBEVAL::COMPILER::LS_DEFAULT, LIBEVAL::COMPILER::m_lexerState, LIBEVAL::COMPILER::m_parseFinished, LIBEVAL::COMPILER::m_tokenizer, and LIBEVAL::TOKENIZER::Restart().

Referenced by LIBEVAL::COMPILER::Compile().

parseError()

void LIBEVAL::COMPILER::parseError ( const char *  s )

inherited

Definition at line 287 of file libeval_compiler.cpp.

{
 reportError( CST_PARSE, s );
}

References LIBEVAL::CST_PARSE, and LIBEVAL::COMPILER::reportError().

parseOk()

void LIBEVAL::COMPILER::parseOk ( )

inherited

Definition at line 293 of file libeval_compiler.cpp.

{
 m_parseFinished = true;
}

References LIBEVAL::COMPILER::m_parseFinished.

reportError()

void LIBEVAL::COMPILER::reportError ( COMPILATION_STAGE  stage, const wxString &  aErrorMsg, int  aPos = -1  )

protectedinherited

Definition at line 669 of file libeval_compiler.cpp.

{
 if( aPos == -1 )
 aPos = m_sourcePos;
 
 m_errorStatus.pendingError = true;
 m_errorStatus.stage = stage;
 m_errorStatus.message = aErrorMsg;
 m_errorStatus.srcPos = aPos;
 
 if( m_errorCallback )
 m_errorCallback( aErrorMsg, aPos );
}

References LIBEVAL::COMPILER::m_errorCallback, LIBEVAL::COMPILER::m_errorStatus, LIBEVAL::COMPILER::m_sourcePos, LIBEVAL::ERROR_STATUS::message, LIBEVAL::ERROR_STATUS::pendingError, LIBEVAL::ERROR_STATUS::srcPos, and LIBEVAL::ERROR_STATUS::stage.

Referenced by LIBEVAL::COMPILER::generateUCode(), LIBEVAL::COMPILER::lexDefault(), and LIBEVAL::COMPILER::parseError().

resolveUnits()

int LIBEVAL::COMPILER::resolveUnits ( )

protectedinherited

Definition at line 397 of file libeval_compiler.cpp.

{
 int unitId = 0;
 
 for( const wxString& unitName : m_unitResolver->GetSupportedUnits() )
 {
 if( m_tokenizer.MatchAhead( unitName, []( int c ) -> bool { return !isalnum( c ); } ) )
 {
 libeval_dbg(10, "Match unit '%s'\n", unitName.c_str() );
 m_tokenizer.NextChar( unitName.length() );
  return unitId;
 }
 
 unitId++;
 }
 
 return -1;
}

References libeval_dbg, LIBEVAL::COMPILER::m_tokenizer, LIBEVAL::COMPILER::m_unitResolver, LIBEVAL::TOKENIZER::MatchAhead(), and LIBEVAL::TOKENIZER::NextChar().

Referenced by LIBEVAL::COMPILER::lexDefault().

SetErrorCallback()

void LIBEVAL::COMPILER::SetErrorCallback ( std::function< void(const wxString &aMessage, int aOffset)>  aCallback )

inlineinherited

Definition at line 511 of file libeval_compiler.h.

 {
 m_errorCallback = std::move( aCallback );
 }

References LIBEVAL::COMPILER::m_errorCallback.

Referenced by DRC_RULE_CONDITION::Compile(), and PCB_EXPR_EVALUATOR::SetErrorCallback().

setRoot()

void LIBEVAL::COMPILER::setRoot ( LIBEVAL::TREE_NODE *  root )

inherited

Definition at line 684 of file libeval_compiler.cpp.

{
 m_tree = root;
}

References LIBEVAL::COMPILER::m_tree.

Member Data Documentation

m_errorCallback

std::function<void( const wxString& aMessage, int aOffset )> LIBEVAL::COMPILER::m_errorCallback

protectedinherited

Definition at line 557 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::reportError(), and LIBEVAL::COMPILER::SetErrorCallback().

m_errorStatus

ERROR_STATUS LIBEVAL::COMPILER::m_errorStatus

protectedinherited

Definition at line 555 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Compile(), LIBEVAL::COMPILER::COMPILER(), LIBEVAL::COMPILER::GetError(), LIBEVAL::COMPILER::IsErrorPending(), and LIBEVAL::COMPILER::reportError().

m_gcItems

std::vector<TREE_NODE*> LIBEVAL::COMPILER::m_gcItems

protectedinherited

Definition at line 561 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Clear(), and LIBEVAL::COMPILER::GcItem().

m_gcStrings

std::vector<wxString*> LIBEVAL::COMPILER::m_gcStrings

protectedinherited

Definition at line 562 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Clear(), and LIBEVAL::COMPILER::GcItem().

m_lexerState

LEXER_STATE LIBEVAL::COMPILER::m_lexerState

protectedinherited

Definition at line 529 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::getToken(), LIBEVAL::COMPILER::lexDefault(), LIBEVAL::COMPILER::lexString(), and LIBEVAL::COMPILER::newString().

m_localeDecimalSeparator

char LIBEVAL::COMPILER::m_localeDecimalSeparator

protectedinherited

Definition at line 549 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::COMPILER(), and LIBEVAL::COMPILER::lexDefault().

m_parseFinished

bool LIBEVAL::COMPILER::m_parseFinished

protectedinherited

Definition at line 554 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Compile(), LIBEVAL::COMPILER::COMPILER(), LIBEVAL::COMPILER::newString(), and LIBEVAL::COMPILER::parseOk().

m_parser

void* LIBEVAL::COMPILER::m_parser

protectedinherited

Definition at line 547 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Compile(), LIBEVAL::COMPILER::COMPILER(), and LIBEVAL::COMPILER::~COMPILER().

m_sourcePos

int LIBEVAL::COMPILER::m_sourcePos

protectedinherited

Definition at line 553 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Compile(), LIBEVAL::COMPILER::COMPILER(), LIBEVAL::COMPILER::GetSourcePos(), and LIBEVAL::COMPILER::reportError().

m_tokenizer

TOKENIZER LIBEVAL::COMPILER::m_tokenizer

protectedinherited

Definition at line 548 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Clear(), LIBEVAL::COMPILER::Compile(), LIBEVAL::COMPILER::lexDefault(), LIBEVAL::COMPILER::lexString(), LIBEVAL::COMPILER::newString(), and LIBEVAL::COMPILER::resolveUnits().

m_tree

TREE_NODE* LIBEVAL::COMPILER::m_tree

protectedinherited

Definition at line 559 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::Clear(), LIBEVAL::COMPILER::Compile(), LIBEVAL::COMPILER::COMPILER(), LIBEVAL::COMPILER::generateUCode(), LIBEVAL::COMPILER::setRoot(), and LIBEVAL::COMPILER::~COMPILER().

m_unitResolver

std::unique_ptr<UNIT_RESOLVER> LIBEVAL::COMPILER::m_unitResolver

protectedinherited

Definition at line 551 of file libeval_compiler.h.

Referenced by LIBEVAL::COMPILER::COMPILER(), LIBEVAL::COMPILER::generateUCode(), PCB_EXPR_COMPILER(), and LIBEVAL::COMPILER::resolveUnits().

---

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

• pcb_expr_evaluator.h
• pcb_expr_evaluator.cpp