1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// MyWindows.cpp
#include "StdAfx.h"
#ifndef _WIN32
#include "MyWindows.h"
#include "MyTypes.h"
#include <stdlib.h> /* FIXED <malloc.h> */
static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
static inline void FreeForBSTR(void *pv) { ::free(pv);}
static UINT MyStringLen(const wchar_t *s)
{
UINT i;
for (i = 0; s[i] != '\0'; i++);
return i;
}
BSTR SysAllocStringByteLen(LPCSTR psz, UINT len)
{
// FIXED int realLen = len + sizeof(UINT) + 3;
const int LEN_ADDON = sizeof(wchar_t) - 1;
int realLen = len + sizeof(UINT) + sizeof(wchar_t) + LEN_ADDON;
void *p = AllocateForBSTR(realLen);
if (p == 0)
return 0;
*(UINT *)p = len;
// "void *" instead of "BSTR" to avoid unaligned copy of "wchar_t" because of optimizer on Solaris
void * bstr = (void *)((UINT *)p + 1);
if (psz) memmove(bstr, psz, len); // psz does not always have "wchar_t" alignment.
void *pb = (void *)(((Byte *)bstr) + len);
memset(pb,0,sizeof(wchar_t) + LEN_ADDON);
return (BSTR)bstr;
}
BSTR WINAPI SysAllocStringLen(const OLECHAR *sz, unsigned int numChars) // FIXME - code
{
UINT len = (numChars + 1) * sizeof(OLECHAR);
void *p = AllocateForBSTR(len + sizeof(UINT));
if (p == 0)
return 0;
memset(p,0,len + sizeof(UINT));
*(UINT *)p = numChars * sizeof(OLECHAR); // FIXED
void * bstr = (void *)((UINT *)p + 1);
if (sz) memmove(bstr, sz, numChars * sizeof(OLECHAR)); // sz does not always have "wchar_t" alignment.
return (BSTR)bstr;
}
BSTR SysAllocString(const OLECHAR *sz)
{
if (sz == 0)
return 0;
UINT strLen = MyStringLen(sz);
UINT len = (strLen + 1) * sizeof(OLECHAR);
void *p = AllocateForBSTR(len + sizeof(UINT));
if (p == 0)
return 0;
*(UINT *)p = strLen * sizeof(OLECHAR); // FIXED
void * bstr = (void *)((UINT *)p + 1);
memmove(bstr, sz, len); // sz does not always have "wchar_t" alignment.
return (BSTR)bstr;
}
void SysFreeString(BSTR bstr)
{
if (bstr != 0)
FreeForBSTR((UINT *)bstr - 1);
}
UINT SysStringByteLen(BSTR bstr)
{
if (bstr == 0)
return 0;
return *((UINT *)bstr - 1);
}
UINT SysStringLen(BSTR bstr)
{
return SysStringByteLen(bstr) / sizeof(OLECHAR);
}
HRESULT VariantClear(VARIANTARG *prop)
{
if (prop->vt == VT_BSTR)
SysFreeString(prop->bstrVal);
prop->vt = VT_EMPTY;
return S_OK;
}
HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src)
{
HRESULT res = ::VariantClear(dest);
if (res != S_OK)
return res;
if (src->vt == VT_BSTR)
{
dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
SysStringByteLen(src->bstrVal));
if (dest->bstrVal == 0)
return E_OUTOFMEMORY;
dest->vt = VT_BSTR;
}
else
*dest = *src;
return S_OK;
}
LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2)
{
if(ft1->dwHighDateTime < ft2->dwHighDateTime)
return -1;
if(ft1->dwHighDateTime > ft2->dwHighDateTime)
return 1;
if(ft1->dwLowDateTime < ft2->dwLowDateTime)
return -1;
if(ft1->dwLowDateTime > ft2->dwLowDateTime)
return 1;
return 0;
}
#endif
|
