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