haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/pcbnew/pcb_expr_evaluator.cpp

1209 lines
37 KiB
C++
Raw Normal View History

Updated copyright headers in expression evaluator code
2020-07-03 16:36:33 +00:00
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
More wxString wide literals.
2022-02-04 22:44:59 +00:00
* Copyright (C) 2019-2022 KiCad Developers, see AUTHORS.txt for contributors.
Updated copyright headers in expression evaluator code
2020-07-03 16:36:33 +00:00
*
* 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 2
* 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, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
#include <cstdio>
Add expression eval to constraint min/max/opt values. Also adds error reporting for above.
2020-07-21 15:49:55 +00:00
#include <memory>
Remove some "class_" prefixes from files.
2020-11-12 20:19:22 +00:00
#include <board.h>
Clean up including of board_design_settings.h
2021-06-06 19:03:10 +00:00
#include <board_design_settings.h>
Cleanup includes in board.h and footprint.h
2021-06-03 18:05:43 +00:00
#include <drc/drc_rtree.h>
Prefix TRACK, ARC and VIA.
2021-06-11 21:07:02 +00:00
#include <pcb_track.h>
Remove pcb_group include from board header
2021-06-03 17:03:25 +00:00
#include <pcb_group.h>
Add implicit rule generation for keepout areas. Also implements collision detection for SHAPE_POLY_SET. Fixes https://gitlab.com/kicad/code/kicad/issues/6105
2020-10-21 23:59:40 +00:00
#include <geometry/shape_segment.h>
Report all DRC rule errors, not just the first.
2020-07-30 11:24:29 +00:00
#include <pcb_expr_evaluator.h>
Remove the wxLog calls from math/util.h for now This was leaking windows headers and partial wx headers to 1084 compilation units...... This also means math/util.h is leaking to 1084 compilation units which seems a bit high too.
2021-06-01 05:17:57 +00:00
#include <wx/log.h>
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
pcb_new: CONNECTIVITY_DATA now keeps a cache of DRC from-tos
2020-09-25 18:26:58 +00:00
#include <connectivity/connectivity_data.h>
#include <connectivity/connectivity_algo.h>
#include <connectivity/from_to_cache.h>
PCB_EXPR_EVALUATOR: added isDiffPair() API method
2020-10-08 21:59:40 +00:00
#include <drc/drc_engine.h>
Fix broken build on Linux with gcc.
2020-10-22 12:36:28 +00:00
#include <geometry/shape_circle.h>
pcb_new: CONNECTIVITY_DATA now keeps a cache of DRC from-tos
2020-09-25 18:26:58 +00:00
bool exprFromTo( LIBEVAL::CONTEXT* aCtx, void* self )
{
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
LIBEVAL::VALUE* result = aCtx->AllocValue();
LIBEVAL::VALUE* argTo = aCtx->Pop();
LIBEVAL::VALUE* argFrom = aCtx->Pop();
result->Set(0.0);
aCtx->Push( result );
if(!item)
return false;
auto ftCache = item->GetBoard()->GetConnectivity()->GetFromToCache();
if( !ftCache )
{
More wxString wide literals.
2022-02-04 22:44:59 +00:00
wxLogWarning( wxT( "Attempting to call fromTo() with non-existent from-to cache, "
"aborting..." ));
pcb_new: CONNECTIVITY_DATA now keeps a cache of DRC from-tos
2020-09-25 18:26:58 +00:00
return true;
}
if( ftCache->IsOnFromToPath( static_cast<BOARD_CONNECTED_ITEM*>( item ),
argFrom->AsString(), argTo->AsString() ) )
{
result->Set(1.0);
}
return true;
}
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Rename DRC rule function onLayer to existsOnLayer. Fixes https://gitlab.com/kicad/code/kicad/issues/5647
2020-09-27 17:05:16 +00:00
static void existsOnLayer( LIBEVAL::CONTEXT* aCtx, void *self )
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
{
Flesh out object properties and DRC Rule syntax help.
2020-09-05 16:00:29 +00:00
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
LIBEVAL::VALUE* arg = aCtx->Pop();
LIBEVAL::VALUE* result = aCtx->AllocValue();
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
result->Set( 0.0 );
aCtx->Push( result );
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Flesh out object properties and DRC Rule syntax help.
2020-09-05 16:00:29 +00:00
if( !item )
return;
Fix logic bug found by Coverity.
2021-06-24 10:14:04 +00:00
if( !arg )
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
{
Fix logic bug found by Coverity.
2021-06-24 10:14:04 +00:00
if( aCtx->HasErrorCallback() )
{
aCtx->ReportError( wxString::Format( _( "Missing argument to '%s'" ),
wxT( "existsOnLayer()" ) ) );
}
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
return;
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
}
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
Don't capture references to local stack variables.
2021-08-21 20:40:17 +00:00
[item, arg, aCtx]() -> double
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
const wxString& layerName = arg->AsString();
wxPGChoices& layerMap = ENUM_MAP<PCB_LAYER_ID>::Instance().Choices();
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( aCtx->HasErrorCallback())
{
/*
* Interpreted version
*/
Flesh out object properties and DRC Rule syntax help.
2020-09-05 16:00:29 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
bool anyMatch = false;
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
for( unsigned ii = 0; ii < layerMap.GetCount(); ++ii )
{
wxPGChoiceEntry& entry = layerMap[ ii ];
Flesh out object properties and DRC Rule syntax help.
2020-09-05 16:00:29 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( entry.GetText().Matches( layerName ))
{
anyMatch = true;
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( item->IsOnLayer( ToLAYER_ID( entry.GetValue())))
return 1.0;
}
}
if( !anyMatch )
{
aCtx->ReportError( wxString::Format( _( "Unrecognized layer '%s'" ),
layerName ) );
}
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
}
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
else
{
/*
* Compiled version
*/
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
BOARD* board = item->GetBoard();
std::unique_lock<std::mutex> cacheLock( board->m_CachesMutex );
auto i = board->m_LayerExpressionCache.find( layerName );
LSET mask;
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( i == board->m_LayerExpressionCache.end() )
{
for( unsigned ii = 0; ii < layerMap.GetCount(); ++ii )
{
wxPGChoiceEntry& entry = layerMap[ ii ];
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( entry.GetText().Matches( layerName ) )
mask.set( ToLAYER_ID( entry.GetValue() ) );
}
Add preflighting for DRC rule function calls.
2020-07-22 13:08:57 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
board->m_LayerExpressionCache[ layerName ] = mask;
}
else
{
mask = i->second;
}
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( ( item->GetLayerSet() & mask ).any() )
return 1.0;
}
Garden-variety 100X performance improvement. Adds a compile mode for layer strings.
2021-08-15 21:20:49 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
return 0.0;
} );
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
}
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Add insideCourtyard DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-28 22:49:17 +00:00
static void isPlated( LIBEVAL::CONTEXT* aCtx, void* self )
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
{
LIBEVAL::VALUE* result = aCtx->AllocValue();
PCB_EXPR_EVALUATOR: implement isPlated virtual property
2020-06-19 21:33:29 +00:00
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
result->Set( 0.0 );
aCtx->Push( result );
Add preflighting for DRC rule function calls.
2020-07-22 13:08:57 +00:00
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
Don't store context in the uCode. (It's not thread-safe.) Although it does give some pretty funny results when filling zones.
2020-07-23 20:47:38 +00:00
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
Nullptr safety.
2021-02-22 01:13:38 +00:00
if( !item )
return;
Enum class PAD_ATTR_T Renamed such that python stays the same
2021-05-01 14:46:50 +00:00
if( item->Type() == PCB_PAD_T && static_cast<PAD*>( item )->GetAttribute() == PAD_ATTRIB::PTH )
Vias are plated holes too....
2021-02-20 12:12:23 +00:00
result->Set( 1.0 );
else if( item->Type() == PCB_VIA_T )
Add auto-completion for DRC rule function calls.
2020-07-22 20:27:38 +00:00
result->Set( 1.0 );
}
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
bool calcIsInsideCourtyard( BOARD_ITEM* aItem, const EDA_RECT& aItemBBox,
std::shared_ptr<SHAPE>& aItemShape, PCB_EXPR_CONTEXT* aCtx,
FOOTPRINT* aFootprint, PCB_LAYER_ID aSide )
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
{
SHAPE_POLY_SET footprintCourtyard;
Fix issue with caches not being initialized when printing msg bar. (cherry picked from commit 43df863df2662bd77769d70e36b1473d2fc08eb9)
2022-07-31 21:14:24 +00:00
footprintCourtyard = aFootprint->GetCourtyard( aSide );
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
Normalize `IsInsideCourtyard` (cherry picked from commit c18d9b9baf86fd30cc4a1492aa08c629efb665da)
2022-03-04 23:49:02 +00:00
if( !aFootprint->GetBoundingBox().Intersects( aItemBBox ) )
return false;
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
if( !aItemShape )
aItemShape = aItem->GetEffectiveShape( aCtx->GetLayer() );
return footprintCourtyard.Collide( aItemShape.get() );
};
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
bool isInsideCourtyard( BOARD_ITEM* aItem, const EDA_RECT& aItemBBox,
std::shared_ptr<SHAPE>& aItemShape, PCB_EXPR_CONTEXT* aCtx,
FOOTPRINT* aFootprint, PCB_LAYER_ID aSide )
{
if( !aFootprint )
return false;
BOARD* board = aItem->GetBoard();
std::unique_lock<std::mutex> cacheLock( board->m_CachesMutex );
std::pair<BOARD_ITEM*, BOARD_ITEM*> key( aFootprint, aItem );
std::map< std::pair<BOARD_ITEM*, BOARD_ITEM*>, bool >* cache;
switch( aSide )
{
case F_Cu: cache = &board->m_InsideFCourtyardCache; break;
case B_Cu: cache = &board->m_InsideBCourtyardCache; break;
default: cache = &board->m_InsideCourtyardCache; break;
}
auto i = cache->find( key );
if( i != cache->end() )
return i->second;
bool res = calcIsInsideCourtyard( aItem, aItemBBox, aItemShape, aCtx, aFootprint, aSide );
(*cache)[ key ] = res;
return res;
};
Add insideCourtyard DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-28 22:49:17 +00:00
static void insideCourtyard( LIBEVAL::CONTEXT* aCtx, void* self )
{
Handle wildcards and "other" item for insideCourtyard DRC function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-30 17:06:50 +00:00
PCB_EXPR_CONTEXT* context = static_cast<PCB_EXPR_CONTEXT*>( aCtx );
LIBEVAL::VALUE* arg = aCtx->Pop();
LIBEVAL::VALUE* result = aCtx->AllocValue();
Add insideCourtyard DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-28 22:49:17 +00:00
result->Set( 0.0 );
aCtx->Push( result );
if( !arg )
{
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
if( aCtx->HasErrorCallback() )
{
aCtx->ReportError( wxString::Format( _( "Missing argument to '%s'" ),
wxT( "insideCourtyard()" ) ) );
}
Add insideCourtyard DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-28 22:49:17 +00:00
return;
}
Add cache for insideArea() and insideCourtyard(). Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 19:19:56 +00:00
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
Handle wildcards and "other" item for insideCourtyard DRC function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-30 17:06:50 +00:00
if( !item )
return;
Add insideCourtyard DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-28 22:49:17 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
[item, arg, context]() -> double
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
BOARD* board = item->GetBoard();
EDA_RECT itemBBox;
std::shared_ptr<SHAPE> itemShape;
if( item->Type() == PCB_ZONE_T || item->Type() == PCB_FP_ZONE_T )
itemBBox = static_cast<ZONE*>( item )->GetCachedBoundingBox();
else
itemBBox = item->GetBoundingBox();
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( arg->AsString() == wxT( "A" ) )
Zones must be entirely inside for insideCourtyard. This is a huge performance win as otherwise we're doing *lots* of shape collisions with ground planes. Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 17:18:31 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
FOOTPRINT* fp = dynamic_cast<FOOTPRINT*>( context->GetItem( 0 ) );
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, In1_Cu ) )
return 1.0;
Zones must be entirely inside for insideCourtyard. This is a huge performance win as otherwise we're doing *lots* of shape collisions with ground planes. Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 17:18:31 +00:00
}
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( arg->AsString() == wxT( "B" ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
FOOTPRINT* fp = dynamic_cast<FOOTPRINT*>( context->GetItem( 1 ) );
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, In1_Cu ) )
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
else for( FOOTPRINT* fp : board->Footprints() )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( fp->GetReference().Matches( arg->AsString() ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, In1_Cu ) )
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
}
return 0.0;
} );
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
}
static void insideFrontCourtyard( LIBEVAL::CONTEXT* aCtx, void* self )
{
PCB_EXPR_CONTEXT* context = static_cast<PCB_EXPR_CONTEXT*>( aCtx );
LIBEVAL::VALUE* arg = aCtx->Pop();
LIBEVAL::VALUE* result = aCtx->AllocValue();
result->Set( 0.0 );
aCtx->Push( result );
if( !arg )
{
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
if( aCtx->HasErrorCallback() )
{
aCtx->ReportError( wxString::Format( _( "Missing argument to '%s'" ),
wxT( "insideFrontCourtyard()" ) ) );
}
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
return;
}
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
if( !item )
return;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
[item, arg, context]() -> double
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
BOARD* board = item->GetBoard();
EDA_RECT itemBBox;
std::shared_ptr<SHAPE> itemShape;
if( item->Type() == PCB_ZONE_T || item->Type() == PCB_FP_ZONE_T )
itemBBox = static_cast<ZONE*>( item )->GetCachedBoundingBox();
else
itemBBox = item->GetBoundingBox();
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( arg->AsString() == wxT( "A" ) )
Zones must be entirely inside for insideCourtyard. This is a huge performance win as otherwise we're doing *lots* of shape collisions with ground planes. Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 17:18:31 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
FOOTPRINT* fp = dynamic_cast<FOOTPRINT*>( context->GetItem( 0 ) );
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, F_Cu ) )
return 1.0;
Zones must be entirely inside for insideCourtyard. This is a huge performance win as otherwise we're doing *lots* of shape collisions with ground planes. Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 17:18:31 +00:00
}
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( arg->AsString() == wxT( "B" ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
FOOTPRINT* fp = dynamic_cast<FOOTPRINT*>( context->GetItem( 1 ) );
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, F_Cu ) )
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
else for( FOOTPRINT* fp : board->Footprints() )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( fp->GetReference().Matches( arg->AsString() ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, F_Cu ) )
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
}
return 0.0;
} );
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
}
Run insideCouryard on all matching footprints, not just the first. Fixes https://gitlab.com/kicad/code/kicad/issues/6945
2021-01-05 22:18:37 +00:00
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
static void insideBackCourtyard( LIBEVAL::CONTEXT* aCtx, void* self )
{
PCB_EXPR_CONTEXT* context = static_cast<PCB_EXPR_CONTEXT*>( aCtx );
LIBEVAL::VALUE* arg = aCtx->Pop();
LIBEVAL::VALUE* result = aCtx->AllocValue();
result->Set( 0.0 );
aCtx->Push( result );
if( !arg )
{
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
if( aCtx->HasErrorCallback() )
{
aCtx->ReportError( wxString::Format( _( "Missing argument to '%s'" ),
wxT( "insideBackCourtyard()" ) ) );
}
Add insideFrontCourtyard and insideBackCourtyard DRC functions. Fixes https://gitlab.com/kicad/code/kicad/issues/7972
2021-03-20 20:09:57 +00:00
return;
}
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
if( !item )
return;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
[item, arg, context]() -> double
Add insideCourtyard DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-28 22:49:17 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
BOARD* board = item->GetBoard();
EDA_RECT itemBBox;
std::shared_ptr<SHAPE> itemShape;
if( item->Type() == PCB_ZONE_T || item->Type() == PCB_FP_ZONE_T )
itemBBox = static_cast<ZONE*>( item )->GetCachedBoundingBox();
else
itemBBox = item->GetBoundingBox();
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( arg->AsString() == wxT( "A" ) )
Run insideCouryard on all matching footprints, not just the first. Fixes https://gitlab.com/kicad/code/kicad/issues/6945
2021-01-05 22:18:37 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
FOOTPRINT* fp = dynamic_cast<FOOTPRINT*>( context->GetItem( 0 ) );
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, B_Cu ) )
return 1.0;
Run insideCouryard on all matching footprints, not just the first. Fixes https://gitlab.com/kicad/code/kicad/issues/6945
2021-01-05 22:18:37 +00:00
}
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( arg->AsString() == wxT( "B" ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
FOOTPRINT* fp = dynamic_cast<FOOTPRINT*>( context->GetItem( 1 ) );
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, B_Cu ) )
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
else for( FOOTPRINT* fp : board->Footprints() )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( fp->GetReference().Matches( arg->AsString() ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( isInsideCourtyard( item, itemBBox, itemShape, context, fp, B_Cu ) )
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
}
return 0.0;
} );
Add insideCourtyard DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/4519
2020-07-28 22:49:17 +00:00
}
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
bool calcIsInsideArea( BOARD_ITEM* aItem, const EDA_RECT& aItemBBox, PCB_EXPR_CONTEXT* aCtx,
ZONE* aArea )
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
BOARD* board = aArea->GetBoard();
Fix typo which leads to catastrophic performance on boards with tons of zones. (cherry picked from commit 392a3ec1315bed39c183bee189b8cbedf3744c7d)
2022-03-08 20:16:37 +00:00
EDA_RECT areaBBox = aArea->GetBoundingBox();
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
std::shared_ptr<SHAPE> shape;
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
Fix typo which leads to catastrophic performance on boards with tons of zones. (cherry picked from commit 392a3ec1315bed39c183bee189b8cbedf3744c7d)
2022-03-08 20:16:37 +00:00
if( !areaBBox.Intersects( aItemBBox ) )
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return false;
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
Don't use bounding box cache during insideArea. For starters we can't rely on it having been updated, but we also cache the entire result so there's no huge cost-savings anyway. Fixes https://gitlab.com/kicad/code/kicad/issues/10821 (cherry picked from commit 8dcc933fc37049faad44f89195d6b7890b34a206)
2022-02-12 13:35:30 +00:00
// Collisions include touching, so we need to deflate outline by enough to exclude it.
// This is particularly important for detecting copper fills as they will be exactly
// touching along the entire exclusion border.
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
SHAPE_POLY_SET areaOutline = *aArea->Outline();
areaOutline.Deflate( board->GetDesignSettings().GetDRCEpsilon(), 0,
SHAPE_POLY_SET::ALLOW_ACUTE_CORNERS );
if( aItem->GetFlags() & HOLE_PROXY )
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( aItem->Type() == PCB_PAD_T )
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
PAD* pad = static_cast<PAD*>( aItem );
const SHAPE_SEGMENT* holeShape = pad->GetEffectiveHoleShape();
return areaOutline.Collide( holeShape );
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
}
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
else if( aItem->Type() == PCB_VIA_T )
{
PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
const SHAPE_CIRCLE holeShape( via->GetPosition(), via->GetDrillValue() );
Respect context layer in eval When testing for a specific layer context, we should only return true if the item either exists on that layer or if the context layer is UNDEFINED_LAYER, meaning the layer value is not material to the test Relates to https://gitlab.com/kicad/code/kicad/-/issues/9366
2021-10-15 15:43:31 +00:00
LSET overlap = via->GetLayerSet() & aArea->GetLayerSet();
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
Check for layer when DRC on vias and non-zone items We were already checking for zone-zone overlap but missing checks when running against (possibly) buried vias as well as the general check Fixes https://gitlab.com/kicad/code/kicad/issues/9366
2021-10-11 17:18:28 +00:00
/// Avoid buried vias that don't overlap the zone's layers
Respect context layer in eval When testing for a specific layer context, we should only return true if the item either exists on that layer or if the context layer is UNDEFINED_LAYER, meaning the layer value is not material to the test Relates to https://gitlab.com/kicad/code/kicad/-/issues/9366
2021-10-15 15:43:31 +00:00
if( overlap.count() > 0 )
{
if( aCtx->GetLayer() == UNDEFINED_LAYER || overlap.Contains( aCtx->GetLayer() ) )
Check for layer when DRC on vias and non-zone items We were already checking for zone-zone overlap but missing checks when running against (possibly) buried vias as well as the general check Fixes https://gitlab.com/kicad/code/kicad/issues/9366
2021-10-11 17:18:28 +00:00
return areaOutline.Collide( &holeShape );
Respect context layer in eval When testing for a specific layer context, we should only return true if the item either exists on that layer or if the context layer is UNDEFINED_LAYER, meaning the layer value is not material to the test Relates to https://gitlab.com/kicad/code/kicad/-/issues/9366
2021-10-15 15:43:31 +00:00
}
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
}
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return false;
}
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( aItem->Type() == PCB_FOOTPRINT_T )
{
FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aItem );
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( ( footprint->GetFlags() & MALFORMED_COURTYARDS ) != 0 )
{
if( aCtx->HasErrorCallback() )
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
aCtx->ReportError( _( "Footprint's courtyard is not a single, closed shape." ) );
}
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return false;
}
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( ( aArea->GetLayerSet() & LSET::FrontMask() ).any() )
{
Fix issue with caches not being initialized when printing msg bar. (cherry picked from commit 43df863df2662bd77769d70e36b1473d2fc08eb9)
2022-07-31 21:14:24 +00:00
const SHAPE_POLY_SET& courtyard = footprint->GetCourtyard( F_CrtYd );
Convert insideArea test for zones to be "any copper inside". The test used to be "entire zone inside", but that didn't work when we use it to implement "copper pour" keepout areas. Fixes https://gitlab.com/kicad/code/kicad/issues/7420
2021-02-04 13:42:30 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( courtyard.OutlineCount() == 0 )
{
if( aCtx->HasErrorCallback() )
aCtx->ReportError( _( "Footprint has no front courtyard." ) );
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return false;
}
else
{
return areaOutline.Collide( &courtyard.Outline( 0 ) );
}
}
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( ( aArea->GetLayerSet() & LSET::BackMask() ).any() )
{
Fix issue with caches not being initialized when printing msg bar. (cherry picked from commit 43df863df2662bd77769d70e36b1473d2fc08eb9)
2022-07-31 21:14:24 +00:00
const SHAPE_POLY_SET& courtyard = footprint->GetCourtyard( B_CrtYd );
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( courtyard.OutlineCount() == 0 )
{
if( aCtx->HasErrorCallback() )
aCtx->ReportError( _( "Footprint has no back courtyard." ) );
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return false;
}
else
{
return areaOutline.Collide( &courtyard.Outline( 0 ) );
}
}
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return false;
}
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( aItem->Type() == PCB_ZONE_T || aItem->Type() == PCB_FP_ZONE_T )
{
ZONE* zone = static_cast<ZONE*>( aItem );
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( !zone->IsFilled() )
return false;
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
DRC_RTREE* zoneRTree = board->m_CopperZoneRTrees[ zone ].get();
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
std::vector<SHAPE*> shapes;
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( zoneRTree )
{
for( PCB_LAYER_ID layer : aArea->GetLayerSet().Seq() )
{
Respect context layer in eval When testing for a specific layer context, we should only return true if the item either exists on that layer or if the context layer is UNDEFINED_LAYER, meaning the layer value is not material to the test Relates to https://gitlab.com/kicad/code/kicad/-/issues/9366
2021-10-15 15:43:31 +00:00
if( aCtx->GetLayer() == layer || aCtx->GetLayer() == UNDEFINED_LAYER )
{
Fix typo which leads to catastrophic performance on boards with tons of zones. (cherry picked from commit 392a3ec1315bed39c183bee189b8cbedf3744c7d)
2022-03-08 20:16:37 +00:00
if( zoneRTree->QueryColliding( areaBBox, &areaOutline, layer ) )
Respect context layer in eval When testing for a specific layer context, we should only return true if the item either exists on that layer or if the context layer is UNDEFINED_LAYER, meaning the layer value is not material to the test Relates to https://gitlab.com/kicad/code/kicad/-/issues/9366
2021-10-15 15:43:31 +00:00
return true;
}
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
}
}
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return false;
}
else
{
Allow Rule Areas on all physical layers. Required to do things like modify silk_clearance rules. (cherry picked from commit 8f670552a66046b3cd3d8ece22ba66ac07151612)
2022-02-17 23:54:15 +00:00
PCB_LAYER_ID layer = aCtx->GetLayer();
if( layer != UNDEFINED_LAYER && !( aArea->GetLayerSet().Contains( layer ) ) )
Check for layer when DRC on vias and non-zone items We were already checking for zone-zone overlap but missing checks when running against (possibly) buried vias as well as the general check Fixes https://gitlab.com/kicad/code/kicad/issues/9366
2021-10-11 17:18:28 +00:00
return false;
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( !shape )
Allow Rule Areas on all physical layers. Required to do things like modify silk_clearance rules. (cherry picked from commit 8f670552a66046b3cd3d8ece22ba66ac07151612)
2022-02-17 23:54:15 +00:00
shape = aItem->GetEffectiveShape( layer );
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return areaOutline.Collide( shape.get() );
}
}
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
bool isInsideArea( BOARD_ITEM* aItem, const EDA_RECT& aItemBBox, PCB_EXPR_CONTEXT* aCtx,
ZONE* aArea )
{
if( !aArea || aArea == aItem || aArea->GetParent() == aItem )
return false;
Thread safety for new caches (which are also used during zone fill). Fixes https://gitlab.com/kicad/code/kicad/issues/7749
2021-02-27 21:33:05 +00:00
58f553a9cad972363c21209285bb4b1b142f95a0 requires that cache be layer-sensitive. Fixes https://gitlab.com/kicad/code/kicad/issues/11814 (cherry picked from commit 5e80e2a421b2af1e26d0be57dc05f803d41526a3)
2022-06-14 23:10:01 +00:00
BOARD* board = aArea->GetBoard();
std::unique_lock<std::mutex> cacheLock( board->m_CachesMutex );
PCB_LAYER_ID layer = aCtx->GetLayer();
std::tuple<BOARD_ITEM*, BOARD_ITEM*, PCB_LAYER_ID> key( aArea, aItem, layer );
auto i = board->m_InsideAreaCache.find( key );
Thread safety for new caches (which are also used during zone fill). Fixes https://gitlab.com/kicad/code/kicad/issues/7749
2021-02-27 21:33:05 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( i != board->m_InsideAreaCache.end() )
return i->second;
Modify insideArea() to return true for zones only when fully inside. Intersections is enough for other objects. This is also a bit of a DRC performance improvement. Fixes https://gitlab.com/kicad/code/kicad/issues/6934
2021-01-05 21:28:42 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
bool isInside = calcIsInsideArea( aItem, aItemBBox, aCtx, aArea );
Fix DRC performance with multi-layer keepout zones. The main issue was a parameter mismatch which caused On^2 behaviour for zone layers. But there are several other performance optimizations here, along with status bar updating for zones while running the dissallow test. Fixes https://gitlab.com/kicad/code/kicad/issues/8521
2021-06-02 13:00:11 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
board->m_InsideAreaCache[ key ] = isInside;
return isInside;
}
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
static void insideArea( LIBEVAL::CONTEXT* aCtx, void* self )
{
PCB_EXPR_CONTEXT* context = static_cast<PCB_EXPR_CONTEXT*>( aCtx );
LIBEVAL::VALUE* arg = aCtx->Pop();
LIBEVAL::VALUE* result = aCtx->AllocValue();
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
result->Set( 0.0 );
aCtx->Push( result );
Add cache for insideArea() and insideCourtyard(). Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 19:19:56 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( !arg )
{
if( aCtx->HasErrorCallback() )
{
aCtx->ReportError( wxString::Format( _( "Missing argument to '%s'" ),
wxT( "insideArea()" ) ) );
}
Add cache for insideArea() and insideCourtyard(). Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 19:19:56 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return;
}
Add cache for insideArea() and insideCourtyard(). Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 19:19:56 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
Add cache for insideArea() and insideCourtyard(). Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 19:19:56 +00:00
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( !item )
return;
Add cache for insideArea() and insideCourtyard(). Fixes https://gitlab.com/kicad/code/kicad/issues/7720
2021-02-26 19:19:56 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
[item, arg, context]() -> double
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
BOARD* board = item->GetBoard();
EDA_RECT itemBBox;
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( item->Type() == PCB_ZONE_T || item->Type() == PCB_FP_ZONE_T )
itemBBox = static_cast<ZONE*>( item )->GetCachedBoundingBox();
else
itemBBox = item->GetBoundingBox();
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( arg->AsString() == wxT( "A" ) )
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
ZONE* zone = dynamic_cast<ZONE*>( context->GetItem( 0 ) );
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return isInsideArea( item, itemBBox, context, zone ) ? 1.0 : 0.0;
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
}
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( arg->AsString() == wxT( "B" ) )
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
ZONE* zone = dynamic_cast<ZONE*>( context->GetItem( 1 ) );
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return isInsideArea( item, itemBBox, context, zone ) ? 1.0 : 0.0;
Do footprint keepouts by courtyard. Fixes https://gitlab.com/kicad/code/kicad/issues/6162
2020-10-25 15:02:49 +00:00
}
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
else if( KIID::SniffTest( arg->AsString() ) )
{
KIID target( arg->AsString());
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
for( ZONE* area : board->Zones() )
{
// Only a single zone can match the UUID; exit once we find a match whether
// "inside" or not
if( area->m_Uuid == target )
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return isInsideArea( item, itemBBox, context, area ) ? 1.0 : 0.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
for( FOOTPRINT* footprint : board->Footprints() )
{
for( ZONE* area : footprint->Zones() )
{
// Only a single zone can match the UUID; exit once we find a match
// whether "inside" or not
if( area->m_Uuid == target )
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
return isInsideArea( item, itemBBox, context, area ) ? 1.0 : 0.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
}
return 0.0;
}
else // Match on zone name
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
for( ZONE* area : board->Zones())
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
{
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( area->GetZoneName().Matches( arg->AsString() ) )
{
// Many zones can match the name; exit only when we find an "inside"
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( isInsideArea( item, itemBBox, context, area ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
return 1.0;
}
}
for( FOOTPRINT* footprint : board->Footprints() )
{
for( ZONE* area : footprint->Zones() )
{
// Many zones can match the name; exit only when we find an "inside"
if( area->GetZoneName().Matches( arg->AsString() ) )
{
Don't capture stack-defined lambdas by reference.
2021-08-21 21:49:57 +00:00
if( isInsideArea( item, itemBBox, context, area ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
return 1.0;
}
}
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
}
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
return 0.0;
Don't require keepout zones to be named. insideArea() now takes A, B, a UUID or a zone name. (Only the UUID is new.)
2020-10-25 20:53:24 +00:00
}
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
} );
Update DRC rules to new layer and disallow grammars. Also adds support for hooking rules up to named zones. Fixes https://gitlab.com/kicad/code/kicad/issues/2041
2020-08-07 20:18:33 +00:00
}
ADDED Properties Dialog for groups. ADDED memberOf() function for DRC rule expressions. Also fixes a bug in several of the pickers where the event wasn't being correctly passed. Fixes https://gitlab.com/kicad/code/kicad/issues/5647
2020-09-24 01:05:46 +00:00
static void memberOf( LIBEVAL::CONTEXT* aCtx, void* self )
{
LIBEVAL::VALUE* arg = aCtx->Pop();
LIBEVAL::VALUE* result = aCtx->AllocValue();
result->Set( 0.0 );
aCtx->Push( result );
if( !arg )
{
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
if( aCtx->HasErrorCallback() )
{
aCtx->ReportError( wxString::Format( _( "Missing argument to '%s'" ),
wxT( "memberOf()" ) ) );
}
ADDED Properties Dialog for groups. ADDED memberOf() function for DRC rule expressions. Also fixes a bug in several of the pickers where the event wasn't being correctly passed. Fixes https://gitlab.com/kicad/code/kicad/issues/5647
2020-09-24 01:05:46 +00:00
return;
}
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
if( !item )
return;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
[item, arg]() -> double
{
PCB_GROUP* group = item->GetParentGroup();
ADDED Properties Dialog for groups. ADDED memberOf() function for DRC rule expressions. Also fixes a bug in several of the pickers where the event wasn't being correctly passed. Fixes https://gitlab.com/kicad/code/kicad/issues/5647
2020-09-24 01:05:46 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
if( !group && item->GetParent() && item->GetParent()->Type() == PCB_FOOTPRINT_T )
group = item->GetParent()->GetParentGroup();
ADDED Properties Dialog for groups. ADDED memberOf() function for DRC rule expressions. Also fixes a bug in several of the pickers where the event wasn't being correctly passed. Fixes https://gitlab.com/kicad/code/kicad/issues/5647
2020-09-24 01:05:46 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
while( group )
{
if( group->GetName().Matches( arg->AsString() ) )
return 1.0;
ADDED Properties Dialog for groups. ADDED memberOf() function for DRC rule expressions. Also fixes a bug in several of the pickers where the event wasn't being correctly passed. Fixes https://gitlab.com/kicad/code/kicad/issues/5647
2020-09-24 01:05:46 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
group = group->GetParentGroup();
}
return 0.0;
} );
ADDED Properties Dialog for groups. ADDED memberOf() function for DRC rule expressions. Also fixes a bug in several of the pickers where the event wasn't being correctly passed. Fixes https://gitlab.com/kicad/code/kicad/issues/5647
2020-09-24 01:05:46 +00:00
}
PCB_EXPR_EVALUATOR: added isMicroVia() and isBlindBuriedVia() built-in methods
2020-08-26 22:04:53 +00:00
static void isMicroVia( LIBEVAL::CONTEXT* aCtx, void* self )
{
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
LIBEVAL::VALUE* result = aCtx->AllocValue();
result->Set( 0.0 );
aCtx->Push( result );
Prefix TRACK, ARC and VIA.
2021-06-11 21:07:02 +00:00
PCB_VIA* via = dyn_cast<PCB_VIA*>( item );
PCB_EXPR_EVALUATOR: added isMicroVia() and isBlindBuriedVia() built-in methods
2020-08-26 22:04:53 +00:00
if( via && via->GetViaType() == VIATYPE::MICROVIA )
result->Set ( 1.0 );
}
static void isBlindBuriedVia( LIBEVAL::CONTEXT* aCtx, void* self )
{
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
LIBEVAL::VALUE* result = aCtx->AllocValue();
result->Set( 0.0 );
aCtx->Push( result );
Prefix TRACK, ARC and VIA.
2021-06-11 21:07:02 +00:00
PCB_VIA* via = dyn_cast<PCB_VIA*>( item );
PCB_EXPR_EVALUATOR: added isMicroVia() and isBlindBuriedVia() built-in methods
2020-08-26 22:04:53 +00:00
if( via && via->GetViaType() == VIATYPE::BLIND_BURIED )
result->Set ( 1.0 );
PCB_EXPR_EVALUATOR: added isDiffPair() API method
2020-10-08 21:59:40 +00:00
}
Implement isCoupledDiffPair() DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/7975
2021-03-20 23:03:34 +00:00
static void isCoupledDiffPair( LIBEVAL::CONTEXT* aCtx, void* self )
{
PCB_EXPR_CONTEXT* context = static_cast<PCB_EXPR_CONTEXT*>( aCtx );
BOARD_CONNECTED_ITEM* a = dynamic_cast<BOARD_CONNECTED_ITEM*>( context->GetItem( 0 ) );
BOARD_CONNECTED_ITEM* b = dynamic_cast<BOARD_CONNECTED_ITEM*>( context->GetItem( 1 ) );
LIBEVAL::VALUE* result = aCtx->AllocValue();
result->Set( 0.0 );
aCtx->Push( result );
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
Apply a more sophisticated test for ignoring isInCoupledDiffPair. The basic problem is that the DRC engine does length testing and skew testing by collecting all the diff pair constituent parts and pairing them itself. Since each part is collected on its own, we need to ignore the 'B' unit when evaluating any conditional expressions. However, doing this in general means that when evaluating "OwnClearance()" we also ignore the 'B' unit and return the diff pair CLEARANCE_CONSTRAINT when we shouldn't. This implements a more discerning test which know what the current requested constraint is when evaluating expressions. See also https://forum.kicad.info/t/solved-custom-differencing-rule-not-working-drc/34034/6 Fixes https://gitlab.com/kicad/code/kicad/issues/11314 (cherry picked from commit f7cdc7af754f0830890a1c007b9079527208c9e6)
2022-04-02 14:08:32 +00:00
[a, b, context]() -> double
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
NETINFO_ITEM* netinfo = a ? a->GetNet() : nullptr;
Implement isCoupledDiffPair() DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/7975
2021-03-20 23:03:34 +00:00
Apply a more sophisticated test for ignoring isInCoupledDiffPair. The basic problem is that the DRC engine does length testing and skew testing by collecting all the diff pair constituent parts and pairing them itself. Since each part is collected on its own, we need to ignore the 'B' unit when evaluating any conditional expressions. However, doing this in general means that when evaluating "OwnClearance()" we also ignore the 'B' unit and return the diff pair CLEARANCE_CONSTRAINT when we shouldn't. This implements a more discerning test which know what the current requested constraint is when evaluating expressions. See also https://forum.kicad.info/t/solved-custom-differencing-rule-not-working-drc/34034/6 Fixes https://gitlab.com/kicad/code/kicad/issues/11314 (cherry picked from commit f7cdc7af754f0830890a1c007b9079527208c9e6)
2022-04-02 14:08:32 +00:00
if( !netinfo )
return 0.0;
wxString coupledNet;
wxString dummy;
if( !DRC_ENGINE::MatchDpSuffix( netinfo->GetNetname(), coupledNet, dummy ) )
return 0.0;
if( context->GetConstraint() == DRC_CONSTRAINT_T::LENGTH_CONSTRAINT
|| context->GetConstraint() == DRC_CONSTRAINT_T::SKEW_CONSTRAINT )
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
{
Apply a more sophisticated test for ignoring isInCoupledDiffPair. The basic problem is that the DRC engine does length testing and skew testing by collecting all the diff pair constituent parts and pairing them itself. Since each part is collected on its own, we need to ignore the 'B' unit when evaluating any conditional expressions. However, doing this in general means that when evaluating "OwnClearance()" we also ignore the 'B' unit and return the diff pair CLEARANCE_CONSTRAINT when we shouldn't. This implements a more discerning test which know what the current requested constraint is when evaluating expressions. See also https://forum.kicad.info/t/solved-custom-differencing-rule-not-working-drc/34034/6 Fixes https://gitlab.com/kicad/code/kicad/issues/11314 (cherry picked from commit f7cdc7af754f0830890a1c007b9079527208c9e6)
2022-04-02 14:08:32 +00:00
// DRC engine evaluates these singly, so we won't have a B item
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
Apply a more sophisticated test for ignoring isInCoupledDiffPair. The basic problem is that the DRC engine does length testing and skew testing by collecting all the diff pair constituent parts and pairing them itself. Since each part is collected on its own, we need to ignore the 'B' unit when evaluating any conditional expressions. However, doing this in general means that when evaluating "OwnClearance()" we also ignore the 'B' unit and return the diff pair CLEARANCE_CONSTRAINT when we shouldn't. This implements a more discerning test which know what the current requested constraint is when evaluating expressions. See also https://forum.kicad.info/t/solved-custom-differencing-rule-not-working-drc/34034/6 Fixes https://gitlab.com/kicad/code/kicad/issues/11314 (cherry picked from commit f7cdc7af754f0830890a1c007b9079527208c9e6)
2022-04-02 14:08:32 +00:00
return b && b->GetNetname() == coupledNet;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
} );
Implement isCoupledDiffPair() DRC rule function. Fixes https://gitlab.com/kicad/code/kicad/issues/7975
2021-03-20 23:03:34 +00:00
}
DRC: allow testing against particular diff pair membership
2021-02-28 00:54:55 +00:00
static void inDiffPair( LIBEVAL::CONTEXT* aCtx, void* self )
{
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
LIBEVAL::VALUE* argv = aCtx->Pop();
DRC: allow testing against particular diff pair membership
2021-02-28 00:54:55 +00:00
PCB_EXPR_VAR_REF* vref = static_cast<PCB_EXPR_VAR_REF*>( self );
BOARD_ITEM* item = vref ? vref->GetObject( aCtx ) : nullptr;
LIBEVAL::VALUE* result = aCtx->AllocValue();
result->Set( 0.0 );
aCtx->Push( result );
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
if( !argv )
DRC: allow testing against particular diff pair membership
2021-02-28 00:54:55 +00:00
{
Add rudimentary type checking to rule eval with reporter. Also cleaned up existing error reporting to not expend CPU cycles when there was no reporter. Fixes https://gitlab.com/kicad/code/kicad/issues/8438
2021-05-20 22:05:27 +00:00
if( aCtx->HasErrorCallback() )
{
aCtx->ReportError( wxString::Format( _( "Missing argument to '%s'" ),
wxT( "inDiffPair()" ) ) );
}
DRC: allow testing against particular diff pair membership
2021-02-28 00:54:55 +00:00
return;
}
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
if( !item || !item->GetBoard() )
return;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
result->SetDeferredEval(
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
[item, argv]() -> double
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
if( item && item->IsConnected() )
{
NETINFO_ITEM* netinfo = static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNet();
DRC: allow testing against particular diff pair membership
2021-02-28 00:54:55 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
wxString refName = netinfo->GetNetname();
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
wxString arg = argv->AsString();
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
wxString baseName, coupledNet;
int polarity = DRC_ENGINE::MatchDpSuffix( refName, coupledNet, baseName );
DRC: allow testing against particular diff pair membership
2021-02-28 00:54:55 +00:00
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
if( polarity != 0 && item->GetBoard()->FindNet( coupledNet ) )
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
{
Don't force user to be overly pedantic when writing diffpair rules. (cherry picked from commit fe7e72538e6a6b28d434990a2a9e2233f25d0745)
2022-02-13 18:15:27 +00:00
if( baseName.Matches( arg ) )
return 1.0;
if( baseName.EndsWith( "_" ) && baseName.BeforeLast( '_' ).Matches( arg ) )
return 1.0;
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
}
}
DRC: inDiffPair should return false if the coupled net is missing Fixes https://gitlab.com/kicad/code/kicad/-/issues/8268
2021-04-22 02:41:17 +00:00
Defer DRC rule function eval to make use of short-circuit bools. The lemon parser doesn't lend itself to short-circuiting booleans, but if we defer processing until we fetch the second value when processing the TR_OP_BOOLEAN opcode then we get to piggy-back on C++'s boolean short-circuiting.
2021-08-21 14:24:20 +00:00
return 0.0;
} );
DRC: allow testing against particular diff pair membership
2021-02-28 00:54:55 +00:00
}
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
PCB_EXPR_BUILTIN_FUNCTIONS::PCB_EXPR_BUILTIN_FUNCTIONS()
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
{
PCB_EXPR_EVALUATOR: added fromTo() method
2020-09-23 21:50:06 +00:00
RegisterAllFunctions();
}
void PCB_EXPR_BUILTIN_FUNCTIONS::RegisterAllFunctions()
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
{
PCB_EXPR_EVALUATOR: added fromTo() method
2020-09-23 21:50:06 +00:00
m_funcs.clear();
More wxString wide literals.
2022-02-04 22:44:59 +00:00
RegisterFunc( wxT( "existsOnLayer('x')" ), existsOnLayer );
RegisterFunc( wxT( "isPlated()" ), isPlated );
RegisterFunc( wxT( "insideCourtyard('x')" ), insideCourtyard );
RegisterFunc( wxT( "insideFrontCourtyard('x')" ), insideFrontCourtyard );
RegisterFunc( wxT( "insideBackCourtyard('x')" ), insideBackCourtyard );
RegisterFunc( wxT( "insideArea('x')" ), insideArea );
RegisterFunc( wxT( "isMicroVia()" ), isMicroVia );
RegisterFunc( wxT( "isBlindBuriedVia()" ), isBlindBuriedVia );
RegisterFunc( wxT( "memberOf('x')" ), memberOf );
RegisterFunc( wxT( "fromTo('x','y')" ), exprFromTo );
RegisterFunc( wxT( "isCoupledDiffPair()" ), isCoupledDiffPair );
RegisterFunc( wxT( "inDiffPair('x')" ), inDiffPair );
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
}
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
Add more consts all over the place
2020-10-27 11:03:35 +00:00
BOARD_ITEM* PCB_EXPR_VAR_REF::GetObject( const LIBEVAL::CONTEXT* aCtx ) const
Fix a compil warning
2020-07-22 07:02:30 +00:00
{
Add more consts all over the place
2020-10-27 11:03:35 +00:00
wxASSERT( dynamic_cast<const PCB_EXPR_CONTEXT*>( aCtx ) );
Fix crash bug from bad static_cast.
2020-08-12 15:26:10 +00:00
Don't store context in the uCode. (It's not thread-safe.) Although it does give some pretty funny results when filling zones.
2020-07-23 20:47:38 +00:00
const PCB_EXPR_CONTEXT* ctx = static_cast<const PCB_EXPR_CONTEXT*>( aCtx );
BOARD_ITEM* item = ctx->GetItem( m_itemIndex );
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
return item;
}
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
class PCB_LAYER_VALUE : public LIBEVAL::VALUE
{
public:
PCB_LAYER_VALUE( PCB_LAYER_ID aLayer ) :
LIBEVAL::VALUE( double( aLayer ) )
{};
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
virtual bool EqualTo( LIBEVAL::CONTEXT* aCtx, const VALUE* b ) const override
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
{
// For boards with user-defined layer names there will be 2 entries for each layer
// in the ENUM_MAP: one for the canonical layer name and one for the user layer name.
// We need to check against both.
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
wxPGChoices& layerMap = ENUM_MAP<PCB_LAYER_ID>::Instance().Choices();
const wxString& layerName = b->AsString();
BOARD* board = static_cast<PCB_EXPR_CONTEXT*>( aCtx )->GetBoard();
std::unique_lock<std::mutex> cacheLock( board->m_CachesMutex );
auto i = board->m_LayerExpressionCache.find( layerName );
LSET mask;
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
if( i == board->m_LayerExpressionCache.end() )
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
{
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
for( unsigned ii = 0; ii < layerMap.GetCount(); ++ii )
{
wxPGChoiceEntry& entry = layerMap[ii];
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
if( entry.GetText().Matches( layerName ) )
mask.set( ToLAYER_ID( entry.GetValue() ) );
}
board->m_LayerExpressionCache[ layerName ] = mask;
}
else
{
mask = i->second;
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
}
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
PCB_LAYER_ID layerId = ToLAYER_ID( (int) AsDouble() );
Respect context layer in eval When testing for a specific layer context, we should only return true if the item either exists on that layer or if the context layer is UNDEFINED_LAYER, meaning the layer value is not material to the test Relates to https://gitlab.com/kicad/code/kicad/-/issues/9366
2021-10-15 15:43:31 +00:00
return mask.Contains( layerId );
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
}
};
Don't store context in the uCode. (It's not thread-safe.) Although it does give some pretty funny results when filling zones.
2020-07-23 20:47:38 +00:00
LIBEVAL::VALUE PCB_EXPR_VAR_REF::GetValue( LIBEVAL::CONTEXT* aCtx )
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
{
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
if( m_itemIndex == 2 )
{
PCB_EXPR_CONTEXT* context = static_cast<PCB_EXPR_CONTEXT*>( aCtx );
return PCB_LAYER_VALUE( context->GetLayer() );
}
Nullptr safety. Fixes https://gitlab.com/kicad/code/kicad/issues/6862
2021-01-02 22:25:28 +00:00
BOARD_ITEM* item = GetObject( aCtx );
if( !item )
return LIBEVAL::VALUE();
auto it = m_matchingTypes.find( TYPE_HASH( *item ) );
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
if( it == m_matchingTypes.end() )
{
Better handling of undefined values in Rule expressions. This is particularly important to keep the user from having to enter overly verbose statements such as: A.Type == 'via' && A.Via_Type == 'buried' when: A.Via_Type == 'buried' is perfectly clear.
2020-07-23 10:35:05 +00:00
// Don't force user to type "A.Type == 'via' && A.Via_Type == 'buried'" when the
Fix source comment/doc typos (follow-up) Found via `codespell -q 3 -S *.po,./thirdparty -L aactual,acount,aline,alocation,alog,anormal,anumber,aother,apoints,aparent,aray,dout,einstance,modul,ot,overide,serie,te,,tesselate,tesselator,tht`
2021-07-03 22:37:31 +00:00
// simpler "A.Via_Type == 'buried'" is perfectly clear. Instead, return an undefined
Better handling of undefined values in Rule expressions. This is particularly important to keep the user from having to enter overly verbose statements such as: A.Type == 'via' && A.Via_Type == 'buried' when: A.Via_Type == 'buried' is perfectly clear.
2020-07-23 10:35:05 +00:00
// value when the property doesn't appear on a particular object.
A rule zone is not really a BOARD_CONNECTED_ITEM. Or at least it shouldn't always be treated as one. Fixes https://gitlab.com/kicad/code/kicad/issues/6382
2020-11-15 17:48:25 +00:00
return LIBEVAL::VALUE();
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
}
else
{
if( m_type == LIBEVAL::VT_NUMERIC )
return LIBEVAL::VALUE( (double) item->Get<int>( it->second ) );
else
{
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
wxString str;
Better handling of undefined values in Rule expressions. This is particularly important to keep the user from having to enter overly verbose statements such as: A.Type == 'via' && A.Via_Type == 'buried' when: A.Via_Type == 'buried' is perfectly clear.
2020-07-23 10:35:05 +00:00
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
if( !m_isEnum )
{
Fix overzealous delete from previous commit.
2020-08-18 17:34:48 +00:00
str = item->Get<wxString>( it->second );
PCB_EXPR_EVALUATOR: don't use string comparison to check for undefined enum values
2021-05-03 12:04:15 +00:00
return LIBEVAL::VALUE( str );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
}
else
{
Better handling of undefined values in Rule expressions. This is particularly important to keep the user from having to enter overly verbose statements such as: A.Type == 'via' && A.Via_Type == 'buried' when: A.Via_Type == 'buried' is perfectly clear.
2020-07-23 10:35:05 +00:00
const wxAny& any = item->Get( it->second );
PCB_EXPR_EVALUATOR: don't use string comparison to check for undefined enum values
2021-05-03 12:04:15 +00:00
bool valid = any.GetAs<wxString>( &str );
if( valid )
return LIBEVAL::VALUE( str );
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
}
Better handling of undefined values in Rule expressions. This is particularly important to keep the user from having to enter overly verbose statements such as: A.Type == 'via' && A.Via_Type == 'buried' when: A.Via_Type == 'buried' is perfectly clear.
2020-07-23 10:35:05 +00:00
PCB_EXPR_EVALUATOR: don't use string comparison to check for undefined enum values
2021-05-03 12:04:15 +00:00
return LIBEVAL::VALUE();
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
}
}
}
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
LIBEVAL::VALUE PCB_EXPR_NETCLASS_REF::GetValue( LIBEVAL::CONTEXT* aCtx )
{
BOARD_ITEM* item = GetObject( aCtx );
if( !item )
return LIBEVAL::VALUE();
if( item->IsConnected() )
return LIBEVAL::VALUE( static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNetClassName() );
else
return LIBEVAL::VALUE();
}
LIBEVAL::VALUE PCB_EXPR_NETNAME_REF::GetValue( LIBEVAL::CONTEXT* aCtx )
{
BOARD_ITEM* item = GetObject( aCtx );
if( !item )
return LIBEVAL::VALUE();
if( item->IsConnected() )
return LIBEVAL::VALUE( static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNetname() );
else
return LIBEVAL::VALUE();
}
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
LIBEVAL::VALUE PCB_EXPR_TYPE_REF::GetValue( LIBEVAL::CONTEXT* aCtx )
{
BOARD_ITEM* item = GetObject( aCtx );
if( !item )
return LIBEVAL::VALUE();
return LIBEVAL::VALUE( ENUM_MAP<KICAD_T>::Instance().ToString( item->Type() ) );
}
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
LIBEVAL::FUNC_CALL_REF PCB_EXPR_UCODE::CreateFuncCall( const wxString& aName )
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
{
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
PCB_EXPR_BUILTIN_FUNCTIONS& registry = PCB_EXPR_BUILTIN_FUNCTIONS::Instance();
PCB_EXPR_EVALUATOR: another string fix for wx 3.0
2020-08-14 12:36:27 +00:00
return registry.Get( aName.Lower() );
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
}
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
Expose pad type in property system. Also corrects the spelling of some enum items so they match the menus (otherwise folks will never be able to figure out what they are).
2020-09-24 13:39:59 +00:00
std::unique_ptr<LIBEVAL::VAR_REF> PCB_EXPR_UCODE::CreateVarRef( const wxString& aVar,
const wxString& aField )
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
{
PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
Support for 'L' in DRC expression language. Also make layer testing work again against both canonical names and user names.
2020-09-27 18:43:44 +00:00
std::unique_ptr<PCB_EXPR_VAR_REF> vref;
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
// Check for a couple of very common cases and compile them straight to "object code".
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( aField.CmpNoCase( wxT( "NetClass" ) ) == 0 )
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
{
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( aVar == wxT( "A" ) )
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
return std::make_unique<PCB_EXPR_NETCLASS_REF>( 0 );
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( aVar == wxT( "B" ) )
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
return std::make_unique<PCB_EXPR_NETCLASS_REF>( 1 );
else
return nullptr;
}
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( aField.CmpNoCase( wxT( "NetName" ) ) == 0 )
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
{
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( aVar == wxT( "A" ) )
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
return std::make_unique<PCB_EXPR_NETNAME_REF>( 0 );
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( aVar == wxT( "B" ) )
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
return std::make_unique<PCB_EXPR_NETNAME_REF>( 1 );
else
return nullptr;
}
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( aField.CmpNoCase( wxT( "Type" ) ) == 0 )
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
{
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( aVar == wxT( "A" ) )
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
return std::make_unique<PCB_EXPR_TYPE_REF>( 0 );
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( aVar == wxT( "B" ) )
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
return std::make_unique<PCB_EXPR_TYPE_REF>( 1 );
else
return nullptr;
}
Performance improvements for DRC rules.
2021-01-11 22:08:07 +00:00
More wxString wide literals.
2022-02-04 22:44:59 +00:00
if( aVar == wxT( "A" ) || aVar == wxT( "AB" ) )
Cleanup creation of all our smart pointers
2020-10-26 23:49:11 +00:00
vref = std::make_unique<PCB_EXPR_VAR_REF>( 0 );
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( aVar == wxT( "B" ) )
Cleanup creation of all our smart pointers
2020-10-26 23:49:11 +00:00
vref = std::make_unique<PCB_EXPR_VAR_REF>( 1 );
More wxString wide literals.
2022-02-04 22:44:59 +00:00
else if( aVar == wxT( "L" ) )
Cleanup creation of all our smart pointers
2020-10-26 23:49:11 +00:00
vref = std::make_unique<PCB_EXPR_VAR_REF>( 2 );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
else
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
return nullptr;
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
if( aField.length() == 0 ) // return reference to base object
{
return std::move( vref );
}
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
wxString field( aField );
More wxString wide literals.
2022-02-04 22:44:59 +00:00
field.Replace( wxT( "_" ), wxT( " " ) );
Code completion hookup to property manager.
2020-07-21 22:42:40 +00:00
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
for( const PROPERTY_MANAGER::CLASS_INFO& cls : propMgr.GetAllClasses() )
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
{
if( propMgr.IsOfType( cls.type, TYPE_HASH( BOARD_ITEM ) ) )
{
PROPERTY_BASE* prop = propMgr.GetProperty( cls.type, field );
Fix a compil warning
2020-07-22 07:02:30 +00:00
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
if( prop )
{
vref->AddAllowedClass( cls.type, prop );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
if( prop->TypeHash() == TYPE_HASH( int ) )
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
{
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
vref->SetType( LIBEVAL::VT_NUMERIC );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
}
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
else if( prop->TypeHash() == TYPE_HASH( wxString ) )
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
{
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
vref->SetType( LIBEVAL::VT_STRING );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
}
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
else if ( prop->HasChoices() )
{ // it's an enum, we treat it as string
vref->SetType( LIBEVAL::VT_STRING );
PCB_EXPR_EVALUATOR: added fromTo() method
2020-09-23 21:50:06 +00:00
vref->SetIsEnum ( true );
OnLayer virtual property in PC_EXPR_EVALUATOR
2020-06-16 19:49:09 +00:00
}
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
else
{
More wxString wide literals.
2022-02-04 22:44:59 +00:00
wxFAIL_MSG( wxT( "PCB_EXPR_UCODE::createVarRef: Unknown property type." ) );
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
}
}
}
}
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
if( vref->GetType() == LIBEVAL::VT_UNDEFINED )
Report all DRC rule errors, not just the first.
2020-07-30 11:24:29 +00:00
vref->SetType( LIBEVAL::VT_PARSE_ERROR );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
return std::move( vref );
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
}
Add a compile error for ill-defined rules, and more performance. Also adds const-safety to GetBoard().
2021-08-16 09:53:27 +00:00
BOARD* PCB_EXPR_CONTEXT::GetBoard() const
{
if( m_items[0] )
return m_items[0]->GetBoard();
return nullptr;
}
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
class PCB_UNIT_RESOLVER : public LIBEVAL::UNIT_RESOLVER
{
public:
virtual ~PCB_UNIT_RESOLVER()
{
}
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
virtual const std::vector<wxString>& GetSupportedUnits() const override
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
{
More wxString wide literals.
2022-02-04 22:44:59 +00:00
static const std::vector<wxString> pcbUnits = { wxT( "mil" ), wxT( "mm" ), wxT( "in" ) };
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
return pcbUnits;
}
Ban unitless numbers in DRC rules. Fixes https://gitlab.com/kicad/code/kicad/issues/6029
2020-10-16 23:14:59 +00:00
virtual wxString GetSupportedUnitsMessage() const override
{
return _( "must be mm, in, or mil" );
}
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
virtual double Convert( const wxString& aString, int unitId ) const override
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
{
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
double v = wxAtof( aString );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
switch( unitId )
{
Fix inches being sometimes used instead of mils
2020-10-02 22:04:16 +00:00
case 0: return DoubleValueFromString( EDA_UNITS::MILS, aString );
Attempt to fix locale issue with decimal separator in rules.
2020-08-15 16:30:55 +00:00
case 1: return DoubleValueFromString( EDA_UNITS::MILLIMETRES, aString );
Add mils to units, remove useMils variables
2020-10-02 20:51:24 +00:00
case 2: return DoubleValueFromString( EDA_UNITS::INCHES, aString );
Hook libeval compiler up to rule parser - convert expression string tokens to single-quote-delimited - fix bug where netclass assignments weren't getting updated after board setup dialog - move property manager rebuild to lazy evaluation - improve performance with wider use of const& - retire DRC_SELECTOR stuff - use wxString for GUI stuff (particularly translated stuff) - fix EqualTo() to return false instead of asserting when op types don't match - fix buffer overruns with fixed-size string buffers - make expression function calls case-insensitive - integrate expression errors into rule parser - produce more and better error messages - keep BOARD_ITEM ptrs const as long as possible - fix a couple of uninitialized variables
2020-07-19 21:22:49 +00:00
default: return v;
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
}
};
};
Migrate RC_ITEM to use shared_ptr
2020-08-11 13:33:16 +00:00
PCB_EXPR_COMPILER::PCB_EXPR_COMPILER()
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
{
Add expression eval to constraint min/max/opt values. Also adds error reporting for above.
2020-07-21 15:49:55 +00:00
m_unitResolver = std::make_unique<PCB_UNIT_RESOLVER>();
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
}
Fix uninitialized member warnings Based on PVS Studio report
2021-05-30 23:47:57 +00:00
PCB_EXPR_EVALUATOR::PCB_EXPR_EVALUATOR() :
m_result( 0 ),
m_compiler(),
m_ucode(),
m_errorStatus()
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
{
}
Fix uninitialized member warnings Based on PVS Studio report
2021-05-30 23:47:57 +00:00
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
PCB_EXPR_EVALUATOR::~PCB_EXPR_EVALUATOR()
{
}
bool PCB_EXPR_EVALUATOR::Evaluate( const wxString& aExpr )
{
Don't store context in the uCode. (It's not thread-safe.) Although it does give some pretty funny results when filling zones.
2020-07-23 20:47:38 +00:00
PCB_EXPR_UCODE ucode;
Apply a more sophisticated test for ignoring isInCoupledDiffPair. The basic problem is that the DRC engine does length testing and skew testing by collecting all the diff pair constituent parts and pairing them itself. Since each part is collected on its own, we need to ignore the 'B' unit when evaluating any conditional expressions. However, doing this in general means that when evaluating "OwnClearance()" we also ignore the 'B' unit and return the diff pair CLEARANCE_CONSTRAINT when we shouldn't. This implements a more discerning test which know what the current requested constraint is when evaluating expressions. See also https://forum.kicad.info/t/solved-custom-differencing-rule-not-working-drc/34034/6 Fixes https://gitlab.com/kicad/code/kicad/issues/11314 (cherry picked from commit f7cdc7af754f0830890a1c007b9079527208c9e6)
2022-04-02 14:08:32 +00:00
PCB_EXPR_CONTEXT preflightContext( NULL_CONSTRAINT, F_Cu );
Add expression eval to constraint min/max/opt values. Also adds error reporting for above.
2020-07-21 15:49:55 +00:00
Fix some more cases of malformed syntax crashing the compiler. Fixes https://gitlab.com/kicad/code/kicad/issues/6016
2020-10-15 15:58:35 +00:00
if( !m_compiler.Compile( aExpr.ToUTF8().data(), &ucode, &preflightContext ) )
return false;
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
Apply a more sophisticated test for ignoring isInCoupledDiffPair. The basic problem is that the DRC engine does length testing and skew testing by collecting all the diff pair constituent parts and pairing them itself. Since each part is collected on its own, we need to ignore the 'B' unit when evaluating any conditional expressions. However, doing this in general means that when evaluating "OwnClearance()" we also ignore the 'B' unit and return the diff pair CLEARANCE_CONSTRAINT when we shouldn't. This implements a more discerning test which know what the current requested constraint is when evaluating expressions. See also https://forum.kicad.info/t/solved-custom-differencing-rule-not-working-drc/34034/6 Fixes https://gitlab.com/kicad/code/kicad/issues/11314 (cherry picked from commit f7cdc7af754f0830890a1c007b9079527208c9e6)
2022-04-02 14:08:32 +00:00
PCB_EXPR_CONTEXT evaluationContext( NULL_CONSTRAINT, F_Cu );
Report all DRC rule errors, not just the first.
2020-07-30 11:24:29 +00:00
LIBEVAL::VALUE* result = ucode.Run( &evaluationContext );
pcbnew: initial version of PCB-specific expression evaluator
2020-06-13 23:22:08 +00:00
if( result->GetType() == LIBEVAL::VT_NUMERIC )
m_result = KiROUND( result->AsDouble() );
return true;
}