reactos/dll/win32/vbscript/global.c

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