netlist_reader.h

Go to the documentation of this file.

#ifndef NETLIST_READER_H
#define NETLIST_READER_H

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 Jean-Pierre Charras.
 * Copyright (C) 2013-2017 Wayne Stambaugh <stambaughw@gmail.com>.
 * Copyright (C) 2012-2017 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 <boost/ptr_container/ptr_vector.hpp>

#include <macros.h>
#include <lib_id.h>

#include <netlist_lexer.h>    // netlist_lexer is common to Eeschema and Pcbnew


class NETLIST;
class COMPONENT;


class CMP_READER
{
    LINE_READER* m_lineReader;            

public:
    CMP_READER( LINE_READER* aLineReader )
    {
        m_lineReader = aLineReader;
    }

    ~CMP_READER()
    {
        if( m_lineReader )
        {
            delete m_lineReader;
            m_lineReader = NULL;
        }
    }

    bool Load( NETLIST* aNetlist );
};


class NETLIST_READER
{
public:

    enum NETLIST_FILE_T
    {
        UNKNOWN = -1,
        ORCAD,
        LEGACY,
        KICAD,

        // Add new types here.  Don't forget to create the appropriate class derived from
        // NETCLASS_READER and add the entry to the NETLIST_READER::GetNetlistReader()
        // function.
    };


    NETLIST_READER( LINE_READER*  aLineReader,
                    NETLIST*      aNetlist,
                    CMP_READER*   aFootprintLinkReader = NULL )
    {
        wxASSERT( aLineReader != NULL );

        m_lineReader           = aLineReader;
        m_footprintReader      = aFootprintLinkReader;
        m_netlist              = aNetlist;
        m_loadFootprintFilters = true;
        m_loadNets             = true;
    }

    virtual ~NETLIST_READER();

    static NETLIST_FILE_T GuessNetlistFileType( LINE_READER* aLineReader );

    static NETLIST_READER* GetNetlistReader( NETLIST*        aNetlist,
                                             const wxString& aNetlistFileName,
                                             const wxString& aCompFootprintFileName = wxEmptyString );

    virtual void LoadNetlist() = 0;

    LINE_READER* GetLineReader();

protected:
    NETLIST*     m_netlist;               
    bool         m_loadFootprintFilters;  
    bool         m_loadNets;              
    LINE_READER* m_lineReader;            

    CMP_READER*  m_footprintReader;
};


class LEGACY_NETLIST_READER : public NETLIST_READER
{
    COMPONENT* loadComponent( char* aText );

    void loadFootprintFilters();

    void loadNet( char* aText, COMPONENT* aComponent );

public:

    LEGACY_NETLIST_READER( LINE_READER*  aLineReader,
                           NETLIST*      aNetlist,
                           CMP_READER*   aFootprintLinkReader = NULL ) :
        NETLIST_READER( aLineReader, aNetlist, aFootprintLinkReader )
    {
    }

    virtual void LoadNetlist() override;
};


class KICAD_NETLIST_PARSER : public NETLIST_LEXER
{
private:
    NL_T::T      token;
    LINE_READER* m_lineReader;  
    NETLIST*     m_netlist;     

    void skipCurrent();

    void parseComponent();

    void parseNet();

    void parseLibPartList();


public:
    KICAD_NETLIST_PARSER( LINE_READER* aReader, NETLIST* aNetlist );

    void SetLineReader( LINE_READER* aLineReader );

    void SetNetlist( NETLIST* aNetlist ) { m_netlist = aNetlist; }

    void Parse();

    // Useful for debug only:
    const char* getTokenName( NL_T::T aTok )
    {
        return NETLIST_LEXER::TokenName( aTok );
    }
};


class KICAD_NETLIST_READER : public NETLIST_READER
{
    KICAD_NETLIST_PARSER* m_parser;     

public:
    KICAD_NETLIST_READER( LINE_READER*  aLineReader,
                          NETLIST*      aNetlist,
                          CMP_READER*   aFootprintLinkReader = NULL ) :
        NETLIST_READER( aLineReader, aNetlist, aFootprintLinkReader ),
        m_parser( new KICAD_NETLIST_PARSER( aLineReader, aNetlist ) )
    {
    }

    virtual ~KICAD_NETLIST_READER()
    {
        delete m_parser;
    }

    virtual void LoadNetlist() override;
};


#endif   // NETLIST_READER_H