2 * Copyright 2008 Jacek Caban for CodeWeavers
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.
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.
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
24 #include "wine/debug.h"
26 WINE_DEFAULT_DEBUG_CHANNEL(jscript
);
34 jsval_t last_index_val
;
37 static const WCHAR sourceW
[] = {'s','o','u','r','c','e',0};
38 static const WCHAR globalW
[] = {'g','l','o','b','a','l',0};
39 static const WCHAR ignoreCaseW
[] = {'i','g','n','o','r','e','C','a','s','e',0};
40 static const WCHAR multilineW
[] = {'m','u','l','t','i','l','i','n','e',0};
41 static const WCHAR lastIndexW
[] = {'l','a','s','t','I','n','d','e','x',0};
42 static const WCHAR toStringW
[] = {'t','o','S','t','r','i','n','g',0};
43 static const WCHAR execW
[] = {'e','x','e','c',0};
44 static const WCHAR testW
[] = {'t','e','s','t',0};
46 static const WCHAR leftContextW
[] =
47 {'l','e','f','t','C','o','n','t','e','x','t',0};
48 static const WCHAR rightContextW
[] =
49 {'r','i','g','h','t','C','o','n','t','e','x','t',0};
51 static const WCHAR idx1W
[] = {'$','1',0};
52 static const WCHAR idx2W
[] = {'$','2',0};
53 static const WCHAR idx3W
[] = {'$','3',0};
54 static const WCHAR idx4W
[] = {'$','4',0};
55 static const WCHAR idx5W
[] = {'$','5',0};
56 static const WCHAR idx6W
[] = {'$','6',0};
57 static const WCHAR idx7W
[] = {'$','7',0};
58 static const WCHAR idx8W
[] = {'$','8',0};
59 static const WCHAR idx9W
[] = {'$','9',0};
61 static inline RegExpInstance
*regexp_from_vdisp(vdisp_t
*vdisp
)
63 return (RegExpInstance
*)vdisp
->u
.jsdisp
;
66 static void set_last_index(RegExpInstance
*This
, DWORD last_index
)
68 This
->last_index
= last_index
;
69 jsval_release(This
->last_index_val
);
70 This
->last_index_val
= jsval_number(last_index
);
73 static HRESULT
do_regexp_match_next(script_ctx_t
*ctx
, RegExpInstance
*regexp
,
74 DWORD rem_flags
, jsstr_t
*jsstr
, const WCHAR
*str
, match_state_t
*ret
)
78 hres
= regexp_execute(regexp
->jsregexp
, ctx
, &ctx
->tmp_heap
,
79 str
, jsstr_length(jsstr
), ret
);
83 if(rem_flags
& REM_RESET_INDEX
)
84 set_last_index(regexp
, 0);
88 if(!(rem_flags
& REM_NO_CTX_UPDATE
) && ctx
->last_match
!= jsstr
) {
89 jsstr_release(ctx
->last_match
);
90 ctx
->last_match
= jsstr_addref(jsstr
);
93 if(!(rem_flags
& REM_NO_CTX_UPDATE
)) {
94 DWORD i
, n
= min(sizeof(ctx
->match_parens
)/sizeof(ctx
->match_parens
[0]), ret
->paren_count
);
96 for(i
=0; i
< n
; i
++) {
97 if(ret
->parens
[i
].index
== -1) {
98 ctx
->match_parens
[i
].index
= 0;
99 ctx
->match_parens
[i
].length
= 0;
101 ctx
->match_parens
[i
].index
= ret
->parens
[i
].index
;
102 ctx
->match_parens
[i
].length
= ret
->parens
[i
].length
;
106 if(n
< sizeof(ctx
->match_parens
)/sizeof(ctx
->match_parens
[0]))
107 memset(ctx
->match_parens
+n
, 0, sizeof(ctx
->match_parens
) - n
*sizeof(ctx
->match_parens
[0]));
110 set_last_index(regexp
, ret
->cp
-str
);
112 if(!(rem_flags
& REM_NO_CTX_UPDATE
)) {
113 ctx
->last_match_index
= ret
->cp
-str
-ret
->match_len
;
114 ctx
->last_match_length
= ret
->match_len
;
120 HRESULT
regexp_match_next(script_ctx_t
*ctx
, jsdisp_t
*dispex
,
121 DWORD rem_flags
, jsstr_t
*jsstr
, match_state_t
**ret
)
123 RegExpInstance
*regexp
= (RegExpInstance
*)dispex
;
124 match_state_t
*match
;
129 if((rem_flags
& REM_CHECK_GLOBAL
) && !(regexp
->jsregexp
->flags
& REG_GLOB
)) {
130 if(rem_flags
& REM_ALLOC_RESULT
)
135 str
= jsstr_flatten(jsstr
);
137 return E_OUTOFMEMORY
;
139 if(rem_flags
& REM_ALLOC_RESULT
) {
140 match
= alloc_match_state(regexp
->jsregexp
, NULL
, str
);
142 return E_OUTOFMEMORY
;
146 mark
= heap_pool_mark(&ctx
->tmp_heap
);
148 if(rem_flags
& REM_NO_PARENS
) {
149 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, NULL
);
151 heap_pool_clear(mark
);
152 return E_OUTOFMEMORY
;
154 match
->cp
= (*ret
)->cp
;
155 match
->match_len
= (*ret
)->match_len
;
160 hres
= do_regexp_match_next(ctx
, regexp
, rem_flags
, jsstr
, str
, match
);
162 if(rem_flags
& REM_NO_PARENS
) {
163 (*ret
)->cp
= match
->cp
;
164 (*ret
)->match_len
= match
->match_len
;
167 heap_pool_clear(mark
);
169 if(hres
!= S_OK
&& (rem_flags
& REM_ALLOC_RESULT
)) {
177 static HRESULT
regexp_match(script_ctx_t
*ctx
, jsdisp_t
*dispex
, jsstr_t
*jsstr
, BOOL gflag
,
178 match_result_t
**match_result
, DWORD
*result_cnt
)
180 RegExpInstance
*This
= (RegExpInstance
*)dispex
;
181 match_result_t
*ret
= NULL
;
182 match_state_t
*result
;
183 DWORD i
=0, ret_size
= 0;
188 mark
= heap_pool_mark(&ctx
->tmp_heap
);
190 str
= jsstr_flatten(jsstr
);
192 return E_OUTOFMEMORY
;
194 result
= alloc_match_state(This
->jsregexp
, &ctx
->tmp_heap
, str
);
196 heap_pool_clear(mark
);
197 return E_OUTOFMEMORY
;
201 hres
= do_regexp_match_next(ctx
, This
, 0, jsstr
, str
, result
);
202 if(hres
== S_FALSE
) {
212 match_result_t
*old_ret
= ret
;
214 ret
= heap_realloc(old_ret
, (ret_size
<<= 1) * sizeof(match_result_t
));
218 ret
= heap_alloc((ret_size
=4) * sizeof(match_result_t
));
221 hres
= E_OUTOFMEMORY
;
226 ret
[i
].index
= result
->cp
- str
- result
->match_len
;
227 ret
[i
++].length
= result
->match_len
;
229 if(!gflag
&& !(This
->jsregexp
->flags
& REG_GLOB
)) {
235 heap_pool_clear(mark
);
246 static HRESULT
RegExp_source(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
252 case DISPATCH_PROPERTYGET
: {
253 RegExpInstance
*This
= regexp_from_vdisp(jsthis
);
254 *r
= jsval_string(jsstr_addref(This
->str
));
258 FIXME("Unimplemented flags %x\n", flags
);
265 static HRESULT
RegExp_global(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
272 static HRESULT
RegExp_ignoreCase(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
279 static HRESULT
RegExp_multiline(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
286 static INT
index_from_val(script_ctx_t
*ctx
, jsval_t v
)
291 hres
= to_number(ctx
, v
, &n
);
293 clear_ei(ctx
); /* FIXME: Move ignoring exceptions to to_primitive */
298 return is_int32(n
) ? n
: 0;
301 static HRESULT
RegExp_lastIndex(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
307 case DISPATCH_PROPERTYGET
: {
308 RegExpInstance
*regexp
= regexp_from_vdisp(jsthis
);
310 return jsval_copy(regexp
->last_index_val
, r
);
312 case DISPATCH_PROPERTYPUT
: {
313 RegExpInstance
*regexp
= regexp_from_vdisp(jsthis
);
316 hres
= jsval_copy(argv
[0], ®exp
->last_index_val
);
320 regexp
->last_index
= index_from_val(ctx
, argv
[0]);
324 FIXME("unimplemented flags: %x\n", flags
);
331 static HRESULT
RegExp_toString(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
334 RegExpInstance
*regexp
;
341 if(!is_vclass(jsthis
, JSCLASS_REGEXP
)) {
342 FIXME("Not a RegExp\n");
346 regexp
= regexp_from_vdisp(jsthis
);
351 len
= jsstr_length(regexp
->str
) + 2;
353 f
= regexp
->jsregexp
->flags
;
358 if(f
& REG_MULTILINE
)
361 ptr
= jsstr_alloc_buf(len
, &ret
);
363 return E_OUTOFMEMORY
;
366 ptr
+= jsstr_flush(regexp
->str
, ptr
);
373 if(f
& REG_MULTILINE
)
376 *r
= jsval_string(ret
);
380 static HRESULT
create_match_array(script_ctx_t
*ctx
, jsstr_t
*input_str
,
381 const match_state_t
*result
, IDispatch
**ret
)
389 static const WCHAR indexW
[] = {'i','n','d','e','x',0};
390 static const WCHAR inputW
[] = {'i','n','p','u','t',0};
391 static const WCHAR lastIndexW
[] = {'l','a','s','t','I','n','d','e','x',0};
392 static const WCHAR zeroW
[] = {'0',0};
394 input
= jsstr_flatten(input_str
);
396 return E_OUTOFMEMORY
;
398 hres
= create_array(ctx
, result
->paren_count
+1, &array
);
402 for(i
=0; i
< result
->paren_count
; i
++) {
403 if(result
->parens
[i
].index
!= -1)
404 str
= jsstr_substr(input_str
, result
->parens
[i
].index
, result
->parens
[i
].length
);
408 hres
= E_OUTOFMEMORY
;
412 hres
= jsdisp_propput_idx(array
, i
+1, jsval_string(str
));
418 while(SUCCEEDED(hres
)) {
419 hres
= jsdisp_propput_name(array
, indexW
, jsval_number(result
->cp
-input
-result
->match_len
));
423 hres
= jsdisp_propput_name(array
, lastIndexW
, jsval_number(result
->cp
-input
));
427 hres
= jsdisp_propput_name(array
, inputW
, jsval_string(jsstr_addref(input_str
)));
431 str
= jsstr_alloc_len(result
->cp
-result
->match_len
, result
->match_len
);
433 hres
= E_OUTOFMEMORY
;
436 hres
= jsdisp_propput_name(array
, zeroW
, jsval_string(str
));
442 jsdisp_release(array
);
446 *ret
= to_disp(array
);
450 static HRESULT
run_exec(script_ctx_t
*ctx
, vdisp_t
*jsthis
, jsval_t arg
,
451 jsstr_t
**input
, match_state_t
**result
, BOOL
*ret
)
453 RegExpInstance
*regexp
;
454 match_state_t
*match
;
455 DWORD last_index
= 0;
460 if(!is_vclass(jsthis
, JSCLASS_REGEXP
)) {
461 FIXME("Not a RegExp\n");
465 regexp
= regexp_from_vdisp(jsthis
);
467 hres
= to_flat_string(ctx
, arg
, &jsstr
, &string
);
471 if(regexp
->jsregexp
->flags
& REG_GLOB
) {
472 if(regexp
->last_index
< 0) {
473 jsstr_release(jsstr
);
474 set_last_index(regexp
, 0);
477 *input
= jsstr_empty();
481 last_index
= regexp
->last_index
;
484 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, string
+last_index
);
486 jsstr_release(jsstr
);
487 return E_OUTOFMEMORY
;
490 hres
= regexp_match_next(ctx
, ®exp
->dispex
, REM_RESET_INDEX
, jsstr
, &match
);
492 jsstr_release(jsstr
);
501 jsstr_release(jsstr
);
505 static HRESULT
RegExp_exec(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
508 match_state_t
*match
;
516 mark
= heap_pool_mark(&ctx
->tmp_heap
);
518 hres
= run_exec(ctx
, jsthis
, argc
? argv
[0] : jsval_string(jsstr_empty()), &string
, &match
, &b
);
520 heap_pool_clear(mark
);
528 hres
= create_match_array(ctx
, string
, match
, &ret
);
530 *r
= jsval_disp(ret
);
536 heap_pool_clear(mark
);
537 jsstr_release(string
);
541 static HRESULT
RegExp_test(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
544 match_state_t
*match
;
552 mark
= heap_pool_mark(&ctx
->tmp_heap
);
553 hres
= run_exec(ctx
, jsthis
, argc
? argv
[0] : jsval_string(undef_str
= jsstr_undefined()), NULL
, &match
, &b
);
554 heap_pool_clear(mark
);
556 jsstr_release(undef_str
);
565 static HRESULT
RegExp_value(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
572 return throw_type_error(ctx
, JS_E_FUNCTION_EXPECTED
, NULL
);
574 FIXME("unimplemented flags %x\n", flags
);
581 static void RegExp_destructor(jsdisp_t
*dispex
)
583 RegExpInstance
*This
= (RegExpInstance
*)dispex
;
586 regexp_destroy(This
->jsregexp
);
587 jsval_release(This
->last_index_val
);
588 jsstr_release(This
->str
);
592 static const builtin_prop_t RegExp_props
[] = {
593 {execW
, RegExp_exec
, PROPF_METHOD
|1},
594 {globalW
, RegExp_global
, 0},
595 {ignoreCaseW
, RegExp_ignoreCase
, 0},
596 {lastIndexW
, RegExp_lastIndex
, 0},
597 {multilineW
, RegExp_multiline
, 0},
598 {sourceW
, RegExp_source
, 0},
599 {testW
, RegExp_test
, PROPF_METHOD
|1},
600 {toStringW
, RegExp_toString
, PROPF_METHOD
}
603 static const builtin_info_t RegExp_info
= {
605 {NULL
, RegExp_value
, 0},
606 sizeof(RegExp_props
)/sizeof(*RegExp_props
),
612 static const builtin_prop_t RegExpInst_props
[] = {
613 {globalW
, RegExp_global
, 0},
614 {ignoreCaseW
, RegExp_ignoreCase
, 0},
615 {lastIndexW
, RegExp_lastIndex
, 0},
616 {multilineW
, RegExp_multiline
, 0},
617 {sourceW
, RegExp_source
, 0}
620 static const builtin_info_t RegExpInst_info
= {
622 {NULL
, RegExp_value
, 0},
623 sizeof(RegExpInst_props
)/sizeof(*RegExpInst_props
),
629 static HRESULT
alloc_regexp(script_ctx_t
*ctx
, jsdisp_t
*object_prototype
, RegExpInstance
**ret
)
631 RegExpInstance
*regexp
;
634 regexp
= heap_alloc_zero(sizeof(RegExpInstance
));
636 return E_OUTOFMEMORY
;
639 hres
= init_dispex(®exp
->dispex
, ctx
, &RegExp_info
, object_prototype
);
641 hres
= init_dispex_from_constr(®exp
->dispex
, ctx
, &RegExpInst_info
, ctx
->regexp_constr
);
652 HRESULT
create_regexp(script_ctx_t
*ctx
, jsstr_t
*src
, DWORD flags
, jsdisp_t
**ret
)
654 RegExpInstance
*regexp
;
658 TRACE("%s %x\n", debugstr_jsstr(src
), flags
);
660 str
= jsstr_flatten(src
);
662 return E_OUTOFMEMORY
;
664 hres
= alloc_regexp(ctx
, NULL
, ®exp
);
668 regexp
->str
= jsstr_addref(src
);
669 regexp
->last_index_val
= jsval_number(0);
671 regexp
->jsregexp
= regexp_new(ctx
, &ctx
->tmp_heap
, str
, jsstr_length(regexp
->str
), flags
, FALSE
);
672 if(!regexp
->jsregexp
) {
673 WARN("regexp_new failed\n");
674 jsdisp_release(®exp
->dispex
);
678 *ret
= ®exp
->dispex
;
682 HRESULT
create_regexp_var(script_ctx_t
*ctx
, jsval_t src_arg
, jsval_t
*flags_arg
, jsdisp_t
**ret
)
684 unsigned flags
, opt_len
= 0;
685 const WCHAR
*opt
= NULL
;
689 if(is_object_instance(src_arg
)) {
692 obj
= iface_to_jsdisp((IUnknown
*)get_object(src_arg
));
694 if(is_class(obj
, JSCLASS_REGEXP
)) {
695 RegExpInstance
*regexp
= (RegExpInstance
*)obj
;
697 hres
= create_regexp(ctx
, regexp
->str
, regexp
->jsregexp
->flags
, ret
);
706 if(!is_string(src_arg
)) {
707 FIXME("src_arg = %s\n", debugstr_jsval(src_arg
));
711 src
= get_string(src_arg
);
716 if(!is_string(*flags_arg
)) {
717 FIXME("unimplemented for %s\n", debugstr_jsval(*flags_arg
));
721 opt_str
= get_string(*flags_arg
);
722 opt
= jsstr_flatten(opt_str
);
724 return E_OUTOFMEMORY
;
725 opt_len
= jsstr_length(opt_str
);
728 hres
= parse_regexp_flags(opt
, opt_len
, &flags
);
732 return create_regexp(ctx
, src
, flags
, ret
);
735 HRESULT
regexp_string_match(script_ctx_t
*ctx
, jsdisp_t
*re
, jsstr_t
*jsstr
, jsval_t
*r
)
737 static const WCHAR indexW
[] = {'i','n','d','e','x',0};
738 static const WCHAR inputW
[] = {'i','n','p','u','t',0};
739 static const WCHAR lastIndexW
[] = {'l','a','s','t','I','n','d','e','x',0};
741 RegExpInstance
*regexp
= (RegExpInstance
*)re
;
742 match_result_t
*match_result
;
743 unsigned match_cnt
, i
;
748 str
= jsstr_flatten(jsstr
);
750 return E_OUTOFMEMORY
;
752 if(!(regexp
->jsregexp
->flags
& REG_GLOB
)) {
753 match_state_t
*match
;
756 mark
= heap_pool_mark(&ctx
->tmp_heap
);
757 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, str
);
759 heap_pool_clear(mark
);
760 return E_OUTOFMEMORY
;
763 hres
= regexp_match_next(ctx
, ®exp
->dispex
, 0, jsstr
, &match
);
765 heap_pool_clear(mark
);
773 hres
= create_match_array(ctx
, jsstr
, match
, &ret
);
775 *r
= jsval_disp(ret
);
781 heap_pool_clear(mark
);
785 hres
= regexp_match(ctx
, ®exp
->dispex
, jsstr
, FALSE
, &match_result
, &match_cnt
);
797 hres
= create_array(ctx
, match_cnt
, &array
);
801 for(i
=0; i
< match_cnt
; i
++) {
804 tmp_str
= jsstr_substr(jsstr
, match_result
[i
].index
, match_result
[i
].length
);
806 hres
= E_OUTOFMEMORY
;
810 hres
= jsdisp_propput_idx(array
, i
, jsval_string(tmp_str
));
811 jsstr_release(tmp_str
);
816 while(SUCCEEDED(hres
)) {
817 hres
= jsdisp_propput_name(array
, indexW
, jsval_number(match_result
[match_cnt
-1].index
));
821 hres
= jsdisp_propput_name(array
, lastIndexW
,
822 jsval_number(match_result
[match_cnt
-1].index
+ match_result
[match_cnt
-1].length
));
826 hres
= jsdisp_propput_name(array
, inputW
, jsval_string(jsstr
));
830 heap_free(match_result
);
832 if(SUCCEEDED(hres
) && r
)
833 *r
= jsval_obj(array
);
835 jsdisp_release(array
);
839 static HRESULT
global_idx(script_ctx_t
*ctx
, DWORD flags
, DWORD idx
, jsval_t
*r
)
842 case DISPATCH_PROPERTYGET
: {
845 ret
= jsstr_substr(ctx
->last_match
, ctx
->match_parens
[idx
].index
, ctx
->match_parens
[idx
].length
);
847 return E_OUTOFMEMORY
;
849 *r
= jsval_string(ret
);
852 case DISPATCH_PROPERTYPUT
:
855 FIXME("unsupported flags\n");
862 static HRESULT
RegExpConstr_idx1(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
863 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
866 return global_idx(ctx
, flags
, 0, r
);
869 static HRESULT
RegExpConstr_idx2(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
870 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
873 return global_idx(ctx
, flags
, 1, r
);
876 static HRESULT
RegExpConstr_idx3(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
877 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
880 return global_idx(ctx
, flags
, 2, r
);
883 static HRESULT
RegExpConstr_idx4(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
884 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
887 return global_idx(ctx
, flags
, 3, r
);
890 static HRESULT
RegExpConstr_idx5(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
891 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
894 return global_idx(ctx
, flags
, 4, r
);
897 static HRESULT
RegExpConstr_idx6(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
898 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
901 return global_idx(ctx
, flags
, 5, r
);
904 static HRESULT
RegExpConstr_idx7(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
905 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
908 return global_idx(ctx
, flags
, 6, r
);
911 static HRESULT
RegExpConstr_idx8(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
912 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
915 return global_idx(ctx
, flags
, 7, r
);
918 static HRESULT
RegExpConstr_idx9(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
919 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
922 return global_idx(ctx
, flags
, 8, r
);
925 static HRESULT
RegExpConstr_leftContext(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
926 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
931 case DISPATCH_PROPERTYGET
: {
934 ret
= jsstr_substr(ctx
->last_match
, 0, ctx
->last_match_index
);
936 return E_OUTOFMEMORY
;
938 *r
= jsval_string(ret
);
941 case DISPATCH_PROPERTYPUT
:
944 FIXME("unsupported flags\n");
951 static HRESULT
RegExpConstr_rightContext(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
,
952 unsigned argc
, jsval_t
*argv
, jsval_t
*r
)
957 case DISPATCH_PROPERTYGET
: {
960 ret
= jsstr_substr(ctx
->last_match
, ctx
->last_match_index
+ctx
->last_match_length
,
961 jsstr_length(ctx
->last_match
) - ctx
->last_match_index
- ctx
->last_match_length
);
963 return E_OUTOFMEMORY
;
965 *r
= jsval_string(ret
);
968 case DISPATCH_PROPERTYPUT
:
971 FIXME("unsupported flags\n");
978 static HRESULT
RegExpConstr_value(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
984 case DISPATCH_METHOD
:
986 if(is_object_instance(argv
[0])) {
987 jsdisp_t
*jsdisp
= iface_to_jsdisp((IUnknown
*)get_object(argv
[0]));
989 if(is_class(jsdisp
, JSCLASS_REGEXP
)) {
990 if(argc
> 1 && !is_undefined(argv
[1])) {
991 jsdisp_release(jsdisp
);
992 return throw_regexp_error(ctx
, JS_E_REGEXP_SYNTAX
, NULL
);
996 *r
= jsval_obj(jsdisp
);
998 jsdisp_release(jsdisp
);
1001 jsdisp_release(jsdisp
);
1006 case DISPATCH_CONSTRUCT
: {
1015 hres
= create_regexp_var(ctx
, argv
[0], argc
> 1 ? argv
+1 : NULL
, &ret
);
1020 *r
= jsval_obj(ret
);
1022 jsdisp_release(ret
);
1026 FIXME("unimplemented flags: %x\n", flags
);
1033 static const builtin_prop_t RegExpConstr_props
[] = {
1034 {idx1W
, RegExpConstr_idx1
, 0},
1035 {idx2W
, RegExpConstr_idx2
, 0},
1036 {idx3W
, RegExpConstr_idx3
, 0},
1037 {idx4W
, RegExpConstr_idx4
, 0},
1038 {idx5W
, RegExpConstr_idx5
, 0},
1039 {idx6W
, RegExpConstr_idx6
, 0},
1040 {idx7W
, RegExpConstr_idx7
, 0},
1041 {idx8W
, RegExpConstr_idx8
, 0},
1042 {idx9W
, RegExpConstr_idx9
, 0},
1043 {leftContextW
, RegExpConstr_leftContext
, 0},
1044 {rightContextW
, RegExpConstr_rightContext
, 0}
1047 static const builtin_info_t RegExpConstr_info
= {
1049 {NULL
, Function_value
, 0},
1050 sizeof(RegExpConstr_props
)/sizeof(*RegExpConstr_props
),
1056 HRESULT
create_regexp_constr(script_ctx_t
*ctx
, jsdisp_t
*object_prototype
, jsdisp_t
**ret
)
1058 RegExpInstance
*regexp
;
1061 static const WCHAR RegExpW
[] = {'R','e','g','E','x','p',0};
1063 hres
= alloc_regexp(ctx
, object_prototype
, ®exp
);
1067 hres
= create_builtin_constructor(ctx
, RegExpConstr_value
, RegExpW
, &RegExpConstr_info
,
1068 PROPF_CONSTR
|2, ®exp
->dispex
, ret
);
1070 jsdisp_release(®exp
->dispex
);
1074 HRESULT
parse_regexp_flags(const WCHAR
*str
, DWORD str_len
, DWORD
*ret
)
1079 for (p
= str
; p
< str
+str_len
; p
++) {
1088 flags
|= REG_MULTILINE
;
1091 flags
|= REG_STICKY
;
1094 WARN("wrong flag %c\n", *p
);