Merge pull request #3 from saurabhb17/master

secondary files

1 files changed, 501 insertions, 0 deletions

diff --git a/new/sch_lpid.cpp b/new/sch_lpid.cpp
new file mode 100644
index 0000000..e475779
--- /dev/null
+++ b/new/sch_lpid.cpp
@@ -0,0 +1,501 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2010 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 <cstring>
+#include <wx/wx.h>      // _()
+
+#include <sch_lpid.h>
+
+using namespace SCH;
+
+static inline bool isDigit( char c )
+{
+    return c >= '0' && c <= '9';
+}
+
+const char* EndsWithRev( const char* start, const char* tail, char separator )
+{
+    bool    sawDigit = false;
+
+    while( tail > start && isDigit( *--tail ) )
+    {
+        sawDigit = true;
+    }
+
+    // if sawDigit, tail points to the 'v' here.
+
+    if( sawDigit && tail-3 >= start )
+    {
+        tail -= 3;
+
+        if( tail[0]==separator && tail[1]=='r' && tail[2]=='e' && tail[3]=='v' )
+        {
+            return tail+1;  // omit separator, return "revN[N..]"
+        }
+    }
+
+    return 0;
+}
+
+int RevCmp( const char* s1, const char* s2 )
+{
+    int r = strncmp( s1, s2, 3 );
+
+    if( r || strlen(s1)<4 || strlen(s2)<4 )
+    {
+        return r;
+    }
+
+    int rnum1 = atoi( s1+3 );
+    int rnum2 = atoi( s2+3 );
+
+    return -(rnum1 - rnum2);    // swap the sign, higher revs first
+}
+
+//----<Policy and field test functions>-------------------------------------
+
+// These all return -1 on success, or >= 0 if there is an error at a
+// particular character offset into their respective arguments.  If >=0,
+// then that return value gives the character offset of the error.
+
+static inline int okLogical( const STRING& aField )
+{
+    // std::string::npos is largest positive number, casting to int makes it -1.
+    // Returning that means success.
+    return int( aField.find_first_of( ":/" ) );
+}
+
+static inline int okBase( const STRING& aField )
+{
+    int offset = int( aField.find_first_of( ":/" ) );
+    if( offset != -1 )
+        return offset;
+
+    // cannot be empty
+    if( !aField.size() )
+        return 0;
+
+    return offset;  // ie. -1
+}
+
+static inline int okCategory( const STRING& aField )
+{
+    return int( aField.find_first_of( ":/" ) );
+}
+
+static int okRevision( const STRING& aField )
+{
+    char  rev[32];  // C string for speed
+
+    if( aField.size() >= 4 )
+    {
+        strcpy( rev, "x/" );
+        strcat( rev, aField.c_str() );
+
+        if( EndsWithRev( rev, rev + strlen(rev) ) == rev+2 )
+            return -1;    // success
+    }
+
+    return 0; // first character position "is in error", is best we can do.
+}
+
+//----</Policy and field test functions>-------------------------------------
+
+
+void LPID::clear()
+{
+    logical.clear();
+    category.clear();
+    baseName.clear();
+    partName.clear();
+    revision.clear();
+}
+
+
+int LPID::Parse( const STRING& aLPID )
+{
+    clear();
+
+    const char* rev = EndsWithRev( aLPID );
+    size_t      revNdx;
+    size_t      partNdx;
+    size_t      baseNdx;
+    int         offset;
+
+    //=====<revision>=========================================
+    if( rev )
+    {
+        revNdx = rev - aLPID.c_str();
+
+        // no need to check revision, EndsWithRev did that.
+        revision = aLPID.substr( revNdx );
+        --revNdx;  // back up to omit the '/' which preceeds the rev
+    }
+    else
+        revNdx = aLPID.size();
+
+    //=====<logical>==========================================
+    if( ( partNdx = aLPID.find( ':' ) ) != aLPID.npos )
+    {
+        offset = SetLogicalLib( aLPID.substr( 0, partNdx ) );
+        if( offset > -1 )
+        {
+            return offset;
+        }
+        ++partNdx;  // skip ':'
+    }
+    else
+        partNdx = 0;
+
+    //=====<rawName && category>==============================
+    // "length limited" search:
+    const char* base = (const char*) memchr( aLPID.c_str() + partNdx, '/', revNdx - partNdx );
+
+    if( base )
+    {
+        baseNdx  = base - aLPID.c_str();
+        offset  = SetCategory( aLPID.substr( partNdx, baseNdx - partNdx ) );
+        if( offset > -1 )
+        {
+            return offset + partNdx;
+        }
+        ++baseNdx;   // skip '/'
+    }
+    else
+    {
+        baseNdx = partNdx;
+    }
+
+    //=====<baseName>==========================================
+    offset = SetBaseName( aLPID.substr( baseNdx, revNdx - baseNdx ) );
+    if( offset > -1 )
+    {
+        return offset + baseNdx;
+    }
+
+    return -1;
+}
+
+
+LPID::LPID( const STRING& aLPID ) throw( PARSE_ERROR )
+{
+    int offset = Parse( aLPID );
+
+    if( offset != -1 )
+    {
+        THROW_PARSE_ERROR(
+                _( "Illegal character found in LPID string" ),
+                wxString::FromUTF8( aLPID.c_str() ),
+                aLPID.c_str(),
+                0,
+                offset
+                );
+    }
+}
+
+
+int LPID::SetLogicalLib( const STRING& aLogical )
+{
+    int offset = okLogical( aLogical );
+    if( offset == -1 )
+    {
+        logical = aLogical;
+    }
+    return offset;
+}
+
+
+int LPID::SetCategory( const STRING& aCategory )
+{
+    int offset = okCategory( aCategory );
+    if( offset == -1 )
+    {
+        category = aCategory;
+
+        // set the partName too
+        if( category.size() )
+        {
+            partName = category;
+            partName += '/';
+            partName += baseName;
+        }
+        else
+            partName = baseName;
+
+    }
+    return offset;
+}
+
+
+int LPID::SetBaseName( const STRING& aBaseName )
+{
+    int offset = okBase( aBaseName );
+    if( offset == -1 )
+    {
+        baseName = aBaseName;
+
+        // set the partName too
+        if( category.size() )
+        {
+            partName = category;
+            partName += '/';
+            partName += baseName;
+        }
+        else
+            partName = baseName;
+    }
+    return offset;
+}
+
+
+int LPID::SetPartName( const STRING& aPartName )
+{
+    STRING  category;
+    STRING  base;
+    int     offset;
+    int     separation = int( aPartName.find_first_of( "/" ) );
+
+    if( separation != -1 )
+    {
+        category = aPartName.substr( 0, separation );
+        base     = aPartName.substr( separation+1 );
+    }
+    else
+    {
+        // leave category empty
+        base = aPartName;
+    }
+
+    if( (offset = SetCategory( category )) != -1 )
+        return offset;
+
+    if( (offset = SetBaseName( base )) != -1 )
+    {
+        return offset + separation + 1;
+    }
+
+    return -1;
+}
+
+
+int LPID::SetRevision( const STRING& aRevision )
+{
+    int offset = okRevision( aRevision );
+    if( offset == -1 )
+    {
+        revision = aRevision;
+    }
+    return offset;
+}
+
+
+STRING LPID::Format() const
+{
+    STRING  ret;
+
+    if( logical.size() )
+    {
+        ret += logical;
+        ret += ':';
+    }
+
+    if( category.size() )
+    {
+        ret += category;
+        ret += '/';
+    }
+
+    ret += baseName;
+
+    if( revision.size() )
+    {
+        ret += '/';
+        ret += revision;
+    }
+
+    return ret;
+}
+
+
+STRING LPID::GetPartNameAndRev() const
+{
+    STRING ret;
+
+    if( category.size() )
+    {
+        ret += category;
+        ret += '/';
+    }
+
+    ret += baseName;
+
+    if( revision.size() )
+    {
+        ret += '/';
+        ret += revision;
+    }
+
+    return ret;
+}
+
+
+STRING LPID::Format( const STRING& aLogicalLib, const STRING& aPartName, const STRING& aRevision )
+    throw( PARSE_ERROR )
+{
+    STRING  ret;
+    int     offset;
+
+    if( aLogicalLib.size() )
+    {
+        offset = okLogical( aLogicalLib );
+        if( offset != -1 )
+        {
+            THROW_PARSE_ERROR(
+                    _( "Illegal character found in logical lib name" ),
+                    wxString::FromUTF8( aLogicalLib.c_str() ),
+                    aLogicalLib.c_str(),
+                    0,
+                    offset
+                    );
+        }
+        ret += aLogicalLib;
+        ret += ':';
+    }
+
+    {
+        STRING  category;
+        STRING  base;
+
+        int separation = int( aPartName.find_first_of( "/" ) );
+
+        if( separation != -1 )
+        {
+            category = aPartName.substr( 0, separation );
+            base     = aPartName.substr( separation+1 );
+        }
+        else
+        {
+            // leave category empty
+            base = aPartName;
+        }
+
+        if( (offset = okCategory( category )) != -1 )
+        {
+            THROW_PARSE_ERROR(
+                    _( "Illegal character found in category" ),
+                    wxString::FromUTF8( aRevision.c_str() ),
+                    aRevision.c_str(),
+                    0,
+                    offset
+                    );
+        }
+
+        if( (offset = okBase( base )) != -1 )
+        {
+            THROW_PARSE_ERROR(
+                    _( "Illegal character found in base name" ),
+                    wxString::FromUTF8( aRevision.c_str() ),
+                    aRevision.c_str(),
+                    0,
+                    offset + separation + 1
+                    );
+        }
+
+        if( category.size() )
+        {
+            ret += category;
+            ret += '/';
+        }
+
+        ret += base;
+    }
+
+    if( aRevision.size() )
+    {
+        offset = okRevision( aRevision );
+        if( offset != -1 )
+        {
+            THROW_PARSE_ERROR(
+                    _( "Illegal character found in revision" ),
+                    wxString::FromUTF8( aRevision.c_str() ),
+                    aRevision.c_str(),
+                    0,
+                    offset
+                    );
+        }
+
+        ret += '/';
+        ret += aRevision;
+    }
+
+    return ret;
+}
+
+
+#if 0 && defined(DEBUG)
+
+// build this with Debug CMAKE_BUILD_TYPE
+
+void LPID::Test()
+{
+    static const char* lpids[] = {
+        "me:passives/R/rev0",
+        "passives/R/rev2",
+        ":passives/R/rev3",
+        "C/rev22",
+        "passives/C22",
+        "R",
+        "me:R",
+        // most difficult:
+        "me:/R/rev0",
+        "me:R/rev0",
+    };
+
+    for( unsigned i=0;  i<sizeof(lpids)/sizeof(lpids[0]);  ++i )
+    {
+        // test some round tripping
+
+        LPID lpid( lpids[i] );  // parse
+
+        // format
+        printf( "input:'%s'  full:'%s'  base:'%s'  partName:'%s'  cat:'%s'  rev:'%s'\n",
+            lpids[i],
+            lpid.Format().c_str(),
+            lpid.GetBaseName().c_str(),
+            lpid.GetPartName().c_str(),
+            lpid.GetCategory().c_str(),
+            lpid.GetRevision().c_str()
+            );
+    }
+}
+
+
+int main( int argc, char** argv )
+{
+    LPID::Test();
+
+    return 0;
+}
+
+#endif