2 * Copyright 2008 Jacek Caban for CodeWeavers
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.
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.
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
21 #include "wine/debug.h"
23 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
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};
70 static HRESULT String_length(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
71 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
73 TRACE("%p\n", dispex);
76 case DISPATCH_PROPERTYGET: {
77 StringInstance *jsthis = (StringInstance*)dispex;
80 V_I4(retv) = jsthis->length;
84 FIXME("unimplemented flags %x\n", flags);
91 /* ECMA-262 3rd Edition 15.5.4.2 */
92 static HRESULT String_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
93 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
95 StringInstance *string;
99 if(!is_class(dispex, JSCLASS_STRING)) {
100 WARN("this is not a string object\n");
104 string = (StringInstance*)dispex;
107 BSTR str = SysAllocString(string->str);
109 return E_OUTOFMEMORY;
111 V_VT(retv) = VT_BSTR;
117 /* ECMA-262 3rd Edition 15.5.4.2 */
118 static HRESULT String_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
119 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
123 return String_toString(dispex, lcid, flags, dp, retv, ei, sp);
126 static HRESULT do_attributeless_tag_format(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
127 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp, const WCHAR *tagname)
129 static const WCHAR tagfmt[] = {'<','%','s','>','%','s','<','/','%','s','>',0};
135 if(!is_class(dispex, JSCLASS_STRING)) {
138 V_VT(&this) = VT_DISPATCH;
139 V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
141 hres = to_string(dispex->ctx, &this, ei, &val_str);
146 length = SysStringLen(val_str);
149 StringInstance *this = (StringInstance*)dispex;
152 length = this->length;
156 BSTR ret = SysAllocStringLen(NULL, length + 2*strlenW(tagname) + 5);
158 SysFreeString(val_str);
159 return E_OUTOFMEMORY;
162 sprintfW(ret, tagfmt, tagname, str, tagname);
164 V_VT(retv) = VT_BSTR;
168 SysFreeString(val_str);
172 static HRESULT do_attribute_tag_format(DispatchEx *dispex, LCID lcid, WORD flags,
173 DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp,
174 const WCHAR *tagname, const WCHAR *attr)
176 static const WCHAR tagfmtW[]
177 = {'<','%','s',' ','%','s','=','\"','%','s','\"','>','%','s','<','/','%','s','>',0};
178 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
182 BSTR attr_value, val_str = NULL;
185 if(!is_class(dispex, JSCLASS_STRING)) {
188 V_VT(&this) = VT_DISPATCH;
189 V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
191 hres = to_string(dispex->ctx, &this, ei, &val_str);
196 length = SysStringLen(val_str);
199 StringInstance *this = (StringInstance*)dispex;
202 length = this->length;
206 hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &attr_value);
208 SysFreeString(val_str);
213 attr_value = SysAllocString(undefinedW);
215 SysFreeString(val_str);
216 return E_OUTOFMEMORY;
221 BSTR ret = SysAllocStringLen(NULL, length + 2*strlenW(tagname)
222 + strlenW(attr) + SysStringLen(attr_value) + 9);
224 SysFreeString(attr_value);
225 SysFreeString(val_str);
226 return E_OUTOFMEMORY;
229 sprintfW(ret, tagfmtW, tagname, attr, attr_value, str, tagname);
231 V_VT(retv) = VT_BSTR;
235 SysFreeString(attr_value);
236 SysFreeString(val_str);
240 static HRESULT String_anchor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
241 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
243 static const WCHAR fontW[] = {'A',0};
244 static const WCHAR colorW[] = {'N','A','M','E',0};
246 return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
249 static HRESULT String_big(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
250 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
252 static const WCHAR bigtagW[] = {'B','I','G',0};
253 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, bigtagW);
256 static HRESULT String_blink(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
257 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
259 static const WCHAR blinktagW[] = {'B','L','I','N','K',0};
260 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, blinktagW);
263 static HRESULT String_bold(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
264 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
266 static const WCHAR boldtagW[] = {'B',0};
267 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, boldtagW);
270 /* ECMA-262 3rd Edition 15.5.4.5 */
271 static HRESULT String_charAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
272 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
276 BSTR ret, val_str = NULL;
282 if(!is_class(dispex, JSCLASS_STRING)) {
285 V_VT(&this) = VT_DISPATCH;
286 V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
288 hres = to_string(dispex->ctx, &this, ei, &val_str);
293 length = SysStringLen(val_str);
296 StringInstance *this = (StringInstance*)dispex;
299 length = this->length;
305 hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &num);
307 SysFreeString(val_str);
311 if(V_VT(&num) == VT_I4) {
314 WARN("pos = %lf\n", V_R8(&num));
320 SysFreeString(val_str);
324 if(0 <= pos && pos < length)
325 ret = SysAllocStringLen(str+pos, 1);
327 ret = SysAllocStringLen(NULL, 0);
328 SysFreeString(val_str);
330 return E_OUTOFMEMORY;
333 V_VT(retv) = VT_BSTR;
338 /* ECMA-262 3rd Edition 15.5.4.5 */
339 static HRESULT String_charCodeAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
340 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
344 DWORD length, idx = 0;
349 if(!is_class(dispex, JSCLASS_STRING)) {
352 V_VT(&this) = VT_DISPATCH;
353 V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
355 hres = to_string(dispex->ctx, &this, ei, &val_str);
360 length = SysStringLen(val_str);
363 StringInstance *this = (StringInstance*)dispex;
366 length = this->length;
369 if(arg_cnt(dp) > 0) {
372 hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &v);
374 SysFreeString(val_str);
378 if(V_VT(&v) != VT_I4 || V_I4(&v) < 0 || V_I4(&v) >= length) {
379 if(retv) num_set_nan(&v);
380 SysFreeString(val_str);
389 V_I4(retv) = str[idx];
392 SysFreeString(val_str);
396 /* ECMA-262 3rd Edition 15.5.4.6 */
397 static HRESULT String_concat(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
398 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
400 BSTR *strs = NULL, ret = NULL;
401 DWORD len = 0, i, l, str_cnt;
408 str_cnt = arg_cnt(dp)+1;
409 strs = heap_alloc_zero(str_cnt * sizeof(BSTR));
411 return E_OUTOFMEMORY;
413 V_VT(&var) = VT_DISPATCH;
414 V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
416 hres = to_string(dispex->ctx, &var, ei, strs);
417 if(SUCCEEDED(hres)) {
418 for(i=0; i < arg_cnt(dp); i++) {
419 hres = to_string(dispex->ctx, get_arg(dp, i), ei, strs+i+1);
425 if(SUCCEEDED(hres)) {
426 for(i=0; i < str_cnt; i++)
427 len += SysStringLen(strs[i]);
429 ptr = ret = SysAllocStringLen(NULL, len);
431 for(i=0; i < str_cnt; i++) {
432 l = SysStringLen(strs[i]);
433 memcpy(ptr, strs[i], l*sizeof(WCHAR));
438 for(i=0; i < str_cnt; i++)
439 SysFreeString(strs[i]);
446 V_VT(retv) = VT_BSTR;
454 static HRESULT String_fixed(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
455 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
457 static const WCHAR fixedtagW[] = {'T','T',0};
458 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fixedtagW);
461 static HRESULT String_fontcolor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
462 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
464 static const WCHAR fontW[] = {'F','O','N','T',0};
465 static const WCHAR colorW[] = {'C','O','L','O','R',0};
467 return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
470 static HRESULT String_fontsize(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
471 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
473 static const WCHAR fontW[] = {'F','O','N','T',0};
474 static const WCHAR colorW[] = {'S','I','Z','E',0};
476 return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
479 static HRESULT String_indexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
480 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
482 DWORD length, pos = 0;
484 BSTR search_str, val_str = NULL;
490 if(!is_class(dispex, JSCLASS_STRING)) {
493 V_VT(&this) = VT_DISPATCH;
494 V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
496 hres = to_string(dispex->ctx, &this, ei, &val_str);
501 length = SysStringLen(val_str);
504 StringInstance *this = (StringInstance*)dispex;
507 length = this->length;
515 SysFreeString(val_str);
519 hres = to_string(dispex->ctx, get_arg(dp,0), ei, &search_str);
521 SysFreeString(val_str);
525 if(arg_cnt(dp) >= 2) {
528 hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &ival);
529 if(SUCCEEDED(hres)) {
530 if(V_VT(&ival) == VT_I4)
531 pos = V_VT(&ival) > 0 ? V_I4(&ival) : 0;
533 pos = V_R8(&ival) > 0.0 ? length : 0;
539 if(SUCCEEDED(hres)) {
542 ptr = strstrW(str+pos, search_str);
549 SysFreeString(search_str);
550 SysFreeString(val_str);
561 static HRESULT String_italics(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
562 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
564 static const WCHAR italicstagW[] = {'I',0};
565 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, italicstagW);
568 static HRESULT String_lastIndexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
569 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
575 static HRESULT String_link(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
576 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
578 static const WCHAR fontW[] = {'A',0};
579 static const WCHAR colorW[] = {'H','R','E','F',0};
581 return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
584 /* ECMA-262 3rd Edition 15.5.4.10 */
585 static HRESULT String_match(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
586 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
589 match_result_t *match_result;
592 VARIANT var, *arg_var;
593 DWORD length, match_cnt, i;
599 if(arg_cnt(dp) != 1) {
600 FIXME("unsupported args\n");
604 arg_var = get_arg(dp, 0);
605 switch(V_VT(arg_var)) {
607 regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
609 if(regexp->builtin_info->class == JSCLASS_REGEXP)
611 jsdisp_release(regexp);
616 hres = to_string(dispex->ctx, arg_var, ei, &match_str);
620 hres = create_regexp_str(dispex->ctx, match_str, SysStringLen(match_str), NULL, 0, ®exp);
621 SysFreeString(match_str);
627 if(!is_class(dispex, JSCLASS_STRING)) {
630 V_VT(&this) = VT_DISPATCH;
631 V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
633 hres = to_string(dispex->ctx, &this, ei, &val_str);
635 jsdisp_release(regexp);
640 length = SysStringLen(val_str);
643 StringInstance *this = (StringInstance*)dispex;
646 length = this->length;
649 hres = regexp_match(regexp, str, length, FALSE, &match_result, &match_cnt);
650 jsdisp_release(regexp);
652 SysFreeString(val_str);
660 V_VT(retv) = VT_NULL;
662 SysFreeString(val_str);
666 hres = create_array(dispex->ctx, match_cnt, &array);
668 SysFreeString(val_str);
672 V_VT(&var) = VT_BSTR;
674 for(i=0; i < match_cnt; i++) {
675 V_BSTR(&var) = SysAllocStringLen(match_result[i].str, match_result[i].len);
677 hres = E_OUTOFMEMORY;
681 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, NULL/*FIXME*/);
682 SysFreeString(V_BSTR(&var));
687 SysFreeString(val_str);
689 if(SUCCEEDED(hres) && retv) {
690 V_VT(retv) = VT_DISPATCH;
691 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
693 jsdisp_release(array);
704 static HRESULT strbuf_append(strbuf_t *buf, const WCHAR *str, DWORD len)
709 if(len + buf->len > buf->size) {
713 new_size = buf->size ? buf->size<<1 : 16;
714 if(new_size < buf->len+len)
715 new_size = buf->len+len;
717 new_buf = heap_realloc(buf->buf, new_size*sizeof(WCHAR));
719 new_buf = heap_alloc(new_size*sizeof(WCHAR));
721 return E_OUTOFMEMORY;
724 buf->size = new_size;
727 memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR));
732 static HRESULT rep_call(DispatchEx *func, const WCHAR *str, match_result_t *match, match_result_t *parens,
733 DWORD parens_cnt, LCID lcid, BSTR *ret, jsexcept_t *ei, IServiceProvider *caller)
735 DISPPARAMS dp = {NULL, NULL, 0, 0};
736 VARIANTARG *args, *arg;
741 dp.cArgs = parens_cnt+3;
742 dp.rgvarg = args = heap_alloc_zero(sizeof(VARIANT)*dp.cArgs);
744 return E_OUTOFMEMORY;
746 arg = get_arg(&dp,0);
748 V_BSTR(arg) = SysAllocStringLen(match->str, match->len);
750 hres = E_OUTOFMEMORY;
752 if(SUCCEEDED(hres)) {
753 for(i=0; i < parens_cnt; i++) {
754 arg = get_arg(&dp,i+1);
756 V_BSTR(arg) = SysAllocStringLen(parens[i].str, parens[i].len);
758 hres = E_OUTOFMEMORY;
764 if(SUCCEEDED(hres)) {
765 arg = get_arg(&dp,parens_cnt+1);
767 V_I4(arg) = match->str - str;
769 arg = get_arg(&dp,parens_cnt+2);
771 V_BSTR(arg) = SysAllocString(str);
773 hres = E_OUTOFMEMORY;
777 hres = jsdisp_call_value(func, lcid, DISPATCH_METHOD, &dp, &var, ei, caller);
779 for(i=0; i < parens_cnt+1; i++) {
780 if(i != parens_cnt+1)
781 SysFreeString(V_BSTR(get_arg(&dp,i)));
788 hres = to_string(func->ctx, &var, ei, ret);
793 /* ECMA-262 3rd Edition 15.5.4.11 */
794 static HRESULT String_replace(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
795 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
797 DWORD parens_cnt = 0, parens_size=0, rep_len=0, length;
798 BSTR rep_str = NULL, match_str = NULL, ret_str;
799 DispatchEx *rep_func = NULL, *regexp = NULL;
800 match_result_t *parens = NULL, match;
802 strbuf_t ret = {NULL,0,0};
809 if(is_class(dispex, JSCLASS_STRING)) {
810 StringInstance *string = (StringInstance*)dispex;
812 length = string->length;
814 FIXME("not String this\n");
820 ret_str = SysAllocString(str);
822 return E_OUTOFMEMORY;
824 V_VT(retv) = VT_BSTR;
825 V_BSTR(retv) = ret_str;
830 arg_var = get_arg(dp, 0);
831 switch(V_VT(arg_var)) {
833 regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
835 if(is_class(regexp, JSCLASS_REGEXP)) {
838 jsdisp_release(regexp);
844 hres = to_string(dispex->ctx, arg_var, ei, &match_str);
849 if(arg_cnt(dp) >= 2) {
850 arg_var = get_arg(dp,1);
851 switch(V_VT(arg_var)) {
853 rep_func = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
855 if(is_class(rep_func, JSCLASS_FUNCTION)) {
858 jsdisp_release(rep_func);
864 hres = to_string(dispex->ctx, arg_var, ei, &rep_str);
868 if(strchrW(rep_str, '$')) {
869 FIXME("unsupported $ in replace string\n");
873 rep_len = SysStringLen(rep_str);
877 if(SUCCEEDED(hres)) {
878 const WCHAR *cp, *ecp;
884 hres = regexp_match_next(regexp, gcheck, str, length, &cp, rep_func ? &parens : NULL,
885 &parens_size, &parens_cnt, &match);
888 if(hres == S_FALSE) {
895 match.str = strstrW(cp, match_str);
898 match.len = SysStringLen(match_str);
899 cp = match.str+match.len;
902 hres = strbuf_append(&ret, ecp, match.str-ecp);
903 ecp = match.str+match.len;
910 hres = rep_call(rep_func, str, &match, parens, parens_cnt, lcid, &cstr, ei, caller);
914 hres = strbuf_append(&ret, cstr, SysStringLen(cstr));
919 hres = strbuf_append(&ret, rep_str, rep_len);
923 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d'};
925 hres = strbuf_append(&ret, undefinedW, sizeof(undefinedW)/sizeof(WCHAR));
932 hres = strbuf_append(&ret, ecp, (str+length)-ecp);
936 jsdisp_release(rep_func);
938 jsdisp_release(regexp);
939 SysFreeString(rep_str);
940 SysFreeString(match_str);
943 if(SUCCEEDED(hres) && retv) {
944 ret_str = SysAllocStringLen(ret.buf, ret.len);
946 return E_OUTOFMEMORY;
948 V_VT(retv) = VT_BSTR;
949 V_BSTR(retv) = ret_str;
950 TRACE("= %s\n", debugstr_w(ret_str));
957 static HRESULT String_search(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
958 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
964 /* ECMA-262 3rd Edition 15.5.4.13 */
965 static HRESULT String_slice(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
966 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
976 if(is_class(dispex, JSCLASS_STRING)) {
977 StringInstance *string = (StringInstance*)dispex;
980 length = string->length;
982 FIXME("this is not a string class\n");
987 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v);
991 if(V_VT(&v) == VT_I4) {
994 start = length + start;
997 }else if(start > length) {
1001 start = V_R8(&v) < 0.0 ? 0 : length;
1007 if(arg_cnt(dp) >= 2) {
1008 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v);
1012 if(V_VT(&v) == VT_I4) {
1018 }else if(end > length) {
1022 end = V_R8(&v) < 0.0 ? 0 : length;
1032 BSTR retstr = SysAllocStringLen(str+start, end-start);
1034 return E_OUTOFMEMORY;
1036 V_VT(retv) = VT_BSTR;
1037 V_BSTR(retv) = retstr;
1042 static HRESULT String_small(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1043 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1045 static const WCHAR smalltagW[] = {'S','M','A','L','L',0};
1046 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, smalltagW);
1049 static HRESULT String_split(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1050 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1052 match_result_t *match_result = NULL;
1053 DWORD match_cnt, i, match_len = 0;
1054 StringInstance *string;
1055 const WCHAR *ptr, *ptr2;
1058 BSTR match_str = NULL;
1063 if(!is_class(dispex, JSCLASS_STRING)) {
1064 FIXME("not String this\n");
1068 string = (StringInstance*)dispex;
1070 if(arg_cnt(dp) != 1) {
1071 FIXME("unsupported args\n");
1075 arg = get_arg(dp, 0);
1080 regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg));
1082 if(is_class(regexp, JSCLASS_REGEXP)) {
1083 hres = regexp_match(regexp, string->str, string->length, TRUE, &match_result, &match_cnt);
1084 jsdisp_release(regexp);
1089 jsdisp_release(regexp);
1093 hres = to_string(dispex->ctx, arg, ei, &match_str);
1097 match_len = SysStringLen(match_str);
1099 SysFreeString(match_str);
1104 hres = create_array(dispex->ctx, 0, &array);
1106 if(SUCCEEDED(hres)) {
1112 ptr2 = match_result[i].str;
1113 }else if(match_str) {
1114 ptr2 = strstrW(ptr, match_str);
1123 V_VT(&var) = VT_BSTR;
1124 V_BSTR(&var) = SysAllocStringLen(ptr, ptr2-ptr);
1126 hres = E_OUTOFMEMORY;
1130 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
1131 SysFreeString(V_BSTR(&var));
1136 ptr = match_result[i].str + match_result[i].len;
1138 ptr = ptr2 + match_len;
1144 if(SUCCEEDED(hres) && (match_str || match_result)) {
1145 DWORD len = (string->str+string->length) - ptr;
1147 if(len || match_str) {
1148 V_VT(&var) = VT_BSTR;
1149 V_BSTR(&var) = SysAllocStringLen(ptr, len);
1152 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
1153 SysFreeString(V_BSTR(&var));
1155 hres = E_OUTOFMEMORY;
1160 SysFreeString(match_str);
1161 heap_free(match_result);
1163 if(SUCCEEDED(hres) && retv) {
1164 V_VT(retv) = VT_DISPATCH;
1165 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
1167 jsdisp_release(array);
1173 static HRESULT String_strike(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1174 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1176 static const WCHAR striketagW[] = {'S','T','R','I','K','E',0};
1177 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, striketagW);
1180 static HRESULT String_sub(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1181 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1183 static const WCHAR subtagW[] = {'S','U','B',0};
1184 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, subtagW);
1187 /* ECMA-262 3rd Edition 15.5.4.15 */
1188 static HRESULT String_substring(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1189 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1199 if(is_class(dispex, JSCLASS_STRING)) {
1200 StringInstance *string = (StringInstance*)dispex;
1202 length = string->length;
1205 FIXME("not string this not supported\n");
1209 if(arg_cnt(dp) >= 1) {
1210 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v);
1214 if(V_VT(&v) == VT_I4) {
1218 else if(start >= length)
1221 start = V_R8(&v) < 0.0 ? 0 : length;
1225 if(arg_cnt(dp) >= 2) {
1226 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v);
1230 if(V_VT(&v) == VT_I4) {
1234 else if(end > length)
1237 end = V_R8(&v) < 0.0 ? 0 : length;
1250 V_VT(retv) = VT_BSTR;
1251 V_BSTR(retv) = SysAllocStringLen(str+start, end-start);
1253 return E_OUTOFMEMORY;
1258 static HRESULT String_substr(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1259 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1265 static HRESULT String_sup(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1266 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1268 static const WCHAR suptagW[] = {'S','U','P',0};
1269 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, suptagW);
1272 static HRESULT String_toLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1273 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1275 StringInstance *string;
1282 if(is_class(dispex, JSCLASS_STRING)) {
1283 string = (StringInstance*)dispex;
1285 length = string->length;
1288 FIXME("not string this not supported\n");
1293 bstr = SysAllocStringLen(str, length);
1295 return E_OUTOFMEMORY;
1299 V_VT(retv) = VT_BSTR;
1300 V_BSTR(retv) = bstr;
1305 static HRESULT String_toUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1306 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1308 StringInstance *string;
1315 if(is_class(dispex, JSCLASS_STRING)) {
1316 string = (StringInstance*)dispex;
1318 length = string->length;
1321 FIXME("not string this not supported\n");
1326 bstr = SysAllocStringLen(str, length);
1328 return E_OUTOFMEMORY;
1332 V_VT(retv) = VT_BSTR;
1333 V_BSTR(retv) = bstr;
1338 static HRESULT String_toLocaleLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1339 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1345 static HRESULT String_toLocaleUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1346 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1352 static HRESULT String_localeCompare(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1353 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1359 static HRESULT String_hasOwnProperty(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1360 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1366 static HRESULT String_propertyIsEnumerable(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1367 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1373 static HRESULT String_isPrototypeOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1374 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1380 static HRESULT String_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1381 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1383 StringInstance *This = (StringInstance*)dispex;
1388 case DISPATCH_PROPERTYGET: {
1389 BSTR str = SysAllocString(This->str);
1391 return E_OUTOFMEMORY;
1393 V_VT(retv) = VT_BSTR;
1398 FIXME("flags %x\n", flags);
1405 static void String_destructor(DispatchEx *dispex)
1407 StringInstance *This = (StringInstance*)dispex;
1409 heap_free(This->str);
1413 static const builtin_prop_t String_props[] = {
1414 {anchorW, String_anchor, PROPF_METHOD},
1415 {bigW, String_big, PROPF_METHOD},
1416 {blinkW, String_blink, PROPF_METHOD},
1417 {boldW, String_bold, PROPF_METHOD},
1418 {charAtW, String_charAt, PROPF_METHOD},
1419 {charCodeAtW, String_charCodeAt, PROPF_METHOD},
1420 {concatW, String_concat, PROPF_METHOD},
1421 {fixedW, String_fixed, PROPF_METHOD},
1422 {fontcolorW, String_fontcolor, PROPF_METHOD},
1423 {fontsizeW, String_fontsize, PROPF_METHOD},
1424 {hasOwnPropertyW, String_hasOwnProperty, PROPF_METHOD},
1425 {indexOfW, String_indexOf, PROPF_METHOD},
1426 {isPrototypeOfW, String_isPrototypeOf, PROPF_METHOD},
1427 {italicsW, String_italics, PROPF_METHOD},
1428 {lastIndexOfW, String_lastIndexOf, PROPF_METHOD},
1429 {lengthW, String_length, 0},
1430 {linkW, String_link, PROPF_METHOD},
1431 {localeCompareW, String_localeCompare, PROPF_METHOD},
1432 {matchW, String_match, PROPF_METHOD},
1433 {propertyIsEnumerableW, String_propertyIsEnumerable, PROPF_METHOD},
1434 {replaceW, String_replace, PROPF_METHOD},
1435 {searchW, String_search, PROPF_METHOD},
1436 {sliceW, String_slice, PROPF_METHOD},
1437 {smallW, String_small, PROPF_METHOD},
1438 {splitW, String_split, PROPF_METHOD},
1439 {strikeW, String_strike, PROPF_METHOD},
1440 {subW, String_sub, PROPF_METHOD},
1441 {substrW, String_substr, PROPF_METHOD},
1442 {substringW, String_substring, PROPF_METHOD},
1443 {supW, String_sup, PROPF_METHOD},
1444 {toLocaleLowerCaseW, String_toLocaleLowerCase, PROPF_METHOD},
1445 {toLocaleUpperCaseW, String_toLocaleUpperCase, PROPF_METHOD},
1446 {toLowerCaseW, String_toLowerCase, PROPF_METHOD},
1447 {toStringW, String_toString, PROPF_METHOD},
1448 {toUpperCaseW, String_toUpperCase, PROPF_METHOD},
1449 {valueOfW, String_valueOf, PROPF_METHOD}
1452 static const builtin_info_t String_info = {
1454 {NULL, String_value, 0},
1455 sizeof(String_props)/sizeof(*String_props),
1461 static HRESULT StringConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1462 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1473 hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1477 str = SysAllocStringLen(NULL, 0);
1479 return E_OUTOFMEMORY;
1482 V_VT(retv) = VT_BSTR;
1486 case DISPATCH_CONSTRUCT: {
1492 hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1496 hres = create_string(dispex->ctx, str, SysStringLen(str), &ret);
1499 hres = create_string(dispex->ctx, NULL, 0, &ret);
1505 V_VT(retv) = VT_DISPATCH;
1506 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(ret);
1511 FIXME("unimplemented flags: %x\n", flags);
1518 static HRESULT string_alloc(script_ctx_t *ctx, BOOL use_constr, StringInstance **ret)
1520 StringInstance *string;
1523 string = heap_alloc_zero(sizeof(StringInstance));
1525 return E_OUTOFMEMORY;
1528 hres = init_dispex_from_constr(&string->dispex, ctx, &String_info, ctx->string_constr);
1530 hres = init_dispex(&string->dispex, ctx, &String_info, NULL);
1540 HRESULT create_string_constr(script_ctx_t *ctx, DispatchEx **ret)
1542 StringInstance *string;
1545 hres = string_alloc(ctx, FALSE, &string);
1549 hres = create_builtin_function(ctx, StringConstr_value, NULL, PROPF_CONSTR, &string->dispex, ret);
1551 jsdisp_release(&string->dispex);
1555 HRESULT create_string(script_ctx_t *ctx, const WCHAR *str, DWORD len, DispatchEx **ret)
1557 StringInstance *string;
1560 hres = string_alloc(ctx, TRUE, &string);
1567 string->length = len;
1568 string->str = heap_alloc((len+1)*sizeof(WCHAR));
1570 jsdisp_release(&string->dispex);
1571 return E_OUTOFMEMORY;
1574 memcpy(string->str, str, len*sizeof(WCHAR));
1575 string->str[len] = 0;
1577 *ret = &string->dispex;