diff options
Diffstat (limited to 'pcbnew/netlist_reader.h')
| -rw-r--r-- | pcbnew/netlist_reader.h | 404 |
1 files changed, 404 insertions, 0 deletions
diff --git a/pcbnew/netlist_reader.h b/pcbnew/netlist_reader.h new file mode 100644 index 0000000..0bdd643 --- /dev/null +++ b/pcbnew/netlist_reader.h @@ -0,0 +1,404 @@ +#ifndef NETLIST_READER_H +#define NETLIST_READER_H + +/** + * @file 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 Wayne Stambaugh <stambaughw@gmail.com>. + * Copyright (C) 2012-2015 KiCad Developers, see CHANGELOG.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 <fctsys.h> +#include <macros.h> +#include <fpid.h> + +#include <netlist_lexer.h> // netlist_lexer is common to Eeschema and Pcbnew + + +class NETLIST; +class COMPONENT; + + +/** + * Class CMP_READER + * reads a component footprint link file (*.cmp) format. + */ +class CMP_READER +{ + LINE_READER* m_lineReader; ///< The line reader to read. + +public: + /** + * CMP_READER constructor. + * @param aLineReader is a LINE_READER (in fact a FILE_LINE_READER) + * which is owned by me ( and deleted by me) to read + * the component footprint link file. + */ + CMP_READER( LINE_READER* aLineReader ) + { + m_lineReader = aLineReader; + } + + ~CMP_READER() + { + if( m_lineReader ) + { + delete m_lineReader; + m_lineReader = NULL; + } + } + + /** + * Function Load + * read the *.cmp file format contains the component footprint assignments created by CvPcb + * into \a aNetlist. + * + * @param aNetlist is the #NETLIST to read into. + * + * @todo At some point in the future, use the footprint field in the new s-expression + * netlist file to assign a footprint to a component instead of using a secondary + * (*.cmp) file. + * + * Sample file footprint assignment entry: + * + * Cmp-Mod V01 Genere by CvPcb 29/10/2003-13: 11:6 * + * BeginCmp + * TimeStamp = /32307DE2/AA450F67; + * Reference = C1; + * ValeurCmp = 47uF; + * IdModule = CP6; + * EndCmp + * + * @throw IO_ERROR if a the #LINE_READER IO error occurs. + * @throw PARSE_ERROR if an error occurs while parsing the file. + * @return true if OK, false if a component reference found in the + * .cmp file is not found in netlist, which means the .cmp file + * is not updated. This is an usual case, in CvPcb, but can be used to + * print a warning in Pcbnew. + */ + bool Load( NETLIST* aNetlist ) throw( IO_ERROR, PARSE_ERROR ); +}; + + +/** + * Class NETLIST_READER + * is a pure virtual class to derive a specific type of netlist reader from. + */ +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. + }; + + + /** + * Constructor + * @param aLineReader ownership is taken of this LINE_READER. + * @param aFootprintLinkReader ownership is taken of this CMP_READER. + */ + 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(); + + /** + * Function GuessNetlistFileType + * looks at \a aFileHeaderLine to see if it matches any of the netlist file types it + * knows about. + * + * @param aLineReader is the #LINE_READER object containing lines from the netlist to test. + * @return the #NETLIST_FILE_T of \a aLineReader. + */ + static NETLIST_FILE_T GuessNetlistFileType( LINE_READER* aLineReader ); + + /** + * Function GetNetlistReader + * attempts to determine the net list file type of \a aNetlistFileName and return the + * appropriate NETLIST_READER type. + * + * @param aNetlist is the netlist to load \a aNetlistFileName into. + * @param aNetlistFileName is the full path and file name of the net list to read. + * @param aCompFootprintFileName is the full path and file name of the component footprint + * associations to read. Set to wxEmptyString if loading the + * footprint association file is not required. + * @return the appropriate NETLIST_READER if \a aNetlistFileName is a valid netlist or + * NULL if \a aNetlistFileName is not a valid netlist files. + */ + static NETLIST_READER* GetNetlistReader( NETLIST* aNetlist, + const wxString& aNetlistFileName, + const wxString& aCompFootprintFileName = wxEmptyString ) + throw( IO_ERROR ); + + /** + * Function LoadNetlist + * loads the contents of the netlist file into \a aNetlist. + * + * @throw IO_ERROR if a file IO error occurs. + * @throw PARSE_ERROR if an error occurs while parsing the file. + */ + virtual void LoadNetlist() throw( IO_ERROR, PARSE_ERROR, boost::bad_pointer ) = 0; + + /** + * Function GetLineReader() + * @return the #LINE_READER associated with the #NETLIST_READER. + */ + LINE_READER* GetLineReader(); + +protected: + NETLIST* m_netlist; ///< The net list to read the file(s) into. + bool m_loadFootprintFilters; ///< Load the component footprint filters section if true. + bool m_loadNets; ///< Load the nets section of the netlist file if true. + LINE_READER* m_lineReader; ///< The line reader of the netlist. + + /// The reader used to load the footprint links. If NULL, footprint links are not read. + CMP_READER* m_footprintReader; +}; + + +/** + * Class LEGACY_NETLIST_READER + * reads the KiCad legacy and the old Orcad netlist formats. + * + * The KiCad legacy netlist format was derived directly from an old Orcad netlist format. The + * primary difference is the header was changed so this reader can read both formats. + */ +class LEGACY_NETLIST_READER : public NETLIST_READER +{ + /** + * Function loadComponent + * read the \a aLine containing the description of a component from a legacy format + * netlist and add it to the netlist. + * + * Analyze the first line of a component description in netlist: + * ( /40C08647 $noname R20 4.7K {Lib=R} + * + * @param aText contains the first line of description + * @return the new component created by parsing \a aLine + * @throw PARSE_ERROR when \a aLine is not a valid component description. + */ + COMPONENT* loadComponent( char* aText ) throw( PARSE_ERROR, boost::bad_pointer ); + + /** + * Function loadFootprintFilters + * loads the footprint filter section of netlist file. + * + * Sample legacy footprint filter section: + * { Allowed footprints by component: + * $component R11 + * R? + * SM0603 + * SM0805 + * R?-* + * SM1206 + * $endlist + * $endfootprintlist + * } + * + * @throw IO_ERROR if a file IO error occurs. + * @throw PARSE_ERROR if an error occurs while parsing the file. + */ + void loadFootprintFilters() throw( IO_ERROR, PARSE_ERROR ); + + /** + * Function loadNet + * read a component net description from \a aText. + * + * @param aText is current line read from the netlist. + * @param aComponent is the component to add the net to. + * @throw PARSE_ERROR if a error occurs reading \a aText. + */ + void loadNet( char* aText, COMPONENT* aComponent ) throw( PARSE_ERROR ); + +public: + + LEGACY_NETLIST_READER( LINE_READER* aLineReader, + NETLIST* aNetlist, + CMP_READER* aFootprintLinkReader = NULL ) : + NETLIST_READER( aLineReader, aNetlist, aFootprintLinkReader ) + { + } + + /** + * Function LoadNetlist + * read the netlist file in the legacy format into \a aNetlist. + * + * The legacy netlist format is: + * \# EESchema Netlist Version 1.0 generee le 18/5/2005-12:30:22 + * ( + * ( 40C08647 $noname R20 4,7K {Lib=R} + * ( 1 VCC ) + * ( 2 MODB_1 ) + * ) + * ( 40C0863F $noname R18 4,7_k {Lib=R} + * ( 1 VCC ) + * ( 2 MODA_1 ) + * ) + * } + * \#End + * + * @throw IO_ERROR if a file IO error occurs. + * @throw PARSE_ERROR if an error occurs while parsing the file. + */ + virtual void LoadNetlist() throw ( IO_ERROR, PARSE_ERROR, boost::bad_pointer ); +}; + + +/** + * Class KICAD_NETLIST_PARSER + * is the parser for reading the KiCad s-expression netlist format. + */ +class KICAD_NETLIST_PARSER : public NETLIST_LEXER +{ +private: + NL_T::T token; + LINE_READER* m_lineReader; ///< The line reader used to parse the netlist. Not owned. + NETLIST* m_netlist; ///< The netlist to parse into. Not owned. + + /** + * Function skipCurrent + * Skip the current token level, i.e + * search for the RIGHT parenthesis which closes the current description + */ + void skipCurrent() throw( IO_ERROR, PARSE_ERROR ); + + /** + * Function parseComponent + * parse a component description: + * (comp (ref P1) + * (value DB25FEMELLE) + * (footprint DB25FC) + * (libsource (lib conn) (part DB25)) + * (sheetpath (names /) (tstamps /)) + * (tstamp 3256759C)) + */ + void parseComponent() throw( IO_ERROR, PARSE_ERROR, boost::bad_pointer ); + + /** + * Function parseNet + * Parses a section like + * (net (code 20) (name /PC-A0) + * (node (ref BUS1) (pin 62)) + * (node (ref U3) (pin 3)) + * (node (ref U9) (pin M6))) + * + * and set the corresponding pads netnames + */ + void parseNet() throw( IO_ERROR, PARSE_ERROR ); + + /** + * Function parseLibPartList + * reads the section "libparts" in the netlist: + * (libparts + * (libpart (lib device) (part C) + * (description "Condensateur non polarise") + * (footprints + * (fp SM*) + * (fp C?) + * (fp C1-1)) + * (fields + * (field (name Reference) C) + * (field (name Value) C)) + * (pins + * (pin (num 1) (name ~) (type passive)) + * (pin (num 2) (name ~) (type passive)))) + * + * And add the strings giving the footprint filter (subsection footprints) + * of the corresponding module info + * <p>This section is used by CvPcb, and is not useful in Pcbnew, + * therefore it it not always read </p> + */ + void parseLibPartList() throw( IO_ERROR, PARSE_ERROR ); + + +public: + KICAD_NETLIST_PARSER( LINE_READER* aReader, NETLIST* aNetlist ); + + void SetLineReader( LINE_READER* aLineReader ); + + void SetNetlist( NETLIST* aNetlist ) { m_netlist = aNetlist; } + + /** + * Function Parse + * parse the full netlist + */ + void Parse() throw( IO_ERROR, PARSE_ERROR, boost::bad_pointer ); + + // Useful for debug only: + const char* getTokenName( NL_T::T aTok ) + { + return NETLIST_LEXER::TokenName( aTok ); + } +}; + + +/** + * Class KICAD_NETLIST_READER + * read the new s-expression based KiCad netlist format. + */ +class KICAD_NETLIST_READER : public NETLIST_READER +{ + KICAD_NETLIST_PARSER* m_parser; ///< The s-expression format 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() throw ( IO_ERROR, PARSE_ERROR, boost::bad_pointer ); +}; + + +#endif // NETLIST_READER_H |