git.oblomov.eu Git - wine/blob - dlls/jscript/string.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 "jscript.h"
  20
  21 #include "wine/debug.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  24
  25 typedef struct {
  26     DispatchEx dispex;
  27
  28     WCHAR *str;
  29     DWORD length;
  30 } StringInstance;
  31
  32 static const WCHAR lengthW[] = {'l','e','n','g','t','h',0};
  33 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
  34 static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
  35 static const WCHAR anchorW[] = {'a','n','c','h','o','r',0};
  36 static const WCHAR bigW[] = {'b','i','g',0};
  37 static const WCHAR blinkW[] = {'b','l','i','n','k',0};
  38 static const WCHAR boldW[] = {'b','o','l','d',0};
  39 static const WCHAR charAtW[] = {'c','h','a','r','A','t',0};
  40 static const WCHAR charCodeAtW[] = {'c','h','a','r','C','o','d','e','A','t',0};
  41 static const WCHAR concatW[] = {'c','o','n','c','a','t',0};
  42 static const WCHAR fixedW[] = {'f','i','x','e','d',0};
  43 static const WCHAR fontcolorW[] = {'f','o','n','t','c','o','l','o','r',0};
  44 static const WCHAR fontsizeW[] = {'f','o','n','t','s','i','z','e',0};
  45 static const WCHAR indexOfW[] = {'i','n','d','e','x','O','f',0};
  46 static const WCHAR italicsW[] = {'i','t','a','l','i','c','s',0};
  47 static const WCHAR lastIndexOfW[] = {'l','a','s','t','I','n','d','e','x','O','f',0};
  48 static const WCHAR linkW[] = {'l','i','n','k',0};
  49 static const WCHAR matchW[] = {'m','a','t','c','h',0};
  50 static const WCHAR replaceW[] = {'r','e','p','l','a','c','e',0};
  51 static const WCHAR searchW[] = {'s','e','a','r','c','h',0};
  52 static const WCHAR sliceW[] = {'s','l','i','c','e',0};
  53 static const WCHAR smallW[] = {'s','m','a','l','l',0};
  54 static const WCHAR splitW[] = {'s','p','l','i','t',0};
  55 static const WCHAR strikeW[] = {'s','t','r','i','k','e',0};
  56 static const WCHAR subW[] = {'s','u','b',0};
  57 static const WCHAR substringW[] = {'s','u','b','s','t','r','i','n','g',0};
  58 static const WCHAR substrW[] = {'s','u','b','s','t','r',0};
  59 static const WCHAR supW[] = {'s','u','p',0};
  60 static const WCHAR toLowerCaseW[] = {'t','o','L','o','w','e','r','C','a','s','e',0};
  61 static const WCHAR toUpperCaseW[] = {'t','o','U','p','p','e','r','C','a','s','e',0};
  62 static const WCHAR toLocaleLowerCaseW[] = {'t','o','L','o','c','a','l','e','L','o','w','e','r','C','a','s','e',0};
  63 static const WCHAR toLocaleUpperCaseW[] = {'t','o','L','o','c','a','l','e','U','p','p','e','r','C','a','s','e',0};
  64 static const WCHAR localeCompareW[] = {'l','o','c','a','l','e','C','o','m','p','a','r','e',0};
  65 static const WCHAR fromCharCodeW[] = {'f','r','o','m','C','h','a','r','C','o','d','e',0};
  66
  67 static HRESULT String_length(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
  68         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  69 {
  70     TRACE("%p\n", dispex);
  71
  72     switch(flags) {
  73     case DISPATCH_PROPERTYGET: {
  74         StringInstance *jsthis = (StringInstance*)dispex;
  75
  76         V_VT(retv) = VT_I4;
  77         V_I4(retv) = jsthis->length;
  78         break;
  79     }
  80     default:
  81         FIXME("unimplemented flags %x\n", flags);
  82         return E_NOTIMPL;
  83     }
  84
  85     return S_OK;
  86 }
  87
  88 /* ECMA-262 3rd Edition    15.5.4.2 */
  89 static HRESULT String_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
  90         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  91 {
  92     StringInstance *string;
  93
  94     TRACE("\n");
  95
  96     if(!is_class(dispex, JSCLASS_STRING)) {
  97         WARN("this is not a string object\n");
  98         return E_FAIL;
  99     }
 100
 101     string = (StringInstance*)dispex;
 102
 103     if(retv) {
 104         BSTR str = SysAllocString(string->str);
 105         if(!str)
 106             return E_OUTOFMEMORY;
 107
 108         V_VT(retv) = VT_BSTR;
 109         V_BSTR(retv) = str;
 110     }
 111     return S_OK;
 112 }
 113
 114 /* ECMA-262 3rd Edition    15.5.4.2 */
 115 static HRESULT String_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 116         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 117 {
 118     TRACE("\n");
 119
 120     return String_toString(dispex, lcid, flags, dp, retv, ei, sp);
 121 }
 122
 123 static HRESULT do_attributeless_tag_format(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 124         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp, const WCHAR *tagname)
 125 {
 126     static const WCHAR tagfmt[] = {'<','%','s','>','%','s','<','/','%','s','>',0};
 127     const WCHAR *str;
 128     DWORD length;
 129     BSTR val_str = NULL;
 130     HRESULT hres;
 131
 132     if(!is_class(dispex, JSCLASS_STRING)) {
 133         VARIANT this;
 134
 135         V_VT(&this) = VT_DISPATCH;
 136         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 137
 138         hres = to_string(dispex->ctx, &this, ei, &val_str);
 139         if(FAILED(hres))
 140             return hres;
 141
 142         str = val_str;
 143         length = SysStringLen(val_str);
 144     }
 145     else {
 146         StringInstance *this = (StringInstance*)dispex;
 147
 148         str = this->str;
 149         length = this->length;
 150     }
 151
 152     if(retv) {
 153         BSTR ret = SysAllocStringLen(NULL, length + 2*strlenW(tagname) + 5);
 154         if(!ret) {
 155             SysFreeString(val_str);
 156             return E_OUTOFMEMORY;
 157         }
 158
 159         sprintfW(ret, tagfmt, tagname, str, tagname);
 160
 161         V_VT(retv) = VT_BSTR;
 162         V_BSTR(retv) = ret;
 163     }
 164
 165     SysFreeString(val_str);
 166     return S_OK;
 167 }
 168
 169 static HRESULT do_attribute_tag_format(DispatchEx *dispex, LCID lcid, WORD flags,
 170         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp,
 171         const WCHAR *tagname, const WCHAR *attr)
 172 {
 173     static const WCHAR tagfmtW[]
 174         = {'<','%','s',' ','%','s','=','\"','%','s','\"','>','%','s','<','/','%','s','>',0};
 175     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
 176
 177     const WCHAR *str;
 178     DWORD length;
 179     BSTR attr_value, val_str = NULL;
 180     HRESULT hres;
 181
 182     if(!is_class(dispex, JSCLASS_STRING)) {
 183         VARIANT this;
 184
 185         V_VT(&this) = VT_DISPATCH;
 186         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 187
 188         hres = to_string(dispex->ctx, &this, ei, &val_str);
 189         if(FAILED(hres))
 190             return hres;
 191
 192         str = val_str;
 193         length = SysStringLen(val_str);
 194     }
 195     else {
 196         StringInstance *this = (StringInstance*)dispex;
 197
 198         str = this->str;
 199         length = this->length;
 200     }
 201
 202     if(arg_cnt(dp)) {
 203         hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &attr_value);
 204         if(FAILED(hres)) {
 205             SysFreeString(val_str);
 206             return hres;
 207         }
 208     }
 209     else {
 210         attr_value = SysAllocString(undefinedW);
 211         if(!attr_value) {
 212             SysFreeString(val_str);
 213             return E_OUTOFMEMORY;
 214         }
 215     }
 216
 217     if(retv) {
 218         BSTR ret = SysAllocStringLen(NULL, length + 2*strlenW(tagname)
 219                 + strlenW(attr) + SysStringLen(attr_value) + 9);
 220         if(!ret) {
 221             SysFreeString(attr_value);
 222             SysFreeString(val_str);
 223             return E_OUTOFMEMORY;
 224         }
 225
 226         sprintfW(ret, tagfmtW, tagname, attr, attr_value, str, tagname);
 227
 228         V_VT(retv) = VT_BSTR;
 229         V_BSTR(retv) = ret;
 230     }
 231
 232     SysFreeString(attr_value);
 233     SysFreeString(val_str);
 234     return S_OK;
 235 }
 236
 237 static HRESULT String_anchor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 238         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 239 {
 240     static const WCHAR fontW[] = {'A',0};
 241     static const WCHAR colorW[] = {'N','A','M','E',0};
 242
 243     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
 244 }
 245
 246 static HRESULT String_big(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 247         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 248 {
 249     static const WCHAR bigtagW[] = {'B','I','G',0};
 250     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, bigtagW);
 251 }
 252
 253 static HRESULT String_blink(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 254         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 255 {
 256     static const WCHAR blinktagW[] = {'B','L','I','N','K',0};
 257     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, blinktagW);
 258 }
 259
 260 static HRESULT String_bold(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 261         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 262 {
 263     static const WCHAR boldtagW[] = {'B',0};
 264     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, boldtagW);
 265 }
 266
 267 /* ECMA-262 3rd Edition    15.5.4.5 */
 268 static HRESULT String_charAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 269         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 270 {
 271     const WCHAR *str;
 272     DWORD length;
 273     BSTR ret, val_str = NULL;
 274     INT pos = 0;
 275     HRESULT hres;
 276
 277     TRACE("\n");
 278
 279     if(!is_class(dispex, JSCLASS_STRING)) {
 280         VARIANT this;
 281
 282         V_VT(&this) = VT_DISPATCH;
 283         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 284
 285         hres = to_string(dispex->ctx, &this, ei, &val_str);
 286         if(FAILED(hres))
 287             return hres;
 288
 289         str = val_str;
 290         length = SysStringLen(val_str);
 291     }
 292     else {
 293         StringInstance *this = (StringInstance*)dispex;
 294
 295         str = this->str;
 296         length = this->length;
 297     }
 298
 299     if(arg_cnt(dp)) {
 300         VARIANT num;
 301
 302         hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &num);
 303         if(FAILED(hres)) {
 304             SysFreeString(val_str);
 305             return hres;
 306         }
 307
 308         if(V_VT(&num) == VT_I4) {
 309             pos = V_I4(&num);
 310         }else {
 311             WARN("pos = %lf\n", V_R8(&num));
 312             pos = -1;
 313         }
 314     }
 315
 316     if(!retv) {
 317         SysFreeString(val_str);
 318         return S_OK;
 319     }
 320
 321     if(0 <= pos && pos < length)
 322         ret = SysAllocStringLen(str+pos, 1);
 323     else
 324         ret = SysAllocStringLen(NULL, 0);
 325     SysFreeString(val_str);
 326     if(!ret) {
 327         return E_OUTOFMEMORY;
 328     }
 329
 330     V_VT(retv) = VT_BSTR;
 331     V_BSTR(retv) = ret;
 332     return S_OK;
 333 }
 334
 335 /* ECMA-262 3rd Edition    15.5.4.5 */
 336 static HRESULT String_charCodeAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 337         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 338 {
 339     const WCHAR *str;
 340     BSTR val_str = NULL;
 341     DWORD length, idx = 0;
 342     HRESULT hres;
 343
 344     TRACE("\n");
 345
 346     if(!is_class(dispex, JSCLASS_STRING)) {
 347         VARIANT this;
 348
 349         V_VT(&this) = VT_DISPATCH;
 350         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 351
 352         hres = to_string(dispex->ctx, &this, ei, &val_str);
 353         if(FAILED(hres))
 354             return hres;
 355
 356         str = val_str;
 357         length = SysStringLen(val_str);
 358     }
 359     else {
 360         StringInstance *this = (StringInstance*)dispex;
 361
 362         str = this->str;
 363         length = this->length;
 364     }
 365
 366     if(arg_cnt(dp) > 0) {
 367         VARIANT v;
 368
 369         hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &v);
 370         if(FAILED(hres)) {
 371             SysFreeString(val_str);
 372             return hres;
 373         }
 374
 375         if(V_VT(&v) != VT_I4 || V_I4(&v) < 0 || V_I4(&v) >= length) {
 376             if(retv) num_set_nan(&v);
 377             SysFreeString(val_str);
 378             return S_OK;
 379         }
 380
 381         idx = V_I4(&v);
 382     }
 383
 384     if(retv) {
 385         V_VT(retv) = VT_I4;
 386         V_I4(retv) = str[idx];
 387     }
 388
 389     SysFreeString(val_str);
 390     return S_OK;
 391 }
 392
 393 /* ECMA-262 3rd Edition    15.5.4.6 */
 394 static HRESULT String_concat(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 395         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 396 {
 397     BSTR *strs = NULL, ret = NULL;
 398     DWORD len = 0, i, l, str_cnt;
 399     VARIANT var;
 400     WCHAR *ptr;
 401     HRESULT hres;
 402
 403     TRACE("\n");
 404
 405     str_cnt = arg_cnt(dp)+1;
 406     strs = heap_alloc_zero(str_cnt * sizeof(BSTR));
 407     if(!strs)
 408         return E_OUTOFMEMORY;
 409
 410     V_VT(&var) = VT_DISPATCH;
 411     V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
 412
 413     hres = to_string(dispex->ctx, &var, ei, strs);
 414     if(SUCCEEDED(hres)) {
 415         for(i=0; i < arg_cnt(dp); i++) {
 416             hres = to_string(dispex->ctx, get_arg(dp, i), ei, strs+i+1);
 417             if(FAILED(hres))
 418                 break;
 419         }
 420     }
 421
 422     if(SUCCEEDED(hres)) {
 423         for(i=0; i < str_cnt; i++)
 424             len += SysStringLen(strs[i]);
 425
 426         ptr = ret = SysAllocStringLen(NULL, len);
 427
 428         for(i=0; i < str_cnt; i++) {
 429             l = SysStringLen(strs[i]);
 430             memcpy(ptr, strs[i], l*sizeof(WCHAR));
 431             ptr += l;
 432         }
 433     }
 434
 435     for(i=0; i < str_cnt; i++)
 436         SysFreeString(strs[i]);
 437     heap_free(strs);
 438
 439     if(FAILED(hres))
 440         return hres;
 441
 442     if(retv) {
 443         V_VT(retv) = VT_BSTR;
 444         V_BSTR(retv) = ret;
 445     }else {
 446         SysFreeString(ret);
 447     }
 448     return S_OK;
 449 }
 450
 451 static HRESULT String_fixed(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 452         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 453 {
 454     static const WCHAR fixedtagW[] = {'T','T',0};
 455     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fixedtagW);
 456 }
 457
 458 static HRESULT String_fontcolor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 459         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 460 {
 461     static const WCHAR fontW[] = {'F','O','N','T',0};
 462     static const WCHAR colorW[] = {'C','O','L','O','R',0};
 463
 464     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
 465 }
 466
 467 static HRESULT String_fontsize(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 468         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 469 {
 470     static const WCHAR fontW[] = {'F','O','N','T',0};
 471     static const WCHAR colorW[] = {'S','I','Z','E',0};
 472
 473     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
 474 }
 475
 476 static HRESULT String_indexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 477         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 478 {
 479     DWORD length, pos = 0;
 480     const WCHAR *str;
 481     BSTR search_str, val_str = NULL;
 482     INT ret = -1;
 483     HRESULT hres;
 484
 485     TRACE("\n");
 486
 487     if(!is_class(dispex, JSCLASS_STRING)) {
 488         VARIANT this;
 489
 490         V_VT(&this) = VT_DISPATCH;
 491         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 492
 493         hres = to_string(dispex->ctx, &this, ei, &val_str);
 494         if(FAILED(hres))
 495             return hres;
 496
 497         str = val_str;
 498         length = SysStringLen(val_str);
 499     }
 500     else {
 501         StringInstance *this = (StringInstance*)dispex;
 502
 503         str = this->str;
 504         length = this->length;
 505     }
 506
 507     if(!arg_cnt(dp)) {
 508         if(retv) {
 509             V_VT(retv) = VT_I4;
 510             V_I4(retv) = -1;
 511         }
 512         SysFreeString(val_str);
 513         return S_OK;
 514     }
 515
 516     hres = to_string(dispex->ctx, get_arg(dp,0), ei, &search_str);
 517     if(FAILED(hres)) {
 518         SysFreeString(val_str);
 519         return hres;
 520     }
 521
 522     if(arg_cnt(dp) >= 2) {
 523         VARIANT ival;
 524
 525         hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &ival);
 526         if(SUCCEEDED(hres)) {
 527             if(V_VT(&ival) == VT_I4)
 528                 pos = V_VT(&ival) > 0 ? V_I4(&ival) : 0;
 529             else
 530                 pos = V_R8(&ival) > 0.0 ? length : 0;
 531             if(pos > length)
 532                 pos = length;
 533         }
 534     }
 535
 536     if(SUCCEEDED(hres)) {
 537         const WCHAR *ptr;
 538
 539         ptr = strstrW(str+pos, search_str);
 540         if(ptr)
 541             ret = ptr - str;
 542         else
 543             ret = -1;
 544     }
 545
 546     SysFreeString(search_str);
 547     SysFreeString(val_str);
 548     if(FAILED(hres))
 549         return hres;
 550
 551     if(retv) {
 552         V_VT(retv) = VT_I4;
 553         V_I4(retv) = ret;
 554     }
 555     return S_OK;
 556 }
 557
 558 static HRESULT String_italics(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 559         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 560 {
 561     static const WCHAR italicstagW[] = {'I',0};
 562     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, italicstagW);
 563 }
 564
 565 /* ECMA-262 3rd Edition    15.5.4.8 */
 566 static HRESULT String_lastIndexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 567         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 568 {
 569     BSTR search_str, val_str = NULL;
 570     DWORD length, pos, search_len;
 571     const WCHAR *str;
 572     INT ret = -1;
 573     HRESULT hres;
 574
 575     TRACE("\n");
 576
 577     if(is_class(dispex, JSCLASS_STRING)) {
 578         StringInstance *this = (StringInstance*)dispex;
 579
 580         str = this->str;
 581         length = this->length;
 582     }else {
 583         VARIANT this;
 584
 585         V_VT(&this) = VT_DISPATCH;
 586         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 587
 588         hres = to_string(dispex->ctx, &this, ei, &val_str);
 589         if(FAILED(hres))
 590             return hres;
 591
 592         str = val_str;
 593         length = SysStringLen(val_str);
 594     }
 595
 596     if(!arg_cnt(dp)) {
 597         if(retv) {
 598             V_VT(retv) = VT_I4;
 599             V_I4(retv) = -1;
 600         }
 601         SysFreeString(val_str);
 602         return S_OK;
 603     }
 604
 605     hres = to_string(dispex->ctx, get_arg(dp,0), ei, &search_str);
 606     if(FAILED(hres)) {
 607         SysFreeString(val_str);
 608         return hres;
 609     }
 610
 611     search_len = SysStringLen(search_str);
 612
 613     if(arg_cnt(dp) >= 2) {
 614         VARIANT ival;
 615
 616         hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &ival);
 617         if(SUCCEEDED(hres)) {
 618             if(V_VT(&ival) == VT_I4)
 619                 pos = V_VT(&ival) > 0 ? V_I4(&ival) : 0;
 620             else
 621                 pos = V_R8(&ival) > 0.0 ? length : 0;
 622             if(pos > length)
 623                 pos = length;
 624         }
 625     }else {
 626         pos = length;
 627     }
 628
 629     if(SUCCEEDED(hres) && length >= search_len) {
 630         const WCHAR *ptr;
 631
 632         for(ptr = str+min(pos, length-search_len); ptr >= str; ptr--) {
 633             if(!memcmp(ptr, search_str, search_len*sizeof(WCHAR))) {
 634                 ret = ptr-str;
 635                 break;
 636             }
 637         }
 638     }
 639
 640     SysFreeString(search_str);
 641     SysFreeString(val_str);
 642     if(FAILED(hres))
 643         return hres;
 644
 645     if(retv) {
 646         V_VT(retv) = VT_I4;
 647         V_I4(retv) = ret;
 648     }
 649     return S_OK;
 650 }
 651
 652 static HRESULT String_link(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 653         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 654 {
 655     static const WCHAR fontW[] = {'A',0};
 656     static const WCHAR colorW[] = {'H','R','E','F',0};
 657
 658     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
 659 }
 660
 661 /* ECMA-262 3rd Edition    15.5.4.10 */
 662 static HRESULT String_match(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 663         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 664 {
 665     const WCHAR *str;
 666     match_result_t *match_result;
 667     DispatchEx *regexp;
 668     DispatchEx *array;
 669     VARIANT var, *arg_var;
 670     DWORD length, match_cnt, i;
 671     BSTR val_str = NULL;
 672     HRESULT hres = S_OK;
 673
 674     TRACE("\n");
 675
 676     if(!arg_cnt(dp)) {
 677         if(retv) {
 678             V_VT(retv) = VT_NULL;
 679         }
 680
 681         return S_OK;
 682     }
 683
 684     arg_var = get_arg(dp, 0);
 685     switch(V_VT(arg_var)) {
 686     case VT_DISPATCH:
 687         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
 688         if(regexp) {
 689             if(regexp->builtin_info->class == JSCLASS_REGEXP)
 690                 break;
 691             jsdisp_release(regexp);
 692         }
 693     default: {
 694         BSTR match_str;
 695
 696         hres = to_string(dispex->ctx, arg_var, ei, &match_str);
 697         if(FAILED(hres))
 698             return hres;
 699
 700         hres = create_regexp_str(dispex->ctx, match_str, SysStringLen(match_str), NULL, 0, &regexp);
 701         SysFreeString(match_str);
 702         if(FAILED(hres))
 703             return hres;
 704     }
 705     }
 706
 707     if(!is_class(dispex, JSCLASS_STRING)) {
 708         VARIANT this;
 709
 710         V_VT(&this) = VT_DISPATCH;
 711         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 712
 713         hres = to_string(dispex->ctx, &this, ei, &val_str);
 714         if(FAILED(hres)) {
 715             jsdisp_release(regexp);
 716             return hres;
 717         }
 718
 719         str = val_str;
 720         length = SysStringLen(val_str);
 721     }
 722     else {
 723         StringInstance *this = (StringInstance*)dispex;
 724
 725         str = this->str;
 726         length = this->length;
 727     }
 728
 729     hres = regexp_match(regexp, str, length, FALSE, &match_result, &match_cnt);
 730     jsdisp_release(regexp);
 731     if(FAILED(hres)) {
 732         SysFreeString(val_str);
 733         return hres;
 734     }
 735
 736     if(!match_cnt) {
 737         TRACE("no match\n");
 738
 739         if(retv)
 740             V_VT(retv) = VT_NULL;
 741
 742         SysFreeString(val_str);
 743         return S_OK;
 744     }
 745
 746     hres = create_array(dispex->ctx, match_cnt, &array);
 747     if(FAILED(hres)) {
 748         SysFreeString(val_str);
 749         return hres;
 750     }
 751
 752     V_VT(&var) = VT_BSTR;
 753
 754     for(i=0; i < match_cnt; i++) {
 755         V_BSTR(&var) = SysAllocStringLen(match_result[i].str, match_result[i].len);
 756         if(!V_BSTR(&var)) {
 757             hres = E_OUTOFMEMORY;
 758             break;
 759         }
 760
 761         hres = jsdisp_propput_idx(array, i, lcid, &var, ei, NULL/*FIXME*/);
 762         SysFreeString(V_BSTR(&var));
 763         if(FAILED(hres))
 764             break;
 765     }
 766
 767     SysFreeString(val_str);
 768
 769     if(SUCCEEDED(hres) && retv) {
 770         V_VT(retv) = VT_DISPATCH;
 771         V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
 772     }else {
 773         jsdisp_release(array);
 774     }
 775     return hres;
 776 }
 777
 778 typedef struct {
 779     WCHAR *buf;
 780     DWORD size;
 781     DWORD len;
 782 } strbuf_t;
 783
 784 static HRESULT strbuf_append(strbuf_t *buf, const WCHAR *str, DWORD len)
 785 {
 786     if(!len)
 787         return S_OK;
 788
 789     if(len + buf->len > buf->size) {
 790         WCHAR *new_buf;
 791         DWORD new_size;
 792
 793         new_size = buf->size ? buf->size<<1 : 16;
 794         if(new_size < buf->len+len)
 795             new_size = buf->len+len;
 796         if(buf->buf)
 797             new_buf = heap_realloc(buf->buf, new_size*sizeof(WCHAR));
 798         else
 799             new_buf = heap_alloc(new_size*sizeof(WCHAR));
 800         if(!new_buf)
 801             return E_OUTOFMEMORY;
 802
 803         buf->buf = new_buf;
 804         buf->size = new_size;
 805     }
 806
 807     memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR));
 808     buf->len += len;
 809     return S_OK;
 810 }
 811
 812 static HRESULT rep_call(DispatchEx *func, const WCHAR *str, match_result_t *match, match_result_t *parens,
 813         DWORD parens_cnt, LCID lcid, BSTR *ret, jsexcept_t *ei, IServiceProvider *caller)
 814 {
 815     DISPPARAMS dp = {NULL, NULL, 0, 0};
 816     VARIANTARG *args, *arg;
 817     VARIANT var;
 818     DWORD i;
 819     HRESULT hres = S_OK;
 820
 821     dp.cArgs = parens_cnt+3;
 822     dp.rgvarg = args = heap_alloc_zero(sizeof(VARIANT)*dp.cArgs);
 823     if(!args)
 824         return E_OUTOFMEMORY;
 825
 826     arg = get_arg(&dp,0);
 827     V_VT(arg) = VT_BSTR;
 828     V_BSTR(arg) = SysAllocStringLen(match->str, match->len);
 829     if(!V_BSTR(arg))
 830         hres = E_OUTOFMEMORY;
 831
 832     if(SUCCEEDED(hres)) {
 833         for(i=0; i < parens_cnt; i++) {
 834             arg = get_arg(&dp,i+1);
 835             V_VT(arg) = VT_BSTR;
 836             V_BSTR(arg) = SysAllocStringLen(parens[i].str, parens[i].len);
 837             if(!V_BSTR(arg)) {
 838                hres = E_OUTOFMEMORY;
 839                break;
 840             }
 841         }
 842     }
 843
 844     if(SUCCEEDED(hres)) {
 845         arg = get_arg(&dp,parens_cnt+1);
 846         V_VT(arg) = VT_I4;
 847         V_I4(arg) = match->str - str;
 848
 849         arg = get_arg(&dp,parens_cnt+2);
 850         V_VT(arg) = VT_BSTR;
 851         V_BSTR(arg) = SysAllocString(str);
 852         if(!V_BSTR(arg))
 853             hres = E_OUTOFMEMORY;
 854     }
 855
 856     if(SUCCEEDED(hres))
 857         hres = jsdisp_call_value(func, lcid, DISPATCH_METHOD, &dp, &var, ei, caller);
 858
 859     for(i=0; i < parens_cnt+1; i++) {
 860         if(i != parens_cnt+1)
 861             SysFreeString(V_BSTR(get_arg(&dp,i)));
 862     }
 863     heap_free(args);
 864
 865     if(FAILED(hres))
 866         return hres;
 867
 868     hres = to_string(func->ctx, &var, ei, ret);
 869     VariantClear(&var);
 870     return hres;
 871 }
 872
 873 /* ECMA-262 3rd Edition    15.5.4.11 */
 874 static HRESULT String_replace(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 875         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 876 {
 877     const WCHAR *str;
 878     DWORD parens_cnt = 0, parens_size=0, rep_len=0, length;
 879     BSTR rep_str = NULL, match_str = NULL, ret_str, val_str = NULL;
 880     DispatchEx *rep_func = NULL, *regexp = NULL;
 881     match_result_t *parens = NULL, match, **parens_ptr = &parens;
 882     strbuf_t ret = {NULL,0,0};
 883     BOOL gcheck = FALSE;
 884     VARIANT *arg_var;
 885     HRESULT hres = S_OK;
 886
 887     TRACE("\n");
 888
 889     if(!is_class(dispex, JSCLASS_STRING)) {
 890         VARIANT this;
 891
 892         V_VT(&this) = VT_DISPATCH;
 893         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
 894
 895         hres = to_string(dispex->ctx, &this, ei, &val_str);
 896         if(FAILED(hres))
 897             return hres;
 898
 899         str = val_str;
 900         length = SysStringLen(val_str);
 901     }
 902     else {
 903         StringInstance *this = (StringInstance*)dispex;
 904
 905         str = this->str;
 906         length = this->length;
 907     }
 908
 909     if(!arg_cnt(dp)) {
 910         if(retv) {
 911             if(!val_str) {
 912                 val_str = SysAllocStringLen(str, length);
 913                 if(!val_str)
 914                     return E_OUTOFMEMORY;
 915             }
 916
 917             V_VT(retv) = VT_BSTR;
 918             V_BSTR(retv) = val_str;
 919         }
 920         return S_OK;
 921     }
 922
 923     arg_var = get_arg(dp, 0);
 924     switch(V_VT(arg_var)) {
 925     case VT_DISPATCH:
 926         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
 927         if(regexp) {
 928             if(is_class(regexp, JSCLASS_REGEXP)) {
 929                 break;
 930             }else {
 931                 jsdisp_release(regexp);
 932                 regexp = NULL;
 933             }
 934         }
 935
 936     default:
 937         hres = to_string(dispex->ctx, arg_var, ei, &match_str);
 938         if(FAILED(hres)) {
 939             SysFreeString(val_str);
 940             return hres;
 941         }
 942     }
 943
 944     if(arg_cnt(dp) >= 2) {
 945         arg_var = get_arg(dp,1);
 946         switch(V_VT(arg_var)) {
 947         case VT_DISPATCH:
 948             rep_func = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
 949             if(rep_func) {
 950                 if(is_class(rep_func, JSCLASS_FUNCTION)) {
 951                     break;
 952                 }else {
 953                     jsdisp_release(rep_func);
 954                     rep_func = NULL;
 955                 }
 956             }
 957
 958         default:
 959             hres = to_string(dispex->ctx, arg_var, ei, &rep_str);
 960             if(FAILED(hres))
 961                 break;
 962
 963             rep_len = SysStringLen(rep_str);
 964             if(!strchrW(rep_str, '$'))
 965                 parens_ptr = NULL;
 966         }
 967     }
 968
 969     if(SUCCEEDED(hres)) {
 970         const WCHAR *cp, *ecp;
 971
 972         cp = ecp = str;
 973
 974         while(1) {
 975             if(regexp) {
 976                 hres = regexp_match_next(regexp, gcheck, str, length, &cp, parens_ptr,
 977                                          &parens_size, &parens_cnt, &match);
 978                 gcheck = TRUE;
 979
 980                 if(hres == S_FALSE) {
 981                     hres = S_OK;
 982                     break;
 983                 }
 984                 if(FAILED(hres))
 985                     break;
 986             }else {
 987                 match.str = strstrW(cp, match_str);
 988                 if(!match.str)
 989                     break;
 990                 match.len = SysStringLen(match_str);
 991                 cp = match.str+match.len;
 992             }
 993
 994             hres = strbuf_append(&ret, ecp, match.str-ecp);
 995             ecp = match.str+match.len;
 996             if(FAILED(hres))
 997                 break;
 998
 999             if(rep_func) {
1000                 BSTR cstr;
1001
1002                 hres = rep_call(rep_func, str, &match, parens, parens_cnt, lcid, &cstr, ei, caller);
1003                 if(FAILED(hres))
1004                     break;
1005
1006                 hres = strbuf_append(&ret, cstr, SysStringLen(cstr));
1007                 SysFreeString(cstr);
1008                 if(FAILED(hres))
1009                     break;
1010             }else if(rep_str && regexp) {
1011                 const WCHAR *ptr = rep_str, *ptr2;
1012
1013                 while((ptr2 = strchrW(ptr, '$'))) {
1014                     hres = strbuf_append(&ret, ptr, ptr2-ptr);
1015                     if(FAILED(hres))
1016                         break;
1017
1018                     switch(ptr2[1]) {
1019                     case '$':
1020                         hres = strbuf_append(&ret, ptr2, 1);
1021                         ptr = ptr2+2;
1022                         break;
1023                     case '&':
1024                         hres = strbuf_append(&ret, match.str, match.len);
1025                         ptr = ptr2+2;
1026                         break;
1027                     case '`':
1028                         hres = strbuf_append(&ret, str, match.str-str);
1029                         ptr = ptr2+2;
1030                         break;
1031                     case '\'':
1032                         hres = strbuf_append(&ret, ecp, (str+length)-ecp);
1033                         ptr = ptr2+2;
1034                         break;
1035                     default: {
1036                         DWORD idx;
1037
1038                         if(!isdigitW(ptr2[1])) {
1039                             hres = strbuf_append(&ret, ptr2, 1);
1040                             ptr = ptr2+1;
1041                             break;
1042                         }
1043
1044                         idx = ptr2[1] - '0';
1045                         if(isdigitW(ptr[3]) && idx*10 + (ptr[2]-'0') <= parens_cnt) {
1046                             idx = idx*10 + (ptr[2]-'0');
1047                             ptr = ptr2+3;
1048                         }else if(idx && idx <= parens_cnt) {
1049                             ptr = ptr2+2;
1050                         }else {
1051                             hres = strbuf_append(&ret, ptr2, 1);
1052                             ptr = ptr2+1;
1053                             break;
1054                         }
1055
1056                         hres = strbuf_append(&ret, parens[idx-1].str, parens[idx-1].len);
1057                     }
1058                     }
1059
1060                     if(FAILED(hres))
1061                         break;
1062                 }
1063
1064                 if(SUCCEEDED(hres))
1065                     hres = strbuf_append(&ret, ptr, (rep_str+rep_len)-ptr);
1066                 if(FAILED(hres))
1067                     break;
1068             }else if(rep_str) {
1069                 hres = strbuf_append(&ret, rep_str, rep_len);
1070                 if(FAILED(hres))
1071                     break;
1072             }else {
1073                 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d'};
1074
1075                 hres = strbuf_append(&ret, undefinedW, sizeof(undefinedW)/sizeof(WCHAR));
1076                 if(FAILED(hres))
1077                     break;
1078             }
1079         }
1080
1081         if(SUCCEEDED(hres))
1082             hres = strbuf_append(&ret, ecp, (str+length)-ecp);
1083     }
1084
1085     if(rep_func)
1086         jsdisp_release(rep_func);
1087     if(regexp)
1088         jsdisp_release(regexp);
1089     SysFreeString(val_str);
1090     SysFreeString(rep_str);
1091     SysFreeString(match_str);
1092     heap_free(parens);
1093
1094     if(SUCCEEDED(hres) && retv) {
1095         ret_str = SysAllocStringLen(ret.buf, ret.len);
1096         if(!ret_str)
1097             return E_OUTOFMEMORY;
1098
1099         V_VT(retv) = VT_BSTR;
1100         V_BSTR(retv) = ret_str;
1101         TRACE("= %s\n", debugstr_w(ret_str));
1102     }
1103
1104     heap_free(ret.buf);
1105     return hres;
1106 }
1107
1108 static HRESULT String_search(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1109         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1110 {
1111     FIXME("\n");
1112     return E_NOTIMPL;
1113 }
1114
1115 /* ECMA-262 3rd Edition    15.5.4.13 */
1116 static HRESULT String_slice(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1117         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1118 {
1119     const WCHAR *str;
1120     BSTR val_str = NULL;
1121     DWORD length;
1122     INT start=0, end;
1123     VARIANT v;
1124     HRESULT hres;
1125
1126     TRACE("\n");
1127
1128     if(!is_class(dispex, JSCLASS_STRING)) {
1129         VARIANT this;
1130
1131         V_VT(&this) = VT_DISPATCH;
1132         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
1133
1134         hres = to_string(dispex->ctx, &this, ei, &val_str);
1135         if(FAILED(hres))
1136             return hres;
1137
1138         str = val_str;
1139         length = SysStringLen(val_str);
1140     }
1141     else {
1142         StringInstance *this = (StringInstance*)dispex;
1143
1144         str = this->str;
1145         length = this->length;
1146     }
1147
1148     if(arg_cnt(dp)) {
1149         hres = to_integer(dispex->ctx, get_arg(dp,0), ei, &v);
1150         if(FAILED(hres)) {
1151             SysFreeString(val_str);
1152             return hres;
1153         }
1154
1155         if(V_VT(&v) == VT_I4) {
1156             start = V_I4(&v);
1157             if(start < 0) {
1158                 start = length + start;
1159                 if(start < 0)
1160                     start = 0;
1161             }else if(start > length) {
1162                 start = length;
1163             }
1164         }else {
1165             start = V_R8(&v) < 0.0 ? 0 : length;
1166         }
1167     }else {
1168         start = 0;
1169     }
1170
1171     if(arg_cnt(dp) >= 2) {
1172         hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &v);
1173         if(FAILED(hres)) {
1174             SysFreeString(val_str);
1175             return hres;
1176         }
1177
1178         if(V_VT(&v) == VT_I4) {
1179             end = V_I4(&v);
1180             if(end < 0) {
1181                 end = length + end;
1182                 if(end < 0)
1183                     end = 0;
1184             }else if(end > length) {
1185                 end = length;
1186             }
1187         }else {
1188             end = V_R8(&v) < 0.0 ? 0 : length;
1189         }
1190     }else {
1191         end = length;
1192     }
1193
1194     if(end < start)
1195         end = start;
1196
1197     if(retv) {
1198         BSTR retstr = SysAllocStringLen(str+start, end-start);
1199         if(!retstr) {
1200             SysFreeString(val_str);
1201             return E_OUTOFMEMORY;
1202         }
1203
1204         V_VT(retv) = VT_BSTR;
1205         V_BSTR(retv) = retstr;
1206     }
1207
1208     SysFreeString(val_str);
1209     return S_OK;
1210 }
1211
1212 static HRESULT String_small(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1213         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1214 {
1215     static const WCHAR smalltagW[] = {'S','M','A','L','L',0};
1216     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, smalltagW);
1217 }
1218
1219 static HRESULT String_split(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1220         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1221 {
1222     match_result_t *match_result = NULL;
1223     DWORD length, match_cnt, i, match_len = 0;
1224     const WCHAR *str, *ptr, *ptr2;
1225     VARIANT *arg, var;
1226     DispatchEx *array;
1227     BSTR val_str = NULL, match_str = NULL;
1228     HRESULT hres;
1229
1230     TRACE("\n");
1231
1232     if(arg_cnt(dp) != 1) {
1233         FIXME("unsupported args\n");
1234         return E_NOTIMPL;
1235     }
1236
1237     if(!is_class(dispex, JSCLASS_STRING)) {
1238         VARIANT this;
1239
1240         V_VT(&this) = VT_DISPATCH;
1241         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
1242
1243         hres = to_string(dispex->ctx, &this, ei, &val_str);
1244         if(FAILED(hres))
1245             return hres;
1246
1247         str = val_str;
1248         length = SysStringLen(val_str);
1249     }
1250     else {
1251         StringInstance *this = (StringInstance*)dispex;
1252
1253         str = this->str;
1254         length = this->length;
1255     }
1256
1257     arg = get_arg(dp, 0);
1258     switch(V_VT(arg)) {
1259     case VT_DISPATCH: {
1260         DispatchEx *regexp;
1261
1262         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg));
1263         if(regexp) {
1264             if(is_class(regexp, JSCLASS_REGEXP)) {
1265                 hres = regexp_match(regexp, str, length, TRUE, &match_result, &match_cnt);
1266                 jsdisp_release(regexp);
1267                 if(FAILED(hres)) {
1268                     SysFreeString(val_str);
1269                     return hres;
1270                 }
1271                 break;
1272             }
1273             jsdisp_release(regexp);
1274         }
1275     }
1276     default:
1277         hres = to_string(dispex->ctx, arg, ei, &match_str);
1278         if(FAILED(hres)) {
1279             SysFreeString(val_str);
1280             return hres;
1281         }
1282
1283         match_len = SysStringLen(match_str);
1284         if(!match_len) {
1285             SysFreeString(match_str);
1286             match_str = NULL;
1287         }
1288     }
1289
1290     hres = create_array(dispex->ctx, 0, &array);
1291
1292     if(SUCCEEDED(hres)) {
1293         ptr = str;
1294         for(i=0;; i++) {
1295             if(match_result) {
1296                 if(i == match_cnt)
1297                     break;
1298                 ptr2 = match_result[i].str;
1299             }else if(match_str) {
1300                 ptr2 = strstrW(ptr, match_str);
1301                 if(!ptr2)
1302                     break;
1303             }else {
1304                 if(!*ptr)
1305                     break;
1306                 ptr2 = ptr+1;
1307             }
1308
1309             V_VT(&var) = VT_BSTR;
1310             V_BSTR(&var) = SysAllocStringLen(ptr, ptr2-ptr);
1311             if(!V_BSTR(&var)) {
1312                 hres = E_OUTOFMEMORY;
1313                 break;
1314             }
1315
1316             hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
1317             SysFreeString(V_BSTR(&var));
1318             if(FAILED(hres))
1319                 break;
1320
1321             if(match_result)
1322                 ptr = match_result[i].str + match_result[i].len;
1323             else if(match_str)
1324                 ptr = ptr2 + match_len;
1325             else
1326                 ptr++;
1327         }
1328     }
1329
1330     if(SUCCEEDED(hres) && (match_str || match_result)) {
1331         DWORD len = (str+length) - ptr;
1332
1333         if(len || match_str) {
1334             V_VT(&var) = VT_BSTR;
1335             V_BSTR(&var) = SysAllocStringLen(ptr, len);
1336
1337             if(V_BSTR(&var)) {
1338                 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
1339                 SysFreeString(V_BSTR(&var));
1340             }else {
1341                 hres = E_OUTOFMEMORY;
1342             }
1343         }
1344     }
1345
1346     SysFreeString(match_str);
1347     SysFreeString(val_str);
1348     heap_free(match_result);
1349
1350     if(SUCCEEDED(hres) && retv) {
1351         V_VT(retv) = VT_DISPATCH;
1352         V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
1353     }else {
1354         jsdisp_release(array);
1355     }
1356
1357     return hres;
1358 }
1359
1360 static HRESULT String_strike(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1361         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1362 {
1363     static const WCHAR striketagW[] = {'S','T','R','I','K','E',0};
1364     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, striketagW);
1365 }
1366
1367 static HRESULT String_sub(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1368         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1369 {
1370     static const WCHAR subtagW[] = {'S','U','B',0};
1371     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, subtagW);
1372 }
1373
1374 /* ECMA-262 3rd Edition    15.5.4.15 */
1375 static HRESULT String_substring(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1376         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1377 {
1378     const WCHAR *str;
1379     BSTR val_str = NULL;
1380     INT start=0, end;
1381     DWORD length;
1382     VARIANT v;
1383     HRESULT hres;
1384
1385     TRACE("\n");
1386
1387     if(!is_class(dispex, JSCLASS_STRING)) {
1388         VARIANT this;
1389
1390         V_VT(&this) = VT_DISPATCH;
1391         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
1392
1393         hres = to_string(dispex->ctx, &this, ei, &val_str);
1394         if(FAILED(hres))
1395             return hres;
1396
1397         str = val_str;
1398         length = SysStringLen(val_str);
1399     }
1400     else {
1401         StringInstance *this = (StringInstance*)dispex;
1402
1403         str = this->str;
1404         length = this->length;
1405     }
1406
1407     if(arg_cnt(dp) >= 1) {
1408         hres = to_integer(dispex->ctx, get_arg(dp,0), ei, &v);
1409         if(FAILED(hres)) {
1410             SysFreeString(val_str);
1411             return hres;
1412         }
1413
1414         if(V_VT(&v) == VT_I4) {
1415             start = V_I4(&v);
1416             if(start < 0)
1417                 start = 0;
1418             else if(start >= length)
1419                 start = length;
1420         }else {
1421             start = V_R8(&v) < 0.0 ? 0 : length;
1422         }
1423     }
1424
1425     if(arg_cnt(dp) >= 2) {
1426         hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &v);
1427         if(FAILED(hres)) {
1428             SysFreeString(val_str);
1429             return hres;
1430         }
1431
1432         if(V_VT(&v) == VT_I4) {
1433             end = V_I4(&v);
1434             if(end < 0)
1435                 end = 0;
1436             else if(end > length)
1437                 end = length;
1438         }else {
1439             end = V_R8(&v) < 0.0 ? 0 : length;
1440         }
1441     }else {
1442         end = length;
1443     }
1444
1445     if(start > end) {
1446         INT tmp = start;
1447         start = end;
1448         end = tmp;
1449     }
1450
1451     if(retv) {
1452         V_VT(retv) = VT_BSTR;
1453         V_BSTR(retv) = SysAllocStringLen(str+start, end-start);
1454         if(!V_BSTR(retv)) {
1455             SysFreeString(val_str);
1456             return E_OUTOFMEMORY;
1457         }
1458     }
1459     SysFreeString(val_str);
1460     return S_OK;
1461 }
1462
1463 /* ECMA-262 3rd Edition    B.2.3 */
1464 static HRESULT String_substr(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1465         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1466 {
1467     BSTR val_str = NULL;
1468     const WCHAR *str;
1469     INT start=0, len;
1470     DWORD length;
1471     VARIANT v;
1472     HRESULT hres;
1473
1474     TRACE("\n");
1475
1476     if(is_class(dispex, JSCLASS_STRING)) {
1477         StringInstance *this = (StringInstance*)dispex;
1478
1479         str = this->str;
1480         length = this->length;
1481     }else {
1482         VARIANT this;
1483
1484         V_VT(&this) = VT_DISPATCH;
1485         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
1486         hres = to_string(dispex->ctx, &this, ei, &val_str);
1487         if(FAILED(hres))
1488             return hres;
1489
1490         str = val_str;
1491         length = SysStringLen(val_str);
1492     }
1493
1494     if(arg_cnt(dp) >= 1) {
1495         hres = to_integer(dispex->ctx, get_arg(dp,0), ei, &v);
1496         if(FAILED(hres)) {
1497             SysFreeString(val_str);
1498             return hres;
1499         }
1500
1501         if(V_VT(&v) == VT_I4) {
1502             start = V_I4(&v);
1503             if(start < 0)
1504                 start = 0;
1505             else if(start >= length)
1506                 start = length;
1507         }else {
1508             start = V_R8(&v) < 0.0 ? 0 : length;
1509         }
1510     }
1511
1512     if(arg_cnt(dp) >= 2) {
1513         hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &v);
1514         if(FAILED(hres)) {
1515             SysFreeString(val_str);
1516             return hres;
1517         }
1518
1519         if(V_VT(&v) == VT_I4) {
1520             len = V_I4(&v);
1521             if(len < 0)
1522                 len = 0;
1523             else if(len > length-start)
1524                 len = length-start;
1525         }else {
1526             len = V_R8(&v) < 0.0 ? 0 : length-start;
1527         }
1528     }else {
1529         len = length-start;
1530     }
1531
1532     hres = S_OK;
1533     if(retv) {
1534         V_VT(retv) = VT_BSTR;
1535         V_BSTR(retv) = SysAllocStringLen(str+start, len);
1536         if(!V_BSTR(retv))
1537             hres = E_OUTOFMEMORY;
1538     }
1539
1540     SysFreeString(val_str);
1541     return hres;
1542 }
1543
1544 static HRESULT String_sup(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1545         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1546 {
1547     static const WCHAR suptagW[] = {'S','U','P',0};
1548     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, suptagW);
1549 }
1550
1551 static HRESULT String_toLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1552         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1553 {
1554     const WCHAR* str;
1555     DWORD length;
1556     BSTR val_str = NULL;
1557     HRESULT  hres;
1558
1559     TRACE("\n");
1560
1561     if(!is_class(dispex, JSCLASS_STRING)) {
1562         VARIANT this;
1563
1564         V_VT(&this) = VT_DISPATCH;
1565         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
1566
1567         hres = to_string(dispex->ctx, &this, ei, &val_str);
1568         if(FAILED(hres))
1569             return hres;
1570
1571         str = val_str;
1572         length = SysStringLen(val_str);
1573     }
1574     else {
1575         StringInstance *this = (StringInstance*)dispex;
1576
1577         str = this->str;
1578         length = this->length;
1579     }
1580
1581     if(retv) {
1582         if(!val_str) {
1583             val_str = SysAllocStringLen(str, length);
1584             if(!val_str)
1585                 return E_OUTOFMEMORY;
1586         }
1587
1588         strlwrW(val_str);
1589
1590         V_VT(retv) = VT_BSTR;
1591         V_BSTR(retv) = val_str;
1592     }
1593     else SysFreeString(val_str);
1594     return S_OK;
1595 }
1596
1597 static HRESULT String_toUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1598         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1599 {
1600     const WCHAR* str;
1601     DWORD length;
1602     BSTR val_str = NULL;
1603     HRESULT hres;
1604
1605     TRACE("\n");
1606
1607     if(!is_class(dispex, JSCLASS_STRING)) {
1608         VARIANT this;
1609
1610         V_VT(&this) = VT_DISPATCH;
1611         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
1612
1613         hres = to_string(dispex->ctx, &this, ei, &val_str);
1614         if(FAILED(hres))
1615             return hres;
1616
1617         str = val_str;
1618         length = SysStringLen(val_str);
1619     }
1620     else {
1621         StringInstance *this = (StringInstance*)dispex;
1622
1623         str = this->str;
1624         length = this->length;
1625     }
1626
1627     if(retv) {
1628         if(!val_str) {
1629             val_str = SysAllocStringLen(str, length);
1630             if(!val_str)
1631                 return E_OUTOFMEMORY;
1632         }
1633
1634         struprW(val_str);
1635
1636         V_VT(retv) = VT_BSTR;
1637         V_BSTR(retv) = val_str;
1638     }
1639     else SysFreeString(val_str);
1640     return S_OK;
1641 }
1642
1643 static HRESULT String_toLocaleLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1644         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1645 {
1646     FIXME("\n");
1647     return E_NOTIMPL;
1648 }
1649
1650 static HRESULT String_toLocaleUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1651         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1652 {
1653     FIXME("\n");
1654     return E_NOTIMPL;
1655 }
1656
1657 static HRESULT String_localeCompare(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1658         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1659 {
1660     FIXME("\n");
1661     return E_NOTIMPL;
1662 }
1663
1664 static HRESULT String_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1665         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1666 {
1667     StringInstance *This = (StringInstance*)dispex;
1668
1669     TRACE("\n");
1670
1671     switch(flags) {
1672     case INVOKE_FUNC:
1673         return throw_type_error(dispex->ctx, ei, IDS_NOT_FUNC, NULL);
1674     case DISPATCH_PROPERTYGET: {
1675         BSTR str = SysAllocString(This->str);
1676         if(!str)
1677             return E_OUTOFMEMORY;
1678
1679         V_VT(retv) = VT_BSTR;
1680         V_BSTR(retv) = str;
1681         break;
1682     }
1683     default:
1684         FIXME("flags %x\n", flags);
1685         return E_NOTIMPL;
1686     }
1687
1688     return S_OK;
1689 }
1690
1691 static void String_destructor(DispatchEx *dispex)
1692 {
1693     StringInstance *This = (StringInstance*)dispex;
1694
1695     heap_free(This->str);
1696     heap_free(This);
1697 }
1698
1699 static const builtin_prop_t String_props[] = {
1700     {anchorW,                String_anchor,                PROPF_METHOD|1},
1701     {bigW,                   String_big,                   PROPF_METHOD},
1702     {blinkW,                 String_blink,                 PROPF_METHOD},
1703     {boldW,                  String_bold,                  PROPF_METHOD},
1704     {charAtW,                String_charAt,                PROPF_METHOD|1},
1705     {charCodeAtW,            String_charCodeAt,            PROPF_METHOD|1},
1706     {concatW,                String_concat,                PROPF_METHOD|1},
1707     {fixedW,                 String_fixed,                 PROPF_METHOD},
1708     {fontcolorW,             String_fontcolor,             PROPF_METHOD|1},
1709     {fontsizeW,              String_fontsize,              PROPF_METHOD|1},
1710     {indexOfW,               String_indexOf,               PROPF_METHOD|2},
1711     {italicsW,               String_italics,               PROPF_METHOD},
1712     {lastIndexOfW,           String_lastIndexOf,           PROPF_METHOD|2},
1713     {lengthW,                String_length,                0},
1714     {linkW,                  String_link,                  PROPF_METHOD|1},
1715     {localeCompareW,         String_localeCompare,         PROPF_METHOD|1},
1716     {matchW,                 String_match,                 PROPF_METHOD|1},
1717     {replaceW,               String_replace,               PROPF_METHOD|1},
1718     {searchW,                String_search,                PROPF_METHOD},
1719     {sliceW,                 String_slice,                 PROPF_METHOD},
1720     {smallW,                 String_small,                 PROPF_METHOD},
1721     {splitW,                 String_split,                 PROPF_METHOD|2},
1722     {strikeW,                String_strike,                PROPF_METHOD},
1723     {subW,                   String_sub,                   PROPF_METHOD},
1724     {substrW,                String_substr,                PROPF_METHOD|2},
1725     {substringW,             String_substring,             PROPF_METHOD|2},
1726     {supW,                   String_sup,                   PROPF_METHOD},
1727     {toLocaleLowerCaseW,     String_toLocaleLowerCase,     PROPF_METHOD},
1728     {toLocaleUpperCaseW,     String_toLocaleUpperCase,     PROPF_METHOD},
1729     {toLowerCaseW,           String_toLowerCase,           PROPF_METHOD},
1730     {toStringW,              String_toString,              PROPF_METHOD},
1731     {toUpperCaseW,           String_toUpperCase,           PROPF_METHOD},
1732     {valueOfW,               String_valueOf,               PROPF_METHOD}
1733 };
1734
1735 static const builtin_info_t String_info = {
1736     JSCLASS_STRING,
1737     {NULL, String_value, 0},
1738     sizeof(String_props)/sizeof(*String_props),
1739     String_props,
1740     String_destructor,
1741     NULL
1742 };
1743
1744 /* ECMA-262 3rd Edition    15.5.3.2 */
1745 static HRESULT StringConstr_fromCharCode(DispatchEx *dispex, LCID lcid, WORD flags,
1746         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1747 {
1748     DWORD i, code;
1749     BSTR ret;
1750     HRESULT hres;
1751
1752     ret = SysAllocStringLen(NULL, arg_cnt(dp));
1753     if(!ret)
1754         return E_OUTOFMEMORY;
1755
1756     for(i=0; i<arg_cnt(dp); i++) {
1757         hres = to_uint32(dispex->ctx, get_arg(dp, i), ei, &code);
1758         if(FAILED(hres)) {
1759             SysFreeString(ret);
1760             return hres;
1761         }
1762
1763         ret[i] = code;
1764     }
1765
1766     if(retv) {
1767         V_VT(retv) = VT_BSTR;
1768         V_BSTR(retv) = ret;
1769     }
1770     else SysFreeString(ret);
1771
1772     return S_OK;
1773 }
1774
1775 static HRESULT StringConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1776         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1777 {
1778     HRESULT hres;
1779
1780     TRACE("\n");
1781
1782     switch(flags) {
1783     case INVOKE_FUNC: {
1784         BSTR str;
1785
1786         if(arg_cnt(dp)) {
1787             hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1788             if(FAILED(hres))
1789                 return hres;
1790         }else {
1791             str = SysAllocStringLen(NULL, 0);
1792             if(!str)
1793                 return E_OUTOFMEMORY;
1794         }
1795
1796         V_VT(retv) = VT_BSTR;
1797         V_BSTR(retv) = str;
1798         break;
1799     }
1800     case DISPATCH_CONSTRUCT: {
1801         DispatchEx *ret;
1802
1803         if(arg_cnt(dp)) {
1804             BSTR str;
1805
1806             hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1807             if(FAILED(hres))
1808                 return hres;
1809
1810             hres = create_string(dispex->ctx, str, SysStringLen(str), &ret);
1811             SysFreeString(str);
1812         }else {
1813             hres = create_string(dispex->ctx, NULL, 0, &ret);
1814         }
1815
1816         if(FAILED(hres))
1817             return hres;
1818
1819         V_VT(retv) = VT_DISPATCH;
1820         V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(ret);
1821         break;
1822     }
1823
1824     default:
1825         FIXME("unimplemented flags: %x\n", flags);
1826         return E_NOTIMPL;
1827     }
1828
1829     return S_OK;
1830 }
1831
1832 static HRESULT string_alloc(script_ctx_t *ctx, DispatchEx *object_prototype, StringInstance **ret)
1833 {
1834     StringInstance *string;
1835     HRESULT hres;
1836
1837     string = heap_alloc_zero(sizeof(StringInstance));
1838     if(!string)
1839         return E_OUTOFMEMORY;
1840
1841     if(object_prototype)
1842         hres = init_dispex(&string->dispex, ctx, &String_info, object_prototype);
1843     else
1844         hres = init_dispex_from_constr(&string->dispex, ctx, &String_info, ctx->string_constr);
1845     if(FAILED(hres)) {
1846         heap_free(string);
1847         return hres;
1848     }
1849
1850     *ret = string;
1851     return S_OK;
1852 }
1853
1854 static const builtin_prop_t StringConstr_props[] = {
1855     {fromCharCodeW,    StringConstr_fromCharCode,    PROPF_METHOD},
1856 };
1857
1858 static const builtin_info_t StringConstr_info = {
1859     JSCLASS_FUNCTION,
1860     {NULL, Function_value, 0},
1861     sizeof(StringConstr_props)/sizeof(*StringConstr_props),
1862     StringConstr_props,
1863     NULL,
1864     NULL
1865 };
1866
1867 HRESULT create_string_constr(script_ctx_t *ctx, DispatchEx *object_prototype, DispatchEx **ret)
1868 {
1869     StringInstance *string;
1870     HRESULT hres;
1871
1872     hres = string_alloc(ctx, object_prototype, &string);
1873     if(FAILED(hres))
1874         return hres;
1875
1876     hres = create_builtin_function(ctx, StringConstr_value, &StringConstr_info, PROPF_CONSTR, &string->dispex, ret);
1877
1878     jsdisp_release(&string->dispex);
1879     return hres;
1880 }
1881
1882 HRESULT create_string(script_ctx_t *ctx, const WCHAR *str, DWORD len, DispatchEx **ret)
1883 {
1884     StringInstance *string;
1885     HRESULT hres;
1886
1887     hres = string_alloc(ctx, NULL, &string);
1888     if(FAILED(hres))
1889         return hres;
1890
1891     if(len == -1)
1892         len = strlenW(str);
1893
1894     string->length = len;
1895     string->str = heap_alloc((len+1)*sizeof(WCHAR));
1896     if(!string->str) {
1897         jsdisp_release(&string->dispex);
1898         return E_OUTOFMEMORY;
1899     }
1900
1901     memcpy(string->str, str, len*sizeof(WCHAR));
1902     string->str[len] = 0;
1903
1904     *ret = &string->dispex;
1905     return S_OK;
1906
1907 }