433 lines
10 KiB
C++
433 lines
10 KiB
C++
/*********************************************/
|
|
/* string.cpp */
|
|
/* some useful functions to handle strings */
|
|
/*********************************************/
|
|
|
|
#include "fctsys.h"
|
|
#include "macros.h"
|
|
#include "kicad_string.h"
|
|
|
|
|
|
/* read a double-quote delimited text from source and put it in in dest,
|
|
* read NbMaxChar bytes max
|
|
* return the char count read from source
|
|
*/
|
|
int ReadDelimitedText( char* dest, char* source, int NbMaxChar )
|
|
{
|
|
int ii, jj, flag = 0;
|
|
|
|
for( ii = 0, jj = 0; ii < NbMaxChar - 1; jj++, source++ )
|
|
{
|
|
if( *source == 0 )
|
|
break; /* E.O.L. */
|
|
if( *source == '"' ) /* delimiter is " */
|
|
{
|
|
if( flag )
|
|
break; /* End of delimited text */
|
|
flag = 1; /* First delimiter found. */
|
|
}
|
|
else if( flag )
|
|
{
|
|
*dest = *source; dest++; ii++;
|
|
}
|
|
}
|
|
|
|
*dest = 0; /* Null terminated */
|
|
return jj;
|
|
}
|
|
|
|
|
|
/* Remove training spaces in text
|
|
* return a pointer on the first non space char in text
|
|
*/
|
|
char* StrPurge( char* 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;
|
|
}
|
|
|
|
|
|
/* Read lines from File
|
|
* Skip void lines and comments (starting by #)
|
|
* return the first non void line.
|
|
* increments *LineNum for each line
|
|
*/
|
|
char* GetLine( FILE* File, char* Line, int* LineNum, int SizeLine )
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/* return in aBuffer the date and time
|
|
* time is the local time.
|
|
*/
|
|
char* DateAndTime( char* aBuffer )
|
|
{
|
|
wxString datetime;
|
|
|
|
datetime = DateAndTime();
|
|
strcpy( aBuffer, CONV_TO_UTF8( datetime ) );
|
|
|
|
return aBuffer;
|
|
}
|
|
|
|
|
|
|
|
/* return the date and time in a wxString
|
|
* note: does the same thing than strftime()
|
|
* time is the local time.
|
|
*/
|
|
wxString DateAndTime()
|
|
{
|
|
wxString Line;
|
|
|
|
wxDateTime datetime = wxDateTime::Now();
|
|
|
|
datetime.SetCountry( wxDateTime::Country_Default );
|
|
Line = datetime.Format( wxDefaultDateTimeFormat, wxDateTime::Local );
|
|
|
|
return Line;
|
|
}
|
|
|
|
|
|
/*
|
|
* sort() function
|
|
* Same as strncmp() but numbers in strings
|
|
* are compared according to the value, not the ascii value of each digit
|
|
*/
|
|
int StrLenNumCmp( const wxChar* str1, const wxChar* str2, int NbMax )
|
|
{
|
|
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 ) ) /* digit found */
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/*
|
|
* sort() function
|
|
* Same as stricmp() but numbers in strings
|
|
* are compared according to the value, not the ascii value of each digit
|
|
*/
|
|
int StrNumICmp( const wxChar* str1, const wxChar* str2 )
|
|
{
|
|
return StrLenNumICmp( str1, str2, 32735 );
|
|
}
|
|
|
|
|
|
/*
|
|
* sort() function
|
|
* Same as strnicmp() but numbers in strings
|
|
* are compared according to the value, not the ascii value of each digit
|
|
*/
|
|
int StrLenNumICmp( const wxChar* str1, const wxChar* str2, int NbMax )
|
|
{
|
|
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 ) ) /* find number */
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/* compare a string to a pattern
|
|
* ( usual chars * and ? allowed).
|
|
* if case_sensitive == true, comparison is case sensitive
|
|
* return true if match else false
|
|
*/
|
|
bool WildCompareString( const wxString& pattern, const wxString& string_to_tst,
|
|
bool case_sensitive )
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/* Converts a string used to compensate for internalization of printf().
|
|
* Generated floats with a comma instead of point.
|
|
* Obsolete: use SetLocaleTo_C_standard instead
|
|
*/
|
|
char* to_point( char* Text )
|
|
{
|
|
char* line = Text;
|
|
|
|
if( Text == NULL )
|
|
return NULL;
|
|
for( ; *Text != 0; Text++ )
|
|
{
|
|
if( *Text == ',' )
|
|
*Text = '.';
|
|
}
|
|
|
|
return line;
|
|
}
|
|
|
|
|
|
/* Convert string to upper case.
|
|
* Returns pointer to the converted string.
|
|
*/
|
|
char* strupper( char* Text )
|
|
{
|
|
char* code = Text;
|
|
|
|
if( Text )
|
|
{
|
|
while( *code )
|
|
{
|
|
if( ( *code >= 'a' ) && ( *code <= 'z' ) )
|
|
*code += 'A' - 'a';
|
|
code++;
|
|
}
|
|
}
|
|
|
|
return Text;
|
|
}
|
|
|
|
|
|
int RefDesStringCompare( const wxString& strFWord, const wxString& strSWord )
|
|
{
|
|
// The different sections of the first string
|
|
wxString strFWordBeg, strFWordMid, strFWordEnd;
|
|
|
|
// The different sections of the second string
|
|
wxString strSWordBeg, strSWordMid, strSWordEnd;
|
|
|
|
int isEqual = 0; // The numerical results of a string compare
|
|
int iReturn = 0; // The variable that is being returned
|
|
|
|
long lFirstDigit = 0; /* The converted middle section of the first
|
|
*string */
|
|
long lSecondDigit = 0; /* The converted middle section of the second
|
|
*string */
|
|
|
|
// Split the two strings into separate parts
|
|
SplitString( strFWord, &strFWordBeg, &strFWordMid, &strFWordEnd );
|
|
SplitString( strSWord, &strSWordBeg, &strSWordMid, &strSWordEnd );
|
|
|
|
// Compare the Beginning section of the strings
|
|
isEqual = strFWordBeg.CmpNoCase( strSWordBeg );
|
|
|
|
if( isEqual > 0 )
|
|
iReturn = 1;
|
|
else if( isEqual < 0 )
|
|
iReturn = -1;
|
|
else
|
|
{
|
|
// If the first sections are equal compare their digits
|
|
strFWordMid.ToLong( &lFirstDigit );
|
|
strSWordMid.ToLong( &lSecondDigit );
|
|
|
|
if( lFirstDigit > lSecondDigit )
|
|
iReturn = 1;
|
|
else if( lFirstDigit < lSecondDigit )
|
|
iReturn = -1;
|
|
else
|
|
{
|
|
// If the first two sections are equal compare the endings
|
|
isEqual = strFWordEnd.CmpNoCase( strSWordEnd );
|
|
|
|
if( isEqual > 0 )
|
|
iReturn = 1;
|
|
else if( isEqual < 0 )
|
|
iReturn = -1;
|
|
else
|
|
iReturn = 0;
|
|
}
|
|
}
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
int SplitString( wxString strToSplit,
|
|
wxString* strBeginning,
|
|
wxString* strDigits,
|
|
wxString* strEnd )
|
|
{
|
|
// Clear all the return strings
|
|
strBeginning->Empty();
|
|
strDigits->Empty();
|
|
strEnd->Empty();
|
|
|
|
// There no need to do anything if the string is empty
|
|
if( strToSplit.length() == 0 )
|
|
return 0;
|
|
|
|
// Starting at the end of the string look for the first digit
|
|
int ii;
|
|
for( ii = (strToSplit.length() - 1); ii >= 0; ii-- )
|
|
{
|
|
if( isdigit( strToSplit[ii] ) )
|
|
break;
|
|
}
|
|
|
|
// If there were no digits then just set the single string
|
|
if( ii < 0 )
|
|
*strBeginning = strToSplit;
|
|
else
|
|
{
|
|
// Since there is at least one digit this is the trailing string
|
|
*strEnd = strToSplit.substr( ii + 1 );
|
|
|
|
// Go to the end of the digits
|
|
int position = ii + 1;
|
|
for( ; ii >= 0; ii-- )
|
|
{
|
|
if( !isdigit( strToSplit[ii] ) )
|
|
break;
|
|
}
|
|
|
|
// If all that was left was digits, then just set the digits string
|
|
if( ii < 0 )
|
|
*strDigits = strToSplit.substr( 0, position );
|
|
|
|
/* We were only looking for the last set of digits everything else is
|
|
*part of the preamble */
|
|
else
|
|
{
|
|
*strDigits = strToSplit.substr( ii + 1, position - ii - 1 );
|
|
*strBeginning = strToSplit.substr( 0, ii + 1 );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|