Add module C API functions (#4636)

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com

jerry-core/api/jerry.c

@@ -689,20 +689,6 @@ jerry_run (const jerry_value_t func_val) /**< function to run */
 
   ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) object_p;
 
-#if JERRY_MODULE_SYSTEM
-  if (JERRY_UNLIKELY (ext_object_p->u.class_prop.class_id == LIT_MAGIC_STRING_MODULE_UL))
-  {
-    ecma_module_t *root_module_p = (ecma_module_t *) ext_object_p;
-
-    if (root_module_p->header.u.class_prop.extra_info != ECMA_MODULE_STATE_LINKED)
-    {
-      return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Module must be in linked state")));
-    }
-
-    return jerry_return (ecma_module_evaluate (root_module_p));
-  }
-#endif /* JERRY_MODULE_SYSTEM */
-
   if (ext_object_p->u.class_prop.class_id != LIT_MAGIC_STRING_SCRIPT_UL)
   {
     return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
@@ -757,6 +743,8 @@ jerry_module_link (const jerry_value_t module_val, /**< root module */
                                                               *   jerry_port_module_resolve when NULL is passed */
                    void *user_p) /**< pointer passed to the resolve callback */
 {
+  jerry_assert_api_available ();
+
 #if JERRY_MODULE_SYSTEM
   if (callback == NULL)
   {
@@ -780,6 +768,191 @@ jerry_module_link (const jerry_value_t module_val, /**< root module */
 #endif /* JERRY_MODULE_SYSTEM */
 } /* jerry_module_link */
 
+/**
+ * Evaluate a module and its dependencies. The module must be in linked state.
+ *
+ * Note:
+ *      returned value must be freed with jerry_release_value, when it is no longer needed.
+ *
+ * @return result of module bytecode execution - if evaluation was successful
+ *         error - otherwise
+ */
+jerry_value_t
+jerry_module_evaluate (const jerry_value_t module_val) /**< root module */
+{
+  jerry_assert_api_available ();
+
+#if JERRY_MODULE_SYSTEM
+  ecma_module_t *module_p = ecma_module_get_resolved_module (module_val);
+
+  if (module_p == NULL)
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_not_module_p)));
+  }
+
+  if (module_p->header.u.class_prop.extra_info != JERRY_MODULE_STATE_LINKED)
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG ("Module must be in linked state")));
+  }
+
+  return jerry_return (ecma_module_evaluate (module_p));
+#else /* !JERRY_MODULE_SYSTEM */
+  JERRY_UNUSED (module_val);
+
+  return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_module_not_supported_p)));
+#endif /* JERRY_MODULE_SYSTEM */
+} /* jerry_module_evaluate */
+
+/**
+ * Returns the current status of a module
+ *
+ * @return current status - if module_val is a module,
+ *         JERRY_MODULE_STATE_INVALID - otherwise
+ */
+jerry_module_state_t
+jerry_module_get_state (const jerry_value_t module_val) /**< module object */
+{
+  jerry_assert_api_available ();
+
+#if JERRY_MODULE_SYSTEM
+  ecma_module_t *module_p = ecma_module_get_resolved_module (module_val);
+
+  if (module_p == NULL)
+  {
+    return JERRY_MODULE_STATE_INVALID;
+  }
+
+  return (jerry_module_state_t) module_p->header.u.class_prop.extra_info;
+#else /* !JERRY_MODULE_SYSTEM */
+  JERRY_UNUSED (module_val);
+
+  return JERRY_MODULE_STATE_INVALID;
+#endif /* JERRY_MODULE_SYSTEM */
+} /* jerry_module_get_state */
+
+/**
+ * Returns the number of import/export requests of a module
+ *
+ * @return number of import/export requests of a module
+ */
+size_t
+jerry_module_get_number_of_requests (const jerry_value_t module_val) /**< module */
+{
+  jerry_assert_api_available ();
+
+#if JERRY_MODULE_SYSTEM
+  ecma_module_t *module_p = ecma_module_get_resolved_module (module_val);
+
+  if (module_p == NULL)
+  {
+    return 0;
+  }
+
+  size_t number_of_requests = 0;
+
+  ecma_module_node_t *node_p = module_p->imports_p;
+
+  while (node_p != NULL)
+  {
+    number_of_requests++;
+    node_p = node_p->next_p;
+  }
+
+  return number_of_requests;
+#else /* !JERRY_MODULE_SYSTEM */
+  JERRY_UNUSED (module_val);
+
+  return 0;
+#endif /* JERRY_MODULE_SYSTEM */
+} /* jerry_module_get_number_of_requests */
+
+/**
+ * Returns the module request specified by the request_index argument
+ *
+ * Note:
+ *      returned value must be freed with jerry_release_value, when it is no longer needed.
+ *
+ * @return string - if the request has not been resolved yet,
+ *         module object - if the request has been resolved successfully,
+ *         error - otherwise
+ */
+jerry_value_t
+jerry_module_get_request (const jerry_value_t module_val, /**< module */
+                          size_t request_index) /**< request index */
+{
+  jerry_assert_api_available ();
+
+#if JERRY_MODULE_SYSTEM
+  ecma_module_t *module_p = ecma_module_get_resolved_module (module_val);
+
+  if (module_p == NULL)
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_not_module_p)));
+  }
+
+  ecma_module_node_t *node_p = module_p->imports_p;
+
+  while (node_p != NULL)
+  {
+    if (request_index == 0)
+    {
+      return ecma_copy_value (node_p->u.path_or_module);
+    }
+
+    --request_index;
+    node_p = node_p->next_p;
+  }
+
+  return jerry_throw (ecma_raise_range_error (ECMA_ERR_MSG ("Request is not available")));
+#else /* !JERRY_MODULE_SYSTEM */
+  JERRY_UNUSED (module_val);
+  JERRY_UNUSED (request_index);
+
+  return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_module_not_supported_p)));
+#endif /* JERRY_MODULE_SYSTEM */
+} /* jerry_module_get_request */
+
+/**
+ * Returns the namespace object of a module
+ *
+ * Note:
+ *      returned value must be freed with jerry_release_value, when it is no longer needed.
+ *
+ * @return object - if namespace object is available,
+ *                  error - otherwise
+ */
+jerry_value_t
+jerry_module_get_namespace (const jerry_value_t module_val) /**< module */
+{
+  jerry_assert_api_available ();
+
+#if JERRY_MODULE_SYSTEM
+  ecma_module_t *module_p = ecma_module_get_resolved_module (module_val);
+
+  if (module_p == NULL)
+  {
+    return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_not_module_p)));
+  }
+
+  if (module_p->namespace_object_p == NULL)
+  {
+    if (module_p->header.u.class_prop.extra_info != JERRY_MODULE_STATE_EVALUATED)
+    {
+      return jerry_throw (ecma_raise_range_error (ECMA_ERR_MSG ("Namespace object has not been created yet")));
+    }
+
+    ecma_module_create_namespace_object (module_p);
+  }
+
+  ecma_ref_object (module_p->namespace_object_p);
+  return ecma_make_object_value (module_p->namespace_object_p);
+#else /* !JERRY_MODULE_SYSTEM */
+  JERRY_UNUSED (module_val);
+
+  return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (error_module_not_supported_p)));
+#endif /* JERRY_MODULE_SYSTEM */
+} /* jerry_module_get_namespace */
+
 /**
  * Run enqueued Promise jobs until the first thrown error or until all get executed.
  *

jerry-core/ecma/base/ecma-module.c

@@ -40,7 +40,7 @@ ecma_module_initialize_context (void)
 
   ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) obj_p;
   ext_object_p->u.class_prop.class_id = LIT_MAGIC_STRING_MODULE_UL;
-  ext_object_p->u.class_prop.extra_info = ECMA_MODULE_STATE_UNLINKED;
+  ext_object_p->u.class_prop.extra_info = JERRY_MODULE_STATE_UNLINKED;
 
   ecma_module_t *module_p = (ecma_module_t *) obj_p;
 
@@ -219,7 +219,7 @@ ecma_module_resolve_export (ecma_module_t *const module_p, /**< base module */
         continue;
       }
 
-      if (current_module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_NATIVE)
+      if (current_module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_NATIVE)
       {
         ecma_object_t *object_p = current_module_p->namespace_object_p;
         ecma_value_t prop_value = ecma_op_object_find_own (ecma_make_object_value (object_p),
@@ -382,17 +382,17 @@ ecma_module_resolve_export (ecma_module_t *const module_p, /**< base module */
 ecma_value_t
 ecma_module_evaluate (ecma_module_t *module_p) /**< module */
 {
-  if (module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_ERROR)
+  if (module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_ERROR)
   {
     return ecma_raise_range_error (ECMA_ERR_MSG ("Module is in error state"));
   }
 
-  if (module_p->header.u.class_prop.extra_info >= ECMA_MODULE_STATE_EVALUATING)
+  if (module_p->header.u.class_prop.extra_info >= JERRY_MODULE_STATE_EVALUATING)
   {
     return ECMA_VALUE_EMPTY;
   }
 
-  JERRY_ASSERT (module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_LINKED);
+  JERRY_ASSERT (module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_LINKED);
 
 #if JERRY_BUILTIN_REALMS
   ecma_object_t *global_object_p = (ecma_object_t *) ecma_op_function_get_realm (module_p->compiled_code_p);
@@ -400,18 +400,18 @@ ecma_module_evaluate (ecma_module_t *module_p) /**< module */
   ecma_object_t *global_object_p = ecma_builtin_get_global ();
 #endif /* JERRY_BUILTIN_REALMS */
 
-  module_p->header.u.class_prop.extra_info = ECMA_MODULE_STATE_EVALUATING;
+  module_p->header.u.class_prop.extra_info = JERRY_MODULE_STATE_EVALUATING;
   module_p->scope_p = ecma_create_decl_lex_env (ecma_get_global_environment (global_object_p));
 
   ecma_value_t ret_value;
   ret_value = vm_run_module (module_p);
 
-  module_p->header.u.class_prop.extra_info = ECMA_MODULE_STATE_ERROR;
+  module_p->header.u.class_prop.extra_info = JERRY_MODULE_STATE_ERROR;
 
   if (!ECMA_IS_VALUE_ERROR (ret_value))
   {
     ecma_free_value (ret_value);
-    module_p->header.u.class_prop.extra_info = ECMA_MODULE_STATE_EVALUATED;
+    module_p->header.u.class_prop.extra_info = JERRY_MODULE_STATE_EVALUATED;
     ret_value = ECMA_VALUE_EMPTY;
   }
 
@@ -482,7 +482,7 @@ ecma_module_namespace_object_add_export_if_needed (ecma_module_t *module_p, /**<
  * @return ECMA_VALUE_ERROR - if an error occured
  *         ECMA_VALUE_EMPTY - otherwise
  */
-static ecma_value_t
+ecma_value_t
 ecma_module_create_namespace_object (ecma_module_t *module_p) /**< module */
 {
   ecma_value_t result = ECMA_VALUE_EMPTY;
@@ -491,7 +491,7 @@ ecma_module_create_namespace_object (ecma_module_t *module_p) /**< module */
     return result;
   }
 
-  JERRY_ASSERT (module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_EVALUATED);
+  JERRY_ASSERT (module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_EVALUATED);
   ecma_module_resolve_set_t *resolve_set_p = NULL;
   ecma_module_resolve_stack_t *stack_p = NULL;
 
@@ -688,7 +688,7 @@ ecma_module_connect_imports (ecma_module_t *module_p)
           return ecma_raise_syntax_error (ECMA_ERR_MSG ("Ambiguous import request"));
         }
 
-        if (record.module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_NATIVE)
+        if (record.module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_NATIVE)
         {
           ecma_object_t *object_p = record.module_p->namespace_object_p;
           prop_value = ecma_op_object_find_own (ecma_make_object_value (object_p), object_p, record.name_p);
@@ -858,12 +858,12 @@ ecma_module_link (ecma_module_t *module_p, /**< root module */
                   jerry_module_resolve_callback_t callback, /**< resolve module callback */
                   void *user_p) /**< pointer passed to the resolve callback */
 {
-  if (module_p->header.u.class_prop.extra_info != ECMA_MODULE_STATE_UNLINKED)
+  if (module_p->header.u.class_prop.extra_info != JERRY_MODULE_STATE_UNLINKED)
   {
     return ecma_raise_type_error (ECMA_ERR_MSG ("Module must be in unlinked state"));
   }
 
-  module_p->header.u.class_prop.extra_info = ECMA_MODULE_STATE_LINKING;
+  module_p->header.u.class_prop.extra_info = JERRY_MODULE_STATE_LINKING;
 
   uint32_t dfs_index = 0;
   ecma_module_stack_item_t *last_p;
@@ -919,7 +919,7 @@ restart:
     node_p->u.path_or_module = resolve_result;
     ecma_deref_object (ecma_get_object_from_value (resolve_result));
 
-    if (resolved_module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_ERROR)
+    if (resolved_module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_ERROR)
     {
       ecma_raise_type_error (ECMA_ERR_MSG ("Cannot link to a module which is in error state"));
       goto error;
@@ -938,10 +938,10 @@ restart:
     {
       module_p = ecma_module_get_from_object (node_p->u.path_or_module);
 
-      if (module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_UNLINKED)
+      if (module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_UNLINKED)
       {
         current_p->node_p = node_p->next_p;
-        module_p->header.u.class_prop.extra_info = ECMA_MODULE_STATE_LINKING;
+        module_p->header.u.class_prop.extra_info = JERRY_MODULE_STATE_LINKING;
 
         ecma_module_stack_item_t *item_p;
         item_p = (ecma_module_stack_item_t *) jmem_heap_alloc_block (sizeof (ecma_module_stack_item_t));
@@ -962,7 +962,7 @@ restart:
         goto restart;
       }
 
-      if (module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_LINKING)
+      if (module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_LINKING)
       {
         uint32_t dfs_ancestor_index = module_p->header.u.class_prop.u.dfs_ancestor_index;
 
@@ -996,8 +996,8 @@ restart:
     {
       ecma_module_stack_item_t *prev_p = last_p->prev_p;
 
-      JERRY_ASSERT (last_p->module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_LINKING);
-      last_p->module_p->header.u.class_prop.extra_info = ECMA_MODULE_STATE_LINKED;
+      JERRY_ASSERT (last_p->module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_LINKING);
+      last_p->module_p->header.u.class_prop.extra_info = JERRY_MODULE_STATE_LINKED;
 
       jmem_heap_free_block (last_p, sizeof (ecma_module_stack_item_t));
       last_p = prev_p;
@@ -1017,8 +1017,8 @@ error:
   {
     ecma_module_stack_item_t *prev_p = last_p->prev_p;
 
-    JERRY_ASSERT (last_p->module_p->header.u.class_prop.extra_info == ECMA_MODULE_STATE_LINKING);
-    last_p->module_p->header.u.class_prop.extra_info = ECMA_MODULE_STATE_UNLINKED;
+    JERRY_ASSERT (last_p->module_p->header.u.class_prop.extra_info == JERRY_MODULE_STATE_LINKING);
+    last_p->module_p->header.u.class_prop.extra_info = JERRY_MODULE_STATE_UNLINKED;
 
     jmem_heap_free_block (last_p, sizeof (ecma_module_stack_item_t));
     last_p = prev_p;
@@ -1075,7 +1075,9 @@ ecma_module_release_module_nodes (ecma_module_node_t *module_node_p, /**< first
 void
 ecma_module_release_module (ecma_module_t *module_p) /**< module */
 {
-  ecma_module_state_t state = (ecma_module_state_t) module_p->header.u.class_prop.extra_info;
+  jerry_module_state_t state = (jerry_module_state_t) module_p->header.u.class_prop.extra_info;
+
+  JERRY_ASSERT (state != JERRY_MODULE_STATE_INVALID);
 
   if (module_p->namespace_object_p != NULL)
   {
@@ -1087,7 +1089,7 @@ ecma_module_release_module (ecma_module_t *module_p) /**< module */
 #endif /* JERRY_NDEBUG */
   }
 
-  if (state == ECMA_MODULE_STATE_NATIVE)
+  if (state == JERRY_MODULE_STATE_NATIVE)
   {
     return;
   }
@@ -1097,7 +1099,7 @@ ecma_module_release_module (ecma_module_t *module_p) /**< module */
   ecma_module_release_module_nodes (module_p->indirect_exports_p, false);
   ecma_module_release_module_nodes (module_p->star_exports_p, false);
 
-  if (state >= ECMA_MODULE_STATE_EVALUATING)
+  if (state >= JERRY_MODULE_STATE_EVALUATING)
   {
     /* The module structure keeps a strong reference to the module scope, which will require an extra GC call. */
     JERRY_CONTEXT (ecma_gc_new_objects)++;

jerry-core/ecma/base/ecma-module.h

@@ -35,20 +35,6 @@ typedef struct ecma_module_names
   ecma_string_t *local_name_p;      /**< Local name of the item */
 } ecma_module_names_t;
 
-/**
- * An enum identifing the current state of the module
- */
-typedef enum
-{
-  ECMA_MODULE_STATE_UNLINKED = 0, /**< module is currently unlinked */
-  ECMA_MODULE_STATE_LINKING = 1, /**< module is currently being linked */
-  ECMA_MODULE_STATE_LINKED = 2, /**< module has been linked */
-  ECMA_MODULE_STATE_EVALUATING = 3, /**< module is currently being evaluated */
-  ECMA_MODULE_STATE_EVALUATED = 4,  /**< module has been evaluated */
-  ECMA_MODULE_STATE_ERROR = 5,  /**< error is encountered during module init */
-  ECMA_MODULE_STATE_NATIVE = 6,  /**< module is native */
-} ecma_module_state_t;
-
 /**
  * Module structure storing an instance of a module
  *
@@ -130,6 +116,7 @@ ecma_value_t ecma_module_evaluate (ecma_module_t *module_p);
 
 void ecma_module_initialize_context (void);
 void ecma_module_cleanup_context (void);
+ecma_value_t ecma_module_create_namespace_object (ecma_module_t *module_p);
 
 void ecma_module_release_module_names (ecma_module_names_t *module_name_p);
 void ecma_module_release_module (ecma_module_t *module_p);

jerry-core/include/jerryscript-core.h

@@ -267,6 +267,11 @@ jerry_value_t jerry_to_property_descriptor (jerry_value_t obj_value, jerry_prope
 
 jerry_value_t jerry_module_link (const jerry_value_t module_val,
                                  jerry_module_resolve_callback_t callback_p, void *user_p);
+jerry_value_t jerry_module_evaluate (const jerry_value_t module_val);
+jerry_module_state_t jerry_module_get_state (const jerry_value_t module_val);
+size_t jerry_module_get_number_of_requests (const jerry_value_t module_val);
+jerry_value_t jerry_module_get_request (const jerry_value_t module_val, size_t request_index);
+jerry_value_t jerry_module_get_namespace (const jerry_value_t module_val);
 
 /**
  * Promise functions.

jerry-core/include/jerryscript-types.h

@@ -288,13 +288,6 @@ typedef void (*jerry_object_native_free_callback_t) (void *native_p);
  */
 typedef void (*jerry_error_object_created_callback_t) (const jerry_value_t error_object, void *user_p);
 
-/**
- * Callback which is called by jerry_module_link to get the referenced module.
- */
-typedef jerry_value_t (*jerry_module_resolve_callback_t) (const jerry_value_t specifier,
-                                                          const jerry_value_t referrer,
-                                                          void *user_p);
-
 /**
  * Callback which tells whether the ECMAScript execution should be stopped.
  *
@@ -522,6 +515,32 @@ typedef enum
   JERRY_ITERATOR_TYPE_SET,          /**< Set iterator */
 } jerry_iterator_type_t;
 
+/**
+ * Module related types.
+ */
+
+/**
+ * An enum representing the current status of a module
+ */
+typedef enum
+{
+  JERRY_MODULE_STATE_INVALID = 0,  /**< return value for jerry_module_get_state when its argument is not a module */
+  JERRY_MODULE_STATE_UNLINKED = 1, /**< module is currently unlinked */
+  JERRY_MODULE_STATE_LINKING = 2, /**< module is currently being linked */
+  JERRY_MODULE_STATE_LINKED = 3, /**< module has been linked (its depencencies has been resolved) */
+  JERRY_MODULE_STATE_EVALUATING = 4, /**< module is currently being evaluated */
+  JERRY_MODULE_STATE_EVALUATED = 5, /**< module has been evaluated (its source code has been executed) */
+  JERRY_MODULE_STATE_ERROR = 6, /**< an error has been encountered before the evaluated state is reached */
+  JERRY_MODULE_STATE_NATIVE = 7, /**< module is native module */
+} jerry_module_state_t;
+
+/**
+ * Callback which is called by jerry_module_link to get the referenced module.
+ */
+typedef jerry_value_t (*jerry_module_resolve_callback_t) (const jerry_value_t specifier,
+                                                          const jerry_value_t referrer,
+                                                          void *user_p);
+
 /**
  * Proxy related types.
  */