sch_legacy_plugin.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2016 CERN
 * Copyright (C) 2016-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Wayne Stambaugh <[email protected]>
 *
 * 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 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include <algorithm>
#include <boost/algorithm/string/join.hpp>
#include <cctype>
#include <mutex>
#include <set>

#include <wx/mstream.h>
#include <wx/filename.h>
#include <wx/log.h>
#include <wx/textfile.h>
#include <wx/tokenzr.h>
#include <wx_filename.h> // For ::ResolvePossibleSymlinks()

#include <kiway.h>
#include <string_utils.h>
#include <locale_io.h>
#include <richio.h>
#include <trace_helpers.h>
#include <trigo.h>
#include <progress_reporter.h>
#include <general.h>
#include <sch_bitmap.h>
#include <sch_bus_entry.h>
#include <sch_symbol.h>
#include <sch_junction.h>
#include <sch_line.h>
#include <sch_marker.h>
#include <sch_no_connect.h>
#include <sch_text.h>
#include <sch_sheet.h>
#include <sch_sheet_pin.h>
#include <bus_alias.h>
#include <sch_plugins/legacy/sch_legacy_plugin.h>
#include <sch_screen.h>
#include <schematic.h>
#include <symbol_library.h>
#include <lib_shape.h>
#include <lib_field.h>
#include <lib_pin.h>
#include <lib_text.h>
#include <eeschema_id.h> // for MAX_UNIT_COUNT_PER_PACKAGE definition
#include <tool/selection.h>


#define Mils2Iu( x ) Mils2iu( x )


// Must be the first line of symbol library document (.dcm) files.
#define DOCFILE_IDENT "EESchema-DOCLIB Version 2.0"

#define SCH_PARSE_ERROR( text, reader, pos ) \
 THROW_PARSE_ERROR( text, reader.GetSource(), reader.Line(), \
 reader.LineNumber(), pos - reader.Line() )


// Token delimiters.
const char* delims = " \t\r\n";

// Tokens to read/save graphic lines style
#define T_STYLE "style"
#define T_COLOR "rgb" // cannot be modified (used by wxWidgets)
#define T_COLORA "rgba" // cannot be modified (used by wxWidgets)
#define T_WIDTH "width"


static bool is_eol( char c )
{
 // The default file eol character used internally by KiCad.
 // |
 // | Possible eol if someone edited the file by hand on certain platforms.
 // | |
 // | | May have gone past eol with strtok().
 // | | |
 if( c == '\n' || c == '\r' || c == 0 )
 return true;

 return false;
}


static bool strCompare( const char* aString, const char* aLine, const char** aOutput = nullptr )
{
 size_t len = strlen( aString );
 bool retv = ( strncasecmp( aLine, aString, len ) == 0 ) &&
 ( isspace( aLine[ len ] ) || aLine[ len ] == 0 );

 if( retv && aOutput )
 {
 const char* tmp = aLine;

 // Move past the end of the token.
 tmp += len;

 // Move to the beginning of the next token.
 while( *tmp && isspace( *tmp ) )
 tmp++;

 *aOutput = tmp;
 }

 return retv;
}


static int parseInt( LINE_READER& aReader, const char* aLine, const char** aOutput = nullptr )
{
 if( !*aLine )
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aLine );

 // Clear errno before calling strtol() in case some other crt call set it.
 errno = 0;

 long retv = strtol( aLine, (char**) aOutput, 10 );

 // Make sure no error occurred when calling strtol().
 if( errno == ERANGE )
 SCH_PARSE_ERROR( "invalid integer value", aReader, aLine );

 // strtol does not strip off whitespace before the next token.
 if( aOutput )
 {
 const char* next = *aOutput;

 while( *next && isspace( *next ) )
 next++;

 *aOutput = next;
 }

 return (int) retv;
}


static uint32_t parseHex( LINE_READER& aReader, const char* aLine, const char** aOutput = nullptr )
{
 if( !*aLine )
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aLine );

 // Due to some issues between some files created by a 64 bits version and those
 // created by a 32 bits version, we use here a temporary at least 64 bits storage:
 unsigned long long retv;

 // Clear errno before calling strtoull() in case some other crt call set it.
 errno = 0;
 retv = strtoull( aLine, (char**) aOutput, 16 );

 // Make sure no error occurred when calling strtoull().
 if( errno == ERANGE )
 SCH_PARSE_ERROR( "invalid hexadecimal number", aReader, aLine );

 // Strip off whitespace before the next token.
 if( aOutput )
 {
 const char* next = *aOutput;

 while( *next && isspace( *next ) )
 next++;

 *aOutput = next;
 }

 return (uint32_t)retv;
}


static double parseDouble( LINE_READER& aReader, const char* aLine,
 const char** aOutput = nullptr )
{
 if( !*aLine )
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aLine );

 // Clear errno before calling strtod() in case some other crt call set it.
 errno = 0;

 double retv = strtod( aLine, (char**) aOutput );

 // Make sure no error occurred when calling strtod().
 if( errno == ERANGE )
 SCH_PARSE_ERROR( "invalid floating point number", aReader, aLine );

 // strtod does not strip off whitespace before the next token.
 if( aOutput )
 {
 const char* next = *aOutput;

 while( *next && isspace( *next ) )
 next++;

 *aOutput = next;
 }

 return retv;
}


static char parseChar( LINE_READER& aReader, const char* aCurrentToken,
 const char** aNextToken = nullptr )
{
 while( *aCurrentToken && isspace( *aCurrentToken ) )
 aCurrentToken++;

 if( !*aCurrentToken )
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );

 if( !isspace( *( aCurrentToken + 1 ) ) )
 SCH_PARSE_ERROR( "expected single character token", aReader, aCurrentToken );

 if( aNextToken )
 {
 const char* next = aCurrentToken + 2;

 while( *next && isspace( *next ) )
 next++;

 *aNextToken = next;
 }

 return *aCurrentToken;
}


static void parseUnquotedString( wxString& aString, LINE_READER& aReader,
 const char* aCurrentToken, const char** aNextToken = nullptr,
 bool aCanBeEmpty = false )
{
 if( !*aCurrentToken )
 {
 if( aCanBeEmpty )
 return;
 else
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
 }

 const char* tmp = aCurrentToken;

 while( *tmp && isspace( *tmp ) )
 tmp++;

 if( !*tmp )
 {
 if( aCanBeEmpty )
 return;
 else
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
 }

 std::string utf8;

 while( *tmp && !isspace( *tmp ) )
 utf8 += *tmp++;

 aString = FROM_UTF8( utf8.c_str() );

 if( aString.IsEmpty() && !aCanBeEmpty )
 SCH_PARSE_ERROR( _( "expected unquoted string" ), aReader, aCurrentToken );

 if( aNextToken )
 {
 const char* next = tmp;

 while( *next && isspace( *next ) )
 next++;

 *aNextToken = next;
 }
}


static void parseQuotedString( wxString& aString, LINE_READER& aReader,
 const char* aCurrentToken, const char** aNextToken = nullptr,
 bool aCanBeEmpty = false )
{
 if( !*aCurrentToken )
 {
 if( aCanBeEmpty )
 return;
 else
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
 }

 const char* tmp = aCurrentToken;

 while( *tmp && isspace( *tmp ) )
 tmp++;

 if( !*tmp )
 {
 if( aCanBeEmpty )
 return;
 else
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
 }

 // Verify opening quote.
 if( *tmp != '"' )
 SCH_PARSE_ERROR( "expecting opening quote", aReader, aCurrentToken );

 tmp++;

 std::string utf8; // utf8 without escapes and quotes.

 // Fetch everything up to closing quote.
 while( *tmp )
 {
 if( *tmp == '\\' )
 {
 tmp++;

 if( !*tmp )
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );

 // Do not copy the escape byte if it is followed by \ or "
 if( *tmp != '"' && *tmp != '\\' )
 utf8 += '\\';

 utf8 += *tmp;
 }
 else if( *tmp == '"' ) // Closing double quote.
 {
 break;
 }
 else
 {
 utf8 += *tmp;
 }

 tmp++;
 }

 aString = FROM_UTF8( utf8.c_str() );

 if( aString.IsEmpty() && !aCanBeEmpty )
 SCH_PARSE_ERROR( "expected quoted string", aReader, aCurrentToken );

 if( *tmp && *tmp != '"' )
 SCH_PARSE_ERROR( "no closing quote for string found", aReader, tmp );

 // Move past the closing quote.
 tmp++;

 if( aNextToken )
 {
 const char* next = tmp;

 while( *next == ' ' )
 next++;

 *aNextToken = next;
 }
}


class SCH_LEGACY_PLUGIN_CACHE
{
 static int s_modHash; // Keep track of the modification status of the library.
 wxString m_fileName; // Absolute path and file name.
 wxFileName m_libFileName; // Absolute path and file name is required here.
 wxDateTime m_fileModTime;
 LIB_SYMBOL_MAP m_symbols; // Map of names of #LIB_SYMBOL pointers.
 bool m_isWritable;
 bool m_isModified;
 int m_versionMajor;
 int m_versionMinor;
 SCH_LIB_TYPE m_libType; // Is this cache a symbol or symbol library.

 void loadHeader( FILE_LINE_READER& aReader );
 static void loadAliases( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader,
 LIB_SYMBOL_MAP* aMap = nullptr );
 static void loadField( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader );
 static void loadDrawEntries( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader,
 int aMajorVersion, int aMinorVersion );
 static void loadFootprintFilters( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader );
 void loadDocs();
 static LIB_SHAPE* loadArc( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader );
 static LIB_SHAPE* loadCircle( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader );
 static LIB_TEXT* loadText( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader,
 int aMajorVersion, int aMinorVersion );
 static LIB_SHAPE* loadRect( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader );
 static LIB_PIN* loadPin( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader );
 static LIB_SHAPE* loadPolyLine( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader );
 static LIB_SHAPE* loadBezier( std::unique_ptr<LIB_SYMBOL>& aSymbol, LINE_READER& aReader );

 static FILL_T parseFillMode( LINE_READER& aReader, const char* aLine, const char** aOutput );
 LIB_SYMBOL* removeSymbol( LIB_SYMBOL* aAlias );

 void saveDocFile();
 static void saveArc( LIB_SHAPE* aArc, OUTPUTFORMATTER& aFormatter );
 static void saveBezier( LIB_SHAPE* aBezier, OUTPUTFORMATTER& aFormatter );
 static void saveCircle( LIB_SHAPE* aCircle, OUTPUTFORMATTER& aFormatter );
 static void saveField( const LIB_FIELD* aField, OUTPUTFORMATTER& aFormatter );
 static void savePin( const LIB_PIN* aPin, OUTPUTFORMATTER& aFormatter );
 static void savePolyLine( LIB_SHAPE* aPolyLine, OUTPUTFORMATTER& aFormatter );
 static void saveRectangle( LIB_SHAPE* aRectangle, OUTPUTFORMATTER& aFormatter );
 static void saveText( const LIB_TEXT* aText, OUTPUTFORMATTER& aFormatter );

 friend SCH_LEGACY_PLUGIN;

 static std::mutex s_modHashMutex;

public:
 SCH_LEGACY_PLUGIN_CACHE( const wxString& aLibraryPath );
 ~SCH_LEGACY_PLUGIN_CACHE();

 static void IncrementModifyHash()
 {
 std::lock_guard<std::mutex> mut( SCH_LEGACY_PLUGIN_CACHE::s_modHashMutex );
 SCH_LEGACY_PLUGIN_CACHE::s_modHash++;
 }

 static int GetModifyHash()
 {
 std::lock_guard<std::mutex> mut( SCH_LEGACY_PLUGIN_CACHE::s_modHashMutex );
 return SCH_LEGACY_PLUGIN_CACHE::s_modHash;
 }

 // Most all functions in this class throw IO_ERROR exceptions. There are no
 // error codes nor user interface calls from here, nor in any SCH_PLUGIN objects.
 // Catch these exceptions higher up please.

 void Save( bool aSaveDocFile = true );

 void Load();

 void AddSymbol( const LIB_SYMBOL* aSymbol );

 void DeleteSymbol( const wxString& aName );

 // If m_libFileName is a symlink follow it to the real source file
 wxFileName GetRealFile() const;

 wxDateTime GetLibModificationTime();

 bool IsFile( const wxString& aFullPathAndFileName ) const;

 bool IsFileChanged() const;

 void SetModified( bool aModified = true ) { m_isModified = aModified; }

 wxString GetLogicalName() const { return m_libFileName.GetName(); }

 void SetFileName( const wxString& aFileName ) { m_libFileName = aFileName; }

 wxString GetFileName() const { return m_libFileName.GetFullPath(); }

 static LIB_SYMBOL* LoadPart( LINE_READER& aReader, int aMajorVersion, int aMinorVersion,
 LIB_SYMBOL_MAP* aMap = nullptr );
 static void SaveSymbol( LIB_SYMBOL* aSymbol, OUTPUTFORMATTER& aFormatter,
 LIB_SYMBOL_MAP* aMap = nullptr );
};


SCH_LEGACY_PLUGIN::SCH_LEGACY_PLUGIN() :
 m_progressReporter( nullptr ),
 m_lineReader( nullptr ),
 m_lastProgressLine( 0 ),
 m_lineCount( 0 )
{
 init( nullptr );
}


SCH_LEGACY_PLUGIN::~SCH_LEGACY_PLUGIN()
{
 delete m_cache;
}


void SCH_LEGACY_PLUGIN::init( SCHEMATIC* aSchematic, const PROPERTIES* aProperties )
{
 m_version = 0;
 m_rootSheet = nullptr;
 m_schematic = aSchematic;
 m_cache = nullptr;
 m_out = nullptr;
}


void SCH_LEGACY_PLUGIN::checkpoint()
{
 const unsigned PROGRESS_DELTA = 250;

 if( m_progressReporter )
 {
 unsigned curLine = m_lineReader->LineNumber();

 if( curLine > m_lastProgressLine + PROGRESS_DELTA )
 {
 m_progressReporter->SetCurrentProgress( ( (double) curLine )
 / std::max( 1U, m_lineCount ) );

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

 m_lastProgressLine = curLine;
 }
 }
}


SCH_SHEET* SCH_LEGACY_PLUGIN::Load( const wxString& aFileName, SCHEMATIC* aSchematic,
 SCH_SHEET* aAppendToMe, const PROPERTIES* aProperties )
{
 wxASSERT( !aFileName || aSchematic != nullptr );

 LOCALE_IO toggle; // toggles on, then off, the C locale.
 SCH_SHEET* sheet;

 wxFileName fn = aFileName;

 // Unfortunately child sheet file names the legacy schematic file format are not fully
 // qualified and are always appended to the project path. The aFileName attribute must
 // always be an absolute path so the project path can be used for load child sheet files.
 wxASSERT( fn.IsAbsolute() );

 if( aAppendToMe )
 {
 wxLogTrace( traceSchLegacyPlugin, "Append \"%s\" to sheet \"%s\".",
 aFileName, aAppendToMe->GetFileName() );

 wxFileName normedFn = aAppendToMe->GetFileName();

 if( !normedFn.IsAbsolute() )
 {
 if( aFileName.Right( normedFn.GetFullPath().Length() ) == normedFn.GetFullPath() )
 m_path = aFileName.Left( aFileName.Length() - normedFn.GetFullPath().Length() );
 }

 if( m_path.IsEmpty() )
 m_path = aSchematic->Prj().GetProjectPath();

 wxLogTrace( traceSchLegacyPlugin, "m_Normalized append path \"%s\".", m_path );
 }
 else
 {
 m_path = aSchematic->Prj().GetProjectPath();
 }

 m_currentPath.push( m_path );
 init( aSchematic, aProperties );

 if( aAppendToMe == nullptr )
 {
 // Clean up any allocated memory if an exception occurs loading the schematic.
 std::unique_ptr<SCH_SHEET> newSheet = std::make_unique<SCH_SHEET>( aSchematic );
 newSheet->SetFileName( aFileName );
 m_rootSheet = newSheet.get();
 loadHierarchy( newSheet.get() );

 // If we got here, the schematic loaded successfully.
 sheet = newSheet.release();
 m_rootSheet = nullptr; // Quiet Coverity warning.
 }
 else
 {
 wxCHECK_MSG( aSchematic->IsValid(), nullptr, "Can't append to a schematic with no root!" );
 m_rootSheet = &aSchematic->Root();
 sheet = aAppendToMe;
 loadHierarchy( sheet );
 }

 wxASSERT( m_currentPath.size() == 1 ); // only the project path should remain

 return sheet;
}


// Everything below this comment is recursive. Modify with care.

void SCH_LEGACY_PLUGIN::loadHierarchy( SCH_SHEET* aSheet )
{
 SCH_SCREEN* screen = nullptr;

 if( !aSheet->GetScreen() )
 {
 // SCH_SCREEN objects store the full path and file name where the SCH_SHEET object only
 // stores the file name and extension. Add the project path to the file name and
 // extension to compare when calling SCH_SHEET::SearchHierarchy().
 wxFileName fileName = aSheet->GetFileName();
 fileName.SetExt( "sch" );

 if( !fileName.IsAbsolute() )
 fileName.MakeAbsolute( m_currentPath.top() );

 // Save the current path so that it gets restored when descending and ascending the
 // sheet hierarchy which allows for sheet schematic files to be nested in folders
 // relative to the last path a schematic was loaded from.
 wxLogTrace( traceSchLegacyPlugin, "Saving path '%s'", m_currentPath.top() );
 m_currentPath.push( fileName.GetPath() );
 wxLogTrace( traceSchLegacyPlugin, "Current path '%s'", m_currentPath.top() );
 wxLogTrace( traceSchLegacyPlugin, "Loading '%s'", fileName.GetFullPath() );

 m_rootSheet->SearchHierarchy( fileName.GetFullPath(), &screen );

 if( screen )
 {
 aSheet->SetScreen( screen );
 screen->SetParent( m_schematic );
 // Do not need to load the sub-sheets - this has already been done.
 }
 else
 {
 aSheet->SetScreen( new SCH_SCREEN( m_schematic ) );
 aSheet->GetScreen()->SetFileName( fileName.GetFullPath() );

 try
 {
 loadFile( fileName.GetFullPath(), aSheet->GetScreen() );
 }
 catch( const IO_ERROR& ioe )
 {
 // If there is a problem loading the root sheet, there is no recovery.
 if( aSheet == m_rootSheet )
 throw( ioe );

 // For all subsheets, queue up the error message for the caller.
 if( !m_error.IsEmpty() )
 m_error += "\n";

 m_error += ioe.What();
 }

 aSheet->GetScreen()->SetFileReadOnly( !fileName.IsFileWritable() );
 aSheet->GetScreen()->SetFileExists( true );

 for( auto aItem : aSheet->GetScreen()->Items().OfType( SCH_SHEET_T ) )
 {
 wxCHECK2( aItem->Type() == SCH_SHEET_T, continue );
 auto sheet = static_cast<SCH_SHEET*>( aItem );

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

 // Recursion starts here.
 loadHierarchy( sheet );
 }
 }

 m_currentPath.pop();
 wxLogTrace( traceSchLegacyPlugin, "Restoring path \"%s\"", m_currentPath.top() );
 }
}


void SCH_LEGACY_PLUGIN::loadFile( const wxString& aFileName, SCH_SCREEN* aScreen )
{
 FILE_LINE_READER reader( aFileName );

 if( m_progressReporter )
 {
 m_progressReporter->Report( wxString::Format( _( "Loading %s..." ), aFileName ) );

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

 m_lineReader = &reader;
 m_lineCount = 0;

 while( reader.ReadLine() )
 m_lineCount++;

 reader.Rewind();
 }

 loadHeader( reader, aScreen );

 LoadContent( reader, aScreen, m_version );

 // Unfortunately schematic files prior to version 2 are not terminated with $EndSCHEMATC
 // so checking for its existance will fail so just exit here and take our chances. :(
 if( m_version > 1 )
 {
 char* line = reader.Line();

 while( *line == ' ' )
 line++;

 if( !strCompare( "$EndSCHEMATC", line ) )
 THROW_IO_ERROR( "'$EndSCHEMATC' not found" );
 }
}


void SCH_LEGACY_PLUGIN::LoadContent( LINE_READER& aReader, SCH_SCREEN* aScreen, int version )
{
 m_version = version;

 // We cannot safely load content without a set root level.
 wxCHECK_RET( m_rootSheet,
 "Cannot call SCH_LEGACY_PLUGIN::LoadContent() without setting root sheet." );

 while( aReader.ReadLine() )
 {
 checkpoint();

 char* line = aReader.Line();

 while( *line == ' ' )
 line++;

 // Either an object will be loaded properly or the file load will fail and raise
 // an exception.
 if( strCompare( "$Descr", line ) )
 loadPageSettings( aReader, aScreen );
 else if( strCompare( "$Comp", line ) )
 aScreen->Append( loadSymbol( aReader ) );
 else if( strCompare( "$Sheet", line ) )
 aScreen->Append( loadSheet( aReader ) );
 else if( strCompare( "$Bitmap", line ) )
 aScreen->Append( loadBitmap( aReader ) );
 else if( strCompare( "Connection", line ) )
 aScreen->Append( loadJunction( aReader ) );
 else if( strCompare( "NoConn", line ) )
 aScreen->Append( loadNoConnect( aReader ) );
 else if( strCompare( "Wire", line ) )
 aScreen->Append( loadWire( aReader ) );
 else if( strCompare( "Entry", line ) )
 aScreen->Append( loadBusEntry( aReader ) );
 else if( strCompare( "Text", line ) )
 aScreen->Append( loadText( aReader ) );
 else if( strCompare( "BusAlias", line ) )
 aScreen->AddBusAlias( loadBusAlias( aReader, aScreen ) );
 else if( strCompare( "$EndSCHEMATC", line ) )
 return;
 else
 SCH_PARSE_ERROR( "unrecognized token", aReader, line );
 }
}


void SCH_LEGACY_PLUGIN::loadHeader( LINE_READER& aReader, SCH_SCREEN* aScreen )
{
 const char* line = aReader.ReadLine();

 if( !line || !strCompare( "Eeschema Schematic File Version", line, &line ) )
 {
 m_error.Printf( _( "'%s' does not appear to be an Eeschema file." ),
 aScreen->GetFileName() );
 THROW_IO_ERROR( m_error );
 }

 // get the file version here.
 m_version = parseInt( aReader, line, &line );

 // The next lines are the lib list section, and are mainly comments, like:
 // LIBS:power
 // the lib list is not used, but is in schematic file just in case.
 // It is usually not empty, but we accept empty list.
 // If empty, there is a legacy section, not used
 // EELAYER i j
 // and the last line is
 // EELAYER END
 // Skip all lines until the end of header "EELAYER END" is found
 while( aReader.ReadLine() )
 {
 checkpoint();

 line = aReader.Line();

 while( *line == ' ' )
 line++;

 if( strCompare( "EELAYER END", line ) )
 return;
 }

 THROW_IO_ERROR( _( "Missing 'EELAYER END'" ) );
}


void SCH_LEGACY_PLUGIN::loadPageSettings( LINE_READER& aReader, SCH_SCREEN* aScreen )
{
 wxASSERT( aScreen != nullptr );

 wxString buf;
 const char* line = aReader.Line();

 PAGE_INFO pageInfo;
 TITLE_BLOCK tb;

 wxCHECK_RET( strCompare( "$Descr", line, &line ), "Invalid sheet description" );

 parseUnquotedString( buf, aReader, line, &line );

 if( !pageInfo.SetType( buf ) )
 SCH_PARSE_ERROR( "invalid page size", aReader, line );

 int pagew = parseInt( aReader, line, &line );
 int pageh = parseInt( aReader, line, &line );

 if( buf == PAGE_INFO::Custom )
 {
 pageInfo.SetWidthMils( pagew );
 pageInfo.SetHeightMils( pageh );
 }
 else
 {
 wxString orientation;

 // Non custom size, set portrait if its present. Can be empty string which defaults
 // to landscape.
 parseUnquotedString( orientation, aReader, line, &line, true );

 if( orientation == "portrait" )
 pageInfo.SetPortrait( true );
 }

 aScreen->SetPageSettings( pageInfo );

 while( line != nullptr )
 {
 buf.clear();

 if( !aReader.ReadLine() )
 SCH_PARSE_ERROR( _( "unexpected end of file" ), aReader, line );

 line = aReader.Line();

 if( strCompare( "Sheet", line, &line ) )
 {
 aScreen->SetVirtualPageNumber( parseInt( aReader, line, &line ) );
 aScreen->SetPageCount( parseInt( aReader, line, &line ) );
 }
 else if( strCompare( "Title", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetTitle( buf );
 }
 else if( strCompare( "Date", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetDate( buf );
 }
 else if( strCompare( "Rev", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetRevision( buf );
 }
 else if( strCompare( "Comp", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetCompany( buf );
 }
 else if( strCompare( "Comment1", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 0, buf );
 }
 else if( strCompare( "Comment2", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 1, buf );
 }
 else if( strCompare( "Comment3", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 2, buf );
 }
 else if( strCompare( "Comment4", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 3, buf );
 }
 else if( strCompare( "Comment5", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 4, buf );
 }
 else if( strCompare( "Comment6", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 5, buf );
 }
 else if( strCompare( "Comment7", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 6, buf );
 }
 else if( strCompare( "Comment8", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 7, buf );
 }
 else if( strCompare( "Comment9", line, &line ) )
 {
 parseQuotedString( buf, aReader, line, &line, true );
 tb.SetComment( 8, buf );
 }
 else if( strCompare( "$EndDescr", line ) )
 {
 aScreen->SetTitleBlock( tb );
 return;
 }
 }

 SCH_PARSE_ERROR( "missing 'EndDescr'", aReader, line );
}


SCH_SHEET* SCH_LEGACY_PLUGIN::loadSheet( LINE_READER& aReader )
{
 std::unique_ptr<SCH_SHEET> sheet = std::make_unique<SCH_SHEET>();

 const char* line = aReader.ReadLine();

 while( line != nullptr )
 {
 if( strCompare( "S", line, &line ) ) // Sheet dimensions.
 {
 wxPoint position;

 position.x = Mils2Iu( parseInt( aReader, line, &line ) );
 position.y = Mils2Iu( parseInt( aReader, line, &line ) );
 sheet->SetPosition( position );

 wxSize size;

 size.SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );
 size.SetHeight( Mils2Iu( parseInt( aReader, line, &line ) ) );
 sheet->SetSize( size );
 }
 else if( strCompare( "U", line, &line ) ) // Sheet UUID.
 {
 wxString text;
 parseUnquotedString( text, aReader, line );

 if( text != "00000000" )
 const_cast<KIID&>( sheet->m_Uuid ) = KIID( text );
 }
 else if( *line == 'F' ) // Sheet field.
 {
 line++;

 wxString text;
 int size;
 int fieldId = parseInt( aReader, line, &line );

 if( fieldId == 0 || fieldId == 1 ) // Sheet name and file name.
 {
 parseQuotedString( text, aReader, line, &line );
 size = Mils2Iu( parseInt( aReader, line, &line ) );

 SCH_FIELD& field = sheet->GetFields()[ fieldId ];
 field.SetText( text );
 field.SetTextSize( wxSize( size, size ) );
 }
 else // Sheet pin.
 {
 // Use a unique_ptr so that we clean up in the case of a throw
 std::unique_ptr<SCH_SHEET_PIN> sheetPin = std::make_unique<SCH_SHEET_PIN>( sheet.get() );

 sheetPin->SetNumber( fieldId );

 // Can be empty fields.
 parseQuotedString( text, aReader, line, &line, true );

 sheetPin->SetText( ConvertToNewOverbarNotation( text ) );

 if( line == nullptr )
 THROW_IO_ERROR( _( "unexpected end of line" ) );

 switch( parseChar( aReader, line, &line ) )
 {
 case 'I': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_INPUT ); break;
 case 'O': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_OUTPUT ); break;
 case 'B': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_BIDI ); break;
 case 'T': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_TRISTATE ); break;
 case 'U': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_UNSPECIFIED ); break;
 default: SCH_PARSE_ERROR( "invalid sheet pin type", aReader, line );
 }

 switch( parseChar( aReader, line, &line ) )
 {
 case 'R': sheetPin->SetSide( SHEET_SIDE::RIGHT ); break;
 case 'T': sheetPin->SetSide( SHEET_SIDE::TOP ); break;
 case 'B': sheetPin->SetSide( SHEET_SIDE::BOTTOM ); break;
 case 'L': sheetPin->SetSide( SHEET_SIDE::LEFT ); break;
 default:
 SCH_PARSE_ERROR( "invalid sheet pin side", aReader, line );
 }

 wxPoint position;

 position.x = Mils2Iu( parseInt( aReader, line, &line ) );
 position.y = Mils2Iu( parseInt( aReader, line, &line ) );
 sheetPin->SetPosition( position );

 size = Mils2Iu( parseInt( aReader, line, &line ) );

 sheetPin->SetTextSize( wxSize( size, size ) );

 sheet->AddPin( sheetPin.release() );
 }
 }
 else if( strCompare( "$EndSheet", line ) )
 {
 sheet->AutoplaceFields( /* aScreen */ nullptr, /* aManual */ false );
 return sheet.release();
 }

 line = aReader.ReadLine();
 }

 SCH_PARSE_ERROR( "missing '$EndSheet`", aReader, line );

 return nullptr; // Prevents compiler warning. Should never get here.
}


SCH_BITMAP* SCH_LEGACY_PLUGIN::loadBitmap( LINE_READER& aReader )
{
 std::unique_ptr<SCH_BITMAP> bitmap = std::make_unique<SCH_BITMAP>();

 const char* line = aReader.Line();

 wxCHECK( strCompare( "$Bitmap", line, &line ), nullptr );

 line = aReader.ReadLine();

 while( line != nullptr )
 {
 if( strCompare( "Pos", line, &line ) )
 {
 wxPoint position;

 position.x = Mils2Iu( parseInt( aReader, line, &line ) );
 position.y = Mils2Iu( parseInt( aReader, line, &line ) );
 bitmap->SetPosition( position );
 }
 else if( strCompare( "Scale", line, &line ) )
 {
 auto scalefactor = parseDouble( aReader, line, &line );

 // Prevent scalefactor values that cannot be displayed.
 // In the case of a bad value, we accept that the image might be mis-scaled
 // rather than removing the full image. Users can then edit the scale factor in
 // Eeschema to the appropriate value
 if( !std::isnormal( scalefactor ) )
 scalefactor = 1.0;

 bitmap->GetImage()->SetScale( scalefactor );
 }
 else if( strCompare( "Data", line, &line ) )
 {
 wxMemoryOutputStream stream;

 while( line )
 {
 if( !aReader.ReadLine() )
 SCH_PARSE_ERROR( _( "Unexpected end of file" ), aReader, line );

 line = aReader.Line();

 if( strCompare( "EndData", line ) )
 {
 // all the PNG date is read.
 // We expect here m_image and m_bitmap are void
 wxImage* image = new wxImage();
 wxMemoryInputStream istream( stream );
 image->LoadFile( istream, wxBITMAP_TYPE_PNG );
 bitmap->GetImage()->SetImage( image );
 bitmap->GetImage()->SetBitmap( new wxBitmap( *image ) );
 break;
 }

 // Read PNG data, stored in hexadecimal,
 // each byte = 2 hexadecimal digits and a space between 2 bytes
 // and put it in memory stream buffer
 // Note:
 // Some old files created bu the V4 schematic versions have a extra
 // "$EndBitmap" at the end of the hexadecimal data. (Probably due to
 // a bug). So discard it
 int len = strlen( line );

 for( ; len > 0 && !isspace( *line ) && '$' != *line; len -= 3, line += 3 )
 {
 int value = 0;

 if( sscanf( line, "%X", &value ) == 1 )
 stream.PutC( (char) value );
 else
 THROW_IO_ERROR( "invalid PNG data" );
 }
 }

 if( line == nullptr )
 THROW_IO_ERROR( _( "unexpected end of file" ) );
 }
 else if( strCompare( "$EndBitmap", line ) )
 return bitmap.release();

 line = aReader.ReadLine();
 }

 THROW_IO_ERROR( _( "unexpected end of file" ) );
}


SCH_JUNCTION* SCH_LEGACY_PLUGIN::loadJunction( LINE_READER& aReader )
{
 std::unique_ptr<SCH_JUNCTION> junction = std::make_unique<SCH_JUNCTION>();

 const char* line = aReader.Line();

 wxCHECK( strCompare( "Connection", line, &line ), nullptr );

 wxString name;

 parseUnquotedString( name, aReader, line, &line );

 wxPoint position;

 position.x = Mils2Iu( parseInt( aReader, line, &line ) );
 position.y = Mils2Iu( parseInt( aReader, line, &line ) );
 junction->SetPosition( position );

 return junction.release();
}


SCH_NO_CONNECT* SCH_LEGACY_PLUGIN::loadNoConnect( LINE_READER& aReader )
{
 std::unique_ptr<SCH_NO_CONNECT> no_connect = std::make_unique<SCH_NO_CONNECT>();

 const char* line = aReader.Line();

 wxCHECK( strCompare( "NoConn", line, &line ), nullptr );

 wxString name;

 parseUnquotedString( name, aReader, line, &line );

 wxPoint position;

 position.x = Mils2Iu( parseInt( aReader, line, &line ) );
 position.y = Mils2Iu( parseInt( aReader, line, &line ) );
 no_connect->SetPosition( position );

 return no_connect.release();
}


SCH_LINE* SCH_LEGACY_PLUGIN::loadWire( LINE_READER& aReader )
{
 std::unique_ptr<SCH_LINE> wire = std::make_unique<SCH_LINE>();

 const char* line = aReader.Line();

 wxCHECK( strCompare( "Wire", line, &line ), nullptr );

 if( strCompare( "Wire", line, &line ) )
 wire->SetLayer( LAYER_WIRE );
 else if( strCompare( "Bus", line, &line ) )
 wire->SetLayer( LAYER_BUS );
 else if( strCompare( "Notes", line, &line ) )
 wire->SetLayer( LAYER_NOTES );
 else
 SCH_PARSE_ERROR( "invalid line type", aReader, line );

 if( !strCompare( "Line", line, &line ) )
 SCH_PARSE_ERROR( "invalid wire definition", aReader, line );

 // Since Sept 15, 2017, a line style is alloved (width, style, color)
 // Only non default values are stored
 while( !is_eol( *line ) )
 {
 wxString buf;

 parseUnquotedString( buf, aReader, line, &line );

 if( buf == ")" )
 continue;

 else if( buf == T_WIDTH )
 {
 int size = Mils2Iu( parseInt( aReader, line, &line ) );
 wire->SetLineWidth( size );
 }
 else if( buf == T_STYLE )
 {
 parseUnquotedString( buf, aReader, line, &line );
 PLOT_DASH_TYPE style = SCH_LINE::GetLineStyleByName( buf );
 wire->SetLineStyle( style );
 }
 else // should be the color parameter.
 {
 // The color param is something like rgb(150, 40, 191)
 // and because there is no space between ( and 150
 // the first param is inside buf.
 // So break keyword and the first param into 2 separate strings.
 wxString prm, keyword;
 keyword = buf.BeforeLast( '(', &prm );

 if( ( keyword == T_COLOR ) || ( keyword == T_COLORA ) )
 {
 long color[4] = { 0 };

 int ii = 0;

 if( !prm.IsEmpty() )
 {
  prm.ToLong( &color[ii] );
 ii++;
 }

 int prm_count = ( keyword == T_COLORA ) ? 4 : 3;
 // fix opacity to 1.0 or 255, when not exists in file
 color[3] = 255;

 for(; ii < prm_count && !is_eol( *line ); ii++ )
 {
 color[ii] = parseInt( aReader, line, &line );

 // Skip the separator between values
 if( *line == ',' || *line == ' ')
 line++;
 }

 wire->SetLineColor( color[0]/255.0, color[1]/255.0, color[2]/255.0,color[3]/255.0 );
 }
 }
 }

 // Read the segment en points coordinates:
 line = aReader.ReadLine();

 wxPoint begin, end;

 begin.x = Mils2Iu( parseInt( aReader, line, &line ) );
 begin.y = Mils2Iu( parseInt( aReader, line, &line ) );
 end.x = Mils2Iu( parseInt( aReader, line, &line ) );
 end.y = Mils2Iu( parseInt( aReader, line, &line ) );

 wire->SetStartPoint( begin );
 wire->SetEndPoint( end );

 return wire.release();
}


SCH_BUS_ENTRY_BASE* SCH_LEGACY_PLUGIN::loadBusEntry( LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK( strCompare( "Entry", line, &line ), nullptr );

 std::unique_ptr<SCH_BUS_ENTRY_BASE> busEntry;

 if( strCompare( "Wire", line, &line ) )
 {
 busEntry = std::make_unique<SCH_BUS_WIRE_ENTRY>();

 if( !strCompare( "Line", line, &line ) )
 SCH_PARSE_ERROR( "invalid bus entry definition expected 'Line'", aReader, line );
 }
 else if( strCompare( "Bus", line, &line ) )
 {
 busEntry = std::make_unique<SCH_BUS_BUS_ENTRY>();

 if( !strCompare( "Bus", line, &line ) )
 SCH_PARSE_ERROR( "invalid bus entry definition expected 'Bus'", aReader, line );
 }
 else
 SCH_PARSE_ERROR( "invalid bus entry type", aReader, line );

 line = aReader.ReadLine();

 wxPoint pos;
 wxSize size;

 pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
 pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
 size.x = Mils2Iu( parseInt( aReader, line, &line ) );
 size.y = Mils2Iu( parseInt( aReader, line, &line ) );

 size.x -= pos.x;
 size.y -= pos.y;

 busEntry->SetPosition( pos );
 busEntry->SetSize( size );

 return busEntry.release();
}

// clang-format off
const std::map<PINSHEETLABEL_SHAPE, const char*> sheetLabelNames
{
 { PINSHEETLABEL_SHAPE::PS_INPUT, "Input" },
 { PINSHEETLABEL_SHAPE::PS_OUTPUT, "Output" },
 { PINSHEETLABEL_SHAPE::PS_BIDI, "BiDi" },
 { PINSHEETLABEL_SHAPE::PS_TRISTATE, "3State" },
 { PINSHEETLABEL_SHAPE::PS_UNSPECIFIED, "UnSpc" },
};
// clang-format on


SCH_TEXT* SCH_LEGACY_PLUGIN::loadText( LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK( strCompare( "Text", line, &line ), nullptr );

 std::unique_ptr<SCH_TEXT> text;

 if( strCompare( "Notes", line, &line ) )
 text.reset( new SCH_TEXT );
 else if( strCompare( "Label", line, &line ) )
 text.reset( new SCH_LABEL );
 else if( strCompare( "HLabel", line, &line ) )
 text.reset( new SCH_HIERLABEL );
 else if( strCompare( "GLabel", line, &line ) )
 {
 // Prior to version 2, the SCH_GLOBALLABEL object did not exist.
 if( m_version == 1 )
 text = std::make_unique<SCH_HIERLABEL>();
 else
 text = std::make_unique<SCH_GLOBALLABEL>();
 }
 else
 SCH_PARSE_ERROR( "unknown Text type", aReader, line );

 // Parse the parameters common to all text objects.
 wxPoint position;

 position.x = Mils2Iu( parseInt( aReader, line, &line ) );
 position.y = Mils2Iu( parseInt( aReader, line, &line ) );
 text->SetPosition( position );

 int spinStyle = parseInt( aReader, line, &line );

 // Sadly we store the orientation of hierarchical and global labels using a different
 // int encoding than that for local labels:
 // Global Local
 // Left justified 0 2
 // Up 1 3
 // Right justified 2 0
 // Down 3 1
 // So we must flip it as the enum is setup with the "global" numbering
 if( text->Type() != SCH_GLOBAL_LABEL_T && text->Type() != SCH_HIER_LABEL_T )
 {
 if( spinStyle == 0 )
 spinStyle = 2;
 else if( spinStyle == 2 )
 spinStyle = 0;
 }

 text->SetLabelSpinStyle( (LABEL_SPIN_STYLE::SPIN) spinStyle );

 int size = Mils2Iu( parseInt( aReader, line, &line ) );

 text->SetTextSize( wxSize( size, size ) );

 // Parse the global and hierarchical label type.
 if( text->Type() == SCH_HIER_LABEL_T || text->Type() == SCH_GLOBAL_LABEL_T )
 {
 auto resultIt = std::find_if( sheetLabelNames.begin(), sheetLabelNames.end(),
 [ &line ]( const auto& it )
 {
 return strCompare( it.second, line, &line );
 } );

 if( resultIt != sheetLabelNames.end() )
 text->SetShape( resultIt->first );
 else
 SCH_PARSE_ERROR( "invalid label type", aReader, line );
 }

 int penWidth = 0;

 // The following tokens do not exist in version 1 schematic files,
 // and not always in version 2 for HLabels and GLabels
 if( m_version > 1 )
 {
 if( m_version > 2 || *line >= ' ' )
 {
 if( strCompare( "Italic", line, &line ) )
 text->SetItalic( true );
 else if( !strCompare( "~", line, &line ) )
 SCH_PARSE_ERROR( _( "expected 'Italics' or '~'" ), aReader, line );
 }

 // The penWidth token does not exist in older versions of the schematic file format
 // so calling parseInt will be made only if the EOL is not reached.
 if( *line >= ' ' )
 penWidth = parseInt( aReader, line, &line );
 }

 text->SetBold( penWidth != 0 );
 text->SetTextThickness( penWidth != 0 ? GetPenSizeForBold( size ) : 0 );

 // Read the text string for the text.
 char* tmp = aReader.ReadLine();

 tmp = strtok( tmp, "\r\n" );
 wxString val = FROM_UTF8( tmp );

 for( ; ; )
 {
 int i = val.find( wxT( "\\n" ) );

 if( i == wxNOT_FOUND )
 break;

 val.erase( i, 2 );
 val.insert( i, wxT( "\n" ) );
 }

 text->SetText( ConvertToNewOverbarNotation( val ) );

 return text.release();
}


SCH_SYMBOL* SCH_LEGACY_PLUGIN::loadSymbol( LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK( strCompare( "$Comp", line, &line ), nullptr );

 std::unique_ptr<SCH_SYMBOL> symbol = std::make_unique<SCH_SYMBOL>();

 line = aReader.ReadLine();

 while( line != nullptr )
 {
 if( strCompare( "L", line, &line ) )
 {
 wxString libName;
 size_t pos = 2; // "X" plus ' ' space character.
 wxString utf8Line = wxString::FromUTF8( line );
 wxStringTokenizer tokens( utf8Line, " \r\n\t" );

 if( tokens.CountTokens() < 2 )
 THROW_PARSE_ERROR( "invalid symbol library definition", aReader.GetSource(),
 aReader.Line(), aReader.LineNumber(), pos );

 libName = tokens.GetNextToken();
 libName.Replace( "~", " " );

 LIB_ID libId;

 // Prior to schematic version 4, library IDs did not have a library nickname so
 // parsing the symbol name with LIB_ID::Parse() would break symbol library links
 // that contained '/' and ':' characters.
 if( m_version > 3 )
 libId.Parse( libName, true );
 else
 libId.SetLibItemName( libName );

 symbol->SetLibId( libId );

 wxString refDesignator = tokens.GetNextToken();

 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 );
 }
 else if( strCompare( "U", line, &line ) )
 {
 // This fixes a potentially buggy files caused by unit being set to zero which
 // causes netlist issues. See https://bugs.launchpad.net/kicad/+bug/1677282.
 int unit = parseInt( aReader, line, &line );

 if( unit == 0 )
 {
 unit = 1;

 // Set the file as modified so the user can be warned.
 if( m_rootSheet->GetScreen() )
 m_rootSheet->GetScreen()->SetContentModified();
 }

 symbol->SetUnit( unit );

 // Same can also happen with the convert parameter
 int convert = parseInt( aReader, line, &line );

 if( convert == 0 )
 {
 convert = 1;

 // Set the file as modified so the user can be warned.
 if( m_rootSheet->GetScreen() )
  m_rootSheet->GetScreen()->SetContentModified();
 }

 symbol->SetConvert( convert );

 wxString text;
 parseUnquotedString( text, aReader, line, &line );

 if( text != "00000000" )
 const_cast<KIID&>( symbol->m_Uuid ) = KIID( text );
 }
 else if( strCompare( "P", line, &line ) )
 {
 wxPoint pos;

 pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
 pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
 symbol->SetPosition( pos );
 }
 else if( strCompare( "AR", line, &line ) )
 {
 const char* strCompare = "Path=";
 int len = strlen( strCompare );

 if( strncasecmp( strCompare, line, len ) != 0 )
 SCH_PARSE_ERROR( "missing 'Path=' token", aReader, line );

 line += len;
 wxString pathStr, reference, unit;

 parseQuotedString( pathStr, aReader, line, &line );

 // Note: AR path excludes root sheet, but includes symbol. Normalize to
 // internal format by shifting everything down one and adding the root sheet.
 KIID_PATH path( pathStr );

 if( path.size() > 0 )
 {
 for( size_t i = path.size() - 1; i > 0; --i )
 path[i] = path[i-1];

 path[0] = m_rootSheet->m_Uuid;
 }
 else
 path.push_back( m_rootSheet->m_Uuid );

 strCompare = "Ref=";
 len = strlen( strCompare );

 if( strncasecmp( strCompare, line, len ) != 0 )
 SCH_PARSE_ERROR( "missing 'Ref=' token", aReader, line );

 line+= len;
 parseQuotedString( reference, aReader, line, &line );

 strCompare = "Part=";
 len = strlen( strCompare );

 if( strncasecmp( strCompare, line, len ) != 0 )
 SCH_PARSE_ERROR( "missing 'Part=' token", aReader, line );

 line+= len;
 parseQuotedString( unit, aReader, line, &line );

 long tmp;

 if( !unit.ToLong( &tmp, 10 ) )
 SCH_PARSE_ERROR( "expected integer value", aReader, line );

 if( tmp < 0 || tmp > MAX_UNIT_COUNT_PER_PACKAGE )
 SCH_PARSE_ERROR( "unit value out of range", aReader, line );

 symbol->AddHierarchicalReference( path, reference, (int)tmp );
 symbol->GetField( REFERENCE_FIELD )->SetText( reference );

 }
 else if( strCompare( "F", line, &line ) )
 {
 int index = parseInt( aReader, line, &line );

 wxString text, name;

 parseQuotedString( text, aReader, line, &line, true );

 char orientation = parseChar( aReader, line, &line );
 wxPoint pos;
 pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
 pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
 int size = Mils2Iu( parseInt( aReader, line, &line ) );
 int attributes = parseHex( aReader, line, &line );

 if( index >= symbol->GetFieldCount() )
 {
 // The first MANDATOR_FIELDS _must_ be constructed within the SCH_SYMBOL
 // constructor. This assert is simply here to guard against a change in that
 // constructor.
 wxASSERT( symbol->GetFieldCount() >= MANDATORY_FIELDS );

 // Ignore the _supplied_ fieldNdx. It is not important anymore if within the
 // user defined fields region (i.e. >= MANDATORY_FIELDS).
 // We freely renumber the index to fit the next available field slot.
 index = symbol->GetFieldCount(); // new has this index after insertion

 SCH_FIELD field( wxPoint( 0, 0 ), index, symbol.get(), name );
 symbol->AddField( field );
 }

 SCH_FIELD& field = symbol->GetFields()[index];

 // Prior to version 2 of the schematic file format, none of the following existed.
 if( m_version > 1 )
 {
 wxString textAttrs;
 char hjustify = parseChar( aReader, line, &line );

 parseUnquotedString( textAttrs, aReader, line, &line );

 // The name of the field is optional.
 parseQuotedString( name, aReader, line, &line, true );

 if( hjustify == 'L' )
 field.SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
 else if( hjustify == 'R' )
 field.SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
 else if( hjustify != 'C' )
 SCH_PARSE_ERROR( "symbol field text horizontal justification must be "
 "L, R, or C", aReader, line );

 // We are guaranteed to have a least one character here for older file formats
 // otherwise an exception would have been raised..
 if( textAttrs[0] == 'T' )
 field.SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
 else if( textAttrs[0] == 'B' )
 field.SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
 else if( textAttrs[0] != 'C' )
 SCH_PARSE_ERROR( "symbol field text vertical justification must be "
 "B, T, or C", aReader, line );

 // Newer file formats include the bold and italics text attribute.
 if( textAttrs.Length() > 1 )
 {
 if( textAttrs.Length() != 3 )
 SCH_PARSE_ERROR( _( "symbol field text attributes must be 3 characters wide" ),
 aReader, line );

 if( textAttrs[1] == 'I' )
 field.SetItalic( true );
 else if( textAttrs[1] != 'N' )
 SCH_PARSE_ERROR( "symbol field text italics indicator must be I or N",
 aReader, line );

 if( textAttrs[2] == 'B' )
 field.SetBold( true );
 else if( textAttrs[2] != 'N' )
 SCH_PARSE_ERROR( "symbol field text bold indicator must be B or N",
 aReader, line );
 }
 }

 field.SetText( text );
 field.SetTextPos( pos );
 field.SetVisible( !attributes );
 field.SetTextSize( wxSize( size, size ) );

 if( orientation == 'H' )
 field.SetTextAngle( TEXT_ANGLE_HORIZ );
 else if( orientation == 'V' )
 field.SetTextAngle( TEXT_ANGLE_VERT );
 else
 SCH_PARSE_ERROR( "symbol field orientation must be H or V", aReader, line );

 if( name.IsEmpty() )
 name = TEMPLATE_FIELDNAME::GetDefaultFieldName( index );

 field.SetName( name );
 }
 else if( strCompare( "$EndComp", line ) )
 {
 // Ensure all flags (some are set by previous initializations) are reset:
 symbol->ClearFlags();
 return symbol.release();
 }
 else
 {
 // There are two lines that begin with a tab or spaces that includes a line with the
 // redundant position information and the transform matrix settings.

 // Parse the redundant position information just the same to check for formatting
 // errors.
 parseInt( aReader, line, &line ); // Always 1.
 parseInt( aReader, line, &line ); // The X coordinate.
 parseInt( aReader, line, &line ); // The Y coordinate.

 line = aReader.ReadLine();

 TRANSFORM transform;

 transform.x1 = parseInt( aReader, line, &line );

 if( transform.x1 < -1 || transform.x1 > 1 )
 SCH_PARSE_ERROR( "invalid symbol X1 transform value", aReader, line );

 transform.y1 = parseInt( aReader, line, &line );

 if( transform.y1 < -1 || transform.y1 > 1 )
 SCH_PARSE_ERROR( "invalid symbol Y1 transform value", aReader, line );

 transform.x2 = parseInt( aReader, line, &line );

 if( transform.x2 < -1 || transform.x2 > 1 )
 SCH_PARSE_ERROR( "invalid symbol X2 transform value", aReader, line );

 transform.y2 = parseInt( aReader, line, &line );

 if( transform.y2 < -1 || transform.y2 > 1 )
 SCH_PARSE_ERROR( "invalid symbol Y2 transform value", aReader, line );

 symbol->SetTransform( transform );
 }

 line = aReader.ReadLine();
 }

 SCH_PARSE_ERROR( "invalid symbol line", aReader, line );

 return nullptr; // Prevents compiler warning. Should never get here.
}


std::shared_ptr<BUS_ALIAS> SCH_LEGACY_PLUGIN::loadBusAlias( LINE_READER& aReader,
 SCH_SCREEN* aScreen )
{
 auto busAlias = std::make_shared<BUS_ALIAS>( aScreen );
 const char* line = aReader.Line();

 wxCHECK( strCompare( "BusAlias", line, &line ), nullptr );

 wxString buf;
 parseUnquotedString( buf, aReader, line, &line );
 busAlias->SetName( buf );

 while( *line != '\0' )
 {
 buf.clear();
 parseUnquotedString( buf, aReader, line, &line, true );

 if( buf.Len() > 0 )
 {
 busAlias->AddMember( buf );
 }
 }

 return busAlias;
}


void SCH_LEGACY_PLUGIN::Save( const wxString& aFileName, SCH_SHEET* aSheet, SCHEMATIC* aSchematic,
 const PROPERTIES* aProperties )
{
 wxCHECK_RET( aSheet != nullptr, "NULL SCH_SHEET object." );
 wxCHECK_RET( !aFileName.IsEmpty(), "No schematic file name defined." );

 LOCALE_IO toggle; // toggles on, then off, the C locale, to write floating point values.

 init( aSchematic, aProperties );

 wxFileName fn = aFileName;

 // File names should be absolute. Don't assume everything relative to the project path
 // works properly.
 wxASSERT( fn.IsAbsolute() );

 FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );

 m_out = &formatter; // no ownership

 Format( aSheet );

 aSheet->GetScreen()->SetFileExists( true );
}


void SCH_LEGACY_PLUGIN::Format( SCH_SHEET* aSheet )
{
 wxCHECK_RET( aSheet != nullptr, "NULL SCH_SHEET* object." );
 wxCHECK_RET( m_schematic != nullptr, "NULL SCHEMATIC* object." );

 SCH_SCREEN* screen = aSheet->GetScreen();

 wxCHECK( screen, /* void */ );

 // Write the header
 m_out->Print( 0, "%s %s %d\n", "EESchema", SCHEMATIC_HEAD_STRING, EESCHEMA_VERSION );

 // This section is not used, but written for file compatibility
 m_out->Print( 0, "EELAYER %d %d\n", SCH_LAYER_ID_COUNT, 0 );
 m_out->Print( 0, "EELAYER END\n" );

 /* Write page info, ScreenNumber and NumberOfScreen; not very meaningful for
 * SheetNumber and Sheet Count in a complex hierarchy, but useful in
 * simple hierarchy and flat hierarchy. Used also to search the root
 * sheet ( ScreenNumber = 1 ) within the files
 */
 const TITLE_BLOCK& tb = screen->GetTitleBlock();
 const PAGE_INFO& page = screen->GetPageSettings();

 m_out->Print( 0, "$Descr %s %d %d%s\n", TO_UTF8( page.GetType() ),
 page.GetWidthMils(),
 page.GetHeightMils(),
 !page.IsCustom() && page.IsPortrait() ? " portrait" : "" );
 m_out->Print( 0, "encoding utf-8\n" );
 m_out->Print( 0, "Sheet %d %d\n", screen->GetVirtualPageNumber(), screen->GetPageCount() );
 m_out->Print( 0, "Title %s\n", EscapedUTF8( tb.GetTitle() ).c_str() );
 m_out->Print( 0, "Date %s\n", EscapedUTF8( tb.GetDate() ).c_str() );
 m_out->Print( 0, "Rev %s\n", EscapedUTF8( tb.GetRevision() ).c_str() );
 m_out->Print( 0, "Comp %s\n", EscapedUTF8( tb.GetCompany() ).c_str() );
 m_out->Print( 0, "Comment1 %s\n", EscapedUTF8( tb.GetComment( 0 ) ).c_str() );
 m_out->Print( 0, "Comment2 %s\n", EscapedUTF8( tb.GetComment( 1 ) ).c_str() );
 m_out->Print( 0, "Comment3 %s\n", EscapedUTF8( tb.GetComment( 2 ) ).c_str() );
 m_out->Print( 0, "Comment4 %s\n", EscapedUTF8( tb.GetComment( 3 ) ).c_str() );
 m_out->Print( 0, "Comment5 %s\n", EscapedUTF8( tb.GetComment( 4 ) ).c_str() );
 m_out->Print( 0, "Comment6 %s\n", EscapedUTF8( tb.GetComment( 5 ) ).c_str() );
 m_out->Print( 0, "Comment7 %s\n", EscapedUTF8( tb.GetComment( 6 ) ).c_str() );
 m_out->Print( 0, "Comment8 %s\n", EscapedUTF8( tb.GetComment( 7 ) ).c_str() );
 m_out->Print( 0, "Comment9 %s\n", EscapedUTF8( tb.GetComment( 8 ) ).c_str() );
 m_out->Print( 0, "$EndDescr\n" );

 for( const auto& alias : screen->GetBusAliases() )
 {
 saveBusAlias( alias );
 }

 // Enforce item ordering
 auto cmp = []( const SCH_ITEM* a, const SCH_ITEM* b ) { return *a < *b; };
 std::multiset<SCH_ITEM*, decltype( cmp )> save_map( cmp );

 for( auto item : screen->Items() )
 save_map.insert( item );


 for( auto& item : save_map )
 {
 switch( item->Type() )
 {
 case SCH_SYMBOL_T:
 saveSymbol( static_cast<SCH_SYMBOL*>( item ) );
 break;
 case SCH_BITMAP_T:
 saveBitmap( static_cast<SCH_BITMAP*>( item ) );
 break;
 case SCH_SHEET_T:
 saveSheet( static_cast<SCH_SHEET*>( item ) );
 break;
 case SCH_JUNCTION_T:
 saveJunction( static_cast<SCH_JUNCTION*>( item ) );
 break;
 case SCH_NO_CONNECT_T:
 saveNoConnect( static_cast<SCH_NO_CONNECT*>( item ) );
 break;
 case SCH_BUS_WIRE_ENTRY_T:
 case SCH_BUS_BUS_ENTRY_T:
 saveBusEntry( static_cast<SCH_BUS_ENTRY_BASE*>( item ) );
 break;
 case SCH_LINE_T:
 saveLine( static_cast<SCH_LINE*>( item ) );
 break;
 case SCH_TEXT_T:
 case SCH_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 saveText( static_cast<SCH_TEXT*>( item ) );
 break;
 default:
 wxASSERT( "Unexpected schematic object type in SCH_LEGACY_PLUGIN::Format()" );
 }
 }

 m_out->Print( 0, "$EndSCHEMATC\n" );
}


void SCH_LEGACY_PLUGIN::Format( SELECTION* aSelection, OUTPUTFORMATTER* aFormatter )
{
 m_out = aFormatter;

 for( unsigned i = 0; i < aSelection->GetSize(); ++i )
 {
 SCH_ITEM* item = (SCH_ITEM*) aSelection->GetItem( i );

 switch( item->Type() )
 {
 case SCH_SYMBOL_T:
 saveSymbol( static_cast< SCH_SYMBOL* >( item ) );
 break;
 case SCH_BITMAP_T:
 saveBitmap( static_cast< SCH_BITMAP* >( item ) );
 break;
 case SCH_SHEET_T:
 saveSheet( static_cast< SCH_SHEET* >( item ) );
 break;
 case SCH_JUNCTION_T:
 saveJunction( static_cast< SCH_JUNCTION* >( item ) );
 break;
 case SCH_NO_CONNECT_T:
 saveNoConnect( static_cast< SCH_NO_CONNECT* >( item ) );
 break;
 case SCH_BUS_WIRE_ENTRY_T:
 case SCH_BUS_BUS_ENTRY_T:
 saveBusEntry( static_cast< SCH_BUS_ENTRY_BASE* >( item ) );
 break;
 case SCH_LINE_T:
 saveLine( static_cast< SCH_LINE* >( item ) );
 break;
 case SCH_TEXT_T:
 case SCH_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 saveText( static_cast< SCH_TEXT* >( item ) );
 break;
 default:
 wxASSERT( "Unexpected schematic object type in SCH_LEGACY_PLUGIN::Format()" );
 }
 }
}


void SCH_LEGACY_PLUGIN::saveSymbol( SCH_SYMBOL* aSymbol )
{
 std::string name1;
 std::string name2;

 static wxString delimiters( wxT( " " ) );

 // This is redundant with the AR entries below, but it makes the files backwards-compatible.
 if( aSymbol->GetInstanceReferences().size() > 0 )
 {
 const SYMBOL_INSTANCE_REFERENCE& instance = aSymbol->GetInstanceReferences()[0];
 name1 = toUTFTildaText( instance.m_Reference );
 }
 else
 {
 if( aSymbol->GetField( REFERENCE_FIELD )->GetText().IsEmpty() )
 name1 = toUTFTildaText( aSymbol->GetPrefix() );
 else
 name1 = toUTFTildaText( aSymbol->GetField( REFERENCE_FIELD )->GetText() );
 }

 wxString symbol_name = aSymbol->GetLibId().Format();

 if( symbol_name.size() )
 {
 name2 = toUTFTildaText( symbol_name );
 }
 else
 {
 name2 = "_NONAME_";
 }

 m_out->Print( 0, "$Comp\n" );
 m_out->Print( 0, "L %s %s\n", name2.c_str(), name1.c_str() );

 // Generate unit number, conversion and timestamp
 m_out->Print( 0, "U %d %d %8.8X\n",
 aSymbol->GetUnit(),
 aSymbol->GetConvert(),
 aSymbol->m_Uuid.AsLegacyTimestamp() );

 // Save the position
 m_out->Print( 0, "P %d %d\n",
 Iu2Mils( aSymbol->GetPosition().x ),
 Iu2Mils( aSymbol->GetPosition().y ) );

 /* If this is a complex hierarchy; save hierarchical references.
 * but for simple hierarchies it is not necessary.
 * the reference inf is already saved
 * this is useful for old Eeschema version compatibility
 */
 if( aSymbol->GetInstanceReferences().size() > 1 )
 {
 for( const SYMBOL_INSTANCE_REFERENCE& instance : aSymbol->GetInstanceReferences() )
 {
 /*format:
 * AR Path="/140/2" Ref="C99" Part="1"
 * where 140 is the uid of the containing sheet and 2 is the timestamp of this symbol.
 * (timestamps are actually 8 hex chars)
 * Ref is the conventional symbol reference designator for this 'path'
 * Part is the conventional symbol unit selection for this 'path'
 */
 wxString path = "/";

 // Skip root sheet
 for( int i = 1; i < (int) instance.m_Path.size(); ++i )
 path += instance.m_Path[i].AsLegacyTimestampString() + "/";

 m_out->Print( 0, "AR Path=\"%s\" Ref=\"%s\" Part=\"%d\" \n",
 TO_UTF8( path + aSymbol->m_Uuid.AsLegacyTimestampString() ),
 TO_UTF8( instance.m_Reference ),
 instance.m_Unit );
 }
 }

 // update the ugly field id, which I would like to see go away someday soon.
 for( int i = 0; i < aSymbol->GetFieldCount(); ++i )
 aSymbol->GetFields()[i].SetId( i );

 // Fixed fields:
 // Save mandatory fields even if they are blank,
 // because the visibility, size and orientation are set from library editor.
 for( unsigned i = 0; i < MANDATORY_FIELDS; ++i )
 saveField( &aSymbol->GetFields()[i] );

 // User defined fields:
 // The *policy* about which user defined fields are symbol of a symbol is now
 // only in the dialog editors. No policy should be enforced here, simply
 // save all the user defined fields, they are present because a dialog editor
 // thought they should be. If you disagree, go fix the dialog editors.
 for( int i = MANDATORY_FIELDS; i < aSymbol->GetFieldCount(); ++i )
 saveField( &aSymbol->GetFields()[i] );

 // Unit number, position, box ( old standard )
 m_out->Print( 0, "\t%-4d %-4d %-4d\n", aSymbol->GetUnit(),
 Iu2Mils( aSymbol->GetPosition().x ),
 Iu2Mils( aSymbol->GetPosition().y ) );

 TRANSFORM transform = aSymbol->GetTransform();

 m_out->Print( 0, "\t%-4d %-4d %-4d %-4d\n",
 transform.x1, transform.y1, transform.x2, transform.y2 );
 m_out->Print( 0, "$EndComp\n" );
}


void SCH_LEGACY_PLUGIN::saveField( SCH_FIELD* aField )
{
 char hjustify = 'C';

 if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_LEFT )
 hjustify = 'L';
 else if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_RIGHT )
 hjustify = 'R';

 char vjustify = 'C';

 if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_BOTTOM )
 vjustify = 'B';
 else if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_TOP )
 vjustify = 'T';

 m_out->Print( 0, "F %d %s %c %-3d %-3d %-3d %4.4X %c %c%c%c",
 aField->GetId(),
 EscapedUTF8( aField->GetText() ).c_str(), // wraps in quotes too
 aField->GetTextAngle() == TEXT_ANGLE_HORIZ ? 'H' : 'V',
 Iu2Mils( aField->GetLibPosition().x ),
 Iu2Mils( aField->GetLibPosition().y ),
 Iu2Mils( aField->GetTextWidth() ),
 !aField->IsVisible(),
 hjustify, vjustify,
 aField->IsItalic() ? 'I' : 'N',
 aField->IsBold() ? 'B' : 'N' );

 // Save field name, if the name is user definable
 if( aField->GetId() >= MANDATORY_FIELDS )
 m_out->Print( 0, " %s", EscapedUTF8( aField->GetName() ).c_str() );

 m_out->Print( 0, "\n" );
}


void SCH_LEGACY_PLUGIN::saveBitmap( SCH_BITMAP* aBitmap )
{
 wxCHECK_RET( aBitmap != nullptr, "SCH_BITMAP* is NULL" );

 const wxImage* image = aBitmap->GetImage()->GetImageData();

 wxCHECK_RET( image != nullptr, "wxImage* is NULL" );

 m_out->Print( 0, "$Bitmap\n" );
 m_out->Print( 0, "Pos %-4d %-4d\n",
 Iu2Mils( aBitmap->GetPosition().x ),
 Iu2Mils( aBitmap->GetPosition().y ) );
 m_out->Print( 0, "Scale %f\n", aBitmap->GetImage()->GetScale() );
 m_out->Print( 0, "Data\n" );

 wxMemoryOutputStream stream;

 image->SaveFile( stream, wxBITMAP_TYPE_PNG );

 // Write binary data in hexadecimal form (ASCII)
 wxStreamBuffer* buffer = stream.GetOutputStreamBuffer();
 char* begin = (char*) buffer->GetBufferStart();

 for( int ii = 0; begin < buffer->GetBufferEnd(); begin++, ii++ )
 {
 if( ii >= 32 )
 {
 ii = 0;

 m_out->Print( 0, "\n" );
 }

 m_out->Print( 0, "%2.2X ", *begin & 0xFF );
 }

 m_out->Print( 0, "\nEndData\n" );
 m_out->Print( 0, "$EndBitmap\n" );
}


void SCH_LEGACY_PLUGIN::saveSheet( SCH_SHEET* aSheet )
{
 wxCHECK_RET( aSheet != nullptr, "SCH_SHEET* is NULL" );

 m_out->Print( 0, "$Sheet\n" );
 m_out->Print( 0, "S %-4d %-4d %-4d %-4d\n",
 Iu2Mils( aSheet->GetPosition().x ),
 Iu2Mils( aSheet->GetPosition().y ),
 Iu2Mils( aSheet->GetSize().x ),
 Iu2Mils( aSheet->GetSize().y ) );

 m_out->Print( 0, "U %8.8X\n", aSheet->m_Uuid.AsLegacyTimestamp() );

 SCH_FIELD& sheetName = aSheet->GetFields()[SHEETNAME];
 SCH_FIELD& fileName = aSheet->GetFields()[SHEETFILENAME];

 if( !sheetName.GetText().IsEmpty() )
 m_out->Print( 0, "F0 %s %d\n",
 EscapedUTF8( sheetName.GetText() ).c_str(),
 Iu2Mils( sheetName.GetTextSize().x ) );

 if( !fileName.GetText().IsEmpty() )
 m_out->Print( 0, "F1 %s %d\n",
 EscapedUTF8( fileName.GetText() ).c_str(),
 Iu2Mils( fileName.GetTextSize().x ) );

 for( const SCH_SHEET_PIN* pin : aSheet->GetPins() )
 {
 int type, side;

 if( pin->GetText().IsEmpty() )
 break;

 switch( pin->GetSide() )
 {
 default:
 case SHEET_SIDE::LEFT: side = 'L'; break;
 case SHEET_SIDE::RIGHT: side = 'R'; break;
 case SHEET_SIDE::TOP: side = 'T'; break;
 case SHEET_SIDE::BOTTOM: side = 'B'; break;
 }

 switch( pin->GetShape() )
 {
 default:
 case PINSHEETLABEL_SHAPE::PS_UNSPECIFIED: type = 'U'; break;
 case PINSHEETLABEL_SHAPE::PS_INPUT: type = 'I'; break;
 case PINSHEETLABEL_SHAPE::PS_OUTPUT: type = 'O'; break;
 case PINSHEETLABEL_SHAPE::PS_BIDI: type = 'B'; break;
 case PINSHEETLABEL_SHAPE::PS_TRISTATE: type = 'T'; break;
 }

 m_out->Print( 0, "F%d %s %c %c %-3d %-3d %-3d\n",
 pin->GetNumber(),
 EscapedUTF8( pin->GetText() ).c_str(), // supplies wrapping quotes
 type, side, Iu2Mils( pin->GetPosition().x ),
 Iu2Mils( pin->GetPosition().y ),
 Iu2Mils( pin->GetTextWidth() ) );
 }

 m_out->Print( 0, "$EndSheet\n" );
}


void SCH_LEGACY_PLUGIN::saveJunction( SCH_JUNCTION* aJunction )
{
 wxCHECK_RET( aJunction != nullptr, "SCH_JUNCTION* is NULL" );

 m_out->Print( 0, "Connection ~ %-4d %-4d\n",
 Iu2Mils( aJunction->GetPosition().x ),
 Iu2Mils( aJunction->GetPosition().y ) );
}


void SCH_LEGACY_PLUGIN::saveNoConnect( SCH_NO_CONNECT* aNoConnect )
{
 wxCHECK_RET( aNoConnect != nullptr, "SCH_NOCONNECT* is NULL" );

 m_out->Print( 0, "NoConn ~ %-4d %-4d\n",
 Iu2Mils( aNoConnect->GetPosition().x ),
 Iu2Mils( aNoConnect->GetPosition().y ) );
}


void SCH_LEGACY_PLUGIN::saveBusEntry( SCH_BUS_ENTRY_BASE* aBusEntry )
{
 wxCHECK_RET( aBusEntry != nullptr, "SCH_BUS_ENTRY_BASE* is NULL" );

 if( aBusEntry->GetLayer() == LAYER_WIRE )
 m_out->Print( 0, "Entry Wire Line\n\t%-4d %-4d %-4d %-4d\n",
 Iu2Mils( aBusEntry->GetPosition().x ),
 Iu2Mils( aBusEntry->GetPosition().y ),
 Iu2Mils( aBusEntry->GetEnd().x ), Iu2Mils( aBusEntry->GetEnd().y ) );
 else
 m_out->Print( 0, "Entry Bus Bus\n\t%-4d %-4d %-4d %-4d\n",
 Iu2Mils( aBusEntry->GetPosition().x ),
 Iu2Mils( aBusEntry->GetPosition().y ),
 Iu2Mils( aBusEntry->GetEnd().x ), Iu2Mils( aBusEntry->GetEnd().y ) );
}


void SCH_LEGACY_PLUGIN::saveLine( SCH_LINE* aLine )
{
 wxCHECK_RET( aLine != nullptr, "SCH_LINE* is NULL" );

 const char* layer = "Notes";
 const char* width = "Line";

 if( aLine->GetLayer() == LAYER_WIRE )
 layer = "Wire";
 else if( aLine->GetLayer() == LAYER_BUS )
 layer = "Bus";

 m_out->Print( 0, "Wire %s %s", layer, width );

 // Write line style (width, type, color) only for non default values
 if( aLine->IsGraphicLine() )
 {
 if( aLine->GetLineSize() != 0 )
 m_out->Print( 0, " %s %d", T_WIDTH, Iu2Mils( aLine->GetLineSize() ) );

 if( aLine->GetLineStyle() != aLine->GetDefaultStyle() )
 m_out->Print( 0, " %s %s", T_STYLE,
 SCH_LINE::GetLineStyleName( aLine->GetLineStyle() ) );

 if( aLine->GetLineColor() != COLOR4D::UNSPECIFIED )
 m_out->Print( 0, " %s",
 TO_UTF8( aLine->GetLineColor().ToColour().GetAsString( wxC2S_CSS_SYNTAX ) ) );
 }

 m_out->Print( 0, "\n" );

 m_out->Print( 0, "\t%-4d %-4d %-4d %-4d",
 Iu2Mils( aLine->GetStartPoint().x ), Iu2Mils( aLine->GetStartPoint().y ),
 Iu2Mils( aLine->GetEndPoint().x ), Iu2Mils( aLine->GetEndPoint().y ) );

 m_out->Print( 0, "\n");
}


void SCH_LEGACY_PLUGIN::saveText( SCH_TEXT* aText )
{
 wxCHECK_RET( aText != nullptr, "SCH_TEXT* is NULL" );

 const char* italics = "~";
 const char* textType = "Notes";

 if( aText->IsItalic() )
 italics = "Italic";

 wxString text = aText->GetText();

 SCH_LAYER_ID layer = aText->GetLayer();

 if( layer == LAYER_NOTES || layer == LAYER_LOCLABEL )
 {
 if( layer == LAYER_NOTES )
 {
 // For compatibility reasons, the text must be saved in only one text line
 // so replace all EOLs with \\n
 text.Replace( wxT( "\n" ), wxT( "\\n" ) );

 // Here we should have no CR or LF character in line
 // This is not always the case if a multiline text was copied (using a copy/paste
 // function) from a text that uses E.O.L characters that differs from the current
 // EOL format. This is mainly the case under Linux using LF symbol when copying
 // a text from Windows (using CRLF symbol) so we must just remove the extra CR left
 // (or LF left under MacOSX)
 for( unsigned ii = 0; ii < text.Len(); )
 {
 if( text[ii] == 0x0A || text[ii] == 0x0D )
 text.erase( ii, 1 );
 else
 ii++;
 }
 }
 else
 {
 textType = "Label";
 }

 // Local labels must have their spin style inverted for left and right
 int spinStyle = static_cast<int>( aText->GetLabelSpinStyle() );

 if( spinStyle == 0 )
 spinStyle = 2;
 else if( spinStyle == 2 )
 spinStyle = 0;

 m_out->Print( 0, "Text %s %-4d %-4d %-4d %-4d %s %d\n%s\n", textType,
 Iu2Mils( aText->GetPosition().x ), Iu2Mils( aText->GetPosition().y ),
 spinStyle,
 Iu2Mils( aText->GetTextWidth() ),
 italics, Iu2Mils( aText->GetTextThickness() ), TO_UTF8( text ) );
 }
 else if( layer == LAYER_GLOBLABEL || layer == LAYER_HIERLABEL )
 {
 textType = ( layer == LAYER_GLOBLABEL ) ? "GLabel" : "HLabel";

 auto shapeLabelIt = sheetLabelNames.find( aText->GetShape() );
 wxCHECK_RET( shapeLabelIt != sheetLabelNames.end(), "Shape not found in names list" );

 m_out->Print( 0, "Text %s %-4d %-4d %-4d %-4d %s %s %d\n%s\n", textType,
 Iu2Mils( aText->GetPosition().x ), Iu2Mils( aText->GetPosition().y ),
 static_cast<int>( aText->GetLabelSpinStyle() ),
 Iu2Mils( aText->GetTextWidth() ),
 shapeLabelIt->second,
 italics,
 Iu2Mils( aText->GetTextThickness() ), TO_UTF8( text ) );
 }
}


void SCH_LEGACY_PLUGIN::saveBusAlias( std::shared_ptr<BUS_ALIAS> aAlias )
{
 wxCHECK_RET( aAlias != nullptr, "BUS_ALIAS* is NULL" );

 wxString members = boost::algorithm::join( aAlias->Members(), " " );

 m_out->Print( 0, "BusAlias %s %s\n",
 TO_UTF8( aAlias->GetName() ), TO_UTF8( members ) );
}


int SCH_LEGACY_PLUGIN_CACHE::s_modHash = 1; // starts at 1 and goes up
std::mutex SCH_LEGACY_PLUGIN_CACHE::s_modHashMutex;


SCH_LEGACY_PLUGIN_CACHE::SCH_LEGACY_PLUGIN_CACHE( const wxString& aFullPathAndFileName ) :
 m_fileName( aFullPathAndFileName ),
 m_libFileName( aFullPathAndFileName ),
 m_isWritable( true ),
 m_isModified( false )
{
 m_versionMajor = -1;
 m_versionMinor = -1;
 m_libType = SCH_LIB_TYPE::LT_EESCHEMA;
}


SCH_LEGACY_PLUGIN_CACHE::~SCH_LEGACY_PLUGIN_CACHE()
{
 // When the cache is destroyed, all of the alias objects on the heap should be deleted.
 for( auto& symbol : m_symbols )
 delete symbol.second;

 m_symbols.clear();
}


// If m_libFileName is a symlink follow it to the real source file
wxFileName SCH_LEGACY_PLUGIN_CACHE::GetRealFile() const
{
 wxFileName fn( m_libFileName );
 WX_FILENAME::ResolvePossibleSymlinks( fn );
 return fn;
}


wxDateTime SCH_LEGACY_PLUGIN_CACHE::GetLibModificationTime()
{
 wxFileName fn = GetRealFile();

 // update the writable flag while we have a wxFileName, in a network this
 // is possibly quite dynamic anyway.
 m_isWritable = fn.IsFileWritable();

 return fn.GetModificationTime();
}


bool SCH_LEGACY_PLUGIN_CACHE::IsFile( const wxString& aFullPathAndFileName ) const
{
 return m_fileName == aFullPathAndFileName;
}


bool SCH_LEGACY_PLUGIN_CACHE::IsFileChanged() const
{
 wxFileName fn = GetRealFile();

 if( m_fileModTime.IsValid() && fn.IsOk() && fn.FileExists() )
 return fn.GetModificationTime() != m_fileModTime;

 return false;
}


LIB_SYMBOL* SCH_LEGACY_PLUGIN_CACHE::removeSymbol( LIB_SYMBOL* aSymbol )
{
 wxCHECK_MSG( aSymbol != nullptr, nullptr, "NULL pointer cannot be removed from library." );

 LIB_SYMBOL* firstChild = nullptr;
 LIB_SYMBOL_MAP::iterator it = m_symbols.find( aSymbol->GetName() );

 if( it == m_symbols.end() )
 return nullptr;

 // If the entry pointer doesn't match the name it is mapped to in the library, we
 // have done something terribly wrong.
 wxCHECK_MSG( *it->second == aSymbol, nullptr,
 "Pointer mismatch while attempting to remove alias entry <" + aSymbol->GetName() +
 "> from library cache <" + m_libFileName.GetName() + ">." );

 // If the symbol is a root symbol used by other symbols find the first alias that uses
 // the root symbol and make it the new root.
 if( aSymbol->IsRoot() )
 {
 for( auto entry : m_symbols )
 {
 if( entry.second->IsAlias()
 && entry.second->GetParent().lock() == aSymbol->SharedPtr() )
 {
 firstChild = entry.second;
 break;
 }
 }

 if( firstChild )
 {
 for( LIB_ITEM& drawItem : aSymbol->GetDrawItems() )
 {
 if( drawItem.Type() == LIB_FIELD_T )
 {
 LIB_FIELD& field = static_cast<LIB_FIELD&>( drawItem );

 if( firstChild->FindField( field.GetCanonicalName() ) )
 continue;
 }

 LIB_ITEM* newItem = (LIB_ITEM*) drawItem.Clone();
 drawItem.SetParent( firstChild );
 firstChild->AddDrawItem( newItem );
 }

 // Reparent the remaining aliases.
 for( auto entry : m_symbols )
 {
 if( entry.second->IsAlias()
 && entry.second->GetParent().lock() == aSymbol->SharedPtr() )
 entry.second->SetParent( firstChild );
 }
 }
 }

 m_symbols.erase( it );
 delete aSymbol;
 m_isModified = true;
 SCH_LEGACY_PLUGIN_CACHE::IncrementModifyHash();
 return firstChild;
}


void SCH_LEGACY_PLUGIN_CACHE::AddSymbol( const LIB_SYMBOL* aSymbol )
{
 // aSymbol is cloned in SYMBOL_LIB::AddSymbol(). The cache takes ownership of aSymbol.
 wxString name = aSymbol->GetName();
 LIB_SYMBOL_MAP::iterator it = m_symbols.find( name );

 if( it != m_symbols.end() )
 {
 removeSymbol( it->second );
 }

 m_symbols[ name ] = const_cast< LIB_SYMBOL* >( aSymbol );
 m_isModified = true;
 SCH_LEGACY_PLUGIN_CACHE::IncrementModifyHash();
}


void SCH_LEGACY_PLUGIN_CACHE::Load()
{
 if( !m_libFileName.FileExists() )
 {
 THROW_IO_ERROR( wxString::Format( _( "Library file '%s' not found." ),
 m_libFileName.GetFullPath() ) );
 }

 wxCHECK_RET( m_libFileName.IsAbsolute(),
 wxString::Format( "Cannot use relative file paths in legacy plugin to "
 "open library '%s'.", m_libFileName.GetFullPath() ) );

 wxLogTrace( traceSchLegacyPlugin, "Loading legacy symbol file '%s'",
 m_libFileName.GetFullPath() );

 FILE_LINE_READER reader( m_libFileName.GetFullPath() );

 if( !reader.ReadLine() )
 THROW_IO_ERROR( _( "Unexpected end of file." ) );

 const char* line = reader.Line();

 if( !strCompare( "EESchema-LIBRARY Version", line, &line ) )
 {
 // Old .sym files (which are libraries with only one symbol, used to store and reuse shapes)
 // EESchema-LIB Version x.x SYMBOL. They are valid files.
 if( !strCompare( "EESchema-LIB Version", line, &line ) )
 SCH_PARSE_ERROR( "file is not a valid symbol or symbol library file", reader, line );
 }

 m_versionMajor = parseInt( reader, line, &line );

 if( *line != '.' )
 SCH_PARSE_ERROR( "invalid file version formatting in header", reader, line );

 line++;

 m_versionMinor = parseInt( reader, line, &line );

 if( m_versionMajor < 1 || m_versionMinor < 0 || m_versionMinor > 99 )
 SCH_PARSE_ERROR( "invalid file version in header", reader, line );

 // Check if this is a symbol library which is the same as a symbol library but without
 // any alias, documentation, footprint filters, etc.
 if( strCompare( "SYMBOL", line, &line ) )
 {
 // Symbol files add date and time stamp info to the header.
 m_libType = SCH_LIB_TYPE::LT_SYMBOL;

 }
 else
 {
 m_libType = SCH_LIB_TYPE::LT_EESCHEMA;
 }

 while( reader.ReadLine() )
 {
 line = reader.Line();

 if( *line == '#' || isspace( *line ) ) // Skip comments and blank lines.
 continue;

 // Headers where only supported in older library file formats.
 if( m_libType == SCH_LIB_TYPE::LT_EESCHEMA && strCompare( "$HEADER", line ) )
 loadHeader( reader );

 if( strCompare( "DEF", line ) )
 {
 // Read one DEF/ENDDEF symbol entry from library:
 LIB_SYMBOL* symbol = LoadPart( reader, m_versionMajor, m_versionMinor, &m_symbols );

 m_symbols[ symbol->GetName() ] = symbol;
 }
 }

 SCH_LEGACY_PLUGIN_CACHE::IncrementModifyHash();

 // Remember the file modification time of library file when the
 // cache snapshot was made, so that in a networked environment we will
 // reload the cache as needed.
 m_fileModTime = GetLibModificationTime();

 if( USE_OLD_DOC_FILE_FORMAT( m_versionMajor, m_versionMinor ) )
 loadDocs();
}


void SCH_LEGACY_PLUGIN_CACHE::loadDocs()
{
 const char* line;
 wxString text;
 wxString aliasName;
 wxFileName fn = m_libFileName;
 LIB_SYMBOL* symbol = nullptr;;

 fn.SetExt( DOC_EXT );

 // Not all libraries will have a document file.
 if( !fn.FileExists() )
 return;

 if( !fn.IsFileReadable() )
 {
 THROW_IO_ERROR( wxString::Format( _( "Insufficient permissions to read library '%s'." ),
 fn.GetFullPath() ) );
 }

 FILE_LINE_READER reader( fn.GetFullPath() );

 line = reader.ReadLine();

 if( !line )
 THROW_IO_ERROR( _( "symbol document library file is empty" ) );

 if( !strCompare( DOCFILE_IDENT, line, &line ) )
 SCH_PARSE_ERROR( "invalid document library file version formatting in header",
 reader, line );

 while( reader.ReadLine() )
 {
 line = reader.Line();

 if( *line == '#' ) // Comment line.
 continue;

 if( !strCompare( "$CMP", line, &line ) != 0 )
 SCH_PARSE_ERROR( "$CMP command expected", reader, line );

 aliasName = wxString::FromUTF8( line );
 aliasName.Trim();

 LIB_SYMBOL_MAP::iterator it = m_symbols.find( aliasName );

 if( it == m_symbols.end() )
 wxLogWarning( "Symbol '%s' not found in library:\n\n"
 "'%s'\n\nat line %d offset %d", aliasName, fn.GetFullPath(),
 reader.LineNumber(), (int) (line - reader.Line() ) );
 else
 symbol = it->second;

 // Read the current alias associated doc.
 // if the alias does not exist, just skip the description
 // (Can happen if a .dcm is not synchronized with the corresponding .lib file)
 while( reader.ReadLine() )
 {
 line = reader.Line();

 if( !line )
 SCH_PARSE_ERROR( "unexpected end of file", reader, line );

 if( strCompare( "$ENDCMP", line, &line ) )
 break;

 text = FROM_UTF8( line + 2 );
 // Remove spaces at eol, and eol chars:
 text = text.Trim();

 switch( line[0] )
 {
 case 'D':
 if( symbol )
 symbol->SetDescription( text );
 break;

 case 'K':
 if( symbol )
 symbol->SetKeyWords( text );
 break;

 case 'F':
 if( symbol )
 symbol->GetFieldById( DATASHEET_FIELD )->SetText( text );
 break;

 case 0:
 case '\n':
 case '\r':
 case '#':
 // Empty line or commment
 break;

 default:
 SCH_PARSE_ERROR( "expected token in symbol definition", reader, line );
 }
 }
 }
}


void SCH_LEGACY_PLUGIN_CACHE::loadHeader( FILE_LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxASSERT( strCompare( "$HEADER", line, &line ) );

 while( aReader.ReadLine() )
 {
 line = (char*) aReader;

 // The time stamp saved in old library files is not used or saved in the latest
 // library file version.
 if( strCompare( "TimeStamp", line, &line ) )
 continue;
 else if( strCompare( "$ENDHEADER", line, &line ) )
 return;
 }

 SCH_PARSE_ERROR( "$ENDHEADER not found", aReader, line );
}


LIB_SYMBOL* SCH_LEGACY_PLUGIN_CACHE::LoadPart( LINE_READER& aReader, int aMajorVersion,
 int aMinorVersion, LIB_SYMBOL_MAP* aMap )
{
 const char* line = aReader.Line();

 while( *line == '#' )
 aReader.ReadLine();

 if( !strCompare( "DEF", line, &line ) )
 SCH_PARSE_ERROR( "invalid symbol definition", aReader, line );

 long num;
 size_t pos = 4; // "DEF" plus the first space.
 wxString utf8Line = wxString::FromUTF8( line );
 wxStringTokenizer tokens( utf8Line, " \r\n\t" );

 if( tokens.CountTokens() < 8 )
 SCH_PARSE_ERROR( "invalid symbol definition", aReader, line );

 // Read DEF line:
 std::unique_ptr<LIB_SYMBOL> symbol = std::make_unique<LIB_SYMBOL>( wxEmptyString );

 wxString name, prefix, tmp;

 name = tokens.GetNextToken();

 // Don't escape symbol library name if it's already been escaped. Given that the original
 // change to escape the symbol library name has resulted in rescue libraries with escaped
 // names, we will have to live with the consequences.
 if( name == UnescapeString( name ) )
 name = EscapeString( name, CTX_LIBID );

 pos += name.size() + 1;

 prefix = tokens.GetNextToken();
 pos += prefix.size() + 1;

 tmp = tokens.GetNextToken();
 pos += tmp.size() + 1; // NumOfPins, unused.

 tmp = tokens.GetNextToken(); // Pin name offset.

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin offset", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 symbol->SetPinNameOffset( Mils2Iu( (int)num ) );

 tmp = tokens.GetNextToken(); // Show pin numbers.

 if( !( tmp == "Y" || tmp == "N") )
 THROW_PARSE_ERROR( "expected Y or N", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 symbol->SetShowPinNumbers( ( tmp == "N" ) ? false : true );

 tmp = tokens.GetNextToken(); // Show pin names.

 if( !( tmp == "Y" || tmp == "N") )
 THROW_PARSE_ERROR( "expected Y or N", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 symbol->SetShowPinNames( ( tmp == "N" ) ? false : true );

 tmp = tokens.GetNextToken(); // Number of units.

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid unit count", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 symbol->SetUnitCount( (int)num );

 // Ensure m_unitCount is >= 1. Could be read as 0 in old libraries.
 if( symbol->GetUnitCount() < 1 )
 symbol->SetUnitCount( 1 );

 // Copy symbol name and prefix.

 // The root alias is added to the alias list by SetName() which is called by SetText().
 if( name.IsEmpty() )
 {
 symbol->SetName( "~" );
 }
 else if( name[0] != '~' )
 {
 symbol->SetName( name );
 }
 else
 {
 symbol->SetName( name.Right( name.Length() - 1 ) );
 symbol->GetValueField().SetVisible( false );
 }

 // Don't set the library alias, this is determined by the symbol library table.
 symbol->SetLibId( LIB_ID( wxEmptyString, symbol->GetName() ) );

 LIB_FIELD& reference = symbol->GetReferenceField();

 if( prefix == "~" )
 {
 reference.Empty();
 reference.SetVisible( false );
 }
 else
 {
 reference.SetText( prefix );
 }

 // In version 2.2 and earlier, this parameter was a '0' which was just a place holder.
 // The was no concept of interchangeable multiple unit symbols.
 if( LIB_VERSION( aMajorVersion, aMinorVersion ) > 0
 && LIB_VERSION( aMajorVersion, aMinorVersion ) <= LIB_VERSION( 2, 2 ) )
 {
 // Nothing needs to be set since the default setting for symbols with multiple
 // units were never interchangeable. Just parse the 0 an move on.
 tmp = tokens.GetNextToken();
 pos += tmp.size() + 1;
 }
 else
 {
 tmp = tokens.GetNextToken();

 if( tmp == "L" )
 symbol->LockUnits( true );
 else if( tmp == "F" || tmp == "0" )
 symbol->LockUnits( false );
 else
 THROW_PARSE_ERROR( "expected L, F, or 0", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 }

 // There is the optional power symbol flag.
 if( tokens.HasMoreTokens() )
 {
 tmp = tokens.GetNextToken();

 if( tmp == "P" )
 symbol->SetPower();
 else if( tmp == "N" )
 symbol->SetNormal();
 else
 THROW_PARSE_ERROR( "expected P or N", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );
 }

 line = aReader.ReadLine();

 // Read lines until "ENDDEF" is found.
 while( line )
 {
 if( *line == '#' ) // Comment
 ;
 else if( strCompare( "Ti", line, &line ) ) // Modification date is ignored.
 continue;
 else if( strCompare( "ALIAS", line, &line ) ) // Aliases
 loadAliases( symbol, aReader, aMap );
 else if( *line == 'F' ) // Fields
 loadField( symbol, aReader );
 else if( strCompare( "DRAW", line, &line ) ) // Drawing objects.
 loadDrawEntries( symbol, aReader, aMajorVersion, aMinorVersion );
 else if( strCompare( "$FPLIST", line, &line ) ) // Footprint filter list
 loadFootprintFilters( symbol, aReader );
 else if( strCompare( "ENDDEF", line, &line ) ) // End of symbol description
 {
 return symbol.release();
 }

 line = aReader.ReadLine();
 }

 SCH_PARSE_ERROR( "missing ENDDEF", aReader, line );
}


void SCH_LEGACY_PLUGIN_CACHE::loadAliases( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader,
 LIB_SYMBOL_MAP* aMap )
{
 wxString newAliasName;
 const char* line = aReader.Line();

 wxCHECK_RET( strCompare( "ALIAS", line, &line ), "Invalid ALIAS section" );

 wxString utf8Line = wxString::FromUTF8( line );
 wxStringTokenizer tokens( utf8Line, " \r\n\t" );

 // Parse the ALIAS list.
 while( tokens.HasMoreTokens() )
 {
 newAliasName = tokens.GetNextToken();

 if( aMap )
 {
 LIB_SYMBOL* newSymbol = new LIB_SYMBOL( newAliasName );

 // Inherit the parent mandatory field attributes.
 for( int id = 0; id < MANDATORY_FIELDS; ++id )
 {
 LIB_FIELD* field = newSymbol->GetFieldById( id );

 // the MANDATORY_FIELDS are exactly that in RAM.
 wxASSERT( field );

 LIB_FIELD* parentField = aSymbol->GetFieldById( id );

 wxASSERT( parentField );

 *field = *parentField;

 if( id == VALUE_FIELD )
 field->SetText( newAliasName );

 field->SetParent( newSymbol );
 }

 newSymbol->SetParent( aSymbol.get() );

 // This will prevent duplicate aliases.
 (*aMap)[ newSymbol->GetName() ] = newSymbol;
 }
 }
}


void SCH_LEGACY_PLUGIN_CACHE::loadField( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_RET( *line == 'F', "Invalid field line" );

 wxString text;
 int id;

 if( sscanf( line + 1, "%d", &id ) != 1 || id < 0 )
 SCH_PARSE_ERROR( "invalid field ID", aReader, line + 1 );

 LIB_FIELD* field;

 if( id >= 0 && id < MANDATORY_FIELDS )
 {
 field = aSymbol->GetFieldById( id );

 // this will fire only if somebody broke a constructor or editor.
 // MANDATORY_FIELDS are always present in ram resident symbols, no
 // exceptions, and they always have their names set, even fixed fields.
 wxASSERT( field );
 }
 else
 {
 field = new LIB_FIELD( aSymbol.get(), id );
 aSymbol->AddDrawItem( field, false );
 }

 // Skip to the first double quote.
 while( *line != '"' && *line != 0 )
 line++;

 if( *line == 0 )
 SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, line );

 parseQuotedString( text, aReader, line, &line, true );

 // The value field needs to be "special" escaped. The other fields are
 // escaped normally and don't need special handling
 if( id == VALUE_FIELD )
 text = EscapeString( text, CTX_QUOTED_STR );

 // Doctor the *.lib file field which has a "~" in blank fields. New saves will
 // not save like this.
 if( text.size() == 1 && text[0] == '~' )
 field->SetText( wxEmptyString );
 else
 field->SetText( ConvertToNewOverbarNotation( text ) );

 wxPoint pos;

 pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
 pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
 field->SetPosition( pos );

 wxSize textSize;

 textSize.x = textSize.y = Mils2Iu( parseInt( aReader, line, &line ) );
 field->SetTextSize( textSize );

 char textOrient = parseChar( aReader, line, &line );

 if( textOrient == 'H' )
 field->SetTextAngle( TEXT_ANGLE_HORIZ );
 else if( textOrient == 'V' )
 field->SetTextAngle( TEXT_ANGLE_VERT );
 else
 SCH_PARSE_ERROR( "invalid field text orientation parameter", aReader, line );

 char textVisible = parseChar( aReader, line, &line );

 if( textVisible == 'V' )
 field->SetVisible( true );
 else if ( textVisible == 'I' )
 field->SetVisible( false );
 else
 SCH_PARSE_ERROR( "invalid field text visibility parameter", aReader, line );

 // It may be technically correct to use the library version to determine if the field text
 // attributes are present. If anyone knows if that is valid and what version that would be,
 // please change this to test the library version rather than an EOL or the quoted string
 // of the field name.
 if( *line != 0 && *line != '"' )
 {
 char textHJustify = parseChar( aReader, line, &line );

 if( textHJustify == 'C' )
 field->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
 else if( textHJustify == 'L' )
 field->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
 else if( textHJustify == 'R' )
 field->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
 else
 SCH_PARSE_ERROR( "invalid field text horizontal justification", aReader, line );

 wxString attributes;

 parseUnquotedString( attributes, aReader, line, &line );

 size_t attrSize = attributes.size();

 if( !(attrSize == 3 || attrSize == 1 ) )
 SCH_PARSE_ERROR( "invalid field text attributes size", aReader, line );

 switch( (wxChar) attributes[0] )
 {
 case 'C': field->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER ); break;
 case 'B': field->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM ); break;
 case 'T': field->SetVertJustify( GR_TEXT_VJUSTIFY_TOP ); break;
 default: SCH_PARSE_ERROR( "invalid field text vertical justification", aReader, line );
 }

 if( attrSize == 3 )
 {
 wxChar attr_1 = attributes[1];
 wxChar attr_2 = attributes[2];

 if( attr_1 == 'I' ) // Italic
 field->SetItalic( true );
 else if( attr_1 != 'N' ) // No italics is default, check for error.
 SCH_PARSE_ERROR( "invalid field text italic parameter", aReader, line );

 if ( attr_2 == 'B' ) // Bold
 field->SetBold( true );
 else if( attr_2 != 'N' ) // No bold is default, check for error.
 SCH_PARSE_ERROR( "invalid field text bold parameter", aReader, line );
 }
 }

 // Fields in RAM must always have names.
 if( id >= 0 && id < MANDATORY_FIELDS )
 {
 // Fields in RAM must always have names, because we are trying to get
 // less dependent on field ids and more dependent on names.
 // Plus assumptions are made in the field editors.
 field->m_name = TEMPLATE_FIELDNAME::GetDefaultFieldName( id );

 // Ensure the VALUE field = the symbol name (can be not the case
 // with malformed libraries: edited by hand, or converted from other tools)
 if( id == VALUE_FIELD )
 field->SetText( aSymbol->GetName() );
 }
 else
 {
 parseQuotedString( field->m_name, aReader, line, &line, true ); // Optional.
 }
}


void SCH_LEGACY_PLUGIN_CACHE::loadDrawEntries( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader,
 int aMajorVersion,
 int aMinorVersion )
{
 const char* line = aReader.Line();

 wxCHECK_RET( strCompare( "DRAW", line, &line ), "Invalid DRAW section" );

 line = aReader.ReadLine();

 while( line )
 {
 if( strCompare( "ENDDRAW", line, &line ) )
 {
 aSymbol->GetDrawItems().sort();
 return;
 }

 switch( line[0] )
 {
 case 'A': // Arc
 aSymbol->AddDrawItem( loadArc( aSymbol, aReader ), false );
 break;

 case 'C': // Circle
 aSymbol->AddDrawItem( loadCircle( aSymbol, aReader ), false );
 break;

 case 'T': // Text
 aSymbol->AddDrawItem( loadText( aSymbol, aReader, aMajorVersion,
 aMinorVersion ), false );
 break;

 case 'S': // Square
 aSymbol->AddDrawItem( loadRect( aSymbol, aReader ), false );
 break;

 case 'X': // Pin Description
 aSymbol->AddDrawItem( loadPin( aSymbol, aReader ), false );
 break;

 case 'P': // Polyline
 aSymbol->AddDrawItem( loadPolyLine( aSymbol, aReader ), false );
 break;

 case 'B': // Bezier Curves
 aSymbol->AddDrawItem( loadBezier( aSymbol, aReader ), false );
 break;

 case '#': // Comment
 case '\n': // Empty line
 case '\r':
 case 0:
 break;

 default:
 SCH_PARSE_ERROR( "undefined DRAW entry", aReader, line );
 }

 line = aReader.ReadLine();
 }

 SCH_PARSE_ERROR( "File ended prematurely loading symbol draw element.", aReader, line );
}


FILL_T SCH_LEGACY_PLUGIN_CACHE::parseFillMode( LINE_READER& aReader, const char* aLine,
 const char** aOutput )
{
 switch ( parseChar( aReader, aLine, aOutput ) )
 {
 case 'F': return FILL_T::FILLED_SHAPE;
 case 'f': return FILL_T::FILLED_WITH_BG_BODYCOLOR;
 case 'N': return FILL_T::NO_FILL;
 default: SCH_PARSE_ERROR( "invalid fill type, expected f, F, or N", aReader, aLine );
 }

 // This will never be reached but quiets the compiler warnings
 return FILL_T::NO_FILL;
}


LIB_SHAPE* SCH_LEGACY_PLUGIN_CACHE::loadArc( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_MSG( strCompare( "A", line, &line ), nullptr, "Invalid arc definition" );

 LIB_SHAPE* arc = new LIB_SHAPE( aSymbol.get(), SHAPE_T::ARC );

 wxPoint center;

 center.x = Mils2Iu( parseInt( aReader, line, &line ) );
 center.y = Mils2Iu( parseInt( aReader, line, &line ) );

 arc->SetPosition( center );

 int radius = Mils2Iu( parseInt( aReader, line, &line ) );
 int angle1 = parseInt( aReader, line, &line );
 int angle2 = parseInt( aReader, line, &line );

 NORMALIZE_ANGLE_POS( angle1 );
 NORMALIZE_ANGLE_POS( angle2 );

 arc->SetUnit( parseInt( aReader, line, &line ) );
 arc->SetConvert( parseInt( aReader, line, &line ) );
 arc->SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );

 // Old libraries (version <= 2.2) do not have always this FILL MODE param
 // when fill mode is no fill (default mode).
 if( *line != 0 )
 arc->SetFillMode( parseFillMode( aReader, line, &line ) );

 // Actual Coordinates of arc ends are read from file
 if( *line != 0 )
 {
 wxPoint arcStart, arcEnd;

 arcStart.x = Mils2Iu( parseInt( aReader, line, &line ) );
 arcStart.y = Mils2Iu( parseInt( aReader, line, &line ) );
 arcEnd.x = Mils2Iu( parseInt( aReader, line, &line ) );
 arcEnd.y = Mils2Iu( parseInt( aReader, line, &line ) );

 arc->SetStart( arcStart );
 arc->SetEnd( arcEnd );
 }
 else
 {
 // Actual Coordinates of arc ends are not read from file
 // (old library), calculate them
 wxPoint arcStart( radius, 0 );
 wxPoint arcEnd( radius, 0 );

 RotatePoint( &arcStart.x, &arcStart.y, -angle1 );
 arcStart += arc->GetCenter();
 arc->SetStart( arcStart );
 RotatePoint( &arcEnd.x, &arcEnd.y, -angle2 );
 arcEnd += arc->GetCenter();
 arc->SetEnd( arcEnd );
 }

 if( !TRANSFORM().MapAngles( &angle1, &angle2 ) )
 {
 wxPoint temp = arc->GetStart();
 arc->SetStart( arc->GetEnd() );
 arc->SetEnd( temp );
 }

 return arc;
}


LIB_SHAPE* SCH_LEGACY_PLUGIN_CACHE::loadCircle( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_MSG( strCompare( "C", line, &line ), nullptr, "Invalid circle definition" );

 LIB_SHAPE* circle = new LIB_SHAPE( aSymbol.get(), SHAPE_T::CIRCLE );

 wxPoint center;

 center.x = Mils2Iu( parseInt( aReader, line, &line ) );
 center.y = Mils2Iu( parseInt( aReader, line, &line ) );

 int radius = Mils2Iu( parseInt( aReader, line, &line ) );

 circle->SetStart( center );
 circle->SetEnd( wxPoint( center.x + radius, center.y ) );
 circle->SetUnit( parseInt( aReader, line, &line ) );
 circle->SetConvert( parseInt( aReader, line, &line ) );
 circle->SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );

 if( *line != 0 )
 circle->SetFillMode( parseFillMode( aReader, line, &line ) );

 return circle;
}


LIB_TEXT* SCH_LEGACY_PLUGIN_CACHE::loadText( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader,
 int aMajorVersion,
 int aMinorVersion )
{
 const char* line = aReader.Line();

 wxCHECK_MSG( strCompare( "T", line, &line ), nullptr, "Invalid LIB_TEXT definition" );

 LIB_TEXT* text = new LIB_TEXT( aSymbol.get() );

 text->SetTextAngle( (double) parseInt( aReader, line, &line ) );

 wxPoint center;

 center.x = Mils2Iu( parseInt( aReader, line, &line ) );
 center.y = Mils2Iu( parseInt( aReader, line, &line ) );
 text->SetPosition( center );

 wxSize size;

 size.x = size.y = Mils2Iu( parseInt( aReader, line, &line ) );
 text->SetTextSize( size );
 text->SetVisible( !parseInt( aReader, line, &line ) );
 text->SetUnit( parseInt( aReader, line, &line ) );
 text->SetConvert( parseInt( aReader, line, &line ) );

 wxString str;

 // If quoted string loading fails, load as not quoted string.
 if( *line == '"' )
 {
 parseQuotedString( str, aReader, line, &line );

 str = ConvertToNewOverbarNotation( str );
 }
 else
 {
 parseUnquotedString( str, aReader, line, &line );

 // In old libs, "spaces" are replaced by '~' in unquoted strings:
 str.Replace( "~", " " );
 }

 if( !str.IsEmpty() )
 {
 // convert two apostrophes back to double quote
 str.Replace( "''", "\"" );
 }

 text->SetText( str );

 // Here things are murky and not well defined. At some point it appears the format
 // was changed to add text properties. However rather than add the token to the end of
 // the text definition, it was added after the string and no mention if the file
 // verion was bumped or not so this code make break on very old symbol libraries.
 //
 // Update: apparently even in the latest version this can be different so added a test
 // for end of line before checking for the text properties.
 if( LIB_VERSION( aMajorVersion, aMinorVersion ) > 0
 && LIB_VERSION( aMajorVersion, aMinorVersion ) > LIB_VERSION( 2, 0 ) && !is_eol( *line ) )
 {
 if( strCompare( "Italic", line, &line ) )
 text->SetItalic( true );
 else if( !strCompare( "Normal", line, &line ) )
 SCH_PARSE_ERROR( "invalid text stype, expected 'Normal' or 'Italic'", aReader, line );

 if( parseInt( aReader, line, &line ) > 0 )
 text->SetBold( true );

 // Some old libaries version > 2.0 do not have these options for text justification:
 if( !is_eol( *line ) )
 {
 switch( parseChar( aReader, line, &line ) )
 {
 case 'L': text->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT ); break;
 case 'C': text->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER ); break;
 case 'R': text->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT ); break;
 default: SCH_PARSE_ERROR( "invalid horizontal text justication; expected L, C, or R",
 aReader, line );
 }

 switch( parseChar( aReader, line, &line ) )
 {
 case 'T': text->SetVertJustify( GR_TEXT_VJUSTIFY_TOP ); break;
 case 'C': text->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER ); break;
 case 'B': text->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM ); break;
 default: SCH_PARSE_ERROR( "invalid vertical text justication; expected T, C, or B",
 aReader, line );
 }
 }
 }

 return text;
}


LIB_SHAPE* SCH_LEGACY_PLUGIN_CACHE::loadRect( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_MSG( strCompare( "S", line, &line ), nullptr, "Invalid rectangle definition" );

 LIB_SHAPE* rectangle = new LIB_SHAPE( aSymbol.get(), SHAPE_T::RECT );

 wxPoint pos;

 pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
 pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
 rectangle->SetPosition( pos );

 wxPoint end;

 end.x = Mils2Iu( parseInt( aReader, line, &line ) );
 end.y = Mils2Iu( parseInt( aReader, line, &line ) );
 rectangle->SetEnd( end );

 rectangle->SetUnit( parseInt( aReader, line, &line ) );
 rectangle->SetConvert( parseInt( aReader, line, &line ) );
 rectangle->SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );

 if( *line != 0 )
 rectangle->SetFillMode( parseFillMode( aReader, line, &line ) );

 return rectangle;
}


LIB_PIN* SCH_LEGACY_PLUGIN_CACHE::loadPin( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_MSG( strCompare( "X", line, &line ), nullptr, "Invalid LIB_PIN definition" );

 wxString name;
 wxString number;

 size_t pos = 2; // "X" plus ' ' space character.
 wxString tmp;
 wxString utf8Line = wxString::FromUTF8( line );
 wxStringTokenizer tokens( utf8Line, " \r\n\t" );

 if( tokens.CountTokens() < 11 )
 SCH_PARSE_ERROR( "invalid pin definition", aReader, line );

 tmp = tokens.GetNextToken();
 name = tmp;
 pos += tmp.size() + 1;

 tmp = tokens.GetNextToken();
 number = tmp ;
 pos += tmp.size() + 1;

 long num;
 wxPoint position;

 tmp = tokens.GetNextToken();

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin X coordinate", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 position.x = Mils2Iu( (int) num );

 tmp = tokens.GetNextToken();

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin Y coordinate", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 position.y = Mils2Iu( (int) num );

 tmp = tokens.GetNextToken();

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin length", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 int length = Mils2Iu( (int) num );


 tmp = tokens.GetNextToken();

 if( tmp.size() > 1 )
 THROW_PARSE_ERROR( "invalid pin orientation", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 int orientation = tmp[0];

 tmp = tokens.GetNextToken();

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin number text size", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 int numberTextSize = Mils2Iu( (int) num );

 tmp = tokens.GetNextToken();

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin name text size", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 int nameTextSize = Mils2Iu( (int) num );

 tmp = tokens.GetNextToken();

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin unit", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 int unit = (int) num;

 tmp = tokens.GetNextToken();

 if( !tmp.ToLong( &num ) )
 THROW_PARSE_ERROR( "invalid pin alternate body type", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 int convert = (int) num;

 tmp = tokens.GetNextToken();

 if( tmp.size() != 1 )
 THROW_PARSE_ERROR( "invalid pin type", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );

 pos += tmp.size() + 1;
 char type = tmp[0];
 ELECTRICAL_PINTYPE pinType;

 switch( type )
 {
 case 'I': pinType = ELECTRICAL_PINTYPE::PT_INPUT; break;
 case 'O': pinType = ELECTRICAL_PINTYPE::PT_OUTPUT; break;
 case 'B': pinType = ELECTRICAL_PINTYPE::PT_BIDI; break;
 case 'T': pinType = ELECTRICAL_PINTYPE::PT_TRISTATE; break;
 case 'P': pinType = ELECTRICAL_PINTYPE::PT_PASSIVE; break;
 case 'U': pinType = ELECTRICAL_PINTYPE::PT_UNSPECIFIED; break;
 case 'W': pinType = ELECTRICAL_PINTYPE::PT_POWER_IN; break;
 case 'w': pinType = ELECTRICAL_PINTYPE::PT_POWER_OUT; break;
 case 'C': pinType = ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR; break;
 case 'E': pinType = ELECTRICAL_PINTYPE::PT_OPENEMITTER; break;
 case 'N': pinType = ELECTRICAL_PINTYPE::PT_NC; break;
 default:
 THROW_PARSE_ERROR( "unknown pin type", aReader.GetSource(), aReader.Line(),
 aReader.LineNumber(), pos );
 }


 LIB_PIN* pin = new LIB_PIN( aSymbol.get(),
 ConvertToNewOverbarNotation( name ),
 ConvertToNewOverbarNotation( number ),
 orientation,
 pinType,
 length,
 nameTextSize,
 numberTextSize,
  convert,
 position,
 unit );

 // Optional
 if( tokens.HasMoreTokens() ) /* Special Symbol defined */
 {
 tmp = tokens.GetNextToken();

 enum
 {
 INVERTED = 1 << 0,
 CLOCK = 1 << 1,
 LOWLEVEL_IN = 1 << 2,
 LOWLEVEL_OUT = 1 << 3,
 FALLING_EDGE = 1 << 4,
 NONLOGIC = 1 << 5
 };

 int flags = 0;

 for( int j = tmp.size(); j > 0; )
 {
 switch( tmp[--j].GetValue() )
 {
 case '~': break;
 case 'N': pin->SetVisible( false ); break;
 case 'I': flags |= INVERTED; break;
 case 'C': flags |= CLOCK; break;
 case 'L': flags |= LOWLEVEL_IN; break;
 case 'V': flags |= LOWLEVEL_OUT; break;
 case 'F': flags |= FALLING_EDGE; break;
 case 'X': flags |= NONLOGIC; break;
 default: THROW_PARSE_ERROR( "invalid pin attribut", aReader.GetSource(),
 aReader.Line(), aReader.LineNumber(), pos );
 }

 pos += 1;
 }

 switch( flags )
 {
 case 0: pin->SetShape( GRAPHIC_PINSHAPE::LINE ); break;
 case INVERTED: pin->SetShape( GRAPHIC_PINSHAPE::INVERTED ); break;
 case CLOCK: pin->SetShape( GRAPHIC_PINSHAPE::CLOCK ); break;
 case INVERTED | CLOCK: pin->SetShape( GRAPHIC_PINSHAPE::INVERTED_CLOCK ); break;
 case LOWLEVEL_IN: pin->SetShape( GRAPHIC_PINSHAPE::INPUT_LOW ); break;
 case LOWLEVEL_IN | CLOCK: pin->SetShape( GRAPHIC_PINSHAPE::CLOCK_LOW ); break;
 case LOWLEVEL_OUT: pin->SetShape( GRAPHIC_PINSHAPE::OUTPUT_LOW ); break;
 case FALLING_EDGE: pin->SetShape( GRAPHIC_PINSHAPE::FALLING_EDGE_CLOCK ); break;
 case NONLOGIC: pin->SetShape( GRAPHIC_PINSHAPE::NONLOGIC ); break;
 default:
 SCH_PARSE_ERROR( "pin attributes do not define a valid pin shape", aReader, line );
 }
 }

 return pin;
}


LIB_SHAPE* SCH_LEGACY_PLUGIN_CACHE::loadPolyLine( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_MSG( strCompare( "P", line, &line ), nullptr, "Invalid poly definition" );

 LIB_SHAPE* polyLine = new LIB_SHAPE( aSymbol.get(), SHAPE_T::POLY );

 int points = parseInt( aReader, line, &line );
 polyLine->SetUnit( parseInt( aReader, line, &line ) );
 polyLine->SetConvert( parseInt( aReader, line, &line ) );
 polyLine->SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );

 wxPoint pt;

 for( int i = 0; i < points; i++ )
 {
 pt.x = Mils2Iu( parseInt( aReader, line, &line ) );
 pt.y = Mils2Iu( parseInt( aReader, line, &line ) );
 polyLine->AddPoint( pt );
 }

 if( *line != 0 )
 polyLine->SetFillMode( parseFillMode( aReader, line, &line ) );

 return polyLine;
}


LIB_SHAPE* SCH_LEGACY_PLUGIN_CACHE::loadBezier( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_MSG( strCompare( "B", line, &line ), nullptr, "Invalid Bezier definition" );

 int points = parseInt( aReader, line, &line );

 wxCHECK_MSG( points == 4, NULL, "Invalid Bezier curve definition" );

 LIB_SHAPE* bezier = new LIB_SHAPE( aSymbol.get(), SHAPE_T::BEZIER );

 bezier->SetUnit( parseInt( aReader, line, &line ) );
 bezier->SetConvert( parseInt( aReader, line, &line ) );
 bezier->SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );

 bezier->SetStart( wxPoint( Mils2Iu( parseInt( aReader, line, &line ) ),
 Mils2Iu( parseInt( aReader, line, &line ) ) ) );

 bezier->SetBezierC1( wxPoint( Mils2Iu( parseInt( aReader, line, &line ) ),
 Mils2Iu( parseInt( aReader, line, &line ) ) ) );

 bezier->SetBezierC2( wxPoint( Mils2Iu( parseInt( aReader, line, &line ) ),
 Mils2Iu( parseInt( aReader, line, &line ) ) ) );

 bezier->SetEnd( wxPoint( Mils2Iu( parseInt( aReader, line, &line ) ),
 Mils2Iu( parseInt( aReader, line, &line ) ) ) );

 bezier->RebuildBezierToSegmentsPointsList( bezier->GetWidth() );

 if( *line != 0 )
 bezier->SetFillMode( parseFillMode( aReader, line, &line ) );

 return bezier;
}


void SCH_LEGACY_PLUGIN_CACHE::loadFootprintFilters( std::unique_ptr<LIB_SYMBOL>& aSymbol,
 LINE_READER& aReader )
{
 const char* line = aReader.Line();

 wxCHECK_RET( strCompare( "$FPLIST", line, &line ), "Invalid footprint filter list" );

 line = aReader.ReadLine();

 wxArrayString footprintFilters;

 while( line )
 {
 if( strCompare( "$ENDFPLIST", line, &line ) )
 {
 aSymbol->SetFPFilters( footprintFilters );
 return;
 }

 wxString footprint;

 parseUnquotedString( footprint, aReader, line, &line );
 footprintFilters.Add( footprint );
 line = aReader.ReadLine();
 }

 SCH_PARSE_ERROR( "File ended prematurely while loading footprint filters.", aReader, line );
}


void SCH_LEGACY_PLUGIN_CACHE::Save( bool aSaveDocFile )
{
 if( !m_isModified )
 return;

 // Write through symlinks, don't replace them
 wxFileName fn = GetRealFile();

 auto formatter = std::make_unique<FILE_OUTPUTFORMATTER>( fn.GetFullPath() );
 formatter->Print( 0, "%s %d.%d\n", LIBFILE_IDENT, LIB_VERSION_MAJOR, LIB_VERSION_MINOR );
 formatter->Print( 0, "#encoding utf-8\n");

 for( LIB_SYMBOL_MAP::iterator it = m_symbols.begin(); it != m_symbols.end(); it++ )
 {
 if( !it->second->IsRoot() )
 continue;

 SaveSymbol( it->second, *formatter.get(), &m_symbols );
 }

 formatter->Print( 0, "#\n#End Library\n" );
 formatter.reset();

 m_fileModTime = fn.GetModificationTime();
 m_isModified = false;

 if( aSaveDocFile )
 saveDocFile();
}


void SCH_LEGACY_PLUGIN_CACHE::SaveSymbol( LIB_SYMBOL* aSymbol, OUTPUTFORMATTER& aFormatter,
 LIB_SYMBOL_MAP* aMap )
{
 /*
 * NB:
 * Some of the rescue code still uses the legacy format as an intermediary, so we have
 * to keep this code.
 */

 wxCHECK_RET( aSymbol && aSymbol->IsRoot(), "Invalid LIB_SYMBOL pointer." );

 // LIB_ALIAS objects are deprecated but we still need to gather up the derived symbols
 // and save their names for the old file format.
 wxArrayString aliasNames;

 if( aMap )
 {
 for( auto entry : *aMap )
 {
 LIB_SYMBOL* symbol = entry.second;

 if( symbol->IsAlias() && symbol->GetParent().lock() == aSymbol->SharedPtr() )
 aliasNames.Add( symbol->GetName() );
 }
 }

 LIB_FIELD& value = aSymbol->GetValueField();

 // First line: it s a comment (symbol name for readers)
 aFormatter.Print( 0, "#\n# %s\n#\n", TO_UTF8( value.GetText() ) );

 // Save data
 aFormatter.Print( 0, "DEF" );
 aFormatter.Print( 0, " %s", TO_UTF8( value.GetText() ) );

 LIB_FIELD& reference = aSymbol->GetReferenceField();

 if( !reference.GetText().IsEmpty() )
 aFormatter.Print( 0, " %s", TO_UTF8( reference.GetText() ) );
 else
 aFormatter.Print( 0, " ~" );

 aFormatter.Print( 0, " %d %d %c %c %d %c %c\n",
 0, Iu2Mils( aSymbol->GetPinNameOffset() ),
 aSymbol->ShowPinNumbers() ? 'Y' : 'N',
 aSymbol->ShowPinNames() ? 'Y' : 'N',
 aSymbol->GetUnitCount(), aSymbol->UnitsLocked() ? 'L' : 'F',
 aSymbol->IsPower() ? 'P' : 'N' );

 timestamp_t dateModified = aSymbol->GetLastModDate();

 if( dateModified != 0 )
 {
 int sec = dateModified & 63;
 int min = ( dateModified >> 6 ) & 63;
 int hour = ( dateModified >> 12 ) & 31;
 int day = ( dateModified >> 17 ) & 31;
 int mon = ( dateModified >> 22 ) & 15;
 int year = ( dateModified >> 26 ) + 1990;

 aFormatter.Print( 0, "Ti %d/%d/%d %d:%d:%d\n", year, mon, day, hour, min, sec );
 }

 std::vector<LIB_FIELD*> fields;
 aSymbol->GetFields( fields );

 // Mandatory fields:
 // may have their own save policy so there is a separate loop for them.
 // Empty fields are saved, because the user may have set visibility,
 // size and orientation
 for( int i = 0; i < MANDATORY_FIELDS; ++i )
 saveField( fields[i], aFormatter );

 // User defined fields:
 // may have their own save policy so there is a separate loop for them.
 int fieldId = MANDATORY_FIELDS; // really wish this would go away.

 for( unsigned i = MANDATORY_FIELDS; i < fields.size(); ++i )
 {
 // There is no need to save empty fields, i.e. no reason to preserve field
 // names now that fields names come in dynamically through the template
 // fieldnames.
 if( !fields[i]->GetText().IsEmpty() )
 {
 fields[i]->SetId( fieldId++ );
 saveField( fields[i], aFormatter );
 }
 }

 // Save the alias list: a line starting by "ALIAS".
 if( !aliasNames.IsEmpty() )
 {
 aFormatter.Print( 0, "ALIAS" );

 for( unsigned i = 0; i < aliasNames.GetCount(); i++ )
 aFormatter.Print( 0, " %s", TO_UTF8( aliasNames[i] ) );

 aFormatter.Print( 0, "\n" );
 }

 wxArrayString footprints = aSymbol->GetFPFilters();

 // Write the footprint filter list
 if( footprints.GetCount() != 0 )
 {
 aFormatter.Print( 0, "$FPLIST\n" );

 for( unsigned i = 0; i < footprints.GetCount(); i++ )
 aFormatter.Print( 0, " %s\n", TO_UTF8( footprints[i] ) );

 aFormatter.Print( 0, "$ENDFPLIST\n" );
 }

 // Save graphics items (including pins)
 if( !aSymbol->GetDrawItems().empty() )
 {
 // Sort the draw items in order to editing a file editing by hand.
 aSymbol->GetDrawItems().sort();

 aFormatter.Print( 0, "DRAW\n" );

 for( LIB_ITEM& item : aSymbol->GetDrawItems() )
 {
 switch( item.Type() )
 {
 default:
 case LIB_FIELD_T: /* Fields have already been saved above. */ break;
 case LIB_PIN_T: savePin( (LIB_PIN* ) &item, aFormatter ); break;
 case LIB_TEXT_T: saveText( ( LIB_TEXT* ) &item, aFormatter ); break;
 case LIB_SHAPE_T:
 {
 LIB_SHAPE& shape = static_cast<LIB_SHAPE&>( item );

 switch( shape.GetShape() )
 {
 case SHAPE_T::ARC: saveArc( &shape, aFormatter ); break;
 case SHAPE_T::BEZIER: saveBezier( &shape, aFormatter ); break;
 case SHAPE_T::CIRCLE: saveCircle( &shape, aFormatter ); break;
 case SHAPE_T::POLY: savePolyLine( &shape, aFormatter ); break;
 case SHAPE_T::RECT: saveRectangle( &shape, aFormatter ); break;
 default: break;
 }
 }
 }
 }

 aFormatter.Print( 0, "ENDDRAW\n" );
 }

 aFormatter.Print( 0, "ENDDEF\n" );
}


void SCH_LEGACY_PLUGIN_CACHE::saveArc( LIB_SHAPE* aArc, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aArc && aArc->GetShape() == SHAPE_T::ARC, "Invalid ARC object." );

 int x1;
 int x2;

 aArc->CalcArcAngles( x1, x2 );

 if( x1 > 1800 )
 x1 -= 3600;

 if( x2 > 1800 )
 x2 -= 3600;

 aFormatter.Print( 0, "A %d %d %d %d %d %d %d %d %c %d %d %d %d\n",
 Iu2Mils( aArc->GetPosition().x ),
 Iu2Mils( aArc->GetPosition().y ),
 Iu2Mils( aArc->GetRadius() ),
 x1,
 x2,
 aArc->GetUnit(),
 aArc->GetConvert(),
 Iu2Mils( aArc->GetWidth() ),
 fill_tab[ static_cast<int>( aArc->GetFillType() ) - 1 ],
 Iu2Mils( aArc->GetStart().x ),
 Iu2Mils( aArc->GetStart().y ),
 Iu2Mils( aArc->GetEnd().x ),
 Iu2Mils( aArc->GetEnd().y ) );
}


void SCH_LEGACY_PLUGIN_CACHE::saveBezier( LIB_SHAPE* aBezier, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aBezier && aBezier->GetShape() == SHAPE_T::BEZIER, "Invalid BEZIER object." );

 aFormatter.Print( 0, "B %u %d %d %d",
 (unsigned)aBezier->GetBezierPoints().size(),
 aBezier->GetUnit(),
 aBezier->GetConvert(),
 Iu2Mils( aBezier->GetWidth() ) );

 for( const wxPoint& pt : aBezier->GetBezierPoints() )
 aFormatter.Print( 0, " %d %d", Iu2Mils( pt.x ), Iu2Mils( pt.y ) );

 aFormatter.Print( 0, " %c\n", fill_tab[ static_cast<int>( aBezier->GetFillType() ) - 1 ] );
}


void SCH_LEGACY_PLUGIN_CACHE::saveCircle( LIB_SHAPE* aCircle, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aCircle && aCircle->GetShape() == SHAPE_T::CIRCLE, "Invalid CIRCLE object." );

 aFormatter.Print( 0, "C %d %d %d %d %d %d %c\n",
 Iu2Mils( aCircle->GetPosition().x ),
 Iu2Mils( aCircle->GetPosition().y ),
 Iu2Mils( aCircle->GetRadius() ),
 aCircle->GetUnit(),
 aCircle->GetConvert(),
 Iu2Mils( aCircle->GetWidth() ),
 fill_tab[ static_cast<int>( aCircle->GetFillType() ) - 1 ] );
}


void SCH_LEGACY_PLUGIN_CACHE::saveField( const LIB_FIELD* aField, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aField && aField->Type() == LIB_FIELD_T, "Invalid LIB_FIELD object." );

 int hjustify, vjustify;
 int id = aField->GetId();
 wxString text = aField->GetText();

 hjustify = 'C';

 if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_LEFT )
 hjustify = 'L';
 else if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_RIGHT )
 hjustify = 'R';

 vjustify = 'C';

 if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_BOTTOM )
 vjustify = 'B';
 else if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_TOP )
 vjustify = 'T';

 aFormatter.Print( 0, "F%d %s %d %d %d %c %c %c %c%c%c",
 id,
 EscapedUTF8( text ).c_str(), // wraps in quotes
 Iu2Mils( aField->GetTextPos().x ),
 Iu2Mils( aField->GetTextPos().y ),
 Iu2Mils( aField->GetTextWidth() ),
 aField->GetTextAngle() == 0 ? 'H' : 'V',
 aField->IsVisible() ? 'V' : 'I',
 hjustify, vjustify,
 aField->IsItalic() ? 'I' : 'N',
 aField->IsBold() ? 'B' : 'N' );

 /* Save field name, if necessary
 * Field name is saved only if it is not the default name.
 * Just because default name depends on the language and can change from
 * a country to another
 */
 wxString defName = TEMPLATE_FIELDNAME::GetDefaultFieldName( id );

 if( id >= MANDATORY_FIELDS && !aField->m_name.IsEmpty() && aField->m_name != defName )
 aFormatter.Print( 0, " %s", EscapedUTF8( aField->m_name ).c_str() );

 aFormatter.Print( 0, "\n" );
}


void SCH_LEGACY_PLUGIN_CACHE::savePin( const LIB_PIN* aPin, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aPin && aPin->Type() == LIB_PIN_T, "Invalid LIB_PIN object." );

 int Etype;

 switch( aPin->GetType() )
 {
 default:
 case ELECTRICAL_PINTYPE::PT_INPUT: Etype = 'I'; break;
 case ELECTRICAL_PINTYPE::PT_OUTPUT: Etype = 'O'; break;
 case ELECTRICAL_PINTYPE::PT_BIDI: Etype = 'B'; break;
 case ELECTRICAL_PINTYPE::PT_TRISTATE: Etype = 'T'; break;
 case ELECTRICAL_PINTYPE::PT_PASSIVE: Etype = 'P'; break;
 case ELECTRICAL_PINTYPE::PT_UNSPECIFIED: Etype = 'U'; break;
 case ELECTRICAL_PINTYPE::PT_POWER_IN: Etype = 'W'; break;
 case ELECTRICAL_PINTYPE::PT_POWER_OUT: Etype = 'w'; break;
 case ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR: Etype = 'C'; break;
 case ELECTRICAL_PINTYPE::PT_OPENEMITTER: Etype = 'E'; break;
 case ELECTRICAL_PINTYPE::PT_NC: Etype = 'N'; break;
 }

 if( !aPin->GetName().IsEmpty() )
 aFormatter.Print( 0, "X %s", TO_UTF8( aPin->GetName() ) );
 else
 aFormatter.Print( 0, "X ~" );

 aFormatter.Print( 0, " %s %d %d %d %c %d %d %d %d %c",
 aPin->GetNumber().IsEmpty() ? "~" : TO_UTF8( aPin->GetNumber() ),
 Iu2Mils( aPin->GetPosition().x ),
 Iu2Mils( aPin->GetPosition().y ),
 Iu2Mils( (int) aPin->GetLength() ),
 (int) aPin->GetOrientation(),
 Iu2Mils( aPin->GetNumberTextSize() ),
 Iu2Mils( aPin->GetNameTextSize() ),
 aPin->GetUnit(),
 aPin->GetConvert(),
 Etype );

 if( aPin->GetShape() != GRAPHIC_PINSHAPE::LINE || !aPin->IsVisible() )
 aFormatter.Print( 0, " " );

 if( !aPin->IsVisible() )
 aFormatter.Print( 0, "N" );

 switch( aPin->GetShape() )
 {
 case GRAPHIC_PINSHAPE::LINE: break;
 case GRAPHIC_PINSHAPE::INVERTED: aFormatter.Print( 0, "I" ); break;
 case GRAPHIC_PINSHAPE::CLOCK: aFormatter.Print( 0, "C" ); break;
 case GRAPHIC_PINSHAPE::INVERTED_CLOCK: aFormatter.Print( 0, "IC" ); break;
 case GRAPHIC_PINSHAPE::INPUT_LOW: aFormatter.Print( 0, "L" ); break;
 case GRAPHIC_PINSHAPE::CLOCK_LOW: aFormatter.Print( 0, "CL" ); break;
 case GRAPHIC_PINSHAPE::OUTPUT_LOW: aFormatter.Print( 0, "V" ); break;
 case GRAPHIC_PINSHAPE::FALLING_EDGE_CLOCK: aFormatter.Print( 0, "F" ); break;
 case GRAPHIC_PINSHAPE::NONLOGIC: aFormatter.Print( 0, "X" ); break;
 default: wxFAIL_MSG( "Invalid pin shape" );
 }

 aFormatter.Print( 0, "\n" );

 const_cast<LIB_PIN*>( aPin )->ClearFlags( IS_CHANGED );
}


void SCH_LEGACY_PLUGIN_CACHE::savePolyLine( LIB_SHAPE* aPolyLine, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aPolyLine && aPolyLine->GetShape() == SHAPE_T::POLY, "Invalid POLY object." );

 aFormatter.Print( 0, "P %d %d %d %d",
 (int) aPolyLine->GetPolyShape().Outline( 0 ).GetPointCount(),
 aPolyLine->GetUnit(),
 aPolyLine->GetConvert(),
 Iu2Mils( aPolyLine->GetWidth() ) );

 for( const VECTOR2I& pt : aPolyLine->GetPolyShape().Outline( 0 ).CPoints() )
 aFormatter.Print( 0, " %d %d", Iu2Mils( pt.x ), Iu2Mils( pt.y ) );

 aFormatter.Print( 0, " %c\n", fill_tab[ static_cast<int>( aPolyLine->GetFillType() ) - 1 ] );
}


void SCH_LEGACY_PLUGIN_CACHE::saveRectangle( LIB_SHAPE* aRectangle, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aRectangle && aRectangle->GetShape() == SHAPE_T::RECT, "Invalid RECT object." );

 aFormatter.Print( 0, "S %d %d %d %d %d %d %d %c\n",
 Iu2Mils( aRectangle->GetPosition().x ),
 Iu2Mils( aRectangle->GetPosition().y ),
 Iu2Mils( aRectangle->GetEnd().x ),
 Iu2Mils( aRectangle->GetEnd().y ),
 aRectangle->GetUnit(),
 aRectangle->GetConvert(),
 Iu2Mils( aRectangle->GetWidth() ),
 fill_tab[ static_cast<int>( aRectangle->GetFillType() ) - 1 ] );
}


void SCH_LEGACY_PLUGIN_CACHE::saveText( const LIB_TEXT* aText, OUTPUTFORMATTER& aFormatter )
{
 wxCHECK_RET( aText && aText->Type() == LIB_TEXT_T, "Invalid LIB_TEXT object." );

 wxString text = aText->GetText();

 if( text.Contains( wxT( " " ) ) || text.Contains( wxT( "~" ) ) || text.Contains( wxT( "\"" ) ) )
 {
 // convert double quote to similar-looking two apostrophes
 text.Replace( wxT( "\"" ), wxT( "''" ) );
 text = wxT( "\"" ) + text + wxT( "\"" );
 }

 aFormatter.Print( 0, "T %g %d %d %d %d %d %d %s", aText->GetTextAngle(),
 Iu2Mils( aText->GetTextPos().x ), Iu2Mils( aText->GetTextPos().y ),
 Iu2Mils( aText->GetTextWidth() ), !aText->IsVisible(),
 aText->GetUnit(), aText->GetConvert(), TO_UTF8( text ) );

 aFormatter.Print( 0, " %s %d", aText->IsItalic() ? "Italic" : "Normal", aText->IsBold() );

 char hjustify = 'C';

 if( aText->GetHorizJustify() == GR_TEXT_HJUSTIFY_LEFT )
 hjustify = 'L';
 else if( aText->GetHorizJustify() == GR_TEXT_HJUSTIFY_RIGHT )
 hjustify = 'R';

 char vjustify = 'C';

 if( aText->GetVertJustify() == GR_TEXT_VJUSTIFY_BOTTOM )
 vjustify = 'B';
 else if( aText->GetVertJustify() == GR_TEXT_VJUSTIFY_TOP )
 vjustify = 'T';

 aFormatter.Print( 0, " %c %c\n", hjustify, vjustify );
}


void SCH_LEGACY_PLUGIN_CACHE::saveDocFile()
{
 /*
 * NB:
 * Some of the rescue code still uses the legacy format as an intermediary, so we have
 * to keep this code.
 */

 wxFileName fileName = m_libFileName;

 fileName.SetExt( DOC_EXT );
 FILE_OUTPUTFORMATTER formatter( fileName.GetFullPath() );

 formatter.Print( 0, "%s\n", DOCFILE_IDENT );

 for( LIB_SYMBOL_MAP::iterator it = m_symbols.begin(); it != m_symbols.end(); ++it )
 {
 wxString description = it->second->GetDescription();
 wxString keyWords = it->second->GetKeyWords();
 wxString docFileName = it->second->GetDatasheetField().GetText();

 if( description.IsEmpty() && keyWords.IsEmpty() && docFileName.IsEmpty() )
 continue;

 formatter.Print( 0, "#\n$CMP %s\n", TO_UTF8( it->second->GetName() ) );

 if( !description.IsEmpty() )
 formatter.Print( 0, "D %s\n", TO_UTF8( description ) );

 if( !keyWords.IsEmpty() )
 formatter.Print( 0, "K %s\n", TO_UTF8( keyWords ) );

 if( !docFileName.IsEmpty() )
 formatter.Print( 0, "F %s\n", TO_UTF8( docFileName ) );

 formatter.Print( 0, "$ENDCMP\n" );
 }

 formatter.Print( 0, "#\n#End Doc Library\n" );
}


void SCH_LEGACY_PLUGIN_CACHE::DeleteSymbol( const wxString& aSymbolName )
{
 LIB_SYMBOL_MAP::iterator it = m_symbols.find( aSymbolName );

 if( it == m_symbols.end() )
 THROW_IO_ERROR( wxString::Format( _( "library %s does not contain a symbol named %s" ),
 m_libFileName.GetFullName(), aSymbolName ) );

 LIB_SYMBOL* symbol = it->second;

 if( symbol->IsRoot() )
 {
 LIB_SYMBOL* rootSymbol = symbol;

 // Remove the root symbol and all its children.
 m_symbols.erase( it );

 LIB_SYMBOL_MAP::iterator it1 = m_symbols.begin();

 while( it1 != m_symbols.end() )
 {
 if( it1->second->IsAlias()
 && it1->second->GetParent().lock() == rootSymbol->SharedPtr() )
 {
 delete it1->second;
 it1 = m_symbols.erase( it1 );
 }
 else
 {
 it1++;
 }
 }

 delete rootSymbol;
 }
 else
 {
 // Just remove the alias.
 m_symbols.erase( it );
 delete symbol;
 }

 SCH_LEGACY_PLUGIN_CACHE::IncrementModifyHash();
 m_isModified = true;
}


void SCH_LEGACY_PLUGIN::cacheLib( const wxString& aLibraryFileName, const PROPERTIES* aProperties )
{
 if( !m_cache || !m_cache->IsFile( aLibraryFileName ) || m_cache->IsFileChanged() )
 {
 // a spectacular episode in memory management:
 delete m_cache;
 m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryFileName );

 // Because m_cache is rebuilt, increment SYMBOL_LIBS::s_modify_generation
 // to modify the hash value that indicate symbol to symbol links
 // must be updated.
 SYMBOL_LIBS::IncrementModifyGeneration();

 if( !isBuffering( aProperties ) )
 m_cache->Load();
 }
}


bool SCH_LEGACY_PLUGIN::writeDocFile( const PROPERTIES* aProperties )
{
 std::string propName( SCH_LEGACY_PLUGIN::PropNoDocFile );

 if( aProperties && aProperties->find( propName ) != aProperties->end() )
 return false;

 return true;
}


bool SCH_LEGACY_PLUGIN::isBuffering( const PROPERTIES* aProperties )
{
 return ( aProperties && aProperties->Exists( SCH_LEGACY_PLUGIN::PropBuffering ) );
}


int SCH_LEGACY_PLUGIN::GetModifyHash() const
{
 if( m_cache )
 return SCH_LEGACY_PLUGIN_CACHE::GetModifyHash();

 // If the cache hasn't been loaded, it hasn't been modified.
 return 0;
}


void SCH_LEGACY_PLUGIN::EnumerateSymbolLib( wxArrayString& aSymbolNameList,
 const wxString& aLibraryPath,
 const PROPERTIES* aProperties )
{
 LOCALE_IO toggle; // toggles on, then off, the C locale.

 bool powerSymbolsOnly = ( aProperties &&
 aProperties->find( SYMBOL_LIB_TABLE::PropPowerSymsOnly ) != aProperties->end() );

 cacheLib( aLibraryPath, aProperties );

 const LIB_SYMBOL_MAP& symbols = m_cache->m_symbols;

 for( LIB_SYMBOL_MAP::const_iterator it = symbols.begin(); it != symbols.end(); ++it )
 {
 if( !powerSymbolsOnly || it->second->IsPower() )
 aSymbolNameList.Add( it->first );
 }
}


void SCH_LEGACY_PLUGIN::EnumerateSymbolLib( std::vector<LIB_SYMBOL*>& aSymbolList,
 const wxString& aLibraryPath,
 const PROPERTIES* aProperties )
{
 LOCALE_IO toggle; // toggles on, then off, the C locale.

 bool powerSymbolsOnly = ( aProperties &&
 aProperties->find( SYMBOL_LIB_TABLE::PropPowerSymsOnly ) != aProperties->end() );

 cacheLib( aLibraryPath, aProperties );

 const LIB_SYMBOL_MAP& symbols = m_cache->m_symbols;

 for( LIB_SYMBOL_MAP::const_iterator it = symbols.begin(); it != symbols.end(); ++it )
 {
 if( !powerSymbolsOnly || it->second->IsPower() )
 aSymbolList.push_back( it->second );
 }
}


LIB_SYMBOL* SCH_LEGACY_PLUGIN::LoadSymbol( const wxString& aLibraryPath,
 const wxString& aSymbolName,
 const PROPERTIES* aProperties )
{
 LOCALE_IO toggle; // toggles on, then off, the C locale.

 cacheLib( aLibraryPath, aProperties );

 LIB_SYMBOL_MAP::const_iterator it = m_cache->m_symbols.find( aSymbolName );

 if( it == m_cache->m_symbols.end() )
 return nullptr;

 return it->second;
}


void SCH_LEGACY_PLUGIN::SaveSymbol( const wxString& aLibraryPath, const LIB_SYMBOL* aSymbol,
 const PROPERTIES* aProperties )
{
 LOCALE_IO toggle; // toggles on, then off, the C locale.

 cacheLib( aLibraryPath, aProperties );

 m_cache->AddSymbol( aSymbol );

 if( !isBuffering( aProperties ) )
 m_cache->Save( writeDocFile( aProperties ) );
}


void SCH_LEGACY_PLUGIN::DeleteSymbol( const wxString& aLibraryPath, const wxString& aSymbolName,
 const PROPERTIES* aProperties )
{
 LOCALE_IO toggle; // toggles on, then off, the C locale.

 cacheLib( aLibraryPath, aProperties );

 m_cache->DeleteSymbol( aSymbolName );

 if( !isBuffering( aProperties ) )
 m_cache->Save( writeDocFile( aProperties ) );
}


void SCH_LEGACY_PLUGIN::CreateSymbolLib( const wxString& aLibraryPath,
 const PROPERTIES* aProperties )
{
 if( wxFileExists( aLibraryPath ) )
 {
 THROW_IO_ERROR( wxString::Format( _( "Symbol library '%s' already exists." ),
 aLibraryPath.GetData() ) );
 }

 LOCALE_IO toggle;

 delete m_cache;
 m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryPath );
 m_cache->SetModified();
 m_cache->Save( writeDocFile( aProperties ) );
 m_cache->Load(); // update m_writable and m_mod_time
}


bool SCH_LEGACY_PLUGIN::DeleteSymbolLib( const wxString& aLibraryPath,
 const PROPERTIES* aProperties )
{
 wxFileName fn = aLibraryPath;

 if( !fn.FileExists() )
 return false;

 // Some of the more elaborate wxRemoveFile() crap puts up its own wxLog dialog
 // we don't want that. we want bare metal portability with no UI here.
 if( wxRemove( aLibraryPath ) )
 {
 THROW_IO_ERROR( wxString::Format( _( "Symbol library '%s' cannot be deleted." ),
 aLibraryPath.GetData() ) );
 }

 if( m_cache && m_cache->IsFile( aLibraryPath ) )
 {
 delete m_cache;
 m_cache = nullptr;
 }

 return true;
}


void SCH_LEGACY_PLUGIN::SaveLibrary( const wxString& aLibraryPath, const PROPERTIES* aProperties )
{
 if( !m_cache )
 m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryPath );

 wxString oldFileName = m_cache->GetFileName();

 if( !m_cache->IsFile( aLibraryPath ) )
 {
 m_cache->SetFileName( aLibraryPath );
 }

 // This is a forced save.
 m_cache->SetModified();
 m_cache->Save( writeDocFile( aProperties ) );
 m_cache->SetFileName( oldFileName );
}


bool SCH_LEGACY_PLUGIN::CheckHeader( const wxString& aFileName )
{
 // Open file and check first line
 wxTextFile tempFile;

 tempFile.Open( aFileName );
 wxString firstline;
 // read the first line
 firstline = tempFile.GetFirstLine();
 tempFile.Close();

 return firstline.StartsWith( "EESchema" );
}


bool SCH_LEGACY_PLUGIN::IsSymbolLibWritable( const wxString& aLibraryPath )
{
 // Writing legacy symbol libraries is deprecated.
 return false;
}


LIB_SYMBOL* SCH_LEGACY_PLUGIN::ParsePart( LINE_READER& reader, int aMajorVersion,
 int aMinorVersion )
{
 return SCH_LEGACY_PLUGIN_CACHE::LoadPart( reader, aMajorVersion, aMinorVersion );
}


void SCH_LEGACY_PLUGIN::FormatPart( LIB_SYMBOL* symbol, OUTPUTFORMATTER & formatter )
{
 SCH_LEGACY_PLUGIN_CACHE::SaveSymbol( symbol, formatter );
}



const char* SCH_LEGACY_PLUGIN::PropBuffering = "buffering";
const char* SCH_LEGACY_PLUGIN::PropNoDocFile = "no_doc_file";