PCB_PARSER Class Reference

Read a Pcbnew s-expression formatted LINE_READER object and returns the appropriate BOARD_ITEM object. More...

#include <pcb_parser.h>

Inheritance diagram for PCB_PARSER:

Classes
struct	GROUP_INFO

Public Member Functions
	PCB_PARSER (LINE_READER *aReader=NULL)
LINE_READER *	SetLineReader (LINE_READER *aReader)
	Set aLineReader into the parser, and returns the previous one, if any. More...
void	SetBoard (BOARD *aBoard)
BOARD_ITEM *	Parse ()
FOOTPRINT *	parseFOOTPRINT (wxArrayString *aInitialComments=0)
bool	IsTooRecent ()
	Return whether a version number, if any was parsed, was too recent. More...
wxString	GetRequiredVersion ()
	Return a string representing the version of KiCad required to open this file. More...

Private Types
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

Private Member Functions
int	getNetCode (int aNetCode)
	< Convert net code using the mapping table if available, otherwise returns unchanged net code if < 0 or if is is out of range More...
void	pushValueIntoMap (int aIndex, int aValue)
	Add aValue value in netcode mapping (m_netCodes) at aIndex. More...
void	init ()
	Clear and re-establish m_layerMap with the default layer names. More...
void	createOldLayerMapping (std::unordered_map< std::string, std::string > &aMap)
	Create a mapping from the (short-lived) bug where layer names were translated. More...
void	skipCurrent ()
	Skip the current token level, i.e search for the RIGHT parenthesis which closes the current description. More...
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 ()
FOOTPRINT *	parseFOOTPRINT_unchecked (wxArrayString *aInitialComments=0)
FP_TEXT *	parseFP_TEXT ()
FP_SHAPE *	parseFP_SHAPE ()
PAD *	parsePAD (FOOTPRINT *aParent=NULL)
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)
BOARD *	parseBOARD_unchecked ()
template<class T , class M >
T	lookUpLayer (const M &aMap)
	Parse the current token for the layer definition of a BOARD_ITEM object. More...
PCB_LAYER_ID	parseBoardItemLayer ()
	Parse the layer definition of a BOARD_ITEM object. More...
LSET	parseBoardItemLayersAsMask ()
	Parse the layers definition of a BOARD_ITEM object. More...
wxPoint	parseXY ()
	Parse a coordinate pair (xy X Y) in board units (mm). More...
void	parseXY (int *aX, int *aY)
std::pair< wxString, wxString >	parseProperty ()
void	parseEDA_TEXT (EDA_TEXT *aText)
	Parse the common settings for any object derived from EDA_TEXT. More...
FP_3DMODEL *	parse3DModel ()
double	parseDouble ()
	Parse the current token as an ASCII numeric string with possible leading whitespace into a double precision floating point number. More...
double	parseDouble (const char *aExpected)
double	parseDouble (PCB_KEYS_T::T aToken)
int	parseBoardUnits ()
int	parseBoardUnits (const char *aExpected)
int	parseBoardUnits (PCB_KEYS_T::T aToken)
int	parseInt ()
int	parseInt (const char *aExpected)
long	parseHex ()
bool	parseBool ()
KIID	CurStrToKIID ()
void	resolveGroups (BOARD_ITEM *aParent)
	Called after parsing a footprint definition or board to build the group membership lists. More...

Private Attributes
BOARD *	m_board
LAYER_ID_MAP	m_layerIndices
	map layer name to it's index More...
LSET_MAP	m_layerMasks
	map layer names to their masks More...
std::set< wxString >	m_undefinedLayers
	set of layers not defined in layers section More...
std::vector< int >	m_netCodes
	net codes mapping for boards being loaded More...
bool	m_tooRecent
	true if version parses as later than supported More...
int	m_requiredVersion
	set to the KiCad format version this board requires More...
bool	m_resetKIIDs
	reading into an existing board; reset UUIDs More...
KIID_MAP	m_resetKIIDMap
bool	m_showLegacyZoneWarning
std::vector< GROUP_INFO >	m_groupInfos

Detailed Description

Read a Pcbnew s-expression formatted LINE_READER object and returns the appropriate BOARD_ITEM object.

Definition at line 68 of file pcb_parser.h.

Member Typedef Documentation

KIID_MAP

typedef std::unordered_map< wxString, KIID > PCB_PARSER::KIID_MAP

private

Definition at line 356 of file pcb_parser.h.

LAYER_ID_MAP

typedef std::unordered_map< std::string, PCB_LAYER_ID > PCB_PARSER::LAYER_ID_MAP

private

Definition at line 354 of file pcb_parser.h.

LSET_MAP

typedef std::unordered_map< std::string, LSET > PCB_PARSER::LSET_MAP

private

Definition at line 355 of file pcb_parser.h.

Constructor & Destructor Documentation

PCB_PARSER()

PCB_PARSER::PCB_PARSER ( LINE_READER *  aReader = NULL )

inline

Definition at line 71 of file pcb_parser.h.

                                              :
        PCB_LEXER( aReader ),
        m_board( nullptr ),
        m_resetKIIDs( false )
    {
        init();
    }

References init().

Member Function Documentation

createOldLayerMapping()

void PCB_PARSER::createOldLayerMapping ( std::unordered_map< std::string, std::string > &  aMap )

private

Create a mapping from the (short-lived) bug where layer names were translated.

Todo:

Remove this once we support custom layer names.

Parameters

aMap	string mapping from translated to English layer names.

Definition at line 1340 of file pcb_parser.cpp.

{
    // N.B. This mapping only includes Italian, Polish and French as they were the only languages that
    // mapped the layer names as of cc2022b1ac739aa673d2a0b7a2047638aa7a47b3 (kicad-i18n) when the
    // bug was fixed in KiCad source.

    // Italian
    aMap["Adesivo.Retro"] = "B.Adhes";
    aMap["Adesivo.Fronte"] = "F.Adhes";
    aMap["Pasta.Retro"] = "B.Paste";
    aMap["Pasta.Fronte"] = "F.Paste";
    aMap["Serigrafia.Retro"] = "B.SilkS";
    aMap["Serigrafia.Fronte"] = "F.SilkS";
    aMap["Maschera.Retro"] = "B.Mask";
    aMap["Maschera.Fronte"] = "F.Mask";
    aMap["Grafica"] = "Dwgs.User";
    aMap["Commenti"] = "Cmts.User";
    aMap["Eco1"] = "Eco1.User";
    aMap["Eco2"] = "Eco2.User";
    aMap["Contorno.scheda"] = "Edge.Cuts";

    // Polish
    aMap["Kleju_Dolna"] = "B.Adhes";
    aMap["Kleju_Gorna"] = "F.Adhes";
    aMap["Pasty_Dolna"] = "B.Paste";
    aMap["Pasty_Gorna"] = "F.Paste";
    aMap["Opisowa_Dolna"] = "B.SilkS";
    aMap["Opisowa_Gorna"] = "F.SilkS";
    aMap["Maski_Dolna"] = "B.Mask";
    aMap["Maski_Gorna"] = "F.Mask";
    aMap["Rysunkowa"] = "Dwgs.User";
    aMap["Komentarzy"] = "Cmts.User";
    aMap["ECO1"] = "Eco1.User";
    aMap["ECO2"] = "Eco2.User";
    aMap["Krawedziowa"] = "Edge.Cuts";

    // French
    aMap["Dessous.Adhes"] = "B.Adhes";
    aMap["Dessus.Adhes"] = "F.Adhes";
    aMap["Dessous.Pate"] = "B.Paste";
    aMap["Dessus.Pate"] = "F.Paste";
    aMap["Dessous.SilkS"] = "B.SilkS";
    aMap["Dessus.SilkS"] = "F.SilkS";
    aMap["Dessous.Masque"] = "B.Mask";
    aMap["Dessus.Masque"] = "F.Mask";
    aMap["Dessin.User"] = "Dwgs.User";
    aMap["Contours.Ci"] = "Edge.Cuts";
}

CurStrToKIID()

KIID PCB_PARSER::CurStrToKIID ( )

private

Definition at line 5067 of file pcb_parser.cpp.

{
    KIID aId;

    if( m_resetKIIDs )
    {
        aId = KIID();
        m_resetKIIDMap.insert( std::make_pair( CurStr(), aId ) );
    }
    else
    {
        aId = KIID( CurStr() );
    }

    return aId;
}

getNetCode()

int PCB_PARSER::getNetCode ( int  aNetCode )

inlineprivate

< Convert net code using the mapping table if available, otherwise returns unchanged net code if < 0 or if is is out of range

Definition at line 130 of file pcb_parser.h.

    {
        if( ( aNetCode >= 0 ) && ( aNetCode < (int) m_netCodes.size() ) )
            return m_netCodes[aNetCode];

        return aNetCode;
    }

References m_netCodes.

GetRequiredVersion()

wxString PCB_PARSER::GetRequiredVersion

(

)

Return a string representing the version of KiCad required to open this file.

Not particularly meaningful if IsTooRecent() returns false.

Definition at line 184 of file pcb_parser.cpp.

{
    int year, month, day;

    year = m_requiredVersion / 10000;
    month = ( m_requiredVersion / 100 ) - ( year * 100 );
    day = m_requiredVersion - ( year * 10000 ) - ( month * 100 );

    // wx throws an assertion, not a catchable exception, when the date is invalid.
    // User input shouldn't give wx asserts, so check manually and throw a proper
    // error instead
    if( day <= 0 || month <= 0 || month > 12 ||
            day > wxDateTime::GetNumberOfDays( (wxDateTime::Month)( month - 1 ), year ) )
    {
        wxString err;
        err.Printf( _( "Cannot interpret date code %d" ), m_requiredVersion );
        THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
    }

    wxDateTime date( day, (wxDateTime::Month)( month - 1 ), year, 0, 0, 0, 0 );
    return date.FormatDate();
}

References _, and THROW_PARSE_ERROR.

Referenced by PCB_IO::DoLoad(), CLIPBOARD_IO::Load(), and PCB_IO::Parse().

init()

void PCB_PARSER::init ( )

private

Clear and re-establish m_layerMap with the default layer names.

m_layerMap will have some of its entries overwritten whenever a (new) board is encountered.

Definition at line 61 of file pcb_parser.cpp.

{
    m_showLegacyZoneWarning = true;
    m_tooRecent = false;
    m_requiredVersion = 0;
    m_layerIndices.clear();
    m_layerMasks.clear();
    m_resetKIIDMap.clear();

    // Add untranslated default (i.e. English) layernames.
    // Some may be overridden later if parsing a board rather than a footprint.
    // The English name will survive if parsing only a footprint.
    for( LAYER_NUM layer = 0;  layer < PCB_LAYER_ID_COUNT;  ++layer )
    {
        std::string untranslated = TO_UTF8( wxString( LSET::Name( PCB_LAYER_ID( layer ) ) ) );

        m_layerIndices[ untranslated ] = PCB_LAYER_ID( layer );
        m_layerMasks[ untranslated ]   = LSET( PCB_LAYER_ID( layer ) );
    }

    m_layerMasks[ "*.Cu" ]      = LSET::AllCuMask();
    m_layerMasks[ "*In.Cu" ]    = LSET::InternalCuMask();
    m_layerMasks[ "F&B.Cu" ]    = LSET( 2, F_Cu, B_Cu );
    m_layerMasks[ "*.Adhes" ]   = LSET( 2, B_Adhes, F_Adhes );
    m_layerMasks[ "*.Paste" ]   = LSET( 2, B_Paste, F_Paste );
    m_layerMasks[ "*.Mask" ]    = LSET( 2, B_Mask,  F_Mask );
    m_layerMasks[ "*.SilkS" ]   = LSET( 2, B_SilkS, F_SilkS );
    m_layerMasks[ "*.Fab" ]     = LSET( 2, B_Fab,   F_Fab );
    m_layerMasks[ "*.CrtYd" ]   = LSET( 2, B_CrtYd, F_CrtYd );

    // This is for the first pretty & *.kicad_pcb formats, which had
    // Inner1_Cu - Inner14_Cu with the numbering sequence
    // reversed from the subsequent format's In1_Cu - In30_Cu numbering scheme.
    // The newer format brought in an additional 16 Cu layers and flipped the cu stack but
    // kept the gap between one of the outside layers and the last cu internal.

    for( int i=1; i<=14; ++i )
    {
        std::string key = StrPrintf( "Inner%d.Cu", i );

        m_layerMasks[ key ] = LSET( PCB_LAYER_ID( In15_Cu - i ) );
    }
}

References LSET::AllCuMask(), B_Adhes, B_CrtYd, B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, F_Adhes, F_CrtYd, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, In15_Cu, LSET::InternalCuMask(), LSET::Name(), PCB_LAYER_ID_COUNT, StrPrintf(), and TO_UTF8.

Referenced by PCB_PARSER(), and SetBoard().

IsTooRecent()

bool PCB_PARSER::IsTooRecent ( )

inline

Return whether a version number, if any was parsed, was too recent.

Definition at line 116 of file pcb_parser.h.

    {
        return m_tooRecent;
    }

References m_tooRecent.

Referenced by PCB_IO::DoLoad(), CLIPBOARD_IO::Load(), and PCB_IO::Parse().

lookUpLayer()

template<class T , class M >

T PCB_PARSER::lookUpLayer ( const M &  aMap )

private

Parse the current token for the layer definition of a BOARD_ITEM object.

Parameters

aMap	is the LAYER_{NUM|MSK}_MAP to use for the lookup.

Returns

The result of the parsed BOARD_ITEM layer or set designator.

Exceptions

IO_ERROR	if the layer is not valid.
PARSE_ERROR	if the layer syntax is incorrect.

Definition at line 1524 of file pcb_parser.cpp.

{
    // avoid constructing another std::string, use lexer's directly
    typename M::const_iterator it = aMap.find( curText );

    if( it == aMap.end() )
    {
        m_undefinedLayers.insert( curText );
        return Rescue;
    }

    // Some files may have saved items to the Rescue Layer due to an issue in v5
    if( it->second == Rescue )
        m_undefinedLayers.insert( curText );

    return it->second;
}

References Rescue.

Parse()

BOARD_ITEM * PCB_PARSER::Parse

(

)

Definition at line 473 of file pcb_parser.cpp.

{
    T               token;
    BOARD_ITEM*     item;
    LOCALE_IO       toggle;

    m_groupInfos.clear();

    // FOOTPRINTS can be prefixed with an initial block of single line comments and these are
    // kept for Format() so they round trip in s-expression form.  BOARDs might  eventually do
    // the same, but currently do not.
    std::unique_ptr<wxArrayString> initial_comments( ReadCommentLines() );

    token = CurTok();

    if( token != T_LEFT )
        Expecting( T_LEFT );

    switch( NextTok() )
    {
    case T_kicad_pcb:
        if( m_board == NULL )
            m_board = new BOARD();

        item = (BOARD_ITEM*) parseBOARD();
        break;

    case T_module:      // legacy token
    case T_footprint:
        item = (BOARD_ITEM*) parseFOOTPRINT( initial_comments.release() );
        break;

    default:
        wxString err;
        err.Printf( _( "Unknown token \"%s\"" ), FromUTF8() );
        THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
    }

    resolveGroups( item );

    return item;
}

References _, NULL, and THROW_PARSE_ERROR.

Referenced by PCB_IO::DoLoad(), CLIPBOARD_IO::Load(), FP_CACHE::Load(), parse(), PCB_IO::Parse(), KI_TEST::ReadBoardItemFromFile(), and KI_TEST::ReadBoardItemFromStream().

parse3DModel()

FP_3DMODEL * PCB_PARSER::parse3DModel ( )

private

Definition at line 367 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_model, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as FP_3DMODEL." ) );

    T token;

    FP_3DMODEL* n3D = new FP_3DMODEL;
    NeedSYMBOLorNUMBER();
    n3D->m_Filename = FromUTF8();

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_at:
            NeedLEFT();
            token = NextTok();

            if( token != T_xyz )
                Expecting( T_xyz );

            /* Note:
             * Prior to KiCad v5, model offset was designated by "at",
             * and the units were in inches.
             * Now we use mm, but support reading of legacy files
             */

            n3D->m_Offset.x = parseDouble( "x value" ) * 25.4f;
            n3D->m_Offset.y = parseDouble( "y value" ) * 25.4f;
            n3D->m_Offset.z = parseDouble( "z value" ) * 25.4f;

            NeedRIGHT();    // xyz
            NeedRIGHT();    // at
            break;

        case T_hide:
            n3D->m_Show = false;
            break;

        case T_opacity:
            n3D->m_Opacity = parseDouble( "opacity value" );
            NeedRIGHT();
            break;

        case T_offset:
            NeedLEFT();
            token = NextTok();

            if( token != T_xyz )
                Expecting( T_xyz );

            /*
             * 3D model offset is in mm
             */
            n3D->m_Offset.x = parseDouble( "x value" );
            n3D->m_Offset.y = parseDouble( "y value" );
            n3D->m_Offset.z = parseDouble( "z value" );

            NeedRIGHT();    // xyz
            NeedRIGHT();    // offset
            break;

        case T_scale:
            NeedLEFT();
            token = NextTok();

            if( token != T_xyz )
                Expecting( T_xyz );

            n3D->m_Scale.x = parseDouble( "x value" );
            n3D->m_Scale.y = parseDouble( "y value" );
            n3D->m_Scale.z = parseDouble( "z value" );

            NeedRIGHT();    // xyz
            NeedRIGHT();    // scale
            break;

        case T_rotate:
            NeedLEFT();
            token = NextTok();

            if( token != T_xyz )
                Expecting( T_xyz );

            n3D->m_Rotation.x = parseDouble( "x value" );
            n3D->m_Rotation.y = parseDouble( "y value" );
            n3D->m_Rotation.z = parseDouble( "z value" );

            NeedRIGHT();    // xyz
            NeedRIGHT();    // rotate
            break;

        default:
            Expecting( "at, hide, opacity, offset, scale, or rotate" );
        }

    }

    return n3D;
}

References FP_3DMODEL::m_Filename, FP_3DMODEL::m_Offset, FP_3DMODEL::m_Opacity, FP_3DMODEL::m_Rotation, FP_3DMODEL::m_Scale, FP_3DMODEL::m_Show, NULL, parseDouble(), FP_3DMODEL::VECTOR3D::x, FP_3DMODEL::VECTOR3D::y, and FP_3DMODEL::VECTOR3D::z.

parseARC()

ARC * PCB_PARSER::parseARC ( )

private

We continue to parse the status field but it is no longer written

Definition at line 4183 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_arc, NULL,
            wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as ARC." ) );

    wxPoint pt;
    T       token;

    std::unique_ptr<ARC> arc = std::make_unique<ARC>( m_board );

    for( token = NextTok(); token != T_RIGHT; token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_start:
            pt.x = parseBoardUnits( "start x" );
            pt.y = parseBoardUnits( "start y" );
            arc->SetStart( pt );
            break;

        case T_mid:
            pt.x = parseBoardUnits( "mid x" );
            pt.y = parseBoardUnits( "mid y" );
            arc->SetMid( pt );
            break;

        case T_end:
            pt.x = parseBoardUnits( "end x" );
            pt.y = parseBoardUnits( "end y" );
            arc->SetEnd( pt );
            break;

        case T_width:
            arc->SetWidth( parseBoardUnits( "width" ) );
            break;

        case T_layer:
            arc->SetLayer( parseBoardItemLayer() );
            break;

        case T_net:
            if( !arc->SetNetCode( getNetCode( parseInt( "net number" ) ), /* aNoAssert */ true ) )
                THROW_IO_ERROR( wxString::Format(
                        _( "Invalid net ID in\nfile: \"%s\"\nline: %d\noffset: %d" ), CurSource(),
                        CurLineNumber(), CurOffset() ) );
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( arc->m_Uuid ) = CurStrToKIID();
            break;

        case T_status:
            arc->SetStatus( static_cast<STATUS_FLAGS>( parseHex() ) );
            break;

        case T_locked:
            arc->SetLocked( true );
            break;

        default:
            Expecting( "start, mid, end, width, layer, net, tstamp, or status" );
        }

        NeedRIGHT();
    }

    return arc.release();
}

References _, Format(), NULL, parseHex(), parseInt(), and THROW_IO_ERROR.

parseBOARD()

BOARD * PCB_PARSER::parseBOARD ( )

private

Definition at line 517 of file pcb_parser.cpp.

{
    try
    {
        return parseBOARD_unchecked();
    }
    catch( const PARSE_ERROR& parse_error )
    {
        if( m_tooRecent )
            throw FUTURE_FORMAT_ERROR( parse_error, GetRequiredVersion() );
        else
            throw;
    }
}

parseBOARD_unchecked()

BOARD * PCB_PARSER::parseBOARD_unchecked ( )

private

Definition at line 533 of file pcb_parser.cpp.

{
    T token;
    std::map<wxString, wxString> properties;

    parseHeader();

    std::vector<BOARD_ITEM*> bulkAddedItems;
    BOARD_ITEM* item = nullptr;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        if( token == T_page && m_requiredVersion <= 20200119 )
            token = T_paper;

        switch( token )
        {
        case T_general:
            parseGeneralSection();
            break;

        case T_paper:
            parsePAGE_INFO();
            break;

        case T_title_block:
            parseTITLE_BLOCK();
            break;

        case T_layers:
            parseLayers();
            break;

        case T_setup:
            parseSetup();
            break;

        case T_property:
            properties.insert( parseProperty() );
            break;

        case T_net:
            parseNETINFO_ITEM();
            break;

        case T_net_class:
            parseNETCLASS();
            m_board->m_LegacyNetclassesLoaded = true;
            break;

        case T_gr_arc:
        case T_gr_curve:
        case T_gr_line:
        case T_gr_poly:
        case T_gr_circle:
        case T_gr_rect:
            item = parsePCB_SHAPE();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_gr_text:
            item = parsePCB_TEXT();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_dimension:
            item = parseDIMENSION();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_module:      // legacy token
        case T_footprint:
            item = parseFOOTPRINT();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_segment:
            item = parseTRACK();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_arc:
            item = parseARC();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_group:
            parseGROUP( m_board );
            break;

        case T_via:
            item = parseVIA();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_zone:
            item = parseZONE( m_board );
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        case T_target:
            item = parsePCB_TARGET();
            m_board->Add( item, ADD_MODE::BULK_APPEND );
            bulkAddedItems.push_back( item );
            break;

        default:
            wxString err;
            err.Printf( _( "Unknown token \"%s\"" ), FromUTF8() );
            THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
        }
    }

    if( bulkAddedItems.size() > 0 )
        m_board->FinalizeBulkAdd( bulkAddedItems );

    m_board->SetProperties( properties );

    if( m_undefinedLayers.size() > 0 )
    {
        bool deleteItems;
        std::vector<BOARD_ITEM*> deleteList;
        wxString msg = wxString::Format( _( "Items found on undefined layers.  Do you wish to\n"
                                            "rescue them to the User.Comments layer?" ) );
        wxString details = wxString::Format( _( "Undefined layers:" ) );

        for( const wxString& undefinedLayer : m_undefinedLayers )
            details += wxT( "\n   " ) + undefinedLayer;

        wxRichMessageDialog dlg( nullptr, msg, _( "Warning" ),
                                 wxYES_NO | wxCANCEL | wxCENTRE | wxICON_WARNING | wxSTAY_ON_TOP );
        dlg.ShowDetailedText( details );
        dlg.SetYesNoCancelLabels( _( "Rescue" ), _( "Delete" ), _( "Cancel" ) );

        switch( dlg.ShowModal() )
        {
        case wxID_YES:    deleteItems = false; break;
        case wxID_NO:     deleteItems = true;  break;
        case wxID_CANCEL:
        default:          THROW_IO_ERROR( wxT( "CANCEL" ) );
        }

        auto visitItem = [&]( BOARD_ITEM* curr_item )
                            {
                                if( curr_item->GetLayer() == Rescue )
                                {
                                    if( deleteItems )
                                        deleteList.push_back( curr_item );
                                    else
                                        curr_item->SetLayer( Cmts_User );
                                }
                            };

        for( auto segm : m_board->Tracks() )
        {
            if( segm->Type() == PCB_VIA_T )
            {
                VIA*         via = (VIA*) segm;
                PCB_LAYER_ID top_layer, bottom_layer;

                if( via->GetViaType() == VIATYPE::THROUGH )
                    continue;

                via->LayerPair( &top_layer, &bottom_layer );

                if( top_layer == Rescue || bottom_layer == Rescue )
                {
                    if( deleteItems )
                        deleteList.push_back( via );
                    else
                    {
                        if( top_layer == Rescue )
                            top_layer = F_Cu;

                        if( bottom_layer == Rescue )
                            bottom_layer = B_Cu;

                        via->SetLayerPair( top_layer, bottom_layer );
                    }
                }
            }
            else
                visitItem( segm );
        }

        for( BOARD_ITEM* zone : m_board->Zones() )
            visitItem( zone );

        for( BOARD_ITEM* drawing : m_board->Drawings() )
            visitItem( drawing );

        for( FOOTPRINT* fp : m_board->Footprints() )
        {
            for( BOARD_ITEM* drawing : fp->GraphicalItems() )
                visitItem( drawing );

            for( BOARD_ITEM* zone : fp->Zones() )
                visitItem( zone );
        }

        for( BOARD_ITEM* curr_item : deleteList )
            m_board->Delete( curr_item );

        m_undefinedLayers.clear();
    }

    return m_board;
}

References _, B_Cu, BULK_APPEND, Cmts_User, F_Cu, Format(), VIA::GetViaType(), VIA::LayerPair(), PCB_VIA_T, Rescue, VIA::SetLayerPair(), THROUGH, THROW_IO_ERROR, and THROW_PARSE_ERROR.

parseBoardItemLayer()

PCB_LAYER_ID PCB_PARSER::parseBoardItemLayer ( )

private

Parse the layer definition of a BOARD_ITEM object.

Returns

The index the parsed BOARD_ITEM layer.

Exceptions

IO_ERROR	if the layer is not valid.
PARSE_ERROR	if the layer syntax is incorrect.

Definition at line 1543 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_layer, UNDEFINED_LAYER,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as layer." ) );

    NextTok();

    PCB_LAYER_ID layerIndex = lookUpLayer<PCB_LAYER_ID>( m_layerIndices );

    // Handle closing ) in object parser.

    return layerIndex;
}

References UNDEFINED_LAYER.

parseBoardItemLayersAsMask()

LSET PCB_PARSER::parseBoardItemLayersAsMask ( )

private

Parse the layers definition of a BOARD_ITEM object.

Returns

The mask of layers the parsed BOARD_ITEM is on.

Exceptions

IO_ERROR	if any of the layers is not valid.
PARSE_ERROR	if the layers syntax is incorrect.

Definition at line 1558 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_layers, LSET(),
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
                 wxT( " as item layer mask." ) );

    LSET layerMask;

    for( T token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        LSET mask = lookUpLayer<LSET>( m_layerMasks );
        layerMask |= mask;
    }

    return layerMask;
}

parseBoardStackup()

void PCB_PARSER::parseBoardStackup ( )

private

Definition at line 1144 of file pcb_parser.cpp.

{
    T token;
    wxString name;
    int dielectric_idx = 1;     // the index of dielectric layers
    BOARD_STACKUP& stackup = m_board->GetDesignSettings().GetStackupDescriptor();

    for( token = NextTok(); token != T_RIGHT; token = NextTok() )
    {
        if( CurTok() != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        if( token != T_layer )
        {
            switch( token )
            {
            case T_copper_finish:
                NeedSYMBOL();
                stackup.m_FinishType = FromUTF8();
                NeedRIGHT();
                break;

            case T_edge_plating:
                token = NextTok();
                stackup.m_EdgePlating = token == T_yes;
                NeedRIGHT();
                break;

            case T_dielectric_constraints:
                token = NextTok();
                stackup.m_HasDielectricConstrains = token == T_yes;
                NeedRIGHT();
                break;

            case T_edge_connector:
                token = NextTok();
                stackup.m_EdgeConnectorConstraints = BS_EDGE_CONNECTOR_NONE;

                if( token == T_yes )
                    stackup.m_EdgeConnectorConstraints = BS_EDGE_CONNECTOR_IN_USE;
                else if( token == T_bevelled )
                    stackup.m_EdgeConnectorConstraints = BS_EDGE_CONNECTOR_BEVELLED;

                NeedRIGHT();
                break;

            case T_castellated_pads:
                token = NextTok();
                stackup.m_CastellatedPads = token == T_yes;
                NeedRIGHT();
                break;

            default:
                // Currently, skip this item if not defined, because the stackup def
                // is a moving target
                //Expecting( "copper_finish, edge_plating, dielectric_constrains, edge_connector, castellated_pads" );
                skipCurrent();
                break;
            }

            continue;
        }

        NeedSYMBOL();
        name = FromUTF8();

        // init the layer id. For dielectric, layer id = UNDEFINED_LAYER
        PCB_LAYER_ID layerId = m_board->GetLayerID( name );

        // Init the type
        BOARD_STACKUP_ITEM_TYPE type = BS_ITEM_TYPE_UNDEFINED;

        if( layerId == F_SilkS || layerId == B_SilkS )
            type = BS_ITEM_TYPE_SILKSCREEN;
        else if( layerId == F_Mask || layerId == B_Mask )
            type = BS_ITEM_TYPE_SOLDERMASK;
        else if( layerId == F_Paste || layerId == B_Paste )
            type = BS_ITEM_TYPE_SOLDERPASTE;
        else if( layerId == UNDEFINED_LAYER )
            type = BS_ITEM_TYPE_DIELECTRIC;
        else if( layerId >= F_Cu && layerId <= B_Cu )
            type = BS_ITEM_TYPE_COPPER;

        BOARD_STACKUP_ITEM* item = nullptr;

        if( type != BS_ITEM_TYPE_UNDEFINED )
        {
            item = new BOARD_STACKUP_ITEM( type );
            item->SetBrdLayerId( layerId );

            if( type == BS_ITEM_TYPE_DIELECTRIC )
                item->SetDielectricLayerId( dielectric_idx++ );

            stackup.Add( item );
        }
        else
            Expecting( "layer_name" );

        bool has_next_sublayer = true;
        int sublayer_idx = 0;       // the index of dielectric sub layers
                                    // sublayer 0 is always existing (main sublayer)

        while( has_next_sublayer )
        {
            has_next_sublayer = false;

            for( token = NextTok(); token != T_RIGHT; token = NextTok() )
            {
                if( token == T_addsublayer )
                {
                    has_next_sublayer = true;
                    break;
                }

                if( token == T_LEFT )
                {
                    token = NextTok();

                    switch( token )
                    {
                    case T_type:
                        NeedSYMBOL();
                        item->SetTypeName( FromUTF8() );
                        NeedRIGHT();
                        break;

                    case T_thickness:
                        item->SetThickness( parseBoardUnits( T_thickness ), sublayer_idx );
                        token = NextTok();

                        if( token == T_LEFT )
                            break;

                        if( token == T_locked )
                        {
                            // Dielectric thickness can be locked (for impedance controlled layers)
                            if( type == BS_ITEM_TYPE_DIELECTRIC )
                                item->SetThicknessLocked( true, sublayer_idx );

                            NeedRIGHT();
                        }
                        break;

                    case T_material:
                        NeedSYMBOL();
                        item->SetMaterial( FromUTF8(), sublayer_idx );
                        NeedRIGHT();
                        break;

                    case T_epsilon_r:
                        NextTok();
                        item->SetEpsilonR( parseDouble(), sublayer_idx );
                        NeedRIGHT();
                        break;

                    case T_loss_tangent:
                        NextTok();
                        item->SetLossTangent( parseDouble(), sublayer_idx );
                        NeedRIGHT();
                        break;

                    case T_color:
                        NeedSYMBOL();
                        item->SetColor( FromUTF8() );
                        NeedRIGHT();
                        break;

                    default:
                        // Currently, skip this item if not defined, because the stackup def
                        // is a moving target
                        //Expecting( "type, thickness, material, epsilon_r, loss_tangent, color" );
                        skipCurrent();
                    }
                }
            }

            if( has_next_sublayer )     // Prepare reading the next sublayer description
            {
                sublayer_idx++;
                item->AddDielectricPrms( sublayer_idx );
            }
        }
    }

    if( token != T_RIGHT )
    {
        Expecting( ")" );
    }

    // Success:
    m_board->GetDesignSettings().m_HasStackup = true;
}

References BOARD_STACKUP::Add(), BOARD_STACKUP_ITEM::AddDielectricPrms(), B_Cu, B_Mask, B_Paste, B_SilkS, BS_EDGE_CONNECTOR_BEVELLED, BS_EDGE_CONNECTOR_IN_USE, BS_EDGE_CONNECTOR_NONE, BS_ITEM_TYPE_COPPER, BS_ITEM_TYPE_DIELECTRIC, BS_ITEM_TYPE_SILKSCREEN, BS_ITEM_TYPE_SOLDERMASK, BS_ITEM_TYPE_SOLDERPASTE, BS_ITEM_TYPE_UNDEFINED, F_Cu, F_Mask, F_Paste, F_SilkS, BOARD_STACKUP::m_CastellatedPads, BOARD_STACKUP::m_EdgeConnectorConstraints, BOARD_STACKUP::m_EdgePlating, BOARD_STACKUP::m_FinishType, BOARD_STACKUP::m_HasDielectricConstrains, name, parseDouble(), BOARD_STACKUP_ITEM::SetBrdLayerId(), BOARD_STACKUP_ITEM::SetColor(), BOARD_STACKUP_ITEM::SetDielectricLayerId(), BOARD_STACKUP_ITEM::SetEpsilonR(), BOARD_STACKUP_ITEM::SetLossTangent(), BOARD_STACKUP_ITEM::SetMaterial(), BOARD_STACKUP_ITEM::SetThickness(), BOARD_STACKUP_ITEM::SetThicknessLocked(), BOARD_STACKUP_ITEM::SetTypeName(), and UNDEFINED_LAYER.

parseBoardUnits() [1/3]

int PCB_PARSER::parseBoardUnits ( )

inlineprivate

Definition at line 287 of file pcb_parser.h.

    {
        // 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 ) );
    }

References IU_PER_MM, KiROUND(), and parseDouble().

Referenced by parseBoardUnits().

parseBoardUnits() [2/3]

int PCB_PARSER::parseBoardUnits ( const char *  aExpected )

inlineprivate

Definition at line 305 of file pcb_parser.h.

    {
        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 EKIROUND (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 ) );
    }

References IU_PER_MM, KiROUND(), and parseDouble().

parseBoardUnits() [3/3]

int PCB_PARSER::parseBoardUnits ( PCB_KEYS_T::T  aToken )

inlineprivate

Definition at line 319 of file pcb_parser.h.

    {
        return parseBoardUnits( GetTokenText( aToken ) );
    }

References DSN::GetTokenText(), and parseBoardUnits().

parseBool()

bool PCB_PARSER::parseBool ( )

private

Definition at line 169 of file pcb_parser.cpp.

{
    T token = NextTok();

    if( token == T_yes )
        return true;
    else if( token == T_no )
        return false;
    else
        Expecting( "yes or no" );

    return false;
}

parseDefaults()

void PCB_PARSER::parseDefaults ( BOARD_DESIGN_SETTINGS &  aSettings )

private

Definition at line 1915 of file pcb_parser.cpp.

{
    T token;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_edge_clearance:
            designSettings.m_CopperEdgeClearance = parseBoardUnits( T_edge_clearance );
            m_board->m_LegacyCopperEdgeClearanceLoaded = true;
            NeedRIGHT();
            break;

        case T_copper_line_width:
            designSettings.m_LineThickness[ LAYER_CLASS_COPPER ] = parseBoardUnits( token );
            NeedRIGHT();
            break;

        case T_copper_text_dims:
            parseDefaultTextDims( designSettings, LAYER_CLASS_COPPER );
            break;

        case T_courtyard_line_width:
            designSettings.m_LineThickness[ LAYER_CLASS_COURTYARD ] = parseBoardUnits( token );
            NeedRIGHT();
            break;

        case T_edge_cuts_line_width:
            designSettings.m_LineThickness[ LAYER_CLASS_EDGES ] = parseBoardUnits( token );
            NeedRIGHT();
            break;

        case T_silk_line_width:
            designSettings.m_LineThickness[ LAYER_CLASS_SILK ] = parseBoardUnits( token );
            NeedRIGHT();
            break;

        case T_silk_text_dims:
            parseDefaultTextDims( designSettings, LAYER_CLASS_SILK );
            break;

        case T_fab_layers_line_width:
            designSettings.m_LineThickness[ LAYER_CLASS_FAB ] = parseBoardUnits( token );
            NeedRIGHT();
            break;

        case T_fab_layers_text_dims:
            parseDefaultTextDims( designSettings, LAYER_CLASS_FAB );
            break;

        case T_other_layers_line_width:
            designSettings.m_LineThickness[ LAYER_CLASS_OTHERS ] = parseBoardUnits( token );
            NeedRIGHT();
            break;

        case T_other_layers_text_dims:
            parseDefaultTextDims( designSettings, LAYER_CLASS_OTHERS );
            break;

        case T_dimension_units:
            designSettings.m_DimensionUnitsMode =
                    static_cast<DIM_UNITS_MODE>( parseInt( "dimension units" ) );
            NeedRIGHT();
            break;

        case T_dimension_precision:
            designSettings.m_DimensionPrecision = parseInt( "dimension precision" );
            NeedRIGHT();
            break;

        default:
            Unexpected( CurText() );
        }
    }
}

References LAYER_CLASS_COPPER, LAYER_CLASS_COURTYARD, LAYER_CLASS_EDGES, LAYER_CLASS_FAB, LAYER_CLASS_OTHERS, LAYER_CLASS_SILK, BOARD_DESIGN_SETTINGS::m_CopperEdgeClearance, BOARD_DESIGN_SETTINGS::m_DimensionPrecision, BOARD_DESIGN_SETTINGS::m_DimensionUnitsMode, BOARD_DESIGN_SETTINGS::m_LineThickness, and parseInt().

parseDefaultTextDims()

void PCB_PARSER::parseDefaultTextDims ( BOARD_DESIGN_SETTINGS &  aSettings, int  aLayer  )

private

Definition at line 1998 of file pcb_parser.cpp.

{
    T token;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_size:
            aSettings.m_TextSize[ aLayer ].x = parseBoardUnits( "default text size X" );
            aSettings.m_TextSize[ aLayer ].y = parseBoardUnits( "default text size Y" );
            NeedRIGHT();
            break;

        case T_thickness:
            aSettings.m_TextThickness[ aLayer ] = parseBoardUnits( "default text width" );
            NeedRIGHT();
            break;

        case T_italic:
            aSettings.m_TextItalic[ aLayer ] = true;
            break;

        case T_keep_upright:
            aSettings.m_TextUpright[ aLayer ] = true;
            break;

        default:
            Expecting( "size, thickness, italic or keep_upright" );
        }
    }
}

References BOARD_DESIGN_SETTINGS::m_TextItalic, BOARD_DESIGN_SETTINGS::m_TextSize, BOARD_DESIGN_SETTINGS::m_TextThickness, and BOARD_DESIGN_SETTINGS::m_TextUpright.

parseDIMENSION()

DIMENSION_BASE * PCB_PARSER::parseDIMENSION ( )

private

Definition at line 2465 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_dimension, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as DIMENSION." ) );

    T token;

    std::unique_ptr<DIMENSION_BASE> dimension;

    // skip value that used to be saved
    if( NextTok() != T_LEFT )
        NeedLEFT();

    token = NextTok();

    bool isLegacyDimension = false;

    // Old format
    if( token == T_width )
    {
        isLegacyDimension = true;
        dimension = std::make_unique<ALIGNED_DIMENSION>( nullptr );
        dimension->SetLineThickness( parseBoardUnits( "dimension width value" ) );
        NeedRIGHT();
    }
    else
    {
        if( token != T_type )
            Expecting( T_type );

        switch( NextTok() )
        {
        case T_aligned:
            dimension = std::make_unique<ALIGNED_DIMENSION>( nullptr );
            break;

        case T_orthogonal:
            dimension = std::make_unique<ORTHOGONAL_DIMENSION>( nullptr );
            break;

        case T_leader:
            dimension = std::make_unique<LEADER>( nullptr );
            break;

        case T_center:
            dimension = std::make_unique<CENTER_DIMENSION>( nullptr );
            break;

        default:
            wxFAIL_MSG( wxT( "Cannot parse unknown dimension type %s" ) +
                        GetTokenString( CurTok() ) );
        }

        NeedRIGHT();
    }

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_layer:
            dimension->SetLayer( parseBoardItemLayer() );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( dimension->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        case T_gr_text:
        {
            PCB_TEXT* text = parsePCB_TEXT();
            dimension->Text() = *text;

            // The text is part of the dimension and shares its uuid
            const_cast<KIID&>( dimension->Text().m_Uuid ) = dimension->m_Uuid;

            // Fetch other dimension properties out of the text item
            dimension->Text().SetTextPos( text->GetTextPos() );

            if( isLegacyDimension )
            {
                EDA_UNITS units   = EDA_UNITS::INCHES;
                FetchUnitsFromString( text->GetText(), units );
                dimension->SetUnits( units );
            }

            delete text;
            break;
        }

        // New format: feature points
        case T_pts:
        {
            wxPoint point;

            parseXY( &point.x, &point.y );
            dimension->SetStart( point );
            parseXY( &point.x, &point.y );
            dimension->SetEnd( point );

            NeedRIGHT();
            break;
        }

        case T_height:
        {
            wxCHECK_MSG( dimension->Type() == PCB_DIM_ALIGNED_T ||
                         dimension->Type() == PCB_DIM_ORTHOGONAL_T, nullptr,
                         wxT( "Invalid height token" ) );
            ALIGNED_DIMENSION* aligned = static_cast<ALIGNED_DIMENSION*>( dimension.get() );
            aligned->SetHeight( parseBoardUnits( "dimension height value" ) );
            NeedRIGHT();
            break;
        }

        case T_orientation:
        {
            wxCHECK_MSG( dimension->Type() == PCB_DIM_ORTHOGONAL_T, nullptr,
                         wxT( "Invalid orientation token" ) );
            ORTHOGONAL_DIMENSION* ortho = static_cast<ORTHOGONAL_DIMENSION*>( dimension.get() );

            int orientation = parseInt( "orthogonal dimension orientation" );
            orientation     = std::max( 0, std::min( 1, orientation ) );
            ortho->SetOrientation( static_cast<ORTHOGONAL_DIMENSION::DIR>( orientation ) );
            NeedRIGHT();
            break;
        }

        case T_format:
        {
            for( token = NextTok(); token != T_RIGHT; token = NextTok() )
            {
                switch( token )
                {
                case T_LEFT:
                    continue;

                case T_prefix:
                    NeedSYMBOLorNUMBER();
                    dimension->SetPrefix( FromUTF8() );
                    NeedRIGHT();
                    break;

                case T_suffix:
                    NeedSYMBOLorNUMBER();
                    dimension->SetSuffix( FromUTF8() );
                    NeedRIGHT();
                    break;

                case T_units:
                {
                    int mode = parseInt( "dimension units mode" );
                    mode = std::max( 0, std::min( 4, mode ) );
                    dimension->SetUnitsMode( static_cast<DIM_UNITS_MODE>( mode ) );
                    NeedRIGHT();
                    break;
                }

                case T_units_format:
                {
                    int format = parseInt( "dimension units format" );
                    format = std::max( 0, std::min( 3, format ) );
                    dimension->SetUnitsFormat( static_cast<DIM_UNITS_FORMAT>( format ) );
                    NeedRIGHT();
                    break;
                }

                case T_precision:
                    dimension->SetPrecision( parseInt( "dimension precision" ) );
                    NeedRIGHT();
                    break;

                case T_override_value:
                    NeedSYMBOLorNUMBER();
                    dimension->SetOverrideTextEnabled( true );
                    dimension->SetOverrideText( FromUTF8() );
                    NeedRIGHT();
                    break;

                case T_suppress_zeroes:
                    dimension->SetSuppressZeroes( true );
                    break;

                default:
                    Expecting( "prefix, suffix, units, units_format, precision, override_value, "
                               "suppress_zeroes" );
                }
            }
            break;
        }

        case T_style:
        {
            // new format: default to keep text aligned off unless token is present
            dimension->SetKeepTextAligned( false );

            for( token = NextTok(); token != T_RIGHT; token = NextTok() )
            {
                switch( token )
                {
                case T_LEFT:
                    continue;

                case T_thickness:
                    dimension->SetLineThickness( parseBoardUnits( "extension line thickness" ) );
                    NeedRIGHT();
                    break;

                case T_arrow_length:
                    dimension->SetArrowLength( parseBoardUnits( "arrow length" ) );
                    NeedRIGHT();
                    break;

                case T_text_position_mode:
                {
                    int mode = parseInt( "dimension text position mode" );
                    mode = std::max( 0, std::min( 3, mode ) );
                    dimension->SetTextPositionMode( static_cast<DIM_TEXT_POSITION>( mode ) );
                    NeedRIGHT();
                    break;
                }

                case T_extension_height:
                {
                    ALIGNED_DIMENSION* aligned = dynamic_cast<ALIGNED_DIMENSION*>( dimension.get() );
                    wxCHECK_MSG( aligned, nullptr, wxT( "Invalid extension_height token" ) );
                    aligned->SetExtensionHeight( parseBoardUnits( "extension height" ) );
                    NeedRIGHT();
                    break;
                }

                case T_extension_offset:
                    dimension->SetExtensionOffset( parseBoardUnits( "extension offset" ) );
                    NeedRIGHT();
                    break;

                case T_keep_text_aligned:
                    dimension->SetKeepTextAligned( true );
                    break;

                case T_text_frame:
                {
                    wxCHECK_MSG( dimension->Type() == PCB_DIM_LEADER_T, nullptr,
                                 wxT( "Invalid text_frame token" ) );
                    LEADER* leader = static_cast<LEADER*>( dimension.get() );

                    int textFrame = parseInt( "dimension text frame mode" );
                    textFrame = std::max( 0, std::min( 3, textFrame ) );
                    leader->SetTextFrame( static_cast<DIM_TEXT_FRAME>( textFrame ) );
                    NeedRIGHT();
                    break;
                }

                default:
                    Expecting( "thickness, arrow_length, text_position_mode, extension_height, "
                               "extension_offset" );
                }
            }

            break;
        }

        // Old format: feature1 stores a feature line.  We only care about the origin.
        case T_feature1:
        {
            NeedLEFT();
            token = NextTok();

            if( token != T_pts )
                Expecting( T_pts );

            wxPoint point;

            parseXY( &point.x, &point.y );
            dimension->SetStart( point );

            parseXY( nullptr, nullptr ); // Ignore second point
            NeedRIGHT();
            NeedRIGHT();
            break;
        }

        // Old format: feature2 stores a feature line.  We only care about the end point.
        case T_feature2:
        {
            NeedLEFT();
            token = NextTok();

            if( token != T_pts )
                Expecting( T_pts );

            wxPoint point;

            parseXY( &point.x, &point.y );
            dimension->SetEnd( point );

            parseXY( nullptr, nullptr ); // Ignore second point

            NeedRIGHT();
            NeedRIGHT();
            break;
        }

        case T_crossbar:
        {
            NeedLEFT();
            token = NextTok();

            if( token == T_pts )
            {
                // If we have a crossbar, we know we're an old aligned dimension
                ALIGNED_DIMENSION* aligned = static_cast<ALIGNED_DIMENSION*>( dimension.get() );

                // Old style: calculate height from crossbar
                wxPoint point1, point2;
                parseXY( &point1.x, &point1.y );
                parseXY( &point2.x, &point2.y );
                aligned->UpdateHeight( point2, point1 ); // Yes, backwards intentionally
                NeedRIGHT();
            }

            NeedRIGHT();
            break;
        }

        // Arrow: no longer saved; no-op
        case T_arrow1a:
            NeedLEFT();
            token = NextTok();

            if( token != T_pts )
                Expecting( T_pts );

            parseXY( nullptr, nullptr );
            parseXY( nullptr, nullptr );
            NeedRIGHT();
            NeedRIGHT();
            break;

        // Arrow: no longer saved; no-op
        case T_arrow1b:
            NeedLEFT();
            token = NextTok();

            if( token != T_pts )
                Expecting( T_pts );

            parseXY( nullptr, nullptr );
            parseXY( nullptr, nullptr );
            NeedRIGHT();
            NeedRIGHT();
            break;

        // Arrow: no longer saved; no-op
        case T_arrow2a:
            NeedLEFT();
            token = NextTok();

            if( token != T_pts )
                Expecting( T_pts );

            parseXY( nullptr, nullptr );
            parseXY( nullptr, nullptr );
            NeedRIGHT();
            NeedRIGHT();
            break;

        // Arrow: no longer saved; no-op
        case T_arrow2b:
            NeedLEFT();
            token = NextTok();

            if( token != T_pts )
                Expecting( T_pts );

            parseXY( nullptr, nullptr );
            parseXY( nullptr, nullptr );
            NeedRIGHT();
            NeedRIGHT();
            break;

        default:
            Expecting( "layer, tstamp, gr_text, feature1, feature2, crossbar, arrow1a, "
                       "arrow1b, arrow2a, or arrow2b" );
        }
    }

    dimension->Update();

    return dimension.release();
}

References FetchUnitsFromString(), EDA_TEXT::GetText(), EDA_TEXT::GetTextPos(), INCHES, EDA_ITEM::m_Uuid, NULL, parseInt(), PCB_DIM_ALIGNED_T, PCB_DIM_LEADER_T, PCB_DIM_ORTHOGONAL_T, ALIGNED_DIMENSION::SetExtensionHeight(), ALIGNED_DIMENSION::SetHeight(), and ALIGNED_DIMENSION::UpdateHeight().

parseDouble() [1/3]

double PCB_PARSER::parseDouble ( )

private

Parse the current token as an ASCII numeric string with possible leading whitespace into a double precision floating point number.

Returns

The result of the parsed token.

Exceptions

IO_ERROR

if an error occurs attempting to convert the current token.

Definition at line 139 of file pcb_parser.cpp.

{
    char* tmp;

    errno = 0;

    double fval = strtod( CurText(), &tmp );

    if( errno )
    {
        wxString error;
        error.Printf( _( "Invalid floating point number in\nfile: \"%s\"\nline: %d\noffset: %d" ),
                      CurSource(), CurLineNumber(), CurOffset() );

        THROW_IO_ERROR( error );
    }

    if( CurText() == tmp )
    {
        wxString error;
        error.Printf( _( "Missing floating point number in\nfile: \"%s\"\nline: %d\noffset: %d" ),
                      CurSource(), CurLineNumber(), CurOffset() );

        THROW_IO_ERROR( error );
    }

    return fval;
}

References _, and THROW_IO_ERROR.

Referenced by parseBoardUnits(), and parseDouble().

parseDouble() [2/3]

double PCB_PARSER::parseDouble ( const char *  aExpected )

inlineprivate

Definition at line 276 of file pcb_parser.h.

    {
        NeedNUMBER( aExpected );
        return parseDouble();
    }

References parseDouble().

parseDouble() [3/3]

double PCB_PARSER::parseDouble ( PCB_KEYS_T::T  aToken )

inlineprivate

Definition at line 282 of file pcb_parser.h.

    {
        return parseDouble( GetTokenText( aToken ) );
    }

References DSN::GetTokenText(), and parseDouble().

parseEDA_TEXT()

void PCB_PARSER::parseEDA_TEXT ( EDA_TEXT *  aText )

private

Parse the common settings for any object derived from EDA_TEXT.

Parameters

aText

A point to the EDA_TEXT object to save the parsed settings into.

Exceptions

PARSE_ERROR

if the text syntax is not valid.

Definition at line 255 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_effects,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as EDA_TEXT." ) );

    T token;

    // Prior to v5.0 text size was omitted from file format if equal to 60mils
    // Now, it is always explicitly written to file
    bool foundTextSize = false;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_font:
            for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
            {
                if( token == T_LEFT )
                    continue;

                switch( token )
                {
                case T_size:
                    {
                        wxSize sz;
                        sz.SetHeight( parseBoardUnits( "text height" ) );
                        sz.SetWidth( parseBoardUnits( "text width" ) );
                        aText->SetTextSize( sz );
                        NeedRIGHT();

                        foundTextSize = true;
                    }
                    break;

                case T_thickness:
                    aText->SetTextThickness( parseBoardUnits( "text thickness" ) );
                    NeedRIGHT();
                    break;

                case T_bold:
                    aText->SetBold( true );
                    break;

                case T_italic:
                    aText->SetItalic( true );
                    break;

                default:
                    Expecting( "size, bold, or italic" );
                }
            }
            break;

        case T_justify:
            for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
            {
                if( token == T_LEFT )
                    continue;

                switch( token )
                {
                case T_left:
                    aText->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
                    break;

                case T_right:
                    aText->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
                    break;

                case T_top:
                    aText->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
                    break;

                case T_bottom:
                    aText->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
                    break;

                case T_mirror:
                    aText->SetMirrored( true );
                    break;

                default:
                    Expecting( "left, right, top, bottom, or mirror" );
                }

            }
            break;

        case T_hide:
            aText->SetVisible( false );
            break;

        default:
            Expecting( "font, justify, or hide" );
        }
    }

    // Text size was not specified in file, force legacy default units
    // 60mils is 1.524mm
    if( !foundTextSize )
    {
        const double defaultTextSize = 1.524 * IU_PER_MM;

        aText->SetTextSize( wxSize( defaultTextSize, defaultTextSize ) );
    }
}

References GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, IU_PER_MM, EDA_TEXT::SetBold(), EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetItalic(), EDA_TEXT::SetMirrored(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetTextThickness(), EDA_TEXT::SetVertJustify(), and EDA_TEXT::SetVisible().

parseFOOTPRINT()

FOOTPRINT * PCB_PARSER::parseFOOTPRINT

(

wxArrayString *

aInitialComments = 0

)

Parameters

aInitialComments

may be a pointer to a heap allocated initial comment block or NULL. If not NULL, then caller has given ownership of a wxArrayString to this function and care must be taken to delete it even on exception.

Definition at line 2866 of file pcb_parser.cpp.

{
    try
    {
        return parseFOOTPRINT_unchecked( aInitialComments );
    }
    catch( const PARSE_ERROR& parse_error )
    {
        if( m_tooRecent )
            throw FUTURE_FORMAT_ERROR( parse_error, GetRequiredVersion() );
        else
            throw;
    }
}

parseFOOTPRINT_unchecked()

FOOTPRINT * PCB_PARSER::parseFOOTPRINT_unchecked ( wxArrayString *  aInitialComments = 0 )

private

Definition at line 2882 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_module || CurTok() == T_footprint, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as FOOTPRINT." ) );

    wxString name;
    wxPoint  pt;
    T        token;
    LIB_ID   fpid;
    int      attributes = 0;

    std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>( m_board );

    std::map<wxString, wxString> properties;

    footprint->SetInitialComments( aInitialComments );

    token = NextTok();

    if( !IsSymbol( token ) && token != T_NUMBER )
        Expecting( "symbol|number" );

    name = FromUTF8();

    if( !name.IsEmpty() && fpid.Parse( name, true ) >= 0 )
    {
        wxString error;
        error.Printf( _( "Invalid footprint ID in\nfile: \"%s\"\nline: %d\noffset: %d" ),
                      CurSource(), CurLineNumber(), CurOffset() );
        THROW_IO_ERROR( error );
    }

    for( token = NextTok(); token != T_RIGHT; token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_version:
        {
            // Theoretically a footprint nested in a PCB could declare its own version, though
            // as of writing this comment we don't do that. Just in case, take the greater
            // version.
            int this_version = parseInt( FromUTF8().mb_str( wxConvUTF8 ) );
            NeedRIGHT();
            m_requiredVersion = std::max( m_requiredVersion, this_version );
            m_tooRecent       = ( m_requiredVersion > SEXPR_BOARD_FILE_VERSION );
            break;
        }

        case T_generator:
            // We currently ignore the generator when parsing. It is included in the file for manual
            // indication of where the footprint came from.
            NeedSYMBOL();
            NeedRIGHT();
            break;

        case T_locked:
            footprint->SetLocked( true );
            break;

        case T_placed:
            footprint->SetIsPlaced( true );
            break;

        case T_layer:
        {
            // Footprints can be only on the front side or the back side.
            // but because we can find some stupid layer in file, ensure a
            // acceptable layer is set for the footprint
            PCB_LAYER_ID layer = parseBoardItemLayer();
            footprint->SetLayer( layer == B_Cu ? B_Cu : F_Cu );
        }
            NeedRIGHT();
            break;

        case T_tedit:
            footprint->SetLastEditTime( parseHex() );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( footprint->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        case T_at:
            pt.x = parseBoardUnits( "X coordinate" );
            pt.y = parseBoardUnits( "Y coordinate" );
            footprint->SetPosition( pt );
            token = NextTok();

            if( token == T_NUMBER )
            {
                footprint->SetOrientation( parseDouble() * 10.0 );
                NeedRIGHT();
            }
            else if( token != T_RIGHT )
            {
                Expecting( T_RIGHT );
            }

            break;

        case T_descr:
            NeedSYMBOLorNUMBER(); // some symbols can be 0508, so a number is also a symbol here
            footprint->SetDescription( FromUTF8() );
            NeedRIGHT();
            break;

        case T_tags:
            NeedSYMBOLorNUMBER(); // some symbols can be 0508, so a number is also a symbol here
            footprint->SetKeywords( FromUTF8() );
            NeedRIGHT();
            break;

        case T_property:
            properties.insert( parseProperty() );
            break;

        case T_path:
            NeedSYMBOLorNUMBER(); // Paths can be numerical so a number is also a symbol here
            footprint->SetPath( KIID_PATH( FromUTF8() ) );
            NeedRIGHT();
            break;

        case T_autoplace_cost90:
            footprint->SetPlacementCost90( parseInt( "auto place cost at 90 degrees" ) );
            NeedRIGHT();
            break;

        case T_autoplace_cost180:
            footprint->SetPlacementCost180( parseInt( "auto place cost at 180 degrees" ) );
            NeedRIGHT();
            break;

        case T_solder_mask_margin:
            footprint->SetLocalSolderMaskMargin( parseBoardUnits( "local solder mask margin value" ) );
            NeedRIGHT();
            break;

        case T_solder_paste_margin:
            footprint->SetLocalSolderPasteMargin(
                    parseBoardUnits( "local solder paste margin value" ) );
            NeedRIGHT();
            break;

        case T_solder_paste_ratio:
            footprint->SetLocalSolderPasteMarginRatio(
                    parseDouble( "local solder paste margin ratio value" ) );
            NeedRIGHT();
            break;

        case T_clearance:
            footprint->SetLocalClearance( parseBoardUnits( "local clearance value" ) );
            NeedRIGHT();
            break;

        case T_zone_connect:
            footprint->SetZoneConnection((ZONE_CONNECTION) parseInt( "zone connection value" ) );
            NeedRIGHT();
            break;

        case T_thermal_width:
            footprint->SetThermalWidth( parseBoardUnits( "thermal width value" ) );
            NeedRIGHT();
            break;

        case T_thermal_gap:
            footprint->SetThermalGap( parseBoardUnits( "thermal gap value" ) );
            NeedRIGHT();
            break;

        case T_attr:
            for( token = NextTok(); token != T_RIGHT; token = NextTok() )
            {
                switch( token )
                {
                case T_virtual:     // legacy token prior to version 20200826
                    attributes |= FP_EXCLUDE_FROM_POS_FILES | FP_EXCLUDE_FROM_BOM;
                    break;

                case T_through_hole:
                    attributes |= FP_THROUGH_HOLE;
                    break;

                case T_smd:
                    attributes |= FP_SMD;
                    break;

                case T_board_only:
                    attributes |= FP_BOARD_ONLY;
                    break;

                case T_exclude_from_pos_files:
                    attributes |= FP_EXCLUDE_FROM_POS_FILES;
                    break;

                case T_exclude_from_bom:
                    attributes |= FP_EXCLUDE_FROM_BOM;
                    break;

                default:
                    Expecting( "through_hole, smd, virtual, board_only, exclude_from_pos_files "
                               "or exclude_from_bom" );
                }
            }
            break;

        case T_fp_text:
        {
            FP_TEXT* text = parseFP_TEXT();
            text->SetParent( footprint.get() );
            double orientation = text->GetTextAngle();
            orientation -= footprint->GetOrientation();
            text->SetTextAngle( orientation );
            text->SetDrawCoord();

            switch( text->GetType() )
            {
            case FP_TEXT::TEXT_is_REFERENCE:
                footprint->Reference() = *text;
                const_cast<KIID&>( footprint->Reference().m_Uuid ) = text->m_Uuid;
                delete text;
                break;

            case FP_TEXT::TEXT_is_VALUE:
                footprint->Value() = *text;
                const_cast<KIID&>( footprint->Value().m_Uuid ) = text->m_Uuid;
                delete text;
                break;

            default:
                footprint->Add( text, ADD_MODE::APPEND );
            }
        }
            break;

        case T_fp_arc:
        {
            FP_SHAPE* shape = parseFP_SHAPE();

            // Drop 0 and NaN angles as these can corrupt/crash the schematic
            if( std::isnormal( shape->GetAngle() ) )
            {
                shape->SetParent( footprint.get() );
                shape->SetDrawCoord();
                footprint->Add( shape, ADD_MODE::APPEND );
            }
            else
                delete shape;
        }
            break;

        case T_fp_circle:
        case T_fp_curve:
        case T_fp_rect:
        case T_fp_line:
        case T_fp_poly:
        {
            FP_SHAPE* shape = parseFP_SHAPE();
            shape->SetParent( footprint.get() );
            shape->SetDrawCoord();
            footprint->Add( shape, ADD_MODE::APPEND );
        }
            break;

        case T_pad:
        {
            PAD* pad = parsePAD( footprint.get() );
            pt       = pad->GetPos0();

            RotatePoint( &pt, footprint->GetOrientation() );
            pad->SetPosition( pt + footprint->GetPosition() );
            footprint->Add( pad, ADD_MODE::APPEND );
        }
            break;

        case T_model:
        {
            FP_3DMODEL* model = parse3DModel();
            footprint->Add3DModel( model );
            delete model;
        }
            break;

        case T_zone:
        {
            ZONE* zone = parseZONE( footprint.get() );
            footprint->Add( zone, ADD_MODE::APPEND );
        }
            break;

        case T_group:
            parseGROUP( footprint.get() );
            break;

        default:
            Expecting( "locked, placed, tedit, tstamp, at, descr, tags, path, "
                       "autoplace_cost90, autoplace_cost180, solder_mask_margin, "
                       "solder_paste_margin, solder_paste_ratio, clearance, "
                       "zone_connect, thermal_width, thermal_gap, attr, fp_text, "
                       "fp_arc, fp_circle, fp_curve, fp_line, fp_poly, fp_rect, pad, "
                       "zone, group, generator, version or model" );
        }
    }

    // In legacy files the lack of attributes indicated a through-hole component which was by
    // default excluded from pos files.  However there was a hack to look for SMD pads and
    // consider those "mislabeled through-hole components" and therefore include them in place
    // files.  We probably don't want to get into that game so we'll just include them by
    // default and let the user change it if required.
    if( m_requiredVersion < 20200826 && attributes == 0 )
        attributes |= FP_THROUGH_HOLE;

    // Legacy files controlled pad locking at the footprint level.
    if( m_requiredVersion < 20210108 )
    {
        for( PAD* pad : footprint->Pads() )
            pad->SetLocked( footprint->IsLocked() || footprint->LegacyPadsLocked() );
    }

    footprint->SetAttributes( attributes );

    footprint->SetFPID( fpid );
    footprint->SetProperties( properties );

    return footprint.release();
}

References _, APPEND, B_Cu, F_Cu, FP_BOARD_ONLY, FP_EXCLUDE_FROM_BOM, FP_EXCLUDE_FROM_POS_FILES, FP_SMD, FP_THROUGH_HOLE, PCB_SHAPE::GetAngle(), PAD::GetPos0(), EDA_TEXT::GetTextAngle(), FP_TEXT::GetType(), EDA_ITEM::m_Uuid, name, NULL, LIB_ID::Parse(), parseDouble(), parseHex(), parseInt(), RotatePoint(), FP_SHAPE::SetDrawCoord(), FP_TEXT::SetDrawCoord(), EDA_ITEM::SetParent(), PAD::SetPosition(), FP_TEXT::SetTextAngle(), SEXPR_BOARD_FILE_VERSION, FP_TEXT::TEXT_is_REFERENCE, FP_TEXT::TEXT_is_VALUE, and THROW_IO_ERROR.

parseFP_SHAPE()

FP_SHAPE * PCB_PARSER::parseFP_SHAPE ( )

private

We continue to parse the status field but it is no longer written

Definition at line 3316 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_fp_arc || CurTok() == T_fp_circle || CurTok() == T_fp_curve ||
                 CurTok() == T_fp_rect || CurTok() == T_fp_line || CurTok() == T_fp_poly, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as FP_SHAPE." ) );

    wxPoint pt;
    T token;

    std::unique_ptr<FP_SHAPE> shape = std::make_unique<FP_SHAPE>( nullptr );

    switch( CurTok() )
    {
    case T_fp_arc:
        shape->SetShape( S_ARC );
        NeedLEFT();
        token = NextTok();

        // the start keyword actually gives the arc center
        // Allows also T_center for future change
        if( token != T_start && token != T_center )
            Expecting( T_start );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetStart0( pt );
        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_end )    // end keyword actually gives the starting point of the arc
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetEnd0( pt );
        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_angle )
            Expecting( T_angle );

        // Setting angle will set m_ThirdPoint0, so must be done after setting
        // m_Start0 and m_End0
        shape->SetAngle( parseDouble( "segment angle" ) * 10.0 );
        NeedRIGHT();
        break;

    case T_fp_circle:
        shape->SetShape( S_CIRCLE );
        NeedLEFT();
        token = NextTok();

        if( token != T_center )
            Expecting( T_center );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetStart0( pt );
        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_end )
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetEnd0( pt );
        NeedRIGHT();
        break;

    case T_fp_curve:
        shape->SetShape( S_CURVE );
        NeedLEFT();
        token = NextTok();

        if( token != T_pts )
            Expecting( T_pts );

        shape->SetStart0( parseXY() );
        shape->SetBezier0_C1( parseXY() );
        shape->SetBezier0_C2( parseXY() );
        shape->SetEnd0( parseXY() );
        NeedRIGHT();
        break;

    case T_fp_rect:
        shape->SetShape( S_RECT );
        NeedLEFT();
        token = NextTok();

        if( token != T_start )
            Expecting( T_start );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetStart0( pt );

        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_end )
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetEnd0( pt );
        NeedRIGHT();
        break;

    case T_fp_line:
        // Default PCB_SHAPE type is S_SEGMENT.
        NeedLEFT();
        token = NextTok();

        if( token != T_start )
            Expecting( T_start );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetStart0( pt );

        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_end )
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetEnd0( pt );
        NeedRIGHT();
        break;

    case T_fp_poly:
    {
        shape->SetShape( S_POLYGON );
        NeedLEFT();
        token = NextTok();

        if( token != T_pts )
            Expecting( T_pts );

        std::vector< wxPoint > pts;

        while( (token = NextTok() ) != T_RIGHT )
            pts.push_back( parseXY() );

        shape->SetPolyPoints( pts );
    }
        break;

    default:
        Expecting( "fp_arc, fp_circle, fp_curve, fp_line, fp_poly, or fp_rect" );
    }

    bool foundFill = false;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_layer:
            shape->SetLayer( parseBoardItemLayer() );
            NeedRIGHT();
            break;

        case T_width:
            shape->SetWidth( parseBoardUnits( T_width ) );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( shape->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        case T_fill:
            foundFill = true;

            for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
            {
                if( token == T_LEFT )
                    token = NextTok();

                switch( token )
                {
                // T_yes was used to indicate filling when first introduced,
                // so treat it like a solid fill since that was the only fill available
                case T_yes:
                case T_solid:
                    shape->SetFilled( true );
                    break;

                case T_none:
                    shape->SetFilled( false );
                    break;

                default:
                    Expecting( "yes, none, solid" );
                }
            }

            break;

        case T_status:
            shape->SetStatus( static_cast<STATUS_FLAGS>( parseHex() ) );
            NeedRIGHT();
            break;

        case T_locked:
            shape->SetLocked( true );
            NeedRIGHT();
            break;

        default:
            Expecting( "layer, width, fill, tstamp, locked, or status" );
        }
    }

    if( !foundFill )
    {
        // Legacy versions didn't have a filled flag but allowed some shapes to indicate they
        // should be filled by specifying a 0 stroke-width.
        if( shape->GetWidth() == 0
                && ( shape->GetShape() == S_RECT || shape->GetShape() == S_CIRCLE ) )
        {
            shape->SetFilled( true );
        }
        // Polygons on non-Edge_Cuts layers were always filled
        else if( shape->GetShape() == S_POLYGON && shape->GetLayer() != Edge_Cuts )
        {
            shape->SetFilled( true );
        }
    }

    // Only filled shapes may have a zero line-width.  This is not permitted in KiCad but some
    // external tools can generate invalid files.
    if( shape->GetWidth() <= 0 && !shape->IsFilled() )
    {
        shape->SetWidth( Millimeter2iu( DEFAULT_LINE_WIDTH ) );
    }

    return shape.release();
}

References DEFAULT_LINE_WIDTH, Edge_Cuts, Millimeter2iu(), NULL, parseDouble(), parseHex(), S_ARC, S_CIRCLE, S_CURVE, S_POLYGON, and S_RECT.

parseFP_TEXT()

FP_TEXT * PCB_PARSER::parseFP_TEXT ( )

private

Definition at line 3215 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_fp_text, NULL,
                 wxString::Format( wxT( "Cannot parse %s as FP_TEXT at line %d, offset %d." ),
                                   GetTokenString( CurTok() ),
                                   CurLineNumber(), CurOffset() ) );

    T token = NextTok();

    std::unique_ptr<FP_TEXT> text = std::make_unique<FP_TEXT>( nullptr );

    switch( token )
    {
    case T_reference:
        text->SetType( FP_TEXT::TEXT_is_REFERENCE );
        break;

    case T_value:
        text->SetType( FP_TEXT::TEXT_is_VALUE );
        break;

    case T_user:
        break;          // Default type is user text.

    default:
        THROW_IO_ERROR(
                wxString::Format( _( "Cannot handle footprint text type %s" ), FromUTF8() ) );
    }

    NeedSYMBOLorNUMBER();

    wxString value = FromUTF8();
    value.Replace( "%V", "${VALUE}" );
    value.Replace( "%R", "${REFERENCE}" );
    text->SetText( value );
    NeedLEFT();
    token = NextTok();

    if( token != T_at )
        Expecting( T_at );

    wxPoint pt;

    pt.x = parseBoardUnits( "X coordinate" );
    pt.y = parseBoardUnits( "Y coordinate" );
    text->SetPos0( pt );

    NextTok();

    if( CurTok() == T_NUMBER )
    {
        text->SetTextAngle( parseDouble() * 10.0 );
        NextTok();
    }

    if( CurTok() == T_unlocked )
    {
        text->SetKeepUpright( false );
        NextTok();
    }

    if( CurTok() != T_RIGHT )
    {
        Unexpected( CurText() );
    }

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_layer:
            text->SetLayer( parseBoardItemLayer() );
            NeedRIGHT();
            break;

        case T_hide:
            text->SetVisible( false );
            break;

        case T_effects:
            parseEDA_TEXT( (EDA_TEXT*) text.get() );
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( text->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        default:
            Expecting( "layer, hide, effects or tstamp" );
        }
    }

    return text.release();
}

References _, Format(), NULL, parseDouble(), FP_TEXT::TEXT_is_REFERENCE, FP_TEXT::TEXT_is_VALUE, and THROW_IO_ERROR.

parseGeneralSection()

void PCB_PARSER::parseGeneralSection ( )

private

Definition at line 890 of file pcb_parser.cpp.

{
     wxCHECK_RET( CurTok() == T_general,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
                 wxT( " as a general section." ) );

    T token;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_thickness:
            m_board->GetDesignSettings().SetBoardThickness( parseBoardUnits( T_thickness ) );
            NeedRIGHT();
            break;

        default:              // Skip everything but the board thickness.
            while( ( token = NextTok() ) != T_RIGHT )
            {
                if( !IsSymbol( token ) && token != T_NUMBER )
                    Expecting( "symbol or number" );
            }
        }
    }
}

parseGROUP()

void PCB_PARSER::parseGROUP ( BOARD_ITEM *  aParent )

private

Definition at line 4126 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_group,
            wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as PCB_GROUP." ) );

    wxPoint pt;
    T       token;

    m_groupInfos.push_back( GROUP_INFO() );
    GROUP_INFO& groupInfo = m_groupInfos.back();
    groupInfo.parent = aParent;

    token = NextTok();

    if( token != T_LEFT )
    {
        // Optional group name present.

        if( !IsSymbol( token ) )
            Expecting( DSN_SYMBOL );

        groupInfo.name = FromUTF8();
    }

    NeedLEFT();
    token = NextTok();

    if( token != T_id )
    {
        Expecting( T_id );
    }

    NextTok();
    groupInfo.uuid = CurStrToKIID();
    NeedRIGHT();

    NeedLEFT();
    token = NextTok();

    if( token != T_members )
    {
        Expecting( T_members );
    }

    while( ( token = NextTok() ) != T_RIGHT )
    {
        // This token is the Uuid of the item in the group.
        // Since groups are serialized at the end of the file/footprint, the Uuid should already
        // have been seen and exist in the board.
        KIID uuid( CurStr() );
        groupInfo.memberUuids.push_back( uuid );
    }

    NeedRIGHT();
}

References DSN_SYMBOL, PCB_PARSER::GROUP_INFO::memberUuids, PCB_PARSER::GROUP_INFO::name, PCB_PARSER::GROUP_INFO::parent, and PCB_PARSER::GROUP_INFO::uuid.

parseHeader()

void PCB_PARSER::parseHeader ( )

private

Definition at line 849 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_kicad_pcb,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a header." ) );

    NeedLEFT();

    T tok = NextTok();

    if( tok == T_version )
    {
        m_requiredVersion = parseInt( FromUTF8().mb_str( wxConvUTF8 ) );
        m_tooRecent = ( m_requiredVersion > SEXPR_BOARD_FILE_VERSION );
        NeedRIGHT();

        NeedLEFT();
        NeedSYMBOL();
        NeedSYMBOL();

        // Older formats included build data
        if( m_requiredVersion < BOARD_FILE_HOST_VERSION )
            NeedSYMBOL();

        NeedRIGHT();
    }
    else
    {
        m_requiredVersion = 20201115;   // Last version before we started writing version #s
                                        // in footprint files as well as board files.
        m_tooRecent = ( m_requiredVersion > SEXPR_BOARD_FILE_VERSION );

        // Skip the host name and host build version information.
        NeedSYMBOL();
        NeedSYMBOL();
        NeedRIGHT();
    }

    m_board->SetFileFormatVersionAtLoad( m_requiredVersion );
}

References BOARD_FILE_HOST_VERSION, parseInt(), and SEXPR_BOARD_FILE_VERSION.

parseHex()

long PCB_PARSER::parseHex ( )

inlineprivate

Definition at line 335 of file pcb_parser.h.

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

References NULL.

parseInt() [1/2]

int PCB_PARSER::parseInt ( )

inlineprivate

Definition at line 324 of file pcb_parser.h.

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

References NULL.

Referenced by parseInt().

parseInt() [2/2]

int PCB_PARSER::parseInt ( const char *  aExpected )

inlineprivate

Definition at line 329 of file pcb_parser.h.

    {
        NeedNUMBER( aExpected );
        return parseInt();
    }

References parseInt().

parseLayer()

void PCB_PARSER::parseLayer ( LAYER *  aLayer )

private

Definition at line 1087 of file pcb_parser.cpp.

{
    T           token;

    std::string name;
    std::string userName;
    std::string type;
    bool        isVisible = true;

    aLayer->clear();

    if( CurTok() != T_LEFT )
        Expecting( T_LEFT );

    // this layer_num is not used, we DO depend on LAYER_T however.
    LAYER_NUM layer_num = parseInt( "layer index" );

    NeedSYMBOLorNUMBER();
    name = CurText();

    NeedSYMBOL();
    type = CurText();

    token = NextTok();

    // @todo Figure out why we are looking for a hide token in the layer definition.
    if( token == T_hide )
    {
        isVisible = false;
        NeedRIGHT();
    }
    else if( token == T_STRING )
    {
        userName = CurText();
        NeedRIGHT();
    }
    else if( token != T_RIGHT )
    {
        Expecting( "hide, user defined name, or )" );
    }

    aLayer->m_name    = FROM_UTF8( name.c_str() );
    aLayer->m_type    = LAYER::ParseType( type.c_str() );
    aLayer->m_number  = layer_num;
    aLayer->m_visible = isVisible;

    if( !userName.empty() )
        aLayer->m_userName = FROM_UTF8( userName.c_str() );

    // The canonical name will get reset back to the default for copper layer on the next
    // save.  The user defined name is now a separate optional layer token from the canonical
    // name.
    if( aLayer->m_name != LSET::Name( static_cast<PCB_LAYER_ID>( aLayer->m_number ) ) )
        aLayer->m_userName = aLayer->m_name;
}

References LAYER::clear(), FROM_UTF8(), LAYER::m_name, LAYER::m_number, LAYER::m_type, LAYER::m_userName, LAYER::m_visible, name, LSET::Name(), parseInt(), and LAYER::ParseType().

parseLayers()

void PCB_PARSER::parseLayers ( )

private

Definition at line 1390 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_layers,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as layers." ) );

    T       token;
    LSET    visibleLayers;
    LSET    enabledLayers;
    int     copperLayerCount = 0;
    LAYER   layer;
    bool    anyHidden = false;

    std::unordered_map< std::string, std::string > v3_layer_names;
    std::vector<LAYER>  cu;

    createOldLayerMapping( v3_layer_names );

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        parseLayer( &layer );

        if( layer.m_type == LT_UNDEFINED )     // it's a non-copper layer
            break;

        cu.push_back( layer );      // it's copper
    }

    // All Cu layers are parsed, but not the non-cu layers here.

    // The original *.kicad_pcb file format and the inverted
    // Cu stack format both have all the Cu layers first, so use this
    // trick to handle either. The layer number in the (layers ..)
    // s-expression element are ignored.
    if( cu.size() )
    {
        // Rework the layer numbers, which changed when the Cu stack
        // was flipped.  So we instead use position in the list.
        cu[cu.size()-1].m_number = B_Cu;

        for( unsigned i=0; i < cu.size()-1; ++i )
        {
            cu[i].m_number = i;
        }

        for( std::vector<LAYER>::const_iterator it = cu.begin(); it<cu.end();  ++it )
        {
            enabledLayers.set( it->m_number );

            if( it->m_visible )
                visibleLayers.set( it->m_number );
            else
                anyHidden = true;

            m_board->SetLayerDescr( PCB_LAYER_ID( it->m_number ), *it );

            UTF8 name = it->m_name;

            m_layerIndices[ name ] = PCB_LAYER_ID( it->m_number );
            m_layerMasks[   name ] = LSET( PCB_LAYER_ID( it->m_number ) );
        }

        copperLayerCount = cu.size();
    }

    // process non-copper layers
    while( token != T_RIGHT )
    {
        LAYER_ID_MAP::const_iterator it = m_layerIndices.find( UTF8( layer.m_name ) );

        if( it == m_layerIndices.end() )
        {
            auto new_layer_it = v3_layer_names.find( layer.m_name.ToStdString() );

            if( new_layer_it != v3_layer_names.end() )
                it = m_layerIndices.find( new_layer_it->second );

            if( it == m_layerIndices.end() )
            {
                wxString error = wxString::Format(
                    _( "Layer \"%s\" in file \"%s\" at line %d, is not in fixed layer hash" ),
                    layer.m_name,
                    CurSource(),
                    CurLineNumber(),
                    CurOffset()
                    );

                THROW_IO_ERROR( error );
            }

            // If we are here, then we have found a translated layer name.  Put it in the maps so that
            // items on this layer get the appropriate layer ID number
            m_layerIndices[ UTF8( layer.m_name ) ] = it->second;
            m_layerMasks[   UTF8( layer.m_name ) ] = it->second;
            layer.m_name = it->first;
        }

        layer.m_number = it->second;
        enabledLayers.set( layer.m_number );

        if( layer.m_visible )
            visibleLayers.set( layer.m_number );
        else
            anyHidden = true;

        m_board->SetLayerDescr( it->second, layer );

        token = NextTok();

        if( token != T_LEFT )
            break;

        parseLayer( &layer );
    }

    // We need at least 2 copper layers and there must be an even number of them.
    if( copperLayerCount < 2 || (copperLayerCount % 2) != 0 )
    {
        wxString err = wxString::Format(
            _( "%d is not a valid layer count" ), copperLayerCount );

        THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
    }

    m_board->SetCopperLayerCount( copperLayerCount );
    m_board->SetEnabledLayers( enabledLayers );

    // Only set this if any layers were explicitly marked as hidden.  Otherwise, we want to leave
    // this alone; default visibility will show everything
    if( anyHidden )
        m_board->m_LegacyVisibleLayers = visibleLayers;
}

References _, B_Cu, Format(), LT_UNDEFINED, LAYER::m_name, LAYER::m_number, LAYER::m_type, LAYER::m_visible, name, THROW_IO_ERROR, and THROW_PARSE_ERROR.

parseNETCLASS()

void PCB_PARSER::parseNETCLASS ( )

private

Definition at line 2061 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_net_class,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as net class." ) );

    T token;

    NETCLASSPTR nc = std::make_shared<NETCLASS>( wxEmptyString );

    // Read netclass name (can be a name or just a number like track width)
    NeedSYMBOLorNUMBER();
    nc->SetName( FromUTF8() );
    NeedSYMBOL();
    nc->SetDescription( FromUTF8() );

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_clearance:
            nc->SetClearance( parseBoardUnits( T_clearance ) );
            break;

        case T_trace_width:
            nc->SetTrackWidth( parseBoardUnits( T_trace_width ) );
            break;

        case T_via_dia:
            nc->SetViaDiameter( parseBoardUnits( T_via_dia ) );
            break;

        case T_via_drill:
            nc->SetViaDrill( parseBoardUnits( T_via_drill ) );
            break;

        case T_uvia_dia:
            nc->SetuViaDiameter( parseBoardUnits( T_uvia_dia ) );
            break;

        case T_uvia_drill:
            nc->SetuViaDrill( parseBoardUnits( T_uvia_drill ) );
            break;

        case T_diff_pair_width:
            nc->SetDiffPairWidth( parseBoardUnits( T_diff_pair_width ) );
            break;

        case T_diff_pair_gap:
            nc->SetDiffPairGap( parseBoardUnits( T_diff_pair_gap ) );
            break;

        case T_add_net:
            NeedSYMBOLorNUMBER();
            nc->Add( FromUTF8() );
            break;

        default:
            Expecting( "clearance, trace_width, via_dia, via_drill, uvia_dia, uvia_drill, "
                       "diff_pair_width, diff_pair_gap or add_net" );
        }

        NeedRIGHT();
    }

    if( !m_board->GetDesignSettings().GetNetClasses().Add( nc ) )
    {
        // Must have been a name conflict, this is a bad board file.
        // User may have done a hand edit to the file.

        // unique_ptr will delete nc on this code path

        wxString error;
        error.Printf( _( "Duplicate NETCLASS name \"%s\" in file \"%s\" at line %d, offset %d" ),
                      nc->GetName().GetData(), CurSource().GetData(), CurLineNumber(), CurOffset() );
        THROW_IO_ERROR( error );
    }
}

References _, and THROW_IO_ERROR.

parseNETINFO_ITEM()

void PCB_PARSER::parseNETINFO_ITEM ( )

private

Definition at line 2035 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_net,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as net." ) );

    int netCode = parseInt( "net number" );

    NeedSYMBOLorNUMBER();
    wxString name = FromUTF8();

    NeedRIGHT();

    // net 0 should be already in list, so store this net
    // if it is not the net 0, or if the net 0 does not exists.
    // (TODO: a better test.)
    if( netCode > NETINFO_LIST::UNCONNECTED || !m_board->FindNet( NETINFO_LIST::UNCONNECTED ) )
    {
        NETINFO_ITEM* net = new NETINFO_ITEM( m_board, name, netCode );
        m_board->Add( net );

        // Store the new code mapping
        pushValueIntoMap( netCode, net->GetNetCode() );
    }
}

References NETINFO_ITEM::GetNetCode(), name, parseInt(), and NETINFO_LIST::UNCONNECTED.

parsePAD()

PAD * PCB_PARSER::parsePAD ( FOOTPRINT *  aParent = NULL )

private

Definition at line 3574 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_pad, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as PAD." ) );

    wxSize  sz;
    wxPoint pt;

    std::unique_ptr<PAD> pad = std::make_unique<PAD>( aParent );

    // File only contains a token if KeepTopBottom is true
    pad->SetKeepTopBottom( false );

    NeedSYMBOLorNUMBER();
    pad->SetName( FromUTF8() );

    T token = NextTok();

    switch( token )
    {
    case T_thru_hole:
        pad->SetAttribute( PAD_ATTRIB_PTH );
        break;

    case T_smd:
        pad->SetAttribute( PAD_ATTRIB_SMD );

        // Default PAD object is thru hole with drill.
        // SMD pads have no hole
        pad->SetDrillSize( wxSize( 0, 0 ) );
        break;

    case T_connect:
        pad->SetAttribute( PAD_ATTRIB_CONN );

        // Default PAD object is thru hole with drill.
        // CONN pads have no hole
        pad->SetDrillSize( wxSize( 0, 0 ) );
        break;

    case T_np_thru_hole:
        pad->SetAttribute( PAD_ATTRIB_NPTH );
        break;

    default:
        Expecting( "thru_hole, smd, connect, or np_thru_hole" );
    }

    token = NextTok();

    switch( token )
    {
    case T_circle:
        pad->SetShape( PAD_SHAPE_CIRCLE );
        break;

    case T_rect:
        pad->SetShape( PAD_SHAPE_RECT );
        break;

    case T_oval:
        pad->SetShape( PAD_SHAPE_OVAL );
        break;

    case T_trapezoid:
        pad->SetShape( PAD_SHAPE_TRAPEZOID );
        break;

    case T_roundrect:
        // Note: the shape can be PAD_SHAPE_ROUNDRECT or PAD_SHAPE_CHAMFERED_RECT
        // (if chamfer parameters are found later in pad descr.)
        pad->SetShape( PAD_SHAPE_ROUNDRECT );
        break;

    case T_custom:
        pad->SetShape( PAD_SHAPE_CUSTOM );
        break;

    default:
        Expecting( "circle, rectangle, roundrect, oval, trapezoid or custom" );
    }

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_size:
            sz.SetWidth( parseBoardUnits( "width value" ) );
            sz.SetHeight( parseBoardUnits( "height value" ) );
            pad->SetSize( sz );
            NeedRIGHT();
            break;

        case T_at:
            pt.x = parseBoardUnits( "X coordinate" );
            pt.y = parseBoardUnits( "Y coordinate" );
            pad->SetPos0( pt );
            token = NextTok();

            if( token == T_NUMBER )
            {
                pad->SetOrientation( parseDouble() * 10.0 );
                NeedRIGHT();
            }
            else if( token != T_RIGHT )
            {
                Expecting( ") or angle value" );
            }

            break;

        case T_rect_delta:
            {
                wxSize delta;
                delta.SetWidth( parseBoardUnits( "rectangle delta width" ) );
                delta.SetHeight( parseBoardUnits( "rectangle delta height" ) );
                pad->SetDelta( delta );
                NeedRIGHT();
            }
            break;

        case T_drill:
            {
                bool    haveWidth = false;
                wxSize  drillSize = pad->GetDrillSize();

                for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
                {
                    if( token == T_LEFT )
                        token = NextTok();

                    switch( token )
                    {
                    case T_oval:
                        pad->SetDrillShape( PAD_DRILL_SHAPE_OBLONG );
                        break;

                    case T_NUMBER:
                        {
                            if( !haveWidth )
                            {
                                drillSize.SetWidth( parseBoardUnits() );

                                // If height is not defined the width and height are the same.
                                drillSize.SetHeight( drillSize.GetWidth() );
                                haveWidth = true;
                            }
                            else
                            {
                                drillSize.SetHeight( parseBoardUnits() );
                            }

                        }
                        break;

                    case T_offset:
                        pt.x = parseBoardUnits( "drill offset x" );
                        pt.y = parseBoardUnits( "drill offset y" );
                        pad->SetOffset( pt );
                        NeedRIGHT();
                        break;

                    default:
                        Expecting( "oval, size, or offset" );
                    }
                }

                // This fixes a bug caused by setting the default PAD drill size to a value other
                // than 0 used to fix a bunch of debug assertions even though it is defined as a
                // through hole pad.  Wouldn't a though hole pad with no drill be a surface mount
                // pad (or a conn pad which is a smd pad with no solder paste)?
                if( ( pad->GetAttribute() != PAD_ATTRIB_SMD ) && ( pad->GetAttribute() != PAD_ATTRIB_CONN ) )
                    pad->SetDrillSize( drillSize );
                else
                    pad->SetDrillSize( wxSize( 0, 0 ) );

            }
            break;

        case T_layers:
            {
                LSET layerMask = parseBoardItemLayersAsMask();
                pad->SetLayerSet( layerMask );
            }
            break;

        case T_net:
            if( ! pad->SetNetCode( getNetCode( parseInt( "net number" ) ), /* aNoAssert */ true ) )
            {
                wxLogError( wxString::Format( _( "Invalid net ID in\n"
                                                 "file: '%s'\n"
                                                 "line: %d\n"
                                                 "offset: %d" ),
                                              CurSource(),
                                              CurLineNumber(),
                                              CurOffset() ) );
            }

            NeedSYMBOLorNUMBER();

            // Test validity of the netname in file for netcodes expected having a net name
            if( m_board && pad->GetNetCode() > 0 &&
                FromUTF8() != m_board->FindNet( pad->GetNetCode() )->GetNetname() )
            {
                pad->SetNetCode( NETINFO_LIST::ORPHANED, /* aNoAssert */ true );
                wxLogError( wxString::Format( _( "Net name doesn't match net ID in\n"
                                                 "file: '%s'\n"
                                                 "line: %d\n"
                                                 "offset: %d" ),
                                              CurSource(),
                                              CurLineNumber(),
                                              CurOffset() ) );
            }

            NeedRIGHT();
            break;

        case T_pinfunction:
            NeedSYMBOLorNUMBER();
            pad->SetPinFunction( FromUTF8() );
            NeedRIGHT();
            break;

        case T_pintype:
            NeedSYMBOLorNUMBER();
            pad->SetPinType( FromUTF8() );
            NeedRIGHT();
            break;

        case T_die_length:
            pad->SetPadToDieLength( parseBoardUnits( T_die_length ) );
            NeedRIGHT();
            break;

        case T_solder_mask_margin:
            pad->SetLocalSolderMaskMargin( parseBoardUnits( T_solder_mask_margin ) );
            NeedRIGHT();
            break;

        case T_solder_paste_margin:
            pad->SetLocalSolderPasteMargin( parseBoardUnits( T_solder_paste_margin ) );
            NeedRIGHT();
            break;

        case T_solder_paste_margin_ratio:
            pad->SetLocalSolderPasteMarginRatio(
                parseDouble( "pad local solder paste margin ratio value" ) );
            NeedRIGHT();
            break;

        case T_clearance:
            pad->SetLocalClearance( parseBoardUnits( "local clearance value" ) );
            NeedRIGHT();
            break;

        case T_zone_connect:
            pad->SetZoneConnection( (ZONE_CONNECTION) parseInt( "zone connection value" ) );
            NeedRIGHT();
            break;

        case T_thermal_width:
            pad->SetThermalSpokeWidth( parseBoardUnits( T_thermal_width ) );
            NeedRIGHT();
            break;

        case T_thermal_gap:
            pad->SetThermalGap( parseBoardUnits( T_thermal_gap ) );
            NeedRIGHT();
            break;

        case T_roundrect_rratio:
            pad->SetRoundRectRadiusRatio( parseDouble( "roundrect radius ratio" ) );
            NeedRIGHT();
            break;

        case T_chamfer_ratio:
            pad->SetChamferRectRatio( parseDouble( "chamfer ratio" ) );

            if( pad->GetChamferRectRatio() > 0 )
                pad->SetShape( PAD_SHAPE_CHAMFERED_RECT );

            NeedRIGHT();
            break;

        case T_chamfer:
        {
            int chamfers = 0;
            bool end_list = false;

            while( !end_list )
            {
                token = NextTok();
                switch( token )
                {
                case T_top_left:
                    chamfers |= RECT_CHAMFER_TOP_LEFT;
                    break;

                case T_top_right:
                    chamfers |= RECT_CHAMFER_TOP_RIGHT;
                    break;

                case T_bottom_left:
                    chamfers |= RECT_CHAMFER_BOTTOM_LEFT;
                    break;

                case T_bottom_right:
                    chamfers |= RECT_CHAMFER_BOTTOM_RIGHT;
                    break;

                case T_RIGHT:
                    pad->SetChamferPositions( chamfers );
                    end_list = true;
                    break;

                default:
                    Expecting( "chamfer_top_left chamfer_top_right chamfer_bottom_left or chamfer_bottom_right" );
                }
            }

            if( pad->GetChamferPositions() != RECT_NO_CHAMFER )
                pad->SetShape( PAD_SHAPE_CHAMFERED_RECT );
        }
            break;

        case T_property:
        {
            while( token != T_RIGHT )
            {
                token = NextTok();

                switch( token )
                {
                case T_pad_prop_bga:
                    pad->SetProperty( PAD_PROP_BGA );
                    break;

                case T_pad_prop_fiducial_glob:
                    pad->SetProperty( PAD_PROP_FIDUCIAL_GLBL );
                    break;

                case T_pad_prop_fiducial_loc:
                    pad->SetProperty( PAD_PROP_FIDUCIAL_LOCAL );
                    break;

                case T_pad_prop_testpoint:
                    pad->SetProperty( PAD_PROP_TESTPOINT );
                    break;

                case T_pad_prop_castellated:
                    pad->SetProperty( PAD_PROP_CASTELLATED );
                    break;

                case T_pad_prop_heatsink:
                    pad->SetProperty( PAD_PROP_HEATSINK );
                    break;

                case T_none:
                    pad->SetProperty( PAD_PROP_NONE );
                    break;

                case T_RIGHT:
                    break;

                default:
#if 0   // Currently: skip unknown property
                    Expecting( "pad_prop_bga pad_prop_fiducial_glob pad_prop_fiducial_loc"
                               " pad_prop_heatsink or pad_prop_castellated" );
#endif
                    break;
                }
            }
        }
            break;

        case T_options:
            parsePAD_option( pad.get() );
            break;

        case T_primitives:
            for( token = NextTok(); token != T_RIGHT; token = NextTok() )
            {
                if( token == T_LEFT )
                    token = NextTok();

                // Currently, I am using parsePCB_SHAPE() to read basic shapes parameters,
                // because they are the same as a PCB_SHAPE.
                // However it could be better to write a specific parser, to avoid possible issues
                // if the PCB_SHAPE parser is modified.
                PCB_SHAPE* dummysegm = NULL;

                switch( token )
                {
                case T_gr_arc:
                    dummysegm = parsePCB_SHAPE();
                    pad->AddPrimitiveArc( dummysegm->GetCenter(), dummysegm->GetArcStart(),
                                          dummysegm->GetAngle(), dummysegm->GetWidth() );
                    break;

                case T_gr_line:
                    dummysegm = parsePCB_SHAPE();
                    pad->AddPrimitiveSegment( dummysegm->GetStart(), dummysegm->GetEnd(),
                                              dummysegm->GetWidth() );
                    break;

                case T_gr_circle:
                    dummysegm = parsePCB_SHAPE();
                    pad->AddPrimitiveCircle( dummysegm->GetCenter(), dummysegm->GetRadius(),
                                             dummysegm->GetWidth(), dummysegm->IsFilled() );
                    break;

                case T_gr_rect:
                    dummysegm = parsePCB_SHAPE();
                    pad->AddPrimitiveRect( dummysegm->GetStart(), dummysegm->GetEnd(),
                                           dummysegm->GetWidth(), dummysegm->IsFilled() );
                    break;


                case T_gr_poly:
                    dummysegm = parsePCB_SHAPE();
                    pad->AddPrimitivePoly( dummysegm->BuildPolyPointsList(), dummysegm->GetWidth(),
                                           dummysegm->IsFilled() );
                    break;

                case T_gr_curve:
                    dummysegm = parsePCB_SHAPE();
                    pad->AddPrimitiveCurve( dummysegm->GetStart(), dummysegm->GetEnd(),
                                            dummysegm->GetBezControl1(),
                                            dummysegm->GetBezControl2(), dummysegm->GetWidth() );
                    break;

                default:
                    Expecting( "gr_line, gr_arc, gr_circle, gr_curve, gr_rect or gr_poly" );
                    break;
                }

                delete dummysegm;
            }
            break;

        case T_remove_unused_layers:
            pad->SetRemoveUnconnected( true );
            NeedRIGHT();
            break;

        case T_keep_end_layers:
            pad->SetKeepTopBottom( true );
            NeedRIGHT();
            break;

        case T_locked:
            pad->SetLocked( true );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( pad->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        default:
            Expecting( "at, locked, drill, layers, net, die_length, roundrect_rratio, "
                       "solder_mask_margin, solder_paste_margin, solder_paste_margin_ratio, "
                       "clearance, tstamp, primitives, remove_unused_layers, keep_end_layers, "
                       "pinfunction, pintype, zone_connect, thermal_width, or thermal_gap" );
        }
    }

    return pad.release();
}

References _, PCB_SHAPE::BuildPolyPointsList(), Format(), PCB_SHAPE::GetAngle(), PCB_SHAPE::GetArcStart(), PCB_SHAPE::GetBezControl1(), PCB_SHAPE::GetBezControl2(), PCB_SHAPE::GetCenter(), PCB_SHAPE::GetEnd(), PCB_SHAPE::GetRadius(), PCB_SHAPE::GetStart(), PCB_SHAPE::GetWidth(), PCB_SHAPE::IsFilled(), NULL, NETINFO_LIST::ORPHANED, PAD_ATTRIB_CONN, PAD_ATTRIB_NPTH, PAD_ATTRIB_PTH, PAD_ATTRIB_SMD, PAD_DRILL_SHAPE_OBLONG, PAD_PROP_BGA, PAD_PROP_CASTELLATED, PAD_PROP_FIDUCIAL_GLBL, PAD_PROP_FIDUCIAL_LOCAL, PAD_PROP_HEATSINK, PAD_PROP_NONE, PAD_PROP_TESTPOINT, PAD_SHAPE_CHAMFERED_RECT, PAD_SHAPE_CIRCLE, PAD_SHAPE_CUSTOM, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, PAD_SHAPE_ROUNDRECT, PAD_SHAPE_TRAPEZOID, parseDouble(), parseInt(), RECT_CHAMFER_BOTTOM_LEFT, RECT_CHAMFER_BOTTOM_RIGHT, RECT_CHAMFER_TOP_LEFT, RECT_CHAMFER_TOP_RIGHT, and RECT_NO_CHAMFER.

parsePAD_option()

bool PCB_PARSER::parsePAD_option ( PAD *  aPad )

private

Definition at line 4052 of file pcb_parser.cpp.

{
    // Parse only the (option ...) inside a pad description
    for( T token = NextTok(); token != T_RIGHT; token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_anchor:
            token = NextTok();
            // Custom shaped pads have a "anchor pad", which is the reference
            // for connection calculations.
            // Because this is an anchor, only the 2 very basic shapes are managed:
            // circle and rect. The default is circle
            switch( token )
            {
                case T_circle:  // default
                    break;

                case T_rect:
                    aPad->SetAnchorPadShape( PAD_SHAPE_RECT );
                    break;

                default:
                    // Currently, because pad options is a moving target
                    // just skip unknown keywords
                    break;
            }
            NeedRIGHT();
            break;

        case T_clearance:
            token = NextTok();
            // Custom shaped pads have a clearance area that is the pad shape
            // (like usual pads) or the convex hull of the pad shape.
            switch( token )
            {
            case T_outline:
                aPad->SetCustomShapeInZoneOpt( CUST_PAD_SHAPE_IN_ZONE_OUTLINE );
                break;

            case T_convexhull:
                aPad->SetCustomShapeInZoneOpt( CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL );
                break;

            default:
                // Currently, because pad options is a moving target
                // just skip unknown keywords
                break;
            }
            NeedRIGHT();
            break;

        default:
            // Currently, because pad options is a moving target
            // just skip unknown keywords
            while( (token = NextTok() ) != T_RIGHT )
            {}
            break;
        }
    }

    return true;
}

References CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL, CUST_PAD_SHAPE_IN_ZONE_OUTLINE, PAD_SHAPE_RECT, PAD::SetAnchorPadShape(), and PAD::SetCustomShapeInZoneOpt().

parsePAGE_INFO()

void PCB_PARSER::parsePAGE_INFO ( )

private

Definition at line 923 of file pcb_parser.cpp.

{
    wxCHECK_RET( ( CurTok() == T_page && m_requiredVersion <= 20200119 ) || CurTok() == T_paper,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a PAGE_INFO." ) );

    T token;
    PAGE_INFO pageInfo;

    NeedSYMBOL();

    wxString pageType = FromUTF8();

    if( !pageInfo.SetType( pageType ) )
    {
        wxString err;
        err.Printf( _( "Page type \"%s\" is not valid " ), FromUTF8() );
        THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
    }

    if( pageType == PAGE_INFO::Custom )
    {
        double width = parseDouble( "width" );      // width in mm

        // Perform some controls to avoid crashes if the size is edited by hands
        if( width < 100.0 )
            width = 100.0;
        else if( width > 1200.0 )
            width = 1200.0;

        double height = parseDouble( "height" );    // height in mm

        if( height < 100.0 )
            height = 100.0;
        else if( height > 1200.0 )
            height = 1200.0;

        pageInfo.SetWidthMils( Mm2mils( width ) );
        pageInfo.SetHeightMils( Mm2mils( height ) );
    }

    token = NextTok();

    if( token == T_portrait )
    {
        pageInfo.SetPortrait( true );
        NeedRIGHT();
    }
    else if( token != T_RIGHT )
    {
        Expecting( "portrait|)" );
    }

    m_board->SetPageSettings( pageInfo );
}

References _, PAGE_INFO::Custom, Mm2mils(), parseDouble(), PAGE_INFO::SetHeightMils(), PAGE_INFO::SetPortrait(), PAGE_INFO::SetType(), PAGE_INFO::SetWidthMils(), and THROW_PARSE_ERROR.

parsePCB_SHAPE()

PCB_SHAPE * PCB_PARSER::parsePCB_SHAPE ( )

private

We continue to parse the status field but it is no longer written

Definition at line 2145 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_gr_arc || CurTok() == T_gr_circle || CurTok() == T_gr_curve ||
                 CurTok() == T_gr_rect || CurTok() == T_gr_line || CurTok() == T_gr_poly, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as PCB_SHAPE." ) );

    T token;
    wxPoint pt;
    std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( nullptr );

    switch( CurTok() )
    {
    case T_gr_arc:
        shape->SetShape( S_ARC );
        NeedLEFT();
        token = NextTok();

        // the start keyword actually gives the arc center
        // Allows also T_center for future change
        if( token != T_start && token != T_center )
            Expecting( T_start );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetCenter( pt );
        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_end )    // the end keyword actually gives the starting point of the arc
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetArcStart( pt );
        NeedRIGHT();
        break;

    case T_gr_circle:
        shape->SetShape( S_CIRCLE );
        NeedLEFT();
        token = NextTok();

        if( token != T_center )
            Expecting( T_center );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetCenter( pt );
        NeedRIGHT();
        NeedLEFT();

        token = NextTok();

        if( token != T_end )
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetEnd( pt );
        NeedRIGHT();
        break;

    case T_gr_curve:
        shape->SetShape( S_CURVE );
        NeedLEFT();
        token = NextTok();

        if( token != T_pts )
            Expecting( T_pts );

        shape->SetStart( parseXY() );
        shape->SetBezControl1( parseXY() );
        shape->SetBezControl2( parseXY() );
        shape->SetEnd( parseXY() );
        NeedRIGHT();
        break;

    case T_gr_rect:
        shape->SetShape( S_RECT );
        NeedLEFT();
        token = NextTok();

        if( token != T_start )
            Expecting( T_start );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetStart( pt );
        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_end )
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetEnd( pt );
        NeedRIGHT();
        break;

    case T_gr_line:
        // Default PCB_SHAPE type is S_SEGMENT.
        NeedLEFT();
        token = NextTok();

        if( token != T_start )
            Expecting( T_start );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetStart( pt );
        NeedRIGHT();
        NeedLEFT();
        token = NextTok();

        if( token != T_end )
            Expecting( T_end );

        pt.x = parseBoardUnits( "X coordinate" );
        pt.y = parseBoardUnits( "Y coordinate" );
        shape->SetEnd( pt );
        NeedRIGHT();
        break;

    case T_gr_poly:
    {
        shape->SetShape( S_POLYGON );
        shape->SetWidth( 0 ); // this is the default value. will be (perhaps) modified later
        NeedLEFT();
        token = NextTok();

        if( token != T_pts )
            Expecting( T_pts );

        std::vector< wxPoint > pts;

        while( (token = NextTok() ) != T_RIGHT )
            pts.push_back( parseXY() );

        shape->SetPolyPoints( pts );
    }
        break;

    default:
        Expecting( "gr_arc, gr_circle, gr_curve, gr_line, gr_poly, or gp_rect" );
    }

    bool foundFill = false;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_angle:
            shape->SetAngle( parseDouble( "segment angle" ) * 10.0 );
            NeedRIGHT();
            break;

        case T_layer:
            shape->SetLayer( parseBoardItemLayer() );
            NeedRIGHT();
            break;

        case T_width:
            shape->SetWidth( parseBoardUnits( T_width ) );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( shape->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        case T_fill:
            foundFill = true;

            for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
            {
                if( token == T_LEFT )
                    token = NextTok();

                switch( token )
                {
                // T_yes was used to indicate filling when first introduced,
                // so treat it like a solid fill since that was the only fill available
                case T_yes:
                case T_solid:
                    shape->SetFilled( true );
                    break;

                case T_none:
                    shape->SetFilled( false );
                    break;

                default:
                    Expecting( "yes, none, solid" );
                }
            }
            break;

        case T_status:
            shape->SetStatus( static_cast<STATUS_FLAGS>( parseHex() ) );
            NeedRIGHT();
            break;

        case T_locked:
            shape->SetLocked( true );
            NeedRIGHT();
            break;

        default:
            Expecting( "layer, width, fill, tstamp, locked or status" );
        }
    }

    if( !foundFill )
    {
        // Legacy versions didn't have a filled flag but allowed some shapes to indicate they
        // should be filled by specifying a 0 stroke-width.
        if( shape->GetWidth() == 0
                && ( shape->GetShape() == S_RECT || shape->GetShape() == S_CIRCLE ) )
        {
            shape->SetFilled( true );
        }
        // Polygons on non-Edge_Cuts layers were always filled
        else if( shape->GetShape() == S_POLYGON && shape->GetLayer() != Edge_Cuts )
        {
            shape->SetFilled( true );
        }
    }

    // Only filled shapes may have a zero line-width.  This is not permitted in KiCad but some
    // external tools can generate invalid files.
    if( shape->GetWidth() <= 0 && !shape->IsFilled() )
    {
        shape->SetWidth( Millimeter2iu( DEFAULT_LINE_WIDTH ) );
    }

    return shape.release();
}

References DEFAULT_LINE_WIDTH, Edge_Cuts, Millimeter2iu(), NULL, parseDouble(), parseHex(), S_ARC, S_CIRCLE, S_CURVE, S_POLYGON, and S_RECT.

parsePCB_TARGET()

PCB_TARGET * PCB_PARSER::parsePCB_TARGET ( )

private

Definition at line 5005 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_target, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as PCB_TARGET." ) );

    wxPoint pt;
    T token;

    std::unique_ptr<PCB_TARGET> target = std::make_unique<PCB_TARGET>( nullptr );

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_x:
            target->SetShape( 1 );
            break;

        case T_plus:
            target->SetShape( 0 );
            break;

        case T_at:
            pt.x = parseBoardUnits( "target x position" );
            pt.y = parseBoardUnits( "target y position" );
            target->SetPosition( pt );
            NeedRIGHT();
            break;

        case T_size:
            target->SetSize( parseBoardUnits( "target size" ) );
            NeedRIGHT();
            break;

        case T_width:
            target->SetWidth( parseBoardUnits( "target thickness" ) );
            NeedRIGHT();
            break;

        case T_layer:
            target->SetLayer( parseBoardItemLayer() );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( target->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        default:
            Expecting( "x, plus, at, size, width, layer or tstamp" );
        }
    }

    return target.release();
}

References NULL.

parsePCB_TEXT()

PCB_TEXT * PCB_PARSER::parsePCB_TEXT ( )

private

Definition at line 2396 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_gr_text, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as PCB_TEXT." ) );

    T token;

    std::unique_ptr<PCB_TEXT> text = std::make_unique<PCB_TEXT>( m_board );
    NeedSYMBOLorNUMBER();

    text->SetText( FromUTF8() );
    NeedLEFT();
    token = NextTok();

    if( token != T_at )
        Expecting( T_at );

    wxPoint pt;

    pt.x = parseBoardUnits( "X coordinate" );
    pt.y = parseBoardUnits( "Y coordinate" );
    text->SetTextPos( pt );

    // If there is no orientation defined, then it is the default value of 0 degrees.
    token = NextTok();

    if( token == T_NUMBER )
    {
        text->SetTextAngle( parseDouble() * 10.0 );
        NeedRIGHT();
    }
    else if( token != T_RIGHT )
    {
        Unexpected( CurText() );
    }

    for( token = NextTok(); token != T_RIGHT; token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_layer:
            text->SetLayer( parseBoardItemLayer() );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( text->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        case T_effects:
            parseEDA_TEXT( (EDA_TEXT*) text.get() );
            break;

        default:
            Expecting( "layer, tstamp or effects" );
        }
    }

    return text.release();
}

References NULL, and parseDouble().

parseProperty()

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

private

Definition at line 240 of file pcb_parser.cpp.

{
    wxString pName;
    wxString pValue;

    NeedSYMBOL();
    pName = FromUTF8();
    NeedSYMBOL();
    pValue = FromUTF8();
    NeedRIGHT();

    return { pName, pValue };
}

parseSetup()

void PCB_PARSER::parseSetup ( )

private

Definition at line 1576 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_setup,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as setup." ) );

    T token;
    NETCLASS*              defaultNetClass = m_board->GetDesignSettings().GetDefault();
    BOARD_DESIGN_SETTINGS& designSettings  = m_board->GetDesignSettings();
    ZONE_SETTINGS&         zoneSettings    = designSettings.GetDefaultZoneSettings();

    // Missing soldermask min width value means that the user has set the value to 0 and
    // not the default value (0.25mm)
    designSettings.m_SolderMaskMinWidth = 0;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_stackup:
            parseBoardStackup();
            break;

        case T_last_trace_width:    // not used now
            /* lastTraceWidth =*/ parseBoardUnits( T_last_trace_width );
            NeedRIGHT();
            break;

        case T_user_trace_width:
        {
            // Make room for the netclass value
            if( designSettings.m_TrackWidthList.empty() )
                designSettings.m_TrackWidthList.emplace_back( 0 );

            designSettings.m_TrackWidthList.push_back( parseBoardUnits( T_user_trace_width ) );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;
        }

        case T_trace_clearance:
            defaultNetClass->SetClearance( parseBoardUnits( T_trace_clearance ) );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_zone_clearance:
            zoneSettings.m_ZoneClearance = parseBoardUnits( T_zone_clearance );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_zone_45_only:
            zoneSettings.m_Zone_45_Only = parseBool();
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_clearance_min:
            designSettings.m_MinClearance = parseBoardUnits( T_clearance_min );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_trace_min:
            designSettings.m_TrackMinWidth = parseBoardUnits( T_trace_min );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_via_size:
            defaultNetClass->SetViaDiameter( parseBoardUnits( T_via_size ) );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_via_drill:
            defaultNetClass->SetViaDrill( parseBoardUnits( T_via_drill ) );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_via_min_annulus:
            designSettings.m_ViasMinAnnulus = parseBoardUnits( T_via_min_annulus );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_via_min_size:
            designSettings.m_ViasMinSize = parseBoardUnits( T_via_min_size );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_through_hole_min:
            designSettings.m_MinThroughDrill = parseBoardUnits( T_through_hole_min );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        // Legacy token for T_through_hole_min
        case T_via_min_drill:
            designSettings.m_MinThroughDrill = parseBoardUnits( T_via_min_drill );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_hole_to_hole_min:
            designSettings.m_HoleToHoleMin = parseBoardUnits( T_hole_to_hole_min );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_user_via:
            {
                int viaSize = parseBoardUnits( "user via size" );
                int viaDrill = parseBoardUnits( "user via drill" );

                // Make room for the netclass value
                if( designSettings.m_ViasDimensionsList.empty() )
                    designSettings.m_ViasDimensionsList.emplace_back( VIA_DIMENSION( 0, 0 ) );

                designSettings.m_ViasDimensionsList.emplace_back( VIA_DIMENSION( viaSize, viaDrill ) );
                m_board->m_LegacyDesignSettingsLoaded = true;
                NeedRIGHT();
            }
            break;

        case T_uvia_size:
            defaultNetClass->SetuViaDiameter( parseBoardUnits( T_uvia_size ) );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_uvia_drill:
            defaultNetClass->SetuViaDrill( parseBoardUnits( T_uvia_drill ) );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_uvias_allowed:
            designSettings.m_MicroViasAllowed = parseBool();
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_blind_buried_vias_allowed:
            designSettings.m_BlindBuriedViaAllowed = parseBool();
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_uvia_min_size:
            designSettings.m_MicroViasMinSize = parseBoardUnits( T_uvia_min_size );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_uvia_min_drill:
            designSettings.m_MicroViasMinDrill = parseBoardUnits( T_uvia_min_drill );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_user_diff_pair:
            {
                int width = parseBoardUnits( "user diff-pair width" );
                int gap = parseBoardUnits( "user diff-pair gap" );
                int viaGap = parseBoardUnits( "user diff-pair via gap" );
                designSettings.m_DiffPairDimensionsList.emplace_back( DIFF_PAIR_DIMENSION( width, gap, viaGap ) );
                m_board->m_LegacyDesignSettingsLoaded = true;
                NeedRIGHT();
            }
            break;

        case T_segment_width:   // note: legacy (pre-6.0) token
            designSettings.m_LineThickness[ LAYER_CLASS_COPPER ] = parseBoardUnits( T_segment_width );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_edge_width:      // note: legacy (pre-6.0) token
            designSettings.m_LineThickness[ LAYER_CLASS_EDGES ] = parseBoardUnits( T_edge_width );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_mod_edge_width:  // note: legacy (pre-6.0) token
            designSettings.m_LineThickness[ LAYER_CLASS_SILK ] = parseBoardUnits( T_mod_edge_width );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_pcb_text_width:  // note: legacy (pre-6.0) token
            designSettings.m_TextThickness[ LAYER_CLASS_COPPER ] = parseBoardUnits( T_pcb_text_width );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_mod_text_width:  // note: legacy (pre-6.0) token
            designSettings.m_TextThickness[ LAYER_CLASS_SILK ] = parseBoardUnits( T_mod_text_width );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_pcb_text_size:   // note: legacy (pre-6.0) token
            designSettings.m_TextSize[ LAYER_CLASS_COPPER ].x = parseBoardUnits( "pcb text width" );
            designSettings.m_TextSize[ LAYER_CLASS_COPPER ].y = parseBoardUnits( "pcb text height" );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_mod_text_size:   // note: legacy (pre-6.0) token
            designSettings.m_TextSize[ LAYER_CLASS_SILK ].x = parseBoardUnits( "footprint text width" );
            designSettings.m_TextSize[ LAYER_CLASS_SILK ].y = parseBoardUnits( "footprint text height" );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_defaults:
            parseDefaults( designSettings );
            m_board->m_LegacyDesignSettingsLoaded = true;
            break;

        case T_pad_size:
            {
                wxSize sz;
                sz.SetWidth( parseBoardUnits( "master pad width" ) );
                sz.SetHeight( parseBoardUnits( "master pad height" ) );
                designSettings.m_Pad_Master.SetSize( sz );
                m_board->m_LegacyDesignSettingsLoaded = true;
                NeedRIGHT();
            }
            break;

        case T_pad_drill:
            {
                int drillSize = parseBoardUnits( T_pad_drill );
                designSettings.m_Pad_Master.SetDrillSize( wxSize( drillSize, drillSize ) );
                m_board->m_LegacyDesignSettingsLoaded = true;
                NeedRIGHT();
            }
            break;

        case T_pad_to_mask_clearance:
            designSettings.m_SolderMaskMargin = parseBoardUnits( T_pad_to_mask_clearance );
            NeedRIGHT();
            break;

        case T_solder_mask_min_width:
            designSettings.m_SolderMaskMinWidth = parseBoardUnits( T_solder_mask_min_width );
            NeedRIGHT();
            break;

        case T_pad_to_paste_clearance:
            designSettings.m_SolderPasteMargin = parseBoardUnits( T_pad_to_paste_clearance );
            NeedRIGHT();
            break;

        case T_pad_to_paste_clearance_ratio:
            designSettings.m_SolderPasteMarginRatio = parseDouble( T_pad_to_paste_clearance_ratio );
            NeedRIGHT();
            break;

        case T_aux_axis_origin:
            {
                int x = parseBoardUnits( "auxiliary origin X" );
                int y = parseBoardUnits( "auxiliary origin Y" );
                designSettings.m_AuxOrigin = wxPoint( x, y );
                // Aux origin still stored in board for the moment
                //m_board->m_LegacyDesignSettingsLoaded = true;
                NeedRIGHT();
            }
            break;

        case T_grid_origin:
            {
                int x = parseBoardUnits( "grid origin X" );
                int y = parseBoardUnits( "grid origin Y" );
                designSettings.m_GridOrigin = wxPoint( x, y );
                // Grid origin still stored in board for the moment
                //m_board->m_LegacyDesignSettingsLoaded = true;
                NeedRIGHT();
            }
            break;

        // Stored in board prior to 6.0
        case T_visible_elements:
            {
                // Make sure to start with DefaultVisible so all new layers are set
                m_board->m_LegacyVisibleItems = GAL_SET::DefaultVisible();

                int visible = parseHex() | MIN_VISIBILITY_MASK;

                for( size_t i = 0; i < sizeof( int ) * CHAR_BIT; i++ )
                    m_board->m_LegacyVisibleItems.set( i, visible & ( 1u << i ) );

                NeedRIGHT();
            }
            break;

        case T_max_error:
            designSettings.m_MaxError = parseBoardUnits( T_max_error );
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_filled_areas_thickness:  // Note: legacy (early 5.99) token
            designSettings.m_ZoneFillVersion = parseBool() ? 5 : 6;
            m_board->m_LegacyDesignSettingsLoaded = true;
            NeedRIGHT();
            break;

        case T_pcbplotparams:
            {
                PCB_PLOT_PARAMS plotParams;
                PCB_PLOT_PARAMS_PARSER parser( reader );
                // parser must share the same current line as our current PCB parser
                // synchronize it.
                parser.SyncLineReaderWith( *this );

                plotParams.Parse( &parser );
                SyncLineReaderWith( parser );

                m_board->SetPlotOptions( plotParams );
            }
            break;

        default:
            Unexpected( CurText() );
        }
    }
}

References GAL_SET::DefaultVisible(), BOARD_DESIGN_SETTINGS::GetDefaultZoneSettings(), LAYER_CLASS_COPPER, LAYER_CLASS_EDGES, LAYER_CLASS_SILK, BOARD_DESIGN_SETTINGS::m_AuxOrigin, BOARD_DESIGN_SETTINGS::m_BlindBuriedViaAllowed, BOARD_DESIGN_SETTINGS::m_DiffPairDimensionsList, BOARD_DESIGN_SETTINGS::m_GridOrigin, BOARD_DESIGN_SETTINGS::m_HoleToHoleMin, BOARD_DESIGN_SETTINGS::m_LineThickness, BOARD_DESIGN_SETTINGS::m_MaxError, BOARD_DESIGN_SETTINGS::m_MicroViasAllowed, BOARD_DESIGN_SETTINGS::m_MicroViasMinDrill, BOARD_DESIGN_SETTINGS::m_MicroViasMinSize, BOARD_DESIGN_SETTINGS::m_MinClearance, BOARD_DESIGN_SETTINGS::m_MinThroughDrill, BOARD_DESIGN_SETTINGS::m_Pad_Master, BOARD_DESIGN_SETTINGS::m_SolderMaskMargin, BOARD_DESIGN_SETTINGS::m_SolderMaskMinWidth, BOARD_DESIGN_SETTINGS::m_SolderPasteMargin, BOARD_DESIGN_SETTINGS::m_SolderPasteMarginRatio, BOARD_DESIGN_SETTINGS::m_TextSize, BOARD_DESIGN_SETTINGS::m_TextThickness, BOARD_DESIGN_SETTINGS::m_TrackMinWidth, BOARD_DESIGN_SETTINGS::m_TrackWidthList, BOARD_DESIGN_SETTINGS::m_ViasDimensionsList, BOARD_DESIGN_SETTINGS::m_ViasMinAnnulus, BOARD_DESIGN_SETTINGS::m_ViasMinSize, ZONE_SETTINGS::m_Zone_45_Only, ZONE_SETTINGS::m_ZoneClearance, BOARD_DESIGN_SETTINGS::m_ZoneFillVersion, MIN_VISIBILITY_MASK, PCB_PLOT_PARAMS::Parse(), parseDouble(), parseHex(), NETCLASS::SetClearance(), PAD::SetDrillSize(), PAD::SetSize(), NETCLASS::SetuViaDiameter(), NETCLASS::SetuViaDrill(), NETCLASS::SetViaDiameter(), and NETCLASS::SetViaDrill().

parseTITLE_BLOCK()

void PCB_PARSER::parseTITLE_BLOCK ( )

private

Definition at line 979 of file pcb_parser.cpp.

{
    wxCHECK_RET( CurTok() == T_title_block,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
                 wxT( " as TITLE_BLOCK." ) );

    T token;
    TITLE_BLOCK titleBlock;

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_title:
            NextTok();
            titleBlock.SetTitle( FromUTF8() );
            break;

        case T_date:
            NextTok();
            titleBlock.SetDate( FromUTF8() );
            break;

        case T_rev:
            NextTok();
            titleBlock.SetRevision( FromUTF8() );
            break;

        case T_company:
            NextTok();
            titleBlock.SetCompany( FromUTF8() );
            break;

        case T_comment:
            {
                int commentNumber = parseInt( "comment" );

                switch( commentNumber )
                {
                case 1:
                    NextTok();
                    titleBlock.SetComment( 0, FromUTF8() );
                    break;

                case 2:
                    NextTok();
                    titleBlock.SetComment( 1, FromUTF8() );
                    break;

                case 3:
                    NextTok();
                    titleBlock.SetComment( 2, FromUTF8() );
                    break;

                case 4:
                    NextTok();
                    titleBlock.SetComment( 3, FromUTF8() );
                    break;

                case 5:
                    NextTok();
                    titleBlock.SetComment( 4, FromUTF8() );
                    break;

                case 6:
                    NextTok();
                    titleBlock.SetComment( 5, FromUTF8() );
                    break;

                case 7:
                    NextTok();
                    titleBlock.SetComment( 6, FromUTF8() );
                    break;

                case 8:
                    NextTok();
                    titleBlock.SetComment( 7, FromUTF8() );
                    break;

                case 9:
                    NextTok();
                    titleBlock.SetComment( 8, FromUTF8() );
                    break;

                default:
                    wxString err;
                    err.Printf( wxT( "%d is not a valid title block comment number" ), commentNumber );
                    THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
                }
            }
            break;

        default:
            Expecting( "title, date, rev, company, or comment" );
        }

        NeedRIGHT();
    }

    m_board->SetTitleBlock( titleBlock );
}

References parseInt(), TITLE_BLOCK::SetComment(), TITLE_BLOCK::SetCompany(), TITLE_BLOCK::SetDate(), TITLE_BLOCK::SetRevision(), TITLE_BLOCK::SetTitle(), and THROW_PARSE_ERROR.

parseTRACK()

TRACK * PCB_PARSER::parseTRACK ( )

private

We continue to parse the status field but it is no longer written

Definition at line 4260 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_segment, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as TRACK." ) );

    wxPoint pt;
    T token;

    std::unique_ptr<TRACK> track = std::make_unique<TRACK>( m_board );

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token != T_LEFT )
            Expecting( T_LEFT );

        token = NextTok();

        switch( token )
        {
        case T_start:
            pt.x = parseBoardUnits( "start x" );
            pt.y = parseBoardUnits( "start y" );
            track->SetStart( pt );
            break;

        case T_end:
            pt.x = parseBoardUnits( "end x" );
            pt.y = parseBoardUnits( "end y" );
            track->SetEnd( pt );
            break;

        case T_width:
            track->SetWidth( parseBoardUnits( "width" ) );
            break;

        case T_layer:
            track->SetLayer( parseBoardItemLayer() );
            break;

        case T_net:
            if( !track->SetNetCode( getNetCode( parseInt( "net number" ) ), /* aNoAssert */ true ) )
                THROW_IO_ERROR( wxString::Format(
                        _( "Invalid net ID in\nfile: \"%s\"\nline: %d\noffset: %d" ), CurSource(),
                        CurLineNumber(), CurOffset() ) );
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( track->m_Uuid ) = CurStrToKIID();
            break;

        case T_status:
            track->SetStatus( static_cast<STATUS_FLAGS>( parseHex() ) );
            break;

        case T_locked:
            track->SetLocked( true );
            break;

        default:
            Expecting( "start, end, width, layer, net, tstamp, or locked" );
        }

        NeedRIGHT();
    }

    return track.release();
}

References _, Format(), NULL, parseHex(), parseInt(), and THROW_IO_ERROR.

parseVIA()

VIA * PCB_PARSER::parseVIA ( )

private

We continue to parse the status field but it is no longer written

Definition at line 4331 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_via, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as VIA." ) );

    wxPoint pt;
    T token;

    std::unique_ptr<VIA> via = std::make_unique<VIA>( m_board );

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_blind:
            via->SetViaType( VIATYPE::BLIND_BURIED );
            break;

        case T_micro:
            via->SetViaType( VIATYPE::MICROVIA );
            break;

        case T_at:
            pt.x = parseBoardUnits( "start x" );
            pt.y = parseBoardUnits( "start y" );
            via->SetStart( pt );
            via->SetEnd( pt );
            NeedRIGHT();
            break;

        case T_size:
            via->SetWidth( parseBoardUnits( "via width" ) );
            NeedRIGHT();
            break;

        case T_drill:
            via->SetDrill( parseBoardUnits( "drill diameter" ) );
            NeedRIGHT();
            break;

        case T_layers:
        {
            PCB_LAYER_ID layer1, layer2;
            NextTok();
            layer1 = lookUpLayer<PCB_LAYER_ID>( m_layerIndices );
            NextTok();
            layer2 = lookUpLayer<PCB_LAYER_ID>( m_layerIndices );
            via->SetLayerPair( layer1, layer2 );
            NeedRIGHT();
        }
            break;

        case T_net:
            if( !via->SetNetCode( getNetCode( parseInt( "net number" ) ), /* aNoAssert */ true ) )
            {
                THROW_IO_ERROR( wxString::Format( _( "Invalid net ID in\n"
                                                     "file: '%s'\n"
                                                     "line: %d\n"
                                                     "offset: %d" ),
                                      CurSource(),
                                      CurLineNumber(),
                                      CurOffset() ) );
            }

            NeedRIGHT();
            break;

        case T_remove_unused_layers:
            via->SetRemoveUnconnected( true );
            NeedRIGHT();
            break;

        case T_keep_end_layers:
            via->SetKeepTopBottom( true );
            NeedRIGHT();
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( via->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        case T_status:
            via->SetStatus( static_cast<STATUS_FLAGS>( parseHex() ) );
            NeedRIGHT();
            break;

        case T_locked:
            via->SetLocked( true );
            NeedRIGHT();
            break;

        case T_free:
            via->SetIsFree();
            NeedRIGHT();
            break;

        default:
            Expecting( "blind, micro, at, size, drill, layers, net, free, tstamp, or status" );
        }
    }

    return via.release();
}

References _, BLIND_BURIED, Format(), MICROVIA, NULL, parseHex(), parseInt(), and THROW_IO_ERROR.

parseXY() [1/2]

wxPoint PCB_PARSER::parseXY ( )

private

Parse a coordinate pair (xy X Y) in board units (mm).

The parser checks if the previous token was T_LEFT and parses the remainder of the token syntax. This is used when parsing a list of coordinate points. This way the parser can be used in either case.

Returns

A wxPoint object containing the coordinate pair.

Exceptions

PARSE_ERROR

if the coordinate pair syntax is incorrect.

Definition at line 208 of file pcb_parser.cpp.

{
    if( CurTok() != T_LEFT )
        NeedLEFT();

    wxPoint pt;
    T token = NextTok();

    if( token != T_xy )
        Expecting( T_xy );

    pt.x = parseBoardUnits( "X coordinate" );
    pt.y = parseBoardUnits( "Y coordinate" );

    NeedRIGHT();

    return pt;
}

parseXY() [2/2]

void PCB_PARSER::parseXY ( int *  aX, int *  aY  )

private

Definition at line 228 of file pcb_parser.cpp.

{
    wxPoint pt = parseXY();

    if( aX )
        *aX = pt.x;

    if( aY )
        *aY = pt.y;
}

parseZONE()

ZONE * PCB_PARSER::parseZONE ( BOARD_ITEM_CONTAINER *  aParent )

private

Definition at line 4442 of file pcb_parser.cpp.

{
    wxCHECK_MSG( CurTok() == T_zone, NULL,
                 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
                 wxT( " as ZONE." ) );

    ZONE_BORDER_DISPLAY_STYLE hatchStyle = ZONE_BORDER_DISPLAY_STYLE::NO_HATCH;

    int      hatchPitch = ZONE::GetDefaultHatchPitch();
    wxPoint  pt;
    T        token;
    int      tmp;
    wxString netnameFromfile;    // the zone net name find in file

    // bigger scope since each filled_polygon is concatenated in here
    std::map<PCB_LAYER_ID, SHAPE_POLY_SET> pts;
    bool         inFootprint = false;
    PCB_LAYER_ID filledLayer;
    bool         addedFilledPolygons = false;

    if( dynamic_cast<FOOTPRINT*>( aParent ) )      // The zone belongs a footprint
        inFootprint = true;

    std::unique_ptr<ZONE> zone;

    if( inFootprint )
        zone = std::make_unique<FP_ZONE>( aParent );
    else
        zone = std::make_unique<ZONE>( aParent );

    zone->SetPriority( 0 );

    for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
    {
        if( token == T_LEFT )
            token = NextTok();

        switch( token )
        {
        case T_net:
            // Init the net code only, not the netname, to be sure
            // the zone net name is the name read in file.
            // (When mismatch, the user will be prompted in DRC, to fix the actual name)
            tmp = getNetCode( parseInt( "net number" ) );

            if( tmp < 0 )
                tmp = 0;

            if( !zone->SetNetCode( tmp, /* aNoAssert */ true ) )
                THROW_IO_ERROR( wxString::Format(
                        _( "Invalid net ID in\nfile: \"%s\"\nline: %d\noffset: %d" ), CurSource(),
                        CurLineNumber(), CurOffset() ) );

            NeedRIGHT();
            break;

        case T_net_name:
            NeedSYMBOLorNUMBER();
            netnameFromfile = FromUTF8();
            NeedRIGHT();
            break;

        case T_layer:   // keyword for zones that are on only one layer
            zone->SetLayer( parseBoardItemLayer() );
            NeedRIGHT();
            break;

        case T_layers:  // keyword for zones that can live on a set of layers
            zone->SetLayerSet( parseBoardItemLayersAsMask() );
            break;

        case T_tstamp:
            NextTok();
            const_cast<KIID&>( zone->m_Uuid ) = CurStrToKIID();
            NeedRIGHT();
            break;

        case T_hatch:
            token = NextTok();

            if( token != T_none && token != T_edge && token != T_full )
                Expecting( "none, edge, or full" );

            switch( token )
            {
            default:
            case T_none: hatchStyle = ZONE_BORDER_DISPLAY_STYLE::NO_HATCH;      break;
            case T_edge: hatchStyle = ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE; break;
            case T_full: hatchStyle = ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_FULL; break;
            }

            hatchPitch = parseBoardUnits( "hatch pitch" );
            NeedRIGHT();
            break;

        case T_priority:
            zone->SetPriority( parseInt( "zone priority" ) );
            NeedRIGHT();
            break;

        case T_connect_pads:
            for( token = NextTok();  token != T_RIGHT;  token = NextTok() )
            {
                if( token == T_LEFT )
                    token = NextTok();

                switch( token )
                {
                case T_yes:
                    zone->SetPadConnection( ZONE_CONNECTION::FULL );
                    break;

                case T_no:
                    zone->SetPadConnection( ZONE_CONNECTION::NONE );
                    break;

                case T_thru_hole_only:
                    zone->SetPadConnection( ZONE_CONNECTION::THT_THERMAL );
                    break;

                case T_clearance:
                    zone->SetLocalClearance( parseBoardUnits( "zone clearance" ) );