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