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 The 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, see <https://www.gnu.org/licenses/>.
 */

 
#ifndef _PCBNEW_PARSER_H_
#define _PCBNEW_PARSER_H_
 
#include <eda_units.h>
#include <core/wx_stl_compat.h>
#include <line_ending.h>
#include <hashtables.h>
#include <lib_id.h>
#include <layer_ids.h>     // PCB_LAYER_ID
#include <lset.h>
#include <pcb_lexer.h>
#include <kiid.h>
#include <math/box2.h>
#include <optional>
#include <constraints/pcb_constraint.h>
#include <drill/drill_span.h>
#include <string_any_map.h>
#include <padstack.h>
#include <pcb_io/common/plugin_common_layer_mapping.h>
 
#include <chrono>
#include <memory>
#include <unordered_map>
#include <utility>
#include <vector>
 
 
class PCB_ARC;
class BOARD;
class BOARD_ITEM;
class ZONE_SETTINGS;
class BOARD_CONNECTED_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_TEXTBOX;
class PCB_TRACK;
class PCB_TABLE;
class PCB_DRILL_CHART;
class PCB_DRILL_MAP;
class PCB_DRILL_CHART;
class PCB_TABLECELL;
class FOOTPRINT;
class PCB_GROUP;
class PCB_POINT;
class PCB_TARGET;
class PCB_GRID_ITEM;
class PCB_VIA;
class ZONE;
struct ZONE_LAYER_PROPERTIES;
class PCB_BARCODE;
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:
 
    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;
 
    PCB_IO_KICAD_SEXPR_PARSER( LINE_READER* aReader, BOARD* aBoard,
                               std::function<bool( wxString, int, wxString, wxString )> aQueryUserCallback,
                               PROGRESS_REPORTER* aProgressReporter = nullptr, unsigned aLineCount = 0,
                               bool aPreserveDestinationStackup = false, bool aAppendToExisting = false ) :
            PCB_LEXER( aReader ),
            m_board( aBoard ),
            m_appendToExisting( aAppendToExisting ),
            m_preserveDestinationStackup( aPreserveDestinationStackup ),
            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();

    const std::vector<wxString>& GetParseWarnings() const { return m_parseWarnings; }

    void SetLayerMappingHandler( LAYER_MAPPING_HANDLER aHandler ) { m_layerMappingHandler = std::move( aHandler ); }
 
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;
        LIB_ID            libId;
        std::vector<KIID> memberUuids;
        std::map<wxString, wxString> customProperties;
    };
 
    struct GENERATOR_INFO : GROUP_INFO
    {
        PCB_LAYER_ID                            layer;
        wxString                                genType;
        STRING_ANY_MAP                          properties;

        std::vector<std::pair<wxString, std::unique_ptr<BOARD_ITEM>>> templates;
 
        // The unique_ptr in `templates` makes this struct move-only.  std::vector resize
        // requires a noexcept move-ctor to move (rather than copy, which is deleted), so
        // declare the move/copy operations explicitly.
        GENERATOR_INFO()                                       = default;
        GENERATOR_INFO( GENERATOR_INFO&& ) noexcept            = default;
        GENERATOR_INFO& operator=( GENERATOR_INFO&& ) noexcept = default;
        GENERATOR_INFO( const GENERATOR_INFO& )                = delete;
        GENERATOR_INFO& operator=( const GENERATOR_INFO& )     = delete;
    };

    struct CONSTRAINT_INFO
    {
        BOARD_ITEM*                    parent = nullptr;
        KIID                           uuid;
        PCB_CONSTRAINT_TYPE            type = PCB_CONSTRAINT_TYPE::UNDEFINED;
        std::vector<CONSTRAINT_MEMBER> members;
        std::optional<double>          value;
        bool                           driving = true;
        std::map<wxString, wxString>   customProperties;
    };

    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 remapAppendedLayers( const std::vector<LAYER>& aSourceLayers, const LSET& aDestInitialEnabled,
                              int aDestInitialCopperCount );
    void parseLayer( LAYER* aLayer );
 
    void parseBoardStackup();
 
    void parseSetup();
 
    void parseDrillSymbolProfile();
    void parseDefaults( BOARD_DESIGN_SETTINGS& aSettings );
    void parseDefaultTextDims( BOARD_DESIGN_SETTINGS& aSettings, int aLayer );
    void parseNETINFO_ITEM();
    void parseNETCLASS();
    void parseNET_CHAINS_SECTION();
 
    void parseTEARDROP_PARAMETERS( TEARDROP_PARAMETERS* tdParams );
 
    void parseTextBoxContent( PCB_TEXTBOX* aTextBox );
 
    void bakeTextBoxLib( PCB_TEXTBOX* aTextBox );

    void parseLineEnding( LINE_ENDING& aEnding );
 
    PCB_SHAPE*           parsePCB_SHAPE( BOARD_ITEM* aParent );
    PCB_TEXT*            parsePCB_TEXT( BOARD_ITEM* aParent, PCB_TEXT* aBaseText = nullptr );
    void                 parsePCB_TEXT_effects( PCB_TEXT* aText, PCB_TEXT* aBaseText = nullptr );
    PCB_REFERENCE_IMAGE* parsePCB_REFERENCE_IMAGE( BOARD_ITEM* aParent );
    PCB_TEXTBOX*         parsePCB_TEXTBOX( BOARD_ITEM* aParent );
    PCB_BARCODE*         parsePCB_BARCODE( BOARD_ITEM* aParent );
    PCB_TABLECELL*       parsePCB_TABLECELL( BOARD_ITEM* aParent );
    PCB_TABLE*           parsePCB_TABLE( BOARD_ITEM* aParent );
    bool                 parseTableBodyToken( PCB_TABLE* aTable, PCB_KEYS_T::T aToken,
                                              bool aAllowIdentity );
    void                 parseTableBody( PCB_TABLE* aTable, bool aAllowIdentity );
    PCB_DRILL_CHART*     parsePCB_DRILL_CHART( BOARD_ITEM* aParent );
    DRILL_SPAN           parseDrillSpanBody();
    PCB_DRILL_MAP*       parsePCB_DRILL_MAP( 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 );
    void        parseFootprintStackup( FOOTPRINT& aFootprint );
 
    PAD*        parsePAD( FOOTPRINT* aParent = nullptr );
    void        parsePAD_primitives( PAD* aPad, PCB_LAYER_ID aLayer );
    void        parsePAD_option( PAD* aPad, PCB_LAYER_ID aLayer );
    void        parsePostMachining( PADSTACK::POST_MACHINING_PROPS& aProps );
    void        parsePadstack( PAD* aPad );
 
    PCB_ARC*       parseARC();
    PCB_TRACK*     parsePCB_TRACK();
    PCB_VIA*       parsePCB_VIA();
    void           parseViastack( PCB_VIA* aVia );
    ZONE*          parseZONE( BOARD_ITEM_CONTAINER* aParent );
    PCB_TARGET*    parsePCB_TARGET();
    PCB_POINT*     parsePCB_POINT();
    PCB_GRID_ITEM* parsePCB_GRID_ITEM();
    BOARD*         parseBOARD();
    void           parseGROUP_members( GROUP_INFO& aGroupInfo );
    void           parseGROUP( BOARD_ITEM* aParent );
    void           parseCONSTRAINT( BOARD_ITEM* aParent );
    void           parseGENERATOR( BOARD_ITEM* aParent );
    void           parseGENERATOR_templates( GENERATOR_INFO& aGenInfo );
 
    // Parse a board, but do not replace PARSE_ERROR with FUTURE_FORMAT_ERROR automatically.
    BOARD*      parseBOARD_unchecked();

    PCB_LAYER_ID lookUpLayer( const LAYER_ID_MAP& aMap );
    LSET lookUpLayerSet( const LSET_MAP& aMap );

    PCB_LAYER_ID parseBoardItemLayer();

    LSET parseBoardItemLayersAsMask();

    LSET parseLayersForCuItemWithSoldermask();

    VECTOR2I parseXY();
 
    void parseXY( int* aX, int* aY );
 
    void parseMargins( int& aLeft, int& aTop, int& aRight, int& aBottom );
 
    void parseZoneDefaults( ZONE_SETTINGS& aZoneSettings );
 
    void parseZoneLayerProperty( std::map<PCB_LAYER_ID, ZONE_LAYER_PROPERTIES>& aProperties );
 
    std::pair<wxString, wxString> parseBoardProperty();
 
    void parseCustomProperty( EDA_ITEM* aItem );
    void parseCustomProperty( std::map<wxString, wxString>& aProps );
 
    void parseVariants();
    void parseFootprintVariant( FOOTPRINT* aFootprint );

    void parseOutlinePoints( SHAPE_LINE_CHAIN& aPoly );

    void parseEDA_TEXT( EDA_TEXT* aText );

    void parseRenderCache( EDA_TEXT* text );
 
    FP_3DMODEL* parse3DModel( bool aFileNameAlreadyParsed = false );

 
    int parseBoardUnits();
 
    int parseBoardUnits( const char* aExpected, EDA_DATA_TYPE aDataType );
 
    inline int parseBoardUnits( const PCB_KEYS_T::T aToken, const EDA_DATA_TYPE aDataType = EDA_DATA_TYPE::DISTANCE )
    {
        return parseBoardUnits( GetTokenText( aToken ), aDataType );
    }
 
    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();
 
    std::optional<bool> parseOptBool();

    bool parseMaybeAbsentBool( bool aDefaultValue );
 
    std::pair<std::optional<bool>, std::optional<bool>> parseFrontBackOptBool( bool aAllowLegacyFormat = false );
 
    void parseNet( BOARD_CONNECTED_ITEM* aItem );
 
    /*
     * @return if m_appendToExisting, returns new KIID(), otherwise returns CurStr() as KIID.
     */
    KIID CurStrToKIID();

    void resolveGroups( BOARD_ITEM* aParent );
    void resolveConstraints( BOARD_ITEM* aParent );

    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; 
    bool                m_preserveDestinationStackup; 
    LAYER_MAPPING_HANDLER m_layerMappingHandler;        

    KIID_MAP            m_resetKIIDMap;
 
    bool                m_showLegacySegmentZoneWarning;
    bool                m_showLegacy5ZoneWarning;
 
    PROGRESS_REPORTER*  m_progressReporter;  
    TIME_PT             m_lastProgressTime;  
    unsigned            m_lineCount;         
 
    std::vector<GROUP_INFO>      m_groupInfos;
    std::vector<GENERATOR_INFO>  m_generatorInfos;
    std::vector<CONSTRAINT_INFO> m_constraintInfos;
 
    std::function<bool( wxString aTitle, int aIcon, wxString aMsg, wxString aAction )> m_queryUserCallback;
 
    std::vector<wxString>       m_parseWarnings;    
};
 
 
#endif    // _PCBNEW_PARSER_H_