/**********************************************************************/ /** Microsoft Windows NT **/ /** Copyright(c) Microsoft Corp., 1994 **/ /**********************************************************************/ /* string.hxx This module contains a light weight string class FILE HISTORY: Johnl 15-Aug-1994 Created MuraliK 09-July-1996 Rewrote for efficiency with no unicode support */ #ifndef _STRING_HXX_ #define _STRING_HXX_ # include // // Maximum number of characters a loadable string resource can be // # define STR_MAX_RES_SIZE ( 320) class dllexp STR; // // If an application defines STR_MODULE_NAME, it will be used // as the default module name on string loads // #ifndef STR_MODULE_NAME #define STR_MODULE_NAME NULL #endif // // These are the characters that are considered to be white space // #define ISWHITE( ch ) ((ch) == L'\t' || (ch) == L' ' || (ch) == L'\r') #define ISWHITEA( ch ) ((ch) == '\t' || (ch) == ' ' || (ch) == '\r') // // Removes useless segments from the URL and makes sure it doesn't go // past the root of the tree (i.e., "/foo/../..") // INT CanonURL( CHAR * pszPath, BOOL fIsDBCS = FALSE ); // // Map these string functions to appropriate RT call depending on the code // page of the system. Thus we only use DBCS operations when necessary. // DWORD InitializeStringFunctions( VOID ); UCHAR * IISstrupr( UCHAR * pszString ); UCHAR * IISstrlwr( UCHAR * pszString ); INT IISstrnicmp( UCHAR * pszString1, UCHAR * pszString2, size_t iSize ); size_t IISstrlen( UCHAR * pszString1 ); char * IISstrncpy (char * dest, const char * source, size_t count); INT IISstricmp( UCHAR * pszString1, UCHAR * pszString2); UCHAR *IISstrrchr(const UCHAR * pszString, UINT c); /*++ class STR: Intention: A light-weight string class supporting encapsulated string class. This object is derived from BUFFER class. It maintains following state: m_fValid - whether this object is valid - used only by STR() init functions * NYI: I need to kill this someday * m_cchLen - string length cached when we update the string. Member Functions: There are two categories of functions: 1) Safe Functions - which do integrity checking of state 2) UnSafe Functions - which do not do integrity checking, but enable writing to the data stream freely. (someday this will be enabled as Safe versions without problem for users) --*/ class dllexp STR : public BUFFER { public: STR() : BUFFER (), m_cchLen ( 0) {} // creates a stack version of the STR object - uses passed in stack buffer // STR does not free this pbInit on its own. STR( CHAR * pbInit, DWORD cbInit) : BUFFER( (BYTE *) pbInit, cbInit), m_cchLen (0) {} STR( DWORD cbInit) : BUFFER( cbInit), m_cchLen (0) {} STR( const CHAR * pchInit ) : BUFFER (), m_cchLen ( 0) { AuxInit( (const BYTE * ) pchInit); } STR( const STR & str ) : BUFFER (), m_cchLen ( 0) { AuxInit( (const BYTE * ) str.QueryStr()); } BOOL SetLen( IN DWORD cchLen) { return ( ( cchLen >= QuerySize())? FALSE : ( *((CHAR *) QueryPtr() + cchLen) = '\0', // null terminate m_cchLen = cchLen, // set the length TRUE ) ); } BOOL IsValid(VOID) const { return ( BUFFER::IsValid()) ; } // // Checks and returns TRUE if this string has no valid data else FALSE // BOOL IsEmpty( VOID) const { return ( *QueryStr() == '\0'); } BOOL Append( const CHAR * pchInit ) { return ((pchInit != NULL) ? (AuxAppend( (const BYTE * ) pchInit, ::strlen(pchInit))) : TRUE); } BOOL Append( const CHAR * pchInit, DWORD cchLen ) { return ((pchInit != NULL) ? (AuxAppend( (const BYTE * ) pchInit, cchLen)) : TRUE); } BOOL Append( const STR & str ) { return AuxAppend( (const BYTE * ) str.QueryStr(), str.QueryCCH()); } // Resets the internal string to be NULL string. Buffer remains cached. VOID Reset( VOID) { DBG_ASSERT( QueryPtr() != NULL); *(QueryStr()) = '\0'; m_cchLen = 0; } BOOL Copy( const CHAR * pchInit ) { if ( QueryPtr() ) { *(QueryStr()) = '\0'; m_cchLen = 0; } return ( (pchInit != NULL) ? AuxAppend( (const BYTE *) pchInit, ::strlen( pchInit ), FALSE ): TRUE); } BOOL SafeCopy( const CHAR * pchInit ); BOOL Copy( const CHAR * pchInit, IN DWORD cchLen ) { if ( QueryPtr() ) { *(QueryStr()) = '\0'; m_cchLen = 0; } return ( (pchInit != NULL) ? AuxAppend( (const BYTE *) pchInit, cchLen, FALSE ): TRUE); } BOOL Copy( const STR & str ) { return ( Copy(str.QueryStr(), str.QueryCCH())); } // // Loads a string from this module's string resource table // BOOL LoadString( IN DWORD dwResID, IN LPCTSTR lpszModuleName = STR_MODULE_NAME, IN DWORD dwLangID = 0); BOOL LoadString( IN DWORD dwResID, IN HMODULE hModule); // // Loads a string with insert params from this module's .mc resource // table. Pass zero for the resource ID to use *this. // BOOL FormatString( IN DWORD dwResID, IN LPCTSTR apszInsertParams[], IN LPCTSTR lpszModuleName = STR_MODULE_NAME OPTIONAL, IN DWORD cbMaxMsg = 1024 OPTIONAL ); // // Inserts and removes any odd ranged Latin-1 characters with the // escaped hexadecimal equivalent (%xx) // BOOL Escape(); BOOL EscapeSpaces(); BOOL Unescape(); // // Returns the number of bytes in the string excluding the terminating // NULL // UINT QueryCB( VOID ) const { return ( m_cchLen * sizeof(CHAR)); } // // Returns # of characters in the string excluding the terminating NULL // UINT QueryCCH( VOID ) const { return (m_cchLen); } // // Makes a copy of the stored string in given buffer // BOOL CopyToBuffer( WCHAR * lpszBuffer, LPDWORD lpcch) const; BOOL CopyToBuffer( CHAR * lpszBuffer, LPDWORD lpcch) const; // // Return the string buffer // CHAR * QueryStrA( VOID ) const { return ( QueryStr()); } CHAR * QueryStr( VOID ) const { return ((CHAR *) QueryPtr()); } // // Makes a clone of the current string in the string pointer passed in. // BOOL Clone( OUT STR * pstrClone) const { return ((pstrClone == NULL) ? (SetLastError(ERROR_INVALID_PARAMETER), FALSE) : (pstrClone->Copy( *this)) ); } // STR::Clone() // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // UNSAFE FUNCTIONS - make sure you have enough space here // Use these only if you have been dumping bytes to string // object by considering it as a buffer object // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // Append a single character VOID Append( CHAR ch) { register CHAR * pch = ((CHAR *) QueryPtr()) + (m_cchLen++); *pch = ch; *(pch+1) = '\0'; } // Append two characters VOID Append( CHAR ch1, CHAR ch2) { register CHAR * pch = ((CHAR *) QueryPtr()) + (m_cchLen += 2); *(pch-2) = ch1; *(pch-1) = ch2; *pch = '\0'; } // Append CRLF pattern \r\n --> use two character append function VOID AppendCRLF(VOID) { Append( '\r', '\n'); } private: DWORD m_cchLen; VOID AuxInit( const BYTE * pInit ); BOOL AuxAppend( const BYTE * pInit, UINT cbStr, BOOL fAddSlop = TRUE ); }; // // Quick macro for declaring a STR that will use stack memory of // bytes. If the buffer overflows then a heap buffer will be allocated // #define STACK_STR( name, size ) \ CHAR __ach##name[size]; \ STR name( __ach##name, sizeof( __ach##name )) // // Unlike the STACK_STR macro, this template can be used for member // variables in classes. // template class dllexp Str : public STR { private: CHAR m_achData[N]; // Actual data public: Str() : STR(m_achData, N) {} }; // class Str #endif // !_STRING_HXX_