dlls/jscript/array.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
  20 #include <math.h>
  21 #include <assert.h>
  22
  23 #include "jscript.h"
  24
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  28
  29 typedef struct {
  30     jsdisp_t dispex;
  31
  32     DWORD length;
  33 } ArrayInstance;
  34
  35 static inline ArrayInstance *array_from_jsdisp(jsdisp_t *jsdisp)
  36 {
  37     return CONTAINING_RECORD(jsdisp, ArrayInstance, dispex);
  38 }
  39
  40 static inline ArrayInstance *array_this(jsval_t vthis)
  41 {
  42     jsdisp_t *jsdisp = is_object_instance(vthis) ? to_jsdisp(get_object(vthis)) : NULL;
  43     return (jsdisp && is_class(jsdisp, JSCLASS_ARRAY)) ? array_from_jsdisp(jsdisp) : NULL;
  44 }
  45
  46 unsigned array_get_length(jsdisp_t *array)
  47 {
  48     assert(is_class(array, JSCLASS_ARRAY));
  49     return array_from_jsdisp(array)->length;
  50 }
  51
  52 static HRESULT get_length(script_ctx_t *ctx, jsval_t vthis, jsdisp_t **jsthis, UINT32 *ret)
  53 {
  54     jsdisp_t *jsdisp;
  55     IDispatch *disp;
  56     jsval_t val;
  57     HRESULT hres;
  58
  59     hres = to_object(ctx, vthis, &disp);
  60     if(FAILED(hres))
  61         return hres;
  62
  63     jsdisp = iface_to_jsdisp(disp);
  64     IDispatch_Release(disp);
  65     if(!jsdisp)
  66         return JS_E_JSCRIPT_EXPECTED;
  67     *jsthis = jsdisp;
  68
  69     if(is_class(jsdisp, JSCLASS_ARRAY)) {
  70         *ret = array_from_jsdisp(jsdisp)->length;
  71         return S_OK;
  72     }
  73
  74     hres = jsdisp_propget_name(jsdisp, L"length", &val);
  75     if(SUCCEEDED(hres)) {
  76         hres = to_uint32(ctx, val, ret);
  77         jsval_release(val);
  78         if(SUCCEEDED(hres))
  79             return hres;
  80     }
  81
  82     jsdisp_release(jsdisp);
  83     return hres;
  84 }
  85
  86 static HRESULT set_length(jsdisp_t *obj, DWORD length)
  87 {
  88     if(is_class(obj, JSCLASS_ARRAY)) {
  89         array_from_jsdisp(obj)->length = length;
  90         return S_OK;
  91     }
  92
  93     return jsdisp_propput_name(obj, L"length", jsval_number(length));
  94 }
  95
  96 WCHAR *idx_to_str(DWORD idx, WCHAR *ptr)
  97 {
  98     if(!idx) {
  99         *ptr = '0';
 100         return ptr;
 101     }
 102
 103     while(idx) {
 104         *ptr-- = '0' + (idx%10);
 105         idx /= 10;
 106     }
 107
 108     return ptr+1;
 109 }
 110
 111 static HRESULT Array_get_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
 112 {
 113     TRACE("%p\n", jsthis);
 114
 115     *r = jsval_number(array_from_jsdisp(jsthis)->length);
 116     return S_OK;
 117 }
 118
 119 static HRESULT Array_set_length(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t value)
 120 {
 121     ArrayInstance *This = array_from_jsdisp(jsthis);
 122     DOUBLE len = -1;
 123     DWORD i;
 124     HRESULT hres;
 125
 126     TRACE("%p %ld\n", This, This->length);
 127
 128     hres = to_number(ctx, value, &len);
 129     if(FAILED(hres))
 130         return hres;
 131
 132     len = floor(len);
 133     if(len!=(DWORD)len)
 134         return JS_E_INVALID_LENGTH;
 135
 136     for(i=len; i < This->length; i++) {
 137         hres = jsdisp_delete_idx(&This->dispex, i);
 138         if(FAILED(hres))
 139             return hres;
 140     }
 141
 142     This->length = len;
 143     return S_OK;
 144 }
 145
 146 static HRESULT concat_array(jsdisp_t *array, ArrayInstance *obj, DWORD *len)
 147 {
 148     jsval_t val;
 149     DWORD i;
 150     HRESULT hres;
 151
 152     for(i=0; i < obj->length; i++) {
 153         hres = jsdisp_get_idx(&obj->dispex, i, &val);
 154         if(hres == DISP_E_UNKNOWNNAME)
 155             continue;
 156         if(FAILED(hres))
 157             return hres;
 158
 159         hres = jsdisp_propput_idx(array, *len+i, val);
 160         jsval_release(val);
 161         if(FAILED(hres))
 162             return hres;
 163     }
 164
 165     *len += obj->length;
 166     return S_OK;
 167 }
 168
 169 static HRESULT concat_obj(jsdisp_t *array, IDispatch *obj, DWORD *len)
 170 {
 171     jsdisp_t *jsobj;
 172     HRESULT hres;
 173
 174     jsobj = iface_to_jsdisp(obj);
 175     if(jsobj) {
 176         if(is_class(jsobj, JSCLASS_ARRAY)) {
 177             hres = concat_array(array, array_from_jsdisp(jsobj), len);
 178             jsdisp_release(jsobj);
 179             return hres;
 180         }
 181         jsdisp_release(jsobj);
 182     }
 183
 184     return jsdisp_propput_idx(array, (*len)++, jsval_disp(obj));
 185 }
 186
 187 static HRESULT Array_concat(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 188         jsval_t *r)
 189 {
 190     IDispatch *jsthis;
 191     jsdisp_t *ret;
 192     DWORD len = 0;
 193     HRESULT hres;
 194
 195     TRACE("\n");
 196
 197     hres = to_object(ctx, vthis, &jsthis);
 198     if(FAILED(hres))
 199         return hres;
 200
 201     hres = create_array(ctx, 0, &ret);
 202     if(FAILED(hres))
 203         goto done;
 204
 205     hres = concat_obj(ret, jsthis, &len);
 206     if(SUCCEEDED(hres)) {
 207         DWORD i;
 208
 209         for(i=0; i < argc; i++) {
 210             if(is_object_instance(argv[i]))
 211                 hres = concat_obj(ret, get_object(argv[i]), &len);
 212             else
 213                 hres = jsdisp_propput_idx(ret, len++, argv[i]);
 214             if(FAILED(hres))
 215                 break;
 216         }
 217     }
 218
 219     if(FAILED(hres))
 220         goto done;
 221
 222     if(r)
 223         *r = jsval_obj(ret);
 224     else
 225         jsdisp_release(ret);
 226 done:
 227     IDispatch_Release(jsthis);
 228     return S_OK;
 229 }
 230
 231 static HRESULT array_join(script_ctx_t *ctx, jsdisp_t *array, DWORD length, const WCHAR *sep,
 232         unsigned seplen, HRESULT (*to_string)(script_ctx_t*,jsval_t,jsstr_t**), jsval_t *r)
 233 {
 234     jsstr_t **str_tab, *ret = NULL;
 235     jsval_t val;
 236     DWORD i;
 237     HRESULT hres = E_FAIL;
 238
 239     if(!length) {
 240         if(r)
 241             *r = jsval_string(jsstr_empty());
 242         return S_OK;
 243     }
 244
 245     str_tab = calloc(length, sizeof(*str_tab));
 246     if(!str_tab)
 247         return E_OUTOFMEMORY;
 248
 249     for(i=0; i < length; i++) {
 250         hres = jsdisp_get_idx(array, i, &val);
 251         if(hres == DISP_E_UNKNOWNNAME) {
 252             hres = S_OK;
 253             continue;
 254         } else if(FAILED(hres))
 255             break;
 256
 257         if(!is_undefined(val) && !is_null(val)) {
 258             hres = to_string(ctx, val, str_tab+i);
 259             jsval_release(val);
 260             if(FAILED(hres))
 261                 break;
 262         }
 263     }
 264
 265     if(SUCCEEDED(hres)) {
 266         DWORD len = 0;
 267
 268         if(str_tab[0])
 269             len = jsstr_length(str_tab[0]);
 270         for(i=1; i < length; i++) {
 271             len += seplen;
 272             if(str_tab[i])
 273                 len += jsstr_length(str_tab[i]);
 274             if(len > JSSTR_MAX_LENGTH) {
 275                 hres = E_OUTOFMEMORY;
 276                 break;
 277             }
 278         }
 279
 280         if(SUCCEEDED(hres)) {
 281             WCHAR *ptr = NULL;
 282
 283             ret = jsstr_alloc_buf(len, &ptr);
 284             if(ret) {
 285                 if(str_tab[0])
 286                     ptr += jsstr_flush(str_tab[0], ptr);
 287
 288                 for(i=1; i < length; i++) {
 289                     if(seplen) {
 290                         memcpy(ptr, sep, seplen*sizeof(WCHAR));
 291                         ptr += seplen;
 292                     }
 293
 294                     if(str_tab[i])
 295                         ptr += jsstr_flush(str_tab[i], ptr);
 296                 }
 297             }else {
 298                 hres = E_OUTOFMEMORY;
 299             }
 300         }
 301     }
 302
 303     for(i=0; i < length; i++) {
 304         if(str_tab[i])
 305             jsstr_release(str_tab[i]);
 306     }
 307     free(str_tab);
 308     if(FAILED(hres))
 309         return hres;
 310
 311     TRACE("= %s\n", debugstr_jsstr(ret));
 312
 313     if(r)
 314         *r = jsval_string(ret);
 315     else
 316         jsstr_release(ret);
 317     return S_OK;
 318 }
 319
 320 /* ECMA-262 3rd Edition    15.4.4.5 */
 321 static HRESULT Array_join(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 322         jsval_t *r)
 323 {
 324     jsdisp_t *jsthis;
 325     UINT32 length;
 326     HRESULT hres;
 327
 328     TRACE("\n");
 329
 330     hres = get_length(ctx, vthis, &jsthis, &length);
 331     if(FAILED(hres))
 332         return hres;
 333
 334     if(argc) {
 335         const WCHAR *sep;
 336         jsstr_t *sep_str;
 337
 338         hres = to_flat_string(ctx, argv[0], &sep_str, &sep);
 339         if(FAILED(hres))
 340             goto done;
 341
 342         hres = array_join(ctx, jsthis, length, sep, jsstr_length(sep_str), to_string, r);
 343
 344         jsstr_release(sep_str);
 345     }else {
 346         hres = array_join(ctx, jsthis, length, L",", 1, to_string, r);
 347     }
 348
 349 done:
 350     jsdisp_release(jsthis);
 351     return hres;
 352 }
 353
 354 static HRESULT Array_pop(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 355         jsval_t *r)
 356 {
 357     jsdisp_t *jsthis;
 358     jsval_t val;
 359     UINT32 length;
 360     HRESULT hres;
 361
 362     TRACE("\n");
 363
 364     hres = get_length(ctx, vthis, &jsthis, &length);
 365     if(FAILED(hres))
 366         return hres;
 367
 368     if(!length) {
 369         hres = set_length(jsthis, 0);
 370         if(FAILED(hres))
 371             goto done;
 372
 373         if(r)
 374             *r = jsval_undefined();
 375         goto done;
 376     }
 377
 378     length--;
 379     hres = jsdisp_get_idx(jsthis, length, &val);
 380     if(SUCCEEDED(hres))
 381         hres = jsdisp_delete_idx(jsthis, length);
 382     else if(hres == DISP_E_UNKNOWNNAME) {
 383         val = jsval_undefined();
 384         hres = S_OK;
 385     }else
 386         goto done;
 387
 388     if(SUCCEEDED(hres))
 389         hres = set_length(jsthis, length);
 390
 391     if(FAILED(hres)) {
 392         jsval_release(val);
 393         goto done;
 394     }
 395
 396     if(r)
 397         *r = val;
 398     else
 399         jsval_release(val);
 400 done:
 401     jsdisp_release(jsthis);
 402     return hres;
 403 }
 404
 405 /* ECMA-262 3rd Edition    15.4.4.7 */
 406 static HRESULT Array_push(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 407         jsval_t *r)
 408 {
 409     jsdisp_t *jsthis;
 410     UINT32 length = 0;
 411     unsigned i;
 412     HRESULT hres;
 413
 414     TRACE("\n");
 415
 416     hres = get_length(ctx, vthis, &jsthis, &length);
 417     if(FAILED(hres))
 418         return hres;
 419
 420     for(i=0; i < argc; i++) {
 421         hres = jsdisp_propput_idx(jsthis, length+i, argv[i]);
 422         if(FAILED(hres))
 423             goto done;
 424     }
 425
 426     hres = set_length(jsthis, length+argc);
 427     if(FAILED(hres))
 428         goto done;
 429
 430     if(r)
 431         *r = jsval_number(length+argc);
 432 done:
 433     jsdisp_release(jsthis);
 434     return hres;
 435 }
 436
 437 static HRESULT Array_reverse(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 438         jsval_t *r)
 439 {
 440     jsdisp_t *jsthis;
 441     UINT32 length, k, l;
 442     jsval_t v1, v2;
 443     HRESULT hres1, hres2;
 444
 445     TRACE("\n");
 446
 447     hres1 = get_length(ctx, vthis, &jsthis, &length);
 448     if(FAILED(hres1))
 449         return hres1;
 450
 451     for(k=0; k<length/2; k++) {
 452         l = length-k-1;
 453
 454         hres1 = jsdisp_get_idx(jsthis, k, &v1);
 455         if(FAILED(hres1) && hres1!=DISP_E_UNKNOWNNAME)
 456             goto done;
 457
 458         hres2 = jsdisp_get_idx(jsthis, l, &v2);
 459         if(FAILED(hres2) && hres2!=DISP_E_UNKNOWNNAME) {
 460             jsval_release(v1);
 461             hres1 = hres2;
 462             goto done;
 463         }
 464
 465         if(hres1 == DISP_E_UNKNOWNNAME)
 466             hres1 = jsdisp_delete_idx(jsthis, l);
 467         else
 468             hres1 = jsdisp_propput_idx(jsthis, l, v1);
 469
 470         if(FAILED(hres1)) {
 471             jsval_release(v1);
 472             jsval_release(v2);
 473             goto done;
 474         }
 475
 476         if(hres2 == DISP_E_UNKNOWNNAME)
 477             hres2 = jsdisp_delete_idx(jsthis, k);
 478         else
 479             hres2 = jsdisp_propput_idx(jsthis, k, v2);
 480
 481         if(FAILED(hres2)) {
 482             jsval_release(v2);
 483             hres1 = hres2;
 484             goto done;
 485         }
 486     }
 487
 488     if(r)
 489         *r = jsval_obj(jsdisp_addref(jsthis));
 490 done:
 491     jsdisp_release(jsthis);
 492     return hres1;
 493 }
 494
 495 /* ECMA-262 3rd Edition    15.4.4.9 */
 496 static HRESULT Array_shift(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 497         jsval_t *r)
 498 {
 499     jsdisp_t *jsthis;
 500     UINT32 length = 0, i;
 501     jsval_t v, ret;
 502     HRESULT hres;
 503
 504     TRACE("\n");
 505
 506     hres = get_length(ctx, vthis, &jsthis, &length);
 507     if(FAILED(hres))
 508         return hres;
 509
 510     if(!length) {
 511         hres = set_length(jsthis, 0);
 512         if(FAILED(hres))
 513             goto done;
 514
 515         if(r)
 516             *r = jsval_undefined();
 517         goto done;
 518     }
 519
 520     hres = jsdisp_get_idx(jsthis, 0, &ret);
 521     if(hres == DISP_E_UNKNOWNNAME) {
 522         ret = jsval_undefined();
 523         hres = S_OK;
 524     }
 525
 526     for(i=1; SUCCEEDED(hres) && i<length; i++) {
 527         hres = jsdisp_get_idx(jsthis, i, &v);
 528         if(hres == DISP_E_UNKNOWNNAME)
 529             hres = jsdisp_delete_idx(jsthis, i-1);
 530         else if(SUCCEEDED(hres)) {
 531             hres = jsdisp_propput_idx(jsthis, i-1, v);
 532             jsval_release(v);
 533         }
 534     }
 535
 536     if(SUCCEEDED(hres)) {
 537         hres = jsdisp_delete_idx(jsthis, length-1);
 538         if(SUCCEEDED(hres))
 539             hres = set_length(jsthis, length-1);
 540     }
 541
 542     if(FAILED(hres))
 543         goto done;
 544
 545     if(r)
 546         *r = ret;
 547     else
 548         jsval_release(ret);
 549 done:
 550     jsdisp_release(jsthis);
 551     return hres;
 552 }
 553
 554 /* ECMA-262 3rd Edition    15.4.4.10 */
 555 static HRESULT Array_slice(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 556 {
 557     jsdisp_t *arr, *jsthis;
 558     DOUBLE range;
 559     UINT32 length, start, end, idx;
 560     HRESULT hres;
 561
 562     TRACE("\n");
 563
 564     hres = get_length(ctx, vthis, &jsthis, &length);
 565     if(FAILED(hres))
 566         return hres;
 567
 568     if(argc) {
 569         hres = to_number(ctx, argv[0], &range);
 570         if(FAILED(hres))
 571             goto done;
 572
 573         range = floor(range);
 574         if(-range>length || isnan(range)) start = 0;
 575         else if(range < 0) start = range+length;
 576         else if(range <= length) start = range;
 577         else start = length;
 578     }
 579     else start = 0;
 580
 581     if(argc > 1) {
 582         hres = to_number(ctx, argv[1], &range);
 583         if(FAILED(hres))
 584             goto done;
 585
 586         range = floor(range);
 587         if(-range>length) end = 0;
 588         else if(range < 0) end = range+length;
 589         else if(range <= length) end = range;
 590         else end = length;
 591     }
 592     else end = length;
 593
 594     hres = create_array(ctx, (end>start)?end-start:0, &arr);
 595     if(FAILED(hres))
 596         goto done;
 597
 598     for(idx=start; idx<end; idx++) {
 599         jsval_t v;
 600
 601         hres = jsdisp_get_idx(jsthis, idx, &v);
 602         if(hres == DISP_E_UNKNOWNNAME)
 603             continue;
 604
 605         if(SUCCEEDED(hres)) {
 606             hres = jsdisp_propput_idx(arr, idx-start, v);
 607             jsval_release(v);
 608         }
 609
 610         if(FAILED(hres)) {
 611             jsdisp_release(arr);
 612             goto done;
 613         }
 614     }
 615
 616     if(r)
 617         *r = jsval_obj(arr);
 618     else
 619         jsdisp_release(arr);
 620     hres = S_OK;
 621
 622 done:
 623     jsdisp_release(jsthis);
 624     return hres;
 625 }
 626
 627 static HRESULT sort_cmp(script_ctx_t *ctx, jsdisp_t *cmp_func, jsval_t v1, jsval_t v2, INT *cmp)
 628 {
 629     HRESULT hres;
 630
 631     if(cmp_func) {
 632         jsval_t args[2] = {v1, v2};
 633         jsval_t res;
 634         double n;
 635
 636         hres = jsdisp_call_value(cmp_func, jsval_undefined(), DISPATCH_METHOD, 2, args, &res);
 637         if(FAILED(hres))
 638             return hres;
 639
 640         hres = to_number(ctx, res, &n);
 641         jsval_release(res);
 642         if(FAILED(hres))
 643             return hres;
 644
 645         if(n == 0)
 646             *cmp = 0;
 647         *cmp = n > 0.0 ? 1 : -1;
 648     }else if(is_undefined(v1)) {
 649         *cmp = is_undefined(v2) ? 0 : 1;
 650     }else if(is_undefined(v2)) {
 651         *cmp = -1;
 652     }else if(is_number(v1) && is_number(v2)) {
 653         double d = get_number(v1)-get_number(v2);
 654         if(d > 0.0)
 655             *cmp = 1;
 656         else
 657             *cmp = d < -0.0 ? -1 : 0;
 658     }else {
 659         jsstr_t *x, *y;
 660
 661         hres = to_string(ctx, v1, &x);
 662         if(FAILED(hres))
 663             return hres;
 664
 665         hres = to_string(ctx, v2, &y);
 666         if(SUCCEEDED(hres)) {
 667             *cmp = jsstr_cmp(x, y);
 668             jsstr_release(y);
 669         }
 670         jsstr_release(x);
 671         if(FAILED(hres))
 672             return hres;
 673     }
 674
 675     return S_OK;
 676 }
 677
 678 /* ECMA-262 3rd Edition    15.4.4.11 */
 679 static HRESULT Array_sort(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 680         jsval_t *r)
 681 {
 682     jsdisp_t *jsthis, *cmp_func = NULL;
 683     jsval_t *vtab, **sorttab = NULL;
 684     UINT32 length;
 685     DWORD i;
 686     HRESULT hres = S_OK;
 687
 688     TRACE("\n");
 689
 690     hres = get_length(ctx, vthis, &jsthis, &length);
 691     if(FAILED(hres))
 692         return hres;
 693
 694     if(argc >= 1) {
 695         if(is_object_instance(argv[0])) {
 696             if(argc > 1 && ctx->version < SCRIPTLANGUAGEVERSION_ES5) {
 697                 WARN("invalid arg_cnt %d\n", argc);
 698                 hres = JS_E_JSCRIPT_EXPECTED;
 699                 goto done;
 700             }
 701             cmp_func = iface_to_jsdisp(get_object(argv[0]));
 702             if(!cmp_func || !is_class(cmp_func, JSCLASS_FUNCTION)) {
 703                 WARN("cmp_func is not a function\n");
 704                 if(cmp_func)
 705                     jsdisp_release(cmp_func);
 706                 hres = JS_E_JSCRIPT_EXPECTED;
 707                 goto done;
 708             }
 709         }else if(ctx->version >= SCRIPTLANGUAGEVERSION_ES5 ? !is_undefined(argv[0]) :
 710                  (!is_null(argv[0]) || is_null_disp(argv[0]))) {
 711             WARN("invalid arg %s\n", debugstr_jsval(argv[0]));
 712             hres = JS_E_JSCRIPT_EXPECTED;
 713             goto done;
 714         }
 715     }
 716
 717     if(!length) {
 718         if(cmp_func)
 719             jsdisp_release(cmp_func);
 720         if(r)
 721             *r = jsval_obj(jsdisp_addref(jsthis));
 722         goto done;
 723     }
 724
 725     vtab = calloc(length, sizeof(*vtab));
 726     if(vtab) {
 727         for(i=0; i<length; i++) {
 728             hres = jsdisp_get_idx(jsthis, i, vtab+i);
 729             if(hres == DISP_E_UNKNOWNNAME) {
 730                 vtab[i] = jsval_undefined();
 731                 hres = S_OK;
 732             } else if(FAILED(hres)) {
 733                 WARN("Could not get elem %ld: %08lx\n", i, hres);
 734                 break;
 735             }
 736         }
 737     }else {
 738         hres = E_OUTOFMEMORY;
 739     }
 740
 741     if(SUCCEEDED(hres)) {
 742         sorttab = malloc(length*2*sizeof(*sorttab));
 743         if(!sorttab)
 744             hres = E_OUTOFMEMORY;
 745     }
 746
 747     /* merge-sort */
 748     if(SUCCEEDED(hres)) {
 749         jsval_t *tmpv, **tmpbuf;
 750         INT cmp;
 751
 752         tmpbuf = sorttab + length;
 753         for(i=0; i < length; i++)
 754             sorttab[i] = vtab+i;
 755
 756         for(i=0; i < length/2; i++) {
 757             hres = sort_cmp(ctx, cmp_func, *sorttab[2*i+1], *sorttab[2*i], &cmp);
 758             if(FAILED(hres))
 759                 break;
 760
 761             if(cmp < 0) {
 762                 tmpv = sorttab[2*i];
 763                 sorttab[2*i] = sorttab[2*i+1];
 764                 sorttab[2*i+1] = tmpv;
 765             }
 766         }
 767
 768         if(SUCCEEDED(hres)) {
 769             DWORD k, a, b, bend;
 770
 771             for(k=2; k < length; k *= 2) {
 772                 for(i=0; i+k < length; i += 2*k) {
 773                     a = b = 0;
 774                     if(i+2*k <= length)
 775                         bend = k;
 776                     else
 777                         bend = length - (i+k);
 778
 779                     memcpy(tmpbuf, sorttab+i, k*sizeof(jsval_t*));
 780
 781                     while(a < k && b < bend) {
 782                         hres = sort_cmp(ctx, cmp_func, *tmpbuf[a], *sorttab[i+k+b], &cmp);
 783                         if(FAILED(hres))
 784                             break;
 785
 786                         if(cmp < 0) {
 787                             sorttab[i+a+b] = tmpbuf[a];
 788                             a++;
 789                         }else {
 790                             sorttab[i+a+b] = sorttab[i+k+b];
 791                             b++;
 792                         }
 793                     }
 794
 795                     if(FAILED(hres))
 796                         break;
 797
 798                     if(a < k)
 799                         memcpy(sorttab+i+a+b, tmpbuf+a, (k-a)*sizeof(jsval_t*));
 800                 }
 801
 802                 if(FAILED(hres))
 803                     break;
 804             }
 805         }
 806
 807         for(i=0; SUCCEEDED(hres) && i < length; i++)
 808             hres = jsdisp_propput_idx(jsthis, i, *sorttab[i]);
 809     }
 810
 811     if(vtab) {
 812         for(i=0; i < length; i++)
 813             jsval_release(vtab[i]);
 814         free(vtab);
 815     }
 816     free(sorttab);
 817     if(cmp_func)
 818         jsdisp_release(cmp_func);
 819
 820     if(FAILED(hres))
 821         goto done;
 822
 823     if(r)
 824         *r = jsval_obj(jsdisp_addref(jsthis));
 825 done:
 826     jsdisp_release(jsthis);
 827     return hres;
 828 }
 829
 830 /* ECMA-262 3rd Edition    15.4.4.12 */
 831 static HRESULT Array_splice(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 832         jsval_t *r)
 833 {
 834     UINT32 length, start=0, delete_cnt=0, i, add_args = 0;
 835     jsdisp_t *ret_array = NULL, *jsthis;
 836     jsval_t val;
 837     double d;
 838     int n;
 839     HRESULT hres = S_OK;
 840
 841     TRACE("\n");
 842
 843     hres = get_length(ctx, vthis, &jsthis, &length);
 844     if(FAILED(hres))
 845         return hres;
 846
 847     if(argc) {
 848         hres = to_integer(ctx, argv[0], &d);
 849         if(FAILED(hres))
 850             goto done;
 851
 852         if(is_int32(d)) {
 853             if((n = d) >= 0)
 854                 start = min(n, length);
 855             else
 856                 start = -n > length ? 0 : length + n;
 857         }else {
 858             start = d < 0.0 ? 0 : length;
 859         }
 860     }
 861
 862     if(argc >= 2) {
 863         hres = to_integer(ctx, argv[1], &d);
 864         if(FAILED(hres))
 865             goto done;
 866
 867         if(is_int32(d)) {
 868             if((n = d) > 0)
 869                 delete_cnt = min(n, length-start);
 870         }else if(d > 0.0) {
 871             delete_cnt = length-start;
 872         }
 873
 874         add_args = argc-2;
 875     } else if (argc && ctx->version >= SCRIPTLANGUAGEVERSION_ES5) {
 876         delete_cnt = length-start;
 877     }
 878
 879     if(r) {
 880         hres = create_array(ctx, 0, &ret_array);
 881         if(FAILED(hres))
 882             goto done;
 883
 884         for(i=0; SUCCEEDED(hres) && i < delete_cnt; i++) {
 885             hres = jsdisp_get_idx(jsthis, start+i, &val);
 886             if(hres == DISP_E_UNKNOWNNAME) {
 887                 hres = S_OK;
 888             }else if(SUCCEEDED(hres)) {
 889                 hres = jsdisp_propput_idx(ret_array, i, val);
 890                 jsval_release(val);
 891             }
 892         }
 893
 894         if(SUCCEEDED(hres))
 895             hres = jsdisp_propput_name(ret_array, L"length", jsval_number(delete_cnt));
 896     }
 897
 898     if(add_args < delete_cnt) {
 899         for(i = start; SUCCEEDED(hres) && i < length-delete_cnt; i++) {
 900             hres = jsdisp_get_idx(jsthis, i+delete_cnt, &val);
 901             if(hres == DISP_E_UNKNOWNNAME) {
 902                 hres = jsdisp_delete_idx(jsthis, i+add_args);
 903             }else if(SUCCEEDED(hres)) {
 904                 hres = jsdisp_propput_idx(jsthis, i+add_args, val);
 905                 jsval_release(val);
 906             }
 907         }
 908
 909         for(i=length; SUCCEEDED(hres) && i != length-delete_cnt+add_args; i--)
 910             hres = jsdisp_delete_idx(jsthis, i-1);
 911     }else if(add_args > delete_cnt) {
 912         for(i=length-delete_cnt; SUCCEEDED(hres) && i != start; i--) {
 913             hres = jsdisp_get_idx(jsthis, i+delete_cnt-1, &val);
 914             if(hres == DISP_E_UNKNOWNNAME) {
 915                 hres = jsdisp_delete_idx(jsthis, i+add_args-1);
 916             }else if(SUCCEEDED(hres)) {
 917                 hres = jsdisp_propput_idx(jsthis, i+add_args-1, val);
 918                 jsval_release(val);
 919             }
 920         }
 921     }
 922
 923     for(i=0; SUCCEEDED(hres) && i < add_args; i++)
 924         hres = jsdisp_propput_idx(jsthis, start+i, argv[i+2]);
 925
 926     if(SUCCEEDED(hres))
 927         hres = jsdisp_propput_name(jsthis, L"length", jsval_number(length-delete_cnt+add_args));
 928
 929     if(FAILED(hres)) {
 930         if(ret_array)
 931             jsdisp_release(ret_array);
 932         goto done;
 933     }
 934
 935     if(r)
 936         *r = jsval_obj(ret_array);
 937 done:
 938     jsdisp_release(jsthis);
 939     return hres;
 940 }
 941
 942 /* ECMA-262 3rd Edition    15.4.4.2 */
 943 static HRESULT Array_toString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 944         jsval_t *r)
 945 {
 946     ArrayInstance *array;
 947
 948     TRACE("\n");
 949
 950     array = array_this(vthis);
 951     if(!array)
 952         return JS_E_ARRAY_EXPECTED;
 953
 954     return array_join(ctx, &array->dispex, array->length, L",", 1, to_string, r);
 955 }
 956
 957 static HRESULT to_locale_string(script_ctx_t *ctx, jsval_t val, jsstr_t **str)
 958 {
 959     jsdisp_t *jsdisp;
 960     IDispatch *obj;
 961     HRESULT hres;
 962
 963     switch(jsval_type(val)) {
 964     case JSV_OBJECT:
 965         hres = disp_call_name(ctx, get_object(val), L"toLocaleString", DISPATCH_METHOD, 0, NULL, &val);
 966         if(FAILED(hres)) {
 967             if(hres == JS_E_INVALID_PROPERTY && ctx->version >= SCRIPTLANGUAGEVERSION_ES5)
 968                 hres = JS_E_FUNCTION_EXPECTED;
 969             return hres;
 970         }
 971         break;
 972     case JSV_NUMBER:
 973         if(ctx->version >= SCRIPTLANGUAGEVERSION_ES5)
 974             return localize_number(ctx, get_number(val), FALSE, str);
 975         /* fall through */
 976     default:
 977         if(ctx->version >= SCRIPTLANGUAGEVERSION_ES5)
 978             break;
 979
 980         hres = to_object(ctx, val, &obj);
 981         if(FAILED(hres))
 982             return hres;
 983
 984         jsdisp = as_jsdisp(obj);
 985         hres = jsdisp_call_name(jsdisp, L"toLocaleString", DISPATCH_METHOD, 0, NULL, &val);
 986         jsdisp_release(jsdisp);
 987         if(FAILED(hres))
 988             return hres;
 989         break;
 990     }
 991
 992     return to_string(ctx, val, str);
 993 }
 994
 995 static HRESULT Array_toLocaleString(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
 996         jsval_t *r)
 997 {
 998     jsdisp_t *jsthis;
 999     UINT32 length;
1000     HRESULT hres;
1001     WCHAR buf[5];
1002     int len;
1003
1004     TRACE("\n");
1005
1006     if(ctx->version < SCRIPTLANGUAGEVERSION_ES5) {
1007         ArrayInstance *array = array_this(vthis);
1008         if(!array)
1009             return JS_E_ARRAY_EXPECTED;
1010         jsthis = jsdisp_addref(&array->dispex);
1011         length = array->length;
1012     }else {
1013         hres = get_length(ctx, vthis, &jsthis, &length);
1014         if(FAILED(hres))
1015             return hres;
1016     }
1017
1018     if(!(len = GetLocaleInfoW(ctx->lcid, LOCALE_SLIST, buf, ARRAY_SIZE(buf) - 1))) {
1019         buf[len++] = ',';
1020         len++;
1021     }
1022     buf[len - 1] = ' ';
1023     buf[len] = '\0';
1024
1025     hres = array_join(ctx, jsthis, length, buf, len, to_locale_string, r);
1026     jsdisp_release(jsthis);
1027     return hres;
1028 }
1029
1030 static HRESULT Array_every(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1031         jsval_t *r)
1032 {
1033     jsval_t context_this = jsval_undefined();
1034     jsval_t value, args[3], res;
1035     BOOL boolval, ret = TRUE;
1036     IDispatch *callback;
1037     unsigned length, i;
1038     jsdisp_t *jsthis;
1039     HRESULT hres;
1040
1041     TRACE("\n");
1042
1043     hres = get_length(ctx, vthis, &jsthis, &length);
1044     if(FAILED(hres))
1045         return hres;
1046
1047     /* FIXME: check IsCallable */
1048     if(!argc || !is_object_instance(argv[0])) {
1049         FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
1050         hres = E_INVALIDARG;
1051         goto done;
1052     }
1053     callback = get_object(argv[0]);
1054
1055     if(argc > 1)
1056         context_this = argv[1];
1057
1058     for(i = 0; i < length; i++) {
1059         hres = jsdisp_get_idx(jsthis, i, &value);
1060         if(FAILED(hres)) {
1061             if(hres == DISP_E_UNKNOWNNAME)
1062                 continue;
1063             goto done;
1064         }
1065         args[0] = value;
1066         args[1] = jsval_number(i);
1067         args[2] = jsval_obj(jsthis);
1068         hres = disp_call_value(ctx, callback, context_this, DISPATCH_METHOD, ARRAY_SIZE(args), args, &res);
1069         jsval_release(value);
1070         if(FAILED(hres))
1071             goto done;
1072
1073         hres = to_boolean(res, &boolval);
1074         jsval_release(res);
1075         if(FAILED(hres))
1076             goto done;
1077         if(!boolval) {
1078             ret = FALSE;
1079             break;
1080         }
1081     }
1082
1083     if(r)
1084         *r = jsval_bool(ret);
1085     hres = S_OK;
1086 done:
1087     jsdisp_release(jsthis);
1088     return hres;
1089 }
1090
1091 static HRESULT Array_filter(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1092         jsval_t *r)
1093 {
1094     jsval_t context_this = jsval_undefined();
1095     jsval_t value, args[3], res;
1096     unsigned length, i, j = 0;
1097     jsdisp_t *jsthis, *arr;
1098     IDispatch *callback;
1099     HRESULT hres;
1100     BOOL boolval;
1101
1102     TRACE("\n");
1103
1104     hres = get_length(ctx, vthis, &jsthis, &length);
1105     if(FAILED(hres))
1106         return hres;
1107
1108     /* FIXME: check IsCallable */
1109     if(!argc || !is_object_instance(argv[0])) {
1110         FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
1111         hres = E_INVALIDARG;
1112         goto done;
1113     }
1114     callback = get_object(argv[0]);
1115
1116     if(argc > 1)
1117         context_this = argv[1];
1118
1119     hres = create_array(ctx, 0, &arr);
1120     if(FAILED(hres))
1121         goto done;
1122
1123     for(i = 0; i < length; i++) {
1124         hres = jsdisp_get_idx(jsthis, i, &value);
1125         if(FAILED(hres)) {
1126             if(hres == DISP_E_UNKNOWNNAME) {
1127                 hres = S_OK;
1128                 continue;
1129             }
1130             break;
1131         }
1132         args[0] = value;
1133         args[1] = jsval_number(i);
1134         args[2] = jsval_obj(jsthis);
1135         hres = disp_call_value(ctx, callback, context_this, DISPATCH_METHOD, ARRAY_SIZE(args), args, &res);
1136         if(SUCCEEDED(hres)) {
1137             hres = to_boolean(res, &boolval);
1138             jsval_release(res);
1139             if(SUCCEEDED(hres) && boolval)
1140                 hres = jsdisp_propput_idx(arr, j++, value);
1141         }
1142         jsval_release(value);
1143         if(FAILED(hres))
1144             break;
1145     }
1146
1147     if(FAILED(hres)) {
1148         jsdisp_release(arr);
1149         goto done;
1150     }
1151     set_length(arr, j);
1152
1153     if(r)
1154         *r = jsval_obj(arr);
1155     else
1156         jsdisp_release(arr);
1157 done:
1158     jsdisp_release(jsthis);
1159     return hres;
1160 }
1161
1162 static HRESULT Array_forEach(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1163         jsval_t *r)
1164 {
1165     jsval_t context_this = jsval_undefined();
1166     jsval_t value, args[3], res;
1167     IDispatch *callback;
1168     jsdisp_t *jsthis;
1169     unsigned length, i;
1170     HRESULT hres;
1171
1172     TRACE("\n");
1173
1174     hres = get_length(ctx, vthis, &jsthis, &length);
1175     if(FAILED(hres))
1176         return hres;
1177
1178     /* Fixme check IsCallable */
1179     if(!argc || !is_object_instance(argv[0])) {
1180         FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
1181         hres = E_INVALIDARG;
1182         goto done;
1183     }
1184     callback = get_object(argv[0]);
1185
1186     if(argc > 1)
1187         context_this = argv[1];
1188
1189     for(i = 0; i < length; i++) {
1190         hres = jsdisp_get_idx(jsthis, i, &value);
1191         if(hres == DISP_E_UNKNOWNNAME)
1192             continue;
1193         if(FAILED(hres))
1194             goto done;
1195
1196         args[0] = value;
1197         args[1] = jsval_number(i);
1198         args[2] = jsval_obj(jsthis);
1199         hres = disp_call_value(ctx, callback, context_this, DISPATCH_METHOD, ARRAY_SIZE(args), args, &res);
1200         jsval_release(value);
1201         if(FAILED(hres))
1202             goto done;
1203         jsval_release(res);
1204     }
1205
1206     if(r) *r = jsval_undefined();
1207     hres = S_OK;
1208 done:
1209     jsdisp_release(jsthis);
1210     return hres;
1211 }
1212
1213 static HRESULT Array_indexOf(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1214         jsval_t *r)
1215 {
1216     jsdisp_t *jsthis;
1217     unsigned length, i, from = 0;
1218     jsval_t search, value;
1219     BOOL eq;
1220     HRESULT hres;
1221
1222     TRACE("\n");
1223
1224     hres = get_length(ctx, vthis, &jsthis, &length);
1225     if(FAILED(hres))
1226         return hres;
1227     if(!length) {
1228         if(r) *r = jsval_number(-1);
1229         goto done;
1230     }
1231
1232     search = argc ? argv[0] : jsval_undefined();
1233
1234     if(argc > 1) {
1235         double from_arg;
1236
1237         hres = to_integer(ctx, argv[1], &from_arg);
1238         if(FAILED(hres))
1239             goto done;
1240
1241         if(from_arg >= 0)
1242             from = min(from_arg, length);
1243         else
1244             from = max(from_arg + length, 0);
1245     }
1246
1247     for(i = from; i < length; i++) {
1248         hres = jsdisp_get_idx(jsthis, i, &value);
1249         if(hres == DISP_E_UNKNOWNNAME)
1250             continue;
1251         if(FAILED(hres))
1252             goto done;
1253
1254         hres = jsval_strict_equal(value, search, &eq);
1255         jsval_release(value);
1256         if(FAILED(hres))
1257             goto done;
1258         if(eq) {
1259             if(r) *r = jsval_number(i);
1260             goto done;
1261         }
1262     }
1263
1264     if(r) *r = jsval_number(-1);
1265     hres = S_OK;
1266 done:
1267     jsdisp_release(jsthis);
1268     return hres;
1269 }
1270
1271 static HRESULT Array_lastIndexOf(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1272         jsval_t *r)
1273 {
1274     jsval_t search, value;
1275     unsigned i, length;
1276     jsdisp_t *jsthis;
1277     HRESULT hres;
1278     BOOL eq;
1279
1280     TRACE("\n");
1281
1282     hres = get_length(ctx, vthis, &jsthis, &length);
1283     if(FAILED(hres))
1284         return hres;
1285     if(!length)
1286         goto notfound;
1287
1288     search = argc ? argv[0] : jsval_undefined();
1289
1290     i = length - 1;
1291     if(argc > 1) {
1292         double from_arg;
1293
1294         hres = to_integer(ctx, argv[1], &from_arg);
1295         if(FAILED(hres))
1296             goto done;
1297
1298         if(from_arg >= 0.0)
1299             i = min(from_arg, i);
1300         else {
1301             from_arg += length;
1302             if(from_arg < 0.0)
1303                 goto notfound;
1304             i = from_arg;
1305         }
1306     }
1307
1308     do {
1309         hres = jsdisp_get_idx(jsthis, i, &value);
1310         if(hres == DISP_E_UNKNOWNNAME)
1311             continue;
1312         if(FAILED(hres))
1313             goto done;
1314
1315         hres = jsval_strict_equal(value, search, &eq);
1316         jsval_release(value);
1317         if(FAILED(hres))
1318             goto done;
1319         if(eq) {
1320             if(r) *r = jsval_number(i);
1321             goto done;
1322         }
1323     } while(i--);
1324
1325 notfound:
1326     if(r) *r = jsval_number(-1);
1327     hres = S_OK;
1328 done:
1329     jsdisp_release(jsthis);
1330     return hres;
1331 }
1332
1333 static HRESULT Array_map(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1334 {
1335     jsval_t context_this = jsval_undefined();
1336     jsval_t callback_args[3], mapped_value;
1337     jsdisp_t *jsthis, *array;
1338     IDispatch *callback;
1339     UINT32 length, k;
1340     HRESULT hres;
1341
1342     TRACE("\n");
1343
1344     hres = get_length(ctx, vthis, &jsthis, &length);
1345     if(FAILED(hres)) {
1346         FIXME("Could not get length\n");
1347         return hres;
1348     }
1349
1350     /* FIXME: check IsCallable */
1351     if(!argc || !is_object_instance(argv[0])) {
1352         FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
1353         hres = E_INVALIDARG;
1354         goto done;
1355     }
1356     callback = get_object(argv[0]);
1357
1358     if(argc > 1)
1359         context_this = argv[1];
1360
1361     hres = create_array(ctx, 0, &array);
1362     if(FAILED(hres))
1363         goto done;
1364
1365     for(k = 0; k < length; k++) {
1366         hres = jsdisp_get_idx(jsthis, k, &callback_args[0]);
1367         if(hres == DISP_E_UNKNOWNNAME) {
1368             hres = S_OK;
1369             continue;
1370         }
1371         if(FAILED(hres))
1372             break;
1373
1374         callback_args[1] = jsval_number(k);
1375         callback_args[2] = jsval_obj(jsthis);
1376         hres = disp_call_value(ctx, callback, context_this, DISPATCH_METHOD, 3, callback_args, &mapped_value);
1377         jsval_release(callback_args[0]);
1378         if(FAILED(hres))
1379             break;
1380
1381         hres = jsdisp_propput_idx(array, k, mapped_value);
1382         if(FAILED(hres))
1383             break;
1384     }
1385
1386     if(SUCCEEDED(hres) && r)
1387         *r = jsval_obj(array);
1388     else
1389         jsdisp_release(array);
1390 done:
1391     jsdisp_release(jsthis);
1392     return hres;
1393 }
1394
1395 static HRESULT Array_reduce(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1396 {
1397     jsval_t callback_args[4], acc, new_acc;
1398     BOOL have_value = FALSE;
1399     IDispatch *callback;
1400     jsdisp_t *jsthis;
1401     UINT32 length, k;
1402     HRESULT hres;
1403
1404     TRACE("\n");
1405
1406     hres = get_length(ctx, vthis, &jsthis, &length);
1407     if(FAILED(hres)) {
1408         FIXME("Could not get length\n");
1409         return hres;
1410     }
1411
1412     /* Fixme check IsCallable */
1413     if(!argc || !is_object_instance(argv[0])) {
1414         FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
1415         hres = E_INVALIDARG;
1416         goto done;
1417     }
1418     callback = get_object(argv[0]);
1419
1420     if(argc > 1) {
1421         have_value = TRUE;
1422         hres = jsval_copy(argv[1], &acc);
1423         if(FAILED(hres))
1424             goto done;
1425     }
1426
1427     for(k = 0; k < length; k++) {
1428         hres = jsdisp_get_idx(jsthis, k, &callback_args[1]);
1429         if(hres == DISP_E_UNKNOWNNAME) {
1430             hres = S_OK;
1431             continue;
1432         }
1433         if(FAILED(hres))
1434             break;
1435
1436         if(!have_value) {
1437             have_value = TRUE;
1438             acc = callback_args[1];
1439             continue;
1440         }
1441
1442         callback_args[0] = acc;
1443         callback_args[2] = jsval_number(k);
1444         callback_args[3] = jsval_obj(jsthis);
1445         hres = disp_call_value(ctx, callback, jsval_undefined(), DISPATCH_METHOD, ARRAY_SIZE(callback_args), callback_args, &new_acc);
1446         jsval_release(callback_args[1]);
1447         if(FAILED(hres))
1448             break;
1449
1450         jsval_release(acc);
1451         acc = new_acc;
1452     }
1453
1454     if(SUCCEEDED(hres) && !have_value) {
1455         WARN("No array element\n");
1456         hres = JS_E_INVALID_ACTION;
1457     }
1458
1459     if(SUCCEEDED(hres) && r)
1460         *r = acc;
1461     else if(have_value)
1462         jsval_release(acc);
1463 done:
1464     jsdisp_release(jsthis);
1465     return hres;
1466 }
1467
1468 static HRESULT Array_some(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1469         jsval_t *r)
1470 {
1471     jsval_t context_this = jsval_undefined();
1472     jsval_t value, args[3], res;
1473     BOOL boolval, ret = FALSE;
1474     IDispatch *callback;
1475     unsigned length, i;
1476     jsdisp_t *jsthis;
1477     HRESULT hres;
1478
1479     TRACE("\n");
1480
1481     hres = get_length(ctx, vthis, &jsthis, &length);
1482     if(FAILED(hres))
1483         return hres;
1484
1485     /* FIXME: check IsCallable */
1486     if(!argc || !is_object_instance(argv[0])) {
1487         FIXME("Invalid arg %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
1488         hres = E_INVALIDARG;
1489         goto done;
1490     }
1491     callback = get_object(argv[0]);
1492
1493     if(argc > 1)
1494         context_this = argv[1];
1495
1496     for(i = 0; i < length; i++) {
1497         hres = jsdisp_get_idx(jsthis, i, &value);
1498         if(FAILED(hres)) {
1499             if(hres == DISP_E_UNKNOWNNAME)
1500                 continue;
1501             goto done;
1502         }
1503         args[0] = value;
1504         args[1] = jsval_number(i);
1505         args[2] = jsval_obj(jsthis);
1506         hres = disp_call_value(ctx, callback, context_this, DISPATCH_METHOD, ARRAY_SIZE(args), args, &res);
1507         jsval_release(value);
1508         if(FAILED(hres))
1509             goto done;
1510
1511         hres = to_boolean(res, &boolval);
1512         jsval_release(res);
1513         if(FAILED(hres))
1514             goto done;
1515         if(boolval) {
1516             ret = TRUE;
1517             break;
1518         }
1519     }
1520
1521     if(r)
1522         *r = jsval_bool(ret);
1523     hres = S_OK;
1524 done:
1525     jsdisp_release(jsthis);
1526     return hres;
1527 }
1528
1529 /* ECMA-262 3rd Edition    15.4.4.13 */
1530 static HRESULT Array_unshift(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1531         jsval_t *r)
1532 {
1533     jsdisp_t *jsthis;
1534     WCHAR buf[14], *buf_end, *str;
1535     UINT32 i, length;
1536     jsval_t val;
1537     DISPID id;
1538     HRESULT hres;
1539
1540     TRACE("\n");
1541
1542     hres = get_length(ctx, vthis, &jsthis, &length);
1543     if(FAILED(hres))
1544         return hres;
1545
1546     if(argc) {
1547         buf_end = buf + ARRAY_SIZE(buf)-1;
1548         *buf_end-- = 0;
1549         i = length;
1550
1551         while(i--) {
1552             str = idx_to_str(i, buf_end);
1553
1554             hres = jsdisp_get_id(jsthis, str, 0, &id);
1555             if(SUCCEEDED(hres)) {
1556                 hres = jsdisp_propget(jsthis, id, &val);
1557                 if(FAILED(hres))
1558                     goto done;
1559
1560                 hres = jsdisp_propput_idx(jsthis, i+argc, val);
1561                 jsval_release(val);
1562             }else if(hres == DISP_E_UNKNOWNNAME) {
1563                 hres = IDispatchEx_DeleteMemberByDispID(&jsthis->IDispatchEx_iface, id);
1564             }
1565         }
1566
1567         if(FAILED(hres))
1568             goto done;
1569     }
1570
1571     for(i=0; i<argc; i++) {
1572         hres = jsdisp_propput_idx(jsthis, i, argv[i]);
1573         if(FAILED(hres))
1574             goto done;
1575     }
1576
1577     if(argc) {
1578         length += argc;
1579         hres = set_length(jsthis, length);
1580         if(FAILED(hres))
1581             goto done;
1582     }
1583
1584     if(r)
1585         *r = ctx->version < 2 ? jsval_undefined() : jsval_number(length);
1586     hres = S_OK;
1587 done:
1588     jsdisp_release(jsthis);
1589     return hres;
1590 }
1591
1592 static void Array_destructor(jsdisp_t *dispex)
1593 {
1594     free(dispex);
1595 }
1596
1597 static void Array_on_put(jsdisp_t *dispex, const WCHAR *name)
1598 {
1599     ArrayInstance *array = array_from_jsdisp(dispex);
1600     const WCHAR *ptr = name;
1601     DWORD id = 0;
1602
1603     if(!is_digit(*ptr))
1604         return;
1605
1606     while(*ptr && is_digit(*ptr)) {
1607         id = id*10 + (*ptr-'0');
1608         ptr++;
1609     }
1610
1611     if(*ptr)
1612         return;
1613
1614     if(id >= array->length)
1615         array->length = id+1;
1616 }
1617
1618 static const builtin_prop_t Array_props[] = {
1619     {L"concat",                Array_concat,               PROPF_METHOD|1},
1620     {L"every",                 Array_every,                PROPF_METHOD|PROPF_ES5|1},
1621     {L"filter",                Array_filter,               PROPF_METHOD|PROPF_ES5|1},
1622     {L"forEach",               Array_forEach,              PROPF_METHOD|PROPF_ES5|1},
1623     {L"indexOf",               Array_indexOf,              PROPF_METHOD|PROPF_ES5|1},
1624     {L"join",                  Array_join,                 PROPF_METHOD|1},
1625     {L"lastIndexOf",           Array_lastIndexOf,          PROPF_METHOD|PROPF_ES5|1},
1626     {L"length",                NULL,0,                     Array_get_length, Array_set_length},
1627     {L"map",                   Array_map,                  PROPF_METHOD|PROPF_ES5|1},
1628     {L"pop",                   Array_pop,                  PROPF_METHOD},
1629     {L"push",                  Array_push,                 PROPF_METHOD|1},
1630     {L"reduce",                Array_reduce,               PROPF_METHOD|PROPF_ES5|1},
1631     {L"reverse",               Array_reverse,              PROPF_METHOD},
1632     {L"shift",                 Array_shift,                PROPF_METHOD},
1633     {L"slice",                 Array_slice,                PROPF_METHOD|2},
1634     {L"some",                  Array_some,                 PROPF_METHOD|PROPF_ES5|1},
1635     {L"sort",                  Array_sort,                 PROPF_METHOD|1},
1636     {L"splice",                Array_splice,               PROPF_METHOD|2},
1637     {L"toLocaleString",        Array_toLocaleString,       PROPF_METHOD},
1638     {L"toString",              Array_toString,             PROPF_METHOD},
1639     {L"unshift",               Array_unshift,              PROPF_METHOD|1},
1640 };
1641
1642 static const builtin_info_t Array_info = {
1643     .class      = JSCLASS_ARRAY,
1644     .props_cnt  = ARRAY_SIZE(Array_props),
1645     .props      = Array_props,
1646     .destructor = Array_destructor,
1647     .on_put     = Array_on_put,
1648 };
1649
1650 static const builtin_prop_t ArrayInst_props[] = {
1651     {L"length",                NULL,0,                     Array_get_length, Array_set_length}
1652 };
1653
1654 static const builtin_info_t ArrayInst_info = {
1655     .class      = JSCLASS_ARRAY,
1656     .props_cnt  = ARRAY_SIZE(ArrayInst_props),
1657     .props      = ArrayInst_props,
1658     .destructor = Array_destructor,
1659     .on_put     = Array_on_put,
1660 };
1661
1662 /* ECMA-262 5.1 Edition    15.4.3.2 */
1663 static HRESULT ArrayConstr_isArray(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
1664 {
1665     jsdisp_t *obj;
1666
1667     TRACE("\n");
1668
1669     if(!argc || !is_object_instance(argv[0])) {
1670         if(r) *r = jsval_bool(FALSE);
1671         return S_OK;
1672     }
1673
1674     obj = to_jsdisp(get_object(argv[0]));
1675     if(r) *r = jsval_bool(obj && is_class(obj, JSCLASS_ARRAY));
1676     return S_OK;
1677 }
1678
1679 static HRESULT ArrayConstr_value(script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv,
1680         jsval_t *r)
1681 {
1682     jsdisp_t *obj;
1683     DWORD i;
1684     HRESULT hres;
1685
1686     TRACE("\n");
1687
1688     switch(flags) {
1689     case DISPATCH_METHOD:
1690     case DISPATCH_CONSTRUCT: {
1691         if(argc == 1 && is_number(argv[0])) {
1692             double n = get_number(argv[0]);
1693
1694             if(n < 0 || !is_int32(n))
1695                 return JS_E_INVALID_LENGTH;
1696             if(!r)
1697                 return S_OK;
1698
1699             hres = create_array(ctx, n, &obj);
1700             if(FAILED(hres))
1701                 return hres;
1702
1703             *r = jsval_obj(obj);
1704             return S_OK;
1705         }
1706
1707         if(!r)
1708             return S_OK;
1709         hres = create_array(ctx, argc, &obj);
1710         if(FAILED(hres))
1711             return hres;
1712
1713         for(i=0; i < argc; i++) {
1714             hres = jsdisp_propput_idx(obj, i, argv[i]);
1715             if(FAILED(hres))
1716                 break;
1717         }
1718         if(FAILED(hres)) {
1719             jsdisp_release(obj);
1720             return hres;
1721         }
1722
1723         *r = jsval_obj(obj);
1724         break;
1725     }
1726     default:
1727         FIXME("unimplemented flags: %x\n", flags);
1728         return E_NOTIMPL;
1729     }
1730
1731     return S_OK;
1732 }
1733
1734 static HRESULT alloc_array(script_ctx_t *ctx, jsdisp_t *object_prototype, ArrayInstance **ret)
1735 {
1736     ArrayInstance *array;
1737     HRESULT hres;
1738
1739     array = calloc(1, sizeof(ArrayInstance));
1740     if(!array)
1741         return E_OUTOFMEMORY;
1742
1743     if(object_prototype)
1744         hres = init_dispex(&array->dispex, ctx, &Array_info, object_prototype);
1745     else
1746         hres = init_dispex_from_constr(&array->dispex, ctx, &ArrayInst_info, ctx->array_constr);
1747
1748     if(FAILED(hres)) {
1749         free(array);
1750         return hres;
1751     }
1752
1753     *ret = array;
1754     return S_OK;
1755 }
1756
1757 static const builtin_prop_t ArrayConstr_props[] = {
1758     {L"isArray",    ArrayConstr_isArray,    PROPF_ES5|PROPF_METHOD|1}
1759 };
1760
1761 static const builtin_info_t ArrayConstr_info = {
1762     .class     = JSCLASS_FUNCTION,
1763     .call      = Function_value,
1764     .props_cnt = ARRAY_SIZE(ArrayConstr_props),
1765     .props     = ArrayConstr_props,
1766 };
1767
1768 HRESULT create_array_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
1769 {
1770     ArrayInstance *array;
1771     HRESULT hres;
1772
1773     hres = alloc_array(ctx, object_prototype, &array);
1774     if(FAILED(hres))
1775         return hres;
1776
1777     hres = create_builtin_constructor(ctx, ArrayConstr_value, L"Array", &ArrayConstr_info, PROPF_CONSTR|1, &array->dispex, ret);
1778
1779     jsdisp_release(&array->dispex);
1780     return hres;
1781 }
1782
1783 HRESULT create_array(script_ctx_t *ctx, DWORD length, jsdisp_t **ret)
1784 {
1785     ArrayInstance *array;
1786     HRESULT hres;
1787
1788     hres = alloc_array(ctx, NULL, &array);
1789     if(FAILED(hres))
1790         return hres;
1791
1792     array->length = length;
1793
1794     *ret = &array->dispex;
1795     return S_OK;
1796 }