1 // MyWindows.cpp
2
3 #include "StdAfx.h"
4
5 #ifndef _WIN32
6
7 #include <stdlib.h>
8 #include <time.h>
9 #ifdef __GNUC__
10 #include <sys/time.h>
11 #endif
12
13 #include "MyWindows.h"
14
AllocateForBSTR(size_t cb)15 static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
FreeForBSTR(void * pv)16 static inline void FreeForBSTR(void *pv) { ::free(pv);}
17
18 /* Win32 uses DWORD (32-bit) type to store size of string before (OLECHAR *) string.
19 We must select CBstrSizeType for another systems (not Win32):
20
21 if (CBstrSizeType is UINT32),
22 then we support only strings smaller than 4 GB.
23 Win32 version always has that limitation.
24
25 if (CBstrSizeType is UINT),
26 (UINT can be 16/32/64-bit)
27 We can support strings larger than 4 GB (if UINT is 64-bit),
28 but sizeof(UINT) can be different in parts compiled by
29 different compilers/settings,
30 and we can't send such BSTR strings between such parts.
31 */
32
33 typedef UINT32 CBstrSizeType;
34 // typedef UINT CBstrSizeType;
35
36 #define k_BstrSize_Max 0xFFFFFFFF
37 // #define k_BstrSize_Max UINT_MAX
38 // #define k_BstrSize_Max ((UINT)(INT)-1)
39
SysAllocStringByteLen(LPCSTR s,UINT len)40 BSTR SysAllocStringByteLen(LPCSTR s, UINT len)
41 {
42 /* Original SysAllocStringByteLen in Win32 maybe fills only unaligned null OLECHAR at the end.
43 We provide also aligned null OLECHAR at the end. */
44
45 if (len >= (k_BstrSize_Max - (UINT)sizeof(OLECHAR) - (UINT)sizeof(OLECHAR) - (UINT)sizeof(CBstrSizeType)))
46 return NULL;
47
48 UINT size = (len + (UINT)sizeof(OLECHAR) + (UINT)sizeof(OLECHAR) - 1) & ~((UINT)sizeof(OLECHAR) - 1);
49 void *p = AllocateForBSTR(size + (UINT)sizeof(CBstrSizeType));
50 if (!p)
51 return NULL;
52 *(CBstrSizeType *)p = (CBstrSizeType)len;
53 BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
54 if (s)
55 memcpy(bstr, s, len);
56 for (; len < size; len++)
57 ((Byte *)bstr)[len] = 0;
58 return bstr;
59 }
60
SysAllocStringLen(const OLECHAR * s,UINT len)61 BSTR SysAllocStringLen(const OLECHAR *s, UINT len)
62 {
63 if (len >= (k_BstrSize_Max - (UINT)sizeof(OLECHAR) - (UINT)sizeof(CBstrSizeType)) / (UINT)sizeof(OLECHAR))
64 return NULL;
65
66 UINT size = len * (UINT)sizeof(OLECHAR);
67 void *p = AllocateForBSTR(size + (UINT)sizeof(CBstrSizeType) + (UINT)sizeof(OLECHAR));
68 if (!p)
69 return NULL;
70 *(CBstrSizeType *)p = (CBstrSizeType)size;
71 BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
72 if (s)
73 memcpy(bstr, s, size);
74 bstr[len] = 0;
75 return bstr;
76 }
77
SysAllocString(const OLECHAR * s)78 BSTR SysAllocString(const OLECHAR *s)
79 {
80 if (!s)
81 return 0;
82 const OLECHAR *s2 = s;
83 while (*s2 != 0)
84 s2++;
85 return SysAllocStringLen(s, (UINT)(s2 - s));
86 }
87
SysFreeString(BSTR bstr)88 void SysFreeString(BSTR bstr)
89 {
90 if (bstr)
91 FreeForBSTR((CBstrSizeType *)bstr - 1);
92 }
93
SysStringByteLen(BSTR bstr)94 UINT SysStringByteLen(BSTR bstr)
95 {
96 if (!bstr)
97 return 0;
98 return *((CBstrSizeType *)bstr - 1);
99 }
100
SysStringLen(BSTR bstr)101 UINT SysStringLen(BSTR bstr)
102 {
103 if (!bstr)
104 return 0;
105 return *((CBstrSizeType *)bstr - 1) / (UINT)sizeof(OLECHAR);
106 }
107
108
VariantClear(VARIANTARG * prop)109 HRESULT VariantClear(VARIANTARG *prop)
110 {
111 if (prop->vt == VT_BSTR)
112 SysFreeString(prop->bstrVal);
113 prop->vt = VT_EMPTY;
114 return S_OK;
115 }
116
VariantCopy(VARIANTARG * dest,const VARIANTARG * src)117 HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src)
118 {
119 HRESULT res = ::VariantClear(dest);
120 if (res != S_OK)
121 return res;
122 if (src->vt == VT_BSTR)
123 {
124 dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
125 SysStringByteLen(src->bstrVal));
126 if (!dest->bstrVal)
127 return E_OUTOFMEMORY;
128 dest->vt = VT_BSTR;
129 }
130 else
131 *dest = *src;
132 return S_OK;
133 }
134
CompareFileTime(const FILETIME * ft1,const FILETIME * ft2)135 LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2)
136 {
137 if (ft1->dwHighDateTime < ft2->dwHighDateTime) return -1;
138 if (ft1->dwHighDateTime > ft2->dwHighDateTime) return 1;
139 if (ft1->dwLowDateTime < ft2->dwLowDateTime) return -1;
140 if (ft1->dwLowDateTime > ft2->dwLowDateTime) return 1;
141 return 0;
142 }
143
GetLastError()144 DWORD GetLastError()
145 {
146 return (DWORD)errno;
147 }
148
SetLastError(DWORD dw)149 void SetLastError(DWORD dw)
150 {
151 errno = (int)dw;
152 }
153
154
TIME_GetBias()155 static LONG TIME_GetBias()
156 {
157 time_t utc = time(NULL);
158 struct tm *ptm = localtime(&utc);
159 int localdaylight = ptm->tm_isdst; /* daylight for local timezone */
160 ptm = gmtime(&utc);
161 ptm->tm_isdst = localdaylight; /* use local daylight, not that of Greenwich */
162 LONG bias = (int)(mktime(ptm)-utc);
163 return bias;
164 }
165
166 #define TICKS_PER_SEC 10000000
167 /*
168 #define SECS_PER_DAY (24 * 60 * 60)
169 #define SECS_1601_TO_1970 ((369 * 365 + 89) * (UInt64)SECS_PER_DAY)
170 #define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKS_PER_SEC)
171 */
172
173 #define GET_TIME_64(pft) ((pft)->dwLowDateTime | ((UInt64)(pft)->dwHighDateTime << 32))
174
175 #define SET_FILETIME(ft, v64) \
176 (ft)->dwLowDateTime = (DWORD)v64; \
177 (ft)->dwHighDateTime = (DWORD)(v64 >> 32);
178
179
FileTimeToLocalFileTime(const FILETIME * fileTime,FILETIME * localFileTime)180 BOOL WINAPI FileTimeToLocalFileTime(const FILETIME *fileTime, FILETIME *localFileTime)
181 {
182 UInt64 v = GET_TIME_64(fileTime);
183 v = (UInt64)((Int64)v - (Int64)TIME_GetBias() * TICKS_PER_SEC);
184 SET_FILETIME(localFileTime, v);
185 return TRUE;
186 }
187
LocalFileTimeToFileTime(const FILETIME * localFileTime,FILETIME * fileTime)188 BOOL WINAPI LocalFileTimeToFileTime(const FILETIME *localFileTime, FILETIME *fileTime)
189 {
190 UInt64 v = GET_TIME_64(localFileTime);
191 v = (UInt64)((Int64)v + (Int64)TIME_GetBias() * TICKS_PER_SEC);
192 SET_FILETIME(fileTime, v);
193 return TRUE;
194 }
195
196 /*
197 VOID WINAPI GetSystemTimeAsFileTime(FILETIME *ft)
198 {
199 UInt64 t = 0;
200 timeval tv;
201 if (gettimeofday(&tv, NULL) == 0)
202 {
203 t = tv.tv_sec * (UInt64)TICKS_PER_SEC + TICKS_1601_TO_1970;
204 t += tv.tv_usec * 10;
205 }
206 SET_FILETIME(ft, t);
207 }
208 */
209
GetTickCount(VOID)210 DWORD WINAPI GetTickCount(VOID)
211 {
212 #ifndef _WIN32
213 // gettimeofday() doesn't work in some MINGWs by unknown reason
214 timeval tv;
215 if (gettimeofday(&tv, NULL) == 0)
216 {
217 // tv_sec and tv_usec are (long)
218 return (DWORD)((UInt64)(Int64)tv.tv_sec * (UInt64)1000 + (UInt64)(Int64)tv.tv_usec / 1000);
219 }
220 #endif
221 return (DWORD)time(NULL) * 1000;
222 }
223
224
225 #define PERIOD_4 (4 * 365 + 1)
226 #define PERIOD_100 (PERIOD_4 * 25 - 1)
227 #define PERIOD_400 (PERIOD_100 * 4 + 1)
228
FileTimeToSystemTime(const FILETIME * ft,SYSTEMTIME * st)229 BOOL WINAPI FileTimeToSystemTime(const FILETIME *ft, SYSTEMTIME *st)
230 {
231 UInt32 v;
232 UInt64 v64 = GET_TIME_64(ft);
233 v64 /= 10000;
234 st->wMilliseconds = (WORD)(v64 % 1000); v64 /= 1000;
235 st->wSecond = (WORD)(v64 % 60); v64 /= 60;
236 st->wMinute = (WORD)(v64 % 60); v64 /= 60;
237 v = (UInt32)v64;
238 st->wHour = (WORD)(v % 24); v /= 24;
239
240 // 1601-01-01 was Monday
241 st->wDayOfWeek = (WORD)((v + 1) % 7);
242
243 UInt32 leaps, year, day, mon;
244 leaps = (3 * ((4 * v + (365 - 31 - 28) * 4 + 3) / PERIOD_400) + 3) / 4;
245 v += 28188 + leaps;
246 // leaps - the number of exceptions from PERIOD_4 rules starting from 1600-03-01
247 // (1959 / 64) - converts day from 03-01 to month
248 year = (20 * v - 2442) / (5 * PERIOD_4);
249 day = v - (year * PERIOD_4) / 4;
250 mon = (64 * day) / 1959;
251 st->wDay = (WORD)(day - (1959 * mon) / 64);
252 mon -= 1;
253 year += 1524;
254 if (mon > 12)
255 {
256 mon -= 12;
257 year++;
258 }
259 st->wMonth = (WORD)mon;
260 st->wYear = (WORD)year;
261
262 /*
263 unsigned year, mon;
264 unsigned char ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
265 unsigned t;
266
267 year = (WORD)(1601 + v / PERIOD_400 * 400);
268 v %= PERIOD_400;
269
270 t = v / PERIOD_100; if (t == 4) t = 3; year += t * 100; v -= t * PERIOD_100;
271 t = v / PERIOD_4; if (t == 25) t = 24; year += t * 4; v -= t * PERIOD_4;
272 t = v / 365; if (t == 4) t = 3; year += t; v -= t * 365;
273
274 st->wYear = (WORD)year;
275
276 if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
277 ms[1] = 29;
278 for (mon = 0;; mon++)
279 {
280 unsigned d = ms[mon];
281 if (v < d)
282 break;
283 v -= d;
284 }
285 st->wDay = (WORD)(v + 1);
286 st->wMonth = (WORD)(mon + 1);
287 */
288
289 return TRUE;
290 }
291
292 #endif
293