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