diff options
Diffstat (limited to 'new/sch_lpid.cpp')
| -rw-r--r-- | new/sch_lpid.cpp | 501 |
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 |