/**
* Check if two literals are equal
* Compare types of literals before performing detailed comparison.
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_type (literal_t lit1, /**< first literal */
literal_t lit2) /**< second literal */
{
if (lit1->get_type () != lit2->get_type ())
{
return false;
}
return lit_literal_equal (lit1, lit2);
} /* lit_literal_equal_type */
/**
* Check if literal equals to zero-terminated string.
* Check that literal is a string literal before performing detailed comparison.
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_type_zt (literal_t lit, /**< literal to compare */
const ecma_char_t *str) /**< zero-terminated string */
{
if (lit->get_type () != LIT_STR_T
&& lit->get_type () != LIT_MAGIC_STR_T
&& lit->get_type () != LIT_MAGIC_STR_EX_T)
{
return false;
}
return lit_literal_equal_zt (lit, str);
} /* lit_literal_equal_type_zt */
/**
* Check if literal equals to utf-8 string.
* Check that literal is a string literal before performing detailed comparison.
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_type_utf8 (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)
{
return false;
}
return lit_literal_equal_utf8 (lit, str_p, str_size);
} /* lit_literal_equal_type_utf8 */
/**
* Check if two literals are equal
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal (literal_t lit1, /**< first literal */
literal_t lit2) /**< second literal */
{
switch (lit2->get_type ())
{
case lit_literal_storage_t::LIT_STR:
{
return lit_literal_equal_charset_rec (lit1, static_cast<lit_charset_record_t *>(lit2));
}
case lit_literal_storage_t::LIT_MAGIC_STR:
{
lit_magic_string_id_t magic_str_id = lit_magic_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:
{
lit_magic_string_ex_id_t magic_str_ex_id = lit_magic_record_ex_get_magic_str_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:
{
return lit_literal_equal_num (lit1, static_cast<lit_number_record_t *>(lit2)->get_number ());
}
default:
{
JERRY_UNREACHABLE ();
}
}
} /* lit_literal_equal */
/**
* Check if literal equals to zero-terminated string
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_zt (literal_t lit, /**< literal to compare */
const ecma_char_t *str) /**< zero-terminated string to compare */
{
switch (lit->get_type ())
{
case LIT_STR_T:
{
return static_cast<lit_charset_record_t *>(lit)->equal_zt (str);
}
case LIT_MAGIC_STR_T:
{
ecma_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
return ecma_compare_zt_strings (str, ecma_get_magic_string_zt (magic_id));
}
case LIT_MAGIC_STR_EX_T:
{
ecma_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
return ecma_compare_zt_strings (str, ecma_get_magic_string_ex_zt (magic_id));
}
case LIT_NUMBER_T:
{
ecma_char_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
ecma_number_to_zt_string (static_cast<lit_number_record_t *>(lit)->get_number (),
buff,
ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER);
return ecma_compare_zt_strings (str, buff);
}
default:
{
JERRY_UNREACHABLE ();
}
}
} /* lit_literal_equal_zt */
/**
* Check if literal equals to charset record
*
* @return true if equal
* false otherwise
*/
static bool
lit_literal_equal_charset_rec (literal_t lit, /**< literal to compare */
lit_charset_record_t *record) /**< charset record to compare */
{
switch (lit->get_type ())
{
case LIT_STR_T:
{
return static_cast<lit_charset_record_t *>(lit)->equal (record);
}
case LIT_MAGIC_STR_T:
{
return record->equal_zt (ecma_get_magic_string_zt (lit_magic_record_get_magic_str_id (lit)));
}
case LIT_MAGIC_STR_EX_T:
{
return record->equal_zt (ecma_get_magic_string_ex_zt (lit_magic_record_ex_get_magic_str_id (lit)));
}
case LIT_NUMBER_T:
{
ecma_char_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
ecma_number_to_zt_string (static_cast<lit_number_record_t *>(lit)->get_number (),
buff,
ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER);
return record->equal_zt (buff);
}
default:
{
JERRY_UNREACHABLE ();
}
}
} /* lit_literal_equal_charset_rec */
/**
* Check if literal contains the string equal to the passed number.
* Check that literal is a number literal before performing detailed comparison.
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_type_num (literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
if (lit->get_type () != lit_literal_storage_t::LIT_NUMBER)
{
return false;
}
return lit_literal_equal_num (lit, num);
} /* lit_literal_equal_type_num */
/**
* Check if literal equals to charset record
*
* @return true if is_equal
* false otherwise
*/
static bool
lit_literal_equal_charset_rec (literal_t lit, /**< literal to compare */
lit_charset_record_t *record) /**< charset record to compare */
{
switch (lit->get_type ())
{
case LIT_STR_T:
{
return static_cast<lit_charset_record_t *>(lit)->is_equal (record);
}
case LIT_MAGIC_STR_T:
{
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));
}
case LIT_MAGIC_STR_EX_T:
{
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));
return record->is_equal_utf8_string (buff, copied);
}
default:
{
JERRY_UNREACHABLE ();
}
}
} /* lit_literal_equal_charset_rec */
/**
* Check if literal equals to utf-8 string
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_utf8 (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 ())
{
case LIT_STR_T:
{
return static_cast<lit_charset_record_t *>(lit)->is_equal_utf8_string (str_p, str_size);
}
case LIT_MAGIC_STR_T:
{
lit_magic_string_id_t magic_id = lit_magic_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:
{
lit_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
return lit_compare_utf8_string_and_magic_string_ex (str_p, str_size, magic_id);
}
case LIT_NUMBER_T:
{
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));
return lit_compare_utf8_strings (str_p, str_size, num_buf, num_size);
}
default:
{
JERRY_UNREACHABLE ();
}
}
} /* lit_literal_equal_utf8 */
