git.oblomov.eu Git - wine/blob - 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 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <math.h>
  23
  24 #include "jscript.h"
  25
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  29
  30 typedef struct {
  31     jsdisp_t dispex;
  32
  33     DWORD length;
  34 } ArrayInstance;
  35
  36 static const WCHAR lengthW[] = {'l','e','n','g','t','h',0};
  37 static const WCHAR concatW[] = {'c','o','n','c','a','t',0};
  38 static const WCHAR joinW[] = {'j','o','i','n',0};
  39 static const WCHAR popW[] = {'p','o','p',0};
  40 static const WCHAR pushW[] = {'p','u','s','h',0};
  41 static const WCHAR reverseW[] = {'r','e','v','e','r','s','e',0};
  42 static const WCHAR shiftW[] = {'s','h','i','f','t',0};
  43 static const WCHAR sliceW[] = {'s','l','i','c','e',0};
  44 static const WCHAR sortW[] = {'s','o','r','t',0};
  45 static const WCHAR spliceW[] = {'s','p','l','i','c','e',0};
  46 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
  47 static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0};
  48 static const WCHAR unshiftW[] = {'u','n','s','h','i','f','t',0};
  49
  50 static const WCHAR default_separatorW[] = {',',0};
  51
  52 static inline ArrayInstance *array_from_vdisp(vdisp_t *vdisp)
  53 {
  54     return (ArrayInstance*)vdisp->u.jsdisp;
  55 }
  56
  57 static inline ArrayInstance *array_this(vdisp_t *jsthis)
  58 {
  59     return is_vclass(jsthis, JSCLASS_ARRAY) ? array_from_vdisp(jsthis) : NULL;
  60 }
  61
  62 static HRESULT get_length(script_ctx_t *ctx, vdisp_t *vdisp, jsdisp_t **jsthis, DWORD *ret)
  63 {
  64     ArrayInstance *array;
  65     jsval_t val;
  66     HRESULT hres;
  67
  68     array = array_this(vdisp);
  69     if(array) {
  70         *jsthis = &array->dispex;
  71         *ret = array->length;
  72         return S_OK;
  73     }
  74
  75     if(!is_jsdisp(vdisp))
  76         return throw_type_error(ctx, JS_E_JSCRIPT_EXPECTED, NULL);
  77
  78     hres = jsdisp_propget_name(vdisp->u.jsdisp, lengthW, &val);
  79     if(FAILED(hres))
  80         return hres;
  81
  82     hres = to_uint32(ctx, val, ret);
  83     jsval_release(val);
  84     if(FAILED(hres))
  85         return hres;
  86
  87     *jsthis = vdisp->u.jsdisp;
  88     return S_OK;
  89 }
  90
  91 static HRESULT set_length(jsdisp_t *obj, DWORD length)
  92 {
  93     if(is_class(obj, JSCLASS_ARRAY)) {
  94         ((ArrayInstance*)obj)->length = length;
  95         return S_OK;
  96     }
  97
  98     return jsdisp_propput_name(obj, lengthW, jsval_number(length));
  99 }
 100
 101 static WCHAR *idx_to_str(DWORD idx, WCHAR *ptr)
 102 {
 103     if(!idx) {
 104         *ptr = '0';
 105         return ptr;
 106     }
 107
 108     while(idx) {
 109         *ptr-- = '0' + (idx%10);
 110         idx /= 10;
 111     }
 112
 113     return ptr+1;
 114 }
 115
 116 static HRESULT Array_length(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 117         jsval_t *r)
 118 {
 119     ArrayInstance *This = array_from_vdisp(jsthis);
 120
 121     TRACE("%p %d\n", This, This->length);
 122
 123     switch(flags) {
 124     case DISPATCH_PROPERTYGET:
 125         *r = jsval_number(This->length);
 126         break;
 127     case DISPATCH_PROPERTYPUT: {
 128         DOUBLE len = -1;
 129         DWORD i;
 130         HRESULT hres;
 131
 132         hres = to_number(ctx, argv[0], &len);
 133         if(FAILED(hres))
 134             return hres;
 135
 136         len = floor(len);
 137         if(len!=(DWORD)len)
 138             return throw_range_error(ctx, JS_E_INVALID_LENGTH, NULL);
 139
 140         for(i=len; i<This->length; i++) {
 141             hres = jsdisp_delete_idx(&This->dispex, i);
 142             if(FAILED(hres))
 143                 return hres;
 144         }
 145
 146         This->length = len;
 147         break;
 148     }
 149     default:
 150         FIXME("unimplemented flags %x\n", flags);
 151         return E_NOTIMPL;
 152     }
 153
 154     return S_OK;
 155 }
 156
 157 static HRESULT concat_array(jsdisp_t *array, ArrayInstance *obj, DWORD *len)
 158 {
 159     jsval_t val;
 160     DWORD i;
 161     HRESULT hres;
 162
 163     for(i=0; i < obj->length; i++) {
 164         hres = jsdisp_get_idx(&obj->dispex, i, &val);
 165         if(hres == DISP_E_UNKNOWNNAME)
 166             continue;
 167         if(FAILED(hres))
 168             return hres;
 169
 170         hres = jsdisp_propput_idx(array, *len+i, val);
 171         jsval_release(val);
 172         if(FAILED(hres))
 173             return hres;
 174     }
 175
 176     *len += obj->length;
 177     return S_OK;
 178 }
 179
 180 static HRESULT concat_obj(jsdisp_t *array, IDispatch *obj, DWORD *len)
 181 {
 182     jsdisp_t *jsobj;
 183     HRESULT hres;
 184
 185     jsobj = iface_to_jsdisp((IUnknown*)obj);
 186     if(jsobj) {
 187         if(is_class(jsobj, JSCLASS_ARRAY)) {
 188             hres = concat_array(array, (ArrayInstance*)jsobj, len);
 189             jsdisp_release(jsobj);
 190             return hres;
 191         }
 192         jsdisp_release(jsobj);
 193     }
 194
 195     return jsdisp_propput_idx(array, (*len)++, jsval_disp(obj));
 196 }
 197
 198 static HRESULT Array_concat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 199         jsval_t *r)
 200 {
 201     jsdisp_t *ret;
 202     DWORD len = 0;
 203     HRESULT hres;
 204
 205     TRACE("\n");
 206
 207     hres = create_array(ctx, 0, &ret);
 208     if(FAILED(hres))
 209         return hres;
 210
 211     hres = concat_obj(ret, jsthis->u.disp, &len);
 212     if(SUCCEEDED(hres)) {
 213         DWORD i;
 214
 215         for(i=0; i < argc; i++) {
 216             if(is_object_instance(argv[i]))
 217                 hres = concat_obj(ret, get_object(argv[i]), &len);
 218             else
 219                 hres = jsdisp_propput_idx(ret, len++, argv[i]);
 220             if(FAILED(hres))
 221                 break;
 222         }
 223     }
 224
 225     if(FAILED(hres))
 226         return hres;
 227
 228     if(r)
 229         *r = jsval_obj(ret);
 230     else
 231         jsdisp_release(ret);
 232     return S_OK;
 233 }
 234
 235 static HRESULT array_join(script_ctx_t *ctx, jsdisp_t *array, DWORD length, const WCHAR *sep, jsval_t *r)
 236 {
 237     jsstr_t **str_tab, *ret = NULL;
 238     jsval_t val;
 239     DWORD i;
 240     HRESULT hres = E_FAIL;
 241
 242     if(!length) {
 243         if(r)
 244             *r = jsval_string(jsstr_empty());
 245         return S_OK;
 246     }
 247
 248     str_tab = heap_alloc_zero(length * sizeof(*str_tab));
 249     if(!str_tab)
 250         return E_OUTOFMEMORY;
 251
 252     for(i=0; i < length; i++) {
 253         hres = jsdisp_get_idx(array, i, &val);
 254         if(hres == DISP_E_UNKNOWNNAME) {
 255             hres = S_OK;
 256             continue;
 257         } else if(FAILED(hres))
 258             break;
 259
 260         if(!is_undefined(val) && !is_null(val)) {
 261             hres = to_string(ctx, val, str_tab+i);
 262             jsval_release(val);
 263             if(FAILED(hres))
 264                 break;
 265         }
 266     }
 267
 268     if(SUCCEEDED(hres)) {
 269         DWORD seplen = 0, len = 0;
 270         WCHAR *ptr;
 271
 272         seplen = strlenW(sep);
 273
 274         if(str_tab[0])
 275             len = jsstr_length(str_tab[0]);
 276         for(i=1; i < length; i++) {
 277             len += seplen;
 278             if(str_tab[i])
 279                 len += jsstr_length(str_tab[i]);
 280             if(len > JSSTR_MAX_LENGTH) {
 281                 hres = E_OUTOFMEMORY;
 282                 break;
 283             }
 284         }
 285
 286         if(SUCCEEDED(hres))
 287             ret = jsstr_alloc_buf(len);
 288         if(ret) {
 289             unsigned tmplen;
 290
 291             ptr = ret->str;
 292
 293             if(str_tab[0]) {
 294                 tmplen = jsstr_length(str_tab[0]);
 295                 memcpy(ptr, str_tab[0]->str, tmplen*sizeof(WCHAR));
 296                 ptr += tmplen;
 297             }
 298
 299             for(i=1; i < length; i++) {
 300                 if(seplen) {
 301                     memcpy(ptr, sep, seplen*sizeof(WCHAR));
 302                     ptr += seplen;
 303                 }
 304
 305                 if(str_tab[i]) {
 306                     tmplen = jsstr_length(str_tab[i]);
 307                     memcpy(ptr, str_tab[i]->str, tmplen*sizeof(WCHAR));
 308                     ptr += tmplen;
 309                 }
 310             }
 311             *ptr=0;
 312         }else {
 313             hres = E_OUTOFMEMORY;
 314         }
 315     }
 316
 317     for(i=0; i < length; i++) {
 318         if(str_tab[i])
 319             jsstr_release(str_tab[i]);
 320     }
 321     heap_free(str_tab);
 322     if(FAILED(hres))
 323         return hres;
 324
 325     TRACE("= %s\n", debugstr_jsstr(ret));
 326
 327     if(r)
 328         *r = jsval_string(ret);
 329     else
 330         jsstr_release(ret);
 331     return S_OK;
 332 }
 333
 334 /* ECMA-262 3rd Edition    15.4.4.5 */
 335 static HRESULT Array_join(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 336         jsval_t *r)
 337 {
 338     jsdisp_t *jsthis;
 339     DWORD length;
 340     HRESULT hres;
 341
 342     TRACE("\n");
 343
 344     hres = get_length(ctx, vthis, &jsthis, &length);
 345     if(FAILED(hres))
 346         return hres;
 347
 348     if(argc) {
 349         jsstr_t *sep;
 350
 351         hres = to_string(ctx, argv[0], &sep);
 352         if(FAILED(hres))
 353             return hres;
 354
 355         hres = array_join(ctx, jsthis, length, sep->str, r);
 356
 357         jsstr_release(sep);
 358     }else {
 359         hres = array_join(ctx, jsthis, length, default_separatorW, r);
 360     }
 361
 362     return hres;
 363 }
 364
 365 static HRESULT Array_pop(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 366         jsval_t *r)
 367 {
 368     jsdisp_t *jsthis;
 369     jsval_t val;
 370     DWORD length;
 371     HRESULT hres;
 372
 373     TRACE("\n");
 374
 375     hres = get_length(ctx, vthis, &jsthis, &length);
 376     if(FAILED(hres))
 377         return hres;
 378
 379     if(!length) {
 380         hres = set_length(jsthis, 0);
 381         if(FAILED(hres))
 382             return hres;
 383
 384         if(r)
 385             *r = jsval_undefined();
 386         return S_OK;
 387     }
 388
 389     length--;
 390     hres = jsdisp_get_idx(jsthis, length, &val);
 391     if(SUCCEEDED(hres))
 392         hres = jsdisp_delete_idx(jsthis, length);
 393     else if(hres == DISP_E_UNKNOWNNAME)
 394         val = jsval_undefined();
 395     else
 396         return hres;
 397
 398     if(SUCCEEDED(hres))
 399         hres = set_length(jsthis, length);
 400
 401     if(FAILED(hres)) {
 402         jsval_release(val);
 403         return hres;
 404     }
 405
 406     if(r)
 407         *r = val;
 408     else
 409         jsval_release(val);
 410     return hres;
 411 }
 412
 413 /* ECMA-262 3rd Edition    15.4.4.7 */
 414 static HRESULT Array_push(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 415         jsval_t *r)
 416 {
 417     jsdisp_t *jsthis;
 418     DWORD length = 0;
 419     unsigned i;
 420     HRESULT hres;
 421
 422     TRACE("\n");
 423
 424     hres = get_length(ctx, vthis, &jsthis, &length);
 425     if(FAILED(hres))
 426         return hres;
 427
 428     for(i=0; i < argc; i++) {
 429         hres = jsdisp_propput_idx(jsthis, length+i, argv[i]);
 430         if(FAILED(hres))
 431             return hres;
 432     }
 433
 434     hres = set_length(jsthis, length+argc);
 435     if(FAILED(hres))
 436         return hres;
 437
 438     if(r)
 439         *r = jsval_number(length+argc);
 440     return S_OK;
 441 }
 442
 443 static HRESULT Array_reverse(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 444         jsval_t *r)
 445 {
 446     jsdisp_t *jsthis;
 447     DWORD length, k, l;
 448     jsval_t v1, v2;
 449     HRESULT hres1, hres2;
 450
 451     TRACE("\n");
 452
 453     hres1 = get_length(ctx, vthis, &jsthis, &length);
 454     if(FAILED(hres1))
 455         return hres1;
 456
 457     for(k=0; k<length/2; k++) {
 458         l = length-k-1;
 459
 460         hres1 = jsdisp_get_idx(jsthis, k, &v1);
 461         if(FAILED(hres1) && hres1!=DISP_E_UNKNOWNNAME)
 462             return hres1;
 463
 464         hres2 = jsdisp_get_idx(jsthis, l, &v2);
 465         if(FAILED(hres2) && hres2!=DISP_E_UNKNOWNNAME) {
 466             jsval_release(v1);
 467             return hres2;
 468         }
 469
 470         if(hres1 == DISP_E_UNKNOWNNAME)
 471             hres1 = jsdisp_delete_idx(jsthis, l);
 472         else
 473             hres1 = jsdisp_propput_idx(jsthis, l, v1);
 474
 475         if(FAILED(hres1)) {
 476             jsval_release(v1);
 477             jsval_release(v2);
 478             return hres1;
 479         }
 480
 481         if(hres2 == DISP_E_UNKNOWNNAME)
 482             hres2 = jsdisp_delete_idx(jsthis, k);
 483         else
 484             hres2 = jsdisp_propput_idx(jsthis, k, v2);
 485
 486         if(FAILED(hres2)) {
 487             jsval_release(v2);
 488             return hres2;
 489         }
 490     }
 491
 492     if(r)
 493         *r = jsval_obj(jsdisp_addref(jsthis));
 494     return S_OK;
 495 }
 496
 497 /* ECMA-262 3rd Edition    15.4.4.9 */
 498 static HRESULT Array_shift(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 499         jsval_t *r)
 500 {
 501     jsdisp_t *jsthis;
 502     DWORD length = 0, i;
 503     jsval_t v, ret;
 504     HRESULT hres;
 505
 506     TRACE("\n");
 507
 508     hres = get_length(ctx, vthis, &jsthis, &length);
 509     if(FAILED(hres))
 510         return hres;
 511
 512     if(!length) {
 513         hres = set_length(jsthis, 0);
 514         if(FAILED(hres))
 515             return hres;
 516     }
 517
 518     if(!length) {
 519         if(r)
 520             *r = jsval_undefined();
 521         return S_OK;
 522     }
 523
 524     hres = jsdisp_get_idx(jsthis, 0, &ret);
 525     if(hres == DISP_E_UNKNOWNNAME) {
 526         ret = jsval_undefined();
 527         hres = S_OK;
 528     }
 529
 530     for(i=1; SUCCEEDED(hres) && i<length; i++) {
 531         hres = jsdisp_get_idx(jsthis, i, &v);
 532         if(hres == DISP_E_UNKNOWNNAME)
 533             hres = jsdisp_delete_idx(jsthis, i-1);
 534         else if(SUCCEEDED(hres))
 535             hres = jsdisp_propput_idx(jsthis, i-1, v);
 536     }
 537
 538     if(SUCCEEDED(hres)) {
 539         hres = jsdisp_delete_idx(jsthis, length-1);
 540         if(SUCCEEDED(hres))
 541             hres = set_length(jsthis, length-1);
 542     }
 543
 544     if(FAILED(hres))
 545         return hres;
 546
 547     if(r)
 548         *r = ret;
 549     else
 550         jsval_release(ret);
 551     return hres;
 552 }
 553
 554 /* ECMA-262 3rd Edition    15.4.4.10 */
 555 static HRESULT Array_slice(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 556 {
 557     jsdisp_t *arr, *jsthis;
 558     DOUBLE range;
 559     DWORD 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             return hres;
 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             return hres;
 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         return hres;
 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             return hres;
 613         }
 614     }
 615
 616     if(r)
 617         *r = jsval_obj(arr);
 618     else
 619         jsdisp_release(arr);
 620
 621     return S_OK;
 622 }
 623
 624 static HRESULT sort_cmp(script_ctx_t *ctx, jsdisp_t *cmp_func, jsval_t v1, jsval_t v2, INT *cmp)
 625 {
 626     HRESULT hres;
 627
 628     if(cmp_func) {
 629         jsval_t args[2] = {v1, v2};
 630         jsval_t res;
 631         double n;
 632
 633         hres = jsdisp_call_value(cmp_func, NULL, DISPATCH_METHOD, 2, args, &res);
 634         if(FAILED(hres))
 635             return hres;
 636
 637         hres = to_number(ctx, res, &n);
 638         jsval_release(res);
 639         if(FAILED(hres))
 640             return hres;
 641
 642         if(n == 0)
 643             *cmp = 0;
 644         *cmp = n > 0.0 ? 1 : -1;
 645     }else if(is_undefined(v1)) {
 646         *cmp = is_undefined(v2) ? 0 : 1;
 647     }else if(is_undefined(v2)) {
 648         *cmp = -1;
 649     }else if(is_number(v1) && is_number(v2)) {
 650         double d = get_number(v1)-get_number(v2);
 651         if(d > 0.0)
 652             *cmp = 1;
 653         else
 654             *cmp = d < -0.0 ? -1 : 0;
 655     }else {
 656         jsstr_t *x, *y;
 657
 658         hres = to_string(ctx, v1, &x);
 659         if(FAILED(hres))
 660             return hres;
 661
 662         hres = to_string(ctx, v2, &y);
 663         if(SUCCEEDED(hres)) {
 664             *cmp = jsstr_cmp(x, y);
 665             jsstr_release(y);
 666         }
 667         jsstr_release(x);
 668         if(FAILED(hres))
 669             return hres;
 670     }
 671
 672     return S_OK;
 673 }
 674
 675 /* ECMA-262 3rd Edition    15.4.4.11 */
 676 static HRESULT Array_sort(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 677         jsval_t *r)
 678 {
 679     jsdisp_t *jsthis, *cmp_func = NULL;
 680     jsval_t *vtab, **sorttab = NULL;
 681     DWORD length;
 682     DWORD i;
 683     HRESULT hres = S_OK;
 684
 685     TRACE("\n");
 686
 687     hres = get_length(ctx, vthis, &jsthis, &length);
 688     if(FAILED(hres))
 689         return hres;
 690
 691     if(argc > 1) {
 692         WARN("invalid arg_cnt %d\n", argc);
 693         return E_FAIL;
 694     }
 695
 696     if(argc == 1) {
 697         if(!is_object_instance(argv[0])) {
 698             WARN("arg is not dispatch\n");
 699             return E_FAIL;
 700         }
 701
 702         cmp_func = iface_to_jsdisp((IUnknown*)get_object(argv[0]));
 703         if(!cmp_func || !is_class(cmp_func, JSCLASS_FUNCTION)) {
 704             WARN("cmp_func is not a function\n");
 705             if(cmp_func)
 706                 jsdisp_release(cmp_func);
 707             return E_FAIL;
 708         }
 709     }
 710
 711     if(!length) {
 712         if(cmp_func)
 713             jsdisp_release(cmp_func);
 714         if(r)
 715             *r = jsval_obj(jsdisp_addref(jsthis));
 716         return S_OK;
 717     }
 718
 719     vtab = heap_alloc_zero(length * sizeof(*vtab));
 720     if(vtab) {
 721         for(i=0; i<length; i++) {
 722             hres = jsdisp_get_idx(jsthis, i, vtab+i);
 723             if(hres == DISP_E_UNKNOWNNAME) {
 724                 vtab[i] = jsval_undefined();
 725                 hres = S_OK;
 726             } else if(FAILED(hres)) {
 727                 WARN("Could not get elem %d: %08x\n", i, hres);
 728                 break;
 729             }
 730         }
 731     }else {
 732         hres = E_OUTOFMEMORY;
 733     }
 734
 735     if(SUCCEEDED(hres)) {
 736         sorttab = heap_alloc(length*2*sizeof(*sorttab));
 737         if(!sorttab)
 738             hres = E_OUTOFMEMORY;
 739     }
 740
 741     /* merge-sort */
 742     if(SUCCEEDED(hres)) {
 743         jsval_t *tmpv, **tmpbuf;
 744         INT cmp;
 745
 746         tmpbuf = sorttab + length;
 747         for(i=0; i < length; i++)
 748             sorttab[i] = vtab+i;
 749
 750         for(i=0; i < length/2; i++) {
 751             hres = sort_cmp(ctx, cmp_func, *sorttab[2*i+1], *sorttab[2*i], &cmp);
 752             if(FAILED(hres))
 753                 break;
 754
 755             if(cmp < 0) {
 756                 tmpv = sorttab[2*i];
 757                 sorttab[2*i] = sorttab[2*i+1];
 758                 sorttab[2*i+1] = tmpv;
 759             }
 760         }
 761
 762         if(SUCCEEDED(hres)) {
 763             DWORD k, a, b, bend;
 764
 765             for(k=2; k < length; k *= 2) {
 766                 for(i=0; i+k < length; i += 2*k) {
 767                     a = b = 0;
 768                     if(i+2*k <= length)
 769                         bend = k;
 770                     else
 771                         bend = length - (i+k);
 772
 773                     memcpy(tmpbuf, sorttab+i, k*sizeof(jsval_t*));
 774
 775                     while(a < k && b < bend) {
 776                         hres = sort_cmp(ctx, cmp_func, *tmpbuf[a], *sorttab[i+k+b], &cmp);
 777                         if(FAILED(hres))
 778                             break;
 779
 780                         if(cmp < 0) {
 781                             sorttab[i+a+b] = tmpbuf[a];
 782                             a++;
 783                         }else {
 784                             sorttab[i+a+b] = sorttab[i+k+b];
 785                             b++;
 786                         }
 787                     }
 788
 789                     if(FAILED(hres))
 790                         break;
 791
 792                     if(a < k)
 793                         memcpy(sorttab+i+a+b, tmpbuf+a, (k-a)*sizeof(jsval_t*));
 794                 }
 795
 796                 if(FAILED(hres))
 797                     break;
 798             }
 799         }
 800
 801         for(i=0; SUCCEEDED(hres) && i < length; i++)
 802             hres = jsdisp_propput_idx(jsthis, i, *sorttab[i]);
 803     }
 804
 805     if(vtab) {
 806         for(i=0; i < length; i++)
 807             jsval_release(vtab[i]);
 808         heap_free(vtab);
 809     }
 810     heap_free(sorttab);
 811     if(cmp_func)
 812         jsdisp_release(cmp_func);
 813
 814     if(FAILED(hres))
 815         return hres;
 816
 817     if(r)
 818         *r = jsval_obj(jsdisp_addref(jsthis));
 819     return S_OK;
 820 }
 821
 822 /* ECMA-262 3rd Edition    15.4.4.12 */
 823 static HRESULT Array_splice(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 824         jsval_t *r)
 825 {
 826     DWORD length, start=0, delete_cnt=0, i, add_args = 0;
 827     jsdisp_t *ret_array = NULL, *jsthis;
 828     jsval_t val;
 829     double d;
 830     int n;
 831     HRESULT hres = S_OK;
 832
 833     TRACE("\n");
 834
 835     hres = get_length(ctx, vthis, &jsthis, &length);
 836     if(FAILED(hres))
 837         return hres;
 838
 839     if(argc) {
 840         hres = to_integer(ctx, argv[0], &d);
 841         if(FAILED(hres))
 842             return hres;
 843
 844         if(is_int32(d)) {
 845             if((n = d) >= 0)
 846                 start = min(n, length);
 847             else
 848                 start = -n > length ? 0 : length + n;
 849         }else {
 850             start = d < 0.0 ? 0 : length;
 851         }
 852     }
 853
 854     if(argc >= 2) {
 855         hres = to_integer(ctx, argv[1], &d);
 856         if(FAILED(hres))
 857             return hres;
 858
 859         if(is_int32(d)) {
 860             if((n = d) > 0)
 861                 delete_cnt = min(n, length-start);
 862         }else if(d > 0.0) {
 863             delete_cnt = length-start;
 864         }
 865
 866         add_args = argc-2;
 867     }
 868
 869     if(r) {
 870         hres = create_array(ctx, 0, &ret_array);
 871         if(FAILED(hres))
 872             return hres;
 873
 874         for(i=0; SUCCEEDED(hres) && i < delete_cnt; i++) {
 875             hres = jsdisp_get_idx(jsthis, start+i, &val);
 876             if(hres == DISP_E_UNKNOWNNAME) {
 877                 hres = S_OK;
 878             }else if(SUCCEEDED(hres)) {
 879                 hres = jsdisp_propput_idx(ret_array, i, val);
 880                 jsval_release(val);
 881             }
 882         }
 883
 884         if(SUCCEEDED(hres))
 885             hres = jsdisp_propput_name(ret_array, lengthW, jsval_number(delete_cnt));
 886     }
 887
 888     if(add_args < delete_cnt) {
 889         for(i = start; SUCCEEDED(hres) && i < length-delete_cnt; i++) {
 890             hres = jsdisp_get_idx(jsthis, i+delete_cnt, &val);
 891             if(hres == DISP_E_UNKNOWNNAME) {
 892                 hres = jsdisp_delete_idx(jsthis, i+add_args);
 893             }else if(SUCCEEDED(hres)) {
 894                 hres = jsdisp_propput_idx(jsthis, i+add_args, val);
 895                 jsval_release(val);
 896             }
 897         }
 898
 899         for(i=length; SUCCEEDED(hres) && i != length-delete_cnt+add_args; i--)
 900             hres = jsdisp_delete_idx(jsthis, i-1);
 901     }else if(add_args > delete_cnt) {
 902         for(i=length-delete_cnt; SUCCEEDED(hres) && i != start; i--) {
 903             hres = jsdisp_get_idx(jsthis, i+delete_cnt-1, &val);
 904             if(hres == DISP_E_UNKNOWNNAME) {
 905                 hres = jsdisp_delete_idx(jsthis, i+add_args-1);
 906             }else if(SUCCEEDED(hres)) {
 907                 hres = jsdisp_propput_idx(jsthis, i+add_args-1, val);
 908                 jsval_release(val);
 909             }
 910         }
 911     }
 912
 913     for(i=0; SUCCEEDED(hres) && i < add_args; i++)
 914         hres = jsdisp_propput_idx(jsthis, start+i, argv[i+2]);
 915
 916     if(SUCCEEDED(hres))
 917         hres = jsdisp_propput_name(jsthis, lengthW, jsval_number(length-delete_cnt+add_args));
 918
 919     if(FAILED(hres)) {
 920         if(ret_array)
 921             jsdisp_release(ret_array);
 922         return hres;
 923     }
 924
 925     if(r)
 926         *r = jsval_obj(ret_array);
 927     return S_OK;
 928 }
 929
 930 /* ECMA-262 3rd Edition    15.4.4.2 */
 931 static HRESULT Array_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 932         jsval_t *r)
 933 {
 934     ArrayInstance *array;
 935
 936     TRACE("\n");
 937
 938     array = array_this(jsthis);
 939     if(!array)
 940         return throw_type_error(ctx, JS_E_ARRAY_EXPECTED, NULL);
 941
 942     return array_join(ctx, &array->dispex, array->length, default_separatorW, r);
 943 }
 944
 945 static HRESULT Array_toLocaleString(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 946         jsval_t *r)
 947 {
 948     FIXME("\n");
 949     return E_NOTIMPL;
 950 }
 951
 952 /* ECMA-262 3rd Edition    15.4.4.13 */
 953 static HRESULT Array_unshift(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
 954         jsval_t *r)
 955 {
 956     jsdisp_t *jsthis;
 957     WCHAR buf[14], *buf_end, *str;
 958     DWORD i, length;
 959     jsval_t val;
 960     DISPID id;
 961     HRESULT hres;
 962
 963     TRACE("\n");
 964
 965     hres = get_length(ctx, vthis, &jsthis, &length);
 966     if(FAILED(hres))
 967         return hres;
 968
 969     if(argc) {
 970         buf_end = buf + sizeof(buf)/sizeof(WCHAR)-1;
 971         *buf_end-- = 0;
 972         i = length;
 973
 974         while(i--) {
 975             str = idx_to_str(i, buf_end);
 976
 977             hres = jsdisp_get_id(jsthis, str, 0, &id);
 978             if(SUCCEEDED(hres)) {
 979                 hres = jsdisp_propget(jsthis, id, &val);
 980                 if(FAILED(hres))
 981                     return hres;
 982
 983                 hres = jsdisp_propput_idx(jsthis, i+argc, val);
 984                 jsval_release(val);
 985             }else if(hres == DISP_E_UNKNOWNNAME) {
 986                 hres = IDispatchEx_DeleteMemberByDispID(vthis->u.dispex, id);
 987             }
 988         }
 989
 990         if(FAILED(hres))
 991             return hres;
 992     }
 993
 994     for(i=0; i<argc; i++) {
 995         hres = jsdisp_propput_idx(jsthis, i, argv[i]);
 996         if(FAILED(hres))
 997             return hres;
 998     }
 999
1000     if(argc) {
1001         length += argc;
1002         hres = set_length(jsthis, length);
1003         if(FAILED(hres))
1004             return hres;
1005     }
1006
1007     if(r)
1008         *r = ctx->version < 2 ? jsval_undefined() : jsval_number(length);
1009     return S_OK;
1010 }
1011
1012 static HRESULT Array_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
1013         jsval_t *r)
1014 {
1015     TRACE("\n");
1016
1017     switch(flags) {
1018     case INVOKE_FUNC:
1019         return throw_type_error(ctx, JS_E_FUNCTION_EXPECTED, NULL);
1020     case INVOKE_PROPERTYGET:
1021         return array_join(ctx, jsthis->u.jsdisp, array_from_vdisp(jsthis)->length, default_separatorW, r);
1022     default:
1023         FIXME("unimplemented flags %x\n", flags);
1024         return E_NOTIMPL;
1025     }
1026
1027     return S_OK;
1028 }
1029
1030 static void Array_destructor(jsdisp_t *dispex)
1031 {
1032     heap_free(dispex);
1033 }
1034
1035 static void Array_on_put(jsdisp_t *dispex, const WCHAR *name)
1036 {
1037     ArrayInstance *array = (ArrayInstance*)dispex;
1038     const WCHAR *ptr = name;
1039     DWORD id = 0;
1040
1041     if(!isdigitW(*ptr))
1042         return;
1043
1044     while(*ptr && isdigitW(*ptr)) {
1045         id = id*10 + (*ptr-'0');
1046         ptr++;
1047     }
1048
1049     if(*ptr)
1050         return;
1051
1052     if(id >= array->length)
1053         array->length = id+1;
1054 }
1055
1056 static const builtin_prop_t Array_props[] = {
1057     {concatW,                Array_concat,               PROPF_METHOD|1},
1058     {joinW,                  Array_join,                 PROPF_METHOD|1},
1059     {lengthW,                Array_length,               0},
1060     {popW,                   Array_pop,                  PROPF_METHOD},
1061     {pushW,                  Array_push,                 PROPF_METHOD|1},
1062     {reverseW,               Array_reverse,              PROPF_METHOD},
1063     {shiftW,                 Array_shift,                PROPF_METHOD},
1064     {sliceW,                 Array_slice,                PROPF_METHOD|2},
1065     {sortW,                  Array_sort,                 PROPF_METHOD|1},
1066     {spliceW,                Array_splice,               PROPF_METHOD|2},
1067     {toLocaleStringW,        Array_toLocaleString,       PROPF_METHOD},
1068     {toStringW,              Array_toString,             PROPF_METHOD},
1069     {unshiftW,               Array_unshift,              PROPF_METHOD|1},
1070 };
1071
1072 static const builtin_info_t Array_info = {
1073     JSCLASS_ARRAY,
1074     {NULL, Array_value, 0},
1075     sizeof(Array_props)/sizeof(*Array_props),
1076     Array_props,
1077     Array_destructor,
1078     Array_on_put
1079 };
1080
1081 static const builtin_prop_t ArrayInst_props[] = {
1082     {lengthW,                Array_length,               0}
1083 };
1084
1085 static const builtin_info_t ArrayInst_info = {
1086     JSCLASS_ARRAY,
1087     {NULL, Array_value, 0},
1088     sizeof(ArrayInst_props)/sizeof(*ArrayInst_props),
1089     ArrayInst_props,
1090     Array_destructor,
1091     Array_on_put
1092 };
1093
1094 static HRESULT ArrayConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv,
1095         jsval_t *r)
1096 {
1097     jsdisp_t *obj;
1098     DWORD i;
1099     HRESULT hres;
1100
1101     TRACE("\n");
1102
1103     switch(flags) {
1104     case DISPATCH_METHOD:
1105     case DISPATCH_CONSTRUCT: {
1106         if(argc == 1 && is_number(argv[0])) {
1107             double n = get_number(argv[0]);
1108
1109             if(n < 0 || !is_int32(n))
1110                 return throw_range_error(ctx, JS_E_INVALID_LENGTH, NULL);
1111
1112             hres = create_array(ctx, n, &obj);
1113             if(FAILED(hres))
1114                 return hres;
1115
1116             *r = jsval_obj(obj);
1117             return S_OK;
1118         }
1119
1120         hres = create_array(ctx, argc, &obj);
1121         if(FAILED(hres))
1122             return hres;
1123
1124         for(i=0; i < argc; i++) {
1125             hres = jsdisp_propput_idx(obj, i, argv[i]);
1126             if(FAILED(hres))
1127                 break;
1128         }
1129         if(FAILED(hres)) {
1130             jsdisp_release(obj);
1131             return hres;
1132         }
1133
1134         *r = jsval_obj(obj);
1135         break;
1136     }
1137     default:
1138         FIXME("unimplemented flags: %x\n", flags);
1139         return E_NOTIMPL;
1140     }
1141
1142     return S_OK;
1143 }
1144
1145 static HRESULT alloc_array(script_ctx_t *ctx, jsdisp_t *object_prototype, ArrayInstance **ret)
1146 {
1147     ArrayInstance *array;
1148     HRESULT hres;
1149
1150     array = heap_alloc_zero(sizeof(ArrayInstance));
1151     if(!array)
1152         return E_OUTOFMEMORY;
1153
1154     if(object_prototype)
1155         hres = init_dispex(&array->dispex, ctx, &Array_info, object_prototype);
1156     else
1157         hres = init_dispex_from_constr(&array->dispex, ctx, &ArrayInst_info, ctx->array_constr);
1158
1159     if(FAILED(hres)) {
1160         heap_free(array);
1161         return hres;
1162     }
1163
1164     *ret = array;
1165     return S_OK;
1166 }
1167
1168 HRESULT create_array_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
1169 {
1170     ArrayInstance *array;
1171     HRESULT hres;
1172
1173     static const WCHAR ArrayW[] = {'A','r','r','a','y',0};
1174
1175     hres = alloc_array(ctx, object_prototype, &array);
1176     if(FAILED(hres))
1177         return hres;
1178
1179     hres = create_builtin_constructor(ctx, ArrayConstr_value, ArrayW, NULL, PROPF_CONSTR|1, &array->dispex, ret);
1180
1181     jsdisp_release(&array->dispex);
1182     return hres;
1183 }
1184
1185 HRESULT create_array(script_ctx_t *ctx, DWORD length, jsdisp_t **ret)
1186 {
1187     ArrayInstance *array;
1188     HRESULT hres;
1189
1190     hres = alloc_array(ctx, NULL, &array);
1191     if(FAILED(hres))
1192         return hres;
1193
1194     array->length = length;
1195
1196     *ret = &array->dispex;
1197     return S_OK;
1198 }