KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_connection.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2018 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * @author Jon Evans <[email protected]>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23#include <regex>
24#include <wx/tokenzr.h>
25
26#include <connection_graph.h>
27#include <sch_symbol.h>
28#include <sch_pin.h>
29#include <sch_screen.h>
31#include <advanced_config.h>
32#include <string_utils.h>
33
34#include <sch_connection.h>
35#include <boost/algorithm/string/join.hpp>
36
66 m_sheet( aPath ),
67 m_local_sheet( aPath ),
68 m_parent( aParent ),
69 m_driver( nullptr ),
70 m_graph( nullptr )
71{
72 Reset();
73}
74
75
77 m_sheet( SCH_SHEET_PATH() ),
78 m_local_sheet( SCH_SHEET_PATH() ),
79 m_parent( nullptr ),
80 m_driver( nullptr ),
81 m_graph( aGraph )
82{
83 Reset();
84}
85
86
88 m_parent( nullptr ),
89 m_driver( nullptr )
90{
91 Reset();
92 Clone( aOther );
93}
94
95
96bool SCH_CONNECTION::operator==( const SCH_CONNECTION& aOther ) const
97{
98 // NOTE: Not comparing m_dirty or net/bus/subgraph codes
99 if( ( aOther.m_driver == m_driver ) &&
100 ( aOther.m_type == m_type ) &&
101 ( aOther.m_name == m_name ) &&
102 ( aOther.m_sheet == m_sheet ) )
103 {
104 return true;
105 }
106
107 return false;
108}
109
110
112{
113 m_driver = aItem;
114
115 recacheName();
116
117 for( const std::shared_ptr<SCH_CONNECTION>& member : m_members )
118 member->SetDriver( aItem );
119}
120
121
123{
124 m_sheet = aSheet;
125 m_local_sheet = aSheet;
126
127 recacheName();
128
129 for( const std::shared_ptr<SCH_CONNECTION>& member : m_members )
130 member->SetSheet( aSheet );
131}
132
133
135{
136 return !( aOther == *this );
137}
138
139
140void SCH_CONNECTION::ConfigureFromLabel( const wxString& aLabel )
141{
142 m_members.clear();
143
144 m_name = aLabel;
145 m_local_name = aLabel;
147
148 wxString prefix;
149 std::vector<wxString> members;
150
151 wxString unescaped = UnescapeString( aLabel );
152
153 if( NET_SETTINGS::ParseBusVector( unescaped, &prefix, &members ) )
154 {
155 m_type = CONNECTION_TYPE::BUS;
156 m_vector_prefix = std::move( prefix );
157
158 long i = 0;
159
160 for( const wxString& vector_member : members )
161 {
162 std::shared_ptr<SCH_CONNECTION> member = std::make_shared<SCH_CONNECTION>( m_parent, m_sheet );
163
164 member->m_type = CONNECTION_TYPE::NET;
165 member->m_prefix = m_prefix;
166 member->m_local_name = vector_member;
167 member->m_local_prefix = m_prefix;
168 member->m_vector_index = i++;
169 member->SetName( vector_member );
170 member->SetGraph( m_graph );
171 m_members.push_back( std::move( member ) );
172 }
173 }
174 else if( NET_SETTINGS::ParseBusGroup( unescaped, &prefix, &members ) )
175 {
176 m_type = CONNECTION_TYPE::BUS_GROUP;
177 m_bus_prefix = prefix;
178
179 // Named bus groups generate a net prefix, unnamed ones don't
180 if( !prefix.IsEmpty() )
181 prefix += wxT( "." );
182
183 for( const wxString& group_member : members )
184 {
185 // Handle alias inside bus group member list
186 if( auto alias = m_graph->GetBusAlias( group_member ) )
187 {
188 for( const wxString& alias_member : alias->Members() )
189 {
190 std::shared_ptr<SCH_CONNECTION> member = std::make_shared<SCH_CONNECTION>( m_parent, m_sheet );
191 member->SetPrefix( prefix );
192 member->SetGraph( m_graph );
193 member->ConfigureFromLabel( EscapeString( alias_member, CTX_NETNAME ) );
194 m_members.push_back( std::move( member ) );
195 }
196 }
197 else
198 {
199 std::shared_ptr<SCH_CONNECTION> member = std::make_shared<SCH_CONNECTION>( m_parent, m_sheet );
200 member->SetPrefix( prefix );
201 member->SetGraph( m_graph );
202 member->ConfigureFromLabel( group_member );
203 m_members.push_back( std::move( member ) );
204 }
205 }
206 }
207 else
208 {
209 m_type = CONNECTION_TYPE::NET;
210 }
211
212 recacheName();
213}
214
215
217{
218 m_type = CONNECTION_TYPE::NONE;
219 m_name.Empty();
220 m_local_name.Empty();
221 m_local_prefix.Empty();
222 m_cached_name.Empty();
224 m_prefix.Empty();
225 m_bus_prefix.Empty();
226 m_suffix .Empty();
228 m_driver = nullptr;
229 m_members.clear();
230 m_dirty = true;
231 m_net_code = 0;
232 m_bus_code = 0;
233 m_subgraph_code = 0;
234 m_vector_start = 0;
235 m_vector_end = 0;
236 m_vector_index = 0;
237 m_vector_prefix.Empty();
238}
239
240
242{
243 m_graph = aOther.m_graph;
244
245 // Note: m_lastDriver is not cloned as it needs to be the last driver of *this* connection
246 m_driver = aOther.Driver();
247 m_sheet = aOther.Sheet();
248
249 // Note: m_local_sheet is not cloned
250 m_name = aOther.m_name;
251 m_type = aOther.m_type;
252
253 // Note: m_local_name is not cloned if not set yet
254 if( m_local_name.IsEmpty() )
255 {
256 m_local_name = aOther.LocalName();
257 m_local_prefix = aOther.Prefix();
258 }
259
260 m_prefix = aOther.Prefix();
261
262 // m_bus_prefix is not cloned; only used for local names
263 m_suffix = aOther.Suffix();
264 m_net_code = aOther.NetCode();
265 m_bus_code = aOther.BusCode();
266 m_vector_start = aOther.VectorStart();
267 m_vector_end = aOther.VectorEnd();
268
269 // Note: m_vector_index is not cloned
270 m_vector_prefix = aOther.VectorPrefix();
271
272 // Note: subgraph code isn't cloned, it should remain with the original object
273
274 // Handle vector bus members: make sure local names are preserved where possible
275 const std::vector<std::shared_ptr<SCH_CONNECTION>>& otherMembers = aOther.Members();
276
277 if( m_type == CONNECTION_TYPE::BUS && aOther.Type() == CONNECTION_TYPE::BUS )
278 {
279 if( m_members.empty() )
280 {
281 m_members = otherMembers;
282 }
283 else
284 {
285 size_t cloneLimit = std::min( m_members.size(), otherMembers.size() );
286
287 for( size_t i = 0; i < cloneLimit; ++i )
288 m_members[i]->Clone( *otherMembers[i] );
289 }
290 }
291 else if( m_type == CONNECTION_TYPE::BUS_GROUP && aOther.Type() == CONNECTION_TYPE::BUS_GROUP )
292 {
293 if( m_members.empty() )
294 {
295 m_members = otherMembers;
296 }
297 else
298 {
299 // TODO: refactor this once we support deep nesting
300 for( std::shared_ptr<SCH_CONNECTION>& member : m_members )
301 {
302 auto it = std::find_if( otherMembers.begin(), otherMembers.end(),
303 [&]( const std::shared_ptr<SCH_CONNECTION>& aTest )
304 {
305 return aTest->LocalName() == member->LocalName();
306 } );
307
308 if( it != otherMembers.end() )
309 member->Clone( **it );
310 }
311 }
312 }
313
314 m_type = aOther.Type();
315
316 recacheName();
317}
318
319
321{
322 wxASSERT( Parent() );
323
324 switch( Parent()->Type() )
325 {
326 case SCH_LABEL_T:
328 case SCH_HIER_LABEL_T:
329 case SCH_SHEET_PIN_T:
330 case SCH_SHEET_T:
331 return true;
332
333 case SCH_PIN_T:
334 {
335 const SCH_PIN* pin = static_cast<const SCH_PIN*>( Parent() );
336
337 if( const SCH_SYMBOL* symbol = dynamic_cast<const SCH_SYMBOL*>( pin->GetParentSymbol() ) )
338 {
339 // Only annotated symbols should drive nets.
340 return pin->IsPower() || symbol->IsAnnotated( &m_sheet );
341 }
342
343 return true;
344 }
345
346 default:
347 return false;
348 }
349}
350
351
353{
354 return m_driver != m_lastDriver;
355}
356
357
359{
361}
362
363
364
365wxString SCH_CONNECTION::Name( bool aIgnoreSheet ) const
366{
367 wxASSERT( !m_cached_name.IsEmpty() );
368 return aIgnoreSheet ? m_cached_name : m_cached_name_with_path;
369}
370
371
373{
374 wxString retv;
375
376 if( m_graph )
377 {
379
380 if( subgraph )
381 retv = subgraph->GetNetName();
382 }
383
384 return retv;
385}
386
387
389{
390 m_cached_name = m_name.IsEmpty() ? wxString( wxT( "<NO NET>" ) )
391 : wxString( m_prefix ) << m_name << m_suffix;
392
393 bool prepend_path = true;
394
395 if( !Parent() || m_type == CONNECTION_TYPE::NONE )
396 prepend_path = false;
397
398 if( m_driver )
399 {
400 switch( m_driver->Type() )
401 {
403 prepend_path = false;
404 break;
405
406 case SCH_PIN_T:
407 { // Normal pins and global power pins do not need a path. But local power pins do
408 SCH_PIN* pin = static_cast<SCH_PIN*>( m_driver );
409
410 prepend_path = pin->IsLocalPower();
411 break;
412 }
413
414 default:
415 break;
416 }
417 }
418
421}
422
423
424void SCH_CONNECTION::SetPrefix( const wxString& aPrefix )
425{
426 m_prefix = aPrefix;
427
428 recacheName();
429
430 for( const std::shared_ptr<SCH_CONNECTION>& m : Members() )
431 m->SetPrefix( aPrefix );
432}
433
434
435void SCH_CONNECTION::SetSuffix( const wxString& aSuffix )
436{
437 m_suffix = aSuffix;
438
439 recacheName();
440
441 for( const std::shared_ptr<SCH_CONNECTION>& m : Members() )
442 m->SetSuffix( aSuffix );
443}
444
445
446void SCH_CONNECTION::AppendInfoToMsgPanel( std::vector<MSG_PANEL_ITEM>& aList ) const
447{
448 wxString msg, group_name;
449 std::vector<wxString> group_members;
450
451 aList.emplace_back( _( "Connection Name" ), UnescapeString( Name() ) );
452
453 if( std::shared_ptr<BUS_ALIAS> alias = m_graph->GetBusAlias( m_name ) )
454 {
455 msg.Printf( _( "Bus Alias %s Members" ), m_name );
456 aList.emplace_back( msg, boost::algorithm::join( alias->Members(), " " ) );
457 }
458 else if( NET_SETTINGS::ParseBusGroup( m_name, &group_name, &group_members ) )
459 {
460 for( const wxString& group_member : group_members )
461 {
462 if( std::shared_ptr<BUS_ALIAS> group_alias = m_graph->GetBusAlias( group_member ) )
463 {
464 msg.Printf( _( "Bus Alias %s Members" ), group_alias->GetName() );
465 aList.emplace_back( msg, boost::algorithm::join( group_alias->Members(), " " ) );
466 }
467 }
468 }
469
470#if defined(DEBUG)
471 // These messages are not flagged as translatable, because they are only debug messages
472
473 if( IsBus() )
474 aList.emplace_back( wxT( "Bus Code" ), wxString::Format( "%d", m_bus_code ) );
475
476 aList.emplace_back( wxT( "Subgraph Code" ), wxString::Format( "%d", m_subgraph_code ) );
477
478 if( SCH_ITEM* driver = Driver() )
479 {
480 UNITS_PROVIDER unitsProvider( schIUScale, EDA_UNITS::MM );
481
482 msg.Printf( wxS( "%s at %p" ),
483 driver->GetItemDescription( &unitsProvider, false ),
484 driver );
485 aList.emplace_back( wxT( "Connection Source" ), msg );
486 }
487#endif
488}
489
490
491bool SCH_CONNECTION::IsBusLabel( const wxString& aLabel )
492{
493 const wxString& unescaped = UnescapeString( aLabel );
494
495 return NET_SETTINGS::ParseBusVector( unescaped, nullptr, nullptr )
496 || NET_SETTINGS::ParseBusGroup( unescaped, nullptr, nullptr );
497}
498
499
500bool SCH_CONNECTION::MightBeBusLabel( const wxString& aLabel )
501{
502 // Weak heuristic for performance reasons. Stronger test will be used for connectivity
503 wxString label = UnescapeString( aLabel );
504
505 return label.Contains( wxT( "[" ) ) || label.Contains( wxT( "{" ) );
506}
507
508
509const std::vector< std::shared_ptr< SCH_CONNECTION > > SCH_CONNECTION::AllMembers() const
510{
511 std::vector< std::shared_ptr< SCH_CONNECTION > > ret( m_members );
512
513 for( const std::shared_ptr<SCH_CONNECTION>& member : m_members )
514 {
515 if( member->IsBus() )
516 ret.insert( ret.end(), member->Members().begin(), member->Members().end() );
517 }
518
519 return ret;
520}
521
522
523static bool isSuperSubOverbar( wxChar c )
524{
525 return c == '_' || c == '^' || c == '~';
526};
527
528
529wxString SCH_CONNECTION::PrintBusForUI( const wxString& aGroup )
530{
531 size_t groupLen = aGroup.length();
532 size_t i = 0;
533 wxString ret;
534
535 // Parse prefix
536 //
537 for( ; i < groupLen; ++i )
538 {
539 if( isSuperSubOverbar( aGroup[i] ) && i + 1 < groupLen && aGroup[i+1] == '{' )
540 {
541 i++;
542 continue;
543 }
544 else if( aGroup[i] == '}' )
545 {
546 continue;
547 }
548
549 ret += aGroup[i];
550
551 if( aGroup[i] == '{' )
552 break;
553 }
554
555 // Parse members
556 //
557 i++; // '{' character
558
559 for( ; i < groupLen; ++i )
560 {
561 if( isSuperSubOverbar( aGroup[i] ) && i + 1 < groupLen && aGroup[i+1] == '{' )
562 {
563 i++;
564 continue;
565 }
566 else if( aGroup[i] == '}' )
567 {
568 continue;
569 }
570
571 ret += aGroup[i];
572
573 if( aGroup[i] == '}' )
574 break;
575 }
576
577 return ret;
578}
579
580
582{
583 if( !aOther->IsBus() )
584 return false;
585
586 if( !IsBus() )
587 {
588 for( const std::shared_ptr<SCH_CONNECTION>& otherMember : aOther->Members() )
589 {
590 if( FullLocalName() == otherMember->FullLocalName() )
591 return true;
592 }
593
594 return false;
595 }
596
597 // If both connections are buses, check if all members of this bus are in the other bus
598 for( const std::shared_ptr<SCH_CONNECTION>& member : m_members )
599 {
600 bool found = false;
601
602 for( const std::shared_ptr<SCH_CONNECTION>& otherMember : aOther->Members() )
603 {
604 if( member->FullLocalName() == otherMember->FullLocalName() )
605 {
606 found = true;
607 break;
608 }
609 }
610
611 // If one of the members is not found in the other connection, this is not a subset
612 if( !found )
613 return false;
614 }
615
616 return true;
617}
618
619
621{
622 if( !aOther->IsBus() )
623 return false;
624
625 wxString me = Name( true );
626
627 for( const std::shared_ptr<SCH_CONNECTION>& m : aOther->Members() )
628 {
629 if( m->Name( true ) == me )
630 return true;
631 }
632
633 return false;
634}
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:114
Calculate the connectivity of a schematic and generates netlists.
std::shared_ptr< BUS_ALIAS > GetBusAlias(const wxString &aName)
Return a bus alias pointer for the given name if it exists (from cache)
CONNECTION_SUBGRAPH * GetSubgraphForItem(SCH_ITEM *aItem) const
A subgraph is a set of items that are electrically connected on a single sheet.
wxString GetNetName() const
Return the fully-qualified net name for this subgraph (if one exists)
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:110
static bool ParseBusGroup(const wxString &aGroup, wxString *name, std::vector< wxString > *aMemberList)
Parse a bus group label into the name and a list of components.
static bool ParseBusVector(const wxString &aBus, wxString *aName, std::vector< wxString > *aMemberList)
Parse a bus vector (e.g.
Each graphical item can have a SCH_CONNECTION describing its logical connection (to a bus or net).
long VectorEnd() const
wxString FullLocalName() const
long m_vector_start
Highest member of a vector bus.
bool IsMemberOfBus(SCH_CONNECTION *aOther) const
Returns true if this connection is a member of bus connection aOther.
void ConfigureFromLabel(const wxString &aLabel)
Configures the connection given a label.
SCH_ITEM * m_parent
The SCH_ITEM this connection is owned by.
SCH_SHEET_PATH m_sheet
The hierarchical sheet this connection is on.
bool operator!=(const SCH_CONNECTION &aOther) const
void SetSuffix(const wxString &aSuffix)
long VectorStart() const
wxString m_name
Name of the connection.
SCH_ITEM * Parent() const
wxString GetNetName() const
long m_vector_end
Lowest member of a vector bus.
SCH_SHEET_PATH Sheet() const
CONNECTION_TYPE Type() const
bool HasDriverChanged() const
const std::vector< std::shared_ptr< SCH_CONNECTION > > AllMembers() const
SCH_CONNECTION(SCH_ITEM *aParent=nullptr, const SCH_SHEET_PATH &aPath=SCH_SHEET_PATH())
Buses can be defined in multiple ways.
void Reset()
Clears connectivity information.
int BusCode() const
bool operator==(const SCH_CONNECTION &aOther) const
Note: the equality operator for SCH_CONNECTION only tests the net properties, not the ownership / she...
std::vector< std::shared_ptr< SCH_CONNECTION > > m_members
For bus connections, store a list of member connections.
wxString m_local_prefix
Local prefix for group bus members (used with m_local_name)
CONNECTION_TYPE m_type
SCH_ITEM * m_driver
The SCH_ITEM that drives this connection's net.
bool IsDriver() const
Checks if the SCH_ITEM this connection is attached to can drive connections Drivers can be labels,...
void SetPrefix(const wxString &aPrefix)
wxString LocalName() const
wxString Name(bool aIgnoreSheet=false) const
bool IsSubsetOf(SCH_CONNECTION *aOther) const
Returns true if this connection is contained within aOther (but not the same as aOther)
wxString Suffix() const
void SetDriver(SCH_ITEM *aItem)
SCH_SHEET_PATH m_local_sheet
When a connection is overridden by one on a different hierarchical sheet, it will be cloned and m_she...
bool IsBus() const
wxString m_prefix
Prefix if connection is member of a labeled bus group (or "" if not)
void Clone(const SCH_CONNECTION &aOther)
Copies connectivity information (but not parent) from another connection.
void * m_lastDriver
WEAK POINTER (there is no guarantee it is still allocated) Equality comparisons are OK,...
wxString m_cached_name_with_path
Full name including sheet path (if not global)
long m_vector_index
Index of bus vector member nets.
wxString VectorPrefix() const
SCH_ITEM * Driver() const
void AppendInfoToMsgPanel(std::vector< MSG_PANEL_ITEM > &aList) const
Adds information about the connection object to aList.
static bool IsBusLabel(const wxString &aLabel)
Test if aLabel has a bus notation.
wxString m_suffix
Name suffix (used only for disambiguation)
wxString m_bus_prefix
Optional prefix of a bus group (always empty for nets and vector buses)
const std::vector< std::shared_ptr< SCH_CONNECTION > > & Members() const
wxString m_cached_name
Full name, including prefix and suffix.
wxString Prefix() const
CONNECTION_GRAPH * m_graph
Pointer to the connection graph for the schematic this connection exists on.
static wxString PrintBusForUI(const wxString &aString)
wxString m_local_name
For bus members, we want to keep track of the "local" name of a member, that is, the name it takes on...
void SetSheet(const SCH_SHEET_PATH &aSheet)
int m_subgraph_code
Groups directly-connected items.
wxString m_vector_prefix
Prefix name of the vector, if m_type == CONNECTION_BUS (or "" if not).
static bool MightBeBusLabel(const wxString &aLabel)
Test if aLabel looks like a bus notation.
int NetCode() const
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:168
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
wxString PathHumanReadable(bool aUseShortRootName=true, bool aStripTrailingSeparator=false) const
Return the sheet path in a human readable form made from the sheet names.
Schematic symbol object.
Definition: sch_symbol.h:75
#define _(s)
static bool isSuperSubOverbar(wxChar c)
static bool isSuperSubOverbar(wxChar c)
wxString UnescapeString(const wxString &aSource)
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
@ CTX_NETNAME
Definition: string_utils.h:53
@ SCH_LABEL_T
Definition: typeinfo.h:168
@ SCH_SHEET_T
Definition: typeinfo.h:176
@ SCH_HIER_LABEL_T
Definition: typeinfo.h:170
@ SCH_SHEET_PIN_T
Definition: typeinfo.h:175
@ SCH_GLOBAL_LABEL_T
Definition: typeinfo.h:169
@ SCH_PIN_T
Definition: typeinfo.h:154