Rework the public API (#4829)

Related to #4186.

Some notable changes:
  - The term 'Error' now strictly refers to native Error objects defined in
    the ECMA standard, which are ordinary objects. All other uses of
    'error' or 'error reference' where the term refers to a thrown value is
    now called 'exception'.

  - Simplified the naming scheme of many String API functions. These functions
    will now also take an 'encoding' argument to specify the desired
    encoding in which to operate.

  - Removed the substring-copy-to-buffer functions. These functions
    behaved awkwardly, as they use character index to specify the
    start/end positions, and were mostly used incorrectly with byte
    offsets instead. The functionality can still be replicated with
    other functions if necessary.

  - String-to-buffer functions will no longer fail if the buffer is not
    sufficiently large, the string will instead be cropped.

  - Fixed the usage of the '_sz' prefix in many API functions. The term
    'sz' means zero-terminated string in hungarian notation, this was
    used incorrectly in many cases.

  - Renamed most of the public API functions to have shorter, more on-point
    names, rather than the often too long descriptive names. Functions are now
    also grouped by the type of value they operate on, where this makes
    sense.

JerryScript-DCO-1.0-Signed-off-by: Dániel Bátyai dbatyai@inf.u-szeged.hu

docs/01.CONFIGURATION.md

@@ -190,7 +190,7 @@ This option is enabled by default.
 
 ### Memory statistics
 
-This option can be used to provide memory usage statistics either upon engine termination, or during runtime using the `jerry_get_memory_stats` jerry API function.
+This option can be used to provide memory usage statistics either upon engine termination, or during runtime using the `jerry_heap_stats` jerry API function.
 The feature can create a significant performance overhead, and should only be used for measurement purposes. This option is disabled by default.
 
 | Options |                                              |

docs/03.API-EXAMPLE.md

@@ -35,47 +35,14 @@ Test if the `pkg-config` works for JerryScript:
 $ pkg-config --cflags --libs libjerry-core libjerry-port-default libjerry-ext libjerry-math
 ```
 
-## Example 1. Execute JavaScript from your application
-
-The most basic example to test the engine is to create an `api-example-1.c` file containing the following code:
-
-[doctest]: # ()
-
-```c
-#include "jerryscript.h"
-
-int
-main (void)
-{
-  const jerry_char_t script[] = "var str = 'Hello, World!';";
-
-  bool ret_value = jerry_run_simple (script, sizeof (script) - 1, JERRY_INIT_EMPTY);
-
-  return (ret_value ? 0 : 1);
-}
-```
-
-To compile it one can use the following command:
-
-```sh
-$ gcc api-example-1.c -o api-example-1 $(pkg-config --cflags --libs libjerry-core libjerry-port-default libjerry-math)
-```
-
-If everything is correct the application returns with a zero exit code:
-
-```
-$ ./api-example-1
-$ echo $?
-```
-
 ## Example 2. Split engine initialization and script execution.
 
 In this example the engine is initialized directly with the `jerry_init` method
 and cleaned up with the `jerry_cleanup` method. The example JavaScript code
 is directly parsed and executed via the `jerry_eval` method. Each `jerry_value_t`
-returned by the API methods is freed with the `jerry_release_value` method.
+returned by the API methods is freed with the `jerry_value_free` method.
 
-To make sure that the code parsing and execution was ok, the `jerry_value_is_error`
+To make sure that the code parsing and execution was ok, the `jerry_value_is_exception`
 method is used to check for any errors.
 
 Use the following code for the `api-example-2.c` file:
@@ -103,10 +70,10 @@ main (void)
                                        JERRY_PARSE_NO_OPTS);
 
   /* Check if there was any error (syntax or runtime) */
-  bool run_ok = !jerry_value_is_error (eval_ret);
+  bool run_ok = !jerry_value_is_exception (eval_ret);
 
   /* Parsed source code must be freed */
-  jerry_release_value (eval_ret);
+  jerry_value_free (eval_ret);
 
   /* Cleanup engine */
   jerry_cleanup ();
@@ -156,20 +123,20 @@ main (void)
   jerry_value_t parsed_code = jerry_parse (script, sizeof (script) - 1, NULL);
 
   /* Check if there is any JS code parse error */
-  if (!jerry_value_is_error (parsed_code))
+  if (!jerry_value_is_exception (parsed_code))
   {
     /* Execute the parsed source code in the Global scope */
     jerry_value_t ret_value = jerry_run (parsed_code);
 
     /* Check the execution return value if there is any error */
-    run_ok = !jerry_value_is_error (ret_value);
+    run_ok = !jerry_value_is_exception (ret_value);
 
     /* Returned value must be freed */
-    jerry_release_value (ret_value);
+    jerry_value_free (ret_value);
   }
 
   /* Parsed source code must be freed */
-  jerry_release_value (parsed_code);
+  jerry_value_free (parsed_code);
 
   /* Cleanup engine */
   jerry_cleanup ();
@@ -200,10 +167,10 @@ In this example a very simple "print" method is added which prints out a static
 This method will be implemented in C and will be called from the JavaScript code.
 For this a few extra API methods are required:
 
-- `jerry_get_global_object`
-- `jerry_create_string`
-- `jerry_set_property`
-- `jerry_create_external_function`
+- `jerry_current_realm`
+- `jerry_string_sz`
+- `jerry_object_set`
+- `jerry_function_external`
 
 The `api-example-4.c` file should contain the following code:
 
@@ -223,7 +190,7 @@ print_handler (const jerry_call_info_t *call_info_p,
   printf ("Print handler was called\n");
 
   /* Return an "undefined" value to the JavaScript engine */
-  return jerry_create_undefined ();
+  return jerry_undefined ();
 }
 
 int
@@ -238,40 +205,40 @@ main (void)
   /* Add the "print" method for the JavaScript global object */
   {
     /* Get the "global" object */
-    jerry_value_t global_object = jerry_get_global_object ();
+    jerry_value_t global_object = jerry_current_realm ();
     /* Create a "print" JS string */
-    jerry_value_t property_name_print = jerry_create_string ((const jerry_char_t *) "print");
+    jerry_value_t property_name_print = jerry_string_sz ("print");
     /* Create a function from a native C method (this function will be called from JS) */
-    jerry_value_t property_value_func = jerry_create_external_function (print_handler);
+    jerry_value_t property_value_func = jerry_function_external (print_handler);
     /* Add the "print" property with the function value to the "global" object */
-    jerry_value_t set_result = jerry_set_property (global_object, property_name_print, property_value_func);
+    jerry_value_t set_result = jerry_object_set (global_object, property_name_print, property_value_func);
 
     /* Check if there was no error when adding the property (in this case it should never happen) */
-    if (jerry_value_is_error (set_result)) {
+    if (jerry_value_is_exception (set_result)) {
       printf ("Failed to add the 'print' property\n");
     }
 
     /* Release all jerry_value_t-s */
-    jerry_release_value (set_result);
-    jerry_release_value (property_value_func);
-    jerry_release_value (property_name_print);
-    jerry_release_value (global_object);
+    jerry_value_free (set_result);
+    jerry_value_free (property_value_func);
+    jerry_value_free (property_name_print);
+    jerry_value_free (global_object);
   }
 
   /* Setup Global scope code */
   jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
 
-  if (!jerry_value_is_error (parsed_code))
+  if (!jerry_value_is_exception (parsed_code))
   {
     /* Execute the parsed source code in the Global scope */
     jerry_value_t ret_value = jerry_run (parsed_code);
 
     /* Returned value must be freed */
-    jerry_release_value (ret_value);
+    jerry_value_free (ret_value);
   }
 
   /* Parsed source code must be freed */
-  jerry_release_value (parsed_code);
+  jerry_value_free (parsed_code);
 
   /* Cleanup engine */
   jerry_cleanup ();
@@ -304,7 +271,7 @@ argument (which probably comes from a JavaScript source) to a JS string and prin
 New API methods used:
 
 - `jerry_value_to_string`
-- `jerry_string_to_utf8_char_buffer`
+- `jerry_string_to_buffer`
 
 The `api-example-5.c` file should contain the following code:
 
@@ -332,17 +299,17 @@ print_handler (const jerry_call_info_t *call_info_p,
      * Please note that if the string does not fit into the buffer nothing will be copied.
      * More details on the API reference page
      */
-    jerry_size_t copied_bytes = jerry_string_to_utf8_char_buffer (string_value, buffer, sizeof (buffer) - 1);
+    jerry_size_t copied_bytes = jerry_string_to_buffer (string_value, JERRY_ENCODING_UTF8, buffer, sizeof (buffer) - 1);
     buffer[copied_bytes] = '\0';
 
     /* Release the "toString" result */
-    jerry_release_value (string_value);
+    jerry_value_free (string_value);
 
     printf ("%s\n", (const char *)buffer);
   }
 
   /* Return an "undefined" value to the JavaScript engine */
-  return jerry_create_undefined ();
+  return jerry_undefined ();
 }
 
 int
@@ -357,40 +324,40 @@ main (void)
   /* Add the "print" method for the JavaScript global object */
   {
     /* Get the "global" object */
-    jerry_value_t global_object = jerry_get_global_object ();
+    jerry_value_t global_object = jerry_current_realm ();
     /* Create a "print" JS string */
-    jerry_value_t property_name_print = jerry_create_string ((const jerry_char_t *) "print");
+    jerry_value_t property_name_print = jerry_string_sz ("print");
     /* Create a function from a native C method (this function will be called from JS) */
-    jerry_value_t property_value_func = jerry_create_external_function (print_handler);
+    jerry_value_t property_value_func = jerry_function_external (print_handler);
     /* Add the "print" property with the function value to the "global" object */
-    jerry_value_t set_result = jerry_set_property (global_object, property_name_print, property_value_func);
+    jerry_value_t set_result = jerry_object_set (global_object, property_name_print, property_value_func);
 
     /* Check if there was no error when adding the property (in this case it should never happen) */
-    if (jerry_value_is_error (set_result)) {
+    if (jerry_value_is_exception (set_result)) {
       printf ("Failed to add the 'print' property\n");
     }
 
     /* Release all jerry_value_t-s */
-    jerry_release_value (set_result);
-    jerry_release_value (property_value_func);
-    jerry_release_value (property_name_print);
-    jerry_release_value (global_object);
+    jerry_value_free (set_result);
+    jerry_value_free (property_value_func);
+    jerry_value_free (property_name_print);
+    jerry_value_free (global_object);
   }
 
   /* Setup Global scope code */
   jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
 
-  if (!jerry_value_is_error (parsed_code))
+  if (!jerry_value_is_exception (parsed_code))
   {
     /* Execute the parsed source code in the Global scope */
     jerry_value_t ret_value = jerry_run (parsed_code);
 
     /* Returned value must be freed */
-    jerry_release_value (ret_value);
+    jerry_value_free (ret_value);
   }
 
   /* Parsed source code must be freed */
-  jerry_release_value (parsed_code);
+  jerry_value_free (parsed_code);
 
   /* Cleanup engine */
   jerry_cleanup ();
@@ -440,23 +407,22 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   /* Register 'print' function from the extensions to the global object */
-  jerryx_handler_register_global ((const jerry_char_t *) "print",
-                                  jerryx_handler_print);
+  jerryx_handler_register_global ("print", jerryx_handler_print);
 
   /* Setup Global scope code */
   jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
 
-  if (!jerry_value_is_error (parsed_code))
+  if (!jerry_value_is_exception (parsed_code))
   {
     /* Execute the parsed source code in the Global scope */
     jerry_value_t ret_value = jerry_run (parsed_code);
 
     /* Returned value must be freed */
-    jerry_release_value (ret_value);
+    jerry_value_free (ret_value);
   }
 
   /* Parsed source code must be freed */
-  jerry_release_value (parsed_code);
+  jerry_value_free (parsed_code);
 
   /* Cleanup engine */
   jerry_cleanup ();
@@ -502,30 +468,29 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   /* Register 'print' function from the extensions */
-  jerryx_handler_register_global ((const jerry_char_t *) "print",
-                                  jerryx_handler_print);
+  jerryx_handler_register_global ("print", jerryx_handler_print);
 
   /* Getting pointer to the Global object */
-  jerry_value_t global_object = jerry_get_global_object ();
+  jerry_value_t global_object = jerry_current_realm ();
 
   /* Constructing strings */
-  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "my_var");
-  jerry_value_t prop_value = jerry_create_string ((const jerry_char_t *) "Hello from C!");
+  jerry_value_t prop_name = jerry_string_sz ("my_var");
+  jerry_value_t prop_value = jerry_string_sz ("Hello from C!");
 
   /* Setting the string value as a property of the Global object */
-  jerry_value_t set_result = jerry_set_property (global_object, prop_name, prop_value);
+  jerry_value_t set_result = jerry_object_set (global_object, prop_name, prop_value);
   /* The 'set_result' should be checked if there was any error */
-  if (jerry_value_is_error (set_result)) {
+  if (jerry_value_is_exception (set_result)) {
     printf ("Failed to add the 'my_var' property\n");
   }
-  jerry_release_value (set_result);
+  jerry_value_free (set_result);
 
   /* Releasing string values, as it is no longer necessary outside of engine */
-  jerry_release_value (prop_name);
-  jerry_release_value (prop_value);
+  jerry_value_free (prop_name);
+  jerry_value_free (prop_value);
 
   /* Releasing the Global object */
-  jerry_release_value (global_object);
+  jerry_value_free (global_object);
 
   /* Now starting script that would output value of just initialized field */
   jerry_value_t eval_ret = jerry_eval (script,
@@ -533,7 +498,7 @@ main (void)
                                        JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
-  jerry_release_value (eval_ret);
+  jerry_value_free (eval_ret);
 
   /* Freeing engine */
   jerry_cleanup ();
@@ -561,9 +526,9 @@ $ ./api-example-7
 JerryScript value can be a boolean, number, null, object, string, undefined or some special type of objects (arraybuffer, symbols, etc).
 
 There is a special "error" value which wraps another value. This "error" can be created by throwing a JavaScript value from JS code
-or via API method(s). It is advised to check for this error with the `jerry_value_is_error` method as not all API methods
-can process error values. To extract the value from the "error" the API method `jerry_get_value_from_error` should be used.
-If an error object is created via API method (for example with `jerry_create_error`) the "error" value is automatically created.
+or via API method(s). It is advised to check for this error with the `jerry_value_is_exception` method as not all API methods
+can process error values. To extract the value from the "error" the API method `jerry_exception_value` should be used.
+If an error object is created via API method (for example with `jerry_error`) the "error" value is automatically created.
 
 Notice the difference between error value and error object:
 - The error object is a object which was constructed via one of the `Error` objects (available from the global object or from API).
@@ -580,7 +545,7 @@ var error_object = new Error ("error message");
 throw "message";
 ```
 
-To check what type a given `jerry_value_t` is the `jerry_value_is_*` methods or the `jerry_value_get_type` could be used.
+To check what type a given `jerry_value_t` is the `jerry_value_is_*` methods or the `jerry_value_type` could be used.
 For example the following code snippet could print out a few types (not all types are checked):
 
 [doctest]: # (test="compile")
@@ -595,14 +560,14 @@ print_value (const jerry_value_t jsvalue)
 {
   jerry_value_t value;
   /* If there is an error extract the object from it */
-  if (jerry_value_is_error (jsvalue))
+  if (jerry_value_is_exception (jsvalue))
   {
     printf ("Error value detected: ");
-    value = jerry_get_value_from_error (jsvalue, false);
+    value = jerry_exception_value (jsvalue, false);
   }
   else
   {
-    value = jerry_acquire_value (jsvalue);
+    value = jerry_value_copy (jsvalue);
   }
 
   if (jerry_value_is_undefined (value))
@@ -627,7 +592,7 @@ print_value (const jerry_value_t jsvalue)
   /* Float value */
   else if (jerry_value_is_number (value))
   {
-    printf ("number: %lf", jerry_get_number_value (value));
+    printf ("number: %lf", jerry_value_as_number (value));
   }
   /* String value */
   else if (jerry_value_is_string (value))
@@ -635,11 +600,11 @@ print_value (const jerry_value_t jsvalue)
     jerry_char_t str_buf_p[256];
 
     /* Determining required buffer size */
-    jerry_size_t req_sz = jerry_get_string_size (value);
+    jerry_size_t req_sz = jerry_string_size (value, JERRY_ENCODING_CESU8);
 
     if (req_sz <= 255)
     {
-      jerry_string_to_char_buffer (value, str_buf_p, req_sz);
+      jerry_string_to_buffer (value, JERRY_ENCODING_CESU8, str_buf_p, req_sz);
       str_buf_p[req_sz] = '\0';
       printf ("%s", (const char *) str_buf_p);
     }
@@ -655,7 +620,7 @@ print_value (const jerry_value_t jsvalue)
   }
 
   printf ("\n");
-  jerry_release_value (value);
+  jerry_value_free (value);
 }
 ```
 
@@ -689,14 +654,14 @@ print_value (const jerry_value_t jsvalue)
 {
   jerry_value_t value;
   /* If there is an error extract the object from it */
-  if (jerry_value_is_error (jsvalue))
+  if (jerry_value_is_exception (jsvalue))
   {
     printf ("Error value detected: ");
-    value = jerry_get_value_from_error (jsvalue, false);
+    value = jerry_exception_value (jsvalue, false);
   }
   else
   {
-    value = jerry_acquire_value (jsvalue);
+    value = jerry_value_copy (jsvalue);
   }
 
   if (jerry_value_is_undefined (value))
@@ -721,7 +686,7 @@ print_value (const jerry_value_t jsvalue)
   /* Float value */
   else if (jerry_value_is_number (value))
   {
-    printf ("number: %lf", jerry_get_number_value (value));
+    printf ("number: %lf", jerry_value_as_number (value));
   }
   /* String value */
   else if (jerry_value_is_string (value))
@@ -729,11 +694,11 @@ print_value (const jerry_value_t jsvalue)
     jerry_char_t str_buf_p[256];
 
     /* Determining required buffer size */
-    jerry_size_t req_sz = jerry_get_string_size (value);
+    jerry_size_t req_sz = jerry_string_size (value, JERRY_ENCODING_CESU8);
 
     if (req_sz <= 255)
     {
-      jerry_string_to_char_buffer (value, str_buf_p, req_sz);
+      jerry_string_to_buffer (value, JERRY_ENCODING_CESU8, str_buf_p, req_sz);
       str_buf_p[req_sz] = '\0';
       printf ("%s", (const char *) str_buf_p);
     }
@@ -749,7 +714,7 @@ print_value (const jerry_value_t jsvalue)
   }
 
   printf ("\n");
-  jerry_release_value (value);
+  jerry_value_free (value);
 }
 
 int
@@ -761,8 +726,7 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   /* Register 'print' function from the extensions */
-  jerryx_handler_register_global ((const jerry_char_t *) "print",
-                                  jerryx_handler_print);
+  jerryx_handler_register_global ("print", jerryx_handler_print);
 
   while (!is_done)
   {
@@ -805,7 +769,7 @@ main (void)
     /* Print out the value */
     print_value (ret_val);
 
-    jerry_release_value (ret_val);
+    jerry_value_free (ret_val);
   }
 
   /* Cleanup engine */
@@ -853,7 +817,7 @@ get_msg_handler (const jerry_call_info_t *call_info_p, /**< call information */
                  const jerry_value_t *args_p, /**< function arguments */
                  const jerry_length_t args_cnt) /**< number of function arguments */
 {
-  return jerry_create_string ((const jerry_char_t *) my_struct.msg);
+  return jerry_string_sz (my_struct.msg);
 } /* get_msg_handler */
 
 int
@@ -863,33 +827,32 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   /* Register 'print' function from the extensions */
-  jerryx_handler_register_global ((const jerry_char_t *) "print",
-                                  jerryx_handler_print);
+  jerryx_handler_register_global ("print", jerryx_handler_print);
 
   /* Do something with the native object */
   my_struct.msg = "Hello, World!";
 
   /* Create an empty JS object */
-  jerry_value_t object = jerry_create_object ();
+  jerry_value_t object = jerry_object ();
 
   /* Create a JS function object and wrap into a jerry value */
-  jerry_value_t func_obj = jerry_create_external_function (get_msg_handler);
+  jerry_value_t func_obj = jerry_function_external (get_msg_handler);
 
   /* Set the native function as a property of the empty JS object */
-  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "myFunc");
-  jerry_release_value (jerry_set_property (object, prop_name, func_obj));
-  jerry_release_value (prop_name);
-  jerry_release_value (func_obj);
+  jerry_value_t prop_name = jerry_string_sz ("myFunc");
+  jerry_value_free (jerry_object_set (object, prop_name, func_obj));
+  jerry_value_free (prop_name);
+  jerry_value_free (func_obj);
 
   /* Wrap the JS object (not empty anymore) into a jerry api value */
-  jerry_value_t global_object = jerry_get_global_object ();
+  jerry_value_t global_object = jerry_current_realm ();
 
   /* Add the JS object to the global context */
-  prop_name = jerry_create_string ((const jerry_char_t *) "MyObject");
-  jerry_release_value (jerry_set_property (global_object, prop_name, object));
-  jerry_release_value (prop_name);
-  jerry_release_value (object);
-  jerry_release_value (global_object);
+  prop_name = jerry_string_sz ("MyObject");
+  jerry_value_free (jerry_object_set (global_object, prop_name, object));
+  jerry_value_free (prop_name);
+  jerry_value_free (object);
+  jerry_value_free (global_object);
 
   /* Now we have a "builtin" object called MyObject with a function called myFunc()
    *
@@ -905,7 +868,7 @@ main (void)
   jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
-  jerry_release_value (eval_ret);
+  jerry_value_free (eval_ret);
 
   /* Cleanup engine */
   jerry_cleanup ();
@@ -960,27 +923,27 @@ add_handler (const jerry_call_info_t *call_info_p, /**< call information */
   /* Note: that the argument count check is ignored for the example's case */
 
   /* Get 'this.x' */
-  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "x");
-  jerry_value_t x_val = jerry_get_property (call_info_p->this_value, prop_name);
+  jerry_value_t prop_name = jerry_string_sz ("x");
+  jerry_value_t x_val = jerry_object_get (call_info_p->this_value, prop_name);
 
-  if (!jerry_value_is_error (x_val))
+  if (!jerry_value_is_exception (x_val))
   {
     /* Convert Jerry API values to double */
-    double x = jerry_get_number_value (x_val);
-    double d = jerry_get_number_value (args_p[0]);
+    double x = jerry_value_as_number (x_val);
+    double d = jerry_value_as_number (args_p[0]);
 
     /* Add the parameter to 'x' */
-    jerry_value_t res_val = jerry_create_number (x + d);
+    jerry_value_t res_val = jerry_number (x + d);
 
     /* Set the new value of 'this.x' */
-    jerry_release_value (jerry_set_property (call_info_p->this_value, prop_name, res_val));
-    jerry_release_value (res_val);
+    jerry_value_free (jerry_object_set (call_info_p->this_value, prop_name, res_val));
+    jerry_value_free (res_val);
   }
 
-  jerry_release_value (x_val);
-  jerry_release_value (prop_name);
+  jerry_value_free (x_val);
+  jerry_value_free (prop_name);
 
-  return jerry_create_undefined ();
+  return jerry_undefined ();
 } /* add_handler */
 
 int
@@ -990,8 +953,7 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   /* Register 'print' function from the extensions */
-  jerryx_handler_register_global ((const jerry_char_t *) "print",
-                                  jerryx_handler_print);
+  jerryx_handler_register_global ("print", jerryx_handler_print);
 
   /* Create a JS object */
   const jerry_char_t my_js_object[] = " \
@@ -1013,16 +975,16 @@ main (void)
                               JERRY_PARSE_NO_OPTS);
 
   /* Create a JS function object and wrap into a jerry value */
-  jerry_value_t add_func_obj = jerry_create_external_function (add_handler);
+  jerry_value_t add_func_obj = jerry_function_external (add_handler);
 
   /* Set the native function as a property of previously created MyObject */
-  jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "add2x");
-  jerry_release_value (jerry_set_property (my_js_obj_val, prop_name, add_func_obj));
-  jerry_release_value (add_func_obj);
-  jerry_release_value (prop_name);
+  jerry_value_t prop_name = jerry_string_sz ("add2x");
+  jerry_value_free (jerry_object_set (my_js_obj_val, prop_name, add_func_obj));
+  jerry_value_free (add_func_obj);
+  jerry_value_free (prop_name);
 
   /* Free JavaScript value, returned by eval (my_js_object) */
-  jerry_release_value (my_js_obj_val);
+  jerry_value_free (my_js_obj_val);
 
   const jerry_char_t script[] = " \
     var str = MyObject.foo (); \
@@ -1035,7 +997,7 @@ main (void)
   jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
-  jerry_release_value (eval_ret);
+  jerry_value_free (eval_ret);
 
   /* Cleanup engine */
   jerry_cleanup ();
@@ -1090,14 +1052,13 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   /* Register the print function */
-  jerryx_handler_register_global ((const jerry_char_t *) "print",
-                                  jerryx_handler_print);
+  jerryx_handler_register_global ("print", jerryx_handler_print);
 
   /* Evaluate the script */
   jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
 
   /* Free the JavaScript value returned by eval */
-  jerry_release_value (eval_ret);
+  jerry_value_free (eval_ret);
 
   /* Cleanup the engine */
   jerry_cleanup ();

docs/06.REFERENCE-COUNTING.md

@@ -3,10 +3,10 @@
 In JerryScript all `jerry_value_t` values are independent
 references to internal objects. Values returned by JerryScript
 API functions are always live references and must be released
-by `jerry_release_value`.
+by `jerry_value_free`.
 
 ```c
-  jerry_value_t global = jerry_get_global_object ();
+  jerry_value_t global = jerry_current_realm ();
 
   /* The value stored in the 'global' variable contains a live
    * reference to the global object. The system also keeps its
@@ -14,9 +14,9 @@ by `jerry_release_value`.
    * are independent, and both must be destroyed before the global
    * object can be freed. */
 
-  jerry_release_value (global);
+  jerry_value_free (global);
 
-  /* Without jerry_release_value() the global object will not
+  /* Without jerry_value_free() the global object will not
    * be freed even by jerry_cleanup(). After the reference
    * is released it becomes a dead reference and cannot be
    * used anymore. */
@@ -26,15 +26,15 @@ Multiple references might refer to the same internal object
 even though their `jerry_value_t` representation might be different.
 
 ```c
-  jerry_value_t pi_ref1 = jerry_create_number (3.14);
-  jerry_value_t pi_ref2 = jerry_acquire_value (pi_ref1);
+  jerry_value_t pi_ref1 = jerry_number (3.14);
+  jerry_value_t pi_ref2 = jerry_value_copy (pi_ref1);
 
   /* Both pi_ref1 and pi_ref2 refer to the same 3.14 value
    * although they might not be equal in C (pi_ref1 != pi_ref2). */
 
   /* Both references must be released. */
-  jerry_release_value (pi_ref1);
-  jerry_release_value (pi_ref2);
+  jerry_value_free (pi_ref1);
+  jerry_value_free (pi_ref2);
 ```
 
 Releasing the same `jerry_value_t` twice to release two live
@@ -42,8 +42,8 @@ references is not allowed and it might cause crashes. Hence the
 following code is an **INCORRECT WAY** of releasing the 3.14 value.
 
 ```c
-  jerry_release_value (pi_ref1);
-  jerry_release_value (pi_ref1);
+  jerry_value_free (pi_ref1);
+  jerry_value_free (pi_ref1);
 ```
 
 JerryScript API functions returning with a `jerry_value_t` always
@@ -53,7 +53,7 @@ stated in the documentation). The next example shows this
 behaviour through property getting and setting.
 
 ```c
-  jerry_value_t prop_value = jerry_get_property (...);
+  jerry_value_t prop_value = jerry_object_get (...);
 
   /* The prop_value must be released later because both the base
    * object and the prop_value have an independent reference to
@@ -61,7 +61,7 @@ behaviour through property getting and setting.
    * prop_value contains a live reference to an error object.
    * This reference must be released as well. */
 
-  if (jerry_value_is_error (prop_value))
+  if (jerry_value_is_exception (prop_value))
   {
     /* Errors can be handled here. */
   }
@@ -73,12 +73,12 @@ behaviour through property getting and setting.
   }
 
   /* The prop_value must be released. */
-  jerry_release_value (prop_value);
+  jerry_value_free (prop_value);
 
   /* Property setting is the same. */
 
-  jerry_value_t new_prop_value = jerry_create_number (2.718);
-  jerry_value_t result = jerry_set_property (..., new_prop_value);
+  jerry_value_t new_prop_value = jerry_number (2.718);
+  jerry_value_t result = jerry_object_set (..., new_prop_value);
 
   /* If the property set is successful, a new reference is created
    * for the value referenced by new_prop_value. The new_prop_value
@@ -86,14 +86,14 @@ behaviour through property getting and setting.
    * is successful. */
 
   /* The new_prop_value can be passed to other JerryScript API
-   * functions before the jerry_release_value () call. */
+   * functions before the jerry_value_free () call. */
 
-  jerry_release_value (new_prop_value);
+  jerry_value_free (new_prop_value);
 
   /* The reference stored in the 'result' variable is live whether
    * the operation is successful or not, and must also be freed. */
 
-  if (jerry_value_is_error (result))
+  if (jerry_value_is_exception (result))
   {
     /* Errors can be handled here. */
   }
@@ -102,7 +102,7 @@ behaviour through property getting and setting.
     /* A reference to a true primitive value is returned. */
   }
 
-  jerry_release_value (result);
+  jerry_value_free (result);
 ```
 
 The simplest form of setting a property without error checking
@@ -110,8 +110,8 @@ is the following:
 
 ```c
   /* There are no 'ifs' in this snippet. */
-  jerry_release_value (jerry_set_property (..., new_prop_value));
-  jerry_release_value (new_prop_value);
+  jerry_value_free (jerry_object_set (..., new_prop_value));
+  jerry_value_free (new_prop_value);
 ```
 
 The reference returned by a `jerry_external_handler_t` callback
@@ -128,48 +128,48 @@ jerry_value_t my_external_handler (const jerry_value_t function_obj,
    * these references are automatically released after the handler
    * is returned. This approach reduces code size which is useful
    * on embedded systems. However you can create other references
-   * to them by calling jerry_acquire_value () if needed. */
+   * to them by calling jerry_value_copy () if needed. */
 
   /* Since the ownership of the reference is transferred to the
    * caller the following snippet is valid. */
 
   /* If the value to be returned is needed for other purposes the
-   * jerry_acquire_value () can be used to create new references. */
-  return jerry_create_string (...);
+   * jerry_value_copy () can be used to create new references. */
+  return jerry_string (...);
 }
 ```
 
 Duplicating a `jerry_value_t` in C does not create another live reference.
 
 ```c
-  jerry_value_t undef = jerry_create_undefined ();
+  jerry_value_t undef = jerry_undefined ();
   jerry_value_t undef2 = undef;
 
   /* Releasing either undef or undef2 is valid but not both.
    * After the release both references become dead (invalid). */
-  jerry_release_value (undef2);
+  jerry_value_free (undef2);
 
   /* Dead references can be reassigned again. */
-  undef = jerry_create_boolean (true);
+  undef = jerry_boolean (true);
 ```
 
 References can be duplicated in C as long as only one of them is freed.
 
 ```c
-  jerry_value_t a = jerry_create_boolean (true);
+  jerry_value_t a = jerry_boolean (true);
 
   jerry_value_t b = a;
   jerry_value_t c = a;
 
   /* A new reference is assigned to 'a'. */
-  a = jerry_create_boolean (false);
+  a = jerry_boolean (false);
 
   [...]
 
-  jerry_release_value (a);
+  jerry_value_free (a);
   /* The 'a' (boolean false) reference becomes dead (invalid). */
 
-  jerry_release_value (c);
+  jerry_value_free (c);
   /* Both 'b' and 'c' (boolean true) references become dead. */
 
   /* Since all references are released, no memory leak occurs. */

docs/07.DEBUGGER.md

@@ -97,14 +97,14 @@ when a source code is received successfully.
 
 ```c
 typedef jerry_value_t
-(*jerry_debugger_wait_for_source_callback_t) (const jerry_char_t *resource_name_p,
-                                              size_t resource_name_size,
+(*jerry_debugger_wait_for_source_callback_t) (const jerry_char_t *source_name_p,
+                                              size_t source_name_size,
                                               const jerry_char_t *source_p,
                                               size_t source_size, void *user_p);
 ```
 
-- `resource_name_p` - resource (usually a file) name of the source code
-- `resource_name_size` - size of resource name
+- `source_name_p` - resource (usually a file) name of the source code
+- `source_name_size` - size of resource name
 - `source_p` - source code character data
 - `source_size` - size of source code
 - `user_p` - custom pointer passed to [jerry_debugger_wait_for_client_source](#jerry_debugger_wait_for_client_source)
@@ -306,8 +306,8 @@ jerry_debugger_wait_for_client_source (jerry_debugger_wait_for_source_callback_t
  * Runs the source code received by jerry_debugger_wait_for_client_source.
  */
 static jerry_value_t
-wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource name */
-                          size_t resource_name_size, /**< size of resource name */
+wait_for_source_callback (const jerry_char_t *source_name_p, /**< resource name */
+                          size_t source_name_size, /**< size of resource name */
                           const jerry_char_t *source_p, /**< source code */
                           size_t source_size, /**< source code size */
                           void *user_p /**< user pointer */)
@@ -315,19 +315,21 @@ wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource nam
   (void) user_p;
 
   jerry_parse_options_t parse_options;
-  parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-  parse_options.resource_name = jerry_create_string ((const jerry_char_t *) resource_name_p);
+  parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
+  parse_options.source_name = jerry_string ((const jerry_char_t *) source_name_p,
+                                              (jerry_size_t) source_name_size,
+                                              JERRY_ENCODING_UTF8);
 
   jerry_value_t ret_val = jerry_parse (source_p,
                                        source_size,
                                        &parse_options);
-  jerry_release_value (parse_options.resource_name);
+  jerry_value_free (parse_options.source_name);
 
-  if (!jerry_value_is_error (ret_val))
+  if (!jerry_value_is_exception (ret_val))
   {
     jerry_value_t func_val = ret_val;
     ret_val = jerry_run (func_val);
-    jerry_release_value (func_val);
+    jerry_value_free (func_val);
   }
 
   return ret_val;
@@ -355,7 +357,7 @@ main (void)
                                                               NULL,
                                                               &run_result);
 
-      jerry_release_value (run_result);
+      jerry_value_free (run_result);
     }
     while (receive_status == JERRY_DEBUGGER_SOURCE_RECEIVED);
 

docs/09.EXT-REFERENCE-ARG.md

@@ -244,7 +244,7 @@ my_external_handler (const jerry_value_t function_obj,
                                                                mapping,
                                                                4);
 
-  if (jerry_value_is_error (rv))
+  if (jerry_value_is_exception (rv))
   {
     /* Handle error. */
     return rv;
@@ -255,7 +255,7 @@ my_external_handler (const jerry_value_t function_obj,
    * required_bool, required_str and optional_num can now be used.
    */
 
-  return jerry_create_undefined (); /* Or return something more meaningful. */
+  return jerry_undefined (); /* Or return something more meaningful. */
 }
 ```
 
@@ -640,7 +640,7 @@ my_external_handler (const jerry_value_t function_obj,
                                                       mapping,
                                                       1);
 
-  if (jerry_value_is_error (rv))
+  if (jerry_value_is_exception (rv))
   {
     /* Handle error. */
     return rv;
@@ -651,7 +651,7 @@ my_external_handler (const jerry_value_t function_obj,
    * required_bool, required_num and optional_num can now be used.
    */
 
-   return jerry_create_undefined (); /* Or return something more meaningful. */
+   return jerry_undefined (); /* Or return something more meaningful. */
 }
 
 ```
@@ -731,7 +731,7 @@ my_external_handler (const jerry_value_t function_obj,
                                                       mapping,
                                                       1);
 
-  if (jerry_value_is_error (rv))
+  if (jerry_value_is_exception (rv))
   {
     /* Handle error. */
     return rv;
@@ -742,7 +742,7 @@ my_external_handler (const jerry_value_t function_obj,
    * required_bool, required_num and optional_num can now be used.
    */
 
-   return jerry_create_undefined (); /* Or return something more meaningful. */
+   return jerry_undefined (); /* Or return something more meaningful. */
 }
 
 ```

docs/10.EXT-REFERENCE-HANDLER.md

@@ -12,7 +12,7 @@ Set a property on a target object with a given name.
 *Note*:
 - The property name must be a zero terminated UTF-8 string.
 - There should be no '\0' (NULL) character in the name excluding the string terminator.
-- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+- Returned value must be freed with [jerry_value_free](#jerry_value_free) when it
   is no longer needed.
 
 
@@ -45,19 +45,19 @@ main (int argc, char **argv)
 {
   jerry_init (JERRY_INIT_EMPTY);
 
-  jerry_value_t global = jerry_get_global_object ();
+  jerry_value_t global = jerry_current_realm ();
 
-  jerry_value_t value = jerry_create_number (3.3);
+  jerry_value_t value = jerry_number (3.3);
   jerry_value_t result = jerryx_set_property_str (global, "value", value);
-  if (jerry_value_is_error (result))
+  if (jerry_value_is_exception (result))
   {
-    /* The error type/reason can be extracted via the `jerry_get_value_from_error` method */
+    /* The error type/reason can be extracted via the `jerry_exception_value` method */
     printf ("Error during property configuration\r\n");
   }
 
-  jerry_release_value (result);
-  jerry_release_value (value);
-  jerry_release_value (global);
+  jerry_value_free (result);
+  jerry_value_free (value);
+  jerry_value_free (global);
   jerry_cleanup();
 
   return 0;
@@ -73,7 +73,7 @@ Get the value of a property from the specified object with the given name.
 *Notes*:
 - The property name must be a zero terminated UTF-8 string.
 - There should be no '\0' (NULL) character in the name excluding the string terminator.
-- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
+- Returned value must be freed with [jerry_value_free](#jerry_value_free) when it
   is no longer needed.
 
 
@@ -104,14 +104,14 @@ main (int argc, char **argv)
 {
   jerry_init (JERRY_INIT_EMPTY);
 
-  jerry_value_t global = jerry_get_global_object ();
+  jerry_value_t global = jerry_current_realm ();
 
   jerry_value_t math_object = jerryx_get_property_str (global, "Math");
 
   /* use math_object */
 
-  jerry_release_value (math_object);
-  jerry_release_value (global);
+  jerry_value_free (math_object);
+  jerry_value_free (global);
   jerry_cleanup();
 
   return 0;
@@ -125,7 +125,7 @@ main (int argc, char **argv)
 Check if a property exists on an object.
 
 *Notes*:
-- The operation performed is the same as what the `jerry_has_property` method.
+- The operation performed is the same as what the `jerry_object_has` method.
 - The property name must be a zero terminated UTF-8 string.
 - There should be no '\0' (NULL) character in the name excluding the string terminator.
 
@@ -157,11 +157,11 @@ main (int argc, char **argv)
 {
   jerry_init (JERRY_INIT_EMPTY);
 
-  jerry_value_t global = jerry_get_global_object ();
+  jerry_value_t global = jerry_current_realm ();
 
   bool have_math = jerryx_has_property_str (global, "Math");
 
-  jerry_release_value (global);
+  jerry_value_free (global);
   jerry_cleanup();
 
   return have_math ? 0 : 1;
@@ -273,7 +273,7 @@ handler (const jerry_call_info_t *call_info_p,
 {
   printf ("native handler called!\n");
 
-  return jerry_create_boolean (true);
+  return jerry_boolean (true);
 }
 
 int
@@ -283,24 +283,24 @@ main (int argc, char **argv)
 
   jerryx_property_entry methods[] =
   {
-    { "demo", jerry_create_external_function (handler) },
+    { "demo", jerry_function_external (handler) },
     { NULL, 0 },
   };
 
-  jerry_value_t global = jerry_get_global_object ();
+  jerry_value_t global = jerry_current_realm ();
   jerryx_register_result reg = jerryx_set_properties (global, methods);
   /* if `reg.result` is undefined all methods are registered */
-  if (jerry_value_is_error (reg.result))
+  if (jerry_value_is_exception (reg.result))
   {
     printf ("Only registered %d properties\r\n", reg.registered);
     /* clean up not registered property values */
     jerryx_release_property_entry (methods, reg);
 
     /* clean up the error */
-    jerry_release_value (reg.result);
+    jerry_value_free (reg.result);
   }
 
-  jerry_release_value (global);
+  jerry_value_free (global);
 
   jerry_cleanup();
 
@@ -314,8 +314,8 @@ To make property registration convenient, there are a set of macros to use
 when setting a property entry:
 
 * `JERRYX_PROPERTY_NUMBER(NAME, NUMBER)` - creates a number entry.
-* `JERRYX_PROPERTY_STRING(NAME, STR)` - creates an UTF-8 string entry. This string must be zero terminated.
-* `JERRYX_PROPERTY_STRING_SZ(NAME, STR, SIZE)` - creates an UTF-8 string entry using only `SIZE` bytes from the string.
+* `JERRYX_PROPERTY_STRING(NAME, STR, SIZE)` - creates an UTF-8 string entry using `SIZE` bytes from the string.
+* `JERRYX_PROPERTY_STRING_SZ(NAME, STR)` - creates an ASCII string entry. This string must be zero terminated.
 * `JERRYX_PROPERTY_BOOLEAN(NAME, VALUE)` - creates a boolean entry.
 * `JERRYX_PROPERTY_FUNCTION(NAME, NATIVE)` - creates a native C function entry.
 * `JERRYX_PROPERTY_UNDEFINED(NAME)` - creates an undefined property entry.
@@ -336,7 +336,7 @@ handler (const jerry_call_info_t *call_info_p,
 {
   printf ("native handler called!\n");
 
-  return jerry_create_boolean (true);
+  return jerry_boolean (true);
 }
 
 int
@@ -357,20 +357,20 @@ main (int argc, char **argv)
     JERRYX_PROPERTY_LIST_END(),
   };
 
-  jerry_value_t global = jerry_get_global_object ();
+  jerry_value_t global = jerry_current_realm ();
   jerryx_register_result reg = jerryx_set_properties (global, methods);
   /* if `reg.result` is undefined all methods are registered */
-  if (jerry_value_is_error (reg.result))
+  if (jerry_value_is_exception (reg.result))
   {
     printf ("Only registered %d properties\r\n", reg.registered);
     /* clean up not registered property values */
     jerryx_release_property_entry (methods, reg);
 
     /* clean up the error */
-    jerry_release_value (reg.result);
+    jerry_value_free (reg.result);
   }
 
-  jerry_release_value (global);
+  jerry_value_free (global);
 
   jerry_cleanup();
 
@@ -551,14 +551,14 @@ jerryx_handler_print (const jerry_value_t func_obj_val, const jerry_value_t this
 
 Register a JavaScript function in the global object.
 
-*Note*: Returned value must be freed with `jerry_release_value`, when it is no
+*Note*: Returned value must be freed with `jerry_value_free`, when it is no
 longer needed.
 
 **Prototype**
 
 ```c
 jerry_value_t
-jerryx_handler_register_global (const jerry_char_t *name_p,
+jerryx_handler_register_global (const char *name_p,
                                 jerry_external_handler_t handler_p);
 ```
 
@@ -589,14 +589,14 @@ static const struct {
 static void
 register_common_functions (void)
 {
-  jerry_value_t ret = jerry_create_undefined ();
+  jerry_value_t ret = jerry_undefined ();
 
-  for (int i = 0; common_functions[i].name_p != NULL && !jerry_value_is_error (ret); i++)
+  for (int i = 0; common_functions[i].name_p != NULL && !jerry_value_is_exception (ret); i++)
   {
-    ret = jerryx_handler_register_global ((const jerry_char_t *) common_functions[i].name_p,
+    ret = jerryx_handler_register_global (common_functions[i].name_p,
                                           common_functions[i].handler_p);
   }
 
-  jerry_release_value (ret);
+  jerry_value_free (ret);
 }
 ```

docs/11.EXT-REFERENCE-AUTORELEASE.md

@@ -4,7 +4,7 @@
 
 **Summary**
 
-Macro for `const jerry_value_t` for which jerry_release_value() is
+Macro for `const jerry_value_t` for which jerry_value_free() is
 automatically called when the variable goes out of scope.
 
 *Note*: The macro depends on compiler support. For GCC and LLVM/clang, the macro is implemented
@@ -21,23 +21,23 @@ using the `__cleanup__` variable attribute. For other compilers, no support has
 static void
 foo (bool enable)
 {
-  JERRYX_AR_VALUE_T bar = jerry_create_string ((const jerry_char_t *) "...");
+  JERRYX_AR_VALUE_T bar = jerry_string_sz ("...");
 
   if (enable)
   {
-    JERRYX_AR_VALUE_T baz = jerry_get_global_object ();
+    JERRYX_AR_VALUE_T baz = jerry_current_realm ();
 
     /* bar and baz can now be used. */
 
     /*
-     * jerry_release_value (baz) and jerry_release_value (bar) is called automatically before
+     * jerry_value_free (baz) and jerry_value_free (bar) is called automatically before
      * returning, because `baz` and `bar` go out of scope.
      */
     return;
   }
 
   /*
-   * jerry_release_value (bar) is called automatically when the function returns,
+   * jerry_value_free (bar) is called automatically when the function returns,
    * because `bar` goes out of scope.
    */
 }
@@ -46,5 +46,5 @@ foo (bool enable)
 **See also**
 
 - [jerry_value_t](../docs/02.API-REFERENCE.md#jerry_value_t)
-- [jerry_acquire_value](../docs/02.API-REFERENCE.md#jerry_acquire_value)
-- [jerry_release_value](../docs/02.API-REFERENCE.md#jerry_release_value)
+- [jerry_value_copy](../docs/02.API-REFERENCE.md#jerry_value_copy)
+- [jerry_value_free](../docs/02.API-REFERENCE.md#jerry_value_free)

docs/12.EXT-REFERENCE-MODULE.md

@@ -164,9 +164,9 @@ load_and_evaluate_js_file (const jerry_value_t name, jerry_value_t *result)
   char *js_file_contents = NULL;
   int file_size = 0;
 
-  jerry_size_t name_size = jerry_get_utf8_string_size (name);
+  jerry_size_t name_size = jerry_string_size (name, JERRY_ENCODING_UTF8);
   jerry_char_t name_string[name_size + 1];
-  jerry_string_to_utf8_char_buffer (name, name_string, name_size);
+  jerry_string_to_buffer (name, JERRY_ENCODING_UTF8, name_string, name_size);
   name_string[name_size] = 0;
 
   FILE *js_file = fopen (name_string, "r");
@@ -205,7 +205,7 @@ canonicalize_file_path (const jerry_value_t name)
   /**
    * Since a file on the file system can be referred to by multiple relative paths, but only by one absolute path, the
    * absolute path becomes the canonical name for the module. Thus, to establish this canonical name, we must search
-   * name for "./" and "../", follow symlinks, etc., then create absolute_path via jerry_create_string () and return
+   * name for "./" and "../", follow symlinks, etc., then create absolute_path via jerry_string () and return
    * it, because it is the canonical name for this module. Thus, we avoid loading the same JavaScript file twice.
    */
 
@@ -271,7 +271,7 @@ loaded.
 static jerry_value_t
 my_module_on_resolve (void)
 {
-  return jerry_create_external_function (very_useful_function);
+  return jerry_function_external (very_useful_function);
 } /* my_module_on_resolve */
 
 /* Note that there is no semicolon at the end of the next line. This is how it must be. */

docs/14.EXT-REFERENCE-HANDLE-SCOPE.md

@@ -20,7 +20,7 @@ JerryScript only supports a single nested hierarchy of scopes. There is only one
 static jerry_value_t
 create_object (void)
 {
-  jerry_value_t obj = jerry_create_object ();
+  jerry_value_t obj = jerry_object ();
   return obj;
 } /* create_object */
 
@@ -41,7 +41,7 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   test_handle_scope_val ();
-  jerry_gc (JERRY_GC_PRESSURE_LOW);
+  jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
 
   jerry_cleanup ();
 } /* main */
@@ -66,7 +66,7 @@ create_object (void)
 {
   jerryx_escapable_handle_scope scope;
   jerryx_open_escapable_handle_scope (&scope);
-  jerry_value_t obj = jerryx_create_handle (jerry_create_object ());
+  jerry_value_t obj = jerryx_create_handle (jerry_object ());
 
   jerry_value_t escaped_obj;
   jerryx_escape_handle(scope, obj, &escaped_obj);
@@ -93,7 +93,7 @@ main (void)
   jerry_init (JERRY_INIT_EMPTY);
 
   test_handle_scope_val ();
-  jerry_gc (JERRY_GC_PRESSURE_LOW);
+  jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
 
   jerry_cleanup ();
 } /* main */
@@ -102,8 +102,8 @@ main (void)
 **See also**
 
 - [jerry_value_t](../docs/02.API-REFERENCE.md#jerry_value_t)
-- [jerry_acquire_value](../docs/02.API-REFERENCE.md#jerry_acquire_value)
-- [jerry_release_value](../docs/02.API-REFERENCE.md#jerry_release_value)
+- [jerry_value_copy](../docs/02.API-REFERENCE.md#jerry_value_copy)
+- [jerry_value_free](../docs/02.API-REFERENCE.md#jerry_value_free)
 
 ## Pre-allocated list of handle scopes and handles