archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/inetcore/mshtml/btools/tlviewer/osutil32.cpp

1149 lines
28 KiB
Raw Blame History

/*
Related Files:
[Section = Compile]
%OsUtilDir%:OsUtil.hxx
[Section =End]
*/
/* -------------------------------------------------------------------------
Project : OB - Type Information Interface
Platform : Win32
Module : osutil.cpp
Copyright (C) 1992-3, Microsoft Corporation
---------------------------------------------------------------------------
Notes : Library routines for programs that run under Win32
---------------------------------------------------------------------------
Revision History:
[ 0] 09-Mar-1993 Angelach: Created Test
[ 1] 10-Mar-1993 Angelach: added support to Win32s
[ 2] 06-Jul-1994 Angelach: added support for remoting
typelib testing
[ 3] 27-Oct-1994 Angelach: added LCMapStringX
[ 4] 06-Mar-1995 Angelach: added osGetNetDrive
[ 5] 07-Mar-1995 Angelach: added Memory-leak detection
--------------------------------------------------------------------------- */
#include "osutil32.hxx"
IMalloc FAR* ppmalloc ; // need for memory allocation
IMallocSpy FAR* g_IMallocSpy ; // [7]
/*---------------------------------------------------------------------------
NAME : osAllocSpaces
PURPOSE : obtains some spaces from the far heap
INPUTS : nSize - no of bytes to be allocated
OUTPUT : pointer to the allocated space
NOTES : caller is responsible to free up the memory after used
---------------------------------------------------------------------------*/
VOID FAR * osAllocSpaces(WORD nSize)
{
return ( (VOID FAR *)malloc(nSize) ) ;
}
/*---------------------------------------------------------------------------
NAME : osGetRootDir
PURPOSE : Retrieves pathspec of the root directory
INPUTS : lpszRootDir - storage for the pathspec
OUTPUT : none
NOTES :
---------------------------------------------------------------------------*/
VOID FAR osGetRootDir(LPXSTR lpszRootDir)
{
osStrCpy(lpszRootDir, XSTR("c:")) ;
osStrCat(lpszRootDir, szPathSep) ;
}
/*---------------------------------------------------------------------------
NAME : osGetCurDir
PURPOSE : Retrieves pathspec of the current directory
INPUTS : lpszCurDir - storage for the pathspec
OUTPUT : True if information is retrieved successfully; otherwise, False
lpszCurDir contains the pathspec if True
NOTES :
---------------------------------------------------------------------------*/
BOOL FAR osGetCurDir(LPXSTR lpszCurDir)
{
int i ;
#if defined (OAU) && !defined (UNICODE) // [1]
char szBufferC[256];
i = GetCurrentDirectory((DWORD)256, szBufferC) ;
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szBufferC,
-1,
lpszCurDir,
256);
#else // if OAU && ! UNICODE
i = GetCurrentDirectory((DWORD)256, lpszCurDir) ;
#endif // if OAU && ! UNICODE
if ( i != 0 )
return TRUE ; // info of the current directory
else // is retrieved successfully
return FALSE ;
}
/*---------------------------------------------------------------------------
NAME : osMkDir
PURPOSE : Creates a subdirectory
INPUTS : lpszSubDir - name of the subdirectory to be created
OUTPUT : True if subdirectory is created successfully; otherwise, False
NOTES :
---------------------------------------------------------------------------*/
BOOL FAR osMkDir(LPXSTR lpszSubDir)
{
SECURITY_ATTRIBUTES sa ;
BOOL rCode ;
sa.nLength = sizeof(SECURITY_ATTRIBUTES) ;
sa.lpSecurityDescriptor = NULL ;
sa.bInheritHandle = FALSE ;
#if defined (OAU) && !defined (UNICODE) // [1]
char szBufferS[256];
WideCharToMultiByte(CP_ACP,
0,
lpszSubDir,
-1,
szBufferS,
256,
NULL,
NULL);
rCode = CreateDirectory(szBufferS, &sa) ;
#else // if OAU && ! UNICODE
rCode = CreateDirectory(lpszSubDir, &sa) ;
#endif // if OAU && ! UNICODE
return rCode;
}
/*---------------------------------------------------------------------------
NAME : osItoA
PURPOSE : Gets the string representation of an integer
INPUTS : inVal - the integer in concern
lpsz - the string representation
OUTPUT : the string representation of inVal will be returned via lpsz
NOTES :
---------------------------------------------------------------------------*/
VOID FAR osItoA (int inVal, LPXSTR lpsz)
{
char szlTmp[20] ;
_itoa(inVal, szlTmp, 10) ;
#ifdef OAU
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szlTmp,
-1,
lpsz,
20);
#else // OAU
osStrCpy(lpsz, szlTmp) ;
#endif // OAU
}
/*---------------------------------------------------------------------------
NAME : osLtoA
PURPOSE : Gets the string representation of a long integer
INPUTS : inVal - the long integer in concern
lpsz - the string representation
OUTPUT : the string representation of inVal will be returned via lpsz
NOTES :
---------------------------------------------------------------------------*/
VOID FAR osLtoA (long inVal, LPXSTR lpsz)
{
char szlTmp[20] ;
_ltoa(inVal, szlTmp, 10) ;
#ifdef OAU
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szlTmp,
-1,
lpsz,
20);
#else // OAU
osStrCpy(lpsz, szlTmp) ;
#endif // OAU
}
/*---------------------------------------------------------------------------
NAME : osAtoL
PURPOSE : Gets the long integer from a string representing that value
INPUTS : lpsz - the string representation
OUTPUT : the long integer
NOTES :
---------------------------------------------------------------------------*/
long FAR osAtoL (LPXSTR lpsz)
{
#ifdef OAU
char szlTmp[20];
WideCharToMultiByte(CP_ACP,
0,
lpsz,
-1,
szlTmp,
20,
NULL,
NULL);
return atol(szlTmp) ;
#else
return atol(lpsz) ;
#endif
}
/*---------------------------------------------------------------------------
NAME : osGetNetDrive
PURPOSE : Establish/Break a net connection
INPUTS : lpszNetDir - string to receieve the network drive letter
bnAct - flag for establishing or breaking the net connection
TRUE: establish a net connection
FALSE: break a net connection
OUTPUT : True if net connect is established/broken successfully
NOTES : Since Win32s has no API's that support net work action; this
routine does nothing for right now. It can be modified to
establish/break a net connection programmatically in the future.
---------------------------------------------------------------------------*/
BOOL FAR osGetNetDrive(LPXSTR lpszNetDir, LPXSTR lpUNCDir, BOOL /*bnAct*/) // [4]
{
osStrCpy(lpszNetDir, XSTR("z:\\tmp\\")) ;
osStrCpy(lpUNCDir, XSTR("\\\\apputest\\slm\\tmp\\")) ;
return TRUE ;
}
/*---------------------------------------------------------------------------
NAME : osCreateGuid
PURPOSE : Converts a GUID value from string to GUID format
INPUTS : lpszGuid - string contains the desired GUID value
OUTPUT : pointer to the GUID structure
NOTES : caller is responsible to free up the memory after used
---------------------------------------------------------------------------*/
GUID FAR * osCreateGuid(LPXSTR lpszGuid)
{
GUID FAR * lpGuid ;
HRESULT hRes ;
lpGuid = (GUID FAR *) osAllocSpaces(sizeof(GUID)*2) ;// allocate space
// for the Guid
if ( lpGuid )
{ // convert string to GUID format
hRes = CLSIDFromStringX(lpszGuid, (LPCLSID)lpGuid);
if ( LOWORD (hRes) )
{
osDeAllocSpaces ((LPXSTR)lpGuid) ; // release space before exit
return NULL ;
}
else
return lpGuid ; // return pointer to the
} // GUID structure
else
return NULL ; // no space is allocated
}
/*---------------------------------------------------------------------------
NAME : osRetrieveGuid
PURPOSE : Converts a GUID structure to a readable string format
INPUTS : lpszGuid - string representation of the GUID will be returned
GUID - the GUID structure in concern
OUTPUT : True if conversion is succeed
NOTES :
---------------------------------------------------------------------------*/
BOOL FAR osRetrieveGuid (LPXSTR lpszGuid, GUID inGuid)
{
LPOLESTR lpszTmp ;
HRESULT hRes ;
// allocate memory for the string
hRes = StringFromCLSID((REFCLSID) inGuid, &lpszTmp) ;
if ( LOWORD (hRes) ) // representation
{
ppmalloc->Free(lpszTmp) ;
return FALSE ;
}
else
{
#ifdef OAU
osStrCpy (lpszGuid, lpszTmp) ;
#else
WideCharToMultiByte(CP_ACP,
0,
lpszTmp,
-1,
lpszGuid,
40,
NULL,
NULL);
#endif
ppmalloc->Free(lpszTmp) ;
return TRUE ;
}
}
/*---------------------------------------------------------------------------
NAME : osGetSize
PURPOSE : returns size of the input data
INPUTS : inVT - data type; WORD
OUTPUT : size of inVT; WORD
NOTES :
---------------------------------------------------------------------------*/
WORD FAR osGetSize (WORD inVT)
{
WORD tSize ;
switch ( inVT )
{
case VT_I2:
tSize = sizeof(short) ;
break ;
case VT_I4:
tSize = sizeof(long) ;
break ;
case VT_R4:
tSize = sizeof(float) ;
break ;
case VT_R8:
tSize = sizeof(double) ;
break ;
case VT_CY:
tSize = sizeof(CY) ;
break ;
case VT_DATE:
tSize = sizeof(DATE) ;
break ;
case VT_BSTR:
tSize = sizeof(BSTR) ;
break ;
case VT_ERROR:
tSize = sizeof(SCODE) ;
break ;
case VT_BOOL:
tSize = sizeof(VARIANT_BOOL) ;
break ;
case VT_VARIANT:
tSize = sizeof(VARIANT) ;
break ;
case VT_I1:
tSize = sizeof(char) ;
break ;
case VT_UI1:
tSize = sizeof(char) ;
break ;
case VT_UI2:
tSize = sizeof(short) ;
break ;
case VT_UI4:
tSize = sizeof(long) ;
break ;
case VT_I8:
tSize = sizeof(long)*2 ;
break ;
case VT_UI8:
tSize = sizeof(long)*2 ;
break ;
case VT_INT:
tSize = sizeof(int) ;
break ;
case VT_UINT:
tSize = sizeof(int) ;
break ;
case VT_VOID:
tSize = 0 ;
break ;
case VT_HRESULT:
tSize = sizeof(HRESULT) ;
break ;
case VT_LPSTR:
tSize = sizeof(LPSTR) ;
break ;
case VT_PTR:
tSize = 4 ;
break ;
case VT_SAFEARRAY:
tSize = sizeof(ARRAYDESC FAR *) ;
break ;
case VT_DISPATCH:
tSize = 4 ;
break ;
case VT_UNKNOWN:
tSize = 4 ;
break ;
default:
tSize = 1 ;
break ;
}
return tSize ;
}
/*---------------------------------------------------------------------------
NAME : osGetAlignment
PURPOSE : returns value of the alignment
INPUTS : inVT - data type; WORD
mAlign - max possible alignment; WORD
OUTPUT : value of the aliangment; WORD
NOTES : value is machine dependent:
Win16 = 1 (everything is packed -> always = 1)
Win32 = natural alignment; max is 4-byte align
mac = everything is on the even-byte boundary
see silver\cl\clutil.cxx for a table of the alignement information
---------------------------------------------------------------------------*/
WORD FAR osGetAlignment (WORD inVT, WORD mAlign)
{
WORD expAlign ;
expAlign = osGetSize(inVT) ; // check size of the data
return ( expAlign <= mAlign ? expAlign : mAlign ) ;
}
/*---------------------------------------------------------------------------
NAME : osGetEnumType
PURPOSE : return the type of an enum member
INPUTS : none
OUTPUT : VT_I2 for Win16; VARTYPE
NOTES :
---------------------------------------------------------------------------*/
VARTYPE FAR osGetEnumType ()
{
return VT_I4 ;
}
/*---------------------------------------------------------------------------
NAME : osOleInit
PURPOSE : Calls OleInitialize and returns its return code
INPUTS : none
OUTPUT : return code from calling OleInitialize; HRESULT
NOTES :
---------------------------------------------------------------------------*/
HRESULT FAR osOleInit ()
{
HRESULT hRes ;
hRes = OleInitialize(NULL) ; // Ole initialization
#ifdef DEBUG
if ( hRes != NOERROR )
return hRes ;
hRes = GetMallocSpy(&g_IMallocSpy) ; // [5]
hRes = CoRegisterMallocSpy(g_IMallocSpy) ;
if ( hRes != NOERROR )
OleUninitialize ;
else
hRes = CoGetMalloc(MEMCTX_TASK, &ppmalloc) ;
#else
if ( !LOWORD(hRes) ) // allocate memory for use in the
hRes = CoGetMalloc(MEMCTX_TASK, &ppmalloc) ; // the program
#endif
return hRes ;
}
/*---------------------------------------------------------------------------
NAME : osOleUninit
PURPOSE : Calls OleUnInitialize
INPUTS : none
OUTPUT : none
NOTES :
---------------------------------------------------------------------------*/
VOID FAR osOleUninit ()
{
ppmalloc->Release () ; // release memory that was been
OleUninitialize (); // allocated at OleInitialize
#ifdef DEBUG
CoRevokeMallocSpy () ; // [5]
#endif
}
/*---------------------------------------------------------------------------
NAME : osMessage
PURPOSE : Displays a MessageBox
INPUTS : Message to be displayed; a string of characters
OUTPUT : none
NOTES :
---------------------------------------------------------------------------*/
VOID FAR osMessage (LPXSTR lpszMsg, LPXSTR lpszTitle)
{
#if defined (OAU) && !defined (UNICODE)// [1]
char szBufferM[256];
char szBufferT[256];
WideCharToMultiByte(CP_ACP,
0,
lpszMsg,
-1,
szBufferM,
256,
NULL,
NULL);
WideCharToMultiByte(CP_ACP,
0,
lpszTitle,
-1,
szBufferT,
256,
NULL,
NULL);
MessageBox (NULL, szBufferM, szBufferT, MB_OK) ;
#else // if OAU && ! UNICODE
MessageBox (NULL, lpszMsg, lpszTitle, MB_OK) ;
#endif // if OAU && ! UNICODE
}
/*---------------------------------------------------------------------------
NAME : osSetErrorMode
PURPOSE : For Win16 compatibility
INPUTS : eFlag - UINT
OUTPUT : UINT
NOTES : This routine is for Win16 compatibility purposes
---------------------------------------------------------------------------*/
UINT FAR osSetErrorMode (UINT eFlag)
{
return eFlag ;
}
/*---------------------------------------------------------------------------
NAME : WinMain
PURPOSE : Entry point of the test
INPUTS : standard inputs
OUTPUT : None
NOTES :
---------------------------------------------------------------------------*/
int FAR pascal WinMain(HINSTANCE /*hInstanceCur*/, HINSTANCE /*hInstancePrev*/, LPSTR lpCmdLineA, int /*nCmdShow*/)
{
#ifdef OAU
XCHAR lpCmdLine[128];
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
lpCmdLineA,
-1,
lpCmdLine,
128);
#else //OAU
#define lpCmdLine lpCmdLineA
#endif //OAU
mainEntry (lpCmdLine) ; // entry point for all programs
return 1 ;
}
//======================= Wrapper functions ==================================
#if !defined(OAU)
/*---------------------------------------------------------------------------
NAME : CreateTypeLibA
PURPOSE : Creates a typelib name of which is an ANSI string
INPUTS : syskind - os that the type library is created on; SYSKIND
szFile - name of type library; ANSI string
ppctlib - pointer to the created library
OUTPUT : None
NOTES :
---------------------------------------------------------------------------*/
STDAPI
CreateTypeLibA(SYSKIND syskind, char * szFile, ICreateTypeLibA * * ppctlib)
{ // [1]
OLECHAR szFileW[_MAX_PATH] ;
ICreateTypeLib * ptlibW ;
HRESULT hresult ;
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szFile,
-1,
szFileW,
_MAX_PATH);
hresult = CreateTypeLib(syskind, szFileW, &ptlibW);
if (hresult == NOERROR)
{
hresult = ptlibW->QueryInterface(IID_ICreateTypeLibA, (VOID **)ppctlib);
ptlibW->Release();
}
return hresult;
}
/*---------------------------------------------------------------------------
NAME : LHashValOfNameSysA
PURPOSE : Finds the hash value for a given string
INPUTS : syskind - current operating system
lcid - lcid of the currenet system
szName - string in concern; ANSI string
OUTPUT : Return LHashValOfNameSys
NOTES :
---------------------------------------------------------------------------*/
STDAPI_(unsigned long)
LHashValOfNameSysA(SYSKIND syskind, LCID lcid, char * szName)
{
OLECHAR szNameW[_MAX_PATH];
if ( szName )
{
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szName,
-1,
szNameW,
_MAX_PATH);
return LHashValOfNameSys(syskind, lcid, szNameW) ;
}
else
return LHashValOfNameSys(syskind, lcid, NULL) ;
}
/*---------------------------------------------------------------------------
NAME : LoadTypeLibA
PURPOSE : Loads a typelib name of which is an ANSI string
INPUTS : szFile - name of type library; ANSI string
pptlib - pointer to the loaded library
OUTPUT : None
NOTES :
---------------------------------------------------------------------------*/
STDAPI
LoadTypeLibA(char * szFile, ITypeLibA * * pptlib)
{
OLECHAR szFileW[_MAX_PATH];
ITypeLib * ptlibW;
HRESULT hresult = (HRESULT) E_INVALIDARG ;
if ( szFile && pptlib )
{
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szFile,
-1,
szFileW,
_MAX_PATH);
hresult = LoadTypeLibEx(szFileW, REGKIND_NONE, &ptlibW);
if (hresult == NOERROR) // convert the wide pointer to a narrow
{ // one
hresult = ptlibW->QueryInterface(IID_ITypeLibA, (VOID **)pptlib);
ptlibW->Release();
}
}
return hresult;
}
/*---------------------------------------------------------------------------
NAME : LoadRegTypeLibA
PURPOSE : Loads a typelib according to the info from the registry
INPUTS : rguid - GUID of the library
wVerMajor - Major version number of the library
wVerMinor - Minor version number of the library
pptlib - pointer to receive the library; an ANSI pointer
OUTPUT : result from LoadRegTypeLib
NOTES :
---------------------------------------------------------------------------*/
STDAPI
LoadRegTypeLibA(REFGUID rguid, unsigned short wVerMajor, unsigned short wVerMinor, LCID lcid, ITypeLibA * * pptlib)
{
ITypeLib * ptlibW;
HRESULT hresult;
hresult = LoadRegTypeLib(rguid, wVerMajor, wVerMinor, lcid, &ptlibW);
if (hresult == NOERROR) { // convert the wide pointer to a narrow
hresult = ptlibW->QueryInterface(IID_ITypeLibA, (VOID **)pptlib);
ptlibW->Release(); // one
}
return hresult;
}
/*---------------------------------------------------------------------------
NAME : RegisterTypeLibA
PURPOSE : Adds information of a library to the system registry
INPUTS : ptlib - pointer to the library; an ANSI pointer
szFullPath - pathspec of the library; ANSI string
szHelpDir - pathspec of the help file; ANSI string
OUTPUT : result from RegisterTypeLib
NOTES :
---------------------------------------------------------------------------*/
STDAPI
RegisterTypeLibA(ITypeLibA FAR * ptlib, char * szFullPath, char * szHelpDir)
{
OLECHAR szPathW[_MAX_PATH];
OLECHAR szHelpW[_MAX_PATH];
ITypeLib FAR * ptlibW = NULL ;
BOOL PathOk = FALSE , HelpOk = FALSE ;
HRESULT hresult = (HRESULT) TYPE_E_LIBNOTREGISTERED ;
if ( !ptlib ) // ptlib == NULL
return (HRESULT) E_INVALIDARG ;
ptlibW = ITypeLibWFromA(ptlib) ; // convert the narrow pointer to a wide
// one
if ( ptlibW ) // check if the pathspec is NULL or not
{ // if it is not, convert the ANSI path
if ( szFullPath ) // to an UNICODE path
{
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szFullPath,
-1,
szPathW,
_MAX_PATH);
PathOk = TRUE ;
}
if ( szHelpDir )
{
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szHelpDir,
-1,
szHelpW,
_MAX_PATH);
HelpOk = TRUE ;
}
if ( PathOk && HelpOk ) // if both pathspec's are not NULL
hresult = RegisterTypeLib(ptlibW, szPathW, szHelpW);
else
{
if ( PathOk ) // here if helpdir is NULL
hresult = RegisterTypeLib(ptlibW, szPathW, NULL);
else // here if pathspec of library is NULL
hresult = RegisterTypeLib(ptlibW, NULL, szHelpW);
}
ptlibW->Release();
}
return hresult;
}
/*---------------------------------------------------------------------------
NAME : CLSIDFromStringA
PURPOSE : Converts an ANSI string to a UUID
INPUTS : szG - string that represents a UUID; ANSI string
lpG - pointer to the UUID
OUTPUT : return code form CLSIDFromString
NOTES :
---------------------------------------------------------------------------*/
STDAPI
CLSIDFromStringA(char * szG, LPCLSID lpG)
{
OLECHAR szGW[100];
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szG,
-1,
szGW,
100);
return CLSIDFromString(szGW, (LPCLSID)lpG) ;
}
/*---------------------------------------------------------------------------
NAME : IIDFromStringA
PURPOSE : Converts an ANSI string to an IID
INPUTS : szA - string that represents a IID; ANSI string
lpiid - pointer to the iid
OUTPUT : Return code form IIDFromString
NOTES :
---------------------------------------------------------------------------*/
STDAPI
IIDFromStringA(LPSTR lpszA, LPIID lpiid)
{
OLECHAR szAW[100];
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
lpszA,
-1,
szAW,
100);
return IIDFromString(szAW, (LPIID)lpiid) ;
}
/*---------------------------------------------------------------------------
NAME : StgCreateDocfileA
PURPOSE : Creates a doc file
INPUTS : pwcsName - name of the doc file; ANSI string
grfMode - creation mode
ppstgOpenA - pointer the storage
OUTPUT : Return code from StgCreateDocfile
NOTES :
---------------------------------------------------------------------------*/
STDAPI StgCreateDocfileA(LPCSTR pwcsName, DWORD grfMode, DWORD reserved, IStorage * *ppstgOpenA)
{
OLECHAR szNameW[100];
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
pwcsName,
-1,
szNameW,
100);
return StgCreateDocfile(szNameW, grfMode, reserved, ppstgOpenA) ;
}
/*---------------------------------------------------------------------------
NAME : CreateFileMonikerA
PURPOSE : Creates a doc file
INPUTS : szfName - name of the file spec; ANSI string
pmk - pointer the moniker
OUTPUT : Return code from CreateFileMoniker
NOTES :
---------------------------------------------------------------------------*/
STDAPI CreateFileMonikerA (char * szfName, LPMONIKER FAR * pmk) // [2]
{
OLECHAR szNameW[128];
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szfName,
-1,
szNameW,
128);
return CreateFileMoniker(szNameW, pmk) ;
}
#endif // if !OAU
#if defined(OAU) && !defined(UNICODE) // [1]
/*---------------------------------------------------------------------------
NAME : osKillFile
PURPOSE : Removes a specific file from the disk
INPUTS : szFile - name of file to be removed; UNICODE string
OUTPUT : Output from DeleteFile
NOTES :
---------------------------------------------------------------------------*/
int osKillFile (XCHAR * szFile)
{
char szBuffer[256];
WideCharToMultiByte(CP_ACP,
0,
szFile,
-1,
szBuffer,
256,
NULL,
NULL);
return DeleteFile (szBuffer) ;
}
/*---------------------------------------------------------------------------
NAME : osRmDir
PURPOSE : Removes a specific directory from the disk
INPUTS : szDir - name of directory to be removed; UNICODE string
OUTPUT : Output from RemoveDirectory
NOTES :
---------------------------------------------------------------------------*/
int osRmDir (XCHAR * szDir)
{
char szBuffer[256];
WideCharToMultiByte(CP_ACP,
0,
szDir,
-1,
szBuffer,
256,
NULL,
NULL);
return RemoveDirectory(szBuffer) ;
}
/*---------------------------------------------------------------------------
NAME : LCMapStringX
PURPOSE : Converts one string of characters to another
INPUTS : lcid - Locale context fo the mapping; LCID
dw1 - type of mapping; unsigned long
sz1 - string for conversion; UNICODE string
i1 - number of characters in sz1; int
sz2 - buffer to store the resulting string; UNICODE string
i2 - number of characters converted
OUTPUT : Output from LCMapStringA
NOTES :
---------------------------------------------------------------------------*/
int LCMapStringX (LCID lcid, DWORD dw1, LPXSTR sz1, int i1, LPXSTR sz2, int i2) // [3]
{
char szBuf1[300];
char szBuf2[300];
int retval ;
WideCharToMultiByte(CP_ACP,
0,
sz1,
-1,
szBuf1,
300,
NULL,
NULL);
retval = LCMapStringA(lcid, dw1, szBuf1, i1, szBuf2, i2) ;
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
szBuf2,
-1,
sz2,
300);
return retval ;
}
#endif // if OAU && !UNICODE
#ifdef OAU
/*---------------------------------------------------------------------------
NAME : fopenX
PURPOSE : Opens a file for read/write
INPUTS : szFilName - name of file to be open; UNICODE string
szMode - purpose for the file; UNICODE string
OUTPUT : Return code from fopen
NOTES :
---------------------------------------------------------------------------*/
FILE * fopenX(XCHAR * szFilName, XCHAR * szMode)
{
char szANSITmp1[256];
char szANSITmp2[256];
WideCharToMultiByte(CP_ACP,
0,
szFilName,
-1,
szANSITmp1,
256,
NULL,
NULL);
WideCharToMultiByte(CP_ACP,
0,
szMode,
-1,
szANSITmp2,
256,
NULL,
NULL);
return fopen(szANSITmp1, szANSITmp2) ; // open output as an ANSI file
}
/*---------------------------------------------------------------------------
NAME : fputsX
PURPOSE : Writes to a file for read/write
INPUTS : szBuf - data to be written; UNICODE string
hFile - handle of the output file
OUTPUT : Return code from fputs
NOTES :
---------------------------------------------------------------------------*/
int fputsX(XCHAR *szBuf, FILE *hFile)
{
char szANSITmp[512];
WideCharToMultiByte(CP_ACP,
0,
szBuf,
-1,
szANSITmp,
512,
NULL,
NULL);
return fputs(szANSITmp, hFile) ;
}
#endif