diff --git a/Makefile.mk b/Makefile.mk index e8e014c60..73f2759fb 100644 --- a/Makefile.mk +++ b/Makefile.mk @@ -273,8 +273,9 @@ SOURCES_JERRY_C = \ $(wildcard ./src/libecmabuiltins/*.c) \ $(wildcard ./src/liballocator/*.c) \ $(wildcard ./src/libcoreint/*.c) \ - $(wildcard ./src/liboptimizer/*.c) ) \ - $(wildcard ./src/libruntime/target/$(TARGET_SYSTEM)/*.c) + $(wildcard ./src/libintstructs/*.c) \ + $(wildcard ./src/liboptimizer/*.c ) \ + $(wildcard ./src/libruntime/target/$(TARGET_SYSTEM)/*.c) ) SOURCES_JERRY_H = \ $(sort \ diff --git a/src/config.h b/src/config.h index 288339704..2970e918c 100644 --- a/src/config.h +++ b/src/config.h @@ -55,7 +55,7 @@ /** * Size of heap */ -#define CONFIG_MEM_HEAP_AREA_SIZE (4 * 1024 + 512) +#define CONFIG_MEM_HEAP_AREA_SIZE (5 * 1024 + 512) /** * Log2 of maximum possible offset in the heap diff --git a/src/libintstructs/lp-string.c b/src/libintstructs/lp-string.c new file mode 100644 index 000000000..35c7c13f2 --- /dev/null +++ b/src/libintstructs/lp-string.c @@ -0,0 +1,56 @@ +/* Copyright 2014 Samsung Electronics Co., Ltd. + * + * 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. + */ + +#include "lp-string.h" + +bool +lp_string_equal (lp_string s1, lp_string s2) +{ + if (s1.length != s2.length) + { + return false; + } + + for (ecma_length_t i = 0; i < s1.length; i++) + { + JERRY_ASSERT (s1.str[i] != '\0' && s1.str[i] != '\0'); + if (s1.str[i] != s2.str[i]) + { + return false; + } + } + + return true; +} + +bool +lp_string_equal_s (lp_string lp, const char *s) +{ + for (ecma_length_t i = 0; i < lp.length; i++) + { + JERRY_ASSERT (lp.str[i] != '\0'); + if (lp.str[i] != s[i]) + { + return false; + } + } + + if (s[lp.length] != '\0') + { + return false; + } + + return true; +} diff --git a/src/libintstructs/lp-string.h b/src/libintstructs/lp-string.h new file mode 100644 index 000000000..266b56862 --- /dev/null +++ b/src/libintstructs/lp-string.h @@ -0,0 +1,33 @@ +/* Copyright 2014 Samsung Electronics Co., Ltd. + * + * 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 LP_STRING +#define LP_STRING + +#include "ecma-globals.h" + +/* Length-prefixed or "pascal" string. */ +typedef struct +{ + ecma_length_t length; + const ecma_char_t *str; +} +__packed +lp_string; + +bool lp_string_equal (lp_string, lp_string); +bool lp_string_equal_s (lp_string, const char *); + +#endif /* LP_STRING */ diff --git a/src/libintstructs/stack.h b/src/libintstructs/stack.h index ad3f5c25a..38224f409 100644 --- a/src/libintstructs/stack.h +++ b/src/libintstructs/stack.h @@ -15,22 +15,16 @@ /** This file contains macros to define and use stacks. - Do define stack type use macro DEFINE_STACK_TYPE. - After definition of type use macro STACK to create stack variable and define all necessaty routines. + Use macro STACK or STATIC_STACK to create stack variable and define all necessaty routines. Also, define variable with name NAME##_global_size. If the variable more than 0, - first NAME##_global_size element will remain untouched during PUSH and POP operations. - Before using the stack, init it by calling INIT_STACK macro. - Use macros PUSH, POP, DROP, CLEAN and HEAD to manipulate the stack. - DO NOT FORGET to free stack memory by calling FREE_STACK macro. - For check usage of stack during a function, use DECLARE_USAGE and CHECK_USAGE macros. + first NAME##_global_size element will remain untouched during STACK_PUSH and STACK_POP operations. + Before using the stack, init it by calling STACK_INIT macro. + Use macros STACK_PUSH, STACK_POP, STACK_DROP, STACK_CLEAN and STACK_HEAD to manipulate the stack. + DO NOT FORGET to free stack memory by calling STACK_FREE macro. + For check usage of stack during a function, use STACK_DECLARE_USAGE and STACK_CHECK_USAGE macros. Example (parser.c): - #ifndef UINT8_T_STACK_DEFINED - #define UINT8_T_STACK_DEFINED - DEFINE_STACK_TYPE (uint8_t) - #endif - enum { temp_name, @@ -38,7 +32,7 @@ max_temp_name, temp_names_global_size }; - STACK(uint8_t, temp_names) + STACK(temp_names, uint8_t, uint8_t) #define GLOBAL(NAME, VAR) \ NAME.data[VAR] @@ -55,19 +49,19 @@ void parser_init (void) { - INIT_STACK(uint8_t, temp_names) + STACK_INIT(uint8_t, temp_names) } void parser_free (void) { - FREE_STACK(temp_names) + STACK_FREE(temp_names) } */ #ifndef STACK_H #define STACK_H -#define DEFINE_STACK_TYPE(DATA_TYPE, TYPE) \ +#define DEFINE_STACK_TYPE(NAME, DATA_TYPE, TYPE) \ typedef struct \ { \ DATA_TYPE length; \ @@ -75,20 +69,20 @@ typedef struct \ TYPE *data; \ } \ __packed \ -TYPE##_stack; +NAME##_stack; -#define INIT_STACK(TYPE, NAME) \ +#define STACK_INIT(TYPE, NAME) \ do { \ -size_t NAME##_size = mem_heap_recommend_allocation_size (sizeof (TYPE) * NAME##_global_size); \ -NAME.data = (TYPE *) mem_heap_alloc_block (NAME##_size, MEM_HEAP_ALLOC_SHORT_TERM); \ -NAME.current = NAME##_global_size; \ -NAME.length = (__typeof__ (NAME.length)) (NAME##_size / sizeof (TYPE)); \ + size_t stack_size = mem_heap_recommend_allocation_size (sizeof (TYPE) * NAME##_global_size); \ + NAME.data = (TYPE *) mem_heap_alloc_block (stack_size, MEM_HEAP_ALLOC_SHORT_TERM); \ + NAME.current = NAME##_global_size; \ + NAME.length = (__typeof__ (NAME.length)) (stack_size / sizeof (TYPE)); \ } while (0) -#define FREE_STACK(NAME) \ +#define STACK_FREE(NAME) \ do { \ -mem_heap_free_block ((uint8_t *) NAME.data); \ -NAME.length = NAME.current = 0; \ + mem_heap_free_block ((uint8_t *) NAME.data); \ + NAME.length = NAME.current = 0; \ } while (0) /* In most cases (for example, in parser) default size of stack is enough. @@ -100,7 +94,7 @@ NAME.length = NAME.current = 0; \ 4) Allocate new memory. (It must point to the memory before increasing). 5) Copy data back. 6) Free temp buffer. */ -#define DEFINE_INCREASE_STACK_SIZE(TYPE, NAME) \ +#define DEFINE_INCREASE_STACK_SIZE(NAME, TYPE) \ static void increase_##NAME##_stack_size (__typeof__ (NAME.length)) __unused; \ static void \ increase_##NAME##_stack_size (__typeof__ (NAME.length) elements_count) { \ @@ -122,6 +116,12 @@ increase_##NAME##_stack_size (__typeof__ (NAME.length) elements_count) { \ mem_heap_free_block ((uint8_t *) NAME.data); \ mem_heap_free_block ((uint8_t *) temp1); \ NAME.data = (TYPE *) mem_heap_alloc_block (new_size, MEM_HEAP_ALLOC_SHORT_TERM); \ + if (NAME.data == NULL) \ + { \ + __printf ("old_size: %d\ntemp1_size: %d\nnew_size: %d\n", old_size, temp1_size, new_size); \ + mem_heap_print (true, false, true); \ + JERRY_UNREACHABLE (); \ + } \ __memcpy (NAME.data, temp2, old_size); \ mem_heap_free_block ((uint8_t *) temp2); \ NAME.length = (__typeof__ (NAME.length)) (new_size / sizeof (TYPE)); \ @@ -137,44 +137,58 @@ decrease_##NAME##_stack_size (uint8_t elements_count) { \ NAME.current = (__typeof__ (NAME.current)) (NAME.current - elements_count); \ } -#define PUSH(NAME, VALUE) \ -increase_##NAME##_stack_size (1); \ -NAME.data[NAME.current - 1] = VALUE; +#define STACK_PUSH(NAME, VALUE) \ +do { \ + increase_##NAME##_stack_size (1); \ + NAME.data[NAME.current - 1] = VALUE; \ +} while (0) -#define POP(VALUE, NAME) \ -decrease_##NAME##_stack_size (1); \ -VALUE = NAME.data[NAME.current]; +#define STACK_POP(NAME, VALUE) \ +do { \ + decrease_##NAME##_stack_size (1); \ + VALUE = NAME.data[NAME.current]; \ +} while (0) -#define DROP(NAME, I) \ -decrease_##NAME##_stack_size (I); +#define STACK_DROP(NAME, I) \ +do { decrease_##NAME##_stack_size (I); } while (0) -#define CLEAN(NAME) \ -DROP (NAME, NAME.current - NAME##_global_size); +#define STACK_CLEAN(NAME) \ +STACK_DROP (NAME, NAME.current - NAME##_global_size); -#define HEAD(NAME, I) \ +#define STACK_HEAD(NAME, I) \ NAME.data[NAME.current - I] #define STACK_SIZE(NAME) \ NAME.current -#define STACK(TYPE, NAME) \ -TYPE##_stack NAME; \ -DEFINE_DECREASE_STACE_SIZE (NAME) \ -DEFINE_INCREASE_STACK_SIZE (TYPE, NAME) +#define STACK_ELEMENT(NAME, I) \ +NAME.data[I] -#define STATIC_STACK(TYPE, NAME) \ -static TYPE##_stack NAME; \ +#define STACK_RAW_DATA(NAME) \ +NAME.data + +#define STACK(NAME, DATA_TYPE, TYPE) \ +DEFINE_STACK_TYPE(NAME, DATA_TYPE, TYPE) \ +NAME##_stack NAME; \ DEFINE_DECREASE_STACE_SIZE (NAME) \ -DEFINE_INCREASE_STACK_SIZE (TYPE, NAME) +DEFINE_INCREASE_STACK_SIZE (NAME, TYPE) + +#define STATIC_STACK(NAME, DATA_TYPE, TYPE) \ +DEFINE_STACK_TYPE(NAME, DATA_TYPE, TYPE) \ +static NAME##_stack NAME; \ +DEFINE_DECREASE_STACE_SIZE (NAME) \ +DEFINE_INCREASE_STACK_SIZE (NAME, TYPE) #ifndef JERRY_NDEBUG -#define DECLARE_USAGE(NAME) \ -uint8_t NAME##_current = NAME.current; -#define CHECK_USAGE(NAME) \ -JERRY_ASSERT (NAME.current == NAME##_current); +#define STACK_DECLARE_USAGE(NAME) \ +__typeof__(NAME.current) NAME##_current = NAME.current; +#define STACK_CHECK_USAGE(NAME) \ +do { \ + JERRY_ASSERT (NAME.current == NAME##_current); \ +} while (0); #else -#define DECLARE_USAGE(NAME) ; -#define CHECK_USAGE(NAME) ; +#define STACK_DECLARE_USAGE(NAME) ; +#define STACK_CHECK_USAGE(NAME) ; #endif /* JERRY_NDEBUG */ #endif /* STACK_H */ diff --git a/src/libjsparser/lexer.c b/src/libjsparser/lexer.c index d0541d7a1..c388a2638 100644 --- a/src/libjsparser/lexer.c +++ b/src/libjsparser/lexer.c @@ -17,31 +17,43 @@ #include "jerry-libc.h" #include "lexer.h" #include "parser.h" +#include "stack.h" +#include "opcodes.h" static token saved_token; static token empty_token = { - .type = - TOK_EMPTY, + .type = TOK_EMPTY, .uid = 0 }; static bool allow_dump_lines = false; static size_t buffer_size = 0; -typedef struct +/* Represents the contents of a script. */ +static const char *buffer_start = NULL; +static const char *buffer = NULL; +static const char *token_start; + +#define LA(I) (get_char (I)) + +enum { - ecma_number_t num; - token tok; -} -num_and_token; + strings_global_size +}; +STATIC_STACK (strings, uint8_t, lp_string) -#define MAX_NUMS 25 +enum +{ + numbers_global_size +}; +STATIC_STACK (numbers, uint8_t, ecma_number_t) -static uint8_t seen_names_count = 0; - -static num_and_token seen_nums[MAX_NUMS]; -static uint8_t seen_nums_count = 0; +enum +{ + num_ids_global_size +}; +STATIC_STACK (num_ids, uint8_t, idx_t) static bool is_empty (token tok) @@ -49,11 +61,6 @@ is_empty (token tok) return tok.type == TOK_EMPTY; } -/* Represents the contents of a script. */ -static const char *buffer_start = NULL; -static const char *buffer = NULL; -static const char *token_start; - static char get_char (size_t i) { @@ -64,44 +71,6 @@ get_char (size_t i) return *(buffer + i); } -#define LA(I) (get_char (I)) - -/* Continuous array of NULL-terminated strings. */ -static char *strings_cache = NULL; -static size_t strings_cache_size = 0; - -static void -increase_strings_cache (void) -{ - char *new_cache; - size_t new_cache_size; - - // if strings_cache_size == 0, allocator recommends minimum size that is more than 0 - new_cache_size = mem_heap_recommend_allocation_size (strings_cache_size * 2); - new_cache = (char *) mem_heap_alloc_block (new_cache_size, MEM_HEAP_ALLOC_SHORT_TERM); - - if (!new_cache) - { - // Allocator alligns recommended memory size - new_cache_size = mem_heap_recommend_allocation_size (strings_cache_size + 1); - new_cache = (char *) mem_heap_alloc_block (new_cache_size, MEM_HEAP_ALLOC_SHORT_TERM); - - if (!new_cache) - { - parser_fatal (ERR_MEMORY); - } - } - - if (strings_cache) - { - __memcpy (new_cache, strings_cache, strings_cache_size); - mem_heap_free_block ((uint8_t *) strings_cache); - } - - strings_cache = new_cache; - strings_cache_size = new_cache_size; -} - #ifdef __TARGET_HOST_x64 static void dump_current_line (void) @@ -137,6 +106,20 @@ current_token_equals_to (const char *str) return false; } +static bool +current_token_equals_to_lp (lp_string str) +{ + if (str.length != (ecma_length_t) (buffer - token_start)) + { + return false; + } + if (!__strncmp ((const char *) str.str, token_start, str.length)) + { + return true; + } + return false; +} + /* If TOKEN represents a keyword, return decoded keyword, if TOKEN represents a Future Reserved Word, return KW_RESERVED, otherwise return KW_NONE. */ @@ -507,171 +490,121 @@ decode_keyword (void) } static token -convert_seen_name_to_token (token_type tt, const char *string) +convert_current_token_to_token (token_type tt) { - uint8_t i; - char *current_string = strings_cache; - JERRY_ASSERT (strings_cache); - token ret_val = empty_token; + JERRY_ASSERT (token_start); - for (i = 0; i < seen_names_count; i++) + for (uint8_t i = 0; i < STACK_SIZE (strings); i++) { - if ((string == NULL && current_token_equals_to (current_string)) - || (string != NULL && !__strcmp (current_string, string))) + if (current_token_equals_to_lp (strings.data[i])) { - ret_val = (token) + return (token) { .type = tt, .uid = i }; - - break; } - - current_string += __strlen (current_string) + 1; } - return ret_val; -} - -static token -add_token_to_seen_names (token_type tt, const char *string) -{ - size_t i; - char *current_string = strings_cache; - size_t required_size; - size_t len = (string == NULL ? (size_t) (buffer - token_start) : __strlen (string)); - token ret_val = empty_token; - - // Go to unused memory of cache - for (i = 0; i < seen_names_count; i++) + const lp_string str = (lp_string) { - current_string += __strlen (current_string) + 1; - } - - required_size = (size_t) (current_string - strings_cache) + len + 1; - if (required_size > strings_cache_size) - { - size_t offset = (size_t) (current_string - strings_cache); - increase_strings_cache (); - - // Now our pointer are invalid, adjust it - current_string = strings_cache + offset; - } - - if (string == NULL) - { - // Copy current token with terminating NULL - __strncpy (current_string, token_start, (size_t) (buffer - token_start)); - current_string += buffer - token_start; - *current_string = '\0'; - } - else - { - __memcpy (current_string, string, __strlen (string) + 1); - } - - ret_val = (token) - { - .type = tt, - .uid = seen_names_count++ + .length = (uint8_t) (buffer - token_start), + .str = (const ecma_char_t *) token_start }; - return ret_val; + STACK_PUSH (strings, str); + + return (token) + { + .type = tt, + .uid = (idx_t) (STACK_SIZE (strings) - 1) + }; } static token convert_seen_num_to_token (ecma_number_t num) { - size_t i; + uint8_t num_id; - for (i = 0; i < seen_nums_count; i++) + JERRY_ASSERT (STACK_SIZE (num_ids) == STACK_SIZE (numbers)); + for (uint8_t i = 0; i < STACK_SIZE (numbers); i++) { - // token must be exactly the same as seen - if (seen_nums[i].num == num) + if (numbers.data[i] == num) { - return seen_nums[i].tok; + return (token) + { + .type = TOK_NUMBER, + .uid = num_ids.data[i] + }; } } - return empty_token; + num_id = STACK_SIZE (num_ids); + STACK_PUSH (num_ids, num_id); + STACK_PUSH (numbers, num); + + return (token) + { + .type = TOK_NUMBER, + .uid = num_id + }; } -static void -add_num_to_seen_tokens (num_and_token nat) +const lp_string * +lexer_get_strings (void) { - JERRY_ASSERT (seen_nums_count < MAX_NUMS); - - seen_nums[seen_nums_count++] = nat; + return STACK_RAW_DATA (strings); } uint8_t -lexer_get_strings (const char **strings) +lexer_get_strings_count (void) { - if (strings) - { - char *current_string = strings_cache; - int i; - for (i = 0; i < seen_names_count; i++) - { - strings[i] = current_string; - current_string += __strlen (current_string) + 1; - } - } - - return seen_names_count; + return STACK_SIZE (strings); } uint8_t lexer_get_reserved_ids_count (void) { - return (uint8_t) (seen_names_count + seen_nums_count); + return (uint8_t) (STACK_SIZE (strings) + STACK_SIZE (numbers)); } -const char * +lp_string lexer_get_string_by_id (uint8_t id) { - int i; - char *current_string = strings_cache; - JERRY_ASSERT (id < seen_names_count); + JERRY_ASSERT (id < STACK_SIZE (strings)); + return STACK_ELEMENT (strings, id); +} - for (i = 0 ; i < id; i++) - { - current_string += __strlen (current_string) + 1; - } - - return current_string; +const ecma_number_t * +lexer_get_nums (void) +{ + return STACK_RAW_DATA (numbers); } uint8_t -lexer_get_nums (ecma_number_t *nums) +lexer_get_nums_count (void) { - int i; - - if (!nums) - { - return seen_nums_count; - } - - for (i = 0; i < seen_nums_count; i++) - { - nums[i] = seen_nums[i].num; - } - - return seen_nums_count; + return STACK_SIZE (numbers); } void lexer_adjust_num_ids (void) { - size_t i; - - for (i = 0; i < seen_nums_count; i++) + JERRY_ASSERT (STACK_SIZE (numbers) == STACK_SIZE (num_ids)); + for (uint8_t i = 0; i < STACK_SIZE (numbers); i++) { - seen_nums[i].tok.uid = (uint8_t) (seen_nums[i].tok.uid + seen_names_count); + STACK_ELEMENT (num_ids, i) = (uint8_t) (STACK_ELEMENT (num_ids, i) + STACK_SIZE (strings)); } } +ecma_number_t +lexer_get_num_by_id (uint8_t id) +{ + JERRY_ASSERT (id >= lexer_get_strings_count () && id < lexer_get_reserved_ids_count ()); + JERRY_ASSERT (STACK_ELEMENT (num_ids, id - lexer_get_strings_count ()) == id); + return STACK_ELEMENT (numbers, id - lexer_get_strings_count ()); +} + static void new_token (void) { @@ -773,20 +706,14 @@ parse_name (void) } } - known_token = convert_seen_name_to_token (TOK_NAME, NULL); - if (!is_empty (known_token)) - { - goto end; - } - - known_token = add_token_to_seen_names (TOK_NAME, NULL); + known_token = convert_current_token_to_token (TOK_NAME); end: token_start = NULL; return known_token; } -static int32_t +static uint32_t hex_to_int (char hex) { switch (hex) @@ -827,7 +754,7 @@ parse_number (void) bool is_fp = false; bool is_exp = false; size_t tok_length = 0, i; - int32_t res = 0; + uint32_t res = 0; token known_token; JERRY_ASSERT (__isdigit (c) || c == '.'); @@ -868,10 +795,17 @@ parse_number (void) } tok_length = (size_t) (buffer - token_start); - // OK, I know that integer overflow can occur here + for (i = 0; i < tok_length; i++) { +#ifndef JERRY_NDEBUG + uint32_t old_res = res; +#endif res = (res << 4) + hex_to_int (token_start[i]); + FIXME (Replace with conversion to ecma_number_t) +#ifndef JERRY_NDEBUG + JERRY_ASSERT (old_res <= res); +#endif } token_start = NULL; @@ -886,23 +820,8 @@ parse_number (void) } known_token = convert_seen_num_to_token ((ecma_number_t) res); - if (!is_empty (known_token)) - { - return known_token; - } + JERRY_ASSERT (!is_empty (known_token)); - known_token = (token) - { - .type = TOK_NUMBER, - .uid = seen_nums_count - }; - add_num_to_seen_tokens ( - (num_and_token) - { - .num = (ecma_number_t) res, - .tok = known_token - } -); return known_token; } @@ -973,23 +892,7 @@ parse_number (void) token_start = NULL; known_token = convert_seen_num_to_token (res); - if (!is_empty (known_token)) - { - return known_token; - } - known_token = (token) - { - .type = TOK_NUMBER, - .uid = seen_nums_count - }; - add_num_to_seen_tokens ( - (num_and_token) - { - .num = res, - .tok = known_token - } -); return known_token; } @@ -1011,54 +914,15 @@ parse_number (void) } known_token = convert_seen_num_to_token ((ecma_number_t) res); - if (!is_empty (known_token)) - { - return known_token; - } - - known_token = (token) - { - .type = TOK_NUMBER, - .uid = seen_nums_count - }; - add_num_to_seen_tokens ( - (num_and_token) - { - .num = (ecma_number_t) res, - .tok = known_token - } -); return known_token; } -static char -escape_char (char c) -{ - switch (c) - { - case 'b': return '\b'; - case 'f': return '\f'; - case 'n': return '\n'; - case 'r': return '\r'; - case 't': return '\t'; - case 'v': return '\v'; - case '\'': - case '"': - case '\\': - default: return c; - } -} - static token parse_string (void) { char c = LA (0); bool is_double_quoted; - char *tok = NULL; - char *index = NULL; - const char *i; - size_t length; - token known_token = empty_token; + token result; JERRY_ASSERT (c == '\'' || c == '"'); @@ -1104,46 +968,13 @@ parse_string (void) consume_char (); } - length = (size_t) (buffer - token_start); - tok = (char *) mem_heap_alloc_block (length + 1, MEM_HEAP_ALLOC_SHORT_TERM); - __memset (tok, '\0', length + 1); - index = tok; - - // Copy current token to TOK and replace escape sequences by there meanings - for (i = token_start; i < buffer; i++) - { - if (*i == '\\') - { - if (*(i+1) == '\n') - { - i++; - continue; - } - *index = escape_char (*(i+1)); - index++; - i++; - continue; - } - - *index = *i; - index++; - } - // Eat up '"' + result = convert_current_token_to_token (TOK_STRING); + consume_char (); - - known_token = convert_seen_name_to_token (TOK_STRING, tok); - if (!is_empty (known_token)) - { - goto end; - } - - known_token = add_token_to_seen_names (TOK_STRING, tok); - -end: - mem_heap_free_block ((uint8_t *) tok); token_start = NULL; - return known_token; + + return result; } static void @@ -1421,7 +1252,10 @@ lexer_init (const char *source, size_t source_size, bool show_opcodes) allow_dump_lines = show_opcodes; buffer_size = source_size; lexer_set_source (source); - increase_strings_cache (); + + STACK_INIT (lp_string, strings); + STACK_INIT (ecma_number_t, numbers); + STACK_INIT (idx_t, num_ids); } void @@ -1439,7 +1273,7 @@ lexer_run_first_pass (void) void lexer_free (void) { - mem_heap_free_block ((uint8_t *) strings_cache); - strings_cache = NULL; - strings_cache_size = 0; + STACK_FREE (strings); + STACK_FREE (numbers); + STACK_FREE (num_ids); } diff --git a/src/libjsparser/lexer.h b/src/libjsparser/lexer.h index 127046ca2..51531f7b8 100644 --- a/src/libjsparser/lexer.h +++ b/src/libjsparser/lexer.h @@ -18,6 +18,7 @@ #include "globals.h" #include "ecma-globals.h" +#include "lp-string.h" /* Keywords. */ typedef uint8_t keyword; @@ -145,14 +146,24 @@ token; void lexer_init (const char *, size_t, bool); void lexer_free (void); + void lexer_run_first_pass (void); + token lexer_next_token (void); void lexer_save_token (token); + void lexer_dump_buffer_state (void); -uint8_t lexer_get_strings (const char **); + uint8_t lexer_get_reserved_ids_count (void); -const char *lexer_get_string_by_id (uint8_t); -uint8_t lexer_get_nums (ecma_number_t *); + +const lp_string *lexer_get_strings (void); +uint8_t lexer_get_strings_count (void); +lp_string lexer_get_string_by_id (uint8_t); + +const ecma_number_t *lexer_get_nums (void); +ecma_number_t lexer_get_num_by_id (uint8_t); +uint8_t lexer_get_nums_count (void); + void lexer_adjust_num_ids (void); #endif diff --git a/src/libjsparser/parser.c b/src/libjsparser/parser.c index ff65c99af..4b499c874 100644 --- a/src/libjsparser/parser.c +++ b/src/libjsparser/parser.c @@ -23,6 +23,7 @@ #include "stack.h" #define INVALID_VALUE 255 +#define INTRINSICS_COUNT 1 typedef enum { @@ -32,50 +33,40 @@ typedef enum } rewritable_opcode_type; +typedef struct +{ + uint8_t args_count; + union + { + void (*fun1) (idx_t); + } + funs; +} +intrinsic_dumper; + #define NESTING_ITERATIONAL 1 #define NESTING_SWITCH 2 #define NESTING_FUNCTION 3 -#ifndef UINT8_T_STACK_DEFINED -#define UINT8_T_STACK_DEFINED -DEFINE_STACK_TYPE (uint8_t, uint8_t) -#endif - -#ifndef UINT16_T_STACK_DEFINED -DEFINE_STACK_TYPE (uint8_t, uint16_t) -#define UINT16_T_STACK_DEFINED -#endif - -#ifndef TOKEN_STACK_DEFINED -DEFINE_STACK_TYPE (uint8_t, token) -#define TOKEN_STACK_DEFINED -#endif - -#ifndef OPCODE_T_STACK_DEFINED -DEFINE_STACK_TYPE (uint8_t, opcode_t) -#define OPCODE_T_STACK_DEFINED -#endif - -#define GLOBAL(NAME, VAR) \ -NAME.data[VAR] +#define GLOBAL(NAME, VAR) STACK_ELEMENT (NAME, VAR) enum { U8_global_size }; -STATIC_STACK (uint8_t, U8) +STATIC_STACK (U8, uint8_t, uint8_t) enum { IDX_global_size }; -STATIC_STACK (uint8_t, IDX) +STATIC_STACK (IDX, uint8_t, uint8_t) enum { nestings_global_size }; -STATIC_STACK (uint8_t, nestings) +STATIC_STACK (nestings, uint8_t, uint8_t) enum { @@ -84,7 +75,7 @@ enum max_temp_name, temp_names_global_size }; -STATIC_STACK (uint8_t, temp_names) +STATIC_STACK (temp_names, uint8_t, uint8_t) #define MAX_TEMP_NAME() \ GLOBAL(temp_names, max_temp_name) @@ -100,7 +91,7 @@ enum tok = 0, toks_global_size }; -STATIC_STACK (token, toks) +STATIC_STACK (toks, uint8_t, token) #define TOK() \ GLOBAL(toks, tok) @@ -110,7 +101,7 @@ enum opcode = 0, ops_global_size }; -STATIC_STACK (opcode_t, ops) +STATIC_STACK (ops, uint8_t, opcode_t) #define OPCODE() \ GLOBAL(ops, opcode) @@ -120,7 +111,7 @@ enum opcode_counter = 0, U16_global_size }; -STATIC_STACK (uint16_t, U16) +STATIC_STACK (U16, uint8_t, uint16_t) #define OPCODE_COUNTER() \ GLOBAL(U16, opcode_counter) @@ -129,19 +120,19 @@ enum { rewritable_continue_global_size }; -STATIC_STACK (uint16_t, rewritable_continue) +STATIC_STACK (rewritable_continue, uint8_t, uint16_t) enum { rewritable_break_global_size }; -STATIC_STACK (uint16_t, rewritable_break) +STATIC_STACK (rewritable_break, uint8_t, uint16_t) #ifndef JERRY_NDEBUG -#define CHECK_USAGE_LHS() \ +#define STACK_CHECK_USAGE_LHS() \ JERRY_ASSERT (IDX.current == IDX_current + 1); #else -#define CHECK_USAGE_LHS() ; +#define STACK_CHECK_USAGE_LHS() ; #endif JERRY_STATIC_ASSERT (sizeof (idx_t) == sizeof (uint8_t)); @@ -159,12 +150,143 @@ typedef enum } argument_list_type; +#define DEFINE_BACKET_TYPE(NAME, KEY_TYPE, VALUE_TYPE) \ +typedef struct \ +{ \ + KEY_TYPE key; \ + VALUE_TYPE value; \ +} \ +__packed \ +NAME##_backet; + +#define DEFINE_HASH_TYPE(NAME, KEY_TYPE, VALUE_TYPE) \ +typedef struct \ +{ \ + uint8_t size; \ + NAME##_backet_stack *backets; \ +} \ +__packed \ +NAME##_hash_table; + +#define HASH_INIT(NAME, SIZE) \ +do { \ + NAME.size = SIZE; \ + size_t size = mem_heap_recommend_allocation_size (SIZE * sizeof (NAME##_backet_stack)); \ + NAME.backets = (NAME##_backet_stack *) mem_heap_alloc_block (size, MEM_HEAP_ALLOC_SHORT_TERM); \ + __memset (NAME.backets, 0, size); \ +} while (0); + +#define HASH_FREE(NAME) \ +do { \ + for (uint8_t i = 0; i < NAME.size; i++) { \ + if (NAME.backets[i].length != 0) { \ + mem_heap_free_block ((uint8_t *) NAME.backets[i].data); \ + } \ + } \ + mem_heap_free_block ((uint8_t *) NAME.backets); \ +} while (0) + +#define DEFINE_HASH_INSERT(NAME, KEY_TYPE, VALUE_TYPE) \ +static void hash_insert_##NAME (KEY_TYPE key, VALUE_TYPE value) __unused; \ +static void hash_insert_##NAME (KEY_TYPE key, VALUE_TYPE value) { \ + NAME##_backet backet = (NAME##_backet) { .key = key, .value = value }; \ + uint8_t hash = KEY_TYPE##_hash (key); \ + JERRY_ASSERT (hash < NAME.size); \ + JERRY_ASSERT (NAME.backets != NULL); \ + if (NAME.backets[hash].length == 0) \ + { \ + size_t stack_size = mem_heap_recommend_allocation_size (0); \ + NAME.backets[hash].data = (NAME##_backet *) mem_heap_alloc_block \ + (stack_size, MEM_HEAP_ALLOC_SHORT_TERM); \ + NAME.backets[hash].current = 0; \ + NAME.backets[hash].length = (__typeof__ (NAME.backets[hash].length)) \ + (stack_size / sizeof (NAME##_backet)); \ + } \ + else if (NAME.backets[hash].current == NAME.backets[hash].length) \ + { \ + size_t old_size = NAME.backets[hash].length * sizeof (NAME##_backet); \ + size_t temp1_size = mem_heap_recommend_allocation_size ( \ + (size_t) (sizeof (NAME##_backet))); \ + size_t new_size = mem_heap_recommend_allocation_size ( \ + (size_t) (temp1_size + old_size)); \ + NAME##_backet *temp1 = (NAME##_backet *) mem_heap_alloc_block \ + (temp1_size, MEM_HEAP_ALLOC_SHORT_TERM); \ + NAME##_backet *temp2 = (NAME##_backet *) mem_heap_alloc_block \ + (old_size, MEM_HEAP_ALLOC_SHORT_TERM); \ + if (temp2 == NULL) \ + { \ + mem_heap_print (true, false, true); \ + JERRY_UNREACHABLE (); \ + } \ + __memcpy (temp2, NAME.backets[hash].data, old_size); \ + mem_heap_free_block ((uint8_t *) NAME.backets[hash].data); \ + mem_heap_free_block ((uint8_t *) temp1); \ + NAME.backets[hash].data = (NAME##_backet *) mem_heap_alloc_block \ + (new_size, MEM_HEAP_ALLOC_SHORT_TERM); \ + __memcpy (NAME.backets[hash].data, temp2, old_size); \ + mem_heap_free_block ((uint8_t *) temp2); \ + NAME.backets[hash].length = (__typeof__ (NAME.backets[hash].length)) \ + (new_size / sizeof (NAME##_backet)); \ + } \ + NAME.backets[hash].data[NAME.backets[hash].current++] = backet; \ +} + +#define HASH_INSERT(NAME, KEY, VALUE) \ +do { \ + hash_insert_##NAME (KEY, VALUE); \ +} while (0) + +#define DEFINE_HASH_LOOKUP(NAME, KEY_TYPE, VALUE_TYPE) \ +static VALUE_TYPE *lookup_##NAME (KEY_TYPE key) __unused; \ +static VALUE_TYPE *lookup_##NAME (KEY_TYPE key) { \ + uint8_t hash = KEY_TYPE##_hash (key); \ + JERRY_ASSERT (hash < NAME.size); \ + if (NAME.backets[hash].length == 0) { \ + return NULL; \ + } \ + for (size_t i = 0; i < NAME.backets[hash].current; i++) { \ + if (KEY_TYPE##_equal (NAME.backets[hash].data[i].key, key)) { \ + return &NAME.backets[hash].data[i].value; \ + } \ + } \ + return NULL; \ +} + +#define HASH_LOOKUP(NAME, KEY) \ +lookup_##NAME (KEY) + +#define HASH_TABLE(NAME, KEY_TYPE, VALUE_TYPE) \ +DEFINE_BACKET_TYPE (NAME, KEY_TYPE, VALUE_TYPE) \ +DEFINE_STACK_TYPE (NAME##_backet, uint8_t, NAME##_backet) \ +DEFINE_HASH_TYPE (NAME, KEY_TYPE, VALUE_TYPE) \ +NAME##_hash_table NAME; \ +DEFINE_HASH_INSERT (NAME, KEY_TYPE, VALUE_TYPE) \ +DEFINE_HASH_LOOKUP (NAME, KEY_TYPE, VALUE_TYPE) + +#define STATIC_HASH_TABLE(NAME, KEY_TYPE, VALUE_TYPE) \ +DEFINE_BACKET_TYPE (NAME, KEY_TYPE, VALUE_TYPE) \ +DEFINE_STACK_TYPE (NAME##_backet, uint8_t, NAME##_backet) \ +DEFINE_HASH_TYPE (NAME, KEY_TYPE, VALUE_TYPE) \ +static NAME##_hash_table NAME; \ +DEFINE_HASH_INSERT (NAME, KEY_TYPE, VALUE_TYPE) \ +DEFINE_HASH_LOOKUP (NAME, KEY_TYPE, VALUE_TYPE) + +static uint8_t lp_string_hash (lp_string); + +STATIC_HASH_TABLE (intrinsics, lp_string, intrinsic_dumper) + static void parse_expression (void); static void parse_statement (void); static void parse_assignment_expression (void); static void parse_source_element_list (void); static void parse_argument_list (argument_list_type, idx_t); +static uint8_t +lp_string_hash (lp_string str) +{ + return str.length % INTRINSICS_COUNT; +} + static idx_t next_temp_name (void) { @@ -174,14 +296,14 @@ next_temp_name (void) static void start_new_scope (void) { - PUSH (temp_names, MAX_TEMP_NAME()); + STACK_PUSH (temp_names, MAX_TEMP_NAME()); MAX_TEMP_NAME() = MIN_TEMP_NAME(); } static void finish_scope (void) { - POP (TEMP_NAME(), temp_names); + STACK_POP (temp_names, TEMP_NAME()); MAX_TEMP_NAME() = TEMP_NAME(); } @@ -198,24 +320,24 @@ reset_temp_name (void) static void push_nesting (uint8_t nesting_type) { - PUSH (nestings, nesting_type); + STACK_PUSH (nestings, nesting_type); } static void pop_nesting (uint8_t nesting_type) { - JERRY_ASSERT (HEAD (nestings, 1) == nesting_type); - DROP (nestings, 1); + JERRY_ASSERT (STACK_HEAD (nestings, 1) == nesting_type); + STACK_DROP (nestings, 1); } static void must_be_inside_but_not_in (uint8_t *inside, uint8_t insides_count, uint8_t not_in) { - DECLARE_USAGE (U8) // i, j - PUSH (U8, 0) - PUSH (U8, 0) -#define I() HEAD (U8, 2) -#define J() HEAD (U8, 1) + STACK_DECLARE_USAGE (U8) // i, j + STACK_PUSH (U8, 0); + STACK_PUSH (U8, 0); +#define I() STACK_HEAD (U8, 2) +#define J() STACK_HEAD (U8, 1) if (STACK_SIZE(nestings) == 0) { @@ -241,10 +363,10 @@ must_be_inside_but_not_in (uint8_t *inside, uint8_t insides_count, uint8_t not_i parser_fatal (ERR_PARSER); cleanup: - DROP (U8, 2) + STACK_DROP (U8, 2); #undef I #undef J - CHECK_USAGE (U8) + STACK_CHECK_USAGE (U8); } static bool @@ -339,128 +461,128 @@ token_after_newlines_must_be_keyword (keyword kw) } #define NEXT(TYPE) \ - do { skip_newlines (); parse_##TYPE (); } while (0) +do { skip_newlines (); parse_##TYPE (); } while (0) #define DUMP_VOID_OPCODE(GETOP) \ - do { \ - OPCODE()=getop_##GETOP (); \ - serializer_dump_opcode (OPCODE()); \ - OPCODE_COUNTER()++; \ - } while (0) +do { \ + OPCODE()=getop_##GETOP (); \ + serializer_dump_opcode (OPCODE()); \ + OPCODE_COUNTER()++; \ +} while (0) #define DUMP_OPCODE_1(GETOP, OP1) \ - do { \ - JERRY_ASSERT (0+OP1 <= 255); \ - OPCODE()=getop_##GETOP ((idx_t) (OP1)); \ - serializer_dump_opcode (OPCODE()); \ - OPCODE_COUNTER()++; \ - } while (0) +do { \ + JERRY_ASSERT (0+OP1 <= 255); \ + OPCODE()=getop_##GETOP ((idx_t) (OP1)); \ + serializer_dump_opcode (OPCODE()); \ + OPCODE_COUNTER()++; \ +} while (0) #define DUMP_OPCODE_2(GETOP, OP1, OP2) \ - do { \ - JERRY_ASSERT (0+OP1 <= 255); \ - JERRY_ASSERT (0+OP2 <= 255); \ - OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2)); \ - serializer_dump_opcode (OPCODE()); \ - OPCODE_COUNTER()++; \ - } while (0) +do { \ + JERRY_ASSERT (0+OP1 <= 255); \ + JERRY_ASSERT (0+OP2 <= 255); \ + OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2)); \ + serializer_dump_opcode (OPCODE()); \ + OPCODE_COUNTER()++; \ +} while (0) #define DUMP_OPCODE_3(GETOP, OP1, OP2, OP3) \ - do { \ - JERRY_ASSERT (0+OP1 <= 255); \ - JERRY_ASSERT (0+OP2 <= 255); \ - JERRY_ASSERT (0+OP3 <= 255); \ - OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2), (idx_t) (OP3)); \ - serializer_dump_opcode (OPCODE()); \ - OPCODE_COUNTER()++; \ - } while (0) +do { \ + JERRY_ASSERT (0+OP1 <= 255); \ + JERRY_ASSERT (0+OP2 <= 255); \ + JERRY_ASSERT (0+OP3 <= 255); \ + OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2), (idx_t) (OP3)); \ + serializer_dump_opcode (OPCODE()); \ + OPCODE_COUNTER()++; \ +} while (0) #define REWRITE_OPCODE_1(OC, GETOP, OP1) \ - do { \ - JERRY_ASSERT (0+OP1 <= 255); \ - OPCODE()=getop_##GETOP ((idx_t) (OP1)); \ - serializer_rewrite_opcode (OC, OPCODE()); \ - } while (0) +do { \ + JERRY_ASSERT (0+OP1 <= 255); \ + OPCODE()=getop_##GETOP ((idx_t) (OP1)); \ + serializer_rewrite_opcode (OC, OPCODE()); \ +} while (0) #define REWRITE_OPCODE_2(OC, GETOP, OP1, OP2) \ - do { \ - JERRY_ASSERT (0+OP1 <= 255); \ - JERRY_ASSERT (0+OP2 <= 255); \ - OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2)); \ - serializer_rewrite_opcode (OC, OPCODE()); \ - } while (0) +do { \ + JERRY_ASSERT (0+OP1 <= 255); \ + JERRY_ASSERT (0+OP2 <= 255); \ + OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2)); \ + serializer_rewrite_opcode (OC, OPCODE()); \ +} while (0) #define REWRITE_OPCODE_3(OC, GETOP, OP1, OP2, OP3) \ - do { \ - JERRY_ASSERT (0+OP1 <= 255); \ - JERRY_ASSERT (0+OP2 <= 255); \ - JERRY_ASSERT (0+OP3 <= 255); \ - OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2), (idx_t) (OP3)); \ - serializer_rewrite_opcode (OC, OPCODE()); \ - } while (0) +do { \ + JERRY_ASSERT (0+OP1 <= 255); \ + JERRY_ASSERT (0+OP2 <= 255); \ + JERRY_ASSERT (0+OP3 <= 255); \ + OPCODE()=getop_##GETOP ((idx_t) (OP1), (idx_t) (OP2), (idx_t) (OP3)); \ + serializer_rewrite_opcode (OC, OPCODE()); \ +} while (0) #define REWRITE_COND_JMP(OC, GETOP, DIFF) \ - do { \ - JERRY_ASSERT (0+DIFF <= 256*256 - 1); \ - DECLARE_USAGE (IDX) \ - JERRY_STATIC_ASSERT (sizeof (idx_t) == 1); \ - PUSH (IDX, (idx_t) ((DIFF) >> JERRY_BITSINBYTE)); \ - PUSH (IDX, (idx_t) ((DIFF) & ((1 << JERRY_BITSINBYTE) - 1))); \ - JERRY_ASSERT ((DIFF) == calc_opcode_counter_from_idx_idx (HEAD (IDX, 2), HEAD (IDX, 1))); \ - OPCODE()=getop_##GETOP (HEAD (IDX, 3), HEAD (IDX, 2), HEAD (IDX, 1)); \ - serializer_rewrite_opcode (OC, OPCODE()); \ - DROP (IDX, 2); \ - CHECK_USAGE (IDX) \ - } while (0) +do { \ + JERRY_ASSERT (0+DIFF <= 256*256 - 1); \ + STACK_DECLARE_USAGE (IDX); \ + JERRY_STATIC_ASSERT (sizeof (idx_t) == 1); \ + STACK_PUSH (IDX, (idx_t) ((DIFF) >> JERRY_BITSINBYTE)); \ + STACK_PUSH (IDX, (idx_t) ((DIFF) & ((1 << JERRY_BITSINBYTE) - 1))); \ + JERRY_ASSERT ((DIFF) == calc_opcode_counter_from_idx_idx (STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1))); \ + OPCODE()=getop_##GETOP (STACK_HEAD (IDX, 3), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); \ + serializer_rewrite_opcode (OC, OPCODE()); \ + STACK_DROP (IDX, 2); \ + STACK_CHECK_USAGE (IDX); \ +} while (0) #define REWRITE_JMP(OC, GETOP, DIFF) \ - do { \ - JERRY_ASSERT (0+DIFF <= 256*256 - 1); \ - DECLARE_USAGE (IDX) \ - JERRY_STATIC_ASSERT (sizeof (idx_t) == 1); \ - PUSH (IDX, (idx_t) ((DIFF) >> JERRY_BITSINBYTE)); \ - PUSH (IDX, (idx_t) ((DIFF) & ((1 << JERRY_BITSINBYTE) - 1))); \ - JERRY_ASSERT ((DIFF) == calc_opcode_counter_from_idx_idx (HEAD (IDX, 2), HEAD (IDX, 1))); \ - OPCODE()=getop_##GETOP (HEAD (IDX, 2), HEAD (IDX, 1)); \ - serializer_rewrite_opcode (OC, OPCODE()); \ - DROP (IDX, 2); \ - CHECK_USAGE (IDX) \ - } while (0) +do { \ + JERRY_ASSERT (0+DIFF <= 256*256 - 1); \ + STACK_DECLARE_USAGE (IDX) \ + JERRY_STATIC_ASSERT (sizeof (idx_t) == 1); \ + STACK_PUSH (IDX, (idx_t) ((DIFF) >> JERRY_BITSINBYTE)); \ + STACK_PUSH (IDX, (idx_t) ((DIFF) & ((1 << JERRY_BITSINBYTE) - 1))); \ + JERRY_ASSERT ((DIFF) == calc_opcode_counter_from_idx_idx (STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1))); \ + OPCODE()=getop_##GETOP (STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); \ + serializer_rewrite_opcode (OC, OPCODE()); \ + STACK_DROP (IDX, 2); \ + STACK_CHECK_USAGE (IDX); \ +} while (0) #define REWRITE_TRY(OC) \ - do { \ - DECLARE_USAGE (IDX) \ - JERRY_STATIC_ASSERT (sizeof (idx_t) == 1); \ - PUSH (IDX, (idx_t) ((OPCODE_COUNTER ()) >> JERRY_BITSINBYTE)); \ - PUSH (IDX, (idx_t) ((OPCODE_COUNTER ()) & ((1 << JERRY_BITSINBYTE) - 1))); \ - JERRY_ASSERT ((OPCODE_COUNTER ()) \ - == calc_opcode_counter_from_idx_idx (HEAD (IDX, 2), HEAD (IDX, 1))); \ - OPCODE()=getop_try (HEAD (IDX, 2), HEAD (IDX, 1)); \ - serializer_rewrite_opcode ((OC), OPCODE()); \ - DROP (IDX, 2); \ - CHECK_USAGE (IDX) \ - } while (0) +do { \ + STACK_DECLARE_USAGE (IDX) \ + JERRY_STATIC_ASSERT (sizeof (idx_t) == 1); \ + STACK_PUSH (IDX, (idx_t) ((OPCODE_COUNTER ()) >> JERRY_BITSINBYTE)); \ + STACK_PUSH (IDX, (idx_t) ((OPCODE_COUNTER ()) & ((1 << JERRY_BITSINBYTE) - 1))); \ + JERRY_ASSERT ((OPCODE_COUNTER ()) \ + == calc_opcode_counter_from_idx_idx (STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1))); \ + OPCODE()=getop_try (STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); \ + serializer_rewrite_opcode ((OC), OPCODE()); \ + STACK_DROP (IDX, 2); \ + STACK_CHECK_USAGE (IDX); \ +} while (0) static void integer_zero (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_SMALLINT, 0); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_SMALLINT, 0); - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } static void boolean_true (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_SIMPLE, ECMA_SIMPLE_VALUE_TRUE); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_SIMPLE, ECMA_SIMPLE_VALUE_TRUE); - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } static void @@ -468,8 +590,8 @@ add_to_rewritable_opcodes (rewritable_opcode_type type, opcode_counter_t oc) { switch (type) { - case REWRITABLE_BREAK: PUSH (rewritable_break, oc); break; - case REWRITABLE_CONTINUE: PUSH (rewritable_continue, oc); break; + case REWRITABLE_BREAK: STACK_PUSH (rewritable_break, oc); break; + case REWRITABLE_CONTINUE: STACK_PUSH (rewritable_continue, oc); break; default: JERRY_UNREACHABLE (); } } @@ -477,49 +599,61 @@ add_to_rewritable_opcodes (rewritable_opcode_type type, opcode_counter_t oc) static void rewrite_rewritable_opcodes (rewritable_opcode_type type, opcode_counter_t oc) { - DECLARE_USAGE (U8) + STACK_DECLARE_USAGE (U8) - PUSH (U8, 0) + STACK_PUSH (U8, 0); switch (type) { case REWRITABLE_BREAK: { - for (HEAD (U8, 1) = 0; HEAD (U8, 1) < STACK_SIZE (rewritable_break); HEAD (U8, 1)++) + for (STACK_HEAD (U8, 1) = 0; STACK_HEAD (U8, 1) < STACK_SIZE (rewritable_break); STACK_HEAD (U8, 1)++) { - REWRITE_JMP (rewritable_break.data[HEAD (U8, 1)], jmp_down, - oc - rewritable_break.data[HEAD (U8, 1)]); + REWRITE_JMP (STACK_ELEMENT (rewritable_break, STACK_HEAD (U8, 1)), jmp_down, + oc - STACK_ELEMENT (rewritable_break, STACK_HEAD (U8, 1))); } - CLEAN (rewritable_break); + STACK_CLEAN (rewritable_break); break; } case REWRITABLE_CONTINUE: { - for (HEAD (U8, 1) = 0; HEAD (U8, 1) < STACK_SIZE (rewritable_continue); HEAD (U8, 1)++) + for (STACK_HEAD (U8, 1) = 0; STACK_HEAD (U8, 1) < STACK_SIZE (rewritable_continue); STACK_HEAD (U8, 1)++) { - REWRITE_JMP (rewritable_continue.data[HEAD (U8, 1)], jmp_up, - rewritable_continue.data[HEAD (U8, 1)] - oc); + REWRITE_JMP (STACK_ELEMENT (rewritable_continue, STACK_HEAD (U8, 1)), jmp_up, + STACK_ELEMENT (rewritable_continue, STACK_HEAD (U8, 1)) - oc); } - CLEAN (rewritable_continue); + STACK_CLEAN (rewritable_continue); break; } default: JERRY_UNREACHABLE (); } - DROP (U8, 1) + STACK_DROP (U8, 1); - CHECK_USAGE (U8) + STACK_CHECK_USAGE (U8); } -static int8_t -intrinsic_argument_count (const char *intrinsic) +static void +dump_assert (idx_t arg) { - if (!__strcmp (intrinsic, "assert")) - { - return 1; - } + DUMP_OPCODE_3 (is_true_jmp_down, arg, 0, 2); + DUMP_OPCODE_1 (exitval, 1); +} - return -1; +static void +fill_intrinsics (void) +{ + lp_string str = (lp_string) + { + .length = 6, + .str = (const ecma_char_t *) "assert" + }; + intrinsic_dumper dumper = (intrinsic_dumper) + { + .args_count = 1, + .funs.fun1 = dump_assert + }; + HASH_INSERT (intrinsics, str, dumper); } static bool @@ -531,49 +665,42 @@ is_intrinsic (idx_t obj) // U8 strs bool result = false; - DECLARE_USAGE (U8) + STACK_DECLARE_USAGE (U8) - PUSH (U8, lexer_get_strings (NULL)); - if (obj < HEAD (U8, 1)) + STACK_PUSH (U8, lexer_get_strings_count ()); + if (obj < STACK_HEAD (U8, 1)) { - const char *string = lexer_get_string_by_id (obj); - result = intrinsic_argument_count (string) >= 0; + if (HASH_LOOKUP (intrinsics, lexer_get_string_by_id (obj)) != NULL) + { + result = true; + goto cleanup; + } } - DROP (U8, 1); +cleanup: + STACK_DROP (U8, 1); - CHECK_USAGE (U8) + STACK_CHECK_USAGE (U8); return result; } static void dump_intrinsic (idx_t obj, idx_t arg) { - // U8 strs - DECLARE_USAGE (U8) - - PUSH (U8, lexer_get_strings (NULL)); - if (obj < HEAD (U8, 1)) + if (obj < lexer_get_strings_count ()) { - const char *string = lexer_get_string_by_id (obj); - if (!__strcmp (string, "assert")) + intrinsic_dumper *dumper = HASH_LOOKUP (intrinsics, lexer_get_string_by_id (obj)); + + JERRY_ASSERT (dumper); + + switch (dumper->args_count) { - /* Dump opcodes like - is_true_jmp arg, +2 - exitval 1 - */ - DUMP_OPCODE_3 (is_true_jmp_down, arg, 0, 2); - DUMP_OPCODE_1 (exitval, 1); - goto cleanup; + case 1: dumper->funs.fun1 (arg); return; + default: JERRY_UNREACHABLE (); } } JERRY_UNREACHABLE (); - -cleanup: - DROP (U8, 1); - - CHECK_USAGE (U8) } /* property_name @@ -584,7 +711,7 @@ cleanup: static void parse_property_name (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) switch (TOK ().type) { @@ -592,13 +719,13 @@ parse_property_name (void) case TOK_STRING: case TOK_NUMBER: { - PUSH (IDX, token_data ()) + STACK_PUSH (IDX, token_data ()); break; } case TOK_SMALL_INT: { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_SMALLINT, token_data ()); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_SMALLINT, token_data ()); break; } default: @@ -607,7 +734,7 @@ parse_property_name (void) } } - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* property_name_and_value @@ -617,38 +744,38 @@ static void parse_property_name_and_value (void) { // IDX lhs, name, expr - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) - PUSH (IDX, next_temp_name ()) + STACK_PUSH (IDX, next_temp_name ()); parse_property_name (); // push name token_after_newlines_must_be (TOK_COLON); NEXT (assignment_expression); // push expr - DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG_PROP_DATA, HEAD(IDX, 1), HEAD(IDX, 2)); + DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG_PROP_DATA, STACK_HEAD(IDX, 1), STACK_HEAD(IDX, 2)); - DROP (IDX, 2); - CHECK_USAGE_LHS () + STACK_DROP (IDX, 2); + STACK_CHECK_USAGE_LHS (); } static void rewrite_meta_opcode_counter (opcode_counter_t meta_oc, opcode_meta_type type) { // IDX oc_idx_1, oc_idx_2 - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) JERRY_STATIC_ASSERT (sizeof (idx_t) == 1); - PUSH (IDX, (idx_t) (OPCODE_COUNTER () >> JERRY_BITSINBYTE)); - PUSH (IDX, (idx_t) (OPCODE_COUNTER () & ((1 << JERRY_BITSINBYTE) - 1))); + STACK_PUSH (IDX, (idx_t) (OPCODE_COUNTER () >> JERRY_BITSINBYTE)); + STACK_PUSH (IDX, (idx_t) (OPCODE_COUNTER () & ((1 << JERRY_BITSINBYTE) - 1))); - JERRY_ASSERT (OPCODE_COUNTER () == calc_opcode_counter_from_idx_idx (HEAD (IDX, 2), HEAD (IDX, 1))); + JERRY_ASSERT (OPCODE_COUNTER () == calc_opcode_counter_from_idx_idx (STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1))); - REWRITE_OPCODE_3 (meta_oc, meta, type, HEAD (IDX, 2), HEAD (IDX, 1)); + REWRITE_OPCODE_3 (meta_oc, meta, type, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); - DROP (IDX, 2); + STACK_DROP (IDX, 2); - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (IDX); } /* property_assignment @@ -659,12 +786,12 @@ rewrite_meta_opcode_counter (opcode_counter_t meta_oc, opcode_meta_type type) static void parse_property_assignment (void) { - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) current_token_must_be (TOK_NAME); - if (!__strcmp ("get", lexer_get_string_by_id (token_data ()))) + if (lp_string_equal_s (lexer_get_string_by_id (token_data ()), "get")) { // name, lhs NEXT (property_name); // push name @@ -672,7 +799,7 @@ parse_property_assignment (void) skip_newlines (); parse_argument_list (AL_FUNC_EXPR, next_temp_name ()); // push lhs - PUSH (U16, opcode_counter); + STACK_PUSH (U16, opcode_counter); DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_FUNCTION_END, INVALID_VALUE, INVALID_VALUE); token_after_newlines_must_be (TOK_OPEN_BRACE); @@ -681,14 +808,14 @@ parse_property_assignment (void) token_after_newlines_must_be (TOK_CLOSE_BRACE); DUMP_VOID_OPCODE (ret); - rewrite_meta_opcode_counter (HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); - DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG_PROP_GETTER, HEAD (IDX, 2), HEAD (IDX, 1)); + rewrite_meta_opcode_counter (STACK_HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); + DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG_PROP_GETTER, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); - HEAD (IDX, 2) = HEAD (IDX, 1); - DROP (IDX, 1); - DROP (U16, 1); + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); + STACK_DROP (IDX, 1); + STACK_DROP (U16, 1); } - else if (!__strcmp ("set", lexer_get_string_by_id (token_data ()))) + else if (lp_string_equal_s (lexer_get_string_by_id (token_data ()), "set")) { // name, lhs NEXT (property_name); // push name @@ -696,7 +823,7 @@ parse_property_assignment (void) skip_newlines (); parse_argument_list (AL_FUNC_EXPR, next_temp_name ()); // push lhs - PUSH (U16, opcode_counter); + STACK_PUSH (U16, opcode_counter); DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_FUNCTION_END, INVALID_VALUE, INVALID_VALUE); token_after_newlines_must_be (TOK_OPEN_BRACE); @@ -705,20 +832,20 @@ parse_property_assignment (void) token_after_newlines_must_be (TOK_CLOSE_BRACE); DUMP_VOID_OPCODE (ret); - rewrite_meta_opcode_counter (HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); - DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG_PROP_SETTER, HEAD (IDX, 2), HEAD (IDX, 1)); + rewrite_meta_opcode_counter (STACK_HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); + DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG_PROP_SETTER, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); - HEAD (IDX, 2) = HEAD (IDX, 1); - DROP (IDX, 1); - DROP (U16, 1); + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); + STACK_DROP (IDX, 1); + STACK_DROP (U16, 1); } else { parse_property_name_and_value (); } - CHECK_USAGE (U16) - CHECK_USAGE_LHS () + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE_LHS (); } /** Parse list of identifiers, assigment expressions or properties, splitted by comma. @@ -730,65 +857,65 @@ parse_argument_list (argument_list_type alt, idx_t obj) // U8 open_tt, close_tt, args_count // IDX lhs, current_arg // U16 oc - DECLARE_USAGE (U8) - DECLARE_USAGE (U16) - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U8) + STACK_DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (IDX) - PUSH (U16, OPCODE_COUNTER ()); + STACK_PUSH (U16, OPCODE_COUNTER ()); switch (alt) { case AL_FUNC_DECL: { - PUSH (U8, TOK_OPEN_PAREN); // Openning token - PUSH (U8, TOK_CLOSE_PAREN); // Ending token + STACK_PUSH (U8, TOK_OPEN_PAREN); // Openning token; + STACK_PUSH (U8, TOK_CLOSE_PAREN); // Ending token; DUMP_OPCODE_2 (func_decl_n, obj, INVALID_VALUE); break; } case AL_FUNC_EXPR: { - PUSH (U8, TOK_OPEN_PAREN); - PUSH (U8, TOK_CLOSE_PAREN); - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (func_expr_n, HEAD (IDX, 1), obj, INVALID_VALUE); + STACK_PUSH (U8, TOK_OPEN_PAREN); + STACK_PUSH (U8, TOK_CLOSE_PAREN); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (func_expr_n, STACK_HEAD (IDX, 1), obj, INVALID_VALUE); break; } case AL_CONSTRUCT_EXPR: { - PUSH (U8, TOK_OPEN_PAREN); - PUSH (U8, TOK_CLOSE_PAREN); - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (construct_n, HEAD (IDX, 1), obj, INVALID_VALUE); + STACK_PUSH (U8, TOK_OPEN_PAREN); + STACK_PUSH (U8, TOK_CLOSE_PAREN); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (construct_n, STACK_HEAD (IDX, 1), obj, INVALID_VALUE); break; } case AL_CALL_EXPR: { - PUSH (U8, TOK_OPEN_PAREN); - PUSH (U8, TOK_CLOSE_PAREN); + STACK_PUSH (U8, TOK_OPEN_PAREN); + STACK_PUSH (U8, TOK_CLOSE_PAREN); if (is_intrinsic (obj)) { break; } else { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (call_n, HEAD (IDX, 1), obj, INVALID_VALUE); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (call_n, STACK_HEAD (IDX, 1), obj, INVALID_VALUE); } break; } case AL_ARRAY_DECL: { - PUSH (U8, TOK_OPEN_SQUARE); - PUSH (U8, TOK_CLOSE_SQUARE); - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_2 (array_decl, HEAD (IDX, 1), INVALID_VALUE); + STACK_PUSH (U8, TOK_OPEN_SQUARE); + STACK_PUSH (U8, TOK_CLOSE_SQUARE); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_2 (array_decl, STACK_HEAD (IDX, 1), INVALID_VALUE); break; } case AL_OBJ_DECL: { - PUSH (U8, TOK_OPEN_BRACE); - PUSH (U8, TOK_CLOSE_BRACE); - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_2 (obj_decl, HEAD (IDX, 1), INVALID_VALUE); + STACK_PUSH (U8, TOK_OPEN_BRACE); + STACK_PUSH (U8, TOK_CLOSE_BRACE); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_2 (obj_decl, STACK_HEAD (IDX, 1), INVALID_VALUE); break; } default: @@ -797,19 +924,19 @@ parse_argument_list (argument_list_type alt, idx_t obj) } } - PUSH (U8, 0); + STACK_PUSH (U8, 0); - current_token_must_be (HEAD (U8, 3)); + current_token_must_be (STACK_HEAD (U8, 3)); skip_newlines (); - while (!token_is (HEAD (U8, 2))) + while (!token_is (STACK_HEAD (U8, 2))) { switch (alt) { case AL_FUNC_DECL: { current_token_must_be (TOK_NAME); - PUSH (IDX, token_data ()) + STACK_PUSH (IDX, token_data ()); break; } case AL_FUNC_EXPR: @@ -820,7 +947,7 @@ parse_argument_list (argument_list_type alt, idx_t obj) parse_assignment_expression (); if (is_intrinsic (obj)) { - dump_intrinsic (obj, HEAD (IDX, 1)); + dump_intrinsic (obj, STACK_HEAD (IDX, 1)); goto next; } break; @@ -836,16 +963,16 @@ parse_argument_list (argument_list_type alt, idx_t obj) } } - DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG, HEAD (IDX, 1), INVALID_VALUE); - HEAD(U8, 1)++; + DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_VARG, STACK_HEAD (IDX, 1), INVALID_VALUE); + STACK_HEAD(U8, 1)++; - DROP (IDX, 1); + STACK_DROP (IDX, 1); next: skip_newlines (); if (!token_is (TOK_COMMA)) { - current_token_must_be (HEAD (U8, 2)); + current_token_must_be (STACK_HEAD (U8, 2)); break; } @@ -856,17 +983,17 @@ next: { case AL_FUNC_DECL: { - REWRITE_OPCODE_2 (HEAD (U16, 1), func_decl_n, obj, HEAD (U8, 1)); + REWRITE_OPCODE_2 (STACK_HEAD (U16, 1), func_decl_n, obj, STACK_HEAD (U8, 1)); break; } case AL_FUNC_EXPR: { - REWRITE_OPCODE_3 (HEAD (U16, 1), func_expr_n, HEAD (IDX, 1), obj, HEAD (U8, 1)); + REWRITE_OPCODE_3 (STACK_HEAD (U16, 1), func_expr_n, STACK_HEAD (IDX, 1), obj, STACK_HEAD (U8, 1)); break; } case AL_CONSTRUCT_EXPR: { - REWRITE_OPCODE_3 (HEAD (U16, 1), construct_n, HEAD (IDX, 1), obj, HEAD (U8, 1)); + REWRITE_OPCODE_3 (STACK_HEAD (U16, 1), construct_n, STACK_HEAD (IDX, 1), obj, STACK_HEAD (U8, 1)); break; } case AL_CALL_EXPR: @@ -877,18 +1004,18 @@ next: } else { - REWRITE_OPCODE_3 (HEAD (U16, 1), call_n, HEAD (IDX, 1), obj, HEAD (U8, 1)); + REWRITE_OPCODE_3 (STACK_HEAD (U16, 1), call_n, STACK_HEAD (IDX, 1), obj, STACK_HEAD (U8, 1)); } break; } case AL_ARRAY_DECL: { - REWRITE_OPCODE_2 (HEAD (U16, 1), array_decl, HEAD (IDX, 1), HEAD (U8, 1)); + REWRITE_OPCODE_2 (STACK_HEAD (U16, 1), array_decl, STACK_HEAD (IDX, 1), STACK_HEAD (U8, 1)); break; } case AL_OBJ_DECL: { - REWRITE_OPCODE_2 (HEAD (U16, 1), obj_decl, HEAD (IDX, 1), HEAD (U8, 1)); + REWRITE_OPCODE_2 (STACK_HEAD (U16, 1), obj_decl, STACK_HEAD (IDX, 1), STACK_HEAD (U8, 1)); break; } default: @@ -897,20 +1024,20 @@ next: } } - DROP (U8, 3); - DROP (U16, 1); + STACK_DROP (U8, 3); + STACK_DROP (U16, 1); - CHECK_USAGE (U8) - CHECK_USAGE (U16) + STACK_CHECK_USAGE (U8); + STACK_CHECK_USAGE (U16); #ifndef JERRY_NDEBUG if (alt == AL_FUNC_DECL) { - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (IDX); } else { - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } #endif } @@ -927,20 +1054,20 @@ parse_function_declaration (void) { // IDX name // U16 meta_oc - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) - DECLARE_USAGE (nestings) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (nestings) assert_keyword (KW_FUNCTION); token_after_newlines_must_be (TOK_NAME); - PUSH (IDX, token_data ()); + STACK_PUSH (IDX, token_data ()); skip_newlines (); - parse_argument_list (AL_FUNC_DECL, HEAD (IDX, 1)); + parse_argument_list (AL_FUNC_DECL, STACK_HEAD (IDX, 1)); - PUSH (U16, OPCODE_COUNTER ()); + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_UNDEFINED, INVALID_VALUE, INVALID_VALUE); token_after_newlines_must_be (TOK_OPEN_BRACE); @@ -954,14 +1081,14 @@ parse_function_declaration (void) DUMP_VOID_OPCODE (ret); - rewrite_meta_opcode_counter (HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); + rewrite_meta_opcode_counter (STACK_HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); - DROP (U16, 1); - DROP (IDX, 1); + STACK_DROP (U16, 1); + STACK_DROP (IDX, 1); - CHECK_USAGE (IDX) - CHECK_USAGE (U16) - CHECK_USAGE (nestings) + STACK_CHECK_USAGE (IDX); + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE (nestings); } /* function_expression @@ -972,27 +1099,27 @@ parse_function_expression (void) { // IDX lhs, name // U16 meta_oc - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) - DECLARE_USAGE (nestings) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (nestings) assert_keyword (KW_FUNCTION); skip_newlines (); if (token_is (TOK_NAME)) { - PUSH (IDX, token_data ()); + STACK_PUSH (IDX, token_data ()); } else { lexer_save_token (TOK()); - PUSH (IDX, next_temp_name ()); + STACK_PUSH (IDX, next_temp_name ()); } skip_newlines (); - parse_argument_list (AL_FUNC_EXPR, HEAD (IDX, 1)); // push lhs + parse_argument_list (AL_FUNC_EXPR, STACK_HEAD (IDX, 1)); // push lhs - PUSH (U16, OPCODE_COUNTER ()); + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_UNDEFINED, INVALID_VALUE, INVALID_VALUE); token_after_newlines_must_be (TOK_OPEN_BRACE); @@ -1005,15 +1132,15 @@ parse_function_expression (void) token_after_newlines_must_be (TOK_CLOSE_BRACE); DUMP_VOID_OPCODE (ret); - rewrite_meta_opcode_counter (HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); + rewrite_meta_opcode_counter (STACK_HEAD (U16, 1), OPCODE_META_TYPE_FUNCTION_END); - HEAD (IDX, 2) = HEAD (IDX, 1); - DROP (IDX, 1); - DROP (U16, 1); + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); + STACK_DROP (IDX, 1); + STACK_DROP (U16, 1); - CHECK_USAGE (U16) - CHECK_USAGE_LHS () - CHECK_USAGE (nestings) + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE_LHS (); + STACK_CHECK_USAGE (nestings); } /* array_literal @@ -1022,11 +1149,11 @@ parse_function_expression (void) static void parse_array_literal (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_argument_list (AL_ARRAY_DECL, 0); - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* object_literal @@ -1035,50 +1162,50 @@ parse_array_literal (void) static void parse_object_literal (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_argument_list (AL_OBJ_DECL, 0); - CHECK_USAGE_LHS (); + STACK_CHECK_USAGE_LHS ();; } static void parse_literal (void) { // IDX lhs; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) switch (TOK ().type) { case TOK_NULL: { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_SIMPLE, ECMA_SIMPLE_VALUE_NULL); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_SIMPLE, ECMA_SIMPLE_VALUE_NULL); break; } case TOK_BOOL: { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_SIMPLE, + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_SIMPLE, token_data () ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE); break; } case TOK_NUMBER: { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_NUMBER, token_data ()); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_NUMBER, token_data ()); break; } case TOK_SMALL_INT: { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_SMALLINT, token_data ()); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_SMALLINT, token_data ()); break; } case TOK_STRING: { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 1), OPCODE_ARG_TYPE_STRING, token_data ()); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 1), OPCODE_ARG_TYPE_STRING, token_data ()); break; } default: @@ -1087,7 +1214,7 @@ parse_literal (void) } } - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* primary_expression @@ -1102,12 +1229,12 @@ static void parse_primary_expression (void) { // IDX lhs; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) if (is_keyword (KW_THIS)) { - PUSH (IDX, next_temp_name ()); - DUMP_OPCODE_1 (this, HEAD (IDX, 1)); + STACK_PUSH (IDX, next_temp_name ()); + DUMP_OPCODE_1 (this, STACK_HEAD (IDX, 1)); goto cleanup; } @@ -1115,7 +1242,7 @@ parse_primary_expression (void) { case TOK_NAME: { - PUSH (IDX, token_data ()); + STACK_PUSH (IDX, token_data ()); break; } case TOK_NULL: @@ -1155,7 +1282,7 @@ parse_primary_expression (void) } cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* member_expression @@ -1183,7 +1310,7 @@ static void parse_member_expression (void) { // IDX obj, lhs, prop; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) if (is_keyword (KW_FUNCTION)) { @@ -1193,10 +1320,10 @@ parse_member_expression (void) { NEXT (member_expression); // push member - parse_argument_list (AL_CONSTRUCT_EXPR, HEAD (IDX, 1)); // push obj + parse_argument_list (AL_CONSTRUCT_EXPR, STACK_HEAD (IDX, 1)); // push obj - HEAD (IDX, 2) = HEAD (IDX, 1); - DROP (IDX, 1) + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); + STACK_DROP (IDX, 1); } else { @@ -1206,7 +1333,7 @@ parse_member_expression (void) skip_newlines (); while (token_is (TOK_OPEN_SQUARE) || token_is (TOK_DOT)) { - PUSH (IDX, next_temp_name ()); + STACK_PUSH (IDX, next_temp_name ()); if (token_is (TOK_OPEN_SQUARE)) { @@ -1220,23 +1347,23 @@ parse_member_expression (void) { parser_fatal (ERR_PARSER); } - PUSH (IDX, token_data ()); + STACK_PUSH (IDX, token_data ()); } else { JERRY_UNREACHABLE (); } - DUMP_OPCODE_3 (prop_getter, HEAD (IDX, 2), HEAD (IDX, 3), HEAD (IDX, 1)); - HEAD (IDX, 3) = HEAD (IDX, 2); + DUMP_OPCODE_3 (prop_getter, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 3), STACK_HEAD (IDX, 1)); + STACK_HEAD (IDX, 3) = STACK_HEAD (IDX, 2); skip_newlines (); - DROP (IDX, 2) + STACK_DROP (IDX, 2); } lexer_save_token (TOK ()); - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* call_expression @@ -1256,7 +1383,7 @@ static void parse_call_expression (void) { // IDX obj, lhs, prop; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_member_expression (); @@ -1267,8 +1394,8 @@ parse_call_expression (void) goto cleanup; } - parse_argument_list (AL_CALL_EXPR, HEAD (IDX, 1)); // push lhs - HEAD (IDX, 2) = HEAD (IDX, 1); + parse_argument_list (AL_CALL_EXPR, STACK_HEAD (IDX, 1)); // push lhs + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); skip_newlines (); while (token_is (TOK_OPEN_PAREN) || token_is (TOK_OPEN_SQUARE) @@ -1278,8 +1405,8 @@ parse_call_expression (void) { case TOK_OPEN_PAREN: { - DROP (IDX, 1) - parse_argument_list (AL_CALL_EXPR, HEAD (IDX, 1)); // push lhs + STACK_DROP (IDX, 1); + parse_argument_list (AL_CALL_EXPR, STACK_HEAD (IDX, 1)); // push lhs skip_newlines (); break; } @@ -1288,20 +1415,20 @@ parse_call_expression (void) NEXT (expression); // push prop next_token_must_be (TOK_CLOSE_SQUARE); - DUMP_OPCODE_3 (prop_getter, HEAD (IDX, 2), HEAD (IDX, 3), HEAD (IDX, 1)); - DROP (IDX, 1) - HEAD (IDX, 2) = HEAD (IDX, 1); + DUMP_OPCODE_3 (prop_getter, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 3), STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); skip_newlines (); break; } case TOK_DOT: { token_after_newlines_must_be (TOK_NAME); - PUSH (IDX, token_data ()); + STACK_PUSH (IDX, token_data ()); - DUMP_OPCODE_3 (prop_getter, HEAD (IDX, 2), HEAD (IDX, 3), HEAD (IDX, 1)); - DROP (IDX, 1) - HEAD (IDX, 2) = HEAD (IDX, 1); + DUMP_OPCODE_3 (prop_getter, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 3), STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); skip_newlines (); break; } @@ -1313,10 +1440,10 @@ parse_call_expression (void) } lexer_save_token (TOK ()); - DROP (IDX, 1) + STACK_DROP (IDX, 1); cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* left_hand_side_expression @@ -1326,11 +1453,11 @@ cleanup: static void parse_left_hand_side_expression (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_call_expression (); - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* postfix_expression @@ -1340,25 +1467,25 @@ static void parse_postfix_expression (void) { // IDX expr, lhs - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_left_hand_side_expression (); // push expr skip_token (); if (token_is (TOK_DOUBLE_PLUS)) { - DUMP_OPCODE_2 (post_incr, next_temp_name (), HEAD (IDX, 1)); + DUMP_OPCODE_2 (post_incr, next_temp_name (), STACK_HEAD (IDX, 1)); } else if (token_is (TOK_DOUBLE_MINUS)) { - DUMP_OPCODE_2 (post_decr, next_temp_name (), HEAD (IDX, 1)); + DUMP_OPCODE_2 (post_decr, next_temp_name (), STACK_HEAD (IDX, 1)); } else { lexer_save_token (TOK ()); } - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* unary_expression @@ -1369,54 +1496,54 @@ static void parse_unary_expression (void) { // IDX expr, lhs; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) switch (TOK ().type) { case TOK_DOUBLE_PLUS: { NEXT (unary_expression); - DUMP_OPCODE_2 (pre_incr, next_temp_name (), HEAD (IDX, 1)); + DUMP_OPCODE_2 (pre_incr, next_temp_name (), STACK_HEAD (IDX, 1)); break; } case TOK_DOUBLE_MINUS: { NEXT (unary_expression); - DUMP_OPCODE_2 (pre_decr, next_temp_name (), HEAD (IDX, 1)); + DUMP_OPCODE_2 (pre_decr, next_temp_name (), STACK_HEAD (IDX, 1)); break; } case TOK_PLUS: { - PUSH (IDX, next_temp_name ()); + STACK_PUSH (IDX, next_temp_name ()); NEXT (unary_expression); integer_zero (); - DUMP_OPCODE_3 (addition, HEAD (IDX, 3), HEAD (IDX, 1), HEAD (IDX, 2)); - DROP (IDX, 2) + DUMP_OPCODE_3 (addition, STACK_HEAD (IDX, 3), STACK_HEAD (IDX, 1), STACK_HEAD (IDX, 2)); + STACK_DROP (IDX, 2); break; } case TOK_MINUS: { - PUSH (IDX, next_temp_name ()); + STACK_PUSH (IDX, next_temp_name ()); NEXT (unary_expression); integer_zero (); - DUMP_OPCODE_3 (substraction, HEAD (IDX, 3), HEAD (IDX, 1), HEAD (IDX, 2)); - DROP (IDX, 2) + DUMP_OPCODE_3 (substraction, STACK_HEAD (IDX, 3), STACK_HEAD (IDX, 1), STACK_HEAD (IDX, 2)); + STACK_DROP (IDX, 2); break; } case TOK_COMPL: { - PUSH (IDX, next_temp_name ()); + STACK_PUSH (IDX, next_temp_name ()); NEXT (unary_expression); - DUMP_OPCODE_2 (b_not, HEAD (IDX, 2), HEAD (IDX, 1)); - DROP (IDX, 1) + DUMP_OPCODE_2 (b_not, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); break; } case TOK_NOT: { - PUSH (IDX, next_temp_name ()); + STACK_PUSH (IDX, next_temp_name ()); NEXT (unary_expression); - DUMP_OPCODE_2 (logical_not, HEAD (IDX, 2), HEAD (IDX, 1)); - DROP (IDX, 1) + DUMP_OPCODE_2 (logical_not, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); break; } case TOK_KEYWORD: @@ -1435,10 +1562,10 @@ parse_unary_expression (void) } if (is_keyword (KW_TYPEOF)) { - PUSH (IDX, next_temp_name ()); + STACK_PUSH (IDX, next_temp_name ()); NEXT (unary_expression); - DUMP_OPCODE_2 (typeof, HEAD (IDX, 2), HEAD (IDX, 1)); - DROP (IDX, 1) + DUMP_OPCODE_2 (typeof, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); break; } /* FALLTHRU. */ @@ -1449,15 +1576,17 @@ parse_unary_expression (void) } } - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } #define DUMP_OF(GETOP, EXPR) \ - PUSH (IDX, next_temp_name ()); \ - NEXT (EXPR);\ - DUMP_OPCODE_3 (GETOP, HEAD (IDX, 2), HEAD (IDX, 3), HEAD (IDX, 1)); \ - HEAD (IDX, 3) = HEAD (IDX, 2); \ - DROP (IDX, 2) +do { \ + STACK_PUSH (IDX, next_temp_name ()); \ + NEXT (EXPR);\ + DUMP_OPCODE_3 (GETOP, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 3), STACK_HEAD (IDX, 1)); \ + STACK_HEAD (IDX, 3) = STACK_HEAD (IDX, 2); \ + STACK_DROP (IDX, 2); \ +} while (0) /* multiplicative_expression : unary_expression (LT!* ('*' | '/' | '%') LT!* unary_expression)* @@ -1466,7 +1595,7 @@ static void parse_multiplicative_expression (void) { // IDX expr1, lhs, expr2; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_unary_expression (); @@ -1485,7 +1614,7 @@ parse_multiplicative_expression (void) } cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* additive_expression @@ -1495,7 +1624,7 @@ static void parse_additive_expression (void) { // IDX expr1, lhs, expr2; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_multiplicative_expression (); @@ -1513,7 +1642,7 @@ parse_additive_expression (void) } cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* shift_expression @@ -1523,7 +1652,7 @@ static void parse_shift_expression (void) { // IDX expr1, lhs, expr2; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_additive_expression (); @@ -1542,7 +1671,7 @@ parse_shift_expression (void) } cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* relational_expression @@ -1552,7 +1681,7 @@ static void parse_relational_expression (void) { // IDX expr1, lhs, expr2; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_shift_expression (); @@ -1590,7 +1719,7 @@ parse_relational_expression (void) } cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* equality_expression @@ -1600,7 +1729,7 @@ static void parse_equality_expression (void) { // IDX expr1, lhs, expr2; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_relational_expression (); @@ -1624,12 +1753,12 @@ parse_equality_expression (void) } cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } #define PARSE_OF(FUNC, EXPR, TOK_TYPE, GETOP) \ static void parse_##FUNC (void) { \ - DECLARE_USAGE (IDX) \ + STACK_DECLARE_USAGE (IDX) \ parse_##EXPR (); \ skip_newlines (); \ while (true) \ @@ -1642,7 +1771,7 @@ static void parse_##FUNC (void) { \ skip_newlines (); \ } \ cleanup: \ - CHECK_USAGE_LHS () \ + STACK_CHECK_USAGE_LHS () \ } /* bitwise_and_expression @@ -1677,43 +1806,43 @@ static void parse_conditional_expression (bool *was_conditional) { // IDX expr, res, lhs - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) parse_logical_or_expression (); skip_newlines (); if (token_is (TOK_QUERY)) { - DUMP_OPCODE_3 (is_true_jmp_down, HEAD (IDX, 1), 0, 2); - PUSH (IDX, next_temp_name ()) - PUSH (U16, OPCODE_COUNTER ()) + DUMP_OPCODE_3 (is_true_jmp_down, STACK_HEAD (IDX, 1), 0, 2); + STACK_PUSH (IDX, next_temp_name ()); + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_2 (jmp_down, INVALID_VALUE, INVALID_VALUE); NEXT (assignment_expression); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, HEAD (IDX, 1)); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, STACK_HEAD (IDX, 1)); token_after_newlines_must_be (TOK_COLON); - REWRITE_JMP (HEAD (U16, 1), jmp_down, OPCODE_COUNTER () - HEAD (U16, 1)); - HEAD (U16, 1) = OPCODE_COUNTER (); + REWRITE_JMP (STACK_HEAD (U16, 1), jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 1)); + STACK_HEAD (U16, 1) = OPCODE_COUNTER (); DUMP_OPCODE_2 (jmp_down, INVALID_VALUE, INVALID_VALUE); - DROP (IDX, 1) + STACK_DROP (IDX, 1); NEXT (assignment_expression); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, HEAD (IDX, 1)); - REWRITE_JMP (HEAD (U16, 1), jmp_down, OPCODE_COUNTER () - HEAD (U16, 1)); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, STACK_HEAD (IDX, 1)); + REWRITE_JMP (STACK_HEAD (U16, 1), jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 1)); *was_conditional = true; - HEAD (IDX, 3) = HEAD (IDX, 2); - DROP (IDX, 2) + STACK_HEAD (IDX, 3) = STACK_HEAD (IDX, 2); + STACK_DROP (IDX, 2); } else { lexer_save_token (TOK ()); } - CHECK_USAGE (U16) - CHECK_USAGE_LHS () + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE_LHS (); } /* assignment_expression @@ -1724,7 +1853,7 @@ static void parse_assignment_expression (void) { // IDX lhs, rhs; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) bool was_conditional = false; parse_conditional_expression (&was_conditional); @@ -1739,73 +1868,73 @@ parse_assignment_expression (void) case TOK_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, HEAD (IDX, 1)); + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, STACK_HEAD (IDX, 1)); break; } case TOK_MULT_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (multiplication, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (multiplication, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_DIV_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (division, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (division, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_MOD_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (remainder, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (remainder, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_PLUS_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (addition, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (addition, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_MINUS_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (substraction, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (substraction, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_LSHIFT_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (b_shift_left, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (b_shift_left, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_RSHIFT_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (b_shift_right, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (b_shift_right, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_RSHIFT_EX_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (b_shift_uright, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (b_shift_uright, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_AND_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (b_and, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (b_and, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_XOR_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (b_xor, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (b_xor, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } case TOK_OR_EQ: { NEXT (assignment_expression); - DUMP_OPCODE_3 (b_or, HEAD (IDX, 2), HEAD (IDX, 2), HEAD (IDX, 1)); + DUMP_OPCODE_3 (b_or, STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 2), STACK_HEAD (IDX, 1)); break; } default: @@ -1815,10 +1944,10 @@ parse_assignment_expression (void) } } - DROP (IDX, 1) + STACK_DROP (IDX, 1); cleanup: - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* expression @@ -1829,7 +1958,7 @@ static void parse_expression (void) { // IDX expr - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) parse_assignment_expression (); @@ -1839,8 +1968,8 @@ parse_expression (void) if (token_is (TOK_COMMA)) { NEXT (assignment_expression); - HEAD (IDX, 2) = HEAD (IDX, 1); - DROP (IDX, 1) + STACK_HEAD (IDX, 2) = STACK_HEAD (IDX, 1); + STACK_DROP (IDX, 1); } else { @@ -1849,7 +1978,7 @@ parse_expression (void) } } - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* variable_declaration @@ -1863,27 +1992,27 @@ parse_variable_declaration (void) { //IDX name, expr; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) current_token_must_be (TOK_NAME); - PUSH (IDX, token_data ()); - DUMP_OPCODE_1 (var_decl, HEAD (IDX, 1)); + STACK_PUSH (IDX, token_data ()); + DUMP_OPCODE_1 (var_decl, STACK_HEAD (IDX, 1)); skip_newlines (); if (token_is (TOK_EQ)) { NEXT (assignment_expression); - DUMP_OPCODE_3 (assignment, HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, HEAD (IDX, 1)); - DROP (IDX, 1) + DUMP_OPCODE_3 (assignment, STACK_HEAD (IDX, 2), OPCODE_ARG_TYPE_VARIABLE, STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); } else { lexer_save_token (TOK ()); } - DROP (IDX, 1) + STACK_DROP (IDX, 1); - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (IDX); } /* variable_declaration_list @@ -1893,7 +2022,7 @@ parse_variable_declaration (void) static void parse_variable_declaration_list (bool *several_decls) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) while (true) { @@ -1913,7 +2042,7 @@ parse_variable_declaration_list (bool *several_decls) } } - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (IDX); } /* for_statement @@ -1941,9 +2070,9 @@ parse_for_or_for_in_statement (void) { // IDX stop; // U16 cond_oc, body_oc, step_oc, end_oc; - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) - DECLARE_USAGE (nestings) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (nestings) assert_keyword (KW_FOR); token_after_newlines_must_be (TOK_OPEN_PAREN); @@ -1985,7 +2114,7 @@ parse_for_or_for_in_statement (void) /* expression contains left_hand_side_expression. */ parse_expression (); - DROP (IDX, 1) + STACK_DROP (IDX, 1); skip_newlines (); if (token_is (TOK_SEMICOLON)) @@ -2031,7 +2160,7 @@ plain_for: 21 jmp_up 5; // step_oc; 22 ... */ - PUSH (U16, OPCODE_COUNTER ()) // cond_oc + STACK_PUSH (U16, OPCODE_COUNTER ()); // cond_oc; skip_newlines (); if (!token_is (TOK_SEMICOLON)) { @@ -2043,36 +2172,36 @@ plain_for: boolean_true (); } - PUSH (U16, OPCODE_COUNTER ()) // end_oc + STACK_PUSH (U16, OPCODE_COUNTER ()); // end_oc; DUMP_OPCODE_3 (is_false_jmp_down, INVALID_VALUE, INVALID_VALUE, INVALID_VALUE); - PUSH (U16, OPCODE_COUNTER ()) // body_oc + STACK_PUSH (U16, OPCODE_COUNTER ()); // body_oc; DUMP_OPCODE_2 (jmp_down, INVALID_VALUE, INVALID_VALUE); - PUSH (U16, OPCODE_COUNTER ()) // step_oc + STACK_PUSH (U16, OPCODE_COUNTER ()); // step_oc; skip_newlines (); if (!token_is (TOK_CLOSE_PAREN)) { parse_assignment_expression (); - DROP (IDX, 1) + STACK_DROP (IDX, 1); next_token_must_be (TOK_CLOSE_PAREN); } - DUMP_OPCODE_2 (jmp_up, 0, OPCODE_COUNTER () - HEAD (U16, 4)); - REWRITE_JMP (HEAD (U16, 2), jmp_down, OPCODE_COUNTER () - HEAD (U16, 2)); + DUMP_OPCODE_2 (jmp_up, 0, OPCODE_COUNTER () - STACK_HEAD (U16, 4)); + REWRITE_JMP (STACK_HEAD (U16, 2), jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 2)); skip_newlines (); push_nesting (NESTING_ITERATIONAL); parse_statement (); pop_nesting (NESTING_ITERATIONAL); - DUMP_OPCODE_2 (jmp_up, 0, OPCODE_COUNTER () - HEAD (U16, 1)); - REWRITE_COND_JMP (HEAD (U16, 3), is_false_jmp_down, OPCODE_COUNTER () - HEAD (U16, 3)); + DUMP_OPCODE_2 (jmp_up, 0, OPCODE_COUNTER () - STACK_HEAD (U16, 1)); + REWRITE_COND_JMP (STACK_HEAD (U16, 3), is_false_jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 3)); - rewrite_rewritable_opcodes (REWRITABLE_CONTINUE, HEAD (U16, 1)); + rewrite_rewritable_opcodes (REWRITABLE_CONTINUE, STACK_HEAD (U16, 1)); rewrite_rewritable_opcodes (REWRITABLE_BREAK, OPCODE_COUNTER ()); - DROP (IDX, 1) - DROP (U16, 4) + STACK_DROP (IDX, 1); + STACK_DROP (U16, 4); goto cleanup; @@ -2080,22 +2209,22 @@ for_in: JERRY_UNIMPLEMENTED (); cleanup: - CHECK_USAGE (IDX) - CHECK_USAGE (U16) - CHECK_USAGE (nestings) + STACK_CHECK_USAGE (IDX); + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE (nestings); } static void parse_expression_inside_parens (void) { // IDX expr; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) token_after_newlines_must_be (TOK_OPEN_PAREN); NEXT (expression); token_after_newlines_must_be (TOK_CLOSE_PAREN); - CHECK_USAGE_LHS () + STACK_CHECK_USAGE_LHS (); } /* statement_list @@ -2104,7 +2233,7 @@ parse_expression_inside_parens (void) static void parse_statement_list (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) while (true) { @@ -2122,7 +2251,7 @@ parse_statement_list (void) } } - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (IDX); } /* if_statement @@ -2133,13 +2262,13 @@ parse_if_statement (void) { // IDX cond; // U16 cond_oc; - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) assert_keyword (KW_IF); parse_expression_inside_parens (); - PUSH (U16, OPCODE_COUNTER ()) + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_3 (is_false_jmp_down, INVALID_VALUE, INVALID_VALUE, INVALID_VALUE); skip_newlines (); @@ -2148,29 +2277,29 @@ parse_if_statement (void) skip_newlines (); if (is_keyword (KW_ELSE)) { - PUSH (U16, OPCODE_COUNTER ()); + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_2 (jmp_down, INVALID_VALUE, INVALID_VALUE); - REWRITE_COND_JMP (HEAD (U16, 2), is_false_jmp_down, OPCODE_COUNTER () - HEAD (U16, 2)); + REWRITE_COND_JMP (STACK_HEAD (U16, 2), is_false_jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 2)); skip_newlines (); parse_statement (); - REWRITE_JMP (HEAD (U16, 1), jmp_down, OPCODE_COUNTER () - HEAD (U16, 1)); + REWRITE_JMP (STACK_HEAD (U16, 1), jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 1)); - DROP (U16, 1); + STACK_DROP (U16, 1); } else { - REWRITE_COND_JMP (HEAD (U16, 1), is_false_jmp_down, OPCODE_COUNTER () - HEAD (U16, 1)); + REWRITE_COND_JMP (STACK_HEAD (U16, 1), is_false_jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 1)); lexer_save_token (TOK ()); } - DROP (U16, 1) - DROP (IDX, 1) + STACK_DROP (U16, 1); + STACK_DROP (IDX, 1); - CHECK_USAGE (U16) - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE (IDX); } /* do_while_statement @@ -2181,13 +2310,13 @@ parse_do_while_statement (void) { // IDX cond; // U16 loop_oc; - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) - DECLARE_USAGE (nestings) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (nestings) assert_keyword (KW_DO); - PUSH (U16, OPCODE_COUNTER ()) + STACK_PUSH (U16, OPCODE_COUNTER ()); skip_newlines (); push_nesting (NESTING_ITERATIONAL); @@ -2196,19 +2325,19 @@ parse_do_while_statement (void) token_after_newlines_must_be_keyword (KW_WHILE); parse_expression_inside_parens (); - PUSH (U16, OPCODE_COUNTER ()) + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_3 (is_true_jmp_up, INVALID_VALUE, INVALID_VALUE, INVALID_VALUE); - REWRITE_COND_JMP (HEAD(U16, 1), is_true_jmp_up, OPCODE_COUNTER () - HEAD (U16, 2)); + REWRITE_COND_JMP (STACK_HEAD(U16, 1), is_true_jmp_up, OPCODE_COUNTER () - STACK_HEAD (U16, 2)); - rewrite_rewritable_opcodes (REWRITABLE_CONTINUE, HEAD (U16, 2)); + rewrite_rewritable_opcodes (REWRITABLE_CONTINUE, STACK_HEAD (U16, 2)); rewrite_rewritable_opcodes (REWRITABLE_BREAK, OPCODE_COUNTER ()); - DROP (IDX, 1) - DROP (U16, 2) + STACK_DROP (IDX, 1); + STACK_DROP (U16, 2); - CHECK_USAGE (U16) - CHECK_USAGE (IDX) - CHECK_USAGE (nestings) + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE (IDX); + STACK_CHECK_USAGE (nestings); } /* while_statement @@ -2219,15 +2348,15 @@ parse_while_statement (void) { // IDX cond; // U16 cond_oc, jmp_oc; - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) - DECLARE_USAGE (nestings) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (nestings) assert_keyword (KW_WHILE); - PUSH (U16, OPCODE_COUNTER ()) // cond_oc + STACK_PUSH (U16, OPCODE_COUNTER ()); // cond_oc; parse_expression_inside_parens (); - PUSH (U16, OPCODE_COUNTER ()) // jmp_oc + STACK_PUSH (U16, OPCODE_COUNTER ()); // jmp_oc; DUMP_OPCODE_3 (is_false_jmp_down, INVALID_VALUE, INVALID_VALUE, INVALID_VALUE); skip_newlines (); @@ -2235,20 +2364,20 @@ parse_while_statement (void) parse_statement (); pop_nesting (NESTING_ITERATIONAL); - PUSH (U16, OPCODE_COUNTER ()) + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_2 (jmp_up, INVALID_VALUE, INVALID_VALUE); - REWRITE_JMP (HEAD (U16, 1), jmp_up, OPCODE_COUNTER () - HEAD (U16, 3)); - REWRITE_COND_JMP (HEAD (U16, 2), is_false_jmp_down, OPCODE_COUNTER () - HEAD (U16, 2)); + REWRITE_JMP (STACK_HEAD (U16, 1), jmp_up, OPCODE_COUNTER () - STACK_HEAD (U16, 3)); + REWRITE_COND_JMP (STACK_HEAD (U16, 2), is_false_jmp_down, OPCODE_COUNTER () - STACK_HEAD (U16, 2)); - rewrite_rewritable_opcodes (REWRITABLE_CONTINUE, HEAD (U16, 3)); + rewrite_rewritable_opcodes (REWRITABLE_CONTINUE, STACK_HEAD (U16, 3)); rewrite_rewritable_opcodes (REWRITABLE_BREAK, OPCODE_COUNTER ()); - DROP (IDX, 1) - DROP (U16, 3) + STACK_DROP (IDX, 1); + STACK_DROP (U16, 3); - CHECK_USAGE (U16) - CHECK_USAGE (IDX) - CHECK_USAGE (nestings) + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE (IDX); + STACK_CHECK_USAGE (nestings); } /* with_statement @@ -2258,21 +2387,21 @@ static void parse_with_statement (void) { // IDX expr; - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) assert_keyword (KW_WITH); parse_expression_inside_parens (); - DUMP_OPCODE_1 (with, HEAD (IDX, 1)); + DUMP_OPCODE_1 (with, STACK_HEAD (IDX, 1)); skip_newlines (); parse_statement (); DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_END_WITH, INVALID_VALUE, INVALID_VALUE); - DROP (IDX, 1) + STACK_DROP (IDX, 1); - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (IDX); } /* case_block @@ -2302,32 +2431,32 @@ parse_catch_clause (void) { // IDX ex_name; // U16 catch_oc; - DECLARE_USAGE (IDX) - DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (U16) assert_keyword (KW_CATCH); token_after_newlines_must_be (TOK_OPEN_PAREN); token_after_newlines_must_be (TOK_NAME); - PUSH (IDX, token_data ()); + STACK_PUSH (IDX, token_data ()); token_after_newlines_must_be (TOK_CLOSE_PAREN); - PUSH (U16, OPCODE_COUNTER ()); + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_CATCH, INVALID_VALUE, INVALID_VALUE); - DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER, HEAD (IDX, 1), INVALID_VALUE); + DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER, STACK_HEAD (IDX, 1), INVALID_VALUE); token_after_newlines_must_be (TOK_OPEN_BRACE); skip_newlines (); parse_statement_list (); next_token_must_be (TOK_CLOSE_BRACE); - rewrite_meta_opcode_counter (HEAD (U16, 1), OPCODE_META_TYPE_CATCH); + rewrite_meta_opcode_counter (STACK_HEAD (U16, 1), OPCODE_META_TYPE_CATCH); - DROP (U16, 1); - DROP (IDX, 1); + STACK_DROP (U16, 1); + STACK_DROP (IDX, 1); - CHECK_USAGE (IDX) - CHECK_USAGE (U16) + STACK_CHECK_USAGE (IDX); + STACK_CHECK_USAGE (U16); } /* finally_clause @@ -2337,11 +2466,11 @@ static void parse_finally_clause (void) { // U16 finally_oc; - DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (U16) assert_keyword (KW_FINALLY); - PUSH (U16, OPCODE_COUNTER ()); + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_FINALLY, INVALID_VALUE, INVALID_VALUE); token_after_newlines_must_be (TOK_OPEN_BRACE); @@ -2349,11 +2478,11 @@ parse_finally_clause (void) parse_statement_list (); next_token_must_be (TOK_CLOSE_BRACE); - rewrite_meta_opcode_counter (HEAD (U16, 1), OPCODE_META_TYPE_FINALLY); + rewrite_meta_opcode_counter (STACK_HEAD (U16, 1), OPCODE_META_TYPE_FINALLY); - DROP (U16, 1) + STACK_DROP (U16, 1); - CHECK_USAGE (U16) + STACK_CHECK_USAGE (U16); } /* try_statement @@ -2363,11 +2492,11 @@ static void parse_try_statement (void) { // U16 try_oc; - DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (U16) assert_keyword (KW_TRY); - PUSH (U16, OPCODE_COUNTER ()) + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_2 (try, INVALID_VALUE, INVALID_VALUE); token_after_newlines_must_be (TOK_OPEN_BRACE); @@ -2375,7 +2504,7 @@ parse_try_statement (void) parse_statement_list (); next_token_must_be (TOK_CLOSE_BRACE); - REWRITE_TRY (HEAD (U16, 1)); + REWRITE_TRY (STACK_HEAD (U16, 1)); token_after_newlines_must_be (TOK_KEYWORD); if (is_keyword (KW_CATCH)) @@ -2403,9 +2532,9 @@ parse_try_statement (void) DUMP_OPCODE_3 (meta, OPCODE_META_TYPE_END_TRY_CATCH_FINALLY, INVALID_VALUE, INVALID_VALUE); - DROP (U16, 1) + STACK_DROP (U16, 1); - CHECK_USAGE (U16) + STACK_CHECK_USAGE (U16); } static void @@ -2483,8 +2612,8 @@ parse_statement (void) { reset_temp_name (); - DECLARE_USAGE (IDX) - DECLARE_USAGE (toks) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (toks) if (token_is (TOK_CLOSE_BRACE)) { @@ -2558,8 +2687,8 @@ parse_statement (void) if (!token_is (TOK_SEMICOLON) && !token_is (TOK_NEWLINE)) { parse_expression (); - DUMP_OPCODE_1 (retval, HEAD (IDX, 1)); - DROP (IDX, 1) + DUMP_OPCODE_1 (retval, STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); insert_semicolon (); goto cleanup; } @@ -2585,8 +2714,8 @@ parse_statement (void) parse_expression (); insert_semicolon (); - DUMP_OPCODE_1 (throw, HEAD (IDX, 1)); - DROP (IDX, 1); + DUMP_OPCODE_1 (throw, STACK_HEAD (IDX, 1)); + STACK_DROP (IDX, 1); goto cleanup; } if (is_keyword (KW_TRY)) @@ -2596,7 +2725,7 @@ parse_statement (void) } if (token_is (TOK_NAME)) { - PUSH (toks, TOK ()) + STACK_PUSH (toks, TOK ()); skip_newlines (); if (token_is (TOK_COLON)) { @@ -2606,22 +2735,22 @@ parse_statement (void) else { lexer_save_token (TOK ()); - POP (TOK(), toks) + STACK_POP (toks, TOK()); parse_expression (); - DROP (IDX, 1) + STACK_DROP (IDX, 1); goto cleanup; } } else { parse_expression (); - DROP (IDX, 1) + STACK_DROP (IDX, 1); goto cleanup; } cleanup: - CHECK_USAGE (IDX) - CHECK_USAGE (toks) + STACK_CHECK_USAGE (IDX); + STACK_CHECK_USAGE (toks); } /* source_element @@ -2631,7 +2760,7 @@ cleanup: static void parse_source_element (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) if (is_keyword (KW_FUNCTION)) { @@ -2642,7 +2771,7 @@ parse_source_element (void) parse_statement (); } - CHECK_USAGE (IDX) + STACK_CHECK_USAGE (IDX); } /* source_element_list @@ -2652,12 +2781,12 @@ static void parse_source_element_list (void) { // U16 reg_var_decl_loc; - DECLARE_USAGE (U16) - DECLARE_USAGE (IDX) - DECLARE_USAGE (temp_names) + STACK_DECLARE_USAGE (U16) + STACK_DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (temp_names) start_new_scope (); - PUSH (U16, OPCODE_COUNTER ()) + STACK_PUSH (U16, OPCODE_COUNTER ()); DUMP_OPCODE_2 (reg_var_decl, MIN_TEMP_NAME (), INVALID_VALUE); while (!token_is (TOK_EOF) && !token_is (TOK_CLOSE_BRACE)) @@ -2668,11 +2797,11 @@ parse_source_element_list (void) lexer_save_token (TOK ()); if (MAX_TEMP_NAME () > MIN_TEMP_NAME ()) { - REWRITE_OPCODE_2 (HEAD (U16, 1), reg_var_decl, MIN_TEMP_NAME (), MAX_TEMP_NAME () - 1); + REWRITE_OPCODE_2 (STACK_HEAD (U16, 1), reg_var_decl, MIN_TEMP_NAME (), MAX_TEMP_NAME () - 1); } else if (MAX_TEMP_NAME () == MIN_TEMP_NAME ()) { - REWRITE_OPCODE_2 (HEAD (U16, 1), reg_var_decl, MIN_TEMP_NAME (), MAX_TEMP_NAME ()); + REWRITE_OPCODE_2 (STACK_HEAD (U16, 1), reg_var_decl, MIN_TEMP_NAME (), MAX_TEMP_NAME ()); } else { @@ -2680,11 +2809,11 @@ parse_source_element_list (void) } finish_scope (); - DROP (U16, 1) + STACK_DROP (U16, 1); - CHECK_USAGE (U16) - CHECK_USAGE (IDX) - CHECK_USAGE (temp_names) + STACK_CHECK_USAGE (U16); + STACK_CHECK_USAGE (IDX); + STACK_CHECK_USAGE (temp_names); } /* program @@ -2693,7 +2822,7 @@ parse_source_element_list (void) void parser_parse_program (void) { - DECLARE_USAGE (IDX) + STACK_DECLARE_USAGE (IDX) skip_newlines (); parse_source_element_list (); @@ -2702,21 +2831,37 @@ parser_parse_program (void) JERRY_ASSERT (token_is (TOK_EOF)); DUMP_OPCODE_1 (exitval, 0); - CHECK_USAGE (IDX) + serializer_adjust_strings (); + + STACK_CHECK_USAGE (IDX); } void -parser_init (void) +parser_init (const char *source, size_t source_size, bool show_opcodes) { - INIT_STACK(uint8_t, U8); - INIT_STACK(uint8_t, IDX); - INIT_STACK(uint8_t, nestings); - INIT_STACK(uint8_t, temp_names); - INIT_STACK(token, toks); - INIT_STACK(opcode_t, ops); - INIT_STACK(uint16_t, U16); - INIT_STACK(opcode_counter_t, rewritable_continue); - INIT_STACK(opcode_counter_t, rewritable_break); + lexer_init (source, source_size, show_opcodes); + serializer_init (show_opcodes); + + lexer_run_first_pass (); + + lexer_adjust_num_ids (); + + serializer_dump_strings_and_nums (lexer_get_strings (), lexer_get_strings_count (), + lexer_get_nums (), lexer_get_nums_count ()); + + STACK_INIT (uint8_t, U8); + STACK_INIT (uint8_t, IDX); + STACK_INIT (uint8_t, nestings); + STACK_INIT (uint8_t, temp_names); + STACK_INIT (token, toks); + STACK_INIT (opcode_t, ops); + STACK_INIT (uint16_t, U16); + STACK_INIT (opcode_counter_t, rewritable_continue); + STACK_INIT (opcode_counter_t, rewritable_break); + + HASH_INIT (intrinsics, 1); + + fill_intrinsics (); MAX_TEMP_NAME () = TEMP_NAME () = MIN_TEMP_NAME () = lexer_get_reserved_ids_count (); OPCODE_COUNTER () = 0; @@ -2725,15 +2870,20 @@ parser_init (void) void parser_free (void) { - FREE_STACK(U8); - FREE_STACK(IDX); - FREE_STACK(nestings); - FREE_STACK(temp_names); - FREE_STACK(toks); - FREE_STACK(ops); - FREE_STACK(U16); - FREE_STACK(rewritable_continue); - FREE_STACK(rewritable_break); + STACK_FREE (U8); + STACK_FREE (IDX); + STACK_FREE (nestings); + STACK_FREE (temp_names); + STACK_FREE (toks); + STACK_FREE (ops); + STACK_FREE (U16); + STACK_FREE (rewritable_continue); + STACK_FREE (rewritable_break); + + HASH_FREE (intrinsics); + + serializer_free (); + lexer_free (); } void diff --git a/src/libjsparser/parser.h b/src/libjsparser/parser.h index 7f36c864e..80f8bcb7d 100644 --- a/src/libjsparser/parser.h +++ b/src/libjsparser/parser.h @@ -18,7 +18,7 @@ #include "globals.h" -void parser_init (void); +void parser_init (const char *, size_t, bool); void parser_parse_program (void); void parser_free (void); diff --git a/src/liboptimizer/bytecode-data.h b/src/liboptimizer/bytecode-data.h index 26c74d4b5..c87cfb3d0 100644 --- a/src/liboptimizer/bytecode-data.h +++ b/src/liboptimizer/bytecode-data.h @@ -19,11 +19,7 @@ #include "opcodes.h" #include "stack.h" #include "jerry-libc.h" - -#ifndef OPCODE_T_STACK_DEFINED -DEFINE_STACK_TYPE (opcode_counter_t, opcode_t) -#define OPCODE_T_STACK_DEFINED -#endif +#include "lp-string.h" /* bytecode_data contains identifiers, string and num literals. Memory map if the following. @@ -36,12 +32,21 @@ DEFINE_STACK_TYPE (opcode_counter_t, opcode_t) U8 nums_count; U32 nums[nums_count]; } */ -extern uint8_t *bytecode_data; +struct +{ + uint8_t strs_count; + uint8_t nums_count; + + const lp_string *strings; + const ecma_number_t *nums; +} +__packed +bytecode_data; enum { bytecode_opcodes_global_size }; -STACK (opcode_t, bytecode_opcodes) +STACK (bytecode_opcodes, opcode_counter_t, opcode_t) #endif // BYTECODE_DATA_H diff --git a/src/liboptimizer/deserializer.c b/src/liboptimizer/deserializer.c index 79681405c..3b5ef80d7 100644 --- a/src/liboptimizer/deserializer.c +++ b/src/liboptimizer/deserializer.c @@ -16,70 +16,34 @@ #include "deserializer.h" #include "bytecode-data.h" -ecma_number_t *num_data = NULL; -uint8_t num_size = 0; - const ecma_char_t * deserialize_string_by_id (uint8_t id) { - uint8_t size, *data; - uint16_t offset; + JERRY_ASSERT (bytecode_data.strings[id].str[bytecode_data.strings[id].length] == '\0'); - if (bytecode_data == NULL) + if (id >= bytecode_data.strs_count) { return NULL; } - - size = *bytecode_data; - - if (id >= size) - { - return NULL; - } - - data = bytecode_data; - - data += id * 2 + 1; - - offset = *((uint16_t *) data); - - return ((const ecma_char_t *) bytecode_data + offset); + return ((const ecma_char_t *) bytecode_data.strings[id].str); } ecma_number_t deserialize_num_by_id (uint8_t id) { - uint16_t str_size; - - str_size = *bytecode_data; - if (id < str_size) - { - return 0; - } - id = (uint8_t) (id - str_size); - - if (num_data == NULL) - { - // Go to last string's offset - uint8_t *data = (uint8_t *) (bytecode_data + str_size * 2 - 1); - uint16_t str_offset = *((uint16_t *) data); - data = bytecode_data + str_offset; - - while (*data) - { - data++; - } - - num_size = *(++data); - num_data = (ecma_number_t *) ++data; - } - - if (id >= num_size) + if (id < bytecode_data.strs_count) { return 0; } - return num_data[id]; + id = (uint8_t) (id - bytecode_data.strs_count); + + if (id >= bytecode_data.nums_count) + { + return 0; + } + + return bytecode_data.nums[id]; } const void * @@ -92,12 +56,5 @@ deserialize_bytecode (void) uint8_t deserialize_min_temp (void) { - uint8_t str_size = *bytecode_data; - - if (num_size == 0) - { - deserialize_num_by_id (str_size); // Init num_data and num_size - } - - return (uint8_t) (str_size + num_size); + return (uint8_t) (bytecode_data.strs_count + bytecode_data.nums_count); } diff --git a/src/liboptimizer/pretty-printer.c b/src/liboptimizer/pretty-printer.c index af27417a9..ce0a971af 100644 --- a/src/liboptimizer/pretty-printer.c +++ b/src/liboptimizer/pretty-printer.c @@ -15,7 +15,7 @@ #include "pretty-printer.h" #include "jerry-libc.h" -#include "deserializer.h" +#include "lexer.h" #define NAME_TO_ID(op) (__op__idx_##op) @@ -39,17 +39,24 @@ static uint8_t opcode_sizes[] = 0 }; -void -pp_strings (const char *strings[], uint8_t size) +static void +dump_lp (lp_string lp) { - uint8_t i; - uint16_t offset = (uint16_t) (size * 2 + 1); - - __printf ("STRINGS %d:\n", size); - for (i = 0; i < size; i++) + for (ecma_length_t i = 0; i < lp.length; i++) { - __printf ("%3d %5d %20s\n", i, offset, strings[i]); - offset = (uint16_t) (offset + __strlen (strings[i]) + 1); + __putchar (lp.str[i]); + } +} + +void +pp_strings (const lp_string strings[], uint8_t size) +{ + __printf ("STRINGS %d:\n", size); + for (uint8_t i = 0; i < size; i++) + { + __printf ("%3d ", i); + dump_lp (strings[i]); + __putchar ('\n'); } } @@ -77,17 +84,17 @@ dump_arg_list (idx_t id) static void dump_variable (idx_t id) { - if (id >= deserialize_min_temp ()) + if (id >= lexer_get_reserved_ids_count ()) { __printf ("tmp%d", id); } - else if (deserialize_string_by_id (id)) + else if (id < lexer_get_strings_count ()) { - __printf ("%s", deserialize_string_by_id (id)); + dump_lp (lexer_get_string_by_id (id)); } else { - __printf ("%d", (int) deserialize_num_by_id (id)); + __printf ("%d", (int) lexer_get_num_by_id (id)); } } @@ -154,14 +161,14 @@ dump_variable (idx_t id) } \ __printf (": SIMPLE"); \ } else if (opcode.data.op.type_value_right == OPCODE_ARG_TYPE_STRING) { \ - __printf ("'%s'", deserialize_string_by_id (opcode.data.op.op2)); \ + dump_lp (lexer_get_string_by_id (opcode.data.op.op2)); \ __printf (": STRING"); \ } else if (opcode.data.op.type_value_right == OPCODE_ARG_TYPE_NUMBER) {\ - __printf ("%d", (int) deserialize_num_by_id (opcode.data.op.op2)); \ + __printf ("%d", (int) lexer_get_num_by_id (opcode.data.op.op2)); \ __printf (": NUMBER"); \ } else if (opcode.data.op.type_value_right == OPCODE_ARG_TYPE_SMALLINT) {\ __printf ("%d", opcode.data.op.op2); \ - __printf (": NUMBER"); \ + __printf (": SMALLINT"); \ } else if (opcode.data.op.type_value_right == OPCODE_ARG_TYPE_VARIABLE) {\ dump_variable (opcode.data.op.op2); \ __printf (": TYPEOF("); \ diff --git a/src/liboptimizer/pretty-printer.h b/src/liboptimizer/pretty-printer.h index 52cf1ab7b..e430b9140 100644 --- a/src/liboptimizer/pretty-printer.h +++ b/src/liboptimizer/pretty-printer.h @@ -17,9 +17,10 @@ #define PRETTY_PRINTER #include "interpreter.h" +#include "lp-string.h" void pp_opcode (opcode_counter_t, opcode_t, bool); -void pp_strings (const char **, uint8_t); +void pp_strings (const lp_string *, uint8_t); void pp_nums (const ecma_number_t *, uint8_t, uint8_t); #endif // PRETTY_PRINTER diff --git a/src/liboptimizer/serializer.c b/src/liboptimizer/serializer.c index 613114045..f2ceeda6f 100644 --- a/src/liboptimizer/serializer.c +++ b/src/liboptimizer/serializer.c @@ -22,94 +22,19 @@ static bool print_opcodes; -uint8_t *bytecode_data = NULL; - void -serializer_init (bool show_opcodes) +serializer_dump_strings_and_nums (const lp_string strings[], uint8_t strs_count, + const ecma_number_t nums[], uint8_t nums_count) { - print_opcodes = show_opcodes; - INIT_STACK (opcode_t, bytecode_opcodes); -} - -uint16_t -serializer_dump_strings (const char *strings[], uint8_t size) -{ - uint8_t i; - uint16_t offset = (uint16_t) (size * 2 + 1), res; - if (print_opcodes) { - pp_strings (strings, size); + pp_strings (strings, strs_count); } - for (i = 0; i < size; i++) - { - offset = (uint16_t) (offset + __strlen (strings[i]) + 1); - } - - bytecode_data = mem_heap_alloc_block (offset, MEM_HEAP_ALLOC_SHORT_TERM); - res = offset; - - bytecode_data[0] = size; - offset = (uint16_t) (size * 2 + 1); - for (i = 0; i < size; i++) - { - *((uint16_t *) (bytecode_data + i * 2 + 1)) = offset; - offset = (uint16_t) (offset + __strlen (strings[i]) + 1); - } - - for (i = 0; i < size; i++) - { - offset = *((uint16_t *) (bytecode_data + i * 2 + 1)); - __strncpy ((char *) (bytecode_data + offset), strings[i], __strlen (strings[i]) + 1); - } - -#ifndef JERRY_NDEBUG - for (i = 0; i < size; i++) - { - JERRY_ASSERT (!__strcmp (strings[i], (const char *) deserialize_string_by_id (i))); - } -#endif - - return res; -} - -void -serializer_dump_nums (const ecma_number_t nums[], uint8_t size, uint16_t offset, uint8_t strings_num) -{ - uint8_t i, *data, type_size = sizeof (ecma_number_t); - - if (print_opcodes) - { - pp_nums (nums, size, strings_num); - } - - data = mem_heap_alloc_block ((size_t) (offset + size * type_size + 1), MEM_HEAP_ALLOC_LONG_TERM); - if (!data) - { - parser_fatal (ERR_MEMORY); - } - - __memcpy (data, bytecode_data, offset); - mem_heap_free_block (bytecode_data); - bytecode_data = data; - data += offset; - data[0] = size; - data++; - for (i = 0; i < size; i++) - { - __memcpy (data, nums + i, type_size); - data += type_size; - } - -#ifndef JERRY_NDEBUG - for (i = 0; i < size; i++) - { - JERRY_ASSERT (nums[i] == deserialize_num_by_id ((uint8_t) (i + strings_num))); - } - - JERRY_ASSERT (deserialize_min_temp () == (uint8_t) (size + strings_num)); -#endif + bytecode_data.strs_count = strs_count; + bytecode_data.nums_count = nums_count; + bytecode_data.strings = strings; + bytecode_data.nums = nums; } void @@ -122,14 +47,14 @@ serializer_dump_opcode (opcode_t opcode) pp_opcode (STACK_SIZE (bytecode_opcodes), opcode, false); } - PUSH (bytecode_opcodes, opcode) + STACK_PUSH (bytecode_opcodes, opcode); } void serializer_rewrite_opcode (const opcode_counter_t loc, opcode_t opcode) { JERRY_ASSERT (loc < STACK_SIZE (bytecode_opcodes)); - bytecode_opcodes.data[loc] = opcode; + STACK_ELEMENT (bytecode_opcodes, loc) = opcode; if (print_opcodes) { @@ -151,18 +76,30 @@ serializer_print_opcodes (void) for (loc = 0; loc < STACK_SIZE (bytecode_opcodes); loc++) { - pp_opcode (loc, bytecode_opcodes.data[loc], false); + pp_opcode (loc, STACK_ELEMENT (bytecode_opcodes, loc), false); } } +/* Make lp_strings also zero-terminated. */ +void +serializer_adjust_strings (void) +{ + for (uint8_t i = 0; i < bytecode_data.strs_count; i++) + { + const ecma_length_t len = bytecode_data.strings[i].length; + ((ecma_char_t *) (bytecode_data.strings[i]).str)[len] = '\0'; + } +} + +void +serializer_init (bool show_opcodes) +{ + print_opcodes = show_opcodes; + STACK_INIT (opcode_t, bytecode_opcodes); +} + void serializer_free (void) { - mem_heap_free_block (bytecode_data); - bytecode_data = NULL; - - if (bytecode_opcodes.data) - { - FREE_STACK (bytecode_opcodes); - } + STACK_FREE (bytecode_opcodes); } diff --git a/src/liboptimizer/serializer.h b/src/liboptimizer/serializer.h index eac4eb5a0..eff7bfc11 100644 --- a/src/liboptimizer/serializer.h +++ b/src/liboptimizer/serializer.h @@ -19,12 +19,12 @@ #include "globals.h" #include "opcodes.h" #include "interpreter.h" +#include "lp-string.h" void serializer_init (bool show_opcodes); -uint16_t serializer_dump_strings (const char **, uint8_t); - -void serializer_dump_nums (const ecma_number_t *, uint8_t, uint16_t, uint8_t); +void serializer_dump_strings_and_nums (const lp_string *, uint8_t, + const ecma_number_t *, uint8_t); void serializer_dump_opcode (opcode_t); @@ -32,6 +32,8 @@ void serializer_rewrite_opcode (const opcode_counter_t, opcode_t); void serializer_print_opcodes (void); +void serializer_adjust_strings (void); + void serializer_free (void); #endif // SERIALIZER_H diff --git a/src/main.c b/src/main.c index 6f9fc6bda..7b33f65df 100644 --- a/src/main.c +++ b/src/main.c @@ -32,32 +32,17 @@ #define MAX_STRINGS 100 #define MAX_NUMS 25 -static const opcode_t * -parser_run (const char *script_source, size_t script_source_size, bool is_show_opcodes) +static bool +jerry_run (const char *script_source, size_t script_source_size, + bool is_parse_only, bool is_show_opcodes, bool is_show_mem_stats) { - const char *strings[MAX_STRINGS]; - ecma_number_t nums[MAX_NUMS]; - uint8_t strings_num, nums_count; - uint16_t offset; const opcode_t *opcodes; - lexer_init (script_source, script_source_size, is_show_opcodes); + mem_init (); - lexer_run_first_pass (); - - strings_num = lexer_get_strings (strings); - nums_count = lexer_get_nums (nums); - lexer_adjust_num_ids (); - - offset = serializer_dump_strings (strings, strings_num); - serializer_dump_nums (nums, nums_count, offset, strings_num); - - parser_init (); + parser_init (script_source, script_source_size, is_show_opcodes); parser_parse_program (); - lexer_free (); - parser_free (); - opcodes = deserialize_bytecode (); optimizer_run_passes ((opcode_t *) opcodes); @@ -66,23 +51,10 @@ parser_run (const char *script_source, size_t script_source_size, bool is_show_o serializer_print_opcodes (); #endif - return opcodes; -} - -static bool -jerry_run (const char *script_source, size_t script_source_size, - bool is_parse_only, bool is_show_opcodes, bool is_show_mem_stats) -{ - const opcode_t *opcodes; - - mem_init (); - - serializer_init (is_show_opcodes); - - opcodes = parser_run (script_source, script_source_size, is_show_opcodes); - if (is_parse_only) { + parser_free (); + mem_finalize (is_show_mem_stats); return true; } @@ -90,7 +62,7 @@ jerry_run (const char *script_source, size_t script_source_size, bool is_success = run_int (); - serializer_free (); + parser_free (); mem_finalize (is_show_mem_stats); diff --git a/tests/unit/common.h b/tests/unit/common.h index 70763d9ae..d1d80d9e4 100644 --- a/tests/unit/common.h +++ b/tests/unit/common.h @@ -16,16 +16,22 @@ #ifndef COMMON_H #define COMMON_H +#include "jerry-libc.h" + #define NAME_TO_ID(op) (__op__idx_##op) #define __OPCODE_SIZE(name, arg1, arg2, arg3) \ sizeof (__op_##name) + 1, +#define LP(s) (lp_string) { .length = (uint8_t) __strlen(s), .str = (ecma_char_t *) s } + static uint8_t opcode_sizes[] = { OP_LIST (OPCODE_SIZE) 0 }; +static bool opcodes_equal (const opcode_t *, opcode_t *, uint16_t) __unused; + static bool opcodes_equal (const opcode_t *opcodes1, opcode_t *opcodes2, uint16_t size) { diff --git a/tests/unit/test_addition_opcode_number_operands.c b/tests/unit/test_addition_opcode_number_operands.c index 3649daeba..020c5c592 100644 --- a/tests/unit/test_addition_opcode_number_operands.c +++ b/tests/unit/test_addition_opcode_number_operands.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -39,11 +40,10 @@ main( int __unused argc, mem_init(); serializer_init (false); - const char *strings[] = { "a", - "b" }; + const lp_string strings[] = { LP("a"), + LP("b") }; ecma_number_t nums [] = { 2.0 }; - uint16_t offset = serializer_dump_strings( strings, 2); - serializer_dump_nums( nums, 1, offset, 2); + serializer_dump_strings_and_nums (strings, 2, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_array_obj.c b/tests/unit/test_array_obj.c index 8fb3db5d1..2eb6b89eb 100644 --- a/tests/unit/test_array_obj.c +++ b/tests/unit/test_array_obj.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -171,15 +172,14 @@ main( int __unused argc, mem_init(); serializer_init (false); - const char *strings[] = { "a", - "b", - "length", - "1" }; + const lp_string strings[] = { LP("a"), + LP("b"), + LP("length"), + LP("1") }; ecma_number_t nums [] = { 2.0, 12.0, 2.5 }; - uint16_t offset = serializer_dump_strings( strings, 4); - serializer_dump_nums( nums, 3, offset, 4); + serializer_dump_strings_and_nums (strings, 4, nums, 3); init_int( test_program, false); diff --git a/tests/unit/test_assignment_opcode.c b/tests/unit/test_assignment_opcode.c index cf02c4715..a7080fa0d 100644 --- a/tests/unit/test_assignment_opcode.c +++ b/tests/unit/test_assignment_opcode.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -42,12 +43,12 @@ main( int __unused argc, }; mem_init(); + serializer_init (false); - const char *strings[] = { "a", - "b" }; + const lp_string strings[] = { LP("a"), + LP("b") }; ecma_number_t nums [] = { 2.0 }; - uint16_t offset = serializer_dump_strings( strings, 2); - serializer_dump_nums( nums, 1, offset, 2); + serializer_dump_strings_and_nums (strings, 2, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_division_opcode.c b/tests/unit/test_division_opcode.c index 8483a04c5..f16d404a3 100644 --- a/tests/unit/test_division_opcode.c +++ b/tests/unit/test_division_opcode.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -37,12 +38,12 @@ main( int __unused argc, }; mem_init(); + serializer_init (false); - const char *strings[] = { "a", - "b" }; - ecma_number_t nums [] = { 2 }; - uint16_t offset = serializer_dump_strings( strings, 2); - serializer_dump_nums( nums, 1, offset, 2); + const lp_string strings[] = { LP("a"), + LP("b") }; + ecma_number_t nums [] = { 2.0 }; + serializer_dump_strings_and_nums (strings, 2, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_multiplication_opcode.c b/tests/unit/test_multiplication_opcode.c index e4370b3be..294d51c97 100644 --- a/tests/unit/test_multiplication_opcode.c +++ b/tests/unit/test_multiplication_opcode.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -37,12 +38,12 @@ main( int __unused argc, }; mem_init(); + serializer_init (false); - const char *strings[] = { "a", - "b" }; - ecma_number_t nums [] = { 2 }; - uint16_t offset = serializer_dump_strings( strings, 2); - serializer_dump_nums( nums, 1, offset, 2); + const lp_string strings[] = { LP("a"), + LP("b") }; + ecma_number_t nums [] = { 2.0 }; + serializer_dump_strings_and_nums (strings, 2, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_obj_initializer.c b/tests/unit/test_obj_initializer.c index 4854a337f..cbec9cf71 100644 --- a/tests/unit/test_obj_initializer.c +++ b/tests/unit/test_obj_initializer.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -136,16 +137,15 @@ main( int __unused argc, mem_init(); serializer_init (false); - const char *strings[] = { "a", - "b", - "property1", - "property2", - "property3", - "value1", - "value2" }; + const lp_string strings[] = { LP("a"), + LP("b"), + LP("property1"), + LP("property2"), + LP("property3"), + LP("value1"), + LP("value2") }; ecma_number_t nums [] = { 2.5 }; - uint16_t offset = serializer_dump_strings( strings, 7); - serializer_dump_nums( nums, 1, offset, 7); + serializer_dump_strings_and_nums (strings, 7, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_remainder_opcode.c b/tests/unit/test_remainder_opcode.c index e5f60aabc..4350c4b81 100644 --- a/tests/unit/test_remainder_opcode.c +++ b/tests/unit/test_remainder_opcode.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -37,12 +38,12 @@ main( int __unused argc, }; mem_init(); + serializer_init (false); - const char *strings[] = { "a", - "b" }; - ecma_number_t nums [] = { 2 }; - uint16_t offset = serializer_dump_strings( strings, 2); - serializer_dump_nums( nums, 1, offset, 2); + const lp_string strings[] = { LP("a"), + LP("b") }; + ecma_number_t nums [] = { 2.0 }; + serializer_dump_strings_and_nums (strings, 2, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_substraction_opcode.c b/tests/unit/test_substraction_opcode.c index 041bb6432..91eb962b0 100644 --- a/tests/unit/test_substraction_opcode.c +++ b/tests/unit/test_substraction_opcode.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -37,12 +38,12 @@ main( int __unused argc, }; mem_init(); + serializer_init (false); - const char *strings[] = { "a", - "b" }; - ecma_number_t nums [] = { 2 }; - uint16_t offset = serializer_dump_strings( strings, 2); - serializer_dump_nums( nums, 1, offset, 2); + const lp_string strings[] = { LP("a"), + LP("b") }; + ecma_number_t nums [] = { 2.0 }; + serializer_dump_strings_and_nums (strings, 2, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_try_catch.c b/tests/unit/test_try_catch.c index d0adf27e1..da6dca5bd 100644 --- a/tests/unit/test_try_catch.c +++ b/tests/unit/test_try_catch.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -50,13 +51,13 @@ main( int __unused argc, }; mem_init(); + serializer_init (false); - const char *strings[] = { "a", - "b", - "c" }; + const lp_string strings[] = { LP("a"), + LP("b"), + LP("c") }; ecma_number_t nums [] = { 2.0 }; - uint16_t offset = serializer_dump_strings( strings, 3); - serializer_dump_nums( nums, 1, offset, 3); + serializer_dump_strings_and_nums (strings, 3, nums, 1); init_int( test_program, false); diff --git a/tests/unit/test_var_decl_opcode_in_decl_lex_env.c b/tests/unit/test_var_decl_opcode_in_decl_lex_env.c index dcee81890..541f72173 100644 --- a/tests/unit/test_var_decl_opcode_in_decl_lex_env.c +++ b/tests/unit/test_var_decl_opcode_in_decl_lex_env.c @@ -18,6 +18,7 @@ #include "mem-allocator.h" #include "opcodes.h" #include "serializer.h" +#include "common.h" /** * Unit test's main function. @@ -35,12 +36,12 @@ main( int __unused argc, }; mem_init(); + serializer_init (false); - const char *strings[] = { "a", - "b" }; - ecma_number_t nums [] = { 2 }; - uint16_t offset = serializer_dump_strings( strings, 2); - serializer_dump_nums( nums, 1, offset, 2); + const lp_string strings[] = { LP("a"), + LP("b") }; + ecma_number_t nums [] = { 2.0 }; + serializer_dump_strings_and_nums (strings, 2, nums, 1); init_int( test_program, false);