pcb_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-2019 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 <convert_to_biu.h>                      // IU_PER_MM
#include <hashtables.h>
#include <layers_id_colors_and_visibility.h>     // PCB_LAYER_ID
#include <math/util.h>                           // KiROUND, Clamp
#include <pcb_lexer.h>

#include <unordered_map>


class ARC;
class BOARD;
class BOARD_ITEM;
class BOARD_ITEM_CONTAINER;
class PAD;
class BOARD_DESIGN_SETTINGS;
class DIMENSION_BASE;
class PCB_SHAPE;
class EDA_TEXT;
class FP_SHAPE;
class FP_TEXT;
class PCB_TEXT;
class TRACK;
class FOOTPRINT;
class PCB_GROUP;
class PCB_TARGET;
class VIA;
class ZONE;
class FP_3DMODEL;
struct LAYER;


class PCB_PARSER : public PCB_LEXER
{
    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;

    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;  
    bool                m_resetKIIDs;       
    KIID_MAP            m_resetKIIDMap;     

    bool                m_showLegacyZoneWarning;

    // 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.
    typedef struct
    {
        BOARD_ITEM*       parent;
        wxString          name;
        KIID              uuid;
        std::vector<KIID> memberUuids;
    } GROUP_INFO;

    std::vector<GROUP_INFO> m_groupInfos;

    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 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();

    PCB_SHAPE*      parsePCB_SHAPE();
    PCB_TEXT*       parsePCB_TEXT();
    DIMENSION_BASE* parseDIMENSION();

    // Parse a footprint, but do not replace PARSE_ERROR with FUTURE_FORMAT_ERROR automatically.
    FOOTPRINT*      parseFOOTPRINT_unchecked( wxArrayString* aInitialComments = 0 );

    FP_TEXT*        parseFP_TEXT();
    FP_SHAPE*       parseFP_SHAPE();
    PAD*            parsePAD( FOOTPRINT* aParent = NULL );

    // Parse only the (option ...) inside a pad description
    bool            parsePAD_option( PAD* aPad );

    ARC*            parseARC();
    TRACK*          parseTRACK();
    VIA*            parseVIA();
    ZONE*           parseZONE( BOARD_ITEM_CONTAINER* aParent );
    PCB_TARGET*     parsePCB_TARGET();
    BOARD*          parseBOARD();
    void            parseGROUP( 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();

    wxPoint parseXY();

    void parseXY( int* aX, int* aY );

    std::pair<wxString, wxString> parseProperty();

    void parseEDA_TEXT( EDA_TEXT* aText );

    FP_3DMODEL* parse3DModel();

    double parseDouble();

    inline double parseDouble( const char* aExpected )
    {
        NeedNUMBER( aExpected );
        return parseDouble();
    }

    inline double parseDouble( PCB_KEYS_T::T aToken )
    {
        return parseDouble( GetTokenText( aToken ) );
    }

    inline int parseBoardUnits()
    {
        // There should be no major rounding issues here, since the values in
        // the file are in mm and get converted to nano-meters.
        // See test program tools/test-nm-biu-to-ascii-mm-round-tripping.cpp
        // to confirm or experiment.  Use a similar strategy in both places, here
        // and in the test program. Make that program with:
        // $ make test-nm-biu-to-ascii-mm-round-tripping
        auto retval = parseDouble() * IU_PER_MM;

        // N.B. we currently represent board units as integers.  Any values that are
        // larger or smaller than those board units represent undefined behavior for
        // the system.  We limit values to the largest that is visible on the screen
        // This is the diagonal distance of the full screen ~1.5m
        double int_limit = std::numeric_limits<int>::max() * 0.7071;    // 0.7071 = roughly 1/sqrt(2)
        return KiROUND( Clamp<double>( -int_limit, retval, int_limit ) );
    }

    inline int parseBoardUnits( const char* aExpected )
    {
        auto retval = parseDouble( aExpected ) * IU_PER_MM;

        // N.B. we currently represent board units as integers.  Any values that are
        // larger or smaller than those board units represent undefined behavior for
        // the system.  We limit values to the largest that is visible on the screen
        double int_limit = std::numeric_limits<int>::max() * 0.7071;

        // Use here KiROUND, not KIROUND (see comments about them)
        // when having a function as argument, because it will be called twice
        // with KIROUND
        return KiROUND( Clamp<double>( -int_limit, retval, int_limit ) );
    }

    inline int parseBoardUnits( PCB_KEYS_T::T aToken )
    {
        return parseBoardUnits( GetTokenText( aToken ) );
    }

    inline int parseInt()
    {
        return (int)strtol( CurText(), NULL, 10 );
    }

    inline int parseInt( const char* aExpected )
    {
        NeedNUMBER( aExpected );
        return parseInt();
    }

    inline long parseHex()
    {
        NextTok();
        return strtol( CurText(), NULL, 16 );
    }

    bool parseBool();

    /*
     * @return if m_resetKIIDs, returns new KIID(), otehrwise returns CurStr() as KIID.
     */
    KIID CurStrToKIID();

    void resolveGroups( BOARD_ITEM* aParent );

public:

    PCB_PARSER( LINE_READER* aReader = NULL ) :
        PCB_LEXER( aReader ),
        m_board( nullptr ),
        m_resetKIIDs( false )
    {
        init();
    }

    // ~PCB_PARSER() {}

    LINE_READER* SetLineReader( LINE_READER* aReader )
    {
        LINE_READER* ret = PopReader();
        PushReader( aReader );
        return ret;
    }

    void SetBoard( BOARD* aBoard )
    {
        init();
        m_board = aBoard;

        if( aBoard != nullptr )
            m_resetKIIDs = true;
    }

    BOARD_ITEM* Parse();
    FOOTPRINT* parseFOOTPRINT( wxArrayString* aInitialComments = 0 );

    bool IsTooRecent()
    {
        return m_tooRecent;
    }

    wxString GetRequiredVersion();

};


#endif    // _PCBNEW_PARSER_H_