pcb_io_kicad_sexpr_parser.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 CERN
 * Copyright (C) 2012-2023 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
 */
 
#ifndef _PCBNEW_PARSER_H_
#define _PCBNEW_PARSER_H_
 
#include <core/wx_stl_compat.h>
#include <hashtables.h>
#include <layer_ids.h> // PCB_LAYER_ID
#include <lset.h>
#include <pcb_lexer.h>
#include <kiid.h>
#include <math/box2.h>
#include <string_any_map.h>
 
#include <chrono>
#include <unordered_map>
 
 
class PCB_ARC;
class BOARD;
class BOARD_ITEM;
class BOARD_ITEM_CONTAINER;
class PAD;
class BOARD_DESIGN_SETTINGS;
class PCB_DIMENSION_BASE;
class PCB_SHAPE;
class PCB_REFERENCE_IMAGE;
class EDA_TEXT;
class PCB_TEXT;
class PCB_TRACK;
class PCB_TABLE;
class PCB_TABLECELL;
class FOOTPRINT;
class PCB_GROUP;
class PCB_TARGET;
class PCB_VIA;
class ZONE;
class FP_3DMODEL;
class SHAPE_LINE_CHAIN;
struct LAYER;
class PROGRESS_REPORTER;
class TEARDROP_PARAMETERS;
 
 
class PCB_IO_KICAD_SEXPR_PARSER : public PCB_LEXER
{
public:
 PCB_IO_KICAD_SEXPR_PARSER( LINE_READER* aReader, BOARD* aAppendToMe,
 std::function<bool( wxString, int, wxString, wxString )> aQueryUserCallback,
 PROGRESS_REPORTER* aProgressReporter = nullptr, unsigned aLineCount = 0 ) :
 PCB_LEXER( aReader ),
 m_board( aAppendToMe ),
 m_appendToExisting( aAppendToMe != nullptr ),
 m_progressReporter( aProgressReporter ),
 m_lastProgressTime( std::chrono::steady_clock::now() ),
 m_lineCount( aLineCount ),
 m_queryUserCallback( std::move( aQueryUserCallback ) )
 {
 init();
 }
 
 // ~PCB_IO_KICAD_SEXPR_PARSER() {}
 
 BOARD_ITEM* Parse();
 
 FOOTPRINT* parseFOOTPRINT( wxArrayString* aInitialComments = nullptr );
 
 bool IsTooRecent()
 {
 return m_tooRecent;
 }
 
 wxString GetRequiredVersion();
 
 bool IsValidBoardHeader();
 
private:
 
 // Group membership info refers to other Uuids in the file.
 // We don't want to rely on group declarations being last in the file, so
 // we store info about the group declarations here during parsing and then resolve
 // them into BOARD_ITEM* after we've parsed the rest of the file.
 struct GROUP_INFO
 {
 virtual ~GROUP_INFO() = default; // Make polymorphic
 
 BOARD_ITEM* parent;
 wxString name;
 bool locked;
 KIID uuid;
 std::vector<KIID> memberUuids;
 };
 
 struct GENERATOR_INFO : GROUP_INFO
 {
 PCB_LAYER_ID layer;
 wxString genType;
 STRING_ANY_MAP properties;
 };
 
 inline int getNetCode( int aNetCode )
 {
 if( ( aNetCode >= 0 ) && ( aNetCode < (int) m_netCodes.size() ) )
 return m_netCodes[aNetCode];
 
 return aNetCode;
 }
 
 void pushValueIntoMap( int aIndex, int aValue );
 
 void init();
 
 void checkpoint();
 
 void createOldLayerMapping( std::unordered_map< std::string, std::string >& aMap );
 
 void skipCurrent();
 
 void parseHeader();
 void parseGeneralSection();
 void parsePAGE_INFO();
 void parseTITLE_BLOCK();
 
 void parseLayers();
 void parseLayer( LAYER* aLayer );
 
 void parseBoardStackup();
 
 void parseSetup();
 void parseDefaults( BOARD_DESIGN_SETTINGS& aSettings );
 void parseDefaultTextDims( BOARD_DESIGN_SETTINGS& aSettings, int aLayer );
 void parseNETINFO_ITEM();
 void parseNETCLASS();
 
 void parseTEARDROP_PARAMETERS( TEARDROP_PARAMETERS* tdParams );
 
 void parseTextBoxContent( PCB_TEXTBOX* aTextBox );
 
 PCB_SHAPE* parsePCB_SHAPE( BOARD_ITEM* aParent );
 PCB_TEXT* parsePCB_TEXT( BOARD_ITEM* aParent );
 void parsePCB_TEXT_effects( PCB_TEXT* aText );
 PCB_REFERENCE_IMAGE* parsePCB_REFERENCE_IMAGE( BOARD_ITEM* aParent );
 PCB_TEXTBOX* parsePCB_TEXTBOX( BOARD_ITEM* aParent );
 PCB_TABLECELL* parsePCB_TABLECELL( BOARD_ITEM* aParent );
 PCB_TABLE* parsePCB_TABLE( BOARD_ITEM* aParent );
 PCB_DIMENSION_BASE* parseDIMENSION( BOARD_ITEM* aParent );
 
 // Parse a footprint, but do not replace PARSE_ERROR with FUTURE_FORMAT_ERROR automatically.
 FOOTPRINT* parseFOOTPRINT_unchecked( wxArrayString* aInitialComments = nullptr );
 
 PAD* parsePAD( FOOTPRINT* aParent = nullptr );
 
 // Parse only the (option ...) inside a pad description
 bool parsePAD_option( PAD* aPad );
 
 PCB_ARC* parseARC();
 PCB_TRACK* parsePCB_TRACK();
 PCB_VIA* parsePCB_VIA();
 ZONE* parseZONE( BOARD_ITEM_CONTAINER* aParent );
 PCB_TARGET* parsePCB_TARGET();
 BOARD* parseBOARD();
 void parseGROUP_members( GROUP_INFO& aGroupInfo );
 void parseGROUP( BOARD_ITEM* aParent );
 void parseGENERATOR( BOARD_ITEM* aParent );
 
 // Parse a board, but do not replace PARSE_ERROR with FUTURE_FORMAT_ERROR automatically.
 BOARD* parseBOARD_unchecked();
 
 template<class T, class M>
 T lookUpLayer( const M& aMap );
 
 PCB_LAYER_ID parseBoardItemLayer();
 
 LSET parseBoardItemLayersAsMask();
 
 VECTOR2I parseXY();
 
 void parseXY( int* aX, int* aY );
 
 void parseMargins( int& aLeft, int& aTop, int& aRight, int& aBottom );
 
 std::pair<wxString, wxString> parseBoardProperty();
 
 void parseOutlinePoints( SHAPE_LINE_CHAIN& aPoly );
 
 void parseEDA_TEXT( EDA_TEXT* aText );
 
 void parseRenderCache( EDA_TEXT* text );
 
 FP_3DMODEL* parse3DModel();
 
 int parseBoardUnits();
 
 int parseBoardUnits( const char* aExpected );
 
 inline int parseBoardUnits( PCB_KEYS_T::T aToken )
 {
 return parseBoardUnits( GetTokenText( aToken ) );
 }
 
 inline int parseInt()
 {
 return (int)strtol( CurText(), nullptr, 10 );
 }
 
 inline int parseInt( const char* aExpected )
 {
 NeedNUMBER( aExpected );
 return parseInt();
 }
 
 inline long parseHex()
 {
 NextTok();
 return strtol( CurText(), nullptr, 16 );
 }
 
 bool parseBool();
 
 bool parseMaybeAbsentBool( bool aDefaultValue );
 
 /*
 * @return if m_appendToExisting, returns new KIID(), otherwise returns CurStr() as KIID.
 */
 KIID CurStrToKIID();
 
 void resolveGroups( BOARD_ITEM* aParent );
 
 typedef std::unordered_map< std::string, PCB_LAYER_ID > LAYER_ID_MAP;
 typedef std::unordered_map< std::string, LSET > LSET_MAP;
 typedef std::unordered_map< wxString, KIID > KIID_MAP;
 
 using TIMEOUT = std::chrono::milliseconds;
 
 using CLOCK = std::chrono::steady_clock;
 
 using TIME_PT = std::chrono::time_point<CLOCK>;
 
 BOARD* m_board;
 LAYER_ID_MAP m_layerIndices; 
 LSET_MAP m_layerMasks; 
 std::set<wxString> m_undefinedLayers; 
 std::vector<int> m_netCodes; 
 bool m_tooRecent; 
 int m_requiredVersion; 
 wxString m_generatorVersion; 
 bool m_appendToExisting; 
 
 KIID_MAP m_resetKIIDMap;
 
 bool m_showLegacySegmentZoneWarning;
 bool m_showLegacy5ZoneWarning;
 
 PROGRESS_REPORTER* m_progressReporter; 
 TIME_PT m_lastProgressTime; 
 unsigned m_lineCount; 
 
 std::map<EDA_TEXT*, std::tuple<wxString, bool, bool>> m_fontTextMap;
 
 std::vector<GROUP_INFO> m_groupInfos;
 std::vector<GENERATOR_INFO> m_generatorInfos;
 
 std::function<bool( wxString aTitle, int aIcon, wxString aMsg, wxString aAction )> m_queryUserCallback;
};
 
 
#endif // _PCBNEW_PARSER_H_