Merge pull request #3 from saurabhb17/master

secondary files

1 files changed, 1561 insertions, 0 deletions

diff --git a/new/sch_sweet_parser.cpp b/new/sch_sweet_parser.cpp
new file mode 100644
index 0000000..f0be7bd
--- /dev/null
+++ b/new/sch_sweet_parser.cpp
@@ -0,0 +1,1561 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2011 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 2010 KiCad Developers, see change_log.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
+ */
+
+#include <sch_sweet_parser.h>
+#include <sch_part.h>
+#include <sch_lib_table.h>
+#include <sch_lpid.h>
+
+#include <macros.h>
+
+using namespace SCH;
+using namespace PR;
+
+
+#define MAX_INHERITANCE_NESTING     6       ///< max depth of inheritance, no problem going larger
+
+
+static inline int internal( const STRING& aCoord )
+{
+    return LogicalToInternal( strtod( aCoord.c_str(), NULL ) );
+}
+
+static inline int fromWidth( const STRING& aWidth )
+{
+    return WidthToInternal( strtod( aWidth.c_str(), NULL ) );
+}
+
+static inline int fromFontz( const STRING& aFontSize )
+{
+    return FontzToInternal( strtod( aFontSize.c_str(), NULL ) );
+}
+
+
+/**
+ * Enum PartBit
+ * is a set of bit positions that can be used to create flag bits within
+ * PART::contains to indicate what state the PART is in and what it contains, i.e.
+ * whether the PART has been parsed, and what the PART contains, categorically.
+ */
+enum PartBit
+{
+    parsed,     ///< have parsed this part already, otherwise 'body' text must be parsed
+    extends,    ///< saw "extends" keyword, inheriting from another PART
+    value,
+    anchor,
+    reference,
+    footprint,
+    datasheet,
+    model,
+    keywords,
+};
+
+
+/// Function PB
+/// is a PartBit shifter for PART::contains field.
+static inline const int PB( PartBit oneBitOnly )
+{
+    return ( 1 << oneBitOnly );
+}
+
+
+void SWEET_PARSER::Parse( PART* me, LIB_TABLE* aTable ) throw( IO_ERROR, PARSE_ERROR )
+{
+    T       tok;
+
+    libs = aTable;
+
+    // empty everything out, could be re-parsing this object and it may not be empty.
+    me->clear();
+
+#if 0
+    // Be flexible regarding the starting point of the stream.
+    // Caller may not have read the first two tokens out of the
+    // stream: T_LEFT and T_part, so ignore them if seen here.
+    // The 1st two tokens T_LEFT and T_part are then optional in the grammar.
+    if( ( tok = NextTok() ) == T_LEFT )
+    {
+        if( ( tok = NextTok() ) != T_part )
+            Expecting( T_part );
+    }
+
+#else
+    // "( part" are not optional
+    NeedLEFT();
+
+    if( ( tok = NextTok() ) != T_part )
+        Expecting( T_part );
+#endif
+
+    NeedSYMBOLorNUMBER();       // toss NAME_HINT
+    tok = NextTok();
+
+    // extends must be _first_ thing, if it is present at all, after NAME_HINT
+    if( tok == T_extends )
+    {
+        parseExtends( me );
+        tok = NextTok();
+    }
+
+    for(  ; tok!=T_RIGHT;  tok = NextTok() )
+    {
+        if( tok == T_LEFT )
+        {
+            PROPERTY*   prop;
+
+            tok = NextTok();
+
+            // because exceptions are thrown, any 'new' allocation has to be stored
+            // somewhere other than on the stack, ASAP.
+
+            switch( tok )
+            {
+            default:
+                // describe what we expect at this level
+                Expecting(
+                    "anchor|value|footprint|model|keywords|alternates\n"
+                    "|property\n"
+                    "  |property_del\n"
+                    "|pin\n"
+                    "  |pin_merge|pin_swap|pin_renum|pin_rename|route_pin_swap\n"
+                    "|polyline|line|rectangle|circle|arc|bezier|text"
+                 );
+                break;
+
+            case T_anchor:
+                if( contains & PB(anchor) )
+                    Duplicate( tok );
+                NeedNUMBER( "anchor x" );
+                me->anchor.x = internal( CurText() );
+                NeedNUMBER( "anchor y" );
+                me->anchor.y = internal( CurText() );
+                contains |= PB(anchor);
+                break;
+
+            case T_line:
+            case T_polyline:
+                POLY_LINE*  pl;
+                pl = new POLY_LINE( me );
+                me->graphics.push_back( pl );
+                parsePolyLine( pl );
+                break;
+
+            case T_rectangle:
+                RECTANGLE* rect;
+                rect = new RECTANGLE( me );
+                me->graphics.push_back( rect );
+                parseRectangle( rect );
+                break;
+
+            case T_circle:
+                CIRCLE* circ;
+                circ = new CIRCLE( me );
+                me->graphics.push_back( circ );
+                parseCircle( circ );
+                break;
+
+            case T_arc:
+                ARC* arc;
+                arc = new ARC( me );
+                me->graphics.push_back( arc );
+                parseArc( arc );
+                break;
+
+            case T_bezier:
+                BEZIER* bezier;
+                bezier = new BEZIER( me );
+                me->graphics.push_back( bezier );
+                parseBezier( bezier );
+                break;
+
+            case T_text:
+                GR_TEXT* text;
+                text = new GR_TEXT( me );
+                me->graphics.push_back( text );
+                parseText( text );
+                break;
+
+            case T_property:
+                prop = new PROPERTY( me );
+                // @todo check for uniqueness
+                me->properties.push_back( prop );
+                NeedSYMBOLorNUMBER();
+                prop->name = FromUTF8();
+
+            L_prop:
+                NeedSYMBOLorNUMBER();
+                prop->text = FromUTF8();
+                tok = NextTok();
+                if( tok == T_LEFT )
+                {
+                    tok = NextTok();
+                    if( tok != T_effects )
+                        Expecting( T_effects );
+                    parseTextEffects( prop->EffectsLookup() );
+                    NeedRIGHT();
+                }
+                else if( tok != T_RIGHT )
+                    Expecting( ") | effects" );
+                break;
+
+            case T_property_del:
+                parsePropertyDel( me );
+                break;
+
+            // reference in a PART is incomplete, it is just the prefix of an
+            // unannotated reference. Only components have full reference designators.
+            case T_reference:
+                if( contains & PB(reference) )
+                    Duplicate( tok );
+                contains |= PB(reference);
+                prop = me->FieldLookup( PART::REFERENCE );
+                goto L_prop;
+
+            case T_value:
+                if( contains & PB(value) )
+                    Duplicate( tok );
+                contains |= PB(value);
+                prop = me->FieldLookup( PART::VALUE );
+                goto L_prop;
+
+            case T_footprint:
+                if( contains & PB(footprint) )
+                    Duplicate( tok );
+                contains |= PB(footprint);
+                prop = me->FieldLookup( PART::FOOTPRINT );
+                goto L_prop;
+
+            case T_datasheet:
+                if( contains & PB(datasheet) )
+                    Duplicate( tok );
+                contains |= PB(datasheet);
+                prop = me->FieldLookup( PART::DATASHEET );
+                goto L_prop;
+
+            case T_model:
+                if( contains & PB(model) )
+                    Duplicate( tok );
+                contains |= PB(model);
+                prop = me->FieldLookup( PART::MODEL );
+                goto L_prop;
+
+            case T_keywords:
+                parseKeywords( me );
+                break;
+
+            case T_alternates:
+                // @todo: do we want to inherit alternates?
+                parseAlternates( me );
+                break;
+
+            case T_pin:
+                // @todo PADNAMEs must be unique
+                PIN* pin;
+                pin = new PIN( me );
+                me->pins.push_back( pin );
+                parsePin( pin );
+                break;
+
+            case T_pin_del:
+                parsePinDel( me );
+                break;
+
+            case T_pin_swap:
+                parsePinSwap( me );
+                break;
+
+            case T_pin_renum:
+                parsePinRenum( me );
+                break;
+
+            case T_pin_rename:
+                parsePinRename( me );
+                break;
+
+            case T_pin_merge:
+                parsePinMerge( me );
+                break;
+
+            /*
+            @todo
+
+            case T_route_pin_swap:
+                break;
+            */
+            }
+        }
+
+        else
+        {
+            switch( tok )
+            {
+            default:
+                Unexpected( tok );
+            }
+        }
+    }
+
+    contains |= PB(parsed);
+
+    me->contains |= contains;
+}
+
+
+void SWEET_PARSER::parseExtends( PART* me )
+{
+    PART*   base;
+    int     offset;
+
+    if( contains & PB(extends) )
+        Duplicate( T_extends );
+
+    NeedSYMBOLorNUMBER();
+    me->setExtends( new LPID() );
+
+    offset = me->extends->Parse( CurText() );
+    if( offset > -1 )   // -1 is success
+        THROW_PARSE_ERROR( _("invalid extends LPID"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() + offset );
+
+    base = libs->LookupPart( *me->extends, me->Owner() );
+
+    // we could be going in circles here, recursively, or too deep, set limits
+    // and disallow extending from self (even indirectly)
+    int extendsDepth = 0;
+    for( const PART* ancestor = base; ancestor && extendsDepth<MAX_INHERITANCE_NESTING;
+            ++extendsDepth, ancestor = ancestor->base )
+    {
+        if( ancestor == me )
+        {
+            THROW_PARSE_ERROR( _("'extends' may not have self as any ancestor"),
+                CurSource(),
+                CurLine(),
+                CurLineNumber(),
+                CurOffset() );
+        }
+    }
+
+    if( extendsDepth == MAX_INHERITANCE_NESTING )
+    {
+        THROW_PARSE_ERROR( _("max allowed extends depth exceeded"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+    me->inherit( *base );
+    me->base = base;
+    contains |= PB(extends);
+}
+
+
+void SWEET_PARSER::parseAlternates( PART* me )
+{
+    T           tok;
+    PART_REF    lpid;
+    int         offset;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( !IsSymbol( tok ) && tok != T_NUMBER )
+            Expecting( "lpid" );
+
+        // lpid.clear(); Parse does this
+
+        offset = lpid.Parse( CurText() );
+        if( offset > -1 )
+        THROW_PARSE_ERROR( _("invalid alternates LPID"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() + offset );
+
+        // PART_REF assignment should be OK, it contains no ownership
+        me->alternates.push_back( lpid );
+    }
+}
+
+
+void SWEET_PARSER::parseKeywords( PART* me )
+{
+    T   tok;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( !IsSymbol( tok ) && tok!=T_NUMBER )
+            Expecting( "symbol|number" );
+
+        // just insert them, duplicates are silently removed and tossed.
+        me->keywords.insert( FromUTF8() );
+    }
+}
+
+
+void SWEET_PARSER::parseFont( FONT* me )
+{
+    /*
+        # The FONT value needs to be defined.  Currently, EESchema does not support
+        # different fonts.  In the future this feature may be implemented and at
+        # that time FONT will have to be defined.  Initially, only the font size and
+        # style are required.  Italic and bold styles are optional.  The font size
+        # height and width are in units yet to be determined.
+        (font [FONT] (size HEIGHT WIDTH) [italic] [bold])
+    */
+
+    // handle the [FONT] 'position dependently', i.e. first
+    T       tok = NextTok();
+    bool    sawBold   = false;
+    bool    sawItalic = false;
+    bool    sawSize   = false;
+
+    if( IsSymbol( tok ) )
+    {
+        me->name = FromUTF8();
+        tok = NextTok();
+    }
+
+    for( ; tok != T_RIGHT; tok = NextTok() )
+    {
+        if( tok == T_LEFT )
+        {
+            tok = NextTok();
+
+            switch( tok )
+            {
+            case T_size:
+                if( sawSize )
+                    Duplicate( T_size );
+                sawSize = true;
+
+                NeedNUMBER( "size height" );
+                me->size.height = fromFontz( CurText() );
+
+                NeedNUMBER( "size width" );
+                me->size.width = fromFontz( CurText() );
+                NeedRIGHT();
+                break;
+
+            default:
+                Expecting( "size" );
+            }
+        }
+        else
+        {
+            switch( tok )
+            {
+            case T_bold:
+                if( sawBold )
+                    Duplicate( T_bold );
+                sawBold = true;
+                me->bold = true;
+                break;
+
+            case T_italic:
+                if( sawItalic )
+                    Duplicate( T_italic );
+                sawItalic = true;
+                me->italic = true;
+                break;
+
+            default:
+                Unexpected( "bold|italic" );
+            }
+        }
+    }
+}
+
+
+void SWEET_PARSER::parseBool( bool* aBool )
+{
+    T   tok = NeedSYMBOL();
+
+    switch( tok )
+    {
+    case T_yes:
+    case T_no:
+        *aBool = (tok == T_yes);
+        break;
+    default:
+        Expecting( "yes|no" );
+    }
+}
+
+
+void SWEET_PARSER::parseStroke( STROKE* me )
+{
+    /*
+        (stroke [WIDTH] [(style [(dashed...)]...)])
+
+        future place holder for arrow heads, dashed lines, all line glamour
+    */
+
+    NeedNUMBER( "stroke" );
+    *me = fromWidth( CurText() );
+    NeedRIGHT();
+}
+
+
+void SWEET_PARSER::parsePinText( PINTEXT* me )
+{
+    /*  either:
+        (signal SIGNAL   (font [FONT] (size HEIGHT WIDTH) [italic] [bold])(visible YES))
+        or
+        (pad PADNAME (font [FONT] (size HEIGHT WIDTH) [italic] [bold])(visible YES))
+    */
+    T       tok;
+    bool    sawFont = false;
+    bool    sawVis  = false;
+
+    // pad or signal text
+    NeedSYMBOLorNUMBER();
+    me->text = FromUTF8();
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok == T_LEFT )
+        {
+            tok = NextTok();
+
+            switch( tok )
+            {
+            case T_font:
+                if( sawFont )
+                    Duplicate( tok );
+                sawFont = true;
+                parseFont( &me->font );
+                break;
+
+            case T_visible:
+                if( sawVis )
+                    Duplicate( tok );
+                sawVis = true;
+                parseBool( &me->isVisible );
+                NeedRIGHT();
+                break;
+
+            default:
+                Expecting( "font" );
+            }
+        }
+
+        else
+        {
+            switch( tok )
+            {
+            default:
+                Expecting( T_LEFT );
+            }
+        }
+    }
+}
+
+
+void SWEET_PARSER::parsePin( PIN* me )
+{
+    /*
+        (pin TYPE SHAPE
+            (at X Y [ANGLE])
+            (length LENGTH)
+            (signal NAME (font [FONT] (size HEIGHT WIDTH) [italic] [bold])(visible YES))
+            (pad NUMBER (font [FONT] (size HEIGHT WIDTH) [italic] [bold] (visible YES))
+            (visible YES)
+        )
+    */
+
+    T       tok;
+    bool    sawShape   = false;
+    bool    sawType    = false;
+    bool    sawAt      = false;
+    bool    sawLen     = false;
+    bool    sawSignal  = false;
+    bool    sawPad     = false;
+    bool    sawVis     = false;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok == T_LEFT )
+        {
+            tok = NextTok();
+
+            switch( tok )
+            {
+            case T_at:
+                if( sawAt )
+                    Duplicate( tok );
+                sawAt = true;
+                parseAt( &me->pos, &me->angle );
+                break;
+
+            case T_length:
+                if( sawLen )
+                    Duplicate( tok );
+                sawLen = true;
+                NeedNUMBER( "length" );
+                me->length = internal( CurText() );
+                NeedRIGHT();
+                break;
+
+            case T_signal:
+                if( sawSignal )
+                    Duplicate( tok );
+                sawSignal = true;
+                parsePinText( &me->signal );
+                break;
+
+            case T_pad:
+                if( sawPad )
+                    Duplicate( tok );
+                sawPad = true;
+                parsePinText( &me->pad );
+                break;
+
+            case T_visible:
+                if( sawVis )
+                    Duplicate( tok );
+                sawVis = true;
+                parseBool( &me->isVisible );
+                NeedRIGHT();
+                break;
+
+            default:
+                Unexpected( tok );
+            }
+        }
+
+        else    // not wrapped in parentheses
+        {
+            switch( tok )
+            {
+            case T_in:
+            case T_out:
+            case T_inout:
+            case T_tristate:
+            case T_passive:
+            case T_unspecified:
+            case T_power_in:
+            case T_power_out:
+            case T_open_collector:
+            case T_open_emitter:
+            case T_unconnected:
+                if( sawType )
+                    Duplicate( tok );
+                sawType = true;
+                me->connectionType = tok;
+                break;
+
+            case T_none:
+            case T_line:
+            case T_inverted:
+            case T_clock:
+            case T_inverted_clk:
+            case T_input_low:
+            case T_clock_low:
+            case T_falling_edge:
+            case T_non_logic:
+                if( sawShape )
+                    Duplicate( tok );
+                sawShape = true;
+                me->shape = tok;
+                break;
+
+            default:
+                Unexpected( tok );
+            }
+        }
+    }
+}
+
+
+void SWEET_PARSER::parsePinDel( PART* me )
+{
+    wxString    pad;
+
+    // we do this somewhat unorthodoxically because we want to avoid doing two lookups,
+    // which would need to be done to 1) find pin, and 2) delete pin.  Only one
+    // lookup is needed with this scheme.
+
+    NeedSYMBOLorNUMBER();
+    pad = FromUTF8();
+
+    // lookup now while CurOffset() is still meaningful.
+    PINS::iterator it = me->pinFindByPad( pad );
+    if( it == me->pins.end() )
+    {
+        THROW_PARSE_ERROR( _("undefined pin"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+/* enable in future, but not now while testing
+    if( (*it)->birthplace == me )
+    {
+        THROW_PARSE_ERROR( _("pin_del allowed for inherited pins only"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+*/
+
+    NeedRIGHT();
+
+    delete *it;         // good thing I'm a friend.
+    me->pins.erase( it );
+}
+
+
+void SWEET_PARSER::parsePinSwap( PART* me )
+{
+    PIN*        pin1;
+    PIN*        pin2;
+
+    wxString    pad;
+
+    NeedSYMBOLorNUMBER();
+    pad = FromUTF8();
+
+    // lookup now while CurOffset() is still meaningful.
+    pin1 = me->PinFindByPad( pad );
+    if( !pin1 )
+    {
+        THROW_PARSE_ERROR( _("undefined pin"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+    NeedSYMBOLorNUMBER();
+    pad = FromUTF8();
+
+    pin2 = me->PinFindByPad( pad );
+    if( !pin2 )
+    {
+        THROW_PARSE_ERROR( _("undefined pin"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+    NeedRIGHT();
+
+    // swap only the text, but might want to swap entire PIN_TEXTs
+    pin2->pad.text = pin1->pad.text;
+    pin1->pad.text = pad;
+}
+
+
+void SWEET_PARSER::parsePinRenum( PART* me )
+{
+    PIN*        pin;
+
+    wxString    oldPad;
+    wxString    newPad;
+
+    NeedSYMBOLorNUMBER();
+    oldPad = FromUTF8();
+
+    // lookup now while CurOffset() is still meaningful.
+    pin = me->PinFindByPad( oldPad );
+    if( !pin )
+    {
+        THROW_PARSE_ERROR( _("undefined pin"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+    NeedSYMBOLorNUMBER();
+    newPad = FromUTF8();
+
+    NeedRIGHT();
+
+    // @todo: check for pad legalities
+    pin->pad.text = newPad;
+}
+
+
+void SWEET_PARSER::parsePinRename( PART* me )
+{
+    PIN*        pin;
+
+    wxString    pad;
+    wxString    newSignal;
+
+    NeedSYMBOLorNUMBER();
+    pad = FromUTF8();
+
+    // lookup now while CurOffset() is still meaningful.
+    pin = me->PinFindByPad( pad );
+    if( !pin )
+    {
+        THROW_PARSE_ERROR( _("undefined pin"),
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+    NeedSYMBOLorNUMBER();
+    newSignal = FromUTF8();
+
+    NeedRIGHT();
+
+    pin->signal.text = newSignal;
+}
+
+
+void SWEET_PARSER::parsePinMerge( PART* me )
+{
+    T           tok;
+    wxString    pad;
+    wxString    signal;
+    wxString    msg;
+
+    NeedSYMBOLorNUMBER();
+
+    wxString    anchorPad = FromUTF8();
+
+    // lookup now while CurOffset() is still good.
+    PINS::iterator pit = me->pinFindByPad( anchorPad );
+    if( pit == me->pins.end() )
+    {
+        msg.Printf( _( "undefined pin %s" ), anchorPad.GetData() );
+        THROW_PARSE_ERROR( msg,
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+    if( !(*pit)->pin_merge.IsEmpty() && anchorPad != (*pit)->pin_merge )
+    {
+        msg.Printf( _( "pin %s already in pin_merge group %s" ),
+                anchorPad.GetData(), (*pit)->pin_merge.GetData() );
+
+        THROW_PARSE_ERROR( msg,
+            CurSource(),
+            CurLine(),
+            CurLineNumber(),
+            CurOffset() );
+    }
+
+    (*pit)->isVisible = true;
+    (*pit)->pin_merge = anchorPad;
+
+    // allocate or find a MERGE_SET;
+    MERGE_SET& ms = me->pin_merges[anchorPad];
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok == T_LEFT )
+        {
+            tok = NextTok();
+
+            switch( tok )
+            {
+            case T_signals:
+                {
+                    PINS    sigPins;   // no ownership
+
+                    while( ( tok = NextTok() ) != T_RIGHT )
+                    {
+                        if( !IsSymbol( tok ) && tok != T_NUMBER )
+                            Expecting( "signal" );
+
+                        signal = FromUTF8();
+
+                        sigPins.clear();
+
+                        me->PinsFindBySignal( &sigPins, signal );
+
+                        if( !sigPins.size() )
+                        {
+                            msg.Printf( _( "no pins with signal %s" ), signal.GetData() );
+                            THROW_PARSE_ERROR( msg,
+                                CurSource(),
+                                CurLine(),
+                                CurLineNumber(),
+                                CurOffset() );
+                        }
+
+                        for( pit = sigPins.begin();  pit != sigPins.end();  ++pit )
+                        {
+                            if( !(*pit)->pin_merge.IsEmpty() && anchorPad != (*pit)->pin_merge  )
+                            {
+                                msg.Printf( _( "signal pin %s already in pin_merge group %s" ),
+                                        pad.GetData(), (*pit)->pin_merge.GetData() );
+
+                                THROW_PARSE_ERROR( msg,
+                                    CurSource(),
+                                    CurLine(),
+                                    CurLineNumber(),
+                                    CurOffset() );
+                            }
+
+                            (*pit)->isVisible = true;
+                            (*pit)->pin_merge = anchorPad;
+                            ms.insert( pad );
+                        }
+                    }
+                }
+                break;
+
+            case T_pads:
+                while( ( tok = NextTok() ) != T_RIGHT )
+                {
+                    if( !IsSymbol( tok ) && tok != T_NUMBER )
+                        Expecting( "pad" );
+
+                    pad = FromUTF8();
+
+                    D(printf("pad=%s\n", TO_UTF8( pad ) );)
+
+                    // find the PIN and mark it as being in this MERGE_SET or throw
+                    // error if already in another MERGET_SET.
+
+                    pit = me->pinFindByPad( pad );
+                    if( pit == me->pins.end() )
+                    {
+                        msg.Printf( _( "undefined pin %s" ), pad.GetData() );
+                        THROW_PARSE_ERROR( msg,
+                            CurSource(),
+                            CurLine(),
+                            CurLineNumber(),
+                            CurOffset() );
+                    }
+
+                    if( !(*pit)->pin_merge.IsEmpty() /* && anchorPad != (*pit)->pin_merge */ )
+                    {
+                        msg.Printf( _( "pin %s already in pin_merge group %s" ),
+                                pad.GetData(), (*pit)->pin_merge.GetData() );
+
+                        THROW_PARSE_ERROR( msg,
+                            CurSource(),
+                            CurLine(),
+                            CurLineNumber(),
+                            CurOffset() );
+                    }
+
+                    (*pit)->isVisible = false;
+                    (*pit)->pin_merge = anchorPad;
+
+                    ms.insert( pad );
+                }
+                break;
+
+            default:
+                Expecting( "pads|signals" );
+                break;
+            }
+        }
+        else
+        {
+            Expecting( T_LEFT );
+        }
+    }
+}
+
+
+void SWEET_PARSER::parsePropertyDel( PART* me )
+{
+    NeedSYMBOLorNUMBER();
+
+    wxString propertyName = FromUTF8();
+
+    if( !me->PropDelete( propertyName ) )
+    {
+        wxString    msg;
+        msg.Printf( _( "Unable to find property: %s" ), propertyName.GetData() );
+        THROW_IO_ERROR( msg );
+    }
+    NeedRIGHT();
+}
+
+
+void SWEET_PARSER::parseTextEffects( TEXT_EFFECTS* me )
+{
+    /*
+        (effects [PROPERTY]
+
+            # Position requires X and Y coordinates.  Position coordinates can be
+            # non-intergr.  Angle is in degrees and defaults to 0 if not defined.
+            (at X Y [ANGLE])
+
+            # The FONT value needs to be defined.  Currently, EESchema does not support
+            # different fonts.  In the future this feature may be implemented and at
+            # that time FONT will have to be defined.  Initially, only the font size and
+            # style are required.  Italic and bold styles are optional.  The font size
+            # height and width are in units yet to be determined.
+            (font [FONT] (size HEIGHT WIDTH) [italic] [bold])
+
+            # Valid visibility values are yes and no.
+            (visible YES)
+        )
+    */
+
+    bool    sawFont = false;
+    bool    sawAt   = false;
+    bool    sawVis  = false;
+
+    T       tok = NextTok();
+
+    if( IsSymbol( tok ) )
+    {
+        me->propName = FromUTF8();
+        tok = NextTok();
+    }
+
+    for(  ; tok != T_RIGHT;  tok = NextTok() )
+    {
+        if( tok != T_LEFT )
+            Expecting( T_LEFT );
+
+        tok = NextTok();
+
+        switch( tok )
+        {
+        case T_at:
+            if( sawAt )
+                Duplicate( tok );
+            sawAt = true;
+            parseAt( &me->pos, &me->angle );
+            break;
+
+        case T_font:
+            if( sawFont )
+                Duplicate( tok );
+            sawFont = true;
+            parseFont( &me->font );
+            break;
+
+        case T_visible:
+            if( sawVis )
+                Duplicate( sawVis );
+            sawVis = true;
+            parseBool( &me->isVisible );
+            NeedRIGHT();
+            break;
+
+        default:
+            Expecting( "at|font|visible" );
+        }
+    }
+}
+
+
+void SWEET_PARSER::parsePolyLine( POLY_LINE* me )
+{
+    /*
+        (polyline|line
+            (pts (xy X Y) (xy X Y) (xy X Y) (xy X Y) (xy X Y))
+
+            # Line widths are in percent of a pin delta
+            [(stroke [WIDTH] [(style [(dashed...)]...)])]
+
+
+            # Valid fill types are none, filled, and transparent.
+            (fill FILL_TYPE)
+        )
+    */
+
+    T       tok;
+    int     count = 0;
+    bool    sawStroke = false;
+    bool    sawFill   = false;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok != T_LEFT )
+            Expecting( T_LEFT );
+
+        tok = NextTok();
+
+        switch( tok )
+        {
+        case T_stroke:
+            if( sawStroke )
+                Duplicate( tok );
+            sawStroke = true;
+            parseStroke( &me->stroke );
+            break;
+
+        case T_pts:
+            if( count )
+                Duplicate( tok );
+            for(  ;  ( tok = NextTok() ) != T_RIGHT;  ++count )
+            {
+                if( tok != T_LEFT )
+                    Expecting( T_LEFT );
+
+                tok = NeedSYMBOL();
+                if( tok != T_xy )
+                    Expecting( T_xy );
+
+                me->pts.push_back( POINT() );
+
+                NeedNUMBER( "x" );
+                me->pts.back().x = internal( CurText() );
+
+                NeedNUMBER( "y" );
+                me->pts.back().y = internal( CurText() );
+
+                NeedRIGHT();
+            }
+            if( count < 2 )
+                Expecting( ">= 2 pts" );
+            break;
+
+        case T_fill:
+            if( sawFill )
+                Duplicate( tok );
+            tok = NeedSYMBOL();
+            switch( tok )
+            {
+            case T_none:
+            case T_filled:
+            case T_transparent:
+                me->fillType = tok;
+                break;
+            default:
+                Expecting( "none|filled|transparent" );
+            }
+            NeedRIGHT();
+            sawFill = true;
+            break;
+
+        default:
+            Expecting( "pts|stroke|fill" );
+        }
+    }
+}
+
+
+void SWEET_PARSER::parseBezier( BEZIER* me )
+{
+    parsePolyLine( me );
+}
+
+
+void SWEET_PARSER::parseRectangle( RECTANGLE* me )
+{
+    /*
+        (rectangle (start X Y) (end X Y) (stroke WIDTH) (fill FILL_TYPE))
+    */
+
+    T       tok;
+    bool    sawStart = false;
+    bool    sawEnd    = false;
+    bool    sawStroke = false;
+    bool    sawFill   = false;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok != T_LEFT )
+            Expecting( T_LEFT );
+
+        tok = NextTok();
+
+        switch( tok )
+        {
+        case T_stroke:
+            if( sawStroke )
+                Duplicate( tok );
+            sawStroke = true;
+            parseStroke( &me->stroke );
+            break;
+
+        case T_fill:
+            if( sawFill )
+                Duplicate( tok );
+            sawFill = true;
+            tok = NeedSYMBOL();
+            switch( tok )
+            {
+            case T_none:
+            case T_filled:
+            case T_transparent:
+                me->fillType = tok;
+                break;
+            default:
+                Expecting( "none|filled|transparent" );
+            }
+            NeedRIGHT();
+            break;
+
+        case T_start:
+            if( sawStart )
+                Duplicate( tok );
+            sawStart = true;
+            NeedNUMBER( "x" );
+            me->start.x = internal( CurText() );
+            NeedNUMBER( "y" );
+            me->start.y = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        case T_end:
+            if( sawEnd )
+                Duplicate( tok );
+            sawEnd = true;
+            NeedNUMBER( "x" );
+            me->end.x = internal( CurText() );
+            NeedNUMBER( "y" );
+            me->end.y = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        default:
+            Expecting( "start|end|stroke|fill" );
+        }
+    }
+}
+
+
+void SWEET_PARSER::parseCircle( CIRCLE* me )
+{
+    /*
+        (circle (center X Y)
+            # Radius length is in units if defined or mils.
+            (radius LENGTH)
+            (stroke WIDTH)
+            (fill FILL_TYPE)
+        )
+    */
+
+    T       tok;
+    bool    sawCenter = false;
+    bool    sawRadius = false;
+    bool    sawStroke = false;
+    bool    sawFill   = false;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok != T_LEFT )
+            Expecting( T_LEFT );
+
+        tok = NextTok();
+
+        switch( tok )
+        {
+        case T_stroke:
+            if( sawStroke )
+                Duplicate( tok );
+            sawStroke = true;
+            parseStroke( &me->stroke );
+            break;
+
+        case T_fill:
+            if( sawFill )
+                Duplicate( tok );
+            sawFill = true;
+            tok = NeedSYMBOL();
+            switch( tok )
+            {
+            case T_none:
+            case T_filled:
+            case T_transparent:
+                me->fillType = tok;
+                break;
+            default:
+                Expecting( "none|filled|transparent" );
+            }
+            NeedRIGHT();
+            break;
+
+        case T_center:
+            if( sawCenter )
+                Duplicate( tok );
+            sawCenter = true;
+            NeedNUMBER( "center x" );
+            me->center.x = internal( CurText() );
+            NeedNUMBER( "center y" );
+            me->center.y = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        case T_radius:
+            if( sawRadius )
+                Duplicate( tok );
+            sawRadius = true;
+            NeedNUMBER( "radius" );
+            me->radius = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        default:
+            Expecting( "center|radius|stroke|fill" );
+        }
+    }
+}
+
+
+void SWEET_PARSER::parseArc( ARC* me )
+{
+    /*
+        (arc (pos X Y) (radius RADIUS) (start X Y) (end X Y)
+            (stroke WIDTH)
+            (fill FILL_TYPE)
+        )
+    */
+
+    T       tok;
+    bool    sawPos    = false;
+    bool    sawStart  = false;
+    bool    sawEnd    = false;
+    bool    sawRadius = false;
+    bool    sawStroke = false;
+    bool    sawFill   = false;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok != T_LEFT )
+            Expecting( T_LEFT );
+
+        tok = NextTok();
+
+        switch( tok )
+        {
+        case T_stroke:
+            if( sawStroke )
+                Duplicate( tok );
+            sawStroke = true;
+            parseStroke( &me->stroke );
+            break;
+
+        case T_fill:
+            if( sawFill )
+                Duplicate( tok );
+            sawFill = true;
+            tok = NeedSYMBOL();
+            switch( tok )
+            {
+            case T_none:
+            case T_filled:
+            case T_transparent:
+                me->fillType = tok;
+                break;
+            default:
+                Expecting( "none|filled|transparent" );
+            }
+            NeedRIGHT();
+            break;
+
+        case T_pos:
+            if( sawPos )
+                Duplicate( tok );
+            sawPos = true;
+            NeedNUMBER( "pos x" );
+            me->pos.x = internal( CurText() );
+            NeedNUMBER( "pos y" );
+            me->pos.y = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        case T_radius:
+            if( sawRadius )
+                Duplicate( tok );
+            sawRadius = true;
+            NeedNUMBER( "radius" );
+            me->radius = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        case T_start:
+            if( sawStart )
+                Duplicate( tok );
+            sawStart = true;
+            NeedNUMBER( "start x" );
+            me->start.x = internal( CurText() );
+            NeedNUMBER( "start y" );
+            me->start.y = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        case T_end:
+            if( sawEnd )
+                Duplicate( tok );
+            sawEnd = true;
+            NeedNUMBER( "end x" );
+            me->end.x = internal( CurText() );
+            NeedNUMBER( "end y" );
+            me->end.y = internal( CurText() );
+            NeedRIGHT();
+            break;
+
+        default:
+            Expecting( "center|radius|stroke|fill" );
+        }
+    }
+}
+
+
+void SWEET_PARSER::parseAt( POINT* pos, float* angle )
+{
+    T       tok;
+
+    NeedNUMBER( "at x" );
+    pos->x = internal( CurText() );
+
+    NeedNUMBER( "at y" );
+    pos->y = internal( CurText() );
+
+    tok = NextTok();
+    if( angle && tok == T_NUMBER )
+    {
+        *angle = strtod( CurText(), NULL );
+        tok = NextTok();
+    }
+    if( tok != T_RIGHT )
+        Expecting( T_RIGHT );
+}
+
+
+void SWEET_PARSER::parseText( GR_TEXT* me )
+{
+    /*
+        (text "This is the text that gets drawn."
+            (at X Y [ANGLE])
+
+            # Valid horizontal justification values are center, right, and left.  Valid
+            # vertical justification values are center, top, bottom.
+            (justify HORIZONTAL_JUSTIFY VERTICAL_JUSTIFY)
+            (font [FONT] (size HEIGHT WIDTH) [italic] [bold])
+            (visible YES)
+            (fill FILL_TYPE)
+        )
+    */
+
+    T       tok;
+    bool    sawAt   = false;
+    bool    sawFill = false;
+    bool    sawFont = false;
+    bool    sawVis  = false;
+    bool    sawJust = false;
+    bool    sawText = false;
+
+    while( ( tok = NextTok() ) != T_RIGHT )
+    {
+        if( tok == T_LEFT )
+        {
+            tok = NextTok();
+
+            switch( tok )
+            {
+            case T_at:
+                if( sawAt )
+                    Duplicate( tok );
+                parseAt( &me->pos, &me->angle );
+                sawAt = true;
+                break;
+
+            case T_fill:
+                if( sawFill )
+                    Duplicate( tok );
+                tok = NeedSYMBOL();
+                switch( tok )
+                {
+                case T_none:
+                case T_filled:
+                case T_transparent:
+                    me->fillType = tok;
+                    break;
+                default:
+                    Expecting( "none|filled|transparent" );
+                }
+                NeedRIGHT();
+                sawFill = true;
+                break;
+
+            case T_justify:
+                if( sawJust )
+                    Duplicate( tok );
+                tok = NeedSYMBOL();
+                switch( tok )
+                {
+                case T_center:
+                case T_right:
+                case T_left:
+                    me->hjustify = tok;
+                    break;
+                default:
+                    Expecting( "center|right|left" );
+                }
+
+                tok = NeedSYMBOL();
+                switch( tok )
+                {
+                case T_center:
+                case T_top:
+                case T_bottom:
+                    me->vjustify = tok;
+                    break;
+                default:
+                    Expecting( "center|top|bottom" );
+                }
+                NeedRIGHT();
+                sawJust = true;
+                break;
+
+            case T_visible:
+                if( sawVis )
+                    Duplicate( tok );
+                parseBool( &me->isVisible );
+                NeedRIGHT();
+                sawVis = true;
+                break;
+
+            case T_font:
+                if( sawFont )
+                    Duplicate( tok );
+                sawFont = true;
+                parseFont( &me->font );
+                break;
+
+            default:
+                Expecting( "at|justify|font|visible|fill" );
+            }
+        }
+        else
+        {
+            if( !IsSymbol( tok ) && tok != T_NUMBER )
+                Expecting( T_STRING );
+
+            if( sawText )
+                Duplicate( tok );
+            sawText = true;
+
+            me->text = wxString::FromUTF8( CurText() );
+        }
+    }
+}
+