Update jerry API

* Fix error handling (related issue: #1141)
 * Move output paramters to the end of the arguments lists

JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com

jerry-core/jerry-api.h

@@ -96,9 +96,9 @@ typedef uint32_t jerry_value_t;
  */
 typedef bool (*jerry_external_handler_t) (const jerry_object_t *function_obj_p,
                                           const jerry_value_t this_val,
-                                          jerry_value_t *ret_val_p,
                                           const jerry_value_t args_p[],
-                                          const jerry_length_t args_count);
+                                          const jerry_length_t args_count,
+                                          jerry_value_t *ret_val_p);
 
 /**
  * Native free callback of an object
@@ -197,15 +197,15 @@ bool jerry_is_constructor (const jerry_object_t *);
 bool jerry_is_function (const jerry_object_t *);
 bool jerry_add_object_field (jerry_object_t *, const jerry_char_t *, jerry_size_t, const jerry_value_t, bool);
 bool jerry_delete_object_field (jerry_object_t *, const jerry_char_t *, jerry_size_t);
-bool jerry_get_object_field_value (jerry_object_t *, const jerry_char_t *, jerry_value_t *);
+jerry_value_t jerry_get_object_field_value (jerry_object_t *, const jerry_char_t *);
-bool jerry_get_object_field_value_sz (jerry_object_t *, const jerry_char_t *, jerry_size_t, jerry_value_t *);
+jerry_value_t jerry_get_object_field_value_sz (jerry_object_t *, const jerry_char_t *, jerry_size_t);
 bool jerry_set_object_field_value (jerry_object_t *, const jerry_char_t *, const jerry_value_t);
 bool jerry_set_object_field_value_sz (jerry_object_t *, const jerry_char_t *, jerry_size_t, const jerry_value_t);
 bool jerry_foreach_object_field (jerry_object_t *, jerry_object_field_foreach_t, void *);
 bool jerry_get_object_native_handle (jerry_object_t *, uintptr_t *);
 void jerry_set_object_native_handle (jerry_object_t *, uintptr_t, jerry_object_free_callback_t);
-bool jerry_construct_object (jerry_object_t *, jerry_value_t *, const jerry_value_t[], uint16_t);
+jerry_value_t jerry_construct_object (jerry_object_t *, const jerry_value_t[], uint16_t);
-bool jerry_call_function (jerry_object_t *, jerry_object_t *, jerry_value_t *, const jerry_value_t[], uint16_t);
+jerry_value_t jerry_call_function (jerry_object_t *, jerry_object_t *, const jerry_value_t[], uint16_t);
 
 /**
  * @}

jerry-core/jerry.c

@@ -124,6 +124,15 @@ jerry_make_api_unavailable (void)
   jerry_api_available = false;
 } /* jerry_make_api_unavailable */
 
+/**
+ * Returns whether the given jerry_value_t is error.
+ */
+bool
+jerry_value_is_error (const jerry_value_t value) /**< api value */
+{
+  return ECMA_IS_VALUE_ERROR (value);
+} /* jerry_value_is_error */
+
 /**
  * Returns whether the given jerry_value_t is null.
  */
@@ -310,10 +319,10 @@ jerry_create_string_value (jerry_string_t *str_p) /**< jerry_string_t from which
  *
  * @return completion code
  */
-inline static jerry_completion_code_t __attr_always_inline___
+static inline jerry_completion_code_t __attr_always_inline___
-jerry_convert_eval_completion_to_retval (jerry_value_t *retval_p, /**< [out] api value */
+jerry_convert_eval_completion_to_retval (ecma_value_t completion, /**< completion of 'eval'-mode
-                                         ecma_value_t completion) /**< completion of 'eval'-mode
                                                                    *   code execution */
+                                         jerry_value_t *retval_p) /**< [out] api value */
 {
   *retval_p = completion;
 
@@ -698,8 +707,8 @@ jerry_create_external_function (jerry_external_handler_t handler_p) /**< pointer
  * Dispatch call to specified external function using the native handler
  *
  * Note:
- *       if called native handler returns true, then dispatcher just returns value received
+ *      if called native handler returns true, then dispatcher just returns value received
- *       through 'return value' output argument, otherwise - throws the value as an exception.
+ *      through 'return value' output argument, otherwise - throws the value as an exception.
  *
  * @return ecma value
  *         Returned value must be freed with ecma_free_value
@@ -717,9 +726,9 @@ jerry_dispatch_external_function (ecma_object_t *function_object_p, /**< externa
 
   bool is_successful = ((jerry_external_handler_t) handler_p) (function_object_p,
                                                                this_arg_value,
-                                                               &ret_value,
                                                                arguments_list_p,
-                                                               arguments_list_len);
+                                                               arguments_list_len,
+                                                               &ret_value);
 
   if (!is_successful)
   {
@@ -879,14 +888,13 @@ jerry_delete_object_field (jerry_object_t *object_p, /**< object to delete field
  *                - there is field with specified name in the object;
  *         false - otherwise.
  */
-bool jerry_get_object_field_value (jerry_object_t *object_p, /**< object */
+jerry_value_t
-                                   const jerry_char_t *field_name_p, /**< field name */
+jerry_get_object_field_value (jerry_object_t *object_p, /**< object */
-                                   jerry_value_t *field_value_p) /**< [out] field value */
+                              const jerry_char_t *field_name_p) /**< field name */
 {
   return jerry_get_object_field_value_sz (object_p,
                                           field_name_p,
-                                          lit_zt_utf8_string_size (field_name_p),
+                                          lit_zt_utf8_string_size (field_name_p));
-                                          field_value_p);
 } /* jerry_get_object_field_value */
 
 /**
@@ -945,38 +953,32 @@ jerry_foreach_object_field (jerry_object_t *object_p, /**< object */
  * Get value of field in the specified object
  *
  * Note:
- *      if value was retrieved successfully, it should be freed
+ *      returned value should be freed with jerry_release_value.
- *      with jerry_release_value just when it becomes unnecessary.
  *
- * @return true, if field value was retrieved successfully, i.e. upon the call:
+ * @return jerry value of the given field
- *                - there is field with specified name in the object;
- *         false - otherwise.
  */
-bool
+jerry_value_t
 jerry_get_object_field_value_sz (jerry_object_t *object_p, /**< object */
                                  const jerry_char_t *field_name_p, /**< name of the field */
-                                 jerry_size_t field_name_size, /**< size of field name in bytes */
+                                 jerry_size_t field_name_size) /**< size of field name in bytes */
-                                 jerry_value_t *field_value_p) /**< [out] field value, if retrieved successfully */
 {
   jerry_assert_api_available ();
 
   ecma_string_t *field_name_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) field_name_p,
                                                                     (lit_utf8_size_t) field_name_size);
 
-  *field_value_p = ecma_op_object_get (object_p, field_name_str_p);
+  ecma_value_t field_value = ecma_op_object_get (object_p, field_name_str_p);
 
   ecma_deref_ecma_string (field_name_str_p);
 
-  return (!ECMA_IS_VALUE_ERROR (*field_value_p)
+  return field_value;
-          && !ecma_is_value_undefined (*field_value_p));
 } /* jerry_get_object_field_value_sz */
 
 /**
  * Set value of field in the specified object
  *
- * @return true, if field value was set successfully, i.e. upon the call:
+ * @return true  - if field value was set successfully
- *                - field value is writable;
+ *         false - otherwise
- *         false - otherwise.
  */
 bool
 jerry_set_object_field_value (jerry_object_t *object_p, /**< object */
@@ -1100,11 +1102,9 @@ jerry_set_object_native_handle (jerry_object_t *object_p, /**< object to set han
  *      If function is invoked as constructor, it should support [[Construct]] method,
  *      otherwise, if function is simply called - it should support [[Call]] method.
  *
- * @return true, if invocation was performed successfully, i.e.:
+ * @return returned jerry value of the given function object
- *                - no unhandled exceptions were thrown in connection with the call;
- *         false - otherwise.
  */
-static bool
+static jerry_value_t
 jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke function as constructor
                                                        *          (this_arg_p should be NULL, as it is ignored),
                                                        *   false - perform function call */
@@ -1114,9 +1114,6 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
                                                     *            if function is invoked as constructor;
                                                     *            in case of simple function call set 'this'
                                                     *            binding to the global object) */
-                       jerry_value_t *retval_p, /**< pointer to place for function's
-                                                 *   return value / thrown exception value
-                                                 *   or NULL (to ignore the values) */
                        const jerry_value_t args_p[], /**< function's call arguments
                                                       *   (NULL if arguments number is zero) */
                        jerry_length_t args_count) /**< number of the arguments */
@@ -1125,8 +1122,6 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
   JERRY_STATIC_ASSERT (sizeof (args_count) == sizeof (ecma_length_t),
                        size_of_args_count_must_be_equal_to_size_of_ecma_length_t);
 
-  bool is_successful = true;
-
   ecma_value_t call_completion;
 
   if (is_invoke_as_constructor)
@@ -1159,29 +1154,19 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
                                              args_count);
   }
 
-  if (ECMA_IS_VALUE_ERROR (call_completion))
+  return call_completion;
-  {
-    /* unhandled exception during the function call */
-    is_successful = false;
-  }
-
-  if (retval_p != NULL)
-  {
-    *retval_p = call_completion;
-  }
-
-  return is_successful;
 } /* jerry_invoke_function */
 
 /**
  * Construct new TypeError object
+ *
+ * @return TypeError object value
  */
-static void
+static jerry_value_t __attr_always_inline___
-jerry_construct_type_error (jerry_value_t *retval_p) /**< [out] value with constructed
+jerry_construct_type_error (void)
-                                                      *         TypeError object */
 {
   ecma_object_t *type_error_obj_p = ecma_new_standard_error (ECMA_ERROR_TYPE);
-  *retval_p = ecma_make_object_value (type_error_obj_p);
+  return ecma_make_error_obj_value (type_error_obj_p);
 } /* jerry_construct_type_error */
 
 /**
@@ -1191,20 +1176,12 @@ jerry_construct_type_error (jerry_value_t *retval_p) /**< [out] value with const
  *      returned value should be freed with jerry_release_value
  *      just when the value becomes unnecessary.
  *
- * @return true, if call was performed successfully, i.e.:
+ * @return returned jerry value of the given function object
- *                - specified object is a function object (see also jerry_is_function);
- *                - no unhandled exceptions were thrown in connection with the call;
- *         false - otherwise, 'retval_p' contains thrown exception:
- *                  if called object is not function object - a TypeError instance;
- *                  else - exception, thrown during the function call.
  */
-bool
+jerry_value_t
 jerry_call_function (jerry_object_t *function_object_p, /**< function object to call */
                      jerry_object_t *this_arg_p, /**< object for 'this' binding
                                                   *   or NULL (set 'this' binding to the global object) */
-                     jerry_value_t *retval_p, /**< pointer to place for function's
-                                               *   return value / thrown exception value
-                                               *   or NULL (to ignore the values) */
                      const jerry_value_t args_p[], /**< function's call arguments
                                                     *   (NULL if arguments number is zero) */
                      uint16_t args_count) /**< number of the arguments */
@@ -1213,17 +1190,10 @@ jerry_call_function (jerry_object_t *function_object_p, /**< function object to
 
   if (jerry_is_function (function_object_p))
   {
-    return jerry_invoke_function (false, function_object_p, this_arg_p, retval_p, args_p, args_count);
+    return jerry_invoke_function (false, function_object_p, this_arg_p, args_p, args_count);
   }
-  else
-  {
-    if (retval_p != NULL)
-    {
-      jerry_construct_type_error (retval_p);
-    }
 
-    return false;
+  return jerry_construct_type_error ();
-  }
 } /* jerry_call_function */
 
 /**
@@ -1233,18 +1203,10 @@ jerry_call_function (jerry_object_t *function_object_p, /**< function object to
  *      returned value should be freed with jerry_release_value
  *      just when the value becomes unnecessary.
  *
- * @return true, if construction was performed successfully, i.e.:
+ * @return returned jerry value of the given constructor
- *                 - specified object is a constructor function object (see also jerry_is_constructor);
- *                 - no unhandled exceptions were thrown in connection with the invocation;
- *         false - otherwise, 'retval_p' contains thrown exception:
- *                 if  specified object is not a constructor function object - a TypeError instance;
- *                 else - exception, thrown during the invocation.
  */
-bool
+jerry_value_t
 jerry_construct_object (jerry_object_t *function_object_p, /**< function object to call */
-                        jerry_value_t *retval_p, /**< pointer to place for function's
-                                                  *   return value / thrown exception value
-                                                  *   or NULL (to ignore the values) */
                         const jerry_value_t args_p[], /**< function's call arguments
                                                        *   (NULL if arguments number is zero) */
                         uint16_t args_count) /**< number of the arguments */
@@ -1253,17 +1215,10 @@ jerry_construct_object (jerry_object_t *function_object_p, /**< function object
 
   if (jerry_is_constructor (function_object_p))
   {
-    return jerry_invoke_function (true, function_object_p, NULL, retval_p, args_p, args_count);
+    return jerry_invoke_function (true, function_object_p, NULL, args_p, args_count);
   }
-  else
-  {
-    if (retval_p != NULL)
-    {
-      jerry_construct_type_error (retval_p);
-    }
 
-    return false;
+  return jerry_construct_type_error ();
-  }
 } /* jerry_construct_object */
 
 /**
@@ -1308,7 +1263,7 @@ jerry_eval (const jerry_char_t *source_p, /**< source code */
                                                        is_direct,
                                                        is_strict);
 
-  status = jerry_convert_eval_completion_to_retval (retval_p, completion);
+  status = jerry_convert_eval_completion_to_retval (completion, retval_p);
 
   return status;
 } /* jerry_eval */
@@ -2088,7 +2043,7 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
     /* vm should be already initialized */
     ecma_value_t completion = vm_run_eval (bytecode_p, false);
 
-    ret_code = jerry_convert_eval_completion_to_retval (retval_p, completion);
+    ret_code = jerry_convert_eval_completion_to_retval (completion, retval_p);
 
     ecma_free_value (completion);
   }

main-unix.c

@@ -74,9 +74,9 @@ read_file (const char *file_name,
 static bool
 assert_handler (const jerry_object_t *function_obj_p __attribute__((unused)), /**< function object */
                 const jerry_value_t this_p __attribute__((unused)), /**< this arg */
-                jerry_value_t *ret_val_p __attribute__((unused)), /**< return argument */
                 const jerry_value_t args_p[], /**< function arguments */
-                const jerry_length_t args_cnt) /**< number of function arguments */
+                const jerry_length_t args_cnt, /**< number of function arguments */
+                jerry_value_t *ret_val_p __attribute__((unused))) /**< return argument */
 {
   if (args_cnt == 1
       && jerry_value_is_boolean (args_p[0])
@@ -417,9 +417,10 @@ main (int argc,
     bool is_done = false;
 
     jerry_object_t *global_obj_p = jerry_get_global ();
-    jerry_value_t print_function;
+    jerry_value_t print_function = jerry_get_object_field_value (global_obj_p,
+                                                                 (jerry_char_t *) "print");
 
-    if (!jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "print", &print_function))
+    if (jerry_value_is_error (print_function))
     {
       return JERRY_STANDALONE_EXIT_CODE_FAIL;
     }
@@ -461,16 +462,12 @@ main (int argc,
 
         /* Print return value */
         const jerry_value_t args[] = { ret_val };
-        jerry_value_t ret_val_print;
+        jerry_value_t ret_val_print = jerry_call_function (jerry_get_object_value (print_function),
-        if (jerry_call_function (jerry_get_object_value (print_function),
+                                                           NULL,
-                                 NULL,
+                                                           args,
-                                 &ret_val_print,
+                                                           1);
-                                 args,
-                                 1))
-        {
-          jerry_release_value (ret_val_print);
-        }
 
+        jerry_release_value (ret_val_print);
         jerry_release_value (ret_val);
       }
     }

tests/unit/test-api.c

@@ -66,9 +66,9 @@ bool test_api_is_free_callback_was_called = false;
 static bool
 handler (const jerry_object_t *function_obj_p, /**< function object */
          const jerry_value_t this_val, /**< this value */
-         jerry_value_t *ret_val_p, /**< [out] return value */
          const jerry_value_t args_p[], /**< arguments list */
-         const jerry_length_t args_cnt) /**< arguments length */
+         const jerry_length_t args_cnt, /**< arguments length */
+         jerry_value_t *ret_val_p) /**< [out] return value */
 {
   char buffer[32];
   jerry_size_t sz;
@@ -96,9 +96,9 @@ handler (const jerry_object_t *function_obj_p, /**< function object */
 static bool
 handler_throw_test (const jerry_object_t *function_obj_p, /**< function object */
                     const jerry_value_t this_val, /**< this value */
-                    jerry_value_t *ret_val_p, /**< [out] return value */
                     const jerry_value_t args_p[], /**< arguments list */
-                    const jerry_length_t args_cnt) /**< arguments length */
+                    const jerry_length_t args_cnt, /**< arguments length */
+                    jerry_value_t *ret_val_p) /**< [out] return value */
 {
   printf ("ok %p %p %p %d %p\n", function_obj_p, this_val, args_p, args_cnt, ret_val_p);
 
@@ -122,9 +122,9 @@ handler_construct_freecb (uintptr_t native_p)
 static bool
 handler_construct (const jerry_object_t *function_obj_p, /**< function object */
                    const jerry_value_t this_val, /**< this value */
-                   jerry_value_t *ret_val_p, /**< [out] return value */
                    const jerry_value_t args_p[], /**< arguments list */
-                   const jerry_length_t args_cnt) /**< arguments length */
+                   const jerry_length_t args_cnt, /**< arguments length */
+                   jerry_value_t *ret_val_p) /**< [out] return value */
 {
   printf ("ok construct %p %p %p %d %p\n", function_obj_p, this_val, args_p, args_cnt, ret_val_p);
 
@@ -277,7 +277,7 @@ main (void)
 
   jerry_init (JERRY_FLAG_EMPTY);
 
-  bool is_ok, is_exception;
+  bool is_ok;
   jerry_size_t sz;
   jerry_value_t val_t, val_foo, val_bar, val_A, val_A_prototype, val_a, val_a_foo, val_value_field, val_p, val_np;
   jerry_value_t val_external, val_external_construct, val_call_external;
@@ -304,39 +304,39 @@ main (void)
   jerry_release_value (args[0]);
 
   // Get global.boo (non-existing field)
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "boo", &val_t);
+  val_t = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "boo");
-  JERRY_ASSERT (!is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_t));
   JERRY_ASSERT (jerry_value_is_undefined (val_t));
 
   // Get global.t
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "t", &val_t);
+  val_t = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "t");
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_t));
   JERRY_ASSERT (jerry_value_is_number (val_t)
                 && jerry_get_number_value (val_t) == 1.0);
   jerry_release_value (val_t);
 
   // Get global.foo
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "foo", &val_foo);
+  val_foo = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "foo");
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_foo));
   JERRY_ASSERT (jerry_value_is_object (val_foo));
 
   // Call foo (4, 2)
   args[0] = jerry_create_number_value (4);
   args[1] = jerry_create_number_value (2);
-  is_ok = jerry_call_function (jerry_get_object_value (val_foo), NULL, &res, args, 2);
+  res = jerry_call_function (jerry_get_object_value (val_foo), NULL, args, 2);
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   JERRY_ASSERT (jerry_value_is_number (res)
                 && jerry_get_number_value (res) == 1.0);
   jerry_release_value (res);
 
   // Get global.bar
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "bar", &val_bar);
+  val_bar = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "bar");
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_bar));
   JERRY_ASSERT (jerry_value_is_object (val_bar));
 
   // Call bar (4, 2)
-  is_ok = jerry_call_function (jerry_get_object_value (val_bar), NULL, &res, args, 2);
+  res = jerry_call_function (jerry_get_object_value (val_bar), NULL, args, 2);
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   JERRY_ASSERT (jerry_value_is_number (res)
                 && jerry_get_number_value (res) == 5.0);
   jerry_release_value (res);
@@ -349,8 +349,8 @@ main (void)
   JERRY_ASSERT (is_ok);
 
   // Call foo (4, 2)
-  is_ok = jerry_call_function (jerry_get_object_value (val_foo), NULL, &res, args, 2);
+  res = jerry_call_function (jerry_get_object_value (val_foo), NULL, args, 2);
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   JERRY_ASSERT (jerry_value_is_string (res));
   sz = jerry_get_string_size (jerry_get_string_value (res));
   JERRY_ASSERT (sz == 4);
@@ -362,17 +362,16 @@ main (void)
   jerry_release_value (args[1]);
 
   // Get global.A
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "A", &val_A);
+  val_A = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "A");
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_A));
   JERRY_ASSERT (jerry_value_is_object (val_A));
 
   // Get A.prototype
   is_ok = jerry_is_constructor (jerry_get_object_value (val_A));
   JERRY_ASSERT (is_ok);
-  is_ok = jerry_get_object_field_value (jerry_get_object_value (val_A),
+  val_A_prototype = jerry_get_object_field_value (jerry_get_object_value (val_A),
-                                        (jerry_char_t *) "prototype",
+                                                  (jerry_char_t *) "prototype");
-                                        &val_A_prototype);
+  JERRY_ASSERT (!jerry_value_is_error (val_A_prototype));
-  JERRY_ASSERT (is_ok);
   JERRY_ASSERT (jerry_value_is_object (val_A_prototype));
   jerry_release_value (val_A);
 
@@ -385,19 +384,19 @@ main (void)
   jerry_release_value (val_foo);
 
   // Get global.a
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "a", &val_a);
+  val_a = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "a");
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_a));
   JERRY_ASSERT (jerry_value_is_object (val_a));
 
   // Get a.t
-  is_ok = jerry_get_object_field_value (jerry_get_object_value (val_a), (jerry_char_t *) "t", &res);
+  res = jerry_get_object_field_value (jerry_get_object_value (val_a), (jerry_char_t *) "t");
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   JERRY_ASSERT (jerry_value_is_number (res)
                 && jerry_get_number_value (res) == 12.0);
   jerry_release_value (res);
 
   // foreach properties
-  jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "p", &val_p);
+  val_p = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "p");
   is_ok = jerry_foreach_object_field (jerry_get_object_value (val_p), foreach, (void *) "user_data");
   JERRY_ASSERT (is_ok);
 
@@ -409,25 +408,23 @@ main (void)
   jerry_release_value (val_p);
 
   // foreach with throw test
-  jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "np", &val_np);
+  val_np = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "np");
   is_ok = !jerry_foreach_object_field (jerry_get_object_value (val_np), foreach_exception, NULL);
   JERRY_ASSERT (is_ok);
   jerry_release_value (val_np);
 
   // Get a.foo
-  is_ok = jerry_get_object_field_value (jerry_get_object_value (val_a),
+  val_a_foo = jerry_get_object_field_value (jerry_get_object_value (val_a),
-                                        (jerry_char_t *) "foo",
+                                            (jerry_char_t *) "foo");
-                                        &val_a_foo);
+  JERRY_ASSERT (!jerry_value_is_error (val_a_foo));
-  JERRY_ASSERT (is_ok);
   JERRY_ASSERT (jerry_value_is_object (val_a_foo));
 
   // Call a.foo ()
-  is_ok = jerry_call_function (jerry_get_object_value (val_a_foo),
+  res = jerry_call_function (jerry_get_object_value (val_a_foo),
-                               jerry_get_object_value (val_a),
+                             jerry_get_object_value (val_a),
-                               &res,
+                             NULL,
-                               NULL,
+                             0);
-                               0);
+  JERRY_ASSERT (!jerry_value_is_error (res));
-  JERRY_ASSERT (is_ok);
   JERRY_ASSERT (jerry_value_is_number (res)
                 && jerry_get_number_value (res) == 12.0);
   jerry_release_value (res);
@@ -449,16 +446,16 @@ main (void)
   jerry_release_value (val_external);
 
   // Call 'call_external' function that should call external function created above
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "call_external", &val_call_external);
+  val_call_external = jerry_get_object_field_value (global_obj_p,
-  JERRY_ASSERT (is_ok);
+                                                    (jerry_char_t *) "call_external");
+  JERRY_ASSERT (!jerry_value_is_error (val_call_external));
   JERRY_ASSERT (jerry_value_is_object (val_call_external));
-  is_ok = jerry_call_function (jerry_get_object_value (val_call_external),
+  res = jerry_call_function (jerry_get_object_value (val_call_external),
-                               global_obj_p,
+                             global_obj_p,
-                               &res,
+                             NULL,
-                               NULL,
+                             0);
-                               0);
   jerry_release_value (val_call_external);
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   JERRY_ASSERT (jerry_value_is_string (res));
   sz = jerry_get_string_size (jerry_get_string_value (res));
   JERRY_ASSERT (sz == 19);
@@ -481,15 +478,14 @@ main (void)
 
   // Call external function created above, as constructor
   args[0] = jerry_create_boolean_value (true);
-  is_ok = jerry_construct_object (external_construct_p, &res, args, 1);
+  res = jerry_construct_object (external_construct_p, args, 1);
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   JERRY_ASSERT (jerry_value_is_object (res));
-  is_ok = jerry_get_object_field_value (jerry_get_object_value (res),
+  val_value_field = jerry_get_object_field_value (jerry_get_object_value (res),
-                                        (jerry_char_t *) "value_field",
+                                                  (jerry_char_t *) "value_field");
-                                        &val_value_field);
 
   // Get 'value_field' of constructed object
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_value_field));
   JERRY_ASSERT (jerry_value_is_boolean (val_value_field)
                 && jerry_get_boolean_value (val_value_field));
   jerry_release_value (val_value_field);
@@ -515,30 +511,30 @@ main (void)
   JERRY_ASSERT (is_ok);
   jerry_release_value (val_t);
 
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "call_throw_test", &val_t);
+  val_t = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "call_throw_test");
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (val_t));
   JERRY_ASSERT (jerry_value_is_object (val_t));
 
-  is_ok = jerry_call_function (jerry_get_object_value (val_t),
+  res = jerry_call_function (jerry_get_object_value (val_t),
-                               global_obj_p,
+                             global_obj_p,
-                               &res,
+                             NULL,
-                               NULL, 0);
+                             0);
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   jerry_release_value (val_t);
   jerry_release_value (res);
 
   // Test: Unhandled exception in called function
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "throw_reference_error", &val_t);
+  val_t = jerry_get_object_field_value (global_obj_p,
-  JERRY_ASSERT (is_ok);
+                                        (jerry_char_t *) "throw_reference_error");
+  JERRY_ASSERT (!jerry_value_is_error (val_t));
   JERRY_ASSERT (jerry_value_is_object (val_t));
 
-  is_ok = jerry_call_function (jerry_get_object_value (val_t),
+  res = jerry_call_function (jerry_get_object_value (val_t),
                                global_obj_p,
-                               &res,
+                               NULL,
-                               NULL, 0);
+                               0);
-  is_exception = !is_ok;
 
-  JERRY_ASSERT (is_exception);
+  JERRY_ASSERT (jerry_value_is_error (res));
   jerry_release_value (val_t);
 
   // 'res' should contain exception object
@@ -547,12 +543,11 @@ main (void)
 
   // Test: Call of non-function
   obj_p = jerry_create_object ();
-  is_ok = jerry_call_function (obj_p,
+  res = jerry_call_function (obj_p,
-                               global_obj_p,
+                             global_obj_p,
-                               &res,
+                             NULL,
-                               NULL, 0);
+                             0);
-  is_exception = !is_ok;
+  JERRY_ASSERT (jerry_value_is_error (res));
-  JERRY_ASSERT (is_exception);
 
   // 'res' should contain exception object
   JERRY_ASSERT (jerry_value_is_object (res));
@@ -561,16 +556,13 @@ main (void)
   jerry_release_object (obj_p);
 
   // Test: Unhandled exception in function called, as constructor
-  is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "throw_reference_error", &val_t);
+  val_t = jerry_get_object_field_value (global_obj_p,
-  JERRY_ASSERT (is_ok);
+                                        (jerry_char_t *) "throw_reference_error");
+  JERRY_ASSERT (!jerry_value_is_error (val_t));
   JERRY_ASSERT (jerry_value_is_object (val_t));
 
-  is_ok = jerry_construct_object (jerry_get_object_value (val_t),
+  res = jerry_construct_object (jerry_get_object_value (val_t), NULL, 0);
-                                  &res,
+  JERRY_ASSERT (jerry_value_is_error (res));
-                                  NULL, 0);
-  is_exception = !is_ok;
-
-  JERRY_ASSERT (is_exception);
   jerry_release_value (val_t);
 
   // 'res' should contain exception object
@@ -579,11 +571,8 @@ main (void)
 
   // Test: Call of non-function as constructor
   obj_p = jerry_create_object ();
-  is_ok = jerry_construct_object (obj_p,
+  res = jerry_construct_object (obj_p, NULL, 0);
-                                  &res,
+  JERRY_ASSERT (jerry_value_is_error (res));
-                                  NULL, 0);
-  is_exception = !is_ok;
-  JERRY_ASSERT (is_exception);
 
   // 'res' should contain exception object
   JERRY_ASSERT (jerry_value_is_object (res));
@@ -618,11 +607,11 @@ main (void)
   JERRY_ASSERT (jerry_value_is_object (val_t));
   JERRY_ASSERT (jerry_is_function (jerry_get_object_value (val_t)));
 
-  is_ok = jerry_call_function (jerry_get_object_value (val_t),
+  res = jerry_call_function (jerry_get_object_value (val_t),
-                               NULL,
+                             NULL,
-                               &res,
+                             NULL,
-                               NULL, 0);
+                             0);
-  JERRY_ASSERT (is_ok);
+  JERRY_ASSERT (!jerry_value_is_error (res));
   JERRY_ASSERT (jerry_value_is_number (res)
                 && jerry_get_number_value (res) == 123.0);
   jerry_release_value (res);