Tools/Xabsl2/yabsl/vsyabsl/text.h

Go to the documentation of this file.

/***************************************************************************
         Copyright (c) Microsoft Corporation, All rights reserved.             
    This code sample is provided "AS IS" without warranty of any kind, 
    it is not recommended for use in a production environment.
***************************************************************************/

#ifndef text_h
#define text_h

/*---------------------------------------------------------
 String function library.

 These definitions allow you to write
 unicode/ansicode independent code.

 Size specific strings:
   UniStr   = unicode string
   UniChar  = unicode character
   CUniStr  = const UniChar*

   AnsiStr  = ascii code string
   AnsiChar = ascii charactre
   CAnsiStr
   
 Portable strings:
   OleStr   = OLECHAR string
   OleChar  = OLECHAR
   COleStr

   Str      = TCHAR string; ie. uses the default windows char size.
   Char     = TCHAR
   CStr

   BSTR     = OleChar Basic Strings
   CBSTR

 Function are all prefixed with the string type:
   uniLen, strLen, ansiLen, oleLen, bstrLen

 Conversions are possible to all other types:
   uniToAnsiDup, strToOleCopy, ansiToStrCat, strToBstrDup

 If you do conversions, your function should start with
 the "USECONV" macro:
   int foo() { USECONV; ...; Char name[100]; oleToStrCopy(name,oleName,99); ... }

 You can do 'inplace' conversion for arguments using the Xxx2Xxx macros:
 a "C" can be added after the "2" for constant arguments:
   LoadTypeLibEx( Str2COle(strName), &lib )

 Most functions take an extra last arguments specifying the maximal
 *length* of the target string. This does NOT include a possible terminating
 '\0' character.

 Constant strings:
   UNI("hi"), OLE("hi"), ANSI("hi"), STR("hi")
   UNI('a'), OLE('a'), ANSI('a'), STR('a')

 Freeing strings:
   strFree, bstrFree
 
---------------------------------------------------------*/

#include <ctype.h>

#ifdef _UNICODE
#ifndef UNICODE
#define UNICODE
#endif
#endif

#define MAXSTR    255
#define MAXPATH   255
#define MAXNAME   99
#define MAXGUID     99
#define MAXIID      MAXGUID
#define MAXCLSID    MAXGUID


typedef unsigned    Nat;

//define conversions: STR2(UNI/ANSI) OLE2(UNI/ANSI)

#ifdef UNICODE
#define STR2UNI
#define OLE2UNI
#else
#define STR2ANSI
#ifndef OLE2ANSI
#define OLE2UNI
#endif
#endif

#ifdef OLE2UNI
#define BSTR2UNI
#else
#define BSTR2ANSI
#endif


//define the basic characters
typedef unsigned short  UniChar;
typedef char            AnsiChar;

#ifndef OLECHAR
#ifdef OLE2ANSI
typedef AnsiChar    OLECHAR;
#else
typedef UniChar     OLECHAR;
#endif
#endif

//define string prefixes
#define UNI(s)  L##s
#define ANSI(s) (s)

//define the portable Char type
#if defined (UNICODE)
    typedef UniChar Char;
#define STR(s)  UNI(s)
#else
    typedef AnsiChar Char;
#define STR(s)  ANSI(s)
#endif

//define portable OLE/BSTR Char type
#ifdef OLE2ANSI
#define OLE ANSI
#else
#define OLE UNI
#endif

typedef OLECHAR OleChar;
typedef OleChar BstrChar;

//strings
typedef Char*       Str;
typedef UniChar*    UniStr;
typedef AnsiChar*   AnsiStr;
typedef OleChar*    OleStr;
typedef BSTR        Bstr;

typedef const Char*     CStr;
typedef const UniChar*  CUniStr;
typedef const AnsiChar* CAnsiStr;
typedef const OleChar*  COleStr;
typedef COleStr         CBstr;
typedef COleStr         CBSTR;

//helpers
#define ansiFree(s) FREE(s)
#define uniFree(s)  FREE(s)
#define strFree(s)  FREE(s)
#define oleFree(s)  FREE(s)


//define the basic ansi/uni code specific functions
int ansiToUniLen( CAnsiStr s );
int uniToAnsiLen( CUniStr s );

UniStr  ansiToUniCopy( UniStr dest, CAnsiStr src, int maxLen );
AnsiStr uniToAnsiCopy( AnsiStr dest, CUniStr src, int maxLen );

UniStr  ansiToUniDup( CAnsiStr s );
AnsiStr uniToAnsiDup( CUniStr s );

UniStr  ansiToUniCat( UniStr dest, CAnsiStr src, int maxLen );
AnsiStr uniToAnsiCat( AnsiStr dest, CUniStr src, int maxLen );

UniStr  uniCopy( UniStr dest, CUniStr src, int maxLen );
AnsiStr ansiCopy( AnsiStr dest, CAnsiStr src, int maxLen );

UniStr  uniCat( UniStr dest, CUniStr src, int maxLen );
AnsiStr ansiCat( AnsiStr dest, CAnsiStr src, int maxLen );


inline  bool   uniEmpty( CUniStr s )        { return (s == NULL || s[0] == 0);  }
inline  int    uniLen( CUniStr s )          { return (s ? lstrlenW(s) : 0);     }
inline  UniStr uniDup( CUniStr s)           { return (s ? wcsdup(s) : NULL);    }

inline  UniStr uniToLower( UniStr s )       { return (s ? _wcslwr(s) : NULL);   }
inline  UniStr uniToUpper( UniStr s )       { return (s ? _wcsupr(s) : NULL);   }
inline  int    uniToInt( CUniStr s )        { return (s ? _wtoi(s) : 0 );       }
inline  void   uniClear( UniStr s )         { if (s) s[0] = UNI('\0');          }

inline  int uniCompare( CUniStr s, CUniStr t )
{
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return wcscmp(s,t);
}

inline  int uniICompare( CUniStr s, CUniStr t )
{
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return wcsicmp(s,t);
}

inline  int uniCompareLen( CUniStr s, CUniStr t, Nat n )
{
    if (n == 0) return 0;
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return wcsncmp(s,t,n);
}

inline  int uniICompareLen( CUniStr s, CUniStr t, Nat n )
{
    if (n == 0) return 0;
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return wcsnicmp(s,t,n);
}

inline UniStr uniFindSubStr( CUniStr s, CUniStr sub )  
{
    if (!s)     return NULL;
    if (!sub)   return NULL;
    return wcsstr(s,sub);
}

inline UniStr uniFindChar( CUniStr s, UniChar c )
{
    if (!s)     return NULL;
    return wcschr(s,c);
}

inline UniStr uniFindCharRev( CUniStr s, UniChar c)
{
    if (!s) return NULL;
    return wcsrchr(s,c);
}

#define uniCharToLower  towlower
#define uniCharToUpper  towupper
#define uniIsSpace      iswspace
#define uniIsPrintable  iswprint
#define uniIsControl    iswcntrl
#define uniIsAlpha      iswalpha
#define uniIsAlphaNum   iswalnum
#define uniIsDigit      iswdigit

inline  bool    ansiEmpty( CAnsiStr s )     { return (s == NULL || s[0] == 0);  }
inline  int     ansiLen( CAnsiStr s )       { return (s ? lstrlenA(s) : 0);     }
inline  AnsiStr ansiDup( CAnsiStr s)        { return (s ? strdup(s) : NULL);    }

inline  AnsiStr ansiToLower( AnsiStr s )    { return (s ? _strlwr(s) : NULL);   }
inline  AnsiStr ansiToUpper( AnsiStr s )    { return (s ? _strupr(s) : NULL);   }
inline  int     ansiToInt( CAnsiStr s )     { return (s ? atoi(s) : 0 );        }
inline  void    ansiClear( AnsiStr s )      { if (s) { s[0] = '\0'; }           }

inline  int ansiCompare( CAnsiStr s, CAnsiStr t )
{
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return strcmp(s,t);
}

inline  int ansiICompare( CAnsiStr s, CAnsiStr t )
{
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return stricmp(s,t);
}

inline  int ansiCompareLen( CAnsiStr s, CAnsiStr t, Nat n )
{
    if (n == 0) return 0;
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return strncmp(s,t,n);
}

inline  int ansiICompareLen( CAnsiStr s, CAnsiStr t, Nat n )
{
    if (n == 0) return 0;
    if (s == t) return 0;
    if (!s)     return (-1);
    if (!t)     return 1;
                return strnicmp(s,t,n);
}

inline  AnsiStr ansiFindSubStr( CAnsiStr s, CAnsiStr sub )  
{
    if (!s)     return NULL;
    if (!sub)   return NULL;
    return strstr(s,sub);
}

inline  AnsiStr ansiFindChar( CAnsiStr s, AnsiChar c )
{
    if (!s)     return NULL;
    return strchr(s,c);
}

inline AnsiStr ansiFindCharRev( CAnsiStr s, AnsiChar c )
{
    if (!s)     return NULL;
    return strrchr(s,c);
}

#define ansiCharToLower     tolower
#define ansiCharToUpper     toupper

#define ansiIsSpace         isspace
#define ansiIsPrintable     isprint
#define ansiIsControl       iscntrl
#define ansiIsAlpha         isalpha
#define ansiIsAlphaNum      isalnum
#define ansiIsDigit         isdigit

//conversion macros
#define USECONV     int _convlen = 0; _convlen

#define Uni2Ansi(u) (\
    (NULL==u) ? NULL : (\
        _convlen = uniToAnsiLen(u), \
            uniToAnsiCopy( (AnsiStr)_alloca((_convlen+1)*sizeof(AnsiChar)), u, _convlen )))

#define Ansi2Uni(a) (\
    (NULL==a) ? NULL : (\
        _convlen = ansiToUniLen(a), \
           ansiToUniCopy( (UniStr)_alloca((_convlen+1)*sizeof(UniChar)), a, _convlen )))

#define AnsiCopy(a) (\
    (NULL==a) ? NULL : (\
        _convlen = ansiLen(a), \
            ansiCopy( (AnsiStr)_alloca((_convlen+1)*sizeof(AnsiChar)), a, _convlen )))

#define UniCopy(u) (\
    (NULL==u) ? NULL : (\
       _convlen = uniLen(u), \
            uniCopy( (UniStr)_alloca((_convlen+1)*sizeof(UniChar)), u, _convlen )))

#define Uni2CAnsi(u)    ((CAnsiStr)Uni2Ansi(u))
#define Ansi2CUni(a)    ((CUniStr)Ansi2Uni(a))


//Str conversion
#ifdef UNICODE

#define Uni2Str UniCopy
#define Str2Uni UniCopy
inline  CStr    Uni2CStr( CUniStr u )   { return u; };
inline  CUniStr Str2CUni( CStr s )      { return s; };

#define Ansi2Str  Ansi2Uni
#define Str2Ansi  Uni2Ansi
#define Ansi2CStr Ansi2CUni
#define Str2CAnsi Uni2CAnsi

#define uniToStrLen     uniLen
#define uniToStrCopy    uniCopy
#define uniToStrDup     uniDup
#define uniToStrCat     uniCat

#define strToUniLen     uniLen
#define strToUniCopy    uniCopy
#define strToUniDup     uniDup
#define strToUniCat     uniCat

#define ansiToStrLen    ansiToUniLen
#define ansiToStrCopy   ansiToUniCopy
#define ansiToStrDup    ansiToUniDup
#define ansiToStrCat    ansiToUniCat

#define strToAnsiLen    uniToAnsiLen
#define strToAnsiCopy   uniToAnsiCopy
#define strToAnsiDup    uniToAnsiDup
#define strToAnsiCat    uniToAnsiCat

#else

#define Ansi2Str    AnsiCopy
#define Str2Ansi    AnsiCopy
inline  CStr        Ansi2CStr( CAnsiStr a ){ return a; };
inline  CAnsiStr    Str2CAnsi( CStr s  )    { return s; };

#define Uni2Str  Uni2Ansi
#define Str2Uni  Ansi2Uni
#define Uni2CStr Uni2CAnsi
#define Str2CUni Ansi2CUni

#define uniToStrLen     uniToAnsiLen
#define uniToStrCopy    uniToAnsiCopy
#define uniToStrDup     uniToAnsiDup
#define uniToStrCat     uniToAnsiCat

#define strToUniLen     ansiToUniLen
#define strToUniCopy    ansiToUniCopy
#define strToUniDup     ansiToUniDup
#define strToUniCat     ansiToUniCat

#define ansiToStrLen    ansiLen
#define ansiToStrCopy   ansiCopy
#define ansiToStrDup    ansiDup
#define ansiToStrCat    ansiCat

#define strToAnsiLen    ansiLen
#define strToAnsiCopy   ansiCopy
#define strToAnsiDup    ansiDup
#define strToAnsiCat    ansiCat


#endif


//Ole conversion
#ifdef OLE2ANSI

#define Ansi2Ole    AnsiCopy
#define Ole2Ansi    AnsiCopy
inline  COleStr     Ansi2COle( CAnsiStr a ){ return a; };
inline  CAnsiStr    Ole2CAnsi( COleStr s ) { return s; };

#define Uni2Ole  Uni2Ansi
#define Ole2Uni  Ansi2Uni
#define Uni2COle Uni2CAnsi
#define Ole2CUni Ansi2CUni

#define uniToOleLen     uniToAnsiLen
#define uniToOleCopy    uniToAnsiCopy
#define uniToOleDup     uniToAnsiDup
#define uniToOleCat     uniToAnsiCat

#define oleToUniLen     ansiToUniLen
#define oleToUniCopy    ansiToUniCopy
#define oleToUniDup     ansiToUniDup
#define oleToUniCat     ansiToUniCat

#define ansiToOleLen    ansiLen
#define ansiToOleCopy   ansiCopy
#define ansiToOleDup    ansiDup
#define ansiToOleCat    ansiCat

#define oleToAnsiLen    ansiLen
#define oleToAnsiCopy   ansiCopy
#define oleToAnsiDup    ansiDup
#define oleToAnsiCat    ansiCat

#else

#define Uni2Ole UniCopy
#define Ole2Uni UniCopy
inline  COleStr Uni2COle( CUniStr u )   { return u; };
inline  CUniStr Ole2CUni( COleStr o )   { return o; };

#define Ansi2Ole  Ansi2Uni
#define Ole2Ansi  Uni2Ansi
#define Ansi2COle Ansi2CUni
#define Ole2CAnsi Uni2CAnsi

#define uniToOleLen     uniLen
#define uniToOleCopy    uniCopy
#define uniToOleDup     uniDup

#define oleToUniLen     uniLen
#define oleToUniCopy    uniCopy
#define oleToUniDup     uniDup
#define oleToUniCat     uniCat

#define ansiToOleLen    ansiToUniLen
#define ansiToOleCopy   ansiToUniCopy
#define ansiToOleDup    ansiToUniDup
#define ansiToOleCat    ansiToUniCat

#define oleToAnsiLen    uniToAnsiLen
#define oleToAnsiCopy   uniToAnsiCopy
#define oleToAnsiDup    uniToAnsiDup
#define oleToAnsiCat    uniToAnsiCat

#endif

//Ole - Str conversion

#if defined(UNICODE)
//ole and str are the same
#define Ole2Str UniCopy
#define Str2Ole UniCopy
inline  COleStr Str2COle( CStr s )      { return s; };
inline  CStr    Ole2CStr( COleStr o )   { return o; };

#define oleToStrLen     uniLen
#define oleToStrCopy    uniCopy
#define oleToStrDup     uniDup
#define oleToStrCat     uniCat

#define strToOleLen     uniLen
#define strToOleCopy    uniCopy
#define strToOleDup     uniDup
#define strToOleCat     uniCat

#elif defined(OLE2ANSI)
//ole and str are the same
#define Str2Ole AnsiCopy
#define Ole2Str AnsiCopy
inline  COleStr Str2COle( CStr s )      { return s; };
inline  CStr    Ole2CStr( COleStr o )   { return o; };

#define oleToStrLen     ansiLen
#define oleToStrCopy    ansiCopy
#define oleToStrDup     ansiDup
#define oleToStrCat     ansiCat

#define strToOleLen     ansiLen
#define strToOleCopy    ansiCopy
#define strToOleDup     ansiDup
#define strToOleCat     ansiCat


#else
//ole is uni, str is ansi
#define Ole2Str  Uni2Ansi
#define Str2Ole  Ansi2Uni
#define Ole2CStr Uni2CAnsi
#define Str2COle Ansi2CUni

#define oleToStrLen     uniToAnsiLen
#define oleToStrCopy    uniToAnsiCopy
#define oleToStrDup     uniToAnsiDup
#define oleToStrCat     uniToAnsiCat

#define strToOleLen     ansiToUniLen
#define strToOleCopy    ansiToUniCopy
#define strToOleDup     ansiToUniDup
#define strToOleCat     ansiToUniCat

#endif


//utility functions

//Str
#ifdef UNICODE

#define strEmpty            uniEmpty
#define strLen              uniLen
#define strCopy             uniCopy
#define strCat              uniCat
#define strDup              uniDup
#define strClear            uniClear
#define strCompare          uniCompare
#define strICompare         uniICompare
#define strCompareLen       uniCompareLen
#define strICompareLen      uniICompareLe
#define strToLower          uniToLower
#define strToUpper          uniToUpper
#define strCharToLower      uniCharToLower
#define strCharToUpper      uniCharToUpper
#define strFindSubStr       uniFindSubStr
#define strFindChar         uniFindChar
#define strFindCharRev      uniFindCharRev
#define strToInt            uniToInt
#define strIsSpace          uniIsSpace
#define strIsPrintable      uniIsPrintable  
#define strIsControl        uniIsControl    
#define strIsAlpha          uniIsAlpha      
#define strIsAlphaNum       uniIsAlphaNum   
#define strIsDigit          uniIsDigit      
#else

#define strEmpty            ansiEmpty
#define strLen              ansiLen
#define strCopy             ansiCopy
#define strCat              ansiCat
#define strDup              ansiDup
#define strClear            ansiClear
#define strCompare          ansiCompare
#define strICompare         ansiICompare
#define strCompareLen       ansiCompareLen
#define strICompareLen      ansiICompareLen
#define strToLower          ansiToLower
#define strToUpper          ansiToUpper
#define strCharToLower      ansiCharToLower
#define strCharToUpper      ansiCharToUpper
#define strFindSubStr       ansiFindSubStr
#define strFindChar         ansiFindChar
#define strFindCharRev      ansiFindCharRev
#define strToInt            ansiToInt
#define strIsSpace          ansiIsSpace
#define strIsPrintable      ansiIsPrintable  
#define strIsControl        ansiIsControl    
#define strIsAlpha          ansiIsAlpha      
#define strIsAlphaNum       ansiIsAlphaNum   
#define strIsDigit          ansiIsDigit      


#endif


//Ole
#ifdef OLE2ANSI

#define oleEmpty            ansiEmpty
#define oleLen              ansiLen
#define oleCopy             ansiCopy
#define oleCat              ansiCat
#define oleDup              ansiDup
#define oleClear            ansiClear
#define oleCompare          ansiCompare
#define oleICompare         ansiICompare
#define oleCompareLen       ansiCompareLen
#define oleICompareLen      ansiICompareLen
#define oleToLower          ansiToLower
#define oleToUpper          ansiToUpper
#define oleCharToLower      ansiCharToLower
#define oleCharToUpper      ansiCharToUpper
#define oleFindSubStr       ansiFindSubStr
#define oleFindChar         ansiFindChar
#define oleFindCharRev      ansiFindCharRev
#define oleToInt            ansiToInt
#define oleIsSpace          ansiIsSpace
#define oleIsPrintable      ansiIsPrintable  
#define oleIsControl        ansiIsControl    
#define oleIsAlpha          ansiIsAlpha      
#define oleIsAlphaNum       ansiIsAlphaNum   
#define oleIsDigit          ansiIsDigit      

#else

#define oleEmpty            uniEmpty
#define oleLen              uniLen
#define oleCopy             uniCopy
#define oleCat              uniCat
#define oleDup              uniDup
#define oleClear            uniClear
#define oleCompare          uniCompare
#define oleICompare         uniICompare
#define oleCompareLen       uniCompareLen
#define oleICompareLen      uniICompareLen
#define oleToLower          uniToLower
#define oleToUpper          uniToUpper
#define oleCharToLower      uniCharToLower
#define oleCharToUpper      uniCharToUpper
#define oleFindSubStr       uniFindSubStr
#define oleFindChar         uniFindChar
#define oleFindCharRev      uniFindCharRev
#define oleToInt            uniToInt
#define oleIsSpace          uniIsSpace
#define oleIsPrintable      uniIsPrintable  
#define oleIsControl        uniIsControl    
#define oleIsAlpha          uniIsAlpha      
#define oleIsAlphaNum       uniIsAlphaNum   
#define oleIsDigit          uniIsDigit      

#endif



//BSTR
inline  bool bstrEmpty( CBSTR s )      { return (s == NULL || s[0] == 0); }
inline  int  bstrLen( CBSTR s)         { return (s ? SysStringLen((BSTR)s) : 0 ); }
inline  BSTR bstrDup( CBSTR s)         { return (s ? SysAllocString((BSTR)s) : NULL ); }

void bstrFree( BSTR& );
BSTR bstrCopy( BSTR&, COleStr, int maxLen );
BSTR bstrCat( BSTR&, COleStr, int maxLen ); 

//conversion
//use dup for 'to bstr' conversion
#define ansiToBstrDup(s)    bstrDup( Ansi2COle(s) )
#define uniToBstrDup(s)     bstrDup( Uni2COle(s) )
#define strToBstrDup(s)     bstrDup( Str2COle(s) )
#define oleToBstrDup(s)     bstrDup( s )

#define bstrNew(s)          oleToBstrDup( OLE(s) )

#define bstrToAnsiDup   oleToAnsiDup
#define bstrToUniDup    oleToUniDup
#define bstrToStrDup    oleToStrDup
#define bstrToOleDup    oleDup

#define Bstr2Ansi       Ole2Ansi
#define Bstr2CAnsi      Ole2CAnsi
#define Bstr2Uni        Ole2Uni
#define Bstr2CUni       Ole2CUni
#define Bstr2Str        Ole2Str
#define Bstr2CStr       Ole2CStr
#define Bstr2Ole        OleCopy
inline  COleStr Bstr2COle( BSTR s)  { return s; }

//len
#define ansiToBstrLen   ansiToOleLen
#define uniToBstrLen    uniToOleLen
#define strToBstrLen    strToOleLen
#define oleToBstrLen    oleLen

#if defined(UNICODE)
#define bstrToAnsiLen   uniToAnsiLen
#define bstrToUniLen    bstrLen
#define bstrToStrLen    bstrLen
#elif defined(OLE2ANSI)
#define bstrToAnsiLen   bstrLen
#define bstrToUniLen    ansiToUniLen
#define bstrToStrLen    bstrLen
#else
#define bstrToAnsiLen   uniToAnsiLen
#define bstrToUniLen    bstrLen
#define bstrToStrLen    uniToAnsiLen
#endif

#define bstrToOleLen    bstrLen

//copy
#define ansiToBstrCopy(d,s,l)   bstrCopy(d,Ansi2COle(s),l)
#define uniToBstrCopy(d,s,l)    bstrCopy(d,Uni2COle(s),l)
#define strToBstrCopy(d,s,l)    bstrCopy(d,Str2COle(s),l)
#define oleToBstrCopy(d,s,l)    bstrCopy(d,s,l)

#define bstrToAnsiCopy      oleToAnsiCopy
#define bstrToUniCopy       oleToUniCopy
#define bstrToStrCopy       oleToStrCopy
#define bstrToOleCopy       oleCopy

//cat
#define ansiToBstrCat(d,s,l)    bstrCat(d,Ansi2COle(s),l)
#define uniToBstrCat(d,s,l)     bstrCat(d,Uni2COle(s),l)
#define strToBstrCat(d,s,l)     bstrCat(d,Str2COle(s),l)
#define oleToBstrCat(d,s,l)     bstrCat(d,s,l)

#define bstrToAnsiCat           oleToAnsiCat
#define bstrToUniCat            oleToUniCat
#define bstrToStrCat            oleToStrCat
#define bstrToOleCat            oleCat

#define bstrClear           bstrFree
#define bstrCompare         oleCompare
#define bstrICompare        oleICompare
#define bstrCompareLen      oleCompareLen
#define bstrICompareLen     oleICompareLen
#define bstrToLower         oleToLower
#define bstrToUpper         oleToUpper
#define bstrFindSubStr      oleFindSubStr
#define bstrFindChar        oleFindChar
#define bstrFindCharRev     oleFindCharRev
#define bstrToInt           oleToInt

//end include
#endif

---