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

Refactor literal-storage to not use C++ features

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Roland Takacs rtakacs.u-szeged@partner.samsung.com
This commit is contained in:
Roland Takacs
2015-12-24 17:24:46 +03:00
committed by Peter Gal
parent f932b7d48c
commit 21f561f8ef
36 changed files with 2603 additions and 3134 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/lit/lit-literal.cpp
+183 -158
View File
@@ -16,7 +16,10 @@
#include "lit-literal.h"
#include "ecma-helpers.h"
#include "lit-magic-strings.h"
#include "rcs-allocator.h"
#include "rcs-records.h"
#include "rcs-iterator.h"
#include "lit-literal-storage.h"
/**
* Initialize literal storage
@@ -24,8 +27,10 @@
void
lit_init ()
{
new (&lit_storage) lit_literal_storage_t ();
lit_storage.init ();
JERRY_ASSERT (rcs_get_node_data_space_size () % RCS_DYN_STORAGE_LENGTH_UNIT == 0);
rcs_lit_storage.init ();
lit_magic_strings_init ();
lit_magic_strings_ex_init ();
} /* lit_init */
@@ -36,8 +41,8 @@ lit_init ()
void
lit_finalize ()
{
lit_storage.cleanup ();
lit_storage.finalize ();
rcs_lit_storage.cleanup ();
rcs_lit_storage.free ();
} /* lit_finalize */
/**
@@ -46,7 +51,7 @@ lit_finalize ()
void
lit_dump_literals ()
{
lit_storage.dump ();
lit_dump_literals (&rcs_lit_storage);
} /* lit_dump_literals */
/**
@@ -55,44 +60,46 @@ lit_dump_literals ()
*
* @return pointer to created record
*/
literal_t
lit_literal_t
lit_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string to initialize the record,
* could be non-zero-terminated */
lit_utf8_size_t str_size) /**< length of the string */
{
JERRY_ASSERT (str_p || !str_size);
for (lit_magic_string_id_t msi = (lit_magic_string_id_t) 0;
msi < LIT_MAGIC_STRING__COUNT;
msi = (lit_magic_string_id_t) (msi + 1))
lit_magic_string_id_t m_str_id;
for (m_str_id = (lit_magic_string_id_t) 0;
m_str_id < LIT_MAGIC_STRING__COUNT;
m_str_id = (lit_magic_string_id_t) (m_str_id + 1))
{
if (lit_get_magic_string_size (msi) != str_size)
if (lit_get_magic_string_size (m_str_id) != str_size)
{
continue;
}
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_utf8 (msi), str_size))
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_utf8 (m_str_id), str_size))
{
return lit_storage.create_magic_record (msi);
return lit_create_magic_literal (&rcs_lit_storage, m_str_id);
}
}
for (lit_magic_string_ex_id_t msi = (lit_magic_string_ex_id_t) 0;
msi < lit_get_magic_string_ex_count ();
msi = (lit_magic_string_ex_id_t) (msi + 1))
lit_magic_string_ex_id_t m_str_ex_id;
for (m_str_ex_id = (lit_magic_string_ex_id_t) 0;
m_str_ex_id < lit_get_magic_string_ex_count ();
m_str_ex_id = (lit_magic_string_ex_id_t) (m_str_ex_id + 1))
{
if (lit_get_magic_string_ex_size (msi) != str_size)
if (lit_get_magic_string_ex_size (m_str_ex_id) != str_size)
{
continue;
}
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_ex_utf8 (msi), str_size))
if (!strncmp ((const char *) str_p, (const char *) lit_get_magic_string_ex_utf8 (m_str_ex_id), str_size))
{
return lit_storage.create_magic_record_ex (msi);
return lit_create_magic_literal_ex (&rcs_lit_storage, m_str_ex_id);
}
}
return lit_storage.create_charset_record (str_p, str_size);
return lit_create_charset_literal (&rcs_lit_storage, str_p, str_size);
} /* lit_create_literal_from_utf8_string */
/**
@@ -101,7 +108,7 @@ lit_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string t
*
* @return pointer to a literal or NULL if no corresponding literal exists
*/
literal_t
lit_literal_t
lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to search for */
lit_utf8_size_t str_size) /**< length of the string */
{
@@ -109,30 +116,34 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
lit_string_hash_t str_hash = lit_utf8_string_calc_hash (str_p, str_size);
for (literal_t lit = lit_storage.get_first (); lit != NULL; lit = lit_storage.get_next (lit))
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
{
rcs_record_t::type_t type = lit->get_type ();
rcs_record_type_t type = rcs_record_get_type (lit);
if (type == LIT_STR_T)
if (RCS_RECORD_TYPE_IS_CHARSET (type))
{
if (static_cast<lit_charset_record_t *>(lit)->get_hash () != str_hash)
if (rcs_record_get_hash (lit) != str_hash)
{
continue;
}
if (static_cast<lit_charset_record_t *>(lit)->get_length () != str_size)
if (rcs_record_get_length (lit) != str_size)
{
continue;
}
if (!static_cast<lit_charset_record_t *>(lit)->compare_utf8 (str_p, str_size))
if (rcs_record_is_equal_charset (&rcs_lit_storage, lit, str_p, str_size))
{
return lit;
}
}
else if (type == LIT_MAGIC_STR_T)
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
{
lit_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
lit_magic_string_id_t magic_id = rcs_record_get_magic_str_id (lit);
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_utf8 (magic_id);
if (lit_get_magic_string_size (magic_id) != str_size)
@@ -145,9 +156,9 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
return lit;
}
}
else if (type == LIT_MAGIC_STR_EX_T)
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
{
lit_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
lit_magic_string_ex_id_t magic_id = rcs_record_get_magic_str_ex_id (lit);
const lit_utf8_byte_t *magic_str_p = lit_get_magic_string_ex_utf8 (magic_id);
if (lit_get_magic_string_ex_size (magic_id) != str_size)
@@ -171,11 +182,11 @@ lit_find_literal_by_utf8_string (const lit_utf8_byte_t *str_p, /**< a string to
*
* @return pointer to existing or newly created record
*/
literal_t
lit_literal_t
lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**< string, could be non-zero-terminated */
lit_utf8_size_t str_size) /**< length of the string */
{
literal_t lit = lit_find_literal_by_utf8_string (str_p, str_size);
lit_literal_t lit = lit_find_literal_by_utf8_string (str_p, str_size);
if (lit == NULL)
{
@@ -191,10 +202,10 @@ lit_find_or_create_literal_from_utf8_string (const lit_utf8_byte_t *str_p, /**<
*
* @return pointer to a newly created record
*/
literal_t
lit_literal_t
lit_create_literal_from_num (ecma_number_t num) /**< number to initialize a new number literal */
{
return lit_storage.create_number_record (num);
return lit_create_number_literal (&rcs_lit_storage, num);
} /* lit_create_literal_from_num */
/**
@@ -202,10 +213,10 @@ lit_create_literal_from_num (ecma_number_t num) /**< number to initialize a new
*
* @return pointer to existing or a newly created record
*/
literal_t
lit_literal_t
lit_find_or_create_literal_from_num (ecma_number_t num) /**< number which a literal should contain */
{
literal_t lit = lit_find_literal_by_num (num);
lit_literal_t lit = lit_find_literal_by_num (num);
if (lit == NULL)
{
@@ -220,19 +231,22 @@ lit_find_or_create_literal_from_num (ecma_number_t num) /**< number which a lite
*
* @return pointer to existing or null
*/
literal_t
lit_literal_t
lit_find_literal_by_num (ecma_number_t num) /**< a number to search for */
{
for (literal_t lit = lit_storage.get_first (); lit != NULL; lit = lit_storage.get_next (lit))
lit_literal_t lit;
for (lit = rcs_record_get_first (&rcs_lit_storage);
lit != NULL;
lit = rcs_record_get_next (&rcs_lit_storage, lit))
{
rcs_record_t::type_t type = lit->get_type ();
rcs_record_type_t type = rcs_record_get_type (lit);
if (type != LIT_NUMBER_T)
if (!RCS_RECORD_TYPE_IS_NUMBER (type))
{
continue;
}
ecma_number_t lit_num = static_cast<lit_number_record_t *>(lit)->get_number ();
ecma_number_t lit_num = rcs_record_get_number (&rcs_lit_storage, lit);
if (lit_num == num)
{
@@ -250,39 +264,45 @@ lit_find_literal_by_num (ecma_number_t num) /**< a number to search for */
* false otherwise
*/
static bool
lit_literal_equal_charset_rec (literal_t lit, /**< literal to compare */
lit_charset_record_t *record) /**< charset record to compare */
lit_literal_equal_charset_rec (lit_literal_t lit, /**< literal to compare */
lit_literal_t record) /**< charset record to compare */
{
switch (lit->get_type ())
switch (rcs_record_get_type (lit))
{
case LIT_STR_T:
case RCS_RECORD_TYPE_CHARSET:
{
return static_cast<lit_charset_record_t *>(lit)->is_equal (record);
return rcs_record_is_equal (&rcs_lit_storage, lit, record);
}
case LIT_MAGIC_STR_T:
case RCS_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_string_id = lit_magic_record_get_magic_str_id (lit);
return record->is_equal_utf8_string (lit_get_magic_string_utf8 (magic_string_id),
lit_get_magic_string_size (magic_string_id));
lit_magic_string_id_t magic_string_id = rcs_record_get_magic_str_id (lit);
return rcs_record_is_equal_charset (&rcs_lit_storage,
record,
lit_get_magic_string_utf8 (magic_string_id),
lit_get_magic_string_size (magic_string_id));
}
case LIT_MAGIC_STR_EX_T:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_string_id = lit_magic_record_ex_get_magic_str_id (lit);
return record->is_equal_utf8_string (lit_get_magic_string_ex_utf8 (magic_string_id),
lit_get_magic_string_ex_size (magic_string_id));
}
case LIT_NUMBER_T:
{
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t copied = ecma_number_to_utf8_string (static_cast<lit_number_record_t *>(lit)->get_number (),
buff,
sizeof (buff));
lit_magic_string_ex_id_t magic_string_id = rcs_record_get_magic_str_ex_id (lit);
return record->is_equal_utf8_string (buff, copied);
return rcs_record_is_equal_charset (&rcs_lit_storage,
record,
lit_get_magic_string_ex_utf8 (magic_string_id),
lit_get_magic_string_ex_size (magic_string_id));
}
case RCS_RECORD_TYPE_NUMBER:
{
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit);
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t copied = ecma_number_to_utf8_string (num, buff, sizeof (buff));
return rcs_record_is_equal_charset (&rcs_lit_storage, record, buff, copied);
}
default:
{
JERRY_UNREACHABLE ();
return false;
}
}
} /* lit_literal_equal_charset_rec */
@@ -294,32 +314,32 @@ lit_literal_equal_charset_rec (literal_t lit, /**< literal to com
* false otherwise
*/
bool
lit_literal_equal_utf8 (literal_t lit, /**< literal to compare */
lit_literal_equal_utf8 (lit_literal_t lit, /**< literal to compare */
const lit_utf8_byte_t *str_p, /**< utf-8 string to compare */
lit_utf8_size_t str_size) /**< string size in bytes */
{
switch (lit->get_type ())
switch (rcs_record_get_type (lit))
{
case LIT_STR_T:
case RCS_RECORD_TYPE_CHARSET:
{
return static_cast<lit_charset_record_t *>(lit)->is_equal_utf8_string (str_p, str_size);
return rcs_record_is_equal_charset (&rcs_lit_storage, lit, str_p, str_size);
}
case LIT_MAGIC_STR_T:
case RCS_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
lit_magic_string_id_t magic_id = rcs_record_get_magic_str_id (lit);
return lit_compare_utf8_string_and_magic_string (str_p, str_size, magic_id);
}
case LIT_MAGIC_STR_EX_T:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
lit_magic_string_ex_id_t magic_id = rcs_record_get_magic_str_ex_id (lit);
return lit_compare_utf8_string_and_magic_string_ex (str_p, str_size, magic_id);
}
case LIT_NUMBER_T:
case RCS_RECORD_TYPE_NUMBER:
{
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit);
lit_utf8_byte_t num_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
lit_utf8_size_t num_size = ecma_number_to_utf8_string (static_cast<lit_number_record_t *>(lit)->get_number (),
num_buf,
sizeof (num_buf));
lit_utf8_size_t num_size = ecma_number_to_utf8_string (num, num_buf, sizeof (num_buf));
return lit_compare_utf8_strings (str_p, str_size, num_buf, num_size);
}
@@ -337,7 +357,7 @@ lit_literal_equal_utf8 (literal_t lit, /**< literal to compare */
* false otherwise
*/
bool
lit_literal_equal_num (literal_t lit, /**< literal to check */
lit_literal_equal_num (lit_literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
@@ -353,32 +373,35 @@ lit_literal_equal_num (literal_t lit, /**< literal to check */
* false otherwise
*/
bool
lit_literal_equal (literal_t lit1, /**< first literal */
literal_t lit2) /**< second literal */
lit_literal_equal (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
switch (lit2->get_type ())
switch (rcs_record_get_type (lit2))
{
case lit_literal_storage_t::LIT_STR:
case RCS_RECORD_TYPE_CHARSET:
{
return lit_literal_equal_charset_rec (lit1, static_cast<lit_charset_record_t *>(lit2));
return lit_literal_equal_charset_rec (lit1, lit2);
}
case lit_literal_storage_t::LIT_MAGIC_STR:
case RCS_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_str_id = lit_magic_record_get_magic_str_id (lit2);
lit_magic_string_id_t magic_str_id = rcs_record_get_magic_str_id (lit2);
return lit_literal_equal_utf8 (lit1,
lit_get_magic_string_utf8 (magic_str_id),
lit_get_magic_string_size (magic_str_id));
}
case lit_literal_storage_t::LIT_MAGIC_STR_EX:
case RCS_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_str_ex_id = lit_magic_record_ex_get_magic_str_id (lit2);
lit_magic_string_ex_id_t magic_str_ex_id = rcs_record_get_magic_str_ex_id (lit2);
return lit_literal_equal_utf8 (lit1,
lit_get_magic_string_ex_utf8 (magic_str_ex_id),
lit_get_magic_string_ex_size (magic_str_ex_id));
}
case lit_literal_storage_t::LIT_NUMBER:
case RCS_RECORD_TYPE_NUMBER:
{
return lit_literal_equal_num (lit1, static_cast<lit_number_record_t *>(lit2)->get_number ());
ecma_number_t num = rcs_record_get_number (&rcs_lit_storage, lit2);
return lit_literal_equal_num (lit1, num);
}
default:
{
@@ -395,13 +418,13 @@ lit_literal_equal (literal_t lit1, /**< first literal */
* false otherwise
*/
bool
lit_literal_equal_type_utf8 (literal_t lit, /**< literal to compare */
lit_literal_equal_type_utf8 (lit_literal_t lit, /**< literal to compare */
const lit_utf8_byte_t *str_p, /**< utf-8 string */
lit_utf8_size_t str_size) /**< string size */
{
if (lit->get_type () != LIT_STR_T
&& lit->get_type () != LIT_MAGIC_STR_T
&& lit->get_type () != LIT_MAGIC_STR_EX_T)
rcs_record_type_t type = rcs_record_get_type (lit);
if (RCS_RECORD_TYPE_IS_NUMBER (type) || RCS_RECORD_TYPE_IS_FREE (type))
{
return false;
}
@@ -417,7 +440,7 @@ lit_literal_equal_type_utf8 (literal_t lit, /**< literal to compare */
* false otherwise
*/
bool
lit_literal_equal_type_cstr (literal_t lit, /**< literal to compare */
lit_literal_equal_type_cstr (lit_literal_t lit, /**< literal to compare */
const char *c_str_p) /**< zero-terminated C-string */
{
return lit_literal_equal_type_utf8 (lit, (const lit_utf8_byte_t *) c_str_p, (lit_utf8_size_t) strlen (c_str_p));
@@ -431,10 +454,10 @@ lit_literal_equal_type_cstr (literal_t lit, /**< literal to compare */
* false otherwise
*/
bool
lit_literal_equal_type_num (literal_t lit, /**< literal to check */
lit_literal_equal_type_num (lit_literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
if (lit->get_type () != lit_literal_storage_t::LIT_NUMBER)
if (!RCS_RECORD_IS_NUMBER (lit))
{
return false;
}
@@ -450,10 +473,10 @@ lit_literal_equal_type_num (literal_t lit, /**< literal to check */
* false otherwise
*/
bool
lit_literal_equal_type (literal_t lit1, /**< first literal */
literal_t lit2) /**< second literal */
lit_literal_equal_type (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
if (lit1->get_type () != lit2->get_type ())
if (rcs_record_get_type (lit1) != rcs_record_get_type (lit2))
{
return false;
}
@@ -461,7 +484,6 @@ lit_literal_equal_type (literal_t lit1, /**< first literal */
return lit_literal_equal (lit1, lit2);
} /* lit_literal_equal_type */
/**
* Get the contents of the literal as a zero-terminated string.
* If literal is a magic string record, the corresponding string is not copied to the buffer,
@@ -470,39 +492,34 @@ lit_literal_equal_type (literal_t lit1, /**< first literal */
* @return pointer to the zero-terminated string.
*/
const lit_utf8_byte_t *
lit_literal_to_utf8_string (literal_t lit, /**< literal to be processed */
lit_literal_to_utf8_string (lit_literal_t lit, /**< literal to be processed */
lit_utf8_byte_t *buff_p, /**< buffer to use as a string storage */
size_t size) /**< size of the buffer */
{
JERRY_ASSERT (buff_p != NULL && size > 0);
rcs_record_t::type_t type = lit->get_type ();
rcs_record_type_t type = rcs_record_get_type (lit);
switch (type)
if (RCS_RECORD_TYPE_IS_CHARSET (type))
{
case LIT_STR_T:
{
lit_charset_record_t *ch_rec_p = static_cast<lit_charset_record_t *> (lit);
ch_rec_p->get_charset (buff_p, size);
return buff_p;
}
case LIT_MAGIC_STR_T:
{
return lit_get_magic_string_utf8 (lit_magic_record_get_magic_str_id (lit));
}
case LIT_MAGIC_STR_EX_T:
{
return lit_get_magic_string_ex_utf8 (lit_magic_record_ex_get_magic_str_id (lit));
}
case LIT_NUMBER_T:
{
ecma_number_to_utf8_string (static_cast<lit_number_record_t *> (lit)->get_number (), buff_p, (ssize_t)size);
return buff_p;
}
default: JERRY_UNREACHABLE ();
rcs_record_get_charset (&rcs_lit_storage, lit, buff_p, size);
return buff_p;
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
{
return lit_get_magic_string_utf8 (rcs_record_get_magic_str_id (lit));
}
else if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
{
return lit_get_magic_string_ex_utf8 (rcs_record_get_magic_str_ex_id (lit));
}
else
{
JERRY_ASSERT (RCS_RECORD_TYPE_IS_NUMBER (type));
JERRY_UNREACHABLE ();
ecma_number_t number = rcs_record_get_number (&rcs_lit_storage, lit);
ecma_number_to_utf8_string (number, buff_p, (ssize_t) size);
return buff_p;
}
} /* lit_literal_to_utf8_string */
/**
@@ -512,7 +529,7 @@ lit_literal_to_utf8_string (literal_t lit, /**< literal to be processed */
* @return pointer to the C string.
*/
const char *
lit_literal_to_str_internal_buf (literal_t lit) /**< literal */
lit_literal_to_str_internal_buf (lit_literal_t lit) /**< literal */
{
static lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER + 1];
memset (buff, 0, sizeof (buff));
@@ -528,11 +545,15 @@ lit_literal_to_str_internal_buf (literal_t lit) /**< literal */
* false otherwise
*/
static bool
lit_literal_exists (literal_t lit) /**< literal to check for existence */
lit_literal_exists (lit_literal_t lit) /**< literal to check for existence */
{
for (literal_t l = lit_storage.get_first (); l != NULL; l = lit_storage.get_next (l))
lit_literal_t current_lit;
for (current_lit = rcs_record_get_first (&rcs_lit_storage);
current_lit != NULL;
current_lit = rcs_record_get_next (&rcs_lit_storage, current_lit))
{
if (l == lit)
if (current_lit == lit)
{
return true;
}
@@ -546,39 +567,39 @@ lit_literal_exists (literal_t lit) /**< literal to check for existence */
*
* @return literal
*/
literal_t
lit_get_literal_by_cp (lit_cpointer_t lit_cp) /**< compressed pointer to literal */
lit_literal_t
lit_get_literal_by_cp (rcs_cpointer_t lit_cp) /**< compressed pointer to literal */
{
JERRY_ASSERT (lit_cp.packed_value != MEM_CP_NULL);
literal_t lit = lit_cpointer_t::decompress (lit_cp);
lit_literal_t lit = rcs_cpointer_decompress (lit_cp);
JERRY_ASSERT (lit_literal_exists (lit));
return lit;
} /* lit_get_literal_by_cp */
lit_string_hash_t
lit_charset_literal_get_hash (literal_t lit) /**< literal */
lit_charset_literal_get_hash (lit_literal_t lit) /**< literal */
{
return static_cast<lit_charset_record_t *> (lit)->get_hash ();
return rcs_record_get_hash (lit);
} /* lit_charset_literal_get_hash */
lit_magic_string_id_t
lit_magic_record_get_magic_str_id (literal_t lit) /**< literal */
lit_magic_literal_get_magic_str_id (lit_literal_t lit) /**< literal */
{
return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<lit_magic_string_id_t> ();
} /* lit_magic_record_get_magic_str_id */
return rcs_record_get_magic_str_id (lit);
} /* lit_magic_literal_get_magic_str_id */
lit_magic_string_ex_id_t
lit_magic_record_ex_get_magic_str_id (literal_t lit) /**< literal */
lit_magic_literal_ex_get_magic_str_id (lit_literal_t lit) /**< literal */
{
return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<lit_magic_string_ex_id_t> ();
} /* lit_magic_record_ex_get_magic_str_id */
return rcs_record_get_magic_str_ex_id (lit);
} /* lit_magic_literal_ex_get_magic_str_id */
lit_utf8_size_t
lit_charset_record_get_size (literal_t lit) /**< literal */
lit_charset_literal_get_size (lit_literal_t lit) /**< literal */
{
return static_cast<lit_charset_record_t *> (lit)->get_length ();
} /* lit_charset_record_get_size */
return rcs_record_get_length (lit);
} /* lit_charset_literal_get_size */
/**
* Get length of the literal
@@ -586,36 +607,40 @@ lit_charset_record_get_size (literal_t lit) /**< literal */
* @return code units count
*/
ecma_length_t
lit_charset_record_get_length (literal_t lit) /**< literal */
lit_charset_literal_get_length (lit_literal_t lit) /**< literal */
{
TODO ("Add special case for literals which doesn't contain long characters");
lit_charset_record_t *charset_record_p = static_cast<lit_charset_record_t *> (lit);
rcs_record_iterator_t lit_iter (&lit_storage, lit);
lit_iter.skip (lit_charset_record_t::header_size ());
rcs_iterator_t it_ctx = rcs_iterator_create (&rcs_lit_storage, lit);
rcs_iterator_skip (&it_ctx, RCS_CHARSET_HEADER_SIZE);
lit_utf8_size_t lit_utf8_str_size = charset_record_p->get_length ();
lit_utf8_size_t lit_utf8_str_size = rcs_record_get_length (lit);
ecma_length_t length = 0;
for (lit_utf8_size_t i = 0; i < lit_utf8_str_size;)
{
lit_utf8_byte_t byte = lit_iter.read <lit_utf8_byte_t> ();
lit_utf8_size_t bytes_to_skip = lit_get_unicode_char_size_by_utf8_first_byte (byte);
lit_iter.skip (bytes_to_skip);
i += bytes_to_skip;
lit_utf8_size_t i = 0;
while (i < lit_utf8_str_size)
{
lit_utf8_byte_t byte;
lit_utf8_size_t bytes_to_skip;
rcs_iterator_read (&it_ctx, &byte, sizeof (lit_utf8_byte_t));
bytes_to_skip = lit_get_unicode_char_size_by_utf8_first_byte (byte);
rcs_iterator_skip (&it_ctx, bytes_to_skip);
i += bytes_to_skip;
length += (bytes_to_skip > LIT_UTF8_MAX_BYTES_IN_CODE_UNIT) ? 2 : 1;
}
#ifndef JERRY_NDEBUG
lit_iter.skip (charset_record_p->get_alignment_bytes_count ());
JERRY_ASSERT (lit_iter.finished ());
rcs_iterator_skip (&it_ctx, rcs_record_get_alignment_bytes_count (lit));
JERRY_ASSERT (rcs_iterator_finished (&it_ctx));
#endif
return length;
} /* lit_charset_record_get_length */
} /* lit_charset_literal_get_length */
ecma_number_t
lit_charset_literal_get_number (literal_t lit) /**< literal */
lit_number_literal_get_number (lit_literal_t lit) /**< literal */
{
return static_cast<lit_number_record_t *> (lit)->get_number ();;
} /* lit_charset_literal_get_number */
return rcs_record_get_number (&rcs_lit_storage, lit);
} /* lit_number_literal_get_number */