SCH_SEXPR_PARSER Class Reference

Object to parser s-expression symbol library and schematic file formats. More...

#include <sch_sexpr_parser.h>

Inheritance diagram for SCH_SEXPR_PARSER:

Public Member Functions
	SCH_SEXPR_PARSER (LINE_READER *aLineReader=nullptr, PROGRESS_REPORTER *aProgressReporter=nullptr, unsigned aLineCount=0, SCH_SHEET *aRootSheet=nullptr, bool aIsAppending=false)
void	ParseLib (LIB_SYMBOL_MAP &aSymbolLibMap)
LIB_SYMBOL *	ParseSymbol (LIB_SYMBOL_MAP &aSymbolLibMap, int aFileVersion=SEXPR_SYMBOL_LIB_FILE_VERSION)
LIB_ITEM *	ParseDrawItem ()
void	ParseSchematic (SCH_SHEET *aSheet, bool aIsCopyablyOnly=false, int aFileVersion=SEXPR_SCHEMATIC_FILE_VERSION)
	Parse the internal LINE_READER object into aSheet. More...
int	GetParsedRequiredVersion () const

Private Member Functions
void	checkpoint ()
KIID	parseKIID ()
void	parseHeader (TSCHEMATIC_T::T aHeaderType, int aFileVersion)
long	parseHex ()
int	parseInt ()
int	parseInt (const char *aExpected)
int	parseInternalUnits ()
int	parseInternalUnits (const char *aExpected)
int	parseInternalUnits (TSCHEMATIC_T::T aToken)
wxPoint	parseXY ()
bool	parseBool ()
void	parseStroke (STROKE_PARAMS &aStroke)
	Parse stroke definition aStroke. More...
void	parseFill (FILL_PARAMS &aFill)
void	parseEDA_TEXT (EDA_TEXT *aText, bool aConvertOverbarSyntax)
void	parsePinNames (std::unique_ptr< LIB_SYMBOL > &aSymbol)
LIB_FIELD *	parseProperty (std::unique_ptr< LIB_SYMBOL > &aSymbol)
LIB_SHAPE *	parseArc ()
LIB_SHAPE *	parseBezier ()
LIB_SHAPE *	parseCircle ()
LIB_PIN *	parsePin ()
LIB_SHAPE *	parsePolyLine ()
LIB_SHAPE *	parseRectangle ()
LIB_TEXT *	parseText ()
LIB_TEXTBOX *	parseTextBox ()
void	parsePAGE_INFO (PAGE_INFO &aPageInfo)
void	parseTITLE_BLOCK (TITLE_BLOCK &aTitleBlock)
void	parseSchSymbolInstances (SCH_SCREEN *aScreen)
void	parseSchSheetInstances (SCH_SHEET *aRootSheet, SCH_SCREEN *aScreen)
SCH_SHEET_PIN *	parseSchSheetPin (SCH_SHEET *aSheet)
SCH_FIELD *	parseSchField (SCH_ITEM *aParent)
SCH_SYMBOL *	parseSchematicSymbol ()
SCH_BITMAP *	parseImage ()
SCH_SHEET *	parseSheet ()
SCH_JUNCTION *	parseJunction ()
SCH_NO_CONNECT *	parseNoConnect ()
SCH_BUS_WIRE_ENTRY *	parseBusEntry ()
SCH_LINE *	parseLine ()
SCH_SHAPE *	parseSchPolyLine ()
SCH_SHAPE *	parseSchArc ()
SCH_SHAPE *	parseSchCircle ()
SCH_SHAPE *	parseSchRectangle ()
SCH_SHAPE *	parseSchBezier ()
SCH_TEXT *	parseSchText ()
SCH_TEXTBOX *	parseSchTextBox ()
void	parseBusAlias (SCH_SCREEN *aScreen)

Private Attributes
int	m_requiredVersion
	Set to the symbol library file version required. More...
int	m_fieldId
	The current field ID. More...
int	m_unit
	The current unit being parsed. More...
int	m_convert
	The current body style being parsed. More...
wxString	m_symbolName
	The current symbol name. More...
bool	m_appending
	Appending load status. More...
std::set< int >	m_fieldIDsRead
	Field IDs that have been read so far for the current symbol. More...
std::set< KIID >	m_uuids
PROGRESS_REPORTER *	m_progressReporter
const LINE_READER *	m_lineReader
unsigned	m_lastProgressLine
unsigned	m_lineCount
KIID	m_rootUuid
SCH_SHEET *	m_rootSheet
	The rootsheet for full project loads or null for importing a schematic. More...

Detailed Description

Object to parser s-expression symbol library and schematic file formats.

Definition at line 77 of file sch_sexpr_parser.h.

Constructor & Destructor Documentation

SCH_SEXPR_PARSER()

SCH_SEXPR_PARSER::SCH_SEXPR_PARSER	(	LINE_READER *	aLineReader = nullptr,
		PROGRESS_REPORTER *	aProgressReporter = nullptr,
		unsigned	aLineCount = 0,
		SCH_SHEET *	aRootSheet = nullptr,
		bool	aIsAppending = false
	)

Definition at line 67 of file sch_sexpr_parser.cpp.

 :
 SCHEMATIC_LEXER( aLineReader ),
 m_requiredVersion( 0 ),
 m_fieldId( 0 ),
 m_unit( 1 ),
 m_convert( 1 ),
 m_appending( aIsAppending ),
 m_progressReporter( aProgressReporter ),
 m_lineReader( aLineReader ),
 m_lastProgressLine( 0 ),
 m_lineCount( aLineCount ),
 m_rootSheet( aRootSheet )
{
}

Member Function Documentation

checkpoint()

void SCH_SEXPR_PARSER::checkpoint ( )

private

Definition at line 85 of file sch_sexpr_parser.cpp.

{
 const unsigned PROGRESS_DELTA = 250;
 
 if( m_progressReporter )
 {
 unsigned curLine = m_lineReader->LineNumber();
 
 if( curLine > m_lastProgressLine + PROGRESS_DELTA )
 {
 m_progressReporter->SetCurrentProgress( ( (double) curLine )
 / std::max( 1U, m_lineCount ) );
 
 if( !m_progressReporter->KeepRefreshing() )
 THROW_IO_ERROR( ( "Open cancelled by user." ) );
 
 m_lastProgressLine = curLine;
 }
 }
}

References PROGRESS_REPORTER::KeepRefreshing(), LINE_READER::LineNumber(), m_lastProgressLine, m_lineCount, m_lineReader, m_progressReporter, PROGRESS_REPORTER::SetCurrentProgress(), and THROW_IO_ERROR.

Referenced by ParseSchematic().

GetParsedRequiredVersion()

int SCH_SEXPR_PARSER::GetParsedRequiredVersion ( ) const

inline

Definition at line 111 of file sch_sexpr_parser.h.

{ return m_requiredVersion; }

References m_requiredVersion.

Referenced by SCH_SEXPR_PLUGIN_CACHE::Load().

parseArc()

LIB_SHAPE * SCH_SEXPR_PARSER::parseArc ( )

private

Definition at line 939 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_arc, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as an arc." ) );
 
 T token;
 VECTOR2I startPoint( 1, 0 ); // Initialize to a non-degenerate arc just for safety
 VECTOR2I midPoint( 1, 1 );
 VECTOR2I endPoint( 0, 1 );
 bool hasMidPoint = false;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 
 // Parameters for legacy format
 VECTOR2I center( 0, 0 );
 EDA_ANGLE startAngle = ANGLE_0;
 EDA_ANGLE endAngle = ANGLE_90;
 bool hasAngles = false;
 
 std::unique_ptr<LIB_SHAPE> arc = std::make_unique<LIB_SHAPE>( nullptr, SHAPE_T::ARC );
 
 arc->SetUnit( m_unit );
 arc->SetConvert( m_convert );
 
 token = NextTok();
 
 if( token == T_private )
 {
 arc->SetPrivate( true );
 token = NextTok();
 }
 
 for( ; token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_start:
 startPoint = parseXY();
 NeedRIGHT();
 break;
 
 case T_mid:
 midPoint = parseXY();
 NeedRIGHT();
 hasMidPoint = true;
 break;
 
 case T_end:
 endPoint = parseXY();
 NeedRIGHT();
 break;
 
 case T_radius:
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 center = parseXY();
 NeedRIGHT();
 break;
 
 case T_length:
 parseInternalUnits( "radius length" );
 NeedRIGHT();
 break;
 
 case T_angles:
 {
 startAngle = EDA_ANGLE( parseDouble( "start radius angle" ), DEGREES_T );
 endAngle = EDA_ANGLE( parseDouble( "end radius angle" ), DEGREES_T );
 startAngle.Normalize();
 endAngle.Normalize();
 NeedRIGHT();
 hasAngles = true;
 break;
 }
 
 default:
 Expecting( "at, length, or angles" );
 }
 }
 
 break;
 
 case T_stroke:
 parseStroke( stroke );
 arc->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 arc->SetFillMode( fill.m_FillType );
 arc->SetFillColor( fill.m_Color );
 break;
 
 default:
 Expecting( "start, mid, end, radius, stroke, or fill" );
 }
 }
 
 if( hasMidPoint )
 {
 arc->SetArcGeometry( startPoint, midPoint, endPoint );
 
 #if 1
 // Should be not required. Unfortunately it is needed because some bugs created
 // incorrect data after conversion of old libraries to the new arc format using
 // startPoint, midPoint, endPoint
 // Until now, in Eeschema the arc angle should be <= 180 deg.
 // If > 180 (bug...) we need to swap arc ends.
 // However arc angle == 180 deg can also create issues in some cases (plotters, hittest)
 // so also avoid arc == 180 deg
 EDA_ANGLE arc_start, arc_end, arc_angle;
 arc->CalcArcAngles( arc_start, arc_end );
 arc_angle = arc_end - arc_start;
 
 if( arc_angle > ANGLE_180 )
 {
 // Change arc to its complement (360deg - arc_angle)
 arc->SetStart( endPoint );
 arc->SetEnd( startPoint );
 VECTOR2I new_center = CalcArcCenter( arc->GetStart(), arc->GetEnd(),
 ANGLE_360 - arc_angle );
 arc->SetCenter( new_center );
 }
 else if( arc_angle == ANGLE_180 )
 {
 VECTOR2I new_center = CalcArcCenter( arc->GetStart(), arc->GetEnd(),
 EDA_ANGLE( 179.5, DEGREES_T ) );
 arc->SetCenter( new_center );
 }
 #endif
 }
 else if( hasAngles )
 {
 arc->SetCenter( center );
 /*
 * Older versions stored start-end with an implied winding, but the winding was different
 * between LibEdit and PCBNew. Since we now use a common class (EDA_SHAPE) for both we
  * need to flip one of them. LibEdit drew the short straw.
 */
 arc->SetStart( endPoint );
 arc->SetEnd( startPoint );
 
 // Like previously, 180 degrees arcs that create issues are just modified
 // to be < 180 degrees to do not break some other functions ( Draw, Plot, HitTest)
 EDA_ANGLE arc_start, arc_end, arc_angle;
 arc->CalcArcAngles( arc_start, arc_end );
 arc_angle = arc_end - arc_start;
 
 // The arc angle should be <= 180 deg.
 // If > 180 we need to swap arc ends (the first choice was not good)
 if( arc_angle > ANGLE_180 )
 {
 arc->SetStart( startPoint );
 arc->SetEnd( endPoint );
 }
 else if( arc_angle == ANGLE_180 )
 {
 arc->SetStart( startPoint );
 arc->SetEnd( endPoint );
 VECTOR2I new_center = CalcArcCenter( arc->GetStart(), arc->GetEnd(),
 EDA_ANGLE( 179.5, DEGREES_T ) );
 arc->SetCenter( new_center );
 }
 }
 else
 {
 wxFAIL_MSG( "Setting arc without either midpoint or angles not implemented." );
 }
 
 return arc.release();
}

References ANGLE_0, ANGLE_180, ANGLE_360, ANGLE_90, ARC, CalcArcCenter(), DEFAULT, DEFAULT_LINE_WIDTH_MILS, DEGREES_T, FILL_PARAMS::m_Color, m_convert, FILL_PARAMS::m_FillType, m_unit, EDA_IU_SCALE::MilsToIU(), EDA_ANGLE::Normalize(), parseDouble(), parseFill(), parseInternalUnits(), parseStroke(), parseXY(), and schIUScale.

Referenced by ParseDrawItem().

parseBezier()

LIB_SHAPE * SCH_SEXPR_PARSER::parseBezier ( )

private

Definition at line 1125 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_bezier, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a bezier." ) );
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 
 std::unique_ptr<LIB_SHAPE> bezier = std::make_unique<LIB_SHAPE>( nullptr, SHAPE_T::BEZIER );
 
 bezier->SetUnit( m_unit );
 bezier->SetConvert( m_convert );
 
 token = NextTok();
 
 if( token == T_private )
 {
 bezier->SetPrivate( true );
 token = NextTok();
 }
 
 for( ; token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_pts:
 {
 int ii = 0;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok(), ++ii )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_xy )
 Expecting( "xy" );
 
 switch( ii )
 {
 case 0: bezier->SetStart( parseXY() ); break;
 case 1: bezier->SetBezierC1( parseXY() ); break;
 case 2: bezier->SetBezierC2( parseXY() ); break;
 case 3: bezier->SetEnd( parseXY() ); break;
 default: Unexpected( "control point" ); break;
 }
 
 NeedRIGHT();
 }
 }
 break;
 
 case T_stroke:
 parseStroke( stroke );
 bezier->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 bezier->SetFillMode( fill.m_FillType );
 bezier->SetFillColor( fill.m_Color );
 break;
 
 default:
 Expecting( "pts, stroke, or fill" );
 }
 }
 
 bezier->RebuildBezierToSegmentsPointsList( bezier->GetWidth() );
 
 return bezier.release();
}

References BEZIER, DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, m_convert, FILL_PARAMS::m_FillType, m_unit, EDA_IU_SCALE::MilsToIU(), parseFill(), parseStroke(), parseXY(), and schIUScale.

Referenced by ParseDrawItem().

parseBool()

bool SCH_SEXPR_PARSER::parseBool ( )

private

Definition at line 120 of file sch_sexpr_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;
}

Referenced by parseSchematicSymbol(), and ParseSymbol().

parseBusAlias()

void SCH_SEXPR_PARSER::parseBusAlias ( SCH_SCREEN *  aScreen )

private

Definition at line 3963 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( CurTok() == T_bus_alias,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a bus alias." ) );
 wxCHECK( aScreen, /* void */ );
 
 T token;
 std::shared_ptr<BUS_ALIAS> busAlias = std::make_shared<BUS_ALIAS>( aScreen );
 wxString alias;
 wxString member;
 
 NeedSYMBOL();
 
 alias = FromUTF8();
 
 if( m_requiredVersion < 20210621 )
 alias = ConvertToNewOverbarNotation( alias );
 
 busAlias->SetName( alias );
 
 NeedLEFT();
 token = NextTok();
 
 if( token != T_members )
 Expecting( "members" );
 
 token = NextTok();
 
 while( token != T_RIGHT )
 {
 if( !IsSymbol( token ) )
 Expecting( "quoted string" );
 
 member = FromUTF8();
 
 if( m_requiredVersion < 20210621 )
 member = ConvertToNewOverbarNotation( member );
 
 busAlias->Members().emplace_back( member );
 
 token = NextTok();
 }
 
 NeedRIGHT();
 
 aScreen->AddBusAlias( busAlias );
}

References SCH_SCREEN::AddBusAlias(), ConvertToNewOverbarNotation(), and m_requiredVersion.

Referenced by ParseSchematic().

parseBusEntry()

SCH_BUS_WIRE_ENTRY * SCH_SEXPR_PARSER::parseBusEntry ( )

private

Definition at line 3267 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_bus_entry, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a bus entry." ) );
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 std::unique_ptr<SCH_BUS_WIRE_ENTRY> busEntry = std::make_unique<SCH_BUS_WIRE_ENTRY>();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 busEntry->SetPosition( parseXY() );
 NeedRIGHT();
 break;
 
 case T_size:
 {
 wxSize size;
 
 size.SetWidth( parseInternalUnits( "bus entry height" ) );
 size.SetHeight( parseInternalUnits( "bus entry width" ) );
 busEntry->SetSize( size );
 NeedRIGHT();
 break;
 }
 
 case T_stroke:
 parseStroke( stroke );
 busEntry->SetStroke( stroke );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( busEntry->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 default:
 Expecting( "at, size, uuid or stroke" );
 }
 }
 
 return busEntry.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, EDA_IU_SCALE::MilsToIU(), parseInternalUnits(), parseKIID(), parseStroke(), parseXY(), and schIUScale.

Referenced by ParseSchematic().

parseCircle()

LIB_SHAPE * SCH_SEXPR_PARSER::parseCircle ( )

private

Definition at line 1206 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_circle, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a circle." ) );
 
 T token;
 VECTOR2I center( 0, 0 );
 int radius = 1; // defaulting to 0 could result in troublesome math....
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 
 std::unique_ptr<LIB_SHAPE> circle = std::make_unique<LIB_SHAPE>( nullptr, SHAPE_T::CIRCLE );
 
 circle->SetUnit( m_unit );
 circle->SetConvert( m_convert );
 
 token = NextTok();
 
 if( token == T_private )
 {
 circle->SetPrivate( true );
 token = NextTok();
 }
 
 for( ; token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_center:
 center = parseXY();
 NeedRIGHT();
 break;
 
 case T_radius:
 radius = parseInternalUnits( "radius length" );
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 circle->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 circle->SetFillMode( fill.m_FillType );
 circle->SetFillColor( fill.m_Color );
 break;
 
 default:
 Expecting( "center, radius, stroke, or fill" );
 }
 }
 
 circle->SetCenter( center );
 circle->SetEnd( VECTOR2I( center.x + radius, center.y ) );
 
 return circle.release();
}

References CIRCLE, DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, m_convert, FILL_PARAMS::m_FillType, m_unit, EDA_IU_SCALE::MilsToIU(), parseFill(), parseInternalUnits(), parseStroke(), parseXY(), schIUScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by ParseDrawItem().

ParseDrawItem()

LIB_ITEM * SCH_SEXPR_PARSER::ParseDrawItem

(

)

Definition at line 408 of file sch_sexpr_parser.cpp.

{
 switch( CurTok() )
 {
 case T_arc:
 return parseArc();
 break;
 
 case T_bezier:
 return parseBezier();
 break;
 
 case T_circle:
 return parseCircle();
 break;
 
 case T_pin:
 return parsePin();
 break;
 
 case T_polyline:
 return parsePolyLine();
 break;
 
 case T_rectangle:
 return parseRectangle();
 break;
 
 case T_text:
 return parseText();
 break;
 
 case T_text_box:
 return parseTextBox();
 break;
 
 default:
 Expecting( "arc, bezier, circle, pin, polyline, rectangle, or text" );
 }
 
 return nullptr;
}

References parseArc(), parseBezier(), parseCircle(), parsePin(), parsePolyLine(), parseRectangle(), parseText(), and parseTextBox().

Referenced by ParseSymbol().

parseEDA_TEXT()

void SCH_SEXPR_PARSER::parseEDA_TEXT ( EDA_TEXT *  aText, bool  aConvertOverbarSyntax  )

private

Definition at line 540 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( aText && ( CurTok() == T_effects || CurTok() == T_href ),
 "Cannot parse " + GetTokenString( CurTok() ) + " as an 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( aConvertOverbarSyntax && m_requiredVersion < 20210606 )
 aText->SetText( ConvertToNewOverbarNotation( aText->GetText() ) );
 
 T token;
 wxString faceName;
 COLOR4D color = COLOR4D::UNSPECIFIED;
 
 // Various text objects (text boxes, schematic text, etc.) all have their own defaults,
 // but the file format default is {center,center} so we have to set that before parsing.
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
 aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 
 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 )
 token = NextTok();
 
 switch( token )
 {
 case T_face:
 NeedSYMBOL();
 faceName = FromUTF8();
 NeedRIGHT();
 break;
 
 case T_size:
 {
 wxSize sz;
 sz.SetHeight( parseInternalUnits( "text height" ) );
 sz.SetWidth( parseInternalUnits( "text width" ) );
 aText->SetTextSize( sz );
 NeedRIGHT();
 break;
 }
 
 case T_thickness:
 aText->SetTextThickness( parseInternalUnits( "text thickness" ) );
 NeedRIGHT();
 break;
 
 case T_bold:
 aText->SetBold( true );
 break;
 
 case T_italic:
 aText->SetItalic( true );
 break;
 
 case T_color:
 color.r = parseInt( "red" ) / 255.0;
 color.g = parseInt( "green" ) / 255.0;
 color.b = parseInt( "blue" ) / 255.0;
 color.a = Clamp( parseDouble( "alpha" ), 0.0, 1.0 );
 aText->SetTextColor( color );
 NeedRIGHT();
 break;
 
 case T_line_spacing:
 aText->SetLineSpacing( parseDouble( "line spacing" ) );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "face, size, thickness, line_spacing, bold, or italic" );
 }
 }
 
 if( !faceName.IsEmpty() )
 {
 aText->SetFont( KIFONT::FONT::GetFont( faceName, aText->IsBold(),
 aText->IsItalic() ) );
 }
 
 break;
 
 case T_justify:
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 switch( token )
 {
 case T_left: aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT ); break;
 case T_right: aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT ); break;
 case T_top: aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP ); break;
 case T_bottom: aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM ); break;
 // Do not set mirror property for schematic text elements
 case T_mirror: break;
 default: Expecting( "left, right, top, bottom, or mirror" );
 }
 }
 
 break;
 
 case T_href:
 {
 NeedSYMBOL();
 wxString hyperlink = FromUTF8();
 
 if( !aText->ValidateHyperlink( hyperlink ) )
 {
 THROW_PARSE_ERROR( wxString::Format( _( "Invalid hyperlink url '%s'" ), hyperlink ),
 CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 else
 {
 aText->SetHyperlink( hyperlink );
 }
 
 NeedRIGHT();
 }
 break;
 
 case T_hide:
 aText->SetVisible( false );
 break;
 
 default:
 Expecting( "font, justify, hide or href" );
 }
 }
}

References _, Clamp(), color, ConvertToNewOverbarNotation(), Format(), KIFONT::FONT::GetFont(), EDA_TEXT::GetText(), GR_TEXT_H_ALIGN_CENTER, GR_TEXT_H_ALIGN_LEFT, GR_TEXT_H_ALIGN_RIGHT, GR_TEXT_V_ALIGN_BOTTOM, GR_TEXT_V_ALIGN_CENTER, GR_TEXT_V_ALIGN_TOP, EDA_TEXT::IsBold(), EDA_TEXT::IsItalic(), m_requiredVersion, parseDouble(), parseInt(), parseInternalUnits(), EDA_TEXT::SetBold(), EDA_TEXT::SetFont(), EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetHyperlink(), EDA_TEXT::SetItalic(), EDA_TEXT::SetLineSpacing(), EDA_TEXT::SetText(), EDA_TEXT::SetTextColor(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetTextThickness(), EDA_TEXT::SetVertJustify(), EDA_TEXT::SetVisible(), THROW_PARSE_ERROR, and EDA_TEXT::ValidateHyperlink().

Referenced by parsePin(), parseProperty(), parseSchField(), parseSchSheetPin(), parseSchText(), parseSchTextBox(), parseText(), and parseTextBox().

parseFill()

void SCH_SEXPR_PARSER::parseFill ( FILL_PARAMS &  aFill )

private

Definition at line 485 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( CurTok() == T_fill, "Cannot parse " + GetTokenString( CurTok() ) + " as a fill." );
 
 aFill.m_FillType = FILL_T::NO_FILL;
 aFill.m_Color = COLOR4D::UNSPECIFIED;
 
 T token;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_type:
 {
 token = NextTok();
 
 switch( token )
 {
 case T_none: aFill.m_FillType = FILL_T::NO_FILL; break;
 case T_outline: aFill.m_FillType = FILL_T::FILLED_SHAPE; break;
 case T_background: aFill.m_FillType = FILL_T::FILLED_WITH_BG_BODYCOLOR; break;
 case T_color: aFill.m_FillType = FILL_T::FILLED_WITH_COLOR; break;
 default: Expecting( "none, outline, color or background" );
 }
 
 NeedRIGHT();
 break;
 }
 
 case T_color:
 {
 COLOR4D color;
 
 color.r = parseInt( "red" ) / 255.0;
 color.g = parseInt( "green" ) / 255.0;
 color.b = parseInt( "blue" ) / 255.0;
 color.a = Clamp( parseDouble( "alpha" ), 0.0, 1.0 );
 aFill.m_Color = color;
 NeedRIGHT();
 break;
 }
 
 default:
 Expecting( "type or color" );
 }
 }
}

References Clamp(), color, FILLED_SHAPE, FILLED_WITH_BG_BODYCOLOR, FILLED_WITH_COLOR, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, NO_FILL, parseDouble(), and parseInt().

Referenced by parseArc(), parseBezier(), parseCircle(), parsePolyLine(), parseRectangle(), parseSchArc(), parseSchBezier(), parseSchCircle(), parseSchPolyLine(), parseSchRectangle(), parseSchTextBox(), parseSheet(), and parseTextBox().

parseHeader()

void SCH_SEXPR_PARSER::parseHeader ( TSCHEMATIC_T::T  aHeaderType, int  aFileVersion  )

private

Definition at line 677 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( CurTok() == aHeaderType,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a header." ) );
 
 NeedLEFT();
 
 T tok = NextTok();
 
 if( tok == T_version )
 {
 m_requiredVersion = parseInt( FromUTF8().mb_str( wxConvUTF8 ) );
 
 if( m_requiredVersion > aFileVersion )
 throw FUTURE_FORMAT_ERROR( FromUTF8() );
 
 NeedRIGHT();
 
 // Skip the host name and host build version information.
 NeedLEFT();
 NeedSYMBOL();
 NeedSYMBOL();
 
 if( m_requiredVersion < 20200827 )
 NeedSYMBOL();
 
 NeedRIGHT();
 }
 else
 {
 m_requiredVersion = aFileVersion;
 
 // Skip the host name and host build version information.
 NeedSYMBOL();
 NeedSYMBOL();
 NeedRIGHT();
 }
}

References m_requiredVersion, and parseInt().

Referenced by ParseLib(), and ParseSchematic().

parseHex()

long SCH_SEXPR_PARSER::parseHex ( )

inlineprivate

Definition at line 120 of file sch_sexpr_parser.h.

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

parseImage()

SCH_BITMAP * SCH_SEXPR_PARSER::parseImage ( )

private

Definition at line 2909 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_image, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as an image." ) );
 
 T token;
 std::unique_ptr<SCH_BITMAP> bitmap = std::make_unique<SCH_BITMAP>();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 bitmap->SetPosition( parseXY() );
 NeedRIGHT();
 break;
 
 case T_scale:
 bitmap->GetImage()->SetScale( parseDouble( "image scale factor" ) );
 
 if( !std::isnormal( bitmap->GetImage()->GetScale() ) )
 bitmap->GetImage()->SetScale( 1.0 );
 
 NeedRIGHT();
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( bitmap->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 case T_data:
 {
 token = NextTok();
 
 wxString data;
 
 // Reserve 128K because most image files are going to be larger than the default
 // 1K that wxString reserves.
 data.reserve( 1 << 17 );
 
 while( token != T_RIGHT )
 {
 if( !IsSymbol( token ) )
 Expecting( "base64 image data" );
 
 data += FromUTF8();
 token = NextTok();
 }
 
 wxMemoryBuffer buffer = wxBase64Decode( data );
 wxMemoryOutputStream stream( buffer.GetData(), buffer.GetBufSize() );
 wxImage* image = new wxImage();
 wxMemoryInputStream istream( stream );
 image->LoadFile( istream, wxBITMAP_TYPE_PNG );
 bitmap->GetImage()->SetImage( image );
 break;
 }
 
 default:
 Expecting( "at, scale, uuid or data" );
 }
 }
 
 return bitmap.release();
}

References image, parseDouble(), parseKIID(), and parseXY().

Referenced by ParseSchematic().

parseInt() [1/2]

int SCH_SEXPR_PARSER::parseInt ( )

inlineprivate

Definition at line 126 of file sch_sexpr_parser.h.

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

Referenced by parseEDA_TEXT(), parseFill(), parseHeader(), parseInt(), parseJunction(), parsePin(), parseProperty(), parseSchematicSymbol(), parseSchField(), parseSchSymbolInstances(), and parseTITLE_BLOCK().

parseInt() [2/2]

int SCH_SEXPR_PARSER::parseInt ( const char *  aExpected )

inlineprivate

Definition at line 131 of file sch_sexpr_parser.h.

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

References parseInt().

parseInternalUnits() [1/3]

int SCH_SEXPR_PARSER::parseInternalUnits ( )

private

Definition at line 452 of file sch_sexpr_parser.cpp.

{
 auto retval = parseDouble() * schIUScale.IU_PER_MM;
 
 // Schematic internal units are represented as integers. Any values that are
 // larger or smaller than the schematic units represent undefined behavior for
 // the system. Limit values to the largest that can be displayed on the screen.
 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 EDA_IU_SCALE::IU_PER_MM, KiROUND(), parseDouble(), and schIUScale.

Referenced by parseArc(), parseBusEntry(), parseCircle(), parseEDA_TEXT(), parseInternalUnits(), parseJunction(), parsePin(), parsePinNames(), parseSchCircle(), parseSchText(), parseSheet(), and parseXY().

parseInternalUnits() [2/3]

int SCH_SEXPR_PARSER::parseInternalUnits ( const char *  aExpected )

private

Definition at line 465 of file sch_sexpr_parser.cpp.

{
 auto retval = parseDouble( aExpected ) * schIUScale.IU_PER_MM;
 
 constexpr double int_limit = std::numeric_limits<int>::max() * 0.7071;
 
 return KiROUND( Clamp<double>( -int_limit, retval, int_limit ) );
}

References EDA_IU_SCALE::IU_PER_MM, KiROUND(), parseDouble(), and schIUScale.

parseInternalUnits() [3/3]

int SCH_SEXPR_PARSER::parseInternalUnits ( TSCHEMATIC_T::T  aToken )

inlineprivate

Definition at line 141 of file sch_sexpr_parser.h.

 {
 return parseInternalUnits( GetTokenText( aToken ) );
 }

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

parseJunction()

SCH_JUNCTION * SCH_SEXPR_PARSER::parseJunction ( )

private

Definition at line 3174 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_junction, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a junction." ) );
 
 T token;
 std::unique_ptr<SCH_JUNCTION> junction = std::make_unique<SCH_JUNCTION>();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 junction->SetPosition( parseXY() );
 NeedRIGHT();
 break;
 
 case T_diameter:
 junction->SetDiameter( parseInternalUnits( "junction diameter" ) );
 NeedRIGHT();
 break;
 
 case T_color:
 {
 COLOR4D color;
 
 color.r = parseInt( "red" ) / 255.0;
 color.g = parseInt( "green" ) / 255.0;
 color.b = parseInt( "blue" ) / 255.0;
 color.a = Clamp( parseDouble( "alpha" ), 0.0, 1.0 );
 
 junction->SetColor( color );
 NeedRIGHT();
 break;
 }
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( junction->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 default:
 Expecting( "at, diameter, color or uuid" );
 }
 }
 
 return junction.release();
}

References Clamp(), color, parseDouble(), parseInt(), parseInternalUnits(), parseKIID(), and parseXY().

Referenced by ParseSchematic().

parseKIID()

KIID SCH_SEXPR_PARSER::parseKIID ( )

private

Definition at line 107 of file sch_sexpr_parser.cpp.

{
 KIID id( FromUTF8() );
 
 while( m_uuids.count( id ) )
 id.Increment();
 
 m_uuids.insert( id );
 
 return id;
}

References m_uuids.

Referenced by parseBusEntry(), parseImage(), parseJunction(), parseLine(), parseNoConnect(), ParseSchematic(), parseSchematicSymbol(), parseSchPolyLine(), parseSchSheetPin(), parseSchText(), and parseSheet().

ParseLib()

void SCH_SEXPR_PARSER::ParseLib

(

LIB_SYMBOL_MAP &

aSymbolLibMap

)

Definition at line 135 of file sch_sexpr_parser.cpp.

{
 T token;
 
 NeedLEFT();
 NextTok();
 parseHeader( T_kicad_symbol_lib, SEXPR_SYMBOL_LIB_FILE_VERSION );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token == T_symbol )
 {
 m_unit = 1;
 m_convert = 1;
 LIB_SYMBOL* symbol = ParseSymbol( aSymbolLibMap, m_requiredVersion );
 aSymbolLibMap[symbol->GetName()] = symbol;
 }
 else
 {
 Expecting( "symbol" );
 }
 }
}

References LIB_SYMBOL::GetName(), m_convert, m_requiredVersion, m_unit, parseHeader(), ParseSymbol(), and SEXPR_SYMBOL_LIB_FILE_VERSION.

Referenced by SCH_SEXPR_PLUGIN_CACHE::Load().

parseLine()

SCH_LINE * SCH_SEXPR_PARSER::parseLine ( )

private

Definition at line 3382 of file sch_sexpr_parser.cpp.

{
 // Note: T_polyline is deprecated in this code: it is now handled by
 // parseSchPolyLine() that can handle true polygons, and not only one segment.
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 int layer;
 
 switch( CurTok() )
 {
 case T_polyline: layer = LAYER_NOTES; break;
 case T_wire: layer = LAYER_WIRE; break;
 case T_bus: layer = LAYER_BUS; break;
 default:
 wxCHECK_MSG( false, nullptr, "Cannot parse " + GetTokenString( CurTok() ) + " as a line." );
 }
 
 std::unique_ptr<SCH_LINE> line = std::make_unique<SCH_LINE>( VECTOR2I(), layer );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_pts:
 NeedLEFT();
 token = NextTok();
 
 if( token != T_xy )
 Expecting( "xy" );
 
 line->SetStartPoint( parseXY() );
 NeedRIGHT();
 NeedLEFT();
 token = NextTok();
 
 if( token != T_xy )
 Expecting( "xy" );
 
 line->SetEndPoint( parseXY() );
 NeedRIGHT();
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 line->SetStroke( stroke );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( line->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 default:
 Expecting( "at, uuid or stroke" );
 }
 }
 
 return line.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, LAYER_BUS, LAYER_NOTES, LAYER_WIRE, EDA_IU_SCALE::MilsToIU(), parseKIID(), parseStroke(), parseXY(), and schIUScale.

Referenced by ParseSchematic().

parseNoConnect()

SCH_NO_CONNECT * SCH_SEXPR_PARSER::parseNoConnect ( )

private

Definition at line 3230 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_no_connect, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a no connect." ) );
 
 T token;
 std::unique_ptr<SCH_NO_CONNECT> no_connect = std::make_unique<SCH_NO_CONNECT>();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 no_connect->SetPosition( parseXY() );
 NeedRIGHT();
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( no_connect->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 default:
 Expecting( "at or uuid" );
  }
 }
 
 return no_connect.release();
}

References parseKIID(), and parseXY().

Referenced by ParseSchematic().

parsePAGE_INFO()

void SCH_SEXPR_PARSER::parsePAGE_INFO ( PAGE_INFO &  aPageInfo )

private

Definition at line 1761 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( ( CurTok() == T_page && m_requiredVersion <= 20200506 ) || CurTok() == T_paper,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a PAGE_INFO." ) );
 
 T token;
 
 NeedSYMBOL();
 
 wxString pageType = FromUTF8();
 
 if( !aPageInfo.SetType( pageType ) )
 {
 THROW_PARSE_ERROR( _( "Invalid page type" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 if( pageType == PAGE_INFO::Custom )
 {
 int width = EDA_UNIT_UTILS::Mm2mils( parseDouble( "width" ) ); // width stored in mm so we convert to mils
 
 // Perform some controls to avoid crashes if the size is edited by hands
 if( width < MIN_PAGE_SIZE_MILS )
 width = MIN_PAGE_SIZE_MILS;
 else if( width > MAX_PAGE_SIZE_EESCHEMA_MILS )
 width = MAX_PAGE_SIZE_EESCHEMA_MILS;
 
 int height = EDA_UNIT_UTILS::Mm2mils( parseDouble( "height" ) ); // height stored in mm so we convert to mils
 
 if( height < MIN_PAGE_SIZE_MILS )
 height = MIN_PAGE_SIZE_MILS;
 else if( height > MAX_PAGE_SIZE_EESCHEMA_MILS )
 height = MAX_PAGE_SIZE_EESCHEMA_MILS;
 
 aPageInfo.SetWidthMils( width );
 aPageInfo.SetHeightMils( height );
 }
 
 token = NextTok();
 
 if( token == T_portrait )
 {
 aPageInfo.SetPortrait( true );
 NeedRIGHT();
 }
 else if( token != T_RIGHT )
 {
 Expecting( "portrait" );
 }
}

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

Referenced by ParseSchematic().

parsePin()

LIB_PIN * SCH_SEXPR_PARSER::parsePin ( )

private

Definition at line 1272 of file sch_sexpr_parser.cpp.

{
 auto parseType = [&]( T token ) -> ELECTRICAL_PINTYPE
 {
 switch( token )
 {
 case T_input: return ELECTRICAL_PINTYPE::PT_INPUT;
 case T_output: return ELECTRICAL_PINTYPE::PT_OUTPUT;
 case T_bidirectional: return ELECTRICAL_PINTYPE::PT_BIDI;
 case T_tri_state: return ELECTRICAL_PINTYPE::PT_TRISTATE;
 case T_passive: return ELECTRICAL_PINTYPE::PT_PASSIVE;
 case T_unspecified: return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
 case T_power_in: return ELECTRICAL_PINTYPE::PT_POWER_IN;
 case T_power_out: return ELECTRICAL_PINTYPE::PT_POWER_OUT;
 case T_open_collector: return ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR;
 case T_open_emitter: return ELECTRICAL_PINTYPE::PT_OPENEMITTER;
 case T_unconnected:
 case T_no_connect: return ELECTRICAL_PINTYPE::PT_NC;
 case T_free: return ELECTRICAL_PINTYPE::PT_NIC;
 
 default:
 Expecting( "input, output, bidirectional, tri_state, passive, "
 "unspecified, power_in, power_out, open_collector, "
 "open_emitter, free or no_connect" );
 return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
 }
 };
 
 auto parseShape = [&]( T token ) -> GRAPHIC_PINSHAPE
 {
 switch( token )
 {
 case T_line: return GRAPHIC_PINSHAPE::LINE;
 case T_inverted: return GRAPHIC_PINSHAPE::INVERTED;
 case T_clock: return GRAPHIC_PINSHAPE::CLOCK;
 case T_inverted_clock: return GRAPHIC_PINSHAPE::INVERTED_CLOCK;
 case T_input_low: return GRAPHIC_PINSHAPE::INPUT_LOW;
 case T_clock_low: return GRAPHIC_PINSHAPE::CLOCK_LOW;
 case T_output_low: return GRAPHIC_PINSHAPE::OUTPUT_LOW;
 case T_edge_clock_high: return GRAPHIC_PINSHAPE::FALLING_EDGE_CLOCK;
 case T_non_logic: return GRAPHIC_PINSHAPE::NONLOGIC;
 
 default:
 Expecting( "line, inverted, clock, inverted_clock, input_low, "
 "clock_low, output_low, edge_clock_high, non_logic" );
 return GRAPHIC_PINSHAPE::LINE;
 }
 };
 
 wxCHECK_MSG( CurTok() == T_pin, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a pin token." ) );
 
 T token;
 wxString tmp;
 wxString error;
 std::unique_ptr<LIB_PIN> pin = std::make_unique<LIB_PIN>( nullptr );
 
 pin->SetUnit( m_unit );
 pin->SetConvert( m_convert );
 
 // Pin electrical type.
 token = NextTok();
 pin->SetType( parseType( token ) );
 
 // Pin shape.
 token = NextTok();
 pin->SetShape( parseShape( token ) );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token == T_hide )
 {
 pin->SetVisible( false );
 continue;
 }
 
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 pin->SetPosition( parseXY() );
 
 switch( parseInt( "pin orientation" ) )
 {
 case 0: pin->SetOrientation( PIN_RIGHT ); break;
 case 90: pin->SetOrientation( PIN_UP ); break;
 case 180: pin->SetOrientation( PIN_LEFT ); break;
 case 270: pin->SetOrientation( PIN_DOWN ); break;
 default: Expecting( "0, 90, 180, or 270" );
 }
 
 NeedRIGHT();
 break;
 
 case T_length:
 pin->SetLength( parseInternalUnits( "pin length" ) );
 NeedRIGHT();
 break;
 
 case T_name:
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid pin name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 if( m_requiredVersion < 20210606 )
 pin->SetName( ConvertToNewOverbarNotation( FromUTF8() ) );
 else
 pin->SetName( FromUTF8() );
 
 token = NextTok();
 
 if( token != T_RIGHT )
 {
 token = NextTok();
 
 if( token == T_effects )
 {
 // The EDA_TEXT font effects formatting is used so use and EDA_TEXT object
 // so duplicate parsing is not required.
 EDA_TEXT text( schIUScale.MilsToIU( DEFAULT_SIZE_TEXT ) );
 
 parseEDA_TEXT( &text, true );
 pin->SetNameTextSize( text.GetTextHeight() );
 NeedRIGHT();
 }
 else
 {
 Expecting( "effects" );
 }
 }
 
 break;
 
 case T_number:
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid pin number" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
 
 pin->SetNumber( FromUTF8() );
 token = NextTok();
 
 if( token != T_RIGHT )
 {
 token = NextTok();
 
 if( token == T_effects )
 {
 // The EDA_TEXT font effects formatting is used so use and EDA_TEXT object
 // so duplicate parsing is not required.
 EDA_TEXT text( schIUScale.MilsToIU( DEFAULT_SIZE_TEXT ) );
 
 parseEDA_TEXT( &text, false );
 pin->SetNumberTextSize( text.GetTextHeight() );
 NeedRIGHT();
 }
 else
 {
 Expecting( "effects" );
 }
 }
 
 break;
 
 case T_alternate:
 {
 LIB_PIN::ALT alt;
 
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid alternate pin name" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
 
 alt.m_Name = FromUTF8();
 
 token = NextTok();
 alt.m_Type = parseType( token );
 
 token = NextTok();
 alt.m_Shape = parseShape( token );
 
 pin->GetAlternates()[ alt.m_Name ] = alt;
 
 NeedRIGHT();
 break;
 }
 
 default:
 Expecting( "at, name, number, length, or alternate" );
 }
 }
 
 return pin.release();
}

References _, CLOCK, CLOCK_LOW, ConvertToNewOverbarNotation(), DEFAULT_SIZE_TEXT, FALLING_EDGE_CLOCK, INPUT_LOW, INVERTED, INVERTED_CLOCK, LINE, m_convert, LIB_PIN::ALT::m_Name, m_requiredVersion, LIB_PIN::ALT::m_Shape, LIB_PIN::ALT::m_Type, m_unit, EDA_IU_SCALE::MilsToIU(), NONLOGIC, OUTPUT_LOW, parseEDA_TEXT(), parseInt(), parseInternalUnits(), parseShape(), parseXY(), pin, PIN_DOWN, PIN_LEFT, PIN_RIGHT, PIN_UP, PT_BIDI, PT_INPUT, PT_NC, PT_NIC, PT_OPENCOLLECTOR, PT_OPENEMITTER, PT_OUTPUT, PT_PASSIVE, PT_POWER_IN, PT_POWER_OUT, PT_TRISTATE, PT_UNSPECIFIED, schIUScale, text, and THROW_PARSE_ERROR.

Referenced by ParseDrawItem().

parsePinNames()

void SCH_SEXPR_PARSER::parsePinNames ( std::unique_ptr< LIB_SYMBOL > &  aSymbol )

private

Definition at line 717 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( CurTok() == T_pin_names,
 "Cannot parse " + GetTokenString( CurTok() ) + " as a pin_name token." );
 
 T token = NextTok();
 
 if( token == T_LEFT )
 {
 token = NextTok();
 
 if( token != T_offset )
 Expecting( "offset" );
 
 aSymbol->SetPinNameOffset( parseInternalUnits( "pin name offset" ) );
 NeedRIGHT();
 token = NextTok(); // Either ) or hide
 }
 
 if( token == T_hide )
 {
 aSymbol->SetShowPinNames( false );
 NeedRIGHT();
 }
 else if( token != T_RIGHT )
 {
 THROW_PARSE_ERROR( _( "Invalid pin names definition" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
}

References _, parseInternalUnits(), and THROW_PARSE_ERROR.

Referenced by ParseSymbol().

parsePolyLine()

LIB_SHAPE * SCH_SEXPR_PARSER::parsePolyLine ( )

private

Definition at line 1482 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_polyline, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a poly." ) );
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<LIB_SHAPE> poly = std::make_unique<LIB_SHAPE>( nullptr, SHAPE_T::POLY );
 
 poly->SetUnit( m_unit );
 poly->SetConvert( m_convert );
 
 token = NextTok();
 
 if( token == T_private )
 {
 poly->SetPrivate( true );
 token = NextTok();
 }
 
 for( ; token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_pts:
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_xy )
 Expecting( "xy" );
 
 poly->AddPoint( parseXY() );
 
 NeedRIGHT();
 }
 
 break;
 
 case T_stroke:
 parseStroke( stroke );
 poly->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 poly->SetFillMode( fill.m_FillType );
 poly->SetFillColor( fill.m_Color );
 break;
 
 default:
 Expecting( "pts, stroke, or fill" );
 }
 }
 
 return poly.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, m_convert, FILL_PARAMS::m_FillType, m_unit, EDA_IU_SCALE::MilsToIU(), parseFill(), parseStroke(), parseXY(), POLY, and schIUScale.

Referenced by ParseDrawItem().

parseProperty()

LIB_FIELD * SCH_SEXPR_PARSER::parseProperty ( std::unique_ptr< LIB_SYMBOL > &  aSymbol )

private

Definition at line 749 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_property, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a property." ) );
 wxCHECK( aSymbol, nullptr );
 
 wxString name;
 wxString value;
 std::unique_ptr<LIB_FIELD> field = std::make_unique<LIB_FIELD>( aSymbol.get(),
 MANDATORY_FIELDS );
 
 T token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid property name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 name = FromUTF8();
 
 if( name.IsEmpty() )
 {
 THROW_PARSE_ERROR( _( "Empty property name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 field->SetName( name );
 
 // Correctly set the ID based on canonical (untranslated) field name
 // If ID is stored in the file (old versions), it will overwrite this
 for( int ii = 0; ii < MANDATORY_FIELDS; ++ii )
 {
 if( !name.CmpNoCase( TEMPLATE_FIELDNAME::GetDefaultFieldName( ii ) ) )
 {
 field->SetId( ii );
 break;
 }
 }
 
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid property value" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 // Empty property values are valid.
 value = FromUTF8();
 
 field->SetText( value );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_id:
 field->SetId( parseInt( "field ID" ) );
 NeedRIGHT();
 break;
 
 case T_at:
 field->SetPosition( parseXY() );
 field->SetTextAngle( EDA_ANGLE( parseDouble( "text angle" ), DEGREES_T ) );
 NeedRIGHT();
 break;
 
 case T_effects:
 parseEDA_TEXT( static_cast<EDA_TEXT*>( field.get() ), field->GetId() == VALUE_FIELD );
 break;
 
 case T_show_name:
 field->SetNameShown();
 NeedRIGHT();
 break;
 
 case T_do_not_autoplace:
 field->SetCanAutoplace( false );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "id, at, show_name, do_not_autoplace, or effects" );
 }
 }
 
 // Due to an bug when in #LIB_SYMBOL::Flatten, duplicate ids slipped through
 // when writing files. This section replaces duplicate #LIB_FIELD indices on
 // load.
 if( m_fieldIDsRead.count( field->GetId() ) )
 {
 int nextAvailableId = field->GetId() + 1;
 
 while( m_fieldIDsRead.count( nextAvailableId ) )
 nextAvailableId += 1;
 
 field->SetId( nextAvailableId );
 }
 
 LIB_FIELD* existingField;
 
 if( field->GetId() < MANDATORY_FIELDS )
 {
 existingField = aSymbol->GetFieldById( field->GetId() );
 
 *existingField = *field;
 m_fieldIDsRead.insert( field->GetId() );
 return existingField;
 }
 else if( name == "ki_keywords" )
 {
 // Not a LIB_FIELD object yet.
 aSymbol->SetKeyWords( value );
 return nullptr;
 }
 else if( name == "ki_description" )
 {
 // Not a LIB_FIELD object yet.
 aSymbol->SetDescription( value );
 return nullptr;
 }
 else if( name == "ki_fp_filters" )
 {
 // Not a LIB_FIELD object yet.
 wxArrayString filters;
 wxStringTokenizer tokenizer( value );
 
 while( tokenizer.HasMoreTokens() )
 {
 wxString curr_token = UnescapeString( tokenizer.GetNextToken() );
 filters.Add( curr_token );
 }
 
 aSymbol->SetFPFilters( filters );
 return nullptr;
 }
 else if( name == "ki_locked" )
 {
 // This is a temporary LIB_FIELD object until interchangeable units are determined on
 // the fly.
 aSymbol->LockUnits( true );
 return nullptr;
 }
 else
 {
 // At this point, a user field is read.
 existingField = aSymbol->FindField( field->GetCanonicalName() );
 
#if 1 // Enable it to modify the name of the field to add if already existing
 // Disable it to skip the field having the same name as previous field
 if( existingField )
 {
 // We cannot handle 2 fields with the same name, so because the field name
 // is already in use, try to build a new name (oldname_x)
 wxString base_name = field->GetCanonicalName();
 
 // Arbitrary limit 10 attempts to find a new name
 for( int ii = 1; ii < 10 && existingField; ii++ )
 {
 wxString newname = base_name;
 newname << '_' << ii;
 
 existingField = aSymbol->FindField( newname );
 
 if( !existingField ) // the modified name is not found, use it
 field->SetName( newname );
 }
 }
#endif
 if( !existingField )
 {
 aSymbol->AddDrawItem( field.get(), false );
 m_fieldIDsRead.insert( field->GetId() );
 return field.release();
 }
 else
 {
 // We cannot handle 2 fields with the same name, so skip this one
 return nullptr;
 }
 }
}

References _, DEGREES_T, LIB_FIELD::GetCanonicalName(), TEMPLATE_FIELDNAME::GetDefaultFieldName(), m_fieldIDsRead, MANDATORY_FIELDS, name, parseDouble(), parseEDA_TEXT(), parseInt(), parseXY(), THROW_PARSE_ERROR, UnescapeString(), and VALUE_FIELD.

Referenced by ParseSymbol().

parseRectangle()

LIB_SHAPE * SCH_SEXPR_PARSER::parseRectangle ( )

private

Definition at line 1550 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_rectangle, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a rectangle." ) );
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<LIB_SHAPE> rectangle = std::make_unique<LIB_SHAPE>( nullptr, SHAPE_T::RECT );
 
 rectangle->SetUnit( m_unit );
 rectangle->SetConvert( m_convert );
 
 token = NextTok();
 
 if( token == T_private )
 {
 rectangle->SetPrivate( true );
 token = NextTok();
 }
 
 for( ; token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_start:
 rectangle->SetPosition( parseXY() );
 NeedRIGHT();
 break;
 
 case T_end:
 rectangle->SetEnd( parseXY() );
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 rectangle->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 rectangle->SetFillMode( fill.m_FillType );
 rectangle->SetFillColor( fill.m_Color );
 break;
 
 default:
 Expecting( "start, end, stroke, or fill" );
 }
 }
 
 return rectangle.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, m_convert, FILL_PARAMS::m_FillType, m_unit, EDA_IU_SCALE::MilsToIU(), parseFill(), parseStroke(), parseXY(), RECT, and schIUScale.

Referenced by ParseDrawItem().

parseSchArc()

SCH_SHAPE * SCH_SEXPR_PARSER::parseSchArc ( )

private

Definition at line 3451 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_arc, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as an arc." ) );
 
 T token;
 VECTOR2I startPoint;
 VECTOR2I midPoint;
 VECTOR2I endPoint;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<SCH_SHAPE> arc = std::make_unique<SCH_SHAPE>( SHAPE_T::ARC );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_start:
 startPoint = parseXY();
 NeedRIGHT();
 break;
 
 case T_mid:
 midPoint = parseXY();
 NeedRIGHT();
 break;
 
 case T_end:
 endPoint = parseXY();
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 arc->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 arc->SetFillMode( fill.m_FillType );
 arc->SetFillColor( fill.m_Color );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( arc->m_Uuid ) = KIID( FromUTF8() );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "start, mid, end, stroke, fill or uuid" );
 }
 }
 
 arc->SetArcGeometry( startPoint, midPoint, endPoint );
 
 return arc.release();
}

References ARC, DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, EDA_IU_SCALE::MilsToIU(), parseFill(), parseStroke(), parseXY(), and schIUScale.

Referenced by ParseSchematic().

parseSchBezier()

SCH_SHAPE * SCH_SEXPR_PARSER::parseSchBezier ( )

private

Definition at line 3631 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_bezier, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a bezier." ) );
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<SCH_SHAPE> bezier = std::make_unique<SCH_SHAPE>( SHAPE_T::BEZIER );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_pts:
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_xy )
 Expecting( "xy" );
 
 bezier->AddPoint( parseXY() );
 
 NeedRIGHT();
 }
 
 break;
 
 case T_stroke:
 parseStroke( stroke );
 bezier->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 bezier->SetFillMode( fill.m_FillType );
 bezier->SetFillColor( fill.m_Color );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( bezier->m_Uuid ) = KIID( FromUTF8() );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "pts, stroke, fill or uuid" );
 }
 }
 
 return bezier.release();
}

References BEZIER, DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, EDA_IU_SCALE::MilsToIU(), parseFill(), parseStroke(), parseXY(), and schIUScale.

Referenced by ParseSchematic().

parseSchCircle()

SCH_SHAPE * SCH_SEXPR_PARSER::parseSchCircle ( )

private

Definition at line 3516 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_circle, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a circle." ) );
 
 T token;
 VECTOR2I center;
 int radius = 0;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<SCH_SHAPE> circle = std::make_unique<SCH_SHAPE>( SHAPE_T::CIRCLE );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_center:
 center = parseXY();
 NeedRIGHT();
 break;
 
 case T_radius:
 radius = parseInternalUnits( "radius length" );
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 circle->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 circle->SetFillMode( fill.m_FillType );
 circle->SetFillColor( fill.m_Color );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( circle->m_Uuid ) = KIID( FromUTF8() );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "center, radius, stroke, fill or uuid" );
 }
 }
 
 circle->SetCenter( center );
 circle->SetEnd( VECTOR2I( center.x + radius, center.y ) );
 
 return circle.release();
}

References CIRCLE, DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, EDA_IU_SCALE::MilsToIU(), parseFill(), parseInternalUnits(), parseStroke(), parseXY(), schIUScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by ParseSchematic().

ParseSchematic()

void SCH_SEXPR_PARSER::ParseSchematic	(	SCH_SHEET *	aSheet,
		bool	aIsCopyablyOnly = false,
		int	aFileVersion = SEXPR_SCHEMATIC_FILE_VERSION
	)

Parse the internal LINE_READER object into aSheet.

When aIsCopyableOnly is true, only schematic objects that are viewable on the canvas for copy and paste purposes are parsed. Other schematic content such as bus definitions or instance data will throw an IO_ERROR exception.

When aIsCopyableOnly is false, full schematic file parsing is performed.

Note

This does not load any sub-sheets or decent complex sheet hierarchies.

Parameters

aSheet	The SCH_SHEET object to store the parsed schematic file.
aIsCopyableOnly	Load only the schematic objects that can be copied into aSheet if true. Otherwise, load the full schematic file format.
aFileVersion	The schematic file version to parser. Defaults to the schematic file being parsed when aIsCopyableOnly is false.

Definition at line 2283 of file sch_sexpr_parser.cpp.

{
 wxCHECK( aSheet != nullptr, /* void */ );
 
 SCH_SCREEN* screen = aSheet->GetScreen();
 
 wxCHECK( screen != nullptr, /* void */ );
 
 if( aIsCopyableOnly )
 m_requiredVersion = aFileVersion;
 
 bool fileHasUuid = false;
 
 T token;
 
 if( !aIsCopyableOnly )
 {
 NeedLEFT();
 NextTok();
 
 if( CurTok() != T_kicad_sch )
 Expecting( "kicad_sch" );
 
 parseHeader( T_kicad_sch, SEXPR_SCHEMATIC_FILE_VERSION );
 
 // Prior to schematic file version 20210406, schematics did not have UUIDs so we need
 // to generate one for the root schematic for instance paths.
 if( m_requiredVersion < 20210406 )
 m_rootUuid = screen->GetUuid();
 }
 
 screen->SetFileFormatVersionAtLoad( m_requiredVersion );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( aIsCopyableOnly && token == T_EOF )
 break;
 
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 checkpoint();
 
 if( !aIsCopyableOnly && token == T_page && m_requiredVersion <= 20200506 )
 token = T_paper;
 
 switch( token )
 {
 case T_uuid:
 NeedSYMBOL();
 screen->m_uuid = parseKIID();
 
 // Set the root sheet UUID with the schematic file UUID. Root sheets are virtual
 // and always get a new UUID so this prevents file churn now that the root UUID
 // is saved in the symbol instance path.
 if( aSheet == m_rootSheet )
 {
 const_cast<KIID&>( aSheet->m_Uuid ) = screen->GetUuid();
 m_rootUuid = screen->GetUuid();
 fileHasUuid = true;
 }
 
 NeedRIGHT();
 break;
 
 case T_paper:
 {
 if( aIsCopyableOnly )
 Unexpected( T_paper );
 
 PAGE_INFO pageInfo;
 parsePAGE_INFO( pageInfo );
 screen->SetPageSettings( pageInfo );
 break;
 }
 
 case T_page:
 {
 if( aIsCopyableOnly )
 Unexpected( T_page );
 
 // Only saved for top-level sniffing in Kicad Manager frame and other external
 // tool usage with flat hierarchies
 NeedSYMBOLorNUMBER();
 NeedSYMBOLorNUMBER();
 NeedRIGHT();
 break;
 }
 
 case T_title_block:
 {
 if( aIsCopyableOnly )
 Unexpected( T_title_block );
 
 TITLE_BLOCK tb;
 parseTITLE_BLOCK( tb );
 screen->SetTitleBlock( tb );
 break;
 }
 
 case T_lib_symbols:
 {
 // Dummy map. No derived symbols are allowed in the library cache.
 LIB_SYMBOL_MAP symbolLibMap;
 LIB_SYMBOL* symbol;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_symbol:
 symbol = ParseSymbol( symbolLibMap, m_requiredVersion );
 symbol->UpdateFieldOrdinals();
 screen->AddLibSymbol( symbol );
 break;
 
 default:
 Expecting( "symbol" );
 }
 }
 
 break;
 }
 
 case T_symbol:
 screen->Append( static_cast<SCH_ITEM*>( parseSchematicSymbol() ) );
 break;
 
 case T_image:
 screen->Append( static_cast<SCH_ITEM*>( parseImage() ) );
 break;
 
 case T_sheet:
 {
 SCH_SHEET* sheet = parseSheet();
 
 // Set the parent to aSheet. This effectively creates a method to find
 // the root sheet from any sheet so a pointer to the root sheet does not
 // need to be stored globally. Note: this is not the same as a hierarchy.
 // Complex hierarchies can have multiple copies of a sheet. This only
 // provides a simple tree to find the root sheet.
 sheet->SetParent( aSheet );
 screen->Append( sheet );
 break;
 }
 
 case T_junction:
 screen->Append( parseJunction() );
 break;
 
 case T_no_connect:
 screen->Append( parseNoConnect() );
 break;
 
 case T_bus_entry:
 screen->Append( parseBusEntry() );
 break;
 
 case T_polyline:
 {
 // polyline keyword is used in eeschema both for SCH_SHAPE and SCH_LINE items.
 // In symbols it describes a polygon, having n corners and can be filled
 // In schematic it describes a line (with no fill descr), but could be extended to a
 // polygon (for instance when importing files) because the schematic handles all
 // SCH_SHAPE.
 
 // parseSchPolyLine() returns always a SCH_SHAPE, io convert it to a simple SCH_LINE
 // For compatibility reasons, keep SCH_SHAPE for a polygon and convert to SCH_LINE
 // when the item has only 2 corners, similar to a SCH_LINE
 SCH_SHAPE* poly = parseSchPolyLine();
 
 if( poly->GetPointCount() > 2 )
 {
 screen->Append( poly );
 }
 else
 {
 // For SCH_SHAPE having only 2 points, this is a "old" SCH_LINE entity.
 // So convert the SCH_SHAPE to a simple SCH_LINE
 SCH_LINE* line = new SCH_LINE( VECTOR2I(), LAYER_NOTES );
 SHAPE_LINE_CHAIN& outline = poly->GetPolyShape().Outline(0);
 line->SetStartPoint( outline.CPoint(0) );
 line->SetEndPoint( outline.CPoint(1) );
 line->SetStroke( poly->GetStroke() );
 const_cast<KIID&>( line->m_Uuid ) = poly->m_Uuid;
 
 screen->Append( line );
 
 delete poly;
 }
 }
 break;
 
 case T_bus:
 case T_wire:
 screen->Append( parseLine() );
 break;
 
 case T_arc:
 screen->Append( parseSchArc() );
 break;
 
 case T_circle:
 screen->Append( parseSchCircle() );
 break;
 
 case T_rectangle:
 screen->Append( parseSchRectangle() );
 break;
 
 case T_bezier:
 screen->Append( parseSchBezier() );
 break;
 
 case T_netclass_flag: // present only during early development of 7.0
 KI_FALLTHROUGH;
 
 case T_text:
 case T_label:
 case T_global_label:
 case T_hierarchical_label:
 case T_directive_label:
 screen->Append( parseSchText() );
 break;
 
 case T_text_box:
 screen->Append( parseSchTextBox() );
 break;
 
 case T_sheet_instances:
 parseSchSheetInstances( aSheet, screen );
 break;
 
 case T_symbol_instances:
 parseSchSymbolInstances( screen );
 break;
 
 case T_bus_alias:
 if( aIsCopyableOnly )
 Unexpected( T_bus_alias );
 
 parseBusAlias( screen );
 break;
 
 default:
 Expecting( "symbol, paper, page, title_block, bitmap, sheet, junction, no_connect, "
 "bus_entry, line, bus, text, label, class_label, global_label, "
 "hierarchical_label, symbol_instances, or bus_alias" );
 }
 }
 
 // Older s-expression schematics may not have a UUID so use the one automatically generated
 // as the virtual root sheet UUID.
 if( ( aSheet == m_rootSheet ) && !fileHasUuid )
 {
 const_cast<KIID&>( aSheet->m_Uuid ) = screen->GetUuid();
 m_rootUuid = screen->GetUuid();
 }
 
 screen->UpdateLocalLibSymbolLinks();
 
 if( m_requiredVersion < 20200828 )
 screen->SetLegacySymbolInstanceData();
}

References SCH_SCREEN::AddLibSymbol(), SCH_SCREEN::Append(), checkpoint(), SHAPE_LINE_CHAIN::CPoint(), EDA_SHAPE::GetPointCount(), EDA_SHAPE::GetPolyShape(), SCH_SHEET::GetScreen(), SCH_SHAPE::GetStroke(), SCH_SCREEN::GetUuid(), KI_FALLTHROUGH, LAYER_NOTES, m_requiredVersion, m_rootSheet, m_rootUuid, SCH_SCREEN::m_uuid, EDA_ITEM::m_Uuid, SHAPE_POLY_SET::Outline(), parseBusAlias(), parseBusEntry(), parseHeader(), parseImage(), parseJunction(), parseKIID(), parseLine(), parseNoConnect(), parsePAGE_INFO(), parseSchArc(), parseSchBezier(), parseSchCircle(), parseSchematicSymbol(), parseSchPolyLine(), parseSchRectangle(), parseSchSheetInstances(), parseSchSymbolInstances(), parseSchText(), parseSchTextBox(), parseSheet(), ParseSymbol(), parseTITLE_BLOCK(), SCH_LINE::SetEndPoint(), SCH_SCREEN::SetFileFormatVersionAtLoad(), SCH_SCREEN::SetLegacySymbolInstanceData(), SCH_SCREEN::SetPageSettings(), EDA_ITEM::SetParent(), SCH_LINE::SetStartPoint(), SCH_LINE::SetStroke(), SCH_SCREEN::SetTitleBlock(), SEXPR_SCHEMATIC_FILE_VERSION, LIB_SYMBOL::UpdateFieldOrdinals(), and SCH_SCREEN::UpdateLocalLibSymbolLinks().

Referenced by SCH_SEXPR_PLUGIN::LoadContent(), SCH_SEXPR_PLUGIN::loadFile(), and KI_TEST::LoadSheetSchematicContents().

parseSchematicSymbol()

SCH_SYMBOL * SCH_SEXPR_PARSER::parseSchematicSymbol ( )

private

Definition at line 2556 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_symbol, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a symbol." ) );
 
 T token;
 wxString libName;
 SCH_FIELD* field;
 std::unique_ptr<SCH_SYMBOL> symbol = std::make_unique<SCH_SYMBOL>();
 TRANSFORM transform;
 std::set<int> fieldIDsRead;
 
 // We'll reset this if we find a fields_autoplaced token
 symbol->ClearFieldsAutoplaced();
 
 m_fieldId = MANDATORY_FIELDS;
 m_fieldIDsRead.clear();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_lib_name:
 {
 LIB_ID libId;
 
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid symbol library name" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
 
 libName = FromUTF8();
 NeedRIGHT();
 break;
 }
 
 case T_lib_id:
 {
 token = NextTok();
 
 if( !IsSymbol( token ) && token != T_NUMBER )
 Expecting( "symbol|number" );
 
 LIB_ID libId;
 wxString name = FromUTF8();
 int bad_pos = libId.Parse( name );
 
 if( bad_pos >= 0 )
 {
 if( static_cast<int>( name.size() ) > bad_pos )
 {
 wxString msg = wxString::Format(
 _( "Symbol %s contains invalid character '%c'" ), name,
 name[bad_pos] );
 
 THROW_PARSE_ERROR( msg, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 
 THROW_PARSE_ERROR( _( "Invalid symbol library ID" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
 
 symbol->SetLibId( libId );
 NeedRIGHT();
 break;
 }
 
 case T_at:
 symbol->SetPosition( parseXY() );
 
 switch( static_cast<int>( parseDouble( "symbol orientation" ) ) )
 {
 case 0: transform = TRANSFORM(); break;
 case 90: transform = TRANSFORM( 0, -1, -1, 0 ); break;
 case 180: transform = TRANSFORM( -1, 0, 0, 1 ); break;
 case 270: transform = TRANSFORM( 0, 1, 1, 0 ); break;
 default: Expecting( "0, 90, 180, or 270" );
 }
 
 symbol->SetTransform( transform );
 NeedRIGHT();
 break;
 
 case T_mirror:
 token = NextTok();
 
 if( token == T_x )
 symbol->SetOrientation( SYM_MIRROR_X );
 else if( token == T_y )
 symbol->SetOrientation( SYM_MIRROR_Y );
 else
 Expecting( "x or y" );
 
 NeedRIGHT();
 break;
 
 case T_unit:
 symbol->SetUnit( parseInt( "symbol unit" ) );
 NeedRIGHT();
 break;
 
 case T_convert:
 symbol->SetConvert( parseInt( "symbol convert" ) );
 NeedRIGHT();
 break;
 
 case T_in_bom:
 symbol->SetIncludeInBom( parseBool() );
 NeedRIGHT();
 break;
 
 case T_on_board:
 symbol->SetIncludeOnBoard( parseBool() );
 NeedRIGHT();
 break;
 
 case T_dnp:
 symbol->SetDNP( parseBool() );
 NeedRIGHT();
 break;
 
 case T_fields_autoplaced:
 symbol->SetFieldsAutoplaced();
 NeedRIGHT();
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( symbol->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 case T_default_instance:
 {
 SCH_SYMBOL_INSTANCE defaultInstance;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_reference:
 NeedSYMBOL();
 defaultInstance.m_Reference = FromUTF8();
 NeedRIGHT();
 break;
 
 case T_unit:
 defaultInstance.m_Unit = parseInt( "symbol unit" );
 NeedRIGHT();
 break;
 
 case T_value:
 NeedSYMBOL();
 symbol->SetValueFieldText( FromUTF8() );
 NeedRIGHT();
 break;
 
 case T_footprint:
 NeedSYMBOL();
 symbol->SetFootprintFieldText( FromUTF8() );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "reference, unit, value or footprint" );
 }
 }
 
 break;
 }
 
 case T_instances:
 {
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_project )
 Expecting( "project" );
 
 NeedSYMBOL();
 
 wxString projectName = FromUTF8();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_path )
 Expecting( "path" );
 
 SCH_SYMBOL_INSTANCE instance;
 
 instance.m_ProjectName = projectName;
 
 NeedSYMBOL();
 instance.m_Path = KIID_PATH( FromUTF8() );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_reference:
 NeedSYMBOL();
 instance.m_Reference = FromUTF8();
 NeedRIGHT();
 break;
 
 case T_unit:
 instance.m_Unit = parseInt( "symbol unit" );
 NeedRIGHT();
 break;
 
 case T_value:
 NeedSYMBOL();
 symbol->SetValueFieldText( FromUTF8() );
 NeedRIGHT();
 break;
 
 case T_footprint:
 NeedSYMBOL();
 symbol->SetFootprintFieldText( FromUTF8() );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "reference, unit, value or footprint" );
 }
 
 symbol->AddHierarchicalReference( instance );
 }
 }
 }
 
 break;
 }
 
 case T_property:
 // The field parent symbol must be set and its orientation must be set before
 // the field positions are set.
 field = parseSchField( symbol.get() );
 
 if( m_fieldIDsRead.count( field->GetId() ) )
 {
 int nextAvailableId = field->GetId() + 1;
 
 while( m_fieldIDsRead.count( nextAvailableId ) )
 nextAvailableId += 1;
 
 field->SetId( nextAvailableId );
 }
 
 if( symbol->GetFieldById( field->GetId() ) )
 *symbol->GetFieldById( field->GetId() ) = *field;
 else
 symbol->AddField( *field );
 
 if( field->GetId() == REFERENCE_FIELD )
 symbol->UpdatePrefix();
 
 m_fieldIDsRead.insert( field->GetId() );
 
 delete field;
 break;
 
 case T_pin:
 {
 // Read an alternate pin designation
 wxString number;
 KIID uuid;
 wxString alt;
 
 NeedSYMBOL();
 number = FromUTF8();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_alternate:
 NeedSYMBOL();
  alt = FromUTF8();
 NeedRIGHT();
 break;
 
 case T_uuid:
 NeedSYMBOL();
 
 // First version to write out pin uuids accidentally wrote out the symbol's
 // uuid for each pin, so ignore uuids coming from that version.
 if( m_requiredVersion >= 20210126 )
 uuid = parseKIID();
 
 NeedRIGHT();
 break;
 
 default:
 Expecting( "alternate or uuid" );
 }
 }
 
 symbol->GetRawPins().emplace_back( std::make_unique<SCH_PIN>( symbol.get(),
 number, alt ) );
 
 const_cast<KIID&>( symbol->GetRawPins().back()->m_Uuid ) = uuid;
 }
 break;
 
 default:
 Expecting( "lib_id, lib_name, at, mirror, uuid, on_board, in_bom, dnp, "
 "default_instance, property, pin, or instances" );
 }
 }
 
 if( !libName.IsEmpty() && ( symbol->GetLibId().Format().wx_str() != libName ) )
 symbol->SetSchSymbolLibraryName( libName );
 
 // Ensure edit/status flags are cleared after these initializations:
 symbol->ClearFlags();
 
 return symbol.release();
}

References _, Format(), SCH_FIELD::GetId(), m_fieldId, m_fieldIDsRead, SCH_SYMBOL_INSTANCE::m_Path, SCH_SYMBOL_INSTANCE::m_ProjectName, SCH_SYMBOL_INSTANCE::m_Reference, m_requiredVersion, SCH_SYMBOL_INSTANCE::m_Unit, MANDATORY_FIELDS, name, LIB_ID::Parse(), parseBool(), parseDouble(), parseInt(), parseKIID(), parseSchField(), parseXY(), REFERENCE_FIELD, SCH_FIELD::SetId(), SYM_MIRROR_X, SYM_MIRROR_Y, and THROW_PARSE_ERROR.

Referenced by ParseSchematic().

parseSchField()

SCH_FIELD * SCH_SEXPR_PARSER::parseSchField ( SCH_ITEM *  aParent )

private

Definition at line 1917 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_property, nullptr,
 "Cannot parse " + GetTokenString( CurTok() ) + " as a property token." );
 
 T token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid property name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 wxString name = FromUTF8();
 
 if( name.IsEmpty() )
 {
 THROW_PARSE_ERROR( _( "Empty property name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid property value" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 // Empty property values are valid.
 wxString value = FromUTF8();
 
 std::unique_ptr<SCH_FIELD> field = std::make_unique<SCH_FIELD>( wxDefaultPosition, -1,
 aParent, name );
 
 field->SetText( value );
 field->SetVisible( true );
 
 // Correctly set the ID based on canonical (untranslated) field name
 // If ID is stored in the file (old versions), it will overwrite this
 if( aParent->Type() == SCH_SYMBOL_T )
 {
 for( int ii = 0; ii < MANDATORY_FIELDS; ++ii )
 {
 if( name == TEMPLATE_FIELDNAME::GetDefaultFieldName( ii, false ) )
 {
 field->SetId( ii );
 break;
 }
 }
 }
 else if( aParent->Type() == SCH_SHEET_T )
 {
 for( int ii = 0; ii < SHEET_MANDATORY_FIELDS; ++ii )
 {
 if( name == SCH_SHEET::GetDefaultFieldName( ii, false ) )
 {
 field->SetId( ii );
 break;
 }
 }
 }
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_id:
 field->SetId( parseInt( "field ID" ) );
 NeedRIGHT();
 break;
 
 case T_at:
 field->SetPosition( parseXY() );
 field->SetTextAngle( EDA_ANGLE( parseDouble( "text angle" ), DEGREES_T ) );
 NeedRIGHT();
 break;
 
 case T_effects:
 parseEDA_TEXT( static_cast<EDA_TEXT*>( field.get() ), field->GetId() == VALUE_FIELD );
 break;
 
 case T_show_name:
 field->SetNameShown();
 NeedRIGHT();
 break;
 
 case T_do_not_autoplace:
 field->SetCanAutoplace( false );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "id, at, show_name, do_not_autoplace or effects" );
 }
 }
 
 return field.release();
}

References _, DEGREES_T, SCH_SHEET::GetDefaultFieldName(), TEMPLATE_FIELDNAME::GetDefaultFieldName(), MANDATORY_FIELDS, name, parseDouble(), parseEDA_TEXT(), parseInt(), parseXY(), SCH_SHEET_T, SCH_SYMBOL_T, SHEET_MANDATORY_FIELDS, THROW_PARSE_ERROR, EDA_ITEM::Type(), and VALUE_FIELD.

Referenced by parseSchematicSymbol(), parseSchText(), and parseSheet().

parseSchPolyLine()

SCH_SHAPE * SCH_SEXPR_PARSER::parseSchPolyLine ( )

private

Definition at line 3321 of file sch_sexpr_parser.cpp.

{
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 int layer = LAYER_NOTES;
 
 std::unique_ptr<SCH_SHAPE> polyline = std::make_unique<SCH_SHAPE>( SHAPE_T::POLY, layer );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_pts:
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_xy )
 Expecting( "xy" );
 
 polyline->AddPoint( parseXY() );
 
 NeedRIGHT();
 }
 break;
 
 case T_stroke:
 parseStroke( stroke );
 polyline->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 polyline->SetFillMode( fill.m_FillType );
 polyline->SetFillColor( fill.m_Color );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( polyline->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 default:
 Expecting( "pts, uuid, stroke, or fill" );
 }
 }
 
 return polyline.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, LAYER_NOTES, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, EDA_IU_SCALE::MilsToIU(), parseFill(), parseKIID(), parseStroke(), parseXY(), POLY, and schIUScale.

Referenced by ParseSchematic().

parseSchRectangle()

SCH_SHAPE * SCH_SEXPR_PARSER::parseSchRectangle ( )

private

Definition at line 3576 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_rectangle, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a rectangle." ) );
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<SCH_SHAPE> rectangle = std::make_unique<SCH_SHAPE>( SHAPE_T::RECT );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_start:
 rectangle->SetPosition( parseXY() );
 NeedRIGHT();
 break;
 
 case T_end:
 rectangle->SetEnd( parseXY() );
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 rectangle->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 rectangle->SetFillMode( fill.m_FillType );
 rectangle->SetFillColor( fill.m_Color );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( rectangle->m_Uuid ) = KIID( FromUTF8() );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "start, end, stroke, fill or uuid" );
 }
 }
 
 return rectangle.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, EDA_IU_SCALE::MilsToIU(), parseFill(), parseStroke(), parseXY(), RECT, and schIUScale.

Referenced by ParseSchematic().

parseSchSheetInstances()

void SCH_SEXPR_PARSER::parseSchSheetInstances ( SCH_SHEET *  aRootSheet, SCH_SCREEN *  aScreen  )

private

Definition at line 2109 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( CurTok() == T_sheet_instances,
 "Cannot parse " + GetTokenString( CurTok() ) + " as an instances token." );
 wxCHECK( aScreen, /* void */ );
 
 T token;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_path:
 {
 NeedSYMBOL();
 
 SCH_SHEET_INSTANCE instance;
 
 instance.m_Path = KIID_PATH( FromUTF8() );
 
 if( ( !m_appending && aRootSheet->GetScreen() == aScreen ) &&
 ( aScreen->GetFileFormatVersionAtLoad() < 20221002 ) )
 instance.m_Path.insert( instance.m_Path.begin(), m_rootUuid );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 std::vector<wxString> whitespaces = { wxT( "\r" ), wxT( "\n" ), wxT( "\t" ),
 wxT( " " ) };
 
 size_t numReplacements = 0;
 
 switch( token )
 {
 case T_page:
 NeedSYMBOL();
 instance.m_PageNumber = FromUTF8();
 
 // Empty page numbers are not permitted
 if( instance.m_PageNumber.IsEmpty() )
 {
 // Use hash character instead
 instance.m_PageNumber = wxT( "#" );
 numReplacements++;
 }
 else
 {
  // Whitespaces are not permitted
 for( wxString ch : whitespaces )
 numReplacements += instance.m_PageNumber.Replace( ch, wxEmptyString );
 
 }
 
 // Set the file as modified so the user can be warned.
 if( numReplacements > 0 )
 aScreen->SetContentModified();
 
 NeedRIGHT();
 break;
 
 default:
 Expecting( "path or page" );
 }
 }
 
 if( ( aScreen->GetFileFormatVersionAtLoad() >= 20221110 )
 && ( instance.m_Path.empty() ) )
 {
 SCH_SHEET_PATH rootSheetPath;
 
 rootSheetPath.push_back( aRootSheet );
 rootSheetPath.SetPageNumber( instance.m_PageNumber );
 }
 else
 {
 aScreen->m_sheetInstances.emplace_back( instance );
 }
 
 break;
 }
 
 default:
 Expecting( "path" );
 }
 }
}

References SCH_SCREEN::GetFileFormatVersionAtLoad(), SCH_SHEET::GetScreen(), m_appending, SCH_SHEET_INSTANCE::m_PageNumber, SCH_SHEET_INSTANCE::m_Path, m_rootUuid, SCH_SCREEN::m_sheetInstances, SCH_SHEET_PATH::push_back(), BASE_SCREEN::SetContentModified(), and SCH_SHEET_PATH::SetPageNumber().

Referenced by ParseSchematic().

parseSchSheetPin()

SCH_SHEET_PIN * SCH_SEXPR_PARSER::parseSchSheetPin ( SCH_SHEET *  aSheet )

private

Definition at line 2023 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( aSheet != nullptr, nullptr, "" );
 wxCHECK_MSG( CurTok() == T_pin, nullptr,
 "Cannot parse " + GetTokenString( CurTok() ) + " as a sheet pin token." );
 
 T token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid sheet pin name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 wxString name = FromUTF8();
 
 if( name.IsEmpty() )
 {
 THROW_PARSE_ERROR( _( "Empty sheet pin name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 auto sheetPin = std::make_unique<SCH_SHEET_PIN>( aSheet, VECTOR2I( 0, 0 ), name );
 
 token = NextTok();
 
 switch( token )
 {
 case T_input: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_INPUT ); break;
 case T_output: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT ); break;
 case T_bidirectional: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_BIDI ); break;
 case T_tri_state: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_TRISTATE ); break;
 case T_passive: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED ); break;
 default:
 Expecting( "input, output, bidirectional, tri_state, or passive" );
 }
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 {
 sheetPin->SetPosition( parseXY() );
 
 double angle = parseDouble( "sheet pin angle (side)" );
 
 if( angle == 0.0 )
 sheetPin->SetSide( SHEET_SIDE::RIGHT );
 else if( angle == 90.0 )
 sheetPin->SetSide( SHEET_SIDE::TOP );
 else if( angle == 180.0 )
 sheetPin->SetSide( SHEET_SIDE::LEFT );
 else if( angle == 270.0 )
 sheetPin->SetSide( SHEET_SIDE::BOTTOM );
 else
 Expecting( "0, 90, 180, or 270" );
 
 NeedRIGHT();
 break;
 }
 
 case T_effects:
 parseEDA_TEXT( static_cast<EDA_TEXT*>( sheetPin.get() ), true );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( sheetPin->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 default:
 Expecting( "at, uuid or effects" );
 }
 }
 
 return sheetPin.release();
}

References _, PNS::angle(), BOTTOM, L_BIDI, L_INPUT, L_OUTPUT, L_TRISTATE, L_UNSPECIFIED, LEFT, name, parseDouble(), parseEDA_TEXT(), parseKIID(), parseXY(), RIGHT, THROW_PARSE_ERROR, and TOP.

Referenced by parseSheet().

parseSchSymbolInstances()

void SCH_SEXPR_PARSER::parseSchSymbolInstances ( SCH_SCREEN *  aScreen )

private

Definition at line 2206 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( CurTok() == T_symbol_instances,
 "Cannot parse " + GetTokenString( CurTok() ) + " as an instances token." );
 wxCHECK( aScreen, /* void */ );
 wxCHECK( m_rootUuid != NilUuid(), /* void */ );
 
 T token;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_path:
 {
 NeedSYMBOL();
 
 SCH_SYMBOL_INSTANCE instance;
 
 instance.m_Path = KIID_PATH( FromUTF8() );
 
 if( !m_appending )
 instance.m_Path.insert( instance.m_Path.begin(), m_rootUuid );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_reference:
 NeedSYMBOL();
 instance.m_Reference = FromUTF8();
 NeedRIGHT();
 break;
 
 case T_unit:
 instance.m_Unit = parseInt( "symbol unit" );
 NeedRIGHT();
 break;
 
 case T_value:
 NeedSYMBOL();
 instance.m_Value = FromUTF8();
 NeedRIGHT();
 break;
 
 case T_footprint:
 NeedSYMBOL();
 instance.m_Footprint = FromUTF8();
 NeedRIGHT();
 break;
 
 default:
 Expecting( "path, unit, value or footprint" );
 }
 }
 
 aScreen->m_symbolInstances.emplace_back( instance );
 break;
 }
 
 default:
 Expecting( "path" );
 }
 }
}

References m_appending, SCH_SYMBOL_INSTANCE::m_Footprint, SCH_SYMBOL_INSTANCE::m_Path, SCH_SYMBOL_INSTANCE::m_Reference, m_rootUuid, SCH_SCREEN::m_symbolInstances, SCH_SYMBOL_INSTANCE::m_Unit, SCH_SYMBOL_INSTANCE::m_Value, NilUuid(), and parseInt().

Referenced by ParseSchematic().

parseSchText()

SCH_TEXT * SCH_SEXPR_PARSER::parseSchText ( )

private

Definition at line 3694 of file sch_sexpr_parser.cpp.

{
 T token;
 std::unique_ptr<SCH_TEXT> text;
 
 switch( CurTok() )
 {
 case T_text: text = std::make_unique<SCH_TEXT>(); break;
 case T_label: text = std::make_unique<SCH_LABEL>(); break;
 case T_global_label: text = std::make_unique<SCH_GLOBALLABEL>(); break;
 case T_hierarchical_label: text = std::make_unique<SCH_HIERLABEL>(); break;
 case T_netclass_flag: text = std::make_unique<SCH_DIRECTIVE_LABEL>(); break;
 case T_directive_label: text = std::make_unique<SCH_DIRECTIVE_LABEL>(); break;
 default:
 wxCHECK_MSG( false, nullptr, "Cannot parse " + GetTokenString( CurTok() ) + " as text." );
 }
 
 // We'll reset this if we find a fields_autoplaced token
 text->ClearFieldsAutoplaced();
 
 NeedSYMBOL();
 
 text->SetText( FromUTF8() );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 text->SetPosition( parseXY() );
 
 switch( static_cast<int>( parseDouble( "text angle" ) ) )
 {
 case 0: text->SetTextSpinStyle( TEXT_SPIN_STYLE::RIGHT ); break;
 case 90: text->SetTextSpinStyle( TEXT_SPIN_STYLE::UP ); break;
 case 180: text->SetTextSpinStyle( TEXT_SPIN_STYLE::LEFT ); break;
 case 270: text->SetTextSpinStyle( TEXT_SPIN_STYLE::BOTTOM ); break;
 default:
 wxFAIL;
 text->SetTextSpinStyle( TEXT_SPIN_STYLE::RIGHT );
 break;
 }
 
 NeedRIGHT();
 break;
 
 case T_shape:
 {
 if( text->Type() == SCH_TEXT_T || text->Type() == SCH_LABEL_T )
 Unexpected( T_shape );
 
 SCH_LABEL_BASE* label = static_cast<SCH_LABEL_BASE*>( text.get() );
 
 token = NextTok();
 
 switch( token )
 {
 case T_input: label->SetShape( LABEL_FLAG_SHAPE::L_INPUT ); break;
 case T_output: label->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT ); break;
 case T_bidirectional: label->SetShape( LABEL_FLAG_SHAPE::L_BIDI ); break;
 case T_tri_state: label->SetShape( LABEL_FLAG_SHAPE::L_TRISTATE ); break;
 case T_passive: label->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED ); break;
 case T_dot: label->SetShape( LABEL_FLAG_SHAPE::F_DOT ); break;
 case T_round: label->SetShape( LABEL_FLAG_SHAPE::F_ROUND ); break;
 case T_diamond: label->SetShape( LABEL_FLAG_SHAPE::F_DIAMOND ); break;
 case T_rectangle: label->SetShape( LABEL_FLAG_SHAPE::F_RECTANGLE ); break;
 default:
 Expecting( "input, output, bidirectional, tri_state, passive, dot, round, diamond"
 "or rectangle" );
 }
 
 NeedRIGHT();
 break;
 }
 
 case T_length:
 {
 if( text->Type() != SCH_DIRECTIVE_LABEL_T )
 Unexpected( T_length );
 
 SCH_DIRECTIVE_LABEL* label = static_cast<SCH_DIRECTIVE_LABEL*>( text.get() );
 
 label->SetPinLength( parseInternalUnits( "pin length" ) );
 NeedRIGHT();
 }
 break;
 
 case T_fields_autoplaced:
 text->SetFieldsAutoplaced();
 NeedRIGHT();
 break;
 
 case T_effects:
 parseEDA_TEXT( static_cast<EDA_TEXT*>( text.get() ), true );
 
 // Spin style is defined differently for graphical text (#SCH_TEXT) objects.
 if( text->Type() == SCH_TEXT_T )
 {
 if( text->GetHorizJustify() == GR_TEXT_H_ALIGN_RIGHT
 && text->GetTextAngle().IsVertical() )
 {
 // The vertically aligned text angle is always 90 (labels use 270 for the
 // down direction) combined with the text justification flags.
 text->SetTextSpinStyle( TEXT_SPIN_STYLE::BOTTOM );
 }
 else if( text->GetHorizJustify() == GR_TEXT_H_ALIGN_RIGHT
 && text->GetTextAngle().IsHorizontal() )
 {
 // The horizontally aligned text angle is always 0 (labels use 180 for the
 // left direction) combined with the text justification flags.
 text->SetTextSpinStyle( TEXT_SPIN_STYLE::LEFT );
 }
 }
 
 break;
 
 case T_iref: // legacy format; current is a T_property (aka SCH_FIELD)
 if( text->Type() == SCH_GLOBAL_LABEL_T )
 {
 SCH_GLOBALLABEL* label = static_cast<SCH_GLOBALLABEL*>( text.get() );
 SCH_FIELD* field = &label->GetFields()[0];
 
 field->SetTextPos( parseXY() );
 NeedRIGHT();
 
 field->SetVisible( true );
 }
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( text->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 case T_property:
 {
 if( text->Type() == SCH_TEXT_T )
 Unexpected( T_property );
 
 SCH_FIELD* field = parseSchField( text.get() );
 
 // If the field is a Intersheetrefs it is not handled like other fields:
 // It always exists and is the first in list
 if( text->Type() == SCH_GLOBAL_LABEL_T
 && ( field->GetInternalName() == wxT( "Intersheet References" ) // old name in V6.0
 || field->GetInternalName() == wxT( "Intersheetrefs" ) ) ) // Current name
 {
 SCH_GLOBALLABEL* label = static_cast<SCH_GLOBALLABEL*>( text.get() );
 label->GetFields()[0] = *field;
 }
 else
 {
 static_cast<SCH_LABEL_BASE*>( text.get() )->GetFields().emplace_back( *field );
 }
 
 delete field;
 break;
 }
 
 default:
 Expecting( "at, shape, iref, uuid or effects" );
 }
 }
 
 SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( text.get() );
 
 if( label && label->GetFields().empty() )
 label->SetFieldsAutoplaced();
 
 return text.release();
}

References TEXT_SPIN_STYLE::BOTTOM, F_DIAMOND, F_DOT, F_RECTANGLE, F_ROUND, SCH_LABEL_BASE::GetFields(), SCH_FIELD::GetInternalName(), GR_TEXT_H_ALIGN_RIGHT, L_BIDI, L_INPUT, L_OUTPUT, L_TRISTATE, L_UNSPECIFIED, TEXT_SPIN_STYLE::LEFT, parseDouble(), parseEDA_TEXT(), parseInternalUnits(), parseKIID(), parseSchField(), parseXY(), TEXT_SPIN_STYLE::RIGHT, SCH_DIRECTIVE_LABEL_T, SCH_GLOBAL_LABEL_T, SCH_LABEL_T, SCH_TEXT_T, SCH_ITEM::SetFieldsAutoplaced(), SCH_DIRECTIVE_LABEL::SetPinLength(), SCH_LABEL_BASE::SetShape(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetVisible(), text, and TEXT_SPIN_STYLE::UP.

Referenced by ParseSchematic().

parseSchTextBox()

SCH_TEXTBOX * SCH_SEXPR_PARSER::parseSchTextBox ( )

private

Definition at line 3873 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_text_box, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a text box." ) );
 
 T token;
 VECTOR2I pos;
 VECTOR2I end;
 VECTOR2I size;
 bool foundEnd = false;
 bool foundSize = false;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<SCH_TEXTBOX> textBox = std::make_unique<SCH_TEXTBOX>();
 
 NeedSYMBOL();
 
 textBox->SetText( FromUTF8() );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_start: // Legacy token during 6.99 development; fails to handle angle
 pos = parseXY();
 NeedRIGHT();
 break;
 
 case T_end: // Legacy token during 6.99 development; fails to handle angle
 end = parseXY();
 foundEnd = true;
 NeedRIGHT();
 break;
 
 case T_at:
 pos = parseXY();
 textBox->SetTextAngle( EDA_ANGLE( parseDouble( "textbox angle" ), DEGREES_T ) );
 NeedRIGHT();
 break;
 
 case T_size:
 size = parseXY();
 foundSize = true;
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 textBox->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 textBox->SetFillMode( fill.m_FillType );
 textBox->SetFillColor( fill.m_Color );
 break;
 
 case T_effects:
 parseEDA_TEXT( static_cast<EDA_TEXT*>( textBox.get() ), false );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( textBox->m_Uuid ) = KIID( FromUTF8() );
 NeedRIGHT();
 break;
 
 default:
 Expecting( "at, size, stroke, fill, effects or uuid" );
 }
 }
 
 textBox->SetPosition( pos );
 
 if( foundEnd )
 textBox->SetEnd( end );
 else if( foundSize )
 textBox->SetEnd( pos + size );
 else
 Expecting( "size" );
 
 return textBox.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, DEGREES_T, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, EDA_IU_SCALE::MilsToIU(), parseDouble(), parseEDA_TEXT(), parseFill(), parseStroke(), parseXY(), and schIUScale.

Referenced by ParseSchematic().

parseSheet()

SCH_SHEET * SCH_SEXPR_PARSER::parseSheet ( )

private

Definition at line 2983 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_sheet, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a sheet." ) );
 
 T token;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 SCH_FIELD* field;
 std::vector<SCH_FIELD> fields;
 std::unique_ptr<SCH_SHEET> sheet = std::make_unique<SCH_SHEET>();
 std::set<int> fieldIDsRead;
 
 // We'll reset this if we find a fields_autoplaced token
 sheet->ClearFieldsAutoplaced();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 sheet->SetPosition( parseXY() );
 NeedRIGHT();
 break;
 
 case T_size:
 {
 wxSize size;
 size.SetWidth( parseInternalUnits( "sheet width" ) );
 size.SetHeight( parseInternalUnits( "sheet height" ) );
 sheet->SetSize( size );
 NeedRIGHT();
 break;
 }
 
 case T_fields_autoplaced:
 sheet->SetFieldsAutoplaced();
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 sheet->SetBorderWidth( stroke.GetWidth() );
 sheet->SetBorderColor( stroke.GetColor() );
 break;
 
 case T_fill:
 parseFill( fill );
 sheet->SetBackgroundColor( fill.m_Color );
 break;
 
 case T_uuid:
 NeedSYMBOL();
 const_cast<KIID&>( sheet->m_Uuid ) = parseKIID();
 NeedRIGHT();
 break;
 
 case T_property:
 field = parseSchField( sheet.get() );
 
 if( m_requiredVersion <= 20200310 )
 {
 // Earlier versions had the wrong ids (and names) saved for sheet fields.
 // Fortunately they only saved the sheetname and sheetfilepath (and always
 // in that order), so we can hack in a recovery.
 if( fields.empty() )
 field->SetId( SHEETNAME );
 else
 field->SetId( SHEETFILENAME );
 }
 
 // It would appear the problem persists past 20200310, but this time with the
 // earlier ids being re-used for later (user) fields. The easiest (and most
 // complete) solution is to disallow multiple instances of the same id (for all
 // files since the source of the error *might* in fact be hand-edited files).
 //
 // While no longer used, -1 is still a valid id for user field. We convert it to
 // the first available ID after the mandatory fields
 
 if( field->GetId() < 0 )
 field->SetId( SHEET_MANDATORY_FIELDS );
 
 while( !fieldIDsRead.insert( field->GetId() ).second )
 field->SetId( field->GetId() + 1 );
 
 fields.emplace_back( *field );
  delete field;
 break;
 
 case T_pin:
 sheet->AddPin( parseSchSheetPin( sheet.get() ) );
 break;
 
 case T_instances:
 {
 std::vector<SCH_SHEET_INSTANCE> instances;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_project )
 Expecting( "project" );
 
 NeedSYMBOL();
 
 wxString projectName = FromUTF8();
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 if( token != T_path )
 Expecting( "path" );
 
 SCH_SHEET_INSTANCE instance;
 
 instance.m_ProjectName = projectName;
 
 NeedSYMBOL();
  instance.m_Path = KIID_PATH( FromUTF8() );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_page:
 {
 NeedSYMBOL();
 instance.m_PageNumber = FromUTF8();
 
 // Empty page numbers are not permitted
 if( instance.m_PageNumber.IsEmpty() )
 {
 // Use hash character instead
 instance.m_PageNumber = wxT( "#" );
 }
 else
 {
 // Whitespaces are not permitted
 std::vector<wxString> whitespaces = { wxT( "\r" ), wxT( "\n" ),
 wxT( "\t" ), wxT( " " ) };
 
 for( wxString ch : whitespaces )
 instance.m_PageNumber.Replace( ch, wxEmptyString );
 }
 
 NeedRIGHT();
 break;
 }
 
 default:
 Expecting( "page" );
 }
 }
 
 instances.emplace_back( instance );
 }
 }
 
 sheet->setInstances( instances );
 break;
 }
 
 default:
 Expecting( "at, size, stroke, background, instances, uuid, property, or pin" );
 }
 }
 
 sheet->SetFields( fields );
 
 return sheet.release();
}

References DEFAULT, DEFAULT_LINE_WIDTH_MILS, STROKE_PARAMS::GetColor(), SCH_FIELD::GetId(), STROKE_PARAMS::GetWidth(), FILL_PARAMS::m_Color, SCH_SHEET_INSTANCE::m_PageNumber, SCH_SHEET_INSTANCE::m_Path, SCH_SHEET_INSTANCE::m_ProjectName, m_requiredVersion, EDA_IU_SCALE::MilsToIU(), parseFill(), parseInternalUnits(), parseKIID(), parseSchField(), parseSchSheetPin(), parseStroke(), parseXY(), schIUScale, SCH_FIELD::SetId(), SHEET_MANDATORY_FIELDS, SHEETFILENAME, and SHEETNAME.

Referenced by ParseSchematic().

parseStroke()

void SCH_SEXPR_PARSER::parseStroke ( STROKE_PARAMS &  aStroke )

private

Parse stroke definition aStroke.

Parameters

aStrokeDef

A reference to the STROKE_PARAMS structure to write to.

Definition at line 475 of file sch_sexpr_parser.cpp.

{
 STROKE_PARAMS_PARSER strokeParser( reader, schIUScale.IU_PER_MM );
 strokeParser.SyncLineReaderWith( *this );
 
 strokeParser.ParseStroke( aStroke );
 SyncLineReaderWith( strokeParser );
}

References EDA_IU_SCALE::IU_PER_MM, STROKE_PARAMS_PARSER::ParseStroke(), and schIUScale.

Referenced by parseArc(), parseBezier(), parseBusEntry(), parseCircle(), parseLine(), parsePolyLine(), parseRectangle(), parseSchArc(), parseSchBezier(), parseSchCircle(), parseSchPolyLine(), parseSchRectangle(), parseSchTextBox(), parseSheet(), and parseTextBox().

ParseSymbol()

LIB_SYMBOL * SCH_SEXPR_PARSER::ParseSymbol	(	LIB_SYMBOL_MAP &	aSymbolLibMap,
		int	aFileVersion = SEXPR_SYMBOL_LIB_FILE_VERSION
	)

Definition at line 165 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_symbol, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a symbol." ) );
 
 T token;
 long tmp;
 wxString name;
 wxString error;
 wxString unitDisplayName;
 LIB_ITEM* item;
 std::unique_ptr<LIB_SYMBOL> symbol = std::make_unique<LIB_SYMBOL>( wxEmptyString );
 
 m_requiredVersion = aFileVersion;
 symbol->SetUnitCount( 1 );
 
 m_fieldId = MANDATORY_FIELDS;
 m_fieldIDsRead.clear();
 
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid symbol name" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 name = FromUTF8();
 
 LIB_ID id;
 int bad_pos = id.Parse( name );
 
 if( bad_pos >= 0 )
 {
 if( static_cast<int>( name.size() ) > bad_pos )
 {
 wxString msg = wxString::Format(
 _( "Symbol %s contains invalid character '%c'" ), name,
 name[bad_pos] );
 
 THROW_PARSE_ERROR( msg, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 
 
 THROW_PARSE_ERROR( _( "Invalid library identifier" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
 
 m_symbolName = id.GetLibItemName().wx_str();
 symbol->SetName( m_symbolName );
 symbol->SetLibId( id );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_power:
 symbol->SetPower();
 NeedRIGHT();
 break;
 
 case T_pin_names:
 parsePinNames( symbol );
 break;
 
 case T_pin_numbers:
 token = NextTok();
 
 if( token != T_hide )
 Expecting( "hide" );
 
 symbol->SetShowPinNumbers( false );
 NeedRIGHT();
 break;
 
 case T_in_bom:
 symbol->SetIncludeInBom( parseBool() );
 NeedRIGHT();
 break;
 
 case T_on_board:
 symbol->SetIncludeOnBoard( parseBool() );
 NeedRIGHT();
 break;
 
 case T_property:
 parseProperty( symbol );
 break;
 
 case T_extends:
 {
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid parent symbol name" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
 
 name = FromUTF8();
 auto it = aSymbolLibMap.find( name );
 
 if( it == aSymbolLibMap.end() )
 {
 error.Printf( _( "No parent for extended symbol %s" ), name.c_str() );
 THROW_PARSE_ERROR( error, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 
 symbol->SetParent( it->second );
 NeedRIGHT();
 break;
 }
 
 case T_symbol:
 {
 token = NextTok();
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid symbol unit name" ), CurSource(), CurLine(),
 CurLineNumber(), CurOffset() );
 }
 
 name = FromUTF8();
 
 if( !name.StartsWith( m_symbolName ) )
 {
 error.Printf( _( "Invalid symbol unit name prefix %s" ), name.c_str() );
 THROW_PARSE_ERROR( error, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 
 name = name.Right( name.Length() - m_symbolName.Length() - 1 );
 
 wxStringTokenizer tokenizer( name, "_" );
 
 if( tokenizer.CountTokens() != 2 )
 {
 error.Printf( _( "Invalid symbol unit name suffix %s" ), name.c_str() );
 THROW_PARSE_ERROR( error, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 
 if( !tokenizer.GetNextToken().ToLong( &tmp ) )
 {
 error.Printf( _( "Invalid symbol unit number %s" ), name.c_str() );
 THROW_PARSE_ERROR( error, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 
 m_unit = static_cast<int>( tmp );
 
 if( !tokenizer.GetNextToken().ToLong( &tmp ) )
 {
 error.Printf( _( "Invalid symbol convert number %s" ), name.c_str() );
 THROW_PARSE_ERROR( error, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
 }
 
 m_convert = static_cast<int>( tmp );
 
 if( m_convert > 1 )
 symbol->SetConversion( true, false );
 
 if( m_unit > symbol->GetUnitCount() )
 symbol->SetUnitCount( m_unit, false );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_unit_name:
 token = NextTok();
 
 if( IsSymbol( token ) )
 {
 unitDisplayName = FromUTF8();
 symbol->SetUnitDisplayName( m_unit, unitDisplayName );
 }
 NeedRIGHT();
 break;
 
 case T_arc:
 case T_bezier:
 case T_circle:
 case T_pin:
 case T_polyline:
 case T_rectangle:
 case T_text:
 case T_text_box:
 item = ParseDrawItem();
 
 wxCHECK_MSG( item, nullptr, "Invalid draw item pointer." );
 
 item->SetParent( symbol.get() );
 symbol->AddDrawItem( item, false );
 break;
 
 default:
 Expecting( "arc, bezier, circle, pin, polyline, rectangle, or text" );
 };
 }
 
 m_unit = 1;
 m_convert = 1;
 break;
 }
 
 case T_arc:
 case T_bezier:
 case T_circle:
 case T_pin:
 case T_polyline:
 case T_rectangle:
 case T_text:
 case T_text_box:
 item = ParseDrawItem();
 
 wxCHECK_MSG( item, nullptr, "Invalid draw item pointer." );
 
 item->SetParent( symbol.get() );
 symbol->AddDrawItem( item, false );
 break;
 
 default:
 Expecting( "pin_names, pin_numbers, arc, bezier, circle, pin, polyline, "
 "rectangle, or text" );
 }
 }
 
 symbol->GetDrawItems().sort();
 m_symbolName.clear();
 
 return symbol.release();
}

References _, Format(), m_convert, m_fieldId, m_fieldIDsRead, m_requiredVersion, m_symbolName, m_unit, MANDATORY_FIELDS, name, LIB_ID::Parse(), parseBool(), ParseDrawItem(), parsePinNames(), parseProperty(), EDA_ITEM::SetParent(), and THROW_PARSE_ERROR.

Referenced by ParseLib(), SCH_SEXPR_PLUGIN::ParseLibSymbol(), and ParseSchematic().

parseText()

LIB_TEXT * SCH_SEXPR_PARSER::parseText ( )

private

Definition at line 1610 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_text, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a text token." ) );
 
 T token;
 std::unique_ptr<LIB_TEXT> text = std::make_unique<LIB_TEXT>( nullptr );
 
 text->SetUnit( m_unit );
 text->SetConvert( m_convert );
 token = NextTok();
 
 if( token == T_private )
 {
 text->SetPrivate( true );
 token = NextTok();
 }
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid text string" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 text->SetText( FromUTF8() );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_at:
 text->SetPosition( parseXY() );
 // Yes, LIB_TEXT is really decidegrees even though all the others are degrees. :(
 text->SetTextAngle( EDA_ANGLE( parseDouble( "text angle" ), TENTHS_OF_A_DEGREE_T ) );
 NeedRIGHT();
 break;
 
 case T_effects:
 parseEDA_TEXT( static_cast<EDA_TEXT*>( text.get() ), true );
 break;
 
 default:
 Expecting( "at or effects" );
 }
 }
 
 return text.release();
}

References _, m_convert, m_unit, parseDouble(), parseEDA_TEXT(), parseXY(), TENTHS_OF_A_DEGREE_T, text, and THROW_PARSE_ERROR.

Referenced by ParseDrawItem().

parseTextBox()

LIB_TEXTBOX * SCH_SEXPR_PARSER::parseTextBox ( )

private

Definition at line 1665 of file sch_sexpr_parser.cpp.

{
 wxCHECK_MSG( CurTok() == T_text_box, nullptr,
 wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a text box." ) );
 
 T token;
 VECTOR2I pos;
 VECTOR2I end;
 VECTOR2I size;
 bool foundEnd = false;
 bool foundSize = false;
 STROKE_PARAMS stroke( schIUScale.MilsToIU( DEFAULT_LINE_WIDTH_MILS ), PLOT_DASH_TYPE::DEFAULT );
 FILL_PARAMS fill;
 std::unique_ptr<LIB_TEXTBOX> textBox = std::make_unique<LIB_TEXTBOX>( nullptr );
 
 token = NextTok();
 
 if( token == T_private )
 {
 textBox->SetPrivate( true );
 token = NextTok();
 }
 
 if( !IsSymbol( token ) )
 {
 THROW_PARSE_ERROR( _( "Invalid text string" ), CurSource(), CurLine(), CurLineNumber(),
 CurOffset() );
 }
 
 textBox->SetText( FromUTF8() );
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_start: // Legacy token during 6.99 development; fails to handle angle
 pos = parseXY();
 NeedRIGHT();
 break;
 
 case T_end: // Legacy token during 6.99 development; fails to handle angle
 end = parseXY();
 foundEnd = true;
 NeedRIGHT();
 break;
 
 case T_at:
 pos = parseXY();
 textBox->SetTextAngle( EDA_ANGLE( parseDouble( "textbox angle" ), DEGREES_T ) );
 NeedRIGHT();
 break;
 
 case T_size:
 size = parseXY();
  foundSize = true;
 NeedRIGHT();
 break;
 
 case T_stroke:
 parseStroke( stroke );
 textBox->SetStroke( stroke );
 break;
 
 case T_fill:
 parseFill( fill );
 textBox->SetFillMode( fill.m_FillType );
 textBox->SetFillColor( fill.m_Color );
 break;
 
 case T_effects:
 parseEDA_TEXT( static_cast<EDA_TEXT*>( textBox.get() ), false );
 break;
 
 default:
 Expecting( "at, size, stroke, fill or effects" );
 }
 }
 
 textBox->SetPosition( pos );
 
 if( foundEnd )
 textBox->SetEnd( end );
 else if( foundSize )
 textBox->SetEnd( pos + size );
 else
 Expecting( "size" );
 
 return textBox.release();
}

References _, DEFAULT, DEFAULT_LINE_WIDTH_MILS, DEGREES_T, FILL_PARAMS::m_Color, FILL_PARAMS::m_FillType, EDA_IU_SCALE::MilsToIU(), parseDouble(), parseEDA_TEXT(), parseFill(), parseStroke(), parseXY(), schIUScale, and THROW_PARSE_ERROR.

Referenced by ParseDrawItem().

parseTITLE_BLOCK()

void SCH_SEXPR_PARSER::parseTITLE_BLOCK ( TITLE_BLOCK &  aTitleBlock )

private

Definition at line 1813 of file sch_sexpr_parser.cpp.

{
 wxCHECK_RET( CurTok() == T_title_block,
 "Cannot parse " + GetTokenString( CurTok() ) + " as a TITLE_BLOCK." );
 
 T token;
 
 for( token = NextTok(); token != T_RIGHT; token = NextTok() )
 {
 if( token != T_LEFT )
 Expecting( T_LEFT );
 
 token = NextTok();
 
 switch( token )
 {
 case T_title:
 NextTok();
 aTitleBlock.SetTitle( FromUTF8() );
 break;
 
 case T_date:
 NextTok();
 aTitleBlock.SetDate( FromUTF8() );
 break;
 
 case T_rev:
 NextTok();
 aTitleBlock.SetRevision( FromUTF8() );
 break;
 
 case T_company:
 NextTok();
 aTitleBlock.SetCompany( FromUTF8() );
 break;
 
 case T_comment:
 {
 int commentNumber = parseInt( "comment" );
 
 switch( commentNumber )
 {
 case 1:
 NextTok();
 aTitleBlock.SetComment( 0, FromUTF8() );
 break;
 
 case 2:
 NextTok();
 aTitleBlock.SetComment( 1, FromUTF8() );
 break;
 
 case 3:
 NextTok();
 aTitleBlock.SetComment( 2, FromUTF8() );
 break;
 
 case 4:
 NextTok();
 aTitleBlock.SetComment( 3, FromUTF8() );
 break;
 
 case 5:
 NextTok();
 aTitleBlock.SetComment( 4, FromUTF8() );
 break;
 
 case 6:
 NextTok();
 aTitleBlock.SetComment( 5, FromUTF8() );
 break;
 
 case 7:
 NextTok();
 aTitleBlock.SetComment( 6, FromUTF8() );
 break;
 
 case 8:
 NextTok();
 aTitleBlock.SetComment( 7, FromUTF8() );
 break;
 
 case 9:
 NextTok();
 aTitleBlock.SetComment( 8, FromUTF8() );
 break;
 
 default:
 THROW_PARSE_ERROR( _( "Invalid title block comment number" ), CurSource(),
 CurLine(), CurLineNumber(), CurOffset() );
 }
 
 break;
 }
 
 default:
 Expecting( "title, date, rev, company, or comment" );
 }
 
 NeedRIGHT();
 }
}

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

Referenced by ParseSchematic().

parseXY()

wxPoint SCH_SEXPR_PARSER::parseXY ( )

inlineprivate

Definition at line 146 of file sch_sexpr_parser.h.

 {
 wxPoint xy;
 
 xy.x = parseInternalUnits( "X coordinate" );
 xy.y = parseInternalUnits( "Y coordinate" );
 
 return xy;
 }

References parseInternalUnits().

Referenced by parseArc(), parseBezier(), parseBusEntry(), parseCircle(), parseImage(), parseJunction(), parseLine(), parseNoConnect(), parsePin(), parsePolyLine(), parseProperty(), parseRectangle(), parseSchArc(), parseSchBezier(), parseSchCircle(), parseSchematicSymbol(), parseSchField(), parseSchPolyLine(), parseSchRectangle(), parseSchSheetPin(), parseSchText(), parseSchTextBox(), parseSheet(), parseText(), and parseTextBox().

Member Data Documentation

m_appending

bool SCH_SEXPR_PARSER::m_appending

private

Appending load status.

Definition at line 209 of file sch_sexpr_parser.h.

Referenced by parseSchSheetInstances(), and parseSchSymbolInstances().

m_convert

int SCH_SEXPR_PARSER::m_convert

private

The current body style being parsed.

Definition at line 207 of file sch_sexpr_parser.h.

Referenced by parseArc(), parseBezier(), parseCircle(), ParseLib(), parsePin(), parsePolyLine(), parseRectangle(), ParseSymbol(), and parseText().

m_fieldId

int SCH_SEXPR_PARSER::m_fieldId

private

The current field ID.

Definition at line 205 of file sch_sexpr_parser.h.

Referenced by parseSchematicSymbol(), and ParseSymbol().

m_fieldIDsRead

std::set<int> SCH_SEXPR_PARSER::m_fieldIDsRead

private

Field IDs that have been read so far for the current symbol.

Definition at line 212 of file sch_sexpr_parser.h.

Referenced by parseProperty(), parseSchematicSymbol(), and ParseSymbol().

m_lastProgressLine

unsigned SCH_SEXPR_PARSER::m_lastProgressLine

private

Definition at line 218 of file sch_sexpr_parser.h.

Referenced by checkpoint().

m_lineCount

unsigned SCH_SEXPR_PARSER::m_lineCount

private

Definition at line 219 of file sch_sexpr_parser.h.

Referenced by checkpoint().

m_lineReader

const LINE_READER* SCH_SEXPR_PARSER::m_lineReader

private

Definition at line 217 of file sch_sexpr_parser.h.

Referenced by checkpoint().

m_progressReporter

PROGRESS_REPORTER* SCH_SEXPR_PARSER::m_progressReporter

private

Definition at line 216 of file sch_sexpr_parser.h.

Referenced by checkpoint().

m_requiredVersion

int SCH_SEXPR_PARSER::m_requiredVersion

private

Set to the symbol library file version required.

Definition at line 204 of file sch_sexpr_parser.h.

Referenced by GetParsedRequiredVersion(), parseBusAlias(), parseEDA_TEXT(), parseHeader(), ParseLib(), parsePAGE_INFO(), parsePin(), ParseSchematic(), parseSchematicSymbol(), parseSheet(), and ParseSymbol().

m_rootSheet

SCH_SHEET* SCH_SEXPR_PARSER::m_rootSheet

private

The rootsheet for full project loads or null for importing a schematic.

Definition at line 224 of file sch_sexpr_parser.h.

Referenced by ParseSchematic().

m_rootUuid

KIID SCH_SEXPR_PARSER::m_rootUuid

private

Definition at line 221 of file sch_sexpr_parser.h.

Referenced by ParseSchematic(), parseSchSheetInstances(), and parseSchSymbolInstances().

m_symbolName

wxString SCH_SEXPR_PARSER::m_symbolName

private

The current symbol name.

Definition at line 208 of file sch_sexpr_parser.h.

Referenced by ParseSymbol().

m_unit

int SCH_SEXPR_PARSER::m_unit

private

The current unit being parsed.

Definition at line 206 of file sch_sexpr_parser.h.

Referenced by parseArc(), parseBezier(), parseCircle(), ParseLib(), parsePin(), parsePolyLine(), parseRectangle(), ParseSymbol(), and parseText().

m_uuids

std::set<KIID> SCH_SEXPR_PARSER::m_uuids

private

Definition at line 214 of file sch_sexpr_parser.h.

Referenced by parseKIID().

---

The documentation for this class was generated from the following files:

• sch_sexpr_parser.h
• sch_sexpr_parser.cpp