YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use unicode iterators in RegExp engine and implement \d, \D, \w, \W, \s, \S, \x, \u matching in RegExp.

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Szilard Ledan szledan.u-szeged@partner.samsung.com
JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com
This commit is contained in:
László Langó
2015-07-22 09:17:37 +02:00
parent 6567651b6c
commit 3c71daaf84
8 changed files with 559 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.cpp
+3 -5
View File
@@ -79,14 +79,12 @@ ecma_builtin_regexp_prototype_exec (ecma_value_t this_arg, /**< this argument */
/* Convert ecma_String_t *to regexp_bytecode_t* */ /* Convert ecma_String_t *to regexp_bytecode_t* */
lit_utf8_size_t input_str_size = ecma_string_get_size (input_str_p); lit_utf8_size_t input_str_size = ecma_string_get_size (input_str_p);
MEM_DEFINE_LOCAL_ARRAY (input_utf8_buffer_p, input_str_size + 1, lit_utf8_byte_t); MEM_DEFINE_LOCAL_ARRAY (input_utf8_buffer_p, input_str_size, lit_utf8_byte_t);
ecma_string_to_utf8_string (input_str_p, input_utf8_buffer_p, (ssize_t) input_str_size); ecma_string_to_utf8_string (input_str_p, input_utf8_buffer_p, (ssize_t) input_str_size);
lit_utf8_iterator_t iter = lit_utf8_iterator_create (input_utf8_buffer_p, input_str_size);
FIXME ("Update ecma_regexp_exec_helper so that zero symbol is not needed."); ret_value = ecma_regexp_exec_helper (obj_p, bytecode_p, &iter);
input_utf8_buffer_p[input_str_size] = LIT_BYTE_NULL;
ret_value = ecma_regexp_exec_helper (obj_p, bytecode_p, input_utf8_buffer_p, input_str_size);
MEM_FINALIZE_LOCAL_ARRAY (input_utf8_buffer_p); MEM_FINALIZE_LOCAL_ARRAY (input_utf8_buffer_p);
jerry-core/ecma/builtin-objects/ecma-builtin-regexp.cpp
+10 -1
View File
@@ -119,7 +119,16 @@ ecma_builtin_regexp_dispatch_construct (const ecma_value_t *arguments_list_p, /*
if (ecma_is_completion_value_empty (ret_value)) if (ecma_is_completion_value_empty (ret_value))
{ {
ret_value = ecma_op_create_regexp_object (pattern_string_p, flags_string_p); if (ecma_string_get_length (pattern_string_p) == 0)
{
ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_EMPTY_NON_CAPTURE_GROUP);
ret_value = ecma_op_create_regexp_object (magic_str_p, flags_string_p);
ecma_deref_ecma_string (magic_str_p);
}
else
{
ret_value = ecma_op_create_regexp_object (pattern_string_p, flags_string_p);
}
} }
if (flags_string_p != NULL) if (flags_string_p != NULL)
jerry-core/ecma/operations/ecma-regexp-object.cpp
+153 -168
View File
@@ -75,17 +75,16 @@ re_parse_regexp_flags (ecma_string_t *flags_str_p, /**< Input string with flags
{ {
ecma_completion_value_t ret_value = ecma_make_empty_completion_value (); ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
FIXME ("Unicode: properly process non-ascii characters.");
lit_utf8_size_t flags_str_size = ecma_string_get_size (flags_str_p); lit_utf8_size_t flags_str_size = ecma_string_get_size (flags_str_p);
MEM_DEFINE_LOCAL_ARRAY (flags_start_p, flags_str_size, lit_utf8_byte_t); MEM_DEFINE_LOCAL_ARRAY (flags_start_p, flags_str_size, lit_utf8_byte_t);
ecma_string_to_utf8_string (flags_str_p, flags_start_p, (ssize_t) flags_str_size); ecma_string_to_utf8_string (flags_str_p, flags_start_p, (ssize_t) flags_str_size);
lit_utf8_byte_t *flags_char_p = flags_start_p; lit_utf8_iterator_t iter = lit_utf8_iterator_create (flags_start_p, flags_str_size);
while (flags_char_p < flags_start_p + flags_str_size while (!lit_utf8_iterator_is_eos (&iter)
&& ecma_is_completion_value_empty (ret_value)) && ecma_is_completion_value_empty (ret_value))
{ {
switch (*flags_char_p) switch (lit_utf8_iterator_read_next (&iter))
{ {
case 'g': case 'g':
{ {
@@ -120,7 +119,6 @@ re_parse_regexp_flags (ecma_string_t *flags_str_p, /**< Input string with flags
break; break;
} }
} }
flags_char_p++;
} }
MEM_FINALIZE_LOCAL_ARRAY (flags_start_p); MEM_FINALIZE_LOCAL_ARRAY (flags_start_p);
@@ -231,48 +229,6 @@ ecma_op_create_regexp_object (ecma_string_t *pattern_p, /**< input pattern */
return ret_value; return ret_value;
} /* ecma_op_create_regexp_object */ } /* ecma_op_create_regexp_object */
/**
* Backtrack a unicode character
*/
static const lit_utf8_byte_t *
re_utf8_backtrack (const lit_utf8_byte_t *str_p)
{
/* FIXME: change to string iterator with unicode support, when it would be implemented */
return --str_p;
} /* re_utf8_backtrack */
/**
* Helper to get an input character and increase string pointer.
*/
static ecma_char_t
re_get_input_char (const lit_utf8_byte_t **char_p)
{
/* FIXME: change to string iterator with unicode support, when it would be implemented */
const lit_utf8_byte_t ch = **char_p;
(*char_p)++;
return ch;
} /* re_get_input_char */
/**
* Helper to get current input character, won't increase string pointer.
*/
static ecma_char_t
re_lookup_input_char (const lit_utf8_byte_t *str_p)
{
/* FIXME: change to string iterator with unicode support, when it would be implemented */
return *str_p;
} /* re_lookup_input_char */
/**
* Helper to get previous input character, won't decrease string pointer.
*/
static ecma_char_t
re_lookup_prev_char (const lit_utf8_byte_t *str_p)
{
/* FIXME: change to string iterator with unicode support, when it would be implemented */
return *(--str_p);
} /* re_lookup_prev_char */
/** /**
* Recursive function for RegExp matching. Tests for a regular expression * Recursive function for RegExp matching. Tests for a regular expression
* match and returns a MatchResult value. * match and returns a MatchResult value.
@@ -286,8 +242,8 @@ re_lookup_prev_char (const lit_utf8_byte_t *str_p)
static ecma_completion_value_t static ecma_completion_value_t
re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
re_bytecode_t *bc_p, /**< pointer to the current RegExp bytecode */ re_bytecode_t *bc_p, /**< pointer to the current RegExp bytecode */
const lit_utf8_byte_t *str_p, /**< pointer to the current input character */ lit_utf8_iterator_t iter, /**< input string iterator */
const lit_utf8_byte_t **res_p) /**< pointer to the matching substring */ lit_utf8_iterator_t *out_iter_p) /**< Output: matching substring iterator */
{ {
ecma_completion_value_t ret_value = ecma_make_empty_completion_value (); ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
re_opcode_t op; re_opcode_t op;
@@ -313,37 +269,52 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_MATCH: case RE_OP_MATCH:
{ {
JERRY_DDLOG ("Execute RE_OP_MATCH: match\n"); JERRY_DDLOG ("Execute RE_OP_MATCH: match\n");
*res_p = str_p; *out_iter_p = iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE); ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
return ret_value; /* match */ return ret_value; /* match */
} }
case RE_OP_CHAR: case RE_OP_CHAR:
{ {
uint32_t ch1 = re_get_value (&bc_p); if (lit_utf8_iterator_is_eos (&iter))
uint32_t ch2 = re_get_input_char (&str_p); {
re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
ecma_char_t ch1 = (ecma_char_t) re_get_value (&bc_p);
ecma_char_t ch2 = lit_utf8_iterator_read_next (&iter);
JERRY_DDLOG ("Character matching %d to %d: ", ch1, ch2); JERRY_DDLOG ("Character matching %d to %d: ", ch1, ch2);
if (ch2 == '\0' || ch1 != ch2) if (ch1 != ch2)
{ {
JERRY_DDLOG ("fail\n"); JERRY_DDLOG ("fail\n");
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} }
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
break; /* tail merge */ break; /* tail merge */
} }
case RE_OP_PERIOD: case RE_OP_PERIOD:
{ {
uint32_t ch1 = re_get_input_char (&str_p); if (lit_utf8_iterator_is_eos (&iter))
JERRY_DDLOG ("Period matching '.' to %d: ", ch1); {
re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
if (ch1 == '\n' || ch1 == '\0') ecma_char_t ch = lit_utf8_iterator_read_next (&iter);
JERRY_DDLOG ("Period matching '.' to %d: ", (uint32_t) ch);
if (lit_char_is_line_terminator (ch))
{ {
JERRY_DDLOG ("fail\n"); JERRY_DDLOG ("fail\n");
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} }
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
break; /* tail merge */ break; /* tail merge */
} }
@@ -351,7 +322,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
{ {
JERRY_DDLOG ("Execute RE_OP_ASSERT_START: "); JERRY_DDLOG ("Execute RE_OP_ASSERT_START: ");
if (str_p <= re_ctx_p->input_start_p) if ((iter.buf_p + iter.buf_pos.offset) <= re_ctx_p->input_start_p)
{ {
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
break; break;
@@ -364,7 +335,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} }
if (lit_char_is_line_terminator (re_lookup_prev_char (str_p))) if (lit_char_is_line_terminator (lit_utf8_iterator_peek_prev (&iter)))
{ {
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
break; break;
@@ -378,7 +349,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
{ {
JERRY_DDLOG ("Execute RE_OP_ASSERT_END: "); JERRY_DDLOG ("Execute RE_OP_ASSERT_END: ");
if (str_p >= re_ctx_p->input_end_p) if ((iter.buf_p + iter.buf_pos.offset) >= re_ctx_p->input_end_p)
{ {
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
break; /* tail merge */ break; /* tail merge */
@@ -391,7 +362,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} }
if (lit_char_is_line_terminator (re_lookup_input_char (str_p))) if (lit_char_is_line_terminator (lit_utf8_iterator_peek_next (&iter)))
{ {
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
break; /* tail merge */ break; /* tail merge */
@@ -406,27 +377,27 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
{ {
bool is_wordchar_left, is_wordchar_right; bool is_wordchar_left, is_wordchar_right;
if (str_p <= re_ctx_p->input_start_p) if ((iter.buf_p + iter.buf_pos.offset) <= re_ctx_p->input_start_p)
{ {
is_wordchar_left = false; /* not a wordchar */ is_wordchar_left = false; /* not a wordchar */
} }
else else
{ {
is_wordchar_left = lit_char_is_word_char (re_lookup_prev_char (str_p)); is_wordchar_left = lit_char_is_word_char (lit_utf8_iterator_peek_prev (&iter));
} }
if (str_p >= re_ctx_p->input_end_p) if ((iter.buf_p + iter.buf_pos.offset) >= re_ctx_p->input_end_p)
{ {
is_wordchar_right = false; /* not a wordchar */ is_wordchar_right = false; /* not a wordchar */
} }
else else
{ {
is_wordchar_right = lit_char_is_word_char (re_lookup_input_char (str_p)); is_wordchar_right = lit_char_is_word_char (lit_utf8_iterator_peek_next (&iter));
} }
if (op == RE_OP_ASSERT_WORD_BOUNDARY) if (op == RE_OP_ASSERT_WORD_BOUNDARY)
{ {
JERRY_DDLOG ("Execute RE_OP_ASSERT_WORD_BOUNDARY at %c: ", *str_p); JERRY_DDLOG ("Execute RE_OP_ASSERT_WORD_BOUNDARY: ");
if (is_wordchar_left == is_wordchar_right) if (is_wordchar_left == is_wordchar_right)
{ {
JERRY_DDLOG ("fail\n"); JERRY_DDLOG ("fail\n");
@@ -437,7 +408,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
else else
{ {
JERRY_ASSERT (op == RE_OP_ASSERT_NOT_WORD_BOUNDARY); JERRY_ASSERT (op == RE_OP_ASSERT_NOT_WORD_BOUNDARY);
JERRY_DDLOG ("Execute RE_OP_ASSERT_NOT_WORD_BOUNDARY at %c: ", *str_p); JERRY_DDLOG ("Execute RE_OP_ASSERT_NOT_WORD_BOUNDARY: ");
if (is_wordchar_left != is_wordchar_right) if (is_wordchar_left != is_wordchar_right)
{ {
@@ -454,19 +425,21 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_LOOKAHEAD_NEG: case RE_OP_LOOKAHEAD_NEG:
{ {
ecma_completion_value_t match_value = ecma_make_empty_completion_value (); ecma_completion_value_t match_value = ecma_make_empty_completion_value ();
const lit_utf8_byte_t *sub_str_p = NULL; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
MEM_DEFINE_LOCAL_ARRAY (saved_bck_p, re_ctx_p->num_of_captures, lit_utf8_byte_t *); uint32_t array_size = re_ctx_p->num_of_captures + re_ctx_p->num_of_non_captures;
size_t size = (size_t) (re_ctx_p->num_of_captures) * sizeof (const lit_utf8_byte_t *); MEM_DEFINE_LOCAL_ARRAY (saved_bck_p, array_size, lit_utf8_iterator_t);
size_t size = (size_t) (array_size) * sizeof (lit_utf8_iterator_t);
memcpy (saved_bck_p, re_ctx_p->saved_p, size); memcpy (saved_bck_p, re_ctx_p->saved_p, size);
do do
{ {
uint32_t offset = re_get_value (&bc_p); uint32_t offset = re_get_value (&bc_p);
if (!sub_str_p) if (!sub_iter.buf_p)
{ {
match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_completion_value_throw (match_value)) if (ecma_is_completion_value_throw (match_value))
{ {
break; break;
@@ -480,11 +453,11 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
{ {
JERRY_DDLOG ("Execute RE_OP_LOOKAHEAD_POS/NEG: "); JERRY_DDLOG ("Execute RE_OP_LOOKAHEAD_POS/NEG: ");
ecma_free_completion_value (match_value); ecma_free_completion_value (match_value);
if ((op == RE_OP_LOOKAHEAD_POS && sub_str_p) if ((op == RE_OP_LOOKAHEAD_POS && sub_iter.buf_p)
|| (op == RE_OP_LOOKAHEAD_NEG && !sub_str_p)) || (op == RE_OP_LOOKAHEAD_NEG && !sub_iter.buf_p))
{ {
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
} }
else else
{ {
@@ -499,7 +472,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
} }
else else
{ {
@@ -519,15 +492,14 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
bool is_match; bool is_match;
JERRY_DDLOG ("Execute RE_OP_CHAR_CLASS/RE_OP_INV_CHAR_CLASS, "); JERRY_DDLOG ("Execute RE_OP_CHAR_CLASS/RE_OP_INV_CHAR_CLASS, ");
if (lit_utf8_iterator_is_eos (&iter))
if (str_p >= re_ctx_p->input_end_p)
{ {
JERRY_DDLOG ("fail\n"); JERRY_DDLOG ("fail\n");
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} }
curr_ch = re_get_input_char (&str_p); curr_ch = lit_utf8_iterator_read_next (&iter);
num_of_ranges = re_get_value (&bc_p); num_of_ranges = re_get_value (&bc_p);
is_match = false; is_match = false;
@@ -573,34 +545,33 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_BACKREFERENCE: case RE_OP_BACKREFERENCE:
{ {
uint32_t backref_idx; uint32_t backref_idx;
const lit_utf8_byte_t *sub_str_p;
backref_idx = re_get_value (&bc_p); backref_idx = re_get_value (&bc_p);
JERRY_DDLOG ("Execute RE_OP_BACKREFERENCE (idx: %d): ", backref_idx); JERRY_DDLOG ("Execute RE_OP_BACKREFERENCE (idx: %d): ", backref_idx);
backref_idx *= 2; /* backref n -> saved indices [n*2, n*2+1] */ backref_idx *= 2; /* backref n -> saved indices [n*2, n*2+1] */
JERRY_ASSERT (backref_idx >= 2 && backref_idx + 1 < re_ctx_p->num_of_captures); JERRY_ASSERT (backref_idx >= 2 && backref_idx + 1 < re_ctx_p->num_of_captures);
if (!re_ctx_p->saved_p[backref_idx] || !re_ctx_p->saved_p[backref_idx + 1]) if (!re_ctx_p->saved_p[backref_idx].buf_p || !re_ctx_p->saved_p[backref_idx + 1].buf_p)
{ {
JERRY_DDLOG ("match\n"); JERRY_DDLOG ("match\n");
break; /* capture is 'undefined', always matches! */ break; /* capture is 'undefined', always matches! */
} }
sub_str_p = re_ctx_p->saved_p[backref_idx]; lit_utf8_iterator_t sub_iter = re_ctx_p->saved_p[backref_idx];
while (sub_str_p < re_ctx_p->saved_p[backref_idx + 1]) while (sub_iter.buf_pos.offset < re_ctx_p->saved_p[backref_idx + 1].buf_pos.offset)
{ {
uint32_t ch1, ch2; ecma_char_t ch1, ch2;
if (str_p >= re_ctx_p->input_end_p) if ((iter.buf_p + iter.buf_pos.offset) >= re_ctx_p->input_end_p)
{ {
JERRY_DDLOG ("fail\n"); JERRY_DDLOG ("fail\n");
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} }
ch1 = re_get_input_char (&sub_str_p); ch1 = lit_utf8_iterator_read_next (&sub_iter);
ch2 = re_get_input_char (&str_p); ch2 = lit_utf8_iterator_read_next (&iter);
if (ch1 != ch2) if (ch1 != ch2)
{ {
@@ -614,21 +585,20 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
} }
case RE_OP_SAVE_AT_START: case RE_OP_SAVE_AT_START:
{ {
const lit_utf8_byte_t *old_start_p;
re_bytecode_t *old_bc_p; re_bytecode_t *old_bc_p;
JERRY_DDLOG ("Execute RE_OP_SAVE_AT_START\n"); JERRY_DDLOG ("Execute RE_OP_SAVE_AT_START\n");
old_start_p = re_ctx_p->saved_p[RE_GLOBAL_START_IDX]; lit_utf8_iterator_t old_start_p = re_ctx_p->saved_p[RE_GLOBAL_START_IDX];
re_ctx_p->saved_p[RE_GLOBAL_START_IDX] = str_p; re_ctx_p->saved_p[RE_GLOBAL_START_IDX] = iter;
do do
{ {
uint32_t offset = re_get_value (&bc_p); uint32_t offset = re_get_value (&bc_p);
const lit_utf8_byte_t *sub_str_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -649,8 +619,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_SAVE_AND_MATCH: case RE_OP_SAVE_AND_MATCH:
{ {
JERRY_DDLOG ("End of pattern is reached: match\n"); JERRY_DDLOG ("End of pattern is reached: match\n");
re_ctx_p->saved_p[RE_GLOBAL_END_IDX] = str_p; re_ctx_p->saved_p[RE_GLOBAL_END_IDX] = iter;
*res_p = str_p; *out_iter_p = iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE); /* match */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE); /* match */
} }
@@ -682,8 +652,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
* after the group first, if zero iteration is allowed. * after the group first, if zero iteration is allowed.
*/ */
uint32_t start_idx, iter_idx, offset; uint32_t start_idx, iter_idx, offset;
const lit_utf8_byte_t *old_start_p; lit_utf8_iterator_t old_start = lit_utf8_iterator_create (NULL, 0);
const lit_utf8_byte_t *sub_str_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
re_bytecode_t *old_bc_p; re_bytecode_t *old_bc_p;
old_bc_p = bc_p; /* save the bytecode start position of the group start */ old_bc_p = bc_p; /* save the bytecode start position of the group start */
@@ -696,8 +666,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
iter_idx = start_idx - 1; iter_idx = start_idx - 1;
start_idx *= 2; start_idx *= 2;
old_start_p = re_ctx_p->saved_p[start_idx]; old_start = re_ctx_p->saved_p[start_idx];
re_ctx_p->saved_p[start_idx] = str_p; re_ctx_p->saved_p[start_idx] = iter;
} }
else else
{ {
@@ -711,11 +681,11 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
bc_p += offset; bc_p += offset;
/* Try to match after the close paren if zero is allowed */ /* Try to match after the close paren if zero is allowed */
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -725,7 +695,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
} }
if (RE_IS_CAPTURE_GROUP (op)) if (RE_IS_CAPTURE_GROUP (op))
{ {
re_ctx_p->saved_p[start_idx] = old_start_p; re_ctx_p->saved_p[start_idx] = old_start;
} }
bc_p = old_bc_p; bc_p = old_bc_p;
@@ -737,8 +707,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START: case RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START:
{ {
uint32_t start_idx, iter_idx, old_iteration_cnt, offset; uint32_t start_idx, iter_idx, old_iteration_cnt, offset;
const lit_utf8_byte_t *old_start_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
const lit_utf8_byte_t *sub_str_p;
re_bytecode_t *old_bc_p; re_bytecode_t *old_bc_p;
re_bytecode_t *end_bc_p = NULL; re_bytecode_t *end_bc_p = NULL;
start_idx = re_get_value (&bc_p); start_idx = re_get_value (&bc_p);
@@ -762,18 +731,19 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
iter_idx = start_idx + (re_ctx_p->num_of_captures / 2) - 1; iter_idx = start_idx + (re_ctx_p->num_of_captures / 2) - 1;
start_idx += re_ctx_p->num_of_captures; start_idx += re_ctx_p->num_of_captures;
} }
old_start_p = re_ctx_p->saved_p[start_idx];
lit_utf8_iterator_t old_start = re_ctx_p->saved_p[start_idx];
old_iteration_cnt = re_ctx_p->num_of_iterations_p[iter_idx]; old_iteration_cnt = re_ctx_p->num_of_iterations_p[iter_idx];
re_ctx_p->saved_p[start_idx] = str_p; re_ctx_p->saved_p[start_idx] = iter;
re_ctx_p->num_of_iterations_p[iter_idx] = 0; re_ctx_p->num_of_iterations_p[iter_idx] = 0;
do do
{ {
offset = re_get_value (&bc_p); offset = re_get_value (&bc_p);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -793,11 +763,11 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
|| op == RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START) || op == RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START)
{ {
JERRY_ASSERT (end_bc_p); JERRY_ASSERT (end_bc_p);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, end_bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, end_bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -807,7 +777,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
} }
} }
re_ctx_p->saved_p[start_idx] = old_start_p; re_ctx_p->saved_p[start_idx] = old_start;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} }
@@ -815,7 +785,6 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_NON_CAPTURE_NON_GREEDY_GROUP_END: case RE_OP_NON_CAPTURE_NON_GREEDY_GROUP_END:
{ {
uint32_t end_idx, iter_idx, min, max; uint32_t end_idx, iter_idx, min, max;
const lit_utf8_byte_t *old_end_p;
re_bytecode_t *old_bc_p; re_bytecode_t *old_bc_p;
/* /*
@@ -846,14 +815,14 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
if (re_ctx_p->num_of_iterations_p[iter_idx] >= min if (re_ctx_p->num_of_iterations_p[iter_idx] >= min
&& re_ctx_p->num_of_iterations_p[iter_idx] <= max) && re_ctx_p->num_of_iterations_p[iter_idx] <= max)
{ {
old_end_p = re_ctx_p->saved_p[end_idx]; lit_utf8_iterator_t old_end = re_ctx_p->saved_p[end_idx];
re_ctx_p->saved_p[end_idx] = str_p; re_ctx_p->saved_p[end_idx] = iter;
const lit_utf8_byte_t *sub_str_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -862,7 +831,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
return match_value; return match_value;
} }
re_ctx_p->saved_p[end_idx] = old_end_p; re_ctx_p->saved_p[end_idx] = old_end;
} }
re_ctx_p->num_of_iterations_p[iter_idx]--; re_ctx_p->num_of_iterations_p[iter_idx]--;
bc_p = old_bc_p; bc_p = old_bc_p;
@@ -874,9 +843,9 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_NON_CAPTURE_GREEDY_GROUP_END: case RE_OP_NON_CAPTURE_GREEDY_GROUP_END:
{ {
uint32_t start_idx, end_idx, iter_idx, min, max, offset; uint32_t start_idx, end_idx, iter_idx, min, max, offset;
const lit_utf8_byte_t *old_start_p; lit_utf8_iterator_t old_start = lit_utf8_iterator_create (NULL, 0);
const lit_utf8_byte_t *old_end_p; lit_utf8_iterator_t old_end = lit_utf8_iterator_create (NULL, 0);
const lit_utf8_byte_t *sub_str_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
re_bytecode_t *old_bc_p; re_bytecode_t *old_bc_p;
end_idx = re_get_value (&bc_p); end_idx = re_get_value (&bc_p);
@@ -901,7 +870,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
/* Check the empty iteration if the minimum number of iterations is reached. */ /* Check the empty iteration if the minimum number of iterations is reached. */
if (re_ctx_p->num_of_iterations_p[iter_idx] >= min if (re_ctx_p->num_of_iterations_p[iter_idx] >= min
&& str_p == re_ctx_p->saved_p[start_idx]) && iter.buf_p == re_ctx_p->saved_p[start_idx].buf_p
&& iter.buf_pos.offset == re_ctx_p->saved_p[start_idx].buf_pos.offset)
{ {
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
@@ -910,21 +880,21 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
re_ctx_p->num_of_iterations_p[iter_idx]++; re_ctx_p->num_of_iterations_p[iter_idx]++;
old_bc_p = bc_p; /* Save the bytecode end position of the END opcodes for matching after it. */ old_bc_p = bc_p; /* Save the bytecode end position of the END opcodes for matching after it. */
old_end_p = re_ctx_p->saved_p[end_idx]; old_end = re_ctx_p->saved_p[end_idx];
re_ctx_p->saved_p[end_idx] = str_p; re_ctx_p->saved_p[end_idx] = iter;
if (re_ctx_p->num_of_iterations_p[iter_idx] < max) if (re_ctx_p->num_of_iterations_p[iter_idx] < max)
{ {
bc_p -= offset; bc_p -= offset;
offset = re_get_value (&bc_p); offset = re_get_value (&bc_p);
old_start_p = re_ctx_p->saved_p[start_idx]; old_start = re_ctx_p->saved_p[start_idx];
re_ctx_p->saved_p[start_idx] = str_p; re_ctx_p->saved_p[start_idx] = iter;
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -933,7 +903,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
return match_value; return match_value;
} }
re_ctx_p->saved_p[start_idx] = old_start_p; re_ctx_p->saved_p[start_idx] = old_start;
/* Try to match alternatives if any. */ /* Try to match alternatives if any. */
bc_p += offset; bc_p += offset;
@@ -942,14 +912,14 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
bc_p++; /* RE_OP_ALTERNATIVE */ bc_p++; /* RE_OP_ALTERNATIVE */
offset = re_get_value (&bc_p); offset = re_get_value (&bc_p);
old_start_p = re_ctx_p->saved_p[start_idx]; old_start = re_ctx_p->saved_p[start_idx];
re_ctx_p->saved_p[start_idx] = str_p; re_ctx_p->saved_p[start_idx] = iter;
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -958,7 +928,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
return match_value; return match_value;
} }
re_ctx_p->saved_p[start_idx] = old_start_p; re_ctx_p->saved_p[start_idx] = old_start;
bc_p += offset; bc_p += offset;
} }
} }
@@ -967,11 +937,11 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
&& re_ctx_p->num_of_iterations_p[iter_idx] <= max) && re_ctx_p->num_of_iterations_p[iter_idx] <= max)
{ {
/* Try to match the rest of the bytecode. */ /* Try to match the rest of the bytecode. */
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, old_bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, old_bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -982,7 +952,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
} }
/* restore if fails */ /* restore if fails */
re_ctx_p->saved_p[end_idx] = old_end_p; re_ctx_p->saved_p[end_idx] = old_end;
re_ctx_p->num_of_iterations_p[iter_idx]--; re_ctx_p->num_of_iterations_p[iter_idx]--;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */ return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
@@ -990,7 +960,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_NON_GREEDY_ITERATOR: case RE_OP_NON_GREEDY_ITERATOR:
{ {
uint32_t min, max, offset, num_of_iter; uint32_t min, max, offset, num_of_iter;
const lit_utf8_byte_t *sub_str_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
min = re_get_value (&bc_p); min = re_get_value (&bc_p);
max = re_get_value (&bc_p); max = re_get_value (&bc_p);
@@ -1004,11 +974,11 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
{ {
if (num_of_iter >= min) if (num_of_iter >= min)
{ {
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p + offset, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p + offset, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -1018,7 +988,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
} }
} }
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (!ecma_is_value_true (match_value)) if (!ecma_is_value_true (match_value))
{ {
@@ -1029,7 +999,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
break; break;
} }
str_p = sub_str_p;
iter = sub_iter;
num_of_iter++; num_of_iter++;
} }
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
@@ -1038,7 +1009,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
case RE_OP_GREEDY_ITERATOR: case RE_OP_GREEDY_ITERATOR:
{ {
uint32_t min, max, offset, num_of_iter; uint32_t min, max, offset, num_of_iter;
const lit_utf8_byte_t *sub_str_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
min = re_get_value (&bc_p); min = re_get_value (&bc_p);
max = re_get_value (&bc_p); max = re_get_value (&bc_p);
@@ -1051,7 +1022,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
while (num_of_iter < max) while (num_of_iter < max)
{ {
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (!ecma_is_value_true (match_value)) if (!ecma_is_value_true (match_value))
{ {
if (ecma_is_completion_value_throw (match_value)) if (ecma_is_completion_value_throw (match_value))
@@ -1061,17 +1033,18 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
break; break;
} }
str_p = sub_str_p;
iter = sub_iter;
num_of_iter++; num_of_iter++;
} }
while (num_of_iter >= min) while (num_of_iter >= min)
{ {
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p + offset, str_p, &sub_str_p); ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p + offset, iter, &sub_iter);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
*res_p = sub_str_p; *out_iter_p = sub_iter;
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
return match_value; /* match */ return match_value; /* match */
} }
@@ -1085,7 +1058,7 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
break; break;
} }
str_p = re_utf8_backtrack (str_p); lit_utf8_iterator_read_prev (&iter);
num_of_iter--; num_of_iter--;
} }
re_ctx_p->recursion_depth--; re_ctx_p->recursion_depth--;
@@ -1205,14 +1178,12 @@ re_set_result_array_properties (ecma_object_t *array_obj_p, /**< result array */
ecma_completion_value_t ecma_completion_value_t
ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
re_bytecode_t *bc_p, /**< start of the RegExp bytecode */ re_bytecode_t *bc_p, /**< start of the RegExp bytecode */
const lit_utf8_byte_t *str_p, /**< start of the input string */ lit_utf8_iterator_t *iter_p) /**< input string iterator */
lit_utf8_size_t str_size) /**< size of the input string */
{ {
ecma_completion_value_t ret_value = ecma_make_empty_completion_value (); ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
lit_utf8_size_t input_size = str_size;
re_matcher_ctx_t re_ctx; re_matcher_ctx_t re_ctx;
re_ctx.input_start_p = str_p; re_ctx.input_start_p = iter_p->buf_p;
re_ctx.input_end_p = str_p + str_size; re_ctx.input_end_p = iter_p->buf_p + iter_p->buf_size;
re_ctx.match_limit = 0; re_ctx.match_limit = 0;
re_ctx.recursion_depth = 0; re_ctx.recursion_depth = 0;
@@ -1227,11 +1198,11 @@ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
JERRY_ASSERT (re_ctx.num_of_captures % 2 == 0); JERRY_ASSERT (re_ctx.num_of_captures % 2 == 0);
re_ctx.num_of_non_captures = re_get_value (&bc_p); re_ctx.num_of_non_captures = re_get_value (&bc_p);
MEM_DEFINE_LOCAL_ARRAY (saved_p, re_ctx.num_of_captures + re_ctx.num_of_non_captures, const lit_utf8_byte_t *); MEM_DEFINE_LOCAL_ARRAY (saved_p, re_ctx.num_of_captures + re_ctx.num_of_non_captures, lit_utf8_iterator_t);
for (uint32_t i = 0; i < re_ctx.num_of_captures + re_ctx.num_of_non_captures; i++) for (uint32_t i = 0; i < re_ctx.num_of_captures + re_ctx.num_of_non_captures; i++)
{ {
saved_p[i] = NULL; saved_p[i] = lit_utf8_iterator_create (NULL, 0);
} }
re_ctx.saved_p = saved_p; re_ctx.saved_p = saved_p;
@@ -1246,24 +1217,30 @@ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
bool is_match = false; bool is_match = false;
re_ctx.num_of_iterations_p = num_of_iter_p; re_ctx.num_of_iterations_p = num_of_iter_p;
int32_t index = 0; int32_t index = 0;
ecma_length_t input_str_len = lit_utf8_string_length (iter_p->buf_p, iter_p->buf_size);
if (re_ctx.flags & RE_FLAG_GLOBAL) if (iter_p->buf_p && re_ctx.flags & RE_FLAG_GLOBAL)
{ {
ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL); ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
ecma_property_t *lastindex_prop_p = ecma_op_object_get_property (obj_p, magic_str_p); ecma_property_t *lastindex_prop_p = ecma_op_object_get_property (obj_p, magic_str_p);
ecma_number_t *lastindex_num_p = ecma_get_number_from_value (lastindex_prop_p->u.named_data_property.value); ecma_number_t *lastindex_num_p = ecma_get_number_from_value (lastindex_prop_p->u.named_data_property.value);
index = ecma_number_to_int32 (*lastindex_num_p); index = ecma_number_to_int32 (*lastindex_num_p);
JERRY_ASSERT (str_p != NULL);
str_p += ecma_number_to_int32 (*lastindex_num_p); JERRY_ASSERT (iter_p->buf_pos.offset == 0 && !iter_p->buf_pos.is_non_bmp_middle);
if (!lit_utf8_iterator_is_eos (iter_p)
&& *lastindex_num_p <= input_str_len)
{
lit_utf8_iterator_advance (iter_p, (ecma_length_t) *lastindex_num_p);
}
ecma_deref_ecma_string (magic_str_p); ecma_deref_ecma_string (magic_str_p);
} }
/* 2. Try to match */ /* 2. Try to match */
const lit_utf8_byte_t *sub_str_p; lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
while (str_p && str_p <= re_ctx.input_end_p && ecma_is_completion_value_empty (ret_value)) while (ecma_is_completion_value_empty (ret_value))
{ {
if (index < 0 || index > (int32_t) input_size) if (index < 0 || index > (int32_t) input_str_len)
{ {
ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL); ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
ecma_number_t *lastindex_num_p = ecma_alloc_number (); ecma_number_t *lastindex_num_p = ecma_alloc_number ();
@@ -1277,8 +1254,7 @@ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
} }
else else
{ {
sub_str_p = NULL; ECMA_TRY_CATCH (match_value, re_match_regexp (&re_ctx, bc_p, *iter_p, &sub_iter), ret_value);
ECMA_TRY_CATCH (match_value, re_match_regexp (&re_ctx, bc_p, str_p, &sub_str_p), ret_value);
if (ecma_is_value_true (match_value)) if (ecma_is_value_true (match_value))
{ {
@@ -1286,17 +1262,21 @@ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
break; break;
} }
str_p++; if (!lit_utf8_iterator_is_eos (iter_p))
{
lit_utf8_iterator_advance (iter_p, 1);
}
index++; index++;
ECMA_FINALIZE (match_value); ECMA_FINALIZE (match_value);
} }
} }
if (re_ctx.flags & RE_FLAG_GLOBAL) if (iter_p->buf_p && re_ctx.flags & RE_FLAG_GLOBAL)
{ {
ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL); ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
ecma_number_t *lastindex_num_p = ecma_alloc_number (); ecma_number_t *lastindex_num_p = ecma_alloc_number ();
*lastindex_num_p = ((ecma_number_t) (sub_str_p - re_ctx.input_start_p)); *lastindex_num_p = sub_iter.buf_pos.offset;
ecma_op_object_put (obj_p, magic_str_p, ecma_make_number_value (lastindex_num_p), true); ecma_op_object_put (obj_p, magic_str_p, ecma_make_number_value (lastindex_num_p), true);
ecma_dealloc_number (lastindex_num_p); ecma_dealloc_number (lastindex_num_p);
ecma_deref_ecma_string (magic_str_p); ecma_deref_ecma_string (magic_str_p);
@@ -1316,14 +1296,19 @@ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
{ {
ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 (i / 2); ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 (i / 2);
if (re_ctx.saved_p[i] && re_ctx.saved_p[i + 1] && re_ctx.saved_p[i + 1] >= re_ctx.saved_p[i]) /* Note: 'iter_p->buf_p == NULL' means the input is empty string */
if (((re_ctx.saved_p[i].buf_p && re_ctx.saved_p[i + 1].buf_p)
|| (!iter_p->buf_p && !re_ctx.saved_p[i].buf_p && !re_ctx.saved_p[i + 1].buf_p))
&& re_ctx.saved_p[i + 1].buf_pos.offset >= re_ctx.saved_p[i].buf_pos.offset)
{ {
ecma_length_t capture_str_len = static_cast<ecma_length_t> (re_ctx.saved_p[i + 1] - re_ctx.saved_p[i]); ecma_length_t capture_str_len;
capture_str_len = (ecma_length_t) re_ctx.saved_p[i + 1].buf_pos.offset - re_ctx.saved_p[i].buf_pos.offset;
ecma_string_t *capture_str_p; ecma_string_t *capture_str_p;
if (capture_str_len > 0) if (capture_str_len > 0)
{ {
capture_str_p = ecma_new_ecma_string_from_utf8 (re_ctx.saved_p[i], capture_str_len); const lit_utf8_byte_t *utf8_str_p = re_ctx.saved_p[i].buf_p + re_ctx.saved_p[i].buf_pos.offset;
capture_str_p = ecma_new_ecma_string_from_utf8 (utf8_str_p, capture_str_len);
} }
else else
{ {
jerry-core/ecma/operations/ecma-regexp-object.h
+2 -3
View File
@@ -44,7 +44,7 @@
*/ */
typedef struct typedef struct
{ {
const lit_utf8_byte_t **saved_p; /**< saved result string pointers, ECMA 262 v5, 15.10.2.1, State */ lit_utf8_iterator_t *saved_p; /**< saved result string pointers, ECMA 262 v5, 15.10.2.1, State */
const lit_utf8_byte_t *input_start_p; /**< start of input pattern string */ const lit_utf8_byte_t *input_start_p; /**< start of input pattern string */
const lit_utf8_byte_t *input_end_p; /**< end of input pattern string */ const lit_utf8_byte_t *input_end_p; /**< end of input pattern string */
uint32_t match_limit; /**< matching limit counter */ uint32_t match_limit; /**< matching limit counter */
@@ -61,8 +61,7 @@ ecma_op_create_regexp_object (ecma_string_t *pattern_p, ecma_string_t *flags_str
extern ecma_completion_value_t extern ecma_completion_value_t
ecma_regexp_exec_helper (ecma_object_t *obj_p, ecma_regexp_exec_helper (ecma_object_t *obj_p,
re_bytecode_t *bc_p, re_bytecode_t *bc_p,
const lit_utf8_byte_t *str_p, lit_utf8_iterator_t *iter_p);
lit_utf8_size_t str_size);
/** /**
* @} * @}
jerry-core/parser/regexp/re-compiler.cpp
+17 -8
View File
@@ -554,14 +554,20 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false); re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false);
break; break;
} }
case RE_TOK_DIGIT:
case RE_TOK_NOT_DIGIT:
case RE_TOK_WHITE:
case RE_TOK_NOT_WHITE:
case RE_TOK_WORD_CHAR:
case RE_TOK_NOT_WORD_CHAR:
case RE_TOK_START_CHAR_CLASS: case RE_TOK_START_CHAR_CLASS:
case RE_TOK_START_INV_CHAR_CLASS: case RE_TOK_START_INV_CHAR_CLASS:
{ {
JERRY_DDLOG ("Compile a character class\n"); JERRY_DDLOG ("Compile a character class\n");
re_append_opcode (bc_ctx_p, re_append_opcode (bc_ctx_p,
re_ctx_p->current_token.type == RE_TOK_START_CHAR_CLASS re_ctx_p->current_token.type == RE_TOK_START_INV_CHAR_CLASS
? RE_OP_CHAR_CLASS ? RE_OP_INV_CHAR_CLASS
: RE_OP_INV_CHAR_CLASS); : RE_OP_CHAR_CLASS);
uint32_t offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p); uint32_t offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
ECMA_TRY_CATCH (empty, ECMA_TRY_CATCH (empty,
@@ -578,6 +584,11 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
} }
ECMA_FINALIZE (empty); ECMA_FINALIZE (empty);
if (ecma_is_completion_value_throw (ret_value))
{
return ret_value; /* error */
}
break; break;
} }
case RE_TOK_END_GROUP: case RE_TOK_END_GROUP:
@@ -648,15 +659,13 @@ re_compile_bytecode (ecma_property_t *bytecode_p, /**< bytecode */
re_ctx.bytecode_ctx_p = &bc_ctx; re_ctx.bytecode_ctx_p = &bc_ctx;
lit_utf8_size_t pattern_str_size = ecma_string_get_size (pattern_str_p); lit_utf8_size_t pattern_str_size = ecma_string_get_size (pattern_str_p);
MEM_DEFINE_LOCAL_ARRAY (pattern_start_p, pattern_str_size + 1, lit_utf8_byte_t); MEM_DEFINE_LOCAL_ARRAY (pattern_start_p, pattern_str_size, lit_utf8_byte_t);
ecma_string_to_utf8_string (pattern_str_p, pattern_start_p, (ssize_t) pattern_str_size); ecma_string_to_utf8_string (pattern_str_p, pattern_start_p, (ssize_t) pattern_str_size);
FIXME ("Update regexp compiler so that zero symbol is not needed."); lit_utf8_iterator_t iter = lit_utf8_iterator_create (pattern_start_p, pattern_str_size);
pattern_start_p[pattern_str_size] = LIT_BYTE_NULL;
re_parser_ctx_t parser_ctx; re_parser_ctx_t parser_ctx;
parser_ctx.pattern_start_p = pattern_start_p; parser_ctx.iter = iter;
parser_ctx.current_char_p = pattern_start_p;
parser_ctx.num_of_groups = -1; parser_ctx.num_of_groups = -1;
re_ctx.parser_ctx_p = &parser_ctx; re_ctx.parser_ctx_p = &parser_ctx;
jerry-core/parser/regexp/re-parser.cpp
+285 -204
View File
@@ -19,31 +19,36 @@
#include "ecma-try-catch-macro.h" #include "ecma-try-catch-macro.h"
#include "jrt-libc-includes.h" #include "jrt-libc-includes.h"
#include "lit-char-helpers.h" #include "lit-char-helpers.h"
#include "re-compiler.h"
#include "re-parser.h" #include "re-parser.h"
#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN #ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN
/* FIXME: change it, when unicode support would be implemented */
#define RE_LOOKUP(str_p, lookup) ((lit_zt_utf8_string_size (str_p) > (lookup)) \
? (ecma_char_t) str_p[lookup] \
: (ecma_char_t) '\0')
/* FIXME: change it, when unicode support would be implemented */
#define RE_ADVANCE(str_p, advance) do { str_p += advance; } while (0)
/** /**
* Get next input character * Lookup a character in the input string.
* *
* @return ecma_char_t * @return unicode codeunit
*/ */
static ecma_char_t static ecma_char_t
re_get_ecma_char (lit_utf8_byte_t **char_p) /**< pointer of input string */ re_lookup (lit_utf8_iterator_t iter, /**< input string iterator */
uint32_t lookup) /**< size of lookup */
{ {
/* FIXME: change to string iterator with unicode support, when it would be implemented */ ecma_char_t ch = 0;
ecma_char_t ch = **char_p; for (uint32_t i = 0; i <= lookup; i++)
RE_ADVANCE (*char_p, 1); {
if (!lit_utf8_iterator_is_eos (&iter))
{
ch = lit_utf8_iterator_read_next (&iter);
}
else
{
ch = 0;
break;
}
}
return ch; return ch;
} /* re_get_ecma_char */ } /* re_lookup */
/** /**
* Parse RegExp iterators * Parse RegExp iterators
@@ -52,24 +57,24 @@ re_get_ecma_char (lit_utf8_byte_t **char_p) /**< pointer of input string */
* Returned value must be freed with ecma_free_completion_value * Returned value must be freed with ecma_free_completion_value
*/ */
static ecma_completion_value_t static ecma_completion_value_t
re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */ re_parse_iterator (lit_utf8_iterator_t iter, /**< RegExp pattern */
re_token_t *re_token_p, /**< output token */ re_token_t *re_token_p, /**< output token */
uint32_t lookup, /**< size of lookup */ uint32_t lookup, /**< size of lookup */
uint32_t *advance_p) /**< output length of current advance */ uint32_t *advance_p) /**< output length of current advance */
{ {
ecma_completion_value_t ret_value = ecma_make_empty_completion_value (); ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
ecma_char_t ch0 = RE_LOOKUP (pattern_p, lookup); ecma_char_t ch0 = re_lookup (iter, lookup);
ecma_char_t ch1 = RE_LOOKUP (pattern_p, lookup + 1); ecma_char_t ch1 = re_lookup (iter, lookup + 1);
switch (ch0) switch (ch0)
{ {
case '?': case LIT_CHAR_QUESTION:
{ {
re_token_p->qmin = 0; re_token_p->qmin = 0;
re_token_p->qmax = 1; re_token_p->qmax = 1;
if (ch1 == '?') if (ch1 == LIT_CHAR_QUESTION)
{ {
*advance_p = 2; *advance_p = 2;
re_token_p->greedy = false; re_token_p->greedy = false;
@@ -81,12 +86,12 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
} }
break; break;
} }
case '*': case LIT_CHAR_ASTERISK:
{ {
re_token_p->qmin = 0; re_token_p->qmin = 0;
re_token_p->qmax = RE_ITERATOR_INFINITE; re_token_p->qmax = RE_ITERATOR_INFINITE;
if (ch1 == '?') if (ch1 == LIT_CHAR_QUESTION)
{ {
*advance_p = 2; *advance_p = 2;
re_token_p->greedy = false; re_token_p->greedy = false;
@@ -98,12 +103,12 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
} }
break; break;
} }
case '+': case LIT_CHAR_PLUS:
{ {
re_token_p->qmin = 1; re_token_p->qmin = 1;
re_token_p->qmax = RE_ITERATOR_INFINITE; re_token_p->qmax = RE_ITERATOR_INFINITE;
if (ch1 == '?') if (ch1 == LIT_CHAR_QUESTION)
{ {
*advance_p = 2; *advance_p = 2;
re_token_p->greedy = false; re_token_p->greedy = false;
@@ -115,7 +120,7 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
} }
break; break;
} }
case '{': case LIT_CHAR_LEFT_BRACE:
{ {
uint32_t qmin = 0; uint32_t qmin = 0;
uint32_t qmax = RE_ITERATOR_INFINITE; uint32_t qmax = RE_ITERATOR_INFINITE;
@@ -124,7 +129,7 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
while (true) while (true)
{ {
(*advance_p)++; (*advance_p)++;
ch1 = RE_LOOKUP (pattern_p, lookup + *advance_p); ch1 = re_lookup (iter, lookup + *advance_p);
if (lit_char_is_decimal_digit (ch1)) if (lit_char_is_decimal_digit (ch1))
{ {
@@ -136,14 +141,14 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
digits++; digits++;
qmin = qmin * 10 + lit_char_hex_to_int (ch1); qmin = qmin * 10 + lit_char_hex_to_int (ch1);
} }
else if (ch1 == ',') else if (ch1 == LIT_CHAR_COMMA)
{ {
if (qmax != RE_ITERATOR_INFINITE) if (qmax != RE_ITERATOR_INFINITE)
{ {
ret_value = ecma_raise_syntax_error ("RegExp quantifier error: double comma."); ret_value = ecma_raise_syntax_error ("RegExp quantifier error: double comma.");
return ret_value; return ret_value;
} }
if ((RE_LOOKUP (pattern_p, lookup + *advance_p + 1)) == '}') if ((re_lookup (iter, lookup + *advance_p + 1)) == LIT_CHAR_RIGHT_BRACE)
{ {
if (digits == 0) if (digits == 0)
{ {
@@ -160,7 +165,7 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
qmin = 0; qmin = 0;
digits = 0; digits = 0;
} }
else if (ch1 == '}') else if (ch1 == LIT_CHAR_RIGHT_BRACE)
{ {
if (digits == 0) if (digits == 0)
{ {
@@ -189,7 +194,7 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
} }
} }
if ((RE_LOOKUP (pattern_p, lookup + *advance_p)) == '?') if ((re_lookup (iter, lookup + *advance_p)) == LIT_CHAR_QUESTION)
{ {
re_token_p->greedy = false; re_token_p->greedy = false;
*advance_p += 1; *advance_p += 1;
@@ -228,29 +233,28 @@ re_parse_iterator (lit_utf8_byte_t *pattern_p, /**< RegExp pattern */
static void static void
re_count_num_of_groups (re_parser_ctx_t *parser_ctx_p) /**< RegExp parser context */ re_count_num_of_groups (re_parser_ctx_t *parser_ctx_p) /**< RegExp parser context */
{ {
lit_utf8_byte_t *pattern_p = parser_ctx_p->pattern_start_p;
ecma_char_t ch1;
int char_class_in = 0; int char_class_in = 0;
parser_ctx_p->num_of_groups = 0; parser_ctx_p->num_of_groups = 0;
ch1 = re_get_ecma_char (&pattern_p); lit_utf8_iterator_t iter = lit_utf8_iterator_create (parser_ctx_p->iter.buf_p,
parser_ctx_p->iter.buf_size);
while (ch1 != LIT_CHAR_NULL) while (!lit_utf8_iterator_is_eos (&iter))
{ {
ecma_char_t ch0 = ch1; ecma_char_t ch0 = lit_utf8_iterator_read_next (&iter);
ch1 = re_get_ecma_char (&pattern_p);
switch (ch0) switch (ch0)
{ {
case '\\': case LIT_CHAR_BACKSLASH:
{ {
ch1 = re_get_ecma_char (&pattern_p); lit_utf8_iterator_advance (&iter, 1);
break; break;
} }
case '[': case LIT_CHAR_LEFT_SQUARE:
{ {
char_class_in++; char_class_in++;
break; break;
} }
case ']': case LIT_CHAR_RIGHT_SQUARE:
{ {
if (!char_class_in) if (!char_class_in)
{ {
@@ -258,9 +262,11 @@ re_count_num_of_groups (re_parser_ctx_t *parser_ctx_p) /**< RegExp parser contex
} }
break; break;
} }
case '(': case LIT_CHAR_LEFT_PAREN:
{ {
if (ch1 != '?' && !char_class_in) if (!lit_utf8_iterator_is_eos (&iter)
&& lit_utf8_iterator_peek_next (&iter) != LIT_CHAR_QUESTION
&& !char_class_in)
{ {
parser_ctx_p->num_of_groups++; parser_ctx_p->num_of_groups++;
} }
@@ -285,18 +291,24 @@ re_parse_char_class (re_parser_ctx_t *parser_ctx_p, /**< number of classes */
re_token_t *out_token_p) /**< output token */ re_token_t *out_token_p) /**< output token */
{ {
ecma_completion_value_t ret_value = ecma_make_empty_completion_value (); ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
lit_utf8_byte_t **pattern_p = &(parser_ctx_p->current_char_p);
re_token_type_t token_type = ((re_compiler_ctx_t *) re_ctx_p)->current_token.type;
out_token_p->qmax = out_token_p->qmin = 1; out_token_p->qmax = out_token_p->qmin = 1;
ecma_char_t start = RE_CHAR_UNDEF; uint32_t start = RE_CHAR_UNDEF;
bool is_range = false; bool is_range = false;
parser_ctx_p->num_of_classes = 0; parser_ctx_p->num_of_classes = 0;
do do
{ {
ecma_char_t ch = re_get_ecma_char (pattern_p); if (lit_utf8_iterator_is_eos (&(parser_ctx_p->iter)))
{
ret_value = ecma_raise_syntax_error ("invalid character class");
return ret_value;
}
if (ch == ']') uint32_t ch = lit_utf8_iterator_read_next (&(parser_ctx_p->iter));
if (ch == LIT_CHAR_RIGHT_SQUARE)
{ {
if (start != RE_CHAR_UNDEF) if (start != RE_CHAR_UNDEF)
{ {
@@ -304,129 +316,171 @@ re_parse_char_class (re_parser_ctx_t *parser_ctx_p, /**< number of classes */
} }
break; break;
} }
else if (ch == '-') else if (ch == LIT_CHAR_MINUS)
{ {
if (start != RE_CHAR_UNDEF && !is_range && RE_LOOKUP (*pattern_p, 0) != ']') if (start != RE_CHAR_UNDEF && !is_range && re_lookup (parser_ctx_p->iter, 0) != LIT_CHAR_RIGHT_SQUARE)
{ {
is_range = true; is_range = true;
continue; continue;
} }
} }
else if (ch == '\\') else if (ch == LIT_CHAR_BACKSLASH)
{ {
ch = re_get_ecma_char (pattern_p); if (lit_utf8_iterator_is_eos (&(parser_ctx_p->iter)))
{
ret_value = ecma_raise_syntax_error ("invalid character class");
return ret_value;
}
if (ch == 'b') ch = lit_utf8_iterator_read_next (&(parser_ctx_p->iter));
if (ch == LIT_CHAR_LOWERCASE_B)
{ {
ch = RE_CONTROL_CHAR_BEL; ch = LIT_CHAR_BS;
} }
else if (ch == 'f') else if (ch == LIT_CHAR_LOWERCASE_F)
{ {
ch = RE_CONTROL_CHAR_FF; ch = LIT_CHAR_FF;
} }
else if (ch == 'n') else if (ch == LIT_CHAR_LOWERCASE_N)
{ {
ch = RE_CONTROL_CHAR_EOL; ch = LIT_CHAR_LF;
} }
else if (ch == 't') else if (ch == LIT_CHAR_LOWERCASE_T)
{ {
ch = RE_CONTROL_CHAR_TAB; ch = LIT_CHAR_TAB;
} }
else if (ch == 'r') else if (ch == LIT_CHAR_LOWERCASE_R)
{ {
ch = RE_CONTROL_CHAR_CR; ch = LIT_CHAR_CR;
} }
else if (ch == 'v') else if (ch == LIT_CHAR_LOWERCASE_V)
{ {
ch = RE_CONTROL_CHAR_VT; ch = LIT_CHAR_VTAB;
} }
else if (ch == 'c') else if (ch == LIT_CHAR_LOWERCASE_C)
{ {
ch = re_get_ecma_char (pattern_p); if (lit_utf8_iterator_is_eos (&(parser_ctx_p->iter)))
if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
{ {
ch = (ch % 32); ret_value = ecma_raise_syntax_error ("decode error");
}
else
{
ret_value = ecma_raise_syntax_error ("invalid regexp control escape");
return ret_value; return ret_value;
} }
if (lit_utf8_iterator_is_eos (&(parser_ctx_p->iter)))
{
ret_value = ecma_raise_syntax_error ("invalid character class");
return ret_value;
}
ch = lit_utf8_iterator_read_next (&(parser_ctx_p->iter));
if ((ch >= LIT_CHAR_ASCII_UPPERCASE_LETTERS_BEGIN && ch <= LIT_CHAR_ASCII_UPPERCASE_LETTERS_END)
|| (ch >= LIT_CHAR_ASCII_LOWERCASE_LETTERS_BEGIN && ch <= LIT_CHAR_ASCII_LOWERCASE_LETTERS_END))
{
/* See ECMA-262 v5, 15.10.2.10 (Point 3) */
ch = (ch % 32);
}
} }
else if (ch == 'x') else if (ch == LIT_CHAR_LOWERCASE_X)
{ {
/* FIXME: get unicode char from hex-digits */ lit_code_point_t code_point;
/* ch = ...; */ const lit_utf8_byte_t *hex_start = parser_ctx_p->iter.buf_p + parser_ctx_p->iter.buf_pos.offset;
if (!lit_read_code_point_from_hex (hex_start, 2, &code_point))
{
ret_value = ecma_raise_syntax_error ("decode error");
return ret_value;
}
lit_utf8_iterator_advance (&(parser_ctx_p->iter), 2);
append_char_class (re_ctx_p, code_point, code_point);
} }
else if (ch == 'u') else if (ch == LIT_CHAR_LOWERCASE_U)
{ {
/* FIXME: get unicode char from digits */ lit_code_point_t code_point;
/* ch = ...; */ const lit_utf8_byte_t *hex_start = parser_ctx_p->iter.buf_p + parser_ctx_p->iter.buf_pos.offset;
if (!lit_read_code_point_from_hex (hex_start, 4, &code_point))
{
ret_value = ecma_raise_syntax_error ("decode error");
return ret_value;
}
lit_utf8_iterator_advance (&(parser_ctx_p->iter), 4);
append_char_class (re_ctx_p, code_point, code_point);
} }
else if (ch == 'd') else if (ch == LIT_CHAR_LOWERCASE_D)
{ {
/* append digits from '0' to '9'. */ /* See ECMA-262 v5, 15.10.2.12 */
append_char_class (re_ctx_p, 0x0030UL, 0x0039UL); append_char_class (re_ctx_p, LIT_CHAR_ASCII_DIGITS_BEGIN, LIT_CHAR_ASCII_DIGITS_END);
ch = RE_CHAR_UNDEF; ch = RE_CHAR_UNDEF;
} }
else if (ch == 'D') else if (ch == LIT_CHAR_UPPERCASE_D)
{ {
append_char_class (re_ctx_p, 0x0000UL, 0x002FUL); /* See ECMA-262 v5, 15.10.2.12 */
append_char_class (re_ctx_p, 0x003AUL, 0xFFFFUL); append_char_class (re_ctx_p, LIT_CHAR_NULL, LIT_CHAR_ASCII_DIGITS_BEGIN - 1);
append_char_class (re_ctx_p, LIT_CHAR_ASCII_DIGITS_END + 1, LIT_UTF16_CODE_UNIT_MAX);
ch = RE_CHAR_UNDEF; ch = RE_CHAR_UNDEF;
} }
else if (ch == 's') else if (ch == LIT_CHAR_LOWERCASE_S)
{ {
append_char_class (re_ctx_p, 0x0009UL, 0x000DUL); /* See ECMA-262 v5, 15.10.2.12 */
append_char_class (re_ctx_p, 0x0020UL, 0x0020UL); append_char_class (re_ctx_p, LIT_CHAR_TAB, LIT_CHAR_CR);
append_char_class (re_ctx_p, 0x00A0UL, 0x00A0UL); append_char_class (re_ctx_p, LIT_CHAR_SP, LIT_CHAR_SP);
append_char_class (re_ctx_p, 0x1680UL, 0x1680UL); append_char_class (re_ctx_p, LIT_CHAR_NBSP, LIT_CHAR_NBSP);
append_char_class (re_ctx_p, 0x180EUL, 0x180EUL); append_char_class (re_ctx_p, 0x1680UL, 0x1680UL); /* Ogham Space Mark */
append_char_class (re_ctx_p, 0x2000UL, 0x200AUL); append_char_class (re_ctx_p, 0x180EUL, 0x180EUL); /* Mongolian Vowel Separator */
append_char_class (re_ctx_p, 0x2028UL, 0x2029UL); append_char_class (re_ctx_p, 0x2000UL, 0x200AUL); /* En Quad - Hair Space */
append_char_class (re_ctx_p, 0x202FUL, 0x202FUL); append_char_class (re_ctx_p, LIT_CHAR_LS, LIT_CHAR_PS);
append_char_class (re_ctx_p, 0x205FUL, 0x205FUL); append_char_class (re_ctx_p, 0x202FUL, 0x202FUL); /* Narrow No-Break Space */
append_char_class (re_ctx_p, 0x3000UL, 0x3000UL); append_char_class (re_ctx_p, 0x205FUL, 0x205FUL); /* Medium Mathematical Space */
append_char_class (re_ctx_p, 0xFEFFUL, 0xFEFFUL); append_char_class (re_ctx_p, 0x3000UL, 0x3000UL); /* Ideographic Space */
append_char_class (re_ctx_p, LIT_CHAR_BOM, LIT_CHAR_BOM);
ch = RE_CHAR_UNDEF; ch = RE_CHAR_UNDEF;
} }
else if (ch == 'S') else if (ch == LIT_CHAR_UPPERCASE_S)
{ {
append_char_class (re_ctx_p, 0x0000UL, 0x0008UL); /* See ECMA-262 v5, 15.10.2.12 */
append_char_class (re_ctx_p, 0x000EUL, 0x001FUL); append_char_class (re_ctx_p, LIT_CHAR_NULL, LIT_CHAR_TAB - 1);
append_char_class (re_ctx_p, 0x0021UL, 0x009FUL); append_char_class (re_ctx_p, LIT_CHAR_CR + 1, LIT_CHAR_SP - 1);
append_char_class (re_ctx_p, 0x00A1UL, 0x167FUL); append_char_class (re_ctx_p, LIT_CHAR_SP + 1, LIT_CHAR_NBSP - 1);
append_char_class (re_ctx_p, LIT_CHAR_NBSP + 1, 0x167FUL);
append_char_class (re_ctx_p, 0x1681UL, 0x180DUL); append_char_class (re_ctx_p, 0x1681UL, 0x180DUL);
append_char_class (re_ctx_p, 0x180FUL, 0x1FFFUL); append_char_class (re_ctx_p, 0x180FUL, 0x1FFFUL);
append_char_class (re_ctx_p, 0x200BUL, 0x2027UL); append_char_class (re_ctx_p, 0x200BUL, LIT_CHAR_LS - 1);
append_char_class (re_ctx_p, 0x202AUL, 0x202EUL); append_char_class (re_ctx_p, LIT_CHAR_PS + 1, 0x202EUL);
append_char_class (re_ctx_p, 0x2030UL, 0x205EUL); append_char_class (re_ctx_p, 0x2030UL, 0x205EUL);
append_char_class (re_ctx_p, 0x2060UL, 0x2FFFUL); append_char_class (re_ctx_p, 0x2060UL, 0x2FFFUL);
append_char_class (re_ctx_p, 0x3001UL, 0xFEFEUL); append_char_class (re_ctx_p, 0x3001UL, LIT_CHAR_BOM - 1);
append_char_class (re_ctx_p, 0xFF00UL, 0xFFFFUL); append_char_class (re_ctx_p, LIT_CHAR_BOM + 1, LIT_UTF16_CODE_UNIT_MAX);
ch = RE_CHAR_UNDEF; ch = RE_CHAR_UNDEF;
} }
else if (ch == 'w') else if (ch == LIT_CHAR_LOWERCASE_W)
{ {
append_char_class (re_ctx_p, 0x0030UL, 0x0039UL); /* See ECMA-262 v5, 15.10.2.12 */
append_char_class (re_ctx_p, 0x0041UL, 0x005AUL); append_char_class (re_ctx_p, LIT_CHAR_0, LIT_CHAR_9);
append_char_class (re_ctx_p, 0x005FUL, 0x005FUL); append_char_class (re_ctx_p, LIT_CHAR_UPPERCASE_A, LIT_CHAR_UPPERCASE_Z);
append_char_class (re_ctx_p, 0x0061UL, 0x007AUL); append_char_class (re_ctx_p, LIT_CHAR_UNDERSCORE, LIT_CHAR_UNDERSCORE);
append_char_class (re_ctx_p, LIT_CHAR_LOWERCASE_A, LIT_CHAR_LOWERCASE_Z);
ch = RE_CHAR_UNDEF; ch = RE_CHAR_UNDEF;
} }
else if (ch == 'W') else if (ch == LIT_CHAR_UPPERCASE_W)
{ {
append_char_class (re_ctx_p, 0x0000UL, 0x002FUL); /* See ECMA-262 v5, 15.10.2.12 */
append_char_class (re_ctx_p, 0x003AUL, 0x0040UL); append_char_class (re_ctx_p, LIT_CHAR_NULL, LIT_CHAR_0 - 1);
append_char_class (re_ctx_p, 0x005BUL, 0x005EUL); append_char_class (re_ctx_p, LIT_CHAR_9 + 1, LIT_CHAR_UPPERCASE_A - 1);
append_char_class (re_ctx_p, 0x0060UL, 0x0060UL); append_char_class (re_ctx_p, LIT_CHAR_UPPERCASE_Z + 1, LIT_CHAR_UNDERSCORE - 1);
append_char_class (re_ctx_p, 0x007BUL, 0xFFFFUL); append_char_class (re_ctx_p, LIT_CHAR_UNDERSCORE + 1, LIT_CHAR_LOWERCASE_A - 1);
append_char_class (re_ctx_p, LIT_CHAR_LOWERCASE_Z + 1, LIT_UTF16_CODE_UNIT_MAX);
ch = RE_CHAR_UNDEF; ch = RE_CHAR_UNDEF;
} }
else if (lit_char_is_decimal_digit (ch)) else if (ch <= LIT_UTF16_CODE_UNIT_MAX
&& lit_char_is_decimal_digit ((ecma_char_t) ch))
{ {
if (ch != LIT_CHAR_0 if (ch != LIT_CHAR_0
|| lit_char_is_decimal_digit (RE_LOOKUP (*pattern_p, 1))) || lit_char_is_decimal_digit (re_lookup (parser_ctx_p->iter, 1)))
{ {
/* FIXME: octal support */ /* FIXME: octal support */
} }
@@ -485,16 +539,16 @@ re_parse_char_class (re_parser_ctx_t *parser_ctx_p, /**< number of classes */
} }
} }
} }
while (true); while (token_type == RE_TOK_START_CHAR_CLASS || token_type == RE_TOK_START_INV_CHAR_CLASS);
uint32_t advance = 0; uint32_t advance = 0;
ECMA_TRY_CATCH (empty, ECMA_TRY_CATCH (empty,
re_parse_iterator (parser_ctx_p->current_char_p, re_parse_iterator (parser_ctx_p->iter,
out_token_p, out_token_p,
0, 0,
&advance), &advance),
ret_value); ret_value);
RE_ADVANCE (parser_ctx_p->current_char_p, advance); lit_utf8_iterator_advance (&(parser_ctx_p->iter), advance);
ECMA_FINALIZE (empty); ECMA_FINALIZE (empty);
return ret_value; return ret_value;
@@ -511,33 +565,40 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
re_token_t *out_token_p) /**< output token */ re_token_t *out_token_p) /**< output token */
{ {
ecma_completion_value_t ret_value = ecma_make_empty_completion_value (); ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
if (lit_utf8_iterator_is_eos (&(parser_ctx_p->iter)))
{
out_token_p->type = RE_TOK_EOF;
return ret_value;
}
uint32_t advance = 0; uint32_t advance = 0;
ecma_char_t ch0 = *(parser_ctx_p->current_char_p); ecma_char_t ch0 = lit_utf8_iterator_peek_next (&(parser_ctx_p->iter));
switch (ch0) switch (ch0)
{ {
case '|': case LIT_CHAR_VLINE:
{ {
advance = 1; advance = 1;
out_token_p->type = RE_TOK_ALTERNATIVE; out_token_p->type = RE_TOK_ALTERNATIVE;
break; break;
} }
case '^': case LIT_CHAR_CIRCUMFLEX:
{ {
advance = 1; advance = 1;
out_token_p->type = RE_TOK_ASSERT_START; out_token_p->type = RE_TOK_ASSERT_START;
break; break;
} }
case '$': case LIT_CHAR_DOLLAR_SIGN:
{ {
advance = 1; advance = 1;
out_token_p->type = RE_TOK_ASSERT_END; out_token_p->type = RE_TOK_ASSERT_END;
break; break;
} }
case '.': case LIT_CHAR_DOT:
{ {
ECMA_TRY_CATCH (empty, ECMA_TRY_CATCH (empty,
re_parse_iterator (parser_ctx_p->current_char_p, re_parse_iterator (parser_ctx_p->iter,
out_token_p, out_token_p,
1, 1,
&advance), &advance),
@@ -547,118 +608,138 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
ECMA_FINALIZE (empty); ECMA_FINALIZE (empty);
break; break;
} }
case '\\': case LIT_CHAR_BACKSLASH:
{ {
advance = 2;
out_token_p->type = RE_TOK_CHAR; out_token_p->type = RE_TOK_CHAR;
ecma_char_t ch1 = RE_LOOKUP (parser_ctx_p->current_char_p, 1); ecma_char_t ch1 = re_lookup (parser_ctx_p->iter, 1);
if (ch1 == 'b') if (ch1 == LIT_CHAR_LOWERCASE_B)
{ {
advance = 2;
out_token_p->type = RE_TOK_ASSERT_WORD_BOUNDARY; out_token_p->type = RE_TOK_ASSERT_WORD_BOUNDARY;
} }
else if (ch1 == 'B') else if (ch1 == LIT_CHAR_UPPERCASE_B)
{ {
advance = 2;
out_token_p->type = RE_TOK_ASSERT_NOT_WORD_BOUNDARY; out_token_p->type = RE_TOK_ASSERT_NOT_WORD_BOUNDARY;
} }
else if (ch1 == 'f') else if (ch1 == LIT_CHAR_LOWERCASE_F)
{ {
out_token_p->value = RE_CONTROL_CHAR_FF; out_token_p->value = LIT_CHAR_FF;
} }
else if (ch1 == 'n') else if (ch1 == LIT_CHAR_LOWERCASE_N)
{ {
out_token_p->value = RE_CONTROL_CHAR_EOL; out_token_p->value = LIT_CHAR_LF;
} }
else if (ch1 == 't') else if (ch1 == LIT_CHAR_LOWERCASE_T)
{ {
out_token_p->value = RE_CONTROL_CHAR_TAB; out_token_p->value = LIT_CHAR_TAB;
} }
else if (ch1 == 'r') else if (ch1 == LIT_CHAR_LOWERCASE_R)
{ {
out_token_p->value = RE_CONTROL_CHAR_CR; out_token_p->value = LIT_CHAR_CR;
} }
else if (ch1 == 'v') else if (ch1 == LIT_CHAR_LOWERCASE_V)
{ {
out_token_p->value = RE_CONTROL_CHAR_VT; out_token_p->value = LIT_CHAR_VTAB;
} }
else if (ch1 == 'c') else if (ch1 == LIT_CHAR_LOWERCASE_C)
{ {
ecma_char_t ch2 = RE_LOOKUP (parser_ctx_p->current_char_p, 2); lit_utf8_iterator_advance (&(parser_ctx_p->iter), 2);
if ((ch2 >= 'A' && ch2 <= 'Z') || (ch2 >= 'a' && ch2 <= 'z')) if (lit_utf8_iterator_is_eos (&(parser_ctx_p->iter)))
{
ret_value = ecma_raise_syntax_error ("invalid character class");
return ret_value;
}
ecma_char_t ch2 = lit_utf8_iterator_read_next (&(parser_ctx_p->iter));
if ((ch2 >= LIT_CHAR_ASCII_UPPERCASE_LETTERS_BEGIN && ch2 <= LIT_CHAR_ASCII_UPPERCASE_LETTERS_END)
|| (ch2 >= LIT_CHAR_ASCII_LOWERCASE_LETTERS_BEGIN && ch2 <= LIT_CHAR_ASCII_LOWERCASE_LETTERS_END))
{ {
advance = 3;
out_token_p->type = RE_TOK_CHAR; out_token_p->type = RE_TOK_CHAR;
out_token_p->value = (ch2 % 32); out_token_p->value = (ch2 % 32);
} }
else }
else if (ch1 == LIT_CHAR_LOWERCASE_X
&& lit_char_is_hex_digit (re_lookup (parser_ctx_p->iter, 2))
&& lit_char_is_hex_digit (re_lookup (parser_ctx_p->iter, 3)))
{
lit_utf8_iterator_advance (&(parser_ctx_p->iter), 2);
lit_code_point_t code_point;
const lit_utf8_byte_t *hex_start = parser_ctx_p->iter.buf_p + parser_ctx_p->iter.buf_pos.offset;
if (!lit_read_code_point_from_hex (hex_start, 2, &code_point))
{ {
ret_value = ecma_raise_syntax_error ("invalid regexp control escape"); ret_value = ecma_raise_syntax_error ("decode error");
break; return ret_value;
} }
}
else if (ch1 == 'x' lit_utf8_iterator_advance (&(parser_ctx_p->iter), 2);
&& lit_char_is_hex_digit (RE_LOOKUP (parser_ctx_p->current_char_p, 2))
&& lit_char_is_hex_digit (RE_LOOKUP (parser_ctx_p->current_char_p, 3)))
{
advance = 4;
out_token_p->type = RE_TOK_CHAR; out_token_p->type = RE_TOK_CHAR;
/* FIXME: get unicode char from hex-digits */ out_token_p->value = code_point;
/* result.value = ...; */
} }
else if (ch1 == 'u' else if (ch1 == LIT_CHAR_LOWERCASE_U
&& lit_char_is_hex_digit (RE_LOOKUP (parser_ctx_p->current_char_p, 2)) && lit_char_is_hex_digit (re_lookup (parser_ctx_p->iter, 2))
&& lit_char_is_hex_digit (RE_LOOKUP (parser_ctx_p->current_char_p, 3)) && lit_char_is_hex_digit (re_lookup (parser_ctx_p->iter, 3))
&& lit_char_is_hex_digit (RE_LOOKUP (parser_ctx_p->current_char_p, 4)) && lit_char_is_hex_digit (re_lookup (parser_ctx_p->iter, 4))
&& lit_char_is_hex_digit (RE_LOOKUP (parser_ctx_p->current_char_p, 5))) && lit_char_is_hex_digit (re_lookup (parser_ctx_p->iter, 5)))
{ {
advance = 4; lit_utf8_iterator_advance (&(parser_ctx_p->iter), 2);
lit_code_point_t code_point;
const lit_utf8_byte_t *hex_start = parser_ctx_p->iter.buf_p + parser_ctx_p->iter.buf_pos.offset;
if (!lit_read_code_point_from_hex (hex_start, 4, &code_point))
{
ret_value = ecma_raise_syntax_error ("decode error");
return ret_value;
}
lit_utf8_iterator_advance (&(parser_ctx_p->iter), 4);
out_token_p->type = RE_TOK_CHAR; out_token_p->type = RE_TOK_CHAR;
/* FIXME: get unicode char from digits */ out_token_p->value = code_point;
/* result.value = ...; */
} }
else if (ch1 == 'd') else if (ch1 == LIT_CHAR_LOWERCASE_D)
{ {
advance = 2;
out_token_p->type = RE_TOK_DIGIT; out_token_p->type = RE_TOK_DIGIT;
} }
else if (ch1 == 'D') else if (ch1 == LIT_CHAR_UPPERCASE_D)
{ {
advance = 2;
out_token_p->type = RE_TOK_NOT_DIGIT; out_token_p->type = RE_TOK_NOT_DIGIT;
} }
else if (ch1 == 's') else if (ch1 == LIT_CHAR_LOWERCASE_S)
{ {
advance = 2;
out_token_p->type = RE_TOK_WHITE; out_token_p->type = RE_TOK_WHITE;
} }
else if (ch1 == 'S') else if (ch1 == LIT_CHAR_UPPERCASE_S)
{ {
advance = 2;
out_token_p->type = RE_TOK_NOT_WHITE; out_token_p->type = RE_TOK_NOT_WHITE;
} }
else if (ch1 == 'w') else if (ch1 == LIT_CHAR_LOWERCASE_W)
{ {
advance = 2;
out_token_p->type = RE_TOK_WORD_CHAR; out_token_p->type = RE_TOK_WORD_CHAR;
} }
else if (ch1 == 'W') else if (ch1 == LIT_CHAR_UPPERCASE_W)
{ {
advance = 2;
out_token_p->type = RE_TOK_NOT_WORD_CHAR; out_token_p->type = RE_TOK_NOT_WORD_CHAR;
} }
else if (lit_char_is_decimal_digit (ch1)) else if (lit_char_is_decimal_digit (ch1))
{ {
if (ch1 == '0') if (ch1 == LIT_CHAR_0)
{ {
if (lit_char_is_decimal_digit (RE_LOOKUP (parser_ctx_p->current_char_p, 2))) if (lit_char_is_decimal_digit (re_lookup (parser_ctx_p->iter, 2)))
{ {
ret_value = ecma_raise_syntax_error ("RegExp escape pattern error."); ret_value = ecma_raise_syntax_error ("RegExp escape pattern error.");
break; break;
} }
advance = 2; advance = 2;
out_token_p->value = RE_CONTROL_CHAR_NUL; out_token_p->value = LIT_UNICODE_CODE_POINT_NULL;
} }
else else
{ {
@@ -671,7 +752,6 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
{ {
uint32_t number = 0; uint32_t number = 0;
int index = 0; int index = 0;
advance = 0;
do do
{ {
@@ -682,7 +762,7 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
} }
advance++; advance++;
ecma_char_t digit = RE_LOOKUP (parser_ctx_p->current_char_p, ecma_char_t digit = re_lookup (parser_ctx_p->iter,
advance); advance);
if (!lit_char_is_decimal_digit (digit)) if (!lit_char_is_decimal_digit (digit))
{ {
@@ -708,12 +788,13 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
} }
else else
{ {
advance = 2;
out_token_p->value = ch1; out_token_p->value = ch1;
} }
uint32_t iter_adv = 0; uint32_t iter_adv = 0;
ECMA_TRY_CATCH (empty, ECMA_TRY_CATCH (empty,
re_parse_iterator (parser_ctx_p->current_char_p, re_parse_iterator (parser_ctx_p->iter,
out_token_p, out_token_p,
advance, advance,
&iter_adv), &iter_adv),
@@ -722,25 +803,25 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
ECMA_FINALIZE (empty); ECMA_FINALIZE (empty);
break; break;
} }
case '(': case LIT_CHAR_LEFT_PAREN:
{ {
if (RE_LOOKUP (parser_ctx_p->current_char_p, 1) == '?') if (re_lookup (parser_ctx_p->iter, 1) == LIT_CHAR_QUESTION)
{ {
ecma_char_t ch2 = RE_LOOKUP (parser_ctx_p->current_char_p, 2); ecma_char_t ch2 = re_lookup (parser_ctx_p->iter, 2);
if (ch2 == '=') if (ch2 == LIT_CHAR_EQUALS)
{ {
/* (?= */ /* (?= */
advance = 3; advance = 3;
out_token_p->type = RE_TOK_ASSERT_START_POS_LOOKAHEAD; out_token_p->type = RE_TOK_ASSERT_START_POS_LOOKAHEAD;
} }
else if (ch2 == '!') else if (ch2 == LIT_CHAR_EXCLAMATION)
{ {
/* (?! */ /* (?! */
advance = 3; advance = 3;
out_token_p->type = RE_TOK_ASSERT_START_NEG_LOOKAHEAD; out_token_p->type = RE_TOK_ASSERT_START_NEG_LOOKAHEAD;
} }
else if (ch2 == ':') else if (ch2 == LIT_CHAR_COLON)
{ {
/* (?: */ /* (?: */
advance = 3; advance = 3;
@@ -755,10 +836,10 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
} }
break; break;
} }
case ')': case LIT_CHAR_RIGHT_PAREN:
{ {
ECMA_TRY_CATCH (empty, ECMA_TRY_CATCH (empty,
re_parse_iterator (parser_ctx_p->current_char_p, re_parse_iterator (parser_ctx_p->iter,
out_token_p, out_token_p,
1, 1,
&advance), &advance),
@@ -768,28 +849,28 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
ECMA_FINALIZE (empty); ECMA_FINALIZE (empty);
break; break;
} }
case '[': case LIT_CHAR_LEFT_SQUARE:
{ {
advance = 1; advance = 1;
out_token_p->type = RE_TOK_START_CHAR_CLASS; out_token_p->type = RE_TOK_START_CHAR_CLASS;
if (RE_LOOKUP (parser_ctx_p->current_char_p, 1) == '^') if (re_lookup (parser_ctx_p->iter, 1) == LIT_CHAR_CIRCUMFLEX)
{ {
advance = 2; advance = 2;
out_token_p->type = RE_TOK_START_INV_CHAR_CLASS; out_token_p->type = RE_TOK_START_INV_CHAR_CLASS;
} }
break; break;
} }
case ']': case LIT_CHAR_RIGHT_SQUARE:
case '}': case LIT_CHAR_RIGHT_BRACE:
case '?': case LIT_CHAR_QUESTION:
case '*': case LIT_CHAR_ASTERISK:
case '+': case LIT_CHAR_PLUS:
case '{': case LIT_CHAR_LEFT_BRACE:
{ {
JERRY_UNREACHABLE (); ret_value = ecma_raise_syntax_error ("Invalid RegExp token.");
break; return ret_value;
} }
case '\0': case LIT_CHAR_NULL:
{ {
advance = 0; advance = 0;
out_token_p->type = RE_TOK_EOF; out_token_p->type = RE_TOK_EOF;
@@ -798,7 +879,7 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
default: default:
{ {
ECMA_TRY_CATCH (empty, ECMA_TRY_CATCH (empty,
re_parse_iterator (parser_ctx_p->current_char_p, re_parse_iterator (parser_ctx_p->iter,
out_token_p, out_token_p,
1, 1,
&advance), &advance),
@@ -813,7 +894,7 @@ re_parse_next_token (re_parser_ctx_t *parser_ctx_p, /**< RegExp parser context *
if (ecma_is_completion_value_empty (ret_value)) if (ecma_is_completion_value_empty (ret_value))
{ {
RE_ADVANCE (parser_ctx_p->current_char_p, advance); lit_utf8_iterator_advance (&(parser_ctx_p->iter), advance);
} }
return ret_value; return ret_value;
jerry-core/parser/regexp/re-parser.h
+5 -12
View File
@@ -59,16 +59,10 @@ typedef enum
*/ */
#define RE_MAX_RE_DECESC_DIGITS 9 #define RE_MAX_RE_DECESC_DIGITS 9
/* FIXME: depends on unicode support */ /**
#define RE_CHAR_UNDEF ((ecma_char_t)-1) * Undefined character (out of the range of the codeunit)
*/
#define RE_CONTROL_CHAR_NUL 0x0000 /* \0 */ #define RE_CHAR_UNDEF 0xFFFFFFFF
#define RE_CONTROL_CHAR_BEL 0x0008 /* \b */
#define RE_CONTROL_CHAR_TAB 0x0009 /* \t */
#define RE_CONTROL_CHAR_EOL 0x000a /* \n */
#define RE_CONTROL_CHAR_VT 0x000b /* \v */
#define RE_CONTROL_CHAR_FF 0x000c /* \f */
#define RE_CONTROL_CHAR_CR 0x000d /* \r */
/** /**
* RegExp token type * RegExp token type
@@ -87,8 +81,7 @@ typedef struct
*/ */
typedef struct typedef struct
{ {
lit_utf8_byte_t *pattern_start_p; /**< start of input pattern string */ lit_utf8_iterator_t iter; /**< iterator of input pattern */
lit_utf8_byte_t *current_char_p; /**< current character in input pattern */
int num_of_groups; /**< number of groups */ int num_of_groups; /**< number of groups */
uint32_t num_of_classes; /**< number of character classes */ uint32_t num_of_classes; /**< number of character classes */
} re_parser_ctx_t; } re_parser_ctx_t;
tests/jerry/regexp-character-class.js
+84 -1
View File
@@ -30,4 +30,87 @@ assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[A-Z]*").exec("abcdefghjklmnopqrstuvwxyz"); r = new RegExp ("[A-Z]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == ""); assert (r == "");
// FIXME: Add more tescase when Unicode support is finished! r = new RegExp ("[^a-z]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("[^A-Z]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("\\d*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("\\D*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("\\w*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("\\W*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("\\s*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("\\S*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[\\d]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("[\\D]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[\\w]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[\\W]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("[\\s]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("[\\S]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[^\\d]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[^\\D]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("[^\\w]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("[^\\W]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[^\\s]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "abcdefghjklmnopqrstuvwxyz");
r = new RegExp ("[^\\S]*").exec("abcdefghjklmnopqrstuvwxyz");
assert (r == "");
r = new RegExp ("\\d*").exec("0123456789");
assert (r == "0123456789");
try
{
r = new RegExp("[");
assert (false);
}
catch (e)
{
assert (e instanceof SyntaxError);
assert (e.message === "invalid character class");
}
try
{
r = new RegExp("[\\");
assert (false);
}
catch (e)
{
assert (e instanceof SyntaxError);
assert (e.message === "invalid character class");
}