kicad/eeschema/netlist_object_list.cpp

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2013 Wayne Stambaugh <stambaughw@gmail.com>
 * Copyright (C) 1992-2018 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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
 */

#include <netlist_object.h>
#include <class_library.h>
#include <sch_junction.h>
#include <sch_component.h>
#include <sch_line.h>
#include <sch_text.h>
#include <sch_sheet.h>
#include <algorithm>

#define IS_WIRE false
#define IS_BUS true

//#define NETLIST_DEBUG

NETLIST_OBJECT_LIST::~NETLIST_OBJECT_LIST()
{
    Clear();
}


void NETLIST_OBJECT_LIST::Clear()
{
    NETLIST_OBJECTS::iterator iter;

    for( iter = begin(); iter != end(); iter++ )
    {
        NETLIST_OBJECT* item = *iter;
        delete item;
    }

    clear();
}


void NETLIST_OBJECT_LIST::SortListbyNetcode()
{
    sort( this->begin(), this->end(), NETLIST_OBJECT_LIST::sortItemsbyNetcode );
}


void NETLIST_OBJECT_LIST::SortListbySheet()
{
    sort( this->begin(), this->end(), NETLIST_OBJECT_LIST::sortItemsBySheet );
}


bool NETLIST_OBJECT_LIST::BuildNetListInfo( SCH_SHEET_LIST& aSheets )
{
    SCH_SHEET_PATH* sheet;

    // Fill list with connected items from the flattened sheet list
    for( unsigned i = 0; i < aSheets.size();  i++ )
    {
        sheet = &aSheets[i];

        for( auto item : sheet->LastScreen()->Items() )
            item->GetNetListItem( *this, sheet );
    }

    if( size() == 0 )
        return false;

    // Sort objects by Sheet
    SortListbySheet();

    sheet = &(GetItem( 0 )->m_SheetPath);
    m_lastNetCode = m_lastBusNetCode = 1;

    for( unsigned ii = 0, istart = 0; ii < size(); ii++ )
    {
        NETLIST_OBJECT* net_item = GetItem( ii );

        if( net_item->m_SheetPath != *sheet )   // Sheet change
        {
            sheet  = &(net_item->m_SheetPath);
            istart = ii;
        }

        switch( net_item->m_Type )
        {
        case NETLIST_ITEM::ITEM_UNSPECIFIED:
            wxMessageBox( wxT( "BuildNetListInfo() error" ) );
            break;

        case NETLIST_ITEM::PIN:
        case NETLIST_ITEM::PINLABEL:
        case NETLIST_ITEM::SHEETLABEL:
        case NETLIST_ITEM::NOCONNECT:
            if( net_item->GetNet() != 0 )
                break;

            // Intentionally fall through if there is no net assigned

        case NETLIST_ITEM::SEGMENT:
            // Test connections point to point type without bus.
            if( net_item->GetNet() == 0 )
            {
                net_item->SetNet( m_lastNetCode );
                m_lastNetCode++;
            }

            pointToPointConnect( net_item, IS_WIRE, istart );
            break;

        case NETLIST_ITEM::JUNCTION:
            // Control of the junction outside BUS.
            if( net_item->GetNet() == 0 )
            {
                net_item->SetNet( m_lastNetCode );
                m_lastNetCode++;
            }

            segmentToPointConnect( net_item, IS_WIRE, istart );

            // Control of the junction, on BUS.
            if( net_item->m_BusNetCode == 0 )
            {
                net_item->m_BusNetCode = m_lastBusNetCode;
                m_lastBusNetCode++;
            }

            segmentToPointConnect( net_item, IS_BUS, istart );
            break;

        case NETLIST_ITEM::LABEL:
        case NETLIST_ITEM::HIERLABEL:
        case NETLIST_ITEM::GLOBLABEL:
            // Test connections type junction without bus.
            if( net_item->GetNet() == 0 )
            {
                net_item->SetNet( m_lastNetCode );
                m_lastNetCode++;
            }

            segmentToPointConnect( net_item, IS_WIRE, istart );
            break;

        case NETLIST_ITEM::SHEETBUSLABELMEMBER:
            if( net_item->m_BusNetCode != 0 )
                break;

            // Intentionally fall through if there is no bus assigned

        case NETLIST_ITEM::BUS:
            // Control type connections point to point mode bus
            if( net_item->m_BusNetCode == 0 )
            {
                net_item->m_BusNetCode = m_lastBusNetCode;
                m_lastBusNetCode++;
            }

            pointToPointConnect( net_item, IS_BUS, istart );
            break;

        case NETLIST_ITEM::BUSLABELMEMBER:
        case NETLIST_ITEM::HIERBUSLABELMEMBER:
        case NETLIST_ITEM::GLOBBUSLABELMEMBER:
            // Control connections similar has on BUS
            if( net_item->GetNet() == 0 )
            {
                net_item->m_BusNetCode = m_lastBusNetCode;
                m_lastBusNetCode++;
            }

            segmentToPointConnect( net_item, IS_BUS, istart );
            break;
        }
    }

#if defined(NETLIST_DEBUG) && defined(DEBUG)
    std::cout << "\n\nafter sheet local\n\n";
    DumpNetTable();
#endif

    // Updating the Bus Labels Netcode connected by Bus
    connectBusLabels();

    // Group objects by label.
    for( unsigned ii = 0; ii < size(); ii++ )
    {
        switch( GetItem( ii )->m_Type )
        {
        case NETLIST_ITEM::PIN:
        case NETLIST_ITEM::SHEETLABEL:
        case NETLIST_ITEM::SEGMENT:
        case NETLIST_ITEM::JUNCTION:
        case NETLIST_ITEM::BUS:
        case NETLIST_ITEM::NOCONNECT:
            break;

        case NETLIST_ITEM::LABEL:
        case NETLIST_ITEM::GLOBLABEL:
        case NETLIST_ITEM::PINLABEL:
        case NETLIST_ITEM::BUSLABELMEMBER:
        case NETLIST_ITEM::GLOBBUSLABELMEMBER:
            labelConnect( GetItem( ii ) );
            break;

        case NETLIST_ITEM::SHEETBUSLABELMEMBER:
        case NETLIST_ITEM::HIERLABEL:
        case NETLIST_ITEM::HIERBUSLABELMEMBER:
            break;

        case NETLIST_ITEM::ITEM_UNSPECIFIED:
            break;
        }
    }

#if defined(NETLIST_DEBUG) && defined(DEBUG)
    std::cout << "\n\nafter sheet global\n\n";
    DumpNetTable();
#endif

    // Connection between hierarchy sheets
    for( unsigned ii = 0; ii < size(); ii++ )
    {
        if( GetItem( ii )->m_Type == NETLIST_ITEM::SHEETLABEL
                || GetItem( ii )->m_Type == NETLIST_ITEM::SHEETBUSLABELMEMBER )
            sheetLabelConnect( GetItem( ii ) );
    }

    // Sort objects by NetCode
    SortListbyNetcode();

#if defined(NETLIST_DEBUG) && defined(DEBUG)
    std::cout << "\n\nafter qsort()\n";
    DumpNetTable();
#endif

    // Compress numbers of Netcode having consecutive values.
    int NetCode = 0;
    m_lastNetCode = 0;

    for( unsigned ii = 0; ii < size(); ii++ )
    {
        if( GetItem( ii )->GetNet() != m_lastNetCode )
        {
            NetCode++;
            m_lastNetCode = GetItem( ii )->GetNet();
        }

        GetItem( ii )->SetNet( NetCode );
    }

    // Set the minimal connection info:
    setUnconnectedFlag();

    // find the best label object to give the best net name to each net
    findBestNetNameForEachNet();

    return true;
}

// Helper function to give a priority to sort labels:
// NETLIST_ITEM::PINLABEL, NETLIST_ITEM::GLOBBUSLABELMEMBER and NETLIST_ITEM::GLOBLABEL are global labels
// and the priority is high
static int getPriority( const NETLIST_OBJECT* Objet )
{
    switch( Objet->m_Type )
    {
    case NETLIST_ITEM::PIN:
        return 1;
    case NETLIST_ITEM::LABEL:
        return 2;
    case NETLIST_ITEM::HIERLABEL:
        return 3;
    case NETLIST_ITEM::PINLABEL:
        return 4;
    case NETLIST_ITEM::GLOBBUSLABELMEMBER:
        return 5;
    case NETLIST_ITEM::GLOBLABEL:
        return 6;
    default:
        break;
    }

    return 0;
}


/* function evalLabelsPriority used by findBestNetNameForEachNet()
 * evalLabelsPriority calculates the priority of alabel1 and aLabel2
 * return true if alabel1 has a higher priority than aLabel2
 */
static bool evalLabelsPriority( const NETLIST_OBJECT* aLabel1, const NETLIST_OBJECT* aLabel2 )
{
    // Global labels have the highest prioriy.
    // For local labels: names are prefixed by their sheetpath
    // use name defined in the more top level hierarchical sheet
    // (i.e. shorter timestamp path because paths are /<timestamp1>/<timestamp2>/...
    // and timestamp = 8 letters.
    // Note: the final net name uses human sheetpath name, not timestamp sheetpath name
    // They are equivalent, but not for human readers.
    if( ! aLabel1->IsLabelGlobal() && ! aLabel2->IsLabelGlobal() )
    {
        if( aLabel1->m_SheetPath.Path().Length() != aLabel2->m_SheetPath.Path().Length() )
            return aLabel1->m_SheetPath.Path().Length() < aLabel2->m_SheetPath.Path().Length();
    }

    int priority1 = getPriority( aLabel1 );
    int priority2 = getPriority( aLabel2 );

    if( priority1 != priority2 )
        return priority1 > priority2;

    // Objects have here the same priority, therefore they have the same type.
    // for global labels, we select the best candidate by alphabetic order
    // because they have no sheetpath as prefix name
    // for other labels, we select them before by sheet deep order
    // because the actual name is /sheetpath/label
    // and for a given path length, by alphabetic order
    if( aLabel1->IsLabelGlobal() )
        return aLabel1->m_Label.Cmp( aLabel2->m_Label ) < 0;

    // Sheet paths have here the same length: use alphabetic label name order
    // For labels on sheets having an equivalent deep in hierarchy, use
    // alphabetic label name order:
    if( aLabel1->m_Label.Cmp( aLabel2->m_Label ) != 0 )
        return aLabel1->m_Label.Cmp( aLabel2->m_Label ) < 0;

    // For identical labels having the same priority: choose the
    // alphabetic label full name order
    return aLabel1->m_SheetPath.PathHumanReadable().Cmp(
                aLabel2->m_SheetPath.PathHumanReadable() ) < 0;
}


void NETLIST_OBJECT_LIST::findBestNetNameForEachNet()
{
    // Important note: NETLIST_ITEM::SHEETLABEL items of sheet items should *NOT* be considered,
    // because they live in a sheet but their names are actually used in the subsheet.
    // Moreover, in the parent sheet, the name of NETLIST_ITEM::SHEETLABEL can be not unique,
    // ( for instance when 2 different sheets share the same schematic in complex hierarchies
    // and 2 identical NETLIST_ITEM::SHEETLABEL labels can be connected to 2 different nets

    int netcode = 0;            // current netcode for tested items
    unsigned idxstart = 0;      // index of the first item of this net
    NETLIST_OBJECT* item;
    NETLIST_OBJECT* candidate;

    // Pass 1: find the best name for labelled nets:
    candidate = NULL;
    for( unsigned ii = 0; ii <= size(); ii++ )
    {
        if( ii == size() ) // last item already tested
            item = NULL;
        else
            item = GetItem( ii );

        if( !item || netcode != item->GetNet() )     // End of net found
        {
            if( candidate )         // One or more labels exists, find the best
            {
                for (unsigned jj = idxstart; jj < ii; jj++ )
                    GetItem( jj )->SetNetNameCandidate( candidate );
            }

            if( item == NULL )  // End of list
                break;

            // Prepare next net analysis:
            netcode = item->GetNet();
            candidate = NULL;
            idxstart = ii;
        }

        switch( item->m_Type )
        {
        case NETLIST_ITEM::HIERLABEL:
        case NETLIST_ITEM::LABEL:
        case NETLIST_ITEM::PINLABEL:
        case NETLIST_ITEM::GLOBLABEL:
        case NETLIST_ITEM::GLOBBUSLABELMEMBER:
            // A candidate is found: select the better between the previous and this one
            if( candidate == NULL )
                candidate = item;
            else
            {
                if( evalLabelsPriority( item, candidate ) )
                    // item has a higher priority than candidate so update the best candidate
                    candidate = item;
            }
            break;

        default:
            break;
        }
    }

    // Pass 2: find the best name for not labelled nets:
    // The "default" net name is Net-<<Ref cmp>_Pad<num pad>>
    // (see NETLIST_OBJECT::GetShortNetName())
    // therefore the "best" is the short net name alphabetically classed first
    // (to avoid net names changes when the net is not modified,
    // even if components are moved or deleted and undelete or replaced, as long
    // the reference is kept)

    // Build a list of items with no net names
    NETLIST_OBJECTS    list;   // no ownership of elements being pointed at

    for( unsigned ii = 0; ii < size(); ii++ )
    {
        item = GetItem( ii );

        if( !item->HasNetNameCandidate() )
            list.push_back( item );
    }

    if( list.size() == 0 )
        return;

    idxstart = 0;
    candidate = NULL;
    netcode = list[0]->GetNet();

    for( unsigned ii = 0; ii <= list.size(); ii++ )
    {
        if( ii < list.size() )
            item = list[ii];
        else
            item = NULL;

        if( !item || netcode != item->GetNet() )     // End of net found
        {
            if( candidate )
            {
                for (unsigned jj = idxstart; jj < ii; jj++ )
                {
                    NETLIST_OBJECT* obj = list[jj];
                    obj->SetNetNameCandidate( candidate );
                }
            }

            if( !item )
                break;

            netcode = item->GetNet();
            candidate = NULL;
            idxstart = ii;
        }

        // Examine all pins of the net to find the best candidate,
        // i.e. the first net name candidate, by alphabetic order
        // the net names are built by GetShortNetName
        // (Net-<{reference}-Pad{pad number}> like Net-<U3-Pad5>
        // Not named nets do not have usually a lot of members.
        // Many have only 2 members(a pad and a non connection symbol)
        if( item->m_Type == NETLIST_ITEM::PIN )
        {
            // A candidate is found, however components which are not in
            // netlist are not candidate because some have their reference
            // changed each time the netlist is built (power components)
            // and anyway obviously they are not a good candidate
            SCH_COMPONENT* link = item->GetComponentParent();

            if( link && link->IsInNetlist() )
            {
                // select the better between the previous and this one
                item->SetNetNameCandidate( item );  // Needed to calculate GetShortNetName

                if( candidate == NULL )
                    candidate = item;
                else
                {
                    if( item->GetShortNetName().Cmp( candidate->GetShortNetName() ) < 0 )
                        candidate = item;
                }
            }
        }
    }
}


void NETLIST_OBJECT_LIST::sheetLabelConnect( NETLIST_OBJECT* SheetLabel )
{
    if( SheetLabel->GetNet() == 0 )
        return;

    for( unsigned ii = 0; ii < size(); ii++ )
    {
        NETLIST_OBJECT* ObjetNet = GetItem( ii );

        if( ObjetNet->m_SheetPath != SheetLabel->m_SheetPathInclude )
            continue;  //use SheetInclude, not the sheet!!

        if( ( ObjetNet->m_Type != NETLIST_ITEM::HIERLABEL )
                && ( ObjetNet->m_Type != NETLIST_ITEM::HIERBUSLABELMEMBER ) )
            continue;

        if( ObjetNet->GetNet() == SheetLabel->GetNet() )
            continue;  //already connected.

        if( ObjetNet->m_Label != SheetLabel->m_Label )
            continue;  //different names.

        // Propagate Netcode having all the objects of the same Netcode.
        if( ObjetNet->GetNet() )
            propagateNetCode( ObjetNet->GetNet(), SheetLabel->GetNet(), IS_WIRE );
        else
            ObjetNet->SetNet( SheetLabel->GetNet() );
    }
}


void NETLIST_OBJECT_LIST::connectBusLabels()
{
    // Propagate the net code between all bus label member objects connected by they name.
    // If the net code is not yet existing, a new one is created
    // Search is done in the entire list
    for( unsigned ii = 0; ii < size(); ii++ )
    {
        NETLIST_OBJECT* Label = GetItem( ii );

        if( Label->IsLabelBusMemberType() )
        {
            if( Label->GetNet() == 0 )
            {
                // Not yet existiing net code: create a new one.
                Label->SetNet( m_lastNetCode );
                m_lastNetCode++;
            }

            for( unsigned jj = ii + 1; jj < size(); jj++ )
            {
                NETLIST_OBJECT* LabelInTst =  GetItem( jj );

                if( LabelInTst->IsLabelBusMemberType() )
                {
                    if( LabelInTst->m_BusNetCode != Label->m_BusNetCode )
                        continue;

                    if( LabelInTst->m_Member != Label->m_Member )
                        continue;

                    if( LabelInTst->GetNet() == 0 )
                        // Append this object to the current net
                        LabelInTst->SetNet( Label->GetNet() );
                    else
                        // Merge the 2 net codes, they are connected.
                        propagateNetCode( LabelInTst->GetNet(), Label->GetNet(), IS_WIRE );
                }
            }
        }
    }
}


void NETLIST_OBJECT_LIST::propagateNetCode( int aOldNetCode, int aNewNetCode, bool aIsBus )
{
    if( aOldNetCode == aNewNetCode )
        return;

    if( aIsBus == false )    // Propagate NetCode
    {
        for( unsigned jj = 0; jj < size(); jj++ )
        {
            NETLIST_OBJECT* object = GetItem( jj );

            if( object->GetNet() == aOldNetCode )
                object->SetNet( aNewNetCode );
        }
    }
    else               // Propagate BusNetCode
    {
        for( unsigned jj = 0; jj < size(); jj++ )
        {
            NETLIST_OBJECT* object = GetItem( jj );

            if( object->m_BusNetCode == aOldNetCode )
                object->m_BusNetCode = aNewNetCode;
        }
    }
}


void NETLIST_OBJECT_LIST::pointToPointConnect( NETLIST_OBJECT* aRef, bool aIsBus, int start )
{
    int netCode;

    if( aIsBus == false )    // Objects other than BUS and BUSLABELS
    {
        netCode = aRef->GetNet();

        for( unsigned i = start; i < size(); i++ )
        {
            NETLIST_OBJECT* item = GetItem( i );

            if( item->m_SheetPath != aRef->m_SheetPath )  //used to be > (why?)
                continue;

            switch( item->m_Type )
            {
            case NETLIST_ITEM::SEGMENT:
            case NETLIST_ITEM::PIN:
            case NETLIST_ITEM::LABEL:
            case NETLIST_ITEM::HIERLABEL:
            case NETLIST_ITEM::GLOBLABEL:
            case NETLIST_ITEM::SHEETLABEL:
            case NETLIST_ITEM::PINLABEL:
            case NETLIST_ITEM::JUNCTION:
            case NETLIST_ITEM::NOCONNECT:
                if( aRef->m_Start == item->m_Start
                    || aRef->m_Start == item->m_End
                    || aRef->m_End   == item->m_Start
                    || aRef->m_End   == item->m_End )
                {
                    if( item->GetNet() == 0 )
                        item->SetNet( netCode );
                    else
                        propagateNetCode( item->GetNet(), netCode, IS_WIRE );
                }
                break;

            case NETLIST_ITEM::BUS:
            case NETLIST_ITEM::BUSLABELMEMBER:
            case NETLIST_ITEM::SHEETBUSLABELMEMBER:
            case NETLIST_ITEM::HIERBUSLABELMEMBER:
            case NETLIST_ITEM::GLOBBUSLABELMEMBER:
            case NETLIST_ITEM::ITEM_UNSPECIFIED:
                break;
            }
        }
    }
    else    // Object type BUS, BUSLABELS, and junctions.
    {
        netCode = aRef->m_BusNetCode;

        for( unsigned i = start; i < size(); i++ )
        {
            NETLIST_OBJECT* item = GetItem( i );

            if( item->m_SheetPath != aRef->m_SheetPath )
                continue;

            switch( item->m_Type )
            {
            case NETLIST_ITEM::ITEM_UNSPECIFIED:
            case NETLIST_ITEM::SEGMENT:
            case NETLIST_ITEM::PIN:
            case NETLIST_ITEM::LABEL:
            case NETLIST_ITEM::HIERLABEL:
            case NETLIST_ITEM::GLOBLABEL:
            case NETLIST_ITEM::SHEETLABEL:
            case NETLIST_ITEM::PINLABEL:
            case NETLIST_ITEM::NOCONNECT:
                break;

            case NETLIST_ITEM::BUS:
            case NETLIST_ITEM::BUSLABELMEMBER:
            case NETLIST_ITEM::SHEETBUSLABELMEMBER:
            case NETLIST_ITEM::HIERBUSLABELMEMBER:
            case NETLIST_ITEM::GLOBBUSLABELMEMBER:
            case NETLIST_ITEM::JUNCTION:
                if(  aRef->m_Start == item->m_Start
                  || aRef->m_Start == item->m_End
                  || aRef->m_End   == item->m_Start
                  || aRef->m_End   == item->m_End )
                {
                    if( item->m_BusNetCode == 0 )
                        item->m_BusNetCode = netCode;
                    else
                        propagateNetCode( item->m_BusNetCode, netCode, IS_BUS );
                }
                break;
            }
        }
    }
}


void NETLIST_OBJECT_LIST::segmentToPointConnect( NETLIST_OBJECT* aJonction,
                                                 bool aIsBus, int aIdxStart )
{
    for( unsigned i = aIdxStart; i < size(); i++ )
    {
        NETLIST_OBJECT* segment = GetItem( i );

        // if different sheets, obviously no physical connection between elements.
        if( segment->m_SheetPath != aJonction->m_SheetPath )
            continue;

        if( aIsBus == IS_WIRE )
        {
            if( segment->m_Type != NETLIST_ITEM::SEGMENT )
                continue;
        }
        else
        {
            if( segment->m_Type != NETLIST_ITEM::BUS )
                continue;
        }

        if( IsPointOnSegment( segment->m_Start, segment->m_End, aJonction->m_Start ) )
        {
            // Propagation Netcode has all the objects of the same Netcode.
            if( aIsBus == IS_WIRE )
            {
                if( segment->GetNet() )
                    propagateNetCode( segment->GetNet(), aJonction->GetNet(), aIsBus );
                else
                    segment->SetNet( aJonction->GetNet() );
            }
            else
            {
                if( segment->m_BusNetCode )
                    propagateNetCode( segment->m_BusNetCode, aJonction->m_BusNetCode, aIsBus );
                else
                    segment->m_BusNetCode = aJonction->m_BusNetCode;
            }
        }
    }
}


void NETLIST_OBJECT_LIST::labelConnect( NETLIST_OBJECT* aLabelRef )
{
    if( aLabelRef->GetNet() == 0 )
        return;

    for( unsigned i = 0; i < size(); i++ )
    {
        NETLIST_OBJECT* item = GetItem( i );

        if( item->GetNet() == aLabelRef->GetNet() )
            continue;

        if( item->m_SheetPath != aLabelRef->m_SheetPath )
        {
            if( item->m_Type != NETLIST_ITEM::PINLABEL && item->m_Type != NETLIST_ITEM::GLOBLABEL
                    && item->m_Type != NETLIST_ITEM::GLOBBUSLABELMEMBER )
                continue;

            if( ( item->m_Type == NETLIST_ITEM::GLOBLABEL
                        || item->m_Type == NETLIST_ITEM::GLOBBUSLABELMEMBER )
                    && item->m_Type != aLabelRef->m_Type )
                //global labels only connect other global labels.
                continue;
        }

        // NETLIST_ITEM::HIERLABEL are used to connect sheets.
        // NETLIST_ITEM::LABEL are local to a sheet
        // NETLIST_ITEM::GLOBLABEL are global.
        // NETLIST_ITEM::PINLABEL is a kind of global label (generated by a power pin invisible)
        if( item->IsLabelType() )
        {
            if( item->m_Label != aLabelRef->m_Label )
                continue;

            if( item->GetNet() )
                propagateNetCode( item->GetNet(), aLabelRef->GetNet(), IS_WIRE );
            else
                item->SetNet( aLabelRef->GetNet() );
        }
    }
}


void NETLIST_OBJECT_LIST::setUnconnectedFlag()
{
    NETLIST_OBJECT* NetItemRef;
    unsigned        NetStart, NetEnd;
    NET_CONNECTION  StateFlag;

    NetStart = NetEnd = 0;
    StateFlag         = NET_CONNECTION::UNCONNECTED;
    for( unsigned ii = 0; ii < size(); ii++ )
    {
        NetItemRef = GetItem( ii );
        if( NetItemRef->m_Type == NETLIST_ITEM::NOCONNECT
                && StateFlag != NET_CONNECTION::PAD_CONNECT )
            StateFlag = NET_CONNECTION::NOCONNECT_SYMBOL_PRESENT;

        // Analysis of current net.
        unsigned idxtoTest = ii + 1;

        if( ( idxtoTest >= size() )
           || ( NetItemRef->GetNet() != GetItem( idxtoTest )->GetNet() ) )
        {
            // Net analysis to update m_ConnectionType
            NetEnd = idxtoTest;

            /* set m_ConnectionType member to StateFlag for all items of
             * this net: */
            for( unsigned kk = NetStart; kk < NetEnd; kk++ )
                GetItem( kk )->m_ConnectionType = StateFlag;

            if( idxtoTest >= size() )
                return;

            // Start Analysis next Net
            StateFlag = NET_CONNECTION::UNCONNECTED;
            NetStart  = idxtoTest;
            continue;
        }

        /* test the current item: if this is a pin and if the reference item
         * is also a pin, then 2 pins are connected, so set StateFlag to
         * PAD_CONNECT (can be already done)  Of course, if the current
         * item is a no connect symbol, set StateFlag to
         * NOCONNECT_SYMBOL_PRESENT to inhibit error diags. However if
         * StateFlag is already set to PAD_CONNECT this state is kept (the
         * no connect symbol was surely an error and an ERC will report this)
         */
       for( ; ; idxtoTest++ )
        {
            if( ( idxtoTest >= size() )
               || ( NetItemRef->GetNet() != GetItem( idxtoTest )->GetNet() ) )
                break;

            switch( GetItem( idxtoTest )->m_Type )
            {
            case NETLIST_ITEM::ITEM_UNSPECIFIED:
                wxMessageBox( wxT( "BuildNetListBase() error" ) );
                break;

            case NETLIST_ITEM::SEGMENT:
            case NETLIST_ITEM::LABEL:
            case NETLIST_ITEM::HIERLABEL:
            case NETLIST_ITEM::GLOBLABEL:
            case NETLIST_ITEM::SHEETLABEL:
            case NETLIST_ITEM::PINLABEL:
            case NETLIST_ITEM::BUS:
            case NETLIST_ITEM::BUSLABELMEMBER:
            case NETLIST_ITEM::SHEETBUSLABELMEMBER:
            case NETLIST_ITEM::HIERBUSLABELMEMBER:
            case NETLIST_ITEM::GLOBBUSLABELMEMBER:
            case NETLIST_ITEM::JUNCTION:
                break;

            case NETLIST_ITEM::PIN:
                if( NetItemRef->m_Type == NETLIST_ITEM::PIN )
                    StateFlag = NET_CONNECTION::PAD_CONNECT;

                break;

            case NETLIST_ITEM::NOCONNECT:
                if( StateFlag != NET_CONNECTION::PAD_CONNECT )
                    StateFlag = NET_CONNECTION::NOCONNECT_SYMBOL_PRESENT;

                break;
            }
        }
    }
}