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=nullptr)
LINE_READER *	SetLineReader (LINE_READER *aReader)
	Set aLineReader into the parser, and returns the previous one, if any. More...
void	SetBoard (BOARD *aBoard)
void	SetProgressReporter (PROGRESS_REPORTER *aProgressReporter, const LINE_READER *aLineReader, unsigned aLineCount)
BOARD_ITEM *	Parse ()
FOOTPRINT *	parseFOOTPRINT (wxArrayString *aInitialComments=nullptr)
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
	The type of progress bar timeout. More...
using	TIMEOUT = std::chrono::milliseconds
	The clock used for the timestamp (guaranteed to be monotonic). More...
using	CLOCK = std::chrono::steady_clock
	The type of the time stamps. More...
using	TIME_PT = std::chrono::time_point< CLOCK >

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	checkpoint ()
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 ()
PCB_DIMENSION_BASE *	parseDIMENSION ()
FOOTPRINT *	parseFOOTPRINT_unchecked (wxArrayString *aInitialComments=nullptr)
FP_TEXT *	parseFP_TEXT ()
FP_SHAPE *	parseFP_SHAPE ()
PAD *	parsePAD (FOOTPRINT *aParent=nullptr)
bool	parsePAD_option (PAD *aPad)
PCB_ARC *	parseARC ()
PCB_TRACK *	parsePCB_TRACK ()
PCB_VIA *	parsePCB_VIA ()
ZONE *	parseZONE (BOARD_ITEM_CONTAINER *aParent)
PCB_TARGET *	parsePCB_TARGET ()
BOARD *	parseBOARD ()
void	parseGROUP (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	parseOutlinePoints (SHAPE_LINE_CHAIN &aPoly)
	Parses possible outline points and stores them into aPoly. More...
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)
double	parseAngle ()
	Parse angles into deci-degrees. More...
double	parseAngle (const char *aExpected)
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
PROGRESS_REPORTER *	m_progressReporter
	optional; may be nullptr More...
const LINE_READER *	m_lineReader
	for progress reporting More...
TIME_PT	m_lastProgressTime
	for progress reporting More...
unsigned	m_lineCount
	for progress reporting More...
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 72 of file pcb_parser.h.

Member Typedef Documentation

CLOCK

using PCB_PARSER::CLOCK = std::chrono::steady_clock

private

The type of the time stamps.

Definition at line 374 of file pcb_parser.h.

KIID_MAP

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

private

The type of progress bar timeout.

Definition at line 366 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 364 of file pcb_parser.h.

LSET_MAP

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

private

Definition at line 365 of file pcb_parser.h.

TIME_PT

using PCB_PARSER::TIME_PT = std::chrono::time_point<CLOCK>

private

Definition at line 375 of file pcb_parser.h.

TIMEOUT

using PCB_PARSER::TIMEOUT = std::chrono::milliseconds

private

The clock used for the timestamp (guaranteed to be monotonic).

Definition at line 371 of file pcb_parser.h.

Constructor & Destructor Documentation

PCB_PARSER()

PCB_PARSER::PCB_PARSER ( LINE_READER *  aReader = nullptr )

inline

Definition at line 75 of file pcb_parser.h.

 :
 PCB_LEXER( aReader ),
 m_board( nullptr ),
 m_resetKIIDs( false ),
 m_progressReporter( nullptr ),
 m_lineReader( nullptr ),
 m_lastProgressTime( std::chrono::steady_clock::now() ),
 m_lineCount( 0 )
 {
 init();
 }

References init().

Member Function Documentation

checkpoint()

void PCB_PARSER::checkpoint ( )

private

Definition at line 112 of file pcb_parser.cpp.

{
 if( m_progressReporter )
 {
 TIME_PT curTime = CLOCK::now();
 unsigned curLine = m_lineReader->LineNumber();
 auto delta = std::chrono::duration_cast<TIMEOUT>( curTime - m_lastProgressTime );

 if( delta > std::chrono::milliseconds( 100 ) )
 {
 m_progressReporter->SetCurrentProgress( ( (double) curLine )
 / std::max( 1U, m_lineCount ) );

 if( !m_progressReporter->KeepRefreshing() )
 THROW_IO_ERROR( ( "Open cancelled by user." ) );

 m_lastProgressTime = curTime;
 }
 }
}

References delta, and THROW_IO_ERROR.

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 1536 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 5551 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 147 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 247 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_PLUGIN::DoLoad(), CLIPBOARD_IO::Load(), and PCB_PLUGIN::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 67 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 133 of file pcb_parser.h.

 {
 return m_tooRecent;
 }

References m_tooRecent.

Referenced by PCB_PLUGIN::DoLoad(), CLIPBOARD_IO::Load(), and PCB_PLUGIN::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 1718 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 627 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 == -1 ) // EOF
 Unexpected( token );

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

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

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

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

 // Locking a footprint has no meaning outside of a board.
 item->SetLocked( false );
 break;

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

 resolveGroups( item );

 return item;
}

References _, BOARD_ITEM::SetLocked(), and THROW_PARSE_ERROR.

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

parse3DModel()

FP_3DMODEL * PCB_PARSER::parse3DModel ( )

private

Definition at line 521 of file pcb_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_model, nullptr,
 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, parseDouble(), FP_3DMODEL::VECTOR3D::x, FP_3DMODEL::VECTOR3D::y, and FP_3DMODEL::VECTOR3D::z.

parseAngle() [1/2]

double PCB_PARSER::parseAngle ( )

inlineprivate

Parse angles into deci-degrees.

Definition at line 318 of file pcb_parser.h.

{ return parseDouble() * 10.0; }

References parseDouble().

parseAngle() [2/2]

double PCB_PARSER::parseAngle ( const char *  aExpected )

inlineprivate

Definition at line 320 of file pcb_parser.h.

 {
 return parseDouble( aExpected ) * 10.0;
 }

References parseDouble().

parseARC()

PCB_ARC * PCB_PARSER::parseARC ( )

private

Definition at line 4627 of file pcb_parser.cpp.

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

 wxPoint pt;
 T token;

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

 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token == T_locked )
 {
 arc->SetLocked( true );
 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;

 // We continue to parse the status field but it is no longer written
 case T_status:
 arc->SetStatus( static_cast<EDA_ITEM_FLAGS>( parseHex() ) );
 break;

 // Continue to process "(locked)" format which was output during 5.99 development
 case T_locked:
 arc->SetLocked( true );
 break;

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

 NeedRIGHT();
 }

 return arc.release();
}

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

parseBOARD()

BOARD * PCB_PARSER::parseBOARD ( )

private

Definition at line 677 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 693 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() )
 {
 checkpoint();

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

 token = NextTok();

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

 switch( token )
 {
 case T_host: // legacy token
 NeedSYMBOL();
 m_board->SetGenerator( FromUTF8() );

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

 NeedRIGHT();
 break;

 case T_generator:
 NeedSYMBOL();
 m_board->SetGenerator( FromUTF8() );
 NeedRIGHT();
 break;

 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 = parsePCB_TRACK();
 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 = parsePCB_VIA();
 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( PCB_TRACK* track : m_board->Tracks() )
 {
 if( track->Type() == PCB_VIA_T )
 {
 PCB_VIA* via = static_cast<PCB_VIA*>( track );
 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( track );
 }
 }

 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, BOARD_FILE_HOST_VERSION, BULK_APPEND, Cmts_User, F_Cu, Format(), PCB_VIA_T, Rescue, THROUGH, THROW_IO_ERROR, THROW_PARSE_ERROR, and via.

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 1737 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 1752 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 1315 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();
 name = FromUTF8();

 // Older versions didn't store opacity with custom colors
 if( name.StartsWith( wxT( "#" ) ) && m_requiredVersion < 20210824 )
 {
 KIGFX::COLOR4D color( name );

 if( item->GetType() == BS_ITEM_TYPE_SOLDERMASK )
 color = color.WithAlpha( DEFAULT_SOLDERMASK_OPACITY );
 else
 color = color.WithAlpha( 1.0 );

 wxColour wx_color = color.ToColour();

 // Open-code wxColour::GetAsString() because 3.0 doesn't handle rgba
 name.Printf( wxT("#%02X%02X%02X%02X" ),
 wx_color.Red(),
  wx_color.Green(),
 wx_color.Blue(),
 wx_color.Alpha() );
 }

 item->SetColor( name );
 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, color, DEFAULT_SOLDERMASK_OPACITY, F_Cu, F_Mask, F_Paste, F_SilkS, BOARD_STACKUP_ITEM::GetType(), 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 ( )

private

Definition at line 197 of file pcb_parser.cpp.

{
 // 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
 constexpr 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 )

private

Definition at line 217 of file pcb_parser.cpp.

{
 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
 constexpr 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 329 of file pcb_parser.h.

 {
 return parseBoardUnits( GetTokenText( aToken ) );
 }

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

parseBool()

bool PCB_PARSER::parseBool ( )

private

Definition at line 232 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 2119 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 2202 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()

PCB_DIMENSION_BASE * PCB_PARSER::parseDIMENSION ( )

private

Definition at line 2795 of file pcb_parser.cpp.

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

 T token;
 bool locked = false;
 std::unique_ptr<PCB_DIMENSION_BASE> dimension;

 token = NextTok();

 if( token == T_locked )
 {
 locked = true;
 token = NextTok();
 }

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

 token = NextTok();

 bool isLegacyDimension = false;

 // Old format
 if( token == T_width )
 {
 isLegacyDimension = true;
 dimension = std::make_unique<PCB_DIM_ALIGNED>( 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<PCB_DIM_ALIGNED>( nullptr );
 break;

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

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

 case T_center:
 dimension = std::make_unique<PCB_DIM_CENTER>( 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" ) );
 PCB_DIM_ALIGNED* aligned = static_cast<PCB_DIM_ALIGNED*>( 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" ) );
 PCB_DIM_ORTHOGONAL* ortho = static_cast<PCB_DIM_ORTHOGONAL*>( dimension.get() );

 int orientation = parseInt( "orthogonal dimension orientation" );
 orientation = std::max( 0, std::min( 1, orientation ) );
 ortho->SetOrientation( static_cast<PCB_DIM_ORTHOGONAL::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:
 {
 PCB_DIM_ALIGNED* aligned = dynamic_cast<PCB_DIM_ALIGNED*>( 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" ) );
 PCB_DIM_LEADER* leader = static_cast<PCB_DIM_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
 PCB_DIM_ALIGNED* aligned = static_cast<PCB_DIM_ALIGNED*>( 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" );
 }
 }

 if( locked )
 dimension->SetLocked( true );

 dimension->Update();

 return dimension.release();
}

References FetchUnitsFromString(), INCHES, locked, ortho, parseInt(), PCB_DIM_ALIGNED_T, PCB_DIM_LEADER_T, PCB_DIM_ORTHOGONAL_T, PCB_DIM_ALIGNED::SetExtensionHeight(), PCB_DIM_ALIGNED::SetHeight(), text, and PCB_DIM_ALIGNED::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 167 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 parseAngle(), and parseDouble().

parseDouble() [2/3]

double PCB_PARSER::parseDouble ( const char *  aExpected )

inlineprivate

Definition at line 304 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 310 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 403 of file pcb_parser.cpp.

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

 // In version 20210606 the notation for overbars was changed from `~...~` to `~{...}`.
 // We need to convert the old syntax to the new one.
 if( m_requiredVersion < 20210606 )
 aText->SetText( ConvertToNewOverbarNotation( aText->GetText() ) );

 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 ConvertToNewOverbarNotation(), EDA_TEXT::GetText(), 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::SetText(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetTextThickness(), EDA_TEXT::SetVertJustify(), and EDA_TEXT::SetVisible().

parseFOOTPRINT()

FOOTPRINT * PCB_PARSER::parseFOOTPRINT

(

wxArrayString *

aInitialComments = nullptr

)

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 3207 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 = nullptr )

private

Definition at line 3223 of file pcb_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_module || CurTok() == T_footprint, nullptr,
 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( parseAngle() );
 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:
 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, name, pad, LIB_ID::Parse(), parseDouble(), parseHex(), parseInt(), RotatePoint(), FP_SHAPE::SetDrawCoord(), EDA_ITEM::SetParent(), SEXPR_BOARD_FILE_VERSION, text, FP_TEXT::TEXT_is_REFERENCE, FP_TEXT::TEXT_is_VALUE, and THROW_IO_ERROR.

parseFP_SHAPE()

FP_SHAPE * PCB_PARSER::parseFP_SHAPE ( )

private

Definition at line 3653 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, nullptr,
 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( SHAPE_T::ARC );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 token = NextTok();

 if( m_requiredVersion <= LEGACY_ARC_FORMATTING )
 {
 // In legacy files the start keyword actually gives the arc center...
 if( token != T_start )
 Expecting( T_start );

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

 // ... and the end keyword gives the start point of the arc
 if( token != T_end )
 Expecting( T_end );

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

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

 shape->SetArcAngleAndEnd0( parseAngle( "segment angle" ), true );
 NeedRIGHT();
 }
 else
 {
 wxPoint arc_start, arc_mid, arc_end;

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

 arc_start.x = parseBoardUnits( "X coordinate" );
 arc_start.y = parseBoardUnits( "Y coordinate" );
 NeedRIGHT();
 NeedLEFT();
 token = NextTok();

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

 arc_mid.x = parseBoardUnits( "X coordinate" );
 arc_mid.y = parseBoardUnits( "Y coordinate" );
 NeedRIGHT();
 NeedLEFT();
 token = NextTok();

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

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

 shape->SetArcGeometry0( arc_start, arc_mid, arc_end );
 }

 break;

 case T_fp_circle:
 shape->SetShape( SHAPE_T::CIRCLE );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 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( SHAPE_T::BEZIER );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 token = NextTok();

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

 shape->SetStart0( parseXY() );
 shape->SetBezierC1_0( parseXY() );
 shape->SetBezierC2_0( parseXY() );
 shape->SetEnd0( parseXY() );
 NeedRIGHT();
 break;

 case T_fp_rect:
 shape->SetShape( SHAPE_T::RECT );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 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.
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 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( SHAPE_T::POLY );
 shape->SetPolyPoints( {} );
 SHAPE_LINE_CHAIN& outline = shape->GetPolyShape().Outline( 0 );

 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 token = NextTok();

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

 while( (token = NextTok() ) != T_RIGHT )
 parseOutlinePoints( outline );

 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;

 // We continue to parse the status field but it is no longer written
 case T_status:
 shape->SetStatus( static_cast<EDA_ITEM_FLAGS>( parseHex() ) );
 NeedRIGHT();
 break;

 // Continue to process "(locked)" format which was output during 5.99 development
 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() == SHAPE_T::RECT || shape->GetShape() == SHAPE_T::CIRCLE ) )
 {
 shape->SetFilled( true );
 }
 // Polygons on non-Edge_Cuts layers were always filled
 else if( shape->GetShape() == SHAPE_T::POLY && 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 ARC, BEZIER, CIRCLE, DEFAULT_LINE_WIDTH, Edge_Cuts, LEGACY_ARC_FORMATTING, Millimeter2iu(), parseHex(), POLY, and RECT.

parseFP_TEXT()

FP_TEXT * PCB_PARSER::parseFP_TEXT ( )

private

Definition at line 3544 of file pcb_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_fp_text, nullptr,
 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() ) );
 }

 token = NextTok();

 if( token == T_locked )
 {
 text->SetLocked( true );
 token = NextTok();
 }

 if( !IsSymbol( token ) && (int) token != DSN_NUMBER )
 Expecting( "text value" );

 wxString value = FromUTF8();
 value.Replace( wxT( "%V" ), wxT( "${VALUE}" ) );
 value.Replace( wxT( "%R" ), wxT( "${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( parseAngle() );
 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 _, DSN_NUMBER, Format(), text, FP_TEXT::TEXT_is_REFERENCE, FP_TEXT::TEXT_is_VALUE, and THROW_IO_ERROR.

parseGeneralSection()

void PCB_PARSER::parseGeneralSection ( )

private

Definition at line 1060 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 4577 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;

 while( ( token = NextTok() ) != T_LEFT )
 {
 if( token == T_STRING )
 groupInfo.name = FromUTF8();
 else if( token == T_locked )
 groupInfo.locked = true;
 else
 Expecting( "group name or locked" );
 }

 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 PCB_PARSER::GROUP_INFO::locked, 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 1034 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();
 }
 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 );
 }

 m_board->SetFileFormatVersionAtLoad( m_requiredVersion );
}

References parseInt(), and SEXPR_BOARD_FILE_VERSION.

parseHex()

long PCB_PARSER::parseHex ( )

inlineprivate

Definition at line 345 of file pcb_parser.h.

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

parseInt() [1/2]

int PCB_PARSER::parseInt ( )

inlineprivate

Definition at line 334 of file pcb_parser.h.

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

Referenced by parseInt().

parseInt() [2/2]

int PCB_PARSER::parseInt ( const char *  aExpected )

inlineprivate

Definition at line 339 of file pcb_parser.h.

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

References parseInt().

parseLayer()

void PCB_PARSER::parseLayer ( LAYER *  aLayer )

private

Definition at line 1258 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 1586 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;
 error.Printf( _( "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 2270 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();

 // Convert overbar syntax from `~...~` to `~{...}`. These were left out of the
 // first merge so the version is a bit later.
 if( m_requiredVersion < 20210606 )
 nc->Add( ConvertToNewOverbarNotation( FromUTF8() ) );
 else
 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 _, ConvertToNewOverbarNotation(), and THROW_IO_ERROR.

parseNETINFO_ITEM()

void PCB_PARSER::parseNETINFO_ITEM ( )

private

Definition at line 2239 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();

 // Convert overbar syntax from `~...~` to `~{...}`. These were left out of the first merge
 // so the version is a bit later.
 if( m_requiredVersion < 20210606 )
 name = ConvertToNewOverbarNotation( name );

 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 ConvertToNewOverbarNotation(), NETINFO_ITEM::GetNetCode(), name, parseInt(), and NETINFO_LIST::UNCONNECTED.

parseOutlinePoints()

void PCB_PARSER::parseOutlinePoints ( SHAPE_LINE_CHAIN &  aPoly )

private

Parses possible outline points and stores them into aPoly.

This accepts points for DRAWSEGMENT polygons, EDGEMODULE polygons and ZONE_CONTAINER polygons. Points and arcs are added to the most recent outline

Parameters

aPoly

polygon container to add points and arcs

Definition at line 291 of file pcb_parser.cpp.

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

 T token = NextTok();

 switch( token )
 {
 case T_xy:
 {
 int x = parseBoardUnits( "X coordinate" );
 int y = parseBoardUnits( "Y coordinate" );

 NeedRIGHT();

 aPoly.Append( x, y );
 break;
 }
 case T_arc:
 {
 bool has_start = false;
 bool has_mid = false;
 bool has_end = false;

 VECTOR2I arc_start, arc_mid, arc_end;

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

 token = NextTok();

 switch( token )
 {
 case T_start:
 arc_start.x = parseBoardUnits( "start x" );
 arc_start.y = parseBoardUnits( "start y" );
 has_start = true;
 break;

 case T_mid:
 arc_mid.x = parseBoardUnits( "mid x" );
 arc_mid.y = parseBoardUnits( "mid y" );
 has_mid = true;
 break;

 case T_end:
 arc_end.x = parseBoardUnits( "end x" );
 arc_end.y = parseBoardUnits( "end y" );
 has_end = true;
 break;

 default:
 Expecting( "start, mid or end" );
 }

 NeedRIGHT();
 }

 if( !has_start )
 Expecting( "start" );

 if( !has_mid )
 Expecting( "mid" );

 if( !has_end )
 Expecting( "end" );

 SHAPE_ARC arc( arc_start, arc_mid, arc_end, 0 );

 aPoly.Append( arc );

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

 break;
 }
 default:
 Expecting( "xy or arc" );
 }
}

References SHAPE_LINE_CHAIN::Append(), VECTOR2< T >::x, and VECTOR2< T >::y.

parsePAD()

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

private

Definition at line 4005 of file pcb_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_pad, nullptr,
 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 RemoveUnconnected is true
 pad->SetRemoveUnconnected( false );
 // File only contains a token if KeepTopBottom is true
 pad->SetKeepTopBottom( false );

 NeedSYMBOLorNUMBER();
 pad->SetNumber( 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_locked )
 {
 pad->SetLocked( true );
 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( parseAngle() );
 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( _( "Invalid net ID in\nfile: %s\nline: %d 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 )
 {
 wxString netName( FromUTF8() );

 // Convert overbar syntax from `~...~` to `~{...}`. These were left out of the
 // first merge so the version is a bit later.
 if( m_requiredVersion < 20210606 )
 netName = ConvertToNewOverbarNotation( netName );

 if( netName != m_board->FindNet( pad->GetNetCode() )->GetNetname() )
 {
 pad->SetNetCode( NETINFO_LIST::ORPHANED, /* aNoAssert */ true );
 wxLogError( _( "Net name doesn't match ID in\nfile: %s\nline: %d 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* dummyShape = nullptr;

 switch( token )
 {
 case T_gr_arc:
 dummyShape = parsePCB_SHAPE();
 pad->AddPrimitiveArc( dummyShape->GetCenter(), dummyShape->GetStart(),
 dummyShape->GetArcAngle(), dummyShape->GetWidth() );
 break;

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

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

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


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

 case T_gr_curve:
 dummyShape = parsePCB_SHAPE();
 pad->AddPrimitiveCurve( dummyShape->GetStart(), dummyShape->GetEnd(),
 dummyShape->GetBezierC1(),
 dummyShape->GetBezierC2(), dummyShape->GetWidth() );
 break;

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

 delete dummyShape;
 }

 break;

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

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

 // Continue to process "(locked)" format which was output during 5.99 development
 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" );
 }
 }

 if( !pad->CanHaveNumber() )
 {
 // At some point it was possible to assign a number to aperture pads so we need to clean
 // those out here.
 pad->SetNumber( wxEmptyString );
 }

 if( !pad->GetRemoveUnconnected() )
 pad->SetKeepTopBottom( true );

 return pad.release();
}

References _, BGA, CASTELLATED, CHAMFERED_RECT, CIRCLE, CONN, ConvertToNewOverbarNotation(), CUSTOM, delta, FIDUCIAL_GLBL, FIDUCIAL_LOCAL, EDA_SHAPE::GetArcAngle(), EDA_SHAPE::GetBezierC1(), EDA_SHAPE::GetBezierC2(), PCB_SHAPE::GetCenter(), EDA_SHAPE::GetEnd(), EDA_SHAPE::GetPolyShape(), EDA_SHAPE::GetRadius(), EDA_SHAPE::GetStart(), EDA_SHAPE::GetWidth(), HEATSINK, EDA_SHAPE::IsFilled(), NONE, NPTH, NETINFO_LIST::ORPHANED, OVAL, pad, PAD_DRILL_SHAPE_OBLONG, parseDouble(), parseInt(), PTH, RECT, RECT_CHAMFER_BOTTOM_LEFT, RECT_CHAMFER_BOTTOM_RIGHT, RECT_CHAMFER_TOP_LEFT, RECT_CHAMFER_TOP_RIGHT, RECT_NO_CHAMFER, ROUNDRECT, SMD, TESTPOINT, and TRAPEZOID.

parsePAD_option()

bool PCB_PARSER::parsePAD_option ( PAD *  aPad )

private

Definition at line 4505 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, RECT, PAD::SetAnchorPadShape(), and PAD::SetCustomShapeInZoneOpt().

parsePAGE_INFO()

void PCB_PARSER::parsePAGE_INFO ( )

private

Definition at line 1093 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

Definition at line 2362 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, nullptr,
 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( SHAPE_T::ARC );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 token = NextTok();

 if( m_requiredVersion <= LEGACY_ARC_FORMATTING )
 {
 // In legacy files the start keyword actually gives the arc center...
 if( token != T_start )
 Expecting( T_start );

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

 // ... and the end keyword gives the start point of the arc
 if( token != T_end )
 Expecting( T_end );

 pt.x = parseBoardUnits( "X coordinate" );
 pt.y = parseBoardUnits( "Y coordinate" );
 shape->SetStart( pt );
 NeedRIGHT();
 }
 else
 {
 wxPoint arc_start, arc_mid, arc_end;

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

 arc_start.x = parseBoardUnits( "X coordinate" );
 arc_start.y = parseBoardUnits( "Y coordinate" );
 NeedRIGHT();
 NeedLEFT();
 token = NextTok();

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

 arc_mid.x = parseBoardUnits( "X coordinate" );
 arc_mid.y = parseBoardUnits( "Y coordinate" );
 NeedRIGHT();
 NeedLEFT();
 token = NextTok();

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

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

 shape->SetArcGeometry( arc_start, arc_mid, arc_end );
 }

 break;

 case T_gr_circle:
 shape->SetShape( SHAPE_T::CIRCLE );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 token = NextTok();

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

 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_curve:
 shape->SetShape( SHAPE_T::BEZIER );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 token = NextTok();

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

 shape->SetStart( parseXY() );
 shape->SetBezierC1( parseXY());
 shape->SetBezierC2( parseXY());
 shape->SetEnd( parseXY() );
 NeedRIGHT();
 break;

 case T_gr_rect:
 shape->SetShape( SHAPE_T::RECT );
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 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.
 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 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( SHAPE_T::POLY );
 shape->SetWidth( 0 ); // this is the default value. will be (perhaps) modified later
 shape->SetPolyPoints( {} );

 SHAPE_LINE_CHAIN& outline = shape->GetPolyShape().Outline( 0 );

 token = NextTok();

 if( token == T_locked )
 {
 shape->SetLocked( true );
 token = NextTok();
 }

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

 token = NextTok();

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

 while( (token = NextTok() ) != T_RIGHT )
 {
 parseOutlinePoints( outline );
 }

 break;
 }

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

 bool foundFill = false;
 double angle;

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

 token = NextTok();

 switch( token )
 {
 case T_angle:
 if( m_requiredVersion <= LEGACY_ARC_FORMATTING )
 {
 angle = parseAngle( "arc angle" );

 if( shape->GetShape() == SHAPE_T::ARC )
 shape->SetArcAngleAndEnd( angle, true );

 NeedRIGHT();
 }
 else
 {
 Unexpected( T_angle );
 }

 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;

 // We continue to parse the status field but it is no longer written
 case T_status:
 shape->SetStatus( static_cast<EDA_ITEM_FLAGS>( parseHex() ) );
 NeedRIGHT();
 break;

 // Continue to process "(locked)" format which was output during 5.99 development
 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() == SHAPE_T::RECT || shape->GetShape() == SHAPE_T::CIRCLE ) )
 {
 shape->SetFilled( true );
 }
 else if( shape->GetShape() == SHAPE_T::POLY && shape->GetLayer() != Edge_Cuts )
 {
 // Polygons on non-Edge_Cuts layers were always filled.
 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 PNS::angle(), ARC, BEZIER, CIRCLE, DEFAULT_LINE_WIDTH, Edge_Cuts, LEGACY_ARC_FORMATTING, Millimeter2iu(), parseHex(), POLY, and RECT.

parsePCB_TARGET()

PCB_TARGET * PCB_PARSER::parsePCB_TARGET ( )

private

Definition at line 5489 of file pcb_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_target, nullptr,
 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();
}

parsePCB_TEXT()

PCB_TEXT * PCB_PARSER::parsePCB_TEXT ( )

private

Definition at line 2726 of file pcb_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_gr_text, nullptr,
 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( parseAngle() );
 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 text.

parsePCB_TRACK()

PCB_TRACK * PCB_PARSER::parsePCB_TRACK ( )

private

Definition at line 4711 of file pcb_parser.cpp.

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

 wxPoint pt;
 T token;

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

 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token == T_locked )
 {
 track->SetLocked( true );
 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;

 // We continue to parse the status field but it is no longer written
 case T_status:
 track->SetStatus( static_cast<EDA_ITEM_FLAGS>( parseHex() ) );
 break;

 // Continue to process "(locked)" format which was output during 5.99 development
 case T_locked:
 track->SetLocked( true );
 break;

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

 NeedRIGHT();
 }

 return track.release();
}

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

parsePCB_VIA()

PCB_VIA * PCB_PARSER::parsePCB_VIA ( )

private

Definition at line 4789 of file pcb_parser.cpp.

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

 wxPoint pt;
 T token;

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

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

 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token == T_locked )
 {
 via->SetLocked( true );
 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;

 // We continue to parse the status field but it is no longer written
 case T_status:
 via->SetStatus( static_cast<EDA_ITEM_FLAGS>( parseHex() ) );
 NeedRIGHT();
 break;

 // Continue to process "(locked)" format which was output during 5.99 development
 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" );
 }
 }

 if( !via->GetRemoveUnconnected() )
 via->SetKeepTopBottom( true );

 return via.release();
}

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

parseProperty()

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

private

Definition at line 388 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 1770 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_ViasMinAnnularWidth = 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.SetAuxOrigin( 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.SetGridOrigin( 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_DE