?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msi: Fix handling of REINSTALL overrides.
[wine.git] / dlls / jscript / string.c
blobeeceb1f6932a0a76720d8aec5a7ca5b5710f507e
1 /*
2 * Copyright 2008 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "jscript.h"
20
21 #include "wine/debug.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
24
25 typedef struct {
26 DispatchEx dispex;
27
28 WCHAR *str;
29 DWORD length;
30 } StringInstance;
31
32 static const WCHAR lengthW[] = {'l','e','n','g','t','h',0};
33 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
34 static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
35 static const WCHAR anchorW[] = {'a','n','c','h','o','r',0};
36 static const WCHAR bigW[] = {'b','i','g',0};
37 static const WCHAR blinkW[] = {'b','l','i','n','k',0};
38 static const WCHAR boldW[] = {'b','o','l','d',0};
39 static const WCHAR charAtW[] = {'c','h','a','r','A','t',0};
40 static const WCHAR charCodeAtW[] = {'c','h','a','r','C','o','d','e','A','t',0};
41 static const WCHAR concatW[] = {'c','o','n','c','a','t',0};
42 static const WCHAR fixedW[] = {'f','i','x','e','d',0};
43 static const WCHAR fontcolorW[] = {'f','o','n','t','c','o','l','o','r',0};
44 static const WCHAR fontsizeW[] = {'f','o','n','t','s','i','z','e',0};
45 static const WCHAR indexOfW[] = {'i','n','d','e','x','O','f',0};
46 static const WCHAR italicsW[] = {'i','t','a','l','i','c','s',0};
47 static const WCHAR lastIndexOfW[] = {'l','a','s','t','I','n','d','e','x','O','f',0};
48 static const WCHAR linkW[] = {'l','i','n','k',0};
49 static const WCHAR matchW[] = {'m','a','t','c','h',0};
50 static const WCHAR replaceW[] = {'r','e','p','l','a','c','e',0};
51 static const WCHAR searchW[] = {'s','e','a','r','c','h',0};
52 static const WCHAR sliceW[] = {'s','l','i','c','e',0};
53 static const WCHAR smallW[] = {'s','m','a','l','l',0};
54 static const WCHAR splitW[] = {'s','p','l','i','t',0};
55 static const WCHAR strikeW[] = {'s','t','r','i','k','e',0};
56 static const WCHAR subW[] = {'s','u','b',0};
57 static const WCHAR substringW[] = {'s','u','b','s','t','r','i','n','g',0};
58 static const WCHAR substrW[] = {'s','u','b','s','t','r',0};
59 static const WCHAR supW[] = {'s','u','p',0};
60 static const WCHAR toLowerCaseW[] = {'t','o','L','o','w','e','r','C','a','s','e',0};
61 static const WCHAR toUpperCaseW[] = {'t','o','U','p','p','e','r','C','a','s','e',0};
62 static const WCHAR toLocaleLowerCaseW[] = {'t','o','L','o','c','a','l','e','L','o','w','e','r','C','a','s','e',0};
63 static const WCHAR toLocaleUpperCaseW[] = {'t','o','L','o','c','a','l','e','U','p','p','e','r','C','a','s','e',0};
64 static const WCHAR localeCompareW[] = {'l','o','c','a','l','e','C','o','m','p','a','r','e',0};
65 static const WCHAR hasOwnPropertyW[] = {'h','a','s','O','w','n','P','r','o','p','e','r','t','y',0};
66 static const WCHAR propertyIsEnumerableW[] =
67 {'p','r','o','p','e','r','t','y','I','s','E','n','u','m','e','r','a','b','l','e',0};
68 static const WCHAR isPrototypeOfW[] = {'i','s','P','r','o','t','o','t','y','p','e','O','f',0};
69
70 static HRESULT String_length(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
71 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
72 {
73 TRACE("%p\n", dispex);
74
75 switch(flags) {
76 case DISPATCH_PROPERTYGET: {
77 StringInstance *jsthis = (StringInstance*)dispex;
78
79 V_VT(retv) = VT_I4;
80 V_I4(retv) = jsthis->length;
81 break;
82 }
83 default:
84 FIXME("unimplemented flags %x\n", flags);
85 return E_NOTIMPL;
86 }
87
88 return S_OK;
89 }
90
91 /* ECMA-262 3rd Edition 15.5.4.2 */
92 static HRESULT String_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
93 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
94 {
95 StringInstance *string;
96
97 TRACE("\n");
98
99 if(!is_class(dispex, JSCLASS_STRING)) {
100 WARN("this is not a string object\n");
101 return E_FAIL;
102 }
103
104 string = (StringInstance*)dispex;
105
106 if(retv) {
107 BSTR str = SysAllocString(string->str);
108 if(!str)
109 return E_OUTOFMEMORY;
110
111 V_VT(retv) = VT_BSTR;
112 V_BSTR(retv) = str;
113 }
114 return S_OK;
115 }
116
117 /* ECMA-262 3rd Edition 15.5.4.2 */
118 static HRESULT String_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
119 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
120 {
121 TRACE("\n");
122
123 return String_toString(dispex, lcid, flags, dp, retv, ei, sp);
124 }
125
126 static HRESULT do_attributeless_tag_format(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
127 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp, const WCHAR *tagname)
128 {
129 static const WCHAR tagfmt[] = {'<','%','s','>','%','s','<','/','%','s','>',0};
130 StringInstance *string;
131 BSTR ret;
132
133 if(!is_class(dispex, JSCLASS_STRING)) {
134 WARN("this is not a string object\n");
135 return E_NOTIMPL;
136 }
137
138 string = (StringInstance*)dispex;
139
140 if(retv) {
141 ret = SysAllocStringLen(NULL, string->length + 2*strlenW(tagname) + 5);
142 if(!ret)
143 return E_OUTOFMEMORY;
144
145 sprintfW(ret, tagfmt, tagname, string->str, tagname);
146
147 V_VT(retv) = VT_BSTR;
148 V_BSTR(retv) = ret;
149 }
150 return S_OK;
151 }
152
153 static HRESULT String_anchor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
154 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
155 {
156 FIXME("\n");
157 return E_NOTIMPL;
158 }
159
160 static HRESULT String_big(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
161 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
162 {
163 static const WCHAR bigtagW[] = {'B','I','G',0};
164 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, bigtagW);
165 }
166
167 static HRESULT String_blink(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
168 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
169 {
170 static const WCHAR blinktagW[] = {'B','L','I','N','K',0};
171 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, blinktagW);
172 }
173
174 static HRESULT String_bold(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
175 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
176 {
177 static const WCHAR boldtagW[] = {'B',0};
178 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, boldtagW);
179 }
180
181 /* ECMA-262 3rd Edition 15.5.4.5 */
182 static HRESULT String_charAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
183 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
184 {
185 StringInstance *strobj;
186 BSTR str;
187 INT pos = 0;
188 HRESULT hres;
189
190 TRACE("\n");
191
192 if(dispex->builtin_info->class != JSCLASS_STRING) {
193 FIXME("not string this not supported\n");
194 return E_NOTIMPL;
195 }
196
197 strobj = (StringInstance*)dispex;
198
199 if(arg_cnt(dp)) {
200 VARIANT num;
201
202 hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &num);
203 if(FAILED(hres))
204 return hres;
205
206 if(V_VT(&num) == VT_I4) {
207 pos = V_I4(&num);
208 }else {
209 WARN("pos = %lf\n", V_R8(&num));
210 pos = -1;
211 }
212 }
213
214 if(!retv)
215 return S_OK;
216
217 if(0 <= pos && pos < strobj->length)
218 str = SysAllocStringLen(strobj->str+pos, 1);
219 else
220 str = SysAllocStringLen(NULL, 0);
221 if(!str)
222 return E_OUTOFMEMORY;
223
224 V_VT(retv) = VT_BSTR;
225 V_BSTR(retv) = str;
226 return S_OK;
227 }
228
229 /* ECMA-262 3rd Edition 15.5.4.5 */
230 static HRESULT String_charCodeAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
231 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
232 {
233 const WCHAR *str;
234 DWORD length, idx = 0;
235 HRESULT hres;
236
237 TRACE("\n");
238
239 if(dispex->builtin_info->class == JSCLASS_STRING) {
240 StringInstance *string = (StringInstance*)dispex;
241
242 str = string->str;
243 length = string->length;
244 }else {
245 FIXME("not string this not supported\n");
246 return E_NOTIMPL;
247 }
248
249 if(arg_cnt(dp) > 0) {
250 VARIANT v;
251
252 hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &v);
253 if(FAILED(hres))
254 return hres;
255
256 if(V_VT(&v) != VT_I4 || V_I4(&v) < 0 || V_I4(&v) >= length) {
257 FIXME("NAN\n");
258 return E_FAIL;
259 }
260
261 idx = V_I4(&v);
262 }
263
264 if(retv) {
265 V_VT(retv) = VT_I4;
266 V_I4(retv) = str[idx];
267 }
268 return S_OK;
269 }
270
271 /* ECMA-262 3rd Edition 15.5.4.6 */
272 static HRESULT String_concat(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
273 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
274 {
275 BSTR *strs = NULL, ret = NULL;
276 DWORD len = 0, i, l, str_cnt;
277 VARIANT var;
278 WCHAR *ptr;
279 HRESULT hres;
280
281 TRACE("\n");
282
283 str_cnt = arg_cnt(dp)+1;
284 strs = heap_alloc_zero(str_cnt * sizeof(BSTR));
285 if(!strs)
286 return E_OUTOFMEMORY;
287
288 V_VT(&var) = VT_DISPATCH;
289 V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
290
291 hres = to_string(dispex->ctx, &var, ei, strs);
292 if(SUCCEEDED(hres)) {
293 for(i=0; i < arg_cnt(dp); i++) {
294 hres = to_string(dispex->ctx, get_arg(dp, i), ei, strs+i+1);
295 if(FAILED(hres))
296 break;
297 }
298 }
299
300 if(SUCCEEDED(hres)) {
301 for(i=0; i < str_cnt; i++)
302 len += SysStringLen(strs[i]);
303
304 ptr = ret = SysAllocStringLen(NULL, len);
305
306 for(i=0; i < str_cnt; i++) {
307 l = SysStringLen(strs[i]);
308 memcpy(ptr, strs[i], l*sizeof(WCHAR));
309 ptr += l;
310 }
311 }
312
313 for(i=0; i < str_cnt; i++)
314 SysFreeString(strs[i]);
315 heap_free(strs);
316
317 if(FAILED(hres))
318 return hres;
319
320 if(retv) {
321 V_VT(retv) = VT_BSTR;
322 V_BSTR(retv) = ret;
323 }else {
324 SysFreeString(ret);
325 }
326 return S_OK;
327 }
328
329 static HRESULT String_fixed(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
330 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
331 {
332 static const WCHAR fixedtagW[] = {'T','T',0};
333 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fixedtagW);
334 }
335
336 static HRESULT String_fontcolor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
337 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
338 {
339 FIXME("\n");
340 return E_NOTIMPL;
341 }
342
343 static HRESULT String_fontsize(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
344 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
345 {
346 FIXME("\n");
347 return E_NOTIMPL;
348 }
349
350 static HRESULT String_indexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
351 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
352 {
353 DWORD length, pos = 0;
354 const WCHAR *str;
355 BSTR search_str;
356 INT ret = -1;
357 HRESULT hres;
358
359 TRACE("\n");
360
361 if(is_class(dispex, JSCLASS_STRING)) {
362 StringInstance *string = (StringInstance*)dispex;
363
364 str = string->str;
365 length = string->length;
366 }else {
367 FIXME("not String this\n");
368 return E_NOTIMPL;
369 }
370
371 if(!arg_cnt(dp)) {
372 if(retv) {
373 V_VT(retv) = VT_I4;
374 V_I4(retv) = -1;
375 }
376 return S_OK;
377 }
378
379 hres = to_string(dispex->ctx, get_arg(dp,0), ei, &search_str);
380 if(FAILED(hres))
381 return hres;
382
383 if(arg_cnt(dp) >= 2) {
384 VARIANT ival;
385
386 hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &ival);
387 if(SUCCEEDED(hres)) {
388 if(V_VT(&ival) == VT_I4)
389 pos = V_VT(&ival) > 0 ? V_I4(&ival) : 0;
390 else
391 pos = V_R8(&ival) > 0.0 ? length : 0;
392 if(pos > length)
393 pos = length;
394 }
395 }
396
397 if(SUCCEEDED(hres)) {
398 const WCHAR *ptr;
399
400 ptr = strstrW(str+pos, search_str);
401 if(ptr)
402 ret = ptr - str;
403 else
404 ret = -1;
405 }
406
407 SysFreeString(search_str);
408 if(FAILED(hres))
409 return hres;
410
411 if(retv) {
412 V_VT(retv) = VT_I4;
413 V_I4(retv) = ret;
414 }
415 return S_OK;
416 }
417
418 static HRESULT String_italics(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
419 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
420 {
421 static const WCHAR italicstagW[] = {'I',0};
422 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, italicstagW);
423 }
424
425 static HRESULT String_lastIndexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
426 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
427 {
428 FIXME("\n");
429 return E_NOTIMPL;
430 }
431
432 static HRESULT String_link(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
433 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
434 {
435 FIXME("\n");
436 return E_NOTIMPL;
437 }
438
439 /* ECMA-262 3rd Edition 15.5.4.10 */
440 static HRESULT String_match(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
441 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
442 {
443 StringInstance *This = (StringInstance*)dispex;
444 match_result_t *match_result;
445 DispatchEx *regexp;
446 DispatchEx *array;
447 VARIANT var, *arg_var;
448 DWORD match_cnt, i;
449 HRESULT hres = S_OK;
450
451 TRACE("\n");
452
453 if(arg_cnt(dp) != 1) {
454 FIXME("unsupported args\n");
455 return E_NOTIMPL;
456 }
457
458 arg_var = get_arg(dp, 0);
459 switch(V_VT(arg_var)) {
460 case VT_DISPATCH:
461 regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
462 if(regexp) {
463 if(regexp->builtin_info->class == JSCLASS_REGEXP)
464 break;
465 jsdisp_release(regexp);
466 }
467 default: {
468 BSTR match_str;
469
470 hres = to_string(dispex->ctx, arg_var, ei, &match_str);
471 if(FAILED(hres))
472 return hres;
473
474 hres = create_regexp_str(dispex->ctx, match_str, SysStringLen(match_str), NULL, 0, &regexp);
475 SysFreeString(match_str);
476 if(FAILED(hres))
477 return hres;
478 }
479 }
480
481 hres = regexp_match(regexp, This->str, This->length, FALSE, &match_result, &match_cnt);
482 jsdisp_release(regexp);
483 if(FAILED(hres))
484 return hres;
485
486 if(!match_cnt) {
487 TRACE("no match\n");
488
489 if(retv)
490 V_VT(retv) = VT_NULL;
491 return S_OK;
492 }
493
494 hres = create_array(dispex->ctx, match_cnt, &array);
495 if(FAILED(hres))
496 return hres;
497
498 V_VT(&var) = VT_BSTR;
499
500 for(i=0; i < match_cnt; i++) {
501 V_BSTR(&var) = SysAllocStringLen(match_result[i].str, match_result[i].len);
502 if(!V_BSTR(&var)) {
503 hres = E_OUTOFMEMORY;
504 break;
505 }
506
507 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, NULL/*FIXME*/);
508 SysFreeString(V_BSTR(&var));
509 if(FAILED(hres))
510 break;
511 }
512
513 if(SUCCEEDED(hres) && retv) {
514 V_VT(retv) = VT_DISPATCH;
515 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
516 }else {
517 jsdisp_release(array);
518 }
519 return hres;
520 }
521
522 typedef struct {
523 WCHAR *buf;
524 DWORD size;
525 DWORD len;
526 } strbuf_t;
527
528 static HRESULT strbuf_append(strbuf_t *buf, const WCHAR *str, DWORD len)
529 {
530 if(!len)
531 return S_OK;
532
533 if(len + buf->len > buf->size) {
534 WCHAR *new_buf;
535 DWORD new_size;
536
537 new_size = buf->size ? buf->size<<1 : 16;
538 if(new_size < buf->len+len)
539 new_size = buf->len+len;
540 if(buf->buf)
541 new_buf = heap_realloc(buf->buf, new_size*sizeof(WCHAR));
542 else
543 new_buf = heap_alloc(new_size*sizeof(WCHAR));
544 if(!new_buf)
545 return E_OUTOFMEMORY;
546
547 buf->buf = new_buf;
548 buf->size = new_size;
549 }
550
551 memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR));
552 buf->len += len;
553 return S_OK;
554 }
555
556 static HRESULT rep_call(DispatchEx *func, const WCHAR *str, match_result_t *match, match_result_t *parens,
557 DWORD parens_cnt, LCID lcid, BSTR *ret, jsexcept_t *ei, IServiceProvider *caller)
558 {
559 DISPPARAMS dp = {NULL, NULL, 0, 0};
560 VARIANTARG *args, *arg;
561 VARIANT var;
562 DWORD i;
563 HRESULT hres = S_OK;
564
565 dp.cArgs = parens_cnt+3;
566 dp.rgvarg = args = heap_alloc_zero(sizeof(VARIANT)*dp.cArgs);
567 if(!args)
568 return E_OUTOFMEMORY;
569
570 arg = get_arg(&dp,0);
571 V_VT(arg) = VT_BSTR;
572 V_BSTR(arg) = SysAllocStringLen(match->str, match->len);
573 if(!V_BSTR(arg))
574 hres = E_OUTOFMEMORY;
575
576 if(SUCCEEDED(hres)) {
577 for(i=0; i < parens_cnt; i++) {
578 arg = get_arg(&dp,i+1);
579 V_VT(arg) = VT_BSTR;
580 V_BSTR(arg) = SysAllocStringLen(parens[i].str, parens[i].len);
581 if(!V_BSTR(arg)) {
582 hres = E_OUTOFMEMORY;
583 break;
584 }
585 }
586 }
587
588 if(SUCCEEDED(hres)) {
589 arg = get_arg(&dp,parens_cnt+1);
590 V_VT(arg) = VT_I4;
591 V_I4(arg) = match->str - str;
592
593 arg = get_arg(&dp,parens_cnt+2);
594 V_VT(arg) = VT_BSTR;
595 V_BSTR(arg) = SysAllocString(str);
596 if(!V_BSTR(arg))
597 hres = E_OUTOFMEMORY;
598 }
599
600 if(SUCCEEDED(hres))
601 hres = jsdisp_call_value(func, lcid, DISPATCH_METHOD, &dp, &var, ei, caller);
602
603 for(i=0; i < parens_cnt+1; i++) {
604 if(i != parens_cnt+1)
605 SysFreeString(V_BSTR(get_arg(&dp,i)));
606 }
607 heap_free(args);
608
609 if(FAILED(hres))
610 return hres;
611
612 hres = to_string(func->ctx, &var, ei, ret);
613 VariantClear(&var);
614 return hres;
615 }
616
617 /* ECMA-262 3rd Edition 15.5.4.11 */
618 static HRESULT String_replace(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
619 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
620 {
621 DWORD parens_cnt = 0, parens_size=0, rep_len=0, length;
622 BSTR rep_str = NULL, match_str = NULL, ret_str;
623 DispatchEx *rep_func = NULL, *regexp = NULL;
624 match_result_t *parens = NULL, match;
625 const WCHAR *str;
626 strbuf_t ret = {NULL,0,0};
627 BOOL gcheck = FALSE;
628 VARIANT *arg_var;
629 HRESULT hres = S_OK;
630
631 TRACE("\n");
632
633 if(is_class(dispex, JSCLASS_STRING)) {
634 StringInstance *string = (StringInstance*)dispex;
635 str = string->str;
636 length = string->length;
637 }else {
638 FIXME("not String this\n");
639 return E_NOTIMPL;
640 }
641
642 if(!arg_cnt(dp)) {
643 if(retv) {
644 ret_str = SysAllocString(str);
645 if(!ret_str)
646 return E_OUTOFMEMORY;
647
648 V_VT(retv) = VT_BSTR;
649 V_BSTR(retv) = ret_str;
650 }
651 return S_OK;
652 }
653
654 arg_var = get_arg(dp, 0);
655 switch(V_VT(arg_var)) {
656 case VT_DISPATCH:
657 regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
658 if(regexp) {
659 if(is_class(regexp, JSCLASS_REGEXP)) {
660 break;
661 }else {
662 jsdisp_release(regexp);
663 regexp = NULL;
664 }
665 }
666
667 default:
668 hres = to_string(dispex->ctx, arg_var, ei, &match_str);
669 if(FAILED(hres))
670 return hres;
671 }
672
673 if(arg_cnt(dp) >= 2) {
674 arg_var = get_arg(dp,1);
675 switch(V_VT(arg_var)) {
676 case VT_DISPATCH:
677 rep_func = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var));
678 if(rep_func) {
679 if(is_class(rep_func, JSCLASS_FUNCTION)) {
680 break;
681 }else {
682 jsdisp_release(rep_func);
683 rep_func = NULL;
684 }
685 }
686
687 default:
688 hres = to_string(dispex->ctx, arg_var, ei, &rep_str);
689 if(FAILED(hres))
690 break;
691
692 if(strchrW(rep_str, '$')) {
693 FIXME("unsupported $ in replace string\n");
694 hres = E_NOTIMPL;
695 }
696
697 rep_len = SysStringLen(rep_str);
698 }
699 }
700
701 if(SUCCEEDED(hres)) {
702 const WCHAR *cp, *ecp;
703
704 cp = ecp = str;
705
706 while(1) {
707 if(regexp) {
708 hres = regexp_match_next(regexp, gcheck, str, length, &cp, rep_func ? &parens : NULL,
709 &parens_size, &parens_cnt, &match);
710 gcheck = TRUE;
711
712 if(hres == S_FALSE) {
713 hres = S_OK;
714 break;
715 }
716 if(FAILED(hres))
717 break;
718 }else {
719 match.str = strstrW(cp, match_str);
720 if(!match.str)
721 break;
722 match.len = SysStringLen(match_str);
723 cp = match.str+match.len;
724 }
725
726 hres = strbuf_append(&ret, ecp, match.str-ecp);
727 ecp = match.str+match.len;
728 if(FAILED(hres))
729 break;
730
731 if(rep_func) {
732 BSTR cstr;
733
734 hres = rep_call(rep_func, str, &match, parens, parens_cnt, lcid, &cstr, ei, caller);
735 if(FAILED(hres))
736 break;
737
738 hres = strbuf_append(&ret, cstr, SysStringLen(cstr));
739 SysFreeString(cstr);
740 if(FAILED(hres))
741 break;
742 }else if(rep_str) {
743 hres = strbuf_append(&ret, rep_str, rep_len);
744 if(FAILED(hres))
745 break;
746 }else {
747 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d'};
748
749 hres = strbuf_append(&ret, undefinedW, sizeof(undefinedW)/sizeof(WCHAR));
750 if(FAILED(hres))
751 break;
752 }
753 }
754
755 if(SUCCEEDED(hres))
756 hres = strbuf_append(&ret, ecp, (str+length)-ecp);
757 }
758
759 if(rep_func)
760 jsdisp_release(rep_func);
761 if(regexp)
762 jsdisp_release(regexp);
763 SysFreeString(rep_str);
764 SysFreeString(match_str);
765 heap_free(parens);
766
767 if(SUCCEEDED(hres) && retv) {
768 ret_str = SysAllocStringLen(ret.buf, ret.len);
769 if(!ret_str)
770 return E_OUTOFMEMORY;
771
772 V_VT(retv) = VT_BSTR;
773 V_BSTR(retv) = ret_str;
774 TRACE("= %s\n", debugstr_w(ret_str));
775 }
776
777 heap_free(ret.buf);
778 return hres;
779 }
780
781 static HRESULT String_search(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
782 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
783 {
784 FIXME("\n");
785 return E_NOTIMPL;
786 }
787
788 /* ECMA-262 3rd Edition 15.5.4.13 */
789 static HRESULT String_slice(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
790 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
791 {
792 const WCHAR *str;
793 DWORD length;
794 INT start=0, end;
795 VARIANT v;
796 HRESULT hres;
797
798 TRACE("\n");
799
800 if(is_class(dispex, JSCLASS_STRING)) {
801 StringInstance *string = (StringInstance*)dispex;
802
803 str = string->str;
804 length = string->length;
805 }else {
806 FIXME("this is not a string class\n");
807 return E_NOTIMPL;
808 }
809
810 if(arg_cnt(dp)) {
811 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v);
812 if(FAILED(hres))
813 return hres;
814
815 if(V_VT(&v) == VT_I4) {
816 start = V_I4(&v);
817 if(start < 0) {
818 start = length + start;
819 if(start < 0)
820 start = 0;
821 }else if(start > length) {
822 start = length;
823 }
824 }else {
825 start = V_R8(&v) < 0.0 ? 0 : length;
826 }
827 }else {
828 start = 0;
829 }
830
831 if(arg_cnt(dp) >= 2) {
832 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v);
833 if(FAILED(hres))
834 return hres;
835
836 if(V_VT(&v) == VT_I4) {
837 end = V_I4(&v);
838 if(end < 0) {
839 end = length + end;
840 if(end < 0)
841 end = 0;
842 }else if(end > length) {
843 end = length;
844 }
845 }else {
846 end = V_R8(&v) < 0.0 ? 0 : length;
847 }
848 }else {
849 end = length;
850 }
851
852 if(end < start)
853 end = start;
854
855 if(retv) {
856 BSTR retstr = SysAllocStringLen(str+start, end-start);
857 if(!str)
858 return E_OUTOFMEMORY;
859
860 V_VT(retv) = VT_BSTR;
861 V_BSTR(retv) = retstr;
862 }
863 return S_OK;
864 }
865
866 static HRESULT String_small(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
867 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
868 {
869 static const WCHAR smalltagW[] = {'S','M','A','L','L',0};
870 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, smalltagW);
871 }
872
873 static HRESULT String_split(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
874 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
875 {
876 match_result_t *match_result = NULL;
877 DWORD match_cnt, i, match_len = 0;
878 StringInstance *string;
879 const WCHAR *ptr, *ptr2;
880 VARIANT *arg, var;
881 DispatchEx *array;
882 BSTR match_str = NULL;
883 HRESULT hres;
884
885 TRACE("\n");
886
887 if(!is_class(dispex, JSCLASS_STRING)) {
888 FIXME("not String this\n");
889 return E_NOTIMPL;
890 }
891
892 string = (StringInstance*)dispex;
893
894 if(arg_cnt(dp) != 1) {
895 FIXME("unsupported args\n");
896 return E_NOTIMPL;
897 }
898
899 arg = get_arg(dp, 0);
900 switch(V_VT(arg)) {
901 case VT_DISPATCH: {
902 DispatchEx *regexp;
903
904 regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg));
905 if(regexp) {
906 if(is_class(regexp, JSCLASS_REGEXP)) {
907 hres = regexp_match(regexp, string->str, string->length, TRUE, &match_result, &match_cnt);
908 jsdisp_release(regexp);
909 if(FAILED(hres))
910 return hres;
911 break;
912 }
913 jsdisp_release(regexp);
914 }
915 }
916 default:
917 hres = to_string(dispex->ctx, arg, ei, &match_str);
918 if(FAILED(hres))
919 return hres;
920
921 match_len = SysStringLen(match_str);
922 if(!match_len) {
923 SysFreeString(match_str);
924 match_str = NULL;
925 }
926 }
927
928 hres = create_array(dispex->ctx, 0, &array);
929
930 if(SUCCEEDED(hres)) {
931 ptr = string->str;
932 for(i=0;; i++) {
933 if(match_result) {
934 if(i == match_cnt)
935 break;
936 ptr2 = match_result[i].str;
937 }else if(match_str) {
938 ptr2 = strstrW(ptr, match_str);
939 if(!ptr2)
940 break;
941 }else {
942 if(!*ptr)
943 break;
944 ptr2 = ptr+1;
945 }
946
947 V_VT(&var) = VT_BSTR;
948 V_BSTR(&var) = SysAllocStringLen(ptr, ptr2-ptr);
949 if(!V_BSTR(&var)) {
950 hres = E_OUTOFMEMORY;
951 break;
952 }
953
954 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
955 SysFreeString(V_BSTR(&var));
956 if(FAILED(hres))
957 break;
958
959 if(match_result)
960 ptr = match_result[i].str + match_result[i].len;
961 else if(match_str)
962 ptr = ptr2 + match_len;
963 else
964 ptr++;
965 }
966 }
967
968 if(SUCCEEDED(hres) && (match_str || match_result)) {
969 DWORD len = (string->str+string->length) - ptr;
970
971 if(len || match_str) {
972 V_VT(&var) = VT_BSTR;
973 V_BSTR(&var) = SysAllocStringLen(ptr, len);
974
975 if(V_BSTR(&var)) {
976 hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp);
977 SysFreeString(V_BSTR(&var));
978 }else {
979 hres = E_OUTOFMEMORY;
980 }
981 }
982 }
983
984 SysFreeString(match_str);
985 heap_free(match_result);
986
987 if(SUCCEEDED(hres) && retv) {
988 V_VT(retv) = VT_DISPATCH;
989 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array);
990 }else {
991 jsdisp_release(array);
992 }
993
994 return hres;
995 }
996
997 static HRESULT String_strike(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
998 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
999 {
1000 static const WCHAR striketagW[] = {'S','T','R','I','K','E',0};
1001 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, striketagW);
1002 }
1003
1004 static HRESULT String_sub(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1005 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1006 {
1007 static const WCHAR subtagW[] = {'S','U','B',0};
1008 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, subtagW);
1009 }
1010
1011 /* ECMA-262 3rd Edition 15.5.4.15 */
1012 static HRESULT String_substring(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1013 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1014 {
1015 const WCHAR *str;
1016 INT start=0, end;
1017 DWORD length;
1018 VARIANT v;
1019 HRESULT hres;
1020
1021 TRACE("\n");
1022
1023 if(is_class(dispex, JSCLASS_STRING)) {
1024 StringInstance *string = (StringInstance*)dispex;
1025
1026 length = string->length;
1027 str = string->str;
1028 }else {
1029 FIXME("not string this not supported\n");
1030 return E_NOTIMPL;
1031 }
1032
1033 if(arg_cnt(dp) >= 1) {
1034 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v);
1035 if(FAILED(hres))
1036 return hres;
1037
1038 if(V_VT(&v) == VT_I4) {
1039 start = V_I4(&v);
1040 if(start < 0)
1041 start = 0;
1042 else if(start >= length)
1043 start = length;
1044 }else {
1045 start = V_R8(&v) < 0.0 ? 0 : length;
1046 }
1047 }
1048
1049 if(arg_cnt(dp) >= 2) {
1050 hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v);
1051 if(FAILED(hres))
1052 return hres;
1053
1054 if(V_VT(&v) == VT_I4) {
1055 end = V_I4(&v);
1056 if(end < 0)
1057 end = 0;
1058 else if(end > length)
1059 end = length;
1060 }else {
1061 end = V_R8(&v) < 0.0 ? 0 : length;
1062 }
1063 }else {
1064 end = length;
1065 }
1066
1067 if(start > end) {
1068 INT tmp = start;
1069 start = end;
1070 end = tmp;
1071 }
1072
1073 if(retv) {
1074 V_VT(retv) = VT_BSTR;
1075 V_BSTR(retv) = SysAllocStringLen(str+start, end-start);
1076 if(!V_BSTR(retv))
1077 return E_OUTOFMEMORY;
1078 }
1079 return S_OK;
1080 }
1081
1082 static HRESULT String_substr(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1083 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1084 {
1085 FIXME("\n");
1086 return E_NOTIMPL;
1087 }
1088
1089 static HRESULT String_sup(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1090 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1091 {
1092 static const WCHAR suptagW[] = {'S','U','P',0};
1093 return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, suptagW);
1094 }
1095
1096 static HRESULT String_toLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1097 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1098 {
1099 StringInstance *string;
1100 const WCHAR* str;
1101 DWORD length;
1102 BSTR bstr;
1103
1104 TRACE("\n");
1105
1106 if(is_class(dispex, JSCLASS_STRING)) {
1107 string = (StringInstance*)dispex;
1108
1109 length = string->length;
1110 str = string->str;
1111 }else {
1112 FIXME("not string this not supported\n");
1113 return E_NOTIMPL;
1114 }
1115
1116 if(retv) {
1117 bstr = SysAllocStringLen(str, length);
1118 if (!bstr)
1119 return E_OUTOFMEMORY;
1120
1121 strlwrW(bstr);
1122
1123 V_VT(retv) = VT_BSTR;
1124 V_BSTR(retv) = bstr;
1125 }
1126 return S_OK;
1127 }
1128
1129 static HRESULT String_toUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1130 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1131 {
1132 StringInstance *string;
1133 const WCHAR* str;
1134 DWORD length;
1135 BSTR bstr;
1136
1137 TRACE("\n");
1138
1139 if(is_class(dispex, JSCLASS_STRING)) {
1140 string = (StringInstance*)dispex;
1141
1142 length = string->length;
1143 str = string->str;
1144 }else {
1145 FIXME("not string this not supported\n");
1146 return E_NOTIMPL;
1147 }
1148
1149 if(retv) {
1150 bstr = SysAllocStringLen(str, length);
1151 if (!bstr)
1152 return E_OUTOFMEMORY;
1153
1154 struprW(bstr);
1155
1156 V_VT(retv) = VT_BSTR;
1157 V_BSTR(retv) = bstr;
1158 }
1159 return S_OK;
1160 }
1161
1162 static HRESULT String_toLocaleLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1163 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1164 {
1165 FIXME("\n");
1166 return E_NOTIMPL;
1167 }
1168
1169 static HRESULT String_toLocaleUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1170 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1171 {
1172 FIXME("\n");
1173 return E_NOTIMPL;
1174 }
1175
1176 static HRESULT String_localeCompare(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1177 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1178 {
1179 FIXME("\n");
1180 return E_NOTIMPL;
1181 }
1182
1183 static HRESULT String_hasOwnProperty(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1184 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1185 {
1186 FIXME("\n");
1187 return E_NOTIMPL;
1188 }
1189
1190 static HRESULT String_propertyIsEnumerable(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1191 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1192 {
1193 FIXME("\n");
1194 return E_NOTIMPL;
1195 }
1196
1197 static HRESULT String_isPrototypeOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1198 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1199 {
1200 FIXME("\n");
1201 return E_NOTIMPL;
1202 }
1203
1204 static HRESULT String_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1205 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1206 {
1207 StringInstance *This = (StringInstance*)dispex;
1208
1209 TRACE("\n");
1210
1211 switch(flags) {
1212 case DISPATCH_PROPERTYGET: {
1213 BSTR str = SysAllocString(This->str);
1214 if(!str)
1215 return E_OUTOFMEMORY;
1216
1217 V_VT(retv) = VT_BSTR;
1218 V_BSTR(retv) = str;
1219 break;
1220 }
1221 default:
1222 FIXME("flags %x\n", flags);
1223 return E_NOTIMPL;
1224 }
1225
1226 return S_OK;
1227 }
1228
1229 static void String_destructor(DispatchEx *dispex)
1230 {
1231 StringInstance *This = (StringInstance*)dispex;
1232
1233 heap_free(This->str);
1234 heap_free(This);
1235 }
1236
1237 static const builtin_prop_t String_props[] = {
1238 {anchorW, String_anchor, PROPF_METHOD},
1239 {bigW, String_big, PROPF_METHOD},
1240 {blinkW, String_blink, PROPF_METHOD},
1241 {boldW, String_bold, PROPF_METHOD},
1242 {charAtW, String_charAt, PROPF_METHOD},
1243 {charCodeAtW, String_charCodeAt, PROPF_METHOD},
1244 {concatW, String_concat, PROPF_METHOD},
1245 {fixedW, String_fixed, PROPF_METHOD},
1246 {fontcolorW, String_fontcolor, PROPF_METHOD},
1247 {fontsizeW, String_fontsize, PROPF_METHOD},
1248 {hasOwnPropertyW, String_hasOwnProperty, PROPF_METHOD},
1249 {indexOfW, String_indexOf, PROPF_METHOD},
1250 {isPrototypeOfW, String_isPrototypeOf, PROPF_METHOD},
1251 {italicsW, String_italics, PROPF_METHOD},
1252 {lastIndexOfW, String_lastIndexOf, PROPF_METHOD},
1253 {lengthW, String_length, 0},
1254 {linkW, String_link, PROPF_METHOD},
1255 {localeCompareW, String_localeCompare, PROPF_METHOD},
1256 {matchW, String_match, PROPF_METHOD},
1257 {propertyIsEnumerableW, String_propertyIsEnumerable, PROPF_METHOD},
1258 {replaceW, String_replace, PROPF_METHOD},
1259 {searchW, String_search, PROPF_METHOD},
1260 {sliceW, String_slice, PROPF_METHOD},
1261 {smallW, String_small, PROPF_METHOD},
1262 {splitW, String_split, PROPF_METHOD},
1263 {strikeW, String_strike, PROPF_METHOD},
1264 {subW, String_sub, PROPF_METHOD},
1265 {substrW, String_substr, PROPF_METHOD},
1266 {substringW, String_substring, PROPF_METHOD},
1267 {supW, String_sup, PROPF_METHOD},
1268 {toLocaleLowerCaseW, String_toLocaleLowerCase, PROPF_METHOD},
1269 {toLocaleUpperCaseW, String_toLocaleUpperCase, PROPF_METHOD},
1270 {toLowerCaseW, String_toLowerCase, PROPF_METHOD},
1271 {toStringW, String_toString, PROPF_METHOD},
1272 {toUpperCaseW, String_toUpperCase, PROPF_METHOD},
1273 {valueOfW, String_valueOf, PROPF_METHOD}
1274 };
1275
1276 static const builtin_info_t String_info = {
1277 JSCLASS_STRING,
1278 {NULL, String_value, 0},
1279 sizeof(String_props)/sizeof(*String_props),
1280 String_props,
1281 String_destructor,
1282 NULL
1283 };
1284
1285 static HRESULT StringConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
1286 VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
1287 {
1288 HRESULT hres;
1289
1290 TRACE("\n");
1291
1292 switch(flags) {
1293 case INVOKE_FUNC: {
1294 BSTR str;
1295
1296 if(arg_cnt(dp)) {
1297 hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1298 if(FAILED(hres))
1299 return hres;
1300 }else {
1301 str = SysAllocStringLen(NULL, 0);
1302 if(!str)
1303 return E_OUTOFMEMORY;
1304 }
1305
1306 V_VT(retv) = VT_BSTR;
1307 V_BSTR(retv) = str;
1308 break;
1309 }
1310 case DISPATCH_CONSTRUCT: {
1311 DispatchEx *ret;
1312
1313 if(arg_cnt(dp)) {
1314 BSTR str;
1315
1316 hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str);
1317 if(FAILED(hres))
1318 return hres;
1319
1320 hres = create_string(dispex->ctx, str, SysStringLen(str), &ret);
1321 SysFreeString(str);
1322 }else {
1323 hres = create_string(dispex->ctx, NULL, 0, &ret);
1324 }
1325
1326 if(FAILED(hres))
1327 return hres;
1328
1329 V_VT(retv) = VT_DISPATCH;
1330 V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(ret);
1331 break;
1332 }
1333
1334 default:
1335 FIXME("unimplemented flags: %x\n", flags);
1336 return E_NOTIMPL;
1337 }
1338
1339 return S_OK;
1340 }
1341
1342 static HRESULT string_alloc(script_ctx_t *ctx, BOOL use_constr, StringInstance **ret)
1343 {
1344 StringInstance *string;
1345 HRESULT hres;
1346
1347 string = heap_alloc_zero(sizeof(StringInstance));
1348 if(!string)
1349 return E_OUTOFMEMORY;
1350
1351 if(use_constr)
1352 hres = init_dispex_from_constr(&string->dispex, ctx, &String_info, ctx->string_constr);
1353 else
1354 hres = init_dispex(&string->dispex, ctx, &String_info, NULL);
1355 if(FAILED(hres)) {
1356 heap_free(string);
1357 return hres;
1358 }
1359
1360 *ret = string;
1361 return S_OK;
1362 }
1363
1364 HRESULT create_string_constr(script_ctx_t *ctx, DispatchEx **ret)
1365 {
1366 StringInstance *string;
1367 HRESULT hres;
1368
1369 hres = string_alloc(ctx, FALSE, &string);
1370 if(FAILED(hres))
1371 return hres;
1372
1373 hres = create_builtin_function(ctx, StringConstr_value, PROPF_CONSTR, &string->dispex, ret);
1374
1375 jsdisp_release(&string->dispex);
1376 return hres;
1377 }
1378
1379 HRESULT create_string(script_ctx_t *ctx, const WCHAR *str, DWORD len, DispatchEx **ret)
1380 {
1381 StringInstance *string;
1382 HRESULT hres;
1383
1384 hres = string_alloc(ctx, TRUE, &string);
1385 if(FAILED(hres))
1386 return hres;
1387
1388 if(len == -1)
1389 len = strlenW(str);
1390
1391 string->length = len;
1392 string->str = heap_alloc((len+1)*sizeof(WCHAR));
1393 if(!string->str) {
1394 jsdisp_release(&string->dispex);
1395 return E_OUTOFMEMORY;
1396 }
1397
1398 memcpy(string->str, str, len*sizeof(WCHAR));
1399 string->str[len] = 0;
1400
1401 *ret = &string->dispex;
1402 return S_OK;
1403
1404 }
Windows API implementation