?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d2d1: Implement d2d_bitmap_brush_GetTransform().
[wine.git] / dlls / vbscript / global.c
blobbbbe22c9005610c900a6fbe10479f8f1cdd471eb
1 /*
2 * Copyright 2011 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <assert.h>
20 #include <math.h>
21
22 #include "vbscript.h"
23 #include "vbscript_defs.h"
24
25 #include "mshtmhst.h"
26 #include "objsafe.h"
27
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
31
32 #define VB_E_CANNOT_CREATE_OBJ 0x800a01ad
33 #define VB_E_MK_PARSE_ERROR 0x800a01b0
34
35 /* Defined as extern in urlmon.idl, but not exported by uuid.lib */
36 const GUID GUID_CUSTOM_CONFIRMOBJECTSAFETY =
37 {0x10200490,0xfa38,0x11d0,{0xac,0x0e,0x00,0xa0,0xc9,0xf,0xff,0xc0}};
38
39 static const WCHAR emptyW[] = {0};
40 static const WCHAR vbscriptW[] = {'V','B','S','c','r','i','p','t',0};
41
42 static IInternetHostSecurityManager *get_sec_mgr(script_ctx_t *ctx)
43 {
44 IInternetHostSecurityManager *secmgr;
45 IServiceProvider *sp;
46 HRESULT hres;
47
48 if(!ctx->site)
49 return NULL;
50
51 if(ctx->secmgr)
52 return ctx->secmgr;
53
54 hres = IActiveScriptSite_QueryInterface(ctx->site, &IID_IServiceProvider, (void**)&sp);
55 if(FAILED(hres))
56 return NULL;
57
58 hres = IServiceProvider_QueryService(sp, &SID_SInternetHostSecurityManager, &IID_IInternetHostSecurityManager,
59 (void**)&secmgr);
60 IServiceProvider_Release(sp);
61 if(FAILED(hres))
62 return NULL;
63
64 return ctx->secmgr = secmgr;
65 }
66
67 static HRESULT return_string(VARIANT *res, const WCHAR *str)
68 {
69 BSTR ret;
70
71 if(!res)
72 return S_OK;
73
74 ret = SysAllocString(str);
75 if(!ret)
76 return E_OUTOFMEMORY;
77
78 V_VT(res) = VT_BSTR;
79 V_BSTR(res) = ret;
80 return S_OK;
81 }
82
83 static HRESULT return_bstr(VARIANT *res, BSTR str)
84 {
85 if(res) {
86 V_VT(res) = VT_BSTR;
87 V_BSTR(res) = str;
88 }else {
89 SysFreeString(str);
90 }
91 return S_OK;
92 }
93
94 static HRESULT return_bool(VARIANT *res, BOOL val)
95 {
96 if(res) {
97 V_VT(res) = VT_BOOL;
98 V_BOOL(res) = val ? VARIANT_TRUE : VARIANT_FALSE;
99 }
100 return S_OK;
101 }
102
103 static HRESULT return_short(VARIANT *res, short val)
104 {
105 if(res) {
106 V_VT(res) = VT_I2;
107 V_I2(res) = val;
108 }
109
110 return S_OK;
111 }
112
113 static HRESULT return_int(VARIANT *res, int val)
114 {
115 if(res) {
116 V_VT(res) = VT_I4;
117 V_I4(res) = val;
118 }
119
120 return S_OK;
121 }
122
123 static inline HRESULT return_double(VARIANT *res, double val)
124 {
125 if(res) {
126 V_VT(res) = VT_R8;
127 V_R8(res) = val;
128 }
129
130 return S_OK;
131 }
132
133 static inline HRESULT return_float(VARIANT *res, float val)
134 {
135 if(res) {
136 V_VT(res) = VT_R4;
137 V_R4(res) = val;
138 }
139
140 return S_OK;
141 }
142
143 static inline HRESULT return_null(VARIANT *res)
144 {
145 if(res)
146 V_VT(res) = VT_NULL;
147 return S_OK;
148 }
149
150 static inline HRESULT return_date(VARIANT *res, double date)
151 {
152 if(res) {
153 V_VT(res) = VT_DATE;
154 V_DATE(res) = date;
155 }
156 return S_OK;
157 }
158
159 HRESULT to_int(VARIANT *v, int *ret)
160 {
161 VARIANT r;
162 HRESULT hres;
163
164 V_VT(&r) = VT_EMPTY;
165 hres = VariantChangeType(&r, v, 0, VT_I4);
166 if(FAILED(hres))
167 return hres;
168
169 *ret = V_I4(&r);
170 return S_OK;
171 }
172
173 static HRESULT to_double(VARIANT *v, double *ret)
174 {
175 VARIANT dst;
176 HRESULT hres;
177
178 V_VT(&dst) = VT_EMPTY;
179 hres = VariantChangeType(&dst, v, 0, VT_R8);
180 if(FAILED(hres))
181 return hres;
182
183 *ret = V_R8(&dst);
184 return S_OK;
185 }
186
187 static HRESULT to_string(VARIANT *v, BSTR *ret)
188 {
189 VARIANT dst;
190 HRESULT hres;
191
192 V_VT(&dst) = VT_EMPTY;
193 hres = VariantChangeType(&dst, v, VARIANT_LOCALBOOL, VT_BSTR);
194 if(FAILED(hres))
195 return hres;
196
197 *ret = V_BSTR(&dst);
198 return S_OK;
199 }
200
201 static HRESULT set_object_site(script_ctx_t *ctx, IUnknown *obj)
202 {
203 IObjectWithSite *obj_site;
204 IUnknown *ax_site;
205 HRESULT hres;
206
207 hres = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (void**)&obj_site);
208 if(FAILED(hres))
209 return S_OK;
210
211 ax_site = create_ax_site(ctx);
212 if(ax_site)
213 hres = IObjectWithSite_SetSite(obj_site, ax_site);
214 else
215 hres = E_OUTOFMEMORY;
216 IUnknown_Release(ax_site);
217 IObjectWithSite_Release(obj_site);
218 return hres;
219 }
220
221 static IUnknown *create_object(script_ctx_t *ctx, const WCHAR *progid)
222 {
223 IInternetHostSecurityManager *secmgr = NULL;
224 struct CONFIRMSAFETY cs;
225 IClassFactoryEx *cfex;
226 IClassFactory *cf;
227 DWORD policy_size;
228 BYTE *bpolicy;
229 IUnknown *obj;
230 DWORD policy;
231 GUID guid;
232 HRESULT hres;
233
234 hres = CLSIDFromProgID(progid, &guid);
235 if(FAILED(hres))
236 return NULL;
237
238 TRACE("GUID %s\n", debugstr_guid(&guid));
239
240 if(ctx->safeopt & INTERFACE_USES_SECURITY_MANAGER) {
241 secmgr = get_sec_mgr(ctx);
242 if(!secmgr)
243 return NULL;
244
245 policy = 0;
246 hres = IInternetHostSecurityManager_ProcessUrlAction(secmgr, URLACTION_ACTIVEX_RUN,
247 (BYTE*)&policy, sizeof(policy), (BYTE*)&guid, sizeof(GUID), 0, 0);
248 if(FAILED(hres) || policy != URLPOLICY_ALLOW)
249 return NULL;
250 }
251
252 hres = CoGetClassObject(&guid, CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER, NULL, &IID_IClassFactory, (void**)&cf);
253 if(FAILED(hres))
254 return NULL;
255
256 hres = IClassFactory_QueryInterface(cf, &IID_IClassFactoryEx, (void**)&cfex);
257 if(SUCCEEDED(hres)) {
258 FIXME("Use IClassFactoryEx\n");
259 IClassFactoryEx_Release(cfex);
260 }
261
262 hres = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void**)&obj);
263 if(FAILED(hres))
264 return NULL;
265
266 if(secmgr) {
267 cs.clsid = guid;
268 cs.pUnk = obj;
269 cs.dwFlags = 0;
270 hres = IInternetHostSecurityManager_QueryCustomPolicy(secmgr, &GUID_CUSTOM_CONFIRMOBJECTSAFETY,
271 &bpolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);
272 if(SUCCEEDED(hres)) {
273 policy = policy_size >= sizeof(DWORD) ? *(DWORD*)bpolicy : URLPOLICY_DISALLOW;
274 CoTaskMemFree(bpolicy);
275 }
276
277 if(FAILED(hres) || policy != URLPOLICY_ALLOW) {
278 IUnknown_Release(obj);
279 return NULL;
280 }
281 }
282
283 hres = set_object_site(ctx, obj);
284 if(FAILED(hres)) {
285 IUnknown_Release(obj);
286 return NULL;
287 }
288
289 return obj;
290 }
291
292 static HRESULT show_msgbox(script_ctx_t *ctx, BSTR prompt, unsigned type, BSTR orig_title, VARIANT *res)
293 {
294 SCRIPTUICHANDLING uic_handling = SCRIPTUICHANDLING_ALLOW;
295 IActiveScriptSiteUIControl *ui_control;
296 IActiveScriptSiteWindow *acts_window;
297 WCHAR *title_buf = NULL;
298 const WCHAR *title;
299 HWND hwnd = NULL;
300 int ret = 0;
301 HRESULT hres;
302
303 hres = IActiveScriptSite_QueryInterface(ctx->site, &IID_IActiveScriptSiteUIControl, (void**)&ui_control);
304 if(SUCCEEDED(hres)) {
305 hres = IActiveScriptSiteUIControl_GetUIBehavior(ui_control, SCRIPTUICITEM_MSGBOX, &uic_handling);
306 IActiveScriptSiteUIControl_Release(ui_control);
307 if(FAILED(hres))
308 uic_handling = SCRIPTUICHANDLING_ALLOW;
309 }
310
311 switch(uic_handling) {
312 case SCRIPTUICHANDLING_ALLOW:
313 break;
314 case SCRIPTUICHANDLING_NOUIDEFAULT:
315 return return_short(res, 0);
316 default:
317 FIXME("blocked\n");
318 return E_FAIL;
319 }
320
321 hres = IActiveScriptSite_QueryInterface(ctx->site, &IID_IActiveScriptSiteWindow, (void**)&acts_window);
322 if(FAILED(hres)) {
323 FIXME("No IActiveScriptSiteWindow\n");
324 return hres;
325 }
326
327 if(ctx->safeopt & INTERFACE_USES_SECURITY_MANAGER) {
328 if(orig_title && *orig_title) {
329 WCHAR *ptr;
330
331 title = title_buf = heap_alloc(sizeof(vbscriptW) + (strlenW(orig_title)+2)*sizeof(WCHAR));
332 if(!title)
333 return E_OUTOFMEMORY;
334
335 memcpy(title_buf, vbscriptW, sizeof(vbscriptW));
336 ptr = title_buf + sizeof(vbscriptW)/sizeof(WCHAR)-1;
337
338 *ptr++ = ':';
339 *ptr++ = ' ';
340 strcpyW(ptr, orig_title);
341 }else {
342 title = vbscriptW;
343 }
344 }else {
345 title = orig_title ? orig_title : emptyW;
346 }
347
348 hres = IActiveScriptSiteWindow_GetWindow(acts_window, &hwnd);
349 if(SUCCEEDED(hres)) {
350 hres = IActiveScriptSiteWindow_EnableModeless(acts_window, FALSE);
351 if(SUCCEEDED(hres)) {
352 ret = MessageBoxW(hwnd, prompt, title, type);
353 hres = IActiveScriptSiteWindow_EnableModeless(acts_window, TRUE);
354 }
355 }
356
357 heap_free(title_buf);
358 IActiveScriptSiteWindow_Release(acts_window);
359 if(FAILED(hres)) {
360 FIXME("failed: %08x\n", hres);
361 return hres;
362 }
363
364 return return_short(res, ret);
365 }
366
367 static HRESULT Global_CCur(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
368 {
369 VARIANT v;
370 HRESULT hres;
371
372 TRACE("%s\n", debugstr_variant(arg));
373
374 assert(args_cnt == 1);
375
376 V_VT(&v) = VT_EMPTY;
377 hres = VariantChangeType(&v, arg, 0, VT_CY);
378 if(FAILED(hres))
379 return hres;
380
381 if(!res) {
382 VariantClear(&v);
383 return DISP_E_BADVARTYPE;
384 }
385
386 *res = v;
387 return S_OK;
388 }
389
390 static HRESULT Global_CInt(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
391 {
392 VARIANT v;
393 HRESULT hres;
394
395 TRACE("%s\n", debugstr_variant(arg));
396
397 assert(args_cnt == 1);
398
399 V_VT(&v) = VT_EMPTY;
400 hres = VariantChangeType(&v, arg, 0, VT_I2);
401 if(FAILED(hres))
402 return hres;
403
404 if(!res)
405 return DISP_E_BADVARTYPE;
406 else {
407 *res = v;
408 return S_OK;
409 }
410 }
411
412 static HRESULT Global_CLng(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
413 {
414 int i;
415 HRESULT hres;
416
417 TRACE("%s\n", debugstr_variant(arg));
418
419 assert(args_cnt == 1);
420
421 hres = to_int(arg, &i);
422 if(FAILED(hres))
423 return hres;
424 if(!res)
425 return DISP_E_BADVARTYPE;
426
427 return return_int(res, i);
428 }
429
430 static HRESULT Global_CBool(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
431 {
432 VARIANT v;
433 HRESULT hres;
434
435 TRACE("%s\n", debugstr_variant(arg));
436
437 assert(args_cnt == 1);
438
439 V_VT(&v) = VT_EMPTY;
440 hres = VariantChangeType(&v, arg, VARIANT_LOCALBOOL, VT_BOOL);
441 if(FAILED(hres))
442 return hres;
443
444 if(res)
445 *res = v;
446 else
447 VariantClear(&v);
448 return S_OK;
449 }
450
451 static HRESULT Global_CByte(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
452 {
453 VARIANT v;
454 HRESULT hres;
455
456 TRACE("%s\n", debugstr_variant(arg));
457
458 assert(args_cnt == 1);
459
460 V_VT(&v) = VT_EMPTY;
461 hres = VariantChangeType(&v, arg, VARIANT_LOCALBOOL, VT_UI1);
462 if(FAILED(hres))
463 return hres;
464
465 if(!res) {
466 VariantClear(&v);
467 return DISP_E_BADVARTYPE;
468 }
469
470 *res = v;
471 return S_OK;
472 }
473
474 static HRESULT Global_CDate(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
475 {
476 FIXME("\n");
477 return E_NOTIMPL;
478 }
479
480 static HRESULT Global_CDbl(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
481 {
482 VARIANT v;
483 HRESULT hres;
484
485 TRACE("%s\n", debugstr_variant(arg));
486
487 assert(args_cnt == 1);
488
489 V_VT(&v) = VT_EMPTY;
490 hres = VariantChangeType(&v, arg, 0, VT_R8);
491 if(FAILED(hres))
492 return hres;
493
494 if(!res)
495 return DISP_E_BADVARTYPE;
496 else {
497 *res = v;
498 return S_OK;
499 }
500 }
501
502 static HRESULT Global_CSng(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
503 {
504 VARIANT v;
505 HRESULT hres;
506
507 TRACE("%s\n", debugstr_variant(arg));
508
509 assert(args_cnt == 1);
510
511 V_VT(&v) = VT_EMPTY;
512 hres = VariantChangeType(&v, arg, 0, VT_R4);
513 if(FAILED(hres))
514 return hres;
515
516 if(!res)
517 return DISP_E_BADVARTYPE;
518
519 *res = v;
520 return S_OK;
521 }
522
523 static HRESULT Global_CStr(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
524 {
525 BSTR str;
526 HRESULT hres;
527
528 TRACE("%s\n", debugstr_variant(arg));
529
530 hres = to_string(arg, &str);
531 if(FAILED(hres))
532 return hres;
533
534 return return_bstr(res, str);
535 }
536
537 static inline WCHAR hex_char(unsigned n)
538 {
539 return n < 10 ? '0'+n : 'A'+n-10;
540 }
541
542 static HRESULT Global_Hex(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
543 {
544 WCHAR buf[17], *ptr;
545 DWORD n;
546
547 TRACE("%s\n", debugstr_variant(arg));
548
549 switch(V_VT(arg)) {
550 case VT_I2:
551 n = (WORD)V_I2(arg);
552 break;
553 case VT_I4:
554 n = V_I4(arg);
555 break;
556 case VT_EMPTY:
557 n = 0;
558 break;
559 case VT_NULL:
560 if(res)
561 V_VT(res) = VT_NULL;
562 return S_OK;
563 default:
564 FIXME("unsupported type %s\n", debugstr_variant(arg));
565 return E_NOTIMPL;
566 }
567
568 buf[16] = 0;
569 ptr = buf+15;
570
571 if(n) {
572 do {
573 *ptr-- = hex_char(n & 0xf);
574 n >>= 4;
575 }while(n);
576 ptr++;
577 }else {
578 *ptr = '0';
579 }
580
581 return return_string(res, ptr);
582 }
583
584 static HRESULT Global_Oct(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
585 {
586 FIXME("\n");
587 return E_NOTIMPL;
588 }
589
590 static HRESULT Global_VarType(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
591 {
592 TRACE("(%s)\n", debugstr_variant(arg));
593
594 assert(args_cnt == 1);
595
596 if(V_VT(arg) & ~VT_TYPEMASK) {
597 FIXME("not supported %s\n", debugstr_variant(arg));
598 return E_NOTIMPL;
599 }
600
601 return return_short(res, V_VT(arg));
602 }
603
604 static HRESULT Global_IsDate(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
605 {
606 FIXME("\n");
607 return E_NOTIMPL;
608 }
609
610 static HRESULT Global_IsEmpty(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
611 {
612 TRACE("(%s)\n", debugstr_variant(arg));
613
614 assert(args_cnt == 1);
615
616 if(res) {
617 V_VT(res) = VT_BOOL;
618 V_BOOL(res) = V_VT(arg) == VT_EMPTY ? VARIANT_TRUE : VARIANT_FALSE;
619 }
620 return S_OK;
621 }
622
623 static HRESULT Global_IsNull(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
624 {
625 TRACE("(%s)\n", debugstr_variant(arg));
626
627 assert(args_cnt == 1);
628
629 if(res) {
630 V_VT(res) = VT_BOOL;
631 V_BOOL(res) = V_VT(arg) == VT_NULL ? VARIANT_TRUE : VARIANT_FALSE;
632 }
633 return S_OK;
634 }
635
636 static HRESULT Global_IsNumeric(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
637 {
638 HRESULT hres;
639 double d;
640
641 TRACE("(%s)\n", debugstr_variant(arg));
642
643 assert(args_cnt == 1);
644
645 hres = to_double(arg, &d);
646
647 return return_bool(res, SUCCEEDED(hres));
648 }
649
650 static HRESULT Global_IsArray(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
651 {
652 FIXME("\n");
653 return E_NOTIMPL;
654 }
655
656 static HRESULT Global_IsObject(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
657 {
658 TRACE("(%s)\n", debugstr_variant(arg));
659
660 assert(args_cnt == 1);
661
662 if(res) {
663 V_VT(res) = VT_BOOL;
664 V_BOOL(res) = V_VT(arg) == VT_DISPATCH ? VARIANT_TRUE : VARIANT_FALSE;
665 }
666 return S_OK;
667 }
668
669 static HRESULT Global_Atn(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
670 {
671 HRESULT hres;
672 double d;
673
674 hres = to_double(arg, &d);
675 if(FAILED(hres))
676 return hres;
677
678 return return_double(res, atan(d));
679 }
680
681 static HRESULT Global_Cos(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
682 {
683 HRESULT hres;
684 double d;
685
686 hres = to_double(arg, &d);
687 if(FAILED(hres))
688 return hres;
689
690 return return_double(res, cos(d));
691 }
692
693 static HRESULT Global_Sin(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
694 {
695 HRESULT hres;
696 double d;
697
698 hres = to_double(arg, &d);
699 if(FAILED(hres))
700 return hres;
701
702 return return_double(res, sin(d));
703 }
704
705 static HRESULT Global_Tan(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
706 {
707 HRESULT hres;
708 double d;
709
710 hres = to_double(arg, &d);
711 if(FAILED(hres))
712 return hres;
713
714 return return_double(res, tan(d));
715 }
716
717 static HRESULT Global_Exp(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
718 {
719 HRESULT hres;
720 double d;
721
722 hres = to_double(arg, &d);
723 if(FAILED(hres))
724 return hres;
725
726 return return_double(res, exp(d));
727 }
728
729 static HRESULT Global_Log(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
730 {
731 HRESULT hres;
732 double d;
733
734 hres = to_double(arg, &d);
735 if(FAILED(hres))
736 return hres;
737
738 if(d <= 0)
739 return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL);
740 else
741 return return_double(res, log(d));
742 }
743
744 static HRESULT Global_Sqr(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
745 {
746 HRESULT hres;
747 double d;
748
749 hres = to_double(arg, &d);
750 if(FAILED(hres))
751 return hres;
752
753 if(d < 0)
754 return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL);
755 else
756 return return_double(res, sqrt(d));
757 }
758
759 static HRESULT Global_Randomize(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
760 {
761 FIXME("\n");
762 return E_NOTIMPL;
763 }
764
765 static HRESULT Global_Rnd(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
766 {
767 FIXME("\n");
768 return E_NOTIMPL;
769 }
770
771 static HRESULT Global_Timer(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
772 {
773 SYSTEMTIME lt;
774 double sec;
775
776 GetLocalTime(&lt);
777 sec = lt.wHour * 3600 + lt.wMinute * 60 + lt.wSecond + lt.wMilliseconds / 1000.0;
778 return return_float(res, sec);
779
780 }
781
782 static HRESULT Global_LBound(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
783 {
784 FIXME("\n");
785 return E_NOTIMPL;
786 }
787
788 static HRESULT Global_UBound(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
789 {
790 FIXME("\n");
791 return E_NOTIMPL;
792 }
793
794 static HRESULT Global_RGB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
795 {
796 HRESULT hres;
797 int i, color[3];
798
799 TRACE("%s %s %s\n", debugstr_variant(arg), debugstr_variant(arg + 1), debugstr_variant(arg + 2));
800
801 assert(args_cnt == 3);
802
803 for(i = 0; i < 3; i++) {
804 hres = to_int(arg + i, color + i);
805 if(FAILED(hres))
806 return hres;
807 if(color[i] > 255)
808 color[i] = 255;
809 if(color[i] < 0)
810 return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL);
811 }
812
813 return return_int(res, RGB(color[0], color[1], color[2]));
814 }
815
816 static HRESULT Global_Len(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
817 {
818 DWORD len;
819 HRESULT hres;
820
821 TRACE("%s\n", debugstr_variant(arg));
822
823 if(V_VT(arg) == VT_NULL)
824 return return_null(res);
825
826 if(V_VT(arg) != VT_BSTR) {
827 BSTR str;
828
829 hres = to_string(arg, &str);
830 if(FAILED(hres))
831 return hres;
832
833 len = SysStringLen(str);
834 SysFreeString(str);
835 }else {
836 len = SysStringLen(V_BSTR(arg));
837 }
838
839 return return_int(res, len);
840 }
841
842 static HRESULT Global_LenB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
843 {
844 FIXME("\n");
845 return E_NOTIMPL;
846 }
847
848 static HRESULT Global_Left(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
849 {
850 BSTR str, ret, conv_str = NULL;
851 int len, str_len;
852 HRESULT hres;
853
854 TRACE("(%s %s)\n", debugstr_variant(args+1), debugstr_variant(args));
855
856 if(V_VT(args) == VT_BSTR) {
857 str = V_BSTR(args);
858 }else {
859 hres = to_string(args, &conv_str);
860 if(FAILED(hres))
861 return hres;
862 str = conv_str;
863 }
864
865 hres = to_int(args+1, &len);
866 if(FAILED(hres))
867 return hres;
868
869 if(len < 0) {
870 FIXME("len = %d\n", len);
871 return E_FAIL;
872 }
873
874 str_len = SysStringLen(str);
875 if(len > str_len)
876 len = str_len;
877
878 ret = SysAllocStringLen(str, len);
879 SysFreeString(conv_str);
880 if(!ret)
881 return E_OUTOFMEMORY;
882
883 return return_bstr(res, ret);
884 }
885
886 static HRESULT Global_LeftB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
887 {
888 FIXME("\n");
889 return E_NOTIMPL;
890 }
891
892 static HRESULT Global_Right(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
893 {
894 BSTR str, ret, conv_str = NULL;
895 int len, str_len;
896 HRESULT hres;
897
898 TRACE("(%s %s)\n", debugstr_variant(args), debugstr_variant(args+1));
899
900 if(V_VT(args+1) == VT_BSTR) {
901 str = V_BSTR(args);
902 }else {
903 hres = to_string(args, &conv_str);
904 if(FAILED(hres))
905 return hres;
906 str = conv_str;
907 }
908
909 hres = to_int(args+1, &len);
910 if(FAILED(hres))
911 return hres;
912
913 if(len < 0) {
914 FIXME("len = %d\n", len);
915 return E_FAIL;
916 }
917
918 str_len = SysStringLen(str);
919 if(len > str_len)
920 len = str_len;
921
922 ret = SysAllocStringLen(str+str_len-len, len);
923 SysFreeString(conv_str);
924 if(!ret)
925 return E_OUTOFMEMORY;
926
927 return return_bstr(res, ret);
928 }
929
930 static HRESULT Global_RightB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
931 {
932 FIXME("\n");
933 return E_NOTIMPL;
934 }
935
936 static HRESULT Global_Mid(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
937 {
938 int len = -1, start, str_len;
939 BSTR str;
940 HRESULT hres;
941
942 TRACE("(%s %s ...)\n", debugstr_variant(args), debugstr_variant(args+1));
943
944 assert(args_cnt == 2 || args_cnt == 3);
945
946 if(V_VT(args) != VT_BSTR) {
947 FIXME("args[0] = %s\n", debugstr_variant(args));
948 return E_NOTIMPL;
949 }
950
951 str = V_BSTR(args);
952
953 hres = to_int(args+1, &start);
954 if(FAILED(hres))
955 return hres;
956
957 if(args_cnt == 3) {
958 hres = to_int(args+2, &len);
959 if(FAILED(hres))
960 return hres;
961
962 if(len < 0) {
963 FIXME("len = %d\n", len);
964 return E_FAIL;
965 }
966 }
967
968
969 str_len = SysStringLen(str);
970 start--;
971 if(start > str_len)
972 start = str_len;
973
974 if(len == -1)
975 len = str_len-start;
976 else if(len > str_len-start)
977 len = str_len-start;
978
979 if(res) {
980 V_VT(res) = VT_BSTR;
981 V_BSTR(res) = SysAllocStringLen(str+start, len);
982 if(!V_BSTR(res))
983 return E_OUTOFMEMORY;
984 }
985
986 return S_OK;
987 }
988
989 static HRESULT Global_MidB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
990 {
991 FIXME("\n");
992 return E_NOTIMPL;
993 }
994
995 static HRESULT Global_StrComp(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
996 {
997 FIXME("\n");
998 return E_NOTIMPL;
999 }
1000
1001 static HRESULT Global_LCase(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1002 {
1003 BSTR str;
1004 HRESULT hres;
1005
1006 TRACE("%s\n", debugstr_variant(arg));
1007
1008 if(V_VT(arg) == VT_NULL) {
1009 if(res)
1010 V_VT(res) = VT_NULL;
1011 return S_OK;
1012 }
1013
1014 hres = to_string(arg, &str);
1015 if(FAILED(hres))
1016 return hres;
1017
1018 if(res) {
1019 WCHAR *ptr;
1020
1021 for(ptr = str; *ptr; ptr++)
1022 *ptr = tolowerW(*ptr);
1023
1024 V_VT(res) = VT_BSTR;
1025 V_BSTR(res) = str;
1026 }else {
1027 SysFreeString(str);
1028 }
1029 return S_OK;
1030 }
1031
1032 static HRESULT Global_UCase(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1033 {
1034 BSTR str;
1035 HRESULT hres;
1036
1037 TRACE("%s\n", debugstr_variant(arg));
1038
1039 if(V_VT(arg) == VT_NULL) {
1040 if(res)
1041 V_VT(res) = VT_NULL;
1042 return S_OK;
1043 }
1044
1045 hres = to_string(arg, &str);
1046 if(FAILED(hres))
1047 return hres;
1048
1049 if(res) {
1050 WCHAR *ptr;
1051
1052 for(ptr = str; *ptr; ptr++)
1053 *ptr = toupperW(*ptr);
1054
1055 V_VT(res) = VT_BSTR;
1056 V_BSTR(res) = str;
1057 }else {
1058 SysFreeString(str);
1059 }
1060 return S_OK;
1061 }
1062
1063 static HRESULT Global_LTrim(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1064 {
1065 BSTR str, conv_str = NULL;
1066 WCHAR *ptr;
1067 HRESULT hres;
1068
1069 TRACE("%s\n", debugstr_variant(arg));
1070
1071 if(V_VT(arg) == VT_BSTR) {
1072 str = V_BSTR(arg);
1073 }else {
1074 hres = to_string(arg, &conv_str);
1075 if(FAILED(hres))
1076 return hres;
1077 str = conv_str;
1078 }
1079
1080 for(ptr = str; *ptr && isspaceW(*ptr); ptr++);
1081
1082 str = SysAllocString(ptr);
1083 SysFreeString(conv_str);
1084 if(!str)
1085 return E_OUTOFMEMORY;
1086
1087 return return_bstr(res, str);
1088 }
1089
1090 static HRESULT Global_RTrim(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1091 {
1092 BSTR str, conv_str = NULL;
1093 WCHAR *ptr;
1094 HRESULT hres;
1095
1096 TRACE("%s\n", debugstr_variant(arg));
1097
1098 if(V_VT(arg) == VT_BSTR) {
1099 str = V_BSTR(arg);
1100 }else {
1101 hres = to_string(arg, &conv_str);
1102 if(FAILED(hres))
1103 return hres;
1104 str = conv_str;
1105 }
1106
1107 for(ptr = str+SysStringLen(str); ptr-1 > str && isspaceW(*(ptr-1)); ptr--);
1108
1109 str = SysAllocStringLen(str, ptr-str);
1110 SysFreeString(conv_str);
1111 if(!str)
1112 return E_OUTOFMEMORY;
1113
1114 return return_bstr(res, str);
1115 }
1116
1117 static HRESULT Global_Trim(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1118 {
1119 BSTR str, conv_str = NULL;
1120 WCHAR *begin_ptr, *end_ptr;
1121 HRESULT hres;
1122
1123 TRACE("%s\n", debugstr_variant(arg));
1124
1125 if(V_VT(arg) == VT_BSTR) {
1126 str = V_BSTR(arg);
1127 }else {
1128 hres = to_string(arg, &conv_str);
1129 if(FAILED(hres))
1130 return hres;
1131 str = conv_str;
1132 }
1133
1134 for(begin_ptr = str; *begin_ptr && isspaceW(*begin_ptr); begin_ptr++);
1135 for(end_ptr = str+SysStringLen(str); end_ptr-1 > begin_ptr && isspaceW(*(end_ptr-1)); end_ptr--);
1136
1137 str = SysAllocStringLen(begin_ptr, end_ptr-begin_ptr);
1138 SysFreeString(conv_str);
1139 if(!str)
1140 return E_OUTOFMEMORY;
1141
1142 return return_bstr(res, str);
1143 }
1144
1145 static HRESULT Global_Space(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1146 {
1147 BSTR str;
1148 int n, i;
1149 HRESULT hres;
1150
1151 TRACE("%s\n", debugstr_variant(arg));
1152
1153 hres = to_int(arg, &n);
1154 if(FAILED(hres))
1155 return hres;
1156
1157 if(n < 0) {
1158 FIXME("n = %d\n", n);
1159 return E_NOTIMPL;
1160 }
1161
1162 if(!res)
1163 return S_OK;
1164
1165 str = SysAllocStringLen(NULL, n);
1166 if(!str)
1167 return E_OUTOFMEMORY;
1168
1169 for(i=0; i<n; i++)
1170 str[i] = ' ';
1171
1172 V_VT(res) = VT_BSTR;
1173 V_BSTR(res) = str;
1174 return S_OK;
1175 }
1176
1177 static HRESULT Global_String(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1178 {
1179 FIXME("\n");
1180 return E_NOTIMPL;
1181 }
1182
1183 static HRESULT Global_InStr(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
1184 {
1185 VARIANT *startv, *str1v, *str2v;
1186 BSTR str1, str2;
1187 int start, ret;
1188 HRESULT hres;
1189
1190 TRACE("\n");
1191
1192 assert(2 <= args_cnt && args_cnt <= 4);
1193
1194 switch(args_cnt) {
1195 case 2:
1196 startv = NULL;
1197 str1v = args;
1198 str2v = args+1;
1199 break;
1200 case 3:
1201 startv = args;
1202 str1v = args+1;
1203 str2v = args+2;
1204 break;
1205 case 4:
1206 FIXME("unsupported compare argument %s\n", debugstr_variant(args));
1207 return E_NOTIMPL;
1208 DEFAULT_UNREACHABLE;
1209 }
1210
1211 if(startv) {
1212 hres = to_int(startv, &start);
1213 if(FAILED(hres))
1214 return hres;
1215 if(--start < 0) {
1216 FIXME("start %d\n", start);
1217 return E_FAIL;
1218 }
1219 }else {
1220 start = 0;
1221 }
1222
1223 if(V_VT(str1v) == VT_NULL || V_VT(str2v) == VT_NULL)
1224 return return_null(res);
1225
1226 if(V_VT(str1v) != VT_BSTR) {
1227 FIXME("Unsupported str1 type %s\n", debugstr_variant(str1v));
1228 return E_NOTIMPL;
1229 }
1230 str1 = V_BSTR(str1v);
1231
1232 if(V_VT(str2v) != VT_BSTR) {
1233 FIXME("Unsupported str2 type %s\n", debugstr_variant(str2v));
1234 return E_NOTIMPL;
1235 }
1236 str2 = V_BSTR(str2v);
1237
1238 if(start < SysStringLen(str1)) {
1239 WCHAR *ptr;
1240
1241 ptr = strstrW(str1+start, str2);
1242 ret = ptr ? ptr-str1+1 : 0;
1243 }else {
1244 ret = 0;
1245 }
1246
1247 return return_int(res, ret);
1248 }
1249
1250 static HRESULT Global_InStrB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1251 {
1252 FIXME("\n");
1253 return E_NOTIMPL;
1254 }
1255
1256 static HRESULT Global_AscB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1257 {
1258 FIXME("\n");
1259 return E_NOTIMPL;
1260 }
1261
1262 static HRESULT Global_ChrB(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1263 {
1264 FIXME("\n");
1265 return E_NOTIMPL;
1266 }
1267
1268 static HRESULT Global_Asc(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1269 {
1270 FIXME("\n");
1271 return E_NOTIMPL;
1272 }
1273
1274 /* The function supports only single-byte and double-byte character sets. It
1275 * ignores language specified by IActiveScriptSite::GetLCID. The argument needs
1276 * to be in range of short or unsigned short. */
1277 static HRESULT Global_Chr(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1278 {
1279 int cp, c, len = 0;
1280 CPINFO cpi;
1281 WCHAR ch;
1282 char buf[2];
1283 HRESULT hres;
1284
1285 TRACE("%s\n", debugstr_variant(arg));
1286
1287 hres = to_int(arg, &c);
1288 if(FAILED(hres))
1289 return hres;
1290
1291 cp = GetACP();
1292 if(!GetCPInfo(cp, &cpi))
1293 cpi.MaxCharSize = 1;
1294
1295 if((c!=(short)c && c!=(unsigned short)c) ||
1296 (unsigned short)c>=(cpi.MaxCharSize>1 ? 0x10000 : 0x100)) {
1297 WARN("invalid arg %d\n", c);
1298 return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL);
1299 }
1300
1301 if(c>>8)
1302 buf[len++] = c>>8;
1303 if(!len || IsDBCSLeadByteEx(cp, buf[0]))
1304 buf[len++] = c;
1305 if(!MultiByteToWideChar(0, 0, buf, len, &ch, 1)) {
1306 WARN("invalid arg %d, cp %d\n", c, cp);
1307 return E_FAIL;
1308 }
1309
1310 if(res) {
1311 V_VT(res) = VT_BSTR;
1312 V_BSTR(res) = SysAllocStringLen(&ch, 1);
1313 if(!V_BSTR(res))
1314 return E_OUTOFMEMORY;
1315 }
1316 return S_OK;
1317 }
1318
1319 static HRESULT Global_AscW(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1320 {
1321 FIXME("\n");
1322 return E_NOTIMPL;
1323 }
1324
1325 static HRESULT Global_ChrW(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1326 {
1327 FIXME("\n");
1328 return E_NOTIMPL;
1329 }
1330
1331 static HRESULT Global_Abs(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1332 {
1333 HRESULT hres;
1334 VARIANT dst;
1335
1336 TRACE("(%s)\n", debugstr_variant(arg));
1337
1338 assert(args_cnt == 1);
1339
1340 hres = VarAbs(arg, &dst);
1341 if(FAILED(hres))
1342 return hres;
1343
1344 if (res)
1345 *res = dst;
1346 else
1347 VariantClear(&dst);
1348
1349 return S_OK;
1350 }
1351
1352 static HRESULT Global_Fix(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1353 {
1354 HRESULT hres;
1355 VARIANT dst;
1356
1357 TRACE("(%s)\n", debugstr_variant(arg));
1358
1359 assert(args_cnt == 1);
1360
1361 hres = VarFix(arg, &dst);
1362 if(FAILED(hres))
1363 return hres;
1364
1365 if (res)
1366 *res = dst;
1367 else
1368 VariantClear(&dst);
1369
1370 return S_OK;
1371 }
1372
1373 static HRESULT Global_Int(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1374 {
1375 HRESULT hres;
1376 VARIANT dst;
1377
1378 TRACE("(%s)\n", debugstr_variant(arg));
1379
1380 assert(args_cnt == 1);
1381
1382 hres = VarInt(arg, &dst);
1383 if(FAILED(hres))
1384 return hres;
1385
1386 if (res)
1387 *res = dst;
1388 else
1389 VariantClear(&dst);
1390
1391 return S_OK;
1392 }
1393
1394 static HRESULT Global_Sgn(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1395 {
1396 double v;
1397 short val;
1398 HRESULT hres;
1399
1400 TRACE("(%s)\n", debugstr_variant(arg));
1401
1402 assert(args_cnt == 1);
1403
1404 if(V_VT(arg) == VT_NULL)
1405 return MAKE_VBSERROR(VBSE_ILLEGAL_NULL_USE);
1406
1407 hres = to_double(arg, &v);
1408 if (FAILED(hres))
1409 return hres;
1410
1411 val = v == 0 ? 0 : (v > 0 ? 1 : -1);
1412 return return_short(res, val);
1413 }
1414
1415 static HRESULT Global_Now(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1416 {
1417 SYSTEMTIME lt;
1418 double date;
1419
1420 TRACE("\n");
1421
1422 GetLocalTime(&lt);
1423 SystemTimeToVariantTime(&lt, &date);
1424 return return_date(res, date);
1425 }
1426
1427 static HRESULT Global_Date(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1428 {
1429 SYSTEMTIME lt;
1430 UDATE ud;
1431 DATE date;
1432 HRESULT hres;
1433
1434 TRACE("\n");
1435
1436 GetLocalTime(&lt);
1437 ud.st = lt;
1438 ud.wDayOfYear = 0;
1439 hres = VarDateFromUdateEx(&ud, 0, VAR_DATEVALUEONLY, &date);
1440 if(FAILED(hres))
1441 return hres;
1442 return return_date(res, date);
1443 }
1444
1445 static HRESULT Global_Time(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1446 {
1447 SYSTEMTIME lt;
1448 UDATE ud;
1449 DATE time;
1450 HRESULT hres;
1451
1452 TRACE("\n");
1453
1454 GetLocalTime(&lt);
1455 ud.st = lt;
1456 ud.wDayOfYear = 0;
1457 hres = VarDateFromUdateEx(&ud, 0, VAR_TIMEVALUEONLY, &time);
1458 if(FAILED(hres))
1459 return hres;
1460 return return_date(res, time);
1461 }
1462
1463 static HRESULT Global_Day(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1464 {
1465 FIXME("\n");
1466 return E_NOTIMPL;
1467 }
1468
1469 static HRESULT Global_Month(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1470 {
1471 FIXME("\n");
1472 return E_NOTIMPL;
1473 }
1474
1475 static HRESULT Global_Weekday(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1476 {
1477 FIXME("\n");
1478 return E_NOTIMPL;
1479 }
1480
1481 static HRESULT Global_Year(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1482 {
1483 FIXME("\n");
1484 return E_NOTIMPL;
1485 }
1486
1487 static HRESULT Global_Hour(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1488 {
1489 FIXME("\n");
1490 return E_NOTIMPL;
1491 }
1492
1493 static HRESULT Global_Minute(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1494 {
1495 FIXME("\n");
1496 return E_NOTIMPL;
1497 }
1498
1499 static HRESULT Global_Second(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1500 {
1501 FIXME("\n");
1502 return E_NOTIMPL;
1503 }
1504
1505 static HRESULT Global_DateValue(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1506 {
1507 FIXME("\n");
1508 return E_NOTIMPL;
1509 }
1510
1511 static HRESULT Global_TimeValue(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1512 {
1513 FIXME("\n");
1514 return E_NOTIMPL;
1515 }
1516
1517 static HRESULT Global_DateSerial(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1518 {
1519 FIXME("\n");
1520 return E_NOTIMPL;
1521 }
1522
1523 static HRESULT Global_TimeSerial(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1524 {
1525 FIXME("\n");
1526 return E_NOTIMPL;
1527 }
1528
1529 static HRESULT Global_InputBox(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1530 {
1531 FIXME("\n");
1532 return E_NOTIMPL;
1533 }
1534
1535 static HRESULT Global_MsgBox(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
1536 {
1537 BSTR prompt, title = NULL;
1538 int type = MB_OK;
1539 HRESULT hres;
1540
1541 TRACE("\n");
1542
1543 assert(1 <= args_cnt && args_cnt <= 5);
1544
1545 hres = to_string(args, &prompt);
1546 if(FAILED(hres))
1547 return hres;
1548
1549 if(args_cnt > 1)
1550 hres = to_int(args+1, &type);
1551
1552 if(SUCCEEDED(hres) && args_cnt > 2)
1553 hres = to_string(args+2, &title);
1554
1555 if(SUCCEEDED(hres) && args_cnt > 3) {
1556 FIXME("unsupported arg_cnt %d\n", args_cnt);
1557 hres = E_NOTIMPL;
1558 }
1559
1560 if(SUCCEEDED(hres))
1561 hres = show_msgbox(This->desc->ctx, prompt, type, title, res);
1562
1563 SysFreeString(prompt);
1564 SysFreeString(title);
1565 return hres;
1566 }
1567
1568 static HRESULT Global_CreateObject(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1569 {
1570 IUnknown *obj;
1571 HRESULT hres;
1572
1573 TRACE("(%s)\n", debugstr_variant(arg));
1574
1575 if(V_VT(arg) != VT_BSTR) {
1576 FIXME("non-bstr arg\n");
1577 return E_INVALIDARG;
1578 }
1579
1580 obj = create_object(This->desc->ctx, V_BSTR(arg));
1581 if(!obj)
1582 return VB_E_CANNOT_CREATE_OBJ;
1583
1584 if(res) {
1585 hres = IUnknown_QueryInterface(obj, &IID_IDispatch, (void**)&V_DISPATCH(res));
1586 if(FAILED(hres))
1587 return hres;
1588
1589 V_VT(res) = VT_DISPATCH;
1590 }
1591
1592 IUnknown_Release(obj);
1593 return S_OK;
1594 }
1595
1596 static HRESULT Global_GetObject(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
1597 {
1598 IBindCtx *bind_ctx;
1599 IUnknown *obj_unk;
1600 IDispatch *disp;
1601 ULONG eaten = 0;
1602 IMoniker *mon;
1603 HRESULT hres;
1604
1605 TRACE("%s %s\n", args_cnt ? debugstr_variant(args) : "", args_cnt > 1 ? debugstr_variant(args+1) : "");
1606
1607 if(args_cnt != 1 || V_VT(args) != VT_BSTR) {
1608 FIXME("unsupported args\n");
1609 return E_NOTIMPL;
1610 }
1611
1612 if(This->desc->ctx->safeopt & (INTERFACE_USES_SECURITY_MANAGER|INTERFACESAFE_FOR_UNTRUSTED_DATA)) {
1613 WARN("blocked in current safety mode\n");
1614 return VB_E_CANNOT_CREATE_OBJ;
1615 }
1616
1617 hres = CreateBindCtx(0, &bind_ctx);
1618 if(FAILED(hres))
1619 return hres;
1620
1621 hres = MkParseDisplayName(bind_ctx, V_BSTR(args), &eaten, &mon);
1622 if(SUCCEEDED(hres)) {
1623 hres = IMoniker_BindToObject(mon, bind_ctx, NULL, &IID_IUnknown, (void**)&obj_unk);
1624 IMoniker_Release(mon);
1625 }else {
1626 hres = MK_E_SYNTAX;
1627 }
1628 IBindCtx_Release(bind_ctx);
1629 if(FAILED(hres))
1630 return hres;
1631
1632 hres = set_object_site(This->desc->ctx, obj_unk);
1633 if(FAILED(hres)) {
1634 IUnknown_Release(obj_unk);
1635 return hres;
1636 }
1637
1638 hres = IUnknown_QueryInterface(obj_unk, &IID_IDispatch, (void**)&disp);
1639 if(SUCCEEDED(hres)) {
1640 if(res) {
1641 V_VT(res) = VT_DISPATCH;
1642 V_DISPATCH(res) = disp;
1643 }else {
1644 IDispatch_Release(disp);
1645 }
1646 }else {
1647 FIXME("object does not support IDispatch\n");
1648 }
1649
1650 return hres;
1651 }
1652
1653 static HRESULT Global_DateAdd(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1654 {
1655 FIXME("\n");
1656 return E_NOTIMPL;
1657 }
1658
1659 static HRESULT Global_DateDiff(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1660 {
1661 FIXME("\n");
1662 return E_NOTIMPL;
1663 }
1664
1665 static HRESULT Global_DatePart(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1666 {
1667 FIXME("\n");
1668 return E_NOTIMPL;
1669 }
1670
1671 static HRESULT Global_TypeName(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1672 {
1673 static const WCHAR ByteW[] = {'B', 'y', 't', 'e', 0};
1674 static const WCHAR IntegerW[] = {'I', 'n', 't', 'e', 'g', 'e', 'r', 0};
1675 static const WCHAR LongW[] = {'L', 'o', 'n', 'g', 0};
1676 static const WCHAR SingleW[] = {'S', 'i', 'n', 'g', 'l', 'e', 0};
1677 static const WCHAR DoubleW[] = {'D', 'o', 'u', 'b', 'l', 'e', 0};
1678 static const WCHAR CurrencyW[] = {'C', 'u', 'r', 'r', 'e', 'n', 'c', 'y', 0};
1679 static const WCHAR DecimalW[] = {'D', 'e', 'c', 'i', 'm', 'a', 'l', 0};
1680 static const WCHAR DateW[] = {'D', 'a', 't', 'e', 0};
1681 static const WCHAR StringW[] = {'S', 't', 'r', 'i', 'n', 'g', 0};
1682 static const WCHAR BooleanW[] = {'B', 'o', 'o', 'l', 'e', 'a', 'n', 0};
1683 static const WCHAR EmptyW[] = {'E', 'm', 'p', 't', 'y', 0};
1684 static const WCHAR NullW[] = {'N', 'u', 'l', 'l', 0};
1685
1686 TRACE("(%s)\n", debugstr_variant(arg));
1687
1688 assert(args_cnt == 1);
1689
1690 switch(V_VT(arg)) {
1691 case VT_UI1:
1692 return return_string(res, ByteW);
1693 case VT_I2:
1694 return return_string(res, IntegerW);
1695 case VT_I4:
1696 return return_string(res, LongW);
1697 case VT_R4:
1698 return return_string(res, SingleW);
1699 case VT_R8:
1700 return return_string(res, DoubleW);
1701 case VT_CY:
1702 return return_string(res, CurrencyW);
1703 case VT_DECIMAL:
1704 return return_string(res, DecimalW);
1705 case VT_DATE:
1706 return return_string(res, DateW);
1707 case VT_BSTR:
1708 return return_string(res, StringW);
1709 case VT_BOOL:
1710 return return_string(res, BooleanW);
1711 case VT_EMPTY:
1712 return return_string(res, EmptyW);
1713 case VT_NULL:
1714 return return_string(res, NullW);
1715 default:
1716 FIXME("arg %s not supported\n", debugstr_variant(arg));
1717 return E_NOTIMPL;
1718 }
1719 }
1720
1721 static HRESULT Global_Array(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1722 {
1723 FIXME("\n");
1724 return E_NOTIMPL;
1725 }
1726
1727 static HRESULT Global_Erase(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1728 {
1729 FIXME("\n");
1730 return E_NOTIMPL;
1731 }
1732
1733 static HRESULT Global_Filter(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1734 {
1735 FIXME("\n");
1736 return E_NOTIMPL;
1737 }
1738
1739 static HRESULT Global_Join(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1740 {
1741 FIXME("\n");
1742 return E_NOTIMPL;
1743 }
1744
1745 static HRESULT Global_Split(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1746 {
1747 FIXME("\n");
1748 return E_NOTIMPL;
1749 }
1750
1751 static HRESULT Global_Replace(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1752 {
1753 FIXME("\n");
1754 return E_NOTIMPL;
1755 }
1756
1757 static HRESULT Global_StrReverse(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1758 {
1759 WCHAR *ptr1, *ptr2, ch;
1760 BSTR ret;
1761 HRESULT hres;
1762
1763 TRACE("%s\n", debugstr_variant(arg));
1764
1765 hres = to_string(arg, &ret);
1766 if(FAILED(hres))
1767 return hres;
1768
1769 ptr1 = ret;
1770 ptr2 = ret + SysStringLen(ret)-1;
1771 while(ptr1 < ptr2) {
1772 ch = *ptr1;
1773 *ptr1++ = *ptr2;
1774 *ptr2-- = ch;
1775 }
1776
1777 return return_bstr(res, ret);
1778 }
1779
1780 static HRESULT Global_InStrRev(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1781 {
1782 FIXME("\n");
1783 return E_NOTIMPL;
1784 }
1785
1786 static HRESULT Global_LoadPicture(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1787 {
1788 FIXME("\n");
1789 return E_NOTIMPL;
1790 }
1791
1792 static HRESULT Global_ScriptEngine(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1793 {
1794 TRACE("%s\n", debugstr_variant(arg));
1795
1796 assert(args_cnt == 0);
1797
1798 return return_string(res, vbscriptW);
1799 }
1800
1801 static HRESULT Global_ScriptEngineMajorVersion(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1802 {
1803 TRACE("%s\n", debugstr_variant(arg));
1804
1805 assert(args_cnt == 0);
1806
1807 return return_int(res, VBSCRIPT_MAJOR_VERSION);
1808 }
1809
1810 static HRESULT Global_ScriptEngineMinorVersion(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1811 {
1812 TRACE("%s\n", debugstr_variant(arg));
1813
1814 assert(args_cnt == 0);
1815
1816 return return_int(res, VBSCRIPT_MINOR_VERSION);
1817 }
1818
1819 static HRESULT Global_ScriptEngineBuildVersion(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1820 {
1821 TRACE("%s\n", debugstr_variant(arg));
1822
1823 assert(args_cnt == 0);
1824
1825 return return_int(res, VBSCRIPT_BUILD_VERSION);
1826 }
1827
1828 static HRESULT Global_FormatNumber(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1829 {
1830 FIXME("\n");
1831 return E_NOTIMPL;
1832 }
1833
1834 static HRESULT Global_FormatCurrency(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1835 {
1836 FIXME("\n");
1837 return E_NOTIMPL;
1838 }
1839
1840 static HRESULT Global_FormatPercent(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1841 {
1842 FIXME("\n");
1843 return E_NOTIMPL;
1844 }
1845
1846 static HRESULT Global_FormatDateTime(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1847 {
1848 FIXME("\n");
1849 return E_NOTIMPL;
1850 }
1851
1852 static HRESULT Global_WeekdayName(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
1853 {
1854 int weekday, first_day = 1, abbrev = 0;
1855 BSTR ret;
1856 HRESULT hres;
1857
1858 TRACE("\n");
1859
1860 assert(1 <= args_cnt && args_cnt <= 3);
1861
1862 hres = to_int(args, &weekday);
1863 if(FAILED(hres))
1864 return hres;
1865
1866 if(args_cnt > 1) {
1867 hres = to_int(args+1, &abbrev);
1868 if(FAILED(hres))
1869 return hres;
1870
1871 if(args_cnt == 3) {
1872 hres = to_int(args+2, &first_day);
1873 if(FAILED(hres))
1874 return hres;
1875 }
1876 }
1877
1878 hres = VarWeekdayName(weekday, abbrev, first_day, 0, &ret);
1879 if(FAILED(hres))
1880 return hres;
1881
1882 return return_bstr(res, ret);
1883 }
1884
1885 static HRESULT Global_MonthName(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
1886 {
1887 int month, abbrev = 0;
1888 BSTR ret;
1889 HRESULT hres;
1890
1891 TRACE("\n");
1892
1893 assert(args_cnt == 1 || args_cnt == 2);
1894
1895 hres = to_int(args, &month);
1896 if(FAILED(hres))
1897 return hres;
1898
1899 if(args_cnt == 2) {
1900 hres = to_int(args+1, &abbrev);
1901 if(FAILED(hres))
1902 return hres;
1903 }
1904
1905 hres = VarMonthName(month, abbrev, 0, &ret);
1906 if(FAILED(hres))
1907 return hres;
1908
1909 return return_bstr(res, ret);
1910 }
1911
1912 static HRESULT Global_Round(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1913 {
1914 double n;
1915 HRESULT hres;
1916
1917 TRACE("%s\n", debugstr_variant(arg));
1918
1919 if(!res)
1920 return S_OK;
1921
1922 switch(V_VT(arg)) {
1923 case VT_I2:
1924 case VT_I4:
1925 case VT_BOOL:
1926 *res = *arg;
1927 return S_OK;
1928 case VT_R8:
1929 n = V_R8(arg);
1930 break;
1931 default:
1932 hres = to_double(arg, &n);
1933 if(FAILED(hres))
1934 return hres;
1935 }
1936
1937 return return_double(res, round(n));
1938 }
1939
1940 static HRESULT Global_Escape(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1941 {
1942 FIXME("\n");
1943 return E_NOTIMPL;
1944 }
1945
1946 static HRESULT Global_Unescape(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1947 {
1948 FIXME("\n");
1949 return E_NOTIMPL;
1950 }
1951
1952 static HRESULT Global_Eval(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1953 {
1954 FIXME("\n");
1955 return E_NOTIMPL;
1956 }
1957
1958 static HRESULT Global_Execute(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1959 {
1960 FIXME("\n");
1961 return E_NOTIMPL;
1962 }
1963
1964 static HRESULT Global_ExecuteGlobal(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1965 {
1966 FIXME("\n");
1967 return E_NOTIMPL;
1968 }
1969
1970 static HRESULT Global_GetRef(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
1971 {
1972 FIXME("\n");
1973 return E_NOTIMPL;
1974 }
1975
1976 static const string_constant_t vbCr = {1, {'\r'}};
1977 static const string_constant_t vbCrLf = {2, {'\r','\n'}};
1978 static const string_constant_t vbNewLine = {2, {'\r','\n'}};
1979 static const string_constant_t vbFormFeed = {1, {0xc}};
1980 static const string_constant_t vbLf = {1, {'\n'}};
1981 static const string_constant_t vbNullChar = {1};
1982 static const string_constant_t vbNullString = {0};
1983 static const string_constant_t vbTab = {1, {'\t'}};
1984 static const string_constant_t vbVerticalTab = {1, {0xb}};
1985
1986 static const builtin_prop_t global_props[] = {
1987 {DISPID_GLOBAL_VBUSESYSTEM, NULL, BP_GET, VT_I2, 0},
1988 {DISPID_GLOBAL_USESYSTEMDAYOFWEEK, NULL, BP_GET, VT_I2, 0},
1989 {DISPID_GLOBAL_VBSUNDAY, NULL, BP_GET, VT_I2, 1},
1990 {DISPID_GLOBAL_VBMONDAY, NULL, BP_GET, VT_I2, 2},
1991 {DISPID_GLOBAL_VBTUESDAY, NULL, BP_GET, VT_I2, 3},
1992 {DISPID_GLOBAL_VBWEDNESDAY, NULL, BP_GET, VT_I2, 4},
1993 {DISPID_GLOBAL_VBTHURSDAY, NULL, BP_GET, VT_I2, 5},
1994 {DISPID_GLOBAL_VBFRIDAY, NULL, BP_GET, VT_I2, 6},
1995 {DISPID_GLOBAL_VBSATURDAY, NULL, BP_GET, VT_I2, 7},
1996 {DISPID_GLOBAL_VBFIRSTJAN1, NULL, BP_GET, VT_I2, 1},
1997 {DISPID_GLOBAL_VBFIRSTFOURDAYS, NULL, BP_GET, VT_I2, 2},
1998 {DISPID_GLOBAL_VBFIRSTFULLWEEK, NULL, BP_GET, VT_I2, 3},
1999 {DISPID_GLOBAL_VBOKONLY, NULL, BP_GET, VT_I2, MB_OK},
2000 {DISPID_GLOBAL_VBOKCANCEL, NULL, BP_GET, VT_I2, MB_OKCANCEL},
2001 {DISPID_GLOBAL_VBABORTRETRYIGNORE, NULL, BP_GET, VT_I2, MB_ABORTRETRYIGNORE},
2002 {DISPID_GLOBAL_VBYESNOCANCEL, NULL, BP_GET, VT_I2, MB_YESNOCANCEL},
2003 {DISPID_GLOBAL_VBYESNO, NULL, BP_GET, VT_I2, MB_YESNO},
2004 {DISPID_GLOBAL_VBRETRYCANCEL, NULL, BP_GET, VT_I2, MB_RETRYCANCEL},
2005 {DISPID_GLOBAL_VBCRITICAL, NULL, BP_GET, VT_I2, MB_ICONHAND},
2006 {DISPID_GLOBAL_VBQUESTION, NULL, BP_GET, VT_I2, MB_ICONQUESTION},
2007 {DISPID_GLOBAL_VBEXCLAMATION, NULL, BP_GET, VT_I2, MB_ICONEXCLAMATION},
2008 {DISPID_GLOBAL_VBINFORMATION, NULL, BP_GET, VT_I2, MB_ICONASTERISK},
2009 {DISPID_GLOBAL_VBDEFAULTBUTTON1, NULL, BP_GET, VT_I2, MB_DEFBUTTON1},
2010 {DISPID_GLOBAL_VBDEFAULTBUTTON2, NULL, BP_GET, VT_I2, MB_DEFBUTTON2},
2011 {DISPID_GLOBAL_VBDEFAULTBUTTON3, NULL, BP_GET, VT_I2, MB_DEFBUTTON3},
2012 {DISPID_GLOBAL_VBDEFAULTBUTTON4, NULL, BP_GET, VT_I2, MB_DEFBUTTON4},
2013 {DISPID_GLOBAL_VBAPPLICATIONMODAL, NULL, BP_GET, VT_I2, MB_APPLMODAL},
2014 {DISPID_GLOBAL_VBSYSTEMMODAL, NULL, BP_GET, VT_I2, MB_SYSTEMMODAL},
2015 {DISPID_GLOBAL_VBOK, NULL, BP_GET, VT_I2, IDOK},
2016 {DISPID_GLOBAL_VBCANCEL, NULL, BP_GET, VT_I2, IDCANCEL},
2017 {DISPID_GLOBAL_VBABORT, NULL, BP_GET, VT_I2, IDABORT},
2018 {DISPID_GLOBAL_VBRETRY, NULL, BP_GET, VT_I2, IDRETRY},
2019 {DISPID_GLOBAL_VBIGNORE, NULL, BP_GET, VT_I2, IDIGNORE},
2020 {DISPID_GLOBAL_VBYES, NULL, BP_GET, VT_I2, IDYES},
2021 {DISPID_GLOBAL_VBNO, NULL, BP_GET, VT_I2, IDNO},
2022 {DISPID_GLOBAL_VBEMPTY, NULL, BP_GET, VT_I2, VT_EMPTY},
2023 {DISPID_GLOBAL_VBNULL, NULL, BP_GET, VT_I2, VT_NULL},
2024 {DISPID_GLOBAL_VBINTEGER, NULL, BP_GET, VT_I2, VT_I2},
2025 {DISPID_GLOBAL_VBLONG, NULL, BP_GET, VT_I2, VT_I4},
2026 {DISPID_GLOBAL_VBSINGLE, NULL, BP_GET, VT_I2, VT_R4},
2027 {DISPID_GLOBAL_VBDOUBLE, NULL, BP_GET, VT_I2, VT_R8},
2028 {DISPID_GLOBAL_VBCURRENCY, NULL, BP_GET, VT_I2, VT_CY},
2029 {DISPID_GLOBAL_VBDATE, NULL, BP_GET, VT_I2, VT_DATE},
2030 {DISPID_GLOBAL_VBSTRING, NULL, BP_GET, VT_I2, VT_BSTR},
2031 {DISPID_GLOBAL_VBOBJECT, NULL, BP_GET, VT_I2, VT_DISPATCH},
2032 {DISPID_GLOBAL_VBERROR, NULL, BP_GET, VT_I2, VT_ERROR},
2033 {DISPID_GLOBAL_VBBOOLEAN, NULL, BP_GET, VT_I2, VT_BOOL},
2034 {DISPID_GLOBAL_VBVARIANT, NULL, BP_GET, VT_I2, VT_VARIANT},
2035 {DISPID_GLOBAL_VBDATAOBJECT, NULL, BP_GET, VT_I2, VT_UNKNOWN},
2036 {DISPID_GLOBAL_VBDECIMAL, NULL, BP_GET, VT_I2, VT_DECIMAL},
2037 {DISPID_GLOBAL_VBBYTE, NULL, BP_GET, VT_I2, VT_UI1},
2038 {DISPID_GLOBAL_VBARRAY, NULL, BP_GET, VT_I2, VT_ARRAY},
2039 {DISPID_GLOBAL_VBTRUE, NULL, BP_GET, VT_I2, VARIANT_TRUE},
2040 {DISPID_GLOBAL_VBFALSE, NULL, BP_GET, VT_I2, VARIANT_FALSE},
2041 {DISPID_GLOBAL_VBUSEDEFAULT, NULL, BP_GET, VT_I2, -2},
2042 {DISPID_GLOBAL_VBBINARYCOMPARE, NULL, BP_GET, VT_I2, 0},
2043 {DISPID_GLOBAL_VBTEXTCOMPARE, NULL, BP_GET, VT_I2, 1},
2044 {DISPID_GLOBAL_VBDATABASECOMPARE, NULL, BP_GET, VT_I2, 2},
2045 {DISPID_GLOBAL_VBGENERALDATE, NULL, BP_GET, VT_I2, 0},
2046 {DISPID_GLOBAL_VBLONGDATE, NULL, BP_GET, VT_I2, 1},
2047 {DISPID_GLOBAL_VBSHORTDATE, NULL, BP_GET, VT_I2, 2},
2048 {DISPID_GLOBAL_VBLONGTIME, NULL, BP_GET, VT_I2, 3},
2049 {DISPID_GLOBAL_VBSHORTTIME, NULL, BP_GET, VT_I2, 4},
2050 {DISPID_GLOBAL_VBOBJECTERROR, NULL, BP_GET, VT_I4, 0x80040000},
2051 {DISPID_GLOBAL_VBBLACK, NULL, BP_GET, VT_I4, 0x000000},
2052 {DISPID_GLOBAL_VBBLUE, NULL, BP_GET, VT_I4, 0xff0000},
2053 {DISPID_GLOBAL_VBCYAN, NULL, BP_GET, VT_I4, 0xffff00},
2054 {DISPID_GLOBAL_VBGREEN, NULL, BP_GET, VT_I4, 0x00ff00},
2055 {DISPID_GLOBAL_VBMAGENTA, NULL, BP_GET, VT_I4, 0xff00ff},
2056 {DISPID_GLOBAL_VBRED, NULL, BP_GET, VT_I4, 0x0000ff},
2057 {DISPID_GLOBAL_VBWHITE, NULL, BP_GET, VT_I4, 0xffffff},
2058 {DISPID_GLOBAL_VBYELLOW, NULL, BP_GET, VT_I4, 0x00ffff},
2059 {DISPID_GLOBAL_VBCR, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbCr},
2060 {DISPID_GLOBAL_VBCRLF, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbCrLf},
2061 {DISPID_GLOBAL_VBNEWLINE, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbNewLine},
2062 {DISPID_GLOBAL_VBFORMFEED, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbFormFeed},
2063 {DISPID_GLOBAL_VBLF, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbLf},
2064 {DISPID_GLOBAL_VBNULLCHAR, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbNullChar},
2065 {DISPID_GLOBAL_VBNULLSTRING, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbNullString},
2066 {DISPID_GLOBAL_VBTAB, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbTab},
2067 {DISPID_GLOBAL_VBVERTICALTAB, NULL, BP_GET, VT_BSTR, (UINT_PTR)&vbVerticalTab},
2068 {DISPID_GLOBAL_CCUR, Global_CCur, 0, 1},
2069 {DISPID_GLOBAL_CINT, Global_CInt, 0, 1},
2070 {DISPID_GLOBAL_CLNG, Global_CLng, 0, 1},
2071 {DISPID_GLOBAL_CBOOL, Global_CBool, 0, 1},
2072 {DISPID_GLOBAL_CBYTE, Global_CByte, 0, 1},
2073 {DISPID_GLOBAL_CDATE, Global_CDate, 0, 1},
2074 {DISPID_GLOBAL_CDBL, Global_CDbl, 0, 1},
2075 {DISPID_GLOBAL_CSNG, Global_CSng, 0, 1},
2076 {DISPID_GLOBAL_CSTR, Global_CStr, 0, 1},
2077 {DISPID_GLOBAL_HEX, Global_Hex, 0, 1},
2078 {DISPID_GLOBAL_OCT, Global_Oct, 0, 1},
2079 {DISPID_GLOBAL_VARTYPE, Global_VarType, 0, 1},
2080 {DISPID_GLOBAL_ISDATE, Global_IsDate, 0, 1},
2081 {DISPID_GLOBAL_ISEMPTY, Global_IsEmpty, 0, 1},
2082 {DISPID_GLOBAL_ISNULL, Global_IsNull, 0, 1},
2083 {DISPID_GLOBAL_ISNUMERIC, Global_IsNumeric, 0, 1},
2084 {DISPID_GLOBAL_ISARRAY, Global_IsArray, 0, 1},
2085 {DISPID_GLOBAL_ISOBJECT, Global_IsObject, 0, 1},
2086 {DISPID_GLOBAL_ATN, Global_Atn, 0, 1},
2087 {DISPID_GLOBAL_COS, Global_Cos, 0, 1},
2088 {DISPID_GLOBAL_SIN, Global_Sin, 0, 1},
2089 {DISPID_GLOBAL_TAN, Global_Tan, 0, 1},
2090 {DISPID_GLOBAL_EXP, Global_Exp, 0, 1},
2091 {DISPID_GLOBAL_LOG, Global_Log, 0, 1},
2092 {DISPID_GLOBAL_SQR, Global_Sqr, 0, 1},
2093 {DISPID_GLOBAL_RANDOMIZE, Global_Randomize, 0, 1},
2094 {DISPID_GLOBAL_RND, Global_Rnd, 0, 1},
2095 {DISPID_GLOBAL_TIMER, Global_Timer, 0, 0},
2096 {DISPID_GLOBAL_LBOUND, Global_LBound, 0, 1},
2097 {DISPID_GLOBAL_UBOUND, Global_UBound, 0, 1},
2098 {DISPID_GLOBAL_RGB, Global_RGB, 0, 3},
2099 {DISPID_GLOBAL_LEN, Global_Len, 0, 1},
2100 {DISPID_GLOBAL_LENB, Global_LenB, 0, 1},
2101 {DISPID_GLOBAL_LEFT, Global_Left, 0, 2},
2102 {DISPID_GLOBAL_LEFTB, Global_LeftB, 0, 2},
2103 {DISPID_GLOBAL_RIGHT, Global_Right, 0, 2},
2104 {DISPID_GLOBAL_RIGHTB, Global_RightB, 0, 2},
2105 {DISPID_GLOBAL_MID, Global_Mid, 0, 2, 3},
2106 {DISPID_GLOBAL_MIDB, Global_MidB, 0, 2, 3},
2107 {DISPID_GLOBAL_STRCOMP, Global_StrComp, 0, 2, 3},
2108 {DISPID_GLOBAL_LCASE, Global_LCase, 0, 1},
2109 {DISPID_GLOBAL_UCASE, Global_UCase, 0, 1},
2110 {DISPID_GLOBAL_LTRIM, Global_LTrim, 0, 1},
2111 {DISPID_GLOBAL_RTRIM, Global_RTrim, 0, 1},
2112 {DISPID_GLOBAL_TRIM, Global_Trim, 0, 1},
2113 {DISPID_GLOBAL_SPACE, Global_Space, 0, 1},
2114 {DISPID_GLOBAL_STRING, Global_String, 0, 0, 2},
2115 {DISPID_GLOBAL_INSTR, Global_InStr, 0, 2, 4},
2116 {DISPID_GLOBAL_INSTRB, Global_InStrB, 0, 3, 4},
2117 {DISPID_GLOBAL_ASCB, Global_AscB, 0, 1},
2118 {DISPID_GLOBAL_CHRB, Global_ChrB, 0, 1},
2119 {DISPID_GLOBAL_ASC, Global_Asc, 0, 1},
2120 {DISPID_GLOBAL_CHR, Global_Chr, 0, 1},
2121 {DISPID_GLOBAL_ASCW, Global_AscW, 0, 1},
2122 {DISPID_GLOBAL_CHRW, Global_ChrW, 0, 1},
2123 {DISPID_GLOBAL_ABS, Global_Abs, 0, 1},
2124 {DISPID_GLOBAL_FIX, Global_Fix, 0, 1},
2125 {DISPID_GLOBAL_INT, Global_Int, 0, 1},
2126 {DISPID_GLOBAL_SGN, Global_Sgn, 0, 1},
2127 {DISPID_GLOBAL_NOW, Global_Now, 0, 0},
2128 {DISPID_GLOBAL_DATE, Global_Date, 0, 0},
2129 {DISPID_GLOBAL_TIME, Global_Time, 0, 0},
2130 {DISPID_GLOBAL_DAY, Global_Day, 0, 1},
2131 {DISPID_GLOBAL_MONTH, Global_Month, 0, 1},
2132 {DISPID_GLOBAL_WEEKDAY, Global_Weekday, 0, 1, 2},
2133 {DISPID_GLOBAL_YEAR, Global_Year, 0, 1},
2134 {DISPID_GLOBAL_HOUR, Global_Hour, 0, 1},
2135 {DISPID_GLOBAL_MINUTE, Global_Minute, 0, 1},
2136 {DISPID_GLOBAL_SECOND, Global_Second, 0, 1},
2137 {DISPID_GLOBAL_DATEVALUE, Global_DateValue, 0, 1},
2138 {DISPID_GLOBAL_TIMEVALUE, Global_TimeValue, 0, 1},
2139 {DISPID_GLOBAL_DATESERIAL, Global_DateSerial, 0, 3},
2140 {DISPID_GLOBAL_TIMESERIAL, Global_TimeSerial, 0, 3},
2141 {DISPID_GLOBAL_INPUTBOX, Global_InputBox, 0, 1, 7},
2142 {DISPID_GLOBAL_MSGBOX, Global_MsgBox, 0, 1, 5},
2143 {DISPID_GLOBAL_CREATEOBJECT, Global_CreateObject, 0, 1},
2144 {DISPID_GLOBAL_GETOBJECT, Global_GetObject, 0, 0, 2},
2145 {DISPID_GLOBAL_DATEADD, Global_DateAdd, 0, 3},
2146 {DISPID_GLOBAL_DATEDIFF, Global_DateDiff, 0, 3, 5},
2147 {DISPID_GLOBAL_DATEPART, Global_DatePart, 0, 2, 4},
2148 {DISPID_GLOBAL_TYPENAME, Global_TypeName, 0, 1},
2149 {DISPID_GLOBAL_ARRAY, Global_Array, 0, 1},
2150 {DISPID_GLOBAL_ERASE, Global_Erase, 0, 1},
2151 {DISPID_GLOBAL_FILTER, Global_Filter, 0, 2, 4},
2152 {DISPID_GLOBAL_JOIN, Global_Join, 0, 1, 2},
2153 {DISPID_GLOBAL_SPLIT, Global_Split, 0, 1, 4},
2154 {DISPID_GLOBAL_REPLACE, Global_Replace, 0, 3, 6},
2155 {DISPID_GLOBAL_STRREVERSE, Global_StrReverse, 0, 1},
2156 {DISPID_GLOBAL_INSTRREV, Global_InStrRev, 0, 2, 4},
2157 {DISPID_GLOBAL_LOADPICTURE, Global_LoadPicture, 0, 1},
2158 {DISPID_GLOBAL_SCRIPTENGINE, Global_ScriptEngine, 0, 0},
2159 {DISPID_GLOBAL_SCRIPTENGINEMAJORVERSION, Global_ScriptEngineMajorVersion, 0, 0},
2160 {DISPID_GLOBAL_SCRIPTENGINEMINORVERSION, Global_ScriptEngineMinorVersion, 0, 0},
2161 {DISPID_GLOBAL_SCRIPTENGINEBUILDVERSION, Global_ScriptEngineBuildVersion, 0, 0},
2162 {DISPID_GLOBAL_FORMATNUMBER, Global_FormatNumber, 0, 1, 5},
2163 {DISPID_GLOBAL_FORMATCURRENCY, Global_FormatCurrency, 0, 1, 5},
2164 {DISPID_GLOBAL_FORMATPERCENT, Global_FormatPercent, 0, 1, 5},
2165 {DISPID_GLOBAL_FORMATDATETIME, Global_FormatDateTime, 0, 1, 2},
2166 {DISPID_GLOBAL_WEEKDAYNAME, Global_WeekdayName, 0, 1, 3},
2167 {DISPID_GLOBAL_MONTHNAME, Global_MonthName, 0, 1, 2},
2168 {DISPID_GLOBAL_ROUND, Global_Round, 0, 1, 2},
2169 {DISPID_GLOBAL_ESCAPE, Global_Escape, 0, 1},
2170 {DISPID_GLOBAL_UNESCAPE, Global_Unescape, 0, 1},
2171 {DISPID_GLOBAL_EVAL, Global_Eval, 0, 1},
2172 {DISPID_GLOBAL_EXECUTE, Global_Execute, 0, 1},
2173 {DISPID_GLOBAL_EXECUTEGLOBAL, Global_ExecuteGlobal, 0, 1},
2174 {DISPID_GLOBAL_GETREF, Global_GetRef, 0, 1},
2175 {DISPID_GLOBAL_VBMSGBOXHELPBUTTON, NULL, BP_GET, VT_I4, MB_HELP},
2176 {DISPID_GLOBAL_VBMSGBOXSETFOREGROUND, NULL, BP_GET, VT_I4, MB_SETFOREGROUND},
2177 {DISPID_GLOBAL_VBMSGBOXRIGHT, NULL, BP_GET, VT_I4, MB_RIGHT},
2178 {DISPID_GLOBAL_VBMSGBOXRTLREADING, NULL, BP_GET, VT_I4, MB_RTLREADING}
2179 };
2180
2181 static HRESULT Err_Description(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
2182 {
2183 FIXME("\n");
2184 return E_NOTIMPL;
2185 }
2186
2187 static HRESULT Err_HelpContext(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
2188 {
2189 FIXME("\n");
2190 return E_NOTIMPL;
2191 }
2192
2193 static HRESULT Err_HelpFile(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
2194 {
2195 FIXME("\n");
2196 return E_NOTIMPL;
2197 }
2198
2199 static HRESULT Err_Number(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
2200 {
2201 HRESULT hres;
2202
2203 TRACE("\n");
2204
2205 if(!This->desc)
2206 return E_UNEXPECTED;
2207
2208 if(args_cnt) {
2209 FIXME("setter not implemented\n");
2210 return E_NOTIMPL;
2211 }
2212
2213 hres = This->desc->ctx->err_number;
2214 return return_int(res, HRESULT_FACILITY(hres) == FACILITY_VBS ? HRESULT_CODE(hres) : hres);
2215 }
2216
2217 static HRESULT Err_Source(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
2218 {
2219 FIXME("\n");
2220 return E_NOTIMPL;
2221 }
2222
2223 static HRESULT Err_Clear(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
2224 {
2225 TRACE("\n");
2226
2227 if(!This->desc)
2228 return E_UNEXPECTED;
2229
2230 This->desc->ctx->err_number = S_OK;
2231 return S_OK;
2232 }
2233
2234 static HRESULT Err_Raise(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
2235 {
2236 FIXME("\n");
2237 return E_NOTIMPL;
2238 }
2239
2240 static const builtin_prop_t err_props[] = {
2241 {DISPID_ERR_DESCRIPTION, Err_Description, BP_GETPUT},
2242 {DISPID_ERR_HELPCONTEXT, Err_HelpContext, BP_GETPUT},
2243 {DISPID_ERR_HELPFILE, Err_HelpFile, BP_GETPUT},
2244 {DISPID_ERR_NUMBER, Err_Number, BP_GETPUT},
2245 {DISPID_ERR_SOURCE, Err_Source, BP_GETPUT},
2246 {DISPID_ERR_CLEAR, Err_Clear},
2247 {DISPID_ERR_RAISE, Err_Raise, 0, 5},
2248 };
2249
2250 HRESULT init_global(script_ctx_t *ctx)
2251 {
2252 HRESULT hres;
2253
2254 ctx->global_desc.ctx = ctx;
2255 ctx->global_desc.builtin_prop_cnt = sizeof(global_props)/sizeof(*global_props);
2256 ctx->global_desc.builtin_props = global_props;
2257
2258 hres = get_typeinfo(GlobalObj_tid, &ctx->global_desc.typeinfo);
2259 if(FAILED(hres))
2260 return hres;
2261
2262 hres = create_vbdisp(&ctx->global_desc, &ctx->global_obj);
2263 if(FAILED(hres))
2264 return hres;
2265
2266 hres = create_script_disp(ctx, &ctx->script_obj);
2267 if(FAILED(hres))
2268 return hres;
2269
2270 ctx->err_desc.ctx = ctx;
2271 ctx->err_desc.builtin_prop_cnt = sizeof(err_props)/sizeof(*err_props);
2272 ctx->err_desc.builtin_props = err_props;
2273
2274 hres = get_typeinfo(ErrObj_tid, &ctx->err_desc.typeinfo);
2275 if(FAILED(hres))
2276 return hres;
2277
2278 return create_vbdisp(&ctx->err_desc, &ctx->err_obj);
2279 }
Windows API implementation