eagle_parser.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2012-2023 KiCad Developers, see AUTHORS.txt for contributors.
 * Copyright (C) 2017 CERN
 *
 * @author Alejandro García Montoro <[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, 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 _EAGLE_PARSER_H_
#define _EAGLE_PARSER_H_
 
#include <map>
#include <memory>
#include <optional>
#include <unordered_map>
 
#include <wx/xml/xml.h>
#include <wx/string.h>
#include <wx/filename.h>
 
#include <layer_ids.h>
#include <trigo.h>
#include <core/wx_stl_compat.h>
#include <widgets/report_severity.h>
 
class FOOTPRINT;
class IO_BASE;
 
struct EINSTANCE;
struct EPART;
struct ETEXT;
struct ESEGMENT;
 
typedef std::unordered_map<wxString, wxXmlNode*> NODE_MAP;
typedef std::map<wxString, EINSTANCE*> EINSTANCE_MAP;
typedef std::map<wxString, std::unique_ptr<EPART>> EPART_MAP;
 
wxString escapeName( const wxString& aNetName );
 
wxString interpretText( const wxString& aText );
 
bool substituteVariable( wxString* aText );
 
wxString convertDescription( wxString aDescr );
 
static inline wxXmlNode* getChildrenNodes( NODE_MAP& aMap, const wxString& aName )
{
 auto it = aMap.find( aName );
 return it == aMap.end() ? nullptr : it->second->GetChildren();
}
 
 
struct XML_PARSER_ERROR : std::runtime_error
{
 XML_PARSER_ERROR( const wxString& aMessage ) noexcept :
 std::runtime_error( "XML parser failed - " + aMessage.ToStdString() )
 {}
};
 
 
struct TRIPLET
{
 const char* element;
 const char* attribute;
 const char* value;
 
 TRIPLET( const char* aElement, const char* aAttribute = "", const char* aValue = "" ) :
 element( aElement ),
 attribute( aAttribute ),
 value( aValue )
 {}
};
 
 
class XPATH
{
 std::vector<TRIPLET> p;
 
public:
 void push( const char* aPathSegment, const char* aAttribute="" )
 {
 p.emplace_back( aPathSegment, aAttribute );
 }
 
 void clear() { p.clear(); }
 
 void pop() { p.pop_back(); }
 
 void Value( const char* aValue )
 {
 p.back().value = aValue;
 }
 
 void Attribute( const char* aAttribute )
 {
 p.back().attribute = aAttribute;
 }
 
 wxString Contents()
 {
 typedef std::vector<TRIPLET>::const_iterator CITER_TRIPLET;
 
 wxString ret;
 
 for( CITER_TRIPLET it = p.begin(); it != p.end(); ++it )
 {
 if( it != p.begin() )
 ret += '.';
 
 ret += it->element;
 
 if( it->attribute[0] && it->value[0] )
 {
 ret += '[';
 ret += it->attribute;
 ret += '=';
 ret += it->value;
 ret += ']';
 }
 }
 
 return ret;
 }
};
 
 
template<typename T>
T Convert( const wxString& aValue )
{
 throw XML_PARSER_ERROR( "Conversion failed. Unknown type." );
}
 
template <>
wxString Convert<wxString>( const wxString& aValue );
 
template <typename T>
class OPTIONAL_XML_ATTRIBUTE
{
private:
 bool m_isAvailable;
 
 T m_data;
 
public:
 OPTIONAL_XML_ATTRIBUTE() :
 m_isAvailable( false ),
 m_data( T() )
 {}
 
 OPTIONAL_XML_ATTRIBUTE( const wxString& aData )
 {
 m_data = T();
 m_isAvailable = !aData.IsEmpty();
 
 if( m_isAvailable )
 Set( aData );
 }
 
 template<typename V = T>
 OPTIONAL_XML_ATTRIBUTE( T aData ) :
 m_isAvailable( true ),
 m_data( aData )
 {}
 
 operator bool() const
 {
 return m_isAvailable;
 }
 
 OPTIONAL_XML_ATTRIBUTE<T>& operator =( const wxString& aData )
 {
 m_isAvailable = !aData.IsEmpty();
 
 if( m_isAvailable )
 Set( aData );
 
 return *this;
 }
 
 OPTIONAL_XML_ATTRIBUTE<T>& operator =( T aData )
 {
 m_data = aData;
 m_isAvailable = true;
 
 return *this;
 }
 
 bool operator ==( const T& aOther ) const
 {
 return m_isAvailable && ( aOther == m_data );
 }
 
 void Set( const wxString& aString )
 {
 m_data = Convert<T>( aString );
 m_isAvailable = !aString.IsEmpty();
 }
 
 T& Get()
 {
 assert( m_isAvailable );
 return m_data;
 }
 
 const T& CGet() const
 {
 assert( m_isAvailable );
 return m_data;
 }
 
 T& operator*()
 {
 return Get();
 }
 
 const T& operator*() const
 {
 return CGet();
 }
 
 T* operator->()
 {
 return &Get();
 }
 
 const T* operator->() const
 {
 return &CGet();
 }
};
 
 
size_t GetNodeCount( const wxXmlNode* aNode );
 
 
NODE_MAP MapChildren( wxXmlNode* aCurrentNode );
 
VECTOR2I ConvertArcCenter( const VECTOR2I& aStart, const VECTOR2I& aEnd, double aAngle );
 
// Pre-declare for typedefs
struct EROT;
struct ECOORD;
 
typedef OPTIONAL_XML_ATTRIBUTE<wxString> opt_wxString;
typedef OPTIONAL_XML_ATTRIBUTE<int> opt_int;
typedef OPTIONAL_XML_ATTRIBUTE<double> opt_double;
typedef OPTIONAL_XML_ATTRIBUTE<bool> opt_bool;
typedef OPTIONAL_XML_ATTRIBUTE<EROT> opt_erot;
typedef OPTIONAL_XML_ATTRIBUTE<ECOORD> opt_ecoord;
 
 
struct EAGLE_BASE
{
 EAGLE_BASE( IO_BASE* aIo = nullptr ) :
 io( aIo ) {}
 
 IO_BASE* io;
 
 /*
 * Send a message to the #IO_BASE #REPORTER object if one exists.
 *
 * @param aMsg is the message to send to the #REPORTER object.
 */
 void Report( const wxString& aMsg, SEVERITY aSeverity = RPT_SEVERITY_UNDEFINED );
 
 void AdvanceProgressPhase();
};
 
 
// All of the 'E'STRUCTS below merely hold Eagle XML information verbatim, in binary.
// For maintenance and troubleshooting purposes, it was thought that we'd need to
// separate the conversion process into distinct steps. There is no intent to have KiCad
// forms of information in these 'E'STRUCTS. They are only binary forms
// of the Eagle information in the corresponding Eagle XML nodes.
 
 
struct EDESCRIPTION : public EAGLE_BASE
{
 /*
 * <!ELEMENT description (#PCDATA)>
 * <!ATTLIST description
 * language %String; "en"
 * >
 */
 
 wxString text;
 opt_wxString language;
 
 EDESCRIPTION( wxXmlNode* aDescription, IO_BASE* aIo = nullptr );
};
 
 
// Eagle coordinates
struct ECOORD : public EAGLE_BASE
{
 enum EAGLE_UNIT
 {
 EU_NM, 
 EU_MM, 
 EU_INCH, 
 EU_MIL, 
 };
 
 long long int value;
 
 static constexpr EAGLE_UNIT ECOORD_UNIT = EU_NM;
 
 ECOORD()
 : value( 0 )
 {
 }
 
 ECOORD( int aValue, enum EAGLE_UNIT aUnit )
 : value( ConvertToNm( aValue, aUnit ) )
 {
 }
 
 ECOORD( const wxString& aValue, enum EAGLE_UNIT aUnit );
 
 int ToMils() const
 {
 return value / 25400;
 }
 
 int To100NanoMeters() const
 {
 return value / 100;
 }
 
 int ToNanoMeters() const
 {
 return value;
 }
 
 float ToMm() const
 {
 return value / 1000000.0;
 }
 
 int ToSchUnits() const { return To100NanoMeters(); }
 int ToPcbUnits() const { return ToNanoMeters(); }
 
 ECOORD operator+( const ECOORD& aOther ) const
 {
 return ECOORD( value + aOther.value, ECOORD_UNIT );
 }
 
 ECOORD operator-( const ECOORD& aOther ) const
 {
 return ECOORD( value - aOther.value, ECOORD_UNIT );
 }
 
 bool operator==( const ECOORD& aOther ) const
 {
 return value == aOther.value;
 }
 
 static long long int ConvertToNm( int aValue, enum EAGLE_UNIT aUnit );
};
 
 
struct ENET : public EAGLE_BASE
{
 /*
 * <!ELEMENT net (segment)*>
 * <!ATTLIST net
 * name %String; #REQUIRED
 * class %Class; "0"
 * >
 */
 wxString netname;
 int netcode;
 
 std::vector<std::unique_ptr<ESEGMENT>> segments;
 
 ENET( int aNetCode, const wxString& aNetName ) :
 netname( aNetName ),
 netcode( aNetCode )
 {}
 
 ENET() :
 netcode( 0 )
 {}
 
 ENET( wxXmlNode* aNet, IO_BASE* aIo = nullptr );
};
 
 
struct EROT
{
 bool mirror;
 bool spin;
 double degrees;
 
 EROT() :
 mirror( false ),
 spin( false ),
 degrees( 0 )
 {}
 
 EROT( double aDegrees ) :
 mirror( false ),
 spin( false ),
 degrees( aDegrees )
 {}
};
 
 
struct EVERTEX : public EAGLE_BASE
{
 /*
 * <!ELEMENT vertex EMPTY>
 * <!ATTLIST vertex
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * curve %WireCurve; "0"
 * >
 * <!-- curve: The curvature from this vertex to the next one -->
 */
 ECOORD x;
 ECOORD y;
 opt_double curve; 
 
 EVERTEX( wxXmlNode* aVertex, IO_BASE* aIo = nullptr );
};
 
 
struct EWIRE : public EAGLE_BASE
{
 /*
 * <!ELEMENT wire EMPTY>
 * <!ATTLIST wire
 * x1 %Coord; #REQUIRED
 * y1 %Coord; #REQUIRED
 * x2 %Coord; #REQUIRED
 * y2 %Coord; #REQUIRED
 * width %Dimension; #REQUIRED
 * layer %Layer; #REQUIRED
 * extent %Extent; #IMPLIED
 * style %WireStyle; "continuous"
 * curve %WireCurve; "0"
 * cap %WireCap; "round"
 * grouprefs IDREFS #IMPLIED
 * >
 * <!-- extent: Only applicable for airwires -->
 * <!-- cap : Only applicable if 'curve' is not zero -->
 */
 ECOORD x1;
 ECOORD y1;
 ECOORD x2;
 ECOORD y2;
 ECOORD width;
 int layer;
 
 // for style: (continuous | longdash | shortdash | dashdot)
 enum { CONTINUOUS,
 LONGDASH,
 SHORTDASH,
 DASHDOT };
 
 opt_wxString extent;
 opt_int style;
 opt_double curve; 
 
 // for cap: (flat | round)
 enum { FLAT,
 ROUND };
 
 opt_int cap;
 
 // TODO add grouprefs
 
 EWIRE( wxXmlNode* aWire, IO_BASE* aIo = nullptr );
};
 
 
struct EJUNCTION : public EAGLE_BASE
{
 /*
 * <!ELEMENT junction EMPTY>
 * <!ATTLIST junction
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * grouprefs IDREFS #IMPLIED
 * >
 */
 
 ECOORD x;
 ECOORD y;
 
 EJUNCTION( wxXmlNode* aJunction, IO_BASE* aIo = nullptr );
};
 
 
struct ELABEL : public EAGLE_BASE
{
 /*
 * <!ELEMENT label EMPTY>
 * <!ATTLIST label
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * size %Dimension; #REQUIRED
 * layer %Layer; #REQUIRED
 * font %TextFont; "proportional"
 * ratio %Int; "8"
 * rot %Rotation; "R0"
 * xref %Bool; "no"
 * align %Align; "bottom-left"
 * grouprefs IDREFS #IMPLIED
 * >
 * <!-- rot: Only 0, 90, 180 or 270 -->
 * <!-- xref: Only in <net> context -->
 */
 
 ECOORD x;
 ECOORD y;
 ECOORD size;
 int layer;
 opt_wxString font;
 opt_int ratio;
 opt_erot rot;
 opt_bool xref;
 opt_wxString align;
 
 // TODO Add grouprefs
 
 ELABEL( wxXmlNode* aLabel, IO_BASE* aIo = nullptr );
};
 
 
struct EVIA : public EAGLE_BASE
{
 /*
 * <!ELEMENT via EMPTY>
 * <!ATTLIST via
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * extent %Extent; #REQUIRED
 * drill %Dimension; #REQUIRED
 * diameter %Dimension; "0"
 * shape %ViaShape; "round"
 * alwaysstop %Bool; "no"
 * grouprefs IDREFS #IMPLIED
 * >
 */
 ECOORD x;
 ECOORD y;
 int layer_front_most; 
 int layer_back_most; 
 ECOORD drill;
 opt_ecoord diam;
 opt_wxString shape;
 opt_bool alwaysStop;
 
 // TODO add grouprefs
 
 EVIA( wxXmlNode* aVia, IO_BASE* aIo = nullptr );
};
 
 
struct ECIRCLE : public EAGLE_BASE
{
 /*
 * <!ELEMENT circle EMPTY>
 * <!ATTLIST circle
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * radius %Coord; #REQUIRED
 * width %Dimension; #REQUIRED
 * layer %Layer; #REQUIRED
 * grouprefs IDREFS #IMPLIED
 * >
 */
 ECOORD x;
 ECOORD y;
 ECOORD radius;
 ECOORD width;
 int layer;
 
 // TODO add grouprefs
 
 ECIRCLE( wxXmlNode* aCircle, IO_BASE* aIo = nullptr );
};
 
 
struct ERECT : public EAGLE_BASE
{
 /*
 * <!ELEMENT rectangle EMPTY>
 * <!ATTLIST rectangle
 * x1 %Coord; #REQUIRED
 * y1 %Coord; #REQUIRED
 * x2 %Coord; #REQUIRED
 * y2 %Coord; #REQUIRED
 * layer %Layer; #REQUIRED
 * rot %Rotation; "R0"
 * grouprefs IDREFS #IMPLIED
 * >
 */
 ECOORD x1;
 ECOORD y1;
 ECOORD x2;
 ECOORD y2;
 int layer;
 opt_erot rot;
 
 ERECT( wxXmlNode* aRect, IO_BASE* aIo = nullptr );
};
 
 
struct ESPLINE : public EAGLE_BASE
{
 /*
 * <!ELEMENT spline (vertex)*>
 * <!-- Four simple (non-curve) vertices define the control points of a degree-3
 * spline curve -->
 * <!ATTLIST spline
 * width %Dimension; #REQUIRED
 * >
 */
 std::vector<std::unique_ptr<EVERTEX>> vertices;
 double width;
 
 ESPLINE( wxXmlNode* aSpline, IO_BASE* aIo = nullptr );
};
 
 
struct EATTR : public EAGLE_BASE
{
 /*
 * <!ELEMENT attribute EMPTY>
 * <!ATTLIST attribute
 * name %String; #REQUIRED
 * value %String; #IMPLIED
 * x %Coord; #IMPLIED
 * y %Coord; #IMPLIED
 * size %Dimension; #IMPLIED
 * layer %Layer; #IMPLIED
 * font %TextFont; #IMPLIED
 * ratio %Int; #IMPLIED
 * rot %Rotation; "R0"
 * display %AttributeDisplay; "value"
 * constant %Bool; "no"
 * align %Align; "bottom-left"
 * grouprefs IDREFS #IMPLIED
 * >
 * <!-- display: Only in <element> or <instance> context -->
 * <!-- constant:Only in <device> context -->
 */
 wxString name;
 opt_wxString value;
 opt_ecoord x;
 opt_ecoord y;
 opt_ecoord size;
 opt_int layer;
 opt_wxString font;
 opt_double ratio;
 opt_erot rot;
 
 enum { // for 'display'
 Off,
 VALUE,
 NAME,
 BOTH,
 };
 
 opt_bool constant;
 opt_int display;
 opt_int align;
 
 // TODO add groupdefs
 
 EATTR( wxXmlNode* aTree, IO_BASE* aIo = nullptr );
 EATTR() {}
};
 
 
struct EDIMENSION : public EAGLE_BASE
{
 /*
 * <!ELEMENT dimension EMPTY>
 * <!ATTLIST dimension
 * x1 %Coord; #REQUIRED
 * y1 %Coord; #REQUIRED
 * x2 %Coord; #REQUIRED
 * y2 %Coord; #REQUIRED
 * x3 %Coord; #REQUIRED
 * y3 %Coord; #REQUIRED
 * layer %Layer; #REQUIRED
 * dtype %DimensionType; "parallel"
 * width %Dimension; "0.13"
 * extwidth %Dimension; "0"
 * extlength %Dimension; "0"
 * extoffset %Dimension; "0"
 * textsize %Dimension; #REQUIRED
 * textratio %Int; "8"
 * unit %GridUnit; "mm"
 * precision %Int; "2"
 * visible %Bool; "no"
 * grouprefs IDREFS #IMPLIED
 * >
 */
 ECOORD x1;
 ECOORD y1;
 ECOORD x2;
 ECOORD y2;
 ECOORD x3;
 ECOORD y3;
 opt_ecoord textsize;
 int layer;
 opt_wxString dimensionType;
 opt_double width;
 opt_double extwidth;
 opt_double extlength;
 opt_double extoffset;
 opt_int textratio;
 opt_wxString unit;
 opt_int precision;
 opt_bool visible;
 
 // TODO add grouprefs
 
 EDIMENSION( wxXmlNode* aDimension, IO_BASE* aIo = nullptr );
};
 
 
struct ETEXT : public EAGLE_BASE
{
 /*
 * <!ELEMENT text (#PCDATA)>
 * <!ATTLIST text
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * size %Dimension; #REQUIRED
 * layer %Layer; #REQUIRED
 * font %TextFont; "proportional"
 * ratio %Int; "8"
 * rot %Rotation; "R0"
 * align %Align; "bottom-left"
 * distance %Int; "50"
 * grouprefs IDREFS #IMPLIED
 * >
 */
 wxString text;
 ECOORD x;
 ECOORD y;
 ECOORD size;
 int layer;
 opt_wxString font;
 opt_double ratio;
 opt_erot rot;
 
 enum { // for align
 CENTER = 0,
 CENTER_LEFT,
 TOP_CENTER,
 TOP_LEFT,
 TOP_RIGHT,
 
 // opposites are -1 x above, used by code tricks in here
 CENTER_RIGHT = -CENTER_LEFT,
 BOTTOM_CENTER = -TOP_CENTER,
 BOTTOM_LEFT = -TOP_RIGHT,
 BOTTOM_RIGHT = -TOP_LEFT,
 };
 
 opt_int align;
 opt_int distance;
 
 // TODO add grouprefs
 
 ETEXT( wxXmlNode* aText, IO_BASE* aIo = nullptr );
 
 VECTOR2I ConvertSize() const;
};
 
 
struct EFRAME : public EAGLE_BASE
{
 /*
 * <!ELEMENT frame EMPTY>
 * <!ATTLIST frame
 * x1 %Coord; #REQUIRED
 * y1 %Coord; #REQUIRED
 * x2 %Coord; #REQUIRED
 * y2 %Coord; #REQUIRED
 * columns %Int; #REQUIRED
 * rows %Int; #REQUIRED
 * layer %Layer; #REQUIRED
 * border-left %Bool; "yes"
 * border-top %Bool; "yes"
 * border-right %Bool; "yes"
 * border-bottom %Bool; "yes"
 * grouprefs IDREFS #IMPLIED
 * >
 */
 ECOORD x1;
 ECOORD y1;
 ECOORD x2;
 ECOORD y2;
 int columns;
 int rows;
 int layer;
 opt_bool border_left;
 opt_bool border_top;
 opt_bool border_right;
 opt_bool border_bottom;
 
 EFRAME( wxXmlNode* aFrameNode, IO_BASE* aIo = nullptr );
};
 
 
struct EPAD_COMMON : public EAGLE_BASE
{
 wxString name;
 ECOORD x, y;
 opt_erot rot;
 opt_bool stop;
 opt_bool thermals;
 
 EPAD_COMMON( wxXmlNode* aPad, IO_BASE* aIo = nullptr );
};
 
 
struct EPAD : public EPAD_COMMON
{
 /*
 * <!ELEMENT pad EMPTY>
 * <!ATTLIST pad
 * name %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * drill %Dimension; #REQUIRED
 * diameter %Dimension; "0"
 * shape %PadShape; "round"
 * rot %Rotation; "R0"
 * stop %Bool; "yes"
 * thermals %Bool; "yes"
 * first %Bool; "no"
 * >
 */
 ECOORD drill;
 opt_ecoord diameter;
 
 // for shape: (square | round | octagon | long | offset)
 enum {
 UNDEF = -1,
 SQUARE,
 ROUND,
 OCTAGON,
 LONG,
 OFFSET,
 };
 
 opt_int shape;
 opt_bool first;
 
 EPAD( wxXmlNode* aPad, IO_BASE* aIo = nullptr );
};
 
 
struct ESMD : public EPAD_COMMON
{
 /*
 * <!ELEMENT smd EMPTY>
 * <!ATTLIST smd
 * name %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * dx %Dimension; #REQUIRED
 * dy %Dimension; #REQUIRED
 * layer %Layer; #REQUIRED
 * roundness %Int; "0"
 * rot %Rotation; "R0"
 * stop %Bool; "yes"
 * thermals %Bool; "yes"
 * cream %Bool; "yes"
 * >
 */
 ECOORD dx;
 ECOORD dy;
 int layer;
 opt_int roundness;
 opt_bool cream;
 
 ESMD( wxXmlNode* aSMD, IO_BASE* aIo = nullptr );
};
 
 
struct EPIN : public EAGLE_BASE
{
 /*
 * <!ELEMENT pin EMPTY>
 * <!ATTLIST pin
 * name %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * visible %PinVisible; "both"
 * length %PinLength; "long"
 * direction %PinDirection; "io"
 * function %PinFunction; "none"
 * swaplevel %Int; "0"
 * rot %Rotation; "R0"
 * >
 */
 wxString name;
 ECOORD x;
 ECOORD y;
 
 opt_wxString visible;
 opt_wxString length;
 opt_wxString direction;
 opt_wxString function;
 opt_int swaplevel;
 opt_erot rot;
 
 EPIN( wxXmlNode* aPin, IO_BASE* aIo = nullptr );
};
 
 
struct EPOLYGON : public EAGLE_BASE
{
 /*
 * <!ELEMENT polygon (vertex)*>
 * <!-- the vertices must define a valid polygon; if the last vertex is the same
 * as the first one, it is ignored -->
 * <!ATTLIST polygon
 * width %Dimension; #REQUIRED
 * layer %Layer; #REQUIRED
 * spacing %Dimension; #IMPLIED
 * pour %PolygonPour; "solid"
 * isolate %Dimension; #IMPLIED
 * orphans %Bool; "no"
 * thermals %Bool; "yes"
 * rank %Int; "0"
 * grouprefs IDREFS #IMPLIED
 * >
 * <!-- isolate: Only in <signal> or <package> context -->
 * <!-- orphans: Only in <signal> context -->
 * <!-- thermals:Only in <signal> context -->
 * <!-- rank: 1..6 in <signal> context, 0 or 7 in <package> context -->
 */
 ECOORD width;
 int layer;
 opt_ecoord spacing;
 
 // KiCad priority is opposite of Eagle rank, that is:
 // - Eagle Low rank drawn first
 // - KiCad high priority drawn first
 // So since Eagle has an upper limit we define this, used for the cases
 // where no rank is specified.
 static const int max_priority = 6;
 
 enum { // for pour
 SOLID,
 HATCH,
 CUTOUT,
 };
 
 int pour;
 opt_ecoord isolate;
 opt_bool orphans;
 opt_bool thermals;
 opt_int rank;
 
 std::vector<std::unique_ptr<EVERTEX>> vertices;
 
 // TODO add grouprefs
 
 EPOLYGON( wxXmlNode* aPolygon, IO_BASE* aIo = nullptr );
};
 
 
struct EHOLE : public EAGLE_BASE
{
 /*
 * <!ELEMENT hole EMPTY>
 * <!ATTLIST hole
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * drill %Dimension; #REQUIRED
 * grouprefs IDREFS #IMPLIED
 * >
 */
 ECOORD x;
 ECOORD y;
 ECOORD drill;
 
 EHOLE( wxXmlNode* aHole, IO_BASE* aIo = nullptr );
};
 
 
struct EVARIANT : public EAGLE_BASE
{
 /*
 * <!ELEMENT variant EMPTY>
 * <!ATTLIST variant
 * name %String; #REQUIRED
 * populate %Bool; "yes"
 * value %String; #IMPLIED
 * technology %String; #IMPLIED
 * >
 * <!-- technology: Only in part context -->
 */
 wxString name;
 opt_bool populate;
 opt_wxString value;
 opt_wxString technology;
 
 EVARIANT( wxXmlNode* aVariant, IO_BASE* aIo = nullptr );
};
 
 
struct EPINMAP : public EAGLE_BASE
{
 /*
 * <!ELEMENT pinmap EMPTY>
 * <!ATTLIST pinmap
 * gate %String; #REQUIRED
 * pin %String; #REQUIRED
 * pinorder %String; #REQUIRED
 * >
 */
 wxString gate;
 wxString pin;
 wxString pinorder;
 
 EPINMAP( wxXmlNode* aPinMap, IO_BASE* aIo = nullptr );
};
 
 
struct EPINMAPPING : public EAGLE_BASE
{
 /*
 * <!ELEMENT pinmapping (pinmap+)>
 * <!ATTLIST pinmapping
 * isusermap %Bool; "no"
 * iddevicewide %Bool; "yes"
 * spiceprefix %String; ""
 * >
 */
 std::vector<std::unique_ptr<EPINMAP>> pinmaps;
 opt_bool isusermap;
 opt_bool iddevicewide;
 opt_wxString spiceprefix;
 
 EPINMAPPING( wxXmlNode* aPinMap, IO_BASE* aIo = nullptr );
};
 
 
struct EMODEL : public EAGLE_BASE
{
 /*
 * <!ELEMENT model (#PCDATA)>
 * <!ATTLIST model
 * name %String; #REQUIRED
 * >
 */
 wxString name;
 wxString model;
 
 EMODEL( wxXmlNode* aModel, IO_BASE* aIo = nullptr );
};
 
 
struct ESPICE : public EAGLE_BASE
{
 /*
 * <!ELEMENT spice (pinmapping, model)>
 */
 std::unique_ptr<EPINMAPPING> pinmapping;
 std::unique_ptr<EMODEL> model;
 
 ESPICE( wxXmlNode* aSpice, IO_BASE* aIo = nullptr );
};
 
 
struct EELEMENT : public EAGLE_BASE
{
 /*
 * <!ELEMENT element (attribute*, variant*)>
 * <!-- variant* is accepted only for compatibility with EAGLE 6.x files -->
 * <!ATTLIST element
 * name %String; #REQUIRED
 * library %String; #REQUIRED
 * library_urn %Urn; ""
 * package %String; #REQUIRED
 * package3d_urn %Urn; ""
 * override_package3d_urn %Urn; ""
 * override_package_urn %Urn; ""
 * override_locally_modified %Bool; "no"
 * value %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * locked %Bool; "no"
 * populate %Bool; "yes"
 * smashed %Bool; "no"
 * rot %Rotation; "R0"
 * grouprefs IDREFS #IMPLIED
 * >
 * <!-- library_urn: Only in parts from online libraries -->
 */
 std::map<wxString, std::unique_ptr<EATTR>> attributes;
 std::map<wxString, std::unique_ptr<EVARIANT>> variants;
 
 wxString name;
 wxString library;
 opt_wxString library_urn;
 wxString package;
 opt_wxString package3d_urn;
 opt_wxString override_package3d_urn;
 opt_bool override_locally_modified;
 wxString value;
 ECOORD x;
 ECOORD y;
 opt_bool locked;
 opt_bool smashed;
 opt_erot rot;
 
 // TODO add grouprefs
 
 EELEMENT( wxXmlNode* aElement, IO_BASE* aIo = nullptr );
};
 
 
struct ELAYER : public EAGLE_BASE
{
 /*
 * <!ELEMENT layer EMPTY>
 * <!ATTLIST layer
 * number %Layer; #REQUIRED
 * name %String; #REQUIRED
 * color %Int; #REQUIRED
 * fill %Int; #REQUIRED
 * visible %Bool; "yes"
 * active %Bool; "yes"
 * >
 */
 int number;
 wxString name;
 int color;
 int fill;
 opt_bool visible;
 opt_bool active;
 
 ELAYER( wxXmlNode* aLayer, IO_BASE* aIo = nullptr );
};
 
 
struct EAGLE_LAYER : public EAGLE_BASE
{
 enum
 {
 TOP = 1,
 ROUTE2 = 2,
 ROUTE3 = 3,
 ROUTE4 = 4,
 ROUTE5 = 5,
 ROUTE6 = 6,
 ROUTE7 = 7,
 ROUTE8 = 8,
 ROUTE9 = 9,
 ROUTE10 = 10,
 ROUTE11 = 11,
 ROUTE12 = 12,
 ROUTE13 = 13,
 ROUTE14 = 14,
 ROUTE15 = 15,
 BOTTOM = 16,
 PADS = 17,
 VIAS = 18,
 UNROUTED = 19,
 DIMENSION = 20,
 TPLACE = 21,
 BPLACE = 22,
 TORIGINS = 23,
 BORIGINS = 24,
 TNAMES = 25,
 BNAMES = 26,
 TVALUES = 27,
 BVALUES = 28,
 TSTOP = 29,
 BSTOP = 30,
 TCREAM = 31,
 BCREAM = 32,
 TFINISH = 33,
 BFINISH = 34,
 TGLUE = 35,
 BGLUE = 36,
 TTEST = 37,
 BTEST = 38,
 TKEEPOUT = 39,
 BKEEPOUT = 40,
 TRESTRICT = 41,
 BRESTRICT = 42,
 VRESTRICT = 43,
 DRILLS = 44,
 HOLES = 45,
 MILLING = 46,
 MEASURES = 47,
 DOCUMENT = 48,
 REFERENCELC = 49,
 REFERENCELS = 50,
 TDOCU = 51,
 BDOCU = 52,
 NETS = 91,
 BUSSES = 92,
 PINS = 93,
 SYMBOLS = 94,
 NAMES = 95,
 VALUES = 96,
 INFO = 97,
 GUIDE = 98,
 USERLAYER1 = 160,
 USERLAYER2 = 161
 };
};
 
 
struct EGATE : public EAGLE_BASE
{
 /*
 * <!ELEMENT gate EMPTY>
 * <!ATTLIST gate
 * name %String; #REQUIRED
 * symbol %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * addlevel %GateAddLevel; "next"
 * swaplevel %Int; "0"
 * >
 */
 
 wxString name;
 wxString symbol;
 
 ECOORD x;
 ECOORD y;
 
 opt_int addlevel;
 opt_int swaplevel;
 
 enum
 {
 MUST,
 CAN,
 NEXT,
 REQUEST,
 ALWAYS
 };
 
 EGATE( wxXmlNode* aGate, IO_BASE* aIo = nullptr );
};
 
 
struct EPART : public EAGLE_BASE
{
 /*
 * <!ELEMENT part (attribute*, variant*, spice?)>
 * <!ATTLIST part
 * name %String; #REQUIRED
 * library %String; #REQUIRED
 * library_urn %Urn; ""
 * deviceset %String; #REQUIRED
 * device %String; #REQUIRED
 * package3d_urn %Urn; ""
 * override_package3d_urn %Urn; ""
 * override_package_urn %Urn; ""
 * override_locally_modified %Bool; "no"
 * technology %String; ""
 * value %String; #IMPLIED
 * >
 * <!-- library_urn: Only in parts from online libraries -->
 */
 std::map<wxString, std::unique_ptr<EATTR>> attributes;
 std::map<wxString, std::unique_ptr<EVARIANT>> variants;
 std::unique_ptr<ESPICE> spice;
 
 wxString name;
 wxString library;
 opt_wxString libraryUrn;
 wxString deviceset;
 wxString device;
 opt_wxString package3d_urn;
 opt_wxString override_package3d_urn;
 opt_wxString override_package_urn;
 opt_bool override_locally_modified;
 opt_wxString technology;
 opt_wxString value;
 
 EPART( wxXmlNode* aPart, IO_BASE* aIo = nullptr );
};
 
 
struct EINSTANCE : public EAGLE_BASE
{
 /*
 * <!ELEMENT instance (attribute)*>
 * <!ATTLIST instance
 * part %String; #REQUIRED
 * gate %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * smashed %Bool; "no"
 * rot %Rotation; "R0"
 * grouprefs IDREFS #IMPLIED
 * >
 * <!-- rot: Only 0, 90, 180 or 270 -->
 */
 
 wxString part;
 wxString gate;
 ECOORD x;
 ECOORD y;
 opt_bool smashed;
 opt_erot rot;
 
 // TODO: add grouprefs
 
 std::map<wxString, std::unique_ptr<EATTR>> attributes;
 
 EINSTANCE( wxXmlNode* aInstance, IO_BASE* aIo = nullptr );
};
 
 
struct ECONNECT : public EAGLE_BASE
{
 /*
 * <!ELEMENT connect EMPTY>
 * <!ATTLIST connect
 * gate %String; #REQUIRED
 * pin %String; #REQUIRED
 * pad %String; #REQUIRED
 * route %ContactRoute; "all"
 * >
 */
 wxString gate;
 wxString pin;
 wxString pad;
 opt_wxString contactroute;
 
 ECONNECT( wxXmlNode* aConnect, IO_BASE* aIo = nullptr );
};
 
 
struct ETECHNOLOGY : public EAGLE_BASE
{
 /*
 * <!ELEMENT technology (attribute)*>
 * <!ATTLIST technology
 * name %String; #REQUIRED
 * >
 */
 wxString name;
 
 std::vector<std::unique_ptr<EATTR>> attributes;
 
 ETECHNOLOGY( wxXmlNode* aTechnology, IO_BASE* aIo = nullptr );
};
 
 
struct EPACKAGE3DINST : public EAGLE_BASE
{
 /*
 * <!ELEMENT package3dinstance EMPTY>
 * <!ATTLIST package3dinstance
 * package3d_urn %Urn; #REQUIRED
 * >
 */
 wxString package3d_urn;
 
 EPACKAGE3DINST( wxXmlNode* aPackage3dInst, IO_BASE* aIo = nullptr );
};
 
 
struct EDEVICE : public EAGLE_BASE
{
 /*
 * <!ELEMENT device (connects?, package3dinstances?, technologies?)>
 * <!ATTLIST device
 * name %String; ""
 * package %String; #IMPLIED
 * >
 */
 wxString name;
 opt_wxString package;
 
 std::vector<std::unique_ptr<ECONNECT>> connects;
 std::vector < std::unique_ptr<EPACKAGE3DINST>> package3dinstances;
 std::vector < std::unique_ptr<ETECHNOLOGY>> technologies;
 
 EDEVICE( wxXmlNode* aDevice, IO_BASE* aIo = nullptr );
};
 
 
struct EDEVICE_SET : public EAGLE_BASE
{
 /*
 * <!ELEMENT deviceset (description?, gates, devices, spice?)>
 * <!ATTLIST deviceset
 * name %String; #REQUIRED
 * urn %Urn; ""
 * locally_modified %Bool; "no"
 * prefix %String; ""
 * uservalue %Bool; "no"
 * library_version %Int; ""
 * library_locally_modified %Bool; "no"
 * >
 * <!-- library_version and library_locally_modified: Only in managed libraries
 * inside boards or schematics -->
 */
 
 wxString name;
 opt_wxString urn;
 opt_bool locally_modified;
 opt_wxString prefix;
 opt_bool uservalue;
 opt_int library_version;
 opt_bool library_locally_modified;
 
 std::optional<EDESCRIPTION> description;
 std::map<wxString, std::unique_ptr<EGATE>> gates;
 std::vector<std::unique_ptr<EDEVICE>> devices;
 std::optional<ESPICE> spice;
 
 EDEVICE_SET( wxXmlNode* aDeviceSet, IO_BASE* aIo = nullptr );
};
 
 
struct ECLASS : public EAGLE_BASE
{
 /*
 * <!ELEMENT class (clearance)*>
 * <!ATTLIST class
 * number %Class; #REQUIRED
 * name %String; #REQUIRED
 * width %Dimension; "0"
 * drill %Dimension; "0"
 * >
 */
 
 wxString number;
 wxString name;
 opt_ecoord width;
 opt_ecoord drill;
 
 std::map<wxString, ECOORD> clearanceMap;
 
 ECLASS( wxXmlNode* aClass, IO_BASE* aIo = nullptr );
};
 
 
struct EPORT : public EAGLE_BASE
{
 /*
 * <!ELEMENT port EMPTY>
 * <!ATTLIST port
 * name %String; #REQUIRED
 * side %String; #REQUIRED
 * coord %Coord; #REQUIRED
 * direction %PortDirection; "io"
 * >
 *
 * The eagle.dtd is incorrect for the EPORT side attribute. It is not an integer, it is a
 * string that defines the side of the module rectangle the port is located. Valid values
 * are "top", "bottom", "right", and "left".
 */
 wxString name;
 wxString side;
 ECOORD coord;
 opt_wxString direction;
 
 EPORT( wxXmlNode* aPort, IO_BASE* aIo = nullptr );
};
 
 
struct EVARIANTDEF : public EAGLE_BASE
{
 /*
 * <!ELEMENT variantdef EMPTY>
 * <!ATTLIST variantdef
 * name %String; #REQUIRED
 * current %Bool; "no"
 * >
 */
 wxString name;
 opt_bool current;
 
 EVARIANTDEF( wxXmlNode* aVariantDef, IO_BASE* aIo = nullptr );
};
 
 
struct ESCHEMATIC_GROUP : public EAGLE_BASE
{
 /*
 * <!ELEMENT schematic_group (attribute*, description?)>
 * <!ATTLIST schematic_group
 * name ID #REQUIRED
 * selectable %Bool; #IMPLIED
 * width %Dimension; #IMPLIED
 * titleSize %Dimension; #IMPLIED
 * titleFont %TextFont; #IMPLIED
 * style %WireStyle; #IMPLIED
 * showAnnotations %Bool; #IMPLIED
 * layer %Layer; #IMPLIED
 * grouprefs IDREFS #IMPLIED
 * >
 */
 wxString name;
 opt_bool selectable;
 opt_ecoord width;
 opt_ecoord titleSize;
 opt_wxString titleFont;
 opt_wxString wireStyle;
 opt_bool showAnnotations;
 opt_int layer;
 opt_wxString grouprefs;
 
 std::optional<EDESCRIPTION> description;
 std::vector<std::unique_ptr<EATTR>> attributes;
 
 ESCHEMATIC_GROUP( wxXmlNode* aSchematicGroup, IO_BASE* aIo = nullptr );
};
 
 
struct EPLAIN : public EAGLE_BASE
{
 /*
 * <!ELEMENT plain (polygon | wire | text | dimension | circle | spline | rectangle |
 * frame | hole)*>
 */
 
 std::vector<std::unique_ptr<EPOLYGON>> polygons;
 std::vector<std::unique_ptr<EWIRE>> wires;
 std::vector<std::unique_ptr<ETEXT>> texts;
 std::vector<std::unique_ptr<EDIMENSION>> dimensions;
 std::vector<std::unique_ptr<ECIRCLE>> circles;
 std::vector<std::unique_ptr<ESPLINE>> splines;
 std::vector<std::unique_ptr<ERECT>> rectangles;
 std::vector<std::unique_ptr<EFRAME>> frames;
 std::vector<std::unique_ptr<EHOLE>> holes;
 
 EPLAIN( wxXmlNode* aPlain, IO_BASE* aIo = nullptr );
};
 
 
struct EMODULEINST : public EAGLE_BASE
{
 /*
 * <!ELEMENT moduleinst (attribute)*>
 * <!ATTLIST moduleinst
 * name %String; #REQUIRED
 * module %String; #REQUIRED
 * modulevariant %String; ""
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * offset %Int; "0"
 * smashed %Bool; "no"
 * rot %Rotation; "R0"
 * >
 * <!-- rot: Only 0, 90, 180 or 270 -->
 */
 
 wxString name;
 wxString moduleinst;
 opt_wxString moduleVariant;
 ECOORD x;
 ECOORD y;
 opt_int offset;
 opt_bool smashed;
 opt_erot rotation;
 
 EMODULEINST( wxXmlNode* aModuleInst, IO_BASE* aIo = nullptr );
};
 
 
struct EPINREF : public EAGLE_BASE
{
 /*
 * <!ELEMENT pinref EMPTY>
 * <!ATTLIST pinref
 * part %String; #REQUIRED
 * gate %String; #REQUIRED
 * pin %String; #REQUIRED
 * >
 */
 wxString part;
 wxString gate;
 wxString pin;
 
 EPINREF( wxXmlNode* aPinRef, IO_BASE* aIo = nullptr );
};
 
 
struct EPORTREF : public EAGLE_BASE
{
 /*
 * <!ELEMENT portref EMPTY>
 * <!ATTLIST portref
 * moduleinst %String; #REQUIRED
 * port %String; #REQUIRED
 * >
 */
 wxString moduleinst;
 wxString port;
 
 EPORTREF( wxXmlNode* aPortRef, IO_BASE* aIo = nullptr );
};
 
 
struct EPROBE : public EAGLE_BASE
{
 /*
 * <!ELEMENT probe EMPTY>
 * <!ATTLIST probe
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * size %Dimension; #REQUIRED
 * layer %Layer; #REQUIRED
 * font %TextFont; "proportional"
 * ratio %Int; "8"
 * rot %Rotation; "R0"
 * xref %Bool; "no"
 * grouprefs IDREFS #IMPLIED
 * >
 * <!-- rot: Only 0, 90, 180 or 270 -->
 * <!-- xref: Only in <net> context -->
 */
 ECOORD x;
 ECOORD y;
 double size;
 int layer;
 opt_wxString font;
 int ratio;
 opt_erot rot;
 opt_bool xref;
 
 // TODO add grouprefs
 
 EPROBE( wxXmlNode* aProbe, IO_BASE* aIo = nullptr );
};
 
 
struct ESEGMENT : public EAGLE_BASE
{
 /*
 * <!ELEMENT segment (pinref | portref | wire | junction | label | probe)*>
 * <!-- 'pinref' and 'junction' are only valid in a <net> context -->
 */
 std::vector<std::unique_ptr<EPINREF>> pinRefs;
 std::vector<std::unique_ptr<EPORTREF>> portRefs;
 std::vector<std::unique_ptr<EWIRE>> wires;
 std::vector<std::unique_ptr<EJUNCTION>> junctions;
 std::vector<std::unique_ptr<ELABEL>> labels;
 std::vector<std::unique_ptr<EPROBE>> probes;
 
 ESEGMENT( wxXmlNode* aSegment, IO_BASE* aIo = nullptr );
};
 
 
struct EBUS : public EAGLE_BASE
{
 /*
 * <!ELEMENT bus (segment)*>
 * <!ATTLIST bus
 * name %String; #REQUIRED
 * >
 */
 
 wxString name;
 std::vector<std::unique_ptr<ESEGMENT>> segments;
 
 EBUS( wxXmlNode* aBus, IO_BASE* aIo = nullptr );
};
 
 
struct ESHEET : public EAGLE_BASE
{
 /*
 * <!ELEMENT sheet (description?, plain?, moduleinsts?, instances?, busses?, nets?)>
 */
 
 opt_wxString description;
 std::unique_ptr<EPLAIN> plain;
 std::map<wxString, std::unique_ptr<EMODULEINST>> moduleinsts;
 std::vector<std::unique_ptr<EINSTANCE>> instances;
 std::vector<std::unique_ptr<EBUS>> busses;
 std::vector<std::unique_ptr<ENET>> nets;
 
 ESHEET( wxXmlNode* aSheet, IO_BASE* aIo = nullptr );
};
 
 
struct EMODULE : public EAGLE_BASE
{
 /*
 * <!ELEMENT module (description?, ports?, variantdefs?, groups?, parts?, sheets?)>
 * <!ATTLIST module
 * name %String; #REQUIRED
 * prefix %String; ""
 * dx %Coord; #REQUIRED
 * dy %Coord; #REQUIRED
 * >
 */
 wxString name;
 opt_wxString prefix;
 ECOORD dx;
 ECOORD dy;
 
 std::optional<EDESCRIPTION> description;
 
 std::map<wxString, std::unique_ptr<EPORT>> ports;
 std::map<wxString, std::unique_ptr<EVARIANTDEF>> variantdefs;
 std::map<wxString, std::unique_ptr<ESCHEMATIC_GROUP>> groups;
 std::map<wxString, std::unique_ptr<EPART>> parts;
 std::vector<std::unique_ptr<ESHEET>> sheets;
 
 EMODULE( wxXmlNode* aModule, IO_BASE* aIo = nullptr );
};
 
 
struct ENOTE : public EAGLE_BASE
{
 /*
 * <!ELEMENT note (#PCDATA)>
 * <!ATTLIST note
 * version %Real; #REQUIRED
 * severity %Severity; #REQUIRED
 * >
 * <!-- version: The EAGLE program version that introduced this compatibility note -->
 */
 double version;
 wxString severity;
 wxString note;
 
 ENOTE( wxXmlNode* aNote, IO_BASE* aIo = nullptr );
};
 
 
struct ECOMPATIBILITY : public EAGLE_BASE
{
 /*
 * <!ELEMENT compatibility (note)*>
 */
 std::vector<std::unique_ptr<ENOTE>> notes;
 
 ECOMPATIBILITY( wxXmlNode* aCompatibility, IO_BASE* aIo = nullptr );
};
 
 
struct ESETTING : public EAGLE_BASE
{
 /*
 * <!ELEMENT setting EMPTY>
 * <!ATTLIST setting
 * alwaysvectorfont %Bool; #IMPLIED
 * verticaltext %VerticalText; "up"
 * keepoldvectorfont %Bool; "no"
 * >
 */
 opt_bool alwaysvectorfont;
 opt_wxString verticaltext;
 opt_bool keepoldvectorfont;
 
 ESETTING( wxXmlNode* aSetting, IO_BASE* aIo = nullptr );
};
 
 
struct EGRID : public EAGLE_BASE
{
 /*
 * <!ELEMENT grid EMPTY>
 * <!ATTLIST grid
 * distance %Real; #IMPLIED
 * unitdist %GridUnit; #IMPLIED
 * unit %GridUnit; #IMPLIED
 * style %GridStyle; "lines"
 * multiple %Int; "1"
 * display %Bool; "no"
 * altdistance %Real; #IMPLIED
 * altunitdist %GridUnit; #IMPLIED
 * altunit %GridUnit; #IMPLIED
 * >
 */
 opt_double distance;
 opt_wxString unitdist;
 opt_wxString unit;
 opt_wxString style;
 opt_int multiple;
 opt_bool display;
 opt_double altdistance;
 opt_wxString altunitdist;
 opt_wxString altunit;
 
 EGRID( wxXmlNode* aGrid, IO_BASE* aIo = nullptr );
};
 
 
struct EFILTER : public EAGLE_BASE
{
 /*
 * <!ELEMENT filter EMPTY>
 * <!ATTLIST filter
 * name %String; #REQUIRED
 * expression %String; #REQUIRED
 * >
 */
 wxString name;
 wxString expression;
 
 EFILTER( wxXmlNode* aGrid, IO_BASE* aIo = nullptr );
};
 
 
struct EPACKAGE : public EAGLE_BASE
{
 /*
 * <!ELEMENT package (description?, (polygon | wire | text | dimension | circle |
 * rectangle | frame | hole | pad | smd)*)>
 * <!ATTLIST package
 * name %String; #REQUIRED
 * urn %Urn; ""
 * locally_modified %Bool; "no"
 * library_version %Int; ""
 * library_locally_modified %Bool; "no"
 * >
 * <!-- library_version and library_locally_modified: Only in managed libraries
 * inside boards or schematics -->
 */
 wxString name;
 opt_wxString urn;
 opt_bool locally_modified;
 opt_int library_version;
 opt_bool library_locally_modified;
 
 std::optional<EDESCRIPTION> description;
 std::vector<std::unique_ptr<EPOLYGON>> polygons;
 std::vector<std::unique_ptr<EWIRE>> wires;
 std::vector<std::unique_ptr<ETEXT>> texts;
 std::vector<std::unique_ptr<EDIMENSION>> dimensions;
 std::vector<std::unique_ptr<ECIRCLE>> circles;
 std::vector<std::unique_ptr<ERECT>> rectangles;
 std::vector<std::unique_ptr<EFRAME>> frames;
 std::vector<std::unique_ptr<EHOLE>> holes;
 std::vector<std::unique_ptr<EPAD>> thtpads;
 std::vector<std::unique_ptr<ESMD>> smdpads;
 
 EPACKAGE( wxXmlNode* aPackage, IO_BASE* aIo = nullptr );
};
 
 
struct EPACKAGEINSTANCE : public EAGLE_BASE
{
 /*
 * <!ELEMENT packageinstance EMPTY>
 * <!ATTLIST packageinstance
 * name %String; #REQUIRED
 * >
 */
 wxString name;
 
 EPACKAGEINSTANCE( wxXmlNode* aPackageInstance, IO_BASE* aIo = nullptr );
};
 
 
struct EPACKAGE3D : public EAGLE_BASE
{
 /*
 * <!ELEMENT package3d (description?, packageinstances?)>
 * <!ATTLIST package3d
 * name %String; ""
 * urn %Urn; #REQUIRED
 * type %Package3dType; #REQUIRED
 * library_version %Int; ""
 * library_locally_modified %Bool; "no"
 * >
 * <!-- library_version and library_locally_modified: Only in managed libraries
 * inside boards or schematics -->
 */
 wxString name;
 wxString urn;
 wxString type;
 opt_int library_version;
 opt_bool library_locally_modified;
 
 std::optional<EDESCRIPTION> description;
 std::vector<std::unique_ptr<EPACKAGEINSTANCE>> packageinstances;
 
 EPACKAGE3D( wxXmlNode* aPackage3d, IO_BASE* aIo = nullptr );
};
 
 
struct ESYMBOL : public EAGLE_BASE
{
 /*
 * <!ELEMENT symbol (description?, (polygon | wire | text | dimension | pin | circle |
 * rectangle | frame)*)>
 * <!ATTLIST symbol
 * name %String; #REQUIRED
 * urn %Urn; ""
 * locally_modified %Bool; "no"
 * library_version %Int; ""
 * library_locally_modified %Bool; "no"
 * >
 * <!-- library_version and library_locally_modified: Only in managed libraries
 * inside boards or schematics -->
 */
 
 wxString name;
 opt_wxString urn;
 opt_bool locally_modified;
 opt_int library_version;
 opt_bool library_locally_modified;
 
 std::optional<EDESCRIPTION> description;
 std::vector<std::unique_ptr<EPOLYGON>> polygons;
 std::vector<std::unique_ptr<EWIRE>> wires;
 std::vector<std::unique_ptr<ETEXT>> texts;
 std::vector<std::unique_ptr<EDIMENSION>> dimensions;
 std::vector<std::unique_ptr<EPIN>> pins;
 std::vector<std::unique_ptr<ECIRCLE>> circles;
 std::vector<std::unique_ptr<ERECT>> rectangles;
 std::vector<std::unique_ptr<EFRAME>> frames;
 
 ESYMBOL( wxXmlNode* aSymbol, IO_BASE* aIo = nullptr );
};
 
 
struct ELIBRARY : public EAGLE_BASE
{
 /*
 * <!ELEMENT library (description?, packages?, packages3d?, symbols?, devicesets?)>
 * <!ATTLIST library
 * name %String; #REQUIRED
 * urn %Urn; ""
 * >
 * <!-- name: Only in libraries used inside boards or schematics -->
 * <!-- urn: Only in online libraries used inside boards or schematics -->
 */
 wxString name;
 opt_wxString urn;
 
 std::optional<EDESCRIPTION> description;
 std::map<wxString, std::unique_ptr<EPACKAGE>> packages;
 std::map<wxString, std::unique_ptr<EPACKAGE3D>> packages3d;
 std::map<wxString, std::unique_ptr<ESYMBOL>> symbols;
 std::map<wxString, std::unique_ptr<EDEVICE_SET>> devicesets;
 
 ELIBRARY( wxXmlNode* aLibrary, IO_BASE* aIo = nullptr );
};
 
 
struct EAPPROVED : public EAGLE_BASE
{
 /*
 * <!ELEMENT approved EMPTY>
 * <!ATTLIST approved
 * hash %String; #REQUIRED
 * >
 */
 wxString hash;
 
 EAPPROVED( wxXmlNode* aApproved, IO_BASE* aIo = nullptr );
};
 
 
struct ESCHEMATIC : public EAGLE_BASE
{
 /*
 * <!ELEMENT schematic (description?, libraries?, attributes?, variantdefs?, classes?,
 * modules?, groups?, parts?, sheets?, errors?)>
 * <!ATTLIST schematic
 * xreflabel %String; #IMPLIED
 * xrefpart %String; #IMPLIED
 * >
 */
 opt_wxString xreflabel;
 opt_wxString xrefpart;
 
 std::optional<EDESCRIPTION> description;
 std::map<wxString, std::unique_ptr<ELIBRARY>> libraries;
 std::map<wxString, std::unique_ptr<EATTR>> attributes;
 std::map<wxString, std::unique_ptr<EVARIANTDEF>> variantdefs;
 std::map<wxString, std::unique_ptr<ECLASS>> classes;
 std::map<wxString, std::unique_ptr<EMODULE>> modules;
 std::map<wxString, std::unique_ptr<ESCHEMATIC_GROUP>> groups;
 std::map<wxString, std::unique_ptr<EPART>> parts;
 std::vector<std::unique_ptr<ESHEET>> sheets;
 std::vector<std::unique_ptr<EAPPROVED>> errors;
 
 ESCHEMATIC( wxXmlNode* aSchematic, IO_BASE* aIo = nullptr );
};
 
 
struct EDRAWING : public EAGLE_BASE
{
 /*
 * <!ELEMENT drawing (settings?, grid?, filters?, layers, (library | schematic | board))>
 */
 std::vector<std::unique_ptr<ESETTING>> settings;
 std::optional<EGRID> grid;
 std::vector<std::unique_ptr<EFILTER>> filters;
 std::vector<std::unique_ptr<ELAYER>> layers;
 std::optional<ESCHEMATIC> schematic;
 std::optional<ELIBRARY> library;
 // std::optional<std::unique_ptr<EBOARD>> board;
 
 EDRAWING( wxXmlNode* aDrawing, IO_BASE* aIo = nullptr );
};
 
 
struct EAGLE_DOC : public EAGLE_BASE
{
 /*
 * <!ELEMENT eagle (compatibility?, drawing, compatibility?)>
 * <!ATTLIST eagle
 * version %Real; #REQUIRED
 * >
 * <!-- version: The EAGLE program version that generated this file, in the
 * form V.RR -->
 */
 
 wxString version;
 
 std::unique_ptr<EDRAWING> drawing;
 std::optional<ECOMPATIBILITY> compatibility;
 
 EAGLE_DOC( wxXmlNode* aEagleDoc, IO_BASE* aIo = nullptr );
};
 
 
#endif // _EAGLE_PARSER_H_