Merge pull request #3 from saurabhb17/master

secondary files

1 files changed, 395 insertions, 0 deletions

diff --git a/common/fpid.cpp b/common/fpid.cpp
new file mode 100644
index 0000000..ba70c67
--- /dev/null
+++ b/common/fpid.cpp
@@ -0,0 +1,395 @@
+/*
+ * 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) 2012 Wayne Stambaugh <stambaughw@verizon.net>
+ * 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 <memory>
+#include <wx/wx.h>      // _()
+
+#include <macros.h>     // TO_UTF8()
+#include <fpid.h>
+#include <kicad_string.h>
+
+
+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;
+}
+
+
+#if 0   // Not used
+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
+}
+#endif
+
+//----<Policy and field test functions>-------------------------------------
+
+
+static inline int okLogical( const std::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 int okRevision( const std::string& aField )
+{
+    char  rev[32];  // C string for speed
+
+    if( aField.size() >= 4 )
+    {
+        strcpy( rev, "x/" );
+        strncat( rev, aField.c_str(), sizeof(rev)-strlen(rev)-1 );
+
+        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 FPID::clear()
+{
+    nickname.clear();
+    footprint.clear();
+    revision.clear();
+}
+
+
+int FPID::Parse( const UTF8& aId )
+{
+    clear();
+
+    const char* buffer = aId.c_str();
+    const char* rev = EndsWithRev( buffer, buffer+aId.length(), '/' );
+    size_t      revNdx;
+    size_t      partNdx;
+    int         offset;
+
+    //=====<revision>=========================================
+    // in a FPID like discret:R3/rev4
+    if( rev )
+    {
+        revNdx = rev - buffer;
+
+        // no need to check revision, EndsWithRev did that.
+        revision = aId.substr( revNdx );
+        --revNdx;  // back up to omit the '/' which precedes the rev
+    }
+    else
+    {
+        revNdx = aId.size();
+    }
+
+    //=====<nickname>==========================================
+    if( ( partNdx = aId.find( ':' ) ) != aId.npos )
+    {
+        offset = SetLibNickname( aId.substr( 0, partNdx ) );
+
+        if( offset > -1 )
+        {
+            return offset;
+        }
+
+        ++partNdx;  // skip ':'
+    }
+    else
+    {
+        partNdx = 0;
+    }
+
+    //=====<footprint name>====================================
+    if( partNdx >= revNdx )
+        return partNdx;     // Error: no footprint name.
+
+    // Be sure the footprint name is valid.
+    // Some chars can be found in board file (in old board files
+    // or converted files from an other EDA tool
+    std::string fpname = aId.substr( partNdx, revNdx-partNdx );
+    ReplaceIllegalFileNameChars( &fpname, '_' );
+    SetFootprintName( UTF8( fpname ) );
+
+    return -1;
+}
+
+
+FPID::FPID( const std::string& aId ) throw( PARSE_ERROR )
+{
+    int offset = Parse( aId );
+
+    if( offset != -1 )
+    {
+        THROW_PARSE_ERROR( _( "Illegal character found in FPID string" ),
+                           wxString::FromUTF8( aId.c_str() ),
+                           aId.c_str(),
+                           0,
+                           offset );
+    }
+}
+
+
+FPID::FPID( const wxString& aId ) throw( PARSE_ERROR )
+{
+    UTF8 id = aId;
+
+    int offset = Parse( id );
+
+    if( offset != -1 )
+    {
+        THROW_PARSE_ERROR( _( "Illegal character found in FPID string" ),
+                           aId,
+                           id.c_str(),
+                           0,
+                           offset );
+    }
+}
+
+
+int FPID::SetLibNickname( const UTF8& aLogical )
+{
+    int offset = okLogical( aLogical );
+
+    if( offset == -1 )
+    {
+        nickname = aLogical;
+    }
+
+    return offset;
+}
+
+
+int FPID::SetFootprintName( const UTF8& aFootprintName )
+{
+    int separation = int( aFootprintName.find_first_of( "/" ) );
+
+    if( separation != -1 )
+    {
+        footprint = aFootprintName.substr( 0, separation-1 );
+        return separation;
+    }
+    else
+    {
+        footprint = aFootprintName;
+    }
+
+    return -1;
+}
+
+
+int FPID::SetRevision( const UTF8& aRevision )
+{
+    int offset = okRevision( aRevision );
+
+    if( offset == -1 )
+    {
+        revision = aRevision;
+    }
+
+    return offset;
+}
+
+
+UTF8 FPID::Format() const
+{
+    UTF8    ret;
+
+    if( nickname.size() )
+    {
+        ret += nickname;
+        ret += ':';
+    }
+
+    ret += footprint;
+
+    if( revision.size() )
+    {
+        ret += '/';
+        ret += revision;
+    }
+
+    return ret;
+}
+
+
+UTF8 FPID::GetFootprintNameAndRev() const
+{
+    UTF8 ret;
+
+    if( revision.size() )
+    {
+        ret += '/';
+        ret += revision;
+    }
+
+    return ret;
+}
+
+
+#if 0   // this is broken, it does not output aFootprintName for some reason
+
+UTF8 FPID::Format( const UTF8& aLogicalLib, const UTF8& aFootprintName,
+                          const UTF8& aRevision )
+    throw( PARSE_ERROR )
+{
+    UTF8    ret;
+    int     offset;
+
+    if( aLogicalLib.size() )
+    {
+        offset = okLogical( aLogicalLib );
+
+        if( offset != -1 )
+        {
+            THROW_PARSE_ERROR( _( "Illegal character found in logical library name" ),
+                               wxString::FromUTF8( aLogicalLib.c_str() ),
+                               aLogicalLib.c_str(),
+                               0,
+                               offset );
+        }
+
+        ret += aLogicalLib;
+        ret += ':';
+    }
+
+    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;
+}
+#endif
+
+
+int FPID::compare( const FPID& aFPID ) const
+{
+    // Don't bother comparing the same object.
+    if( this == &aFPID )
+        return 0;
+
+    int retv = nickname.compare( aFPID.nickname );
+
+    if( retv != 0 )
+        return retv;
+
+    retv = footprint.compare( aFPID.footprint );
+
+    if( retv != 0 )
+        return retv;
+
+    return revision.compare( aFPID.revision );
+}
+
+
+#if 0 && defined(DEBUG)
+
+// build this with Debug CMAKE_BUILD_TYPE
+
+void FPID::Test()
+{
+    static const char* lpids[] = {
+        "smt:R_0805/rev0",
+        "mysmt:R_0805/rev2",
+        "device:AXIAL-0500",
+    };
+
+    for( unsigned i=0;  i<sizeof(lpids)/sizeof(lpids[0]);  ++i )
+    {
+        // test some round tripping
+
+        FPID lpid( lpids[i] );  // parse
+
+        // format
+        printf( "input:'%s'  full:'%s'  nickname: %s  footprint:'%s' rev:'%s'\n",
+                lpids[i],
+                lpid.Format().c_str(),
+                lpid.GetLibNickname().c_str(),
+                lpid.GetFootprintName().c_str(),
+                lpid.GetRevision().c_str() );
+    }
+}
+
+
+int main( int argc, char** argv )
+{
+    FPID::Test();
+
+    return 0;
+}
+
+#endif