jscript: Make String_match generic.
[wine] / 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 /* 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)
94 {
95     StringInstance *string;
96
97     TRACE("\n");
98
99     if(!is_class(dispex, JSCLASS_STRING)) {
100         WARN("this is not a string object\n");
101         return E_FAIL;
102     }
103
104     string = (StringInstance*)dispex;
105
106     if(retv) {
107         BSTR str = SysAllocString(string->str);
108         if(!str)
109             return E_OUTOFMEMORY;
110
111         V_VT(retv) = VT_BSTR;
112         V_BSTR(retv) = str;
113     }
114     return S_OK;
115 }
116
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)
120 {
121     TRACE("\n");
122
123     return String_toString(dispex, lcid, flags, dp, retv, ei, sp);
124 }
125
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)
128 {
129     static const WCHAR tagfmt[] = {'<','%','s','>','%','s','<','/','%','s','>',0};
130     const WCHAR *str;
131     DWORD length;
132     BSTR val_str = NULL;
133     HRESULT hres;
134
135     if(!is_class(dispex, JSCLASS_STRING)) {
136         VARIANT this;
137
138         V_VT(&this) = VT_DISPATCH;
139         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
140
141         hres = to_string(dispex->ctx, &this, ei, &val_str);
142         if(FAILED(hres))
143             return hres;
144
145         str = val_str;
146         length = SysStringLen(val_str);
147     }
148     else {
149         StringInstance *this = (StringInstance*)dispex;
150
151         str = this->str;
152         length = this->length;
153     }
154
155     if(retv) {
156         BSTR ret = SysAllocStringLen(NULL, length + 2*strlenW(tagname) + 5);
157         if(!ret) {
158             SysFreeString(val_str);
159             return E_OUTOFMEMORY;
160         }
161
162         sprintfW(ret, tagfmt, tagname, str, tagname);
163
164         V_VT(retv) = VT_BSTR;
165         V_BSTR(retv) = ret;
166     }
167
168     SysFreeString(val_str);
169     return S_OK;
170 }
171
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)
175 {
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};
179
180     const WCHAR *str;
181     DWORD length;
182     BSTR attr_value, val_str = NULL;
183     HRESULT hres;
184
185     if(!is_class(dispex, JSCLASS_STRING)) {
186         VARIANT this;
187
188         V_VT(&this) = VT_DISPATCH;
189         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
190
191         hres = to_string(dispex->ctx, &this, ei, &val_str);
192         if(FAILED(hres))
193             return hres;
194
195         str = val_str;
196         length = SysStringLen(val_str);
197     }
198     else {
199         StringInstance *this = (StringInstance*)dispex;
200
201         str = this->str;
202         length = this->length;
203     }
204
205     if(arg_cnt(dp)) {
206         hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &attr_value);
207         if(FAILED(hres)) {
208             SysFreeString(val_str);
209             return hres;
210         }
211     }
212     else {
213         attr_value = SysAllocString(undefinedW);
214         if(!attr_value) {
215             SysFreeString(val_str);
216             return E_OUTOFMEMORY;
217         }
218     }
219
220     if(retv) {
221         BSTR ret = SysAllocStringLen(NULL, length + 2*strlenW(tagname)
222                 + strlenW(attr) + SysStringLen(attr_value) + 9);
223         if(!ret) {
224             SysFreeString(attr_value);
225             SysFreeString(val_str);
226             return E_OUTOFMEMORY;
227         }
228
229         sprintfW(ret, tagfmtW, tagname, attr, attr_value, str, tagname);
230
231         V_VT(retv) = VT_BSTR;
232         V_BSTR(retv) = ret;
233     }
234
235     SysFreeString(attr_value);
236     SysFreeString(val_str);
237     return S_OK;
238 }
239
240 static HRESULT String_anchor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
241         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
242 {
243     static const WCHAR fontW[] = {'A',0};
244     static const WCHAR colorW[] = {'N','A','M','E',0};
245
246     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
247 }
248
249 static HRESULT String_big(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
250         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
251 {
252     static const WCHAR bigtagW[] = {'B','I','G',0};
253     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, bigtagW);
254 }
255
256 static HRESULT String_blink(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
257         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
258 {
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);
261 }
262
263 static HRESULT String_bold(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
264         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
265 {
266     static const WCHAR boldtagW[] = {'B',0};
267     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, boldtagW);
268 }
269
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)
273 {
274     const WCHAR *str;
275     DWORD length;
276     BSTR ret, val_str = NULL;
277     INT pos = 0;
278     HRESULT hres;
279
280     TRACE("\n");
281
282     if(!is_class(dispex, JSCLASS_STRING)) {
283         VARIANT this;
284
285         V_VT(&this) = VT_DISPATCH;
286         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
287
288         hres = to_string(dispex->ctx, &this, ei, &val_str);
289         if(FAILED(hres))
290             return hres;
291
292         str = val_str;
293         length = SysStringLen(val_str);
294     }
295     else {
296         StringInstance *this = (StringInstance*)dispex;
297
298         str = this->str;
299         length = this->length;
300     }
301
302     if(arg_cnt(dp)) {
303         VARIANT num;
304
305         hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &num);
306         if(FAILED(hres)) {
307             SysFreeString(val_str);
308             return hres;
309         }
310
311         if(V_VT(&num) == VT_I4) {
312             pos = V_I4(&num);
313         }else {
314             WARN("pos = %lf\n", V_R8(&num));
315             pos = -1;
316         }
317     }
318
319     if(!retv) {
320         SysFreeString(val_str);
321         return S_OK;
322     }
323
324     if(0 <= pos && pos < length)
325         ret = SysAllocStringLen(str+pos, 1);
326     else
327         ret = SysAllocStringLen(NULL, 0);
328     SysFreeString(val_str);
329     if(!ret) {
330         return E_OUTOFMEMORY;
331     }
332
333     V_VT(retv) = VT_BSTR;
334     V_BSTR(retv) = ret;
335     return S_OK;
336 }
337
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)
341 {
342     const WCHAR *str;
343     BSTR val_str = NULL;
344     DWORD length, idx = 0;
345     HRESULT hres;
346
347     TRACE("\n");
348
349     if(!is_class(dispex, JSCLASS_STRING)) {
350         VARIANT this;
351
352         V_VT(&this) = VT_DISPATCH;
353         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
354
355         hres = to_string(dispex->ctx, &this, ei, &val_str);
356         if(FAILED(hres))
357             return hres;
358
359         str = val_str;
360         length = SysStringLen(val_str);
361     }
362     else {
363         StringInstance *this = (StringInstance*)dispex;
364
365         str = this->str;
366         length = this->length;
367     }
368
369     if(arg_cnt(dp) > 0) {
370         VARIANT v;
371
372         hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &v);
373         if(FAILED(hres)) {
374             SysFreeString(val_str);
375             return hres;
376         }
377
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);
381             return S_OK;
382         }
383
384         idx = V_I4(&v);
385     }
386
387     if(retv) {
388         V_VT(retv) = VT_I4;
389         V_I4(retv) = str[idx];
390     }
391
392     SysFreeString(val_str);
393     return S_OK;
394 }
395
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)
399 {
400     BSTR *strs = NULL, ret = NULL;
401     DWORD len = 0, i, l, str_cnt;
402     VARIANT var;
403     WCHAR *ptr;
404     HRESULT hres;
405
406     TRACE("\n");
407
408     str_cnt = arg_cnt(dp)+1;
409     strs = heap_alloc_zero(str_cnt * sizeof(BSTR));
410     if(!strs)
411         return E_OUTOFMEMORY;
412
413     V_VT(&var) = VT_DISPATCH;
414     V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
415
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);
420             if(FAILED(hres))
421                 break;
422         }
423     }
424
425     if(SUCCEEDED(hres)) {
426         for(i=0; i < str_cnt; i++)
427             len += SysStringLen(strs[i]);
428
429         ptr = ret = SysAllocStringLen(NULL, len);
430
431         for(i=0; i < str_cnt; i++) {
432             l = SysStringLen(strs[i]);
433             memcpy(ptr, strs[i], l*sizeof(WCHAR));
434             ptr += l;
435         }
436     }
437
438     for(i=0; i < str_cnt; i++)
439         SysFreeString(strs[i]);
440     heap_free(strs);
441
442     if(FAILED(hres))
443         return hres;
444
445     if(retv) {
446         V_VT(retv) = VT_BSTR;
447         V_BSTR(retv) = ret;
448     }else {
449         SysFreeString(ret);
450     }
451     return S_OK;
452 }
453
454 static HRESULT String_fixed(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
455         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
456 {
457     static const WCHAR fixedtagW[] = {'T','T',0};
458     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fixedtagW);
459 }
460
461 static HRESULT String_fontcolor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
462         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
463 {
464     static const WCHAR fontW[] = {'F','O','N','T',0};
465     static const WCHAR colorW[] = {'C','O','L','O','R',0};
466
467     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
468 }
469
470 static HRESULT String_fontsize(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
471         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
472 {
473     static const WCHAR fontW[] = {'F','O','N','T',0};
474     static const WCHAR colorW[] = {'S','I','Z','E',0};
475
476     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
477 }
478
479 static HRESULT String_indexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
480         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
481 {
482     DWORD length, pos = 0;
483     const WCHAR *str;
484     BSTR search_str, val_str = NULL;
485     INT ret = -1;
486     HRESULT hres;
487
488     TRACE("\n");
489
490     if(!is_class(dispex, JSCLASS_STRING)) {
491         VARIANT this;
492
493         V_VT(&this) = VT_DISPATCH;
494         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
495
496         hres = to_string(dispex->ctx, &this, ei, &val_str);
497         if(FAILED(hres))
498             return hres;
499
500         str = val_str;
501         length = SysStringLen(val_str);
502     }
503     else {
504         StringInstance *this = (StringInstance*)dispex;
505
506         str = this->str;
507         length = this->length;
508     }
509
510     if(!arg_cnt(dp)) {
511         if(retv) {
512             V_VT(retv) = VT_I4;
513             V_I4(retv) = -1;
514         }
515         SysFreeString(val_str);
516         return S_OK;
517     }
518
519     hres = to_string(dispex->ctx, get_arg(dp,0), ei, &search_str);
520     if(FAILED(hres)) {
521         SysFreeString(val_str);
522         return hres;
523     }
524
525     if(arg_cnt(dp) >= 2) {
526         VARIANT ival;
527
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;
532             else
533                 pos = V_R8(&ival) > 0.0 ? length : 0;
534             if(pos > length)
535                 pos = length;
536         }
537     }
538
539     if(SUCCEEDED(hres)) {
540         const WCHAR *ptr;
541
542         ptr = strstrW(str+pos, search_str);
543         if(ptr)
544             ret = ptr - str;
545         else
546             ret = -1;
547     }
548
549     SysFreeString(search_str);
550     SysFreeString(val_str);
551     if(FAILED(hres))
552         return hres;
553
554     if(retv) {
555         V_VT(retv) = VT_I4;
556         V_I4(retv) = ret;
557     }
558     return S_OK;
559 }
560
561 static HRESULT String_italics(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
562         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
563 {
564     static const WCHAR italicstagW[] = {'I',0};
565     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, italicstagW);
566 }
567
568 static HRESULT String_lastIndexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
569         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
570 {
571     FIXME("\n");
572     return E_NOTIMPL;
573 }
574
575 static HRESULT String_link(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
576         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
577 {
578     static const WCHAR fontW[] = {'A',0};
579     static const WCHAR colorW[] = {'H','R','E','F',0};
580
581     return do_attribute_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fontW, colorW);
582 }
583
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)
587 {
588     const WCHAR *str;
589     match_result_t *match_result;
590     DispatchEx *regexp;
591     DispatchEx *array;
592     VARIANT var, *arg_var;
593     DWORD length, match_cnt, i;
594     BSTR val_str;
595     HRESULT hres = S_OK;
596
597     TRACE("\n");
598
599     if(arg_cnt(dp) != 1) {
600         FIXME("unsupported args\n");
601         return E_NOTIMPL;
602     }
603
604     arg_var = get_arg(dp, 0);
605     switch(V_VT(arg_var)) {
606     case VT_DISPATCH:
607         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
608         if(regexp) {
609             if(regexp->builtin_info->class == JSCLASS_REGEXP)
610                 break;
611             jsdisp_release(regexp);
612         }
613     default: {
614         BSTR match_str;
615
616         hres = to_string(dispex->ctx, arg_var, ei, &match_str);
617         if(FAILED(hres))
618             return hres;
619
620         hres = create_regexp_str(dispex->ctx, match_str, SysStringLen(match_str), NULL, 0, &regexp);
621         SysFreeString(match_str);
622         if(FAILED(hres))
623             return hres;
624     }
625     }
626
627     if(!is_class(dispex, JSCLASS_STRING)) {
628         VARIANT this;
629
630         V_VT(&this) = VT_DISPATCH;
631         V_DISPATCH(&this) = (IDispatch*)_IDispatchEx_(dispex);
632
633         hres = to_string(dispex->ctx, &this, ei, &val_str);
634         if(FAILED(hres)) {
635             jsdisp_release(regexp);
636             return hres;
637         }
638
639         str = val_str;
640         length = SysStringLen(val_str);
641     }
642     else {
643         StringInstance *this = (StringInstance*)dispex;
644
645         str = this->str;
646         length = this->length;
647     }
648
649     hres = regexp_match(regexp, str, length, FALSE, &match_result, &match_cnt);
650     jsdisp_release(regexp);
651     if(FAILED(hres)) {
652         SysFreeString(val_str);
653         return hres;
654     }
655
656     if(!match_cnt) {
657         TRACE("no match\n");
658
659         if(retv)
660             V_VT(retv) = VT_NULL;
661
662         SysFreeString(val_str);
663         return S_OK;
664     }
665
666     hres = create_array(dispex->ctx, match_cnt, &array);
667     if(FAILED(hres)) {
668         SysFreeString(val_str);
669         return hres;
670     }
671
672     V_VT(&var) = VT_BSTR;
673
674     for(i=0; i < match_cnt; i++) {
675         V_BSTR(&var) = SysAllocStringLen(match_result[i].str, match_result[i].len);
676         if(!V_BSTR(&var)) {
677             hres = E_OUTOFMEMORY;
678             break;
679         }
680
681         hres = jsdisp_propput_idx(array, i, lcid, &var, ei, NULL/*FIXME*/);
682         SysFreeString(V_BSTR(&var));
683         if(FAILED(hres))
684             break;
685     }
686
687     SysFreeString(val_str);
688
689     if(SUCCEEDED(hres) && retv) {
690         V_VT(retv) = VT_DISPATCH;
691         V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
692     }else {
693         jsdisp_release(array);
694     }
695     return hres;
696 }
697
698 typedef struct {
699     WCHAR *buf;
700     DWORD size;
701     DWORD len;
702 } strbuf_t;
703
704 static HRESULT strbuf_append(strbuf_t *buf, const WCHAR *str, DWORD len)
705 {
706     if(!len)
707         return S_OK;
708
709     if(len + buf->len > buf->size) {
710         WCHAR *new_buf;
711         DWORD new_size;
712
713         new_size = buf->size ? buf->size<<1 : 16;
714         if(new_size < buf->len+len)
715             new_size = buf->len+len;
716         if(buf->buf)
717             new_buf = heap_realloc(buf->buf, new_size*sizeof(WCHAR));
718         else
719             new_buf = heap_alloc(new_size*sizeof(WCHAR));
720         if(!new_buf)
721             return E_OUTOFMEMORY;
722
723         buf->buf = new_buf;
724         buf->size = new_size;
725     }
726
727     memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR));
728     buf->len += len;
729     return S_OK;
730 }
731
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)
734 {
735     DISPPARAMS dp = {NULL, NULL, 0, 0};
736     VARIANTARG *args, *arg;
737     VARIANT var;
738     DWORD i;
739     HRESULT hres = S_OK;
740
741     dp.cArgs = parens_cnt+3;
742     dp.rgvarg = args = heap_alloc_zero(sizeof(VARIANT)*dp.cArgs);
743     if(!args)
744         return E_OUTOFMEMORY;
745
746     arg = get_arg(&dp,0);
747     V_VT(arg) = VT_BSTR;
748     V_BSTR(arg) = SysAllocStringLen(match->str, match->len);
749     if(!V_BSTR(arg))
750         hres = E_OUTOFMEMORY;
751
752     if(SUCCEEDED(hres)) {
753         for(i=0; i < parens_cnt; i++) {
754             arg = get_arg(&dp,i+1);
755             V_VT(arg) = VT_BSTR;
756             V_BSTR(arg) = SysAllocStringLen(parens[i].str, parens[i].len);
757             if(!V_BSTR(arg)) {
758                hres = E_OUTOFMEMORY;
759                break;
760             }
761         }
762     }
763
764     if(SUCCEEDED(hres)) {
765         arg = get_arg(&dp,parens_cnt+1);
766         V_VT(arg) = VT_I4;
767         V_I4(arg) = match->str - str;
768
769         arg = get_arg(&dp,parens_cnt+2);
770         V_VT(arg) = VT_BSTR;
771         V_BSTR(arg) = SysAllocString(str);
772         if(!V_BSTR(arg))
773             hres = E_OUTOFMEMORY;
774     }
775
776     if(SUCCEEDED(hres))
777         hres = jsdisp_call_value(func, lcid, DISPATCH_METHOD, &dp, &var, ei, caller);
778
779     for(i=0; i < parens_cnt+1; i++) {
780         if(i != parens_cnt+1)
781             SysFreeString(V_BSTR(get_arg(&dp,i)));
782     }
783     heap_free(args);
784
785     if(FAILED(hres))
786         return hres;
787
788     hres = to_string(func->ctx, &var, ei, ret);
789     VariantClear(&var);
790     return hres;
791 }
792
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)
796 {
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;
801     const WCHAR *str;
802     strbuf_t ret = {NULL,0,0};
803     BOOL gcheck = FALSE;
804     VARIANT *arg_var;
805     HRESULT hres = S_OK;
806
807     TRACE("\n");
808
809     if(is_class(dispex, JSCLASS_STRING)) {
810         StringInstance *string = (StringInstance*)dispex;
811         str = string->str;
812         length = string->length;
813     }else {
814         FIXME("not String this\n");
815         return E_NOTIMPL;
816     }
817
818     if(!arg_cnt(dp)) {
819         if(retv) {
820             ret_str = SysAllocString(str);
821             if(!ret_str)
822                 return E_OUTOFMEMORY;
823
824             V_VT(retv) = VT_BSTR;
825             V_BSTR(retv) = ret_str;
826         }
827         return S_OK;
828     }
829
830     arg_var = get_arg(dp, 0);
831     switch(V_VT(arg_var)) {
832     case VT_DISPATCH:
833         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
834         if(regexp) {
835             if(is_class(regexp, JSCLASS_REGEXP)) {
836                 break;
837             }else {
838                 jsdisp_release(regexp);
839                 regexp = NULL;
840             }
841         }
842
843     default:
844         hres = to_string(dispex->ctx, arg_var, ei, &match_str);
845         if(FAILED(hres))
846             return hres;
847     }
848
849     if(arg_cnt(dp) >= 2) {
850         arg_var = get_arg(dp,1);
851         switch(V_VT(arg_var)) {
852         case VT_DISPATCH:
853             rep_func = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
854             if(rep_func) {
855                 if(is_class(rep_func, JSCLASS_FUNCTION)) {
856                     break;
857                 }else {
858                     jsdisp_release(rep_func);
859                     rep_func = NULL;
860                 }
861             }
862
863         default:
864             hres = to_string(dispex->ctx, arg_var, ei, &rep_str);
865             if(FAILED(hres))
866                 break;
867
868             if(strchrW(rep_str, '$')) {
869                 FIXME("unsupported $ in replace string\n");
870                 hres = E_NOTIMPL;
871             }
872
873             rep_len = SysStringLen(rep_str);
874         }
875     }
876
877     if(SUCCEEDED(hres)) {
878         const WCHAR *cp, *ecp;
879
880         cp = ecp = str;
881
882         while(1) {
883             if(regexp) {
884                 hres = regexp_match_next(regexp, gcheck, str, length, &cp, rep_func ? &parens : NULL,
885                                          &parens_size, &parens_cnt, &match);
886                 gcheck = TRUE;
887
888                 if(hres == S_FALSE) {
889                     hres = S_OK;
890                     break;
891                 }
892                 if(FAILED(hres))
893                     break;
894             }else {
895                 match.str = strstrW(cp, match_str);
896                 if(!match.str)
897                     break;
898                 match.len = SysStringLen(match_str);
899                 cp = match.str+match.len;
900             }
901
902             hres = strbuf_append(&ret, ecp, match.str-ecp);
903             ecp = match.str+match.len;
904             if(FAILED(hres))
905                 break;
906
907             if(rep_func) {
908                 BSTR cstr;
909
910                 hres = rep_call(rep_func, str, &match, parens, parens_cnt, lcid, &cstr, ei, caller);
911                 if(FAILED(hres))
912                     break;
913
914                 hres = strbuf_append(&ret, cstr, SysStringLen(cstr));
915                 SysFreeString(cstr);
916                 if(FAILED(hres))
917                     break;
918             }else if(rep_str) {
919                 hres = strbuf_append(&ret, rep_str, rep_len);
920                 if(FAILED(hres))
921                     break;
922             }else {
923                 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d'};
924
925                 hres = strbuf_append(&ret, undefinedW, sizeof(undefinedW)/sizeof(WCHAR));
926                 if(FAILED(hres))
927                     break;
928             }
929         }
930
931         if(SUCCEEDED(hres))
932             hres = strbuf_append(&ret, ecp, (str+length)-ecp);
933     }
934
935     if(rep_func)
936         jsdisp_release(rep_func);
937     if(regexp)
938         jsdisp_release(regexp);
939     SysFreeString(rep_str);
940     SysFreeString(match_str);
941     heap_free(parens);
942
943     if(SUCCEEDED(hres) && retv) {
944         ret_str = SysAllocStringLen(ret.buf, ret.len);
945         if(!ret_str)
946             return E_OUTOFMEMORY;
947
948         V_VT(retv) = VT_BSTR;
949         V_BSTR(retv) = ret_str;
950         TRACE("= %s\n", debugstr_w(ret_str));
951     }
952
953     heap_free(ret.buf);
954     return hres;
955 }
956
957 static HRESULT String_search(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
958         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
959 {
960     FIXME("\n");
961     return E_NOTIMPL;
962 }
963
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)
967 {
968     const WCHAR *str;
969     DWORD length;
970     INT start=0, end;
971     VARIANT v;
972     HRESULT hres;
973
974     TRACE("\n");
975
976     if(is_class(dispex, JSCLASS_STRING)) {
977         StringInstance *string = (StringInstance*)dispex;
978
979         str = string->str;
980         length = string->length;
981     }else {
982         FIXME("this is not a string class\n");
983         return E_NOTIMPL;
984     }
985
986     if(arg_cnt(dp)) {
987         hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v);
988         if(FAILED(hres))
989             return hres;
990
991         if(V_VT(&v) == VT_I4) {
992             start = V_I4(&v);
993             if(start < 0) {
994                 start = length + start;
995                 if(start < 0)
996                     start = 0;
997             }else if(start > length) {
998                 start = length;
999             }
1000         }else {
1001             start = V_R8(&v) < 0.0 ? 0 : length;
1002         }
1003     }else {
1004         start = 0;
1005     }
1006
1007     if(arg_cnt(dp) >= 2) {
1008         hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v);
1009         if(FAILED(hres))
1010             return hres;
1011
1012         if(V_VT(&v) == VT_I4) {
1013             end = V_I4(&v);
1014             if(end < 0) {
1015                 end = length + end;
1016                 if(end < 0)
1017                     end = 0;
1018             }else if(end > length) {
1019                 end = length;
1020             }
1021         }else {
1022             end = V_R8(&v) < 0.0 ? 0 : length;
1023         }
1024     }else {
1025         end = length;
1026     }
1027
1028     if(end < start)
1029         end = start;
1030
1031     if(retv) {
1032         BSTR retstr = SysAllocStringLen(str+start, end-start);
1033         if(!str)
1034             return E_OUTOFMEMORY;
1035
1036         V_VT(retv) = VT_BSTR;
1037         V_BSTR(retv) = retstr;
1038     }
1039     return S_OK;
1040 }
1041
1042 static HRESULT String_small(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1043         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1044 {
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);
1047 }
1048
1049 static HRESULT String_split(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1050         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1051 {
1052     match_result_t *match_result = NULL;
1053     DWORD match_cnt, i, match_len = 0;
1054     StringInstance *string;
1055     const WCHAR *ptr, *ptr2;
1056     VARIANT *arg, var;
1057     DispatchEx *array;
1058     BSTR match_str = NULL;
1059     HRESULT hres;
1060
1061     TRACE("\n");
1062
1063     if(!is_class(dispex, JSCLASS_STRING)) {
1064         FIXME("not String this\n");
1065         return E_NOTIMPL;
1066     }
1067
1068     string = (StringInstance*)dispex;
1069
1070     if(arg_cnt(dp) != 1) {
1071         FIXME("unsupported args\n");
1072         return E_NOTIMPL;
1073     }
1074
1075     arg = get_arg(dp, 0);
1076     switch(V_VT(arg)) {
1077     case VT_DISPATCH: {
1078         DispatchEx *regexp;
1079
1080         regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg));
1081         if(regexp) {
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);
1085                 if(FAILED(hres))
1086                     return hres;
1087                 break;
1088             }
1089             jsdisp_release(regexp);
1090         }
1091     }
1092     default:
1093         hres = to_string(dispex->ctx, arg, ei, &match_str);
1094         if(FAILED(hres))
1095             return hres;
1096
1097         match_len = SysStringLen(match_str);
1098         if(!match_len) {
1099             SysFreeString(match_str);
1100             match_str = NULL;
1101         }
1102     }
1103
1104     hres = create_array(dispex->ctx, 0, &array);
1105
1106     if(SUCCEEDED(hres)) {
1107         ptr = string->str;
1108         for(i=0;; i++) {
1109             if(match_result) {
1110                 if(i == match_cnt)
1111                     break;
1112                 ptr2 = match_result[i].str;
1113             }else if(match_str) {
1114                 ptr2 = strstrW(ptr, match_str);
1115                 if(!ptr2)
1116                     break;
1117             }else {
1118                 if(!*ptr)
1119                     break;
1120                 ptr2 = ptr+1;
1121             }
1122
1123             V_VT(&var) = VT_BSTR;
1124             V_BSTR(&var) = SysAllocStringLen(ptr, ptr2-ptr);
1125             if(!V_BSTR(&var)) {
1126                 hres = E_OUTOFMEMORY;
1127                 break;
1128             }
1129
1130             hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
1131             SysFreeString(V_BSTR(&var));
1132             if(FAILED(hres))
1133                 break;
1134
1135             if(match_result)
1136                 ptr = match_result[i].str + match_result[i].len;
1137             else if(match_str)
1138                 ptr = ptr2 + match_len;
1139             else
1140                 ptr++;
1141         }
1142     }
1143
1144     if(SUCCEEDED(hres) && (match_str || match_result)) {
1145         DWORD len = (string->str+string->length) - ptr;
1146
1147         if(len || match_str) {
1148             V_VT(&var) = VT_BSTR;
1149             V_BSTR(&var) = SysAllocStringLen(ptr, len);
1150
1151             if(V_BSTR(&var)) {
1152                 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
1153                 SysFreeString(V_BSTR(&var));
1154             }else {
1155                 hres = E_OUTOFMEMORY;
1156             }
1157         }
1158     }
1159
1160     SysFreeString(match_str);
1161     heap_free(match_result);
1162
1163     if(SUCCEEDED(hres) && retv) {
1164         V_VT(retv) = VT_DISPATCH;
1165         V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
1166     }else {
1167         jsdisp_release(array);
1168     }
1169
1170     return hres;
1171 }
1172
1173 static HRESULT String_strike(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1174         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1175 {
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);
1178 }
1179
1180 static HRESULT String_sub(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1181         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1182 {
1183     static const WCHAR subtagW[] = {'S','U','B',0};
1184     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, subtagW);
1185 }
1186
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)
1190 {
1191     const WCHAR *str;
1192     INT start=0, end;
1193     DWORD length;
1194     VARIANT v;
1195     HRESULT hres;
1196
1197     TRACE("\n");
1198
1199     if(is_class(dispex, JSCLASS_STRING)) {
1200         StringInstance *string = (StringInstance*)dispex;
1201
1202         length = string->length;
1203         str = string->str;
1204     }else {
1205         FIXME("not string this not supported\n");
1206         return E_NOTIMPL;
1207     }
1208
1209     if(arg_cnt(dp) >= 1) {
1210         hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v);
1211         if(FAILED(hres))
1212             return hres;
1213
1214         if(V_VT(&v) == VT_I4) {
1215             start = V_I4(&v);
1216             if(start < 0)
1217                 start = 0;
1218             else if(start >= length)
1219                 start = length;
1220         }else {
1221             start = V_R8(&v) < 0.0 ? 0 : length;
1222         }
1223     }
1224
1225     if(arg_cnt(dp) >= 2) {
1226         hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v);
1227         if(FAILED(hres))
1228             return hres;
1229
1230         if(V_VT(&v) == VT_I4) {
1231             end = V_I4(&v);
1232             if(end < 0)
1233                 end = 0;
1234             else if(end > length)
1235                 end = length;
1236         }else {
1237             end = V_R8(&v) < 0.0 ? 0 : length;
1238         }
1239     }else {
1240         end = length;
1241     }
1242
1243     if(start > end) {
1244         INT tmp = start;
1245         start = end;
1246         end = tmp;
1247     }
1248
1249     if(retv) {
1250         V_VT(retv) = VT_BSTR;
1251         V_BSTR(retv) = SysAllocStringLen(str+start, end-start);
1252         if(!V_BSTR(retv))
1253             return E_OUTOFMEMORY;
1254     }
1255     return S_OK;
1256 }
1257
1258 static HRESULT String_substr(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1259         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1260 {
1261     FIXME("\n");
1262     return E_NOTIMPL;
1263 }
1264
1265 static HRESULT String_sup(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1266         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1267 {
1268     static const WCHAR suptagW[] = {'S','U','P',0};
1269     return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, suptagW);
1270 }
1271
1272 static HRESULT String_toLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1273         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1274 {
1275     StringInstance *string;
1276     const WCHAR* str;
1277     DWORD length;
1278     BSTR bstr;
1279
1280     TRACE("\n");
1281
1282     if(is_class(dispex, JSCLASS_STRING)) {
1283         string = (StringInstance*)dispex;
1284
1285         length = string->length;
1286         str = string->str;
1287     }else {
1288         FIXME("not string this not supported\n");
1289         return E_NOTIMPL;
1290     }
1291
1292     if(retv) {
1293         bstr = SysAllocStringLen(str, length);
1294         if (!bstr)
1295             return E_OUTOFMEMORY;
1296
1297         strlwrW(bstr);
1298
1299         V_VT(retv) = VT_BSTR;
1300         V_BSTR(retv) = bstr;
1301     }
1302     return S_OK;
1303 }
1304
1305 static HRESULT String_toUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1306         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1307 {
1308     StringInstance *string;
1309     const WCHAR* str;
1310     DWORD length;
1311     BSTR bstr;
1312
1313     TRACE("\n");
1314
1315     if(is_class(dispex, JSCLASS_STRING)) {
1316         string = (StringInstance*)dispex;
1317
1318         length = string->length;
1319         str = string->str;
1320     }else {
1321         FIXME("not string this not supported\n");
1322         return E_NOTIMPL;
1323     }
1324
1325     if(retv) {
1326         bstr = SysAllocStringLen(str, length);
1327         if (!bstr)
1328             return E_OUTOFMEMORY;
1329
1330         struprW(bstr);
1331
1332         V_VT(retv) = VT_BSTR;
1333         V_BSTR(retv) = bstr;
1334     }
1335     return S_OK;
1336 }
1337
1338 static HRESULT String_toLocaleLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1339         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1340 {
1341     FIXME("\n");
1342     return E_NOTIMPL;
1343 }
1344
1345 static HRESULT String_toLocaleUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1346         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1347 {
1348     FIXME("\n");
1349     return E_NOTIMPL;
1350 }
1351
1352 static HRESULT String_localeCompare(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1353         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1354 {
1355     FIXME("\n");
1356     return E_NOTIMPL;
1357 }
1358
1359 static HRESULT String_hasOwnProperty(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1360         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1361 {
1362     FIXME("\n");
1363     return E_NOTIMPL;
1364 }
1365
1366 static HRESULT String_propertyIsEnumerable(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1367         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1368 {
1369     FIXME("\n");
1370     return E_NOTIMPL;
1371 }
1372
1373 static HRESULT String_isPrototypeOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1374         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1375 {
1376     FIXME("\n");
1377     return E_NOTIMPL;
1378 }
1379
1380 static HRESULT String_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1381         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1382 {
1383     StringInstance *This = (StringInstance*)dispex;
1384
1385     TRACE("\n");
1386
1387     switch(flags) {
1388     case DISPATCH_PROPERTYGET: {
1389         BSTR str = SysAllocString(This->str);
1390         if(!str)
1391             return E_OUTOFMEMORY;
1392
1393         V_VT(retv) = VT_BSTR;
1394         V_BSTR(retv) = str;
1395         break;
1396     }
1397     default:
1398         FIXME("flags %x\n", flags);
1399         return E_NOTIMPL;
1400     }
1401
1402     return S_OK;
1403 }
1404
1405 static void String_destructor(DispatchEx *dispex)
1406 {
1407     StringInstance *This = (StringInstance*)dispex;
1408
1409     heap_free(This->str);
1410     heap_free(This);
1411 }
1412
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}
1450 };
1451
1452 static const builtin_info_t String_info = {
1453     JSCLASS_STRING,
1454     {NULL, String_value, 0},
1455     sizeof(String_props)/sizeof(*String_props),
1456     String_props,
1457     String_destructor,
1458     NULL
1459 };
1460
1461 static HRESULT StringConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1462         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1463 {
1464     HRESULT hres;
1465
1466     TRACE("\n");
1467
1468     switch(flags) {
1469     case INVOKE_FUNC: {
1470         BSTR str;
1471
1472         if(arg_cnt(dp)) {
1473             hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1474             if(FAILED(hres))
1475                 return hres;
1476         }else {
1477             str = SysAllocStringLen(NULL, 0);
1478             if(!str)
1479                 return E_OUTOFMEMORY;
1480         }
1481
1482         V_VT(retv) = VT_BSTR;
1483         V_BSTR(retv) = str;
1484         break;
1485     }
1486     case DISPATCH_CONSTRUCT: {
1487         DispatchEx *ret;
1488
1489         if(arg_cnt(dp)) {
1490             BSTR str;
1491
1492             hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1493             if(FAILED(hres))
1494                 return hres;
1495
1496             hres = create_string(dispex->ctx, str, SysStringLen(str), &ret);
1497             SysFreeString(str);
1498         }else {
1499             hres = create_string(dispex->ctx, NULL, 0, &ret);
1500         }
1501
1502         if(FAILED(hres))
1503             return hres;
1504
1505         V_VT(retv) = VT_DISPATCH;
1506         V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(ret);
1507         break;
1508     }
1509
1510     default:
1511         FIXME("unimplemented flags: %x\n", flags);
1512         return E_NOTIMPL;
1513     }
1514
1515     return S_OK;
1516 }
1517
1518 static HRESULT string_alloc(script_ctx_t *ctx, BOOL use_constr, StringInstance **ret)
1519 {
1520     StringInstance *string;
1521     HRESULT hres;
1522
1523     string = heap_alloc_zero(sizeof(StringInstance));
1524     if(!string)
1525         return E_OUTOFMEMORY;
1526
1527     if(use_constr)
1528         hres = init_dispex_from_constr(&string->dispex, ctx, &String_info, ctx->string_constr);
1529     else
1530         hres = init_dispex(&string->dispex, ctx, &String_info, NULL);
1531     if(FAILED(hres)) {
1532         heap_free(string);
1533         return hres;
1534     }
1535
1536     *ret = string;
1537     return S_OK;
1538 }
1539
1540 HRESULT create_string_constr(script_ctx_t *ctx, DispatchEx **ret)
1541 {
1542     StringInstance *string;
1543     HRESULT hres;
1544
1545     hres = string_alloc(ctx, FALSE, &string);
1546     if(FAILED(hres))
1547         return hres;
1548
1549     hres = create_builtin_function(ctx, StringConstr_value, NULL, PROPF_CONSTR, &string->dispex, ret);
1550
1551     jsdisp_release(&string->dispex);
1552     return hres;
1553 }
1554
1555 HRESULT create_string(script_ctx_t *ctx, const WCHAR *str, DWORD len, DispatchEx **ret)
1556 {
1557     StringInstance *string;
1558     HRESULT hres;
1559
1560     hres = string_alloc(ctx, TRUE, &string);
1561     if(FAILED(hres))
1562         return hres;
1563
1564     if(len == -1)
1565         len = strlenW(str);
1566
1567     string->length = len;
1568     string->str = heap_alloc((len+1)*sizeof(WCHAR));
1569     if(!string->str) {
1570         jsdisp_release(&string->dispex);
1571         return E_OUTOFMEMORY;
1572     }
1573
1574     memcpy(string->str, str, len*sizeof(WCHAR));
1575     string->str[len] = 0;
1576
1577     *ret = &string->dispex;
1578     return S_OK;
1579
1580 }