KiCad PCB EDA Suite
pcb_expr_evaluator.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2019-2022 KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you may find one here:
18 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
19 * or you may search the http://www.gnu.org website for the version 2 license,
20 * or you may write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24
25#include <cstdio>
26#include <memory>
27#include <board.h>
29#include <pcb_expr_evaluator.h>
30#include <drc/drc_engine.h>
31
32/* --------------------------------------------------------------------------------------------
33 * Specialized Expression References
34 */
35
37{
38 wxASSERT( dynamic_cast<const PCB_EXPR_CONTEXT*>( aCtx ) );
39
40 const PCB_EXPR_CONTEXT* ctx = static_cast<const PCB_EXPR_CONTEXT*>( aCtx );
41 BOARD_ITEM* item = ctx->GetItem( m_itemIndex );
42 return item;
43}
44
45
47{
48public:
50 LIBEVAL::VALUE( LayerName( aLayer ) ),
51 m_layer( aLayer )
52 {};
53
54 virtual bool EqualTo( LIBEVAL::CONTEXT* aCtx, const VALUE* b ) const override
55 {
56 // For boards with user-defined layer names there will be 2 entries for each layer
57 // in the ENUM_MAP: one for the canonical layer name and one for the user layer name.
58 // We need to check against both.
59
60 wxPGChoices& layerMap = ENUM_MAP<PCB_LAYER_ID>::Instance().Choices();
61 const wxString& layerName = b->AsString();
62 BOARD* board = static_cast<PCB_EXPR_CONTEXT*>( aCtx )->GetBoard();
63 std::unique_lock<std::mutex> cacheLock( board->m_CachesMutex );
64 auto i = board->m_LayerExpressionCache.find( layerName );
65 LSET mask;
66
67 if( i == board->m_LayerExpressionCache.end() )
68 {
69 for( unsigned ii = 0; ii < layerMap.GetCount(); ++ii )
70 {
71 wxPGChoiceEntry& entry = layerMap[ii];
72
73 if( entry.GetText().Matches( layerName ) )
74 mask.set( ToLAYER_ID( entry.GetValue() ) );
75 }
76
77 board->m_LayerExpressionCache[ layerName ] = mask;
78 }
79 else
80 {
81 mask = i->second;
82 }
83
84 return mask.Contains( m_layer );
85 }
86
87protected:
89};
90
91
93{
94 PCB_EXPR_CONTEXT* context = static_cast<PCB_EXPR_CONTEXT*>( aCtx );
95
96 if( m_itemIndex == 2 )
97 return new PCB_LAYER_VALUE( context->GetLayer() );
98
99 BOARD_ITEM* item = GetObject( aCtx );
100
101 if( !item )
102 return new LIBEVAL::VALUE();
103
104 auto it = m_matchingTypes.find( TYPE_HASH( *item ) );
105
106 if( it == m_matchingTypes.end() )
107 {
108 // Don't force user to type "A.Type == 'via' && A.Via_Type == 'buried'" when the
109 // simpler "A.Via_Type == 'buried'" is perfectly clear. Instead, return an undefined
110 // value when the property doesn't appear on a particular object.
111
112 return new LIBEVAL::VALUE();
113 }
114 else
115 {
117 return new LIBEVAL::VALUE( (double) item->Get<int>( it->second ) );
118 else
119 {
120 wxString str;
121
122 if( !m_isEnum )
123 {
124 str = item->Get<wxString>( it->second );
125 return new LIBEVAL::VALUE( str );
126 }
127 else
128 {
129 const wxAny& any = item->Get( it->second );
130 bool valid = any.GetAs<wxString>( &str );
131
132 if( valid )
133 {
134 if( it->second->Name() == wxT( "Layer" ) )
135 return new PCB_LAYER_VALUE( context->GetBoard()->GetLayerID( str ) );
136 else
137 return new LIBEVAL::VALUE( str );
138 }
139 }
140
141 return new LIBEVAL::VALUE();
142 }
143 }
144}
145
146
148{
149 BOARD_CONNECTED_ITEM* item = dynamic_cast<BOARD_CONNECTED_ITEM*>( GetObject( aCtx ) );
150
151 if( !item )
152 return new LIBEVAL::VALUE();
153
154 return new LIBEVAL::VALUE( item->GetEffectiveNetClass()->GetName() );
155}
156
157
159{
160 BOARD_CONNECTED_ITEM* item = dynamic_cast<BOARD_CONNECTED_ITEM*>( GetObject( aCtx ) );
161
162 if( !item )
163 return new LIBEVAL::VALUE();
164
165 return new LIBEVAL::VALUE( item->GetNetname() );
166}
167
168
170{
171 BOARD_ITEM* item = GetObject( aCtx );
172
173 if( !item )
174 return new LIBEVAL::VALUE();
175
176 return new LIBEVAL::VALUE( ENUM_MAP<KICAD_T>::Instance().ToString( item->Type() ) );
177}
178
179
181{
183
184 return registry.Get( aName.Lower() );
185}
186
187
188std::unique_ptr<LIBEVAL::VAR_REF> PCB_EXPR_UCODE::CreateVarRef( const wxString& aVar,
189 const wxString& aField )
190{
192 std::unique_ptr<PCB_EXPR_VAR_REF> vref;
193
194 // Check for a couple of very common cases and compile them straight to "object code".
195
196 if( aField.CmpNoCase( wxT( "NetClass" ) ) == 0 )
197 {
198 if( aVar == wxT( "A" ) )
199 return std::make_unique<PCB_EXPR_NETCLASS_REF>( 0 );
200 else if( aVar == wxT( "B" ) )
201 return std::make_unique<PCB_EXPR_NETCLASS_REF>( 1 );
202 else
203 return nullptr;
204 }
205 else if( aField.CmpNoCase( wxT( "NetName" ) ) == 0 )
206 {
207 if( aVar == wxT( "A" ) )
208 return std::make_unique<PCB_EXPR_NETNAME_REF>( 0 );
209 else if( aVar == wxT( "B" ) )
210 return std::make_unique<PCB_EXPR_NETNAME_REF>( 1 );
211 else
212 return nullptr;
213 }
214 else if( aField.CmpNoCase( wxT( "Type" ) ) == 0 )
215 {
216 if( aVar == wxT( "A" ) )
217 return std::make_unique<PCB_EXPR_TYPE_REF>( 0 );
218 else if( aVar == wxT( "B" ) )
219 return std::make_unique<PCB_EXPR_TYPE_REF>( 1 );
220 else
221 return nullptr;
222 }
223
224 if( aVar == wxT( "A" ) || aVar == wxT( "AB" ) )
225 vref = std::make_unique<PCB_EXPR_VAR_REF>( 0 );
226 else if( aVar == wxT( "B" ) )
227 vref = std::make_unique<PCB_EXPR_VAR_REF>( 1 );
228 else if( aVar == wxT( "L" ) )
229 vref = std::make_unique<PCB_EXPR_VAR_REF>( 2 );
230 else
231 return nullptr;
232
233 if( aField.length() == 0 ) // return reference to base object
234 {
235 return std::move( vref );
236 }
237
238 wxString field( aField );
239 field.Replace( wxT( "_" ), wxT( " " ) );
240
241 for( const PROPERTY_MANAGER::CLASS_INFO& cls : propMgr.GetAllClasses() )
242 {
243 if( propMgr.IsOfType( cls.type, TYPE_HASH( BOARD_ITEM ) ) )
244 {
245 PROPERTY_BASE* prop = propMgr.GetProperty( cls.type, field );
246
247 if( prop )
248 {
249 vref->AddAllowedClass( cls.type, prop );
250
251 if( prop->TypeHash() == TYPE_HASH( int ) )
252 {
253 vref->SetType( LIBEVAL::VT_NUMERIC );
254 }
255 else if( prop->TypeHash() == TYPE_HASH( wxString ) )
256 {
257 vref->SetType( LIBEVAL::VT_STRING );
258 }
259 else if ( prop->HasChoices() )
260 { // it's an enum, we treat it as string
261 vref->SetType( LIBEVAL::VT_STRING );
262 vref->SetIsEnum ( true );
263 }
264 else
265 {
266 wxFAIL_MSG( wxT( "PCB_EXPR_UCODE::createVarRef: Unknown property type." ) );
267 }
268 }
269 }
270 }
271
272 if( vref->GetType() == LIBEVAL::VT_UNDEFINED )
273 vref->SetType( LIBEVAL::VT_PARSE_ERROR );
274
275 return std::move( vref );
276}
277
278
280{
281 if( m_items[0] )
282 return m_items[0]->GetBoard();
283
284 return nullptr;
285}
286
287
288/* --------------------------------------------------------------------------------------------
289 * Unit Resolvers
290 */
291
292const std::vector<wxString>& PCB_UNIT_RESOLVER::GetSupportedUnits() const
293{
294 static const std::vector<wxString> pcbUnits = { wxT( "mil" ), wxT( "mm" ), wxT( "in" ) };
295
296 return pcbUnits;
297}
298
299
301{
302 return _( "must be mm, in, or mil" );
303}
304
305
306double PCB_UNIT_RESOLVER::Convert( const wxString& aString, int unitId ) const
307{
308 double v = wxAtof( aString );
309
310 switch( unitId )
311 {
315 default: return v;
316 }
317};
318
319
320const std::vector<wxString>& PCB_UNITLESS_RESOLVER::GetSupportedUnits() const
321{
322 static const std::vector<wxString> emptyUnits;
323
324 return emptyUnits;
325}
326
327
328double PCB_UNITLESS_RESOLVER::Convert( const wxString& aString, int unitId ) const
329{
330 return wxAtof( aString );
331};
332
333
335{
336 m_unitResolver.reset( aUnitResolver );
337}
338
339
340/* --------------------------------------------------------------------------------------------
341 * PCB Expression Evaluator
342 */
343
345 m_result( 0 ),
346 m_compiler( aUnitResolver ),
347 m_ucode(),
348 m_errorStatus()
349{
350}
351
352
354{
355}
356
357
358bool PCB_EXPR_EVALUATOR::Evaluate( const wxString& aExpr )
359{
360 PCB_EXPR_UCODE ucode;
361 PCB_EXPR_CONTEXT preflightContext( NULL_CONSTRAINT, F_Cu );
362
363 if( !m_compiler.Compile( aExpr.ToUTF8().data(), &ucode, &preflightContext ) )
364 return false;
365
366 PCB_EXPR_CONTEXT evaluationContext( NULL_CONSTRAINT, F_Cu );
367 LIBEVAL::VALUE* result = ucode.Run( &evaluationContext );
368
369 if( result->GetType() == LIBEVAL::VT_NUMERIC )
370 m_result = KiROUND( result->AsDouble() );
371
372 return true;
373}
374
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:109
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
virtual NETCLASS * GetEffectiveNetClass() const
Return the NETCLASS for this item.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:58
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
Definition: board_item.cpp:43
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:265
const PCB_LAYER_ID GetLayerID(const wxString &aLayerName) const
Return the ID of a layer.
Definition: board.cpp:432
std::unordered_map< wxString, LSET > m_LayerExpressionCache
Definition: board.h:1144
std::mutex m_CachesMutex
Definition: board.h:1138
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:97
static ENUM_MAP< T > & Instance()
Definition: property.h:573
wxAny Get(PROPERTY_BASE *aProperty) const
Definition: inspectable.h:84
std::unique_ptr< UNIT_RESOLVER > m_unitResolver
bool Compile(const wxString &aString, UCODE *aCode, CONTEXT *aPreflightContext)
VALUE * Run(CONTEXT *ctx)
virtual double AsDouble() const
VAR_TYPE_T GetType() const
LSET is a set of PCB_LAYER_IDs.
Definition: layer_ids.h:530
bool Contains(PCB_LAYER_ID aLayer)
See if the layer set contains a PCB layer.
Definition: layer_ids.h:600
const wxString GetName() const
Definition: netclass.h:65
LIBEVAL::FUNC_CALL_REF Get(const wxString &name)
static PCB_EXPR_BUILTIN_FUNCTIONS & Instance()
PCB_EXPR_COMPILER(LIBEVAL::UNIT_RESOLVER *aUnitResolver)
BOARD_ITEM * GetItem(int index) const
BOARD_ITEM * m_items[2]
BOARD * GetBoard() const
PCB_LAYER_ID GetLayer() const
bool Evaluate(const wxString &aExpr)
PCB_EXPR_EVALUATOR(LIBEVAL::UNIT_RESOLVER *aUnitResolver)
PCB_EXPR_COMPILER m_compiler
LIBEVAL::VALUE * GetValue(LIBEVAL::CONTEXT *aCtx) override
LIBEVAL::VALUE * GetValue(LIBEVAL::CONTEXT *aCtx) override
LIBEVAL::VALUE * GetValue(LIBEVAL::CONTEXT *aCtx) override
virtual LIBEVAL::FUNC_CALL_REF CreateFuncCall(const wxString &aName) override
virtual std::unique_ptr< LIBEVAL::VAR_REF > CreateVarRef(const wxString &aVar, const wxString &aField) override
BOARD_ITEM * GetObject(const LIBEVAL::CONTEXT *aCtx) const
std::unordered_map< TYPE_ID, PROPERTY_BASE * > m_matchingTypes
LIBEVAL::VAR_TYPE_T m_type
LIBEVAL::VALUE * GetValue(LIBEVAL::CONTEXT *aCtx) override
PCB_LAYER_VALUE(PCB_LAYER_ID aLayer)
virtual bool EqualTo(LIBEVAL::CONTEXT *aCtx, const VALUE *b) const override
const std::vector< wxString > & GetSupportedUnits() const override
double Convert(const wxString &aString, int unitId) const override
double Convert(const wxString &aString, int unitId) const override
wxString GetSupportedUnitsMessage() const override
const std::vector< wxString > & GetSupportedUnits() const override
virtual size_t TypeHash() const =0
Return type-id of the property type.
virtual bool HasChoices() const
Return true if this PROPERTY has a limited set of possible values.
Definition: property.h:225
Provide class metadata.Helper macro to map type hashes to names.
Definition: property_mgr.h:74
CLASSES_INFO GetAllClasses()
static PROPERTY_MANAGER & Instance()
Definition: property_mgr.h:76
PROPERTY_BASE * GetProperty(TYPE_ID aType, const wxString &aProperty) const
Return a property for a specific type.
bool IsOfType(TYPE_ID aDerived, TYPE_ID aBase) const
Return true if aDerived is inherited from aBase.
@ NULL_CONSTRAINT
Definition: drc_rule.h:46
#define _(s)
wxString LayerName(int aLayer)
Returns the default display name for a given layer.
Definition: layer_id.cpp:30
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:59
@ F_Cu
Definition: layer_ids.h:64
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:932
double DoubleValueFromString(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnits, const wxString &aTextValue, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE)
Function DoubleValueFromString converts aTextValue to a double.
Definition: eda_units.cpp:456
std::function< void(CONTEXT *, void *)> FUNC_CALL_REF
BOARD * GetBoard()
#define TYPE_HASH(x)
Definition: property.h:62
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:85