2726 lines
72 KiB
C++
2726 lines
72 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2020 CERN
|
|
*
|
|
* @author Wayne Stambaugh <stambaughw@gmail.com>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation, either version 3 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/**
|
|
* @file sch_sexpr_parser.cpp
|
|
* @brief Schematic and symbol library s-expression file format parser implementations.
|
|
*/
|
|
|
|
// For some reason wxWidgets is built with wxUSE_BASE64 unset so expose the wxWidgets
|
|
// base64 code.
|
|
#define wxUSE_BASE64 1
|
|
#include <wx/base64.h>
|
|
#include <wx/mstream.h>
|
|
#include <wx/tokenzr.h>
|
|
|
|
#include <common.h>
|
|
#include <lib_id.h>
|
|
|
|
#include <class_libentry.h>
|
|
#include <lib_arc.h>
|
|
#include <lib_bezier.h>
|
|
#include <lib_circle.h>
|
|
#include <lib_pin.h>
|
|
#include <lib_polyline.h>
|
|
#include <lib_rectangle.h>
|
|
#include <lib_text.h>
|
|
#include <sch_bitmap.h>
|
|
#include <sch_bus_entry.h>
|
|
#include <sch_component.h>
|
|
#include <sch_edit_frame.h> // CMP_ORIENT_XXX
|
|
#include <sch_field.h>
|
|
#include <sch_line.h>
|
|
#include <sch_junction.h>
|
|
#include <sch_no_connect.h>
|
|
#include <sch_screen.h>
|
|
#include <sch_sexpr_parser.h>
|
|
#include <template_fieldnames.h>
|
|
|
|
|
|
using namespace TSCHEMATIC_T;
|
|
|
|
|
|
SCH_SEXPR_PARSER::SCH_SEXPR_PARSER( LINE_READER* aLineReader ) :
|
|
SCHEMATIC_LEXER( aLineReader ),
|
|
m_requiredVersion( 0 ),
|
|
m_fieldId( 0 ),
|
|
m_unit( 1 ),
|
|
m_convert( 1 )
|
|
{
|
|
}
|
|
|
|
|
|
bool SCH_SEXPR_PARSER::parseBool()
|
|
{
|
|
T token = NextTok();
|
|
|
|
if( token == T_yes )
|
|
return true;
|
|
else if( token == T_no )
|
|
return false;
|
|
else
|
|
Expecting( "yes or no" );
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool SCH_SEXPR_PARSER::IsTooRecent() const
|
|
{
|
|
return m_requiredVersion && m_requiredVersion > SEXPR_SYMBOL_LIB_FILE_VERSION;
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::ParseLib( LIB_PART_MAP& aSymbolLibMap )
|
|
{
|
|
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_PART* symbol = ParseSymbol( aSymbolLibMap, m_requiredVersion );
|
|
aSymbolLibMap[symbol->GetName()] = symbol;
|
|
}
|
|
else
|
|
{
|
|
Expecting( "symbol" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
LIB_PART* SCH_SEXPR_PARSER::ParseSymbol( LIB_PART_MAP& aSymbolLibMap, int aFileVersion )
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_symbol, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a symbol." ) );
|
|
|
|
T token;
|
|
long tmp;
|
|
wxString name;
|
|
wxString error;
|
|
LIB_ITEM* item;
|
|
std::unique_ptr<LIB_PART> symbol( new LIB_PART( wxEmptyString ) );
|
|
|
|
m_requiredVersion = aFileVersion;
|
|
symbol->SetUnitCount( 1 );
|
|
|
|
m_fieldId = MANDATORY_FIELDS;
|
|
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid symbol name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
name = FromUTF8();
|
|
|
|
LIB_ID id;
|
|
|
|
if( id.Parse( name, LIB_ID::ID_SCH ) >= 0 )
|
|
{
|
|
error.Printf( _( "Invalid library identifier in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
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_property:
|
|
parseProperty( symbol );
|
|
break;
|
|
|
|
case T_extends:
|
|
{
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf(
|
|
_( "Invalid symbol extends name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
name = FromUTF8();
|
|
auto it = aSymbolLibMap.find( name );
|
|
|
|
if( it == aSymbolLibMap.end() )
|
|
{
|
|
error.Printf(
|
|
_( "No parent for extended symbol %s in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
name.c_str(), CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
symbol->SetParent( it->second );
|
|
NeedRIGHT();
|
|
break;
|
|
}
|
|
|
|
case T_symbol:
|
|
{
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf(
|
|
_( "Invalid symbol unit name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
name = FromUTF8();
|
|
|
|
if( !name.StartsWith( m_symbolName ) )
|
|
{
|
|
error.Printf(
|
|
_( "Invalid symbol unit name prefix %s in\nfile: \"%s\"\n"
|
|
"line: %d\noffset: %d" ),
|
|
name.c_str(), CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
name = name.Right( name.Length() - m_symbolName.Length() - 1 );
|
|
|
|
wxStringTokenizer tokenizer( name, "_" );
|
|
|
|
if( tokenizer.CountTokens() != 2 )
|
|
{
|
|
error.Printf(
|
|
_( "Invalid symbol unit name suffix %s in\nfile: \"%s\"\n"
|
|
"line: %d\noffset: %d" ),
|
|
name.c_str(), CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
if( !tokenizer.GetNextToken().ToLong( &tmp ) )
|
|
{
|
|
error.Printf(
|
|
_( "Invalid symbol unit number %s in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
name.c_str(), CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
m_unit = static_cast<int>( tmp );
|
|
|
|
if( !tokenizer.GetNextToken().ToLong( &tmp ) )
|
|
{
|
|
error.Printf(
|
|
_( "Invalid symbol convert number %s in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
name.c_str(), CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
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_arc:
|
|
case T_bezier:
|
|
case T_circle:
|
|
case T_pin:
|
|
case T_polyline:
|
|
case T_rectangle:
|
|
case T_text:
|
|
item = ParseDrawItem();
|
|
|
|
wxCHECK_MSG( item, nullptr, "Invalid draw item pointer." );
|
|
|
|
item->SetParent( symbol.get() );
|
|
symbol->AddDrawItem( item );
|
|
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:
|
|
item = ParseDrawItem();
|
|
|
|
wxCHECK_MSG( item, nullptr, "Invalid draw item pointer." );
|
|
|
|
item->SetParent( symbol.get() );
|
|
symbol->AddDrawItem( item );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "pin_names, pin_numbers, arc, bezier, circle, pin, polyline, "
|
|
"rectangle, or text" );
|
|
}
|
|
}
|
|
|
|
m_symbolName.clear();
|
|
|
|
return symbol.release();
|
|
}
|
|
|
|
|
|
LIB_ITEM* SCH_SEXPR_PARSER::ParseDrawItem()
|
|
{
|
|
switch( CurTok() )
|
|
{
|
|
case T_arc:
|
|
return static_cast<LIB_ITEM*>( parseArc() );
|
|
break;
|
|
|
|
case T_bezier:
|
|
return static_cast<LIB_ITEM*>( parseBezier() );
|
|
break;
|
|
|
|
case T_circle:
|
|
return static_cast<LIB_ITEM*>( parseCircle() );
|
|
break;
|
|
|
|
case T_pin:
|
|
return static_cast<LIB_ITEM*>( parsePin() );
|
|
break;
|
|
|
|
case T_polyline:
|
|
return static_cast<LIB_ITEM*>( parsePolyLine() );
|
|
break;
|
|
|
|
case T_rectangle:
|
|
return static_cast<LIB_ITEM*>( parseRectangle() );
|
|
break;
|
|
|
|
case T_text:
|
|
return static_cast<LIB_TEXT*>( parseText() );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "arc, bezier, circle, pin, polyline, rectangle, or text" );
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
double SCH_SEXPR_PARSER::parseDouble()
|
|
{
|
|
char* tmp;
|
|
|
|
errno = 0;
|
|
|
|
double fval = strtod( CurText(), &tmp );
|
|
|
|
if( errno )
|
|
{
|
|
wxString error;
|
|
error.Printf( _( "Invalid floating point number in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
if( CurText() == tmp )
|
|
{
|
|
wxString error;
|
|
error.Printf( _( "Missing floating point number in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
return fval;
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseStroke( STROKE_PARAMS& aStroke )
|
|
{
|
|
wxCHECK_RET( CurTok() == T_stroke,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a stroke." ) );
|
|
|
|
aStroke.SetWidth( Mils2iu( DEFAULT_LINE_THICKNESS ) );
|
|
aStroke.SetType( PLOT_DASH_TYPE::DEFAULT );
|
|
aStroke.SetColor( 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_width:
|
|
aStroke.SetWidth( parseInternalUnits( "stroke width" ) );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_type:
|
|
{
|
|
token = NextTok();
|
|
|
|
switch( token )
|
|
{
|
|
case T_dash: aStroke.SetType( PLOT_DASH_TYPE::DASH ); break;
|
|
case T_dot: aStroke.SetType( PLOT_DASH_TYPE::DOT ); break;
|
|
case T_dash_dot: aStroke.SetType( PLOT_DASH_TYPE::DASHDOT ); break;
|
|
case T_solid: aStroke.SetType( PLOT_DASH_TYPE::SOLID ); break;
|
|
default:
|
|
Expecting( "solid, dash, dash_dot, or dot" );
|
|
}
|
|
|
|
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 );
|
|
|
|
aStroke.SetColor( color );
|
|
NeedRIGHT();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Expecting( "width, type, or color" );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseFill( FILL_PARAMS& aFill )
|
|
{
|
|
wxCHECK_RET( CurTok() == T_fill,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as fill." ) );
|
|
|
|
aFill.m_FillType = 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 = NO_FILL; break;
|
|
case T_outline: aFill.m_FillType = FILLED_SHAPE; break;
|
|
case T_background: aFill.m_FillType = FILLED_WITH_BG_BODYCOLOR; break;
|
|
default:
|
|
Expecting( "none, outline, 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" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseEDA_TEXT( EDA_TEXT* aText )
|
|
{
|
|
wxCHECK_RET( aText && CurTok() == T_effects,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as EDA_TEXT." ) );
|
|
|
|
T token;
|
|
|
|
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_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;
|
|
|
|
default:
|
|
Expecting( "size, bold, or italic" );
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case T_justify:
|
|
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
|
|
{
|
|
switch( token )
|
|
{
|
|
case T_left:
|
|
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
|
|
break;
|
|
|
|
case T_right:
|
|
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
|
|
break;
|
|
|
|
case T_top:
|
|
aText->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
|
|
break;
|
|
|
|
case T_bottom:
|
|
aText->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
|
|
break;
|
|
|
|
case T_mirror:
|
|
aText->SetMirrored( true );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "left, right, top, bottom, or mirror" );
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case T_hide:
|
|
aText->SetVisible( false );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "font, justify, or hide" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseHeader( TSCHEMATIC_T::T aHeaderType, int aFileVersion )
|
|
{
|
|
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 ) );
|
|
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();
|
|
}
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parsePinNames( std::unique_ptr<LIB_PART>& aSymbol )
|
|
{
|
|
wxCHECK_RET( CurTok() == T_pin_names,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
|
|
wxT( " as a pin_name token." ) );
|
|
|
|
wxString error;
|
|
|
|
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 )
|
|
{
|
|
error.Printf(
|
|
_( "Invalid symbol names definition in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseProperty( std::unique_ptr<LIB_PART>& aSymbol )
|
|
{
|
|
wxCHECK_RET( CurTok() == T_property,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
|
|
wxT( " as a property token." ) );
|
|
wxCHECK( aSymbol, /* void */ );
|
|
|
|
wxString error;
|
|
wxString name;
|
|
wxString value;
|
|
std::unique_ptr<LIB_FIELD> field( new LIB_FIELD( aSymbol.get(), MANDATORY_FIELDS ) );
|
|
|
|
T token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid property name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
name = FromUTF8();
|
|
|
|
if( name.IsEmpty() )
|
|
{
|
|
error.Printf( _( "Empty property name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
field->SetName( name );
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid property value in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
// 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( static_cast<int>( parseDouble( "text angle" ) * 10.0 ) );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_effects:
|
|
parseEDA_TEXT( static_cast<EDA_TEXT*>( field.get() ) );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "id, at or effects" );
|
|
}
|
|
}
|
|
|
|
LIB_FIELD* existingField;
|
|
|
|
if( field->GetId() < MANDATORY_FIELDS )
|
|
{
|
|
existingField = aSymbol->GetField( field->GetId() );
|
|
|
|
*existingField = *field;
|
|
}
|
|
else if( name == "ki_keywords" )
|
|
{
|
|
// Not a LIB_FIELD object yet.
|
|
aSymbol->SetKeyWords( value );
|
|
}
|
|
else if( name == "ki_description" )
|
|
{
|
|
// Not a LIB_FIELD object yet.
|
|
aSymbol->SetDescription( value );
|
|
}
|
|
else if( name == "ki_fp_filters" )
|
|
{
|
|
// Not a LIB_FIELD object yet.
|
|
wxArrayString filters;
|
|
wxStringTokenizer tokenizer( value );
|
|
|
|
while( tokenizer.HasMoreTokens() )
|
|
filters.Add( tokenizer.GetNextToken() );
|
|
|
|
aSymbol->SetFootprintFilters( filters );
|
|
}
|
|
else if( name == "ki_locked" )
|
|
{
|
|
// This is a temporary LIB_FIELD object until interchangeable units are determined on
|
|
// the fly.
|
|
aSymbol->LockUnits( true );
|
|
}
|
|
else
|
|
{
|
|
existingField = aSymbol->GetField( field->GetId() );
|
|
|
|
if( !existingField )
|
|
{
|
|
aSymbol->AddDrawItem( field.release() );
|
|
}
|
|
else
|
|
{
|
|
*existingField = *field;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
LIB_ARC* SCH_SEXPR_PARSER::parseArc()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_arc, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as an arc token." ) );
|
|
|
|
T token;
|
|
wxPoint startPoint;
|
|
wxPoint midPoint;
|
|
wxPoint endPoint;
|
|
wxPoint pos;
|
|
FILL_PARAMS fill;
|
|
bool hasMidPoint = false;
|
|
std::unique_ptr<LIB_ARC> arc( new LIB_ARC( nullptr ) );
|
|
|
|
arc->SetUnit( m_unit );
|
|
arc->SetConvert( m_convert );
|
|
|
|
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();
|
|
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:
|
|
pos = parseXY();
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_length:
|
|
arc->SetRadius( parseInternalUnits( "radius length" ) );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_angles:
|
|
{
|
|
int angle1 = KiROUND( parseDouble( "start radius angle" ) * 10.0 );
|
|
int angle2 = KiROUND( parseDouble( "end radius angle" ) * 10.0 );
|
|
|
|
NORMALIZE_ANGLE_POS( angle1 );
|
|
NORMALIZE_ANGLE_POS( angle2 );
|
|
arc->SetFirstRadiusAngle( angle1 );
|
|
arc->SetSecondRadiusAngle( angle2 );
|
|
NeedRIGHT();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Expecting( "at, length, or angle" );
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case T_stroke:
|
|
NeedLEFT();
|
|
token = NextTok();
|
|
|
|
if( token != T_width )
|
|
Expecting( "width" );
|
|
|
|
arc->SetWidth( parseInternalUnits( "stroke width" ) );
|
|
NeedRIGHT(); // Closes width token;
|
|
NeedRIGHT(); // Closes stroke token;
|
|
break;
|
|
|
|
case T_fill:
|
|
parseFill( fill );
|
|
arc->SetFillMode( fill.m_FillType );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "start, end, radius, stroke, or fill" );
|
|
}
|
|
}
|
|
|
|
arc->SetPosition( pos );
|
|
arc->SetStart( startPoint );
|
|
arc->SetEnd( endPoint );
|
|
|
|
if( hasMidPoint )
|
|
{
|
|
VECTOR2I center = GetArcCenter( arc->GetStart(), midPoint, arc->GetEnd() );
|
|
|
|
arc->SetPosition( wxPoint( center.x, center.y ) );
|
|
|
|
// @todo Calculate the radius.
|
|
|
|
arc->CalcRadiusAngles();
|
|
}
|
|
|
|
return arc.release();
|
|
}
|
|
|
|
|
|
LIB_BEZIER* SCH_SEXPR_PARSER::parseBezier()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_bezier, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a bezier." ) );
|
|
|
|
T token;
|
|
FILL_PARAMS fill;
|
|
std::unique_ptr<LIB_BEZIER> bezier( new LIB_BEZIER( nullptr ) );
|
|
|
|
bezier->SetUnit( m_unit );
|
|
bezier->SetConvert( m_convert );
|
|
|
|
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:
|
|
NeedLEFT();
|
|
token = NextTok();
|
|
|
|
if( token != T_width )
|
|
Expecting( "width" );
|
|
|
|
bezier->SetWidth( parseInternalUnits( "stroke width" ) );
|
|
NeedRIGHT(); // Closes width token;
|
|
NeedRIGHT(); // Closes stroke token;
|
|
break;
|
|
|
|
case T_fill:
|
|
parseFill( fill );
|
|
bezier->SetFillMode( fill.m_FillType );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "pts, stroke, or fill" );
|
|
}
|
|
}
|
|
|
|
return bezier.release();
|
|
}
|
|
|
|
|
|
LIB_CIRCLE* SCH_SEXPR_PARSER::parseCircle()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_circle, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a circle token." ) );
|
|
|
|
T token;
|
|
FILL_PARAMS fill;
|
|
std::unique_ptr<LIB_CIRCLE> circle( new LIB_CIRCLE( nullptr ) );
|
|
|
|
circle->SetUnit( m_unit );
|
|
circle->SetConvert( m_convert );
|
|
|
|
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
|
|
{
|
|
if( token != T_LEFT )
|
|
Expecting( T_LEFT );
|
|
|
|
token = NextTok();
|
|
|
|
switch( token )
|
|
{
|
|
case T_center:
|
|
circle->SetPosition( parseXY() );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_radius:
|
|
circle->SetRadius( parseInternalUnits( "radius length" ) );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_stroke:
|
|
NeedLEFT();
|
|
token = NextTok();
|
|
|
|
if( token != T_width )
|
|
Expecting( "width" );
|
|
|
|
circle->SetWidth( parseInternalUnits( "stroke width" ) );
|
|
NeedRIGHT(); // Closes width token;
|
|
NeedRIGHT(); // Closes stroke token;
|
|
break;
|
|
|
|
case T_fill:
|
|
parseFill( fill );
|
|
circle->SetFillMode( fill.m_FillType );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "start, end, radius, stroke, or fill" );
|
|
}
|
|
}
|
|
|
|
return circle.release();
|
|
}
|
|
|
|
|
|
LIB_PIN* SCH_SEXPR_PARSER::parsePin()
|
|
{
|
|
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: return ELECTRICAL_PINTYPE::PT_NC;
|
|
|
|
default:
|
|
Expecting( "input, output, bidirectional, tri_state, passive, "
|
|
"unspecified, power_in, power_out, open_collector, "
|
|
"open_emitter, or unconnected" );
|
|
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( new 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 ) )
|
|
{
|
|
error.Printf( _( "Invalid pin name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
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;
|
|
|
|
parseEDA_TEXT( &text );
|
|
pin->SetNameTextSize( text.GetTextHeight() );
|
|
NeedRIGHT();
|
|
}
|
|
else
|
|
{
|
|
Expecting( "effects" );
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case T_number:
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid pin number in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
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;
|
|
|
|
parseEDA_TEXT( &text );
|
|
pin->SetNumberTextSize( text.GetTextHeight() );
|
|
NeedRIGHT();
|
|
}
|
|
else
|
|
{
|
|
Expecting( "effects" );
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case T_alternate:
|
|
{
|
|
LIB_PIN::ALT alt;
|
|
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid alternate pin name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
|
|
LIB_POLYLINE* SCH_SEXPR_PARSER::parsePolyLine()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_polyline, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a polyline." ) );
|
|
|
|
T token;
|
|
FILL_PARAMS fill;
|
|
std::unique_ptr<LIB_POLYLINE> polyLine( new LIB_POLYLINE( nullptr ) );
|
|
|
|
polyLine->SetUnit( m_unit );
|
|
polyLine->SetConvert( m_convert );
|
|
|
|
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:
|
|
NeedLEFT();
|
|
token = NextTok();
|
|
|
|
if( token != T_width )
|
|
Expecting( "width" );
|
|
|
|
polyLine->SetWidth( parseInternalUnits( "stroke width" ) );
|
|
NeedRIGHT(); // Closes width token;
|
|
NeedRIGHT(); // Closes stroke token;
|
|
break;
|
|
|
|
case T_fill:
|
|
parseFill( fill );
|
|
polyLine->SetFillMode( fill.m_FillType );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "pts, stroke, or fill" );
|
|
}
|
|
}
|
|
|
|
return polyLine.release();
|
|
}
|
|
|
|
|
|
LIB_RECTANGLE* SCH_SEXPR_PARSER::parseRectangle()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_rectangle, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a rectangle token." ) );
|
|
|
|
T token;
|
|
FILL_PARAMS fill;
|
|
std::unique_ptr<LIB_RECTANGLE> rectangle( new LIB_RECTANGLE( nullptr ) );
|
|
|
|
rectangle->SetUnit( m_unit );
|
|
rectangle->SetConvert( m_convert );
|
|
|
|
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:
|
|
NeedLEFT();
|
|
token = NextTok();
|
|
|
|
if( token != T_width )
|
|
Expecting( "width" );
|
|
|
|
rectangle->SetWidth( parseInternalUnits( "stroke width" ) );
|
|
NeedRIGHT(); // Closes width token;
|
|
NeedRIGHT(); // Closes stroke token;
|
|
break;
|
|
|
|
case T_fill:
|
|
parseFill( fill );
|
|
rectangle->SetFillMode( fill.m_FillType );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "start, end, stroke, or fill" );
|
|
}
|
|
}
|
|
|
|
return rectangle.release();
|
|
}
|
|
|
|
|
|
LIB_TEXT* SCH_SEXPR_PARSER::parseText()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_text, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a text token." ) );
|
|
|
|
T token;
|
|
wxString tmp;
|
|
wxString error;
|
|
std::unique_ptr<LIB_TEXT> text( new LIB_TEXT( nullptr ) );
|
|
|
|
text->SetUnit( m_unit );
|
|
text->SetConvert( m_convert );
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid text string in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
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() );
|
|
text->SetTextAngle( parseDouble( "text angle" ) );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_effects:
|
|
parseEDA_TEXT( static_cast<EDA_TEXT*>( text.get() ) );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "at or effects" );
|
|
}
|
|
}
|
|
|
|
return text.release();
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parsePAGE_INFO( PAGE_INFO& aPageInfo )
|
|
{
|
|
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 ) )
|
|
{
|
|
wxString err;
|
|
err.Printf( _( "Page type \"%s\" is not valid " ), GetChars( FromUTF8() ) );
|
|
THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
|
|
}
|
|
|
|
if( pageType == PAGE_INFO::Custom )
|
|
{
|
|
double width = parseDouble( "width" ); // width in mm
|
|
|
|
// Perform some controls to avoid crashes if the size is edited by hands
|
|
if( width < 100.0 )
|
|
width = 100.0;
|
|
else if( width > 1200.0 )
|
|
width = 1200.0;
|
|
|
|
double height = parseDouble( "height" ); // height in mm
|
|
|
|
if( height < 100.0 )
|
|
height = 100.0;
|
|
else if( height > 1200.0 )
|
|
height = 1200.0;
|
|
|
|
aPageInfo.SetWidthMils( Mm2mils( width ) );
|
|
aPageInfo.SetHeightMils( Mm2mils( height ) );
|
|
}
|
|
|
|
token = NextTok();
|
|
|
|
if( token == T_portrait )
|
|
{
|
|
aPageInfo.SetPortrait( true );
|
|
NeedRIGHT();
|
|
}
|
|
else if( token != T_RIGHT )
|
|
{
|
|
Expecting( "portrait" );
|
|
}
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseTITLE_BLOCK( TITLE_BLOCK& aTitleBlock )
|
|
{
|
|
wxCHECK_RET( CurTok() == T_title_block,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
|
|
wxT( " as 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:
|
|
wxString err;
|
|
err.Printf( wxT( "%d is not a valid title block comment number" ), commentNumber );
|
|
THROW_PARSE_ERROR( err, CurSource(), CurLine(), CurLineNumber(), CurOffset() );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Expecting( "title, date, rev, company, or comment" );
|
|
}
|
|
|
|
NeedRIGHT();
|
|
}
|
|
}
|
|
|
|
|
|
SCH_FIELD* SCH_SEXPR_PARSER::parseSchField( SCH_ITEM* aParent )
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_property, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
|
|
wxT( " as a property token." ) );
|
|
|
|
wxString error;
|
|
wxString name;
|
|
wxString value;
|
|
|
|
T token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid property name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
name = FromUTF8();
|
|
|
|
if( name.IsEmpty() )
|
|
{
|
|
error.Printf( _( "Empty property name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid property value in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
// Empty property values are valid.
|
|
value = FromUTF8();
|
|
|
|
std::unique_ptr<SCH_FIELD> field( new SCH_FIELD( wxDefaultPosition, -1, aParent, name ) );
|
|
|
|
field->SetText( value );
|
|
field->SetVisible( true );
|
|
|
|
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( static_cast<int>( parseDouble( "text angle" ) * 10.0 ) );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_effects:
|
|
parseEDA_TEXT( static_cast<EDA_TEXT*>( field.get() ) );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "at or effects" );
|
|
}
|
|
}
|
|
|
|
return field.release();
|
|
}
|
|
|
|
|
|
SCH_SHEET_PIN* SCH_SEXPR_PARSER::parseSchSheetPin( SCH_SHEET* aSheet )
|
|
{
|
|
wxCHECK_MSG( aSheet != nullptr, nullptr, "" );
|
|
wxCHECK_MSG( CurTok() == T_pin, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
|
|
wxT( " as a sheet pin token." ) );
|
|
|
|
wxString error;
|
|
wxString name;
|
|
wxString shape;
|
|
|
|
T token = NextTok();
|
|
|
|
if( !IsSymbol( token ) )
|
|
{
|
|
error.Printf( _( "Invalid sheet pin name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
name = FromUTF8();
|
|
|
|
if( name.IsEmpty() )
|
|
{
|
|
error.Printf( _( "Empty sheet pin name in\nfile: \"%s\"\nline: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
std::unique_ptr<SCH_SHEET_PIN> sheetPin( new SCH_SHEET_PIN( aSheet, wxPoint( 0, 0 ), name ) );
|
|
|
|
token = NextTok();
|
|
|
|
switch( token )
|
|
{
|
|
case T_input: sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_INPUT ); break;
|
|
case T_output: sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_OUTPUT ); break;
|
|
case T_bidirectional: sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_BIDI ); break;
|
|
case T_tri_state: sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_TRISTATE ); break;
|
|
case T_passive: sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_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->SetEdge( SHEET_RIGHT_SIDE );
|
|
else if( angle == 90.0 )
|
|
sheetPin->SetEdge( SHEET_TOP_SIDE );
|
|
else if( angle == 180.0 )
|
|
sheetPin->SetEdge( SHEET_LEFT_SIDE );
|
|
else if( angle == 270.0 )
|
|
sheetPin->SetEdge( SHEET_BOTTOM_SIDE );
|
|
else
|
|
Expecting( "0, 90, 180, or 270" );
|
|
|
|
NeedRIGHT();
|
|
break;
|
|
}
|
|
|
|
case T_effects:
|
|
parseEDA_TEXT( static_cast<EDA_TEXT*>( sheetPin.get() ) );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "at or effects" );
|
|
}
|
|
}
|
|
|
|
return sheetPin.release();
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseSchSymbolInstances( SCH_SCREEN* aScreen )
|
|
{
|
|
wxCHECK_RET( CurTok() == T_symbol_instances,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
|
|
wxT( " as a 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();
|
|
|
|
COMPONENT_INSTANCE_REFERENCE instance;
|
|
|
|
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();
|
|
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" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::ParseSchematic( SCH_SHEET* aSheet, bool aIsCopyableOnly, int aFileVersion )
|
|
{
|
|
wxCHECK( aSheet != nullptr, /* void */ );
|
|
|
|
SCH_SCREEN* screen = aSheet->GetScreen();
|
|
|
|
wxCHECK( screen != nullptr, /* void */ );
|
|
|
|
if( aIsCopyableOnly )
|
|
m_requiredVersion = aFileVersion;
|
|
|
|
T token;
|
|
|
|
if( !aIsCopyableOnly )
|
|
{
|
|
NeedLEFT();
|
|
NextTok();
|
|
|
|
if( CurTok() != T_kicad_sch )
|
|
Expecting( "kicad_sch" );
|
|
|
|
parseHeader( T_kicad_sch, SEXPR_SCHEMATIC_FILE_VERSION );
|
|
}
|
|
|
|
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
|
|
{
|
|
if( aIsCopyableOnly && token == T_EOF )
|
|
break;
|
|
|
|
if( token != T_LEFT )
|
|
Expecting( T_LEFT );
|
|
|
|
token = NextTok();
|
|
|
|
if( !aIsCopyableOnly && token == T_page && m_requiredVersion <= 20200506 )
|
|
token = T_paper;
|
|
|
|
switch( token )
|
|
{
|
|
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_PART_MAP symbolLibMap;
|
|
|
|
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
|
|
{
|
|
if( token != T_LEFT )
|
|
Expecting( T_LEFT );
|
|
|
|
token = NextTok();
|
|
|
|
switch( token )
|
|
{
|
|
case T_symbol:
|
|
screen->AddLibSymbol( ParseSymbol( symbolLibMap ) );
|
|
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( static_cast<SCH_ITEM*>( sheet ) );
|
|
break;
|
|
}
|
|
|
|
case T_junction:
|
|
screen->Append( static_cast<SCH_ITEM*>( parseJunction() ) );
|
|
break;
|
|
|
|
case T_no_connect:
|
|
screen->Append( static_cast<SCH_ITEM*>( parseNoConnect() ) );
|
|
break;
|
|
|
|
case T_bus_entry:
|
|
screen->Append( static_cast<SCH_ITEM*>( parseBusEntry() ) );
|
|
break;
|
|
|
|
case T_polyline:
|
|
case T_bus:
|
|
case T_wire:
|
|
screen->Append( static_cast<SCH_ITEM*>( parseLine() ) );
|
|
break;
|
|
|
|
case T_text:
|
|
case T_label:
|
|
case T_global_label:
|
|
case T_hierarchical_label:
|
|
screen->Append( static_cast<SCH_ITEM*>( parseSchText() ) );
|
|
break;
|
|
|
|
case T_symbol_instances:
|
|
if( aIsCopyableOnly )
|
|
Unexpected( 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, global_label, hierarchical_label, "
|
|
"symbol_instances, or bus_alias" );
|
|
}
|
|
}
|
|
|
|
screen->UpdateLocalLibSymbolLinks();
|
|
}
|
|
|
|
|
|
SCH_COMPONENT* SCH_SEXPR_PARSER::parseSchematicSymbol()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_symbol, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a symbol." ) );
|
|
|
|
T token;
|
|
wxString tmp;
|
|
wxString error;
|
|
wxString libName;
|
|
SCH_FIELD* field;
|
|
std::unique_ptr<SCH_COMPONENT> symbol( new SCH_COMPONENT() );
|
|
TRANSFORM transform;
|
|
std::set<int> fieldIDsRead;
|
|
|
|
m_fieldId = MANDATORY_FIELDS;
|
|
|
|
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 ) )
|
|
{
|
|
error.Printf( _( "Invalid symbol library name in\nfile: \"%s\"\n"
|
|
"line: %d\noffset: %d" ),
|
|
CurSource().c_str(), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
libName = FromUTF8();
|
|
NeedRIGHT();
|
|
break;
|
|
}
|
|
|
|
case T_lib_id:
|
|
{
|
|
token = NextTok();
|
|
|
|
if( !IsSymbol( token ) && token != T_NUMBER )
|
|
Expecting( "symbol|number" );
|
|
|
|
LIB_ID libId;
|
|
|
|
if( libId.Parse( FromUTF8(), LIB_ID::ID_SCH ) >= 0 )
|
|
{
|
|
error.Printf( _( "Invalid symbol library ID in\nfile: \"%s\"\nline: %d\n"
|
|
"offset: %d" ),
|
|
GetChars( CurSource() ), CurLineNumber(), CurOffset() );
|
|
THROW_IO_ERROR( error );
|
|
}
|
|
|
|
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( CMP_MIRROR_X );
|
|
else if( token == T_y )
|
|
symbol->SetOrientation( CMP_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_uuid:
|
|
NeedSYMBOL();
|
|
const_cast<KIID&>( symbol->m_Uuid ) = KIID( FromUTF8() );
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
case T_property:
|
|
{
|
|
// The field parent symbol must be set and it's orientation must be set before
|
|
// the field positions are set.
|
|
field = parseSchField( symbol.get() );
|
|
|
|
// It would appear that at some point we allowed duplicate ids to slip through
|
|
// when writing files. 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 fields and will
|
|
// get written out as the next unused number on save.
|
|
if( fieldIDsRead.count( field->GetId() ) )
|
|
field->SetId( -1 );
|
|
else
|
|
fieldIDsRead.insert( field->GetId() );
|
|
|
|
// Set the default symbol reference prefix.
|
|
if( field->GetId() == REFERENCE )
|
|
{
|
|
wxString refDesignator = field->GetText();
|
|
|
|
refDesignator.Replace( "~", " " );
|
|
|
|
wxString prefix = refDesignator;
|
|
|
|
while( prefix.Length() )
|
|
{
|
|
if( ( prefix.Last() < '0' || prefix.Last() > '9') && prefix.Last() != '?' )
|
|
break;
|
|
|
|
prefix.RemoveLast();
|
|
}
|
|
|
|
// Avoid a prefix containing trailing/leading spaces
|
|
prefix.Trim( true );
|
|
prefix.Trim( false );
|
|
|
|
if( prefix.IsEmpty() )
|
|
symbol->SetPrefix( wxString( "U" ) );
|
|
else
|
|
symbol->SetPrefix( prefix );
|
|
}
|
|
|
|
if( symbol->GetField( field->GetId() ) )
|
|
*symbol->GetField( field->GetId() ) = *field;
|
|
else
|
|
symbol->AddField( *field );
|
|
|
|
delete field;
|
|
break;
|
|
}
|
|
|
|
case T_pin:
|
|
{
|
|
SCH_PIN* pin = new SCH_PIN( nullptr, symbol.get() );
|
|
|
|
NeedSYMBOL();
|
|
pin->SetNumber( FromUTF8() );
|
|
|
|
token = NextTok();
|
|
|
|
if( token == T_alternate )
|
|
{
|
|
NeedSYMBOL();
|
|
pin->SetAlt( FromUTF8() );
|
|
NeedRIGHT();
|
|
}
|
|
else
|
|
{
|
|
Expecting( "alternate" );
|
|
}
|
|
|
|
symbol->GetPins().push_back( pin );
|
|
|
|
NeedRIGHT();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Expecting( "lib_id, lib_name, at, mirror, uuid, 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();
|
|
}
|
|
|
|
|
|
SCH_BITMAP* SCH_SEXPR_PARSER::parseImage()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_image, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as an image." ) );
|
|
|
|
T token;
|
|
std::unique_ptr<SCH_BITMAP> bitmap( new 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_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 );
|
|
bitmap->GetImage()->SetBitmap( new wxBitmap( *image ) );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Expecting( "at, scale, or data" );
|
|
}
|
|
}
|
|
|
|
return bitmap.release();
|
|
}
|
|
|
|
|
|
SCH_SHEET* SCH_SEXPR_PARSER::parseSheet()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_sheet, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a sheet." ) );
|
|
|
|
T token;
|
|
STROKE_PARAMS stroke;
|
|
FILL_PARAMS fill;
|
|
SCH_FIELD* field;
|
|
std::vector<SCH_FIELD> fields;
|
|
std::unique_ptr<SCH_SHEET> sheet( new SCH_SHEET() );
|
|
std::set<int> fieldIDsRead;
|
|
|
|
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_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 ) = KIID( FromUTF8() );
|
|
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 fields and will
|
|
// get written out as the next unused number on save.
|
|
if( fieldIDsRead.count( field->GetId() ) )
|
|
field->SetId( -1 );
|
|
else
|
|
fieldIDsRead.insert( field->GetId() );
|
|
|
|
fields.emplace_back( *field );
|
|
delete field;
|
|
break;
|
|
|
|
case T_pin:
|
|
sheet->AddPin( parseSchSheetPin( sheet.get() ) );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "at, size, stroke, background, uuid, property, or pin" );
|
|
}
|
|
}
|
|
|
|
sheet->SetFields( fields );
|
|
|
|
return sheet.release();
|
|
}
|
|
|
|
|
|
SCH_JUNCTION* SCH_SEXPR_PARSER::parseJunction()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_junction, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a junction." ) );
|
|
|
|
T token;
|
|
std::unique_ptr<SCH_JUNCTION> junction( new 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;
|
|
}
|
|
|
|
default:
|
|
Expecting( "at" );
|
|
}
|
|
}
|
|
|
|
return junction.release();
|
|
}
|
|
|
|
|
|
SCH_NO_CONNECT* SCH_SEXPR_PARSER::parseNoConnect()
|
|
{
|
|
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( new 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;
|
|
|
|
default:
|
|
Expecting( "at" );
|
|
}
|
|
}
|
|
|
|
return no_connect.release();
|
|
}
|
|
|
|
|
|
SCH_BUS_WIRE_ENTRY* SCH_SEXPR_PARSER::parseBusEntry()
|
|
{
|
|
wxCHECK_MSG( CurTok() == T_bus_entry, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a bus entry." ) );
|
|
|
|
T token;
|
|
STROKE_PARAMS stroke;
|
|
std::unique_ptr<SCH_BUS_WIRE_ENTRY> busEntry( new 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;
|
|
|
|
default:
|
|
Expecting( "at, size, or stroke" );
|
|
}
|
|
}
|
|
|
|
return busEntry.release();
|
|
}
|
|
|
|
|
|
SCH_LINE* SCH_SEXPR_PARSER::parseLine()
|
|
{
|
|
T token;
|
|
STROKE_PARAMS stroke;
|
|
std::unique_ptr<SCH_LINE> line( new SCH_LINE() );
|
|
|
|
switch( CurTok() )
|
|
{
|
|
case T_polyline: line->SetLayer( LAYER_NOTES ); break;
|
|
case T_wire: line->SetLayer( LAYER_WIRE ); break;
|
|
case T_bus: line->SetLayer( LAYER_BUS ); break;
|
|
default:
|
|
wxCHECK_MSG( false, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a line." ) );
|
|
}
|
|
|
|
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;
|
|
|
|
default:
|
|
Expecting( "at or stroke" );
|
|
}
|
|
}
|
|
|
|
return line.release();
|
|
}
|
|
|
|
|
|
SCH_TEXT* SCH_SEXPR_PARSER::parseSchText()
|
|
{
|
|
T token;
|
|
std::unique_ptr<SCH_TEXT> text;
|
|
|
|
switch( CurTok() )
|
|
{
|
|
case T_text: text.reset( new SCH_TEXT ); break;
|
|
case T_label: text.reset( new SCH_LABEL ); break;
|
|
case T_global_label: text.reset( new SCH_GLOBALLABEL ); break;
|
|
case T_hierarchical_label: text.reset( new SCH_HIERLABEL ); break;
|
|
default:
|
|
wxCHECK_MSG( false, nullptr,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as text." ) );
|
|
}
|
|
|
|
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->SetLabelSpinStyle( LABEL_SPIN_STYLE::RIGHT ); break;
|
|
case 90: text->SetLabelSpinStyle( LABEL_SPIN_STYLE::UP ); break;
|
|
case 180: text->SetLabelSpinStyle( LABEL_SPIN_STYLE::LEFT ); break;
|
|
case 270: text->SetLabelSpinStyle( LABEL_SPIN_STYLE::BOTTOM ); break;
|
|
default:
|
|
wxFAIL;
|
|
text->SetLabelSpinStyle( LABEL_SPIN_STYLE::RIGHT );
|
|
break;
|
|
}
|
|
|
|
NeedRIGHT();
|
|
break;
|
|
}
|
|
|
|
case T_shape:
|
|
{
|
|
if( text->Type() == SCH_TEXT_T || text->Type() == SCH_LABEL_T )
|
|
Unexpected( T_shape );
|
|
|
|
token = NextTok();
|
|
|
|
switch( token )
|
|
{
|
|
case T_input: text->SetShape( PINSHEETLABEL_SHAPE::PS_INPUT ); break;
|
|
case T_output: text->SetShape( PINSHEETLABEL_SHAPE::PS_OUTPUT ); break;
|
|
case T_bidirectional: text->SetShape( PINSHEETLABEL_SHAPE::PS_BIDI ); break;
|
|
case T_tri_state: text->SetShape( PINSHEETLABEL_SHAPE::PS_TRISTATE ); break;
|
|
case T_passive: text->SetShape( PINSHEETLABEL_SHAPE::PS_UNSPECIFIED ); break;
|
|
default:
|
|
Expecting( "input, output, bidirectional, tri_state, or passive" );
|
|
}
|
|
|
|
NeedRIGHT();
|
|
break;
|
|
}
|
|
|
|
case T_effects:
|
|
parseEDA_TEXT( static_cast<EDA_TEXT*>( text.get() ) );
|
|
break;
|
|
|
|
default:
|
|
Expecting( "at, shape, or effects" );
|
|
}
|
|
}
|
|
|
|
return text.release();
|
|
}
|
|
|
|
|
|
void SCH_SEXPR_PARSER::parseBusAlias( SCH_SCREEN* aScreen )
|
|
{
|
|
wxCHECK_RET( CurTok() == T_bus_alias,
|
|
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a bus alias." ) );
|
|
wxCHECK( aScreen, /* void */ );
|
|
|
|
T token;
|
|
auto busAlias = std::make_shared< BUS_ALIAS >( aScreen );
|
|
|
|
NeedSYMBOL();
|
|
busAlias->SetName( FromUTF8() );
|
|
NeedLEFT();
|
|
token = NextTok();
|
|
|
|
if( token != T_members )
|
|
Expecting( "members" );
|
|
|
|
token = NextTok();
|
|
|
|
while( token != T_RIGHT )
|
|
{
|
|
if( !IsSymbol( token ) )
|
|
Expecting( "quoted string" );
|
|
|
|
busAlias->AddMember( FromUTF8() );
|
|
token = NextTok();
|
|
}
|
|
|
|
NeedRIGHT();
|
|
|
|
aScreen->AddBusAlias( busAlias );
|
|
}
|