StrFunc.h

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: String functions.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
// Credits: LefterisE@stackoverflow.com for the neat stristr algorithm.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#ifndef _StrFunc_h_incl_
#define _StrFunc_h_incl_

#undef USE_ULIB_NEW_DELETE // Define this to make 'new' use mem_Alloc (not recommended).

#include <uLib/MemFunc.h>
#include <String.h>
#include <Time.h> // Used by SysTimeStr

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#if defined(_MSC_VER) && (_MSC_VER > 1200)
  // Note: _MSC_VER 1200 == VC6 (But.. When was __pragma actually introduced?)
  #define BEGIN_STRSAFE_OVERRIDE __pragma( warning( disable:4996 ))
  #define END_STRSAFE_OVERRIDE   __pragma( warning( default:4996 ))
#else // Sorry, I don't know how to squelch that on other compilers..
  #define BEGIN_STRSAFE_OVERRIDE
  #define END_STRSAFE_OVERRIDE
#endif

BEGIN_EXTERN_C


char*    __fastcall strecpy( register char* Dst, register const char* Src );
wchar_t* __fastcall wcsecpy( register wchar_t* Dst, register const wchar_t* Src ); 


char*    __fastcall strnecpy( register char* Dst, register const char* Src, size_t N );
wchar_t* __fastcall wcsnecpy( register wchar_t* Dst, register const wchar_t* Src, size_t N ); 


char*    stristr( const char* str, const char* pattern );
wchar_t* wcsistr( const wchar_t* str, const wchar_t* pattern ); 


char*    __fastcall strncpyz( register char* Dst, register const char* Src, size_t Count );
wchar_t* __fastcall wcsncpyz( register wchar_t* Dst, register const wchar_t* Src, size_t Count ); 


size_t wcsbytes( const wchar_t* Src );

#ifdef _UNICODE
  #define _tcsecpy    wcsecpy
  #define _tcsnecpy   wcsnecpy
  #define _tcsistr    wcsistr
  #define _tcsncpyz   wcsncpyz
  #define _tcsnchr    (CSTR)wmemchr
#else
  #define _tcsecpy    strecpy
  #define _tcsnecpy   strnecpy
  #define _tcsistr    stristr
  #define _tcsncpyz   strncpyz
  #define _tcsnchr    (CSTR)memchr
#endif


#ifdef __cplusplus
  bool __forceinline IsString( CSTR Str ) { return (Str && *Str); }
#else
  #define IsString( Str ) ((Str) && *(Str)) // Careful if passing expressions!
#endif


#ifdef __cplusplus
extern "C++" template <typename chrType>
    INT_PTR CharIndex( const chrType* Buffer, const chrType* Inside )
    {
        INT_PTR ix = Inside - Buffer; // Note: C typed ptr arithmetic does auto-div by element size.
        _ASSERTE( ix >= 0 ); // In case caller messed up...
        return ix;
    }
#else 
  #ifdef _UNICODE
    #define CharIndex  CharIndexW
  #else
    #define CharIndex  CharIndexA
  #endif
#endif

// Explicit A/W versions

INT_PTR CharIndexA( const CHAR* Buffer, const CHAR* Inside );
INT_PTR CharIndexW( const WCHAR* Buffer, const WCHAR* Inside );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

CSTR newStr( CSTR Src );          
TSTR newStrBuf( WORD nChar );     
CSTR deleteStr( CSTR Dup );       

WCSTR newWStr( WCSTR Src );       
WCSTR deleteWStr( WCSTR Dup );    

ASTR mem_DupAStr( ACSTR Src );    
WSTR mem_DupWStr( WCSTR Src );    
ASTR mem_AllocAStr( WORD nChar ); 
WSTR mem_AllocWStr( WORD nChar ); 
CSTR mem_FreeStr( CSTR Dup );     

#ifdef _UNICODE
  #define mem_DupStr    mem_DupWStr
  #define mem_AllocStr  mem_AllocWStr
#else
  #define mem_DupStr    mem_DupAStr
  #define mem_AllocStr  mem_AllocAStr
#endif

//-! @relatedalso stxlt // fails to appear in stxlt :(

ASTR mem_ADupWStr( WCSTR WStr, UINT CodePg DEF_(CP_ACP), UINT ccExtra DEF_(0) );

//-! @relatedalso stxlt

WSTR mem_WDupAStr( ACSTR AStr, UINT CodePg DEF_(CP_ACP), UINT ccExtra DEF_(0) );

#ifndef NO_WINTERNAL // UNICODE_STRING is considered (by MS) as "internal"
//-! @relatedalso unist

PUNICODE_STRING mem_AllocUniStr( WORD ccStr, OPTOUT PULONG cbAlloc );
#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


ACSTR _MBStr( WCSTR pWStr );

// These belong here as well, but are declared/documented in "salloc"..

// ASTR mem_ADupWStr( WCSTR WStr, UINT CodePg DEF_(CP_ACP), UINT ccExtra DEF_(0) );
// WSTR mem_WDupAStr( ACSTR AStr, UINT CodePg DEF_(CP_ACP), UINT ccExtra DEF_(0) );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


CSTR LoadStr( HMODULE hModule, UINT Id, TSTR Buf DEF_(NULL), UINT Count DEF_(0) );


WCSTR GetResourceStr( HMODULE hModule, UINT Id, PWORD pCount );


WCSTR FindResourceStrEx( HMODULE hModule, UINT Id, LANGID Lang, PWORD pCount );


CSTR DupResourceStrEx( HMODULE hModule, UINT Id, LANGID Lang, PWORD pCount );
CSTR FreeResourceStrEx( CSTR pzRcDupStr ); 


struct RC_STRING
{
    WORD  Length; 
    WCSTR Text;   

  #ifdef __cplusplus
    RC_STRING() : Length(0), Text(NULL) {}
    RC_STRING( HMODULE hModule, UINT Id ) { GetResource( hModule, Id ); }
    WCSTR GetResource( HMODULE hModule, UINT Id ) {
        return (Text = GetResourceStr( hModule, Id, &Length ));
        }
  #endif
};

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#ifdef _UNICODE
  #define EnumerateMultiSz    EnumerateMultiSzW
  #define PFnEnumMultiString  PFnEnumMultiStringW
  #define MultiSzLength       MultiSzLengthW
  #define MultiSzCount        MultiSzCountW
#else
  #define EnumerateMultiSz    EnumerateMultiSzA
  #define PFnEnumMultiString  PFnEnumMultiStringA
  #define MultiSzLength       MultiSzLengthA
  #define MultiSzCount        MultiSzCountA
#endif


typedef bool (__stdcall *PFnEnumMultiStringA)( ASTR Str, PVOID Context );
typedef bool (__stdcall *PFnEnumMultiStringW)( WSTR Str, PVOID Context );


UINT EnumerateMultiSzA( ASTR MultiSz, PFnEnumMultiStringA Action, PVOID Context );
UINT EnumerateMultiSzW( WSTR MultiSz, PFnEnumMultiStringW Action, PVOID Context );


UINT MultiSzLengthA( ACSTR MultiSz );
UINT MultiSzLengthW( WCSTR MultiSz ); 


UINT MultiSzCountA( ACSTR MultiSz );
UINT MultiSzCountW( WCSTR MultiSz ); 


TSTR MultiCrLfToLf( TSTR pText );


TSTR LinesToMultiSz( TSTR pText, UINT* ccSz );


TSTR MultiSzToLines( TSTR pText );


TSTR DuplicateMultiSz( CSTR pzMulti );
TSTR FreeMultiSz( TSTR pzMulti ); 

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


bool SplitUncPath(
    IN CSTR UncPath,
    OUT TSTR Svr, UINT ccSvr, OUT TSTR Share, UINT ccShare,
    OPTOUT TSTR Path DEF_(NULL), UINT ccPath DEF_(0)
    );


bool SplitNetShareName(
    IN CSTR ShareName,
    OUT WSTR Server, UINT ccServer, OUT WSTR Share, UINT ccShare
    );


CSTR WithoutBackslash( CSTR PathName );
CSTR WithBackslash( CSTR PathName ); 


bool GetRootOf( IN CSTR PathName, OUT TSTR Root, UINT ccRoot );


CSTR __cdecl StrFmt( TSTR Buf, UINT ccBuf, CSTR Fmt, ... );


TSTR ReplaceStrChar( TSTR Str, TCHAR From, TCHAR To, OPTOUT UINT* pCount );


bool MatchPattern( CSTR String, CSTR Pattern, bool CaseSens );


#ifndef _UNICODE
UINT DeduplicateCharSepText(
    INOUT ASTR Text, CHAR Separator, bool caseSens, bool emitSorted
    );
#endif


UINT PrependString( INOUT TSTR String, UINT ccBuf, OPTIN TCHAR Sep, CSTR Prolog );


UINT AppendString( INOUT TSTR String, UINT ccBuf, OPTIN TCHAR Sep, CSTR Epilog );


ULONG GetStringHash( WCSTR Str,
    ULONG Algorithm DEF_(0), //HASH_STRING_ALGORITHM_DEFAULT
    bool caseSens DEF_(true)
    );
#ifndef HASH_STRING_ALGORITHM_DEFAULT
  #define HASH_STRING_ALGORITHM_DEFAULT (0)
  #define HASH_STRING_ALGORITHM_X65599  (1)
  #define HASH_STRING_ALGORITHM_INVALID (0xffffffff)
#endif


CSTR HexString (
    PBYTE pData, UINT dataLen,
    TSTR strBuf DEF_(NULL), UINT bufSize DEF_(0),
    bool tailDots DEF_(false)
    );


CSTR DataSizeStr( UINT64 Size );


CSTR IsoDataSizeStr( UINT64 Size );


CSTR FileAttribStr( DWORD Attr );


#define DEF_DATETIME_FMT _T("%Y-%m-%d %H.%M.%S")


CSTR FileTimeStr( FILETIME* FTime, CSTR Fmt DEF_( DEF_DATETIME_FMT ));

// N.B: The \% escaping above is for doxygen, e.g \%A is really %A.

CSTR SysTimeStr( SYSTEMTIME* Time, CSTR Fmt );


CSTR FileTypeStr( CSTR FName );


CSTR EngFormat( long double Value, BYTE nDecimals, CSTR Unit DEF_(NULL) );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

CSTR GetGUIDString( REFIID riid, TSTR pzBuf DEF_(NULL), UINT ccBuf DEF_(0) );

CSTR GetIIDString( REFIID riid, TSTR pzBuf DEF_(NULL), UINT ccBuf DEF_(0) );

CSTR GetCLSIDString( REFIID riid, TSTR pzBuf DEF_(NULL), UINT ccBuf DEF_(0) );

CSTR GetCLSIDAppname( REFIID riid, TSTR pzBuf DEF_(NULL), UINT ccBuf DEF_(0) );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#ifndef NO_WINTERNAL // UNICODE_STRING is "internal" due to where it's declared..


PUNICODE_STRING _InitUnicodeString( PUNICODE_STRING puStr, PCWSTR pwzSrc );


PSTRING _InitString( PSTRING pStr, LPCSTR pzSrc );


bool SetUnicodeString( PUNICODE_STRING puStr, WCSTR wzSrc );


#define INIT_PACKED_UNICODE_STRING( pu, bufsize ) \
    (pu)->Buffer = (PWSTR)( (PBYTE)(pu) + sizeof(UNICODE_STRING) ); \
    (pu)->MaximumLength = bufsize - sizeof(UNICODE_STRING); \
    (pu)->Length = 0


PUNICODE_STRING InitPackedUnicodeString( PVOID Buffer, USHORT cbBuffer );

// mem_AllocUnistr() belong here too, but is declared/documented in "salloc".

#endif // NO_WINTERNAL
END_EXTERN_C
#ifdef __cplusplus

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class UString : public UNICODE_STRING {
protected:
    WORD  Flags;
    enum eFlags {
        UF_OWN_BUFFER = 0x0001
        };
    bool _allocBuf( size_t nChar );
    void _freeBuf();
public:
    UString();
    UString( WCSTR Src );
    UString( ACSTR Src ); 
    UString( const UNICODE_STRING& Src ); 
    UString( size_t Len ); 
    void    Clear() { _freeBuf(); }
    virtual ~UString();

    UString& operator = ( WCSTR Src );
    UString& operator = ( ACSTR Src ); 
    UString& operator = ( const UNICODE_STRING& Src ); 

    void Set( WCSTR Src );
    bool Set( ACSTR Src ); 
    bool Set( const UNICODE_STRING& Src ); 

    operator PWSTR()  { return Buffer; }
    operator PCWSTR() { return (PCWSTR) Buffer; }
    operator UNICODE_STRING()  { return *this; } 
    operator PUNICODE_STRING() { return this; }  
};

#endif//def __cplusplus
#ifdef __cplusplus

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  Used internally in uLib here and there..
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

struct StringEntry : LIST_ENTRY
{
    CSTR     Name; 
    UINT_PTR Data; 

    StringEntry( CSTR pzName, UINT_PTR uData ) { Name = newStr( pzName ); Data = uData; }
    ~StringEntry() { deleteStr( Name ); }


    static bool __stdcall _delete( PLIST_ENTRY This, PVOID Ctx ) {
        delete (StringEntry*) This; return true;
        }
};
typedef struct StringEntry* PStringEntry;
#ifdef __DOXYGEN__
typedef struct StringEntry  StringEntry;
#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class StringCache {
public:
    char* Storage;  
    //union _uStrg { // Under consideration...
    //char*    a;  //!< @dt Multi-string content buffer. Treat as R/O.
    //wchar_t* w;  //!< @dt Multi-string content buffer. Treat as R/O.
    //} Storage;


    StringCache( UINT InitSize DEF_(4096), UINT ChunkSize DEF_(4096) );

    // TODO: Add ctor for existing multi-sz block, eg. ini section..

    ~StringCache(); 

    // NOTE: DupStr may cause a reallocation of Storage which will invalidate
    // any external string poiters referencing the previous storage block.
    // WordList handles this case, but user code might not..

    char* DupStr( char* Str ); 
    //wchar_t* DupStr( wchar_t* Str ); //!< @dt Copy *Str* into next available Storage.

    void Reset(); 
    void Free();  
    int StorageSize() { return StgSize; }
    int StorageUsed() { return StgUsed; }

protected:
    UINT  StgSize, StgUsed, StgChunk; // Storage size, used, chunk size
    bool  GrowStorage(); // Grow the string content block.
};
typedef class StringCache* PStringCache;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class WordList : public StringCache {
public:
    char** Strings; 
    //union _uStrs { // Under consideration..
    //    char**    a;
    //    wchar_t** w;
    //} Strings; //!< @dt Sorted string list (pointer array). Treat as R/O.
    UINT Count;     


    WordList( // Default = 128 strings of 32 char average.
        UINT InitListDim DEF_(128), UINT InitStgSize DEF_(4096),
        UINT ListGrowBy DEF_(128), UINT StgGrowBy DEF_(4096)
        );

    // TODO: Add ctor for existing StringCache, eg. ini section..

    ~WordList(); 


    bool AddString( char* Str, bool caseSens = true );
    //bool AddString( wchar_t* Str, bool caseSens = true );


    char* Search( char* Key,
        int (__stdcall *Compare)( char* Key, char* Str, void* Ctx ),
        void* Context
        );
    //wchar_t* Search( wchar_t* Key,
    //    int (__stdcall *Compare)( wchar_t* Key, wchar_t* Str, void* Ctx ),
    //    void* Context
    //    );

    void Reset(); 
    void Free();  

protected:
    UINT Dim; // Dimension of Strings array.
    UINT ListChunk; // Ptr chunk size.
    bool Grow(); // Grow the pointer array.
};
typedef class WordList* PWordList;

#endif//def __cplusplus
#endif //ndef _StrFunc_h_incl_
// EOF