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