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