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_jsdisp(jsdisp_t
*jsdisp
)
63 return CONTAINING_RECORD(jsdisp
, RegExpInstance
, dispex
);
66 static inline RegExpInstance
*regexp_from_vdisp(vdisp_t
*vdisp
)
68 return regexp_from_jsdisp(vdisp
->u
.jsdisp
);
71 static void set_last_index(RegExpInstance
*This
, DWORD last_index
)
73 This
->last_index
= last_index
;
74 jsval_release(This
->last_index_val
);
75 This
->last_index_val
= jsval_number(last_index
);
78 static HRESULT
do_regexp_match_next(script_ctx_t
*ctx
, RegExpInstance
*regexp
,
79 DWORD rem_flags
, jsstr_t
*jsstr
, const WCHAR
*str
, match_state_t
*ret
)
83 hres
= regexp_execute(regexp
->jsregexp
, ctx
, &ctx
->tmp_heap
,
84 str
, jsstr_length(jsstr
), ret
);
88 if(rem_flags
& REM_RESET_INDEX
)
89 set_last_index(regexp
, 0);
93 if(!(rem_flags
& REM_NO_CTX_UPDATE
) && ctx
->last_match
!= jsstr
) {
94 jsstr_release(ctx
->last_match
);
95 ctx
->last_match
= jsstr_addref(jsstr
);
98 if(!(rem_flags
& REM_NO_CTX_UPDATE
)) {
99 DWORD i
, n
= min(ARRAY_SIZE(ctx
->match_parens
), ret
->paren_count
);
101 for(i
=0; i
< n
; i
++) {
102 if(ret
->parens
[i
].index
== -1) {
103 ctx
->match_parens
[i
].index
= 0;
104 ctx
->match_parens
[i
].length
= 0;
106 ctx
->match_parens
[i
].index
= ret
->parens
[i
].index
;
107 ctx
->match_parens
[i
].length
= ret
->parens
[i
].length
;
111 if(n
< ARRAY_SIZE(ctx
->match_parens
))
112 memset(ctx
->match_parens
+n
, 0, sizeof(ctx
->match_parens
) - n
*sizeof(ctx
->match_parens
[0]));
115 set_last_index(regexp
, ret
->cp
-str
);
117 if(!(rem_flags
& REM_NO_CTX_UPDATE
)) {
118 ctx
->last_match_index
= ret
->cp
-str
-ret
->match_len
;
119 ctx
->last_match_length
= ret
->match_len
;
125 HRESULT
regexp_match_next(script_ctx_t
*ctx
, jsdisp_t
*dispex
,
126 DWORD rem_flags
, jsstr_t
*jsstr
, match_state_t
**ret
)
128 RegExpInstance
*regexp
= regexp_from_jsdisp(dispex
);
129 match_state_t
*match
;
134 if((rem_flags
& REM_CHECK_GLOBAL
) && !(regexp
->jsregexp
->flags
& REG_GLOB
)) {
135 if(rem_flags
& REM_ALLOC_RESULT
)
140 str
= jsstr_flatten(jsstr
);
142 return E_OUTOFMEMORY
;
144 if(rem_flags
& REM_ALLOC_RESULT
) {
145 match
= alloc_match_state(regexp
->jsregexp
, NULL
, str
);
147 return E_OUTOFMEMORY
;
151 mark
= heap_pool_mark(&ctx
->tmp_heap
);
153 if(rem_flags
& REM_NO_PARENS
) {
154 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, NULL
);
156 heap_pool_clear(mark
);
157 return E_OUTOFMEMORY
;
159 match
->cp
= (*ret
)->cp
;
160 match
->match_len
= (*ret
)->match_len
;
165 hres
= do_regexp_match_next(ctx
, regexp
, rem_flags
, jsstr
, str
, match
);
167 if(rem_flags
& REM_NO_PARENS
) {
168 (*ret
)->cp
= match
->cp
;
169 (*ret
)->match_len
= match
->match_len
;
172 heap_pool_clear(mark
);
174 if(hres
!= S_OK
&& (rem_flags
& REM_ALLOC_RESULT
)) {
182 static HRESULT
regexp_match(script_ctx_t
*ctx
, jsdisp_t
*dispex
, jsstr_t
*jsstr
, BOOL gflag
,
183 match_result_t
**match_result
, DWORD
*result_cnt
)
185 RegExpInstance
*This
= regexp_from_jsdisp(dispex
);
186 match_result_t
*ret
= NULL
;
187 match_state_t
*result
;
188 DWORD i
=0, ret_size
= 0;
193 mark
= heap_pool_mark(&ctx
->tmp_heap
);
195 str
= jsstr_flatten(jsstr
);
197 return E_OUTOFMEMORY
;
199 result
= alloc_match_state(This
->jsregexp
, &ctx
->tmp_heap
, str
);
201 heap_pool_clear(mark
);
202 return E_OUTOFMEMORY
;
206 hres
= do_regexp_match_next(ctx
, This
, 0, jsstr
, str
, result
);
207 if(hres
== S_FALSE
) {
217 match_result_t
*old_ret
= ret
;
219 ret
= heap_realloc(old_ret
, (ret_size
<<= 1) * sizeof(match_result_t
));
223 ret
= heap_alloc((ret_size
=4) * sizeof(match_result_t
));
226 hres
= E_OUTOFMEMORY
;
231 ret
[i
].index
= result
->cp
- str
- result
->match_len
;
232 ret
[i
++].length
= result
->match_len
;
234 if(!gflag
&& !(This
->jsregexp
->flags
& REG_GLOB
)) {
240 heap_pool_clear(mark
);
251 static HRESULT
RegExp_get_source(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
255 *r
= jsval_string(jsstr_addref(regexp_from_jsdisp(jsthis
)->str
));
259 static HRESULT
RegExp_get_global(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
263 *r
= jsval_bool(!!(regexp_from_jsdisp(jsthis
)->jsregexp
->flags
& REG_GLOB
));
267 static HRESULT
RegExp_get_ignoreCase(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
271 *r
= jsval_bool(!!(regexp_from_jsdisp(jsthis
)->jsregexp
->flags
& REG_FOLD
));
275 static HRESULT
RegExp_get_multiline(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
279 *r
= jsval_bool(!!(regexp_from_jsdisp(jsthis
)->jsregexp
->flags
& REG_MULTILINE
));
283 static INT
index_from_val(script_ctx_t
*ctx
, jsval_t v
)
288 hres
= to_number(ctx
, v
, &n
);
290 clear_ei(ctx
); /* FIXME: Move ignoring exceptions to to_primitive */
295 return is_int32(n
) ? n
: 0;
298 static HRESULT
RegExp_get_lastIndex(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
300 RegExpInstance
*regexp
= regexp_from_jsdisp(jsthis
);
304 return jsval_copy(regexp
->last_index_val
, r
);
307 static HRESULT
RegExp_set_lastIndex(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t value
)
309 RegExpInstance
*regexp
= regexp_from_jsdisp(jsthis
);
314 jsval_release(regexp
->last_index_val
);
315 hres
= jsval_copy(value
, ®exp
->last_index_val
);
319 regexp
->last_index
= index_from_val(ctx
, value
);
323 static HRESULT
RegExp_toString(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
326 RegExpInstance
*regexp
;
333 if(!is_vclass(jsthis
, JSCLASS_REGEXP
)) {
334 FIXME("Not a RegExp\n");
338 regexp
= regexp_from_vdisp(jsthis
);
343 len
= jsstr_length(regexp
->str
) + 2;
345 f
= regexp
->jsregexp
->flags
;
350 if(f
& REG_MULTILINE
)
353 ret
= jsstr_alloc_buf(len
, &ptr
);
355 return E_OUTOFMEMORY
;
358 ptr
+= jsstr_flush(regexp
->str
, ptr
);
365 if(f
& REG_MULTILINE
)
368 *r
= jsval_string(ret
);
372 static HRESULT
create_match_array(script_ctx_t
*ctx
, jsstr_t
*input_str
,
373 const match_state_t
*result
, IDispatch
**ret
)
381 static const WCHAR indexW
[] = {'i','n','d','e','x',0};
382 static const WCHAR inputW
[] = {'i','n','p','u','t',0};
383 static const WCHAR lastIndexW
[] = {'l','a','s','t','I','n','d','e','x',0};
384 static const WCHAR zeroW
[] = {'0',0};
386 input
= jsstr_flatten(input_str
);
388 return E_OUTOFMEMORY
;
390 hres
= create_array(ctx
, result
->paren_count
+1, &array
);
394 for(i
=0; i
< result
->paren_count
; i
++) {
395 if(result
->parens
[i
].index
!= -1)
396 str
= jsstr_substr(input_str
, result
->parens
[i
].index
, result
->parens
[i
].length
);
400 hres
= E_OUTOFMEMORY
;
404 hres
= jsdisp_propput_idx(array
, i
+1, jsval_string(str
));
410 while(SUCCEEDED(hres
)) {
411 hres
= jsdisp_propput_name(array
, indexW
, jsval_number(result
->cp
-input
-result
->match_len
));
415 hres
= jsdisp_propput_name(array
, lastIndexW
, jsval_number(result
->cp
-input
));
419 hres
= jsdisp_propput_name(array
, inputW
, jsval_string(jsstr_addref(input_str
)));
423 str
= jsstr_alloc_len(result
->cp
-result
->match_len
, result
->match_len
);
425 hres
= E_OUTOFMEMORY
;
428 hres
= jsdisp_propput_name(array
, zeroW
, jsval_string(str
));
434 jsdisp_release(array
);
438 *ret
= to_disp(array
);
442 static HRESULT
run_exec(script_ctx_t
*ctx
, vdisp_t
*jsthis
, jsval_t arg
,
443 jsstr_t
**input
, match_state_t
**result
, BOOL
*ret
)
445 RegExpInstance
*regexp
;
446 match_state_t
*match
;
447 DWORD last_index
= 0;
452 if(!is_vclass(jsthis
, JSCLASS_REGEXP
)) {
453 FIXME("Not a RegExp\n");
457 regexp
= regexp_from_vdisp(jsthis
);
459 hres
= to_flat_string(ctx
, arg
, &jsstr
, &string
);
463 if(regexp
->jsregexp
->flags
& REG_GLOB
) {
464 if(regexp
->last_index
< 0) {
465 jsstr_release(jsstr
);
466 set_last_index(regexp
, 0);
469 *input
= jsstr_empty();
473 last_index
= regexp
->last_index
;
476 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, string
+last_index
);
478 jsstr_release(jsstr
);
479 return E_OUTOFMEMORY
;
482 hres
= regexp_match_next(ctx
, ®exp
->dispex
, REM_RESET_INDEX
, jsstr
, &match
);
484 jsstr_release(jsstr
);
493 jsstr_release(jsstr
);
497 static HRESULT
RegExp_exec(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
500 match_state_t
*match
;
508 mark
= heap_pool_mark(&ctx
->tmp_heap
);
510 hres
= run_exec(ctx
, jsthis
, argc
? argv
[0] : jsval_string(jsstr_empty()), &string
, &match
, &b
);
512 heap_pool_clear(mark
);
520 hres
= create_match_array(ctx
, string
, match
, &ret
);
522 *r
= jsval_disp(ret
);
528 heap_pool_clear(mark
);
529 jsstr_release(string
);
533 static HRESULT
RegExp_test(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
536 match_state_t
*match
;
544 mark
= heap_pool_mark(&ctx
->tmp_heap
);
545 hres
= run_exec(ctx
, jsthis
, argc
? argv
[0] : jsval_string(undef_str
= jsstr_undefined()), NULL
, &match
, &b
);
546 heap_pool_clear(mark
);
548 jsstr_release(undef_str
);
557 static HRESULT
RegExp_value(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
564 return throw_type_error(ctx
, JS_E_FUNCTION_EXPECTED
, NULL
);
566 FIXME("unimplemented flags %x\n", flags
);
573 static void RegExp_destructor(jsdisp_t
*dispex
)
575 RegExpInstance
*This
= regexp_from_jsdisp(dispex
);
578 regexp_destroy(This
->jsregexp
);
579 jsval_release(This
->last_index_val
);
580 jsstr_release(This
->str
);
584 static const builtin_prop_t RegExp_props
[] = {
585 {execW
, RegExp_exec
, PROPF_METHOD
|1},
586 {globalW
, NULL
,0, RegExp_get_global
},
587 {ignoreCaseW
, NULL
,0, RegExp_get_ignoreCase
},
588 {lastIndexW
, NULL
,0, RegExp_get_lastIndex
, RegExp_set_lastIndex
},
589 {multilineW
, NULL
,0, RegExp_get_multiline
},
590 {sourceW
, NULL
,0, RegExp_get_source
},
591 {testW
, RegExp_test
, PROPF_METHOD
|1},
592 {toStringW
, RegExp_toString
, PROPF_METHOD
}
595 static const builtin_info_t RegExp_info
= {
597 {NULL
, RegExp_value
, 0},
598 ARRAY_SIZE(RegExp_props
),
604 static const builtin_prop_t RegExpInst_props
[] = {
605 {globalW
, NULL
,0, RegExp_get_global
},
606 {ignoreCaseW
, NULL
,0, RegExp_get_ignoreCase
},
607 {lastIndexW
, NULL
,0, RegExp_get_lastIndex
, RegExp_set_lastIndex
},
608 {multilineW
, NULL
,0, RegExp_get_multiline
},
609 {sourceW
, NULL
,0, RegExp_get_source
}
612 static const builtin_info_t RegExpInst_info
= {
614 {NULL
, RegExp_value
, 0},
615 ARRAY_SIZE(RegExpInst_props
),
621 static HRESULT
alloc_regexp(script_ctx_t
*ctx
, jsdisp_t
*object_prototype
, RegExpInstance
**ret
)
623 RegExpInstance
*regexp
;
626 regexp
= heap_alloc_zero(sizeof(RegExpInstance
));
628 return E_OUTOFMEMORY
;
631 hres
= init_dispex(®exp
->dispex
, ctx
, &RegExp_info
, object_prototype
);
633 hres
= init_dispex_from_constr(®exp
->dispex
, ctx
, &RegExpInst_info
, ctx
->regexp_constr
);
644 HRESULT
create_regexp(script_ctx_t
*ctx
, jsstr_t
*src
, DWORD flags
, jsdisp_t
**ret
)
646 RegExpInstance
*regexp
;
650 TRACE("%s %x\n", debugstr_jsstr(src
), flags
);
652 str
= jsstr_flatten(src
);
654 return E_OUTOFMEMORY
;
656 hres
= alloc_regexp(ctx
, NULL
, ®exp
);
660 regexp
->str
= jsstr_addref(src
);
661 regexp
->last_index_val
= jsval_number(0);
663 regexp
->jsregexp
= regexp_new(ctx
, &ctx
->tmp_heap
, str
, jsstr_length(regexp
->str
), flags
, FALSE
);
664 if(!regexp
->jsregexp
) {
665 WARN("regexp_new failed\n");
666 jsdisp_release(®exp
->dispex
);
670 *ret
= ®exp
->dispex
;
674 HRESULT
create_regexp_var(script_ctx_t
*ctx
, jsval_t src_arg
, jsval_t
*flags_arg
, jsdisp_t
**ret
)
676 unsigned flags
, opt_len
= 0;
677 const WCHAR
*opt
= NULL
;
681 if(is_object_instance(src_arg
)) {
684 obj
= iface_to_jsdisp(get_object(src_arg
));
686 if(is_class(obj
, JSCLASS_REGEXP
)) {
687 RegExpInstance
*regexp
= regexp_from_jsdisp(obj
);
689 hres
= create_regexp(ctx
, regexp
->str
, regexp
->jsregexp
->flags
, ret
);
698 if(!is_string(src_arg
)) {
699 FIXME("src_arg = %s\n", debugstr_jsval(src_arg
));
703 src
= get_string(src_arg
);
708 if(!is_string(*flags_arg
)) {
709 FIXME("unimplemented for %s\n", debugstr_jsval(*flags_arg
));
713 opt_str
= get_string(*flags_arg
);
714 opt
= jsstr_flatten(opt_str
);
716 return E_OUTOFMEMORY
;
717 opt_len
= jsstr_length(opt_str
);
720 hres
= parse_regexp_flags(opt
, opt_len
, &flags
);
724 return create_regexp(ctx
, src
, flags
, ret
);
727 HRESULT
regexp_string_match(script_ctx_t
*ctx
, jsdisp_t
*re
, jsstr_t
*jsstr
, jsval_t
*r
)
729 static const WCHAR indexW
[] = {'i','n','d','e','x',0};
730 static const WCHAR inputW
[] = {'i','n','p','u','t',0};
731 static const WCHAR lastIndexW
[] = {'l','a','s','t','I','n','d','e','x',0};
733 RegExpInstance
*regexp
= regexp_from_jsdisp(re
);
734 match_result_t
*match_result
;
735 unsigned match_cnt
, i
;
740 str
= jsstr_flatten(jsstr
);
742 return E_OUTOFMEMORY
;
744 if(!(regexp
->jsregexp
->flags
& REG_GLOB
)) {
745 match_state_t
*match
;
748 mark
= heap_pool_mark(&ctx
->tmp_heap
);
749 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, str
);
751 heap_pool_clear(mark
);
752 return E_OUTOFMEMORY
;
755 hres
= regexp_match_next(ctx
, ®exp
->dispex
, 0, jsstr
, &match
);
757 heap_pool_clear(mark
);
765 hres
= create_match_array(ctx
, jsstr
, match
, &ret
);
767 *r
= jsval_disp(ret
);
773 heap_pool_clear(mark
);
777 hres
= regexp_match(ctx
, ®exp
->dispex
, jsstr
, FALSE
, &match_result
, &match_cnt
);
789 hres
= create_array(ctx
, match_cnt
, &array
);
793 for(i
=0; i
< match_cnt
; i
++) {
796 tmp_str
= jsstr_substr(jsstr
, match_result
[i
].index
, match_result
[i
].length
);
798 hres
= E_OUTOFMEMORY
;
802 hres
= jsdisp_propput_idx(array
, i
, jsval_string(tmp_str
));
803 jsstr_release(tmp_str
);
808 while(SUCCEEDED(hres
)) {
809 hres
= jsdisp_propput_name(array
, indexW
, jsval_number(match_result
[match_cnt
-1].index
));
813 hres
= jsdisp_propput_name(array
, lastIndexW
,
814 jsval_number(match_result
[match_cnt
-1].index
+ match_result
[match_cnt
-1].length
));
818 hres
= jsdisp_propput_name(array
, inputW
, jsval_string(jsstr
));
822 heap_free(match_result
);
824 if(SUCCEEDED(hres
) && r
)
825 *r
= jsval_obj(array
);
827 jsdisp_release(array
);
831 static HRESULT
global_idx(script_ctx_t
*ctx
, DWORD idx
, jsval_t
*r
)
835 ret
= jsstr_substr(ctx
->last_match
, ctx
->match_parens
[idx
].index
, ctx
->match_parens
[idx
].length
);
837 return E_OUTOFMEMORY
;
839 *r
= jsval_string(ret
);
843 static HRESULT
RegExpConstr_get_idx1(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
846 return global_idx(ctx
, 0, r
);
849 static HRESULT
RegExpConstr_get_idx2(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
852 return global_idx(ctx
, 1, r
);
855 static HRESULT
RegExpConstr_get_idx3(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
858 return global_idx(ctx
, 2, r
);
861 static HRESULT
RegExpConstr_get_idx4(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
864 return global_idx(ctx
, 3, r
);
867 static HRESULT
RegExpConstr_get_idx5(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
870 return global_idx(ctx
, 4, r
);
873 static HRESULT
RegExpConstr_get_idx6(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
876 return global_idx(ctx
, 5, r
);
879 static HRESULT
RegExpConstr_get_idx7(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
882 return global_idx(ctx
, 6, r
);
885 static HRESULT
RegExpConstr_get_idx8(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
888 return global_idx(ctx
, 7, r
);
891 static HRESULT
RegExpConstr_get_idx9(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
894 return global_idx(ctx
, 8, r
);
897 static HRESULT
RegExpConstr_get_leftContext(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
903 ret
= jsstr_substr(ctx
->last_match
, 0, ctx
->last_match_index
);
905 return E_OUTOFMEMORY
;
907 *r
= jsval_string(ret
);
911 static HRESULT
RegExpConstr_get_rightContext(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
917 ret
= jsstr_substr(ctx
->last_match
, ctx
->last_match_index
+ctx
->last_match_length
,
918 jsstr_length(ctx
->last_match
) - ctx
->last_match_index
- ctx
->last_match_length
);
920 return E_OUTOFMEMORY
;
922 *r
= jsval_string(ret
);
926 static HRESULT
RegExpConstr_value(script_ctx_t
*ctx
, vdisp_t
*jsthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
932 case DISPATCH_METHOD
:
934 if(is_object_instance(argv
[0])) {
935 jsdisp_t
*jsdisp
= iface_to_jsdisp(get_object(argv
[0]));
937 if(is_class(jsdisp
, JSCLASS_REGEXP
)) {
938 if(argc
> 1 && !is_undefined(argv
[1])) {
939 jsdisp_release(jsdisp
);
940 return throw_regexp_error(ctx
, JS_E_REGEXP_SYNTAX
, NULL
);
944 *r
= jsval_obj(jsdisp
);
946 jsdisp_release(jsdisp
);
949 jsdisp_release(jsdisp
);
954 case DISPATCH_CONSTRUCT
: {
963 hres
= create_regexp_var(ctx
, argv
[0], argc
> 1 ? argv
+1 : NULL
, &ret
);
974 FIXME("unimplemented flags: %x\n", flags
);
981 static const builtin_prop_t RegExpConstr_props
[] = {
982 {idx1W
, NULL
,0, RegExpConstr_get_idx1
, builtin_set_const
},
983 {idx2W
, NULL
,0, RegExpConstr_get_idx2
, builtin_set_const
},
984 {idx3W
, NULL
,0, RegExpConstr_get_idx3
, builtin_set_const
},
985 {idx4W
, NULL
,0, RegExpConstr_get_idx4
, builtin_set_const
},
986 {idx5W
, NULL
,0, RegExpConstr_get_idx5
, builtin_set_const
},
987 {idx6W
, NULL
,0, RegExpConstr_get_idx6
, builtin_set_const
},
988 {idx7W
, NULL
,0, RegExpConstr_get_idx7
, builtin_set_const
},
989 {idx8W
, NULL
,0, RegExpConstr_get_idx8
, builtin_set_const
},
990 {idx9W
, NULL
,0, RegExpConstr_get_idx9
, builtin_set_const
},
991 {leftContextW
, NULL
,0, RegExpConstr_get_leftContext
, builtin_set_const
},
992 {rightContextW
, NULL
,0, RegExpConstr_get_rightContext
, builtin_set_const
}
995 static const builtin_info_t RegExpConstr_info
= {
997 DEFAULT_FUNCTION_VALUE
,
998 ARRAY_SIZE(RegExpConstr_props
),
1004 HRESULT
create_regexp_constr(script_ctx_t
*ctx
, jsdisp_t
*object_prototype
, jsdisp_t
**ret
)
1006 RegExpInstance
*regexp
;
1009 static const WCHAR RegExpW
[] = {'R','e','g','E','x','p',0};
1011 hres
= alloc_regexp(ctx
, object_prototype
, ®exp
);
1015 hres
= create_builtin_constructor(ctx
, RegExpConstr_value
, RegExpW
, &RegExpConstr_info
,
1016 PROPF_CONSTR
|2, ®exp
->dispex
, ret
);
1018 jsdisp_release(®exp
->dispex
);
1022 HRESULT
parse_regexp_flags(const WCHAR
*str
, DWORD str_len
, DWORD
*ret
)
1027 for (p
= str
; p
< str
+str_len
; p
++) {
1036 flags
|= REG_MULTILINE
;
1039 flags
|= REG_STICKY
;
1042 WARN("wrong flag %c\n", *p
);