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

Rework RegExp engine and add support for proper unicode matching (#3746)

Browse Source 
This change includes several bugfixes, general improvements, and support
for additional features.
- Added full support for web compatibility syntax defined in Annex B
- Implemented parsing and matching patterns in unicode mode
- Fixed capture results when iterating with nested capturing groups
- Significantly reduced regexp bytecode size
- Reduced stack usage during regexp execution
- Improved matching performance

JerryScript-DCO-1.0-Signed-off-by: Dániel Bátyai dbatyai@inf.u-szeged.hu
This commit is contained in:
Dániel Bátyai
2020-05-26 15:28:54 +02:00
committed by GitHub
parent 908240ba62
commit 8f76a1f382
30 changed files with 3641 additions and 2647 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/parser/js/js-lexer.c
+2 -10
View File
@@ -2847,9 +2847,6 @@ lexer_construct_regexp_object (parser_context_t *context_p, /**< context */
context_p->literal_count++;
/* Compile the RegExp literal and store the RegExp bytecode pointer */
const re_compiled_code_t *re_bytecode_p = NULL;
ecma_value_t completion_value;
ecma_string_t *pattern_str_p = NULL;
if (lit_is_valid_cesu8_string (regex_start_p, length))
@@ -2862,19 +2859,14 @@ lexer_construct_regexp_object (parser_context_t *context_p, /**< context */
pattern_str_p = ecma_new_ecma_string_from_utf8_converted_to_cesu8 (regex_start_p, length);
}
completion_value = re_compile_bytecode (&re_bytecode_p,
pattern_str_p,
current_flags);
re_compiled_code_t *re_bytecode_p = re_compile_bytecode (pattern_str_p, current_flags);
ecma_deref_ecma_string (pattern_str_p);
if (ECMA_IS_VALUE_ERROR (completion_value))
if (JERRY_UNLIKELY (re_bytecode_p == NULL))
{
jcontext_release_exception ();
parser_raise_error (context_p, PARSER_ERR_INVALID_REGEXP);
}
ecma_free_value (completion_value);
literal_p->type = LEXER_REGEXP_LITERAL;
literal_p->u.bytecode_p = (ecma_compiled_code_t *) re_bytecode_p;
jerry-core/parser/js/js-parser.c
+8
View File
@@ -2723,6 +2723,14 @@ parser_parse_script (const uint8_t *arg_list_p, /**< function argument list */
jcontext_raise_exception (ECMA_VALUE_NULL);
return ECMA_VALUE_ERROR;
}
if (parser_error.error == PARSER_ERR_INVALID_REGEXP)
{
/* The RegExp compiler has already raised an exception. */
JERRY_ASSERT (jcontext_has_pending_exception ());
return ECMA_VALUE_ERROR;
}
#if ENABLED (JERRY_ERROR_MESSAGES)
const lit_utf8_byte_t *err_bytes_p = (const lit_utf8_byte_t *) parser_error_to_string (parser_error.error);
lit_utf8_size_t err_bytes_size = lit_zt_utf8_string_size (err_bytes_p);
jerry-core/parser/regexp/re-bytecode.c
+460 -312
View File
@@ -14,8 +14,9 @@
*/
#include "ecma-globals.h"
#include "re-bytecode.h"
#include "ecma-regexp-object.h"
#include "lit-strings.h"
#include "re-bytecode.h"
#if ENABLED (JERRY_BUILTIN_REGEXP)
@@ -29,135 +30,103 @@
* @{
*/
/**
* Size of block of RegExp bytecode. Used for allocation
*
* @return pointer to the RegExp compiled code header
*/
#define REGEXP_BYTECODE_BLOCK_SIZE 8UL
void
re_initialize_regexp_bytecode (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytecode context */
re_initialize_regexp_bytecode (re_compiler_ctx_t *re_ctx_p) /**< RegExp bytecode context */
{
const size_t initial_size = JERRY_ALIGNUP (REGEXP_BYTECODE_BLOCK_SIZE + sizeof (re_compiled_code_t), JMEM_ALIGNMENT);
bc_ctx_p->block_start_p = jmem_heap_alloc_block (initial_size);
bc_ctx_p->block_end_p = bc_ctx_p->block_start_p + initial_size;
bc_ctx_p->current_p = bc_ctx_p->block_start_p + sizeof (re_compiled_code_t);
const size_t initial_size = sizeof (re_compiled_code_t);
re_ctx_p->bytecode_start_p = jmem_heap_alloc_block (initial_size);
re_ctx_p->bytecode_size = initial_size;
} /* re_initialize_regexp_bytecode */
/**
* Realloc the bytecode container
*
* @return current position in RegExp bytecode
*/
static uint8_t *
re_realloc_regexp_bytecode_block (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytecode context */
inline uint32_t JERRY_ATTR_ALWAYS_INLINE
re_bytecode_size (re_compiler_ctx_t *re_ctx_p) /**< RegExp bytecode context */
{
JERRY_ASSERT (bc_ctx_p->block_end_p >= bc_ctx_p->block_start_p);
const size_t old_size = (size_t) (bc_ctx_p->block_end_p - bc_ctx_p->block_start_p);
/* If one of the members of RegExp bytecode context is NULL, then all member should be NULL
* (it means first allocation), otherwise all of the members should be a non NULL pointer. */
JERRY_ASSERT ((!bc_ctx_p->current_p && !bc_ctx_p->block_end_p && !bc_ctx_p->block_start_p)
|| (bc_ctx_p->current_p && bc_ctx_p->block_end_p && bc_ctx_p->block_start_p));
const size_t new_size = old_size + REGEXP_BYTECODE_BLOCK_SIZE;
JERRY_ASSERT (bc_ctx_p->current_p >= bc_ctx_p->block_start_p);
const size_t current_ptr_offset = (size_t) (bc_ctx_p->current_p - bc_ctx_p->block_start_p);
bc_ctx_p->block_start_p = jmem_heap_realloc_block (bc_ctx_p->block_start_p,
old_size,
new_size);
bc_ctx_p->block_end_p = bc_ctx_p->block_start_p + new_size;
bc_ctx_p->current_p = bc_ctx_p->block_start_p + current_ptr_offset;
return bc_ctx_p->current_p;
} /* re_realloc_regexp_bytecode_block */
return (uint32_t) re_ctx_p->bytecode_size;
} /* re_bytecode_size */
/**
* Append a new bytecode to the and of the bytecode container
*/
static uint8_t *
re_bytecode_reserve (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
re_bytecode_reserve (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const size_t size) /**< size */
{
JERRY_ASSERT (size <= REGEXP_BYTECODE_BLOCK_SIZE);
uint8_t *current_p = bc_ctx_p->current_p;
if (current_p + size > bc_ctx_p->block_end_p)
{
current_p = re_realloc_regexp_bytecode_block (bc_ctx_p);
}
bc_ctx_p->current_p += size;
return current_p;
const size_t old_size = re_ctx_p->bytecode_size;
const size_t new_size = old_size + size;
re_ctx_p->bytecode_start_p = jmem_heap_realloc_block (re_ctx_p->bytecode_start_p, old_size, new_size);
re_ctx_p->bytecode_size = new_size;
return re_ctx_p->bytecode_start_p + old_size;
} /* re_bytecode_reserve */
/**
* Insert a new bytecode to the bytecode container
*/
static void
re_bytecode_insert (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
static uint8_t *
re_bytecode_insert (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const size_t offset, /**< distance from the start of the container */
const size_t size) /**< size */
{
JERRY_ASSERT (size <= REGEXP_BYTECODE_BLOCK_SIZE);
const size_t tail_size = re_ctx_p->bytecode_size - offset;
re_bytecode_reserve (re_ctx_p, size);
uint8_t *current_p = bc_ctx_p->current_p;
if (current_p + size > bc_ctx_p->block_end_p)
{
re_realloc_regexp_bytecode_block (bc_ctx_p);
}
uint8_t *dest_p = re_ctx_p->bytecode_start_p + offset;
memmove (dest_p + size, dest_p, tail_size);
uint8_t *dest_p = bc_ctx_p->block_start_p + offset;
const size_t bytecode_length = re_get_bytecode_length (bc_ctx_p);
if (bytecode_length - offset > 0)
{
memmove (dest_p + size, dest_p, bytecode_length - offset);
}
bc_ctx_p->current_p += size;
return dest_p;
} /* re_bytecode_insert */
/**
* Encode ecma_char_t into bytecode
* Append a byte
*/
static void
re_encode_char (uint8_t *dest_p, /**< destination */
const ecma_char_t c) /**< character */
void
re_append_byte (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const uint8_t byte) /**< byte value */
{
*dest_p++ = (uint8_t) ((c >> 8) & 0xFF);
*dest_p = (uint8_t) (c & 0xFF);
} /* re_encode_char */
uint8_t *dest_p = re_bytecode_reserve (re_ctx_p, sizeof (uint8_t));
*dest_p = byte;
} /* re_append_byte */
/**
* Encode uint32_t into bytecode
* Insert a byte value
*/
static void
re_encode_u32 (uint8_t *dest_p, /**< destination */
const uint32_t u) /**< uint32 value */
void
re_insert_byte (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const uint32_t offset, /**< distance from the start of the container */
const uint8_t byte) /**< byte value */
{
*dest_p++ = (uint8_t) ((u >> 24) & 0xFF);
*dest_p++ = (uint8_t) ((u >> 16) & 0xFF);
*dest_p++ = (uint8_t) ((u >> 8) & 0xFF);
*dest_p = (uint8_t) (u & 0xFF);
} /* re_encode_u32 */
uint8_t *dest_p = re_bytecode_insert (re_ctx_p, offset, sizeof (uint8_t));
*dest_p = byte;
} /* re_insert_byte */
/**
* Get a character from the RegExp bytecode and increase the bytecode position
*
* @return ecma character
* Get a single byte and icnrease bytecode position.
*/
inline ecma_char_t JERRY_ATTR_ALWAYS_INLINE
re_get_char (const uint8_t **bc_p) /**< pointer to bytecode start */
inline uint8_t JERRY_ATTR_ALWAYS_INLINE
re_get_byte (const uint8_t **bc_p) /**< pointer to bytecode start */
{
const uint8_t *src_p = *bc_p;
ecma_char_t chr = (ecma_char_t) *src_p++;
chr = (ecma_char_t) (chr << 8);
chr = (ecma_char_t) (chr | *src_p);
(*bc_p) += sizeof (ecma_char_t);
return chr;
} /* re_get_char */
return *((*bc_p)++);
} /* re_get_byte */
/**
* Append a RegExp opcode
*/
inline void JERRY_ATTR_ALWAYS_INLINE
re_append_opcode (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const re_opcode_t opcode) /**< input opcode */
{
re_append_byte (re_ctx_p, (uint8_t) opcode);
} /* re_append_opcode */
/**
* Insert a RegExp opcode
*/
inline void JERRY_ATTR_ALWAYS_INLINE
re_insert_opcode (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const uint32_t offset, /**< distance from the start of the container */
const re_opcode_t opcode) /**< input opcode */
{
re_insert_byte (re_ctx_p, offset, (uint8_t) opcode);
} /* re_insert_opcode */
/**
* Get a RegExp opcode and increase the bytecode position
@@ -167,318 +136,497 @@ re_get_char (const uint8_t **bc_p) /**< pointer to bytecode start */
inline re_opcode_t JERRY_ATTR_ALWAYS_INLINE
re_get_opcode (const uint8_t **bc_p) /**< pointer to bytecode start */
{
return (re_opcode_t) *((*bc_p)++);
return (re_opcode_t) re_get_byte (bc_p);
} /* re_get_opcode */
/**
* Get a parameter of a RegExp opcode and increase the bytecode position
*
* @return opcode parameter
* Encode 2 byte unsigned integer into the bytecode
*/
inline uint32_t JERRY_ATTR_ALWAYS_INLINE
re_get_value (const uint8_t **bc_p) /**< pointer to bytecode start */
static void
re_encode_u16 (uint8_t *dest_p, /**< destination */
const uint16_t value) /**< value */
{
const uint8_t *src_p = *bc_p;
uint32_t value = (uint32_t) (*src_p++);
value <<= 8;
value |= ((uint32_t) (*src_p++));
value <<= 8;
value |= ((uint32_t) (*src_p++));
value <<= 8;
value |= ((uint32_t) (*src_p++));
*dest_p++ = (uint8_t) ((value >> 8) & 0xFF);
*dest_p = (uint8_t) (value & 0xFF);
} /* re_encode_u16 */
(*bc_p) += sizeof (uint32_t);
/**
* Encode 4 byte unsigned integer into the bytecode
*/
static void
re_encode_u32 (uint8_t *dest_p, /**< destination */
const uint32_t value) /**< value */
{
*dest_p++ = (uint8_t) ((value >> 24) & 0xFF);
*dest_p++ = (uint8_t) ((value >> 16) & 0xFF);
*dest_p++ = (uint8_t) ((value >> 8) & 0xFF);
*dest_p = (uint8_t) (value & 0xFF);
} /* re_encode_u32 */
/**
* Decode 2 byte unsigned integer from bytecode
*
* @return uint16_t value
*/
static uint16_t
re_decode_u16 (const uint8_t *src_p) /**< source */
{
uint16_t value = (uint16_t) (((uint16_t) *src_p++) << 8);
value = (uint16_t) (value + *src_p++);
return value;
} /* re_decode_u16 */
/**
* Decode 4 byte unsigned integer from bytecode
*
* @return uint32_t value
*/
static uint32_t JERRY_ATTR_NOINLINE
re_decode_u32 (const uint8_t *src_p) /**< source */
{
uint32_t value = (uint32_t) (((uint32_t) *src_p++) << 24);
value += (uint32_t) (((uint32_t) *src_p++) << 16);
value += (uint32_t) (((uint32_t) *src_p++) << 8);
value += (uint32_t) (*src_p++);
return value;
} /* re_decode_u32 */
/**
* Get the encoded size of an uint32_t value.
*
* @return encoded value size
*/
inline static size_t JERRY_ATTR_ALWAYS_INLINE
re_get_encoded_value_size (uint32_t value) /**< value */
{
if (JERRY_LIKELY (value <= RE_VALUE_1BYTE_MAX))
{
return 1;
}
return 5;
} /* re_get_encoded_value_size */
/*
* Encode a value to the specified position in the bytecode.
*/
static void
re_encode_value (uint8_t *dest_p, /**< position in bytecode */
const uint32_t value) /**< value */
{
if (JERRY_LIKELY (value <= RE_VALUE_1BYTE_MAX))
{
*dest_p = (uint8_t) value;
return;
}
*dest_p++ = (uint8_t) (RE_VALUE_4BYTE_MARKER);
re_encode_u32 (dest_p, value);
} /* re_encode_value */
/**
* Append a value to the end of the bytecode.
*/
void
re_append_value (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const uint32_t value) /**< value */
{
const size_t size = re_get_encoded_value_size (value);
uint8_t *dest_p = re_bytecode_reserve (re_ctx_p, size);
re_encode_value (dest_p, value);
} /* re_append_value */
/**
* Insert a value into the bytecode at a specific offset.
*/
void
re_insert_value (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const uint32_t offset, /**< bytecode offset */
const uint32_t value) /**< value */
{
const size_t size = re_get_encoded_value_size (value);
uint8_t *dest_p = re_bytecode_insert (re_ctx_p, offset, size);
re_encode_value (dest_p, value);
} /* re_insert_value */
/**
* Read an encoded value from the bytecode.
*
* @return decoded value
*/
uint32_t JERRY_ATTR_ALWAYS_INLINE
re_get_value (const uint8_t **bc_p) /** refence to bytecode pointer */
{
uint32_t value = *(*bc_p)++;
if (JERRY_LIKELY (value <= RE_VALUE_1BYTE_MAX))
{
return value;
}
value = re_decode_u32 (*bc_p);
*bc_p += sizeof (uint32_t);
return value;
} /* re_get_value */
/**
* Get length of bytecode
*
* @return bytecode length (unsigned integer)
*/
inline uint32_t JERRY_ATTR_PURE JERRY_ATTR_ALWAYS_INLINE
re_get_bytecode_length (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytecode context */
{
return ((uint32_t) (bc_ctx_p->current_p - bc_ctx_p->block_start_p));
} /* re_get_bytecode_length */
/**
* Append a RegExp opcode
*/
void
re_append_opcode (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
const re_opcode_t opcode) /**< input opcode */
{
uint8_t *dest_p = re_bytecode_reserve (bc_ctx_p, sizeof (uint8_t));
*dest_p = (uint8_t) opcode;
} /* re_append_opcode */
/**
* Append a parameter of a RegExp opcode
*/
void
re_append_u32 (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
const uint32_t value) /**< input value */
{
uint8_t *dest_p = re_bytecode_reserve (bc_ctx_p, sizeof (uint32_t));
re_encode_u32 (dest_p, value);
} /* re_append_u32 */
/**
* Append a character to the RegExp bytecode
*/
void
re_append_char (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
const ecma_char_t input_char) /**< input char */
re_append_char (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const lit_code_point_t cp) /**< code point */
{
uint8_t *dest_p = re_bytecode_reserve (bc_ctx_p, sizeof (ecma_char_t));
re_encode_char (dest_p, input_char);
#if ENABLED (JERRY_ES2015)
const size_t size = (re_ctx_p->flags & RE_FLAG_UNICODE) ? sizeof (lit_code_point_t) : sizeof (ecma_char_t);
#else /* !ENABLED (JERRY_ES2015) */
JERRY_UNUSED (re_ctx_p);
const size_t size = sizeof (ecma_char_t);
#endif /* !ENABLED (JERRY_ES2015) */
uint8_t *dest_p = re_bytecode_reserve (re_ctx_p, size);
#if ENABLED (JERRY_ES2015)
if (re_ctx_p->flags & RE_FLAG_UNICODE)
{
re_encode_u32 (dest_p, cp);
return;
}
#endif /* ENABLED (JERRY_ES2015) */
JERRY_ASSERT (cp <= LIT_UTF16_CODE_UNIT_MAX);
re_encode_u16 (dest_p, (ecma_char_t) cp);
} /* re_append_char */
/**
* Append a jump offset parameter of a RegExp opcode
* Append a character to the RegExp bytecode
*/
void
re_append_jump_offset (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
uint32_t value) /**< input value */
re_insert_char (re_compiler_ctx_t *re_ctx_p, /**< RegExp bytecode context */
const uint32_t offset, /**< bytecode offset */
const lit_code_point_t cp) /**< code point*/
{
value += (uint32_t) (sizeof (uint32_t));
re_append_u32 (bc_ctx_p, value);
} /* re_append_jump_offset */
#if ENABLED (JERRY_ES2015)
const size_t size = (re_ctx_p->flags & RE_FLAG_UNICODE) ? sizeof (lit_code_point_t) : sizeof (ecma_char_t);
#else /* !ENABLED (JERRY_ES2015) */
JERRY_UNUSED (re_ctx_p);
const size_t size = sizeof (ecma_char_t);
#endif /* !ENABLED (JERRY_ES2015) */
uint8_t *dest_p = re_bytecode_insert (re_ctx_p, offset, size);
#if ENABLED (JERRY_ES2015)
if (re_ctx_p->flags & RE_FLAG_UNICODE)
{
re_encode_u32 (dest_p, cp);
return;
}
#endif /* ENABLED (JERRY_ES2015) */
JERRY_ASSERT (cp <= LIT_UTF16_CODE_UNIT_MAX);
re_encode_u16 (dest_p, (ecma_char_t) cp);
} /* re_insert_char */
/**
* Insert a RegExp opcode
* Decode a character from the bytecode.
*
* @return decoded character
*/
void
re_insert_opcode (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
const uint32_t offset, /**< distance from the start of the container */
const re_opcode_t opcode) /**< input opcode */
inline lit_code_point_t JERRY_ATTR_ALWAYS_INLINE
re_get_char (const uint8_t **bc_p, /**< reference to bytecode pointer */
bool unicode) /**< full unicode mode */
{
re_bytecode_insert (bc_ctx_p, offset, sizeof (uint8_t));
*(bc_ctx_p->block_start_p + offset) = (uint8_t) opcode;
} /* re_insert_opcode */
lit_code_point_t cp;
/**
* Insert a parameter of a RegExp opcode
*/
void
re_insert_u32 (re_bytecode_ctx_t *bc_ctx_p, /**< RegExp bytecode context */
uint32_t offset, /**< distance from the start of the container */
uint32_t value) /**< input value */
{
re_bytecode_insert (bc_ctx_p, offset, sizeof (uint32_t));
re_encode_u32 (bc_ctx_p->block_start_p + offset, value);
} /* re_insert_u32 */
#if !ENABLED (JERRY_ES2015)
JERRY_UNUSED (unicode);
#else /* ENABLED (JERRY_ES2015) */
if (unicode)
{
cp = re_decode_u32 (*bc_p);
*bc_p += sizeof (lit_code_point_t);
}
else
#endif /* ENABLED (JERRY_ES2015) */
{
cp = re_decode_u16 (*bc_p);
*bc_p += sizeof (ecma_char_t);
}
return cp;
} /* re_get_char */
#if ENABLED (JERRY_REGEXP_DUMP_BYTE_CODE)
static uint32_t
re_get_bytecode_offset (const uint8_t *start_p, /**< bytecode start pointer */
const uint8_t *current_p) /**< current bytecode pointer */
{
return (uint32_t) ((uintptr_t) current_p - (uintptr_t) start_p);
} /* re_get_bytecode_offset */
/**
* RegExp bytecode dumper
*/
void
re_dump_bytecode (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytecode context */
re_dump_bytecode (re_compiler_ctx_t *re_ctx_p) /**< RegExp bytecode context */
{
re_compiled_code_t *compiled_code_p = (re_compiled_code_t *) bc_ctx_p->block_start_p;
JERRY_DEBUG_MSG ("%d ", compiled_code_p->header.status_flags);
JERRY_DEBUG_MSG ("%d ", compiled_code_p->captures_count);
JERRY_DEBUG_MSG ("%d | ", compiled_code_p->non_captures_count);
static const char escape_chars[] = {'d', 'D', 'w', 'W', 's', 'S'};
const uint8_t *bytecode_p = (const uint8_t *) (compiled_code_p + 1);
re_compiled_code_t *compiled_code_p = (re_compiled_code_t *) re_ctx_p->bytecode_start_p;
JERRY_DEBUG_MSG ("Flags: 0x%x ", compiled_code_p->header.status_flags);
JERRY_DEBUG_MSG ("Capturing groups: %d ", compiled_code_p->captures_count);
JERRY_DEBUG_MSG ("Non-capturing groups: %d\n", compiled_code_p->non_captures_count);
re_opcode_t op;
while ((op = re_get_opcode (&bytecode_p)))
const uint8_t *bytecode_start_p = (const uint8_t *) (compiled_code_p + 1);
const uint8_t *bytecode_p = bytecode_start_p;
while (true)
{
JERRY_DEBUG_MSG ("[%3u] ", (uint32_t) ((uintptr_t) bytecode_p - (uintptr_t) bytecode_start_p));
re_opcode_t op = *bytecode_p++;
switch (op)
{
case RE_OP_MATCH:
case RE_OP_ALTERNATIVE_START:
{
JERRY_DEBUG_MSG ("MATCH, ");
JERRY_DEBUG_MSG ("ALTERNATIVE_START ");
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG ("tail offset: [%3u]\n", offset);
break;
}
case RE_OP_CHAR:
case RE_OP_ALTERNATIVE_NEXT:
{
JERRY_DEBUG_MSG ("CHAR ");
JERRY_DEBUG_MSG ("%c, ", (char) re_get_char (&bytecode_p));
JERRY_DEBUG_MSG ("ALTERNATIVE_NEXT ");
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG ("tail offset: [%3u]\n", offset);
break;
}
case RE_OP_CAPTURE_NON_GREEDY_ZERO_GROUP_START:
case RE_OP_NO_ALTERNATIVE:
{
JERRY_DEBUG_MSG ("N");
/* FALLTHRU */
}
case RE_OP_CAPTURE_GREEDY_ZERO_GROUP_START:
{
JERRY_DEBUG_MSG ("GZ_START ");
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("NO_ALTERNATIVES\n");
break;
}
case RE_OP_CAPTURE_GROUP_START:
case RE_OP_CAPTURING_GROUP_START:
{
JERRY_DEBUG_MSG ("START ");
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("CAPTURING_GROUP_START ");
JERRY_DEBUG_MSG ("idx: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("capture count: %u, ", re_get_value (&bytecode_p));
const uint32_t qmin = re_get_value (&bytecode_p);
JERRY_DEBUG_MSG ("qmin: %u", qmin);
if (qmin == 0)
{
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG (", tail offset: [%3u]\n", offset);
}
else
{
JERRY_DEBUG_MSG ("\n");
}
break;
}
case RE_OP_CAPTURE_NON_GREEDY_GROUP_END:
case RE_OP_NON_CAPTURING_GROUP_START:
{
JERRY_DEBUG_MSG ("N");
/* FALLTHRU */
}
case RE_OP_CAPTURE_GREEDY_GROUP_END:
{
JERRY_DEBUG_MSG ("G_END ");
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("NON_CAPTURING_GROUP_START ");
JERRY_DEBUG_MSG ("idx: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("capture start: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("capture count: %u, ", re_get_value (&bytecode_p));
const uint32_t qmin = re_get_value (&bytecode_p);
JERRY_DEBUG_MSG ("qmin: %u", qmin);
if (qmin == 0)
{
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG (", tail offset: [%3u]\n", offset);
}
else
{
JERRY_DEBUG_MSG ("\n");
}
break;
}
case RE_OP_NON_CAPTURE_NON_GREEDY_ZERO_GROUP_START:
case RE_OP_GREEDY_CAPTURING_GROUP_END:
{
JERRY_DEBUG_MSG ("N");
/* FALLTHRU */
}
case RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START:
{
JERRY_DEBUG_MSG ("GZ_NC_START ");
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("GREEDY_CAPTURING_GROUP_END ");
JERRY_DEBUG_MSG ("idx: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmin: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmax: %u\n", re_get_value (&bytecode_p) - RE_QMAX_OFFSET);
break;
}
case RE_OP_NON_CAPTURE_GROUP_START:
case RE_OP_LAZY_CAPTURING_GROUP_END:
{
JERRY_DEBUG_MSG ("NC_START ");
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("LAZY_CAPTURING_GROUP_END ");
JERRY_DEBUG_MSG ("idx: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmin: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmax: %u\n", re_get_value (&bytecode_p) - RE_QMAX_OFFSET);
break;
}
case RE_OP_NON_CAPTURE_NON_GREEDY_GROUP_END:
case RE_OP_GREEDY_NON_CAPTURING_GROUP_END:
{
JERRY_DEBUG_MSG ("N");
/* FALLTHRU */
}
case RE_OP_NON_CAPTURE_GREEDY_GROUP_END:
{
JERRY_DEBUG_MSG ("G_NC_END ");
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("GREEDY_NON_CAPTURING_GROUP_END ");
JERRY_DEBUG_MSG ("idx: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmin: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmax: %u\n", re_get_value (&bytecode_p) - RE_QMAX_OFFSET);
break;
}
case RE_OP_SAVE_AT_START:
case RE_OP_LAZY_NON_CAPTURING_GROUP_END:
{
JERRY_DEBUG_MSG ("RE_START ");
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
break;
}
case RE_OP_SAVE_AND_MATCH:
{
JERRY_DEBUG_MSG ("RE_END, ");
JERRY_DEBUG_MSG ("LAZY_NON_CAPTURING_GROUP_END ");
JERRY_DEBUG_MSG ("idx: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmin: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmax: %u\n", re_get_value (&bytecode_p) - RE_QMAX_OFFSET);
break;
}
case RE_OP_GREEDY_ITERATOR:
{
JERRY_DEBUG_MSG ("GREEDY_ITERATOR ");
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmin: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmax: %u, ", re_get_value (&bytecode_p) - RE_QMAX_OFFSET);
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG ("tail offset: [%3u]\n", offset);
break;
}
case RE_OP_NON_GREEDY_ITERATOR:
case RE_OP_LAZY_ITERATOR:
{
JERRY_DEBUG_MSG ("NON_GREEDY_ITERATOR ");
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("LAZY_ITERATOR ");
JERRY_DEBUG_MSG ("qmin: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("qmax: %u, ", re_get_value (&bytecode_p) - RE_QMAX_OFFSET);
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG ("tail offset: [%3u]\n", offset);
break;
}
case RE_OP_PERIOD:
case RE_OP_ITERATOR_END:
{
JERRY_DEBUG_MSG ("PERIOD ");
break;
}
case RE_OP_ALTERNATIVE:
{
JERRY_DEBUG_MSG ("ALTERNATIVE ");
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
break;
}
case RE_OP_ASSERT_START:
{
JERRY_DEBUG_MSG ("ASSERT_START ");
break;
}
case RE_OP_ASSERT_END:
{
JERRY_DEBUG_MSG ("ASSERT_END ");
break;
}
case RE_OP_ASSERT_WORD_BOUNDARY:
{
JERRY_DEBUG_MSG ("ASSERT_WORD_BOUNDARY ");
break;
}
case RE_OP_ASSERT_NOT_WORD_BOUNDARY:
{
JERRY_DEBUG_MSG ("ASSERT_NOT_WORD_BOUNDARY ");
break;
}
case RE_OP_LOOKAHEAD_POS:
{
JERRY_DEBUG_MSG ("LOOKAHEAD_POS ");
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
break;
}
case RE_OP_LOOKAHEAD_NEG:
{
JERRY_DEBUG_MSG ("LOOKAHEAD_NEG ");
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("ITERATOR_END\n");
break;
}
case RE_OP_BACKREFERENCE:
{
JERRY_DEBUG_MSG ("BACKREFERENCE ");
JERRY_DEBUG_MSG ("%d, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("idx: %d\n", re_get_value (&bytecode_p));
break;
}
case RE_OP_INV_CHAR_CLASS:
case RE_OP_ASSERT_LINE_START:
{
JERRY_DEBUG_MSG ("INV_");
/* FALLTHRU */
JERRY_DEBUG_MSG ("ASSERT_LINE_START\n");
break;
}
case RE_OP_ASSERT_LINE_END:
{
JERRY_DEBUG_MSG ("ASSERT_LINE_END\n");
break;
}
case RE_OP_ASSERT_LOOKAHEAD_POS:
{
JERRY_DEBUG_MSG ("ASSERT_LOOKAHEAD_POS ");
JERRY_DEBUG_MSG ("qmin: %u, ", *bytecode_p++);
JERRY_DEBUG_MSG ("capture start: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("capture count: %u, ", re_get_value (&bytecode_p));
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG ("tail offset: [%3u]\n", offset);
break;
}
case RE_OP_ASSERT_LOOKAHEAD_NEG:
{
JERRY_DEBUG_MSG ("ASSERT_LOOKAHEAD_NEG ");
JERRY_DEBUG_MSG ("qmin: %u, ", *bytecode_p++);
JERRY_DEBUG_MSG ("capture start: %u, ", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("capture count: %u, ", re_get_value (&bytecode_p));
const uint32_t offset = re_get_value (&bytecode_p) + re_get_bytecode_offset (bytecode_start_p, bytecode_p);
JERRY_DEBUG_MSG ("tail offset: [%3u]\n", offset);
break;
}
case RE_OP_ASSERT_END:
{
JERRY_DEBUG_MSG ("ASSERT_END\n");
break;
}
case RE_OP_ASSERT_WORD_BOUNDARY:
{
JERRY_DEBUG_MSG ("ASSERT_WORD_BOUNDARY\n");
break;
}
case RE_OP_ASSERT_NOT_WORD_BOUNDARY:
{
JERRY_DEBUG_MSG ("ASSERT_NOT_WORD_BOUNDARY\n");
break;
}
case RE_OP_CLASS_ESCAPE:
{
ecma_class_escape_t escape = (ecma_class_escape_t) *bytecode_p++;
JERRY_DEBUG_MSG ("CLASS_ESCAPE \\%c\n", escape_chars[escape]);
break;
}
case RE_OP_CHAR_CLASS:
{
JERRY_DEBUG_MSG ("CHAR_CLASS ");
uint32_t num_of_class = re_get_value (&bytecode_p);
JERRY_DEBUG_MSG ("%d", num_of_class);
while (num_of_class)
uint8_t flags = *bytecode_p++;
uint32_t char_count = (flags & RE_CLASS_HAS_CHARS) ? re_get_value (&bytecode_p) : 0;
uint32_t range_count = (flags & RE_CLASS_HAS_RANGES) ? re_get_value (&bytecode_p) : 0;
if (flags & RE_CLASS_INVERT)
{
if ((compiled_code_p->header.status_flags & RE_FLAG_UNICODE) != 0)
{
JERRY_DEBUG_MSG (" %u", re_get_value (&bytecode_p));
JERRY_DEBUG_MSG ("-%u", re_get_value (&bytecode_p));
}
else
{
JERRY_DEBUG_MSG (" %u", re_get_char (&bytecode_p));
JERRY_DEBUG_MSG ("-%u", re_get_char (&bytecode_p));
}
num_of_class--;
JERRY_DEBUG_MSG ("inverted ");
}
JERRY_DEBUG_MSG (", ");
JERRY_DEBUG_MSG ("escapes: ");
uint8_t escape_count = flags & RE_CLASS_ESCAPE_COUNT_MASK;
while (escape_count--)
{
JERRY_DEBUG_MSG ("\\%c, ", escape_chars[*bytecode_p++]);
}
JERRY_DEBUG_MSG ("chars: ");
while (char_count--)
{
JERRY_DEBUG_MSG ("\\u%04x, ", re_get_char (&bytecode_p, re_ctx_p->flags & RE_FLAG_UNICODE));
}
JERRY_DEBUG_MSG ("ranges: ");
while (range_count--)
{
const lit_code_point_t begin = re_get_char (&bytecode_p, re_ctx_p->flags & RE_FLAG_UNICODE);
const lit_code_point_t end = re_get_char (&bytecode_p, re_ctx_p->flags & RE_FLAG_UNICODE);
JERRY_DEBUG_MSG ("\\u%04x-\\u%04x, ", begin, end);
}
JERRY_DEBUG_MSG ("\n");
break;
}
#if ENABLED (JERRY_ES2015)
case RE_OP_UNICODE_PERIOD:
{
JERRY_DEBUG_MSG ("UNICODE_PERIOD\n");
break;
}
#endif /* ENABLED (JERRY_ES2015) */
case RE_OP_PERIOD:
{
JERRY_DEBUG_MSG ("PERIOD\n");
break;
}
case RE_OP_CHAR:
{
JERRY_DEBUG_MSG ("CHAR \\u%04x\n", re_get_char (&bytecode_p, re_ctx_p->flags & RE_FLAG_UNICODE));
break;
}
case RE_OP_BYTE:
{
const uint8_t ch = *bytecode_p++;
JERRY_DEBUG_MSG ("BYTE \\u%04x '%c'\n", ch, (char) ch);
break;
}
case RE_OP_EOF:
{
JERRY_DEBUG_MSG ("EOF\n");
return;
}
default:
{
JERRY_DEBUG_MSG ("UNKNOWN(%d), ", (uint32_t) op);
JERRY_DEBUG_MSG ("UNKNOWN(%d)\n", (uint32_t) op);
break;
}
}
}
JERRY_DEBUG_MSG ("EOF\n");
} /* re_dump_bytecode */
#endif /* ENABLED (JERRY_REGEXP_DUMP_BYTE_CODE) */
jerry-core/parser/regexp/re-bytecode.h
+62 -58
View File
@@ -19,6 +19,7 @@
#if ENABLED (JERRY_BUILTIN_REGEXP)
#include "ecma-globals.h"
#include "re-compiler-context.h"
/** \addtogroup parser Parser
* @{
@@ -40,43 +41,57 @@
*/
#define RE_FLAGS_MASK 0x3F
/**
* Maximum value that can be encoded in the RegExp bytecode as a single byte.
*/
#define RE_VALUE_1BYTE_MAX 0xFE
/**
* Marker that signals that the actual value is enocded in the following 4 bytes in the bytecode.
*/
#define RE_VALUE_4BYTE_MARKER 0xFF
/**
* RegExp opcodes
*/
typedef enum
{
RE_OP_EOF,
/* Group opcode order is important, because RE_IS_CAPTURE_GROUP is based on it.
* Change it carefully. Capture opcodes should be at first.
*/
RE_OP_CAPTURE_GROUP_START, /**< group start */
RE_OP_CAPTURE_GREEDY_ZERO_GROUP_START, /**< greedy zero group start */
RE_OP_CAPTURE_NON_GREEDY_ZERO_GROUP_START, /**< non-greedy zero group start */
RE_OP_CAPTURE_GREEDY_GROUP_END, /**< greedy group end */
RE_OP_CAPTURE_NON_GREEDY_GROUP_END, /**< non-greedy group end */
RE_OP_NON_CAPTURE_GROUP_START, /**< non-capture group start */
RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START, /**< non-capture greedy zero group start */
RE_OP_NON_CAPTURE_NON_GREEDY_ZERO_GROUP_START, /**< non-capture non-greedy zero group start */
RE_OP_NON_CAPTURE_GREEDY_GROUP_END, /**< non-capture greedy group end */
RE_OP_NON_CAPTURE_NON_GREEDY_GROUP_END, /**< non-capture non-greedy group end */
RE_OP_EOF, /**< end of pattern */
RE_OP_ALTERNATIVE_START, /**< start of alternatives */
RE_OP_ALTERNATIVE_NEXT, /**< next alternative */
RE_OP_NO_ALTERNATIVE, /**< no alternative */
RE_OP_CAPTURING_GROUP_START, /**< start of a capturing group */
RE_OP_NON_CAPTURING_GROUP_START, /**< start of a non-capturing group */
RE_OP_GREEDY_CAPTURING_GROUP_END, /**< end of a greedy capturing group */
RE_OP_GREEDY_NON_CAPTURING_GROUP_END, /**< end of a greedy non-capturing group */
RE_OP_LAZY_CAPTURING_GROUP_END, /**< end of a lazy capturing group */
RE_OP_LAZY_NON_CAPTURING_GROUP_END, /**< end of a lazy non-capturing group */
RE_OP_MATCH, /**< match */
RE_OP_CHAR, /**< any character */
RE_OP_SAVE_AT_START, /**< save at start */
RE_OP_SAVE_AND_MATCH, /**< save and match */
RE_OP_PERIOD, /**< "." */
RE_OP_ALTERNATIVE, /**< "|" */
RE_OP_GREEDY_ITERATOR, /**< greedy iterator */
RE_OP_NON_GREEDY_ITERATOR, /**< non-greedy iterator */
RE_OP_ASSERT_START, /**< "^" */
RE_OP_ASSERT_END, /**< "$" */
RE_OP_ASSERT_WORD_BOUNDARY, /**< "\b" */
RE_OP_ASSERT_NOT_WORD_BOUNDARY, /**< "\B" */
RE_OP_LOOKAHEAD_POS, /**< lookahead pos */
RE_OP_LOOKAHEAD_NEG, /**< lookahead neg */
RE_OP_BACKREFERENCE, /**< "\[0..9]" */
RE_OP_CHAR_CLASS, /**< "[ ]" */
RE_OP_INV_CHAR_CLASS /**< "[^ ]" */
RE_OP_LAZY_ITERATOR, /**< lazy iterator */
RE_OP_ITERATOR_END, /*** end of an iterator */
RE_OP_BACKREFERENCE, /**< backreference */
RE_OP_ASSERT_LINE_START, /**< line start assertion */
RE_OP_ASSERT_LINE_END, /**< line end assertion */
RE_OP_ASSERT_WORD_BOUNDARY, /**< word boundary assertion */
RE_OP_ASSERT_NOT_WORD_BOUNDARY, /**< not word boundary assertion */
RE_OP_ASSERT_LOOKAHEAD_POS, /**< positive lookahead assertion */
RE_OP_ASSERT_LOOKAHEAD_NEG, /**< negative lookahead assertion */
RE_OP_ASSERT_END, /**< end of an assertion */
RE_OP_CLASS_ESCAPE, /**< class escape */
RE_OP_CHAR_CLASS, /**< character class */
#if ENABLED (JERRY_ES2015)
RE_OP_UNICODE_PERIOD, /**< period in full unicode mode */
#endif /* ENABLED (JERRY_ES2015) */
RE_OP_PERIOD, /**< period in non-unicode mode */
RE_OP_CHAR, /**< any code point */
RE_OP_BYTE, /**< 1-byte utf8 character */
} re_opcode_t;
/**
@@ -85,42 +100,31 @@ typedef enum
typedef struct
{
ecma_compiled_code_t header; /**< compiled code header */
uint32_t captures_count; /**< number of capturing groups */
uint32_t non_captures_count; /**< number of non-capturing groups */
ecma_value_t source; /**< original RegExp pattern */
uint32_t captures_count; /**< number of capturing brackets */
uint32_t non_captures_count; /**< number of non capturing brackets */
} re_compiled_code_t;
/**
* Context of RegExp bytecode container
*/
typedef struct
{
uint8_t *block_start_p; /**< start of bytecode block */
uint8_t *block_end_p; /**< end of bytecode block */
uint8_t *current_p; /**< current position in bytecode */
} re_bytecode_ctx_t;
void re_initialize_regexp_bytecode (re_compiler_ctx_t *re_ctx_p);
uint32_t re_bytecode_size (re_compiler_ctx_t *re_ctx_p);
void re_append_opcode (re_compiler_ctx_t *re_ctx_p, const re_opcode_t opcode);
void re_append_byte (re_compiler_ctx_t *re_ctx_p, const uint8_t byte);
void re_append_char (re_compiler_ctx_t *re_ctx_p, const lit_code_point_t cp);
void re_append_value (re_compiler_ctx_t *re_ctx_p, const uint32_t value);
void re_insert_opcode (re_compiler_ctx_t *re_ctx_p, const uint32_t offset, const re_opcode_t opcode);
void re_insert_byte (re_compiler_ctx_t *re_ctx_p, const uint32_t offset, const uint8_t byte);
void re_insert_char (re_compiler_ctx_t *re_ctx_p, const uint32_t offset, const lit_code_point_t cp);
void re_insert_value (re_compiler_ctx_t *re_ctx_p, const uint32_t offset, const uint32_t value);
re_opcode_t re_get_opcode (const uint8_t **bc_p);
ecma_char_t re_get_char (const uint8_t **bc_p);
uint8_t re_get_byte (const uint8_t **bc_p);
lit_code_point_t re_get_char (const uint8_t **bc_p, bool unicode);
uint32_t re_get_value (const uint8_t **bc_p);
uint32_t JERRY_ATTR_PURE re_get_bytecode_length (re_bytecode_ctx_t *bc_ctx_p);
void re_initialize_regexp_bytecode (re_bytecode_ctx_t *bc_ctx_p);
void re_append_opcode (re_bytecode_ctx_t *bc_ctx_p, const re_opcode_t opcode);
void re_append_u32 (re_bytecode_ctx_t *bc_ctx_p, const uint32_t value);
void re_append_char (re_bytecode_ctx_t *bc_ctx_p, const ecma_char_t input_char);
void re_append_jump_offset (re_bytecode_ctx_t *bc_ctx_p, uint32_t value);
void re_insert_opcode (re_bytecode_ctx_t *bc_ctx_p, const uint32_t offset, const re_opcode_t opcode);
void re_insert_u32 (re_bytecode_ctx_t *bc_ctx_p, const uint32_t offset, const uint32_t value);
void re_bytecode_list_insert (re_bytecode_ctx_t *bc_ctx_p,
const size_t offset,
const uint8_t *bytecode_p,
const size_t length);
#if ENABLED (JERRY_REGEXP_DUMP_BYTE_CODE)
void re_dump_bytecode (re_bytecode_ctx_t *bc_ctx);
void re_dump_bytecode (re_compiler_ctx_t *bc_ctx);
#endif /* ENABLED (JERRY_REGEXP_DUMP_BYTE_CODE) */
/**
jerry-core/parser/regexp/re-compiler-context.h
+60
View File
@@ -0,0 +1,60 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RE_COMPILER_CONTEXT_H
#define RE_COMPILER_CONTEXT_H
#if ENABLED (JERRY_BUILTIN_REGEXP)
#include "re-token.h"
/** \addtogroup parser Parser
* @{
*
* \addtogroup regexparser Regular expression
* @{
*
* \addtogroup regexparser_compiler Compiler
* @{
*/
/**
* RegExp compiler context
*/
typedef struct
{
const lit_utf8_byte_t *input_start_p; /**< start of input pattern */
const lit_utf8_byte_t *input_curr_p; /**< current position in input pattern */
const lit_utf8_byte_t *input_end_p; /**< end of input pattern */
uint8_t *bytecode_start_p; /**< start of bytecode block */
size_t bytecode_size; /**< size of bytecode */
uint32_t captures_count; /**< number of capture groups */
uint32_t non_captures_count; /**< number of non-capture groups */
int groups_count; /**< number of groups */
uint16_t flags; /**< RegExp flags */
re_token_t token; /**< current token */
} re_compiler_ctx_t;
/**
* @}
* @}
* @}
*/
#endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
#endif /* !RE_COMPILER_CONTEXT_H */
jerry-core/parser/regexp/re-compiler.c
+77 -832
View File
@@ -23,6 +23,7 @@
#include "jmem.h"
#include "re-bytecode.h"
#include "re-compiler.h"
#include "re-compiler-context.h"
#include "re-parser.h"
#if ENABLED (JERRY_BUILTIN_REGEXP)
@@ -38,896 +39,140 @@
*/
/**
* Insert simple atom iterator
* Search for the given pattern in the RegExp cache.
*
* @return empty ecma value - if inserted successfully
* error ecma value - otherwise
*
* Returned value must be freed with ecma_free_value
* @return pointer to bytecode if found
* NULL - otherwise
*/
static ecma_value_t
re_insert_simple_iterator (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
uint32_t new_atom_start_offset) /**< atom start offset */
static re_compiled_code_t *
re_cache_lookup (ecma_string_t *pattern_str_p, /**< pattern string */
uint16_t flags) /**< flags */
{
uint32_t atom_code_length;
uint32_t offset;
uint32_t qmin, qmax;
qmin = re_ctx_p->current_token.qmin;
qmax = re_ctx_p->current_token.qmax;
if (qmin == 1 && qmax == 1)
{
return ECMA_VALUE_EMPTY;
}
else if (qmin > qmax)
{
/* ECMA-262 v5.1 15.10.2.5 */
return ecma_raise_syntax_error (ECMA_ERR_MSG ("RegExp quantifier error: min > max."));
}
/* TODO: optimize bytecode length. Store 0 rather than INF */
re_append_opcode (re_ctx_p->bytecode_ctx_p, RE_OP_MATCH); /* complete 'sub atom' */
uint32_t bytecode_length = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
atom_code_length = (uint32_t) (bytecode_length - new_atom_start_offset);
offset = new_atom_start_offset;
re_insert_u32 (re_ctx_p->bytecode_ctx_p, offset, atom_code_length);
re_insert_u32 (re_ctx_p->bytecode_ctx_p, offset, qmax);
re_insert_u32 (re_ctx_p->bytecode_ctx_p, offset, qmin);
if (re_ctx_p->current_token.greedy)
{
re_insert_opcode (re_ctx_p->bytecode_ctx_p, offset, RE_OP_GREEDY_ITERATOR);
}
else
{
re_insert_opcode (re_ctx_p->bytecode_ctx_p, offset, RE_OP_NON_GREEDY_ITERATOR);
}
return ECMA_VALUE_EMPTY;
} /* re_insert_simple_iterator */
/**
* Get the type of a group start
*
* @return RegExp opcode
*/
static re_opcode_t
re_get_start_opcode_type (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
bool is_capturable) /**< is capturable group */
{
if (is_capturable)
{
if (re_ctx_p->current_token.qmin == 0)
{
if (re_ctx_p->current_token.greedy)
{
return RE_OP_CAPTURE_GREEDY_ZERO_GROUP_START;
}
return RE_OP_CAPTURE_NON_GREEDY_ZERO_GROUP_START;
}
return RE_OP_CAPTURE_GROUP_START;
}
if (re_ctx_p->current_token.qmin == 0)
{
if (re_ctx_p->current_token.greedy)
{
return RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START;
}
return RE_OP_NON_CAPTURE_NON_GREEDY_ZERO_GROUP_START;
}
return RE_OP_NON_CAPTURE_GROUP_START;
} /* re_get_start_opcode_type */
/**
* Get the type of a group end
*
* @return RegExp opcode
*/
static re_opcode_t
re_get_end_opcode_type (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
bool is_capturable) /**< is capturable group */
{
if (is_capturable)
{
if (re_ctx_p->current_token.greedy)
{
return RE_OP_CAPTURE_GREEDY_GROUP_END;
}
return RE_OP_CAPTURE_NON_GREEDY_GROUP_END;
}
if (re_ctx_p->current_token.greedy)
{
return RE_OP_NON_CAPTURE_GREEDY_GROUP_END;
}
return RE_OP_NON_CAPTURE_NON_GREEDY_GROUP_END;
} /* re_get_end_opcode_type */
/**
* Enclose the given bytecode to a group
*
* @return empty ecma value - if inserted successfully
* error ecma value - otherwise
*
* Returned value must be freed with ecma_free_value
*/
static ecma_value_t
re_insert_into_group (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
uint32_t group_start_offset, /**< offset of group start */
uint32_t idx, /**< index of group */
bool is_capturable) /**< is capturable group */
{
uint32_t qmin = re_ctx_p->current_token.qmin;
uint32_t qmax = re_ctx_p->current_token.qmax;
if (qmin > qmax)
{
/* ECMA-262 v5.1 15.10.2.5 */
return ecma_raise_syntax_error (ECMA_ERR_MSG ("RegExp quantifier error: min > max."));
}
re_opcode_t start_opcode = re_get_start_opcode_type (re_ctx_p, is_capturable);
re_opcode_t end_opcode = re_get_end_opcode_type (re_ctx_p, is_capturable);
uint32_t start_head_offset_len = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
re_insert_u32 (re_ctx_p->bytecode_ctx_p, group_start_offset, idx);
re_insert_opcode (re_ctx_p->bytecode_ctx_p, group_start_offset, start_opcode);
start_head_offset_len = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p) - start_head_offset_len;
re_append_opcode (re_ctx_p->bytecode_ctx_p, end_opcode);
re_append_u32 (re_ctx_p->bytecode_ctx_p, idx);
re_append_u32 (re_ctx_p->bytecode_ctx_p, qmin);
re_append_u32 (re_ctx_p->bytecode_ctx_p, qmax);
group_start_offset += start_head_offset_len;
re_append_jump_offset (re_ctx_p->bytecode_ctx_p,
re_get_bytecode_length (re_ctx_p->bytecode_ctx_p) - group_start_offset);
if (start_opcode != RE_OP_CAPTURE_GROUP_START && start_opcode != RE_OP_NON_CAPTURE_GROUP_START)
{
re_insert_u32 (re_ctx_p->bytecode_ctx_p,
group_start_offset,
re_get_bytecode_length (re_ctx_p->bytecode_ctx_p) - group_start_offset);
}
return ECMA_VALUE_EMPTY;
} /* re_insert_into_group */
/**
* Enclose the given bytecode to a group and inster jump value
*
* @return empty ecma value - if inserted successfully
* error ecma value - otherwise
*
* Returned value must be freed with ecma_free_value
*/
static ecma_value_t
re_insert_into_group_with_jump (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
uint32_t group_start_offset, /**< offset of group start */
uint32_t idx, /**< index of group */
bool is_capturable) /**< is capturable group */
{
re_insert_u32 (re_ctx_p->bytecode_ctx_p,
group_start_offset,
re_get_bytecode_length (re_ctx_p->bytecode_ctx_p) - group_start_offset);
return re_insert_into_group (re_ctx_p, group_start_offset, idx, is_capturable);
} /* re_insert_into_group_with_jump */
/**
* Append a character class range to the bytecode
*/
static void
re_append_char_class (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
lit_code_point_t start, /**< character class range from */
lit_code_point_t end) /**< character class range to */
{
re_ctx_p->parser_ctx_p->classes_count++;
#if ENABLED (JERRY_ES2015)
if (re_ctx_p->flags & RE_FLAG_UNICODE)
{
re_append_u32 (re_ctx_p->bytecode_ctx_p, ecma_regexp_canonicalize (start, re_ctx_p->flags & RE_FLAG_IGNORE_CASE));
re_append_u32 (re_ctx_p->bytecode_ctx_p, ecma_regexp_canonicalize (end, re_ctx_p->flags & RE_FLAG_IGNORE_CASE));
return;
}
#endif /* ENABLED (JERRY_ES2015) */
JERRY_ASSERT (start <= LIT_UTF16_CODE_UNIT_MAX);
JERRY_ASSERT (end <= LIT_UTF16_CODE_UNIT_MAX);
re_append_char (re_ctx_p->bytecode_ctx_p,
(ecma_char_t) ecma_regexp_canonicalize (start,
re_ctx_p->flags & RE_FLAG_IGNORE_CASE));
re_append_char (re_ctx_p->bytecode_ctx_p,
(ecma_char_t) ecma_regexp_canonicalize (end,
re_ctx_p->flags & RE_FLAG_IGNORE_CASE));
} /* re_append_char_class */
/**
* Read the input pattern and parse the range of character class
*
* @return empty ecma value - if parsed successfully
* error ecma value - otherwise
*
* Returned value must be freed with ecma_free_value
*/
static ecma_value_t
re_parse_char_class (re_compiler_ctx_t *re_ctx_p, /**< number of classes */
re_token_t *out_token_p) /**< [out] output token */
{
re_parser_ctx_t *const parser_ctx_p = re_ctx_p->parser_ctx_p;
out_token_p->qmax = out_token_p->qmin = 1;
parser_ctx_p->classes_count = 0;
lit_code_point_t start = LIT_CHAR_UNDEF;
bool is_range = false;
const bool is_char_class = (re_ctx_p->current_token.type == RE_TOK_START_CHAR_CLASS
|| re_ctx_p->current_token.type == RE_TOK_START_INV_CHAR_CLASS);
const ecma_char_t prev_char = lit_cesu8_peek_prev (parser_ctx_p->input_curr_p);
if (prev_char != LIT_CHAR_LEFT_SQUARE && prev_char != LIT_CHAR_CIRCUMFLEX)
{
lit_utf8_decr (&parser_ctx_p->input_curr_p);
lit_utf8_decr (&parser_ctx_p->input_curr_p);
}
do
{
if (parser_ctx_p->input_curr_p >= parser_ctx_p->input_end_p)
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("invalid character class, end of string"));
}
lit_code_point_t ch = lit_cesu8_read_next (&parser_ctx_p->input_curr_p);
if (ch == LIT_CHAR_RIGHT_SQUARE)
{
if (start != LIT_CHAR_UNDEF)
{
re_append_char_class (re_ctx_p, start, start);
}
break;
}
else if (ch == LIT_CHAR_MINUS)
{
if (parser_ctx_p->input_curr_p >= parser_ctx_p->input_end_p)
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("invalid character class, end of string after '-'"));
}
if (start != LIT_CHAR_UNDEF
&& !is_range
&& *parser_ctx_p->input_curr_p != LIT_CHAR_RIGHT_SQUARE)
{
is_range = true;
continue;
}
}
else if (ch == LIT_CHAR_BACKSLASH)
{
if (parser_ctx_p->input_curr_p >= parser_ctx_p->input_end_p)
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("invalid character class, end of string after '\\'"));
}
ch = lit_cesu8_read_next (&parser_ctx_p->input_curr_p);
if (ch == LIT_CHAR_LOWERCASE_B)
{
ch = LIT_CHAR_BS;
}
else if (ch == LIT_CHAR_LOWERCASE_F)
{
ch = LIT_CHAR_FF;
}
else if (ch == LIT_CHAR_LOWERCASE_N)
{
ch = LIT_CHAR_LF;
}
else if (ch == LIT_CHAR_LOWERCASE_T)
{
ch = LIT_CHAR_TAB;
}
else if (ch == LIT_CHAR_LOWERCASE_R)
{
ch = LIT_CHAR_CR;
}
else if (ch == LIT_CHAR_LOWERCASE_V)
{
ch = LIT_CHAR_VTAB;
}
else if (ch == LIT_CHAR_LOWERCASE_C)
{
if (parser_ctx_p->input_curr_p < parser_ctx_p->input_end_p)
{
ch = *parser_ctx_p->input_curr_p;
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)
|| (ch >= LIT_CHAR_0 && ch <= LIT_CHAR_9))
{
/* See ECMA-262 v5, 15.10.2.10 (Point 3) */
ch = (ch % 32);
parser_ctx_p->input_curr_p++;
}
else
{
ch = LIT_CHAR_LOWERCASE_C;
}
}
}
else if (ch == LIT_CHAR_LOWERCASE_X && re_hex_lookup (parser_ctx_p, 2))
{
ecma_char_t code_unit;
if (!lit_read_code_unit_from_hex (parser_ctx_p->input_curr_p, 2, &code_unit))
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("invalid character class, end of string after '\\x'"));
}
parser_ctx_p->input_curr_p += 2;
if (parser_ctx_p->input_curr_p < parser_ctx_p->input_end_p
&& is_range == false
&& lit_cesu8_peek_next (parser_ctx_p->input_curr_p) == LIT_CHAR_MINUS)
{
start = code_unit;
continue;
}
ch = code_unit;
}
else if (ch == LIT_CHAR_LOWERCASE_U && re_hex_lookup (parser_ctx_p, 4))
{
ecma_char_t code_unit;
if (!lit_read_code_unit_from_hex (parser_ctx_p->input_curr_p, 4, &code_unit))
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("invalid character class, end of string after '\\u'"));
}
parser_ctx_p->input_curr_p += 4;
if (parser_ctx_p->input_curr_p < parser_ctx_p->input_end_p
&& is_range == false
&& lit_cesu8_peek_next (parser_ctx_p->input_curr_p) == LIT_CHAR_MINUS)
{
start = code_unit;
continue;
}
ch = code_unit;
}
else if (ch == LIT_CHAR_LOWERCASE_D)
{
/* See ECMA-262 v5, 15.10.2.12 */
re_append_char_class (re_ctx_p, LIT_CHAR_ASCII_DIGITS_BEGIN, LIT_CHAR_ASCII_DIGITS_END);
ch = LIT_CHAR_UNDEF;
}
else if (ch == LIT_CHAR_UPPERCASE_D)
{
/* See ECMA-262 v5, 15.10.2.12 */
re_append_char_class (re_ctx_p, LIT_CHAR_NULL, LIT_CHAR_ASCII_DIGITS_BEGIN - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_ASCII_DIGITS_END + 1, LIT_UTF16_CODE_UNIT_MAX);
ch = LIT_CHAR_UNDEF;
}
else if (ch == LIT_CHAR_LOWERCASE_S)
{
/* See ECMA-262 v5, 15.10.2.12 */
re_append_char_class (re_ctx_p, LIT_CHAR_TAB, LIT_CHAR_CR);
re_append_char_class (re_ctx_p, LIT_CHAR_SP, LIT_CHAR_SP);
re_append_char_class (re_ctx_p, LIT_CHAR_NBSP, LIT_CHAR_NBSP);
re_append_char_class (re_ctx_p, 0x1680UL, 0x1680UL); /* Ogham Space Mark */
re_append_char_class (re_ctx_p, 0x180EUL, 0x180EUL); /* Mongolian Vowel Separator */
re_append_char_class (re_ctx_p, 0x2000UL, 0x200AUL); /* En Quad - Hair Space */
re_append_char_class (re_ctx_p, LIT_CHAR_LS, LIT_CHAR_PS);
re_append_char_class (re_ctx_p, 0x202FUL, 0x202FUL); /* Narrow No-Break Space */
re_append_char_class (re_ctx_p, 0x205FUL, 0x205FUL); /* Medium Mathematical Space */
re_append_char_class (re_ctx_p, 0x3000UL, 0x3000UL); /* Ideographic Space */
re_append_char_class (re_ctx_p, LIT_CHAR_BOM, LIT_CHAR_BOM);
ch = LIT_CHAR_UNDEF;
}
else if (ch == LIT_CHAR_UPPERCASE_S)
{
/* See ECMA-262 v5, 15.10.2.12 */
re_append_char_class (re_ctx_p, LIT_CHAR_NULL, LIT_CHAR_TAB - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_CR + 1, LIT_CHAR_SP - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_SP + 1, LIT_CHAR_NBSP - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_NBSP + 1, 0x167FUL);
re_append_char_class (re_ctx_p, 0x1681UL, 0x180DUL);
re_append_char_class (re_ctx_p, 0x180FUL, 0x1FFFUL);
re_append_char_class (re_ctx_p, 0x200BUL, LIT_CHAR_LS - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_PS + 1, 0x202EUL);
re_append_char_class (re_ctx_p, 0x2030UL, 0x205EUL);
re_append_char_class (re_ctx_p, 0x2060UL, 0x2FFFUL);
re_append_char_class (re_ctx_p, 0x3001UL, LIT_CHAR_BOM - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_BOM + 1, LIT_UTF16_CODE_UNIT_MAX);
ch = LIT_CHAR_UNDEF;
}
else if (ch == LIT_CHAR_LOWERCASE_W)
{
/* See ECMA-262 v5, 15.10.2.12 */
re_append_char_class (re_ctx_p, LIT_CHAR_0, LIT_CHAR_9);
re_append_char_class (re_ctx_p, LIT_CHAR_UPPERCASE_A, LIT_CHAR_UPPERCASE_Z);
re_append_char_class (re_ctx_p, LIT_CHAR_UNDERSCORE, LIT_CHAR_UNDERSCORE);
re_append_char_class (re_ctx_p, LIT_CHAR_LOWERCASE_A, LIT_CHAR_LOWERCASE_Z);
ch = LIT_CHAR_UNDEF;
}
else if (ch == LIT_CHAR_UPPERCASE_W)
{
/* See ECMA-262 v5, 15.10.2.12 */
re_append_char_class (re_ctx_p, LIT_CHAR_NULL, LIT_CHAR_0 - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_9 + 1, LIT_CHAR_UPPERCASE_A - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_UPPERCASE_Z + 1, LIT_CHAR_UNDERSCORE - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_UNDERSCORE + 1, LIT_CHAR_LOWERCASE_A - 1);
re_append_char_class (re_ctx_p, LIT_CHAR_LOWERCASE_Z + 1, LIT_UTF16_CODE_UNIT_MAX);
ch = LIT_CHAR_UNDEF;
}
else if (lit_char_is_octal_digit ((ecma_char_t) ch))
{
lit_utf8_decr (&parser_ctx_p->input_curr_p);
ch = (ecma_char_t) re_parse_octal (parser_ctx_p);
}
} /* ch == LIT_CHAR_BACKSLASH */
#if ENABLED (JERRY_ES2015)
if (re_ctx_p->flags & RE_FLAG_UNICODE
&& lit_is_code_point_utf16_high_surrogate (ch)
&& parser_ctx_p->input_curr_p < parser_ctx_p->input_end_p)
{
const ecma_char_t next_ch = lit_cesu8_peek_next (parser_ctx_p->input_curr_p);
if (lit_is_code_point_utf16_low_surrogate (next_ch))
{
ch = lit_convert_surrogate_pair_to_code_point ((ecma_char_t) ch, next_ch);
lit_utf8_incr (&parser_ctx_p->input_curr_p);
}
}
#endif /* ENABLED (JERRY_ES2015) */
if (start != LIT_CHAR_UNDEF)
{
if (is_range)
{
if (start > ch)
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("invalid character class, wrong order"));
}
else
{
re_append_char_class (re_ctx_p, start, ch);
start = LIT_CHAR_UNDEF;
is_range = false;
}
}
else
{
re_append_char_class (re_ctx_p, start, start);
start = ch;
}
}
else
{
start = ch;
}
}
while (is_char_class);
return re_parse_iterator (parser_ctx_p, out_token_p);
} /* re_parse_char_class */
/**
* Parse alternatives
*
* @return empty ecma value - if alternative was successfully parsed
* error ecma value - otherwise
*
* Returned value must be freed with ecma_free_value
*/
static ecma_value_t
re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
bool expect_eof) /**< expect end of file */
{
ECMA_CHECK_STACK_USAGE ();
uint32_t idx;
re_bytecode_ctx_t *bc_ctx_p = re_ctx_p->bytecode_ctx_p;
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
uint32_t alternative_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
while (ecma_is_value_empty (ret_value))
{
ecma_value_t next_token_result = re_parse_next_token (re_ctx_p->parser_ctx_p,
&(re_ctx_p->current_token));
if (ECMA_IS_VALUE_ERROR (next_token_result))
{
return next_token_result;
}
JERRY_ASSERT (ecma_is_value_empty (next_token_result));
uint32_t new_atom_start_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
switch (re_ctx_p->current_token.type)
{
case RE_TOK_START_CAPTURE_GROUP:
{
idx = re_ctx_p->captures_count++;
JERRY_TRACE_MSG ("Compile a capture group start (idx: %u)\n", (unsigned int) idx);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_value_empty (ret_value))
{
ret_value = re_insert_into_group (re_ctx_p, new_atom_start_offset, idx, true);
}
break;
}
case RE_TOK_START_NON_CAPTURE_GROUP:
{
idx = re_ctx_p->non_captures_count++;
JERRY_TRACE_MSG ("Compile a non-capture group start (idx: %u)\n", (unsigned int) idx);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_value_empty (ret_value))
{
ret_value = re_insert_into_group (re_ctx_p, new_atom_start_offset, idx, false);
}
break;
}
case RE_TOK_CHAR:
{
JERRY_TRACE_MSG ("Compile character token: %c, qmin: %u, qmax: %u\n",
(char) re_ctx_p->current_token.value, (unsigned int) re_ctx_p->current_token.qmin,
(unsigned int) re_ctx_p->current_token.qmax);
re_append_opcode (bc_ctx_p, RE_OP_CHAR);
re_append_char (bc_ctx_p, (ecma_char_t) ecma_regexp_canonicalize ((ecma_char_t) re_ctx_p->current_token.value,
re_ctx_p->flags & RE_FLAG_IGNORE_CASE));
ret_value = re_insert_simple_iterator (re_ctx_p, new_atom_start_offset);
break;
}
case RE_TOK_PERIOD:
{
JERRY_TRACE_MSG ("Compile a period\n");
re_append_opcode (bc_ctx_p, RE_OP_PERIOD);
ret_value = re_insert_simple_iterator (re_ctx_p, new_atom_start_offset);
break;
}
case RE_TOK_ALTERNATIVE:
{
JERRY_TRACE_MSG ("Compile an alternative\n");
re_insert_u32 (bc_ctx_p, alternative_offset, re_get_bytecode_length (bc_ctx_p) - alternative_offset);
re_append_opcode (bc_ctx_p, RE_OP_ALTERNATIVE);
alternative_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
break;
}
case RE_TOK_ASSERT_START:
{
JERRY_TRACE_MSG ("Compile a start assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_START);
break;
}
case RE_TOK_ASSERT_END:
{
JERRY_TRACE_MSG ("Compile an end assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_END);
break;
}
case RE_TOK_ASSERT_WORD_BOUNDARY:
{
JERRY_TRACE_MSG ("Compile a word boundary assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_WORD_BOUNDARY);
break;
}
case RE_TOK_ASSERT_NOT_WORD_BOUNDARY:
{
JERRY_TRACE_MSG ("Compile a not word boundary assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_NOT_WORD_BOUNDARY);
break;
}
case RE_TOK_ASSERT_START_POS_LOOKAHEAD:
{
JERRY_TRACE_MSG ("Compile a positive lookahead assertion\n");
idx = re_ctx_p->non_captures_count++;
re_append_opcode (bc_ctx_p, RE_OP_LOOKAHEAD_POS);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_value_empty (ret_value))
{
re_append_opcode (bc_ctx_p, RE_OP_MATCH);
ret_value = re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false);
}
break;
}
case RE_TOK_ASSERT_START_NEG_LOOKAHEAD:
{
JERRY_TRACE_MSG ("Compile a negative lookahead assertion\n");
idx = re_ctx_p->non_captures_count++;
re_append_opcode (bc_ctx_p, RE_OP_LOOKAHEAD_NEG);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_value_empty (ret_value))
{
re_append_opcode (bc_ctx_p, RE_OP_MATCH);
ret_value = re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false);
}
break;
}
case RE_TOK_BACKREFERENCE:
{
uint32_t backref = (uint32_t) re_ctx_p->current_token.value;
idx = re_ctx_p->non_captures_count++;
if (backref > re_ctx_p->highest_backref)
{
re_ctx_p->highest_backref = backref;
}
JERRY_TRACE_MSG ("Compile a backreference: %u\n", (unsigned int) backref);
re_append_opcode (bc_ctx_p, RE_OP_BACKREFERENCE);
re_append_u32 (bc_ctx_p, backref);
ret_value = re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false);
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_INV_CHAR_CLASS:
{
JERRY_TRACE_MSG ("Compile a character class\n");
re_append_opcode (bc_ctx_p,
re_ctx_p->current_token.type == RE_TOK_START_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);
ret_value = re_parse_char_class (re_ctx_p,
&(re_ctx_p->current_token));
if (!ECMA_IS_VALUE_ERROR (ret_value))
{
re_insert_u32 (bc_ctx_p, offset, re_ctx_p->parser_ctx_p->classes_count);
ret_value = re_insert_simple_iterator (re_ctx_p, new_atom_start_offset);
}
break;
}
case RE_TOK_END_GROUP:
{
JERRY_TRACE_MSG ("Compile a group end\n");
if (expect_eof)
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("Unexpected end of paren."));
}
re_insert_u32 (bc_ctx_p, alternative_offset, re_get_bytecode_length (bc_ctx_p) - alternative_offset);
return ECMA_VALUE_EMPTY;
}
case RE_TOK_EOF:
{
if (!expect_eof)
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("Unexpected end of pattern."));
}
re_insert_u32 (bc_ctx_p, alternative_offset, re_get_bytecode_length (bc_ctx_p) - alternative_offset);
return ECMA_VALUE_EMPTY;
}
default:
{
return ecma_raise_syntax_error (ECMA_ERR_MSG ("Unexpected RegExp token."));
}
}
}
return ret_value;
} /* re_parse_alternative */
/**
* Search for the given pattern in the RegExp cache
*
* @return index of bytecode in cache - if found
* RE_CACHE_SIZE - otherwise
*/
static uint8_t
re_find_bytecode_in_cache (ecma_string_t *pattern_str_p, /**< pattern string */
uint16_t flags) /**< flags */
{
uint8_t free_idx = RE_CACHE_SIZE;
re_compiled_code_t **cache_p = JERRY_CONTEXT (re_cache);
for (uint8_t idx = 0u; idx < RE_CACHE_SIZE; idx++)
{
const re_compiled_code_t *cached_bytecode_p = JERRY_CONTEXT (re_cache)[idx];
re_compiled_code_t *cached_bytecode_p = cache_p[idx];
if (cached_bytecode_p != NULL)
if (cached_bytecode_p == NULL)
{
ecma_string_t *cached_pattern_str_p = ecma_get_string_from_value (cached_bytecode_p->source);
if ((cached_bytecode_p->header.status_flags & RE_FLAGS_MASK) == flags
&& ecma_compare_ecma_strings (cached_pattern_str_p, pattern_str_p))
{
JERRY_TRACE_MSG ("RegExp is found in cache\n");
return idx;
}
break;
}
else
ecma_string_t *cached_pattern_str_p = ecma_get_string_from_value (cached_bytecode_p->source);
if ((cached_bytecode_p->header.status_flags & RE_FLAGS_MASK) == flags
&& ecma_compare_ecma_strings (cached_pattern_str_p, pattern_str_p))
{
/* mark as free, so it can be overridden if the cache is full */
free_idx = idx;
return cached_bytecode_p;
}
}
JERRY_TRACE_MSG ("RegExp is NOT found in cache\n");
return free_idx;
} /* re_find_bytecode_in_cache */
return NULL;
} /* re_cache_lookup */
/**
* Run gerbage collection in RegExp cache
* Run garbage collection in RegExp cache.
*/
void
re_cache_gc_run (void)
re_cache_gc (void)
{
re_compiled_code_t **cache_p = JERRY_CONTEXT (re_cache);
for (uint32_t i = 0u; i < RE_CACHE_SIZE; i++)
{
const re_compiled_code_t *cached_bytecode_p = JERRY_CONTEXT (re_cache)[i];
const re_compiled_code_t *cached_bytecode_p = cache_p[i];
if (cached_bytecode_p != NULL
&& cached_bytecode_p->header.refs == 1)
if (cached_bytecode_p == NULL)
{
/* Only the cache has reference for the bytecode */
ecma_bytecode_deref ((ecma_compiled_code_t *) cached_bytecode_p);
JERRY_CONTEXT (re_cache)[i] = NULL;
break;
}
ecma_bytecode_deref ((ecma_compiled_code_t *) cached_bytecode_p);
cache_p[i] = NULL;
}
} /* re_cache_gc_run */
JERRY_CONTEXT (re_cache_idx) = 0;
} /* re_cache_gc */
/**
* Compilation of RegExp bytecode
*
* @return empty ecma value - if bytecode was compiled successfully
* error ecma value - otherwise
*
* Returned value must be freed with ecma_free_value
* @return pointer to bytecode if compilation was successful
* NULL - otherwise
*/
ecma_value_t
re_compile_bytecode (const re_compiled_code_t **out_bytecode_p, /**< [out] pointer to bytecode */
ecma_string_t *pattern_str_p, /**< pattern */
re_compiled_code_t *
re_compile_bytecode (ecma_string_t *pattern_str_p, /**< pattern */
uint16_t flags) /**< flags */
{
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
uint8_t cache_idx = re_find_bytecode_in_cache (pattern_str_p, flags);
re_compiled_code_t *cached_bytecode_p = re_cache_lookup (pattern_str_p, flags);
if (cache_idx < RE_CACHE_SIZE)
if (cached_bytecode_p != NULL)
{
*out_bytecode_p = JERRY_CONTEXT (re_cache)[cache_idx];
if (*out_bytecode_p != NULL)
{
ecma_bytecode_ref ((ecma_compiled_code_t *) *out_bytecode_p);
return ret_value;
}
ecma_bytecode_ref ((ecma_compiled_code_t *) cached_bytecode_p);
return cached_bytecode_p;
}
/* not in the RegExp cache, so compile it */
re_compiler_ctx_t re_ctx;
re_ctx.flags = flags;
re_ctx.highest_backref = 0;
re_ctx.captures_count = 1;
re_ctx.non_captures_count = 0;
re_bytecode_ctx_t bc_ctx;
re_ctx.bytecode_ctx_p = &bc_ctx;
re_initialize_regexp_bytecode (&bc_ctx);
re_initialize_regexp_bytecode (&re_ctx);
ECMA_STRING_TO_UTF8_STRING (pattern_str_p, pattern_start_p, pattern_start_size);
re_parser_ctx_t parser_ctx;
parser_ctx.input_start_p = pattern_start_p;
parser_ctx.input_curr_p = (lit_utf8_byte_t *) pattern_start_p;
parser_ctx.input_end_p = pattern_start_p + pattern_start_size;
parser_ctx.groups_count = -1;
re_ctx.parser_ctx_p = &parser_ctx;
re_ctx.input_start_p = pattern_start_p;
re_ctx.input_curr_p = (lit_utf8_byte_t *) pattern_start_p;
re_ctx.input_end_p = pattern_start_p + pattern_start_size;
re_ctx.groups_count = -1;
/* Parse RegExp pattern */
re_ctx.captures_count = 1;
re_append_opcode (&bc_ctx, RE_OP_SAVE_AT_START);
ecma_value_t result = re_parse_alternative (&re_ctx, true);
ECMA_FINALIZE_UTF8_STRING (pattern_start_p, pattern_start_size);
if (ECMA_IS_VALUE_ERROR (result))
{
ret_value = result;
}
/* Check for invalid backreference */
else if (re_ctx.highest_backref >= re_ctx.captures_count)
{
ret_value = ecma_raise_syntax_error ("Invalid backreference.\n");
}
else
{
re_append_opcode (&bc_ctx, RE_OP_SAVE_AND_MATCH);
re_append_opcode (&bc_ctx, RE_OP_EOF);
/* Initialize bytecode header */
re_compiled_code_t *re_compiled_code_p = (re_compiled_code_t *) bc_ctx.block_start_p;
re_compiled_code_p->header.refs = 1;
re_compiled_code_p->header.status_flags = re_ctx.flags;
ecma_ref_ecma_string (pattern_str_p);
re_compiled_code_p->source = ecma_make_string_value (pattern_str_p);
re_compiled_code_p->captures_count = re_ctx.captures_count;
re_compiled_code_p->non_captures_count = re_ctx.non_captures_count;
}
size_t byte_code_size = (size_t) (bc_ctx.block_end_p - bc_ctx.block_start_p);
if (!ecma_is_value_empty (ret_value))
{
/* Compilation failed, free bytecode. */
JERRY_TRACE_MSG ("RegExp compilation failed!\n");
jmem_heap_free_block (bc_ctx.block_start_p, byte_code_size);
*out_bytecode_p = NULL;
jmem_heap_free_block (re_ctx.bytecode_start_p, re_ctx.bytecode_size);
return NULL;
}
else
{
/* Align bytecode size to JMEM_ALIGNMENT so that it can be stored in the bytecode header. */
const uint32_t final_size = JERRY_ALIGNUP (re_ctx.bytecode_size, JMEM_ALIGNMENT);
re_compiled_code_t *re_compiled_code_p = (re_compiled_code_t *) jmem_heap_realloc_block (re_ctx.bytecode_start_p,
re_ctx.bytecode_size,
final_size);
/* Bytecoded will be inserted into the cache and returned to the caller, so refcount is implicitly set to 2. */
re_compiled_code_p->header.refs = 2;
re_compiled_code_p->header.size = (uint16_t) (final_size >> JMEM_ALIGNMENT_LOG);
re_compiled_code_p->header.status_flags = re_ctx.flags;
ecma_ref_ecma_string (pattern_str_p);
re_compiled_code_p->source = ecma_make_string_value (pattern_str_p);
re_compiled_code_p->captures_count = re_ctx.captures_count;
re_compiled_code_p->non_captures_count = re_ctx.non_captures_count;
#if ENABLED (JERRY_REGEXP_DUMP_BYTE_CODE)
if (JERRY_CONTEXT (jerry_init_flags) & ECMA_INIT_SHOW_REGEXP_OPCODES)
{
re_dump_bytecode (&bc_ctx);
}
if (JERRY_CONTEXT (jerry_init_flags) & ECMA_INIT_SHOW_REGEXP_OPCODES)
{
re_dump_bytecode (&re_ctx);
}
#endif /* ENABLED (JERRY_REGEXP_DUMP_BYTE_CODE) */
*out_bytecode_p = (re_compiled_code_t *) bc_ctx.block_start_p;
((re_compiled_code_t *) bc_ctx.block_start_p)->header.size = (uint16_t) (byte_code_size >> JMEM_ALIGNMENT_LOG);
uint8_t cache_idx = JERRY_CONTEXT (re_cache_idx);
if (cache_idx == RE_CACHE_SIZE)
{
if (JERRY_CONTEXT (re_cache_idx) == RE_CACHE_SIZE)
{
JERRY_CONTEXT (re_cache_idx) = 0;
}
JERRY_TRACE_MSG ("RegExp cache is full! Remove the element on idx: %d\n", JERRY_CONTEXT (re_cache_idx));
cache_idx = JERRY_CONTEXT (re_cache_idx)++;
/* The garbage collector might run during the byte code
* allocations above and it may free this entry. */
if (JERRY_CONTEXT (re_cache)[cache_idx] != NULL)
{
ecma_bytecode_deref ((ecma_compiled_code_t *) JERRY_CONTEXT (re_cache)[cache_idx]);
}
}
JERRY_TRACE_MSG ("Insert bytecode into RegExp cache (idx: %d).\n", cache_idx);
ecma_bytecode_ref ((ecma_compiled_code_t *) *out_bytecode_p);
JERRY_CONTEXT (re_cache)[cache_idx] = *out_bytecode_p;
if (JERRY_CONTEXT (re_cache)[cache_idx] != NULL)
{
ecma_bytecode_deref ((ecma_compiled_code_t *) JERRY_CONTEXT (re_cache)[cache_idx]);
}
return ret_value;
JERRY_CONTEXT (re_cache)[cache_idx] = re_compiled_code_p;
JERRY_CONTEXT (re_cache_idx) = (uint8_t) (cache_idx + 1) % RE_CACHE_SIZE;
return re_compiled_code_p;
} /* re_compile_bytecode */
/**
jerry-core/parser/regexp/re-compiler.h
+3 -18
View File
@@ -20,7 +20,6 @@
#include "ecma-globals.h"
#include "re-bytecode.h"
#include "re-parser.h"
/** \addtogroup parser Parser
* @{
@@ -32,24 +31,10 @@
* @{
*/
/**
* Context of RegExp compiler
*/
typedef struct
{
uint16_t flags; /**< RegExp flags */
uint32_t captures_count; /**< number of capture groups */
uint32_t non_captures_count; /**< number of non-capture groups */
uint32_t highest_backref; /**< highest backreference */
re_bytecode_ctx_t *bytecode_ctx_p; /**< pointer of RegExp bytecode context */
re_token_t current_token; /**< current token */
re_parser_ctx_t *parser_ctx_p; /**< pointer of RegExp parser context */
} re_compiler_ctx_t;
re_compiled_code_t *
re_compile_bytecode (ecma_string_t *pattern_str_p, uint16_t flags);
ecma_value_t
re_compile_bytecode (const re_compiled_code_t **out_bytecode_p, ecma_string_t *pattern_str_p, uint16_t flags);
void re_cache_gc_run (void);
void re_cache_gc (void);
/**
* @}
jerry-core/parser/regexp/re-parser.c
+1137 -456
View File
File diff suppressed because it is too large Load Diff
jerry-core/parser/regexp/re-parser.h
+8 -62
View File
@@ -18,45 +18,18 @@
#if ENABLED (JERRY_BUILTIN_REGEXP)
#include "re-compiler-context.h"
/** \addtogroup parser Parser
* @{
*
* \addtogroup regexparser Regular expression
* @{
*
* \addtogroup regexparser_bytecode Bytecode
* \addtogroup regexparser_parser Parser
* @{
*/
/**
* RegExp token type definitions
*/
typedef enum
{
RE_TOK_EOF, /**< EOF */
RE_TOK_BACKREFERENCE, /**< "\[0..9]" */
RE_TOK_CHAR, /**< any character */
RE_TOK_ALTERNATIVE, /**< "|" */
RE_TOK_ASSERT_START, /**< "^" */
RE_TOK_ASSERT_END, /**< "$" */
RE_TOK_PERIOD, /**< "." */
RE_TOK_START_CAPTURE_GROUP, /**< "(" */
RE_TOK_START_NON_CAPTURE_GROUP, /**< "(?:" */
RE_TOK_END_GROUP, /**< ")" */
RE_TOK_ASSERT_START_POS_LOOKAHEAD, /**< "(?=" */
RE_TOK_ASSERT_START_NEG_LOOKAHEAD, /**< "(?!" */
RE_TOK_ASSERT_WORD_BOUNDARY, /**< "\b" */
RE_TOK_ASSERT_NOT_WORD_BOUNDARY, /**< "\B" */
RE_TOK_DIGIT, /**< "\d" */
RE_TOK_NOT_DIGIT, /**< "\D" */
RE_TOK_WHITE, /**< "\s" */
RE_TOK_NOT_WHITE, /**< "\S" */
RE_TOK_WORD_CHAR, /**< "\w" */
RE_TOK_NOT_WORD_CHAR, /**< "\W" */
RE_TOK_START_CHAR_CLASS, /**< "[ ]" */
RE_TOK_START_INV_CHAR_CLASS, /**< "[^ ]" */
} re_token_type_t;
/**
* @}
*
@@ -65,43 +38,16 @@ typedef enum
*/
/**
* RegExp constant of infinite
* Value used for infinite quantifier.
*/
#define RE_ITERATOR_INFINITE ((uint32_t) - 1)
#define RE_INFINITY UINT32_MAX
/**
* Maximum number of decimal escape digits
* Maximum decimal value of an octal escape
*/
#define RE_MAX_RE_DECESC_DIGITS 9
#define RE_MAX_OCTAL_VALUE 0xff
/**
* RegExp token type
*/
typedef struct
{
re_token_type_t type; /**< type of the token */
uint32_t value; /**< value of the token */
uint32_t qmin; /**< minimum number of token iterations */
uint32_t qmax; /**< maximum number of token iterations */
bool greedy; /**< type of iteration */
} re_token_t;
/**
* RegExp parser context
*/
typedef struct
{
const lit_utf8_byte_t *input_start_p; /**< start of input pattern */
const lit_utf8_byte_t *input_curr_p; /**< current position in input pattern */
const lit_utf8_byte_t *input_end_p; /**< end of input pattern */
int groups_count; /**< number of groups */
uint32_t classes_count; /**< number of character classes */
} re_parser_ctx_t;
bool re_hex_lookup (re_parser_ctx_t *parser_ctx_p, uint32_t lookup);
uint32_t re_parse_octal (re_parser_ctx_t *parser_ctx_p);
ecma_value_t re_parse_iterator (re_parser_ctx_t *parser_ctx_p, re_token_t *re_token_p);
ecma_value_t re_parse_next_token (re_parser_ctx_t *parser_ctx_p, re_token_t *out_token_p);
ecma_value_t re_parse_alternative (re_compiler_ctx_t *re_ctx_p, bool expect_eof);
/**
* @}
jerry-core/parser/regexp/re-token.h
+72
View File
@@ -0,0 +1,72 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef RE_TOKEN_H
#define RE_TOKEN_H
#if ENABLED (JERRY_BUILTIN_REGEXP)
/** \addtogroup parser Parser
* @{
*
* \addtogroup regexparser Regular expression
* @{
*
* \addtogroup regexparser_parser Parser
* @{
*/
/**
* RegExp token type definitions
*/
typedef enum
{
RE_TOK_EOF, /**< EOF */
RE_TOK_BACKREFERENCE, /**< "\[0..9]" */
RE_TOK_ALTERNATIVE, /**< "|" */
RE_TOK_ASSERT_START, /**< "^" */
RE_TOK_ASSERT_END, /**< "$" */
RE_TOK_PERIOD, /**< "." */
RE_TOK_START_CAPTURE_GROUP, /**< "(" */
RE_TOK_START_NON_CAPTURE_GROUP, /**< "(?:" */
RE_TOK_END_GROUP, /**< ")" */
RE_TOK_ASSERT_LOOKAHEAD, /**< "(?=" */
RE_TOK_ASSERT_WORD_BOUNDARY, /**< "\b" */
RE_TOK_ASSERT_NOT_WORD_BOUNDARY, /**< "\B" */
RE_TOK_CLASS_ESCAPE, /**< "\d \D \w \W \s \S" */
RE_TOK_CHAR_CLASS, /**< "[ ]" */
RE_TOK_CHAR, /**< any character */
} re_token_type_t;
/**
* RegExp token
*/
typedef struct
{
uint32_t value; /**< value of the token */
uint32_t qmin; /**< minimum number of token iterations */
uint32_t qmax; /**< maximum number of token iterations */
re_token_type_t type; /**< type of the token */
bool greedy; /**< type of iteration */
} re_token_t;
/**
* @}
* @}
* @}
*/
#endif /* ENABLED (JERRY_BUILTIN_REGEXP) */
#endif /* !RE_TOKEN_H */