marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added support for anonymous structs/unions on compilers that implement it.

oldstable
Patrik Stridvall 1999-09-19 14:20:33 +00:00 committed by Alexandre Julliard
parent 87d95b7bc5
commit 311e456a64
20 changed files with 346 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dlls/advapi32/service.c
View File

@ -158,8 +158,8 @@ OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
BOOL WINAPI
AllocateLocallyUniqueId( PLUID lpluid )
{
lpluid->LowPart = time(NULL);
lpluid->HighPart = 0;
lpluid->s.LowPart = time(NULL);
lpluid->s.HighPart = 0;
return TRUE;
}

4
dlls/comctl32/comctl32undoc.c
View File

@ -89,8 +89,8 @@ DPA_LoadStream (HDPA *phDpa, DPALOADPROC loadProc, IStream *pStream, LPARAM lPar
*phDpa = (HDPA)NULL;
position.LowPart = 0;
position.HighPart = 0;
position.s.LowPart = 0;
position.s.HighPart = 0;
errCode = IStream_Seek (pStream, position, STREAM_SEEK_CUR, &newPosition);
if (errCode != S_OK)

46
files/drive.c
View File

@ -678,10 +678,10 @@ static int DRIVE_GetFreeSpace( int drive, PULARGE_INTEGER size,
# error "statfs has no bfree/bavail member!"
# endif
#endif
size->LowPart = (DWORD)bigsize;
size->HighPart = (DWORD)(bigsize>>32);
available->LowPart = (DWORD)bigavail;
available->HighPart = (DWORD)(bigavail>>32);
size->s.LowPart = (DWORD)bigsize;
size->s.HighPart = (DWORD)(bigsize>>32);
available->s.LowPart = (DWORD)bigavail;
available->s.HighPart = (DWORD)(bigavail>>32);
return 1;
}
@ -755,37 +755,37 @@ BOOL WINAPI GetDiskFreeSpaceA( LPCSTR root, LPDWORD cluster_sectors,
if (!DRIVE_GetFreeSpace(drive, &size, &available)) return FALSE;
/* Cap the size and available at 2GB as per specs. */
if ((size.HighPart) ||(size.LowPart > 0x7fffffff))
if ((size.s.HighPart) ||(size.s.LowPart > 0x7fffffff))
{
size.HighPart = 0;
size.LowPart = 0x7fffffff;
size.s.HighPart = 0;
size.s.LowPart = 0x7fffffff;
}
if ((available.HighPart) ||(available.LowPart > 0x7fffffff))
if ((available.s.HighPart) ||(available.s.LowPart > 0x7fffffff))
{
available.HighPart =0;
available.LowPart = 0x7fffffff;
available.s.HighPart =0;
available.s.LowPart = 0x7fffffff;
}
if (DRIVE_GetType(drive)==TYPE_CDROM) {
if (sector_bytes)
*sector_bytes = 2048;
size.LowPart /= 2048;
available.LowPart /= 2048;
size.s.LowPart /= 2048;
available.s.LowPart /= 2048;
} else {
if (sector_bytes)
*sector_bytes = 512;
size.LowPart /= 512;
available.LowPart /= 512;
size.s.LowPart /= 512;
available.s.LowPart /= 512;
}
/* fixme: probably have to adjust those variables too for CDFS */
cluster_sec = 1;
while (cluster_sec * 65536 < size.LowPart) cluster_sec *= 2;
while (cluster_sec * 65536 < size.s.LowPart) cluster_sec *= 2;
if (cluster_sectors)
*cluster_sectors = cluster_sec;
if (free_clusters)
*free_clusters = available.LowPart / cluster_sec;
*free_clusters = available.s.LowPart / cluster_sec;
if (total_clusters)
*total_clusters = size.LowPart / cluster_sec;
*total_clusters = size.s.LowPart / cluster_sec;
return TRUE;
}
@ -846,14 +846,14 @@ BOOL WINAPI GetDiskFreeSpaceExA( LPCSTR root,
if (total)
{
total->HighPart = size.HighPart;
total->LowPart = size.LowPart ;
total->s.HighPart = size.s.HighPart;
total->s.LowPart = size.s.LowPart ;
}
if (totalfree)
{
totalfree->HighPart = available.HighPart;
totalfree->LowPart = available.LowPart ;
totalfree->s.HighPart = available.s.HighPart;
totalfree->s.LowPart = available.s.LowPart ;
}
if (avail)
@ -877,8 +877,8 @@ BOOL WINAPI GetDiskFreeSpaceExA( LPCSTR root,
/* Quick hack, should eventually be fixed to work 100% with
Windows2000 (see comment above). */
avail->HighPart = available.HighPart;
avail->LowPart = available.LowPart ;
avail->s.HighPart = available.s.HighPart;
avail->s.LowPart = available.s.LowPart ;
}
return TRUE;

20
include/winnt.h
View File

@ -908,16 +908,20 @@ typedef struct _TOKEN_GROUPS {
* LUID_AND_ATTRIBUTES
*/
typedef struct _LARGE_INTEGER
{
DWORD LowPart;
LONG HighPart;
typedef union _LARGE_INTEGER {
struct {
DWORD LowPart;
LONG HighPart;
} DUMMYSTRUCTNAME;
LONGLONG QuadPart;
} LARGE_INTEGER, *LPLARGE_INTEGER, *PLARGE_INTEGER;
typedef struct _ULARGE_INTEGER
{
DWORD LowPart;
DWORD HighPart;
typedef union _ULARGE_INTEGER {
struct {
DWORD LowPart;
LONG HighPart;
} DUMMYSTRUCTNAME;
LONGLONG QuadPart;
} ULARGE_INTEGER, *LPULARGE_INTEGER, *PULARGE_INTEGER;
/*

19
include/wtypes.h
View File

@ -147,19 +147,20 @@ typedef struct tagBLOB
#ifndef _tagCY_DEFINED
#define _tagCY_DEFINED
typedef union tagCY
{
typedef union tagCY {
struct {
#ifdef BIG_ENDIAN
long Hi;
long Lo;
#else
unsigned long Lo;
long Hi;
#endif
} u;
LONG Hi;
LONG Lo;
#else /* defined(BIG_ENDIAN) */
ULONG Lo;
LONG Hi;
#endif /* defined(BIG_ENDIAN) */
} DUMMYSTRUCTNAME;
LONGLONG int64;
} CY;
#endif /* _tagCY_DEFINED */
/*

10
msdos/vxd.c
View File

@ -1044,8 +1044,8 @@ void WINAPI VXD_Win32s( CONTEXT86 *context )
TRACE("NtCreateSection: name=%s\n", atom? name : NULL);
result = CreateFileMappingA(hFile, NULL, protect,
size? size->HighPart : 0,
size? size->LowPart : 0,
size? size->s.HighPart : 0,
size? size->s.LowPart : 0,
atom? name : NULL);
}
@ -1207,12 +1207,12 @@ void WINAPI VXD_Win32s( CONTEXT86 *context )
InheritDisposition, AllocationType, Protect);
TRACE("NtMapViewOfSection: "
"base=%lx, offset=%lx, size=%lx, access=%lx\n",
(DWORD)address, SectionOffset? SectionOffset->LowPart : 0,
(DWORD)address, SectionOffset? SectionOffset->s.LowPart : 0,
ViewSize? *ViewSize : 0, access);
result = (DWORD)MapViewOfFileEx(SectionHandle, access,
SectionOffset? SectionOffset->HighPart : 0,
SectionOffset? SectionOffset->LowPart : 0,
SectionOffset? SectionOffset->s.HighPart : 0,
SectionOffset? SectionOffset->s.LowPart : 0,
ViewSize? *ViewSize : 0, address);
TRACE("NtMapViewOfSection: result=%lx\n", result);

4
ole/antimoniker.c
View File

@ -261,9 +261,9 @@ HRESULT WINAPI AntiMonikerImpl_GetSizeMax(IMoniker* iface,
/* Normaly the sizemax must be the size of DWORD ! but I tested this function it ususlly return 16 bytes */
/* more than the number of bytes used by AntiMoniker::Save function */
pcbSize->LowPart = sizeof(DWORD)+16;
pcbSize->s.LowPart = sizeof(DWORD)+16;
pcbSize->HighPart=0;
pcbSize->s.HighPart=0;
return S_OK;
}

8
ole/compositemoniker.c
View File

@ -409,8 +409,8 @@ HRESULT WINAPI CompositeMonikerImpl_GetSizeMax(IMoniker* iface,ULARGE_INTEGER* p
if (pcbSize!=NULL)
return E_POINTER;
pcbSize->LowPart =0;
pcbSize->HighPart=0;
pcbSize->s.LowPart =0;
pcbSize->s.HighPart=0;
IMoniker_Enum(iface,TRUE,&enumMk);
@ -420,8 +420,8 @@ HRESULT WINAPI CompositeMonikerImpl_GetSizeMax(IMoniker* iface,ULARGE_INTEGER* p
IMoniker_Release(pmk);
pcbSize->LowPart +=ptmpSize.LowPart;
pcbSize->HighPart+=ptmpSize.HighPart;
pcbSize->s.LowPart +=ptmpSize.s.LowPart;
pcbSize->s.HighPart+=ptmpSize.s.HighPart;
}
IEnumMoniker_Release(enumMk);

10
ole/datacache.c
View File

@ -773,8 +773,8 @@ static HMETAFILE DataCache_ReadPresMetafile(
/*
* Skip the header
*/
offset.HighPart = 0;
offset.LowPart = sizeof(PresentationDataHeader);
offset.s.HighPart = 0;
offset.s.LowPart = sizeof(PresentationDataHeader);
hres = IStream_Seek(
presStream,
@ -787,7 +787,7 @@ static HMETAFILE DataCache_ReadPresMetafile(
*/
metafileBits = HeapAlloc(GetProcessHeap(),
0,
streamInfo.cbSize.LowPart);
streamInfo.cbSize.s.LowPart);
/*
* Read the metafile bits.
@ -795,7 +795,7 @@ static HMETAFILE DataCache_ReadPresMetafile(
hres = IStream_Read(
presStream,
metafileBits,
streamInfo.cbSize.LowPart,
streamInfo.cbSize.s.LowPart,
NULL);
/*
@ -803,7 +803,7 @@ static HMETAFILE DataCache_ReadPresMetafile(
*/
if (SUCCEEDED(hres))
{
newMetafile = SetMetaFileBitsEx(streamInfo.cbSize.LowPart, metafileBits);
newMetafile = SetMetaFileBitsEx(streamInfo.cbSize.s.LowPart, metafileBits);
}
/*

4
ole/filemoniker.c
View File

@ -423,8 +423,8 @@ HRESULT WINAPI FileMonikerImpl_GetSizeMax(IMoniker* iface,
sizeof(WORD)+ /* constant : 0x3 */
len*sizeof(WCHAR); /* unicde filePath string */
pcbSize->LowPart=sizeMAx;
pcbSize->HighPart=0;
pcbSize->s.LowPart=sizeMAx;
pcbSize->s.HighPart=0;
return S_OK;
}

74
ole/hglobalstream.c
View File

@ -257,14 +257,14 @@ HGLOBALStreamImpl* HGLOBALStreamImpl_Construct(
/*
* Start the stream at the begining.
*/
newStream->currentPosition.HighPart = 0;
newStream->currentPosition.LowPart = 0;
newStream->currentPosition.s.HighPart = 0;
newStream->currentPosition.s.LowPart = 0;
/*
* Initialize the size of the stream to the size of the handle.
*/
newStream->streamSize.HighPart = 0;
newStream->streamSize.LowPart = GlobalSize(newStream->supportHandle);
newStream->streamSize.s.HighPart = 0;
newStream->streamSize.s.LowPart = GlobalSize(newStream->supportHandle);
}
return newStream;
@ -420,19 +420,19 @@ HRESULT WINAPI HGLOBALStreamImpl_Read(
* Using the known size of the stream, calculate the number of bytes
* to read from the block chain
*/
bytesToReadFromBuffer = MIN( This->streamSize.LowPart - This->currentPosition.LowPart, cb);
bytesToReadFromBuffer = MIN( This->streamSize.s.LowPart - This->currentPosition.s.LowPart, cb);
/*
* Lock the buffer in position and copy the data.
*/
supportBuffer = GlobalLock(This->supportHandle);
memcpy(pv, (char *) supportBuffer+This->currentPosition.LowPart, bytesToReadFromBuffer);
memcpy(pv, (char *) supportBuffer+This->currentPosition.s.LowPart, bytesToReadFromBuffer);
/*
* Move the current position to the new position
*/
This->currentPosition.LowPart+=bytesToReadFromBuffer;
This->currentPosition.s.LowPart+=bytesToReadFromBuffer;
/*
* Return the number of bytes read.
@ -493,14 +493,14 @@ HRESULT WINAPI HGLOBALStreamImpl_Write(
}
else
{
newSize.HighPart = 0;
newSize.LowPart = This->currentPosition.LowPart + cb;
newSize.s.HighPart = 0;
newSize.s.LowPart = This->currentPosition.s.LowPart + cb;
}
/*
* Verify if we need to grow the stream
*/
if (newSize.LowPart > This->streamSize.LowPart)
if (newSize.s.LowPart > This->streamSize.s.LowPart)
{
/* grow stream */
IStream_SetSize(iface, newSize);
@ -511,12 +511,12 @@ HRESULT WINAPI HGLOBALStreamImpl_Write(
*/
supportBuffer = GlobalLock(This->supportHandle);
memcpy((char *) supportBuffer+This->currentPosition.LowPart, pv, cb);
memcpy((char *) supportBuffer+This->currentPosition.s.LowPart, pv, cb);
/*
* Move the current position to the new position
*/
This->currentPosition.LowPart+=cb;
This->currentPosition.s.LowPart+=cb;
/*
* Return the number of bytes read.
@ -550,7 +550,7 @@ HRESULT WINAPI HGLOBALStreamImpl_Seek(
ULARGE_INTEGER newPosition;
TRACE("(%p, %ld, %ld, %p)\n", iface,
dlibMove.LowPart, dwOrigin, plibNewPosition);
dlibMove.s.LowPart, dwOrigin, plibNewPosition);
/*
* The caller is allowed to pass in NULL as the new position return value.
@ -569,8 +569,8 @@ HRESULT WINAPI HGLOBALStreamImpl_Seek(
switch (dwOrigin)
{
case STREAM_SEEK_SET:
plibNewPosition->HighPart = 0;
plibNewPosition->LowPart = 0;
plibNewPosition->s.HighPart = 0;
plibNewPosition->s.LowPart = 0;
break;
case STREAM_SEEK_CUR:
*plibNewPosition = This->currentPosition;
@ -585,13 +585,13 @@ HRESULT WINAPI HGLOBALStreamImpl_Seek(
/*
* We don't support files with offsets of 64 bits.
*/
assert(dlibMove.HighPart == 0);
assert(dlibMove.s.HighPart == 0);
/*
* Check if we end-up before the beginning of the file. That should trigger an
* error.
*/
if ( (dlibMove.LowPart<0) && (plibNewPosition->LowPart < (ULONG)(-dlibMove.LowPart)) )
if ( (dlibMove.s.LowPart<0) && (plibNewPosition->s.LowPart < (ULONG)(-dlibMove.s.LowPart)) )
{
/*
* I don't know what error to send there.
@ -604,7 +604,7 @@ HRESULT WINAPI HGLOBALStreamImpl_Seek(
* If the file pointer ends-up after the end of the stream, the next Write operation will
* make the file larger. This is how it is documented.
*/
plibNewPosition->LowPart += dlibMove.LowPart;
plibNewPosition->s.LowPart += dlibMove.s.LowPart;
This->currentPosition = *plibNewPosition;
return S_OK;
@ -625,25 +625,25 @@ HRESULT WINAPI HGLOBALStreamImpl_SetSize(
{
HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
TRACE("(%p, %ld)\n", iface, libNewSize.LowPart);
TRACE("(%p, %ld)\n", iface, libNewSize.s.LowPart);
/*
* As documented.
*/
if (libNewSize.HighPart != 0)
if (libNewSize.s.HighPart != 0)
return STG_E_INVALIDFUNCTION;
if (This->streamSize.LowPart == libNewSize.LowPart)
if (This->streamSize.s.LowPart == libNewSize.s.LowPart)
return S_OK;
/*
* Re allocate the HGlobal to fit the new size of the stream.
*/
This->supportHandle = GlobalReAlloc(This->supportHandle,
libNewSize.LowPart,
libNewSize.s.LowPart,
0);
This->streamSize.LowPart = libNewSize.LowPart;
This->streamSize.s.LowPart = libNewSize.s.LowPart;
return S_OK;
}
@ -669,7 +669,7 @@ HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
ULARGE_INTEGER totalBytesWritten;
TRACE("(%p, %p, %ld, %p, %p)\n", iface, pstm,
cb.LowPart, pcbRead, pcbWritten);
cb.s.LowPart, pcbRead, pcbWritten);
/*
* Sanity check
@ -677,28 +677,28 @@ HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
if ( pstm == 0 )
return STG_E_INVALIDPOINTER;
totalBytesRead.LowPart = totalBytesRead.HighPart = 0;
totalBytesWritten.LowPart = totalBytesWritten.HighPart = 0;
totalBytesRead.s.LowPart = totalBytesRead.s.HighPart = 0;
totalBytesWritten.s.LowPart = totalBytesWritten.s.HighPart = 0;
/*
* use stack to store data temporarly
* there is surely more performant way of doing it, for now this basic
* implementation will do the job
*/
while ( cb.LowPart > 0 )
while ( cb.s.LowPart > 0 )
{
if ( cb.LowPart >= 128 )
if ( cb.s.LowPart >= 128 )
copySize = 128;
else
copySize = cb.LowPart;
copySize = cb.s.LowPart;
IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
totalBytesRead.LowPart += bytesRead;
totalBytesRead.s.LowPart += bytesRead;
IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
totalBytesWritten.LowPart += bytesWritten;
totalBytesWritten.s.LowPart += bytesWritten;
/*
* Check that read & write operations were succesfull
@ -710,9 +710,9 @@ HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
}
if (bytesRead!=copySize)
cb.LowPart = 0;
cb.s.LowPart = 0;
else
cb.LowPart -= bytesRead;
cb.s.LowPart -= bytesRead;
}
/*
@ -720,14 +720,14 @@ HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
*/
if (pcbRead)
{
pcbRead->LowPart = totalBytesRead.LowPart;
pcbRead->HighPart = totalBytesRead.HighPart;
pcbRead->s.LowPart = totalBytesRead.s.LowPart;
pcbRead->s.HighPart = totalBytesRead.s.HighPart;
}
if (pcbWritten)
{
pcbWritten->LowPart = totalBytesWritten.LowPart;
pcbWritten->HighPart = totalBytesWritten.HighPart;
pcbWritten->s.LowPart = totalBytesWritten.s.LowPart;
pcbWritten->s.HighPart = totalBytesWritten.s.HighPart;
}
return hr;
}

4
ole/itemmoniker.c
View File

@ -322,13 +322,13 @@ HRESULT WINAPI ItemMonikerImpl_GetSizeMax(IMoniker* iface,
/* for more details see ItemMonikerImpl_Save coments */
pcbSize->LowPart = sizeof(DWORD) + /* DWORD witch contains delimiter length */
pcbSize->s.LowPart = sizeof(DWORD) + /* DWORD witch contains delimiter length */
delimiterLength + /* item delimiter string */
sizeof(DWORD) + /* DWORD witch contains item name length */
nameLength + /* item name string */
34; /* this constant was added ! because when I tested this function it usually */
/* returns 34 bytes more than the number of bytes used by IMoniker::Save function */
pcbSize->HighPart=0;
pcbSize->s.HighPart=0;
return S_OK;
}

28
ole/memlockbytes.c
View File

@ -215,8 +215,8 @@ HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(HGLOBAL hGlobal,
/*
* Initialize the size of the array to the size of the handle.
*/
newLockBytes->byteArraySize.HighPart = 0;
newLockBytes->byteArraySize.LowPart = GlobalSize(
newLockBytes->byteArraySize.s.HighPart = 0;
newLockBytes->byteArraySize.s.LowPart = GlobalSize(
newLockBytes->supportHandle);
}
@ -365,15 +365,15 @@ HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
/*
* Make sure the offset is valid.
*/
if (ulOffset.LowPart > This->byteArraySize.LowPart)
if (ulOffset.s.LowPart > This->byteArraySize.s.LowPart)
return E_FAIL;
/*
* Using the known size of the array, calculate the number of bytes
* to read.
*/
bytesToReadFromBuffer = MIN(This->byteArraySize.LowPart -
ulOffset.LowPart, cb);
bytesToReadFromBuffer = MIN(This->byteArraySize.s.LowPart -
ulOffset.s.LowPart, cb);
/*
* Lock the buffer in position and copy the data.
@ -381,7 +381,7 @@ HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
supportBuffer = GlobalLock(This->supportHandle);
memcpy(pv,
(char *) supportBuffer + ulOffset.LowPart,
(char *) supportBuffer + ulOffset.s.LowPart,
bytesToReadFromBuffer);
/*
@ -440,14 +440,14 @@ HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
}
else
{
newSize.HighPart = 0;
newSize.LowPart = ulOffset.LowPart + cb;
newSize.s.HighPart = 0;
newSize.s.LowPart = ulOffset.s.LowPart + cb;
}
/*
* Verify if we need to grow the stream
*/
if (newSize.LowPart > This->byteArraySize.LowPart)
if (newSize.s.LowPart > This->byteArraySize.s.LowPart)
{
/* grow stream */
if (HGLOBALLockBytesImpl_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
@ -459,7 +459,7 @@ HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
*/
supportBuffer = GlobalLock(This->supportHandle);
memcpy((char *) supportBuffer + ulOffset.LowPart, pv, cb);
memcpy((char *) supportBuffer + ulOffset.s.LowPart, pv, cb);
/*
* Return the number of bytes written.
@ -500,23 +500,23 @@ HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
/*
* As documented.
*/
if (libNewSize.HighPart != 0)
if (libNewSize.s.HighPart != 0)
return STG_E_INVALIDFUNCTION;
if (This->byteArraySize.LowPart == libNewSize.LowPart)
if (This->byteArraySize.s.LowPart == libNewSize.s.LowPart)
return S_OK;
/*
* Re allocate the HGlobal to fit the new size of the stream.
*/
This->supportHandle = GlobalReAlloc(This->supportHandle,
libNewSize.LowPart,
libNewSize.s.LowPart,
0);
if (This->supportHandle == 0)
return STG_E_MEDIUMFULL;
This->byteArraySize.LowPart = libNewSize.LowPart;
This->byteArraySize.s.LowPart = libNewSize.s.LowPart;
return S_OK;
}

34
ole/olefont.c
View File

@ -540,8 +540,8 @@ static HRESULT WINAPI OLEFontImpl_get_Size(
if (psize==0)
return E_POINTER;
psize->u.Hi = 0;
psize->u.Lo = this->description.cySize.u.Lo;
psize->s.Hi = 0;
psize->s.Lo = this->description.cySize.s.Lo;
return S_OK;
}
@ -557,8 +557,8 @@ static HRESULT WINAPI OLEFontImpl_put_Size(
{
_ICOM_THIS(OLEFontImpl, iface);
this->description.cySize.u.Hi = 0;
this->description.cySize.u.Lo = this->description.cySize.u.Lo;
this->description.cySize.s.Hi = 0;
this->description.cySize.s.Lo = this->description.cySize.s.Lo;
return S_OK;
}
@ -810,7 +810,7 @@ static HRESULT WINAPI OLEFontImpl_get_hFont(
*/
IFont_get_Size(iface, &cySize);
fontHeight = MulDiv(cySize.u.Lo, 2540L, 72L);
fontHeight = MulDiv(cySize.s.Lo, 2540L, 72L);
fontHeight = MulDiv(fontHeight, this->cyLogical,this->cyHimetric);
memset(&logFont, 0, sizeof(LOGFONTW));
@ -1232,12 +1232,12 @@ static HRESULT WINAPI OLEFontImpl_Load(
/*
* Size
*/
IStream_Read(pLoadStream, &this->description.cySize.u.Lo, 4, &cbRead);
IStream_Read(pLoadStream, &this->description.cySize.s.Lo, 4, &cbRead);
if (cbRead!=4)
return E_FAIL;
this->description.cySize.u.Hi = 0;
this->description.cySize.s.Hi = 0;
/*
* FontName
@ -1327,7 +1327,7 @@ static HRESULT WINAPI OLEFontImpl_Save(
/*
* Size
*/
IStream_Write(pOutStream, &this->description.cySize.u.Lo, 4, &cbWritten);
IStream_Write(pOutStream, &this->description.cySize.s.Lo, 4, &cbWritten);
if (cbWritten!=4)
return E_FAIL;
@ -1379,18 +1379,18 @@ static HRESULT WINAPI OLEFontImpl_GetSizeMax(
if (pcbSize==NULL)
return E_POINTER;
pcbSize->HighPart = 0;
pcbSize->LowPart = 0;
pcbSize->s.HighPart = 0;
pcbSize->s.LowPart = 0;
pcbSize->LowPart += sizeof(BYTE); /* Version */
pcbSize->LowPart += sizeof(WORD); /* Lang code */
pcbSize->LowPart += sizeof(BYTE); /* Flags */
pcbSize->LowPart += sizeof(WORD); /* Weight */
pcbSize->LowPart += sizeof(DWORD); /* Size */
pcbSize->LowPart += sizeof(BYTE); /* StrLength */
pcbSize->s.LowPart += sizeof(BYTE); /* Version */
pcbSize->s.LowPart += sizeof(WORD); /* Lang code */
pcbSize->s.LowPart += sizeof(BYTE); /* Flags */
pcbSize->s.LowPart += sizeof(WORD); /* Weight */
pcbSize->s.LowPart += sizeof(DWORD); /* Size */
pcbSize->s.LowPart += sizeof(BYTE); /* StrLength */
if (this->description.lpstrName!=0)
pcbSize->LowPart += lstrlenW(this->description.lpstrName);
pcbSize->s.LowPart += lstrlenW(this->description.lpstrName);
return S_OK;
}

28
ole/stg_bigblockfile.c
View File

@ -175,7 +175,7 @@ static BOOL BIGBLOCKFILE_FileInit(LPBIGBLOCKFILE This, HANDLE hFile)
return FALSE;
}
This->filesize.LowPart = GetFileSize(This->hfile, NULL);
This->filesize.s.LowPart = GetFileSize(This->hfile, NULL);
/* create the mapped pages list
*/
@ -221,8 +221,8 @@ static BOOL BIGBLOCKFILE_MemInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt)
*/
ILockBytes_AddRef(This->pLkbyt);
This->filesize.LowPart = GlobalSize(This->hbytearray);
This->filesize.HighPart = 0;
This->filesize.s.LowPart = GlobalSize(This->hbytearray);
This->filesize.s.HighPart = 0;
This->pbytearray = GlobalLock(This->hbytearray);
@ -289,8 +289,8 @@ void* BIGBLOCKFILE_GetROBigBlock(
*
*/
if ((This->blocksize * (index + 1)) >
(This->filesize.LowPart +
(This->blocksize - (This->filesize.LowPart % This->blocksize))))
(This->filesize.s.LowPart +
(This->blocksize - (This->filesize.s.LowPart % This->blocksize))))
return 0;
return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_READ);
@ -316,12 +316,12 @@ void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index)
/*
* make sure that the block physically exists
*/
if ((This->blocksize * (index + 1)) > This->filesize.LowPart)
if ((This->blocksize * (index + 1)) > This->filesize.s.LowPart)
{
ULARGE_INTEGER newSize;
newSize.HighPart = 0;
newSize.LowPart = This->blocksize * (index + 1);
newSize.s.HighPart = 0;
newSize.s.LowPart = This->blocksize * (index + 1);
BIGBLOCKFILE_SetSize(This, newSize);
}
@ -377,7 +377,7 @@ void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock)
*/
void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
{
if (This->filesize.LowPart == newSize.LowPart)
if (This->filesize.s.LowPart == newSize.s.LowPart)
return;
if (This->fileBased)
@ -396,7 +396,7 @@ void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
/*
* set the new end of file
*/
SetFilePointer(This->hfile, newSize.LowPart, NULL, FILE_BEGIN);
SetFilePointer(This->hfile, newSize.s.LowPart, NULL, FILE_BEGIN);
SetEndOfFile(This->hfile);
/*
@ -429,8 +429,8 @@ void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
*/
BIGBLOCKFILE_RemoveAllBlocks(This);
This->filesize.LowPart = newSize.LowPart;
This->filesize.HighPart = newSize.HighPart;
This->filesize.s.LowPart = newSize.s.LowPart;
This->filesize.s.HighPart = newSize.s.HighPart;
}
/******************************************************************************
@ -811,8 +811,8 @@ static void * BIGBLOCKFILE_GetMappedView(
newMappedPage->next = This->maplisthead->next;
This->maplisthead->next = newMappedPage;
if (((pagenum + 1) * PAGE_SIZE) > This->filesize.LowPart)
numBytesToMap = This->filesize.LowPart - (pagenum * PAGE_SIZE);
if (((pagenum + 1) * PAGE_SIZE) > This->filesize.s.LowPart)
numBytesToMap = This->filesize.s.LowPart - (pagenum * PAGE_SIZE);
else
numBytesToMap = PAGE_SIZE;

84
ole/stg_stream.c
View File

@ -84,14 +84,14 @@ StgStreamImpl* StgStreamImpl_Construct(
/*
* Start the stream at the begining.
*/
newStream->currentPosition.HighPart = 0;
newStream->currentPosition.LowPart = 0;
newStream->currentPosition.s.HighPart = 0;
newStream->currentPosition.s.LowPart = 0;
/*
* Initialize the rest of the data.
*/
newStream->streamSize.HighPart = 0;
newStream->streamSize.LowPart = 0;
newStream->streamSize.s.HighPart = 0;
newStream->streamSize.s.LowPart = 0;
newStream->bigBlockChain = 0;
newStream->smallBlockChain = 0;
@ -272,16 +272,16 @@ void StgStreamImpl_OpenBlockChain(
/*
* This code supports only streams that are <32 bits in size.
*/
assert(This->streamSize.HighPart == 0);
assert(This->streamSize.s.HighPart == 0);
if(curProperty.startingBlock == BLOCK_END_OF_CHAIN)
{
assert( (This->streamSize.HighPart == 0) && (This->streamSize.LowPart == 0) );
assert( (This->streamSize.s.HighPart == 0) && (This->streamSize.s.LowPart == 0) );
}
else
{
if ( (This->streamSize.HighPart == 0) &&
(This->streamSize.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
if ( (This->streamSize.s.HighPart == 0) &&
(This->streamSize.s.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
{
This->smallBlockChain = SmallBlockChainStream_Construct(
This->parentStorage->ancestorStorage,
@ -332,7 +332,7 @@ HRESULT WINAPI StgStreamImpl_Read(
* Using the known size of the stream, calculate the number of bytes
* to read from the block chain
*/
bytesToReadFromBuffer = MIN( This->streamSize.LowPart - This->currentPosition.LowPart, cb);
bytesToReadFromBuffer = MIN( This->streamSize.s.LowPart - This->currentPosition.s.LowPart, cb);
/*
* Depending on the type of chain that was opened when the stream was constructed,
@ -375,7 +375,7 @@ HRESULT WINAPI StgStreamImpl_Read(
/*
* Advance the pointer for the number of positions read.
*/
This->currentPosition.LowPart += *pcbRead;
This->currentPosition.s.LowPart += *pcbRead;
/*
* The function returns S_OK if the buffer was filled completely
@ -430,14 +430,14 @@ HRESULT WINAPI StgStreamImpl_Write(
}
else
{
newSize.HighPart = 0;
newSize.LowPart = This->currentPosition.LowPart + cb;
newSize.s.HighPart = 0;
newSize.s.LowPart = This->currentPosition.s.LowPart + cb;
}
/*
* Verify if we need to grow the stream
*/
if (newSize.LowPart > This->streamSize.LowPart)
if (newSize.s.LowPart > This->streamSize.s.LowPart)
{
/* grow stream */
IStream_SetSize(iface, newSize);
@ -470,7 +470,7 @@ HRESULT WINAPI StgStreamImpl_Write(
/*
* Advance the position pointer for the number of positions written.
*/
This->currentPosition.LowPart += *pcbWritten;
This->currentPosition.s.LowPart += *pcbWritten;
return S_OK;
}
@ -494,7 +494,7 @@ HRESULT WINAPI StgStreamImpl_Seek(
ULARGE_INTEGER newPosition;
TRACE("(%p, %ld, %ld, %p)\n",
iface, dlibMove.LowPart, dwOrigin, plibNewPosition);
iface, dlibMove.s.LowPart, dwOrigin, plibNewPosition);
/*
* The caller is allowed to pass in NULL as the new position return value.
@ -513,8 +513,8 @@ HRESULT WINAPI StgStreamImpl_Seek(
switch (dwOrigin)
{
case STREAM_SEEK_SET:
plibNewPosition->HighPart = 0;
plibNewPosition->LowPart = 0;
plibNewPosition->s.HighPart = 0;
plibNewPosition->s.LowPart = 0;
break;
case STREAM_SEEK_CUR:
*plibNewPosition = This->currentPosition;
@ -529,13 +529,13 @@ HRESULT WINAPI StgStreamImpl_Seek(
/*
* We don't support files with offsets of 64 bits.
*/
assert(dlibMove.HighPart == 0);
assert(dlibMove.s.HighPart == 0);
/*
* Check if we end-up before the beginning of the file. That should trigger an
* error.
*/
if ( (dlibMove.LowPart<0) && (plibNewPosition->LowPart < (ULONG)(-dlibMove.LowPart)) )
if ( (dlibMove.s.LowPart<0) && (plibNewPosition->s.LowPart < (ULONG)(-dlibMove.s.LowPart)) )
{
/*
* I don't know what error to send there.
@ -548,7 +548,7 @@ HRESULT WINAPI StgStreamImpl_Seek(
* If the file pointer ends-up after the end of the stream, the next Write operation will
* make the file larger. This is how it is documented.
*/
plibNewPosition->LowPart += dlibMove.LowPart;
plibNewPosition->s.LowPart += dlibMove.s.LowPart;
This->currentPosition = *plibNewPosition;
return S_OK;
@ -572,15 +572,15 @@ HRESULT WINAPI StgStreamImpl_SetSize(
StgProperty curProperty;
BOOL Success;
TRACE("(%p, %ld)\n", iface, libNewSize.LowPart);
TRACE("(%p, %ld)\n", iface, libNewSize.s.LowPart);
/*
* As documented.
*/
if (libNewSize.HighPart != 0)
if (libNewSize.s.HighPart != 0)
return STG_E_INVALIDFUNCTION;
if (This->streamSize.LowPart == libNewSize.LowPart)
if (This->streamSize.s.LowPart == libNewSize.s.LowPart)
return S_OK;
/*
@ -588,7 +588,7 @@ HRESULT WINAPI StgStreamImpl_SetSize(
*/
if ((This->smallBlockChain == 0) && (This->bigBlockChain == 0))
{
if (libNewSize.LowPart < LIMIT_TO_USE_SMALL_BLOCK)
if (libNewSize.s.LowPart < LIMIT_TO_USE_SMALL_BLOCK)
{
This->smallBlockChain = SmallBlockChainStream_Construct(
This->parentStorage->ancestorStorage,
@ -613,9 +613,9 @@ HRESULT WINAPI StgStreamImpl_SetSize(
* Determine if we have to switch from small to big blocks or vice versa
*/
if ( (This->smallBlockChain!=0) &&
(curProperty.size.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
(curProperty.size.s.LowPart < LIMIT_TO_USE_SMALL_BLOCK) )
{
if (libNewSize.LowPart >= LIMIT_TO_USE_SMALL_BLOCK)
if (libNewSize.s.LowPart >= LIMIT_TO_USE_SMALL_BLOCK)
{
/*
* Transform the small block chain into a big block chain
@ -642,8 +642,8 @@ HRESULT WINAPI StgStreamImpl_SetSize(
This->ownerProperty,
&curProperty);
curProperty.size.HighPart = libNewSize.HighPart;
curProperty.size.LowPart = libNewSize.LowPart;
curProperty.size.s.HighPart = libNewSize.s.HighPart;
curProperty.size.s.LowPart = libNewSize.s.LowPart;
if (Success)
{
@ -678,7 +678,7 @@ HRESULT WINAPI StgStreamImpl_CopyTo(
ULARGE_INTEGER totalBytesWritten;
TRACE("(%p, %p, %ld, %p, %p)\n",
iface, pstm, cb.LowPart, pcbRead, pcbWritten);
iface, pstm, cb.s.LowPart, pcbRead, pcbWritten);
/*
* Sanity check
@ -686,28 +686,28 @@ HRESULT WINAPI StgStreamImpl_CopyTo(
if ( pstm == 0 )
return STG_E_INVALIDPOINTER;
totalBytesRead.LowPart = totalBytesRead.HighPart = 0;
totalBytesWritten.LowPart = totalBytesWritten.HighPart = 0;
totalBytesRead.s.LowPart = totalBytesRead.s.HighPart = 0;
totalBytesWritten.s.LowPart = totalBytesWritten.s.HighPart = 0;
/*
* use stack to store data temporarly
* there is surely more performant way of doing it, for now this basic
* implementation will do the job
*/
while ( cb.LowPart > 0 )
while ( cb.s.LowPart > 0 )
{
if ( cb.LowPart >= 128 )
if ( cb.s.LowPart >= 128 )
copySize = 128;
else
copySize = cb.LowPart;
copySize = cb.s.LowPart;
IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
totalBytesRead.LowPart += bytesRead;
totalBytesRead.s.LowPart += bytesRead;
IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
totalBytesWritten.LowPart += bytesWritten;
totalBytesWritten.s.LowPart += bytesWritten;
/*
* Check that read & write operations were succesfull
@ -719,9 +719,9 @@ HRESULT WINAPI StgStreamImpl_CopyTo(
}
if (bytesRead!=copySize)
cb.LowPart = 0;
cb.s.LowPart = 0;
else
cb.LowPart -= bytesRead;
cb.s.LowPart -= bytesRead;
}
/*
@ -729,14 +729,14 @@ HRESULT WINAPI StgStreamImpl_CopyTo(
*/
if (pcbRead)
{
pcbRead->LowPart = totalBytesRead.LowPart;
pcbRead->HighPart = totalBytesRead.HighPart;
pcbRead->s.LowPart = totalBytesRead.s.LowPart;
pcbRead->s.HighPart = totalBytesRead.s.HighPart;
}
if (pcbWritten)
{
pcbWritten->LowPart = totalBytesWritten.LowPart;
pcbWritten->HighPart = totalBytesWritten.HighPart;
pcbWritten->s.LowPart = totalBytesWritten.s.LowPart;
pcbWritten->s.HighPart = totalBytesWritten.s.HighPart;
}
return hr;
}

84
ole/storage.c
View File

@ -732,7 +732,7 @@ HRESULT WINAPI IStream16_fnSeek(
IStream16* iface,LARGE_INTEGER offset,DWORD whence,ULARGE_INTEGER *newpos
) {
ICOM_THIS(IStream16Impl,iface);
TRACE_(relay)("(%p)->([%ld.%ld],%ld,%p)\n",This,offset.HighPart,offset.LowPart,whence,newpos);
TRACE_(relay)("(%p)->([%ld.%ld],%ld,%p)\n",This,offset.s.HighPart,offset.s.LowPart,whence,newpos);
switch (whence) {
/* unix SEEK_xx should be the same as win95 ones */
@ -740,31 +740,31 @@ HRESULT WINAPI IStream16_fnSeek(
/* offset must be ==0 (<0 is invalid, and >0 cannot be handled
* right now.
*/
assert(offset.HighPart==0);
This->offset.HighPart = offset.HighPart;
This->offset.LowPart = offset.LowPart;
assert(offset.s.HighPart==0);
This->offset.s.HighPart = offset.s.HighPart;
This->offset.s.LowPart = offset.s.LowPart;
break;
case SEEK_CUR:
if (offset.HighPart < 0) {
if (offset.s.HighPart < 0) {
/* FIXME: is this negation correct ? */
offset.HighPart = -offset.HighPart;
offset.LowPart = (0xffffffff ^ offset.LowPart)+1;
offset.s.HighPart = -offset.s.HighPart;
offset.s.LowPart = (0xffffffff ^ offset.s.LowPart)+1;
assert(offset.HighPart==0);
assert(This->offset.LowPart >= offset.LowPart);
This->offset.LowPart -= offset.LowPart;
assert(offset.s.HighPart==0);
assert(This->offset.s.LowPart >= offset.s.LowPart);
This->offset.s.LowPart -= offset.s.LowPart;
} else {
assert(offset.HighPart==0);
This->offset.LowPart+= offset.LowPart;
assert(offset.s.HighPart==0);
This->offset.s.LowPart+= offset.s.LowPart;
}
break;
case SEEK_END:
assert(offset.HighPart==0);
This->offset.LowPart = This->stde.pps_size-offset.LowPart;
assert(offset.s.HighPart==0);
This->offset.s.LowPart = This->stde.pps_size-offset.s.LowPart;
break;
}
if (This->offset.LowPart>This->stde.pps_size)
This->offset.LowPart=This->stde.pps_size;
if (This->offset.s.LowPart>This->stde.pps_size)
This->offset.s.LowPart=This->stde.pps_size;
if (newpos) *newpos = This->offset;
return S_OK;
}
@ -784,11 +784,11 @@ HRESULT WINAPI IStream16_fnRead(
if (!pcbRead) bytesread=&xxread;
*bytesread = 0;
if (cb>This->stde.pps_size-This->offset.LowPart)
cb=This->stde.pps_size-This->offset.LowPart;
if (cb>This->stde.pps_size-This->offset.s.LowPart)
cb=This->stde.pps_size-This->offset.s.LowPart;
if (This->stde.pps_size < 0x1000) {
/* use small block reader */
blocknr = STORAGE_get_nth_next_small_blocknr(This->hf,This->stde.pps_sb,This->offset.LowPart/SMALLSIZE);
blocknr = STORAGE_get_nth_next_small_blocknr(This->hf,This->stde.pps_sb,This->offset.s.LowPart/SMALLSIZE);
while (cb) {
int cc;
@ -797,10 +797,10 @@ HRESULT WINAPI IStream16_fnRead(
return E_FAIL;
}
cc = cb;
if (cc>SMALLSIZE-(This->offset.LowPart&(SMALLSIZE-1)))
cc=SMALLSIZE-(This->offset.LowPart&(SMALLSIZE-1));
memcpy((LPBYTE)pv,block+(This->offset.LowPart&(SMALLSIZE-1)),cc);
This->offset.LowPart+=cc;
if (cc>SMALLSIZE-(This->offset.s.LowPart&(SMALLSIZE-1)))
cc=SMALLSIZE-(This->offset.s.LowPart&(SMALLSIZE-1));
memcpy((LPBYTE)pv,block+(This->offset.s.LowPart&(SMALLSIZE-1)),cc);
This->offset.s.LowPart+=cc;
(LPBYTE)pv+=cc;
*bytesread+=cc;
cb-=cc;
@ -808,7 +808,7 @@ HRESULT WINAPI IStream16_fnRead(
}
} else {
/* use big block reader */
blocknr = STORAGE_get_nth_next_big_blocknr(This->hf,This->stde.pps_sb,This->offset.LowPart/BIGSIZE);
blocknr = STORAGE_get_nth_next_big_blocknr(This->hf,This->stde.pps_sb,This->offset.s.LowPart/BIGSIZE);
while (cb) {
int cc;
@ -817,10 +817,10 @@ HRESULT WINAPI IStream16_fnRead(
return E_FAIL;
}
cc = cb;
if (cc>BIGSIZE-(This->offset.LowPart&(BIGSIZE-1)))
cc=BIGSIZE-(This->offset.LowPart&(BIGSIZE-1));
memcpy((LPBYTE)pv,block+(This->offset.LowPart&(BIGSIZE-1)),cc);
This->offset.LowPart+=cc;
if (cc>BIGSIZE-(This->offset.s.LowPart&(BIGSIZE-1)))
cc=BIGSIZE-(This->offset.s.LowPart&(BIGSIZE-1));
memcpy((LPBYTE)pv,block+(This->offset.s.LowPart&(BIGSIZE-1)),cc);
This->offset.s.LowPart+=cc;
(LPBYTE)pv+=cc;
*bytesread+=cc;
cb-=cc;
@ -847,7 +847,7 @@ HRESULT WINAPI IStream16_fnWrite(
TRACE_(relay)("(%p)->(%p,%ld,%p)\n",This,pv,cb,pcbWrite);
/* do we need to junk some blocks? */
newsize = This->offset.LowPart+cb;
newsize = This->offset.s.LowPart+cb;
oldsize = This->stde.pps_size;
if (newsize < oldsize) {
if (oldsize < 0x1000) {
@ -1033,7 +1033,7 @@ HRESULT WINAPI IStream16_fnWrite(
/* finally the write pass */
if (This->stde.pps_size < 0x1000) {
blocknr = STORAGE_get_nth_next_small_blocknr(hf,This->stde.pps_sb,This->offset.LowPart/SMALLSIZE);
blocknr = STORAGE_get_nth_next_small_blocknr(hf,This->stde.pps_sb,This->offset.s.LowPart/SMALLSIZE);
assert(blocknr>=0);
while (cb>0) {
/* we ensured that it is allocated above */
@ -1044,10 +1044,10 @@ HRESULT WINAPI IStream16_fnWrite(
if (!STORAGE_get_small_block(hf,blocknr,block))
return E_FAIL;
cc = SMALLSIZE-(This->offset.LowPart&(SMALLSIZE-1));
cc = SMALLSIZE-(This->offset.s.LowPart&(SMALLSIZE-1));
if (cc>cb)
cc=cb;
memcpy( ((LPBYTE)block)+(This->offset.LowPart&(SMALLSIZE-1)),
memcpy( ((LPBYTE)block)+(This->offset.s.LowPart&(SMALLSIZE-1)),
(LPBYTE)((char *) pv+curoffset),
cc
);
@ -1056,12 +1056,12 @@ HRESULT WINAPI IStream16_fnWrite(
cb -= cc;
curoffset += cc;
(LPBYTE)pv += cc;
This->offset.LowPart += cc;
This->offset.s.LowPart += cc;
*byteswritten += cc;
blocknr = STORAGE_get_next_small_blocknr(hf,blocknr);
}
} else {
blocknr = STORAGE_get_nth_next_big_blocknr(hf,This->stde.pps_sb,This->offset.LowPart/BIGSIZE);
blocknr = STORAGE_get_nth_next_big_blocknr(hf,This->stde.pps_sb,This->offset.s.LowPart/BIGSIZE);
assert(blocknr>=0);
while (cb>0) {
/* we ensured that it is allocated above, so it better is */
@ -1072,10 +1072,10 @@ HRESULT WINAPI IStream16_fnWrite(
if (!STORAGE_get_big_block(hf,blocknr,block))
return E_FAIL;
cc = BIGSIZE-(This->offset.LowPart&(BIGSIZE-1));
cc = BIGSIZE-(This->offset.s.LowPart&(BIGSIZE-1));
if (cc>cb)
cc=cb;
memcpy( ((LPBYTE)block)+(This->offset.LowPart&(BIGSIZE-1)),
memcpy( ((LPBYTE)block)+(This->offset.s.LowPart&(BIGSIZE-1)),
(LPBYTE)((char *) pv+curoffset),
cc
);
@ -1084,7 +1084,7 @@ HRESULT WINAPI IStream16_fnWrite(
cb -= cc;
curoffset += cc;
(LPBYTE)pv += cc;
This->offset.LowPart += cc;
This->offset.s.LowPart += cc;
*byteswritten += cc;
blocknr = STORAGE_get_next_big_blocknr(hf,blocknr);
}
@ -1272,7 +1272,7 @@ HRESULT WINAPI IStorage16_fnStat(
);
pstatstg->pwcsName=(LPOLESTR16)SEGPTR_GET(SEGPTR_STRDUP_WtoA(This->stde.pps_rawname));
pstatstg->type = This->stde.pps_type;
pstatstg->cbSize.LowPart = This->stde.pps_size;
pstatstg->cbSize.s.LowPart = This->stde.pps_size;
pstatstg->mtime = This->stde.pps_ft1; /* FIXME */ /* why? */
pstatstg->atime = This->stde.pps_ft2; /* FIXME */
pstatstg->ctime = This->stde.pps_ft2; /* FIXME */
@ -1395,8 +1395,8 @@ HRESULT WINAPI IStorage16_fnCreateStream(
lpstr = (IStream16Impl*)PTR_SEG_TO_LIN(*ppstm);
DuplicateHandle( GetCurrentProcess(), This->hf, GetCurrentProcess(),
&lpstr->hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
lpstr->offset.LowPart = 0;
lpstr->offset.HighPart = 0;
lpstr->offset.s.LowPart = 0;
lpstr->offset.s.HighPart = 0;
ppsent=STORAGE_get_free_pps_entry(lpstr->hf);
if (ppsent<0)
@ -1494,8 +1494,8 @@ HRESULT WINAPI IStorage16_fnOpenStream(
IStream16_fnRelease((IStream16*)lpstr);
return E_FAIL;
}
lpstr->offset.LowPart = 0;
lpstr->offset.HighPart = 0;
lpstr->offset.s.LowPart = 0;
lpstr->offset.s.HighPart = 0;
lpstr->ppsent = newpps;
return S_OK;
}

140
ole/storage32.c
View File

@ -630,8 +630,8 @@ HRESULT WINAPI StorageBaseImpl_RenameElement(
renamedProperty.propertyType = currentProperty.propertyType;
renamedProperty.startingBlock = currentProperty.startingBlock;
renamedProperty.size.LowPart = currentProperty.size.LowPart;
renamedProperty.size.HighPart = currentProperty.size.HighPart;
renamedProperty.size.s.LowPart = currentProperty.size.s.LowPart;
renamedProperty.size.s.HighPart = currentProperty.size.s.HighPart;
renamedProperty.previousProperty = PROPERTY_NULL;
renamedProperty.nextProperty = PROPERTY_NULL;
@ -800,8 +800,8 @@ HRESULT WINAPI StorageBaseImpl_CreateStream(
newStreamProperty.propertyType = PROPTYPE_STREAM;
newStreamProperty.startingBlock = BLOCK_END_OF_CHAIN;
newStreamProperty.size.LowPart = 0;
newStreamProperty.size.HighPart = 0;
newStreamProperty.size.s.LowPart = 0;
newStreamProperty.size.s.HighPart = 0;
newStreamProperty.previousProperty = PROPERTY_NULL;
newStreamProperty.nextProperty = PROPERTY_NULL;
@ -985,8 +985,8 @@ HRESULT WINAPI StorageImpl_CreateStorage(
newProperty.propertyType = PROPTYPE_STORAGE;
newProperty.startingBlock = BLOCK_END_OF_CHAIN;
newProperty.size.LowPart = 0;
newProperty.size.HighPart = 0;
newProperty.size.s.LowPart = 0;
newProperty.size.s.HighPart = 0;
newProperty.previousProperty = PROPERTY_NULL;
newProperty.nextProperty = PROPERTY_NULL;
@ -1107,8 +1107,8 @@ static ULONG getFreeProperty(
/*
* initialize the size used by the property stream
*/
newSize.HighPart = 0;
newSize.LowPart = storage->bigBlockSize * blockCount;
newSize.s.HighPart = 0;
newSize.s.LowPart = storage->bigBlockSize * blockCount;
/*
* add a property block to the property chain
@ -1699,8 +1699,8 @@ static HRESULT deleteStreamProperty(
HRESULT hr;
ULARGE_INTEGER size;
size.HighPart = 0;
size.LowPart = 0;
size.s.HighPart = 0;
size.s.LowPart = 0;
hr = StorageBaseImpl_OpenStream(
(IStorage*)parentStorage,
@ -2094,8 +2094,8 @@ HRESULT StorageImpl_Construct(
/*
* Add one block for the big block depot and one block for the properties
*/
size.HighPart = 0;
size.LowPart = This->bigBlockSize * 3;
size.s.HighPart = 0;
size.s.LowPart = This->bigBlockSize * 3;
BIGBLOCKFILE_SetSize(This->bigBlockFile, size);
/*
@ -2161,8 +2161,8 @@ HRESULT StorageImpl_Construct(
rootProp.nextProperty = PROPERTY_NULL;
rootProp.dirProperty = PROPERTY_NULL;
rootProp.startingBlock = BLOCK_END_OF_CHAIN;
rootProp.size.HighPart = 0;
rootProp.size.LowPart = 0;
rootProp.size.s.HighPart = 0;
rootProp.size.s.LowPart = 0;
StorageImpl_WriteProperty(This, 0, &rootProp);
}
@ -2924,8 +2924,8 @@ BOOL StorageImpl_ReadProperty(
BOOL readSucessful;
ULONG bytesRead;
offsetInPropSet.HighPart = 0;
offsetInPropSet.LowPart = index * PROPSET_BLOCK_SIZE;
offsetInPropSet.s.HighPart = 0;
offsetInPropSet.s.LowPart = index * PROPSET_BLOCK_SIZE;
readSucessful = BlockChainStream_ReadAt(
This->rootBlockChain,
@ -2997,9 +2997,9 @@ BOOL StorageImpl_ReadProperty(
StorageUtl_ReadDWord(
currentProperty,
OFFSET_PS_SIZE,
&buffer->size.LowPart);
&buffer->size.s.LowPart);
buffer->size.HighPart = 0;
buffer->size.s.HighPart = 0;
}
return readSucessful;
@ -3018,8 +3018,8 @@ BOOL StorageImpl_WriteProperty(
BOOL writeSucessful;
ULONG bytesWritten;
offsetInPropSet.HighPart = 0;
offsetInPropSet.LowPart = index * PROPSET_BLOCK_SIZE;
offsetInPropSet.s.HighPart = 0;
offsetInPropSet.s.LowPart = index * PROPSET_BLOCK_SIZE;
memset(currentProperty, 0, PROPSET_BLOCK_SIZE);
@ -3088,7 +3088,7 @@ BOOL StorageImpl_WriteProperty(
StorageUtl_WriteDWord(
currentProperty,
OFFSET_PS_SIZE,
buffer->size.LowPart);
buffer->size.s.LowPart);
writeSucessful = BlockChainStream_WriteAt(This->rootBlockChain,
offsetInPropSet,
@ -3200,8 +3200,8 @@ BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
* Copy the contents of the small block chain to the big block chain
* by small block size increments.
*/
offset.LowPart = 0;
offset.HighPart = 0;
offset.s.LowPart = 0;
offset.s.HighPart = 0;
cbTotalRead = 0;
cbTotalWritten = 0;
@ -3222,7 +3222,7 @@ BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
&cbWritten);
cbTotalWritten += cbWritten;
offset.LowPart += This->smallBlockSize;
offset.s.LowPart += This->smallBlockSize;
} while (successRead && successWrite);
free(buffer);
@ -3233,8 +3233,8 @@ BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
* Destroy the small block chain.
*/
propertyIndex = (*ppsbChain)->ownerPropertyIndex;
size.HighPart = 0;
size.LowPart = 0;
size.s.HighPart = 0;
size.s.LowPart = 0;
SmallBlockChainStream_SetSize(*ppsbChain, size);
SmallBlockChainStream_Destroy(*ppsbChain);
*ppsbChain = 0;
@ -4054,8 +4054,8 @@ BOOL BlockChainStream_ReadAt(BlockChainStream* This,
void* buffer,
ULONG* bytesRead)
{
ULONG blockNoInSequence = offset.LowPart / This->parentStorage->bigBlockSize;
ULONG offsetInBlock = offset.LowPart % This->parentStorage->bigBlockSize;
ULONG blockNoInSequence = offset.s.LowPart / This->parentStorage->bigBlockSize;
ULONG offsetInBlock = offset.s.LowPart % This->parentStorage->bigBlockSize;
ULONG bytesToReadInBuffer;
ULONG blockIndex;
BYTE* bufferWalker;
@ -4143,8 +4143,8 @@ BOOL BlockChainStream_WriteAt(BlockChainStream* This,
const void* buffer,
ULONG* bytesWritten)
{
ULONG blockNoInSequence = offset.LowPart / This->parentStorage->bigBlockSize;
ULONG offsetInBlock = offset.LowPart % This->parentStorage->bigBlockSize;
ULONG blockNoInSequence = offset.s.LowPart / This->parentStorage->bigBlockSize;
ULONG offsetInBlock = offset.s.LowPart % This->parentStorage->bigBlockSize;
ULONG bytesToWrite;
ULONG blockIndex;
BYTE* bufferWalker;
@ -4239,9 +4239,9 @@ BOOL BlockChainStream_Shrink(BlockChainStream* This,
/*
* Figure out how many blocks are needed to contain the new size
*/
numBlocks = newSize.LowPart / This->parentStorage->bigBlockSize;
numBlocks = newSize.s.LowPart / This->parentStorage->bigBlockSize;
if ((newSize.LowPart % This->parentStorage->bigBlockSize) != 0)
if ((newSize.s.LowPart % This->parentStorage->bigBlockSize) != 0)
numBlocks++;
blockIndex = BlockChainStream_GetHeadOfChain(This);
@ -4338,9 +4338,9 @@ BOOL BlockChainStream_Enlarge(BlockChainStream* This,
/*
* Figure out how many blocks are needed to contain this stream
*/
newNumBlocks = newSize.LowPart / This->parentStorage->bigBlockSize;
newNumBlocks = newSize.s.LowPart / This->parentStorage->bigBlockSize;
if ((newSize.LowPart % This->parentStorage->bigBlockSize) != 0)
if ((newSize.s.LowPart % This->parentStorage->bigBlockSize) != 0)
newNumBlocks++;
/*
@ -4411,10 +4411,10 @@ BOOL BlockChainStream_SetSize(
{
ULARGE_INTEGER size = BlockChainStream_GetSize(This);
if (newSize.LowPart == size.LowPart)
if (newSize.s.LowPart == size.s.LowPart)
return TRUE;
if (newSize.LowPart < size.LowPart)
if (newSize.s.LowPart < size.s.LowPart)
{
BlockChainStream_Shrink(This, newSize);
}
@ -4423,7 +4423,7 @@ BOOL BlockChainStream_SetSize(
ULARGE_INTEGER fileSize =
BIGBLOCKFILE_GetSize(This->parentStorage->bigBlockFile);
ULONG diff = newSize.LowPart - size.LowPart;
ULONG diff = newSize.s.LowPart - size.s.LowPart;
/*
* Make sure the file stays a multiple of blocksize
@ -4432,7 +4432,7 @@ BOOL BlockChainStream_SetSize(
diff += (This->parentStorage->bigBlockSize -
(diff % This->parentStorage->bigBlockSize) );
fileSize.LowPart += diff;
fileSize.s.LowPart += diff;
BIGBLOCKFILE_SetSize(This->parentStorage->bigBlockFile, fileSize);
BlockChainStream_Enlarge(This, newSize);
@ -4472,9 +4472,9 @@ ULARGE_INTEGER BlockChainStream_GetSize(BlockChainStream* This)
* size of them
*/
ULARGE_INTEGER result;
result.HighPart = 0;
result.s.HighPart = 0;
result.LowPart =
result.s.LowPart =
BlockChainStream_GetCount(This) *
This->parentStorage->bigBlockSize;
@ -4553,8 +4553,8 @@ ULONG SmallBlockChainStream_GetNextBlockInChain(
ULONG bytesRead;
BOOL success;
offsetOfBlockInDepot.HighPart = 0;
offsetOfBlockInDepot.LowPart = blockIndex * sizeof(ULONG);
offsetOfBlockInDepot.s.HighPart = 0;
offsetOfBlockInDepot.s.LowPart = blockIndex * sizeof(ULONG);
/*
* Read those bytes in the buffer from the small block file.
@ -4591,8 +4591,8 @@ void SmallBlockChainStream_SetNextBlockInChain(
DWORD buffer;
ULONG bytesWritten;
offsetOfBlockInDepot.HighPart = 0;
offsetOfBlockInDepot.LowPart = blockIndex * sizeof(ULONG);
offsetOfBlockInDepot.s.HighPart = 0;
offsetOfBlockInDepot.s.LowPart = blockIndex * sizeof(ULONG);
StorageUtl_WriteDWord(&buffer, 0, nextBlock);
@ -4637,14 +4637,14 @@ ULONG SmallBlockChainStream_GetNextFreeBlock(
BOOL success = TRUE;
ULONG smallBlocksPerBigBlock;
offsetOfBlockInDepot.HighPart = 0;
offsetOfBlockInDepot.s.HighPart = 0;
/*
* Scan the small block depot for a free block
*/
while (nextBlockIndex != BLOCK_UNUSED)
{
offsetOfBlockInDepot.LowPart = blockIndex * sizeof(ULONG);
offsetOfBlockInDepot.s.LowPart = blockIndex * sizeof(ULONG);
success = BlockChainStream_ReadAt(
This->parentStorage->smallBlockDepotChain,
@ -4732,8 +4732,8 @@ ULONG SmallBlockChainStream_GetNextFreeBlock(
&rootProp);
rootProp.startingBlock = sbStartIndex;
rootProp.size.HighPart = 0;
rootProp.size.LowPart = This->parentStorage->bigBlockSize;
rootProp.size.s.HighPart = 0;
rootProp.size.s.LowPart = This->parentStorage->bigBlockSize;
StorageImpl_WriteProperty(
This->parentStorage,
@ -4759,10 +4759,10 @@ ULONG SmallBlockChainStream_GetNextFreeBlock(
This->parentStorage->rootPropertySetIndex,
&rootProp);
if (rootProp.size.LowPart <
if (rootProp.size.s.LowPart <
(blocksRequired * This->parentStorage->bigBlockSize))
{
rootProp.size.LowPart += This->parentStorage->bigBlockSize;
rootProp.size.s.LowPart += This->parentStorage->bigBlockSize;
BlockChainStream_SetSize(
This->parentStorage->smallBlockRootChain,
@ -4794,9 +4794,9 @@ BOOL SmallBlockChainStream_ReadAt(
{
ULARGE_INTEGER offsetInBigBlockFile;
ULONG blockNoInSequence =
offset.LowPart / This->parentStorage->smallBlockSize;
offset.s.LowPart / This->parentStorage->smallBlockSize;
ULONG offsetInBlock = offset.LowPart % This->parentStorage->smallBlockSize;
ULONG offsetInBlock = offset.s.LowPart % This->parentStorage->smallBlockSize;
ULONG bytesToReadInBuffer;
ULONG blockIndex;
ULONG bytesReadFromBigBlockFile;
@ -4805,7 +4805,7 @@ BOOL SmallBlockChainStream_ReadAt(
/*
* This should never happen on a small block file.
*/
assert(offset.HighPart==0);
assert(offset.s.HighPart==0);
/*
* Find the first block in the stream that contains part of the buffer.
@ -4836,11 +4836,11 @@ BOOL SmallBlockChainStream_ReadAt(
/*
* Calculate the offset of the small block in the small block file.
*/
offsetInBigBlockFile.HighPart = 0;
offsetInBigBlockFile.LowPart =
offsetInBigBlockFile.s.HighPart = 0;
offsetInBigBlockFile.s.LowPart =
blockIndex * This->parentStorage->smallBlockSize;
offsetInBigBlockFile.LowPart += offsetInBlock;
offsetInBigBlockFile.s.LowPart += offsetInBlock;
/*
* Read those bytes in the buffer from the small block file.
@ -4882,9 +4882,9 @@ BOOL SmallBlockChainStream_WriteAt(
{
ULARGE_INTEGER offsetInBigBlockFile;
ULONG blockNoInSequence =
offset.LowPart / This->parentStorage->smallBlockSize;
offset.s.LowPart / This->parentStorage->smallBlockSize;
ULONG offsetInBlock = offset.LowPart % This->parentStorage->smallBlockSize;
ULONG offsetInBlock = offset.s.LowPart % This->parentStorage->smallBlockSize;
ULONG bytesToWriteInBuffer;
ULONG blockIndex;
ULONG bytesWrittenFromBigBlockFile;
@ -4893,7 +4893,7 @@ BOOL SmallBlockChainStream_WriteAt(
/*
* This should never happen on a small block file.
*/
assert(offset.HighPart==0);
assert(offset.s.HighPart==0);
/*
* Find the first block in the stream that contains part of the buffer.
@ -4926,11 +4926,11 @@ BOOL SmallBlockChainStream_WriteAt(
/*
* Calculate the offset of the small block in the small block file.
*/
offsetInBigBlockFile.HighPart = 0;
offsetInBigBlockFile.LowPart =
offsetInBigBlockFile.s.HighPart = 0;
offsetInBigBlockFile.s.LowPart =
blockIndex * This->parentStorage->smallBlockSize;
offsetInBigBlockFile.LowPart += offsetInBlock;
offsetInBigBlockFile.s.LowPart += offsetInBlock;
/*
* Write those bytes in the buffer to the small block file.
@ -4969,9 +4969,9 @@ BOOL SmallBlockChainStream_Shrink(
ULONG numBlocks;
ULONG count = 0;
numBlocks = newSize.LowPart / This->parentStorage->smallBlockSize;
numBlocks = newSize.s.LowPart / This->parentStorage->smallBlockSize;
if ((newSize.LowPart % This->parentStorage->smallBlockSize) != 0)
if ((newSize.s.LowPart % This->parentStorage->smallBlockSize) != 0)
numBlocks++;
blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
@ -5076,9 +5076,9 @@ BOOL SmallBlockChainStream_Enlarge(
/*
* Figure out how many blocks are needed to contain this stream
*/
newNumBlocks = newSize.LowPart / This->parentStorage->smallBlockSize;
newNumBlocks = newSize.s.LowPart / This->parentStorage->smallBlockSize;
if ((newSize.LowPart % This->parentStorage->smallBlockSize) != 0)
if ((newSize.s.LowPart % This->parentStorage->smallBlockSize) != 0)
newNumBlocks++;
/*
@ -5150,10 +5150,10 @@ BOOL SmallBlockChainStream_SetSize(
{
ULARGE_INTEGER size = SmallBlockChainStream_GetSize(This);
if (newSize.LowPart == size.LowPart)
if (newSize.s.LowPart == size.s.LowPart)
return TRUE;
if (newSize.LowPart < size.LowPart)
if (newSize.s.LowPart < size.s.LowPart)
{
SmallBlockChainStream_Shrink(This, newSize);
}
@ -5514,8 +5514,8 @@ HRESULT WINAPI StgIsStorageILockBytes(ILockBytes *plkbyt)
BYTE sig[8];
ULARGE_INTEGER offset;
offset.HighPart = 0;
offset.LowPart = 0;
offset.s.HighPart = 0;
offset.s.LowPart = 0;
ILockBytes_ReadAt(plkbyt, offset, sig, sizeof(sig), NULL);

74
ole/variant.c
View File

@ -2206,7 +2206,7 @@ HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbO
* Convert currency to unsigned char
*/
HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
if (t > UI1_MAX || t < UI1_MIN) return DISP_E_OVERFLOW;
@ -2412,7 +2412,7 @@ HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, short* psO
* Convert currency to signed short
*/
HRESULT WINAPI VarI2FromCy(CY cyIn, short* psOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
if (t > I2_MAX || t < I2_MIN) return DISP_E_OVERFLOW;
@ -2605,7 +2605,7 @@ HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG* plOu
* Convert currency to signed long
*/
HRESULT WINAPI VarI4FromCy(CY cyIn, LONG* plOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
if (t > I4_MAX || t < I4_MIN) return DISP_E_OVERFLOW;
@ -2779,7 +2779,7 @@ HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, FLOAT* pfl
* Convert currency to float
*/
HRESULT WINAPI VarR4FromCy(CY cyIn, FLOAT* pfltOut) {
*pfltOut = (FLOAT)((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
*pfltOut = (FLOAT)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
return S_OK;
}
@ -2929,7 +2929,7 @@ HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double* pd
* Convert currency to double
*/
HRESULT WINAPI VarR8FromCy(CY cyIn, double* pdblOut) {
*pdblOut = (double)((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
*pdblOut = (double)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
return S_OK;
}
@ -3120,7 +3120,7 @@ HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
* Convert currency to date
*/
HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut) {
*pdateOut = (DATE)((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
*pdateOut = (DATE)((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
if (*pdateOut > DATE_MAX || *pdateOut < DATE_MIN) return DISP_E_TYPEMISMATCH;
return S_OK;
@ -3537,7 +3537,7 @@ HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
* Convert currency to boolean
*/
HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) {
if (cyIn.u.Hi || cyIn.u.Lo) *pboolOut = -1;
if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
else *pboolOut = 0;
return S_OK;
@ -3741,7 +3741,7 @@ HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut)
* Convert currency to signed char
*/
HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
@ -3975,7 +3975,7 @@ HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pu
* Convert currency to unsigned short
*/
HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
@ -4123,7 +4123,7 @@ HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
* Convert currency to unsigned long
*/
HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
double t = round((((double)cyIn.u.Hi * 4294967296.0) + (double)cyIn.u.Lo) / 10000);
double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
@ -4137,8 +4137,8 @@ HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
* Convert unsigned char to currency
*/
HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
pcyOut->u.Hi = 0;
pcyOut->u.Lo = ((ULONG)bIn) * 10000;
pcyOut->s.Hi = 0;
pcyOut->s.Lo = ((ULONG)bIn) * 10000;
return S_OK;
}
@ -4148,9 +4148,9 @@ HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
* Convert signed short to currency
*/
HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
if (sIn < 0) pcyOut->u.Hi = -1;
else pcyOut->u.Hi = 0;
pcyOut->u.Lo = ((ULONG)sIn) * 10000;
if (sIn < 0) pcyOut->s.Hi = -1;
else pcyOut->s.Hi = 0;
pcyOut->s.Lo = ((ULONG)sIn) * 10000;
return S_OK;
}
@ -4161,9 +4161,9 @@ HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
*/
HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
double t = (double)lIn * (double)10000;
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (lIn < 0) pcyOut->u.Hi--;
pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (lIn < 0) pcyOut->s.Hi--;
return S_OK;
}
@ -4174,9 +4174,9 @@ HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
*/
HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
double t = round((double)fltIn * (double)10000);
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (fltIn < 0) pcyOut->u.Hi--;
pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (fltIn < 0) pcyOut->s.Hi--;
return S_OK;
}
@ -4187,9 +4187,9 @@ HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
*/
HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
double t = round(dblIn * (double)10000);
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (dblIn < 0) pcyOut->u.Hi--;
pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (dblIn < 0) pcyOut->s.Hi--;
return S_OK;
}
@ -4200,9 +4200,9 @@ HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
*/
HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
double t = round((double)dateIn * (double)10000);
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (dateIn < 0) pcyOut->u.Hi--;
pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
if (dateIn < 0) pcyOut->s.Hi--;
return S_OK;
}
@ -4221,9 +4221,9 @@ HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut
* Convert boolean to currency
*/
HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
if (boolIn < 0) pcyOut->u.Hi = -1;
else pcyOut->u.Hi = 0;
pcyOut->u.Lo = (ULONG)boolIn * (ULONG)10000;
if (boolIn < 0) pcyOut->s.Hi = -1;
else pcyOut->s.Hi = 0;
pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
return S_OK;
}
@ -4233,9 +4233,9 @@ HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
* Convert signed char to currency
*/
HRESULT WINAPI VarCyFromI1(CHAR cIn, CY* pcyOut) {
if (cIn < 0) pcyOut->u.Hi = -1;
else pcyOut->u.Hi = 0;
pcyOut->u.Lo = (ULONG)cIn * (ULONG)10000;
if (cIn < 0) pcyOut->s.Hi = -1;
else pcyOut->s.Hi = 0;
pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
return S_OK;
}
@ -4245,8 +4245,8 @@ HRESULT WINAPI VarCyFromI1(CHAR cIn, CY* pcyOut) {
* Convert unsigned short to currency
*/
HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
pcyOut->u.Hi = 0;
pcyOut->u.Lo = (ULONG)usIn * (ULONG)10000;
pcyOut->s.Hi = 0;
pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
return S_OK;
}
@ -4257,8 +4257,8 @@ HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
*/
HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) {
double t = (double)ulIn * (double)10000;
pcyOut->u.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->u.Lo = (ULONG)fmod(t, (double)4294967296.0);
pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
return S_OK;
}

8
win32/newfns.c
View File

@ -28,8 +28,8 @@ BOOL WINAPI QueryPerformanceCounter(PLARGE_INTEGER counter)
struct timeval tv;
gettimeofday(&tv,NULL);
counter->LowPart = tv.tv_usec+tv.tv_sec*1000000;
counter->HighPart = 0;
counter->s.LowPart = tv.tv_usec+tv.tv_sec*1000000;
counter->s.HighPart = 0;
return TRUE;
}
@ -38,8 +38,8 @@ BOOL WINAPI QueryPerformanceCounter(PLARGE_INTEGER counter)
*/
BOOL WINAPI QueryPerformanceFrequency(PLARGE_INTEGER frequency)
{
frequency->LowPart = 1000000;
frequency->HighPart = 0;
frequency->s.LowPart = 1000000;
frequency->s.HighPart = 0;
return TRUE;
}