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