|
|
//+----------------------------------------------------------------------------
//
// Copyright (c) 1996 Microsoft Corporation
//
// File: olestr.h
//
// Synopsis: ct versions of the printf family and olestr functions
//
// History: 30-May-96 MikeW Created.
// 12-Nov-97 a-sverrt Added a couple more olestrxxx macros.
//
// Notes: The ct version of the printf family adds two new format
// specifiers: %os and %oc. These specifiers mean ole-string
// and ole-character respectively.
//
// In the ANSI-version of this family these specifiers mean
// "an octal digit followed by the letter s (or c)". Code that
// uses octal should be careful when using these functions.
//
//-----------------------------------------------------------------------------
#ifndef _OLESTR_H_
#define _OLESTR_H_
//
// Determine if Ole is Unicode based or not
//
#if !defined(WIN16) && !defined(_MAC)
#define OLE_IS_UNICODE
#endif
//
// Use : as path separator on Mac
//
#ifdef _MAC
#define CH_SEP ':'
#define SZ_SEP TEXT(":")
#else
#define CH_SEP '\\'
#define SZ_SEP TEXT("\\")
#endif // _MAC
//
// Format specifiers for Unicode and Ansi strings and characters
//
#define UNICODE_STRING_SPECIFIER "ls"
#define UNICODE_CHAR_SPECIFIER "lc"
#define ANSI_STRING_SPECIFIER "hs"
#define ANSI_CHAR_SPECIFIER "hc"
//
// Format specifiers for Ole strings and characters
//
#ifdef OLE_IS_UNICODE
#define OLE_STRING_SPECIFIER UNICODE_STRING_SPECIFIER
#define OLE_CHAR_SPECIFIER UNICODE_CHAR_SPECIFIER
#else // !OLE_IS_UNICODE
#define OLE_STRING_SPECIFIER ANSI_STRING_SPECIFIER
#define OLE_CHAR_SPECIFIER ANSI_CHAR_SPECIFIER
#endif // !OLE_IS_UNICODE
//
// Unicode/Ansi indepedent ctprintf-family
//
#ifndef UNICODE_ONLY
int ctprintfA(const char *format, ...);int ctsprintfA(char *buffer, const char *format, ...);int ctsnprintfA(char *buffer, size_t count, const char *format, ...);int ctfprintfA(FILE *stream, const char *format, ...);int ctvprintfA(const char *format, va_list varargs);int ctvsprintfA(char *buffer, const char *format, va_list varargs);int ctvsnprintfA( char *buffer, size_t count, const char *format, va_list varargs);int ctvfprintfA(FILE *stream, const char *format, va_list varargs);
#endif // !UNICODE_ONLY
#ifndef ANSI_ONLY
int ctprintfW(const wchar_t *format, ...);int ctsprintfW(wchar_t *buffer, const wchar_t *format, ...);int ctsnprintfW(wchar_t *buffer, size_t count, const wchar_t *format, ...);int ctfprintfW(FILE *stream, const wchar_t *format, ...);int ctvprintfW(const wchar_t *format, va_list varargs);int ctvsprintfW(wchar_t *buffer, const wchar_t *format, va_list varargs);int ctvsnprintfW( wchar_t *buffer, size_t count, const wchar_t *format, va_list varargs);int ctvfprintfW(FILE *stream, const wchar_t *format, va_list varargs);
#endif //!ANSI_ONLY
#ifdef UNICODE
#define ctprintf ctprintfW
#define ctsprintf ctsprintfW
#define ctsnprintf ctsnprintfW
#define ctfprintf ctfprintfW
#define ctvprintf ctvprintfW
#define ctvsprintf ctvsprintfW
#define ctvsnprintf ctvsnprintfW
#define ctvfprintf ctvfprintfW
#else // !UNICODE
#define ctprintf ctprintfA
#define ctsprintf ctsprintfA
#define ctsnprintf ctsnprintfA
#define ctfprintf ctfprintfA
#define ctvprintf ctvprintfA
#define ctvsprintf ctvsprintfA
#define ctvsnprintf ctvsnprintfA
#define ctvfprintf ctvfprintfA
#endif // !UNICODE
//
// Unicode/Ansi independent ole string functions
//
#ifdef OLE_IS_UNICODE
#define olembstowcs(x,y,z) mbstowcs(x,y,z)
#define olestrcat wcscat
#define olestrchr wcschr
#define olestrcmp wcscmp
#define olestrcpy wcscpy
#define _olestricmp _wcsicmp
#define olestrlen wcslen
#define olestrncmp wcsncmp
#define olestrncpy wcsncpy
#define _olestrnicmp _wcsnicmp
#define olestrrchr wcsrchr
#define olestrstr wcsstr
#define olestrtok wcstok
#define olestrtol wcstol
#define olestrtoul wcstoul
#define olestrtombs(x,y,z) wcstombs(x,y,z)
#define olewcstombs(x,y,z) wcstombs(x,y,z)
#define tooleupper towupper
#define _ltoole _ltow
#define olectsnprintf ctsnprintfW
#define olectsprintf ctsprintfW
#define olesscanf swscanf
#define olesprintf swprintf
#else // !OLE_IS_UNICODE
#define olembstowcs(x,y,z) strcpy(x,y)
#define olestrcat strcat
#define olestrchr strchr
#define olestrcmp strcmp
#define olestrcpy strcpy
#define _olestricmp _stricmp
#define olestrlen strlen
#define olestrncmp strncmp
#define olestrncpy strncpy
#define _olestrnicmp _strnicmp
#define olestrrchr strrchr
#define olestrstr strstr
#define olestrtok strtok
#define olestrtol strtol
#define olestrtoul strtoul
#define olestrtombs(x,y,z) strncpy(x,y,z)
#define olewcstombs(x,y,z) strcpy(x,y) // srt: equivalent to converting in this case
#define tooleupper toupper
#define _ltoole _ltoa
#define olectsnprintf ctsnprintfA
#define olectsprintf ctsprintfA
#define olesscanf sscanf
#define olesprintf sprintf
#endif // !OLE_IS_UNICODE
//
// String copy & conversion functions
//
#ifdef __cplusplus
HRESULT CopyString(LPCWSTR, LPSTR *);HRESULT CopyString(LPCSTR, LPWSTR *);HRESULT CopyString(LPCSTR, LPSTR *);HRESULT CopyString(LPCWSTR, LPWSTR *);HRESULT CopyString(LPCWSTR, LPSTR, int, int);HRESULT CopyString(LPCSTR, LPWSTR, int, int);
//+--------------------------------------------------------------------------
//
// unsigned char thunks
//
// DBCS chars are unsigned so the signed functions above won't match.
// However, the signed functions are written to be DBCS aware so it's ok
// to just cast & thunk.
//
//---------------------------------------------------------------------------
inline HRESULT CopyString(LPCWSTR pszSource, unsigned char **ppszDest){ return CopyString(pszSource, (char **) ppszDest);}
inline HRESULT CopyString(unsigned char *pszSource, LPWSTR *ppszDest){ return CopyString((char *) pszSource, ppszDest);}
inline HRESULT CopyString(unsigned char *pszSource, unsigned char ** ppszDest){ return CopyString((char *) pszSource, (char **) ppszDest);}
#endif // __cplusplus
HRESULT TStringToOleString(LPCTSTR pszSource, LPOLESTR *ppszDest);HRESULT WStringToOleString(LPCWSTR pszSource, LPOLESTR *ppszDest);HRESULT AStringToOleString(LPCSTR pszSource, LPOLESTR *ppszDest);
HRESULT OleStringToTString(LPCOLESTR pszSource, LPTSTR *ppszDest);HRESULT OleStringToWString(LPCOLESTR pszSource, LPWSTR *ppszDest);HRESULT OleStringToAString(LPCOLESTR pszSource, LPSTR *ppszDest);
HRESULT TStringToAString (LPCTSTR pszSource, LPSTR *ppszDest);HRESULT AStringToTString (LPCSTR pszSource, LPTSTR *ppszDest);
#endif // _OLESTR_H_
|
