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 inline RegExpInstance
*regexp_from_jsdisp(jsdisp_t
*jsdisp
)
39 return CONTAINING_RECORD(jsdisp
, RegExpInstance
, dispex
);
42 static inline RegExpInstance
*regexp_this(jsval_t vthis
)
44 jsdisp_t
*jsdisp
= is_object_instance(vthis
) ? to_jsdisp(get_object(vthis
)) : NULL
;
45 return (jsdisp
&& is_class(jsdisp
, JSCLASS_REGEXP
)) ? regexp_from_jsdisp(jsdisp
) : NULL
;
48 static void set_last_index(RegExpInstance
*This
, DWORD last_index
)
50 This
->last_index
= last_index
;
51 jsval_release(This
->last_index_val
);
52 This
->last_index_val
= jsval_number(last_index
);
55 static HRESULT
do_regexp_match_next(script_ctx_t
*ctx
, RegExpInstance
*regexp
,
56 DWORD rem_flags
, jsstr_t
*jsstr
, const WCHAR
*str
, match_state_t
*ret
)
60 hres
= regexp_execute(regexp
->jsregexp
, ctx
, &ctx
->tmp_heap
,
61 str
, jsstr_length(jsstr
), ret
);
65 if(rem_flags
& REM_RESET_INDEX
)
66 set_last_index(regexp
, 0);
70 if(!(rem_flags
& REM_NO_CTX_UPDATE
) && ctx
->last_match
!= jsstr
) {
71 jsstr_release(ctx
->last_match
);
72 ctx
->last_match
= jsstr_addref(jsstr
);
75 if(!(rem_flags
& REM_NO_CTX_UPDATE
)) {
76 DWORD i
, n
= min(ARRAY_SIZE(ctx
->match_parens
), ret
->paren_count
);
78 for(i
=0; i
< n
; i
++) {
79 if(ret
->parens
[i
].index
== -1) {
80 ctx
->match_parens
[i
].index
= 0;
81 ctx
->match_parens
[i
].length
= 0;
83 ctx
->match_parens
[i
].index
= ret
->parens
[i
].index
;
84 ctx
->match_parens
[i
].length
= ret
->parens
[i
].length
;
88 if(n
< ARRAY_SIZE(ctx
->match_parens
))
89 memset(ctx
->match_parens
+n
, 0, sizeof(ctx
->match_parens
) - n
*sizeof(ctx
->match_parens
[0]));
92 set_last_index(regexp
, ret
->cp
-str
);
94 if(!(rem_flags
& REM_NO_CTX_UPDATE
)) {
95 ctx
->last_match_index
= ret
->cp
-str
-ret
->match_len
;
96 ctx
->last_match_length
= ret
->match_len
;
102 HRESULT
regexp_match_next(script_ctx_t
*ctx
, jsdisp_t
*dispex
,
103 DWORD rem_flags
, jsstr_t
*jsstr
, match_state_t
**ret
)
105 RegExpInstance
*regexp
= regexp_from_jsdisp(dispex
);
106 match_state_t
*match
;
111 if((rem_flags
& REM_CHECK_GLOBAL
) && !(regexp
->jsregexp
->flags
& REG_GLOB
)) {
112 if(rem_flags
& REM_ALLOC_RESULT
)
117 str
= jsstr_flatten(jsstr
);
119 return E_OUTOFMEMORY
;
121 if(rem_flags
& REM_ALLOC_RESULT
) {
122 match
= alloc_match_state(regexp
->jsregexp
, NULL
, str
);
124 return E_OUTOFMEMORY
;
128 mark
= heap_pool_mark(&ctx
->tmp_heap
);
130 if(rem_flags
& REM_NO_PARENS
) {
131 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, NULL
);
133 heap_pool_clear(mark
);
134 return E_OUTOFMEMORY
;
136 match
->cp
= (*ret
)->cp
;
137 match
->match_len
= (*ret
)->match_len
;
142 hres
= do_regexp_match_next(ctx
, regexp
, rem_flags
, jsstr
, str
, match
);
144 if(rem_flags
& REM_NO_PARENS
) {
145 (*ret
)->cp
= match
->cp
;
146 (*ret
)->match_len
= match
->match_len
;
149 heap_pool_clear(mark
);
151 if(hres
!= S_OK
&& (rem_flags
& REM_ALLOC_RESULT
)) {
159 static HRESULT
regexp_match(script_ctx_t
*ctx
, jsdisp_t
*dispex
, jsstr_t
*jsstr
, BOOL gflag
,
160 match_result_t
**match_result
, DWORD
*result_cnt
)
162 RegExpInstance
*This
= regexp_from_jsdisp(dispex
);
163 match_result_t
*ret
= NULL
;
164 match_state_t
*result
;
165 DWORD i
=0, ret_size
= 0;
170 mark
= heap_pool_mark(&ctx
->tmp_heap
);
172 str
= jsstr_flatten(jsstr
);
174 return E_OUTOFMEMORY
;
176 result
= alloc_match_state(This
->jsregexp
, &ctx
->tmp_heap
, str
);
178 heap_pool_clear(mark
);
179 return E_OUTOFMEMORY
;
183 hres
= do_regexp_match_next(ctx
, This
, 0, jsstr
, str
, result
);
184 if(hres
== S_FALSE
) {
194 match_result_t
*old_ret
= ret
;
196 ret
= realloc(old_ret
, (ret_size
<<= 1) * sizeof(match_result_t
));
200 ret
= malloc((ret_size
=4) * sizeof(match_result_t
));
203 hres
= E_OUTOFMEMORY
;
208 ret
[i
].index
= result
->cp
- str
- result
->match_len
;
209 ret
[i
++].length
= result
->match_len
;
211 if(!gflag
&& !(This
->jsregexp
->flags
& REG_GLOB
)) {
217 heap_pool_clear(mark
);
228 static HRESULT
RegExp_get_source(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
232 *r
= jsval_string(jsstr_addref(regexp_from_jsdisp(jsthis
)->str
));
236 static HRESULT
RegExp_get_global(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
240 *r
= jsval_bool(!!(regexp_from_jsdisp(jsthis
)->jsregexp
->flags
& REG_GLOB
));
244 static HRESULT
RegExp_get_ignoreCase(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
248 *r
= jsval_bool(!!(regexp_from_jsdisp(jsthis
)->jsregexp
->flags
& REG_FOLD
));
252 static HRESULT
RegExp_get_multiline(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
256 *r
= jsval_bool(!!(regexp_from_jsdisp(jsthis
)->jsregexp
->flags
& REG_MULTILINE
));
260 static INT
index_from_val(script_ctx_t
*ctx
, jsval_t v
)
265 hres
= to_number(ctx
, v
, &n
);
270 return is_int32(n
) ? n
: 0;
273 static HRESULT
RegExp_get_lastIndex(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
275 RegExpInstance
*regexp
= regexp_from_jsdisp(jsthis
);
279 return jsval_copy(regexp
->last_index_val
, r
);
282 static HRESULT
RegExp_set_lastIndex(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t value
)
284 RegExpInstance
*regexp
= regexp_from_jsdisp(jsthis
);
289 jsval_release(regexp
->last_index_val
);
290 hres
= jsval_copy(value
, ®exp
->last_index_val
);
294 regexp
->last_index
= index_from_val(ctx
, value
);
298 static HRESULT
RegExp_toString(script_ctx_t
*ctx
, jsval_t vthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
301 RegExpInstance
*regexp
;
308 if(!(regexp
= regexp_this(vthis
))) {
309 WARN("Not a RegExp\n");
310 return JS_E_REGEXP_EXPECTED
;
317 len
= jsstr_length(regexp
->str
) + 2;
319 f
= regexp
->jsregexp
->flags
;
324 if(f
& REG_MULTILINE
)
327 ret
= jsstr_alloc_buf(len
, &ptr
);
329 return E_OUTOFMEMORY
;
332 ptr
+= jsstr_flush(regexp
->str
, ptr
);
339 if(f
& REG_MULTILINE
)
342 *r
= jsval_string(ret
);
346 static HRESULT
create_match_array(script_ctx_t
*ctx
, jsstr_t
*input_str
,
347 const match_state_t
*result
, IDispatch
**ret
)
355 input
= jsstr_flatten(input_str
);
357 return E_OUTOFMEMORY
;
359 hres
= create_array(ctx
, result
->paren_count
+1, &array
);
363 for(i
=0; i
< result
->paren_count
; i
++) {
364 if(result
->parens
[i
].index
!= -1)
365 str
= jsstr_substr(input_str
, result
->parens
[i
].index
, result
->parens
[i
].length
);
369 hres
= E_OUTOFMEMORY
;
373 hres
= jsdisp_propput_idx(array
, i
+1, jsval_string(str
));
379 while(SUCCEEDED(hres
)) {
380 hres
= jsdisp_propput_name(array
, L
"index", jsval_number(result
->cp
-input
-result
->match_len
));
384 hres
= jsdisp_propput_name(array
, L
"lastIndex", jsval_number(result
->cp
-input
));
388 hres
= jsdisp_propput_name(array
, L
"input", jsval_string(jsstr_addref(input_str
)));
392 str
= jsstr_alloc_len(result
->cp
-result
->match_len
, result
->match_len
);
394 hres
= E_OUTOFMEMORY
;
397 hres
= jsdisp_propput_name(array
, L
"0", jsval_string(str
));
403 jsdisp_release(array
);
407 *ret
= to_disp(array
);
411 static HRESULT
run_exec(script_ctx_t
*ctx
, jsval_t vthis
, jsval_t arg
,
412 jsstr_t
**input
, match_state_t
**result
, BOOL
*ret
)
414 RegExpInstance
*regexp
;
415 match_state_t
*match
;
416 DWORD last_index
= 0;
421 if(!(regexp
= regexp_this(vthis
))) {
422 WARN("Not a RegExp\n");
423 return JS_E_REGEXP_EXPECTED
;
426 hres
= to_flat_string(ctx
, arg
, &jsstr
, &string
);
430 if(regexp
->jsregexp
->flags
& REG_GLOB
) {
431 if(regexp
->last_index
< 0) {
432 jsstr_release(jsstr
);
433 set_last_index(regexp
, 0);
436 *input
= jsstr_empty();
440 last_index
= regexp
->last_index
;
443 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, string
+last_index
);
445 jsstr_release(jsstr
);
446 return E_OUTOFMEMORY
;
449 hres
= regexp_match_next(ctx
, ®exp
->dispex
, REM_RESET_INDEX
, jsstr
, &match
);
451 jsstr_release(jsstr
);
460 jsstr_release(jsstr
);
464 static HRESULT
RegExp_exec(script_ctx_t
*ctx
, jsval_t vthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
467 match_state_t
*match
;
475 mark
= heap_pool_mark(&ctx
->tmp_heap
);
477 hres
= run_exec(ctx
, vthis
, argc
? argv
[0] : jsval_string(jsstr_empty()), &string
, &match
, &b
);
479 heap_pool_clear(mark
);
487 hres
= create_match_array(ctx
, string
, match
, &ret
);
489 *r
= jsval_disp(ret
);
495 heap_pool_clear(mark
);
496 jsstr_release(string
);
500 static HRESULT
RegExp_test(script_ctx_t
*ctx
, jsval_t vthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
503 match_state_t
*match
;
511 mark
= heap_pool_mark(&ctx
->tmp_heap
);
512 hres
= run_exec(ctx
, vthis
, argc
? argv
[0] : jsval_string(undef_str
= jsstr_undefined()), NULL
, &match
, &b
);
513 heap_pool_clear(mark
);
515 jsstr_release(undef_str
);
524 static HRESULT
RegExp_value(script_ctx_t
*ctx
, jsval_t vthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
531 return JS_E_FUNCTION_EXPECTED
;
533 FIXME("unimplemented flags %x\n", flags
);
540 static void RegExp_destructor(jsdisp_t
*dispex
)
542 RegExpInstance
*This
= regexp_from_jsdisp(dispex
);
545 regexp_destroy(This
->jsregexp
);
546 jsval_release(This
->last_index_val
);
547 jsstr_release(This
->str
);
551 static HRESULT
RegExp_gc_traverse(struct gc_ctx
*gc_ctx
, enum gc_traverse_op op
, jsdisp_t
*dispex
)
553 return gc_process_linked_val(gc_ctx
, op
, dispex
, ®exp_from_jsdisp(dispex
)->last_index_val
);
556 static const builtin_prop_t RegExp_props
[] = {
557 {L
"exec", RegExp_exec
, PROPF_METHOD
|1},
558 {L
"global", NULL
,0, RegExp_get_global
},
559 {L
"ignoreCase", NULL
,0, RegExp_get_ignoreCase
},
560 {L
"lastIndex", NULL
,0, RegExp_get_lastIndex
, RegExp_set_lastIndex
},
561 {L
"multiline", NULL
,0, RegExp_get_multiline
},
562 {L
"source", NULL
,0, RegExp_get_source
},
563 {L
"test", RegExp_test
, PROPF_METHOD
|1},
564 {L
"toString", RegExp_toString
, PROPF_METHOD
}
567 static const builtin_info_t RegExp_info
= {
570 ARRAY_SIZE(RegExp_props
),
580 static const builtin_prop_t RegExpInst_props
[] = {
581 {L
"global", NULL
,0, RegExp_get_global
},
582 {L
"ignoreCase", NULL
,0, RegExp_get_ignoreCase
},
583 {L
"lastIndex", NULL
,0, RegExp_get_lastIndex
, RegExp_set_lastIndex
},
584 {L
"multiline", NULL
,0, RegExp_get_multiline
},
585 {L
"source", NULL
,0, RegExp_get_source
}
588 static const builtin_info_t RegExpInst_info
= {
591 ARRAY_SIZE(RegExpInst_props
),
601 static HRESULT
alloc_regexp(script_ctx_t
*ctx
, jsstr_t
*str
, jsdisp_t
*object_prototype
, RegExpInstance
**ret
)
603 RegExpInstance
*regexp
;
606 regexp
= calloc(1, sizeof(RegExpInstance
));
608 return E_OUTOFMEMORY
;
611 hres
= init_dispex(®exp
->dispex
, ctx
, &RegExp_info
, object_prototype
);
613 hres
= init_dispex_from_constr(®exp
->dispex
, ctx
, &RegExpInst_info
, ctx
->regexp_constr
);
620 regexp
->str
= jsstr_addref(str
);
621 regexp
->last_index_val
= jsval_number(0);
627 HRESULT
create_regexp(script_ctx_t
*ctx
, jsstr_t
*src
, DWORD flags
, jsdisp_t
**ret
)
629 RegExpInstance
*regexp
;
633 str
= jsstr_flatten(src
);
635 return E_OUTOFMEMORY
;
637 TRACE("%s %lx\n", debugstr_wn(str
, jsstr_length(src
)), flags
);
639 hres
= alloc_regexp(ctx
, src
, NULL
, ®exp
);
643 regexp
->jsregexp
= regexp_new(ctx
, &ctx
->tmp_heap
, str
, jsstr_length(regexp
->str
), flags
, FALSE
);
644 if(!regexp
->jsregexp
) {
645 WARN("regexp_new failed\n");
646 jsdisp_release(®exp
->dispex
);
650 *ret
= ®exp
->dispex
;
654 HRESULT
create_regexp_var(script_ctx_t
*ctx
, jsval_t src_arg
, jsval_t
*flags_arg
, jsdisp_t
**ret
)
657 const WCHAR
*opt
= NULL
;
661 if(is_object_instance(src_arg
)) {
664 obj
= iface_to_jsdisp(get_object(src_arg
));
666 if(is_class(obj
, JSCLASS_REGEXP
)) {
667 RegExpInstance
*regexp
= regexp_from_jsdisp(obj
);
669 hres
= create_regexp(ctx
, regexp
->str
, regexp
->jsregexp
->flags
, ret
);
678 if(is_undefined(src_arg
))
681 hres
= to_string(ctx
, src_arg
, &src
);
685 if(flags_arg
&& !is_undefined(*flags_arg
)) {
688 hres
= to_string(ctx
, *flags_arg
, &opt_str
);
689 if(SUCCEEDED(hres
)) {
690 opt
= jsstr_flatten(opt_str
);
692 hres
= parse_regexp_flags(opt
, jsstr_length(opt_str
), &flags
);
694 hres
= E_OUTOFMEMORY
;
695 jsstr_release(opt_str
);
700 hres
= create_regexp(ctx
, src
, flags
, ret
);
705 HRESULT
regexp_string_match(script_ctx_t
*ctx
, jsdisp_t
*re
, jsstr_t
*jsstr
, jsval_t
*r
)
707 RegExpInstance
*regexp
= regexp_from_jsdisp(re
);
708 match_result_t
*match_result
;
714 str
= jsstr_flatten(jsstr
);
716 return E_OUTOFMEMORY
;
718 if(!(regexp
->jsregexp
->flags
& REG_GLOB
)) {
719 match_state_t
*match
;
722 mark
= heap_pool_mark(&ctx
->tmp_heap
);
723 match
= alloc_match_state(regexp
->jsregexp
, &ctx
->tmp_heap
, str
);
725 heap_pool_clear(mark
);
726 return E_OUTOFMEMORY
;
729 hres
= regexp_match_next(ctx
, ®exp
->dispex
, 0, jsstr
, &match
);
731 heap_pool_clear(mark
);
739 hres
= create_match_array(ctx
, jsstr
, match
, &ret
);
741 *r
= jsval_disp(ret
);
747 heap_pool_clear(mark
);
751 hres
= regexp_match(ctx
, ®exp
->dispex
, jsstr
, FALSE
, &match_result
, &match_cnt
);
763 hres
= create_array(ctx
, match_cnt
, &array
);
767 for(i
=0; i
< match_cnt
; i
++) {
770 tmp_str
= jsstr_substr(jsstr
, match_result
[i
].index
, match_result
[i
].length
);
772 hres
= E_OUTOFMEMORY
;
776 hres
= jsdisp_propput_idx(array
, i
, jsval_string(tmp_str
));
777 jsstr_release(tmp_str
);
782 while(SUCCEEDED(hres
)) {
783 hres
= jsdisp_propput_name(array
, L
"index", jsval_number(match_result
[match_cnt
-1].index
));
787 hres
= jsdisp_propput_name(array
, L
"lastIndex",
788 jsval_number(match_result
[match_cnt
-1].index
+ match_result
[match_cnt
-1].length
));
792 hres
= jsdisp_propput_name(array
, L
"input", jsval_string(jsstr
));
798 if(SUCCEEDED(hres
) && r
)
799 *r
= jsval_obj(array
);
801 jsdisp_release(array
);
805 static HRESULT
global_idx(script_ctx_t
*ctx
, DWORD idx
, jsval_t
*r
)
809 ret
= jsstr_substr(ctx
->last_match
, ctx
->match_parens
[idx
].index
, ctx
->match_parens
[idx
].length
);
811 return E_OUTOFMEMORY
;
813 *r
= jsval_string(ret
);
817 static HRESULT
RegExpConstr_get_idx1(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
820 return global_idx(ctx
, 0, r
);
823 static HRESULT
RegExpConstr_get_idx2(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
826 return global_idx(ctx
, 1, r
);
829 static HRESULT
RegExpConstr_get_idx3(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
832 return global_idx(ctx
, 2, r
);
835 static HRESULT
RegExpConstr_get_idx4(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
838 return global_idx(ctx
, 3, r
);
841 static HRESULT
RegExpConstr_get_idx5(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
844 return global_idx(ctx
, 4, r
);
847 static HRESULT
RegExpConstr_get_idx6(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
850 return global_idx(ctx
, 5, r
);
853 static HRESULT
RegExpConstr_get_idx7(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
856 return global_idx(ctx
, 6, r
);
859 static HRESULT
RegExpConstr_get_idx8(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
862 return global_idx(ctx
, 7, r
);
865 static HRESULT
RegExpConstr_get_idx9(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
868 return global_idx(ctx
, 8, r
);
871 static HRESULT
RegExpConstr_get_leftContext(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
877 ret
= jsstr_substr(ctx
->last_match
, 0, ctx
->last_match_index
);
879 return E_OUTOFMEMORY
;
881 *r
= jsval_string(ret
);
885 static HRESULT
RegExpConstr_get_rightContext(script_ctx_t
*ctx
, jsdisp_t
*jsthis
, jsval_t
*r
)
891 ret
= jsstr_substr(ctx
->last_match
, ctx
->last_match_index
+ctx
->last_match_length
,
892 jsstr_length(ctx
->last_match
) - ctx
->last_match_index
- ctx
->last_match_length
);
894 return E_OUTOFMEMORY
;
896 *r
= jsval_string(ret
);
900 static HRESULT
RegExpConstr_value(script_ctx_t
*ctx
, jsval_t vthis
, WORD flags
, unsigned argc
, jsval_t
*argv
,
906 case DISPATCH_METHOD
:
908 if(is_object_instance(argv
[0])) {
909 jsdisp_t
*jsdisp
= iface_to_jsdisp(get_object(argv
[0]));
911 if(is_class(jsdisp
, JSCLASS_REGEXP
)) {
912 if(argc
> 1 && !is_undefined(argv
[1])) {
913 jsdisp_release(jsdisp
);
914 return JS_E_REGEXP_SYNTAX
;
918 *r
= jsval_obj(jsdisp
);
920 jsdisp_release(jsdisp
);
923 jsdisp_release(jsdisp
);
928 case DISPATCH_CONSTRUCT
: {
932 hres
= create_regexp_var(ctx
, argc
? argv
[0] : jsval_undefined(), argc
> 1 ? argv
+1 : NULL
, &ret
);
943 FIXME("unimplemented flags: %x\n", flags
);
950 static const builtin_prop_t RegExpConstr_props
[] = {
951 {L
"$1", NULL
,0, RegExpConstr_get_idx1
, builtin_set_const
},
952 {L
"$2", NULL
,0, RegExpConstr_get_idx2
, builtin_set_const
},
953 {L
"$3", NULL
,0, RegExpConstr_get_idx3
, builtin_set_const
},
954 {L
"$4", NULL
,0, RegExpConstr_get_idx4
, builtin_set_const
},
955 {L
"$5", NULL
,0, RegExpConstr_get_idx5
, builtin_set_const
},
956 {L
"$6", NULL
,0, RegExpConstr_get_idx6
, builtin_set_const
},
957 {L
"$7", NULL
,0, RegExpConstr_get_idx7
, builtin_set_const
},
958 {L
"$8", NULL
,0, RegExpConstr_get_idx8
, builtin_set_const
},
959 {L
"$9", NULL
,0, RegExpConstr_get_idx9
, builtin_set_const
},
960 {L
"leftContext", NULL
,0, RegExpConstr_get_leftContext
, builtin_set_const
},
961 {L
"rightContext", NULL
,0, RegExpConstr_get_rightContext
, builtin_set_const
}
964 static const builtin_info_t RegExpConstr_info
= {
967 ARRAY_SIZE(RegExpConstr_props
),
973 HRESULT
create_regexp_constr(script_ctx_t
*ctx
, jsdisp_t
*object_prototype
, jsdisp_t
**ret
)
975 jsstr_t
*str
= jsstr_empty();
976 RegExpInstance
*regexp
;
979 hres
= alloc_regexp(ctx
, str
, object_prototype
, ®exp
);
984 hres
= create_builtin_constructor(ctx
, RegExpConstr_value
, L
"RegExp", &RegExpConstr_info
,
985 PROPF_CONSTR
|2, ®exp
->dispex
, ret
);
987 jsdisp_release(®exp
->dispex
);
991 HRESULT
parse_regexp_flags(const WCHAR
*str
, DWORD str_len
, DWORD
*ret
)
996 for (p
= str
; p
< str
+str_len
; p
++) {
1005 flags
|= REG_MULTILINE
;
1008 flags
|= REG_STICKY
;
1011 WARN("wrong flag %c\n", *p
);