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