specctra.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2007-2013 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2007-2023 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef SPECCTRA_H_
#define SPECCTRA_H_
 
 
// see http://www.boost.org/libs/ptr_container/doc/ptr_sequence_adapter.html
#include <boost/ptr_container/ptr_vector.hpp>
 
// see http://www.boost.org/libs/ptr_container/doc/ptr_set.html
#include <boost/ptr_container/ptr_set.hpp>
 
#include <specctra_import_export/specctra_lexer.h>
 
#include <memory>
#include <geometry/shape_poly_set.h>
 
// all outside the DSN namespace:
class BOARD;
class PCB_TRACK;
class PCB_VIA;
class NETCLASS;
class FOOTPRINT;
class SHAPE_POLY_SET;
 
typedef DSN::T DSN_T;
 
 
void ExportBoardToSpecctraFile( BOARD* aBoard, const wxString& aFullFilename );
 
 
namespace DSN {
 
 
class SPECCTRA_DB;
 
 
const char* GetTokenText( T aTok );
 
 
struct POINT
{
 double x;
 double y;
 
 POINT() { x=0.0; y=0.0; }
 
 POINT( double aX, double aY ) :
 x(aX), y(aY)
 {
 }
 
 bool operator==( const POINT& other ) const
 {
 return x==other.x && y==other.y;
 }
 
 bool operator!=( const POINT& other ) const
 {
 return !( *this == other );
 }
 
 POINT& operator+=( const POINT& other )
 {
 x += other.x;
 y += other.y;
 return *this;
 }
 
 POINT& operator=( const POINT& other )
 {
 x = other.x;
 y = other.y;
 return *this;
 }
 
 void FixNegativeZero()
 {
 if( x == -0.0 )
 x = 0.0;
 
 if( y == -0.0 )
 y = 0.0;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) const
 {
 out->Print( nestLevel, " %.6g %.6g", x, y );
 }
};
 
typedef std::vector<std::string> STRINGS;
typedef std::vector<POINT> POINTS;
 
struct PROPERTY
{
 std::string name;
 std::string value;
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) const
 {
 const char* quoteName = out->GetQuoteChar( name.c_str() );
 const char* quoteValue = out->GetQuoteChar( value.c_str() );
 
 out->Print( nestLevel, "(%s%s%s %s%s%s)\n",
 quoteName, name.c_str(), quoteName,
 quoteValue, value.c_str(), quoteValue );
 }
};
 
typedef std::vector<PROPERTY> PROPERTIES;
 
 
class UNIT_RES;
 
class ELEM
{
public:
 
 ELEM( DSN_T aType, ELEM* aParent = nullptr );
 
 virtual ~ELEM();
 
 DSN_T Type() const { return type; }
 
 const char* Name() const;
 
 
 virtual UNIT_RES* GetUnits() const;
 
 virtual void Format( OUTPUTFORMATTER* out, int nestLevel );
 
 virtual void FormatContents( OUTPUTFORMATTER* out, int nestLevel )
 {
 // overridden in ELEM_HOLDER
 }
 
 void SetParent( ELEM* aParent )
 {
 parent = aParent;
 }
 
protected:
 
 std::string makeHash()
 {
 sf.Clear();
 FormatContents( &sf, 0 );
  sf.StripUseless();
 
 return sf.GetString();
 }
 
 // avoid creating this for every compare, make static.
 static STRING_FORMATTER sf;
 
 DSN_T type;
 ELEM* parent;
 
private:
 friend class SPECCTRA_DB;
};
 
 
class ELEM_HOLDER : public ELEM
{
public:
 
 ELEM_HOLDER( DSN_T aType, ELEM* aParent = nullptr ) :
 ELEM( aType, aParent )
 {
 }
 
 virtual void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override;
 
 
 //-----< list operations >--------------------------------------------
 
 int FindElem( DSN_T aType, int instanceNum = 0 );
 
 
 int Length() const
 {
 return kids.size();
 }
 
 void Append( ELEM* aElem )
 {
 kids.push_back( aElem );
 }
 
 ELEM* Replace( int aIndex, ELEM* aElem )
 {
 ELEM_ARRAY::auto_type ret = kids.replace( aIndex, aElem );
 return ret.release();
 }
 
 ELEM* Remove( int aIndex )
 {
 ELEM_ARRAY::auto_type ret = kids.release( kids.begin() + aIndex );
 return ret.release();
 }
 
 void Insert( int aIndex, ELEM* aElem ) { kids.insert( kids.begin() + aIndex, aElem ); }
 
 ELEM* At( int aIndex ) const
 {
 // we have varying sized objects and are using polymorphism, so we
 // must return a pointer not a reference.
 return (ELEM*) &kids[aIndex];
 }
 
 ELEM* operator[]( int aIndex ) const
 {
 return At( aIndex );
 }
 
 void Delete( int aIndex ) { kids.erase( kids.begin() + aIndex ); }
 
private:
 friend class SPECCTRA_DB;
 
 typedef boost::ptr_vector<ELEM> ELEM_ARRAY;
 
 ELEM_ARRAY kids; 
};
 
 
class PARSER : public ELEM
{
public:
 
 PARSER( ELEM* aParent );
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override;
 
private:
 friend class SPECCTRA_DB;
 
 char string_quote;
 bool space_in_quoted_tokens;
 bool case_sensitive;
 bool wires_include_testpoint;
 bool routes_include_testpoint;
 bool routes_include_guides;
 bool routes_include_image_conductor;
 bool via_rotate_first;
 bool generated_by_freeroute;
 
 STRINGS constants;
 
 std::string host_cad;
 std::string host_version;
};
 
 
class UNIT_RES : public ELEM
{
public:
 
 static UNIT_RES Default;
 
 UNIT_RES( ELEM* aParent, DSN_T aType ) :
 ELEM( aType, aParent )
 {
 units = T_inch;
 value = 2540000;
 }
 
 DSN_T GetEngUnits() const { return units; }
 int GetValue() const { return value; }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( type == T_unit )
 out->Print( nestLevel, "(%s %s)\n", Name(), GetTokenText( units ) );
 else // T_resolution
 out->Print( nestLevel, "(%s %s %d)\n", Name(), GetTokenText( units ), value );
 }
 
private:
 friend class SPECCTRA_DB;
 
 DSN_T units;
 int value;
};
 
 
class RECTANGLE : public ELEM
{
public:
 
 RECTANGLE( ELEM* aParent ) :
 ELEM( T_rect, aParent )
 {
 }
 
 void SetLayerId( const char* aLayerId )
 {
 layer_id = aLayerId;
 }
 
 void SetCorners( const POINT& aPoint0, const POINT& aPoint1 )
 {
 point0 = aPoint0;
 point0.FixNegativeZero();
 
 point1 = aPoint1;
 point1.FixNegativeZero();
 }
 
 POINT GetOrigin() { return point0; }
 POINT GetEnd() { return point1; }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* newline = nestLevel ? "\n" : "";
 
 const char* quote = out->GetQuoteChar( layer_id.c_str() );
 
 out->Print( nestLevel, "(%s %s%s%s %.6g %.6g %.6g %.6g)%s",
 Name(),
 quote, layer_id.c_str(), quote,
 point0.x, point0.y,
 point1.x, point1.y,
 newline );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string layer_id;
 
 POINT point0; 
 POINT point1;
};
 
 
class RULE : public ELEM
{
public:
 
 RULE( ELEM* aParent, DSN_T aType ) :
 ELEM( aType, aParent )
 {
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s", Name() );
 
 bool singleLine;
 
 if( m_rules.size() == 1 )
 {
 singleLine = true;
 out->Print( 0, " %s)", m_rules.begin()->c_str() );
 }
 
 else
 {
 out->Print( 0, "\n" );
 singleLine = false;
 
 for( STRINGS::const_iterator i = m_rules.begin(); i != m_rules.end(); ++i )
 out->Print( nestLevel+1, "%s\n", i->c_str() );
 
 out->Print( nestLevel, ")" );
 }
 
 if( nestLevel || !singleLine )
 out->Print( 0, "\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 STRINGS m_rules; 
};
 
 
class LAYER_RULE : public ELEM
{
public:
 
 LAYER_RULE( ELEM* aParent ) :
 ELEM( T_layer_rule, aParent )
 {
 m_rule = nullptr;
 }
 
 ~LAYER_RULE()
 {
 delete m_rule;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s", Name() );
 
 for( STRINGS::const_iterator i = m_layer_ids.begin(); i != m_layer_ids.end(); ++i )
 {
 const char* quote = out->GetQuoteChar( i->c_str() );
 out->Print( 0, " %s%s%s", quote, i->c_str(), quote );
 }
 
 out->Print( 0 , "\n" );
 
 if( m_rule )
 m_rule->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 STRINGS m_layer_ids;
 RULE* m_rule;
};
 
 
typedef boost::ptr_vector<LAYER_RULE> LAYER_RULES;
 
 
class PATH : public ELEM
{
public:
 
 PATH( ELEM* aParent, DSN_T aType = T_path ) :
 ELEM( aType, aParent )
 {
 aperture_width = 0.0;
 aperture_type = T_round;
 }
 
 void AppendPoint( const POINT& aPoint )
 {
 points.push_back( aPoint );
 }
 
 POINTS& GetPoints() {return points; }
 
 void SetLayerId( const char* aLayerId )
 {
 layer_id = aLayerId;
 }
 
 void SetAperture( double aWidth )
 {
 aperture_width = aWidth;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* newline = nestLevel ? "\n" : "";
 
 const char* quote = out->GetQuoteChar( layer_id.c_str() );
 
 const int RIGHTMARGIN = 70;
 int perLine = out->Print( nestLevel, "(%s %s%s%s %.6g",
 Name(),
 quote, layer_id.c_str(), quote,
 aperture_width );
 
 int wrapNest = std::max( nestLevel+1, 6 );
 
 for( unsigned i = 0; i < points.size(); ++i )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( wrapNest, "%s", "" );
 }
 else
 {
 perLine += out->Print( 0, " " );
 }
 
 perLine += out->Print( 0, "%.6g %.6g", points[i].x, points[i].y );
 }
 
 if( aperture_type == T_square )
 {
 out->Print( 0, "(aperture_type square)" );
 }
 
 out->Print( 0, ")%s", newline );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string layer_id;
 double aperture_width;
 
 POINTS points;
 DSN_T aperture_type;
};
 
typedef boost::ptr_vector<PATH> PATHS;
 
 
class BOUNDARY : public ELEM
{
public:
 
 BOUNDARY( ELEM* aParent, DSN_T aType = T_boundary ) :
 ELEM( aType, aParent )
 {
 rectangle = nullptr;
 }
 
 ~BOUNDARY()
 {
 delete rectangle;
 }
 
 void GetCorners( std::vector<double>& aBuffer )
 {
 if( rectangle )
 {
 aBuffer.push_back( rectangle->GetOrigin().x );
 aBuffer.push_back( rectangle->GetOrigin().y );
 
 aBuffer.push_back( rectangle->GetOrigin().x );
 aBuffer.push_back( rectangle->GetEnd().y );
 
 aBuffer.push_back( rectangle->GetEnd().x );
 aBuffer.push_back( rectangle->GetEnd().y );
 
 aBuffer.push_back( rectangle->GetEnd().x );
 aBuffer.push_back( rectangle->GetOrigin().y );
 }
 else
 {
 for( PATHS::iterator i=paths.begin(); i!=paths.end(); ++i )
 {
 POINTS& plist = i->GetPoints();
 
 for( unsigned jj = 0; jj < plist.size(); jj++ )
 {
 aBuffer.push_back( plist[jj].x );
 aBuffer.push_back( plist[jj].y );
 }
 }
 }
 }
 
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s\n", Name() );
 
 if( rectangle )
 rectangle->Format( out, nestLevel+1 );
 else
 {
 for( PATHS::iterator i = paths.begin(); i != paths.end(); ++i )
 i->Format( out, nestLevel+1 );
 }
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 // only one or the other of these two is used, not both
 PATHS paths;
 RECTANGLE* rectangle;
};
 
 
class CIRCLE : public ELEM
{
public:
 CIRCLE( ELEM* aParent ) :
 ELEM( T_circle, aParent )
 {
 diameter = 0.0;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* newline = nestLevel ? "\n" : "";
 
 const char* quote = out->GetQuoteChar( layer_id.c_str() );
 out->Print( nestLevel, "(%s %s%s%s %.6g", Name(), quote, layer_id.c_str(), quote,
 diameter );
 
 if( vertex.x!=0.0 || vertex.y!=0.0 )
 out->Print( 0, " %.6g %.6g)%s", vertex.x, vertex.y, newline );
 else
 out->Print( 0, ")%s", newline );
 }
 
 void SetLayerId( const char* aLayerId )
 {
 layer_id = aLayerId;
 }
 
 void SetDiameter( double aDiameter )
 {
 diameter = aDiameter;
 }
 
 void SetVertex( const POINT& aVertex )
 {
 vertex = aVertex;
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string layer_id;
 
 double diameter;
 POINT vertex; // POINT's constructor sets to (0,0)
};
 
 
class QARC : public ELEM
{
public:
 QARC( ELEM* aParent ) :
 ELEM( T_qarc, aParent )
 {
 aperture_width = 0.0;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* newline = nestLevel ? "\n" : "";
 
 const char* quote = out->GetQuoteChar( layer_id.c_str() );
 out->Print( nestLevel, "(%s %s%s%s %.6g", Name(), quote, layer_id.c_str(), quote,
 aperture_width );
 
 for( int i=0; i<3; ++i )
 out->Print( 0, " %.6g %.6g", vertex[i].x, vertex[i].y );
 
 out->Print( 0, ")%s", newline );
 }
 
 void SetLayerId( const char* aLayerId )
 {
 layer_id = aLayerId;
 }
 
 void SetStart( const POINT& aStart )
 {
 vertex[0] = aStart;
 
 // no -0.0 on the printouts!
 vertex[0].FixNegativeZero();
 }
 
 void SetEnd( const POINT& aEnd )
 {
 vertex[1] = aEnd;
 
 // no -0.0 on the printouts!
 vertex[1].FixNegativeZero();
 }
 
 void SetCenter( const POINT& aCenter )
 {
 vertex[2] = aCenter;
 
 // no -0.0 on the printouts!
 vertex[2].FixNegativeZero();
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string layer_id;
 double aperture_width;
 POINT vertex[3];
};
 
 
class WINDOW : public ELEM
{
public:
 
 WINDOW( ELEM* aParent, DSN_T aType = T_window ) :
 ELEM( aType, aParent )
 {
 shape = nullptr;
 }
 
 ~WINDOW()
 {
 delete shape;
 }
 
 void SetShape( ELEM* aShape )
 {
 delete shape;
 shape = aShape;
 
 if( aShape )
 {
 wxASSERT( aShape->Type()==T_rect
 || aShape->Type()==T_circle
 || aShape->Type()==T_qarc
 || aShape->Type()==T_path
 || aShape->Type()==T_polygon);
 
 aShape->SetParent( this );
 }
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s ", Name() );
 
 if( shape )
 shape->Format( out, 0 );
 
 out->Print( 0, ")\n" );
 }
 
protected:
 /* <shape_descriptor >::=
 [<rectangle_descriptor> |
 <circle_descriptor> |
 <polygon_descriptor> |
 <path_descriptor> |
 <qarc_descriptor> ]
 */
 ELEM* shape;
 
private:
 friend class SPECCTRA_DB;
};
 
typedef boost::ptr_vector<WINDOW> WINDOWS;
 
 
class KEEPOUT : public ELEM
{
public:
 
 KEEPOUT( ELEM* aParent, DSN_T aType ) :
 ELEM( aType, aParent )
 {
 m_rules = nullptr;
 m_place_rules = nullptr;
 m_shape = nullptr;
 
 m_sequence_number = -1;
 }
 
 ~KEEPOUT()
 {
 delete m_rules;
 delete m_place_rules;
 delete m_shape;
 }
 
 void SetShape( ELEM* aShape )
 {
 delete m_shape;
 m_shape = aShape;
 
 if( aShape )
 {
 wxASSERT( aShape->Type()==T_rect
 || aShape->Type()==T_circle
 || aShape->Type()==T_qarc
 || aShape->Type()==T_path
 || aShape->Type()==T_polygon);
 
 aShape->SetParent( this );
 }
 }
 
 void AddWindow( WINDOW* aWindow )
 {
 aWindow->SetParent( this );
 m_windows.push_back( aWindow );
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* newline = "\n";
 
 out->Print( nestLevel, "(%s", Name() );
 
 if( m_name.size() )
 {
 const char* quote = out->GetQuoteChar( m_name.c_str() );
 out->Print( 0, " %s%s%s", quote, m_name.c_str(), quote );
 }
 // Could be not needed:
#if 1
 else
 {
 out->Print( 0, " \"\"" ); // the zone with no name or net_code == 0
 }
#endif
 
 if( m_sequence_number != -1 )
 out->Print( 0, " (sequence_number %d)", m_sequence_number );
 
 if( m_shape )
 {
 out->Print( 0, " " );
 m_shape->Format( out, 0 );
 }
 
 if( m_rules )
 {
 out->Print( 0, "%s", newline );
 newline = "";
 m_rules->Format( out, nestLevel+1 );
 }
 
 if( m_place_rules )
 {
 out->Print( 0, "%s", newline );
 newline = "";
 m_place_rules->Format( out, nestLevel+1 );
 }
 
 if( m_windows.size() )
 {
 out->Print( 0, "%s", newline );
 newline = "";
 
 for( WINDOWS::iterator i = m_windows.begin(); i != m_windows.end(); ++i )
 i->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 else
 {
 out->Print( 0, ")\n" );
 }
 }
 
protected:
 std::string m_name;
 int m_sequence_number;
 RULE* m_rules;
 RULE* m_place_rules;
 
 WINDOWS m_windows;
 
 /* <shape_descriptor >::=
 [<rectangle_descriptor> |
 <circle_descriptor> |
 <polygon_descriptor> |
 <path_descriptor> |
 <qarc_descriptor> ]
 */
 ELEM* m_shape;
 
private:
 friend class SPECCTRA_DB;
};
 
typedef boost::ptr_vector<KEEPOUT> KEEPOUTS;
 
 
class VIA : public ELEM
{
public:
 
 VIA( ELEM* aParent ) :
 ELEM( T_via, aParent )
 {
 }
 
 void AppendVia( const char* aViaName )
 {
 m_padstacks.push_back( aViaName );
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const int RIGHTMARGIN = 80;
 int perLine = out->Print( nestLevel, "(%s", Name() );
 
 for( STRINGS::iterator i = m_padstacks.begin(); i != m_padstacks.end(); ++i )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "");
 }
 
 const char* quote = out->GetQuoteChar( i->c_str() );
 perLine += out->Print( 0, " %s%s%s", quote, i->c_str(), quote );
 }
 
 if( m_spares.size() )
 {
 out->Print( 0, "\n" );
 
 perLine = out->Print( nestLevel+1, "(spare" );
 
 for( STRINGS::iterator i = m_spares.begin(); i != m_spares.end(); ++i )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+2, "%s", "");
 }
 
 const char* quote = out->GetQuoteChar( i->c_str() );
 perLine += out->Print( 0, " %s%s%s", quote, i->c_str(), quote );
 }
 
 out->Print( 0, ")" );
 }
 
 out->Print( 0, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 STRINGS m_padstacks;
 STRINGS m_spares;
};
 
 
class CLASSES : public ELEM
{
public:
 CLASSES( ELEM* aParent ) :
 ELEM( T_classes, aParent )
 {
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 for( STRINGS::iterator i = class_ids.begin(); i != class_ids.end(); ++i )
 {
 const char* quote = out->GetQuoteChar( i->c_str() );
 out->Print( nestLevel, "%s%s%s\n", quote, i->c_str(), quote );
 }
 }
 
private:
 friend class SPECCTRA_DB;
 
 STRINGS class_ids;
};
 
 
class CLASS_CLASS : public ELEM_HOLDER
{
public:
 
 CLASS_CLASS( ELEM* aParent, DSN_T aType ) :
 ELEM_HOLDER( aType, aParent )
 {
 classes = nullptr;
 }
 
 ~CLASS_CLASS()
 {
 delete classes;
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( classes )
 classes->Format( out, nestLevel );
 
 // format the kids
 ELEM_HOLDER::FormatContents( out, nestLevel );
 }
 
private:
 friend class SPECCTRA_DB;
 
 CLASSES* classes;
 
 // rule | layer_rule are put into the kids container.
};
 
 
class CONTROL : public ELEM_HOLDER
{
public:
 CONTROL( ELEM* aParent ) :
 ELEM_HOLDER( T_control, aParent )
 {
 via_at_smd = false;
 via_at_smd_grid_on = false;
 }
 
 ~CONTROL()
 {
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s\n", Name() );
 
 out->Print( nestLevel+1, "(via_at_smd %s", via_at_smd ? "on" : "off" );
 
 if( via_at_smd_grid_on )
 out->Print( 0, " grid %s", via_at_smd_grid_on ? "on" : "off" );
 
 out->Print( 0, ")\n" );
 
 for( int i = 0; i < Length(); ++i )
 At(i)->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 bool via_at_smd;
 bool via_at_smd_grid_on;
};
 
 
class LAYER : public ELEM
{
public:
 LAYER( ELEM* aParent ) :
 ELEM( T_layer, aParent )
 {
 layer_type = T_signal;
 direction = -1;
 cost = -1;
 cost_type = -1;
 
 rules = nullptr;
 }
 
 ~LAYER()
 {
 delete rules;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( name.c_str() );
 
 out->Print( nestLevel, "(%s %s%s%s\n", Name(), quote, name.c_str(), quote );
 
 out->Print( nestLevel+1, "(type %s)\n", GetTokenText( layer_type ) );
 
 if( properties.size() )
 {
 out->Print( nestLevel+1, "(property\n" );
 
 for( PROPERTIES::iterator i = properties.begin(); i != properties.end(); ++i )
 {
 i->Format( out, nestLevel+2 );
 }
 out->Print( nestLevel+1, ")\n" );
 }
 
 if( direction != -1 )
 out->Print( nestLevel+1, "(direction %s)\n", GetTokenText( (DSN_T)direction ) );
 
 if( rules )
 rules->Format( out, nestLevel+1 );
 
 if( cost != -1 )
 {
 if( cost < 0 )
 // positive integer, stored as negative.
 out->Print( nestLevel+1, "(cost %d", -cost );
 else
 out->Print( nestLevel+1, "(cost %s", GetTokenText( (DSN_T)cost ) );
 
 if( cost_type != -1 )
 out->Print( 0, " (type %s)", GetTokenText( (DSN_T)cost_type ) );
 
 out->Print( 0, ")\n" );
 }
 
 if( use_net.size() )
 {
 out->Print( nestLevel+1, "(use_net" );
 
 for( STRINGS::const_iterator i = use_net.begin(); i != use_net.end(); ++i )
 {
 quote = out->GetQuoteChar( i->c_str() );
 out->Print( 0, " %s%s%s", quote, i->c_str(), quote );
 }
 
 out->Print( 0, ")\n" );
 }
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string name;
 DSN_T layer_type; 
 int direction;
 
 int cost;
 int cost_type; 
 RULE* rules;
 STRINGS use_net;
 
 PROPERTIES properties;
};
 
typedef boost::ptr_vector<LAYER> LAYERS;
 
 
class SPECCTRA_LAYER_PAIR : public ELEM
{
public:
 SPECCTRA_LAYER_PAIR( ELEM* aParent ) :
 ELEM( T_layer_pair, aParent )
 {
 layer_weight = 0.0;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote0 = out->GetQuoteChar( layer_id0.c_str() );
 const char* quote1 = out->GetQuoteChar( layer_id1.c_str() );
 
 out->Print( nestLevel, "(%s %s%s%s %s%s%s %.6g)\n", Name(), quote0, layer_id0.c_str(),
 quote0, quote1, layer_id1.c_str(), quote1, layer_weight );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string layer_id0;
 std::string layer_id1;
 
 double layer_weight;
};
 
typedef boost::ptr_vector<SPECCTRA_LAYER_PAIR> SPECCTRA_LAYER_PAIRS;
 
 
class LAYER_NOISE_WEIGHT : public ELEM
{
 friend class SPECCTRA_DB;
 
 SPECCTRA_LAYER_PAIRS layer_pairs;
 
public:
 
 LAYER_NOISE_WEIGHT( ELEM* aParent ) :
 ELEM( T_layer_noise_weight, aParent )
 {
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s\n", Name() );
 
 for( SPECCTRA_LAYER_PAIRS::iterator i = layer_pairs.begin(); i != layer_pairs.end(); ++i )
 i->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
};
 
 
class COPPER_PLANE : public KEEPOUT
{
public:
 COPPER_PLANE( ELEM* aParent ) :
 KEEPOUT( aParent, T_plane )
 {}
 
private:
 friend class SPECCTRA_DB;
};
 
typedef boost::ptr_vector<COPPER_PLANE> COPPER_PLANES;
 
 
class TOKPROP : public ELEM
{
public:
 TOKPROP( ELEM* aParent, DSN_T aType ) :
 ELEM( aType, aParent )
 {
 // Do not leave uninitialized members
 value = T_NONE;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s %s)\n", Name(), GetTokenText( value ) );
 }
 
private:
 friend class SPECCTRA_DB;
 
 DSN_T value;
};
 
 
class STRINGPROP : public ELEM
{
public:
 STRINGPROP( ELEM* aParent, DSN_T aType ) :
 ELEM( aType, aParent )
 {
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( value.c_str() );
 
 out->Print( nestLevel, "(%s %s%s%s)\n",
 Name(),
 quote, value.c_str(), quote );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string value;
};
 
 
class REGION : public ELEM_HOLDER
{
public:
 REGION( ELEM* aParent ) :
 ELEM_HOLDER( T_region, aParent )
 {
 m_rectangle = nullptr;
 m_polygon = nullptr;
 m_rules = nullptr;
 }
 
 ~REGION()
 {
 delete m_rectangle;
 delete m_polygon;
 delete m_rules;
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( m_region_id.size() )
 {
 const char* quote = out->GetQuoteChar( m_region_id.c_str() );
 out->Print( nestLevel, "%s%s%s\n", quote, m_region_id.c_str(), quote );
 }
 
 if( m_rectangle )
 m_rectangle->Format( out, nestLevel );
 
 if( m_polygon )
 m_polygon->Format( out, nestLevel );
 
 ELEM_HOLDER::FormatContents( out, nestLevel );
 
 if( m_rules )
 m_rules->Format( out, nestLevel );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_region_id;
 
 //-----<mutually exclusive>--------------------------------------
 RECTANGLE* m_rectangle;
 PATH* m_polygon;
 //-----</mutually exclusive>-------------------------------------
 
 /* region_net | region_class | region_class_class are all mutually
 exclusive and are put into the kids container.
 */
 
 RULE* m_rules;
};
 
 
class GRID : public ELEM
{
public:
 GRID( ELEM* aParent ) :
 ELEM( T_grid, aParent )
 {
 m_grid_type = T_via;
 m_direction = T_NONE;
 m_dimension = 0.0;
 m_offset = 0.0;
 m_image_type = T_NONE;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s %s %.6g", Name(), GetTokenText( m_grid_type ), m_dimension );
 
 if( m_grid_type == T_place )
 {
 if( m_image_type == T_smd || m_image_type == T_pin )
 out->Print( 0, " (image_type %s)", GetTokenText( m_image_type ) );
 }
 else
 {
 if( m_direction == T_x || m_direction == T_y )
 out->Print( 0, " (direction %s)", GetTokenText( m_direction ) );
 }
 
 if( m_offset != 0.0 )
 out->Print( 0, " (offset %.6g)", m_offset );
 
 out->Print( 0, ")\n");
 }
 
private:
 friend class SPECCTRA_DB;
 
 DSN_T m_grid_type; 
 double m_dimension;
 DSN_T m_direction; 
 double m_offset;
 DSN_T m_image_type;
};
 
 
class STRUCTURE_OUT : public ELEM
{
public:
 STRUCTURE_OUT( ELEM* aParent ) :
 ELEM( T_structure_out, aParent )
 {
 m_rules = nullptr;
 }
 
 ~STRUCTURE_OUT()
 {
 delete m_rules;
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 for( LAYERS::iterator i = m_layers.begin(); i != m_layers.end(); ++i )
 i->Format( out, nestLevel );
 
 if( m_rules )
 m_rules->Format( out, nestLevel );
 }
 
private:
 friend class SPECCTRA_DB;
 
 LAYERS m_layers;
 RULE* m_rules;
};
 
 
class STRUCTURE : public ELEM_HOLDER
{
public:
 STRUCTURE( ELEM* aParent ) :
 ELEM_HOLDER( T_structure, aParent )
 {
 m_unit = nullptr;
 m_layer_noise_weight = nullptr;
 m_boundary = nullptr;
 m_place_boundary = nullptr;
 m_via = nullptr;
 m_control = nullptr;
 m_rules = nullptr;
 m_place_rules = nullptr;
 }
 
 ~STRUCTURE()
 {
 delete m_unit;
 delete m_layer_noise_weight;
 delete m_boundary;
 delete m_place_boundary;
 delete m_via;
 delete m_control;
 delete m_rules;
 delete m_place_rules;
 }
 
 void SetBOUNDARY( BOUNDARY *aBoundary )
 {
 delete m_boundary;
 m_boundary = aBoundary;
 
 if( m_boundary )
 m_boundary->SetParent( this );
 }
 
 void SetPlaceBOUNDARY( BOUNDARY *aBoundary )
 {
 delete m_place_boundary;
 m_place_boundary = aBoundary;
 
 if( m_place_boundary )
 m_place_boundary->SetParent( this );
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( m_unit )
 m_unit->Format( out, nestLevel );
 
 for( LAYERS::iterator i=m_layers.begin(); i!=m_layers.end(); ++i )
 i->Format( out, nestLevel );
 
 if( m_layer_noise_weight )
 m_layer_noise_weight->Format( out, nestLevel );
 
 if( m_boundary )
 m_boundary->Format( out, nestLevel );
 
 if( m_place_boundary )
 m_place_boundary->Format( out, nestLevel );
 
 for( COPPER_PLANES::iterator i=m_planes.begin(); i!=m_planes.end(); ++i )
 i->Format( out, nestLevel );
 
 for( REGIONS::iterator i=m_regions.begin(); i!=m_regions.end(); ++i )
 i->Format( out, nestLevel );
 
 for( KEEPOUTS::iterator i=m_keepouts.begin(); i!=m_keepouts.end(); ++i )
 i->Format( out, nestLevel );
 
 if( m_via )
 m_via->Format( out, nestLevel );
 
 if( m_control )
 m_control->Format( out, nestLevel );
 
 for( int i=0; i<Length(); ++i )
 {
 At(i)->Format( out, nestLevel );
 }
 
 if( m_rules )
 m_rules->Format( out, nestLevel );
 
 if( m_place_rules )
 m_place_rules->Format( out, nestLevel );
 
 for( GRIDS::iterator i=m_grids.begin(); i!=m_grids.end(); ++i )
 i->Format( out, nestLevel );
 }
 
 UNIT_RES* GetUnits() const override
 {
 if( m_unit )
 return m_unit;
 
 return ELEM::GetUnits();
 }
 
private:
 friend class SPECCTRA_DB;
 
 UNIT_RES* m_unit;
 
 LAYERS m_layers;
 
 LAYER_NOISE_WEIGHT* m_layer_noise_weight;
 
 BOUNDARY* m_boundary;
 BOUNDARY* m_place_boundary;
 VIA* m_via;
 CONTROL* m_control;
 RULE* m_rules;
 
 KEEPOUTS m_keepouts;
 
 COPPER_PLANES m_planes;
 
 typedef boost::ptr_vector<REGION> REGIONS;
 REGIONS m_regions;
 
 RULE* m_place_rules;
 
 typedef boost::ptr_vector<GRID> GRIDS;
 GRIDS m_grids;
};
 
 
class PLACE : public ELEM
{
public:
 PLACE( ELEM* aParent ) :
 ELEM( T_place, aParent )
 {
 m_side = T_front;
 
 m_rotation = 0.0;
 
 m_hasVertex = false;
 
 m_mirror = T_NONE;
 m_status = T_NONE;
 
 m_place_rules = nullptr;
 
 m_lock_type = T_NONE;
 m_rules = nullptr;
 m_region = nullptr;
 }
 
 ~PLACE()
 {
 delete m_place_rules;
 delete m_rules;
 delete m_region;
 }
 
 void SetVertex( const POINT& aVertex )
 {
 m_vertex = aVertex;
 m_vertex.FixNegativeZero();
 m_hasVertex = true;
 }
 
 void SetRotation( double aRotation )
 {
 m_rotation = aRotation;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override;
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_component_id; 
 
 DSN_T m_side;
 
 double m_rotation;
 
 bool m_hasVertex;
 POINT m_vertex;
 
 DSN_T m_mirror;
 DSN_T m_status;
 
 std::string m_logical_part;
 
 RULE* m_place_rules;
 
 PROPERTIES m_properties;
 
 DSN_T m_lock_type;
 
 //-----<mutually exclusive>--------------
 RULE* m_rules;
 REGION* m_region;
 //-----</mutually exclusive>-------------
 
 std::string m_part_number;
};
 
typedef boost::ptr_vector<PLACE> PLACES;
 
 
class COMPONENT : public ELEM
{
public:
 COMPONENT( ELEM* aParent ) :
 ELEM( T_component, aParent )
 {
 }
 
 const std::string& GetImageId() const { return m_image_id; }
 void SetImageId( const std::string& aImageId )
 {
 m_image_id = aImageId;
 }
 
 
// static int Compare( IMAGE* lhs, IMAGE* rhs );
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( m_image_id.c_str() );
 out->Print( nestLevel, "(%s %s%s%s\n", Name(), quote, m_image_id.c_str(), quote );
 
 FormatContents( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 for( PLACES::iterator i=m_places.begin(); i!=m_places.end(); ++i )
 i->Format( out, nestLevel );
 }
 
private:
 friend class SPECCTRA_DB;
 
// std::string m_hash; ///< a hash string used by Compare(), not Format()ed/exported.
 
 std::string m_image_id;
 PLACES m_places;
};
 
typedef boost::ptr_vector<COMPONENT> COMPONENTS;
 
 
class PLACEMENT : public ELEM
{
public:
 PLACEMENT( ELEM* aParent ) :
 ELEM( T_placement, aParent )
 {
 m_unit = nullptr;
 m_flip_style = DSN_T( T_NONE );
 }
 
 ~PLACEMENT()
 {
 delete m_unit;
 }
 
 COMPONENT* LookupCOMPONENT( const std::string& imageName )
 {
 for( unsigned i = 0; i < m_components.size(); ++i )
 {
 if( 0 == m_components[i].GetImageId().compare( imageName ) )
 return &m_components[i];
 }
 
 COMPONENT* added = new COMPONENT(this);
 m_components.push_back( added );
 added->SetImageId( imageName );
 return added;
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( m_unit )
 m_unit->Format( out, nestLevel );
 
 if( m_flip_style != DSN_T( T_NONE ) )
 {
 out->Print( nestLevel, "(place_control (flip_style %s))\n",
 GetTokenText( m_flip_style ) );
 }
 
 for( COMPONENTS::iterator i = m_components.begin(); i != m_components.end(); ++i )
 i->Format( out, nestLevel );
 }
 
 UNIT_RES* GetUnits() const override
 {
 if( m_unit )
 return m_unit;
 
 return ELEM::GetUnits();
 }
 
private:
 friend class SPECCTRA_DB;
 
 UNIT_RES* m_unit;
 
 DSN_T m_flip_style;
 
 COMPONENTS m_components;
};
 
 
class SHAPE : public WINDOW
{
public:
 SHAPE( ELEM* aParent, DSN_T aType = T_shape ) :
 WINDOW( aParent, aType )
 {
 m_connect = T_on;
 }
 
 void SetConnect( DSN_T aConnect )
 {
 m_connect = aConnect;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s ", Name() );
 
 if( shape )
 shape->Format( out, 0 );
 
 if( m_connect == T_off )
 out->Print( 0, "(connect %s)", GetTokenText( m_connect ) );
 
 if( m_windows.size() )
 {
 out->Print( 0, "\n" );
 
 for( WINDOWS::iterator i=m_windows.begin(); i!=m_windows.end(); ++i )
 i->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 else
 {
 out->Print( 0, ")\n" );
 }
 }
 
private:
 friend class SPECCTRA_DB;
 
 DSN_T m_connect;
 
 /* <shape_descriptor >::=
 [<rectangle_descriptor> |
 <circle_descriptor> |
 <polygon_descriptor> |
 <path_descriptor> |
 <qarc_descriptor> ]
 ELEM* shape; // inherited from WINDOW
 */
 
 WINDOWS m_windows;
};
 
 
class PIN : public ELEM
{
public:
 PIN( ELEM* aParent ) :
 ELEM( T_pin, aParent )
 {
 m_rotation = 0.0;
 m_isRotated = false;
 m_kiNetCode = 0;
 }
 
 void SetRotation( double aRotation )
 {
 m_rotation = aRotation;
 m_isRotated = (aRotation != 0.0);
 }
 
 void SetVertex( const POINT& aPoint )
 {
 m_vertex = aPoint;
 m_vertex.FixNegativeZero();
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( m_padstack_id.c_str() );
 if( m_isRotated )
 out->Print( nestLevel, "(pin %s%s%s (rotate %.6g)", quote, m_padstack_id.c_str(), quote,
 m_rotation );
 else
 out->Print( nestLevel, "(pin %s%s%s", quote, m_padstack_id.c_str(), quote );
 
 quote = out->GetQuoteChar( m_pin_id.c_str() );
 out->Print( 0, " %s%s%s %.6g %.6g)\n", quote, m_pin_id.c_str(), quote, m_vertex.x, m_vertex.y );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_padstack_id;
 double m_rotation;
 bool m_isRotated;
 std::string m_pin_id;
 POINT m_vertex;
 
 int m_kiNetCode; 
};
 
typedef boost::ptr_vector<PIN> PINS;
 
 
class LIBRARY;
 
class IMAGE : public ELEM_HOLDER
{
public:
 IMAGE( ELEM* aParent ) :
 ELEM_HOLDER( T_image, aParent )
 {
 m_side = T_both;
 m_unit = nullptr;
 m_rules = nullptr;
 m_place_rules = nullptr;
 m_duplicated = 0;
 }
 
 ~IMAGE()
 {
 delete m_unit;
 delete m_rules;
 delete m_place_rules;
 }
 
 static int Compare( IMAGE* lhs, IMAGE* rhs );
 
 std::string GetImageId()
 {
 if( m_duplicated )
 {
 return m_image_id + "::" + std::to_string( m_duplicated );
 }
 
 return m_image_id;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 std::string imageId = GetImageId();
 
 const char* quote = out->GetQuoteChar( imageId.c_str() );
 
 out->Print( nestLevel, "(%s %s%s%s", Name(), quote, imageId.c_str(), quote );
 
 FormatContents( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
 // this is here for makeHash()
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( m_side != T_both )
 out->Print( 0, " (side %s)", GetTokenText( m_side ) );
 
 out->Print( 0, "\n");
 
 if( m_unit )
 m_unit->Format( out, nestLevel );
 
 // format the kids, which in this class are the shapes
 ELEM_HOLDER::FormatContents( out, nestLevel );
 
 for( PINS::iterator i=m_pins.begin(); i!=m_pins.end(); ++i )
 i->Format( out, nestLevel );
 
 if( m_rules )
 m_rules->Format( out, nestLevel );
 
 if( m_place_rules )
 m_place_rules->Format( out, nestLevel );
 
 for( KEEPOUTS::iterator i=m_keepouts.begin(); i!=m_keepouts.end(); ++i )
 i->Format( out, nestLevel );
 }
 
 UNIT_RES* GetUnits() const override
 {
 if( m_unit )
 return m_unit;
 
 return ELEM::GetUnits();
 }
 
private:
 friend class SPECCTRA_DB;
 friend class LIBRARY;
 
 std::string m_hash; 
 
 std::string m_image_id;
 DSN_T m_side;
 UNIT_RES* m_unit;
 
 /* The grammar spec says only one outline is supported, but I am seeing
 *.dsn examples with multiple outlines. So the outlines will go into
 the kids list.
 */
 
 PINS m_pins;
 
 RULE* m_rules;
 RULE* m_place_rules;
 
 KEEPOUTS m_keepouts;
 
 int m_duplicated; 
};
 
typedef boost::ptr_vector<IMAGE> IMAGES;
 
 
class PADSTACK : public ELEM_HOLDER
{
public:
 PADSTACK() :
 ELEM_HOLDER( T_padstack, nullptr )
 {
 m_unit = nullptr;
 m_rotate = T_on;
 m_absolute = T_off;
 m_rules = nullptr;
 m_attach = T_off;
 }
 
 ~PADSTACK()
 {
 delete m_unit;
 delete m_rules;
 }
 
 const std::string& GetPadstackId()
 {
 return m_padstack_id;
 }
 
 static int Compare( PADSTACK* lhs, PADSTACK* rhs );
 
 void SetPadstackId( const char* aPadstackId )
 {
 m_padstack_id = aPadstackId;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( m_padstack_id.c_str() );
 
 out->Print( nestLevel, "(%s %s%s%s\n", Name(), quote, m_padstack_id.c_str(), quote );
 
 FormatContents( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
 // this factored out for use by Compare()
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( m_unit )
 m_unit->Format( out, nestLevel );
 
 // format the kids, which in this class are the shapes
 ELEM_HOLDER::FormatContents( out, nestLevel );
 
 out->Print( nestLevel, "%s", "" );
 
 // spec for <attach_descriptor> says default is on, so
 // print the off condition to override this.
 if( m_attach == T_off )
 {
 out->Print( 0, "(attach off)" );
 }
 else if( m_attach == T_on )
 {
 const char* quote = out->GetQuoteChar( m_via_id.c_str() );
 
 out->Print( 0, "(attach on (use_via %s%s%s))", quote, m_via_id.c_str(), quote );
 }
 
 if( m_rotate == T_off ) // print the non-default
 out->Print( 0, "(rotate %s)", GetTokenText( m_rotate ) );
 
 if( m_absolute == T_on ) // print the non-default
 out->Print( 0, "(absolute %s)", GetTokenText( m_absolute ) );
 
 out->Print( 0, "\n" );
 
 if( m_rules )
 m_rules->Format( out, nestLevel );
 }
 
 
 UNIT_RES* GetUnits() const override
 {
 if( m_unit )
 return m_unit;
 
 return ELEM::GetUnits();
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_hash; 
 
 std::string m_padstack_id;
 UNIT_RES* m_unit;
 
 /* The shapes are stored in the kids list */
 
 DSN_T m_rotate;
 DSN_T m_absolute;
 DSN_T m_attach;
 std::string m_via_id;
 
 RULE* m_rules;
};
 
typedef boost::ptr_vector<PADSTACK> PADSTACKS;
 
 
inline bool operator<( const PADSTACK& lhs, const PADSTACK& rhs )
{
 return PADSTACK::Compare( (PADSTACK*) &lhs, (PADSTACK*) &rhs ) < 0;
}
 
 
class LIBRARY : public ELEM
{
public:
 LIBRARY( ELEM* aParent, DSN_T aType = T_library ) :
 ELEM( aType, aParent )
 {
 m_unit = nullptr;
// via_start_index = -1; // 0 or greater means there is at least one via
 }
 
 ~LIBRARY()
 {
 delete m_unit;
 }
 
 void AddPadstack( PADSTACK* aPadstack )
 {
 aPadstack->SetParent( this );
 m_padstacks.push_back( aPadstack );
 }
 
/*
 void SetViaStartIndex( int aIndex )
 {
 via_start_index = aIndex;
 }
 int GetViaStartIndex()
 {
 return via_start_index;
 }
*/
 
 int FindIMAGE( IMAGE* aImage )
 {
 unsigned i;
 
 for( i=0; i<m_images.size(); ++i )
 {
 if( 0 == IMAGE::Compare( aImage, &m_images[i] ) )
 return (int) i;
 }
 
 // There is no match to the IMAGE contents, but now generate a unique
 // name for it.
 int dups = 1;
 
 for( i=0; i<m_images.size(); ++i )
 {
 if( 0 == aImage->m_image_id.compare( m_images[i].m_image_id ) )
 aImage->m_duplicated = dups++;
 }
 
 return -1;
 }
 
 
 void AppendIMAGE( IMAGE* aImage )
 {
 aImage->SetParent( this );
 m_images.push_back( aImage );
 }
 
 IMAGE* LookupIMAGE( IMAGE* aImage )
 {
 int ndx = FindIMAGE( aImage );
 
 if( ndx == -1 )
 {
 AppendIMAGE( aImage );
 return aImage;
 }
 
 return &m_images[ndx];
 }
 
 int FindVia( PADSTACK* aVia )
 {
 for( unsigned i = 0; i < m_vias.size(); ++i )
 {
 if( 0 == PADSTACK::Compare( aVia, &m_vias[i] ) )
 return int( i );
 }
 
 return -1;
 }
 
 void AppendVia( PADSTACK* aVia )
 {
 aVia->SetParent( this );
 m_vias.push_back( aVia );
 }
 
 
 void AppendPADSTACK( PADSTACK* aPadstack )
 {
 aPadstack->SetParent( this );
 m_padstacks.push_back( aPadstack );
 }
 
 PADSTACK* LookupVia( PADSTACK* aVia )
 {
 int ndx = FindVia( aVia );
 
 if( ndx == -1 )
 {
 AppendVia( aVia );
 return aVia;
 }
 
 return &m_vias[ndx];
 }
 
 PADSTACK* FindPADSTACK( const std::string& aPadstackId )
 {
 for( unsigned i = 0; i < m_padstacks.size(); ++i )
 {
 PADSTACK* ps = &m_padstacks[i];
 
 if( ps->GetPadstackId().compare( aPadstackId ) == 0 )
 return ps;
 }
 
 return nullptr;
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( m_unit )
 m_unit->Format( out, nestLevel );
 
 for( IMAGES::iterator i = m_images.begin(); i != m_images.end(); ++i )
 i->Format( out, nestLevel );
 
 for( PADSTACKS::iterator i = m_padstacks.begin(); i != m_padstacks.end(); ++i )
 i->Format( out, nestLevel );
 
 for( PADSTACKS::iterator i = m_vias.begin(); i != m_vias.end(); ++i )
 i->Format( out, nestLevel );
 }
 
 UNIT_RES* GetUnits() const override
 {
 if( m_unit )
 return m_unit;
 
 return ELEM::GetUnits();
 }
 
private:
 friend class SPECCTRA_DB;
 
 UNIT_RES* m_unit;
 IMAGES m_images;
 
 PADSTACKS m_padstacks; 
 PADSTACKS m_vias;
};
 
 
struct PIN_REF : public ELEM
{
 PIN_REF( ELEM* aParent ) :
 ELEM( T_pin, aParent )
 {
 }
 
 
 int FormatIt( OUTPUTFORMATTER* out, int nestLevel )
 {
 // only print the newline if there is a nest level, and make
 // the quotes unconditional on this one.
 const char* newline = nestLevel ? "\n" : "";
 
 const char* cquote = out->GetQuoteChar( component_id.c_str() );
 const char* pquote = out->GetQuoteChar( pin_id.c_str() );
 
 return out->Print( nestLevel, "%s%s%s-%s%s%s%s", cquote, component_id.c_str(), cquote,
 pquote, pin_id.c_str(), pquote, newline );
 }
 
 std::string component_id;
 std::string pin_id;
};
 
typedef std::vector<PIN_REF> PIN_REFS;
 
 
class FROMTO : public ELEM
{
public:
 FROMTO( ELEM* aParent ) :
 ELEM( T_fromto, aParent )
 {
 m_rules = nullptr;
 m_fromto_type = DSN_T( T_NONE );
 }
 ~FROMTO()
 {
 delete m_rules;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 // no quoting on these two, the lexer preserved the quotes on input
 out->Print( nestLevel, "(%s %s %s ",
 Name(), m_fromText.c_str(), m_toText.c_str() );
 
 if( m_fromto_type != DSN_T( T_NONE ) )
 out->Print( 0, "(type %s)", GetTokenText( m_fromto_type ) );
 
 if( m_net_id.size() )
 {
 const char* quote = out->GetQuoteChar( m_net_id.c_str() );
 out->Print( 0, "(net %s%s%s)", quote, m_net_id.c_str(), quote );
 }
 
 bool singleLine = true;
 
 if( m_rules || m_layer_rules.size() )
 {
 out->Print( 0, "\n" );
 singleLine = false;
 }
 
 if( m_rules )
 m_rules->Format( out, nestLevel+1 );
 
 /*
 if( circuit.size() )
 out->Print( nestLevel, "%s\n", circuit.c_str() );
 */
 
 for( LAYER_RULES::iterator i = m_layer_rules.begin(); i != m_layer_rules.end(); ++i )
 i->Format( out, nestLevel+1 );
 
 out->Print( singleLine ? 0 : nestLevel, ")" );
 
 if( nestLevel || !singleLine )
 out->Print( 0, "\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_fromText;
 std::string m_toText;
 
 DSN_T m_fromto_type;
 std::string m_net_id;
 RULE* m_rules;
// std::string m_circuit;
 LAYER_RULES m_layer_rules;
};
 
typedef boost::ptr_vector<FROMTO> FROMTOS;
 
 
class COMP_ORDER : public ELEM
{
public:
 COMP_ORDER( ELEM* aParent ) :
 ELEM( T_comp_order, aParent )
 {
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s", Name() );
 
 for( STRINGS::iterator i = m_placement_ids.begin(); i != m_placement_ids.end(); ++i )
 {
 const char* quote = out->GetQuoteChar( i->c_str() );
 out->Print( 0, " %s%s%s", quote, i->c_str(), quote );
 }
 
 out->Print( 0, ")" );
 
 if( nestLevel )
 out->Print( 0, "\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 STRINGS m_placement_ids;
};
 
typedef boost::ptr_vector<COMP_ORDER> COMP_ORDERS;
 
class NET : public ELEM
{
public:
 NET( ELEM* aParent ) :
 ELEM( T_net, aParent )
 {
 m_unassigned = false;
 m_net_number = T_NONE;
 m_pins_type = T_pins;
 
 m_type = T_NONE;
 m_supply = T_NONE;
 
 m_rules = nullptr;
 m_comp_order = nullptr;
 }
 
 ~NET()
 {
 delete m_rules;
 delete m_comp_order;
 }
 
 int FindPIN_REF( const std::string& aComponent )
 {
 for( unsigned i = 0; i < m_pins.size(); ++i )
 {
 if( aComponent.compare( m_pins[i].component_id ) == 0 )
 return int(i);
 }
 
 return -1;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( m_net_id.c_str() );
 const char* space = " ";
 
 out->Print( nestLevel, "(%s %s%s%s", Name(), quote, m_net_id.c_str(), quote );
 
 if( m_unassigned )
  {
 out->Print( 0, "%s(unassigned)", space );
 space = ""; // only needed one space
 }
 
 if( m_net_number != T_NONE )
 {
 out->Print( 0, "%s(net_number %d)", space, m_net_number );
 // space = "";
 }
 
 out->Print( 0, "\n" );
 
 if( m_pins.size() )
 {
 const int RIGHTMARGIN = 80;
 int perLine = out->Print( nestLevel+1, "(%s", GetTokenText( m_pins_type ) );
 
 for( PIN_REFS::iterator i = m_pins.begin(); i != m_pins.end(); ++i )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n");
 perLine = out->Print( nestLevel+2, "%s", "" );
 }
 else
 {
 perLine += out->Print( 0, " " );
 }
 
 perLine += i->FormatIt( out, 0 );
 }
 
 out->Print( 0, ")\n" );
 }
 
 if( m_comp_order )
 m_comp_order->Format( out, nestLevel+1 );
 
 if( m_type != T_NONE )
 out->Print( nestLevel+1, "(type %s)\n", GetTokenText( m_type ) );
 
 if( m_rules )
 m_rules->Format( out, nestLevel+1 );
 
 for( LAYER_RULES::iterator i = m_layer_rules.begin(); i != m_layer_rules.end(); ++i )
 i->Format( out, nestLevel+1 );
 
 for( FROMTOS::iterator i = m_fromtos.begin(); i != m_fromtos.end(); ++i )
 i->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_net_id;
 bool m_unassigned;
 int m_net_number;
 
 DSN_T m_pins_type; 
 PIN_REFS m_pins;
 
 PIN_REFS m_expose;
 PIN_REFS m_noexpose;
 PIN_REFS m_source;
 PIN_REFS m_load;
 PIN_REFS m_terminator;
 
 DSN_T m_type; 
 
 DSN_T m_supply; 
 
 RULE* m_rules;
 
 LAYER_RULES m_layer_rules;
 
 FROMTOS m_fromtos;
 
 COMP_ORDER* m_comp_order;
};
 
typedef boost::ptr_vector<NET> NETS;
 
 
class TOPOLOGY : public ELEM
{
public:
 TOPOLOGY( ELEM* aParent ) :
 ELEM( T_topology, aParent )
 {
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 for( FROMTOS::iterator i = m_fromtos.begin(); i != m_fromtos.end(); ++i )
 i->Format( out, nestLevel );
 
 for( COMP_ORDERS::iterator i = m_comp_orders.begin(); i != m_comp_orders.end(); ++i )
 i->Format( out, nestLevel );
 }
 
private:
 friend class SPECCTRA_DB;
 
 FROMTOS m_fromtos;
 
 COMP_ORDERS m_comp_orders;
};
 
 
class CLASS : public ELEM
{
public:
 CLASS( ELEM* aParent ) :
 ELEM( T_class, aParent )
 {
 m_rules = nullptr;
 m_topology = nullptr;
 }
 
 ~CLASS()
 {
 delete m_rules;
 delete m_topology;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( m_class_id.c_str() );
 
 int perLine = out->Print( nestLevel, "(%s %s%s%s", Name(), quote, m_class_id.c_str(), quote );
 
 const int RIGHTMARGIN = 72;
 
 for( STRINGS::iterator i=m_net_ids.begin(); i!=m_net_ids.end(); ++i )
 {
 const char* space = " ";
 
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "" );
 space = ""; // no space at first net_id of the line
 }
 
 quote = out->GetQuoteChar( i->c_str() );
 perLine += out->Print( 0, "%s%s%s%s", space, quote, i->c_str(), quote );
 }
 
 bool newLine = false;
 
 if( m_circuit.size() || m_rules || m_layer_rules.size() || m_topology )
 {
 out->Print( 0, "\n" );
 newLine = true;
 }
 
 if( m_circuit.size() )
 {
 out->Print( nestLevel+1, "(circuit\n" );
 
 for( STRINGS::iterator i = m_circuit.begin(); i != m_circuit.end(); ++i )
 out->Print( nestLevel + 2, "%s\n", i->c_str() );
 
 out->Print( nestLevel+1, ")\n" );
 }
 
 if( m_rules )
 m_rules->Format( out, nestLevel+1 );
 
 for( LAYER_RULES::iterator i = m_layer_rules.begin(); i != m_layer_rules.end(); ++i )
 i->Format( out, nestLevel + 1 );
 
 if( m_topology )
 m_topology->Format( out, nestLevel+1 );
 
 out->Print( newLine ? nestLevel : 0, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_class_id;
 
 STRINGS m_net_ids;
 
 STRINGS m_circuit;
 
 RULE* m_rules;
 
 LAYER_RULES m_layer_rules;
 
 TOPOLOGY* m_topology;
};
 
typedef boost::ptr_vector<CLASS> CLASSLIST;
 
 
class NETWORK : public ELEM
{
public:
 NETWORK( ELEM* aParent ) :
 ELEM( T_network, aParent )
 {
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 for( NETS::iterator i = m_nets.begin(); i != m_nets.end(); ++i )
 i->Format( out, nestLevel );
 
 for( CLASSLIST::iterator i = m_classes.begin(); i != m_classes.end(); ++i )
 i->Format( out, nestLevel );
 }
 
private:
 friend class SPECCTRA_DB;
 
 NETS m_nets;
 CLASSLIST m_classes;
};
 
 
class CONNECT : public ELEM
{
 // @todo not completed.
 
public:
 CONNECT( ELEM* aParent ) :
 ELEM( T_connect, aParent ) {}
};
 
 
class WIRE : public ELEM
{
public:
 WIRE( ELEM* aParent ) :
 ELEM( T_wire, aParent )
 {
 m_shape = nullptr;
 m_connect = nullptr;
 
 m_turret = -1;
 m_wire_type = T_NONE;
 m_attr = T_NONE;
 m_supply = false;
 }
 
 ~WIRE()
 {
 delete m_shape;
 delete m_connect;
 }
 
 void SetShape( ELEM* aShape )
 {
 delete m_shape;
 m_shape = aShape;
 
 if( aShape )
 {
 wxASSERT(aShape->Type()==T_rect || aShape->Type()==T_circle
 || aShape->Type()==T_qarc || aShape->Type()==T_path
 || aShape->Type()==T_polygon);
 
 aShape->SetParent( this );
 }
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 out->Print( nestLevel, "(%s ", Name() );
 
 if( m_shape )
 m_shape->Format( out, 0 );
 
 if( m_net_id.size() )
 {
 const char* quote = out->GetQuoteChar( m_net_id.c_str() );
 out->Print( 0, "(net %s%s%s)", quote, m_net_id.c_str(), quote );
 }
 
 if( m_turret >= 0 )
 out->Print( 0, "(turrent %d)", m_turret );
 
 if( m_wire_type != T_NONE )
 out->Print( 0, "(type %s)", GetTokenText( m_wire_type ) );
 
 if( m_attr != T_NONE )
 out->Print( 0, "(attr %s)", GetTokenText( m_attr ) );
 
 if( m_shield.size() )
 {
 const char* quote = out->GetQuoteChar( m_shield.c_str() );
 out->Print( 0, "(shield %s%s%s)", quote, m_shield.c_str(), quote );
 }
 
 if( m_windows.size() )
 {
 out->Print( 0, "\n" );
 
 for( WINDOWS::iterator i = m_windows.begin(); i != m_windows.end(); ++i )
 i->Format( out, nestLevel + 1 );
 }
 
 if( m_connect )
 m_connect->Format( out, 0 );
 
 if( m_supply )
 out->Print( 0, "(supply)" );
 
 out->Print( 0, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 /* <shape_descriptor >::=
 [<rectangle_descriptor> |
 <circle_descriptor> |
 <polygon_descriptor> |
 <path_descriptor> |
 <qarc_descriptor> ]
 */
 ELEM* m_shape;
 
 std::string m_net_id;
 int m_turret;
 DSN_T m_wire_type;
 DSN_T m_attr;
 std::string m_shield;
 WINDOWS m_windows;
 CONNECT* m_connect;
 bool m_supply;
};
 
typedef boost::ptr_vector<WIRE> WIRES;
 
 
class WIRE_VIA : public ELEM
{
public:
 WIRE_VIA( ELEM* aParent ) :
 ELEM( T_via, aParent )
 {
 m_via_number = -1;
 m_via_type = T_NONE;
 m_attr = T_NONE;
 m_supply = false;
 }
 
 const std::string& GetPadstackId()
 {
 return m_padstack_id;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( m_padstack_id.c_str() );
 
 const int RIGHTMARGIN = 80;
 int perLine = out->Print( nestLevel, "(%s %s%s%s", Name(), quote, m_padstack_id.c_str(),
 quote );
 
 for( POINTS::iterator i = m_vertexes.begin(); i != m_vertexes.end(); ++i )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "" );
 }
 else
 {
 perLine += out->Print( 0, " " );
 }
 
 perLine += out->Print( 0, "%.6g %.6g", i->x, i->y );
 }
 
 if( m_net_id.size() || m_via_number!=-1 || m_via_type!=T_NONE || m_attr!=T_NONE || m_supply)
 out->Print( 0, " " );
 
 if( m_net_id.size() )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "" );
 }
 
 quote = out->GetQuoteChar( m_net_id.c_str() );
 perLine += out->Print( 0, "(net %s%s%s)", quote, m_net_id.c_str(), quote );
 }
 
 if( m_via_number != -1 )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "" );
 }
 
 perLine += out->Print( 0, "(via_number %d)", m_via_number );
 }
 
 if( m_via_type != T_NONE )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "" );
 }
 
 perLine += out->Print( 0, "(type %s)", GetTokenText( m_via_type ) );
 }
 
 if( m_attr != T_NONE )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "" );
 }
 
 if( m_attr == T_virtual_pin )
 {
 quote = out->GetQuoteChar( m_virtual_pin_name.c_str() );
 perLine += out->Print( 0, "(attr virtual_pin %s%s%s)", quote,
 m_virtual_pin_name.c_str(), quote );
 }
 else
 {
 perLine += out->Print( 0, "(attr %s)", GetTokenText( m_attr ) );
 }
 }
 
 if( m_supply )
 {
 if( perLine > RIGHTMARGIN )
 {
 out->Print( 0, "\n" );
 perLine = out->Print( nestLevel+1, "%s", "" );
 }
 
 perLine += out->Print( 0, "(supply)" );
 }
 
 if( m_contact_layers.size() )
 {
 out->Print( 0, "\n" );
 out->Print( nestLevel+1, "(contact\n" );
 
 for( STRINGS::iterator i = m_contact_layers.begin(); i != m_contact_layers.end(); ++i )
 {
 quote = out->GetQuoteChar( i->c_str() );
 out->Print( nestLevel+2, "%s%s%s\n", quote, i->c_str(), quote );
 }
 
 out->Print( nestLevel+1, "))\n" );
 }
 else
 {
 out->Print( 0, ")\n" );
 }
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_padstack_id;
 POINTS m_vertexes;
 std::string m_net_id;
 int m_via_number;
 DSN_T m_via_type;
 DSN_T m_attr;
 std::string m_virtual_pin_name;
 STRINGS m_contact_layers;
 bool m_supply;
};
 
typedef boost::ptr_vector<WIRE_VIA> WIRE_VIAS;
 
 
class WIRING : public ELEM
{
public:
 WIRING( ELEM* aParent ) :
 ELEM( T_wiring, aParent )
 {
 unit = nullptr;
 }
 
 ~WIRING()
 {
 delete unit;
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( unit )
 unit->Format( out, nestLevel );
 
 for( WIRES::iterator i = wires.begin(); i != wires.end(); ++i )
 i->Format( out, nestLevel );
 
 for( WIRE_VIAS::iterator i = wire_vias.begin(); i != wire_vias.end(); ++i )
 i->Format( out, nestLevel );
 }
 
 UNIT_RES* GetUnits() const override
 {
 if( unit )
 return unit;
 
 return ELEM::GetUnits();
 }
 
private:
 friend class SPECCTRA_DB;
 
 UNIT_RES* unit;
 WIRES wires;
 WIRE_VIAS wire_vias;
};
 
 
class PCB : public ELEM
{
public:
 PCB( ELEM* aParent = nullptr ) :
 ELEM( T_pcb, aParent )
 {
 m_parser = nullptr;
 m_resolution = nullptr;
 m_unit = nullptr;
 m_structure = nullptr;
 m_placement = nullptr;
 m_library = nullptr;
 m_network = nullptr;
 m_wiring = nullptr;
 }
 
 ~PCB()
 {
 delete m_parser;
 delete m_resolution;
 delete m_unit;
 delete m_structure;
 delete m_placement;
 delete m_library;
 delete m_network;
 delete m_wiring;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( m_pcbname.c_str() );
 
 out->Print( nestLevel, "(%s %s%s%s\n", Name(), quote, m_pcbname.c_str(), quote );
 
 if( m_parser )
 m_parser->Format( out, nestLevel+1 );
 
 if( m_resolution )
 m_resolution->Format( out, nestLevel+1 );
 
 if( m_unit )
 m_unit->Format( out, nestLevel+1 );
 
 if( m_structure )
 m_structure->Format( out, nestLevel+1 );
 
 if( m_placement )
 m_placement->Format( out, nestLevel+1 );
 
 if( m_library )
 m_library->Format( out, nestLevel+1 );
 
 if( m_network )
 m_network->Format( out, nestLevel+1 );
 
 if( m_wiring )
 m_wiring->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
 UNIT_RES* GetUnits() const override
 {
 if( m_unit )
 return m_unit;
 
 if( m_resolution )
 return m_resolution->GetUnits();
 
 return ELEM::GetUnits();
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string m_pcbname;
 PARSER* m_parser;
 UNIT_RES* m_resolution;
 UNIT_RES* m_unit;
 STRUCTURE* m_structure;
 PLACEMENT* m_placement;
 LIBRARY* m_library;
  NETWORK* m_network;
 WIRING* m_wiring;
};
 
 
class ANCESTOR : public ELEM
{
public:
 ANCESTOR( ELEM* aParent ) :
 ELEM( T_ancestor, aParent )
 {
 time_stamp = time(nullptr);
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 char temp[80];
 struct tm* tmp;
 
 tmp = localtime( &time_stamp );
 strftime( temp, sizeof(temp), "%b %d %H : %M : %S %Y", tmp );
 
 // format the time first to temp
 // filename may be empty, so quote it just in case.
 out->Print( nestLevel, "(%s \"%s\" (created_time %s)\n", Name(), filename.c_str(), temp );
 
 if( comment.size() )
 {
 const char* quote = out->GetQuoteChar( comment.c_str() );
 out->Print( nestLevel+1, "(comment %s%s%s)\n", quote, comment.c_str(), quote );
 }
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string filename;
 std::string comment;
 time_t time_stamp;
};
 
typedef boost::ptr_vector<ANCESTOR> ANCESTORS;
 
 
class HISTORY : public ELEM
{
public:
 HISTORY( ELEM* aParent ) :
 ELEM( T_history, aParent )
 {
 time_stamp = time(nullptr);
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 for( ANCESTORS::iterator i=ancestors.begin(); i!=ancestors.end(); ++i )
 i->Format( out, nestLevel );
 
 char temp[80];
 struct tm* tmp;
 
 tmp = localtime( &time_stamp );
 strftime( temp, sizeof( temp ), "%b %d %H : %M : %S %Y", tmp );
 
 // format the time first to temp
 out->Print( nestLevel, "(self (created_time %s)\n", temp );
 
 for( STRINGS::iterator i=comments.begin(); i!=comments.end(); ++i )
 {
 const char* quote = out->GetQuoteChar( i->c_str() );
 out->Print( nestLevel+1, "(comment %s%s%s)\n", quote, i->c_str(), quote );
 }
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 ANCESTORS ancestors;
  time_t time_stamp;
 STRINGS comments;
};
 
 
class SUPPLY_PIN : public ELEM
{
public:
 SUPPLY_PIN( ELEM* aParent ) :
 ELEM( T_supply_pin, aParent )
 {
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 bool singleLine = pin_refs.size() <= 1;
 out->Print( nestLevel, "(%s", Name() );
 
 if( singleLine )
 {
 out->Print( 0, "%s", " " );
 pin_refs.begin()->Format( out, 0 );
 }
 else
 {
 for( PIN_REFS::iterator i = pin_refs.begin(); i != pin_refs.end(); ++i )
 i->FormatIt( out, nestLevel + 1 );
 }
 
 if( net_id.size() )
 {
 const char* newline = singleLine ? "" : "\n";
 
 const char* quote = out->GetQuoteChar( net_id.c_str() );
 out->Print( singleLine ? 0 : nestLevel+1, " (net %s%s%s)%s",
 quote, net_id.c_str(), quote, newline );
 }
 
 out->Print( singleLine ? 0 : nestLevel, ")\n");
 }
 
private:
 friend class SPECCTRA_DB;
 
 PIN_REFS pin_refs;
 std::string net_id;
};
 
typedef boost::ptr_vector<SUPPLY_PIN> SUPPLY_PINS;
 
 
class NET_OUT : public ELEM
{
public:
 NET_OUT( ELEM* aParent ) :
 ELEM( T_net_out, aParent )
 {
 rules = nullptr;
 net_number = -1;
 }
 
 ~NET_OUT()
 {
 delete rules;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( net_id.c_str() );
 
 // cannot use Type() here, it is T_net_out and we need "(net "
 out->Print( nestLevel, "(net %s%s%s\n", quote, net_id.c_str(), quote );
 
 if( net_number>= 0 )
 out->Print( nestLevel+1, "(net_number %d)\n", net_number );
 
 if( rules )
 rules->Format( out, nestLevel+1 );
 
 for( WIRES::iterator i = wires.begin(); i != wires.end(); ++i )
 i->Format( out, nestLevel + 1 );
 
 for( WIRE_VIAS::iterator i = wire_vias.begin(); i != wire_vias.end(); ++i )
 i->Format( out, nestLevel + 1 );
 
 for( SUPPLY_PINS::iterator i = supply_pins.begin(); i != supply_pins.end(); ++i )
 i->Format( out, nestLevel + 1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string net_id;
 int net_number;
 RULE* rules;
 WIRES wires;
 WIRE_VIAS wire_vias;
 SUPPLY_PINS supply_pins;
};
 
typedef boost::ptr_vector<NET_OUT> NET_OUTS;
 
 
class ROUTE : public ELEM
{
public:
 ROUTE( ELEM* aParent ) :
 ELEM( T_route, aParent )
 {
 resolution = nullptr;
 parser = nullptr;
 structure_out = nullptr;
 library = nullptr;
 }
 
 ~ROUTE()
 {
 delete resolution;
 delete parser;
 delete structure_out;
 delete library;
// delete test_points;
 }
 
 UNIT_RES* GetUnits() const override
 {
 if( resolution )
 return resolution;
 
 return ELEM::GetUnits();
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 if( resolution )
 resolution->Format( out, nestLevel );
 
 if( parser )
 parser->Format( out, nestLevel );
 
 if( structure_out )
 structure_out->Format( out, nestLevel );
 
 if( library )
 library->Format( out, nestLevel );
 
 if( net_outs.size() )
 {
 out->Print( nestLevel, "(network_out\n" );
 
 for( NET_OUTS::iterator i = net_outs.begin(); i != net_outs.end(); ++i )
 i->Format( out, nestLevel + 1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
// if( test_poinst )
// test_points->Format( out, nestLevel );
 }
 
private:
 friend class SPECCTRA_DB;
 
 UNIT_RES* resolution;
 PARSER* parser;
 STRUCTURE_OUT* structure_out;
 LIBRARY* library;
 NET_OUTS net_outs;
// TEST_POINTS* test_points;
};
 
 
struct PIN_PAIR
{
 PIN_PAIR( ELEM* aParent = nullptr ) :
 was( aParent ),
 is( aParent )
 {
 }
 
 PIN_REF was;
 PIN_REF is;
};
 
typedef std::vector<PIN_PAIR> PIN_PAIRS;
 
 
class WAS_IS : public ELEM
{
public:
 WAS_IS( ELEM* aParent ) :
 ELEM( T_was_is, aParent )
 {
 }
 
 void FormatContents( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 for( PIN_PAIRS::iterator i = pin_pairs.begin(); i != pin_pairs.end(); ++i )
 {
 out->Print( nestLevel, "(pins " );
 i->was.Format( out, 0 );
 out->Print( 0, " " );
 i->is.Format( out, 0 );
 out->Print( 0, ")\n" );
 }
 }
 
private:
 friend class SPECCTRA_DB;
 
 PIN_PAIRS pin_pairs;
};
 
 
class SESSION : public ELEM
{
public:
 SESSION( ELEM* aParent = nullptr ) :
 ELEM( T_session, aParent )
 {
 history = nullptr;
 structure = nullptr;
 placement = nullptr;
 was_is = nullptr;
 route = nullptr;
 }
 
 ~SESSION()
 {
 delete history;
 delete structure;
 delete placement;
 delete was_is;
 delete route;
 }
 
 void Format( OUTPUTFORMATTER* out, int nestLevel ) override
 {
 const char* quote = out->GetQuoteChar( session_id.c_str() );
 out->Print( nestLevel, "(%s %s%s%s\n", Name(), quote, session_id.c_str(), quote );
 
 out->Print( nestLevel+1, "(base_design \"%s\")\n", base_design.c_str() );
 
 if( history )
 history->Format( out, nestLevel+1 );
 
 if( structure )
 structure->Format( out, nestLevel+1 );
 
 if( placement )
 placement->Format( out, nestLevel+1 );
 
 if( was_is )
 was_is->Format( out, nestLevel+1 );
 
 if( route )
 route->Format( out, nestLevel+1 );
 
 out->Print( nestLevel, ")\n" );
 }
 
private:
 friend class SPECCTRA_DB;
 
 std::string session_id;
 std::string base_design;
 
 HISTORY* history;
 STRUCTURE* structure;
 PLACEMENT* placement;
 WAS_IS* was_is;
 ROUTE* route;
 
/* not supported:
 FLOOR_PLAN* floor_plan;
 NET_PIN_CHANGES* net_pin_changes;
 SWAP_HISTORY* swap_history;
*/
};
 
typedef boost::ptr_set<PADSTACK> PADSTACKSET;
 
 
class SPECCTRA_DB : public SPECCTRA_LEXER
{
public:
 
 SPECCTRA_DB() :
 SPECCTRA_LEXER( 0 ) // LINE_READER* == nullptr, no DSNLEXER::PushReader()
 {
 // The LINE_READER will be pushed from an automatic instantiation,
 // we don't own it:
 wxASSERT( !iOwnReaders );
 
 m_pcb = nullptr;
 m_session = nullptr;
 m_quote_char += '"';
 m_footprintsAreFlipped = false;
 
 SetSpecctraMode( true );
 
 // Avoid not initialized members:
 m_routeResolution = nullptr;
 m_sessionBoard = nullptr;
 m_top_via_layer = 0;
 m_bot_via_layer = 0;
 }
 
 virtual ~SPECCTRA_DB()
 {
 delete m_pcb;
 delete m_session;
 
 deleteNETs();
 }
 
 static PCB* MakePCB();
 
 void SetPCB( PCB* aPcb )
 {
 delete m_pcb;
 m_pcb = aPcb;
 }
 
 PCB* GetPCB() { return m_pcb; }
 
 void SetSESSION( SESSION* aSession )
 {
 delete m_session;
 m_session = aSession;
 }
 
 SESSION* GetSESSION() { return m_session; }
 
 void LoadPCB( const wxString& aFilename );
 
 void LoadSESSION( const wxString& aFilename );
 
 void ExportPCB( const wxString& aFilename, bool aNameChange=false );
 
 void FromBOARD( BOARD* aBoard );
 
 void FromSESSION( BOARD* aBoard );
 
 void ExportSESSION( const wxString& aFilename );
 
 bool BuiltBoardOutlines( BOARD* aBoard );
 
 void FlipFOOTPRINTs( BOARD* aBoard );
 
 void RevertFOOTPRINTs( BOARD* aBoard );
 
private:
 void buildLayerMaps( BOARD* aBoard );
 
 int findLayerName( const std::string& aLayerName ) const;
 
 void readCOMPnPIN( std::string* component_id, std::string* pid_id );
 
 void readTIME( time_t* time_stamp );
 
 void doPCB( PCB* growth );
 void doPARSER( PARSER* growth );
 void doRESOLUTION( UNIT_RES* growth );
 void doUNIT( UNIT_RES* growth );
 void doSTRUCTURE( STRUCTURE* growth );
 void doSTRUCTURE_OUT( STRUCTURE_OUT* growth );
 void doLAYER_NOISE_WEIGHT( LAYER_NOISE_WEIGHT* growth );
 void doSPECCTRA_LAYER_PAIR( SPECCTRA_LAYER_PAIR* growth );
 void doBOUNDARY( BOUNDARY* growth );
 void doRECTANGLE( RECTANGLE* growth );
 void doPATH( PATH* growth );
 void doSTRINGPROP( STRINGPROP* growth );
 void doTOKPROP( TOKPROP* growth );
 void doVIA( VIA* growth );
 void doCONTROL( CONTROL* growth );
 void doLAYER( LAYER* growth );
 void doRULE( RULE* growth );
 void doKEEPOUT( KEEPOUT* growth );
 void doCIRCLE( CIRCLE* growth );
 void doQARC( QARC* growth );
 void doWINDOW( WINDOW* growth );
 void doCONNECT( CONNECT* growth );
 void doREGION( REGION* growth );
 void doCLASS_CLASS( CLASS_CLASS* growth );
 void doLAYER_RULE( LAYER_RULE* growth );
 void doCLASSES( CLASSES* growth );
 void doGRID( GRID* growth );
 void doPLACE( PLACE* growth );
 void doCOMPONENT( COMPONENT* growth );
 void doPLACEMENT( PLACEMENT* growth );
 void doPROPERTIES( PROPERTIES* growth );
 void doPADSTACK( PADSTACK* growth );
 void doSHAPE( SHAPE* growth );
 void doIMAGE( IMAGE* growth );
 void doLIBRARY( LIBRARY* growth );
 void doPIN( PIN* growth );
 void doNET( NET* growth );
 void doNETWORK( NETWORK* growth );
 void doCLASS( CLASS* growth );
 void doTOPOLOGY( TOPOLOGY* growth );
 void doFROMTO( FROMTO* growth );
 void doCOMP_ORDER( COMP_ORDER* growth );
 void doWIRE( WIRE* growth );
 void doWIRE_VIA( WIRE_VIA* growth );
 void doWIRING( WIRING* growth );
 void doSESSION( SESSION* growth );
 void doANCESTOR( ANCESTOR* growth );
 void doHISTORY( HISTORY* growth );
 void doROUTE( ROUTE* growth );
 void doWAS_IS( WAS_IS* growth );
 void doNET_OUT( NET_OUT* growth );
 void doSUPPLY_PIN( SUPPLY_PIN* growth );
 
 //-----<FromBOARD>-------------------------------------------------------
 
 void fillBOUNDARY( BOARD* aBoard, BOUNDARY* aBoundary );
 
 IMAGE* makeIMAGE( BOARD* aBoard, FOOTPRINT* aFootprint );
 
 PADSTACK* makePADSTACK( BOARD* aBoard, PAD* aPad );
 
 PADSTACK* makeVia( int aCopperDiameter, int aDrillDiameter,
 int aTopLayer, int aBotLayer );
 
 PADSTACK* makeVia( const ::PCB_VIA* aVia );
 
 void deleteNETs()
 {
 for( unsigned n = 0; n < m_nets.size(); ++n )
 delete m_nets[n];
 
 m_nets.clear();
 }
 
 void exportNETCLASS( const std::shared_ptr<NETCLASS>& aNetClass, BOARD* aBoard );
 
 //-----</FromBOARD>------------------------------------------------------
 
 //-----<FromSESSION>-----------------------------------------------------
 
 PCB_TRACK* makeTRACK( WIRE* wire, PATH* aPath, int aPointIndex, int aNetcode );
 
 PCB_VIA* makeVIA( WIRE_VIA*aVia, PADSTACK* aPadstack, const POINT& aPoint, int aNetCode,
 int aViaDrillDefault );
 
 //-----</FromSESSION>----------------------------------------------------
 
 static const KEYWORD keywords[];
 
 PCB* m_pcb;
 SHAPE_POLY_SET m_brd_outlines; // the board outlines for DSN export
 SESSION* m_session;
 wxString m_filename;
 std::string m_quote_char;
 
 bool m_footprintsAreFlipped;
 
 STRING_FORMATTER m_sf;
 
 STRINGS m_layerIds; 
 
 std::vector<int> m_kicadLayer2pcb; 
 std::vector<PCB_LAYER_ID> m_pcbLayer2kicad; 
 
 UNIT_RES* m_routeResolution;
 
 BOARD* m_sessionBoard;
 
 static const KICAD_T scanPADs[];
 
 PADSTACKSET m_padstackset;
 
 std::vector<NET*> m_nets;
 
 int m_top_via_layer;
 int m_bot_via_layer;
};
 
 
} // namespace DSN
 
#endif // SPECCTRA_H_