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 hasOwnPropertyW[] = {'h','a','s','O','w','n','P','r','o','p','e','r','t','y',0};
  66 static const WCHAR propertyIsEnumerableW[] =
  67     {'p','r','o','p','e','r','t','y','I','s','E','n','u','m','e','r','a','b','l','e',0};
  68 static const WCHAR isPrototypeOfW[] = {'i','s','P','r','o','t','o','t','y','p','e','O','f',0};
  69
  70 static HRESULT String_length(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
  71         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  72 {
  73     TRACE("%p\n", dispex);
  74
  75     switch(flags) {
  76     case DISPATCH_PROPERTYGET: {
  77         StringInstance *jsthis = (StringInstance*)dispex;
  78
  79         V_VT(retv) = VT_I4;
  80         V_I4(retv) = jsthis->length;
  81         break;
  82     }
  83     default:
  84         FIXME("unimplemented flags %x\n", flags);
  85         return E_NOTIMPL;
  86     }
  87
  88     return S_OK;
  89 }
  90
  91 static HRESULT String_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
  92         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  93 {
  94     FIXME("\n");
  95     return E_NOTIMPL;
  96 }
  97
  98 static HRESULT String_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
  99         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 100 {
 101     FIXME("\n");
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT String_anchor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 106         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 107 {
 108     FIXME("\n");
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT String_big(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 113         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 114 {
 115     FIXME("\n");
 116     return E_NOTIMPL;
 117 }
 118
 119 static HRESULT String_blink(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 120         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 121 {
 122     FIXME("\n");
 123     return E_NOTIMPL;
 124 }
 125
 126 static HRESULT String_bold(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 127         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 128 {
 129     FIXME("\n");
 130     return E_NOTIMPL;
 131 }
 132
 133 /* ECMA-262 3rd Edition    15.5.4.5 */
 134 static HRESULT String_charAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 135         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 136 {
 137     StringInstance *strobj;
 138     BSTR str;
 139     INT pos = 0;
 140     HRESULT hres;
 141
 142     TRACE("\n");
 143
 144     if(dispex->builtin_info->class != JSCLASS_STRING) {
 145         FIXME("not string this not supported\n");
 146         return E_NOTIMPL;
 147     }
 148
 149     strobj = (StringInstance*)dispex;
 150
 151     if(arg_cnt(dp)) {
 152         VARIANT num;
 153
 154         hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &num);
 155         if(FAILED(hres))
 156             return hres;
 157
 158         if(V_VT(&num) == VT_I4) {
 159             pos = V_I4(&num);
 160         }else {
 161             WARN("pos = %lf\n", V_R8(&num));
 162             pos = -1;
 163         }
 164     }
 165
 166     if(!retv)
 167         return S_OK;
 168
 169     if(0 <= pos && pos < strobj->length)
 170         str = SysAllocStringLen(strobj->str+pos, 1);
 171     else
 172         str = SysAllocStringLen(NULL, 0);
 173     if(!str)
 174         return E_OUTOFMEMORY;
 175
 176     V_VT(retv) = VT_BSTR;
 177     V_BSTR(retv) = str;
 178     return S_OK;
 179 }
 180
 181 static HRESULT String_charCodeAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 182         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 183 {
 184     FIXME("\n");
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT String_concat(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 189         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 190 {
 191     FIXME("\n");
 192     return E_NOTIMPL;
 193 }
 194
 195 static HRESULT String_fixed(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 196         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 197 {
 198     FIXME("\n");
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT String_fontcolor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 203         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 204 {
 205     FIXME("\n");
 206     return E_NOTIMPL;
 207 }
 208
 209 static HRESULT String_fontsize(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 210         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 211 {
 212     FIXME("\n");
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT String_indexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 217         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 218 {
 219     FIXME("\n");
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT String_italics(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 224         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 225 {
 226     FIXME("\n");
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT String_lastIndexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 231         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 232 {
 233     FIXME("\n");
 234     return E_NOTIMPL;
 235 }
 236
 237 static HRESULT String_link(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 238         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 239 {
 240     FIXME("\n");
 241     return E_NOTIMPL;
 242 }
 243
 244 /* ECMA-262 3rd Edition    15.5.4.10 */
 245 static HRESULT String_match(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 246         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 247 {
 248     StringInstance *This = (StringInstance*)dispex;
 249     match_result_t *match_result;
 250     DispatchEx *array;
 251     VARIANT var, *arg_var;
 252     DWORD match_cnt, i;
 253     HRESULT hres = S_OK;
 254
 255     TRACE("\n");
 256
 257     if(dp->cArgs - dp->cNamedArgs != 1) {
 258         FIXME("unsupported args\n");
 259         return E_NOTIMPL;
 260     }
 261
 262     arg_var = get_arg(dp, 0);
 263     switch(V_VT(arg_var)) {
 264     case VT_DISPATCH: {
 265         DispatchEx *regexp;
 266
 267         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
 268         if(regexp) {
 269             if(regexp->builtin_info->class == JSCLASS_REGEXP) {
 270                 hres = regexp_match(regexp, This->str, This->length, FALSE, &match_result, &match_cnt);
 271                 jsdisp_release(regexp);
 272                 if(FAILED(hres))
 273                     return hres;
 274                 break;
 275             }
 276             jsdisp_release(regexp);
 277         }
 278     }
 279     default:
 280         FIXME("implemented only for regexp args\n");
 281         return E_NOTIMPL;
 282     }
 283
 284     if(!match_cnt) {
 285         TRACE("no match\n");
 286
 287         if(retv)
 288             V_VT(retv) = VT_NULL;
 289         return S_OK;
 290     }
 291
 292     hres = create_array(dispex->ctx, match_cnt, &array);
 293     if(FAILED(hres))
 294         return hres;
 295
 296     V_VT(&var) = VT_BSTR;
 297
 298     for(i=0; i < match_cnt; i++) {
 299         V_BSTR(&var) = SysAllocStringLen(match_result[i].str, match_result[i].len);
 300         if(!V_BSTR(&var)) {
 301             hres = E_OUTOFMEMORY;
 302             break;
 303         }
 304
 305         hres = jsdisp_propput_idx(array, i, lcid, &var, ei, NULL/*FIXME*/);
 306         SysFreeString(V_BSTR(&var));
 307         if(FAILED(hres))
 308             break;
 309     }
 310
 311     if(FAILED(hres)) {
 312         jsdisp_release(array);
 313         return hres;
 314     }
 315
 316     V_VT(retv) = VT_DISPATCH;
 317     V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
 318     return S_OK;
 319 }
 320
 321 static HRESULT String_replace(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 322         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 323 {
 324     FIXME("\n");
 325     return E_NOTIMPL;
 326 }
 327
 328 static HRESULT String_search(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 329         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 330 {
 331     FIXME("\n");
 332     return E_NOTIMPL;
 333 }
 334
 335 static HRESULT String_slice(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 336         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 337 {
 338     FIXME("\n");
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT String_small(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 343         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 344 {
 345     FIXME("\n");
 346     return E_NOTIMPL;
 347 }
 348
 349 static HRESULT String_split(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 350         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 351 {
 352     FIXME("\n");
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT String_strike(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 357         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 358 {
 359     FIXME("\n");
 360     return E_NOTIMPL;
 361 }
 362
 363 static HRESULT String_sub(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 364         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 365 {
 366     FIXME("\n");
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT String_substring(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 371         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 372 {
 373     FIXME("\n");
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT String_substr(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 378         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 379 {
 380     FIXME("\n");
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT String_sup(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 385         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 386 {
 387     FIXME("\n");
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT String_toLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 392         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 393 {
 394     FIXME("\n");
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT String_toUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 399         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 400 {
 401     FIXME("\n");
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT String_toLocaleLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 406         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 407 {
 408     FIXME("\n");
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT String_toLocaleUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 413         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 414 {
 415     FIXME("\n");
 416     return E_NOTIMPL;
 417 }
 418
 419 static HRESULT String_localeCompare(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 420         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 421 {
 422     FIXME("\n");
 423     return E_NOTIMPL;
 424 }
 425
 426 static HRESULT String_hasOwnProperty(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 427         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 428 {
 429     FIXME("\n");
 430     return E_NOTIMPL;
 431 }
 432
 433 static HRESULT String_propertyIsEnumerable(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 434         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 435 {
 436     FIXME("\n");
 437     return E_NOTIMPL;
 438 }
 439
 440 static HRESULT String_isPrototypeOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 441         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 442 {
 443     FIXME("\n");
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT String_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 448         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 449 {
 450     FIXME("\n");
 451     return E_NOTIMPL;
 452 }
 453
 454 static void String_destructor(DispatchEx *dispex)
 455 {
 456     StringInstance *This = (StringInstance*)dispex;
 457
 458     heap_free(This->str);
 459     heap_free(This);
 460 }
 461
 462 static const builtin_prop_t String_props[] = {
 463     {anchorW,                String_anchor,                PROPF_METHOD},
 464     {bigW,                   String_big,                   PROPF_METHOD},
 465     {blinkW,                 String_blink,                 PROPF_METHOD},
 466     {boldW,                  String_bold,                  PROPF_METHOD},
 467     {charAtW,                String_charAt,                PROPF_METHOD},
 468     {charCodeAtW,            String_charCodeAt,            PROPF_METHOD},
 469     {concatW,                String_concat,                PROPF_METHOD},
 470     {fixedW,                 String_fixed,                 PROPF_METHOD},
 471     {fontcolorW,             String_fontcolor,             PROPF_METHOD},
 472     {fontsizeW,              String_fontsize,              PROPF_METHOD},
 473     {hasOwnPropertyW,        String_hasOwnProperty,        PROPF_METHOD},
 474     {indexOfW,               String_indexOf,               PROPF_METHOD},
 475     {isPrototypeOfW,         String_isPrototypeOf,         PROPF_METHOD},
 476     {italicsW,               String_italics,               PROPF_METHOD},
 477     {lastIndexOfW,           String_lastIndexOf,           PROPF_METHOD},
 478     {lengthW,                String_length,                0},
 479     {linkW,                  String_link,                  PROPF_METHOD},
 480     {localeCompareW,         String_localeCompare,         PROPF_METHOD},
 481     {matchW,                 String_match,                 PROPF_METHOD},
 482     {propertyIsEnumerableW,  String_propertyIsEnumerable,  PROPF_METHOD},
 483     {replaceW,               String_replace,               PROPF_METHOD},
 484     {searchW,                String_search,                PROPF_METHOD},
 485     {sliceW,                 String_slice,                 PROPF_METHOD},
 486     {smallW,                 String_small,                 PROPF_METHOD},
 487     {splitW,                 String_split,                 PROPF_METHOD},
 488     {strikeW,                String_strike,                PROPF_METHOD},
 489     {substringW,             String_substring,             PROPF_METHOD},
 490     {substrW,                String_substr,                PROPF_METHOD},
 491     {subW,                   String_sub,                   PROPF_METHOD},
 492     {supW,                   String_sup,                   PROPF_METHOD},
 493     {toLocaleLowerCaseW,     String_toLocaleLowerCase,     PROPF_METHOD},
 494     {toLocaleUpperCaseW,     String_toLocaleUpperCase,     PROPF_METHOD},
 495     {toLowerCaseW,           String_toLowerCase,           PROPF_METHOD},
 496     {toStringW,              String_toString,              PROPF_METHOD},
 497     {toUpperCaseW,           String_toUpperCase,           PROPF_METHOD},
 498     {valueOfW,               String_valueOf,               PROPF_METHOD}
 499 };
 500
 501 static const builtin_info_t String_info = {
 502     JSCLASS_STRING,
 503     {NULL, String_value, 0},
 504     sizeof(String_props)/sizeof(*String_props),
 505     String_props,
 506     String_destructor,
 507     NULL
 508 };
 509
 510 static HRESULT StringConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 511         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 512 {
 513     FIXME("\n");
 514     return E_NOTIMPL;
 515 }
 516
 517 static HRESULT string_alloc(script_ctx_t *ctx, BOOL use_constr, StringInstance **ret)
 518 {
 519     StringInstance *string;
 520     HRESULT hres;
 521
 522     string = heap_alloc_zero(sizeof(StringInstance));
 523     if(!string)
 524         return E_OUTOFMEMORY;
 525
 526     if(use_constr)
 527         hres = init_dispex_from_constr(&string->dispex, ctx, &String_info, ctx->string_constr);
 528     else
 529         hres = init_dispex(&string->dispex, ctx, &String_info, NULL);
 530     if(FAILED(hres)) {
 531         heap_free(string);
 532         return hres;
 533     }
 534
 535     *ret = string;
 536     return S_OK;
 537 }
 538
 539 HRESULT create_string_constr(script_ctx_t *ctx, DispatchEx **ret)
 540 {
 541     StringInstance *string;
 542     HRESULT hres;
 543
 544     hres = string_alloc(ctx, FALSE, &string);
 545     if(FAILED(hres))
 546         return hres;
 547
 548     hres = create_builtin_function(ctx, StringConstr_value, PROPF_CONSTR, &string->dispex, ret);
 549
 550     jsdisp_release(&string->dispex);
 551     return hres;
 552 }
 553
 554 HRESULT create_string(script_ctx_t *ctx, const WCHAR *str, DWORD len, DispatchEx **ret)
 555 {
 556     StringInstance *string;
 557     HRESULT hres;
 558
 559     hres = string_alloc(ctx, TRUE, &string);
 560     if(FAILED(hres))
 561         return hres;
 562
 563     if(len == -1)
 564         len = strlenW(str);
 565
 566     string->length = len;
 567     string->str = heap_alloc((len+1)*sizeof(WCHAR));
 568     if(!string->str) {
 569         jsdisp_release(&string->dispex);
 570         return E_OUTOFMEMORY;
 571     }
 572
 573     memcpy(string->str, str, len*sizeof(WCHAR));
 574     string->str[len] = 0;
 575
 576     *ret = &string->dispex;
 577     return S_OK;
 578
 579 }