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