#include <pcb_expr_evaluator.h>

Inheritance diagram for PCB_EXPR_UCODE:

Public Member Functions
	PCB_EXPR_UCODE ()

virtual	~PCB_EXPR_UCODE ()

virtual std::unique_ptr< LIBEVAL::VAR_REF >	CreateVarRef (const wxString &aVar, const wxString &aField) override

virtual LIBEVAL::FUNC_CALL_REF	CreateFuncCall (const wxString &aName) override

void	AddOp (UOP *uop)

VALUE *	Run (CONTEXT *ctx)

wxString	Dump () const

Protected Attributes
std::vector< UOP * >	m_ucode

Detailed Description

Definition at line 40 of file pcb_expr_evaluator.h.

Constructor & Destructor Documentation

◆ PCB_EXPR_UCODE()

PCB_EXPR_UCODE::PCB_EXPR_UCODE ( )

inline

Definition at line 43 of file pcb_expr_evaluator.h.

43{};

◆ ~PCB_EXPR_UCODE()

virtual PCB_EXPR_UCODE::~PCB_EXPR_UCODE ( )

inlinevirtual

Definition at line 44 of file pcb_expr_evaluator.h.

44{};

Member Function Documentation

◆ AddOp()

void LIBEVAL::UCODE::AddOp ( UOP * uop )

inlineinherited

Definition at line 377 of file libeval_compiler.h.

 {
 m_ucode.push_back(uop);
 }

References LIBEVAL::UCODE::m_ucode.

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

◆ CreateFuncCall()

LIBEVAL::FUNC_CALL_REF PCB_EXPR_UCODE::CreateFuncCall ( const wxString & aName )

overridevirtual

Reimplemented from LIBEVAL::UCODE.

Definition at line 180 of file pcb_expr_evaluator.cpp.

{
 PCB_EXPR_BUILTIN_FUNCTIONS& registry = PCB_EXPR_BUILTIN_FUNCTIONS::Instance();
 
 return registry.Get( aName.Lower() );
}

References PCB_EXPR_BUILTIN_FUNCTIONS::Get(), and PCB_EXPR_BUILTIN_FUNCTIONS::Instance().

◆ CreateVarRef()

std::unique_ptr< LIBEVAL::VAR_REF > PCB_EXPR_UCODE::CreateVarRef	(	const wxString &	aVar,
		const wxString &	aField
	)

overridevirtual

Reimplemented from LIBEVAL::UCODE.

Definition at line 188 of file pcb_expr_evaluator.cpp.

{
 PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
 std::unique_ptr<PCB_EXPR_VAR_REF> vref;
 
 // Check for a couple of very common cases and compile them straight to "object code".
 
 if( aField.CmpNoCase( wxT( "NetClass" ) ) == 0 )
 {
 if( aVar == wxT( "A" ) )
 return std::make_unique<PCB_EXPR_NETCLASS_REF>( 0 );
 else if( aVar == wxT( "B" ) )
 return std::make_unique<PCB_EXPR_NETCLASS_REF>( 1 );
 else
 return nullptr;
 }
 else if( aField.CmpNoCase( wxT( "NetName" ) ) == 0 )
 {
 if( aVar == wxT( "A" ) )
 return std::make_unique<PCB_EXPR_NETNAME_REF>( 0 );
 else if( aVar == wxT( "B" ) )
 return std::make_unique<PCB_EXPR_NETNAME_REF>( 1 );
 else
 return nullptr;
 }
 else if( aField.CmpNoCase( wxT( "Type" ) ) == 0 )
 {
 if( aVar == wxT( "A" ) )
 return std::make_unique<PCB_EXPR_TYPE_REF>( 0 );
 else if( aVar == wxT( "B" ) )
 return std::make_unique<PCB_EXPR_TYPE_REF>( 1 );
 else
 return nullptr;
 }
 
 if( aVar == wxT( "A" ) || aVar == wxT( "AB" ) )
 vref = std::make_unique<PCB_EXPR_VAR_REF>( 0 );
 else if( aVar == wxT( "B" ) )
 vref = std::make_unique<PCB_EXPR_VAR_REF>( 1 );
 else if( aVar == wxT( "L" ) )
 vref = std::make_unique<PCB_EXPR_VAR_REF>( 2 );
 else
 return nullptr;
 
 if( aField.length() == 0 ) // return reference to base object
 {
 return std::move( vref );
 }
 
 wxString field( aField );
 field.Replace( wxT( "_" ), wxT( " " ) );
 
 for( const PROPERTY_MANAGER::CLASS_INFO& cls : propMgr.GetAllClasses() )
 {
 if( propMgr.IsOfType( cls.type, TYPE_HASH( BOARD_ITEM ) ) )
 {
 PROPERTY_BASE* prop = propMgr.GetProperty( cls.type, field );
 
 if( prop )
 {
 vref->AddAllowedClass( cls.type, prop );
 
 if( prop->TypeHash() == TYPE_HASH( int ) )
 {
 vref->SetType( LIBEVAL::VT_NUMERIC );
 }
 else if( prop->TypeHash() == TYPE_HASH( wxString ) )
 {
 vref->SetType( LIBEVAL::VT_STRING );
 }
 else if ( prop->HasChoices() )
 { // it's an enum, we treat it as string
 vref->SetType( LIBEVAL::VT_STRING );
 vref->SetIsEnum ( true );
 }
 else
 {
 wxFAIL_MSG( wxT( "PCB_EXPR_UCODE::createVarRef: Unknown property type." ) );
 }
 }
 }
 }
 
 if( vref->GetType() == LIBEVAL::VT_UNDEFINED )
 vref->SetType( LIBEVAL::VT_PARSE_ERROR );
 
 return std::move( vref );
}

References PROPERTY_MANAGER::GetAllClasses(), PROPERTY_MANAGER::GetProperty(), PROPERTY_BASE::HasChoices(), PROPERTY_MANAGER::Instance(), PROPERTY_MANAGER::IsOfType(), TYPE_HASH, PROPERTY_BASE::TypeHash(), LIBEVAL::VT_NUMERIC, LIBEVAL::VT_PARSE_ERROR, LIBEVAL::VT_STRING, and LIBEVAL::VT_UNDEFINED.

◆ Dump()

wxString LIBEVAL::UCODE::Dump ( ) const

inherited

Definition at line 190 of file libeval_compiler.cpp.

{
 wxString rv;
 
 for( auto op : m_ucode )
 {
 rv += op->Format();
 rv += "\n";
 }
 
 return rv;
};

References LIBEVAL::UCODE::m_ucode.

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

◆ Run()

VALUE * LIBEVAL::UCODE::Run ( CONTEXT * ctx )

inherited

Definition at line 1235 of file libeval_compiler.cpp.

{
 static VALUE g_false( 0 );
 
 try
 {
 for( UOP* op : m_ucode )
 op->Exec( ctx );
 }
 catch(...)
 {
 // rules which fail outright should not be fired
 return &g_false;
 }
 
 if( ctx->SP() == 1 )
 {
 return ctx->Pop();
 }
 else
 {
 // If stack is corrupted after execution it suggests a problem with the compiler, not
 // the rule....
 
 // do not use "assert"; it crashes outright on OSX
 wxASSERT( ctx->SP() == 1 );
 
 // non-well-formed rules should not be fired on a release build
 return &g_false;
 }
}

References LIBEVAL::UCODE::m_ucode, LIBEVAL::CONTEXT::Pop(), and LIBEVAL::CONTEXT::SP().

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

Member Data Documentation

◆ m_ucode

std::vector<UOP*> LIBEVAL::UCODE::m_ucode

protectedinherited

Definition at line 397 of file libeval_compiler.h.

Referenced by LIBEVAL::UCODE::AddOp(), LIBEVAL::UCODE::Dump(), LIBEVAL::UCODE::Run(), and LIBEVAL::UCODE::~UCODE().

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

Public Member Functions

Protected Attributes