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