Subversion Repositories spk

/*********************************************************
 *
 * STRUTILS char handling functions
 * modified: 2.9.2004 09:34
 *
 * define STRUTILS_WIN_WCHAR to use str2wchar and wchar2str
 *
 ********************************************************/

#ifndef STRUTILS_INCLUDED
#define STRUTILS_INCLUDED

#include <locale.h>
#include <string.h>
#ifdef STRUTILS_WIN_WCHAR
#include <windows.h>
#endif

#define STRUTILS_MACRO

//---------------------------------------------------------------------------------
size_t memrep(void *buffer, int c, int n, size_t count, size_t limit=0);
size_t strrep(char *string, char c, char n, size_t limit=0);
bool isinteger(const char *string);
bool isfloat(const char *string);
bool isblank(const char *string);
char ** strexplode(char separator, char *string, size_t *size, size_t limit=0);
char ** lineexplode(char *string, size_t size, size_t *count);
char * ExtractFileName(const char *pszPath, bool bNoExtension=false);
char * ExtractFilePath(const char *pszPath);
char * strcat2(int num, ...);
bool isblank(const char *str);
char * ChangeFileExtension(const char *pszFileName, const char *pszExt);
const char * GetFileExtension(const char *pszFileName);
int hextoi(const char *str);
bool ishexa(const char *str);

#ifdef STRUTILS_WIN_WCHAR
wchar_t * str2wchar(const char *sz);
char * wchar2str(const wchar_t *ws);
#endif
//---------------------------------------------------------------------------------
#ifdef STRUTILS_MACRO

#define strcreate(buffer, src) { delete[] buffer; \
buffer=new char[(src==NULL ? 0 : strlen(src)) + 1]; \
buffer[0]=0; \
if(src) strcpy(buffer, src); }

#else

inline void strcreate(char *&buffer, const char *src)
{
        buffer=new char[(src==NULL ? 0 : strlen(src)) + 1];
        buffer[0]=0;
        if(src) strcpy(buffer, src);
}
#endif
//---------------------------------------------------------------------------------
#ifdef STRUTILS_MACRO

#define wstrcreate(buffer, src) delete[] buffer; \
buffer=new wchar_t[(src==NULL ? 0 : wcslen(src)) + 1]; \
buffer[0]=0; \
if(src) wcscpy(buffer, src);

#else

inline void wstrcreate(wchar_t *&buffer, const wchar_t *src)
{
        buffer=new wchar_t[(src==NULL ? 0 : wcslen(src)) + 1];
        buffer[0]=0;
        if(src) wcscpy(buffer, src);
}
#endif
//---------------------------------------------------------------------------------
inline
char * trim(char *text)
{
        while(*text==' ' || *text==9)
                text++;
        
        int e=(int)strlen(text);
        for( ; e > 0 && text[e-1]==' ' || text[e-1]==9; e--)
                ;
        
        text[e]=0;
        return text;
}
//---------------------------------------------------------------------------------
inline size_t memrep(void *buffer, int c, int n, size_t count, size_t limit)
{
        char *pos=(char*)buffer, *end=(char*)buffer + count;
        size_t rep=0;
        do{
                pos=(char*)memchr(pos, c, end - pos);
                if(pos) {
                        *pos=n;
                        pos++;
                        rep++;
                        if(limit && rep >= limit) break;
                }
        }
        while(pos && (pos < end));
        return rep;
}
//---------------------------------------------------------------------------------
inline size_t strrep(char *string, char c, char n, size_t limit)
{
        return memrep(string, c, n, strlen(string), limit);
}
//---------------------------------------------------------------------------------
inline bool isinteger(const char *string)
{
        size_t i=0;
        size_t s=strlen(string);

        bool bRes = s > 0;
        if(bRes){
                if(string[0]=='+' || string[0]=='-') i++;
                for( ; i < s; ++i){
                        if(string[i] < '0' || string[i] > '9'){
                                bRes=false;
                                break;
                        }
                }
        }
        return bRes;
}
//---------------------------------------------------------------------------------
inline bool isfloat(const char *string)
{
        lconv *lc=localeconv();
        size_t size=strlen(string), i=0;
        int dec=0;
        bool bRes = (size > 0);
        if(bRes){
                if(string[i]=='+' || string[i]=='-') i++;
                // no decimal point on begining or end
                if((bRes=(string[i]!=*(lc->decimal_point) && string[size-1]!=*(lc->decimal_point)))==true){
                        for( ; i < size; i++){
                                // only one decimal point allowed
                                if(string[i]==*(lc->decimal_point) && ++dec > 1) return false;
                                // allowed chars are 0-9 and decimal point
                                if((bRes=((string[i] >= '0' && string[i] <= '9') || string[i]==*(lc->decimal_point)))==false) break;
                        }
                }
        }
        if(bRes==false){
                if((string[i]|0x20)=='e' || (string[i]|0x20)=='d'){
                        i++;
                        if(string[i]=='+' || string[i]=='-') i++;
                        for( ; i < size; i++){
                                if((bRes=(string[i] >= '0' && string[i] <= '9'))==false) break;
                        }
                }
        }
        return bRes;
}
//---------------------------------------------------------------------------------
inline bool isblank(const char *str)
{
        size_t i;
        for(i=0; str[i]!=0; i++){
                if(str[i]!=' ') return false;
        }
        return true;
}
//---------------------------------------------------------------------------------
#ifdef STRUTILS_WIN_WCHAR
inline wchar_t * str2wchar(const char *sz)
{
        size_t len=strlen(sz);
        wchar_t *ws=new wchar_t[len + 1];
        MultiByteToWideChar(CP_ACP, 0, sz, len, ws, len);
        ws[len]=0;
        return ws;
}
//---------------------------------------------------------------------------------
inline char * wchar2str(const wchar_t *ws)
{
        size_t len=wcslen(ws);
        char *sz=new char[len + 1];
        WideCharToMultiByte(CP_ACP, 0, ws, len, sz, len, 0, 0);
        sz[len]=0;
        return sz;
}
//---------------------------------------------------------------------------------
#endif // defined(STRUTILS_WIN_WCHAR)

#endif // !defined(STRUTILS_INCLUDED)