commint forgotten file

pcbnew/netlist_reader_common.cpp

+/**
+ * @file pcbnew/netlist_reader_common.cpp
+ */
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 1992-2011 Jean-Pierre Charras.
+ * Copyright (C) 1992-2011 KiCad Developers, see change_log.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 <fctsys.h>
+#include <wxPcbStruct.h>
+#include <richio.h>
+#include <macros.h>
+
+#include <class_board.h>
+#include <class_module.h>
+#include <pcbnew.h>
+
+#include <netlist_reader.h>
+
+#include <algorithm>
+
+/*
+ * Function ReadNetList
+ * The main function to detect the netlist format,and run the right netlist reader
+ * aFile = the already opened file (will be closed by the netlist reader)
+ */
+bool NETLIST_READER::ReadNetList( FILE* aFile )
+{
+    // Try to determine the netlist type:
+    // Beginning of the first line of known formats, without spaces
+    #define HEADERS_COUNT 3
+    #define HEADER_ORCADPCB "({EESchemaNetlist"
+    #define HEADER_PCBNEW "#EESchemaNetlist"
+    #define HEADER_KICAD_NETFMT "(export"
+    const std::string headers[HEADERS_COUNT] =
+    {
+        HEADER_ORCADPCB, HEADER_PCBNEW, HEADER_KICAD_NETFMT
+    };
+
+    int format = -1;
+    for ( int jj = 0; jj < HEADERS_COUNT; jj++ )
+    {
+        int imax = headers[jj].size();
+        int ii = 0;
+        for( ; ii < imax; ii++ )
+        {
+            int data;
+            // Read header, and skip blanks to avoid errors if an header changes
+            do
+            {
+                data = fgetc( aFile );
+            } while ( ( data == ' ' ) &&( EOF != data ) ) ;
+
+            if( (int)headers[jj][ii] == data )
+                continue;
+            break;
+        }
+        if( ii == imax )    // header found
+        {
+            format = jj;
+            break;
+        }
+        rewind( aFile );
+    }
+
+    rewind( aFile );
+    bool success = false;
+    switch( format )
+    {
+        case 0:
+            m_typeNetlist = NETLIST_TYPE_ORCADPCB2;
+            success = ReadOldFmtdNetList( aFile );
+            break;
+
+        case 1:
+            m_typeNetlist = NETLIST_TYPE_PCBNEW;
+            success = ReadOldFmtdNetList( aFile );
+            break;
+
+        case 2:
+            m_typeNetlist = NETLIST_TYPE_KICAD;
+            success = ReadKicadNetList( aFile );
+            break;
+
+        default:    // Unrecognized format:
+            break;
+
+    }
+
+    return success;
+}
+
+/**
+ * Function GetComponentInfoList
+ * @return a reference to the libpart info corresponding to a given part
+ * @param aPartname = the name of the libpart
+ */
+LIPBART_INFO* NETLIST_READER::GetLibpart(const wxString & aPartname)
+{
+    for( unsigned ii = 0; ii < m_libpartList.size(); ii++ )
+    {
+        if( m_libpartList[ii]->m_Libpart == aPartname )
+            return m_libpartList[ii];
+    }
+
+    return NULL;
+}
+
+
+bool NETLIST_READER::InitializeModules()
+{
+    if( m_UseCmpFile )  // Try to get footprint name from .cmp file
+    {
+        readModuleComponentLinkfile();
+    }
+
+    if( m_pcbframe == NULL )
+        return true;
+
+    for( unsigned ii = 0; ii < m_componentsInNetlist.size(); ii++ )
+    {
+        COMPONENT_INFO* currcmp_info = m_componentsInNetlist[ii];
+        // Test if module is already loaded.
+        wxString * idMod = m_UseTimeStamp?
+                           &currcmp_info->m_TimeStamp : &currcmp_info->m_Reference;
+
+        MODULE* module = FindModule( *idMod );
+        if( module == NULL )   // not existing, load it
+        {
+            m_newModulesList.push_back( currcmp_info );
+        }
+    }
+
+    bool success = loadNewModules();
+
+    // Update modules fields
+    for( unsigned ii = 0; ii < m_componentsInNetlist.size(); ii++ )
+    {
+        COMPONENT_INFO* currcmp_info =  m_componentsInNetlist[ii];
+        // Test if module is already loaded.
+        wxString * idMod = m_UseTimeStamp?
+                              &currcmp_info->m_TimeStamp : &currcmp_info->m_Reference;
+
+        MODULE* module = FindModule( *idMod );
+        if( module )
+        {
+             // Update current module ( reference, value and "Time Stamp")
+            module->m_Reference->m_Text = currcmp_info->m_Reference;
+            module->m_Value->m_Text     = currcmp_info->m_Value;
+            module->SetPath( currcmp_info->m_TimeStamp );
+        }
+        else   // not existing
+        {
+        }
+    }
+
+    // clear pads netnames
+    for( MODULE* module = m_pcbframe->GetBoard()->m_Modules; module; module = module->Next() )
+    {
+        for( D_PAD* pad = module->m_Pads; pad; pad = pad->Next() )
+            pad->SetNetname( wxEmptyString );
+    }
+
+    return success;
+}
+
+void NETLIST_READER::TestFootprintsMatchingAndExchange()
+{
+#ifdef PCBNEW
+
+    for( MODULE* module = m_pcbframe->GetBoard()->m_Modules; module; module = module->Next() )
+    {
+        // Search for the corresponding module info
+        COMPONENT_INFO * cmp_info = NULL;
+        for( unsigned ii = 0; ii < m_componentsInNetlist.size(); ii++ )
+        {
+            COMPONENT_INFO * candidate =  m_componentsInNetlist[ii];
+            // Test if cmp_info matches the current module:
+            if( candidate->m_Reference.CmpNoCase( module->GetReference() ) == 0 )
+            {
+                cmp_info = candidate;
+                break;
+            }
+        }
+        if( cmp_info == NULL )   // not found in netlist
+             continue;
+
+        if( module->GetLibRef().CmpNoCase( cmp_info->m_Footprint ) != 0 )
+        {
+            if( m_ChangeFootprints )   // footprint exchange allowed.
+            {
+                MODULE* newModule = m_pcbframe->GetModuleLibrary( wxEmptyString,
+                                                                  cmp_info->m_Footprint,
+                                                                  false );
+
+                if( newModule )
+                {
+                    // Change old module to the new module (and delete the old one)
+                    m_pcbframe->Exchange_Module( module, newModule, NULL );
+                    module = newModule;
+                }
+                else if( m_messageWindow )
+                {
+                wxString msg;
+                msg.Printf( _( "Component \"%s\": module [%s] not found\n" ),
+                            GetChars( cmp_info->m_Reference ),
+                            GetChars( cmp_info->m_Footprint ) );
+
+                m_messageWindow->AppendText( msg );
+                }
+            }
+            else if( m_messageWindow )
+            {
+                wxString msg;
+                msg.Printf( _( "Component \"%s\": Mismatch! module is [%s] and netlist said [%s]\n" ),
+                            GetChars( cmp_info->m_Reference ),
+                            GetChars( module->GetLibRef() ),
+                            GetChars( cmp_info->m_Footprint ) );
+
+                m_messageWindow->AppendText( msg );
+            }
+        }
+    }
+#endif
+}
+
+/**
+ * Function SetPadNetName
+ *  Update a pad netname
+ *  @param aModule = module reference
+ *  @param aPadname = pad name (pad num)
+ *  @param aNetname = new net name of the pad
+ *  @return a pointer to the pad or NULL if the pad is not found
+ */
+D_PAD* NETLIST_READER::SetPadNetName( const wxString & aModule, const wxString & aPadname,
+                      const wxString & aNetname )
+{
+    if( m_pcbframe == NULL )
+        return NULL;
+
+    MODULE* module = m_pcbframe->GetBoard()->FindModuleByReference( aModule );
+    if( module )
+    {
+        D_PAD * pad = module->FindPadByName( aPadname );
+        if( pad )
+        {
+            pad->SetNetname( aNetname );
+            return pad;
+        }
+        if( m_messageWindow )
+        {
+            wxString msg;
+            msg.Printf( _( "Module [%s]: Pad [%s] not found" ),
+                        GetChars( aModule ), GetChars( aPadname ) );
+            m_messageWindow->AppendText( msg + wxT( "\n" ) );
+        }
+    }
+
+    return NULL;
+}
+
+
+/* function RemoveExtraFootprints
+ * Remove (delete) not locked footprints found on board, but not in netlist
+ */
+void NETLIST_READER::RemoveExtraFootprints()
+{
+    MODULE* nextModule;
+
+    MODULE* module = m_pcbframe->GetBoard()->m_Modules;
+    for( ; module != NULL; module = nextModule )
+    {
+        unsigned ii;
+        nextModule = module->Next();
+
+        if( module->m_ModuleStatus & MODULE_is_LOCKED )
+            continue;
+
+        for( ii = 0; ii < m_componentsInNetlist.size(); ii++ )
+        {
+            COMPONENT_INFO* cmp_info = m_componentsInNetlist[ii];
+            if( module->m_Reference->m_Text.CmpNoCase( cmp_info->m_Reference ) == 0 )
+                break; // Module is found in net list.
+        }
+
+        if( ii == m_componentsInNetlist.size() )   // Module not found in netlist.
+            module->DeleteStructure();
+    }
+}
+
+
+/* Search for a module id the modules existing in the current BOARD.
+ * aId is a key to identify the module to find:
+ * The reference or the full time stamp, according to m_UseTimeStamp
+ * Returns the module is found, NULL otherwise.
+ */
+MODULE* NETLIST_READER::FindModule( const wxString& aId )
+{
+    MODULE* module = m_pcbframe->GetBoard()->m_Modules;
+    for( ; module != NULL; module = module->Next() )
+    {
+        if( m_UseTimeStamp ) // identification by time stamp
+        {
+            if( aId.CmpNoCase( module->m_Path ) == 0 )
+                return module;
+        }
+        else    // identification by Reference
+        {
+            if( aId.CmpNoCase( module->m_Reference->m_Text ) == 0 )
+                return module;
+        }
+    }
+
+    return NULL;
+}
+
+
+/*
+ * function readModuleComponentLinkfile
+ * read the *.cmp file ( filename in m_cmplistFullName )
+ * giving the equivalence Footprint_names / components
+ * to find the footprint name corresponding to aCmpIdent
+ * return true if the file can be read
+ *
+ * Sample file:
+ *
+ * Cmp-Mod V01 Genere by Pcbnew 29/10/2003-13: 11:6 *
+ *  BeginCmp
+ *  TimeStamp = /32307DE2/AA450F67;
+ *  Reference = C1;
+ *  ValeurCmp = 47uF;
+ *  IdModule  = CP6;
+ *  EndCmp
+ *
+ */
+
+bool NETLIST_READER::readModuleComponentLinkfile()
+{
+    wxString refcurrcmp;    // Stores value read from line like Reference = BUS1;
+    wxString timestamp;     // Stores value read from line like TimeStamp = /32307DE2/AA450F67;
+    wxString footprint;     // Stores value read from line like IdModule  = CP6;
+
+    FILE*    cmpFile = wxFopen( m_cmplistFullName, wxT( "rt" ) );
+
+    if( cmpFile == NULL )
+    {
+        wxString msg;
+        msg.Printf( _( "File <%s> not found, use Netlist for footprints selection" ),
+                   GetChars( m_cmplistFullName ) );
+
+        if( m_messageWindow )
+            m_messageWindow->AppendText( msg );
+        return false;
+    }
+
+    // netlineReader dtor will close cmpFile
+    FILE_LINE_READER netlineReader( cmpFile, m_cmplistFullName );
+    wxString buffer;
+    wxString value;
+
+    while( netlineReader.ReadLine() )
+    {
+        buffer = FROM_UTF8( netlineReader.Line() );
+
+        if( ! buffer.StartsWith( wxT("BeginCmp") ) )
+            continue;
+
+        // Begin component description.
+        refcurrcmp.Empty();
+        footprint.Empty();
+        timestamp.Empty();
+
+        while( netlineReader.ReadLine() )
+        {
+            buffer = FROM_UTF8( netlineReader.Line() );
+
+            if( buffer.StartsWith( wxT("EndCmp") ) )
+                break;
+
+            // store string value, stored between '=' and ';' delimiters.
+            value = buffer.AfterFirst( '=' );
+            value = value.BeforeLast( ';');
+            value.Trim(true);
+            value.Trim(false);
+
+            if( buffer.StartsWith( wxT("Reference") ) )
+            {
+                refcurrcmp = value;
+                continue;
+            }
+
+            if( buffer.StartsWith( wxT("IdModule  =" ) ) )
+            {
+                footprint = value;
+                continue;
+            }
+
+            if( buffer.StartsWith( wxT("TimeStamp =" ) ) )
+            {
+                timestamp = value;
+                continue;
+            }
+        }
+
+        // Find the corresponding item in module info list:
+        for( unsigned ii = 0; ii < m_componentsInNetlist.size(); ii++ )
+        {
+            COMPONENT_INFO * cmp_info = m_componentsInNetlist[ii];
+            if( m_UseTimeStamp )    // Use schematic timestamp to locate the footprint
+            {
+                if( cmp_info->m_TimeStamp.CmpNoCase( timestamp ) == 0  &&
+                    !timestamp.IsEmpty() )
+                {    // Found
+                    if( !footprint.IsEmpty() )
+                        cmp_info->m_Footprint = footprint;
+                    break;
+                }
+            }
+            else                   // Use schematic reference to locate the footprint
+            {
+                if( cmp_info->m_Reference.CmpNoCase( refcurrcmp ) == 0 )   // Found!
+                {
+                    if( !footprint.IsEmpty() )
+                        cmp_info->m_Footprint = footprint;
+                    break;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/* Function to sort the footprint list, used by loadNewModules.
+ * the given list is sorted by name
+ */
+#ifdef PCBNEW
+static bool SortByLibName( COMPONENT_INFO* ref, COMPONENT_INFO* cmp )
+{
+    int ii = ref->m_Footprint.CmpNoCase( cmp->m_Footprint );
+    return ii > 0;
+}
+#endif
+
+/* Load new modules from library.
+ * If a new module is already loaded it is duplicated, which avoid multiple
+ * unnecessary disk or net access to read libraries.
+ * return false if a footprint is not found, true if OK
+ */
+bool NETLIST_READER::loadNewModules()
+{
+    bool         success = true;
+#ifdef PCBNEW
+    COMPONENT_INFO* ref, * cmp;
+    MODULE*      Module = NULL;
+    wxPoint      ModuleBestPosition;
+    BOARD*       pcb = m_pcbframe->GetBoard();
+
+    if( m_newModulesList.size() == 0 )
+        return true;
+
+    sort( m_newModulesList.begin(), m_newModulesList.end(), SortByLibName );
+
+    // Calculate the footprint "best" position:
+    EDA_RECT bbbox = pcb->ComputeBoundingBox( true );
+
+    if( bbbox.GetWidth() || bbbox.GetHeight() )
+    {
+        ModuleBestPosition = bbbox.GetEnd();
+        ModuleBestPosition.y += 5000;
+    }
+
+    ref = cmp = m_newModulesList[0];
+
+    for( unsigned ii = 0; ii < m_newModulesList.size(); ii++ )
+    {
+        cmp = m_newModulesList[ii];
+
+        if( (ii == 0) || ( ref->m_Footprint != cmp->m_Footprint) )
+        {
+            // New footprint : must be loaded from a library
+            Module = m_pcbframe->GetModuleLibrary( wxEmptyString, cmp->m_Footprint, false );
+            ref = cmp;
+
+            if( Module == NULL )
+            {
+                success = false;
+                if( m_messageWindow )
+                {
+                    wxString msg;
+                    msg.Printf( _( "Component [%s]: footprint <%s> not found" ),
+                                GetChars( cmp->m_Reference ),
+                                GetChars( cmp->m_Footprint ) );
+
+                    msg += wxT("\n");
+                    m_messageWindow->AppendText( msg );
+                }
+                continue;
+            }
+
+            Module->SetPosition( ModuleBestPosition );
+
+            /* Update schematic links : reference "Time Stamp" and schematic
+             * hierarchical path */
+            Module->m_Reference->m_Text = cmp->m_Reference;
+            Module->SetTimeStamp( GetNewTimeStamp() );
+            Module->SetPath( cmp->m_TimeStamp );
+        }
+        else
+        {
+            // Footprint already loaded from a library, duplicate it (faster)
+            if( Module == NULL )
+                continue;            // Module does not exist in library.
+
+            MODULE* newmodule = new MODULE( *Module );
+            newmodule->SetParent( pcb );
+
+            pcb->Add( newmodule, ADD_APPEND );
+
+            Module = newmodule;
+            Module->m_Reference->m_Text = cmp->m_Reference;
+            Module->SetTimeStamp( GetNewTimeStamp() );
+            Module->SetPath( cmp->m_TimeStamp );
+        }
+    }
+#endif
+    return success;
+}