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

Remove unused internal functions

Browse Source 
The internals have surprisingly large number of unused functions at
surprising places. This patch cleans them out to make maintenance
easier and to prevent dead code having effect on future decisions.

The patch intentionally does not try to clean up public API but
focuses on internal modules only that are/should not be reachable
from "outside".

However, unit tests do access private API, thus tests of literal
storage had to be adjusted.

JerryScript-DCO-1.0-Signed-off-by: Akos Kiss akiss@inf.u-szeged.hu
This commit is contained in:
Akos Kiss
2016-04-21 12:11:44 +02:00
parent a87aca4d84
commit 27682017e9
15 changed files with 31 additions and 919 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/lit/lit-literal.c
-258
View File
@@ -266,264 +266,6 @@ lit_find_literal_by_num (const ecma_number_t num) /**< a number to search for */
return NULL;
} /* lit_find_literal_by_num */
/**
* Check if literal equals to charset record
*
* @return true if is_equal
* false otherwise
*/
static bool
lit_literal_equal_charset_rec (lit_literal_t lit, /**< literal to compare */
lit_literal_t record) /**< charset record to compare */
{
switch (lit->type)
{
case LIT_RECORD_TYPE_CHARSET:
{
return lit_literal_equal_charset (lit,
lit_charset_literal_get_charset (record),
lit_charset_literal_get_size (record));
}
case LIT_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_string_id = lit_magic_literal_get_magic_str_id (lit);
return lit_literal_equal_charset (record,
lit_get_magic_string_utf8 (magic_string_id),
lit_get_magic_string_size (magic_string_id));
}
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_string_id = lit_magic_literal_get_magic_str_ex_id (lit);
return lit_literal_equal_charset (record,
lit_get_magic_string_ex_utf8 (magic_string_id),
lit_get_magic_string_ex_size (magic_string_id));
}
case LIT_RECORD_TYPE_NUMBER:
{
ecma_number_t num = lit_number_literal_get_number (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 lit_literal_equal_charset (record, buff, copied);
}
default:
{
JERRY_UNREACHABLE ();
return false;
}
}
} /* lit_literal_equal_charset_rec */
/**
* Check if literal equals to utf-8 string
*
* @return true if equal
* false otherwise
*/
bool
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->type)
{
case LIT_RECORD_TYPE_CHARSET:
{
if (lit_charset_literal_get_size (lit) != str_size)
{
return 0;
}
return !strncmp ((const char *) lit_charset_literal_get_charset (lit), (const char *) str_p, str_size);
}
case LIT_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_id = lit_magic_literal_get_magic_str_id (lit);
return lit_compare_utf8_string_and_magic_string (str_p, str_size, magic_id);
}
case LIT_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_id = lit_magic_literal_get_magic_str_ex_id (lit);
return lit_compare_utf8_string_and_magic_string_ex (str_p, str_size, magic_id);
}
case LIT_RECORD_TYPE_NUMBER:
{
ecma_number_t num = lit_number_literal_get_number (lit);
lit_utf8_byte_t num_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
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);
}
default:
{
JERRY_UNREACHABLE ();
}
}
} /* lit_literal_equal_utf8 */
/**
* Check if literal contains the string equal to the passed number
*
* @return true if equal
* false otherwise
*/
bool
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];
lit_utf8_size_t copied = ecma_number_to_utf8_string (num, buff, sizeof (buff));
return lit_literal_equal_utf8 (lit, buff, copied);
} /* lit_literal_equal_num */
/**
* Check if literal contains the string equal to the buffer
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal_charset (lit_literal_t lit, /**< literal to checks */
const lit_utf8_byte_t *buff, /**< string buffer */
lit_utf8_size_t size) /**< buffer size */
{
JERRY_ASSERT (lit->type == LIT_RECORD_TYPE_CHARSET);
if (size != lit_charset_literal_get_size (lit))
{
return false;
}
return !strncmp ((const char *) buff, (const char *) lit_charset_literal_get_charset (lit), size);
} /* lit_literal_equal_charset */
/**
* Check if two literals are equal
*
* @return true if equal
* false otherwise
*/
bool
lit_literal_equal (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
switch (lit2->type)
{
case LIT_RECORD_TYPE_CHARSET:
{
return lit_literal_equal_charset_rec (lit1, lit2);
}
case LIT_RECORD_TYPE_MAGIC_STR:
{
lit_magic_string_id_t magic_str_id = lit_magic_literal_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_RECORD_TYPE_MAGIC_STR_EX:
{
lit_magic_string_ex_id_t magic_str_ex_id = lit_magic_literal_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_RECORD_TYPE_NUMBER:
{
ecma_number_t num = lit_number_literal_get_number (lit2);
return lit_literal_equal_num (lit1, num);
}
default:
{
JERRY_UNREACHABLE ();
break;
}
}
JERRY_UNREACHABLE ();
return 0;
} /* lit_literal_equal */
/**
* 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 (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 */
{
const lit_record_type_t type = (const lit_record_type_t) lit->type;
if (type == LIT_RECORD_TYPE_NUMBER || type == LIT_RECORD_TYPE_FREE)
{
return false;
}
return lit_literal_equal_utf8 (lit, str_p, str_size);
} /* lit_literal_equal_type_utf8 */
/**
* Check if literal equals to C string.
* Check that literal is a string literal before performing detailed comparison.
*
* @return true if equal
* false otherwise
*/
bool
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));
} /* lit_literal_equal_type_cstr */
/**
* 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 (lit_literal_t lit, /**< literal to check */
ecma_number_t num) /**< number to compare with */
{
if (lit->type != LIT_RECORD_TYPE_NUMBER)
{
return false;
}
return lit_literal_equal_num (lit, num);
} /* lit_literal_equal_type_num */
/**
* 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 (lit_literal_t lit1, /**< first literal */
lit_literal_t lit2) /**< second literal */
{
if (lit1->type != lit2->type)
{
return false;
}
return lit_literal_equal (lit1, lit2);
} /* lit_literal_equal_type */
/**
* Check if literal really exists in the storage
*
jerry-core/lit/lit-literal.h
-11
View File
@@ -38,16 +38,6 @@ extern lit_literal_t lit_create_literal_from_num (ecma_number_t);
extern lit_literal_t lit_find_literal_by_num (ecma_number_t);
extern lit_literal_t lit_find_or_create_literal_from_num (ecma_number_t);
extern bool lit_literal_equal_utf8 (lit_literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
extern bool lit_literal_equal_num (lit_literal_t, ecma_number_t);
extern bool lit_literal_equal (lit_literal_t, lit_literal_t);
extern bool lit_literal_equal_type_utf8 (lit_literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
extern bool lit_literal_equal_type_cstr (lit_literal_t, const char *);
extern bool lit_literal_equal_type_num (lit_literal_t, ecma_number_t);
extern bool lit_literal_equal_type (lit_literal_t, lit_literal_t);
extern bool lit_literal_equal_charset (lit_literal_t, const lit_utf8_byte_t *, lit_utf8_size_t);
extern lit_literal_t lit_get_literal_by_cp (lit_cpointer_t);
extern ecma_number_t lit_number_literal_get_number (lit_literal_t);
@@ -55,7 +45,6 @@ extern lit_string_hash_t lit_charset_literal_get_hash (lit_literal_t);
extern lit_utf8_size_t lit_charset_literal_get_size (lit_literal_t);
extern ecma_length_t lit_charset_literal_get_length (lit_literal_t);
extern lit_utf8_byte_t *lit_charset_literal_get_charset (lit_literal_t);
extern lit_literal_t lit_literal_get_next (lit_literal_t);
extern lit_magic_string_id_t lit_magic_literal_get_magic_str_id (lit_literal_t);
extern lit_magic_string_ex_id_t lit_magic_literal_get_magic_str_ex_id (lit_literal_t);
jerry-core/lit/lit-strings.c
-221
View File
@@ -18,41 +18,6 @@
#include "jrt-libc-includes.h"
JERRY_STATIC_ASSERT (sizeof (lit_utf8_iterator_pos_t) == sizeof (lit_utf8_size_t),
size_of_lit_utf8_iterator_pos_t_must_be_equal_to_size_of_lit_utf8_size_t);
/**
* Compare two iterator positions
*
* @return +1, if pos1 > pos2
* 0, if pos1 == pos2
* -1, otherwise
*/
int32_t
lit_utf8_iterator_pos_cmp (lit_utf8_iterator_pos_t pos1, /**< first position of the iterator */
lit_utf8_iterator_pos_t pos2) /**< second position of the iterator */
{
if (pos1.offset < pos2.offset)
{
return -1;
}
else if (pos1.offset > pos2.offset)
{
return 1;
}
if (pos1.is_non_bmp_middle == false && pos2.is_non_bmp_middle == true)
{
return -1;
}
else if (pos1.is_non_bmp_middle == true && pos2.is_non_bmp_middle == false)
{
return 1;
}
return 0;
} /* lit_utf8_iterator_pos_cmp */
/**
* Validate utf-8 string
*
@@ -246,69 +211,6 @@ lit_is_code_point_utf16_high_surrogate (lit_code_point_t code_point) /**< code p
return LIT_UTF16_HIGH_SURROGATE_MIN <= code_point && code_point <= LIT_UTF16_HIGH_SURROGATE_MAX;
} /* lit_is_code_point_utf16_high_surrogate */
/**
* Initialize iterator for traversing utf-8 string as a string of code units
*
* @return iterator
*/
lit_utf8_iterator_t
lit_utf8_iterator_create (const lit_utf8_byte_t *utf8_buf_p, /**< utf-8 string */
lit_utf8_size_t buf_size) /**< string size */
{
JERRY_ASSERT (utf8_buf_p || !buf_size);
JERRY_ASSERT (lit_is_utf8_string_valid (utf8_buf_p, buf_size));
lit_utf8_iterator_t buf_iter =
{
utf8_buf_p,
buf_size,
LIT_ITERATOR_POS_ZERO
};
return buf_iter;
} /* lit_utf8_iterator_create */
/**
* Reset iterator to point to the beginning of a string
*/
void
lit_utf8_iterator_seek_bos (lit_utf8_iterator_t *iter_p) /**< iterator to reset */
{
iter_p->buf_pos.offset = 0;
iter_p->buf_pos.is_non_bmp_middle = false;
} /* lit_utf8_iterator_seek_bos */
/**
* Get iterator's position
*
* @return current position of the iterator
*/
lit_utf8_iterator_pos_t
lit_utf8_iterator_get_pos (const lit_utf8_iterator_t *iter_p) /**< iterator */
{
return iter_p->buf_pos;
} /* lit_utf8_iterator_get_pos */
/**
* Restore previously saved position of the iterator
*/
void
lit_utf8_iterator_seek (lit_utf8_iterator_t *iter_p, /**< utf-8 string iterator */
lit_utf8_iterator_pos_t iter_pos) /**< position to restore */
{
JERRY_ASSERT (iter_pos.offset <= iter_p->buf_size);
#ifndef JERRY_NDEBUG
if (iter_pos.offset < iter_p->buf_size)
{
lit_utf8_byte_t byte = *(iter_p->buf_p + iter_pos.offset);
JERRY_ASSERT ((byte & LIT_UTF8_EXTRA_BYTE_MASK) != LIT_UTF8_EXTRA_BYTE_MARKER);
JERRY_ASSERT (!iter_pos.is_non_bmp_middle || ((byte & LIT_UTF8_4_BYTE_MASK) == LIT_UTF8_4_BYTE_MARKER));
}
#endif /* !JERRY_NDEBUG */
iter_p->buf_pos = iter_pos;
} /* lit_utf8_iterator_seek */
/**
* Represents code point (>0xFFFF) as surrogate pair and returns its lower part
*
@@ -342,112 +244,6 @@ convert_code_point_to_high_surrogate (lit_code_point_t code_point) /**< code poi
return (LIT_UTF16_HIGH_SURROGATE_MARKER | code_unit_bits);
} /* convert_code_point_to_high_surrogate */
/**
* Get next code unit form the iterated string
*
* @return next code unit
*/
ecma_char_t
lit_utf8_iterator_peek_next (const lit_utf8_iterator_t *iter_p) /**< [in] utf-8 string iterator */
{
JERRY_ASSERT (!lit_utf8_iterator_is_eos (iter_p));
lit_code_point_t code_point;
lit_read_code_point_from_utf8 (iter_p->buf_p + iter_p->buf_pos.offset,
iter_p->buf_size - iter_p->buf_pos.offset,
&code_point);
if (code_point <= LIT_UTF16_CODE_UNIT_MAX)
{
JERRY_ASSERT (!iter_p->buf_pos.is_non_bmp_middle);
return (ecma_char_t) code_point;
}
else
{
if (iter_p->buf_pos.is_non_bmp_middle)
{
return convert_code_point_to_low_surrogate (code_point);
}
else
{
return convert_code_point_to_high_surrogate (code_point);
}
}
} /* lit_utf8_iterator_peek_next */
/**
* Increment iterator to point to next code unit
*/
void
lit_utf8_iterator_incr (lit_utf8_iterator_t *iter_p) /**< [in,out] utf-8 string iterator */
{
lit_utf8_iterator_read_next (iter_p);
} /* lit_utf8_iterator_incr */
/**
* Skip specified number of code units
*/
void
lit_utf8_iterator_advance (lit_utf8_iterator_t *iter_p, /**< [in,out] iterator */
ecma_length_t chars_count) /**< number of code units to skip */
{
while (chars_count--)
{
lit_utf8_iterator_incr (iter_p);
}
} /* lit_utf8_iterator_advance */
/**
* Get next code unit form the iterated string and increment iterator to point to next code unit
*
* @return next code unit
*/
ecma_char_t
lit_utf8_iterator_read_next (lit_utf8_iterator_t *iter_p) /**< [in,out] utf-8 string iterator */
{
JERRY_ASSERT (!lit_utf8_iterator_is_eos (iter_p));
lit_code_point_t code_point;
lit_utf8_size_t utf8_char_size = lit_read_code_point_from_utf8 (iter_p->buf_p + iter_p->buf_pos.offset,
iter_p->buf_size - iter_p->buf_pos.offset,
&code_point);
if (code_point <= LIT_UTF16_CODE_UNIT_MAX)
{
JERRY_ASSERT (!iter_p->buf_pos.is_non_bmp_middle);
iter_p->buf_pos.offset = (iter_p->buf_pos.offset + utf8_char_size) & LIT_ITERATOR_OFFSET_MASK;
return (ecma_char_t) code_point;
}
else
{
if (iter_p->buf_pos.is_non_bmp_middle)
{
iter_p->buf_pos.offset = (iter_p->buf_pos.offset + utf8_char_size) & LIT_ITERATOR_OFFSET_MASK;
iter_p->buf_pos.is_non_bmp_middle = false;
return convert_code_point_to_low_surrogate (code_point);
}
else
{
iter_p->buf_pos.is_non_bmp_middle = true;
return convert_code_point_to_high_surrogate (code_point);
}
}
} /* lit_utf8_iterator_read_next */
/**
* Checks iterator reached end of the string
*
* @return true - iterator is at the end of string
* false - otherwise
*/
bool
lit_utf8_iterator_is_eos (const lit_utf8_iterator_t *iter_p) /**< utf-8 string iterator */
{
JERRY_ASSERT (iter_p->buf_pos.offset <= iter_p->buf_size);
return (iter_p->buf_pos.offset == iter_p->buf_size);
} /* lit_utf8_iterator_is_eos */
/**
* Calculate size of a zero-terminated utf-8 string
*
@@ -1001,20 +797,3 @@ bool lit_compare_utf8_strings_relational (const lit_utf8_byte_t *string1_p, /**<
return (string1_pos >= string1_end_p && string2_pos < string2_end_p);
} /* lit_compare_utf8_strings_relational */
/**
* Print code unit to standard output
*/
void
lit_put_ecma_char (ecma_char_t ecma_char) /**< code unit */
{
if (ecma_char <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)
{
jerry_port_putchar (ecma_char);
}
else
{
/* TODO: Support unicode characters printing. */
jerry_port_putchar ('_');
}
} /* lit_put_ecma_char */
jerry-core/lit/lit-strings.h
-57
View File
@@ -80,48 +80,11 @@
*/
#define LIT_UTF8_CESU8_SURROGATE_SIZE_DIF (2 * LIT_UTF8_MAX_BYTES_IN_CODE_UNIT - LIT_UTF8_MAX_BYTES_IN_CODE_POINT)
/**
* Width of the offset field in lit_utf8_iterator_pos_t structure
*/
#define LIT_ITERATOR_OFFSET_WIDTH (31)
/**
* Iterator's offset field mask
*/
#define LIT_ITERATOR_OFFSET_MASK ((1ull << LIT_ITERATOR_OFFSET_WIDTH) - 1)
/**
* Byte values >= LIT_UTF8_FIRST_BYTE_MAX are not allowed in internal strings
*/
#define LIT_UTF8_FIRST_BYTE_MAX LIT_UTF8_5_BYTE_MARKER
/**
* Represents position of the iterator
*/
typedef struct
{
__extension__ lit_utf8_size_t offset : LIT_ITERATOR_OFFSET_WIDTH; /** offset to utf-8 char */
bool is_non_bmp_middle: 1; /** flag indicating that current position of the iterator is the middle of
* 4-byte char */
} lit_utf8_iterator_pos_t;
/**
* Value of an iterator, positioned to beginning of a string
*/
#define LIT_ITERATOR_POS_ZERO {0, false}
/**
* Represents an iterator over utf-8 buffer
*/
typedef struct
{
const lit_utf8_byte_t *buf_p; /* buffer */
lit_utf8_size_t buf_size; /* buffer length */
lit_utf8_iterator_pos_t buf_pos; /* position in the buffer */
} lit_utf8_iterator_t;
int32_t lit_utf8_iterator_pos_cmp (lit_utf8_iterator_pos_t, lit_utf8_iterator_pos_t);
/* validation */
bool lit_is_utf8_string_valid (const lit_utf8_byte_t *, lit_utf8_size_t);
bool lit_is_cesu8_string_valid (const lit_utf8_byte_t *, lit_utf8_size_t);
@@ -130,23 +93,6 @@ bool lit_is_cesu8_string_valid (const lit_utf8_byte_t *, lit_utf8_size_t);
bool lit_is_code_point_utf16_low_surrogate (lit_code_point_t);
bool lit_is_code_point_utf16_high_surrogate (lit_code_point_t);
/* iteration */
lit_utf8_iterator_t lit_utf8_iterator_create (const lit_utf8_byte_t *, lit_utf8_size_t);
void lit_utf8_iterator_seek_bos (lit_utf8_iterator_t *);
lit_utf8_iterator_pos_t lit_utf8_iterator_get_pos (const lit_utf8_iterator_t *);
void lit_utf8_iterator_seek (lit_utf8_iterator_t *, lit_utf8_iterator_pos_t);
ecma_char_t lit_utf8_iterator_peek_next (const lit_utf8_iterator_t *);
void lit_utf8_iterator_incr (lit_utf8_iterator_t *);
void lit_utf8_iterator_advance (lit_utf8_iterator_t *, ecma_length_t);
ecma_char_t lit_utf8_iterator_read_next (lit_utf8_iterator_t *);
bool lit_utf8_iterator_is_eos (const lit_utf8_iterator_t *);
/* size */
lit_utf8_size_t lit_zt_utf8_string_size (const lit_utf8_byte_t *);
@@ -189,7 +135,4 @@ ecma_char_t lit_utf8_peek_prev (const lit_utf8_byte_t *);
void lit_utf8_incr (const lit_utf8_byte_t **);
void lit_utf8_decr (const lit_utf8_byte_t **);
/* print */
void lit_put_ecma_char (ecma_char_t);
#endif /* !LIT_STRINGS_H */