git.oblomov.eu Git - wine/blob - dlls/jscript/global.c

   1 /*
   2  * Copyright 2008 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 "config.h"
  20 #include "wine/port.h"
  21
  22 #include <math.h>
  23 #include <limits.h>
  24
  25 #include "jscript.h"
  26 #include "engine.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  31
  32 #define LONGLONG_MAX (((LONGLONG)0x7fffffff<<32)|0xffffffff)
  33
  34 static const WCHAR NaNW[] = {'N','a','N',0};
  35 static const WCHAR InfinityW[] = {'I','n','f','i','n','i','t','y',0};
  36 static const WCHAR ArrayW[] = {'A','r','r','a','y',0};
  37 static const WCHAR BooleanW[] = {'B','o','o','l','e','a','n',0};
  38 static const WCHAR DateW[] = {'D','a','t','e',0};
  39 static const WCHAR ErrorW[] = {'E','r','r','o','r',0};
  40 static const WCHAR EvalErrorW[] = {'E','v','a','l','E','r','r','o','r',0};
  41 static const WCHAR RangeErrorW[] = {'R','a','n','g','e','E','r','r','o','r',0};
  42 static const WCHAR ReferenceErrorW[] = {'R','e','f','e','r','e','n','c','e','E','r','r','o','r',0};
  43 static const WCHAR SyntaxErrorW[] = {'S','y','n','t','a','x','E','r','r','o','r',0};
  44 static const WCHAR TypeErrorW[] = {'T','y','p','e','E','r','r','o','r',0};
  45 static const WCHAR URIErrorW[] = {'U','R','I','E','r','r','o','r',0};
  46 static const WCHAR FunctionW[] = {'F','u','n','c','t','i','o','n',0};
  47 static const WCHAR NumberW[] = {'N','u','m','b','e','r',0};
  48 static const WCHAR ObjectW[] = {'O','b','j','e','c','t',0};
  49 static const WCHAR StringW[] = {'S','t','r','i','n','g',0};
  50 static const WCHAR RegExpW[] = {'R','e','g','E','x','p',0};
  51 static const WCHAR RegExpErrorW[] = {'R','e','g','E','x','p','E','r','r','o','r',0};
  52 static const WCHAR ActiveXObjectW[] = {'A','c','t','i','v','e','X','O','b','j','e','c','t',0};
  53 static const WCHAR VBArrayW[] = {'V','B','A','r','r','a','y',0};
  54 static const WCHAR EnumeratorW[] = {'E','n','u','m','e','r','a','t','o','r',0};
  55 static const WCHAR escapeW[] = {'e','s','c','a','p','e',0};
  56 static const WCHAR evalW[] = {'e','v','a','l',0};
  57 static const WCHAR isNaNW[] = {'i','s','N','a','N',0};
  58 static const WCHAR isFiniteW[] = {'i','s','F','i','n','i','t','e',0};
  59 static const WCHAR parseIntW[] = {'p','a','r','s','e','I','n','t',0};
  60 static const WCHAR parseFloatW[] = {'p','a','r','s','e','F','l','o','a','t',0};
  61 static const WCHAR unescapeW[] = {'u','n','e','s','c','a','p','e',0};
  62 static const WCHAR _GetObjectW[] = {'G','e','t','O','b','j','e','c','t',0};
  63 static const WCHAR ScriptEngineW[] = {'S','c','r','i','p','t','E','n','g','i','n','e',0};
  64 static const WCHAR ScriptEngineMajorVersionW[] =
  65     {'S','c','r','i','p','t','E','n','g','i','n','e','M','a','j','o','r','V','e','r','s','i','o','n',0};
  66 static const WCHAR ScriptEngineMinorVersionW[] =
  67     {'S','c','r','i','p','t','E','n','g','i','n','e','M','i','n','o','r','V','e','r','s','i','o','n',0};
  68 static const WCHAR ScriptEngineBuildVersionW[] =
  69     {'S','c','r','i','p','t','E','n','g','i','n','e','B','u','i','l','d','V','e','r','s','i','o','n',0};
  70 static const WCHAR CollectGarbageW[] = {'C','o','l','l','e','c','t','G','a','r','b','a','g','e',0};
  71 static const WCHAR MathW[] = {'M','a','t','h',0};
  72 static const WCHAR encodeURIW[] = {'e','n','c','o','d','e','U','R','I',0};
  73 static const WCHAR decodeURIW[] = {'d','e','c','o','d','e','U','R','I',0};
  74 static const WCHAR encodeURIComponentW[] = {'e','n','c','o','d','e','U','R','I','C','o','m','p','o','n','e','n','t',0};
  75 static const WCHAR decodeURIComponentW[] = {'d','e','c','o','d','e','U','R','I','C','o','m','p','o','n','e','n','t',0};
  76
  77 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
  78
  79 static int uri_char_table[] = {
  80     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 00-0f */
  81     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 10-1f */
  82     0,2,0,0,1,0,1,2,2,2,2,1,1,2,2,1, /* 20-2f */
  83     2,2,2,2,2,2,2,2,2,2,1,1,0,1,0,1, /* 30-3f */
  84     1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 40-4f */
  85     2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,2, /* 50-5f */
  86     0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* 60-6f */
  87     2,2,2,2,2,2,2,2,2,2,2,0,0,0,2,0, /* 70-7f */
  88 };
  89
  90 /* 1 - reserved */
  91 /* 2 - unescaped */
  92
  93 static inline BOOL is_uri_reserved(WCHAR c)
  94 {
  95     return c < 128 && uri_char_table[c] == 1;
  96 }
  97
  98 static inline BOOL is_uri_unescaped(WCHAR c)
  99 {
 100     return c < 128 && uri_char_table[c] == 2;
 101 }
 102
 103 /* Check that the character is one of the 69 non-blank characters as defined by ECMA-262 B.2.1 */
 104 static inline BOOL is_ecma_nonblank(const WCHAR c)
 105 {
 106     return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
 107         c == '@' || c == '*' || c == '_' || c == '+' || c == '-' || c == '.' || c == '/');
 108 }
 109
 110 static WCHAR int_to_char(int i)
 111 {
 112     if(i < 10)
 113         return '0'+i;
 114     return 'A'+i-10;
 115 }
 116
 117 static HRESULT constructor_call(jsdisp_t *constr, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 118 {
 119     if(flags != DISPATCH_PROPERTYGET)
 120         return jsdisp_call_value(constr, NULL, flags, argc, argv, r);
 121
 122     *r = jsval_obj(jsdisp_addref(constr));
 123     return S_OK;
 124 }
 125
 126 static HRESULT JSGlobal_Array(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 127         jsval_t *r)
 128 {
 129     TRACE("\n");
 130
 131     return constructor_call(ctx->array_constr, flags, argc, argv, r);
 132 }
 133
 134 static HRESULT JSGlobal_Boolean(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 135         jsval_t *r)
 136 {
 137     TRACE("\n");
 138
 139     return constructor_call(ctx->bool_constr, flags, argc, argv, r);
 140 }
 141
 142 static HRESULT JSGlobal_Date(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 143         jsval_t *r)
 144 {
 145     TRACE("\n");
 146
 147     return constructor_call(ctx->date_constr, flags, argc, argv, r);
 148 }
 149
 150 static HRESULT JSGlobal_Error(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 151         jsval_t *r)
 152 {
 153     TRACE("\n");
 154
 155     return constructor_call(ctx->error_constr, flags, argc, argv, r);
 156 }
 157
 158 static HRESULT JSGlobal_EvalError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 159         jsval_t *r)
 160 {
 161     TRACE("\n");
 162
 163     return constructor_call(ctx->eval_error_constr, flags, argc, argv, r);
 164 }
 165
 166 static HRESULT JSGlobal_RangeError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 167         jsval_t *r)
 168 {
 169     TRACE("\n");
 170
 171     return constructor_call(ctx->range_error_constr, flags, argc, argv, r);
 172 }
 173
 174 static HRESULT JSGlobal_RegExpError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 175         jsval_t *r)
 176 {
 177     TRACE("\n");
 178
 179     return constructor_call(ctx->regexp_error_constr, flags, argc, argv, r);
 180 }
 181
 182 static HRESULT JSGlobal_ReferenceError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 183         jsval_t *r)
 184 {
 185     TRACE("\n");
 186
 187     return constructor_call(ctx->reference_error_constr, flags, argc, argv, r);
 188 }
 189
 190 static HRESULT JSGlobal_SyntaxError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 191         jsval_t *r)
 192 {
 193     TRACE("\n");
 194
 195     return constructor_call(ctx->syntax_error_constr, flags, argc, argv, r);
 196 }
 197
 198 static HRESULT JSGlobal_TypeError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 199         jsval_t *r)
 200 {
 201     TRACE("\n");
 202
 203     return constructor_call(ctx->type_error_constr, flags, argc, argv, r);
 204 }
 205
 206 static HRESULT JSGlobal_URIError(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 207         jsval_t *r)
 208 {
 209     TRACE("\n");
 210
 211     return constructor_call(ctx->uri_error_constr, flags, argc, argv, r);
 212 }
 213
 214 static HRESULT JSGlobal_Function(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 215         jsval_t *r)
 216 {
 217     TRACE("\n");
 218
 219     return constructor_call(ctx->function_constr, flags, argc, argv, r);
 220 }
 221
 222 static HRESULT JSGlobal_Number(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 223         jsval_t *r)
 224 {
 225     TRACE("\n");
 226
 227     return constructor_call(ctx->number_constr, flags, argc, argv, r);
 228 }
 229
 230 static HRESULT JSGlobal_Object(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 231         jsval_t *r)
 232 {
 233     TRACE("\n");
 234
 235     return constructor_call(ctx->object_constr, flags, argc, argv, r);
 236 }
 237
 238 static HRESULT JSGlobal_String(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 239         jsval_t *r)
 240 {
 241     TRACE("\n");
 242
 243     return constructor_call(ctx->string_constr, flags, argc, argv, r);
 244 }
 245
 246 static HRESULT JSGlobal_RegExp(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 247         jsval_t *r)
 248 {
 249     TRACE("\n");
 250
 251     return constructor_call(ctx->regexp_constr, flags, argc, argv, r);
 252 }
 253
 254 static HRESULT JSGlobal_ActiveXObject(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 255         jsval_t *r)
 256 {
 257     TRACE("\n");
 258
 259     return constructor_call(ctx->activex_constr, flags, argc, argv, r);
 260 }
 261
 262 static HRESULT JSGlobal_VBArray(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 263         jsval_t *r)
 264 {
 265     TRACE("\n");
 266
 267     return constructor_call(ctx->vbarray_constr, flags, argc, argv, r);
 268 }
 269
 270 static HRESULT JSGlobal_Enumerator(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 271         jsval_t *r)
 272 {
 273     FIXME("\n");
 274     return E_NOTIMPL;
 275 }
 276
 277 static HRESULT JSGlobal_escape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 278         jsval_t *r)
 279 {
 280     BSTR ret, str;
 281     const WCHAR *ptr;
 282     DWORD len = 0;
 283     HRESULT hres;
 284
 285     TRACE("\n");
 286
 287     if(!argc) {
 288         if(r) {
 289             ret = SysAllocString(undefinedW);
 290             if(!ret)
 291                 return E_OUTOFMEMORY;
 292
 293             *r = jsval_string(ret);
 294         }
 295
 296         return S_OK;
 297     }
 298
 299     hres = to_string(ctx, argv[0], &str);
 300     if(FAILED(hres))
 301         return hres;
 302
 303     for(ptr=str; *ptr; ptr++) {
 304         if(*ptr > 0xff)
 305             len += 6;
 306         else if(is_ecma_nonblank(*ptr))
 307             len++;
 308         else
 309             len += 3;
 310     }
 311
 312     ret = SysAllocStringLen(NULL, len);
 313     if(!ret) {
 314         SysFreeString(str);
 315         return E_OUTOFMEMORY;
 316     }
 317
 318     len = 0;
 319     for(ptr=str; *ptr; ptr++) {
 320         if(*ptr > 0xff) {
 321             ret[len++] = '%';
 322             ret[len++] = 'u';
 323             ret[len++] = int_to_char(*ptr >> 12);
 324             ret[len++] = int_to_char((*ptr >> 8) & 0xf);
 325             ret[len++] = int_to_char((*ptr >> 4) & 0xf);
 326             ret[len++] = int_to_char(*ptr & 0xf);
 327         }
 328         else if(is_ecma_nonblank(*ptr))
 329             ret[len++] = *ptr;
 330         else {
 331             ret[len++] = '%';
 332             ret[len++] = int_to_char(*ptr >> 4);
 333             ret[len++] = int_to_char(*ptr & 0xf);
 334         }
 335     }
 336
 337     SysFreeString(str);
 338
 339     if(r)
 340         *r = jsval_string(ret);
 341     else
 342         SysFreeString(ret);
 343     return S_OK;
 344 }
 345
 346 /* ECMA-262 3rd Edition    15.1.2.1 */
 347 static HRESULT JSGlobal_eval(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 348         jsval_t *r)
 349 {
 350     bytecode_t *code;
 351     HRESULT hres;
 352
 353     TRACE("\n");
 354
 355     if(!argc) {
 356         if(r)
 357             *r = jsval_undefined();
 358         return S_OK;
 359     }
 360
 361     if(!is_string(argv[0])) {
 362         if(r)
 363             return jsval_copy(argv[0], r);
 364         return S_OK;
 365     }
 366
 367     if(!ctx->exec_ctx) {
 368         FIXME("No active exec_ctx\n");
 369         return E_UNEXPECTED;
 370     }
 371
 372     TRACE("parsing %s\n", debugstr_jsval(argv[0]));
 373     hres = compile_script(ctx, get_string(argv[0]), NULL, TRUE, FALSE, &code);
 374     if(FAILED(hres)) {
 375         WARN("parse (%s) failed: %08x\n", debugstr_jsval(argv[0]), hres);
 376         return throw_syntax_error(ctx, hres, NULL);
 377     }
 378
 379     hres = exec_source(ctx->exec_ctx, code, &code->global_code, TRUE, r);
 380     release_bytecode(code);
 381     return hres;
 382 }
 383
 384 static HRESULT JSGlobal_isNaN(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 385         jsval_t *r)
 386 {
 387     BOOL ret = TRUE;
 388     double n;
 389     HRESULT hres;
 390
 391     TRACE("\n");
 392
 393     if(argc) {
 394         hres = to_number(ctx, argv[0], &n);
 395         if(FAILED(hres))
 396             return hres;
 397
 398         if(!isnan(n))
 399             ret = FALSE;
 400     }
 401
 402     if(r)
 403         *r = jsval_bool(ret);
 404     return S_OK;
 405 }
 406
 407 static HRESULT JSGlobal_isFinite(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 408         jsval_t *r)
 409 {
 410     BOOL ret = FALSE;
 411     HRESULT hres;
 412
 413     TRACE("\n");
 414
 415     if(argc) {
 416         double n;
 417
 418         hres = to_number(ctx, argv[0], &n);
 419         if(FAILED(hres))
 420             return hres;
 421
 422         if(!isinf(n) && !isnan(n))
 423             ret = TRUE;
 424     }
 425
 426     if(r)
 427         *r = jsval_bool(ret);
 428     return S_OK;
 429 }
 430
 431 static INT char_to_int(WCHAR c)
 432 {
 433     if('0' <= c && c <= '9')
 434         return c - '0';
 435     if('a' <= c && c <= 'z')
 436         return c - 'a' + 10;
 437     if('A' <= c && c <= 'Z')
 438         return c - 'A' + 10;
 439     return 100;
 440 }
 441
 442 static HRESULT JSGlobal_parseInt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 443         jsval_t *r)
 444 {
 445     BOOL neg = FALSE, empty = TRUE;
 446     DOUBLE ret = 0.0;
 447     INT radix=0, i;
 448     WCHAR *ptr;
 449     BSTR str;
 450     HRESULT hres;
 451
 452     if(!argc) {
 453         if(r)
 454             *r = jsval_number(NAN);
 455         return S_OK;
 456     }
 457
 458     if(argc >= 2) {
 459         hres = to_int32(ctx, argv[1], &radix);
 460         if(FAILED(hres))
 461             return hres;
 462
 463         if(radix && (radix < 2 || radix > 36)) {
 464             WARN("radix %d out of range\n", radix);
 465             if(r)
 466                 *r = jsval_number(NAN);
 467             return S_OK;
 468         }
 469     }
 470
 471     hres = to_string(ctx, argv[0], &str);
 472     if(FAILED(hres))
 473         return hres;
 474
 475     for(ptr = str; isspaceW(*ptr); ptr++);
 476
 477     switch(*ptr) {
 478     case '+':
 479         ptr++;
 480         break;
 481     case '-':
 482         neg = TRUE;
 483         ptr++;
 484         break;
 485     }
 486
 487     if(!radix) {
 488         if(*ptr == '0') {
 489             if(ptr[1] == 'x' || ptr[1] == 'X') {
 490                 radix = 16;
 491                 ptr += 2;
 492             }else {
 493                 radix = 8;
 494                 ptr++;
 495                 empty = FALSE;
 496             }
 497         }else {
 498             radix = 10;
 499         }
 500     }
 501
 502     i = char_to_int(*ptr++);
 503     if(i < radix) {
 504         do {
 505             ret = ret*radix + i;
 506             i = char_to_int(*ptr++);
 507         }while(i < radix);
 508     }else if(empty) {
 509         ret = NAN;
 510     }
 511
 512     SysFreeString(str);
 513
 514     if(neg)
 515         ret = -ret;
 516
 517     if(r)
 518         *r = jsval_number(ret);
 519     return S_OK;
 520 }
 521
 522 static HRESULT JSGlobal_parseFloat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 523         jsval_t *r)
 524 {
 525     LONGLONG d = 0, hlp;
 526     int exp = 0;
 527     WCHAR *str;
 528     BSTR val_str = NULL;
 529     BOOL ret_nan = TRUE, positive = TRUE;
 530     HRESULT hres;
 531
 532     if(!argc) {
 533         if(r)
 534             *r = jsval_number(NAN);
 535         return S_OK;
 536     }
 537
 538     hres = to_string(ctx, argv[0], &val_str);
 539     if(FAILED(hres))
 540         return hres;
 541
 542     str = val_str;
 543
 544     while(isspaceW(*str)) str++;
 545
 546     if(*str == '+')
 547         str++;
 548     else if(*str == '-') {
 549         positive = FALSE;
 550         str++;
 551     }
 552
 553     if(isdigitW(*str))
 554         ret_nan = FALSE;
 555
 556     while(isdigitW(*str)) {
 557         hlp = d*10 + *(str++) - '0';
 558         if(d>LONGLONG_MAX/10 || hlp<0) {
 559             exp++;
 560             break;
 561         }
 562         else
 563             d = hlp;
 564     }
 565     while(isdigitW(*str)) {
 566         exp++;
 567         str++;
 568     }
 569
 570     if(*str == '.') str++;
 571
 572     if(isdigitW(*str))
 573         ret_nan = FALSE;
 574
 575     while(isdigitW(*str)) {
 576         hlp = d*10 + *(str++) - '0';
 577         if(d>LONGLONG_MAX/10 || hlp<0)
 578             break;
 579
 580         d = hlp;
 581         exp--;
 582     }
 583     while(isdigitW(*str))
 584         str++;
 585
 586     if(*str && !ret_nan && (*str=='e' || *str=='E')) {
 587         int sign = 1, e = 0;
 588
 589         str++;
 590         if(*str == '+')
 591             str++;
 592         else if(*str == '-') {
 593             sign = -1;
 594             str++;
 595         }
 596
 597         while(isdigitW(*str)) {
 598             if(e>INT_MAX/10 || (e = e*10 + *str++ - '0')<0)
 599                 e = INT_MAX;
 600         }
 601         e *= sign;
 602
 603         if(exp<0 && e<0 && exp+e>0) exp = INT_MIN;
 604         else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX;
 605         else exp += e;
 606     }
 607
 608     SysFreeString(val_str);
 609
 610     if(ret_nan) {
 611         if(r)
 612             *r = jsval_number(NAN);
 613         return S_OK;
 614     }
 615
 616     if(!positive)
 617         d = -d;
 618     if(r)
 619         *r = jsval_number(exp>0 ? d*pow(10, exp) : d/pow(10, -exp));
 620     return S_OK;
 621 }
 622
 623 static inline int hex_to_int(const WCHAR wch) {
 624     if(toupperW(wch)>='A' && toupperW(wch)<='F') return toupperW(wch)-'A'+10;
 625     if(isdigitW(wch)) return wch-'0';
 626     return -1;
 627 }
 628
 629 static HRESULT JSGlobal_unescape(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 630         jsval_t *r)
 631 {
 632     BSTR ret, str;
 633     const WCHAR *ptr;
 634     DWORD len = 0;
 635     HRESULT hres;
 636
 637     TRACE("\n");
 638
 639     if(!argc) {
 640         if(r) {
 641             ret = SysAllocString(undefinedW);
 642             if(!ret)
 643                 return E_OUTOFMEMORY;
 644             *r = jsval_string(ret);
 645         }
 646
 647         return S_OK;
 648     }
 649
 650     hres = to_string(ctx, argv[0], &str);
 651     if(FAILED(hres))
 652         return hres;
 653
 654     for(ptr=str; *ptr; ptr++) {
 655         if(*ptr == '%') {
 656             if(hex_to_int(*(ptr+1))!=-1 && hex_to_int(*(ptr+2))!=-1)
 657                 ptr += 2;
 658             else if(*(ptr+1)=='u' && hex_to_int(*(ptr+2))!=-1 && hex_to_int(*(ptr+3))!=-1
 659                     && hex_to_int(*(ptr+4))!=-1 && hex_to_int(*(ptr+5))!=-1)
 660                 ptr += 5;
 661         }
 662
 663         len++;
 664     }
 665
 666     ret = SysAllocStringLen(NULL, len);
 667     if(!ret) {
 668         SysFreeString(str);
 669         return E_OUTOFMEMORY;
 670     }
 671
 672     len = 0;
 673     for(ptr=str; *ptr; ptr++) {
 674         if(*ptr == '%') {
 675             if(hex_to_int(*(ptr+1))!=-1 && hex_to_int(*(ptr+2))!=-1) {
 676                 ret[len] = (hex_to_int(*(ptr+1))<<4) + hex_to_int(*(ptr+2));
 677                 ptr += 2;
 678             }
 679             else if(*(ptr+1)=='u' && hex_to_int(*(ptr+2))!=-1 && hex_to_int(*(ptr+3))!=-1
 680                     && hex_to_int(*(ptr+4))!=-1 && hex_to_int(*(ptr+5))!=-1) {
 681                 ret[len] = (hex_to_int(*(ptr+2))<<12) + (hex_to_int(*(ptr+3))<<8)
 682                     + (hex_to_int(*(ptr+4))<<4) + hex_to_int(*(ptr+5));
 683                 ptr += 5;
 684             }
 685             else
 686                 ret[len] = *ptr;
 687         }
 688         else
 689             ret[len] = *ptr;
 690
 691         len++;
 692     }
 693
 694     SysFreeString(str);
 695
 696     if(r)
 697         *r = jsval_string(ret);
 698     else
 699         SysFreeString(ret);
 700     return S_OK;
 701 }
 702
 703 static HRESULT JSGlobal_GetObject(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 704         jsval_t *r)
 705 {
 706     FIXME("\n");
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT JSGlobal_ScriptEngine(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 711         jsval_t *r)
 712 {
 713     static const WCHAR JScriptW[] = {'J','S','c','r','i','p','t',0};
 714
 715     TRACE("\n");
 716
 717     if(r) {
 718         BSTR ret;
 719
 720         ret = SysAllocString(JScriptW);
 721         if(!ret)
 722             return E_OUTOFMEMORY;
 723
 724         *r = jsval_string(ret);
 725     }
 726
 727     return S_OK;
 728 }
 729
 730 static HRESULT JSGlobal_ScriptEngineMajorVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 731         jsval_t *r)
 732 {
 733     TRACE("\n");
 734
 735     if(r)
 736         *r = jsval_number(JSCRIPT_MAJOR_VERSION);
 737     return S_OK;
 738 }
 739
 740 static HRESULT JSGlobal_ScriptEngineMinorVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 741         jsval_t *r)
 742 {
 743     TRACE("\n");
 744
 745     if(r)
 746         *r = jsval_number(JSCRIPT_MINOR_VERSION);
 747     return S_OK;
 748 }
 749
 750 static HRESULT JSGlobal_ScriptEngineBuildVersion(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 751         jsval_t *r)
 752 {
 753     TRACE("\n");
 754
 755     if(r)
 756         *r = jsval_number(JSCRIPT_BUILD_VERSION);
 757     return S_OK;
 758 }
 759
 760 static HRESULT JSGlobal_CollectGarbage(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 761         jsval_t *r)
 762 {
 763     FIXME("\n");
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT JSGlobal_encodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 768         jsval_t *r)
 769 {
 770     const WCHAR *ptr;
 771     DWORD len = 0, i;
 772     char buf[4];
 773     BSTR str, ret;
 774     WCHAR *rptr;
 775     HRESULT hres;
 776
 777     TRACE("\n");
 778
 779     if(!argc) {
 780         if(r) {
 781             ret = SysAllocString(undefinedW);
 782             if(!ret)
 783                 return E_OUTOFMEMORY;
 784
 785             *r = jsval_string(ret);
 786         }
 787
 788         return S_OK;
 789     }
 790
 791     hres = to_string(ctx, argv[0], &str);
 792     if(FAILED(hres))
 793         return hres;
 794
 795     for(ptr = str; *ptr; ptr++) {
 796         if(is_uri_unescaped(*ptr) || is_uri_reserved(*ptr) || *ptr == '#') {
 797             len++;
 798         }else {
 799             i = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, NULL, 0, NULL, NULL)*3;
 800             if(!i) {
 801                 SysFreeString(str);
 802                 return throw_uri_error(ctx, JS_E_INVALID_URI_CHAR, NULL);
 803             }
 804
 805             len += i;
 806         }
 807     }
 808
 809     rptr = ret = SysAllocStringLen(NULL, len);
 810     if(!ret) {
 811         SysFreeString(str);
 812         return E_OUTOFMEMORY;
 813     }
 814
 815     for(ptr = str; *ptr; ptr++) {
 816         if(is_uri_unescaped(*ptr) || is_uri_reserved(*ptr) || *ptr == '#') {
 817             *rptr++ = *ptr;
 818         }else {
 819             len = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, buf, sizeof(buf), NULL, NULL);
 820             for(i=0; i<len; i++) {
 821                 *rptr++ = '%';
 822                 *rptr++ = int_to_char((BYTE)buf[i] >> 4);
 823                 *rptr++ = int_to_char(buf[i] & 0x0f);
 824             }
 825         }
 826     }
 827
 828     TRACE("%s -> %s\n", debugstr_w(str), debugstr_w(ret));
 829     SysFreeString(str);
 830
 831     if(r)
 832         *r = jsval_string(ret);
 833     else
 834         SysFreeString(ret);
 835     return S_OK;
 836 }
 837
 838 static HRESULT JSGlobal_decodeURI(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 839         jsval_t *r)
 840 {
 841     BSTR str, ret;
 842     WCHAR *ptr;
 843     int i, len = 0, val, res;
 844     char buf[4];
 845     WCHAR out;
 846     HRESULT hres;
 847
 848     TRACE("\n");
 849
 850     if(!argc) {
 851         if(r) {
 852             ret = SysAllocString(undefinedW);
 853             if(!ret)
 854                 return E_OUTOFMEMORY;
 855
 856             *r = jsval_string(ret);
 857         }
 858
 859         return S_OK;
 860     }
 861
 862     hres = to_string(ctx, argv[0], &str);
 863     if(FAILED(hres))
 864         return hres;
 865
 866     for(ptr=str; *ptr; ptr++) {
 867         if(*ptr != '%') {
 868             len++;
 869         }else {
 870             res = 0;
 871             for(i=0; i<4; i++) {
 872                 if(ptr[i*3]!='%' || hex_to_int(ptr[i*3+1])==-1 || (val=hex_to_int(ptr[i*3+2]))==-1)
 873                     break;
 874                 val += hex_to_int(ptr[i*3+1])<<4;
 875                 buf[i] = val;
 876
 877                 res = MultiByteToWideChar(CP_UTF8, 0, buf, i+1, &out, 1);
 878                 if(res)
 879                     break;
 880             }
 881
 882             if(!res) {
 883                 SysFreeString(str);
 884                 return throw_uri_error(ctx, JS_E_INVALID_URI_CODING, NULL);
 885             }
 886
 887             ptr += i*3+2;
 888             len++;
 889         }
 890     }
 891
 892     ret = SysAllocStringLen(NULL, len);
 893     if(!ret) {
 894         SysFreeString(str);
 895         return E_OUTOFMEMORY;
 896     }
 897
 898     len = 0;
 899     for(ptr=str; *ptr; ptr++) {
 900         if(*ptr != '%') {
 901             ret[len] = *ptr;
 902             len++;
 903         }else {
 904             for(i=0; i<4; i++) {
 905                 if(ptr[i*3]!='%' || hex_to_int(ptr[i*3+1])==-1 || (val=hex_to_int(ptr[i*3+2]))==-1)
 906                     break;
 907                 val += hex_to_int(ptr[i*3+1])<<4;
 908                 buf[i] = val;
 909
 910                 res = MultiByteToWideChar(CP_UTF8, 0, buf, i+1, ret+len, 1);
 911                 if(res)
 912                     break;
 913             }
 914
 915             ptr += i*3+2;
 916             len++;
 917         }
 918     }
 919
 920     TRACE("%s -> %s\n", debugstr_w(str), debugstr_w(ret));
 921     SysFreeString(str);
 922
 923     if(r)
 924         *r = jsval_string(ret);
 925     else
 926         SysFreeString(ret);
 927     return S_OK;
 928 }
 929
 930 static HRESULT JSGlobal_encodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 931         jsval_t *r)
 932 {
 933     BSTR str, ret;
 934     char buf[4];
 935     const WCHAR *ptr;
 936     DWORD len = 0, size, i;
 937     HRESULT hres;
 938
 939     TRACE("\n");
 940
 941     if(!argc) {
 942         if(r) {
 943             ret = SysAllocString(undefinedW);
 944             if(!ret)
 945                 return E_OUTOFMEMORY;
 946
 947             *r = jsval_string(ret);
 948         }
 949
 950         return S_OK;
 951     }
 952
 953     hres = to_string(ctx, argv[0], &str);
 954     if(FAILED(hres))
 955         return hres;
 956
 957     for(ptr=str; *ptr; ptr++) {
 958         if(is_uri_unescaped(*ptr))
 959             len++;
 960         else {
 961             size = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, NULL, 0, NULL, NULL);
 962             if(!size) {
 963                 SysFreeString(str);
 964                 return throw_uri_error(ctx, JS_E_INVALID_URI_CHAR, NULL);
 965             }
 966             len += size*3;
 967         }
 968     }
 969
 970     ret = SysAllocStringLen(NULL, len);
 971     if(!ret) {
 972         SysFreeString(str);
 973         return E_OUTOFMEMORY;
 974     }
 975
 976     len = 0;
 977     for(ptr=str; *ptr; ptr++) {
 978         if(is_uri_unescaped(*ptr))
 979             ret[len++] = *ptr;
 980         else {
 981             size = WideCharToMultiByte(CP_UTF8, 0, ptr, 1, buf, sizeof(buf), NULL, NULL);
 982             for(i=0; i<size; i++) {
 983                 ret[len++] = '%';
 984                 ret[len++] = int_to_char((BYTE)buf[i] >> 4);
 985                 ret[len++] = int_to_char(buf[i] & 0x0f);
 986             }
 987         }
 988     }
 989
 990     SysFreeString(str);
 991
 992     if(r)
 993         *r = jsval_string(ret);
 994     else
 995         SysFreeString(ret);
 996     return S_OK;
 997 }
 998
 999 /* ECMA-262 3rd Edition    15.1.3.2 */
1000 static HRESULT JSGlobal_decodeURIComponent(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
1001         jsval_t *r)
1002 {
1003     BSTR str, ret;
1004     const WCHAR *ptr;
1005     WCHAR *out_ptr;
1006     DWORD len = 0;
1007     HRESULT hres;
1008
1009     TRACE("\n");
1010
1011     if(!argc) {
1012         if(r) {
1013             ret = SysAllocString(undefinedW);
1014             if(!ret)
1015                 return E_OUTOFMEMORY;
1016
1017             *r = jsval_string(ret);
1018         }
1019
1020         return S_OK;
1021     }
1022
1023     hres = to_string(ctx, argv[0], &str);
1024     if(FAILED(hres))
1025         return hres;
1026
1027     ptr = str;
1028     while(*ptr) {
1029         if(*ptr == '%') {
1030             char octets[4];
1031             unsigned char mask = 0x80;
1032             int i, size, num_bytes = 0;
1033             if(hex_to_int(*(ptr+1)) < 0 || hex_to_int(*(ptr+2)) < 0) {
1034                 FIXME("Throw URIError: Invalid hex sequence\n");
1035                 SysFreeString(str);
1036                 return E_FAIL;
1037             }
1038             octets[0] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1039             ptr += 3;
1040             while(octets[0] & mask) {
1041                 mask = mask >> 1;
1042                 ++num_bytes;
1043             }
1044             if(num_bytes == 1 || num_bytes > 4) {
1045                 FIXME("Throw URIError: Invalid initial UTF character\n");
1046                 SysFreeString(str);
1047                 return E_FAIL;
1048             }
1049             for(i = 1; i < num_bytes; ++i) {
1050                 if(*ptr != '%'){
1051                     FIXME("Throw URIError: Incomplete UTF sequence\n");
1052                     SysFreeString(str);
1053                     return E_FAIL;
1054                 }
1055                 if(hex_to_int(*(ptr+1)) < 0 || hex_to_int(*(ptr+2)) < 0) {
1056                     FIXME("Throw URIError: Invalid hex sequence\n");
1057                     SysFreeString(str);
1058                     return E_FAIL;
1059                 }
1060                 octets[i] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1061                 ptr += 3;
1062             }
1063             size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, octets,
1064                     num_bytes ? num_bytes : 1, NULL, 0);
1065             if(size == 0) {
1066                 FIXME("Throw URIError: Invalid UTF sequence\n");
1067                 SysFreeString(str);
1068                 return E_FAIL;
1069             }
1070             len += size;
1071         }else {
1072             ++ptr;
1073             ++len;
1074         }
1075     }
1076
1077     out_ptr = ret = SysAllocStringLen(NULL, len);
1078     if(!ret) {
1079         SysFreeString(str);
1080         return E_OUTOFMEMORY;
1081     }
1082
1083     ptr = str;
1084     while(*ptr) {
1085         if(*ptr == '%') {
1086             char octets[4];
1087             unsigned char mask = 0x80;
1088             int i, size, num_bytes = 0;
1089             octets[0] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1090             ptr += 3;
1091             while(octets[0] & mask) {
1092                 mask = mask >> 1;
1093                 ++num_bytes;
1094             }
1095             for(i = 1; i < num_bytes; ++i) {
1096                 octets[i] = (hex_to_int(*(ptr+1)) << 4) + hex_to_int(*(ptr+2));
1097                 ptr += 3;
1098             }
1099             size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, octets,
1100                     num_bytes ? num_bytes : 1, out_ptr, len);
1101             len -= size;
1102             out_ptr += size;
1103         }else {
1104             *out_ptr++ = *ptr++;
1105             --len;
1106         }
1107     }
1108
1109     SysFreeString(str);
1110
1111     if(r)
1112         *r = jsval_string(ret);
1113     else
1114         SysFreeString(ret);
1115     return S_OK;
1116 }
1117
1118 static const builtin_prop_t JSGlobal_props[] = {
1119     {ActiveXObjectW,             JSGlobal_ActiveXObject,             PROPF_CONSTR|1},
1120     {ArrayW,                     JSGlobal_Array,                     PROPF_CONSTR|1},
1121     {BooleanW,                   JSGlobal_Boolean,                   PROPF_CONSTR|1},
1122     {CollectGarbageW,            JSGlobal_CollectGarbage,            PROPF_METHOD},
1123     {DateW,                      JSGlobal_Date,                      PROPF_CONSTR|7},
1124     {EnumeratorW,                JSGlobal_Enumerator,                PROPF_METHOD|7},
1125     {ErrorW,                     JSGlobal_Error,                     PROPF_CONSTR|1},
1126     {EvalErrorW,                 JSGlobal_EvalError,                 PROPF_CONSTR|1},
1127     {FunctionW,                  JSGlobal_Function,                  PROPF_CONSTR|1},
1128     {_GetObjectW,                JSGlobal_GetObject,                 PROPF_METHOD|2},
1129     {NumberW,                    JSGlobal_Number,                    PROPF_CONSTR|1},
1130     {ObjectW,                    JSGlobal_Object,                    PROPF_CONSTR|1},
1131     {RangeErrorW,                JSGlobal_RangeError,                PROPF_CONSTR|1},
1132     {ReferenceErrorW,            JSGlobal_ReferenceError,            PROPF_CONSTR|1},
1133     {RegExpW,                    JSGlobal_RegExp,                    PROPF_CONSTR|2},
1134     {RegExpErrorW,               JSGlobal_RegExpError,               PROPF_CONSTR|1},
1135     {ScriptEngineW,              JSGlobal_ScriptEngine,              PROPF_METHOD},
1136     {ScriptEngineBuildVersionW,  JSGlobal_ScriptEngineBuildVersion,  PROPF_METHOD},
1137     {ScriptEngineMajorVersionW,  JSGlobal_ScriptEngineMajorVersion,  PROPF_METHOD},
1138     {ScriptEngineMinorVersionW,  JSGlobal_ScriptEngineMinorVersion,  PROPF_METHOD},
1139     {StringW,                    JSGlobal_String,                    PROPF_CONSTR|1},
1140     {SyntaxErrorW,               JSGlobal_SyntaxError,               PROPF_CONSTR|1},
1141     {TypeErrorW,                 JSGlobal_TypeError,                 PROPF_CONSTR|1},
1142     {URIErrorW,                  JSGlobal_URIError,                  PROPF_CONSTR|1},
1143     {VBArrayW,                   JSGlobal_VBArray,                   PROPF_CONSTR|1},
1144     {decodeURIW,                 JSGlobal_decodeURI,                 PROPF_METHOD|1},
1145     {decodeURIComponentW,        JSGlobal_decodeURIComponent,        PROPF_METHOD|1},
1146     {encodeURIW,                 JSGlobal_encodeURI,                 PROPF_METHOD|1},
1147     {encodeURIComponentW,        JSGlobal_encodeURIComponent,        PROPF_METHOD|1},
1148     {escapeW,                    JSGlobal_escape,                    PROPF_METHOD|1},
1149     {evalW,                      JSGlobal_eval,                      PROPF_METHOD|1},
1150     {isFiniteW,                  JSGlobal_isFinite,                  PROPF_METHOD|1},
1151     {isNaNW,                     JSGlobal_isNaN,                     PROPF_METHOD|1},
1152     {parseFloatW,                JSGlobal_parseFloat,                PROPF_METHOD|1},
1153     {parseIntW,                  JSGlobal_parseInt,                  PROPF_METHOD|2},
1154     {unescapeW,                  JSGlobal_unescape,                  PROPF_METHOD|1}
1155 };
1156
1157 static const builtin_info_t JSGlobal_info = {
1158     JSCLASS_GLOBAL,
1159     {NULL, NULL, 0},
1160     sizeof(JSGlobal_props)/sizeof(*JSGlobal_props),
1161     JSGlobal_props,
1162     NULL,
1163     NULL
1164 };
1165
1166 static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
1167 {
1168     HRESULT hres;
1169
1170     hres = init_function_constr(ctx, object_prototype);
1171     if(FAILED(hres))
1172         return hres;
1173
1174     hres = create_object_constr(ctx, object_prototype, &ctx->object_constr);
1175     if(FAILED(hres))
1176         return hres;
1177
1178     hres = create_activex_constr(ctx, &ctx->activex_constr);
1179     if(FAILED(hres))
1180         return hres;
1181
1182     hres = create_array_constr(ctx, object_prototype, &ctx->array_constr);
1183     if(FAILED(hres))
1184         return hres;
1185
1186     hres = create_bool_constr(ctx, object_prototype, &ctx->bool_constr);
1187     if(FAILED(hres))
1188         return hres;
1189
1190     hres = create_date_constr(ctx, object_prototype, &ctx->date_constr);
1191     if(FAILED(hres))
1192         return hres;
1193
1194     hres = init_error_constr(ctx, object_prototype);
1195     if(FAILED(hres))
1196         return hres;
1197
1198     hres = create_number_constr(ctx, object_prototype, &ctx->number_constr);
1199     if(FAILED(hres))
1200         return hres;
1201
1202     hres = create_regexp_constr(ctx, object_prototype, &ctx->regexp_constr);
1203     if(FAILED(hres))
1204         return hres;
1205
1206     hres = create_string_constr(ctx, object_prototype, &ctx->string_constr);
1207     if(FAILED(hres))
1208         return hres;
1209
1210     hres = create_vbarray_constr(ctx, object_prototype, &ctx->vbarray_constr);
1211     if(FAILED(hres))
1212         return hres;
1213
1214     return S_OK;
1215 }
1216
1217 HRESULT init_global(script_ctx_t *ctx)
1218 {
1219     jsdisp_t *math, *object_prototype;
1220     HRESULT hres;
1221
1222     if(ctx->global)
1223         return S_OK;
1224
1225     hres = create_object_prototype(ctx, &object_prototype);
1226     if(FAILED(hres))
1227         return hres;
1228
1229     hres = init_constructors(ctx, object_prototype);
1230     jsdisp_release(object_prototype);
1231     if(FAILED(hres))
1232         return hres;
1233
1234     hres = create_dispex(ctx, &JSGlobal_info, NULL, &ctx->global);
1235     if(FAILED(hres))
1236         return hres;
1237
1238     hres = create_math(ctx, &math);
1239     if(FAILED(hres))
1240         return hres;
1241
1242     hres = jsdisp_propput_name(ctx->global, MathW, jsval_obj(math));
1243     jsdisp_release(math);
1244     if(FAILED(hres))
1245         return hres;
1246
1247     hres = jsdisp_propput_name(ctx->global, undefinedW, jsval_undefined());
1248     if(FAILED(hres))
1249         return hres;
1250
1251     hres = jsdisp_propput_name(ctx->global, NaNW, jsval_number(NAN));
1252     if(FAILED(hres))
1253         return hres;
1254
1255     hres = jsdisp_propput_name(ctx->global, InfinityW, jsval_number(INFINITY));
1256     return hres;
1257 }