haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/eeschema/sch_sexpr_parser.cpp

2643 lines
68 KiB
C++
Raw Normal View History

Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2020 CERN
*
* @author Wayne Stambaugh <stambaughw@gmail.com>
*
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
* 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.
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
*
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
* 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.
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
*
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
*/
/**
* @file sch_sexpr_parser.cpp
* @brief Schematic and symbol library s-expression file format parser implementations.
*/
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
// For some reason wxWidgets is built with wxUSE_BASE64 unset so expose the wxWidgets
// base64 code.
#define wxUSE_BASE64 1
#include <wx/base64.h>
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
#include <wx/mstream.h>
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
#include <wx/tokenzr.h>
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
#include <common.h>
#include <lib_id.h>
#include <plotter.h>
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
#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>
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
#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>
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
#include <sch_sexpr_parser.h>
#include <template_fieldnames.h>
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
using namespace TSCHEMATIC_T;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
SCH_SEXPR_PARSER::SCH_SEXPR_PARSER( LINE_READER* aLineReader ) :
Eeschema: implement s-expression schematic file formatter. Please note that the symbol cache is not embedded in the schematic file to allow for round robin testing with the existing file format. Once the parser round robin testing is complete, the symbol cache will be embedded in the schematic file.
2020-03-16 13:04:50 +00:00
SCHEMATIC_LEXER( aLineReader ),
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
m_requiredVersion( 0 ),
fix a few minor Coverity warnings.
2020-04-10 16:28:12 +00:00
m_fieldId( 0 ),
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
m_unit( 1 ),
m_convert( 1 )
{
}
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();
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
parseHeader( T_kicad_symbol_lib, SEXPR_SYMBOL_LIB_FILE_VERSION );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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;
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
LIB_PART* symbol = ParseSymbol( aSymbolLibMap, m_requiredVersion );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
aSymbolLibMap[symbol->GetName()] = symbol;
}
else
{
Expecting( "symbol" );
}
}
}
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
LIB_PART* SCH_SEXPR_PARSER::ParseSymbol( LIB_PART_MAP& aSymbolLibMap, int aFileVersion )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
wxCHECK_MSG( CurTok() == T_symbol, nullptr,
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a symbol." ) );
T token;
long tmp;
wxString name;
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
wxString error;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
LIB_ITEM* item;
std::unique_ptr<LIB_PART> symbol( new LIB_PART( wxEmptyString ) );
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
m_requiredVersion = aFileVersion;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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();
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
LIB_ID id;
if( id.Parse( name, LIB_ID::ID_SCH ) >= 0 )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
error.Printf( _( "Invalid library identifier in\nfile: \"%s\"\nline: %d\noffset: %d" ),
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
CurSource().c_str(), CurLineNumber(), CurOffset() );
THROW_IO_ERROR( error );
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
m_symbolName = id.GetLibItemName().wx_str();
symbol->SetName( m_symbolName );
symbol->SetLibId( id );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
{
if( token != T_LEFT )
Expecting( T_LEFT );
token = NextTok();
switch( token )
{
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
case T_power:
symbol->SetPower();
NeedRIGHT();
break;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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(
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
_( "Invalid symbol unit name prefix %s in\nfile: \"%s\"\n"
"line: %d\noffset: %d" ),
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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(
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
_( "Invalid symbol unit name suffix %s in\nfile: \"%s\"\n"
"line: %d\noffset: %d" ),
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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;
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
void SCH_SEXPR_PARSER::parseStroke( STROKE_PARAMS& aStroke )
{
wxCHECK_RET( CurTok() == T_stroke,
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as a stroke." ) );
Eeschema: avoid initializing default line thickness to 0: it can create issues. Some graphic line thickness were initialized to 0. The actual line thickness is set after reading config. But in some cases the config does not exist, and 0 line thickness creates draw issues.
2020-04-12 17:50:33 +00:00
aStroke.m_Width = Mils2iu( DEFAULT_LINE_THICKNESS );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
aStroke.m_Type = PLOT_DASH_TYPE::DEFAULT;
aStroke.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_width:
aStroke.m_Width = parseInternalUnits( "stroke width" );
NeedRIGHT();
break;
case T_type:
{
token = NextTok();
switch( token )
{
case T_dash: aStroke.m_Type = PLOT_DASH_TYPE::DASH; break;
case T_dot: aStroke.m_Type = PLOT_DASH_TYPE::DOT; break;
case T_dash_dot: aStroke.m_Type = PLOT_DASH_TYPE::DASHDOT; break;
case T_solid: aStroke.m_Type = PLOT_DASH_TYPE::SOLID; break;
default:
Expecting( "solid, dash, dash_dot, or dot" );
}
NeedRIGHT();
break;
}
case T_color:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
{
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.m_Color = color;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
NeedRIGHT();
break;
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
default:
Expecting( "width, type, or color" );
}
}
}
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
void SCH_SEXPR_PARSER::parseFill( FILL_PARAMS& aFill )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
wxCHECK_RET( CurTok() == T_fill,
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as fill." ) );
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
aFill.m_FillType = NO_FILL;
aFill.m_Color = COLOR4D::UNSPECIFIED;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
T token;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
{
if( token != T_LEFT )
Expecting( T_LEFT );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
token = NextTok();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
switch( token )
{
case T_type:
{
token = NextTok();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
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" );
}
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
NeedRIGHT();
break;
}
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
case T_color:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
{
COLOR4D color;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
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;
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
NeedRIGHT();
break;
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
}
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
default:
Expecting( "type or color" );
}
}
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
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:
Remove a bunch of globals.
2020-04-14 12:25:00 +00:00
aText->SetTextThickness( parseInternalUnits( "text thickness" ) );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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" );
}
}
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
void SCH_SEXPR_PARSER::parseHeader( TSCHEMATIC_T::T aHeaderType, int aFileVersion )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
wxCHECK_RET( CurTok() == aHeaderType,
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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();
NeedSYMBOL();
NeedRIGHT();
}
else
{
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
m_requiredVersion = aFileVersion;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
// 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,
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
wxT( " as a pin_name token." ) );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
wxString error;
T token = NextTok();
if( token == T_LEFT )
{
token = NextTok();
if( token != T_offset )
Expecting( "offset" );
aSymbol->SetPinNameOffset( parseInternalUnits( "pin name offset" ) );
NeedRIGHT();
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
token = NextTok(); // Either ) or hide
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
if( token == T_hide )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
aSymbol->SetShowPinNames( false );
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
NeedRIGHT();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
else if( token != T_RIGHT )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
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,
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
wxT( " as a property token." ) );
Eeschema: fix new symbol library file format parser bug. LIB_FIELD objects require a LIB_PART as a parent. Add missing parent on symbol library load. Fixes https://gitlab.com/kicad/code/kicad/issues/4360
2020-05-08 17:33:41 +00:00
wxCHECK( aSymbol, /* void */ );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
wxString error;
wxString name;
wxString value;
Eeschema: fix new symbol library file format parser bug. LIB_FIELD objects require a LIB_PART as a parent. Add missing parent on symbol library load. Fixes https://gitlab.com/kicad/code/kicad/issues/4360
2020-05-08 17:33:41 +00:00
std::unique_ptr<LIB_FIELD> field( new LIB_FIELD( aSymbol.get(), MANDATORY_FIELDS ) );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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 );
}
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
field->SetName( name );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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();
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
field->SetText( value );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
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" );
}
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
LIB_FIELD* existingField;
if( field->GetId() < MANDATORY_FIELDS )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
existingField = aSymbol->GetField( field->GetId() );
/// @todo Remove this once the legacy file format is deprecated.
if( field->GetId() == DATASHEET )
{
aSymbol->SetDocFileName( value );
field->SetText( wxEmptyString );
}
*existingField = *field;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
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" )
{
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
// This is a temporary LIB_FIELD object until interchangeable units are determined on
// the fly.
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
aSymbol->LockUnits( true );
}
else
{
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
existingField = aSymbol->GetField( field->GetId() );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
if( !existingField )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
aSymbol->AddDrawItem( field.release() );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
else
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
*existingField = *field;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
}
}
LIB_ARC* SCH_SEXPR_PARSER::parseArc()
{
wxCHECK_MSG( CurTok() == T_arc, nullptr,
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) + wxT( " as an arc token." ) );
T token;
Eeschema: implement s-expression schematic file formatter. Please note that the symbol cache is not embedded in the schematic file to allow for round robin testing with the existing file format. Once the parser round robin testing is complete, the symbol cache will be embedded in the schematic file.
2020-03-16 13:04:50 +00:00
wxPoint startPoint;
wxPoint midPoint;
wxPoint endPoint;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
wxPoint pos;
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
FILL_PARAMS fill;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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:
Eeschema: implement s-expression schematic file formatter. Please note that the symbol cache is not embedded in the schematic file to allow for round robin testing with the existing file format. Once the parser round robin testing is complete, the symbol cache will be embedded in the schematic file.
2020-03-16 13:04:50 +00:00
startPoint = parseXY();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
NeedRIGHT();
break;
case T_mid:
Eeschema: implement s-expression schematic file formatter. Please note that the symbol cache is not embedded in the schematic file to allow for round robin testing with the existing file format. Once the parser round robin testing is complete, the symbol cache will be embedded in the schematic file.
2020-03-16 13:04:50 +00:00
midPoint = parseXY();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
NeedRIGHT();
hasMidPoint = true;
break;
case T_end:
Eeschema: implement s-expression schematic file formatter. Please note that the symbol cache is not embedded in the schematic file to allow for round robin testing with the existing file format. Once the parser round robin testing is complete, the symbol cache will be embedded in the schematic file.
2020-03-16 13:04:50 +00:00
endPoint = parseXY();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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:
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
parseFill( fill );
arc->SetFillMode( fill.m_FillType );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
break;
default:
Expecting( "start, end, radius, stroke, or fill" );
}
}
arc->SetPosition( pos );
Eeschema: implement s-expression schematic file formatter. Please note that the symbol cache is not embedded in the schematic file to allow for round robin testing with the existing file format. Once the parser round robin testing is complete, the symbol cache will be embedded in the schematic file.
2020-03-16 13:04:50 +00:00
arc->SetStart( startPoint );
arc->SetEnd( endPoint );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
if( hasMidPoint )
{
Eeschema: implement s-expression schematic file formatter. Please note that the symbol cache is not embedded in the schematic file to allow for round robin testing with the existing file format. Once the parser round robin testing is complete, the symbol cache will be embedded in the schematic file.
2020-03-16 13:04:50 +00:00
VECTOR2I center = GetArcCenter( arc->GetStart(), midPoint, arc->GetEnd() );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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;
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
FILL_PARAMS fill;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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:
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
parseFill( fill );
bezier->SetFillMode( fill.m_FillType );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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;
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
FILL_PARAMS fill;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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:
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
parseFill( fill );
circle->SetFillMode( fill.m_FillType );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
break;
default:
Expecting( "start, end, radius, stroke, or fill" );
}
}
return circle.release();
}
LIB_PIN* SCH_SEXPR_PARSER::parsePin()
{
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();
switch( token )
{
case T_input:
pin->SetType( ELECTRICAL_PINTYPE::PT_INPUT );
break;
case T_output:
pin->SetType( ELECTRICAL_PINTYPE::PT_OUTPUT );
break;
case T_bidirectional:
pin->SetType( ELECTRICAL_PINTYPE::PT_BIDI );
break;
case T_tri_state:
pin->SetType( ELECTRICAL_PINTYPE::PT_TRISTATE );
break;
case T_passive:
pin->SetType( ELECTRICAL_PINTYPE::PT_PASSIVE );
break;
case T_unspecified:
pin->SetType( ELECTRICAL_PINTYPE::PT_UNSPECIFIED );
break;
case T_power_in:
pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
break;
case T_power_out:
pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_OUT );
break;
case T_open_collector:
pin->SetType( ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR );
break;
case T_open_emitter:
pin->SetType( ELECTRICAL_PINTYPE::PT_OPENEMITTER );
break;
case T_unconnected:
pin->SetType( ELECTRICAL_PINTYPE::PT_NC );
break;
default:
Expecting( "input, output, bidirectional, tri_state, passive, unspecified, "
"power_in, power_out, open_collector, open_emitter, or unconnected" );
}
// Pin shape.
token = NextTok();
switch( token )
{
case T_line:
pin->SetShape( GRAPHIC_PINSHAPE::LINE );
break;
case T_inverted:
pin->SetShape( GRAPHIC_PINSHAPE::INVERTED );
break;
case T_clock:
pin->SetShape( GRAPHIC_PINSHAPE::CLOCK );
break;
case T_inverted_clock:
pin->SetShape( GRAPHIC_PINSHAPE::INVERTED_CLOCK );
break;
case T_input_low:
pin->SetShape( GRAPHIC_PINSHAPE::INPUT_LOW );
break;
case T_clock_low:
pin->SetShape( GRAPHIC_PINSHAPE::CLOCK_LOW );
break;
case T_output_low:
pin->SetShape( GRAPHIC_PINSHAPE::OUTPUT_LOW );
break;
case T_edge_clock_high:
pin->SetShape( GRAPHIC_PINSHAPE::FALLING_EDGE_CLOCK );
break;
case T_non_logic:
pin->SetShape( GRAPHIC_PINSHAPE::NONLOGIC );
break;
default:
Expecting( "line, inverted, clock, inverted_clock, input_low, clock_low, "
"output_low, edge_clock_high, non_logic" );
}
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();
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
if( token != T_RIGHT )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
token = NextTok();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
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" );
}
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
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();
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
if( token != T_RIGHT )
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
{
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
token = NextTok();
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
Fix minor symbol library s-expression formatter and parser bugs.
2020-02-28 16:12:08 +00:00
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(), false );
NeedRIGHT();
}
else
{
Expecting( "effects" );
}
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
}
break;
default:
Expecting( "at, name, number, or length" );
}
}
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;
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
FILL_PARAMS fill;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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:
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
parseFill( fill );
polyLine->SetFillMode( fill.m_FillType );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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;
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
FILL_PARAMS fill;
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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:
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
parseFill( fill );
rectangle->SetFillMode( fill.m_FillType );
Implement symbol library s-expression parser. This implements all existing symbol library object support and the ability to save and load symbol library files between file formats for round robin testing.
2020-02-28 14:03:09 +00:00
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();
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
void SCH_SEXPR_PARSER::parsePAGE_INFO( PAGE_INFO& aPageInfo )
{
Fix sch parser issue with older file versions. Fixes https://gitlab.com/kicad/code/kicad/issues/4417
2020-05-12 19:04:49 +00:00
wxCHECK_RET( ( CurTok() == T_page && m_requiredVersion <= 20200506 ) || CurTok() == T_paper,
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
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();
}
}
Reconcile new Sheet Fields and new S-expr file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4327
2020-05-06 14:47:51 +00:00
SCH_FIELD* SCH_SEXPR_PARSER::parseSchField( SCH_ITEM* aParent )
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
{
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();
Reconcile new Sheet Fields and new S-expr file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4327
2020-05-06 14:47:51 +00:00
std::unique_ptr<SCH_FIELD> field( new SCH_FIELD( wxDefaultPosition, -1, aParent, name ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
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 )
{
Eeschema: minor s-expression file format improvements. I could not find a reasonable solution to the mandatory field canonical name issue so field indices are back in play as much as I did not want to use them. They really only have meaning for the mandatory fields. For all other fields, the index number is meaningless and the field name is the primary means for searching. Fix a broken field size bug in the symbol library formatter.
2020-04-05 21:11:31 +00:00
case T_id:
field->SetId( parseInt( "field ID" ) );
NeedRIGHT();
break;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
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();
}
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
void SCH_SEXPR_PARSER::parseSchSymbolInstances( SCH_SCREEN* aScreen )
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
{
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
wxCHECK_RET( CurTok() == T_symbol_instances,
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
wxT( "Cannot parse " ) + GetTokenString( CurTok() ) +
wxT( " as a instances token." ) );
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
wxCHECK( aScreen, /* void */ );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
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();
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
COMPONENT_INSTANCE_REFERENCE instance;
instance.m_Path = KIID_PATH( FromUTF8() );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
{
if( token != T_LEFT )
Expecting( T_LEFT );
token = NextTok();
switch( token )
{
case T_reference:
NeedSYMBOL();
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
instance.m_Reference = FromUTF8();
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
NeedRIGHT();
break;
case T_unit:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
instance.m_Unit = parseInt( "symbol unit" );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
NeedRIGHT();
break;
default:
Expecting( "path or unit" );
}
}
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
aScreen->m_symbolInstances.emplace_back( instance );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
}
default:
Expecting( "path" );
}
}
}
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
void SCH_SEXPR_PARSER::ParseSchematic( SCH_SHEET* aSheet, bool aIsCopyableOnly, int aFileVersion )
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
{
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
wxCHECK( aSheet != nullptr, /* void */ );
SCH_SCREEN* screen = aSheet->GetScreen();
wxCHECK( screen != nullptr, /* void */ );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( aIsCopyableOnly )
m_requiredVersion = aFileVersion;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
T token;
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( !aIsCopyableOnly )
{
NeedLEFT();
NextTok();
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( CurTok() != T_kicad_sch )
Expecting( "kicad_sch" );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
parseHeader( T_kicad_sch, SEXPR_SCHEMATIC_FILE_VERSION );
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
{
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( aIsCopyableOnly && token == T_EOF )
break;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
if( token != T_LEFT )
Expecting( T_LEFT );
token = NextTok();
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( !aIsCopyableOnly && token == T_page && m_requiredVersion <= 20200506 )
Fix issues with Kicad Manager frame and new kicad_sch files. Fixes https://gitlab.com/kicad/code/kicad/issues/4410
2020-05-12 11:53:45 +00:00
token = T_paper;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
switch( token )
{
Fix issues with Kicad Manager frame and new kicad_sch files. Fixes https://gitlab.com/kicad/code/kicad/issues/4410
2020-05-12 11:53:45 +00:00
case T_paper:
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
{
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( aIsCopyableOnly )
Unexpected( T_paper );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
PAGE_INFO pageInfo;
parsePAGE_INFO( pageInfo );
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->SetPageSettings( pageInfo );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
}
Fix issues with Kicad Manager frame and new kicad_sch files. Fixes https://gitlab.com/kicad/code/kicad/issues/4410
2020-05-12 11:53:45 +00:00
case T_page:
{
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( aIsCopyableOnly )
Unexpected( T_page );
Fix issues with Kicad Manager frame and new kicad_sch files. Fixes https://gitlab.com/kicad/code/kicad/issues/4410
2020-05-12 11:53:45 +00:00
// Only saved for top-level sniffing in Kicad Manager frame and other external
// tool usage with flat hierarchies
NeedSYMBOLorNUMBER();
NeedSYMBOLorNUMBER();
NeedRIGHT();
break;
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
case T_title_block:
{
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( aIsCopyableOnly )
Unexpected( T_title_block );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
TITLE_BLOCK tb;
parseTITLE_BLOCK( tb );
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->SetTitleBlock( tb );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
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:
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
screen->AddLibSymbol( ParseSymbol( symbolLibMap ) );
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
break;
default:
Expecting( "symbol" );
}
}
break;
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
case T_symbol:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->Append( static_cast<SCH_ITEM*>( parseSchematicSymbol() ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
case T_image:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->Append( static_cast<SCH_ITEM*>( parseImage() ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
case T_sheet:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
{
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 ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
case T_junction:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->Append( static_cast<SCH_ITEM*>( parseJunction() ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
case T_no_connect:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->Append( static_cast<SCH_ITEM*>( parseNoConnect() ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
case T_bus_entry:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->Append( static_cast<SCH_ITEM*>( parseBusEntry() ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
case T_polyline:
case T_bus:
case T_wire:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->Append( static_cast<SCH_ITEM*>( parseLine() ) );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
case T_text:
case T_label:
case T_global_label:
case T_hierarchical_label:
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
screen->Append( static_cast<SCH_ITEM*>( parseSchText() ) );
break;
case T_symbol_instances:
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( aIsCopyableOnly )
Unexpected( T_symbol_instances );
Eeschema: make schematic sharing truly safe across all designs. There has been a long standing (since the beginning of the project?) issue with sharing schematics between projects. It has been somewhat supported for complex hierarchies (a sheet shared multiple times in a single design) but it has not been well supported for simple hierarchies (the symbol references cannot be changed in the shared schematic). This issue has been resolved by moving all of the symbol instance sheet paths from the symbol definitions in the all of the project files and save all symbol path instances in the root sheet. This ensures that orphaned symbol instance paths do not accumulate in shared schematic files and that designs that reuse schematic in simple hierarchies can how have different references. It also allows the root schematic from one project to be uses as a sub-sheet in another project. When legacy schematics are loaded, all sheet and symbol UUIDs are converted from time stamps to true UUIDs. This is done to ensure there are no sheet path instance clashes between projects. That being said, there are no checks for this. It is assumed that the probability of UUID clashes is so low that it doesn't make sense to test for them.
2020-04-26 20:53:29 +00:00
parseSchSymbolInstances( screen );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
Eeschema: add missing bus alias support to new schematic file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4335
2020-05-06 13:27:01 +00:00
case T_bus_alias:
Use new file formats for copy and paste in schematic and symbol editors.
2020-05-13 21:58:30 +00:00
if( aIsCopyableOnly )
Unexpected( T_bus_alias );
Eeschema: add missing bus alias support to new schematic file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4335
2020-05-06 13:27:01 +00:00
parseBusAlias( screen );
break;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
default:
Fix issues with Kicad Manager frame and new kicad_sch files. Fixes https://gitlab.com/kicad/code/kicad/issues/4410
2020-05-12 11:53:45 +00:00
Expecting( "symbol, paper, page, title_block, bitmap, sheet, junction, no_connect, "
Eeschema: add missing bus alias support to new schematic file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4335
2020-05-06 13:27:01 +00:00
"bus_entry, line, bus, text, label, global_label, hierarchical_label, "
"symbol_instances, or bus_alias" );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
}
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
Eeschema: fix copy and paste bug. Add required library symbols to new file formatter and parser when copying schematic symbols to prevent missing library symbol when pasting into a different schematic which may not have the same library symbol available. Fix a minor bug where the default schematic symbol reference was not set by the parser when loading. Fixes https://gitlab.com/kicad/code/kicad/issues/4442
2020-05-15 19:53:59 +00:00
screen->UpdateLocalLibSymbolLinks();
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
}
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;
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
wxString error;
wxString libName;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
SCH_FIELD* field;
std::unique_ptr<SCH_COMPONENT> symbol( new SCH_COMPONENT() );
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
TRANSFORM transform;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
m_fieldId = MANDATORY_FIELDS;
for( token = NextTok(); token != T_RIGHT; token = NextTok() )
{
if( token != T_LEFT )
Expecting( T_LEFT );
token = NextTok();
switch( token )
{
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
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;
}
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
case T_lib_id:
{
token = NextTok();
if( !IsSymbol( token ) && token != T_NUMBER )
Expecting( "symbol|number" );
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
LIB_ID libId;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
if( libId.Parse( FromUTF8(), LIB_ID::ID_SCH ) >= 0 )
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
{
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
error.Printf( _( "Invalid symbol library ID in\nfile: \"%s\"\nline: %d\n"
"offset: %d" ),
GetChars( CurSource() ), CurLineNumber(), CurOffset() );
THROW_IO_ERROR( error );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
symbol->SetLibId( libId );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
NeedRIGHT();
break;
}
case T_at:
symbol->SetPosition( parseXY() );
switch( static_cast<int>( parseDouble( "symbol orientation" ) ) )
{
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
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;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
default: Expecting( "0, 90, 180, or 270" );
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
symbol->SetTransform( transform );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
NeedRIGHT();
break;
case T_mirror:
token = NextTok();
if( token == T_x )
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
symbol->SetOrientation( CMP_MIRROR_X );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
else if( token == T_y )
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
symbol->SetOrientation( CMP_MIRROR_Y );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
else
Expecting( "x or y" );
NeedRIGHT();
break;
case T_unit:
symbol->SetUnit( parseInt( "symbol unit" ) );
NeedRIGHT();
break;
Eeschema: add missing alternate body style to new schematic file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4321
2020-05-05 13:14:14 +00:00
case T_convert:
symbol->SetConvert( parseInt( "symbol convert" ) );
NeedRIGHT();
break;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
case T_uuid:
NeedSYMBOL();
const_cast<KIID&>( symbol->m_Uuid ) = KIID( FromUTF8() );
NeedRIGHT();
break;
case T_property:
{
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
// The field parent symbol must be set and it's orientation must be set before
// the field positions are set.
field = parseSchField( symbol.get() );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Eeschema: fix copy and paste bug. Add required library symbols to new file formatter and parser when copying schematic symbols to prevent missing library symbol when pasting into a different schematic which may not have the same library symbol available. Fix a minor bug where the default schematic symbol reference was not set by the parser when loading. Fixes https://gitlab.com/kicad/code/kicad/issues/4442
2020-05-15 19:53:59 +00:00
// 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 );
}
Fix schematic field index bug in s-expression file format plugin.
2020-05-01 15:57:45 +00:00
if( symbol->GetField( field->GetId() ) )
*symbol->GetField( field->GetId() ) = *field;
Reconcile new Sheet Fields and new S-expr file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4327
2020-05-06 14:47:51 +00:00
else
symbol->AddField( *field );
Fix schematic field index bug in s-expression file format plugin.
2020-05-01 15:57:45 +00:00
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
delete field;
break;
}
default:
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
Expecting( "lib_id, lib_name, at, mirror, uuid, property, or instances" );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
}
}
Make the new schematic and symbol library file formats the default. This is a very large and potentially disruptive change so this will be an unusually long and detailed commit message. The new file formats are now the default in both the schematic and symbol library editors. Existing symbol libraries will be saved in their current format until new features are added to library symbols. Once this happens, both the legacy schematic and symbol file formats will be no longer be savable and existing libraries will have to be converted. Saving to the legacy file formats is still available for round robin testing and should not be used for normal editing. When loading the legacy schematic file, it is imperative that the schematic library symbols are rescued and/or remapped to valid library identifiers. Otherwise, there will be no way to link to the original library symbol and the user will be required manually set the library identifier. The cached symbol will be saved in the schematic file so the last library symbol in the cache will still be used but there will be no way to update it from the original library. The next save after loading a legacy schematic file will be converted to the s-expression file format. Schematics with hierarchical sheets will automatically have all sheet file name extensions changed to .kicad_sym and saved to the new format as well. Appending schematics requires that the schematic to append has already been converted to the new file format. This is required to ensure that library symbols are guaranteed to be valid for the appended schematic. The schematic symbol library symbol link resolution has been moved out of the SCH_COMPONENT object and move into the SCH_SCREEN object that owns the symbol. This was done to ensure that there is a single place where the library symbol links get resolved rather than the dozen or so different code paths that previously existed. It also removes the necessity of the SCH_COMPONENT object of requiring any knowledge of the symbol library table and/or the cache library. When opening an s-expression schematic, the legacy cache library is not loaded so any library symbols not rescued cannot be loaded. Broken library symbol links will have to be manually resolved by adding the cache library to the symbol library table and changing the links in the schematic symbol. Now that the library symbols are embedded in the schematic file, the SCH_SCREEN object maintains the list of library symbols for the schematic automatically. No external manipulation of this library cache should ever occur. ADDED: S-expression schematic and symbol library file formats.
2020-04-16 16:43:50 +00:00
if( !libName.IsEmpty() && ( symbol->GetLibId().Format().wx_str() != libName ) )
symbol->SetSchSymbolLibraryName( libName );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Eeschema: ensure component edit flags are cleared after loading a schematic file. Fixes #4515 https://gitlab.com/kicad/code/kicad/issues/4515
2020-05-22 18:25:43 +00:00
// Ensure edit/status flags are cleared after these initializations:
symbol->ClearFlags();
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
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();
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
wxString data;
Fix infinite loop bug in new schematic file format image parser. Fixes https://gitlab.com/kicad/code/kicad/issues/4362
2020-05-09 18:20:04 +00:00
// Reserve 128K because most image files are going to be larger than the default
// 1K that wxString reserves.
Eeschema: fix new schematic file format image parser buffer size. Fixes https://gitlab.com/kicad/code/kicad/issues/4387
2020-05-10 12:47:42 +00:00
data.reserve( 1 << 17 );
Fix infinite loop bug in new schematic file format image parser. Fixes https://gitlab.com/kicad/code/kicad/issues/4362
2020-05-09 18:20:04 +00:00
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
while( token != T_RIGHT )
{
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
if( !IsSymbol( token ) )
Expecting( "base64 image data" );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
data += FromUTF8();
Fix infinite loop bug in new schematic file format image parser. Fixes https://gitlab.com/kicad/code/kicad/issues/4362
2020-05-09 18:20:04 +00:00
token = NextTok();
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
}
Eeschema: minor s-expression schematic file format improvement. Save image data using a base64 encoded string to reduce the file size.
2020-03-27 12:52:40 +00:00
wxMemoryBuffer buffer = wxBase64Decode( data );
wxMemoryOutputStream stream( buffer.GetData(), buffer.GetBufSize() );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
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;
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
FILL_PARAMS fill;
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
SCH_FIELD* field;
std::vector<SCH_FIELD> fields;
std::unique_ptr<SCH_SHEET> sheet( new SCH_SHEET() );
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.m_Width );
sheet->SetBorderColor( stroke.m_Color );
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
break;
case T_fill:
parseFill( fill );
sheet->SetBackgroundColor( fill.m_Color );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
break;
case T_uuid:
NeedSYMBOL();
const_cast<KIID&>( sheet->m_Uuid ) = KIID( FromUTF8() );
NeedRIGHT();
break;
case T_property:
Reconcile new Sheet Fields and new S-expr file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4327
2020-05-06 14:47:51 +00:00
field = parseSchField( sheet.get() );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
Reconcile new Sheet Fields and new S-expr file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4327
2020-05-06 14:47:51 +00:00
if( m_requiredVersion <= 20200310 )
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
{
Reconcile new Sheet Fields and new S-expr file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4327
2020-05-06 14:47:51 +00:00
// 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 );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
}
fields.emplace_back( *field );
delete field;
break;
case T_pin:
sheet->AddPin( parseSchSheetPin( sheet.get() ) );
break;
default:
Generalize fill parsing and add support for sheet background R/W. Also fixes a bug in colour parsing (the alpha channel is a float).
2020-04-07 14:00:58 +00:00
Expecting( "at, size, stroke, background, uuid, property, or pin" );
Eeschema: implement s-expression schematic file format parser. Fix a few issues with the s-expression schematic file formatter.
2020-03-25 15:27:15 +00:00
}
}
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;
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;
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 );
if( size.y < 0 )
busEntry->SetBusEntryShape( '/' );
NeedRIGHT();
break;
}
default:
Expecting( "at or size" );
}
}
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->SetLineWidth( stroke.m_Width );
line->SetLineStyle( stroke.m_Type );
line->SetLineColor( stroke.m_Color );
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();
}
Eeschema: add missing bus alias support to new schematic file format. Fixes https://gitlab.com/kicad/code/kicad/issues/4335
2020-05-06 13:27:01 +00:00
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 );
}