Part I: Implement ES2015 module system. (#2599)

JerryScript-DCO-1.0-Signed-off-by: Daniel Vince vinced@inf.u-szeged.hu
2019-03-18 16:22:06 +01:00
parent 3d3e6fdf58
commit 4123f35a3b
45 changed files with 2095 additions and 8 deletions
@@ -296,6 +296,59 @@ typedef struct

 #endif /* JERRY_DEBUGGER */

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+/**
+ * String struct for storing the module path.
+ */
+typedef struct parser_module_utf8_string
+{
+  uint8_t *value_p;     /**< string value stored as uint8_t */
+  prop_length_t length; /**< length of the string */
+} parser_module_utf8_string_t;
+
+/**
+ * Imported or exported names, for example:
+ * import { v as x } from "module";
+ *  exported name: v
+ *  imported name: x
+ * export x as v;
+ *  exported variable: x
+ *  exported as: v
+ * Reference: https://www.ecma-international.org/ecma-262/6.0/#table-41
+ */
+typedef struct parser_module_names
+{
+  ecma_string_t *import_name_p; /**< local name of the import - export item */
+  ecma_string_t *local_name_p;  /**< import name of the import - export item */
+
+  struct parser_module_names *next_p; /**< next linked list node */
+} parser_module_names_t;
+
+/**
+ * Module node to store imports / exports.
+ */
+typedef struct parser_module_node
+{
+  parser_module_names_t *module_names_p; /**< names of the requested imports - exports */
+  uint16_t module_request_count;         /**< count of the requested imports - exports */
+
+  parser_module_utf8_string_t script_path; /**< path of the requested module*/
+
+  struct parser_module_node *next_p; /**< next linked list node */
+} parser_module_node_t;
+
+/**
+ * Module context in the parser context. It is not in the context if modules
+ * are not enabled during the build. It's value is NULL if there is no import /
+ * export in the script, otherwise it contains all the imports and exports.
+ */
+typedef struct
+{
+  parser_module_node_t *imports_p; /**< import item of the current context */
+  parser_module_node_t *exports_p; /**< export item of the current context */
+} parser_module_context_t;
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
 /**
 * Those members of a context which needs
 * to be saved when a sub-function is parsed.
@@ -342,6 +395,11 @@ typedef struct
  parser_saved_context_t *last_context_p;     /**< last saved context */
  parser_stack_iterator_t last_statement;     /**< last statement position */

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+  parser_module_context_t *module_context_p;  /**< shared module context inside the parser */
+  parser_module_node_t *module_current_node_p; /**< import / export node that is being processed */
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
  /* Lexer members. */
  lexer_token_t token;                        /**< current token */
  lexer_lit_object_t lit_object;              /**< current literal object */
@@ -548,6 +606,38 @@ void parser_scan_until (parser_context_t *context_p, lexer_range_t *range_p, lex
 void parser_parse_statements (parser_context_t *context_p);
 void parser_free_jumps (parser_stack_iterator_t iterator);

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+/**
+ * @}
+ *
+ * \addtogroup jsparser_stmt Module statement parser
+ * @{
+ */
+
+void parser_module_add_export_node_to_context (parser_context_t *context_p);
+void parser_module_add_import_node_to_context (parser_context_t *context_p);
+void parser_module_check_request_place (parser_context_t *context_p);
+void parser_module_context_cleanup (parser_context_t *context_p);
+void parser_module_context_init (parser_context_t *context_p);
+void parser_module_free_saved_names (parser_module_node_t *module_node_p);
+void parser_module_handle_from_clause (parser_context_t *context_p);
+void parser_module_handle_requests (parser_context_t *context_p);
+void parser_module_partial_cleanup_on_error (parser_module_node_t *module_node_p);
+void parser_module_parse_export_item_list (parser_context_t *context_p);
+void parser_module_parse_import_item_list (parser_context_t *context_p);
+
+parser_module_node_t *parser_module_create_module_node (parser_context_t *context_p,
+                                                        parser_module_node_t *template_node_p);
+parser_module_node_t *parser_module_get_export_node (parser_context_t *context_p);
+
+void parser_module_add_item_to_node (parser_context_t *context_p,
+                                     parser_module_node_t *module_node_p,
+                                     lexer_literal_t *import_name_p,
+                                     lexer_literal_t *local_name_p,
+                                     bool is_import_item);
+
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
 /**
 * @}
 *
@@ -0,0 +1,603 @@
+/* Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * 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 "js-parser-internal.h"
+
+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+#include "jcontext.h"
+#include "jerryscript-port.h"
+
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-helpers.h"
+#include "ecma-literal-storage.h"
+#include "ecma-lex-env.h"
+#include "ecma-module.h"
+
+/**
+ * Maximum import count limit.
+ */
+#define MAX_IMPORT_COUNT UINT16_MAX
+
+/**
+ * Check duplicates in module node.
+ * @return true - if the given item is duplicated entry in the current node
+ *         false - otherwise
+ */
+static bool
+parser_module_check_for_duplicates_in_node (parser_module_node_t *module_node_p, /**< module node */
+                                            lexer_literal_t *import_name_p) /**< newly imported name */
+{
+  JERRY_ASSERT (import_name_p != NULL);
+
+  parser_module_names_t *import_names_p = module_node_p->module_names_p;
+
+  while (import_names_p != NULL)
+  {
+    uint8_t flags = ECMA_STRING_FLAG_IS_ASCII;
+    lit_utf8_size_t current_length = 0;
+    const uint8_t *current_p = ecma_string_get_chars (import_names_p->import_name_p, &current_length, &flags);
+
+    if (current_p != NULL && current_length == import_name_p->prop.length
+        && memcmp (current_p, import_name_p->u.char_p, current_length) == 0)
+    {
+      return true;
+    }
+
+    import_names_p = import_names_p->next_p;
+  }
+
+  return false;
+} /* parser_module_check_for_duplicates_in_node */
+
+/**
+ * Check duplicates in the whole module context.
+ * @return true - if the given item is duplicated entry
+ *         false - otherwise
+ */
+static bool
+parser_module_check_for_duplicates (parser_context_t *context_p, /**< parser context */
+                                    parser_module_node_t *module_node_p, /**< module noda */
+                                    lexer_literal_t *import_name_p) /**< newly imported name */
+{
+  if (import_name_p == NULL)
+  {
+    return false;
+  }
+
+  bool hasDuplicate = parser_module_check_for_duplicates_in_node (module_node_p,
+                                                                  import_name_p);
+
+  if (!hasDuplicate)
+  {
+    parser_module_node_t *node_p = context_p->module_context_p->imports_p;
+    while (node_p != NULL && !hasDuplicate)
+    {
+      hasDuplicate = parser_module_check_for_duplicates_in_node (node_p,
+                                                                 import_name_p);
+      node_p = node_p->next_p;
+    }
+  }
+
+  return hasDuplicate;
+} /* parser_module_check_for_duplicates */
+
+/**
+ * Delete the saved names from the given module node.
+ */
+void
+parser_module_free_saved_names (parser_module_node_t *module_node_p) /**< module node */
+{
+  if (module_node_p == NULL || module_node_p->module_names_p == NULL)
+  {
+    return;
+  }
+
+  parser_module_names_t *current_p = module_node_p->module_names_p;
+
+  for (uint16_t i = 0; i < module_node_p->module_request_count; i++)
+  {
+    parser_module_names_t *next_p = current_p->next_p;
+
+    if (current_p->import_name_p != NULL)
+    {
+      ecma_deref_ecma_string (current_p->import_name_p);
+      current_p->import_name_p = NULL;
+    }
+
+    if (current_p->local_name_p != NULL)
+    {
+      ecma_deref_ecma_string (current_p->local_name_p);
+      current_p->local_name_p = NULL;
+    }
+
+    parser_free (current_p, sizeof (parser_module_names_t));
+    current_p = next_p;
+  }
+} /* parser_module_free_saved_names */
+
+/**
+ * Add export node to parser context.
+ */
+void
+parser_module_add_export_node_to_context (parser_context_t *context_p) /**< parser context */
+{
+  parser_module_node_t *module_node_p = context_p->module_current_node_p;
+  parser_module_node_t *exports_p = context_p->module_context_p->exports_p;
+
+  if (exports_p != NULL)
+  {
+    parser_module_names_t *module_names_p = module_node_p->module_names_p;
+
+    for (uint16_t i = 0; i < module_node_p->module_request_count - 1 ; i++)
+    {
+      module_names_p = module_names_p->next_p;
+    }
+
+    module_names_p->next_p = exports_p->module_names_p;
+    exports_p->module_names_p = module_node_p->module_names_p;
+
+    int request_count = exports_p->module_request_count + module_node_p->module_request_count;
+
+    if ((uint16_t) request_count < MAX_IMPORT_COUNT)
+    {
+      exports_p->module_request_count = (uint16_t) request_count;
+    }
+    else
+    {
+      parser_raise_error (context_p, PARSER_ERR_MODULE_REQUEST_LIMIT_REACHED);
+    }
+  }
+  else
+  {
+    parser_module_node_t *export_node_p = parser_module_create_module_node (context_p, module_node_p);
+    context_p->module_context_p->exports_p = export_node_p;
+  }
+} /* parser_module_add_export_node_to_context */
+
+/**
+ * Add import node to parser context.
+ */
+void
+parser_module_add_import_node_to_context (parser_context_t *context_p) /**< parser context */
+{
+  parser_module_node_t *module_node_p = context_p->module_current_node_p;
+  parser_module_node_t *stored_imports = context_p->module_context_p->imports_p;
+  bool is_stored_module = false;
+
+  while (stored_imports != NULL)
+  {
+    if (stored_imports->script_path.length == module_node_p->script_path.length
+        && memcmp (stored_imports->script_path.value_p,
+                   module_node_p->script_path.value_p,
+                   stored_imports->script_path.length) == 0)
+    {
+      parser_free (module_node_p->script_path.value_p, module_node_p->script_path.length * sizeof (uint8_t));
+
+      parser_module_names_t *module_names_p = module_node_p->module_names_p;
+      is_stored_module = true;
+
+      for (uint16_t i = 0; i < module_node_p->module_request_count - 1; i++)
+      {
+        module_names_p = module_names_p->next_p;
+      }
+
+      module_names_p->next_p = stored_imports->module_names_p;
+      stored_imports->module_names_p = module_node_p->module_names_p;
+
+      int request_count = stored_imports->module_request_count + module_node_p->module_request_count;
+      if ((uint16_t) request_count < MAX_IMPORT_COUNT)
+      {
+        stored_imports->module_request_count = (uint16_t) request_count;
+      }
+      else
+      {
+        parser_raise_error (context_p, PARSER_ERR_MODULE_REQUEST_LIMIT_REACHED);
+      }
+
+      break;
+    }
+    stored_imports = stored_imports->next_p;
+  }
+
+  if (!is_stored_module)
+  {
+    parser_module_node_t *permanent_node_p = parser_module_create_module_node (context_p, module_node_p);
+    permanent_node_p->next_p = context_p->module_context_p->imports_p;
+    context_p->module_context_p->imports_p = permanent_node_p;
+  }
+
+} /* parser_module_add_import_node_to_context */
+
+/**
+ * Add import or export item to module node.
+ */
+void
+parser_module_add_item_to_node (parser_context_t *context_p, /**< parser context */
+                                parser_module_node_t *module_node_p, /**< current module node */
+                                lexer_literal_t *import_name_p, /**< import name */
+                                lexer_literal_t *local_name_p, /**< local name */
+                                bool is_import_item) /**< given item is import item */
+{
+  if (is_import_item
+      && parser_module_check_for_duplicates (context_p, module_node_p, import_name_p))
+  {
+    parser_raise_error (context_p, PARSER_ERR_DUPLICATED_LABEL);
+  }
+
+  parser_module_names_t *new_names_p = (parser_module_names_t *) parser_malloc (context_p,
+                                                                                sizeof (parser_module_names_t));
+
+  new_names_p->next_p = module_node_p->module_names_p;
+  module_node_p->module_names_p = new_names_p;
+
+  module_node_p->module_names_p->import_name_p = ecma_new_ecma_string_from_utf8 (import_name_p->u.char_p,
+                                                                                 import_name_p->prop.length);
+
+  module_node_p->module_names_p->local_name_p = ecma_new_ecma_string_from_utf8 (local_name_p->u.char_p,
+                                                                                local_name_p->prop.length);
+
+  module_node_p->module_request_count++;
+} /* parser_module_add_item_to_node */
+
+/**
+ * Cleanup the whole module context from parser context.
+ */
+void
+parser_module_context_cleanup (parser_context_t *context_p) /**< parser context */
+{
+  parser_module_context_t *module_context_p = context_p->module_context_p;
+
+  if (module_context_p == NULL)
+  {
+    return;
+  }
+
+  parser_module_node_t *current_node_p = module_context_p->imports_p;
+
+  while (current_node_p != NULL)
+  {
+    parser_free (current_node_p->script_path.value_p, current_node_p->script_path.length * sizeof (uint8_t));
+    parser_module_free_saved_names (current_node_p);
+
+    parser_module_node_t *next_node_p = current_node_p->next_p;
+
+    parser_free (current_node_p, sizeof (parser_module_node_t));
+    current_node_p = next_node_p;
+  }
+
+  parser_module_context_t *parent_context_p = JERRY_CONTEXT (module_top_context_p);
+  if ((parent_context_p == NULL || parent_context_p->exports_p == NULL || parent_context_p->imports_p == NULL)
+      && module_context_p->exports_p != NULL)
+  {
+    parser_module_free_saved_names (module_context_p->exports_p);
+    parser_free (module_context_p->exports_p, sizeof (parser_module_node_t));
+  }
+
+  parser_free (module_context_p, sizeof (parser_module_context_t));
+  context_p->module_context_p = NULL;
+} /* parser_module_context_cleanup */
+
+/**
+ * Create module context and bind to the parser context.
+ */
+void
+parser_module_context_init (parser_context_t *context_p) /**< parser context */
+{
+  if (context_p->module_context_p == NULL)
+  {
+    context_p->module_context_p = (parser_module_context_t *) parser_malloc (context_p,
+                                                                             sizeof (parser_module_context_t));
+
+    memset (context_p->module_context_p, 0, sizeof (parser_module_context_t));
+  }
+} /* parser_module_context_init */
+
+/**
+ * Create import node.
+ * @return - the copy of the template if the second parameter is not NULL.
+ *         - otherwise: an empty import node.
+ */
+parser_module_node_t *
+parser_module_create_module_node (parser_context_t *context_p, /**< parser context */
+                                  parser_module_node_t *template_node_p) /**< template node for the new node */
+{
+  parser_module_node_t *node = (parser_module_node_t *) parser_malloc (context_p, sizeof (parser_module_node_t));
+
+  if (template_node_p != NULL)
+  {
+    node->module_names_p = template_node_p->module_names_p;
+    node->module_request_count = template_node_p->module_request_count;
+
+    node->script_path.value_p = template_node_p->script_path.value_p;
+    node->script_path.length = template_node_p->script_path.length;
+    node->next_p = NULL;
+  }
+  else
+  {
+    memset (node, 0, sizeof (parser_module_node_t));
+  }
+
+  return node;
+} /* parser_module_create_module_node */
+
+/**
+ * Create export node or get the previously created one.
+ * @return the export node
+ */
+parser_module_node_t *
+parser_module_get_export_node (parser_context_t *context_p) /**< parser context */
+{
+  if (context_p->module_context_p->exports_p != NULL)
+  {
+    return context_p->module_context_p->exports_p;
+  }
+
+  return parser_module_create_module_node (context_p, NULL);
+} /* parser_module_get_export_node */
+
+/**
+ * Parse export item list.
+ */
+void
+parser_module_parse_export_item_list (parser_context_t *context_p) /**< parser context */
+{
+  if (context_p->token.type == LEXER_LITERAL
+      && lexer_compare_raw_identifier_to_current (context_p, "from", 4))
+  {
+    parser_raise_error (context_p, PARSER_ERR_INVALID_CHARACTER);
+  }
+
+  if (context_p->token.type == LEXER_KEYW_DEFAULT || context_p->token.type == LEXER_MULTIPLY)
+  {
+    /* TODO: This part is going to be implemented in the next part of the patch. */
+    parser_raise_error (context_p, PARSER_ERR_NOT_IMPLEMENTED);
+  }
+
+  bool has_export_name = false;
+  lexer_literal_t *export_name_p = NULL;
+  lexer_literal_t *local_name_p = NULL;
+  parser_module_node_t *module_node_p = context_p->module_current_node_p;
+
+  while (true)
+  {
+    if (has_export_name
+        && context_p->token.type != LEXER_KEYW_DEFAULT
+        && (context_p->token.type != LEXER_LITERAL
+            || lexer_compare_raw_identifier_to_current (context_p, "from", 4)
+            || lexer_compare_raw_identifier_to_current (context_p, "as", 2)))
+    {
+      parser_raise_error (context_p, PARSER_ERR_INVALID_CHARACTER);
+    }
+
+    if (context_p->token.lit_location.type != LEXER_IDENT_LITERAL
+        && context_p->token.lit_location.type != LEXER_STRING_LITERAL)
+    {
+      parser_raise_error (context_p, PARSER_ERR_PROPERTY_IDENTIFIER_EXPECTED);
+    }
+
+    lexer_construct_literal_object (context_p, &context_p->token.lit_location, LEXER_STRING_LITERAL);
+
+    if (has_export_name)
+    {
+      export_name_p = context_p->lit_object.literal_p;
+    }
+    else
+    {
+      local_name_p = context_p->lit_object.literal_p;
+      export_name_p = context_p->lit_object.literal_p;
+    }
+
+    lexer_next_token (context_p);
+
+    if (context_p->token.type == LEXER_COMMA)
+    {
+      has_export_name = false;
+      parser_module_add_item_to_node (context_p, module_node_p, export_name_p, local_name_p, false);
+    }
+    else if (context_p->token.type == LEXER_LITERAL
+             && lexer_compare_raw_identifier_to_current (context_p, "as", 2))
+    {
+      if (has_export_name)
+      {
+        parser_raise_error (context_p, PARSER_ERR_INVALID_CHARACTER);
+      }
+
+      has_export_name = true;
+    }
+    else
+    {
+      parser_module_add_item_to_node (context_p, module_node_p, export_name_p, local_name_p, false);
+      break;
+    }
+    lexer_next_token (context_p);
+  }
+} /* parser_module_parse_export_item_list */
+
+/**
+ * Parse import item list.
+ */
+void
+parser_module_parse_import_item_list (parser_context_t *context_p) /**< parser context */
+{
+  /* Import list is empty, the whole module will be loaded. */
+  if (context_p->token.type == LEXER_LITERAL
+      && lexer_compare_raw_identifier_to_current (context_p, "from", 4))
+  {
+    /* TODO: This part is going to be implemented in the next part of the patch. */
+    parser_raise_error (context_p, PARSER_ERR_NOT_IMPLEMENTED);
+  }
+
+  bool has_import_name = false;
+  lexer_literal_t *import_name_p = NULL;
+  lexer_literal_t *local_name_p = NULL;
+  parser_module_node_t *module_node_p = context_p->module_current_node_p;
+
+  while (true)
+  {
+    bool whole_module_needed = context_p->token.type == LEXER_MULTIPLY;
+
+    if (whole_module_needed)
+    {
+      parser_raise_error (context_p, PARSER_ERR_NOT_IMPLEMENTED);
+    }
+
+    if (context_p->token.type != LEXER_LITERAL
+        || lexer_compare_raw_identifier_to_current (context_p, "from", 4)
+        || lexer_compare_raw_identifier_to_current (context_p, "as", 2))
+    {
+      parser_raise_error (context_p, PARSER_ERR_INVALID_CHARACTER);
+    }
+
+    lexer_construct_literal_object (context_p, &context_p->token.lit_location, LEXER_IDENT_LITERAL);
+
+    if (has_import_name)
+    {
+      import_name_p = context_p->lit_object.literal_p;
+    }
+    else
+    {
+      local_name_p = context_p->lit_object.literal_p;
+      import_name_p = context_p->lit_object.literal_p;
+    }
+
+
+    lexer_next_token (context_p);
+
+    if (context_p->token.type == LEXER_RIGHT_BRACE
+        || (context_p->token.type == LEXER_LITERAL
+            && lexer_compare_raw_identifier_to_current (context_p, "from", 4)))
+    {
+      parser_module_add_item_to_node (context_p, module_node_p, import_name_p, local_name_p, true);
+      break;
+    }
+
+    if (context_p->token.type == LEXER_COMMA)
+    {
+      parser_module_add_item_to_node (context_p, module_node_p, import_name_p, local_name_p, true);
+      has_import_name = false;
+    }
+    else if (context_p->token.type == LEXER_LITERAL
+             && lexer_compare_raw_identifier_to_current (context_p, "as", 2))
+    {
+      if (has_import_name)
+      {
+        parser_raise_error (context_p, PARSER_ERR_INVALID_CHARACTER);
+      }
+
+      has_import_name = true;
+    }
+    else
+    {
+      parser_raise_error (context_p, PARSER_ERR_RIGHT_PAREN_COMMA_FROM_EXPECTED);
+    }
+    lexer_next_token (context_p);
+  }
+} /* parser_module_parse_import_item_list */
+
+/**
+ * Handle import requests.
+ * Check if imported variables are exported in the appropriate module.
+ * Raise parser error if imported item is not exported.
+ */
+void
+parser_module_handle_requests (parser_context_t *context_p) /**< parser context */
+{
+  parser_module_context_t *module_context_p = JERRY_CONTEXT (module_top_context_p);
+
+  if (context_p->module_context_p->exports_p == NULL || module_context_p == NULL)
+  {
+    return;
+  }
+
+  bool throw_error = false;
+
+  parser_module_names_t *import_name_p = module_context_p->imports_p->module_names_p;
+  parser_module_names_t *current_exports_p = context_p->module_context_p->exports_p->module_names_p;
+
+  for (uint16_t i = 0; i < module_context_p->imports_p->module_request_count; ++i)
+  {
+    bool request_is_found_in_module = false;
+    parser_module_names_t *export_iterator_p = current_exports_p;
+
+    for (uint16_t j = 0; j < context_p->module_context_p->exports_p->module_request_count;
+         ++j, export_iterator_p = export_iterator_p->next_p)
+    {
+      if (ecma_compare_ecma_strings (import_name_p->local_name_p, export_iterator_p->import_name_p))
+      {
+        request_is_found_in_module = true;
+        break;
+      }
+    }
+
+    if (!request_is_found_in_module)
+    {
+      parser_module_free_saved_names (context_p->module_context_p->exports_p);
+      throw_error = true;
+      break;
+    }
+
+    import_name_p = import_name_p->next_p;
+  }
+
+  *module_context_p->exports_p = *context_p->module_context_p->exports_p;
+  parser_free (context_p->module_context_p->exports_p, sizeof (parser_module_node_t));
+
+  if (throw_error)
+  {
+    parser_raise_error (context_p, PARSER_ERR_MODULE_REQUEST_NOT_FOUND);
+  }
+} /* parser_module_handle_requests */
+
+/**
+ * Raises parser error if the import or export statement is not in the global scope.
+ */
+void
+parser_module_check_request_place (parser_context_t *context_p) /**< parser context */
+{
+  if (context_p->last_context_p != NULL
+      || context_p->stack_top_uint8 != 0
+      || (JERRY_CONTEXT (status_flags) & ECMA_STATUS_DIRECT_EVAL) != 0)
+  {
+    parser_raise_error (context_p, PARSER_ERR_MODULE_UNEXPECTED);
+  }
+} /* parser_module_check_request_place */
+
+/**
+ * Handle from clause at the end of the import / export statement.
+ */
+void
+parser_module_handle_from_clause (parser_context_t *context_p) /**< parser context */
+{
+  parser_module_node_t *module_node_p = context_p->module_current_node_p;
+  lexer_expect_object_literal_id (context_p, LEXER_OBJ_IDENT_NO_OPTS);
+
+  if (context_p->lit_object.literal_p->prop.length == 0)
+  {
+    parser_raise_error (context_p, PARSER_ERR_PROPERTY_IDENTIFIER_EXPECTED);
+  }
+
+  module_node_p->script_path.length = (prop_length_t) (context_p->lit_object.literal_p->prop.length + 1);
+  module_node_p->script_path.value_p = (uint8_t *) parser_malloc (context_p,
+                                                                  module_node_p->script_path.length * sizeof (uint8_t));
+
+  memcpy (module_node_p->script_path.value_p,
+          context_p->lit_object.literal_p->u.char_p,
+          module_node_p->script_path.length);
+  module_node_p->script_path.value_p[module_node_p->script_path.length - 1] = '\0';
+
+  lexer_next_token (context_p);
+} /* parser_module_handle_from_clause */
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
@@ -324,6 +324,17 @@ parser_parse_var_statement (parser_context_t *context_p) /**< context */

    context_p->lit_object.literal_p->status_flags |= LEXER_FLAG_VAR;

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+    if (context_p->module_context_p != NULL && context_p->module_current_node_p != NULL)
+    {
+      parser_module_add_item_to_node (context_p,
+                                      context_p->module_current_node_p,
+                                      context_p->lit_object.literal_p,
+                                      context_p->lit_object.literal_p,
+                                      false);
+    }
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
    lexer_next_token (context_p);

    if (context_p->token.type == LEXER_ASSIGN)
@@ -389,6 +400,17 @@ parser_parse_function_statement (parser_context_t *context_p) /**< context */

  name_p = context_p->lit_object.literal_p;

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+  if (context_p->module_context_p != NULL && context_p->module_current_node_p != NULL)
+  {
+    parser_module_add_item_to_node (context_p,
+                                    context_p->module_current_node_p,
+                                    name_p,
+                                    name_p,
+                                    false);
+  }
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
  status_flags = PARSER_IS_FUNCTION | PARSER_IS_CLOSURE;
  if (context_p->lit_object.type != LEXER_LITERAL_OBJECT_ANY)
  {
@@ -1653,6 +1675,151 @@ parser_parse_continue_statement (parser_context_t *context_p) /**< context */
  }
 } /* parser_parse_continue_statement */

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+/**
+ * Parse import statement.
+ */
+static void
+parser_parse_import_statement (parser_context_t *context_p) /**< context */
+{
+  JERRY_ASSERT (context_p->token.type == LEXER_KEYW_IMPORT);
+
+  parser_module_check_request_place (context_p);
+  parser_module_context_init (context_p);
+
+  parser_module_node_t module_node;
+  memset (&module_node, 0, sizeof (parser_module_node_t));
+  context_p->module_current_node_p = &module_node;
+
+  lexer_next_token (context_p);
+
+  switch (context_p->token.type)
+  {
+    case LEXER_LEFT_BRACE:
+    {
+      lexer_next_token (context_p);
+      parser_module_parse_import_item_list (context_p);
+
+      if (context_p->token.type != LEXER_RIGHT_BRACE)
+      {
+        parser_raise_error (context_p, PARSER_ERR_RIGHT_PAREN_EXPECTED);
+      }
+
+      lexer_next_token (context_p);
+      break;
+    }
+
+    case LEXER_MULTIPLY:
+    case LEXER_LITERAL:
+    {
+      parser_module_parse_import_item_list (context_p);
+      break;
+    }
+
+    default:
+    {
+      parser_raise_error (context_p, PARSER_ERR_LEFT_PAREN_MULTIPLY_LITERAL_EXPECTED);
+    }
+  }
+
+  if (context_p->token.type != LEXER_LITERAL ||!lexer_compare_raw_identifier_to_current (context_p, "from", 4))
+  {
+    parser_raise_error (context_p, PARSER_ERR_FROM_EXPECTED);
+  }
+
+  parser_module_handle_from_clause (context_p);
+  parser_module_add_import_node_to_context (context_p);
+
+  context_p->module_current_node_p = NULL;
+} /* parser_parse_import_statement */
+
+/**
+ * Parse export statement.
+ */
+static void
+parser_parse_export_statement (parser_context_t *context_p) /**< context */
+{
+  JERRY_ASSERT (context_p->token.type == LEXER_KEYW_EXPORT);
+
+  parser_module_check_request_place (context_p);
+  parser_module_context_init (context_p);
+
+  parser_module_node_t module_node;
+  memset (&module_node, 0, sizeof (parser_module_node_t));
+  context_p->module_current_node_p = &module_node;
+
+  lexer_next_token (context_p);
+
+  switch (context_p->token.type)
+  {
+    case LEXER_LEFT_BRACE:
+    {
+      lexer_next_token (context_p);
+      parser_module_parse_export_item_list (context_p);
+
+      if (context_p->token.type != LEXER_RIGHT_BRACE)
+      {
+        parser_raise_error (context_p, PARSER_ERR_RIGHT_PAREN_EXPECTED);
+      }
+
+      lexer_next_token (context_p);
+      break;
+    }
+
+    case LEXER_KEYW_DEFAULT:
+    {
+      /* TODO: This part is going to be implemented in the next part of the patch. */
+      parser_raise_error (context_p, PARSER_ERR_NOT_IMPLEMENTED);
+      break;
+    }
+
+    case LEXER_MULTIPLY:
+    case LEXER_LITERAL:
+    {
+      parser_module_parse_export_item_list (context_p);
+      break;
+    }
+
+    case LEXER_KEYW_FUNCTION:
+    {
+      parser_parse_function_statement (context_p);
+      break;
+    }
+
+    case LEXER_KEYW_VAR:
+    {
+      parser_parse_var_statement (context_p);
+      break;
+    }
+
+    case LEXER_KEYW_CLASS:
+    {
+      /* TODO: This part is going to be implemented in the next part of the patch. */
+      parser_raise_error (context_p, PARSER_ERR_NOT_IMPLEMENTED);
+      break;
+    }
+
+    default:
+    {
+      parser_raise_error (context_p, PARSER_ERR_LEFT_PAREN_MULTIPLY_LITERAL_EXPECTED);
+      break;
+    }
+  }
+
+  if (context_p->token.type == LEXER_LITERAL
+      && lexer_compare_raw_identifier_to_current (context_p, "from", 4))
+  {
+    /* TODO: Import the requested properties from the given script and export
+             them from the current to make a redirection.
+       This part is going to be implemented in the next part of the patch. */
+    parser_raise_error (context_p, PARSER_ERR_NOT_IMPLEMENTED);
+  }
+
+  parser_module_add_export_node_to_context (context_p);
+  context_p->module_current_node_p = NULL;
+} /* parser_parse_export_statement */
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
 /**
 * Parse label statement.
 */
@@ -1898,6 +2065,20 @@ parser_parse_statements (parser_context_t *context_p) /**< context */
      }
 #endif /* !CONFIG_DISABLE_ES2015_CLASS */

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+      case LEXER_KEYW_IMPORT:
+      {
+        parser_parse_import_statement (context_p);
+        break;
+      }
+
+      case LEXER_KEYW_EXPORT:
+      {
+        parser_parse_export_statement (context_p);
+        break;
+      }
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
      case LEXER_KEYW_FUNCTION:
      {
        parser_parse_function_statement (context_p);
@@ -1064,6 +1064,46 @@ parser_error_to_string (parser_error_t error) /**< error code */
    {
      return "Non-strict argument definition.";
    }
+
+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+    case PARSER_ERR_MODULE_REQUEST_NOT_FOUND:
+    {
+      return "Import request not found in the module.";
+    }
+    case PARSER_ERR_FILE_NOT_FOUND:
+    {
+      return "Requested module not found.";
+    }
+    case PARSER_ERR_NOT_IMPLEMENTED:
+    {
+      return "Requested feature is not implemented yet.";
+    }
+    case PARSER_ERR_LEFT_PAREN_MULTIPLY_LITERAL_EXPECTED:
+    {
+      return "Expected '{' or '*' or literal token.";
+    }
+    case PARSER_ERR_RIGHT_PAREN_COMMA_FROM_EXPECTED:
+    {
+      return "Expected '}' or 'as' or 'from' literal token.";
+    }
+    case PARSER_ERR_FROM_EXPECTED:
+    {
+      return "Expected 'from' token.";
+    }
+    case PARSER_ERR_STRING_EXPECTED:
+    {
+      return "Expected a string.";
+    }
+    case PARSER_ERR_MODULE_REQUEST_LIMIT_REACHED:
+    {
+      return "Maximum module request count reached.";
+    }
+    case PARSER_ERR_MODULE_UNEXPECTED:
+    {
+      return "Import and export statements must be in the global context.";
+    }
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
    default:
    {
      JERRY_ASSERT (error == PARSER_ERR_NO_ERROR);
@@ -19,6 +19,7 @@
 #include "ecma-literal-storage.h"
 #include "jcontext.h"
 #include "js-parser-internal.h"
+#include "ecma-module.h"

 #ifndef JERRY_DISABLE_JS_PARSER

@@ -2360,7 +2361,7 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
                     parser_error_location_t *error_location_p) /**< error location */
 {
  parser_context_t context;
-  ecma_compiled_code_t *compiled_code;
+  ecma_compiled_code_t *compiled_code_p;

  context.error = PARSER_ERR_NO_ERROR;
  context.allocated_buffer_p = NULL;
@@ -2397,6 +2398,10 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
  context.last_statement.current_p = NULL;
  context.status_flags |= parse_opts & PARSER_STRICT_MODE_MASK;

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+  context.module_context_p = NULL;
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
 #ifndef CONFIG_DISABLE_ES2015_CLASS
  context.status_flags |= PARSER_GET_CLASS_PARSER_OPTS (parse_opts);
 #endif /* !CONFIG_DISABLE_ES2015_CLASS */
@@ -2474,7 +2479,15 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
    JERRY_ASSERT (context.last_cbc_opcode == PARSER_CBC_UNAVAILABLE);
    JERRY_ASSERT (context.allocated_buffer_p == NULL);

-    compiled_code = parser_post_processing (&context);
+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+    if (context.module_context_p != NULL)
+    {
+      parser_module_handle_requests (&context);
+      ecma_module_load_modules (&context);
+    }
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
+    compiled_code_p = parser_post_processing (&context);
    parser_list_free (&context.literal_pool);

 #ifdef PARSER_DUMP_BYTE_CODE
@@ -2507,7 +2520,7 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
      error_location_p->column = context.token.column;
    }

-    compiled_code = NULL;
+    compiled_code_p = NULL;
    parser_free_literals (&context.literal_pool);
    parser_cbc_stream_free (&context.byte_code);
  }
@@ -2522,9 +2535,12 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
  }
 #endif /* PARSER_DUMP_BYTE_CODE */

+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+  parser_module_context_cleanup (&context);
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
  parser_stack_free (&context);

-  return compiled_code;
+  return compiled_code_p;
 } /* parser_parse_source */

 /**
@@ -2850,6 +2866,13 @@ void
 parser_raise_error (parser_context_t *context_p, /**< context */
                    parser_error_t error) /**< error code */
 {
+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+  if (context_p->module_context_p != NULL)
+  {
+    parser_module_free_saved_names (context_p->module_current_node_p);
+  }
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
  parser_saved_context_t *saved_context_p = context_p->last_context_p;

  while (saved_context_p != NULL)
@@ -90,6 +90,7 @@ typedef enum
  PARSER_ERR_LEFT_BRACE_EXPECTED,                     /**< left brace expected */
  PARSER_ERR_RIGHT_PAREN_EXPECTED,                    /**< right paren expected */
  PARSER_ERR_RIGHT_SQUARE_EXPECTED,                   /**< right square expected */
+
 #ifndef CONFIG_DISABLE_ES2015_TEMPLATE_STRINGS
  PARSER_ERR_RIGHT_BRACE_EXPECTED,                    /**< right brace expected */
 #endif /* !CONFIG_DISABLE_ES2015_TEMPLATE_STRINGS */
@@ -129,7 +130,20 @@ typedef enum
  PARSER_ERR_REST_PARAMETER_DEFAULT_INITIALIZER,      /**< rest parameter default initializer */
 #endif /* !CONFIG_DISABLE_ES2015_FUNCTION_REST_PARAMETER */
  PARSER_ERR_OBJECT_PROPERTY_REDEFINED,               /**< property of object literal redefined */
-  PARSER_ERR_NON_STRICT_ARG_DEFINITION                /**< non-strict argument definition */
+
+#ifndef CONFIG_DISABLE_ES2015_MODULE_SYSTEM
+  PARSER_ERR_RIGHT_PAREN_COMMA_FROM_EXPECTED,         /**< rigth paren or comma or from expected */
+  PARSER_ERR_FROM_EXPECTED,                           /**< from expected */
+  PARSER_ERR_STRING_EXPECTED,                         /**< string literal expected */
+  PARSER_ERR_MODULE_REQUEST_NOT_FOUND,                /**< not found imported variable in module */
+  PARSER_ERR_FILE_NOT_FOUND,                          /**< not found given file in the import statement */
+  PARSER_ERR_NOT_IMPLEMENTED,                         /**< feature not implemented yet */
+  PARSER_ERR_MODULE_REQUEST_LIMIT_REACHED,            /**< maximum number of requests reached */
+  PARSER_ERR_MODULE_UNEXPECTED,                       /**< unexpected import or export statement */
+  PARSER_ERR_LEFT_PAREN_MULTIPLY_LITERAL_EXPECTED,    /**< left paren or multiply or literal expected */
+#endif /* !CONFIG_DISABLE_ES2015_MODULE_SYSTEM */
+
+  PARSER_ERR_NON_STRICT_ARG_DEFINITION               /**< non-strict argument definition */
 } parser_error_t;

 /**