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     FIXME("\n");
  74     return E_NOTIMPL;
  75 }
  76
  77 static HRESULT String_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
  78         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  79 {
  80     FIXME("\n");
  81     return E_NOTIMPL;
  82 }
  83
  84 static HRESULT String_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
  85         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  86 {
  87     FIXME("\n");
  88     return E_NOTIMPL;
  89 }
  90
  91 static HRESULT String_anchor(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_big(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_blink(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_bold(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_charAt(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_charCodeAt(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 static HRESULT String_concat(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 134         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 135 {
 136     FIXME("\n");
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT String_fixed(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 141         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 142 {
 143     FIXME("\n");
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT String_fontcolor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 148         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 149 {
 150     FIXME("\n");
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT String_fontsize(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 155         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 156 {
 157     FIXME("\n");
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT String_indexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 162         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 163 {
 164     FIXME("\n");
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT String_italics(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 169         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 170 {
 171     FIXME("\n");
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT String_lastIndexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 176         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 177 {
 178     FIXME("\n");
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT String_link(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 183         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 184 {
 185     FIXME("\n");
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT String_match(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 190         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 191 {
 192     StringInstance *This = (StringInstance*)dispex;
 193     match_result_t *match_result;
 194     DispatchEx *array;
 195     VARIANT var, *arg_var;
 196     DWORD match_cnt, i;
 197     HRESULT hres = S_OK;
 198
 199     TRACE("\n");
 200
 201     if(dp->cArgs - dp->cNamedArgs != 1) {
 202         FIXME("unsupported args\n");
 203         return E_NOTIMPL;
 204     }
 205
 206     arg_var = get_arg(dp, 0);
 207     switch(V_VT(arg_var)) {
 208     case VT_DISPATCH: {
 209         DispatchEx *regexp;
 210
 211         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
 212         if(regexp) {
 213             if(regexp->builtin_info->class == JSCLASS_REGEXP) {
 214                 hres = regexp_match(regexp, This->str, This->length, FALSE, &match_result, &match_cnt);
 215                 jsdisp_release(regexp);
 216                 if(FAILED(hres))
 217                     return hres;
 218                 break;
 219             }
 220             jsdisp_release(regexp);
 221         }
 222     }
 223     default:
 224         FIXME("implemented only for regexp args\n");
 225         return E_NOTIMPL;
 226     }
 227
 228     if(!match_cnt) {
 229         TRACE("no match\n");
 230
 231         if(retv)
 232             V_VT(retv) = VT_NULL;
 233         return S_OK;
 234     }
 235
 236     hres = create_array(dispex->ctx, match_cnt, &array);
 237     if(FAILED(hres))
 238         return hres;
 239
 240     V_VT(&var) = VT_BSTR;
 241
 242     for(i=0; i < match_cnt; i++) {
 243         V_BSTR(&var) = SysAllocStringLen(match_result[i].str, match_result[i].len);
 244         if(!V_BSTR(&var)) {
 245             hres = E_OUTOFMEMORY;
 246             break;
 247         }
 248
 249         hres = jsdisp_propput_idx(array, i, lcid, &var, ei, NULL/*FIXME*/);
 250         SysFreeString(V_BSTR(&var));
 251         if(FAILED(hres))
 252             break;
 253     }
 254
 255     if(FAILED(hres)) {
 256         jsdisp_release(array);
 257         return hres;
 258     }
 259
 260     V_VT(retv) = VT_DISPATCH;
 261     V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
 262     return S_OK;
 263 }
 264
 265 static HRESULT String_replace(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 266         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 267 {
 268     FIXME("\n");
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT String_search(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 273         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 274 {
 275     FIXME("\n");
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT String_slice(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 280         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 281 {
 282     FIXME("\n");
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT String_small(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 287         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 288 {
 289     FIXME("\n");
 290     return E_NOTIMPL;
 291 }
 292
 293 static HRESULT String_split(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 294         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 295 {
 296     FIXME("\n");
 297     return E_NOTIMPL;
 298 }
 299
 300 static HRESULT String_strike(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 301         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 302 {
 303     FIXME("\n");
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT String_sub(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 308         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 309 {
 310     FIXME("\n");
 311     return E_NOTIMPL;
 312 }
 313
 314 static HRESULT String_substring(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 315         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 316 {
 317     FIXME("\n");
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT String_substr(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_sup(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_toLowerCase(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_toUpperCase(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_toLocaleLowerCase(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_toLocaleUpperCase(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_localeCompare(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_hasOwnProperty(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_propertyIsEnumerable(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_isPrototypeOf(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_value(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 void String_destructor(DispatchEx *dispex)
 399 {
 400     StringInstance *This = (StringInstance*)dispex;
 401
 402     heap_free(This->str);
 403     heap_free(This);
 404 }
 405
 406 static const builtin_prop_t String_props[] = {
 407     {anchorW,                String_anchor,                PROPF_METHOD},
 408     {bigW,                   String_big,                   PROPF_METHOD},
 409     {blinkW,                 String_blink,                 PROPF_METHOD},
 410     {boldW,                  String_bold,                  PROPF_METHOD},
 411     {charAtW,                String_charAt,                PROPF_METHOD},
 412     {charCodeAtW,            String_charCodeAt,            PROPF_METHOD},
 413     {concatW,                String_concat,                PROPF_METHOD},
 414     {fixedW,                 String_fixed,                 PROPF_METHOD},
 415     {fontcolorW,             String_fontcolor,             PROPF_METHOD},
 416     {fontsizeW,              String_fontsize,              PROPF_METHOD},
 417     {hasOwnPropertyW,        String_hasOwnProperty,        PROPF_METHOD},
 418     {indexOfW,               String_indexOf,               PROPF_METHOD},
 419     {isPrototypeOfW,         String_isPrototypeOf,         PROPF_METHOD},
 420     {italicsW,               String_italics,               PROPF_METHOD},
 421     {lastIndexOfW,           String_lastIndexOf,           PROPF_METHOD},
 422     {lengthW,                String_length,                0},
 423     {linkW,                  String_link,                  PROPF_METHOD},
 424     {localeCompareW,         String_localeCompare,         PROPF_METHOD},
 425     {matchW,                 String_match,                 PROPF_METHOD},
 426     {propertyIsEnumerableW,  String_propertyIsEnumerable,  PROPF_METHOD},
 427     {replaceW,               String_replace,               PROPF_METHOD},
 428     {searchW,                String_search,                PROPF_METHOD},
 429     {sliceW,                 String_slice,                 PROPF_METHOD},
 430     {smallW,                 String_small,                 PROPF_METHOD},
 431     {splitW,                 String_split,                 PROPF_METHOD},
 432     {strikeW,                String_strike,                PROPF_METHOD},
 433     {substringW,             String_substring,             PROPF_METHOD},
 434     {substrW,                String_substr,                PROPF_METHOD},
 435     {subW,                   String_sub,                   PROPF_METHOD},
 436     {supW,                   String_sup,                   PROPF_METHOD},
 437     {toLocaleLowerCaseW,     String_toLocaleLowerCase,     PROPF_METHOD},
 438     {toLocaleUpperCaseW,     String_toLocaleUpperCase,     PROPF_METHOD},
 439     {toLowerCaseW,           String_toLowerCase,           PROPF_METHOD},
 440     {toStringW,              String_toString,              PROPF_METHOD},
 441     {toUpperCaseW,           String_toUpperCase,           PROPF_METHOD},
 442     {valueOfW,               String_valueOf,               PROPF_METHOD}
 443 };
 444
 445 static const builtin_info_t String_info = {
 446     JSCLASS_STRING,
 447     {NULL, String_value, 0},
 448     sizeof(String_props)/sizeof(*String_props),
 449     String_props,
 450     String_destructor,
 451     NULL
 452 };
 453
 454 static HRESULT StringConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 455         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 456 {
 457     FIXME("\n");
 458     return E_NOTIMPL;
 459 }
 460
 461 static HRESULT string_alloc(script_ctx_t *ctx, BOOL use_constr, StringInstance **ret)
 462 {
 463     StringInstance *string;
 464     HRESULT hres;
 465
 466     string = heap_alloc_zero(sizeof(StringInstance));
 467     if(!string)
 468         return E_OUTOFMEMORY;
 469
 470     if(use_constr)
 471         hres = init_dispex_from_constr(&string->dispex, ctx, &String_info, ctx->string_constr);
 472     else
 473         hres = init_dispex(&string->dispex, ctx, &String_info, NULL);
 474     if(FAILED(hres)) {
 475         heap_free(string);
 476         return hres;
 477     }
 478
 479     *ret = string;
 480     return S_OK;
 481 }
 482
 483 HRESULT create_string_constr(script_ctx_t *ctx, DispatchEx **ret)
 484 {
 485     StringInstance *string;
 486     HRESULT hres;
 487
 488     hres = string_alloc(ctx, FALSE, &string);
 489     if(FAILED(hres))
 490         return hres;
 491
 492     hres = create_builtin_function(ctx, StringConstr_value, PROPF_CONSTR, &string->dispex, ret);
 493
 494     jsdisp_release(&string->dispex);
 495     return hres;
 496 }
 497
 498 HRESULT create_string(script_ctx_t *ctx, const WCHAR *str, DWORD len, DispatchEx **ret)
 499 {
 500     StringInstance *string;
 501     HRESULT hres;
 502
 503     hres = string_alloc(ctx, TRUE, &string);
 504     if(FAILED(hres))
 505         return hres;
 506
 507     if(len == -1)
 508         len = strlenW(str);
 509
 510     string->length = len;
 511     string->str = heap_alloc((len+1)*sizeof(WCHAR));
 512     if(!string->str) {
 513         jsdisp_release(&string->dispex);
 514         return E_OUTOFMEMORY;
 515     }
 516
 517     memcpy(string->str, str, len*sizeof(WCHAR));
 518     string->str[len] = 0;
 519
 520     *ret = &string->dispex;
 521     return S_OK;
 522
 523 }