Renaming core -> jerry-core.

jerry-core/parser/js/bytecode-data.h

@@ -0,0 +1,48 @@
+/* Copyright 2014-2015 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 BYTECODE_DATA_H
+#define BYTECODE_DATA_H
+
+#include "opcodes.h"
+#include "stack.h"
+#include "jrt-libc-includes.h"
+#include "literal.h"
+#include "scopes-tree.h"
+#include "lit-id-hash-table.h"
+
+#define BLOCK_SIZE 64
+
+typedef struct
+{
+  opcode_counter_t oc;
+  idx_t uid;
+  uint8_t reserved;
+}
+lit_id_table_key;
+
+typedef struct
+{
+  const literal *literals;
+  const opcode_t *opcodes;
+  lit_id_hash_table *lit_id_hash;
+  literal_index_t literals_count;
+  opcode_counter_t opcodes_count;
+} bytecode_data_t;
+
+extern bytecode_data_t bytecode_data;
+extern scopes_tree current_scope;
+
+#endif // BYTECODE_DATA_H

jerry-core/parser/js/deserializer.cpp

@@ -0,0 +1,101 @@
+/* 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 "deserializer.h"
+#include "bytecode-data.h"
+#include "ecma-helpers.h"
+
+const ecma_char_t *strings_buffer;
+
+void
+deserializer_set_strings_buffer (const ecma_char_t *s)
+{
+  strings_buffer = s;
+}
+
+literal
+deserialize_literal_by_id (literal_index_t id)
+{
+  JERRY_ASSERT (id != INVALID_LITERAL);
+  JERRY_ASSERT (id < bytecode_data.literals_count);
+  return bytecode_data.literals[id];
+}
+
+literal_index_t
+deserialize_lit_id_by_uid (uint8_t id, opcode_counter_t oc)
+{
+  if (bytecode_data.lit_id_hash == null_hash)
+  {
+    return INVALID_LITERAL;
+  }
+  return lit_id_hash_table_lookup (bytecode_data.lit_id_hash, id, oc);
+}
+
+const void *
+deserialize_bytecode (void)
+{
+  JERRY_ASSERT (bytecode_data.opcodes != NULL);
+  return bytecode_data.opcodes;
+}
+
+opcode_t
+deserialize_opcode (opcode_counter_t oc)
+{
+  if (bytecode_data.opcodes == NULL)
+  {
+    return deserialize_op_meta (oc).op;
+  }
+  JERRY_ASSERT (oc < bytecode_data.opcodes_count);
+  return bytecode_data.opcodes[oc];
+}
+
+op_meta
+deserialize_op_meta (opcode_counter_t oc)
+{
+  JERRY_ASSERT (current_scope);
+  return scopes_tree_op_meta (current_scope, oc);
+}
+
+uint8_t
+deserialize_min_temp (void)
+{
+  return 128;
+}
+
+void
+deserializer_init (void)
+{
+  bytecode_data.literals = NULL;
+  strings_buffer = NULL;
+  bytecode_data.opcodes = NULL;
+}
+
+void
+deserializer_free (void)
+{
+  if (strings_buffer)
+  {
+    mem_heap_free_block ((uint8_t *) strings_buffer);
+  }
+  if (bytecode_data.lit_id_hash != NULL)
+  {
+    lit_id_hash_table_free (bytecode_data.lit_id_hash);
+  }
+  if (bytecode_data.literals != NULL)
+  {
+    mem_heap_free_block ((uint8_t *) bytecode_data.literals);
+  }
+  mem_heap_free_block ((uint8_t *) bytecode_data.opcodes);
+}

jerry-core/parser/js/deserializer.h

@@ -0,0 +1,35 @@
+/* Copyright 2014-2015 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 DESERIALIZER_H
+#define DESERIALIZER_H
+
+#include "jrt.h"
+#include "ecma-globals.h"
+#include "opcodes.h"
+#include "scopes-tree.h"
+#include "literal.h"
+
+void deserializer_init (void);
+void deserializer_set_strings_buffer (const ecma_char_t *);
+literal deserialize_literal_by_id (literal_index_t);
+literal_index_t deserialize_lit_id_by_uid (uint8_t, opcode_counter_t);
+const void *deserialize_bytecode (void);
+opcode_t deserialize_opcode (opcode_counter_t);
+op_meta deserialize_op_meta (opcode_counter_t);
+uint8_t deserialize_min_temp (void);
+void deserializer_free (void);
+
+#endif //DESERIALIZER_H

jerry-core/parser/js/lexer.h

@@ -0,0 +1,191 @@
+/* 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 LEXER_H
+#define LEXER_H
+
+#include "literal.h"
+
+#define INVALID_VALUE 255
+#define INVALID_LITERAL UINT32_MAX
+
+/* Keywords.  */
+typedef enum
+{
+  /* Not a keyword.  */
+  KW_NONE = 0,
+  KW_BREAK,
+  KW_CASE,
+  KW_CATCH,
+  KW_CLASS,
+
+  KW_CONST,
+  KW_CONTINUE,
+  KW_DEBUGGER,
+  KW_DEFAULT,
+  KW_DELETE,
+
+  KW_DO,
+  KW_ELSE,
+  KW_ENUM,
+  KW_EXPORT,
+  KW_EXTENDS,
+
+  KW_FINALLY,
+  KW_FOR,
+  KW_FUNCTION,
+  KW_IF,
+  KW_IN,
+
+  KW_INSTANCEOF,
+  KW_INTERFACE,
+  KW_IMPORT,
+  KW_IMPLEMENTS,
+  KW_LET,
+
+  KW_NEW,
+  KW_PACKAGE,
+  KW_PRIVATE,
+  KW_PROTECTED,
+  KW_PUBLIC,
+
+  KW_RETURN,
+  KW_STATIC,
+  KW_SUPER,
+  KW_SWITCH,
+  KW_THIS,
+
+  KW_THROW,
+  KW_TRY,
+  KW_TYPEOF,
+  KW_VAR,
+  KW_VOID,
+
+  KW_WHILE,
+  KW_WITH,
+  KW_YIELD
+}
+keyword;
+
+
+/* Type of tokens.  */
+typedef enum
+{
+  TOK_EOF = 0, // End of file
+  TOK_NAME, // Identifier
+  TOK_KEYWORD, // Keyword
+  TOK_SMALL_INT,
+  TOK_NUMBER,
+
+  TOK_NULL,
+  TOK_BOOL,
+  TOK_NEWLINE,
+  TOK_STRING,
+  TOK_OPEN_BRACE, // {
+
+  TOK_CLOSE_BRACE, // }
+  TOK_OPEN_PAREN, // (
+  TOK_CLOSE_PAREN, //)
+  TOK_OPEN_SQUARE, // [
+  TOK_CLOSE_SQUARE, // [
+
+  TOK_DOT, // .
+  TOK_SEMICOLON, // ;
+  TOK_COMMA, // ,
+  TOK_LESS, // <
+  TOK_GREATER, // >
+
+  TOK_LESS_EQ, // <=
+  TOK_GREATER_EQ, // <=
+  TOK_DOUBLE_EQ, // ==
+  TOK_NOT_EQ, // !=
+  TOK_TRIPLE_EQ, // ===
+
+  TOK_NOT_DOUBLE_EQ, // !==
+  TOK_PLUS, // +
+  TOK_MINUS, // -
+  TOK_MULT, // *
+  TOK_MOD, // %
+
+  TOK_DOUBLE_PLUS, // ++
+  TOK_DOUBLE_MINUS, // --
+  TOK_LSHIFT, // <<
+  TOK_RSHIFT, // >>
+  TOK_RSHIFT_EX, // >>>
+
+  TOK_AND, // &
+  TOK_OR, // |
+  TOK_XOR, // ^
+  TOK_NOT, // !
+  TOK_COMPL, // ~
+
+  TOK_DOUBLE_AND, // &&
+  TOK_DOUBLE_OR, // ||
+  TOK_QUERY, // ?
+  TOK_COLON, // :
+  TOK_EQ, // =
+
+  TOK_PLUS_EQ, // +=
+  TOK_MINUS_EQ, // -=
+  TOK_MULT_EQ, // *=
+  TOK_MOD_EQ, // %=
+  TOK_LSHIFT_EQ, // <<=
+
+  TOK_RSHIFT_EQ, // >>=
+  TOK_RSHIFT_EX_EQ, // >>>=
+  TOK_AND_EQ, // &=
+  TOK_OR_EQ, // |=
+  TOK_XOR_EQ, // ^=
+
+  TOK_DIV, // /
+  TOK_DIV_EQ, // /=
+  TOK_EMPTY,
+}
+token_type;
+
+typedef size_t locus;
+
+/* Represents the contents of a token.  */
+typedef struct
+{
+  locus loc;
+  token_type type;
+  literal_index_t uid;
+}
+token;
+
+void lexer_init (const char *, size_t, bool);
+void lexer_free (void);
+
+token lexer_next_token (void);
+void lexer_save_token (token);
+token lexer_prev_token (void);
+
+const literal *lexer_get_literals (void);
+const ecma_char_t *lexer_get_strings_cache (void);
+void lexer_add_literal_if_not_present (literal);
+literal_index_t lexer_get_literals_count (void);
+literal lexer_get_literal_by_id (literal_index_t);
+literal_index_t lexer_lookup_literal_uid (literal lit);
+
+void lexer_seek (locus);
+void lexer_locus_to_line_and_column (locus, size_t *, size_t *);
+void lexer_dump_line (size_t);
+const char *lexer_keyword_to_string (keyword);
+const char *lexer_token_type_to_string (token_type);
+
+void lexer_set_strict_mode (bool);
+
+#endif

jerry-core/parser/js/literal.cpp

@@ -0,0 +1,235 @@
+/* Copyright 2014-2015 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 "literal.h"
+#include "ecma-helpers.h"
+#include "jrt-libc-includes.h"
+
+literal
+create_empty_literal (void)
+{
+  literal ret;
+
+  ret.type = LIT_UNKNOWN;
+  ret.data.none = NULL;
+
+  return ret;
+}
+
+literal
+create_literal_from_num (ecma_number_t num)
+{
+  literal ret;
+
+  ret.type = LIT_NUMBER;
+  ret.data.num = num;
+
+  return ret;
+}
+
+literal
+create_literal_from_str (const char *s, ecma_length_t len)
+{
+  return create_literal_from_zt ((const ecma_char_t *) s, len);
+}
+
+literal
+create_literal_from_str_compute_len (const char *s)
+{
+  return create_literal_from_zt ((const ecma_char_t *) s, (ecma_length_t) strlen (s));
+}
+
+literal
+create_literal_from_zt (const ecma_char_t *s, ecma_length_t len)
+{
+  for (ecma_magic_string_id_t msi = (ecma_magic_string_id_t) 0;
+       msi < ECMA_MAGIC_STRING__COUNT;
+       msi = (ecma_magic_string_id_t) (msi + 1))
+  {
+    if (ecma_zt_string_length (ecma_get_magic_string_zt (msi)) != len)
+    {
+      continue;
+    }
+    if (!strncmp ((const char *) s, (const char *) ecma_get_magic_string_zt (msi), len))
+    {
+      literal ret;
+
+      ret.type = LIT_MAGIC_STR;
+      ret.data.magic_str_id = msi;
+
+      return ret;
+    }
+  }
+
+  literal ret;
+
+  ret.type = LIT_STR;
+  ret.data.lp.length = len;
+  ret.data.lp.str = s;
+  ret.data.lp.hash = ecma_chars_buffer_calc_hash_last_chars (s, len);
+
+  return ret;
+}
+
+bool
+literal_equal_type (literal lit1, literal lit2)
+{
+  if (lit1.type != lit2.type)
+  {
+    return false;
+  }
+  return literal_equal (lit1, lit2);
+}
+
+bool
+literal_equal_type_s (literal lit, const char *s)
+{
+  return literal_equal_type_zt (lit, (const ecma_char_t *) s);
+}
+
+bool
+literal_equal_type_zt (literal lit, const ecma_char_t *s)
+{
+  if (lit.type != LIT_STR && lit.type != LIT_MAGIC_STR)
+  {
+    return false;
+  }
+  return literal_equal_zt (lit, s);
+}
+
+bool
+literal_equal_type_num (literal lit, ecma_number_t num)
+{
+  if (lit.type != LIT_NUMBER)
+  {
+    return false;
+  }
+  return literal_equal_num (lit, num);
+}
+
+static bool
+literal_equal_lp (literal lit, lp_string lp)
+{
+  switch (lit.type)
+  {
+    case LIT_UNKNOWN:
+    {
+      return false;
+    }
+    case LIT_STR:
+    {
+      return lp_string_equal (lit.data.lp, lp);
+    }
+    case LIT_MAGIC_STR:
+    {
+      return lp_string_equal_zt (lp, ecma_get_magic_string_zt (lit.data.magic_str_id));
+    }
+    case LIT_NUMBER:
+    {
+      ecma_char_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
+      ecma_number_to_zt_string (lit.data.num, buff, ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER);
+      return lp_string_equal_zt (lp, buff);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+}
+
+bool
+literal_equal (literal lit1, literal lit2)
+{
+  switch (lit2.type)
+  {
+    case LIT_UNKNOWN:
+    {
+      return lit2.type == LIT_UNKNOWN;
+    }
+    case LIT_STR:
+    {
+      return literal_equal_lp (lit1, lit2.data.lp);
+    }
+    case LIT_MAGIC_STR:
+    {
+      return literal_equal_zt (lit1, ecma_get_magic_string_zt (lit2.data.magic_str_id));
+    }
+    case LIT_NUMBER:
+    {
+      return literal_equal_num (lit1, lit2.data.num);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+}
+
+bool
+literal_equal_s (literal lit, const char *s)
+{
+  return literal_equal_zt (lit, (const ecma_char_t *) s);
+}
+
+bool
+literal_equal_zt (literal lit, const ecma_char_t *s)
+{
+  switch (lit.type)
+  {
+    case LIT_UNKNOWN:
+    {
+      return false;
+    }
+    case LIT_STR:
+    {
+      return lp_string_equal_zt (lit.data.lp, s);
+    }
+    case LIT_MAGIC_STR:
+    {
+      return ecma_compare_zt_strings (s, ecma_get_magic_string_zt (lit.data.magic_str_id));
+    }
+    case LIT_NUMBER:
+    {
+      ecma_char_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
+      ecma_number_to_zt_string (lit.data.num, buff, ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER);
+      return ecma_compare_zt_strings (s, buff);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+}
+
+bool
+literal_equal_num (literal lit, ecma_number_t num)
+{
+  ecma_char_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
+  ecma_number_to_zt_string (num, buff, ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER);
+  return literal_equal_zt (lit, buff);
+}
+
+const ecma_char_t *
+literal_to_zt (literal lit)
+{
+  JERRY_ASSERT (lit.type == LIT_STR || lit.type == LIT_MAGIC_STR);
+
+  switch (lit.type)
+  {
+    case LIT_STR: return lit.data.lp.str;
+    case LIT_MAGIC_STR: return ecma_get_magic_string_zt (lit.data.magic_str_id);
+    default: JERRY_UNREACHABLE ();
+  }
+}

jerry-core/parser/js/literal.h

@@ -0,0 +1,62 @@
+/* Copyright 2015 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 LITERAL_H
+#define LITERAL_H
+
+#include "ecma-globals.h"
+#include "lp-string.h"
+
+typedef enum
+{
+  LIT_UNKNOWN,
+  LIT_STR,
+  LIT_MAGIC_STR,
+  LIT_NUMBER
+}
+literal_type;
+
+typedef struct
+{
+  union
+  {
+    ecma_magic_string_id_t magic_str_id;
+    ecma_number_t num;
+    lp_string lp;
+    void *none;
+  }
+  data;
+  literal_type type;
+}
+literal;
+
+#define LITERAL_TO_REWRITE (INVALID_VALUE - 1)
+
+literal create_empty_literal (void);
+literal create_literal_from_num (ecma_number_t);
+literal create_literal_from_str (const char *, ecma_length_t);
+literal create_literal_from_str_compute_len (const char *);
+literal create_literal_from_zt (const ecma_char_t *, ecma_length_t);
+bool literal_equal (literal, literal);
+bool literal_equal_s (literal, const char *);
+bool literal_equal_zt (literal, const ecma_char_t *);
+bool literal_equal_num (literal, ecma_number_t);
+bool literal_equal_type (literal, literal);
+bool literal_equal_type_s (literal, const char *);
+bool literal_equal_type_zt (literal, const ecma_char_t *);
+bool literal_equal_type_num (literal, ecma_number_t);
+const ecma_char_t *literal_to_zt (literal);
+
+#endif /* LITERAL_H */

jerry-core/parser/js/opcodes-dumper.h

@@ -0,0 +1,233 @@
+/* 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 OPCODES_DUMPER_H
+#define OPCODES_DUMPER_H
+
+#include "opcodes.h"
+#include "ecma-globals.h"
+#include "lexer.h"
+
+typedef enum
+{
+  OPERAND_LITERAL,
+  OPERAND_TMP
+}
+operand_type;
+
+typedef struct
+{
+  operand_type type;
+  union
+  {
+    idx_t uid;
+    literal_index_t lit_id;
+  }
+  data;
+}
+operand;
+
+typedef enum
+{
+  VARG_FUNC_DECL,
+  VARG_FUNC_EXPR,
+  VARG_ARRAY_DECL,
+  VARG_OBJ_DECL,
+  VARG_CONSTRUCT_EXPR,
+  VARG_CALL_EXPR
+}
+varg_list_type;
+
+operand empty_operand (void);
+operand literal_operand (literal_index_t);
+bool operand_is_empty (operand);
+
+void dumper_init (void);
+void dumper_free (void);
+
+void dumper_new_statement (void);
+void dumper_new_scope (void);
+void dumper_finish_scope (void);
+
+bool dumper_is_intrinsic (operand);
+operand dump_intrinsic (operand, operand);
+
+void dump_boolean_assignment (operand, bool);
+operand dump_boolean_assignment_res (bool);
+void dump_string_assignment (operand, literal_index_t);
+operand dump_string_assignment_res (literal_index_t);
+void dump_number_assignment (operand, literal_index_t);
+operand dump_number_assignment_res (literal_index_t);
+void dump_smallint_assignment (operand, idx_t);
+operand dump_smallint_assignment_res (idx_t);
+void dump_undefined_assignment (operand);
+operand dump_undefined_assignment_res (void);
+void dump_null_assignment (operand);
+operand dump_null_assignment_res (void);
+void dump_variable_assignment (operand, operand);
+operand dump_variable_assignment_res (operand);
+
+void dump_varg_header_for_rewrite (varg_list_type, operand);
+operand rewrite_varg_header_set_args_count (uint8_t);
+void dump_this_arg (operand);
+void dump_varg (operand);
+
+void dump_prop_name_and_value (operand, operand);
+void dump_prop_getter_decl (operand, operand);
+void dump_prop_setter_decl (operand, operand);
+void dump_prop_getter (operand, operand, operand);
+operand dump_prop_getter_res (operand, operand);
+void dump_prop_setter (operand, operand, operand);
+
+void dump_function_end_for_rewrite (void);
+void rewrite_function_end (varg_list_type);
+
+void dump_this (operand);
+operand dump_this_res (void);
+
+void dump_post_increment (operand, operand);
+operand dump_post_increment_res (operand);
+void dump_post_decrement (operand, operand);
+operand dump_post_decrement_res (operand);
+void dump_pre_increment (operand, operand);
+operand dump_pre_increment_res (operand);
+void dump_pre_decrement (operand, operand);
+operand dump_pre_decrement_res (operand);
+void dump_unary_plus (operand, operand);
+operand dump_unary_plus_res (operand);
+void dump_unary_minus (operand, operand);
+operand dump_unary_minus_res (operand);
+void dump_bitwise_not (operand, operand);
+operand dump_bitwise_not_res (operand);
+void dump_logical_not (operand, operand);
+operand dump_logical_not_res (operand);
+
+void dump_multiplication (operand, operand, operand);
+operand dump_multiplication_res (operand, operand);
+void dump_division (operand, operand, operand);
+operand dump_division_res (operand, operand);
+void dump_remainder (operand, operand, operand);
+operand dump_remainder_res (operand, operand);
+void dump_addition (operand, operand, operand);
+operand dump_addition_res (operand, operand);
+void dump_substraction (operand, operand, operand);
+operand dump_substraction_res (operand, operand);
+void dump_left_shift (operand, operand, operand);
+operand dump_left_shift_res (operand, operand);
+void dump_right_shift (operand, operand, operand);
+operand dump_right_shift_res (operand, operand);
+void dump_right_shift_ex (operand, operand, operand);
+operand dump_right_shift_ex_res (operand, operand);
+void dump_less_than (operand, operand, operand);
+operand dump_less_than_res (operand, operand);
+void dump_greater_than (operand, operand, operand);
+operand dump_greater_than_res (operand, operand);
+void dump_less_or_equal_than (operand, operand, operand);
+operand dump_less_or_equal_than_res (operand, operand);
+void dump_greater_or_equal_than (operand, operand, operand);
+operand dump_greater_or_equal_than_res (operand, operand);
+void dump_instanceof (operand, operand, operand);
+operand dump_instanceof_res (operand, operand);
+void dump_in (operand, operand, operand);
+operand dump_in_res (operand, operand);
+void dump_equal_value (operand, operand, operand);
+operand dump_equal_value_res (operand, operand);
+void dump_not_equal_value (operand, operand, operand);
+operand dump_not_equal_value_res (operand, operand);
+void dump_equal_value_type (operand, operand, operand);
+operand dump_equal_value_type_res (operand, operand);
+void dump_not_equal_value_type (operand, operand, operand);
+operand dump_not_equal_value_type_res (operand, operand);
+void dump_bitwise_and (operand, operand, operand);
+operand dump_bitwise_and_res (operand, operand);
+void dump_bitwise_xor (operand, operand, operand);
+operand dump_bitwise_xor_res (operand, operand);
+void dump_bitwise_or (operand, operand, operand);
+operand dump_bitwise_or_res (operand, operand);
+
+void start_dumping_logical_and_checks (void);
+void dump_logical_and_check_for_rewrite (operand);
+void rewrite_logical_and_checks (void);
+void start_dumping_logical_or_checks (void);
+void dump_logical_or_check_for_rewrite (operand);
+void rewrite_logical_or_checks (void);
+void dump_conditional_check_for_rewrite (operand);
+void rewrite_conditional_check (void);
+void dump_jump_to_end_for_rewrite (void);
+void rewrite_jump_to_end (void);
+
+void start_dumping_assignment_expression (void);
+operand dump_prop_setter_or_variable_assignment_res (operand, operand);
+operand dump_prop_setter_or_addition_res (operand, operand);
+operand dump_prop_setter_or_multiplication_res (operand, operand);
+operand dump_prop_setter_or_division_res (operand, operand);
+operand dump_prop_setter_or_remainder_res (operand, operand);
+operand dump_prop_setter_or_substraction_res (operand, operand);
+operand dump_prop_setter_or_left_shift_res (operand, operand);
+operand dump_prop_setter_or_right_shift_res (operand, operand);
+operand dump_prop_setter_or_right_shift_ex_res (operand, operand);
+operand dump_prop_setter_or_bitwise_and_res (operand, operand);
+operand dump_prop_setter_or_bitwise_xor_res (operand, operand);
+operand dump_prop_setter_or_bitwise_or_res (operand, operand);
+
+void start_collecting_breaks (void);
+void start_collecting_continues (void);
+void dumper_set_break_target (void);
+void dumper_set_continue_target (void);
+void dumper_set_next_interation_target (void);
+void dump_continue_for_rewrite (void);
+void dump_break_for_rewrite (void);
+void rewrite_continues (void);
+void rewrite_breaks (void);
+void dump_continue_iterations_check (operand);
+
+void start_dumping_case_clauses (void);
+void dump_case_clause_check_for_rewrite (operand, operand);
+void dump_default_clause_check_for_rewrite (void);
+void rewrite_case_clause (void);
+void rewrite_default_clause (void);
+void finish_dumping_case_clauses (void);
+
+void dump_delete (operand, operand, bool, locus);
+operand dump_delete_res (operand, bool, locus);
+
+void dump_typeof (operand, operand);
+operand dump_typeof_res (operand);
+
+void dump_with (operand);
+void dump_with_end (void);
+
+void dump_try_for_rewrite (void);
+void rewrite_try (void);
+void dump_catch_for_rewrite (operand);
+void rewrite_catch (void);
+void dump_finally_for_rewrite (void);
+void rewrite_finally (void);
+void dump_end_try_catch_finally (void);
+void dump_throw (operand);
+
+bool dumper_variable_declaration_exists (literal_index_t);
+void dump_variable_declaration (literal_index_t);
+
+void dump_strict_mode_header (void);
+
+void dump_reg_var_decl_for_rewrite (void);
+void rewrite_reg_var_decl (void);
+
+void dump_ret (void);
+void dump_retval (operand op);
+void dump_exit (void);
+
+#endif /* OPCODES_DUMPER_H */

jerry-core/parser/js/parser.h

@@ -0,0 +1,25 @@
+/* Copyright 2014-2015 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 PARSER_H
+#define PARSER_H
+
+#include "jrt.h"
+
+void parser_init (const char *, size_t, bool);
+void parser_parse_program (void);
+void parser_free (void);
+
+#endif

jerry-core/parser/js/scopes-tree.cpp

@@ -0,0 +1,686 @@
+/* Copyright 2014-2015 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 "scopes-tree.h"
+#include "mem-heap.h"
+#include "jrt-libc-includes.h"
+#include "lexer.h"
+#include "bytecode-data.h"
+
+#define OPCODE(op) (__op__idx_##op)
+#define HASH_SIZE 128
+
+static hash_table lit_id_to_uid = null_hash;
+static opcode_counter_t global_oc;
+static idx_t next_uid;
+
+static void
+assert_tree (scopes_tree t)
+{
+  JERRY_ASSERT (t != NULL);
+  JERRY_ASSERT (t->t.magic == TREE_MAGIC);
+}
+
+static idx_t
+get_uid (op_meta *op, uint8_t i)
+{
+  JERRY_ASSERT (i < 4);
+  raw_opcode *raw = (raw_opcode *) &op->op;
+  return raw->uids[i + 1];
+}
+
+static void
+set_uid (op_meta *op, uint8_t i, idx_t uid)
+{
+  JERRY_ASSERT (i < 4);
+  raw_opcode *raw = (raw_opcode *) &op->op;
+  raw->uids[i + 1] = uid;
+}
+
+opcode_counter_t
+scopes_tree_opcodes_num (scopes_tree t)
+{
+  assert_tree (t);
+  return t->opcodes_num;
+}
+
+void
+scopes_tree_add_op_meta (scopes_tree tree, op_meta op)
+{
+  assert_tree (tree);
+  linked_list_set_element (tree->opcodes, tree->opcodes_num++, &op);
+}
+
+void
+scopes_tree_set_op_meta (scopes_tree tree, opcode_counter_t oc, op_meta op)
+{
+  assert_tree (tree);
+  JERRY_ASSERT (oc < tree->opcodes_num);
+  linked_list_set_element (tree->opcodes, oc, &op);
+}
+
+void
+scopes_tree_set_opcodes_num (scopes_tree tree, opcode_counter_t oc)
+{
+  assert_tree (tree);
+  JERRY_ASSERT (oc < tree->opcodes_num);
+  tree->opcodes_num = oc;
+}
+
+op_meta
+scopes_tree_op_meta (scopes_tree tree, opcode_counter_t oc)
+{
+  assert_tree (tree);
+  JERRY_ASSERT (oc < tree->opcodes_num);
+  return *(op_meta *) linked_list_element (tree->opcodes, oc);
+}
+
+opcode_counter_t
+scopes_tree_count_opcodes (scopes_tree t)
+{
+  assert_tree (t);
+  opcode_counter_t res = t->opcodes_num;
+  for (uint8_t i = 0; i < t->t.children_num; i++)
+  {
+    res = (opcode_counter_t) (
+      res + scopes_tree_count_opcodes (
+        *(scopes_tree *) linked_list_element (t->t.children, i)));
+  }
+  return res;
+}
+
+static uint16_t
+lit_id_hash (void * lit_id)
+{
+  return *(literal_index_t *) lit_id % HASH_SIZE;
+}
+
+static void
+start_new_block_if_necessary (void)
+{
+  if (global_oc % BLOCK_SIZE == 0)
+  {
+    next_uid = 0;
+    if (lit_id_to_uid != null_hash)
+    {
+      hash_table_free (lit_id_to_uid);
+      lit_id_to_uid = null_hash;
+    }
+    lit_id_to_uid = hash_table_init (sizeof (literal_index_t), sizeof (idx_t), HASH_SIZE, lit_id_hash,
+                                     MEM_HEAP_ALLOC_SHORT_TERM);
+  }
+}
+
+static bool
+is_possible_literal (uint16_t mask, uint8_t index)
+{
+  int res;
+  switch (index)
+  {
+    case 0:
+    {
+      res = mask >> 8;
+      break;
+    }
+    case 1:
+    {
+      res = (mask & 0xF0) >> 4;
+      break;
+    }
+    default:
+    {
+      JERRY_ASSERT (index = 2);
+      res = mask & 0x0F;
+    }
+  }
+  JERRY_ASSERT (res == 0 || res == 1);
+  return res == 1;
+}
+
+static void
+change_uid (op_meta *om, lit_id_hash_table *lit_ids, uint16_t mask)
+{
+  for (uint8_t i = 0; i < 3; i++)
+  {
+    if (is_possible_literal (mask, i))
+    {
+      if (get_uid (om, i) == LITERAL_TO_REWRITE)
+      {
+        JERRY_ASSERT (om->lit_id[i] != NOT_A_LITERAL);
+        literal_index_t lit_id = om->lit_id[i];
+        idx_t *uid = (idx_t *) hash_table_lookup (lit_id_to_uid, &lit_id);
+        if (uid == NULL)
+        {
+          hash_table_insert (lit_id_to_uid, &lit_id, &next_uid);
+          lit_id_hash_table_insert (lit_ids, next_uid, global_oc, lit_id);
+          uid = (idx_t *) hash_table_lookup (lit_id_to_uid, &lit_id);
+          JERRY_ASSERT (uid != NULL);
+          JERRY_ASSERT (*uid == next_uid);
+          next_uid++;
+        }
+        set_uid (om, i, *uid);
+      }
+      else
+      {
+        JERRY_ASSERT (om->lit_id[i] == NOT_A_LITERAL);
+      }
+    }
+    else
+    {
+      JERRY_ASSERT (om->lit_id[i] == NOT_A_LITERAL);
+    }
+  }
+}
+
+static void
+insert_uids_to_lit_id_map (op_meta *om, uint16_t mask)
+{
+  for (uint8_t i = 0; i < 3; i++)
+  {
+    if (is_possible_literal (mask, i))
+    {
+      if (get_uid (om, i) == LITERAL_TO_REWRITE)
+      {
+        JERRY_ASSERT (om->lit_id[i] != NOT_A_LITERAL);
+        literal_index_t lit_id = om->lit_id[i];
+        idx_t *uid = (idx_t *) hash_table_lookup (lit_id_to_uid, &lit_id);
+        if (uid == NULL)
+        {
+          hash_table_insert (lit_id_to_uid, &lit_id, &next_uid);
+          uid = (idx_t *) hash_table_lookup (lit_id_to_uid, &lit_id);
+          JERRY_ASSERT (uid != NULL);
+          JERRY_ASSERT (*uid == next_uid);
+          next_uid++;
+        }
+      }
+      else
+      {
+        JERRY_ASSERT (om->lit_id[i] == NOT_A_LITERAL);
+      }
+    }
+    else
+    {
+      JERRY_ASSERT (om->lit_id[i] == NOT_A_LITERAL);
+    }
+  }
+}
+
+static op_meta *
+extract_op_meta (scopes_tree tree, opcode_counter_t opc_index)
+{
+  return (op_meta *) linked_list_element (tree->opcodes, opc_index);
+}
+
+static opcode_t
+generate_opcode (scopes_tree tree, opcode_counter_t opc_index, lit_id_hash_table *lit_ids)
+{
+  start_new_block_if_necessary ();
+  op_meta *om = extract_op_meta (tree, opc_index);
+  /* Now we should change uids of opcodes.
+     Since different opcodes has different literals/tmps in different places,
+     we should change only them.
+     For each case possible literal positions are shown as 0xYYY literal,
+     where Y is set to '1' when there is a possible literal in this position,
+     and '0' otherwise.  */
+  switch (om->op.op_idx)
+  {
+    case OPCODE (prop_getter):
+    case OPCODE (prop_setter):
+    case OPCODE (delete_prop):
+    case OPCODE (b_shift_left):
+    case OPCODE (b_shift_right):
+    case OPCODE (b_shift_uright):
+    case OPCODE (b_and):
+    case OPCODE (b_or):
+    case OPCODE (b_xor):
+    case OPCODE (equal_value):
+    case OPCODE (not_equal_value):
+    case OPCODE (equal_value_type):
+    case OPCODE (not_equal_value_type):
+    case OPCODE (less_than):
+    case OPCODE (greater_than):
+    case OPCODE (less_or_equal_than):
+    case OPCODE (greater_or_equal_than):
+    case OPCODE (instanceof):
+    case OPCODE (in):
+    case OPCODE (addition):
+    case OPCODE (substraction):
+    case OPCODE (division):
+    case OPCODE (multiplication):
+    case OPCODE (remainder):
+    {
+      change_uid (om, lit_ids, 0x111);
+      break;
+    }
+    case OPCODE (call_n):
+    case OPCODE (native_call):
+    case OPCODE (construct_n):
+    case OPCODE (func_expr_n):
+    case OPCODE (delete_var):
+    case OPCODE (typeof):
+    case OPCODE (b_not):
+    case OPCODE (logical_not):
+    case OPCODE (post_incr):
+    case OPCODE (post_decr):
+    case OPCODE (pre_incr):
+    case OPCODE (pre_decr):
+    case OPCODE (unary_plus):
+    case OPCODE (unary_minus):
+    {
+      change_uid (om, lit_ids, 0x110);
+      break;
+    }
+    case OPCODE (assignment):
+    {
+      switch (om->op.data.assignment.type_value_right)
+      {
+        case OPCODE_ARG_TYPE_SIMPLE:
+        case OPCODE_ARG_TYPE_SMALLINT:
+        case OPCODE_ARG_TYPE_SMALLINT_NEGATE:
+        {
+          change_uid (om, lit_ids, 0x100);
+          break;
+        }
+        case OPCODE_ARG_TYPE_NUMBER:
+        case OPCODE_ARG_TYPE_NUMBER_NEGATE:
+        case OPCODE_ARG_TYPE_STRING:
+        case OPCODE_ARG_TYPE_VARIABLE:
+        {
+          change_uid (om, lit_ids, 0x101);
+          break;
+        }
+      }
+      break;
+    }
+    case OPCODE (func_decl_n):
+    case OPCODE (array_decl):
+    case OPCODE (obj_decl):
+    case OPCODE (this_binding):
+    case OPCODE (with):
+    case OPCODE (throw_value):
+    case OPCODE (is_true_jmp_up):
+    case OPCODE (is_true_jmp_down):
+    case OPCODE (is_false_jmp_up):
+    case OPCODE (is_false_jmp_down):
+    case OPCODE (var_decl):
+    case OPCODE (retval):
+    {
+      change_uid (om, lit_ids, 0x100);
+      break;
+    }
+    case OPCODE (exitval):
+    case OPCODE (ret):
+    case OPCODE (try_block):
+    case OPCODE (jmp_up):
+    case OPCODE (jmp_down):
+    case OPCODE (nop):
+    case OPCODE (reg_var_decl):
+    {
+      change_uid (om, lit_ids, 0x000);
+      break;
+    }
+    case OPCODE (meta):
+    {
+      switch (om->op.data.meta.type)
+      {
+        case OPCODE_META_TYPE_VARG_PROP_DATA:
+        case OPCODE_META_TYPE_VARG_PROP_GETTER:
+        case OPCODE_META_TYPE_VARG_PROP_SETTER:
+        {
+          change_uid (om, lit_ids, 0x011);
+          break;
+        }
+        case OPCODE_META_TYPE_THIS_ARG:
+        case OPCODE_META_TYPE_VARG:
+        case OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER:
+        {
+          change_uid (om, lit_ids, 0x010);
+          break;
+        }
+        case OPCODE_META_TYPE_UNDEFINED:
+        case OPCODE_META_TYPE_END_WITH:
+        case OPCODE_META_TYPE_FUNCTION_END:
+        case OPCODE_META_TYPE_CATCH:
+        case OPCODE_META_TYPE_FINALLY:
+        case OPCODE_META_TYPE_END_TRY_CATCH_FINALLY:
+        case OPCODE_META_TYPE_STRICT_CODE:
+        {
+          change_uid (om, lit_ids, 0x000);
+          break;
+        }
+      }
+      break;
+    }
+  }
+  return om->op;
+}
+
+static idx_t
+count_new_literals_in_opcode (scopes_tree tree, opcode_counter_t opc_index)
+{
+  start_new_block_if_necessary ();
+  idx_t current_uid = next_uid;
+  op_meta *om = extract_op_meta (tree, opc_index);
+  switch (om->op.op_idx)
+  {
+    case OPCODE (prop_getter):
+    case OPCODE (prop_setter):
+    case OPCODE (delete_prop):
+    case OPCODE (b_shift_left):
+    case OPCODE (b_shift_right):
+    case OPCODE (b_shift_uright):
+    case OPCODE (b_and):
+    case OPCODE (b_or):
+    case OPCODE (b_xor):
+    case OPCODE (equal_value):
+    case OPCODE (not_equal_value):
+    case OPCODE (equal_value_type):
+    case OPCODE (not_equal_value_type):
+    case OPCODE (less_than):
+    case OPCODE (greater_than):
+    case OPCODE (less_or_equal_than):
+    case OPCODE (greater_or_equal_than):
+    case OPCODE (instanceof):
+    case OPCODE (in):
+    case OPCODE (addition):
+    case OPCODE (substraction):
+    case OPCODE (division):
+    case OPCODE (multiplication):
+    case OPCODE (remainder):
+    {
+      insert_uids_to_lit_id_map (om, 0x111);
+      break;
+    }
+    case OPCODE (call_n):
+    case OPCODE (native_call):
+    case OPCODE (construct_n):
+    case OPCODE (func_expr_n):
+    case OPCODE (delete_var):
+    case OPCODE (typeof):
+    case OPCODE (b_not):
+    case OPCODE (logical_not):
+    case OPCODE (post_incr):
+    case OPCODE (post_decr):
+    case OPCODE (pre_incr):
+    case OPCODE (pre_decr):
+    case OPCODE (unary_plus):
+    case OPCODE (unary_minus):
+    {
+      insert_uids_to_lit_id_map (om, 0x110);
+      break;
+    }
+    case OPCODE (assignment):
+    {
+      switch (om->op.data.assignment.type_value_right)
+      {
+        case OPCODE_ARG_TYPE_SIMPLE:
+        case OPCODE_ARG_TYPE_SMALLINT:
+        case OPCODE_ARG_TYPE_SMALLINT_NEGATE:
+        {
+          insert_uids_to_lit_id_map (om, 0x100);
+          break;
+        }
+        case OPCODE_ARG_TYPE_NUMBER:
+        case OPCODE_ARG_TYPE_NUMBER_NEGATE:
+        case OPCODE_ARG_TYPE_STRING:
+        case OPCODE_ARG_TYPE_VARIABLE:
+        {
+          insert_uids_to_lit_id_map (om, 0x101);
+          break;
+        }
+      }
+      break;
+    }
+    case OPCODE (func_decl_n):
+    case OPCODE (array_decl):
+    case OPCODE (obj_decl):
+    case OPCODE (this_binding):
+    case OPCODE (with):
+    case OPCODE (throw_value):
+    case OPCODE (is_true_jmp_up):
+    case OPCODE (is_true_jmp_down):
+    case OPCODE (is_false_jmp_up):
+    case OPCODE (is_false_jmp_down):
+    case OPCODE (var_decl):
+    case OPCODE (retval):
+    {
+      insert_uids_to_lit_id_map (om, 0x100);
+      break;
+    }
+    case OPCODE (exitval):
+    case OPCODE (ret):
+    case OPCODE (try_block):
+    case OPCODE (jmp_up):
+    case OPCODE (jmp_down):
+    case OPCODE (nop):
+    case OPCODE (reg_var_decl):
+    {
+      insert_uids_to_lit_id_map (om, 0x000);
+      break;
+    }
+    case OPCODE (meta):
+    {
+      switch (om->op.data.meta.type)
+      {
+        case OPCODE_META_TYPE_VARG_PROP_DATA:
+        case OPCODE_META_TYPE_VARG_PROP_GETTER:
+        case OPCODE_META_TYPE_VARG_PROP_SETTER:
+        {
+          insert_uids_to_lit_id_map (om, 0x011);
+          break;
+        }
+        case OPCODE_META_TYPE_THIS_ARG:
+        case OPCODE_META_TYPE_VARG:
+        case OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER:
+        {
+          insert_uids_to_lit_id_map (om, 0x010);
+          break;
+        }
+        case OPCODE_META_TYPE_UNDEFINED:
+        case OPCODE_META_TYPE_END_WITH:
+        case OPCODE_META_TYPE_FUNCTION_END:
+        case OPCODE_META_TYPE_CATCH:
+        case OPCODE_META_TYPE_FINALLY:
+        case OPCODE_META_TYPE_END_TRY_CATCH_FINALLY:
+        case OPCODE_META_TYPE_STRICT_CODE:
+        {
+          insert_uids_to_lit_id_map (om, 0x000);
+          break;
+        }
+      }
+      break;
+    }
+  }
+  return (idx_t) (next_uid - current_uid);
+}
+
+/* Before filling literal indexes 'hash' table we shall initiate it with number of neccesary literal indexes.
+   Since bytecode is divided into blocks and id of the block is a part of hash key, we shall divide bytecode
+   into blocks and count unique literal indexes used in each block. */
+size_t
+scopes_tree_count_literals_in_blocks (scopes_tree tree)
+{
+  assert_tree (tree);
+  size_t result = 0;
+  if (lit_id_to_uid != null_hash)
+  {
+    hash_table_free (lit_id_to_uid);
+    lit_id_to_uid = null_hash;
+  }
+  next_uid = 0;
+  global_oc = 0;
+
+  assert_tree (tree);
+  opcode_counter_t opc_index;
+  bool header = true;
+  for (opc_index = 0; opc_index < tree->opcodes_num; opc_index++)
+  {
+    op_meta *om = extract_op_meta (tree, opc_index);
+    if (om->op.op_idx != OPCODE (var_decl)
+        && om->op.op_idx != OPCODE (meta) && !header)
+    {
+      break;
+    }
+    if (om->op.op_idx == OPCODE (reg_var_decl))
+    {
+      header = false;
+    }
+    result += count_new_literals_in_opcode (tree, opc_index);
+  }
+  for (uint8_t child_id = 0; child_id < tree->t.children_num; child_id++)
+  {
+    result += scopes_tree_count_literals_in_blocks (*(scopes_tree *) linked_list_element (tree->t.children, child_id));
+  }
+  for (; opc_index < tree->opcodes_num; opc_index++)
+  {
+    result += count_new_literals_in_opcode (tree, opc_index);
+  }
+
+  return result;
+}
+
+/* This function performs functions hoisting.
+
+   Each scope consists of four parts:
+   1) Header with 'use strict' marker and reg_var_decl opcode
+   2) Variable declarations, dumped by the preparser
+   3) Function declarations
+   4) Computational code
+
+   Header and var_decls are dumped first,
+   then we shall recursively dump function declaration,
+   and finally, other opcodes.
+
+   For each opcodes block (size of block is defined in bytecode-data.h)
+   literal indexes 'hash' table is filled. */
+static void
+merge_subscopes (scopes_tree tree, opcode_t *data, lit_id_hash_table *lit_ids)
+{
+  assert_tree (tree);
+  JERRY_ASSERT (data);
+  opcode_counter_t opc_index;
+  bool header = true;
+  for (opc_index = 0; opc_index < tree->opcodes_num; opc_index++)
+  {
+    op_meta *om = extract_op_meta (tree, opc_index);
+    if (om->op.op_idx != OPCODE (var_decl)
+        && om->op.op_idx != OPCODE (meta) && !header)
+    {
+      break;
+    }
+    if (om->op.op_idx == OPCODE (reg_var_decl))
+    {
+      header = false;
+    }
+    data[global_oc] = generate_opcode (tree, opc_index, lit_ids);
+    global_oc++;
+  }
+  for (uint8_t child_id = 0; child_id < tree->t.children_num; child_id++)
+  {
+    merge_subscopes (*(scopes_tree *) linked_list_element (tree->t.children, child_id),
+                     data, lit_ids);
+  }
+  for (; opc_index < tree->opcodes_num; opc_index++)
+  {
+    data[global_oc] = generate_opcode (tree, opc_index, lit_ids);
+    global_oc++;
+  }
+}
+
+/* Postparser.
+   Init literal indexes 'hash' table.
+   Reorder function declarations.
+   Rewrite opcodes' temporary uids with their keys in literal indexes 'hash' table. */
+opcode_t *
+scopes_tree_raw_data (scopes_tree tree, lit_id_hash_table *lit_ids)
+{
+  JERRY_ASSERT (lit_ids);
+  assert_tree (tree);
+  if (lit_id_to_uid != null_hash)
+  {
+    hash_table_free (lit_id_to_uid);
+    lit_id_to_uid = null_hash;
+  }
+  next_uid = 0;
+  global_oc = 0;
+
+  /* Dump bytecode and fill literal indexes 'hash' table. */
+  size_t size = ((size_t) (scopes_tree_count_opcodes (tree) + 1) * sizeof (opcode_t)); // +1 for valgrind
+  opcode_t *opcodes = (opcode_t *) mem_heap_alloc_block (size, MEM_HEAP_ALLOC_LONG_TERM);
+  memset (opcodes, 0, size);
+  merge_subscopes (tree, opcodes, lit_ids);
+  if (lit_id_to_uid != null_hash)
+  {
+    hash_table_free (lit_id_to_uid);
+    lit_id_to_uid = null_hash;
+  }
+  return opcodes;
+}
+
+void
+scopes_tree_set_strict_mode (scopes_tree tree, bool strict_mode)
+{
+  assert_tree (tree);
+  tree->strict_mode = strict_mode ? 1 : 0;
+}
+
+bool
+scopes_tree_strict_mode (scopes_tree tree)
+{
+  assert_tree (tree);
+  return (bool) tree->strict_mode;
+}
+
+scopes_tree
+scopes_tree_init (scopes_tree parent)
+{
+  scopes_tree tree = (scopes_tree) mem_heap_alloc_block (sizeof (scopes_tree_int), MEM_HEAP_ALLOC_SHORT_TERM);
+  memset (tree, 0, sizeof (scopes_tree_int));
+  tree->t.magic = TREE_MAGIC;
+  tree->t.parent = (tree_header *) parent;
+  tree->t.children = null_list;
+  tree->t.children_num = 0;
+  if (parent != NULL)
+  {
+    if (parent->t.children_num == 0)
+    {
+      parent->t.children = linked_list_init (sizeof (scopes_tree));
+    }
+    linked_list_set_element (parent->t.children, parent->t.children_num, &tree);
+    void *added = linked_list_element (parent->t.children, parent->t.children_num);
+    JERRY_ASSERT (*(scopes_tree *) added == tree);
+    parent->t.children_num++;
+  }
+  tree->opcodes_num = 0;
+  tree->strict_mode = 0;
+  tree->opcodes = linked_list_init (sizeof (op_meta));
+  return tree;
+}
+
+void
+scopes_tree_free (scopes_tree tree)
+{
+  assert_tree (tree);
+  if (tree->t.children_num != 0)
+  {
+    for (uint8_t i = 0; i < tree->t.children_num; ++i)
+    {
+      scopes_tree_free (*(scopes_tree *) linked_list_element (tree->t.children, i));
+    }
+    linked_list_free (tree->t.children);
+  }
+  linked_list_free (tree->opcodes);
+  mem_heap_free_block ((uint8_t *) tree);
+}

jerry-core/parser/js/scopes-tree.h

@@ -0,0 +1,60 @@
+/* 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 SCOPES_TREE_H
+#define SCOPES_TREE_H
+
+#include "tree.h"
+#include "linked-list.h"
+#include "lexer.h"
+#include "ecma-globals.h"
+#include "hash-table.h"
+#include "opcodes.h"
+#include "lit-id-hash-table.h"
+
+#define NOT_A_LITERAL (INVALID_LITERAL - 1)
+
+typedef struct
+{
+  literal_index_t lit_id[3];
+  opcode_t op;
+}
+op_meta;
+
+typedef struct
+{
+  tree_header t;
+  linked_list opcodes;
+  opcode_counter_t opcodes_num;
+  unsigned strict_mode:1;
+}
+scopes_tree_int;
+
+typedef scopes_tree_int * scopes_tree;
+
+scopes_tree scopes_tree_init (scopes_tree);
+void scopes_tree_free (scopes_tree);
+opcode_counter_t scopes_tree_opcodes_num (scopes_tree);
+void scopes_tree_add_op_meta (scopes_tree, op_meta);
+void scopes_tree_set_op_meta (scopes_tree, opcode_counter_t, op_meta);
+void scopes_tree_set_opcodes_num (scopes_tree, opcode_counter_t);
+op_meta scopes_tree_op_meta (scopes_tree, opcode_counter_t);
+size_t scopes_tree_count_literals_in_blocks (scopes_tree);
+opcode_counter_t scopes_tree_count_opcodes (scopes_tree);
+opcode_t *scopes_tree_raw_data (scopes_tree, lit_id_hash_table *);
+void scopes_tree_set_strict_mode (scopes_tree, bool);
+bool scopes_tree_strict_mode (scopes_tree);
+
+#endif /* SCOPES_TREE_H */

jerry-core/parser/js/serializer.cpp

@@ -0,0 +1,143 @@
+/* Copyright 2014-2015 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 "jrt.h"
+#include "serializer.h"
+#include "parser.h"
+#include "jrt-libc-includes.h"
+#include "bytecode-data.h"
+#include "deserializer.h"
+#include "pretty-printer.h"
+
+bytecode_data_t bytecode_data;
+scopes_tree current_scope;
+
+static bool print_opcodes;
+
+void
+serializer_set_scope (scopes_tree new_scope)
+{
+  current_scope = new_scope;
+}
+
+void
+serializer_merge_scopes_into_bytecode (void)
+{
+  JERRY_ASSERT (bytecode_data.lit_id_hash == null_hash);
+  bytecode_data.opcodes_count = scopes_tree_count_opcodes (current_scope);
+  bytecode_data.lit_id_hash = lit_id_hash_table_init (scopes_tree_count_literals_in_blocks (current_scope),
+                                                      bytecode_data.opcodes_count);
+  bytecode_data.opcodes = scopes_tree_raw_data (current_scope, bytecode_data.lit_id_hash);
+}
+
+void
+serializer_dump_literals (const literal literals[], literal_index_t literals_count)
+{
+#ifdef JERRY_ENABLE_PRETTY_PRINTER
+  if (print_opcodes)
+  {
+    pp_literals (literals, literals_count);
+  }
+#endif
+
+  bytecode_data.literals_count = literals_count;
+  bytecode_data.literals = literals;
+}
+
+void
+serializer_dump_op_meta (op_meta op)
+{
+  JERRY_ASSERT (scopes_tree_opcodes_num (current_scope) < MAX_OPCODES);
+
+  scopes_tree_add_op_meta (current_scope, op);
+
+#ifdef JERRY_ENABLE_PRETTY_PRINTER
+  if (print_opcodes)
+  {
+    pp_op_meta ((opcode_counter_t) (scopes_tree_opcodes_num (current_scope) - 1), op, false);
+  }
+#endif
+}
+
+opcode_counter_t
+serializer_get_current_opcode_counter (void)
+{
+  return scopes_tree_opcodes_num (current_scope);
+}
+
+opcode_counter_t
+serializer_count_opcodes_in_subscopes (void)
+{
+  return (opcode_counter_t) (scopes_tree_count_opcodes (current_scope) - scopes_tree_opcodes_num (current_scope));
+}
+
+void
+serializer_set_writing_position (opcode_counter_t oc)
+{
+  scopes_tree_set_opcodes_num (current_scope, oc);
+}
+
+void
+serializer_rewrite_op_meta (const opcode_counter_t loc, op_meta op)
+{
+  scopes_tree_set_op_meta (current_scope, loc, op);
+
+#ifdef JERRY_ENABLE_PRETTY_PRINTER
+  if (print_opcodes)
+  {
+    pp_op_meta (loc, op, true);
+  }
+#endif
+}
+
+void
+serializer_print_opcodes (void)
+{
+#ifdef JERRY_ENABLE_PRETTY_PRINTER
+  opcode_counter_t loc;
+
+  if (!print_opcodes)
+  {
+    return;
+  }
+
+  printf ("AFTER OPTIMIZER:\n");
+
+  for (loc = 0; loc < bytecode_data.opcodes_count; loc++)
+  {
+    op_meta opm;
+
+    opm.op = bytecode_data.opcodes[loc];
+    for (int i = 0; i < 3; i++)
+    {
+      opm.lit_id [i] = NOT_A_LITERAL;
+    }
+
+    pp_op_meta (loc, opm, false);
+  }
+#endif
+}
+
+void
+serializer_init (bool show_opcodes)
+{
+  current_scope = NULL;
+  print_opcodes = show_opcodes;
+}
+
+void
+serializer_free (void)
+{
+}

jerry-core/parser/js/serializer.h

@@ -0,0 +1,38 @@
+/* Copyright 2014-2015 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 SERIALIZER_H
+#define SERIALIZER_H
+
+#include "jrt.h"
+#include "ecma-globals.h"
+#include "opcodes.h"
+#include "vm.h"
+#include "literal.h"
+#include "scopes-tree.h"
+
+void serializer_init (bool show_opcodes);
+void serializer_dump_literals (const literal *, literal_index_t);
+void serializer_set_scope (scopes_tree);
+void serializer_merge_scopes_into_bytecode (void);
+void serializer_dump_op_meta (op_meta);
+opcode_counter_t serializer_get_current_opcode_counter (void);
+opcode_counter_t serializer_count_opcodes_in_subscopes (void);
+void serializer_set_writing_position (opcode_counter_t);
+void serializer_rewrite_op_meta (opcode_counter_t, op_meta);
+void serializer_print_opcodes (void);
+void serializer_free (void);
+
+#endif // SERIALIZER_H

jerry-core/parser/js/syntax-errors.cpp

@@ -0,0 +1,224 @@
+/* Copyright 2014-2015 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 "syntax-errors.h"
+#include "stack.h"
+#include "jrt.h"
+#include "parser.h"
+#include "jrt-libc-includes.h"
+#include "ecma-helpers.h"
+
+typedef struct
+{
+  prop_type type;
+  literal lit;
+}
+prop_literal;
+
+enum
+{
+  props_global_size
+};
+STATIC_STACK (props, prop_literal)
+
+enum
+{
+  U8_global_size
+};
+STATIC_STACK (U8, uint8_t)
+
+static prop_literal
+create_prop_literal (literal lit, prop_type type)
+{
+  prop_literal ret;
+
+  ret.type = type;
+  ret.lit = lit;
+
+  return ret;
+}
+
+void
+syntax_start_checking_of_prop_names (void)
+{
+  STACK_PUSH (U8, (uint8_t) STACK_SIZE (props));
+}
+
+void
+syntax_add_prop_name (operand op, prop_type pt)
+{
+  JERRY_ASSERT (op.type == OPERAND_LITERAL);
+  STACK_PUSH (props, create_prop_literal (lexer_get_literal_by_id (op.data.lit_id), pt));
+}
+
+void
+syntax_check_for_duplication_of_prop_names (bool is_strict, locus loc __attr_unused___)
+{
+  if (STACK_SIZE (props) - STACK_TOP (U8) < 2)
+  {
+    STACK_DROP (U8, 1);
+    return;
+  }
+
+  for (uint8_t i = (uint8_t) (STACK_TOP (U8) + 1);
+       i < STACK_SIZE (props);
+       i++)
+  {
+    const prop_literal previous = STACK_ELEMENT (props, i);
+    if (previous.type == VARG)
+    {
+      continue;
+    }
+    JERRY_ASSERT (previous.type == PROP_DATA
+                  || previous.type == PROP_GET
+                  || previous.type == PROP_SET);
+    for (uint8_t j = STACK_TOP (U8); j < i; j = (uint8_t) (j + 1))
+    {
+      /*4*/
+      const prop_literal current = STACK_ELEMENT (props, j);
+      if (current.type == VARG)
+      {
+        continue;
+      }
+      JERRY_ASSERT (current.type == PROP_DATA
+                    || current.type == PROP_GET
+                    || current.type == PROP_SET);
+      if (literal_equal (previous.lit, current.lit))
+      {
+        /*a*/
+        if (is_strict && previous.type == PROP_DATA && current.type == PROP_DATA)
+        {
+          PARSE_ERROR_VARG ("Duplication of parameter name '%s' in ObjectDeclaration is not allowed in strict mode",
+                            loc, (const char *) literal_to_zt (current.lit));
+        }
+        /*b*/
+        if (previous.type == PROP_DATA
+            && (current.type == PROP_SET || current.type == PROP_GET))
+        {
+          PARSE_ERROR_VARG ("Parameter name '%s' in ObjectDeclaration may not be both data and accessor",
+                            loc, (const char *) literal_to_zt (current.lit));
+        }
+        /*c*/
+        if (current.type == PROP_DATA
+            && (previous.type == PROP_SET || previous.type == PROP_GET))
+        {
+          PARSE_ERROR_VARG ("Parameter name '%s' in ObjectDeclaration may not be both data and accessor",
+                            loc, (const char *) literal_to_zt (current.lit));
+        }
+        /*d*/
+        if ((previous.type == PROP_SET && current.type == PROP_SET)
+            || (previous.type == PROP_GET && current.type == PROP_GET))
+        {
+          PARSE_ERROR_VARG ("Parameter name '%s' in ObjectDeclaration may not be accessor of same type",
+                            loc, (const char *) literal_to_zt (current.lit));
+        }
+      }
+    }
+  }
+
+  STACK_DROP (props, (uint8_t) (STACK_SIZE (props) - STACK_TOP (U8)));
+  STACK_DROP (U8, 1);
+}
+
+void
+syntax_start_checking_of_vargs (void)
+{
+  STACK_PUSH (U8, (uint8_t) STACK_SIZE (props));
+}
+
+void syntax_add_varg (operand op)
+{
+  JERRY_ASSERT (op.type == OPERAND_LITERAL);
+  STACK_PUSH (props, create_prop_literal (lexer_get_literal_by_id (op.data.lit_id), VARG));
+}
+
+static void
+emit_error_on_eval_and_arguments (operand op, locus loc __attr_unused___)
+{
+  if (op.type == OPERAND_LITERAL)
+  {
+    if (literal_equal_type_zt (lexer_get_literal_by_id (op.data.lit_id),
+                               ecma_get_magic_string_zt (ECMA_MAGIC_STRING_ARGUMENTS))
+        || literal_equal_type_zt (lexer_get_literal_by_id (op.data.lit_id),
+                                  ecma_get_magic_string_zt (ECMA_MAGIC_STRING_EVAL)))
+    {
+      PARSE_ERROR ("'eval' and 'arguments' are not allowed here in strict mode", loc);
+    }
+  }
+}
+
+void
+syntax_check_for_eval_and_arguments_in_strict_mode (operand op, bool is_strict, locus loc)
+{
+  if (is_strict)
+  {
+    emit_error_on_eval_and_arguments (op, loc);
+  }
+}
+
+/* 13.1, 15.3.2 */
+void
+syntax_check_for_syntax_errors_in_formal_param_list (bool is_strict, locus loc __attr_unused___)
+{
+  if (STACK_SIZE (props) - STACK_TOP (U8) < 2 || !is_strict)
+  {
+    STACK_DROP (U8, 1);
+    return;
+  }
+  for (uint8_t i = (uint8_t) (STACK_TOP (U8) + 1); i < STACK_SIZE (props); i = (uint8_t) (i + 1))
+  {
+    JERRY_ASSERT (STACK_ELEMENT (props, i).type == VARG);
+    const literal previous = STACK_ELEMENT (props, i).lit;
+    JERRY_ASSERT (previous.type == LIT_STR || previous.type == LIT_MAGIC_STR);
+    for (uint8_t j = STACK_TOP (U8); j < i; j = (uint8_t) (j + 1))
+    {
+      JERRY_ASSERT (STACK_ELEMENT (props, j).type == VARG);
+      const literal current = STACK_ELEMENT (props, j).lit;
+      JERRY_ASSERT (current.type == LIT_STR || current.type == LIT_MAGIC_STR);
+      if (literal_equal_type (previous, current))
+      {
+        PARSE_ERROR_VARG ("Duplication of literal '%s' in FormalParameterList is not allowed in strict mode",
+                          loc, (const char *) literal_to_zt (previous));
+      }
+    }
+  }
+
+  STACK_DROP (props, (uint8_t) (STACK_SIZE (props) - STACK_TOP (U8)));
+  STACK_DROP (U8, 1);
+}
+
+void
+syntax_check_delete (bool is_strict, locus loc __attr_unused___)
+{
+  if (is_strict)
+  {
+    PARSE_ERROR ("'delete' operator shall not apply on identifier in strict mode.", loc);
+  }
+}
+
+void
+syntax_init (void)
+{
+  STACK_INIT (props);
+  STACK_INIT (U8);
+}
+
+void
+syntax_free (void)
+{
+  STACK_FREE (U8);
+  STACK_FREE (props);
+}
+

jerry-core/parser/js/syntax-errors.h

@@ -0,0 +1,104 @@
+/* Copyright 2014-2015 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 SYNTAX_ERRORS_H
+#define SYNTAX_ERRORS_H
+
+#include "literal.h"
+#include "opcodes-dumper.h"
+#include "lexer.h"
+
+#ifndef JERRY_NDEBUG
+#define PARSE_ERROR(MESSAGE, LOCUS) do { \
+  size_t line, column; \
+  lexer_locus_to_line_and_column ((locus) (LOCUS), &line, &column); \
+  lexer_dump_line (line); \
+  printf ("\n"); \
+  for (size_t i = 0; i < column; i++) { \
+    putchar (' '); \
+  } \
+  printf ("^\n"); \
+  printf ("ERROR: Ln %lu, Col %lu: %s\n", (unsigned long) (line + 1), (unsigned long) (column + 1), MESSAGE); \
+  jerry_fatal (ERR_PARSER); \
+} while (0)
+#define PARSE_WARN(MESSAGE, LOCUS) do { \
+  size_t line, column; \
+  lexer_locus_to_line_and_column ((locus) (LOCUS), &line, &column); \
+  printf ("WARNING: Ln %lu, Col %lu: %s\n", (unsigned long) (line + 1), (unsigned long) (column + 1), MESSAGE); \
+} while (0)
+#define PARSE_ERROR_VARG(MESSAGE, LOCUS, ...) do { \
+  size_t line, column; \
+  lexer_locus_to_line_and_column ((locus) (LOCUS), &line, &column); \
+  lexer_dump_line (line); \
+  printf ("\n"); \
+  for (size_t i = 0; i < column; i++) { \
+    putchar (' '); \
+  } \
+  printf ("^\n"); \
+  printf ("ERROR: Ln %lu, Col %lu: ", (unsigned long) (line + 1), (unsigned long) (column + 1)); \
+  printf (MESSAGE, __VA_ARGS__); \
+  printf ("\n"); \
+  jerry_fatal (ERR_PARSER); \
+} while (0)
+#define PARSE_SORRY(MESSAGE, LOCUS) do { \
+  size_t line, column; \
+  lexer_locus_to_line_and_column ((locus) (LOCUS), &line, &column); \
+  lexer_dump_line (line); \
+  printf ("\n"); \
+  for (size_t i = 0; i < column; i++) { \
+    putchar (' '); \
+  } \
+    printf ("^\n"); \
+  printf ("SORRY, Unimplemented: Ln %lu, Col %lu: %s\n", (unsigned long) (line + 1), (unsigned long) (column + 1), MESSAGE); \
+  JERRY_UNIMPLEMENTED ("Unimplemented parser feature."); \
+} while (0)
+#else /* JERRY_NDEBUG */
+#define PARSE_ERROR(MESSAGE, LOCUS) do { \
+  jerry_fatal (ERR_PARSER); \
+} while (0)
+#define PARSE_WARN(MESSAGE, LOCUS) do { \
+} while (0)
+#define PARSE_ERROR_VARG(MESSAGE, LOCUS, ...) do { \
+  jerry_fatal (ERR_PARSER); \
+} while (0)
+#define PARSE_SORRY(MESSAGE, LOCUS) do { \
+  JERRY_UNIMPLEMENTED ("Unimplemented parser feature."); \
+} while (0)
+#endif /* JERRY_NDEBUG */
+
+typedef enum
+{
+  PROP_DATA,
+  PROP_SET,
+  PROP_GET,
+  VARG
+}
+prop_type;
+
+void syntax_init (void);
+void syntax_free (void);
+
+void syntax_start_checking_of_prop_names (void);
+void syntax_add_prop_name (operand, prop_type);
+void syntax_check_for_duplication_of_prop_names (bool, locus);
+
+void syntax_start_checking_of_vargs (void);
+void syntax_add_varg (operand);
+void syntax_check_for_eval_and_arguments_in_strict_mode (operand, bool, locus);
+void syntax_check_for_syntax_errors_in_formal_param_list (bool, locus);
+
+void syntax_check_delete (bool, locus);
+
+#endif /* SYNTAX_ERRORS_H */