eagle_parser.cpp

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-2021 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
 */

#include <plugins/eagle/eagle_parser.h>

#include <string_utils.h>
#include <richio.h>
#include <wx/log.h>

#include <functional>
#include <cstdio>

constexpr auto DEFAULT_ALIGNMENT = ETEXT::BOTTOM_LEFT;


wxString escapeName( const wxString& aNetName )
{
 wxString ret( aNetName );

 ret.Replace( wxT( "!" ), wxT( "~" ) );

 return ConvertToNewOverbarNotation( ret );
}


template<> template<>
OPTIONAL_XML_ATTRIBUTE<wxString>::OPTIONAL_XML_ATTRIBUTE( wxString aData )
{
 m_isAvailable = !aData.IsEmpty();

 if( m_isAvailable )
 Set( aData );
}


ECOORD::ECOORD( const wxString& aValue, enum ECOORD::EAGLE_UNIT aUnit )
{
 // This array is used to adjust the fraction part value basing on the number of digits
 // in the fraction.
 constexpr int DIVIDERS[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };
 constexpr unsigned int DIVIDERS_MAX_IDX = sizeof( DIVIDERS ) / sizeof( DIVIDERS[0] ) - 1;

 int integer, fraction, pre_fraction, post_fraction;

 // The following check is needed to handle correctly negative fractions where the integer
 // part == 0.
 bool negative = ( aValue[0] == '-' );

 // %n is used to find out how many digits contains the fraction part, e.g. 0.001 contains 3
 // digits.
 int ret = sscanf( aValue.c_str(), "%d.%n%d%n", &integer, &pre_fraction, &fraction,
 &post_fraction );

 if( ret == 0 )
 throw XML_PARSER_ERROR( "Invalid coordinate" );

 // process the integer part
 value = ConvertToNm( integer, aUnit );

 // process the fraction part
 if( ret == 2 )
 {
 int digits = post_fraction - pre_fraction;

 // adjust the number of digits if necessary as we cannot handle anything smaller than
 // nanometers (rounding).
 if( (unsigned) digits > DIVIDERS_MAX_IDX )
 {
 int diff = digits - DIVIDERS_MAX_IDX;
 digits = DIVIDERS_MAX_IDX;
 fraction /= DIVIDERS[diff];
 }

 int frac_value = ConvertToNm( fraction, aUnit ) / DIVIDERS[digits];

 // keep the sign in mind
 value = negative ? value - frac_value : value + frac_value;
 }
}


long long int ECOORD::ConvertToNm( int aValue, enum EAGLE_UNIT aUnit )
{
 long long int ret;

 switch( aUnit )
 {
 default:
 case EU_NM: ret = aValue; break;
 case EU_MM: ret = (long long) aValue * 1000000; break;
 case EU_INCH: ret = (long long) aValue * 25400000; break;
 case EU_MIL: ret = (long long) aValue * 25400; break;
 }

 if( ( ret > 0 ) != ( aValue > 0 ) )
 wxLogError( _( "Invalid size %lld: too large" ), aValue );

 return ret;
}


// Template specializations below parse wxString to the used types:
// - wxString (preferred)
// - string
// - double
// - int
// - bool
// - EROT
// - ECOORD

template <>
wxString Convert<wxString>( const wxString& aValue )
{
 return aValue;
}


template <>
std::string Convert<std::string>( const wxString& aValue )
{
 return std::string( aValue.ToUTF8() );
}


template <>
double Convert<double>( const wxString& aValue )
{
 double value;

 if( aValue.ToCDouble( &value ) )
 return value;
 else
 throw XML_PARSER_ERROR( "Conversion to double failed. Original value: '" +
 aValue.ToStdString() + "'." );
}


template <>
int Convert<int>( const wxString& aValue )
{
 if( aValue.IsEmpty() )
 throw XML_PARSER_ERROR( "Conversion to int failed. Original value is empty." );

 return wxAtoi( aValue );
}


template <>
bool Convert<bool>( const wxString& aValue )
{
 if( aValue != wxT( "yes" ) && aValue != wxT( "no" ) )
 throw XML_PARSER_ERROR( "Conversion to bool failed. Original value, '" +
 aValue.ToStdString() +
 "', is neither 'yes' nor 'no'." );

 return aValue == wxT( "yes" );
}


template<>
EROT Convert<EROT>( const wxString& aRot )
{
 EROT value;

 value.spin = aRot.find( 'S' ) != aRot.npos;
 value.mirror = aRot.find( 'M' ) != aRot.npos;
 value.degrees = strtod( aRot.c_str()
 + 1 // skip leading 'R'
 + int( value.spin ) // skip optional leading 'S'
 + int( value.mirror ), // skip optional leading 'M'
 nullptr );

 return value;
}


template<>
ECOORD Convert<ECOORD>( const wxString& aCoord )
{
 // Eagle uses millimeters as the default unit
 return ECOORD( aCoord, ECOORD::EAGLE_UNIT::EU_MM );
}


template<typename T>
T parseRequiredAttribute( wxXmlNode* aNode, const wxString& aAttribute )
{
 wxString value;

 if( aNode->GetAttribute( aAttribute, &value ) )
 return Convert<T>( value );
 else
 throw XML_PARSER_ERROR( "The required attribute " + aAttribute + " is missing." );
}


template<typename T>
OPTIONAL_XML_ATTRIBUTE<T> parseOptionalAttribute( wxXmlNode* aNode, const wxString& aAttribute )
{
 return OPTIONAL_XML_ATTRIBUTE<T>( aNode->GetAttribute( aAttribute ) );
}


NODE_MAP MapChildren( wxXmlNode* aCurrentNode )
{
 // Map node_name -> node_pointer
 NODE_MAP nodesMap;

 // Loop through all children mapping them in nodesMap
 if( aCurrentNode )
 aCurrentNode = aCurrentNode->GetChildren();

 while( aCurrentNode )
 {
 // Create a new pair in the map
 // key: current node name
 // value: current node pointer
 nodesMap[aCurrentNode->GetName()] = aCurrentNode;

 // Get next child
 aCurrentNode = aCurrentNode->GetNext();
 }

 return nodesMap;
}


wxPoint ConvertArcCenter( const wxPoint& aStart, const wxPoint& aEnd, double aAngle )
{
 // Eagle give us start and end.
 // S_ARC wants start to give the center, and end to give the start.
 double dx = aEnd.x - aStart.x, dy = aEnd.y - aStart.y;
 wxPoint mid = ( aStart + aEnd ) / 2;

 double dlen = sqrt( dx*dx + dy*dy );

 if( !std::isnormal( dlen ) || !std::isnormal( aAngle ) )
 {
 THROW_IO_ERROR( wxString::Format( _( "Invalid Arc with radius %f and angle %f" ),
 dlen,
 aAngle ) );
 }

 double dist = dlen / ( 2 * tan( DEG2RAD( aAngle ) / 2 ) );

 wxPoint center(
 mid.x + dist * ( dy / dlen ),
 mid.y - dist * ( dx / dlen )
 );

 return center;
}


static int parseAlignment( const wxString& aAlignment )
{
 // (bottom-left | bottom-center | bottom-right | center-left |
 // center | center-right | top-left | top-center | top-right)
 if( aAlignment == wxT( "center" ) )
 return ETEXT::CENTER;
 else if( aAlignment == wxT( "center-right" ) )
 return ETEXT::CENTER_RIGHT;
 else if( aAlignment == wxT( "top-left" ) )
 return ETEXT::TOP_LEFT;
 else if( aAlignment == wxT( "top-center" ) )
 return ETEXT::TOP_CENTER;
 else if( aAlignment == wxT( "top-right" ) )
 return ETEXT::TOP_RIGHT;
 else if( aAlignment == wxT( "bottom-left" ) )
 return ETEXT::BOTTOM_LEFT;
 else if( aAlignment == wxT( "bottom-center" ) )
 return ETEXT::BOTTOM_CENTER;
 else if( aAlignment == wxT( "bottom-right" ) )
 return ETEXT::BOTTOM_RIGHT;
 else if( aAlignment == wxT( "center-left" ) )
 return ETEXT::CENTER_LEFT;

 return DEFAULT_ALIGNMENT;
}


EWIRE::EWIRE( wxXmlNode* aWire )
{
 /*
 <!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 -- only applicable for airwires --
 style %WireStyle; "continuous"
 curve %WireCurve; "0"
 cap %WireCap; "round" -- only applicable if 'curve' is not zero --
 >
 */

 x1 = parseRequiredAttribute<ECOORD>( aWire, wxT( "x1" ) );
 y1 = parseRequiredAttribute<ECOORD>( aWire, wxT( "y1" ) );
 x2 = parseRequiredAttribute<ECOORD>( aWire, wxT( "x2" ) );
 y2 = parseRequiredAttribute<ECOORD>( aWire, wxT( "y2" ) );
 width = parseRequiredAttribute<ECOORD>( aWire, wxT( "width" ) );
 layer = parseRequiredAttribute<int>( aWire, wxT( "layer" ) );
 curve = parseOptionalAttribute<double>( aWire, wxT( "curve" ) );

 opt_wxString s = parseOptionalAttribute<wxString>( aWire, wxT( "style" ) );

 if( s == wxT( "continuous" ) )
 style = EWIRE::CONTINUOUS;
 else if( s == wxT( "longdash" ) )
 style = EWIRE::LONGDASH;
 else if( s == wxT( "shortdash" ) )
 style = EWIRE::SHORTDASH;
 else if( s == wxT( "dashdot" ) )
 style = EWIRE::DASHDOT;

 s = parseOptionalAttribute<wxString>( aWire, wxT( "cap" ) );

 if( s == wxT( "round" ) )
 cap = EWIRE::ROUND;
 else if( s == wxT( "flat" ) )
 cap = EWIRE::FLAT;
}


EJUNCTION::EJUNCTION( wxXmlNode* aJunction )
{
 /*
 <!ELEMENT junction EMPTY>
 <!ATTLIST junction
 x %Coord; #REQUIRED
 y %Coord; #REQUIRED
 >
 */

 x = parseRequiredAttribute<ECOORD>( aJunction, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aJunction, wxT( "y" ) );
}


ELABEL::ELABEL( wxXmlNode* aLabel, const wxString& aNetName )
{
 /*
 <!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"
 >
 */

 x = parseRequiredAttribute<ECOORD>( aLabel, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aLabel, wxT( "y" ) );
 size = parseRequiredAttribute<ECOORD>( aLabel, wxT( "size" ) );
 layer = parseRequiredAttribute<int>( aLabel, wxT( "layer" ) );
 rot = parseOptionalAttribute<EROT>( aLabel, wxT( "rot" ) );
 xref = parseOptionalAttribute<wxString>( aLabel, wxT( "xref" ) );
 netname = aNetName;
}


EVIA::EVIA( wxXmlNode* aVia )
{
 /*
 <!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"
 >
 */

 x = parseRequiredAttribute<ECOORD>( aVia, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aVia, wxT( "y" ) );

 wxString ext = parseRequiredAttribute<wxString>( aVia, wxT( "extent" ) );
 sscanf( ext.c_str(), "%d-%d", &layer_front_most, &layer_back_most );

 drill = parseRequiredAttribute<ECOORD>( aVia, wxT( "drill" ) );
 diam = parseOptionalAttribute<ECOORD>( aVia, wxT( "diameter" ) );
 shape = parseOptionalAttribute<wxString>( aVia, wxT( "shape" ) );
}


ECIRCLE::ECIRCLE( wxXmlNode* aCircle )
{
 /*
 <!ELEMENT circle EMPTY>
 <!ATTLIST circle
 x %Coord; #REQUIRED
 y %Coord; #REQUIRED
 radius %Coord; #REQUIRED
 width %Dimension; #REQUIRED
 layer %Layer; #REQUIRED
 >
 */

 x = parseRequiredAttribute<ECOORD>( aCircle, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aCircle, wxT( "y" ) );
 radius = parseRequiredAttribute<ECOORD>( aCircle, wxT( "radius" ) );
 width = parseRequiredAttribute<ECOORD>( aCircle, wxT( "width" ) );
 layer = parseRequiredAttribute<int>( aCircle, wxT( "layer" ) );
}


ERECT::ERECT( wxXmlNode* aRect )
{
 /*
 <!ELEMENT rectangle EMPTY>
 <!ATTLIST rectangle
 x1 %Coord; #REQUIRED
 y1 %Coord; #REQUIRED
 x2 %Coord; #REQUIRED
 y2 %Coord; #REQUIRED
 layer %Layer; #REQUIRED
 rot %Rotation; "R0"
 >
 */

 x1 = parseRequiredAttribute<ECOORD>( aRect, wxT( "x1" ) );
 y1 = parseRequiredAttribute<ECOORD>( aRect, wxT( "y1" ) );
 x2 = parseRequiredAttribute<ECOORD>( aRect, wxT( "x2" ) );
 y2 = parseRequiredAttribute<ECOORD>( aRect, wxT( "y2" ) );
 layer = parseRequiredAttribute<int>( aRect, wxT( "layer" ) );
 rot = parseOptionalAttribute<EROT>( aRect, wxT( "rot" ) );
}


EATTR::EATTR( wxXmlNode* aTree )
{
 /*
 <!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" -- only in <element> or <instance> context --
 constant %Bool; "no" -- only in <device> context --
 >
 */

 name = parseRequiredAttribute<wxString>( aTree, wxT( "name" ) );
 value = parseOptionalAttribute<wxString>( aTree, wxT( "value" ) );

 x = parseOptionalAttribute<ECOORD>( aTree, wxT( "x" ) );
 y = parseOptionalAttribute<ECOORD>( aTree, wxT( "y" ) );
 size = parseOptionalAttribute<ECOORD>( aTree, wxT( "size" ) );

 layer = parseOptionalAttribute<int>( aTree, wxT( "layer" ) );
 ratio = parseOptionalAttribute<double>( aTree, wxT( "ratio" ) );
 rot = parseOptionalAttribute<EROT>( aTree, wxT( "rot" ) );

 opt_wxString stemp = parseOptionalAttribute<wxString>( aTree, wxT( "display" ) );

 // (off | value | name | both)
 if( stemp == wxT( "off" ) )
 display = EATTR::Off;
 else if( stemp == wxT( "name" ) )
 display = EATTR::NAME;
 else if( stemp == wxT( "both" ) )
 display = EATTR::BOTH;
 else // "value" is the default
 display = EATTR::VALUE;

 stemp = parseOptionalAttribute<wxString>( aTree, wxT( "align" ) );

 align = stemp ? parseAlignment( *stemp ) : DEFAULT_ALIGNMENT;
}


EDIMENSION::EDIMENSION( wxXmlNode* aDimension )
{
 /*
 <!ELEMENT dimension EMPTY>
 <!ATTLIST dimension
 x1 %Coord; #REQUIRED
 y1 %Coord; #REQUIRED
 x2 %Coord; #REQUIRED
 y2 %Coord; #REQUIRED
 x3 %Coord; #REQUIRED
 y3 %Coord; #REQUIRED
 textsize %Coord;
 layer %Layer; #REQUIRED
 dtype %DimensionType; "parallel"
 >
 */

 x1 = parseRequiredAttribute<ECOORD>( aDimension, wxT( "x1" ) );
 y1 = parseRequiredAttribute<ECOORD>( aDimension, wxT( "y1" ) );
 x2 = parseRequiredAttribute<ECOORD>( aDimension, wxT( "x2" ) );
 y2 = parseRequiredAttribute<ECOORD>( aDimension, wxT( "y2" ) );
 x3 = parseRequiredAttribute<ECOORD>( aDimension, wxT( "x3" ) );
 y3 = parseRequiredAttribute<ECOORD>( aDimension, wxT( "y3" ) );
 textsize = parseOptionalAttribute<ECOORD>( aDimension, wxT( "textsize" ) );
 layer = parseRequiredAttribute<int>( aDimension, wxT( "layer" ) );
 dimensionType = parseOptionalAttribute<wxString>( aDimension, wxT( "dtype" ) );
}


ETEXT::ETEXT( wxXmlNode* aText )
{
 /*
 <!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"
 >
 */

 text = aText->GetNodeContent();
 x = parseRequiredAttribute<ECOORD>( aText, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aText, wxT( "y" ) );
 size = parseRequiredAttribute<ECOORD>( aText, wxT( "size" ) );
 layer = parseRequiredAttribute<int>( aText, wxT( "layer" ) );

 font = parseOptionalAttribute<wxString>( aText, wxT( "font" ) );
 ratio = parseOptionalAttribute<double>( aText, wxT( "ratio" ) );
 rot = parseOptionalAttribute<EROT>( aText, wxT( "rot" ) );

 opt_wxString stemp = parseOptionalAttribute<wxString>( aText, wxT( "align" ) );

 align = stemp ? parseAlignment( *stemp ) : DEFAULT_ALIGNMENT;
}


wxSize ETEXT::ConvertSize() const
{
 wxSize textsize;

 if( font )
 {
 const wxString& fontName = font.CGet();

 if( fontName == wxT( "vector" ) )
 {
 textsize = wxSize( size.ToSchUnits(), size.ToSchUnits() );
 }
 else if( fontName == wxT( "fixed" ) )
 {
 textsize = wxSize( size.ToSchUnits(), size.ToSchUnits() * 0.80 );
 }
 else
 {
 textsize = wxSize( size.ToSchUnits(), size.ToSchUnits() );
 }
 }
 else
 {
 textsize = wxSize( size.ToSchUnits() * 0.85, size.ToSchUnits() );
 }

 return textsize;
}


EFRAME::EFRAME( wxXmlNode* aFrameNode )
{
 /*
 * <!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"
 * >
 */
 border_left = true;
 border_top = true;
 border_right = true;
 border_bottom = true;

 x1 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "x1" ) );
 y1 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "y1" ) );
 x2 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "x2" ) );
 y2 = parseRequiredAttribute<ECOORD>( aFrameNode, wxT( "y2" ) );
 columns = parseRequiredAttribute<int>( aFrameNode, wxT( "columns" ) );
 rows = parseRequiredAttribute<int>( aFrameNode, wxT( "rows" ) );
 layer = parseRequiredAttribute<int>( aFrameNode, wxT( "layer" ) );
 border_left = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-left" ) );
 border_top = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-top" ) );
 border_right = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-right" ) );
 border_bottom = parseOptionalAttribute<bool>( aFrameNode, wxT( "border-bottom" ) );
}


EPAD_COMMON::EPAD_COMMON( wxXmlNode* aPad )
{
 // #REQUIRED says DTD, throw exception if not found
 name = parseRequiredAttribute<wxString>( aPad, wxT( "name" ) );
 x = parseRequiredAttribute<ECOORD>( aPad, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aPad, wxT( "y" ) );
 rot = parseOptionalAttribute<EROT>( aPad, wxT( "rot" ) );
 stop = parseOptionalAttribute<bool>( aPad, wxT( "stop" ) );
 thermals = parseOptionalAttribute<bool>( aPad, wxT( "thermals" ) );
}


EPAD::EPAD( wxXmlNode* aPad )
 : EPAD_COMMON( aPad )
{
 /*
 <!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"
 >
 */

 // #REQUIRED says DTD, throw exception if not found
 drill = parseRequiredAttribute<ECOORD>( aPad, wxT( "drill" ) );

 // Optional attributes
 diameter = parseOptionalAttribute<ECOORD>( aPad, wxT( "diameter" ) );

 opt_wxString s = parseOptionalAttribute<wxString>( aPad, wxT( "shape" ) );

 // (square | round | octagon | long | offset)
 if( s == wxT( "square" ) )
 shape = EPAD::SQUARE;
 else if( s == wxT( "round" ) )
 shape = EPAD::ROUND;
 else if( s == wxT( "octagon" ) )
 shape = EPAD::OCTAGON;
 else if( s == wxT( "long" ) )
 shape = EPAD::LONG;
 else if( s == wxT( "offset" ) )
 shape = EPAD::OFFSET;

 first = parseOptionalAttribute<bool>( aPad, wxT( "first" ) );
}


ESMD::ESMD( wxXmlNode* aSMD )
 : EPAD_COMMON( aSMD )
{
 /*
 <!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"
 >
 */

 // DTD #REQUIRED, throw exception if not found
 dx = parseRequiredAttribute<ECOORD>( aSMD, wxT( "dx" ) );
 dy = parseRequiredAttribute<ECOORD>( aSMD, wxT( "dy" ) );
 layer = parseRequiredAttribute<int>( aSMD, wxT( "layer" ) );

 roundness = parseOptionalAttribute<int>( aSMD, wxT( "roundness" ) );
 cream = parseOptionalAttribute<bool>( aSMD, wxT( "cream" ) );
}


EPIN::EPIN( wxXmlNode* aPin )
{
 /*
 <!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"
 >
 */

 // DTD #REQUIRED, throw exception if not found
 name = parseRequiredAttribute<wxString>( aPin, wxT( "name" ) );
 x = parseRequiredAttribute<ECOORD>( aPin, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aPin, wxT( "y" ) );

 visible = parseOptionalAttribute<wxString>( aPin, wxT( "visible" ) );
 length = parseOptionalAttribute<wxString>( aPin, wxT( "length" ) );
 direction = parseOptionalAttribute<wxString>( aPin, wxT( "direction" ) );
 function = parseOptionalAttribute<wxString>( aPin, wxT( "function" ) );
 swaplevel = parseOptionalAttribute<int>( aPin, wxT( "swaplevel" ) );
 rot = parseOptionalAttribute<EROT>( aPin, wxT( "rot" ) );
}


EVERTEX::EVERTEX( wxXmlNode* aVertex )
{
 /*
 <!ELEMENT vertex EMPTY>
 <!ATTLIST vertex
 x %Coord; #REQUIRED
 y %Coord; #REQUIRED
 curve %WireCurve; "0" -- the curvature from this vertex to the next one --
 >
 */

 x = parseRequiredAttribute<ECOORD>( aVertex, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aVertex, wxT( "y" ) );
 curve = parseOptionalAttribute<double>( aVertex, wxT( "curve" ) );
}


EPOLYGON::EPOLYGON( wxXmlNode* aPolygon )
{
 /*
 <!ATTLIST polygon
 width %Dimension; #REQUIRED
 layer %Layer; #REQUIRED
 spacing %Dimension; #IMPLIED
 pour %PolygonPour; "solid"
 isolate %Dimension; #IMPLIED -- only in <signal> or <package> context --
 orphans %Bool; "no" -- only in <signal> context --
 thermals %Bool; "yes" -- only in <signal> context --
 rank %Int; "0" -- 1..6 in <signal> context, 0 or 7 in
 <package> context --
 >
 */

 width = parseRequiredAttribute<ECOORD>( aPolygon, wxT( "width" ) );
 layer = parseRequiredAttribute<int>( aPolygon, wxT( "layer" ) );

 spacing = parseOptionalAttribute<ECOORD>( aPolygon, wxT( "spacing" ) );
 isolate = parseOptionalAttribute<ECOORD>( aPolygon, wxT( "isolate" ) );
 opt_wxString s = parseOptionalAttribute<wxString>( aPolygon, wxT( "pour" ) );

 // default pour to solid fill
 pour = EPOLYGON::SOLID;

 // (solid | hatch | cutout)
 if( s == wxT( "hatch" ) )
 pour = EPOLYGON::HATCH;
 else if( s == wxT( "cutout" ) )
 pour = EPOLYGON::CUTOUT;

 orphans = parseOptionalAttribute<bool>( aPolygon, wxT( "orphans" ) );
 thermals = parseOptionalAttribute<bool>( aPolygon, wxT( "thermals" ) );
 rank = parseOptionalAttribute<int>( aPolygon, wxT( "rank" ) );
}


EHOLE::EHOLE( wxXmlNode* aHole )
{
 /*
 <!ELEMENT hole EMPTY>
 <!ATTLIST hole
 x %Coord; #REQUIRED
 y %Coord; #REQUIRED
 drill %Dimension; #REQUIRED
 >
 */

 // #REQUIRED:
 x = parseRequiredAttribute<ECOORD>( aHole, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aHole, wxT( "y" ) );
 drill = parseRequiredAttribute<ECOORD>( aHole, wxT( "drill" ) );
}


EELEMENT::EELEMENT( wxXmlNode* aElement )
{
 /*
 <!ELEMENT element (attribute*, variant*)>
 <!ATTLIST element
 name %String; #REQUIRED
 library %String; #REQUIRED
 package %String; #REQUIRED
 value %String; #REQUIRED
 x %Coord; #REQUIRED
 y %Coord; #REQUIRED
 locked %Bool; "no"
 smashed %Bool; "no"
 rot %Rotation; "R0"
 >
 */

 // #REQUIRED
 name = parseRequiredAttribute<wxString>( aElement, wxT( "name" ) );
 library = parseRequiredAttribute<wxString>( aElement, wxT( "library" ) );
 value = parseRequiredAttribute<wxString>( aElement, wxT( "value" ) );
 std::string p = parseRequiredAttribute<std::string>( aElement, wxT( "package" ) );
 ReplaceIllegalFileNameChars( &p, '_' );
 package = wxString::FromUTF8( p.c_str() );

 x = parseRequiredAttribute<ECOORD>( aElement, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aElement, wxT( "y" ) );

 // optional
 locked = parseOptionalAttribute<bool>( aElement, wxT( "locked" ) );
 smashed = parseOptionalAttribute<bool>( aElement, wxT( "smashed" ) );
 rot = parseOptionalAttribute<EROT>( aElement, wxT( "rot" ) );
}


ELAYER::ELAYER( wxXmlNode* aLayer )
{
 /*
 <!ELEMENT layer EMPTY>
 <!ATTLIST layer
 number %Layer; #REQUIRED
 name %String; #REQUIRED
 color %Int; #REQUIRED
 fill %Int; #REQUIRED
 visible %Bool; "yes"
 active %Bool; "yes"
 >
 */

 number = parseRequiredAttribute<int>( aLayer, wxT( "number" ) );
 name = parseRequiredAttribute<wxString>( aLayer, wxT( "name" ) );
 color = parseRequiredAttribute<int>( aLayer, wxT( "color" ) );
 fill = 1; // Temporary value.
 visible = parseOptionalAttribute<bool>( aLayer, wxT( "visible" ) );
 active = parseOptionalAttribute<bool>( aLayer, wxT( "active" ) );
}


EPART::EPART( wxXmlNode* aPart )
{
 /*
 * <!ELEMENT part (attribute*, variant*)>
 * <!ATTLIST part
 * name %String; #REQUIRED
 * library %String; #REQUIRED
 * deviceset %String; #REQUIRED
 * device %String; #REQUIRED
 * technology %String; ""
 * value %String; #IMPLIED
 * >
 */
 // #REQUIRED
 name = parseRequiredAttribute<wxString>( aPart, wxT( "name" ) );
 library = parseRequiredAttribute<wxString>( aPart, wxT( "library" ) );
 deviceset = parseRequiredAttribute<wxString>( aPart, wxT( "deviceset" ) );
 device = parseRequiredAttribute<wxString>( aPart, wxT( "device" ) );
 technology = parseOptionalAttribute<wxString>( aPart, wxT( "technology" ) );
 value = parseOptionalAttribute<wxString>( aPart, wxT( "value" ) );

 for( wxXmlNode* child = aPart->GetChildren(); child; child = child->GetNext() )
 {
 if( child->GetName() == wxT( "attribute" ) )
 {
 std::string aname, avalue;

 for( wxXmlAttribute* x = child->GetAttributes(); x; x = x->GetNext() )
 {
 if( x->GetName() == wxT( "name" ) )
 aname = x->GetValue();
 else if( x->GetName() == wxT( "value" ) )
 avalue = x->GetValue();
 }

 if( aname.size() && avalue.size() )
 attribute[aname] = avalue;
 }
 else if( child->GetName() == wxT( "variant" ) )
 {
 std::string aname, avalue;

 for( wxXmlAttribute* x = child->GetAttributes(); x; x = x->GetNext() )
 {
 if( x->GetName() == wxT( "name" ) )
 aname = x->GetValue();
 else if( x->GetName() == wxT( "value" ) )
 avalue = x->GetValue();
 }

 if( aname.size() && avalue.size() )
 variant[aname] = avalue;
 }
 }
}


EINSTANCE::EINSTANCE( wxXmlNode* aInstance )
{
 /*
 * <!ELEMENT instance (attribute)*>
 * <!ATTLIST instance
 * part %String; #REQUIRED
 * gate %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * smashed %Bool; "no"
 * rot %Rotation; "R0"
 * >
 */
 part = parseRequiredAttribute<wxString>( aInstance, wxT( "part" ) );
 gate = parseRequiredAttribute<wxString>( aInstance, wxT( "gate" ) );

 x = parseRequiredAttribute<ECOORD>( aInstance, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aInstance, wxT( "y" ) );

 // optional
 smashed = parseOptionalAttribute<bool>( aInstance, wxT( "smashed" ) );
 rot = parseOptionalAttribute<EROT>( aInstance, wxT( "rot" ) );
}


EGATE::EGATE( wxXmlNode* aGate )
{
 /*
 * <!ELEMENT gate EMPTY>
 * <!ATTLIST gate
 * name %String; #REQUIRED
 * symbol %String; #REQUIRED
 * x %Coord; #REQUIRED
 * y %Coord; #REQUIRED
 * addlevel %GateAddLevel; "next"
 * swaplevel %Int; "0"
 * >
 */

 name = parseRequiredAttribute<wxString>( aGate, wxT( "name" ) );
 symbol = parseRequiredAttribute<wxString>( aGate, wxT( "symbol" ) );

 x = parseRequiredAttribute<ECOORD>( aGate, wxT( "x" ) );
 y = parseRequiredAttribute<ECOORD>( aGate, wxT( "y" ) );

 opt_wxString stemp = parseOptionalAttribute<wxString>( aGate, wxT( "addlevel" ) );

 // (off | value | name | both)
 if( stemp == wxT( "must" ) )
 addlevel = EGATE::MUST;
 else if( stemp == wxT( "can" ) )
 addlevel = EGATE::CAN;
 else if( stemp == wxT( "next" ) )
 addlevel = EGATE::NEXT;
 else if( stemp == wxT( "request" ) )
 addlevel = EGATE::REQUEST;
 else if( stemp == wxT( "always" ) )
 addlevel = EGATE::ALWAYS;
 else
 addlevel = EGATE::NEXT;
}


ECONNECT::ECONNECT( wxXmlNode* aConnect )
{
 /*
 * <!ELEMENT connect EMPTY>
 * <!ATTLIST connect
 * gate %String; #REQUIRED
 * pin %String; #REQUIRED
 * pad %String; #REQUIRED
 * route %ContactRoute; "all"
 * >
 */
 gate = parseRequiredAttribute<wxString>( aConnect, wxT( "gate" ) );
 pin = parseRequiredAttribute<wxString>( aConnect, wxT( "pin" ) );
 pad = parseRequiredAttribute<wxString>( aConnect, wxT( "pad" ) );
}


EDEVICE::EDEVICE( wxXmlNode* aDevice )
{
 /*
 <!ELEMENT device (connects?, technologies?)>
 <!ATTLIST device
 name %String; ""
 package %String; #IMPLIED
 >
 */
 name = parseRequiredAttribute<wxString>( aDevice, wxT( "name" ) );
 opt_wxString pack = parseOptionalAttribute<wxString>( aDevice, wxT( "package" ) );

 if( pack )
 {
 std::string p( pack->c_str() );
 ReplaceIllegalFileNameChars( &p, '_' );
 package.Set( wxString::FromUTF8( p.c_str() ) );
 }

 NODE_MAP aDeviceChildren = MapChildren( aDevice );
 wxXmlNode* connectNode = getChildrenNodes( aDeviceChildren, wxT( "connects" ) );

 while( connectNode )
 {
 connects.emplace_back( connectNode );
 connectNode = connectNode->GetNext();
 }
}


EDEVICE_SET::EDEVICE_SET( wxXmlNode* aDeviceSet )
{
 /*
 <!ELEMENT deviceset (description?, gates, devices)>
 <!ATTLIST deviceset
 name %String; #REQUIRED
 prefix %String; ""
 uservalue %Bool; "no"
 >
 */

 name = parseRequiredAttribute<wxString>( aDeviceSet, wxT( "name" ) );
 prefix = parseOptionalAttribute<wxString>( aDeviceSet, wxT( "prefix" ) );
 uservalue = parseOptionalAttribute<bool>( aDeviceSet, wxT( "uservalue" ) );

 /* Russell: Parsing of devices and gates moved to sch_eagle_plugin.cpp
 *
 //TODO: description

 NODE_MAP aDeviceSetChildren = MapChildren(aDeviceSet);
 wxXmlNode* deviceNode = getChildrenNodes(aDeviceSetChildren, wxT( "device" ));

 while(deviceNode){
 devices.push_back(EDEVICE(deviceNode));
 deviceNode->GetNext();
 }

 wxXmlNode* gateNode = getChildrenNodes(aDeviceSetChildren, wxT( "gate" ));

 while(gateNode){
 gates.push_back(EGATE(gateNode));
 gateNode->GetNext();
 }
 */

}


ECLASS::ECLASS( wxXmlNode* aClass )
{
 number = parseRequiredAttribute<wxString>( aClass, wxT( "number" ) );
 name = parseRequiredAttribute<wxString>( aClass, wxT( "name" ) );

 for( wxXmlNode* child = aClass->GetChildren(); child; child = child->GetNext() )
 {
 if( child->GetName() == wxT( "clearance" ) )
 {
 wxString to = parseRequiredAttribute<wxString>( child, wxT( "class" ) );
 ECOORD value = parseRequiredAttribute<ECOORD>( child, wxT( "value" ) );

 clearanceMap[to] = value;
 }
 }
}