]>
Commit | Line | Data |
---|---|---|
ff7c6d11 XL |
1 | // Licensed under the Apache License, Version 2.0 |
2 | // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
3 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. | |
4 | // All files in the project carrying such notice may not be copied, modified, or distributed | |
5 | // except according to those terms. | |
6 | //! Mappings for the contents of OleAuto.h | |
7 | use ctypes::{c_double, c_float, c_int, c_uint, c_void}; | |
8 | use shared::basetsd::{LONG64, ULONG64}; | |
9 | use shared::minwindef::{BYTE, DWORD, FLOAT, UINT, ULONG, USHORT, WORD}; | |
10 | use shared::wtypes::{BSTR, DATE, DECIMAL, LPBSTR, LPDECIMAL, VARTYPE}; | |
11 | use shared::wtypesbase::{DOUBLE, LPCOLESTR, LPOLESTR, OLECHAR}; | |
12 | use um::minwinbase::LPSYSTEMTIME; | |
0bf4aa26 | 13 | use um::oaidl::{DISPID_UNKNOWN, ITypeLib, SAFEARRAY, VARIANT, VARIANTARG}; |
ff7c6d11 XL |
14 | use um::winnt::{CHAR, HRESULT, INT, LCID, LONG, LPCSTR, SHORT}; |
15 | extern "system" { | |
16 | pub fn SysAllocString( | |
17 | psz: *const OLECHAR, | |
18 | ) -> BSTR; | |
19 | pub fn SysReAllocString( | |
20 | pbstr: *mut BSTR, | |
21 | psz: *const OLECHAR, | |
22 | ) -> INT; | |
23 | pub fn SysAllocStringLen( | |
24 | strIn: *const OLECHAR, | |
25 | ui: UINT, | |
26 | ) -> BSTR; | |
27 | pub fn SysReAllocStringLen( | |
28 | pbstr: *mut BSTR, | |
29 | psz: *const OLECHAR, | |
30 | len: c_uint, | |
31 | ) -> INT; | |
32 | pub fn SysFreeString( | |
33 | bstrString: BSTR, | |
34 | ); | |
35 | pub fn SysStringLen( | |
36 | pbstr: BSTR, | |
37 | ) -> UINT; | |
38 | pub fn SysStringByteLen( | |
39 | bstr: BSTR, | |
40 | ) -> UINT; | |
41 | pub fn SysAllocStringByteLen( | |
42 | psz: LPCSTR, | |
43 | len: UINT, | |
44 | ) -> BSTR; | |
45 | pub fn DosDateTimeToVariantTime( | |
46 | wDosDate: USHORT, | |
47 | wDosTime: USHORT, | |
48 | pvtime: *mut DOUBLE, | |
49 | ) -> INT; | |
50 | pub fn VariantTimeToDosDateTime( | |
51 | vtime: DOUBLE, | |
52 | pwDosDate: *mut USHORT, | |
53 | pwDosTime: *mut USHORT, | |
54 | ) -> INT; | |
55 | pub fn SystemTimeToVariantTime( | |
56 | lpSystemTime: LPSYSTEMTIME, | |
57 | pvtime: *mut DOUBLE, | |
58 | ) -> INT; | |
59 | pub fn VariantTimeToSystemTime( | |
60 | vtime: DOUBLE, | |
61 | lpSystemTime: LPSYSTEMTIME, | |
62 | ) -> INT; | |
0bf4aa26 XL |
63 | pub fn SafeArrayAccessData( |
64 | psa: *mut SAFEARRAY, | |
65 | ppvData: *mut *mut c_void, | |
66 | ) -> HRESULT; | |
67 | pub fn SafeArrayUnaccessData( | |
68 | psa: *mut SAFEARRAY, | |
69 | ) -> HRESULT; | |
70 | pub fn SafeArrayCreateVector( | |
71 | vt: VARTYPE, | |
72 | lLbound: LONG, | |
73 | cElements: ULONG, | |
74 | ) -> *mut SAFEARRAY; | |
60c5eb7d XL |
75 | pub fn SafeArrayGetLBound( |
76 | psa: *mut SAFEARRAY, | |
77 | nDim: UINT, | |
78 | plLbound: *mut LONG | |
79 | ) -> HRESULT; | |
80 | pub fn SafeArrayGetUBound( | |
81 | psa: *mut SAFEARRAY, | |
82 | nDim: UINT, | |
83 | plUbound: *mut LONG | |
84 | ) -> HRESULT; | |
85 | pub fn SafeArrayDestroy( | |
86 | psa: *mut SAFEARRAY | |
87 | ) -> HRESULT; | |
ff7c6d11 XL |
88 | pub fn VariantInit( |
89 | pvarg: *mut VARIANTARG, | |
90 | ); | |
91 | pub fn VariantClear( | |
92 | pvarg: *mut VARIANTARG, | |
93 | ) -> HRESULT; | |
94 | pub fn VariantCopy( | |
95 | pvargDest: *mut VARIANTARG, | |
96 | pvargSrc: *const VARIANTARG, | |
97 | ) -> HRESULT; | |
98 | pub fn VariantCopyInd( | |
99 | pvarDest: *mut VARIANT, | |
100 | pvargSrc: *const VARIANTARG, | |
101 | ) -> HRESULT; | |
102 | pub fn VariantChangeType( | |
103 | pvargDest: *mut VARIANTARG, | |
104 | pvarSrc: *const VARIANTARG, | |
105 | wFlags: USHORT, | |
106 | vt: VARTYPE, | |
107 | ) -> HRESULT; | |
108 | pub fn VariantChangeTypeEx( | |
109 | pvargDest: *mut VARIANTARG, | |
110 | pvarSrc: *const VARIANTARG, | |
111 | lcid: LCID, | |
112 | wFlags: USHORT, | |
113 | vt: VARTYPE, | |
114 | ) -> HRESULT; | |
115 | pub fn VarUI1FromI2( | |
116 | sIn: SHORT, | |
117 | pbOut: *mut BYTE, | |
118 | ); | |
119 | pub fn VarUI1FromI4( | |
120 | lIn: LONG, | |
121 | pbOut: *mut BYTE, | |
122 | ); | |
123 | pub fn VarUI1FromI8( | |
124 | i64In: LONG64, | |
125 | pbOut: *mut BYTE, | |
126 | ); | |
127 | pub fn VarUI1FromR4( | |
128 | fltIn: FLOAT, | |
129 | pbOut: *mut BYTE, | |
130 | ); | |
131 | pub fn VarUI1FromR8( | |
132 | dblIn: DOUBLE, | |
133 | pbOut: *mut BYTE, | |
134 | ); | |
135 | pub fn VarUI1FromDate( | |
136 | dateIn: DATE, | |
137 | pbOut: *mut BYTE, | |
138 | ); | |
139 | pub fn VarUI1FromStr( | |
140 | strIn: LPCOLESTR, | |
141 | lcid: LCID, | |
142 | dwFlags: ULONG, | |
143 | pbOut: *mut BYTE, | |
144 | ); | |
145 | pub fn VarUI1FromI1( | |
146 | cIn: CHAR, | |
147 | pbOut: *mut BYTE, | |
148 | ); | |
149 | pub fn VarUI1FromUI2( | |
150 | uiIn: USHORT, | |
151 | pbOut: *mut BYTE, | |
152 | ); | |
153 | pub fn VarUI1FromUI4( | |
154 | ulIn: ULONG, | |
155 | pbOut: *mut BYTE, | |
156 | ); | |
157 | pub fn VarUI1FromUI8( | |
158 | ui64In: ULONG64, | |
159 | pbOut: *mut BYTE, | |
160 | ); | |
161 | pub fn VarUI1FromDec( | |
162 | pdecIn: *const DECIMAL, | |
163 | pbOut: *mut BYTE, | |
164 | ); | |
165 | pub fn VarI2FromUI1( | |
166 | bIn: BYTE, | |
167 | psOut: *mut SHORT, | |
168 | ); | |
169 | pub fn VarI2FromI4( | |
170 | lIn: LONG, | |
171 | psOut: *mut SHORT, | |
172 | ); | |
173 | pub fn VarI2FromI8( | |
174 | i64In: LONG64, | |
175 | psOut: *mut SHORT, | |
176 | ); | |
177 | pub fn VarI2FromR4( | |
178 | fltIn: FLOAT, | |
179 | psOut: *mut SHORT, | |
180 | ); | |
181 | pub fn VarI2FromR8( | |
182 | dblIn: DOUBLE, | |
183 | psOut: *mut SHORT, | |
184 | ); | |
185 | pub fn VarI2FromDate( | |
186 | dateIn: DATE, | |
187 | psOut: *mut SHORT, | |
188 | ); | |
189 | pub fn VarI2FromStr( | |
190 | strIn: LPCOLESTR, | |
191 | lcid: LCID, | |
192 | dwFlags: ULONG, | |
193 | psOut: *mut SHORT, | |
194 | ); | |
195 | pub fn VarI2FromI1( | |
196 | cIn: CHAR, | |
197 | psOut: *mut SHORT, | |
198 | ); | |
199 | pub fn VarI2FromUI2( | |
200 | uiIn: USHORT, | |
201 | psOut: *mut SHORT, | |
202 | ); | |
203 | pub fn VarI2FromUI4( | |
204 | ulIn: ULONG, | |
205 | psOut: *mut SHORT, | |
206 | ); | |
207 | pub fn VarI2FromUI8( | |
208 | ui64In: ULONG64, | |
209 | psOut: *mut SHORT, | |
210 | ); | |
211 | pub fn VarI2FromDec( | |
212 | pdecIn: *const DECIMAL, | |
213 | psOut: *mut SHORT, | |
214 | ); | |
215 | pub fn VarI4FromUI1( | |
216 | bIn: BYTE, | |
217 | plOut: *mut LONG, | |
218 | ); | |
219 | pub fn VarI4FromI2( | |
220 | sIn: SHORT, | |
221 | plOut: *mut LONG, | |
222 | ); | |
223 | pub fn VarI4FromI8( | |
224 | i64In: LONG64, | |
225 | plOut: *mut LONG, | |
226 | ); | |
227 | pub fn VarI4FromR4( | |
228 | fltIn: FLOAT, | |
229 | plOut: *mut LONG, | |
230 | ); | |
231 | pub fn VarI4FromR8( | |
232 | dblIn: DOUBLE, | |
233 | plOut: *mut LONG, | |
234 | ); | |
235 | pub fn VarI4FromDate( | |
236 | dateIn: DATE, | |
237 | plOut: *mut LONG, | |
238 | ); | |
239 | pub fn VarI4FromStr( | |
240 | strIn: LPCOLESTR, | |
241 | lcid: LCID, | |
242 | dwFlags: ULONG, | |
243 | plOut: *mut LONG, | |
244 | ); | |
245 | pub fn VarI4FromI1( | |
246 | cIn: CHAR, | |
247 | plOut: *mut LONG, | |
248 | ); | |
249 | pub fn VarI4FromUI2( | |
250 | uiIn: USHORT, | |
251 | plOut: *mut LONG, | |
252 | ); | |
253 | pub fn VarI4FromUI4( | |
254 | ulIn: ULONG, | |
255 | plOut: *mut LONG, | |
256 | ); | |
257 | pub fn VarI4FromUI8( | |
258 | ui64In: ULONG64, | |
259 | plOut: *mut LONG, | |
260 | ); | |
261 | pub fn VarI4FromDec( | |
262 | pdecIn: *const DECIMAL, | |
263 | plOut: *mut LONG, | |
264 | ); | |
265 | pub fn VarI8FromUI1( | |
266 | bIn: BYTE, | |
267 | pi64Out: *mut LONG64, | |
268 | ); | |
269 | pub fn VarI8FromI2( | |
270 | sIn: SHORT, | |
271 | pi64Out: *mut LONG64, | |
272 | ); | |
273 | pub fn VarI8FromR4( | |
274 | fltIn: FLOAT, | |
275 | pi64Out: *mut LONG64, | |
276 | ); | |
277 | pub fn VarI8FromR8( | |
278 | dblIn: DOUBLE, | |
279 | pi64Out: *mut LONG64, | |
280 | ); | |
281 | pub fn VarI8FromDate( | |
282 | dateIn: DATE, | |
283 | pi64Out: *mut LONG64, | |
284 | ); | |
285 | pub fn VarI8FromStr( | |
286 | strIn: LPCOLESTR, | |
287 | lcid: LCID, | |
288 | dwFlags: ULONG, | |
289 | pi64Out: *mut LONG64, | |
290 | ); | |
291 | pub fn VarI8FromI1( | |
292 | cIn: CHAR, | |
293 | pi64Out: *mut LONG64, | |
294 | ); | |
295 | pub fn VarI8FromUI2( | |
296 | uiIn: USHORT, | |
297 | pi64Out: *mut LONG64, | |
298 | ); | |
299 | pub fn VarI8FromUI4( | |
300 | ulIn: ULONG, | |
301 | pi64Out: *mut LONG64, | |
302 | ); | |
303 | pub fn VarI8FromUI8( | |
304 | ui64In: ULONG64, | |
305 | pi64Out: *mut LONG64, | |
306 | ); | |
307 | pub fn VarI8FromDec( | |
308 | pdecIn: *const DECIMAL, | |
309 | pi64Out: *mut LONG64, | |
310 | ); | |
311 | pub fn VarR4FromUI1( | |
312 | bIn: BYTE, | |
313 | pfltOut: *mut FLOAT, | |
314 | ); | |
315 | pub fn VarR4FromI2( | |
316 | sIn: SHORT, | |
317 | pfltOut: *mut FLOAT, | |
318 | ); | |
319 | pub fn VarR4FromI4( | |
320 | lIn: LONG, | |
321 | pfltOut: *mut FLOAT, | |
322 | ); | |
323 | pub fn VarR4FromI8( | |
324 | i64In: LONG64, | |
325 | pfltOut: *mut FLOAT, | |
326 | ); | |
327 | pub fn VarR4FromR8( | |
328 | dblIn: DOUBLE, | |
329 | pfltOut: *mut FLOAT, | |
330 | ); | |
331 | pub fn VarR4FromDate( | |
332 | dateIn: DATE, | |
333 | pfltOut: *mut FLOAT, | |
334 | ); | |
335 | pub fn VarR4FromStr( | |
336 | strIn: LPCOLESTR, | |
337 | lcid: LCID, | |
338 | dwFlags: ULONG, | |
339 | pfltOut: *mut FLOAT, | |
340 | ); | |
341 | pub fn VarR4FromI1( | |
342 | cIn: CHAR, | |
343 | pfltOut: *mut FLOAT, | |
344 | ); | |
345 | pub fn VarR4FromUI2( | |
346 | uiIn: USHORT, | |
347 | pfltOut: *mut FLOAT, | |
348 | ); | |
349 | pub fn VarR4FromUI4( | |
350 | ulIn: ULONG, | |
351 | pfltOut: *mut FLOAT, | |
352 | ); | |
353 | pub fn VarR4FromUI8( | |
354 | ui64In: ULONG64, | |
355 | pfltOut: *mut FLOAT, | |
356 | ); | |
357 | pub fn VarR4FromDec( | |
358 | pdecIn: *const DECIMAL, | |
359 | pfltOut: *mut FLOAT, | |
360 | ); | |
361 | pub fn VarR8FromUI1( | |
362 | bIn: BYTE, | |
363 | pdblOut: *mut DOUBLE, | |
364 | ); | |
365 | pub fn VarR8FromI2( | |
366 | sIn: SHORT, | |
367 | pdblOut: *mut DOUBLE, | |
368 | ); | |
369 | pub fn VarR8FromI4( | |
370 | lIn: LONG, | |
371 | pdblOut: *mut DOUBLE, | |
372 | ); | |
373 | pub fn VarR8FromI8( | |
374 | i64In: LONG64, | |
375 | pdblOut: *mut DOUBLE, | |
376 | ); | |
377 | pub fn VarR8FromR4( | |
378 | fltIn: FLOAT, | |
379 | pdblOut: *mut DOUBLE, | |
380 | ); | |
381 | pub fn VarR8FromDate( | |
382 | dateIn: DATE, | |
383 | pdblOut: *mut DOUBLE, | |
384 | ); | |
385 | pub fn VarR8FromStr( | |
386 | strIn: LPCOLESTR, | |
387 | lcid: LCID, | |
388 | dwFlags: ULONG, | |
389 | pdblOut: *mut DOUBLE, | |
390 | ); | |
391 | pub fn VarR8FromI1( | |
392 | cIn: CHAR, | |
393 | pdblOut: *mut DOUBLE, | |
394 | ); | |
395 | pub fn VarR8FromUI2( | |
396 | uiIn: USHORT, | |
397 | pdblOut: *mut DOUBLE, | |
398 | ); | |
399 | pub fn VarR8FromUI4( | |
400 | ulIn: ULONG, | |
401 | pdblOut: *mut DOUBLE, | |
402 | ); | |
403 | pub fn VarR8FromUI8( | |
404 | ui64In: ULONG64, | |
405 | pdblOut: *mut DOUBLE, | |
406 | ); | |
407 | pub fn VarR8FromDec( | |
408 | pdecIn: *const DECIMAL, | |
409 | pdblOut: *mut DOUBLE, | |
410 | ); | |
411 | pub fn VarDateFromUI1( | |
412 | bIn: BYTE, | |
413 | pdateOut: *mut DATE, | |
414 | ); | |
415 | pub fn VarDateFromI2( | |
416 | sIn: SHORT, | |
417 | pdateOut: *mut DATE, | |
418 | ); | |
419 | pub fn VarDateFromI4( | |
420 | lIn: LONG, | |
421 | pdateOut: *mut DATE, | |
422 | ); | |
423 | pub fn VarDateFromI8( | |
424 | i64In: LONG64, | |
425 | pdateOut: *mut DATE, | |
426 | ); | |
427 | pub fn VarDateFromR4( | |
428 | fltIn: FLOAT, | |
429 | pdateOut: *mut DATE, | |
430 | ); | |
431 | pub fn VarDateFromR8( | |
432 | dblIn: DOUBLE, | |
433 | pdateOut: *mut DATE, | |
434 | ); | |
435 | pub fn VarDateFromStr( | |
436 | strIn: LPCOLESTR, | |
437 | lcid: LCID, | |
438 | dwFlags: ULONG, | |
439 | pdateOut: *mut DATE, | |
440 | ); | |
441 | pub fn VarDateFromI1( | |
442 | cIn: CHAR, | |
443 | pdateOut: *mut DATE, | |
444 | ); | |
445 | pub fn VarDateFromUI2( | |
446 | uiIn: USHORT, | |
447 | pdateOut: *mut DATE, | |
448 | ); | |
449 | pub fn VarDateFromUI4( | |
450 | ulIn: ULONG, | |
451 | pdateOut: *mut DATE, | |
452 | ); | |
453 | pub fn VarDateFromUI8( | |
454 | ui64In: ULONG64, | |
455 | pdateOut: *mut DATE, | |
456 | ); | |
457 | pub fn VarDateFromDec( | |
458 | pdecIn: *const DECIMAL, | |
459 | pdateOut: *mut DATE, | |
460 | ); | |
461 | pub fn VarBstrFromUI1( | |
462 | bVal: BYTE, | |
463 | lcid: LCID, | |
464 | dwFlags: ULONG, | |
465 | pbstrOut: *mut BSTR, | |
466 | ); | |
467 | pub fn VarBstrFromI2( | |
468 | iVal: SHORT, | |
469 | lcid: LCID, | |
470 | dwFlags: ULONG, | |
471 | pbstrOut: *mut BSTR, | |
472 | ); | |
473 | pub fn VarBstrFromI4( | |
474 | lIn: LONG, | |
475 | lcid: LCID, | |
476 | dwFlags: ULONG, | |
477 | pbstrOut: *mut BSTR, | |
478 | ); | |
479 | pub fn VarBstrFromI8( | |
480 | i64In: LONG64, | |
481 | lcid: LCID, | |
482 | dwFlags: ULONG, | |
483 | pbstrOut: *mut BSTR, | |
484 | ); | |
485 | pub fn VarBstrFromR4( | |
486 | fltIn: FLOAT, | |
487 | lcid: LCID, | |
488 | dwFlags: ULONG, | |
489 | pbstrOut: *mut BSTR, | |
490 | ); | |
491 | pub fn VarBstrFromR8( | |
492 | dblIn: DOUBLE, | |
493 | lcid: LCID, | |
494 | dwFlags: ULONG, | |
495 | pbstrOut: *mut BSTR, | |
496 | ); | |
497 | pub fn VarBstrFromDate( | |
498 | dateIn: DATE, | |
499 | lcid: LCID, | |
500 | dwFlags: ULONG, | |
501 | pbstrOut: *mut BSTR, | |
502 | ); | |
503 | pub fn VarBstrFromI1( | |
504 | cIn: CHAR, | |
505 | lcid: LCID, | |
506 | dwFlags: ULONG, | |
507 | pbstrOut: *mut BSTR, | |
508 | ); | |
509 | pub fn VarBstrFromUI2( | |
510 | uiIn: USHORT, | |
511 | lcid: LCID, | |
512 | dwFlags: ULONG, | |
513 | pbstrOut: *mut BSTR, | |
514 | ); | |
515 | pub fn VarBstrFromUI4( | |
516 | ulIn: ULONG, | |
517 | lcid: LCID, | |
518 | dwFlags: ULONG, | |
519 | pbstrOut: *mut BSTR, | |
520 | ); | |
521 | pub fn VarBstrFromUI8( | |
522 | ui64In: ULONG64, | |
523 | lcid: LCID, | |
524 | dwFlags: ULONG, | |
525 | pbstrOut: *mut BSTR, | |
526 | ); | |
527 | pub fn VarBstrFromDec( | |
528 | pdecIn: *const DECIMAL, | |
529 | lcid: LCID, | |
530 | dwFlags: ULONG, | |
531 | pbstrOut: *mut BSTR, | |
532 | ); | |
533 | pub fn VarUI2FromUI1( | |
534 | bIn: BYTE, | |
535 | puiOut: *mut USHORT, | |
536 | ); | |
537 | pub fn VarUI2FromI2( | |
538 | uiIn: SHORT, | |
539 | puiOut: *mut USHORT, | |
540 | ); | |
541 | pub fn VarUI2FromI4( | |
542 | lIn: LONG, | |
543 | puiOut: *mut USHORT, | |
544 | ); | |
545 | pub fn VarUI2FromI8( | |
546 | i64In: LONG64, | |
547 | puiOut: *mut USHORT, | |
548 | ); | |
549 | pub fn VarUI2FromR4( | |
550 | fltIn: FLOAT, | |
551 | puiOut: *mut USHORT, | |
552 | ); | |
553 | pub fn VarUI2FromR8( | |
554 | dblIn: DOUBLE, | |
555 | puiOut: *mut USHORT, | |
556 | ); | |
557 | pub fn VarUI2FromDate( | |
558 | dateIn: DATE, | |
559 | puiOut: *mut USHORT, | |
560 | ); | |
561 | pub fn VarUI2FromStr( | |
562 | strIn: LPCOLESTR, | |
563 | lcid: LCID, | |
564 | dwFlags: ULONG, | |
565 | puiOut: *mut USHORT, | |
566 | ); | |
567 | pub fn VarUI2FromI1( | |
568 | cIn: CHAR, | |
569 | puiOut: *mut USHORT, | |
570 | ); | |
571 | pub fn VarUI2FromUI4( | |
572 | ulIn: ULONG, | |
573 | puiOut: *mut USHORT, | |
574 | ); | |
575 | pub fn VarUI2FromUI8( | |
576 | i64In: ULONG64, | |
577 | puiOut: *mut USHORT, | |
578 | ); | |
579 | pub fn VarUI2FromDec( | |
580 | pdecIn: *const DECIMAL, | |
581 | puiOut: *mut USHORT, | |
582 | ); | |
583 | pub fn VarUI4FromUI1( | |
584 | bIn: BYTE, | |
585 | pulOut: *mut ULONG, | |
586 | ); | |
587 | pub fn VarUI4FromI2( | |
588 | uiIn: SHORT, | |
589 | pulOut: *mut ULONG, | |
590 | ); | |
591 | pub fn VarUI4FromI4( | |
592 | lIn: LONG, | |
593 | pulOut: *mut ULONG, | |
594 | ); | |
595 | pub fn VarUI4FromI8( | |
596 | i64In: LONG64, | |
597 | plOut: *mut ULONG, | |
598 | ); | |
599 | pub fn VarUI4FromR4( | |
600 | fltIn: FLOAT, | |
601 | pulOut: *mut ULONG, | |
602 | ); | |
603 | pub fn VarUI4FromR8( | |
604 | dblIn: DOUBLE, | |
605 | pulOut: *mut ULONG, | |
606 | ); | |
607 | pub fn VarUI4FromDate( | |
608 | dateIn: DATE, | |
609 | pulOut: *mut ULONG, | |
610 | ); | |
611 | pub fn VarUI4FromStr( | |
612 | strIn: LPCOLESTR, | |
613 | lcid: LCID, | |
614 | dwFlags: ULONG, | |
615 | pulOut: *mut ULONG, | |
616 | ); | |
617 | pub fn VarUI4FromI1( | |
618 | cIn: CHAR, | |
619 | pulOut: *mut ULONG, | |
620 | ); | |
621 | pub fn VarUI4FromUI2( | |
622 | uiIn: USHORT, | |
623 | pulOut: *mut ULONG, | |
624 | ); | |
625 | pub fn VarUI4FromUI8( | |
626 | ui64In: ULONG64, | |
627 | plOut: *mut ULONG, | |
628 | ); | |
629 | pub fn VarUI4FromDec( | |
630 | pdecIn: *const DECIMAL, | |
631 | pulOut: *mut ULONG, | |
632 | ); | |
633 | pub fn VarUI8FromUI1( | |
634 | bIn: BYTE, | |
635 | pi64Out: *mut ULONG64, | |
636 | ); | |
637 | pub fn VarUI8FromI2( | |
638 | sIn: SHORT, | |
639 | pi64Out: *mut ULONG64, | |
640 | ); | |
641 | pub fn VarUI8FromI4( | |
642 | lIn: LONG, | |
643 | pi64Out: *mut ULONG64, | |
644 | ); | |
645 | pub fn VarUI8FromI8( | |
646 | ui64In: LONG64, | |
647 | pi64Out: *mut ULONG64, | |
648 | ); | |
649 | pub fn VarUI8FromR4( | |
650 | fltIn: FLOAT, | |
651 | pi64Out: *mut ULONG64, | |
652 | ); | |
653 | pub fn VarUI8FromR8( | |
654 | dblIn: DOUBLE, | |
655 | pi64Out: *mut ULONG64, | |
656 | ); | |
657 | pub fn VarUI8FromDate( | |
658 | dateIn: DATE, | |
659 | pi64Out: *mut ULONG64, | |
660 | ); | |
661 | pub fn VarUI8FromStr( | |
662 | strIn: LPCOLESTR, | |
663 | lcid: LCID, | |
664 | dwFlags: ULONG, | |
665 | pi64Out: *mut ULONG64, | |
666 | ); | |
667 | pub fn VarUI8FromI1( | |
668 | cIn: CHAR, | |
669 | pi64Out: *mut ULONG64, | |
670 | ); | |
671 | pub fn VarUI8FromUI2( | |
672 | uiIn: USHORT, | |
673 | pi64Out: *mut ULONG64, | |
674 | ); | |
675 | pub fn VarUI8FromUI4( | |
676 | ulIn: ULONG, | |
677 | pi64Out: *mut ULONG64, | |
678 | ); | |
679 | pub fn VarUI8FromDec( | |
680 | pdecIn: *const DECIMAL, | |
681 | pi64Out: *mut ULONG64, | |
682 | ); | |
683 | pub fn VarDecFromUI1( | |
684 | bIn: BYTE, | |
685 | pdecOut: *mut DECIMAL, | |
686 | ); | |
687 | pub fn VarDecFromI2( | |
688 | uiIn: SHORT, | |
689 | pdecOut: *mut DECIMAL, | |
690 | ); | |
691 | pub fn VarDecFromI4( | |
692 | lIn: LONG, | |
693 | pdecOut: *mut DECIMAL, | |
694 | ); | |
695 | pub fn VarDecFromI8( | |
696 | i64In: LONG64, | |
697 | pdecOut: *mut DECIMAL, | |
698 | ); | |
699 | pub fn VarDecFromR4( | |
700 | fltIn: FLOAT, | |
701 | pdecOut: *mut DECIMAL, | |
702 | ); | |
703 | pub fn VarDecFromR8( | |
704 | dblIn: DOUBLE, | |
705 | pdecOut: *mut DECIMAL, | |
706 | ); | |
707 | pub fn VarDecFromDate( | |
708 | dateIn: DATE, | |
709 | pdecOut: *mut DECIMAL, | |
710 | ); | |
711 | pub fn VarDecFromStr( | |
712 | strIn: LPCOLESTR, | |
713 | lcid: LCID, | |
714 | dwFlags: ULONG, | |
715 | pdecOut: *mut DECIMAL, | |
716 | ); | |
717 | pub fn VarDecFromI1( | |
718 | cIn: CHAR, | |
719 | pdecOut: *mut DECIMAL, | |
720 | ); | |
721 | pub fn VarDecFromUI2( | |
722 | uiIn: USHORT, | |
723 | pdecOut: *mut DECIMAL, | |
724 | ); | |
725 | pub fn VarDecFromUI4( | |
726 | ulIn: ULONG, | |
727 | pdecOut: *mut DECIMAL, | |
728 | ); | |
729 | pub fn VarDecFromUI8( | |
730 | ui64In: ULONG64, | |
731 | pdecOut: *mut DECIMAL, | |
732 | ); | |
733 | pub fn VarDecAdd( | |
734 | pdecLeft: LPDECIMAL, | |
735 | pdecRight: LPDECIMAL, | |
736 | pdecResult: LPDECIMAL, | |
737 | ); | |
738 | pub fn VarDecDiv( | |
739 | pdecLeft: LPDECIMAL, | |
740 | pdecRight: LPDECIMAL, | |
741 | pdecResult: LPDECIMAL, | |
742 | ); | |
743 | pub fn VarDecMul( | |
744 | pdecLeft: LPDECIMAL, | |
745 | pdecRight: LPDECIMAL, | |
746 | pdecResult: LPDECIMAL, | |
747 | ); | |
748 | pub fn VarDecSub( | |
749 | pdecLeft: LPDECIMAL, | |
750 | pdecRight: LPDECIMAL, | |
751 | pdecResult: LPDECIMAL, | |
752 | ); | |
753 | pub fn VarDecAbs( | |
754 | pdecIn: LPDECIMAL, | |
755 | pdecResult: LPDECIMAL, | |
756 | ); | |
757 | pub fn VarDecFix( | |
758 | pdecIn: LPDECIMAL, | |
759 | pdecResult: LPDECIMAL, | |
760 | ); | |
761 | pub fn VarDecInt( | |
762 | pdecIn: LPDECIMAL, | |
763 | pdecResult: LPDECIMAL, | |
764 | ); | |
765 | pub fn VarDecNeg( | |
766 | pdecIn: LPDECIMAL, | |
767 | pdecResult: LPDECIMAL, | |
768 | ); | |
769 | pub fn VarDecRound( | |
770 | pdecIn: LPDECIMAL, | |
771 | cDecimals: c_int, | |
772 | pdecResult: LPDECIMAL, | |
773 | ); | |
774 | pub fn VarDecCmp( | |
775 | pdecLeft: LPDECIMAL, | |
776 | pdecRight: LPDECIMAL, | |
777 | ); | |
778 | pub fn VarDecCmpR8( | |
779 | pdecLeft: LPDECIMAL, | |
780 | dblRight: c_double, | |
781 | ); | |
782 | pub fn VarBstrCat( | |
783 | bstrLeft: BSTR, | |
784 | bstrRight: BSTR, | |
785 | pbstrResult: LPBSTR, | |
786 | ); | |
787 | pub fn VarBstrCmp( | |
788 | bstrLeft: BSTR, | |
789 | bstrRight: BSTR, | |
790 | lcid: LCID, | |
791 | dwFlags: ULONG, | |
792 | ); | |
793 | pub fn VarR8Pow( | |
794 | dblLeft: c_double, | |
795 | dblRight: c_double, | |
796 | pdblResult: *mut c_double, | |
797 | ); | |
798 | pub fn VarR4CmpR8( | |
799 | fltLeft: c_float, | |
800 | dblRight: c_double, | |
801 | ); | |
802 | pub fn VarR8Round( | |
803 | dblIn: c_double, | |
804 | cDecimals: c_int, | |
805 | pdblResult: *mut c_double, | |
806 | ); | |
807 | pub fn GetAltMonthNames( | |
808 | lcid: LCID, | |
809 | prgp: *mut LPOLESTR, | |
810 | ); | |
811 | } | |
812 | pub type DISPID = LONG; | |
813 | pub type MEMBERID = DISPID; | |
814 | pub const MEMBERID_NIL: MEMBERID = DISPID_UNKNOWN; | |
815 | pub const DISPATCH_METHOD: WORD = 0x1; | |
816 | pub const DISPATCH_PROPERTYGET: WORD = 0x2; | |
817 | pub const DISPATCH_PROPERTYPUT: WORD = 0x4; | |
818 | pub const DISPATCH_PROPERTYPUTREF: WORD = 0x8; | |
819 | ENUM!{enum REGKIND { | |
820 | REGKIND_DEFAULT = 0, | |
821 | REGKIND_REGISTER, | |
822 | REGKIND_NONE, | |
823 | }} | |
824 | extern "system" { | |
825 | pub fn LoadTypeLibEx( | |
826 | szFile: LPCOLESTR, | |
827 | regkind: REGKIND, | |
828 | pptlib: *mut *mut ITypeLib, | |
829 | ) -> HRESULT; | |
830 | pub fn RevokeActiveObject( | |
831 | dwRegister: DWORD, | |
832 | pvReserved: *mut c_void, | |
833 | ); | |
834 | pub fn OaBuildVersion() -> ULONG; | |
835 | pub fn OaEnablePerUserTLibRegistration(); | |
836 | } |