kicad/common/string.cpp

/****************************************************************************/
/*	 MODULE:					 string.cpp									*/
/*	 ROLE: fonctions complementaires de traitement de chaines de caracteres */
/****************************************************************************/

#include "fctsys.h"
#include <time.h>
#include "common.h"


/*********************************************************************/
int ReadDelimitedText( char* dest, char* source, int NbMaxChar )
/*********************************************************************/

/* lit et place dans dest la chaine de caractere trouvee dans source,
 *  delimitee par " .
 *  transfere NbMaxChar max
 *  retourne le nombre de codes lus dans source
 *  dest est termine par NULL
 */
{
    int ii, jj, flag = 0;

    for( ii = 0, jj = 0; ii < NbMaxChar - 1; jj++, source++ )
    {
        if( *source == 0 )
            break;                      /* fin de ligne */
        if( *source == '"' )            /* delimiteur trouve */
        {
            if( flag )
                break;                  /* Fin de texte delimite */
            flag = 1;                   /* Marque 1er delimiteur trouve */
        }
        else if( flag )
        {
            *dest = *source; dest++; ii++;
        }
    }

    *dest = 0;  /* Null terminaison */
    return jj;
}


/********************************/
char* StrPurge( char* text )
/********************************/

/* Supprime les caracteres Space en debut de la ligne text
 *  retourne un pointeur sur le 1er caractere non Space de text
 */
{
    char* ptspace;

    if( text == NULL )
        return NULL;

    while( (*text <= ' ') && *text )
        text++;

    ptspace = text + strlen( text ) - 1;
    while( (*ptspace <= ' ') && *ptspace && (ptspace >= text) )
    {
        *ptspace = 0; ptspace--;
    }

    return text;
}


/*****************************************************************/
char* GetLine( FILE* File, char* Line, int* LineNum, int SizeLine )
/*****************************************************************/

/* Routine de lecture de 1 ligne utile
 *  retourne la 1ere ligne utile lue.
 *  elimine lignes vides et commentaires
 *  incremente *LineNum a chaque ligne lue
 */
{
    do  {
        if( fgets( Line, SizeLine, File ) == NULL )
            return NULL;
        if( LineNum )
            *LineNum += 1;
    } while( Line[0] == '#' || Line[0] == '\n' ||  Line[0] == '\r'
             || Line[0] == 0 );

    strtok( Line, "\n\r" );
    return Line;
}


/*******************************/
char* DateAndTime( char* Line )
/*******************************/
/* Retourne la chaine de caractere donnant date+heure */
{
    time_t     Time_Buf;
    struct tm* Date;

    time( &Time_Buf );
    Date = gmtime( &Time_Buf );
    sprintf( Line, "%d/%d/%d-%2.2d:%2.2d:%2.2d",
             Date->tm_mday, Date->tm_mon + 1, Date->tm_year + 1900,
             Date->tm_hour, Date->tm_min, Date->tm_sec );

    return Line;
}


/*******************************/
wxString DateAndTime()
/*******************************/
/* Retourne la chaine de caractere donnant date+heure */
{
    time_t     Time_Buf;
    struct tm* Date;
    wxString   Line;

    time( &Time_Buf );
    
    Date = gmtime( &Time_Buf );
    
    Line.Printf( wxT( "%d/%d/%d-%2.2d:%2.2d:%2.2d" ),
                 Date->tm_mday, Date->tm_mon + 1, Date->tm_year + 1900,
                 Date->tm_hour, Date->tm_min, Date->tm_sec );

    return Line;
}


/************************************************************/
int StrLenNumCmp( const wxChar* str1, const wxChar* str2, int NbMax )
/************************************************************/

/*
 *  routine (compatible qsort() ) de comparaison pour classement alphab<EFBFBD>tique
 *  Analogue a strncmp() mais les nombres sont compar<EFBFBD>s selon leur valeur num<EFBFBD>rique
 *  et non pas par leur code ascii
 */
{
    int i;
    int nb1 = 0, nb2 = 0;

    if( (str1 == NULL) || (str2 == NULL) )
        return 0;

    for( i = 0; i < NbMax; i++ )
    {
        if( isdigit( *str1 ) && isdigit( *str2 ) ) /* nombres en jeu */
        {
            nb1 = 0; nb2 = 0;
            while( isdigit( *str1 ) )
            {
                nb1 = nb1 * 10 + *str1 - '0'; str1++;
            }

            while( isdigit( *str2 ) )
            {
                nb2 = nb2 * 10 + *str2 - '0'; str2++;
            }

            if( nb1 < nb2 )
                return -1;
            if( nb1 > nb2 )
                return 1;
        }

        if( *str1 < *str2 )
            return -1;
        if( *str1 > *str2 )
            return 1;
        if( (*str1 == 0 ) && ( *str2 == 0 ) )
            return 0;
        str1++; str2++;
    }

    return 0;
}


/***********************************************/
int StrNumICmp( const wxChar* str1, const wxChar* str2 )
/***********************************************/

/*
 *  routine (compatible qsort() ) de comparaison pour classement alphab<EFBFBD>tique,
 *  avec lower case == upper case.
 *  Analogue a stricmp() mais les nombres sont compar<EFBFBD>s selon leur valeur num<EFBFBD>rique
 *  et non pas par leur code ascii
 */
{
    return StrLenNumICmp( str1, str2, 32735 );
}


/**************************************************************/
int StrLenNumICmp( const wxChar* str1, const wxChar* str2, int NbMax )
/**************************************************************/

/*
 *  routine (compatible qsort() ) de comparaison pour classement alphabetique,
 *  avec lower case == upper case.
 *  Analogue a stricmp() mais les nombres sont compares selon leur valeur numerique
 *  et non pas par leur code ascii
 */
{
    int i;
    int nb1 = 0, nb2 = 0;

    if( (str1 == NULL) || (str2 == NULL) )
        return 0;

    for( i = 0; i < NbMax; i++ )
    {
        if( isdigit( *str1 ) && isdigit( *str2 ) ) /* nombres en jeu */
        {
            nb1 = 0; nb2 = 0;
            while( isdigit( *str1 ) )
            {
                nb1 = nb1 * 10 + *str1 - '0'; str1++;
            }

            while( isdigit( *str2 ) )
            {
                nb2 = nb2 * 10 + *str2 - '0'; str2++;
            }

            if( nb1 < nb2 )
                return -1;
            if( nb1 > nb2 )
                return 1;
        }

        if( toupper( *str1 ) < toupper( *str2 ) )
            return -1;
        if( toupper( *str1 ) > toupper( *str2 ) )
            return 1;
        if( (*str1 == 0 ) && ( *str2 == 0 ) )
            return 0;
        str1++; str2++;
    }

    return 0;
}


/***********************************************************************/
bool WildCompareString( const wxString& pattern, const wxString& string_to_tst,
                        bool case_sensitive )
/***********************************************************************/

/* compare 2 noms de composants, selon regles usuelles
 *  ( Jokers * , ? , autoris<EFBFBD>s).
 *  la chaine de reference est "pattern"
 *  si case_sensitive == TRUE, comparaison exacte
 *  retourne TRUE si match
 *  retourne FALSE si differences
 */
{
    const wxChar* cp = NULL, * mp = NULL;
    const wxChar* wild, * string;
    wxString      _pattern, _string_to_tst;

    if( case_sensitive )
    {
        wild = pattern.GetData(); string = string_to_tst.GetData();
    }
    else
    {
        _pattern = pattern; _pattern.MakeUpper();
        _string_to_tst = string_to_tst; _string_to_tst.MakeUpper();
        wild = _pattern.GetData(); string = _string_to_tst.GetData();
    }

    while( (*string) && (*wild != '*') )
    {
        if( (*wild != *string) && (*wild != '?') )
            return FALSE;
        wild++; string++;
    }

    while( *string )
    {
        if( *wild == '*' )
        {
            if( ! * ++wild )
                return 1;
            mp = wild;
            cp = string + 1;
        }
        else if( (*wild == *string) || (*wild == '?') )
        {
            wild++;
            string++;
        }
        else
        {
            wild   = mp;
            string = cp++;
        }
    }

    while( *wild == '*' )
    {
        wild++;
    }

    return ! * wild;
}


/***********************************************/
void ChangeSpaces( char* Text, int NewChar )
/***********************************************/
/* Change dans un texte les espaces en NewChar */
{
    if( Text == NULL )
        return;
    while( *Text )
    {
        if( *Text == ' ' )
            *Text = (char) NewChar;
        Text++;
    }
}


/***************************/
char* to_point( char* Text )
/**************************/

/* convertit les , en . dans une chaine. utilis<69> pour compenser
 *  l'internalisationde la fct printf
 *  qui genere les flottants avec une virgule au lieu du point
 */
{
    char* line = Text;

    if( Text == NULL )
        return NULL;
    for( ; *Text != 0; Text++ )
    {
        if( *Text == ',' )
            *Text = '.';
    }

    return line;
}


/********************************/
char* strupper( char* Text )
/********************************/

/* Change les caracteres 'a' ... 'z' en 'A' ... 'Z'. dans la chaine Text.
 *  Retourne Text
 */
{
    char* code = Text;

    if( Text )
    {
        while( *code )
        {
            if( (*code >= 'a') && (*code <= 'z') )
                *code += 'A' - 'a';
            code++;
        }
    }

    return Text;
}


#if 0
/********************************/
char* strlower( char* text )
/********************************/
{
    char* start = text;

    while( *text )
    {
        if( *text >= 'A' && *text <= 'Z' )
            *text -= 'A' - 'a';
        text++;
    }

    return start;
}
#endif