lib_id.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2012 Wayne Stambaugh <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.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, see <https://www.gnu.org/licenses/>.
 */
 
#include <cstring>
#include <memory>
#include <wx/translation.h>
#include <fmt/format.h>
 
#include <ki_exception.h>
#include <macros.h>     // TO_UTF8()
#include <lib_id.h>
#include <name_validation.h>
 
 
const wxString& GetLibIdForbiddenChars()
{
    static const wxString chars = wxS( "<>\"\\:\t\n\r" );
    return chars;
}
 
 
const wxString& GetLibFilenameForbiddenChars()
{
    // Filenames additionally forbid these path and format characters, which a LIB_ID name
    // is allowed to contain.
    static const wxString chars = GetLibIdForbiddenChars() + wxS( "%$/" );
    return chars;
}
 
 
static int checkLibNickname( const UTF8& aField )
{
    // std::string::npos is largest positive number, casting to int makes it -1.
    // Returning that means success.
    return int( aField.find_first_of( ":" ) );
}
 
 
void LIB_ID::clear()
{
    m_libraryName.clear();
    m_itemName.clear();
    m_subLibraryName.clear();
}
 
 
int LIB_ID::Parse( const UTF8& aId, bool aFix )
{
    clear();
 
    size_t partNdx;
    int    offset = -1;
 
    //=====<library nickname>=============================
    if( ( partNdx = aId.find( ':' ) ) != aId.npos )
    {
        offset = SetLibNickname( aId.substr( 0, partNdx ) );
 
        if( offset > -1 )
            return offset;
 
        ++partNdx;  // skip ':'
    }
    else
    {
        partNdx = 0;
    }
 
    //=====<item name>====================================
    UTF8 fpname = aId.substr( partNdx );
 
    // Be sure the item name is valid.
    // Some chars can be found in legacy files converted files from other EDA tools.
    if( aFix )
        fpname = FixIllegalChars( fpname, false );
    else
        offset = HasIllegalChars( fpname );
 
    if( offset > -1 )
        return offset;
 
    SetLibItemName( fpname );
 
    return -1;
}
 
 
LIB_ID::LIB_ID( const wxString& aLibraryName, const wxString& aItemName ) :
        m_libraryName( aLibraryName ),
        m_itemName( aItemName )
{
}
 
 
int LIB_ID::SetLibNickname( const UTF8& aLibNickname )
{
    int offset = checkLibNickname( aLibNickname );
 
    if( offset == -1 )
        m_libraryName = aLibNickname;
 
    return offset;
}
 
 
int LIB_ID::SetLibItemName( const UTF8& aLibItemName )
{
    m_itemName = aLibItemName;
 
    return -1;
}
 
 
UTF8 LIB_ID::Format() const
{
    UTF8    ret;
 
    if( m_libraryName.size() )
    {
        ret += m_libraryName;
        ret += ':';
    }
 
    ret += m_itemName;
 
    return ret;
}
 
 
UTF8 LIB_ID::Format( const UTF8& aLibraryName, const UTF8& aLibItemName )
{
    UTF8    ret;
    int     offset;
 
    if( aLibraryName.size() )
    {
        offset = checkLibNickname( aLibraryName );
 
        if( offset != -1 )
        {
            THROW_PARSE_ERROR( _( "Illegal character found in library nickname" ),
                               wxString::FromUTF8( aLibraryName.c_str() ), aLibraryName.c_str(),
                               0, offset );
        }
 
        ret += aLibraryName;
        ret += ':';
    }
 
    ret += aLibItemName;
 
    return ret;
}
 
 
int LIB_ID::compare( const LIB_ID& aLibId ) const
{
    // Don't bother comparing the same object.
    if( this == &aLibId )
        return 0;
 
    int retv = m_libraryName.compare( aLibId.m_libraryName );
 
    if( retv != 0 )
        return retv;
 
    return m_itemName.compare( aLibId.m_itemName );
}
 
 
int LIB_ID::HasIllegalChars( const UTF8& aLibItemName )
{
    int offset = 0;
 
    for( auto& ch : aLibItemName )
    {
        if( !isLegalChar( ch ) )
            return offset;
        else
            ++offset;
    }
 
    return -1;
}
 
 
UTF8 LIB_ID::FixIllegalChars( const UTF8& aLibItemName, bool aLib )
{
    UTF8 fixedName;
 
    for( UTF8::uni_iter chIt = aLibItemName.ubegin(); chIt < aLibItemName.uend(); ++chIt )
    {
        auto ch = *chIt;
        if( aLib )
            fixedName += isLegalLibraryNameChar( ch ) ? ch : '_';
        else
            fixedName += isLegalChar( ch ) ? ch : '_';
    }
 
    return fixedName;
}
 
 
bool LIB_ID::isLegalChar( unsigned aUniChar )
{
    return GetLibIdForbiddenChars().Find( wxUniChar( aUniChar ) ) == wxNOT_FOUND;
}
 
 
unsigned LIB_ID::FindIllegalLibraryNameChar( const UTF8& aLibraryName )
{
    for( unsigned ch : aLibraryName )
    {
        if( !isLegalLibraryNameChar( ch ) )
            return ch;
    }
 
    return 0;
}
 
 
bool LIB_ID::isLegalLibraryNameChar( unsigned aUniChar )
{
    bool const space_allowed = true;
 
    if( aUniChar < ' ' )
        return false;
 
    switch( aUniChar )
    {
    case '\\':
    case ':':
        return false;
 
    case ' ':
        return space_allowed;
 
    default:
        return true;
    }
}
 
 
const wxString LIB_ID::GetFullLibraryName() const
{
    if( m_subLibraryName.empty() )
        return m_libraryName;
 
    return wxString::Format( wxS( "%s - %s" ), m_libraryName.c_str(), m_subLibraryName.c_str() );
}