diff --git a/docs/API-EXAMPLE.md b/docs/API-EXAMPLE.md index 08c40d3807..d587e364d6 100644 --- a/docs/API-EXAMPLE.md +++ b/docs/API-EXAMPLE.md @@ -11,7 +11,7 @@ This guide is intended to introduce you to JerryScript embedding API through cre int main (int argc, char * argv[]) { - const jerry_api_char_t script[] = "print ('Hello, World!');"; + const jerry_char_t script[] = "print ('Hello, World!');"; size_t script_size = strlen ((const char *) script); jerry_completion_code_t return_code = jerry_run_simple (script, @@ -45,29 +45,29 @@ Here we perform the same actions, as `jerry_run_simple`, while splitting into se int main (int argc, char * argv[]) { - const jerry_api_char_t script[] = "print ('Hello, World!');"; + const jerry_char_t script[] = "print ('Hello, World!');"; size_t script_size = strlen ((const char *) script); /* Initialize engine */ jerry_init (JERRY_FLAG_EMPTY); /* Setup Global scope code */ - jerry_api_object_t *error_object_p = NULL; + jerry_object_t *error_object_p = NULL; if (!jerry_parse (script, script_size, &error_object_p)) { /* Error object must be freed, if parsing failed */ - jerry_api_release_object (error_object_p); + jerry_release_object (error_object_p); } else { /* Execute Global scope code */ - jerry_api_value_t error_value = jerry_api_create_void_value (); + jerry_value_t error_value = jerry_create_void_value (); jerry_completion_code_t return_code = jerry_run (&error_value); if (return_code == JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION) { /* Error value must be freed, if 'jerry_run' returns with an unhandled exception */ - jerry_api_release_value (&error_value); + jerry_release_value (&error_value); } } @@ -89,33 +89,33 @@ Our code is more complex now, but it introduces possibilities to interact with J int main (int argc, char * argv[]) { - const jerry_api_char_t script_1[] = "var s = 'Hello, World!';"; - const jerry_api_char_t script_2[] = "print (s);"; + const jerry_char_t script_1[] = "var s = 'Hello, World!';"; + const jerry_char_t script_2[] = "print (s);"; /* Initialize engine */ jerry_init (JERRY_FLAG_EMPTY); - jerry_api_value_t eval_ret; + jerry_value_t eval_ret; /* Evaluate script1 */ - jerry_api_eval (script_1, - strlen ((const char *) script_1), - false, - false, - &eval_ret); + jerry_eval (script_1, + strlen ((const char *) script_1), + false, + false, + &eval_ret); /* Free JavaScript value, returned by eval */ - jerry_api_release_value (&eval_ret); + jerry_release_value (&eval_ret); /* Evaluate script2 */ - jerry_api_eval (script_2, - strlen ((const char *) script_2), - false, - false, - &eval_ret); + jerry_eval (script_2, + strlen ((const char *) script_2), + false, + false, + &eval_ret); /* Free JavaScript value, returned by eval */ - jerry_api_release_value (&eval_ret); + jerry_release_value (&eval_ret); /* Cleanup engine */ jerry_cleanup (); @@ -134,44 +134,44 @@ This way, we execute two independent script parts in one execution environment. int main (int argc, char * argv[]) { - const jerry_api_char_t str[] = "Hello, World!"; - const jerry_api_char_t var_name[] = "s"; - const jerry_api_char_t script[] = "print (s);"; + const jerry_char_t str[] = "Hello, World!"; + const jerry_char_t var_name[] = "s"; + const jerry_char_t script[] = "print (s);"; /* Initializing JavaScript environment */ jerry_init (JERRY_FLAG_EMPTY); /* Getting pointer to the Global object */ - jerry_api_object_t *object_p = jerry_api_get_global (); + jerry_object_t *object_p = jerry_get_global (); /* Constructing string */ - jerry_api_string_t *str_val_p = jerry_api_create_string (str); + jerry_string_t *str_val_p = jerry_create_string (str); /* Constructing string value descriptor */ - jerry_api_value_t value; + jerry_value_t value; value.type = JERRY_API_DATA_TYPE_STRING; value.u.v_string = str_val_p; /* Setting the string value to field of the Global object */ - jerry_api_set_object_field_value (object_p, var_name, &value); + jerry_set_object_field_value (object_p, var_name, &value); /* Releasing string value, as it is no longer necessary outside of engine */ - jerry_api_release_string (str_val_p); + jerry_release_string (str_val_p); /* Same for pointer to the Global object */ - jerry_api_release_object (object_p); + jerry_release_object (object_p); - jerry_api_value_t eval_ret; + jerry_value_t eval_ret; /* Now starting script that would output value of just initialized field */ - jerry_api_eval (script, - strlen ((const char *) script), - false, - false, - &eval_ret); + jerry_eval (script, + strlen ((const char *) script), + false, + false, + &eval_ret); /* Free JavaScript value, returned by eval */ - jerry_api_release_value (&eval_ret); + jerry_release_value (&eval_ret); /* Freeing engine */ jerry_cleanup (); @@ -205,7 +205,7 @@ Structure, used to put values to or receive values from the engine is the follow Abstract values, to be sent to or received from the engine are described with the structure. -Pointers to strings or objects and values should be released just when become unnecessary, using `jerry_api_release_string` or `jerry_api_release_object` and `jerry_api_release_value`, correspondingly. +Pointers to strings or objects and values should be released just when become unnecessary, using `jerry_release_string` or `jerry_release_object` and `jerry_release_value`, correspondingly. The following example function will output a JavaScript value: @@ -213,7 +213,7 @@ The following example function will output a JavaScript value: #include static void -print_value (const jerry_api_value_t *value_p) +print_value (const jerry_value_t *value_p) { switch (value_p->type) { @@ -267,11 +267,9 @@ print_value (const jerry_api_value_t *value_p) case JERRY_API_DATA_TYPE_STRING: { /* Determining required buffer size */ - jerry_api_size_t req_sz = jerry_api_get_string_size (value_p->u.v_string); - jerry_api_char_t *str_buf_p = (jerry_api_char_t *) malloc (req_sz); - jerry_api_string_to_char_buffer (value_p->u.v_string, - str_buf_p, - req_sz); + jerry_size_t req_sz = jerry_get_string_size (value_p->u.v_string); + jerry_char_t *str_buf_p = (jerry_char_t *) malloc (req_sz); + jerry_string_to_char_buffer (value_p->u.v_string, str_buf_p, req_sz); printf ("%s", (const char *) str_buf_p); @@ -311,7 +309,7 @@ Shell operation can be described with the following loop: #include "jerry.h" -static void print_value (const jerry_api_value_t *value_p); +static void print_value (const jerry_value_t *value_p); int main (int argc, char * argv[]) @@ -334,21 +332,21 @@ main (int argc, char * argv[]) break; } - jerry_api_value_t ret_val; + jerry_value_t ret_val; /* Evaluate entered command */ - status = jerry_api_eval ((const jerry_api_char_t *) cmd, - strlen (cmd), - false, - false, - &ret_val); + status = jerry_eval ((const jerry_char_t *) cmd, + strlen (cmd), + false, + false, + &ret_val); /* If command evaluated successfully, print value, returned by eval */ if (status == JERRY_COMPLETION_CODE_OK) { /* 'eval' completed successfully */ print_value (&ret_val); - jerry_api_release_value (&ret_val); + jerry_release_value (&ret_val); } else { @@ -386,14 +384,14 @@ struct my_struct * Get a string from a native object */ static bool -get_msg_handler (const jerry_api_object_t *function_obj_p, /**< function object */ - const jerry_api_value_t *this_p, /**< this arg */ - jerry_api_value_t *ret_val_p, /**< return argument */ - const jerry_api_value_t *args_p, /**< function arguments */ - const jerry_api_length_t args_cnt) /**< number of function arguments */ +get_msg_handler (const jerry_object_t *function_obj_p, /**< function object */ + const jerry_value_t *this_p, /**< this arg */ + jerry_value_t *ret_val_p, /**< return argument */ + const jerry_value_t *args_p, /**< function arguments */ + const jerry_length_t args_cnt) /**< number of function arguments */ { - jerry_api_string_t *msg_str_p = jerry_api_create_string ((const jerry_api_char_t *) my_struct.msg); - *ret_val_p = jerry_api_create_string_value (msg_str_p); + jerry_string_t *msg_str_p = jerry_create_string ((const jerry_char_t *) my_struct.msg); + *ret_val_p = jerry_create_string_value (msg_str_p); return true; } /* get_msg_handler */ @@ -410,53 +408,49 @@ main (int argc, char * argv[]) my_struct.msg = "Hello World"; /* Create an empty JS object */ - jerry_api_object_t *object_p = jerry_api_create_object (); + jerry_object_t *object_p = jerry_create_object (); /* Create a JS function object and wrap into a jerry value */ - jerry_api_value_t object_value; + jerry_value_t object_value; object_value.type = JERRY_API_DATA_TYPE_OBJECT; - object_value.u.v_object = jerry_api_create_external_function (get_msg_handler); + object_value.u.v_object = jerry_create_external_function (get_msg_handler); /* Set the native function as a property of the empty JS object */ - jerry_api_set_object_field_value (object_p, - (const jerry_api_char_t *) "myFunc", - &object_value); - jerry_api_release_value (&object_value); + jerry_set_object_field_value (object_p, + (const jerry_char_t *) "myFunc", + &object_value); + jerry_release_value (&object_value); /* Wrap the JS object (not empty anymore) into a jerry api value */ object_value.type = JERRY_API_DATA_TYPE_OBJECT; object_value.u.v_object = object_p; - jerry_api_object_t *global_obj_p = jerry_api_get_global (); + jerry_object_t *global_obj_p = jerry_get_global (); /* Add the JS object to the global context */ - jerry_api_set_object_field_value (global_obj_p, - (const jerry_api_char_t *) "MyObject", - &object_value); - jerry_api_release_value (&object_value); - jerry_api_release_object (global_obj_p); + jerry_set_object_field_value (global_obj_p, + (const jerry_char_t *) "MyObject", + &object_value); + jerry_release_value (&object_value); + jerry_release_object (global_obj_p); /* Now we have a "builtin" object called MyObject with a function called myFunc() * * Equivalent JS code: * var MyObject = { myFunc : function () { return "some string value"; } } */ - const jerry_api_char_t script[] = " \ + const jerry_char_t script[] = " \ var str = MyObject.myFunc (); \ print (str); \ "; size_t script_size = strlen ((const char *) script); - jerry_api_value_t eval_ret; + jerry_value_t eval_ret; /* Evaluate script */ - status = jerry_api_eval (script, - script_size, - false, - false, - &eval_ret); + status = jerry_eval (script, script_size, false, false, &eval_ret); /* Free JavaScript value, returned by eval */ - jerry_api_release_value (&eval_ret); + jerry_release_value (&eval_ret); /* Cleanup engine */ jerry_cleanup (); @@ -473,7 +467,7 @@ Hello World ## Step 7. Extending JS Objects with native functions -Here we create a JS Object with `jerry_api_eval`, then extend it with a native function. This function shows how to get a property value from the object and how to manipulate it. +Here we create a JS Object with `jerry_eval`, then extend it with a native function. This function shows how to get a property value from the object and how to manipulate it. ```c #include @@ -483,30 +477,30 @@ Here we create a JS Object with `jerry_api_eval`, then extend it with a native f * Add param to 'this.x' */ static bool -add_handler (const jerry_api_object_t *function_obj_p, /**< function object */ - const jerry_api_value_t *this_p, /**< this arg */ - jerry_api_value_t *ret_val_p, /**< return argument */ - const jerry_api_value_t *args_p, /**< function arguments */ - const jerry_api_length_t args_cnt) /**< number of function arguments */ +add_handler (const jerry_object_t *function_obj_p, /**< function object */ + const jerry_value_t *this_p, /**< this arg */ + jerry_value_t *ret_val_p, /**< return argument */ + const jerry_value_t *args_p, /**< function arguments */ + const jerry_length_t args_cnt) /**< number of function arguments */ { - jerry_api_value_t x_val; + jerry_value_t x_val; /* Get 'this.x' */ - if (jerry_api_get_object_field_value (jerry_api_get_object_value (this_p), - (const jerry_api_char_t *) "x", - &x_val)) + if (jerry_get_object_field_value (jerry_get_object_value (this_p), + (const jerry_char_t *) "x", + &x_val)) { /* Convert Jerry API values to double */ - double x = jerry_api_get_number_value (&x_val); - double d = jerry_api_get_number_value (args_p); + double x = jerry_get_number_value (&x_val); + double d = jerry_get_number_value (args_p); /* Add the parameter to 'x' */ - jerry_api_value_t res_val = jerry_api_create_number_value (x + d); + jerry_value_t res_val = jerry_create_number_value (x + d); /* Set the new value of 'this.x' */ - jerry_api_set_object_field_value (jerry_api_get_object_value (this_p), - (const jerry_api_char_t *) "x", - &res_val); + jerry_set_object_field_value (jerry_get_object_value (this_p), + (const jerry_char_t *) "x", + &res_val); } @@ -522,7 +516,7 @@ main (int argc, char * argv[]) jerry_init (JERRY_FLAG_EMPTY); /* Create a JS object */ - const jerry_api_char_t my_js_object[] = " \ + const jerry_char_t my_js_object[] = " \ MyObject = \ { x : 12, \ y : 'Value of x is ', \ @@ -533,32 +527,32 @@ main (int argc, char * argv[]) } \ "; - jerry_api_value_t my_js_obj_val; + jerry_value_t my_js_obj_val; /* Evaluate script */ - status = jerry_api_eval (my_js_object, - strlen ((const char *) my_js_object), - false, - false, - &my_js_obj_val); + status = jerry_eval (my_js_object, + strlen ((const char *) my_js_object), + false, + false, + &my_js_obj_val); - jerry_api_object_t *object_p = jerry_api_get_object_value (&my_js_obj_val); + jerry_object_t *object_p = jerry_get_object_value (&my_js_obj_val); /* Create a JS function object and wrap into a jerry value */ - jerry_api_value_t object_value; + jerry_value_t object_value; object_value.type = JERRY_API_DATA_TYPE_OBJECT; - object_value.u.v_object = jerry_api_create_external_function (add_handler); + object_value.u.v_object = jerry_create_external_function (add_handler); /* Set the native function as a property of previously created MyObject */ - jerry_api_set_object_field_value (object_p, - (const jerry_api_char_t *) "add2x", - &object_value); - jerry_api_release_value (&object_value); + jerry_set_object_field_value (object_p, + (const jerry_char_t *) "add2x", + &object_value); + jerry_release_value (&object_value); /* Free JavaScript value, returned by eval (my_js_object) */ - jerry_api_release_value (&my_js_obj_val); + jerry_release_value (&my_js_obj_val); - const jerry_api_char_t script[] = " \ + const jerry_char_t script[] = " \ var str = MyObject.foo (); \ print (str); \ MyObject.add2x (5); \ @@ -566,17 +560,13 @@ main (int argc, char * argv[]) "; size_t script_size = strlen ((const char *) script); - jerry_api_value_t eval_ret; + jerry_value_t eval_ret; /* Evaluate script */ - status = jerry_api_eval (script, - script_size, - false, - false, - &eval_ret); + status = jerry_eval (script, script_size, false, false, &eval_ret); /* Free JavaScript value, returned by eval */ - jerry_api_release_value (&eval_ret); + jerry_release_value (&eval_ret); /* Cleanup engine */ jerry_cleanup (); diff --git a/jerry-core/ecma/operations/ecma-eval.c b/jerry-core/ecma/operations/ecma-eval.c index 18887b66a8..5559138cd5 100644 --- a/jerry-core/ecma/operations/ecma-eval.c +++ b/jerry-core/ecma/operations/ecma-eval.c @@ -56,7 +56,7 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */ { ECMA_STRING_TO_UTF8_STRING (code_p, code_utf8_buffer_p, code_utf8_buffer_size); - ret_value = ecma_op_eval_chars_buffer ((jerry_api_char_t *) code_utf8_buffer_p, + ret_value = ecma_op_eval_chars_buffer ((jerry_char_t *) code_utf8_buffer_p, chars_num, is_direct, is_called_from_strict_mode_code); @@ -77,7 +77,7 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */ * @return ecma value */ ecma_value_t -ecma_op_eval_chars_buffer (const jerry_api_char_t *code_p, /**< code characters buffer */ +ecma_op_eval_chars_buffer (const jerry_char_t *code_p, /**< code characters buffer */ size_t code_buffer_size, /**< size of the buffer */ bool is_direct, /**< is eval called directly (ECMA-262 v5, 15.1.2.1.1) */ bool is_called_from_strict_mode_code) /**< is eval is called from strict mode code */ @@ -90,7 +90,7 @@ ecma_op_eval_chars_buffer (const jerry_api_char_t *code_p, /**< code characters jsp_status_t parse_status; bool is_strict_call = (is_direct && is_called_from_strict_mode_code); - jerry_api_object_t *error_obj_p = NULL; + jerry_object_t *error_obj_p = NULL; parse_status = parser_parse_eval (code_p, code_buffer_size, diff --git a/jerry-core/ecma/operations/ecma-eval.h b/jerry-core/ecma/operations/ecma-eval.h index 2e198ff1fd..ea60596270 100644 --- a/jerry-core/ecma/operations/ecma-eval.h +++ b/jerry-core/ecma/operations/ecma-eval.h @@ -1,4 +1,5 @@ /* Copyright 2015-2016 Samsung Electronics Co., Ltd. + * Copyright 2016 University of Szeged. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -29,7 +30,7 @@ extern ecma_value_t ecma_op_eval (ecma_string_t *, bool, bool); extern ecma_value_t -ecma_op_eval_chars_buffer (const jerry_api_char_t *, size_t, bool, bool); +ecma_op_eval_chars_buffer (const jerry_char_t *, size_t, bool, bool); /** * @} diff --git a/jerry-core/jerry-api.h b/jerry-core/jerry-api.h index b39257fc56..634b4c9dd9 100644 --- a/jerry-core/jerry-api.h +++ b/jerry-core/jerry-api.h @@ -47,67 +47,67 @@ typedef enum */ typedef enum { - JERRY_API_DATA_TYPE_VOID, /**< no return value */ - JERRY_API_DATA_TYPE_UNDEFINED, /**< undefined */ - JERRY_API_DATA_TYPE_NULL, /**< null */ - JERRY_API_DATA_TYPE_BOOLEAN, /**< bool */ - JERRY_API_DATA_TYPE_FLOAT32, /**< 32-bit float */ - JERRY_API_DATA_TYPE_FLOAT64, /**< 64-bit float */ - JERRY_API_DATA_TYPE_UINT32, /**< number converted to 32-bit unsigned integer */ - JERRY_API_DATA_TYPE_STRING, /**< string */ - JERRY_API_DATA_TYPE_OBJECT /**< object */ -} jerry_api_data_type_t; + JERRY_DATA_TYPE_VOID, /**< no return value */ + JERRY_DATA_TYPE_UNDEFINED, /**< undefined */ + JERRY_DATA_TYPE_NULL, /**< null */ + JERRY_DATA_TYPE_BOOLEAN, /**< bool */ + JERRY_DATA_TYPE_FLOAT32, /**< 32-bit float */ + JERRY_DATA_TYPE_FLOAT64, /**< 64-bit float */ + JERRY_DATA_TYPE_UINT32, /**< number converted to 32-bit unsigned integer */ + JERRY_DATA_TYPE_STRING, /**< string */ + JERRY_DATA_TYPE_OBJECT /**< object */ +} jerry_data_type_t; /** * Jerry API Error object types */ typedef enum { - JERRY_API_ERROR_COMMON, /**< Error */ - JERRY_API_ERROR_EVAL, /**< EvalError */ - JERRY_API_ERROR_RANGE, /**< RangeError */ - JERRY_API_ERROR_REFERENCE, /**< ReferenceError */ - JERRY_API_ERROR_SYNTAX, /**< SyntaxError */ - JERRY_API_ERROR_TYPE, /**< TypeError */ - JERRY_API_ERROR_URI /**< URIError */ -} jerry_api_error_t; + JERRY_ERROR_COMMON, /**< Error */ + JERRY_ERROR_EVAL, /**< EvalError */ + JERRY_ERROR_RANGE, /**< RangeError */ + JERRY_ERROR_REFERENCE, /**< ReferenceError */ + JERRY_ERROR_SYNTAX, /**< SyntaxError */ + JERRY_ERROR_TYPE, /**< TypeError */ + JERRY_ERROR_URI /**< URIError */ +} jerry_error_t; /** * Jerry's char value -*/ -typedef uint8_t jerry_api_char_t; + */ +typedef uint8_t jerry_char_t; /** * Pointer to an array of character values */ -typedef jerry_api_char_t *jerry_api_char_ptr_t; +typedef jerry_char_t *jerry_char_ptr_t; /** * Jerry's size -*/ -typedef uint32_t jerry_api_size_t; + */ +typedef uint32_t jerry_size_t; /** * Jerry's length -*/ -typedef uint32_t jerry_api_length_t; + */ +typedef uint32_t jerry_length_t; /** * Jerry's string value */ -typedef struct ecma_string_t jerry_api_string_t; +typedef struct ecma_string_t jerry_string_t; /** * Jerry's object value */ -typedef struct ecma_object_t jerry_api_object_t; +typedef struct ecma_object_t jerry_object_t; /** * Description of an extension function's argument */ -typedef struct jerry_api_value_t +typedef struct jerry_value_t { - jerry_api_data_type_t type; /**< argument data type */ + jerry_data_type_t type; /**< argument data type */ union { @@ -118,212 +118,128 @@ typedef struct jerry_api_value_t uint32_t v_uint32; /**< number converted 32-bit unsigned integer */ - jerry_api_string_t *v_string; /**< pointer to a JS string */ - jerry_api_object_t *v_object; /**< pointer to a JS object */ + jerry_string_t *v_string; /**< pointer to a JS string */ + jerry_object_t *v_object; /**< pointer to a JS object */ } u; -} jerry_api_value_t; +} jerry_value_t; /** - * Jerry external function handler type + * Type of an external function handler */ -typedef bool (*jerry_external_handler_t) (const jerry_api_object_t *function_obj_p, - const jerry_api_value_t *this_p, - jerry_api_value_t *ret_val_p, - const jerry_api_value_t args_p[], - const jerry_api_length_t args_count); +typedef bool (*jerry_external_handler_t) (const jerry_object_t *function_obj_p, + const jerry_value_t *this_p, + jerry_value_t *ret_val_p, + const jerry_value_t args_p[], + const jerry_length_t args_count); /** - * An object's native free callback + * Native free callback of an object */ typedef void (*jerry_object_free_callback_t) (const uintptr_t native_p); /** - * function type applied for each fields in objects + * Function type applied for each fields in objects */ -typedef bool (*jerry_object_field_foreach_t) (const jerry_api_string_t *field_name_p, - const jerry_api_value_t *field_value_p, +typedef bool (*jerry_object_field_foreach_t) (const jerry_string_t *field_name_p, + const jerry_value_t *field_value_p, void *user_data_p); -/** - * Returns whether the given jerry_api_value_t is void. - */ -bool jerry_api_value_is_void (const jerry_api_value_t *value_p); - -/** - * Returns whether the given jerry_api_value_t is null. - */ -bool jerry_api_value_is_null (const jerry_api_value_t *value_p); - -/** - * Returns whether the given jerry_api_value_t is undefined. - */ -bool jerry_api_value_is_undefined (const jerry_api_value_t *value_p); /** - * Returns whether the given jerry_api_value_t has boolean type. + * Get the global context */ -bool jerry_api_value_is_boolean (const jerry_api_value_t *value_p); +jerry_object_t *jerry_get_global (void); /** - * Returns whether the given jerry_api_value_t is number. - * - * More specifically, returns true if the type is JERRY_API_DATA_TYPE_FLOAT32, - * JERRY_API_DATA_TYPE_FLOAT64 or JERRY_API_DATA_TYPE_UINT32, false otherwise. - */ -bool jerry_api_value_is_number (const jerry_api_value_t *value_p); - -/** - * Returns whether the given jerry_api_value_t is string. + * Checker functions of 'jerry_value_t' */ -bool jerry_api_value_is_string (const jerry_api_value_t *value_p); +bool jerry_value_is_void (const jerry_value_t *value_p); +bool jerry_value_is_null (const jerry_value_t *value_p); +bool jerry_value_is_undefined (const jerry_value_t *value_p); +bool jerry_value_is_boolean (const jerry_value_t *value_p); +bool jerry_value_is_number (const jerry_value_t *value_p); +bool jerry_value_is_string (const jerry_value_t *value_p); +bool jerry_value_is_object (const jerry_value_t *value_p); +bool jerry_value_is_function (const jerry_value_t *value_p); /** - * Returns whether the given jerry_api_value_t is object. + * Getter functions of 'jerry_value_t' */ -bool jerry_api_value_is_object (const jerry_api_value_t *value_p); +bool jerry_get_boolean_value (const jerry_value_t *value_p); +double jerry_get_number_value (const jerry_value_t *value_p); +jerry_string_t *jerry_get_string_value (const jerry_value_t *value_p); +jerry_object_t *jerry_get_object_value (const jerry_value_t *value_p); /** - * Returns whether the given jerry_api_value_t is a function object. - * - * More specifically, returns true if the jerry_api_value_t of the value - * pointed by value_p has JERRY_API_DATA_TYPE_OBJECT type and - * jerry_api_is_function() functiron return true for its v_object member, - * otherwise false. + * Converters of 'jerry_value_t' */ -bool jerry_api_value_is_function (const jerry_api_value_t *value_p); +jerry_string_t *jerry_value_to_string (const jerry_value_t *); /** - * Returns the boolean v_bool member of the given jerry_api_value_t structure. - * If the given jerry_api_value_t structure has type other than - * JERRY_API_DATA_TYPE_BOOLEAN, JERRY_ASSERT fails. + * Create functions of 'jerry_value_t' */ -bool jerry_api_get_boolean_value (const jerry_api_value_t *value_p); +jerry_value_t jerry_create_void_value (void); +jerry_value_t jerry_create_null_value (void); +jerry_value_t jerry_create_undefined_value (void); +jerry_value_t jerry_create_boolean_value (bool value); +jerry_value_t jerry_create_number_value (double value); +jerry_value_t jerry_create_object_value (jerry_object_t *value); +jerry_value_t jerry_create_string_value (jerry_string_t *value); /** - * Returns the number value of the given jerry_api_value_t structure - * as a double. - * - * If the given jerry_api_value_t structure has type JERRY_API_DATA_TYPE_UINT32 - * v_uint32 member will be returned as a double value. If the given - * jerry_api_value_t structure has type JERRY_API_DATA_TYPE_FLOAT32 - * v_float32 member will be returned as a double and if tpye is - * JERRY_API_DATA_TYPE_FLOAT64 the function returns the v_float64 member. - * As long as the type is none of the above, JERRY_ASSERT falis. + * Acquire types with reference counter (increase the references) */ -double jerry_api_get_number_value (const jerry_api_value_t *value_p); +jerry_string_t *jerry_acquire_string (jerry_string_t *); +jerry_object_t *jerry_acquire_object (jerry_object_t *); +jerry_value_t *jerry_acquire_value (jerry_value_t *); /** - * Returns the v_string member of the given jerry_api_value_t structure. - * If the given jerry_api_value_t structure has type other than - * JERRY_API_DATA_TYPE_STRING, JERRY_ASSERT fails. + * Relase the referenced values */ -jerry_api_string_t *jerry_api_get_string_value (const jerry_api_value_t *value_p); +void jerry_release_object (jerry_object_t *); +void jerry_release_string (jerry_string_t *); +void jerry_release_value (jerry_value_t *); /** - * Returns the v_object member of the given jerry_api_value_t structure. - * If the given jerry_api_value_t structure has type other than - * JERRY_API_DATA_TYPE_OBJECT, JERRY_ASSERT fails. + * Create functions of API objects */ -jerry_api_object_t *jerry_api_get_object_value (const jerry_api_value_t *value_p); +jerry_object_t *jerry_create_object (void); +jerry_object_t *jerry_create_array_object (jerry_size_t); +jerry_object_t *jerry_create_external_function (jerry_external_handler_t); +jerry_object_t *jerry_create_error (jerry_error_t, const jerry_char_t *); +jerry_object_t *jerry_create_error_sz (jerry_error_t, const jerry_char_t *, jerry_size_t); +jerry_string_t *jerry_create_string (const jerry_char_t *); +jerry_string_t *jerry_create_string_sz (const jerry_char_t *, jerry_size_t); /** - * Creates and returns a jerry_api_value_t with type - * JERRY_API_DATA_TYPE_VOID. + * Functions of array objects */ -jerry_api_value_t jerry_api_create_void_value (void); +bool jerry_set_array_index_value (jerry_object_t *, jerry_length_t, jerry_value_t *); +bool jerry_get_array_index_value (jerry_object_t *, jerry_length_t, jerry_value_t *); /** - * Creates and returns a jerry_api_value_t with type - * JERRY_API_DATA_TYPE_NULL. + * Functions of 'jerry_string_t' */ -jerry_api_value_t jerry_api_create_null_value (void); +jerry_size_t jerry_get_string_size (const jerry_string_t *); +jerry_length_t jerry_get_string_length (const jerry_string_t *); +jerry_size_t jerry_string_to_char_buffer (const jerry_string_t *, jerry_char_t *, jerry_size_t); /** - * Creates and returns a jerry_api_value_t with type - * JERRY_API_DATA_TYPE_UNDEFINED. + * General API functions of JS objects */ -jerry_api_value_t jerry_api_create_undefined_value (void); - -/** - * Creates a JERRY_API_DATA_TYPE_BOOLEAN jerry_api_value_t from the given - * boolean parameter and returns with it. - */ -jerry_api_value_t jerry_api_create_boolean_value (bool value); - -/** - * Creates a jerry_api_value_t from the given double parameter and returns - * with it. - * The v_float64 member will be set and the will be JERRY_API_DATA_TYPE_FLOAT64. - */ -jerry_api_value_t jerry_api_create_number_value (double value); - -/** - * Creates a JERRY_API_DATA_TYPE_OBJECT type jerry_api_value_t from the - * given jerry_api_object_t *parameter and returns with it. - */ -jerry_api_value_t jerry_api_create_object_value (jerry_api_object_t *value); - -/** - * Creates a JERRY_API_DATA_TYPE_STRING type jerry_api_value_t from the - * given jerry_api_string_t *parameter and returns with it. - */ -jerry_api_value_t jerry_api_create_string_value (jerry_api_string_t *value); - -jerry_api_size_t jerry_api_string_to_char_buffer (const jerry_api_string_t *, jerry_api_char_t *, jerry_api_size_t); -jerry_api_string_t *jerry_api_acquire_string (jerry_api_string_t *); -jerry_api_object_t *jerry_api_acquire_object (jerry_api_object_t *); -jerry_api_value_t *jerry_api_acquire_value (jerry_api_value_t *); - -void jerry_api_release_object (jerry_api_object_t *); -void jerry_api_release_string (jerry_api_string_t *); -void jerry_api_release_value (jerry_api_value_t *); - -jerry_api_object_t *jerry_api_create_array_object (jerry_api_size_t); -jerry_api_object_t *jerry_api_create_object (void); -jerry_api_string_t *jerry_api_create_string (const jerry_api_char_t *); -jerry_api_string_t *jerry_api_create_string_sz (const jerry_api_char_t *, jerry_api_size_t); - -bool jerry_api_set_array_index_value (jerry_api_object_t *, jerry_api_length_t, jerry_api_value_t *); -bool jerry_api_get_array_index_value (jerry_api_object_t *, jerry_api_length_t, jerry_api_value_t *); - -jerry_api_object_t *jerry_api_create_error (jerry_api_error_t, const jerry_api_char_t *); -jerry_api_object_t *jerry_api_create_error_sz (jerry_api_error_t, const jerry_api_char_t *, jerry_api_size_t); -jerry_api_object_t *jerry_api_create_external_function (jerry_external_handler_t); - -bool jerry_api_is_constructor (const jerry_api_object_t *); -bool jerry_api_is_function (const jerry_api_object_t *); - -bool jerry_api_add_object_field (jerry_api_object_t *, const jerry_api_char_t *, jerry_api_size_t, - const jerry_api_value_t *, bool); -bool jerry_api_delete_object_field (jerry_api_object_t *, const jerry_api_char_t *, jerry_api_size_t); - -bool jerry_api_get_object_field_value (jerry_api_object_t *, const jerry_api_char_t *, jerry_api_value_t *); -bool jerry_api_get_object_field_value_sz (jerry_api_object_t *, const jerry_api_char_t *, jerry_api_size_t, - jerry_api_value_t *); - -bool jerry_api_set_object_field_value (jerry_api_object_t *, const jerry_api_char_t *, const jerry_api_value_t *); -bool jerry_api_set_object_field_value_sz (jerry_api_object_t *, const jerry_api_char_t *, jerry_api_size_t, - const jerry_api_value_t *); - -bool jerry_api_foreach_object_field (jerry_api_object_t *, jerry_object_field_foreach_t, void *); -bool jerry_api_get_object_native_handle (jerry_api_object_t *, uintptr_t *); -void jerry_api_set_object_native_handle (jerry_api_object_t *, uintptr_t, jerry_object_free_callback_t); -bool jerry_api_call_function (jerry_api_object_t *, jerry_api_object_t *, jerry_api_value_t *, - const jerry_api_value_t[], uint16_t); -bool jerry_api_construct_object (jerry_api_object_t *, jerry_api_value_t *, const jerry_api_value_t[], uint16_t); -jerry_completion_code_t jerry_api_eval (const jerry_api_char_t *, size_t, bool, bool, jerry_api_value_t *); -jerry_api_object_t *jerry_api_get_global (void); - -void jerry_api_gc (void); -void jerry_register_external_magic_strings (const jerry_api_char_ptr_t *, uint32_t, const jerry_api_length_t *); - -size_t jerry_parse_and_save_snapshot (const jerry_api_char_t *, size_t, bool, uint8_t *, size_t); -jerry_completion_code_t jerry_exec_snapshot (const void *, size_t, bool, jerry_api_value_t *); - -jerry_api_size_t jerry_api_get_string_size (const jerry_api_string_t *); -jerry_api_length_t jerry_api_get_string_length (const jerry_api_string_t *); - -jerry_api_string_t *jerry_api_value_to_string (const jerry_api_value_t *); +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 *); +bool jerry_get_object_field_value_sz (jerry_object_t *, const jerry_char_t *, jerry_size_t, jerry_value_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); +bool jerry_call_function (jerry_object_t *, jerry_object_t *, jerry_value_t *, const jerry_value_t[], uint16_t); /** * @} diff --git a/jerry-core/jerry.c b/jerry-core/jerry.c index e6fa07ce15..8c8f83d551 100644 --- a/jerry-core/jerry.c +++ b/jerry-core/jerry.c @@ -125,119 +125,119 @@ jerry_make_api_unavailable (void) } /* jerry_make_api_unavailable */ /** - * Returns whether the given jerry_api_value_t is void. + * Returns whether the given jerry_value_t is void. */ bool -jerry_api_value_is_void (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_void (const jerry_value_t *value_p) /**< pointer to api value */ { - return value_p->type == JERRY_API_DATA_TYPE_VOID; -} /* jerry_api_value_is_void */ + return value_p->type == JERRY_DATA_TYPE_VOID; +} /* jerry_value_is_void */ /** - * Returns whether the given jerry_api_value_t is null. + * Returns whether the given jerry_value_t is null. */ bool -jerry_api_value_is_null (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_null (const jerry_value_t *value_p) /**< pointer to api value */ { - return value_p->type == JERRY_API_DATA_TYPE_NULL; -} /* jerry_api_value_is_null */ + return value_p->type == JERRY_DATA_TYPE_NULL; +} /* jerry_value_is_null */ /** - * Returns whether the given jerry_api_value_t is undefined. + * Returns whether the given jerry_value_t is undefined. */ bool -jerry_api_value_is_undefined (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_undefined (const jerry_value_t *value_p) /**< pointer to api value */ { - return value_p->type == JERRY_API_DATA_TYPE_UNDEFINED; -} /* jerry_api_value_is_undefined */ + return value_p->type == JERRY_DATA_TYPE_UNDEFINED; +} /* jerry_value_is_undefined */ /** - * Returns whether the given jerry_api_value_t has boolean type. + * Returns whether the given jerry_value_t has boolean type. */ bool -jerry_api_value_is_boolean (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_boolean (const jerry_value_t *value_p) /**< pointer to api value */ { - return value_p->type == JERRY_API_DATA_TYPE_BOOLEAN; -} /* jerry_api_value_is_boolean */ + return value_p->type == JERRY_DATA_TYPE_BOOLEAN; +} /* jerry_value_is_boolean */ /** - * Returns whether the given jerry_api_value_t is number. + * Returns whether the given jerry_value_t is number. * - * More specifically, returns true if the type is JERRY_API_DATA_TYPE_FLOAT32, - * JERRY_API_DATA_TYPE_FLOAT64 or JERRY_API_DATA_TYPE_UINT32, false otherwise. + * More specifically, returns true if the type is JERRY_DATA_TYPE_FLOAT32, + * JERRY_DATA_TYPE_FLOAT64 or JERRY_DATA_TYPE_UINT32, false otherwise. */ bool -jerry_api_value_is_number (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_number (const jerry_value_t *value_p) /**< pointer to api value */ { - return value_p->type == JERRY_API_DATA_TYPE_FLOAT32 - || value_p->type == JERRY_API_DATA_TYPE_FLOAT64 - || value_p->type == JERRY_API_DATA_TYPE_UINT32; -} /* jerry_api_value_is_number */ + return value_p->type == JERRY_DATA_TYPE_FLOAT32 + || value_p->type == JERRY_DATA_TYPE_FLOAT64 + || value_p->type == JERRY_DATA_TYPE_UINT32; +} /* jerry_value_is_number */ /** - * Returns whether the given jerry_api_value_t is string. + * Returns whether the given jerry_value_t is string. */ bool -jerry_api_value_is_string (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_string (const jerry_value_t *value_p) /**< pointer to api value */ { - return value_p->type == JERRY_API_DATA_TYPE_STRING; -} /* jerry_api_value_is_string */ + return value_p->type == JERRY_DATA_TYPE_STRING; +} /* jerry_value_is_string */ /** - * Returns whether the given jerry_api_value_t is object. + * Returns whether the given jerry_value_t is object. */ bool -jerry_api_value_is_object (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_object (const jerry_value_t *value_p) /**< pointer to api value */ { - return value_p->type == JERRY_API_DATA_TYPE_OBJECT; -} /* jerry_api_value_is_object */ + return value_p->type == JERRY_DATA_TYPE_OBJECT; +} /* jerry_value_is_object */ /** - * Returns whether the given jerry_api_value_t is a function object. + * Returns whether the given jerry_value_t is a function object. * - * More specifically, returns true if the jerry_api_value_t of the value - * pointed by value_p has JERRY_API_DATA_TYPE_OBJECT type and - * jerry_api_is_function() functiron return true for its v_object member, + * More specifically, returns true if the jerry_value_t of the value + * pointed by value_p has JERRY_DATA_TYPE_OBJECT type and + * jerry_is_function() functiron return true for its v_object member, * otherwise false. */ bool -jerry_api_value_is_function (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_value_is_function (const jerry_value_t *value_p) /**< pointer to api value */ { - return jerry_api_value_is_object (value_p) && jerry_api_is_function (value_p->u.v_object); -} /* jerry_api_value_is_function */ + return jerry_value_is_object (value_p) && jerry_is_function (value_p->u.v_object); +} /* jerry_value_is_function */ /** - * Returns the boolean v_bool member of the given jerry_api_value_t structure. - * If the given jerry_api_value_t structure has type other than - * JERRY_API_DATA_TYPE_BOOLEAN, JERRY_ASSERT fails. + * Returns the boolean v_bool member of the given jerry_value_t structure. + * If the given jerry_value_t structure has type other than + * JERRY_DATA_TYPE_BOOLEAN, JERRY_ASSERT fails. */ bool -jerry_api_get_boolean_value (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_get_boolean_value (const jerry_value_t *value_p) /**< pointer to api value */ { - JERRY_ASSERT (jerry_api_value_is_boolean (value_p)); + JERRY_ASSERT (jerry_value_is_boolean (value_p)); return value_p->u.v_bool; -} /* jerry_api_get_boolean_value */ +} /* jerry_get_boolean_value */ /** - * Returns the number value of the given jerry_api_value_t structure + * Returns the number value of the given jerry_value_t structure * as a double. * - * If the given jerry_api_value_t structure has type JERRY_API_DATA_TYPE_UINT32 + * If the given jerry_value_t structure has type JERRY_DATA_TYPE_UINT32 * v_uint32 member will be returned as a double value. If the given - * jerry_api_value_t structure has type JERRY_API_DATA_TYPE_FLOAT32 + * jerry_value_t structure has type JERRY_DATA_TYPE_FLOAT32 * v_float32 member will be returned as a double and if tpye is - * JERRY_API_DATA_TYPE_FLOAT64 the function returns the v_float64 member. + * JERRY_DATA_TYPE_FLOAT64 the function returns the v_float64 member. * As long as the type is none of the above, JERRY_ASSERT falis. */ double -jerry_api_get_number_value (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_get_number_value (const jerry_value_t *value_p) /**< pointer to api value */ { - JERRY_ASSERT (jerry_api_value_is_number (value_p)); - if (value_p->type == JERRY_API_DATA_TYPE_UINT32) + JERRY_ASSERT (jerry_value_is_number (value_p)); + if (value_p->type == JERRY_DATA_TYPE_UINT32) { return value_p->u.v_uint32; } - else if (value_p->type == JERRY_API_DATA_TYPE_FLOAT32) + else if (value_p->type == JERRY_DATA_TYPE_FLOAT32) { return value_p->u.v_float32; } @@ -245,134 +245,134 @@ jerry_api_get_number_value (const jerry_api_value_t *value_p) /**< pointer to ap { return value_p->u.v_float64; } -} /* jerry_api_get_number_value */ +} /* jerry_get_number_value */ /** - * Returns the v_string member of the given jerry_api_value_t structure. - * If the given jerry_api_value_t structure has type other than - * JERRY_API_DATA_TYPE_STRING, JERRY_ASSERT fails. + * Returns the v_string member of the given jerry_value_t structure. + * If the given jerry_value_t structure has type other than + * JERRY_DATA_TYPE_STRING, JERRY_ASSERT fails. */ -jerry_api_string_t * -jerry_api_get_string_value (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_string_t * +jerry_get_string_value (const jerry_value_t *value_p) /**< pointer to api value */ { - JERRY_ASSERT (jerry_api_value_is_string (value_p)); + JERRY_ASSERT (jerry_value_is_string (value_p)); return value_p->u.v_string; -} /* jerry_api_get_string_value */ +} /* jerry_get_string_value */ /** - * Returns the v_object member of the given jerry_api_value_t structure. - * If the given jerry_api_value_t structure has type other than - * JERRY_API_DATA_TYPE_OBJECT, JERRY_ASSERT fails. + * Returns the v_object member of the given jerry_value_t structure. + * If the given jerry_value_t structure has type other than + * JERRY_DATA_TYPE_OBJECT, JERRY_ASSERT fails. */ -jerry_api_object_t * -jerry_api_get_object_value (const jerry_api_value_t *value_p) /**< pointer to api value */ +jerry_object_t * +jerry_get_object_value (const jerry_value_t *value_p) /**< pointer to api value */ { - JERRY_ASSERT (jerry_api_value_is_object (value_p)); + JERRY_ASSERT (jerry_value_is_object (value_p)); return value_p->u.v_object; -} /* jerry_api_get_object_value */ +} /* jerry_get_object_value */ /** - * Creates and returns a jerry_api_value_t with type - * JERRY_API_DATA_TYPE_VOID. + * Creates and returns a jerry_value_t with type + * JERRY_DATA_TYPE_VOID. */ -jerry_api_value_t -jerry_api_create_void_value (void) +jerry_value_t +jerry_create_void_value (void) { - jerry_api_value_t jerry_val; - jerry_val.type = JERRY_API_DATA_TYPE_VOID; + jerry_value_t jerry_val; + jerry_val.type = JERRY_DATA_TYPE_VOID; return jerry_val; -} /* jerry_api_create_void_value */ +} /* jerry_create_void_value */ /** - * Creates and returns a jerry_api_value_t with type - * JERRY_API_DATA_TYPE_NULL. + * Creates and returns a jerry_value_t with type + * JERRY_DATA_TYPE_NULL. */ -jerry_api_value_t -jerry_api_create_null_value (void) +jerry_value_t +jerry_create_null_value (void) { - jerry_api_value_t jerry_val; - jerry_val.type = JERRY_API_DATA_TYPE_NULL; + jerry_value_t jerry_val; + jerry_val.type = JERRY_DATA_TYPE_NULL; return jerry_val; -} /* jerry_api_create_null_value */ +} /* jerry_create_null_value */ /** - * Creates and returns a jerry_api_value_t with type - * JERRY_API_DATA_TYPE_UNDEFINED. + * Creates and returns a jerry_value_t with type + * JERRY_DATA_TYPE_UNDEFINED. */ -jerry_api_value_t -jerry_api_create_undefined_value (void) +jerry_value_t +jerry_create_undefined_value (void) { - jerry_api_value_t jerry_val; - jerry_val.type = JERRY_API_DATA_TYPE_UNDEFINED; + jerry_value_t jerry_val; + jerry_val.type = JERRY_DATA_TYPE_UNDEFINED; return jerry_val; -} /* jerry_api_create_undefined_value */ +} /* jerry_create_undefined_value */ /** - * Creates a JERRY_API_DATA_TYPE_BOOLEAN jerry_api_value_t from the given + * Creates a JERRY_DATA_TYPE_BOOLEAN jerry_value_t from the given * boolean parameter and returns with it. */ -jerry_api_value_t -jerry_api_create_boolean_value (bool value) /**< bool value from which a jerry_api_value_t will be created */ +jerry_value_t +jerry_create_boolean_value (bool value) /**< bool value from which a jerry_value_t will be created */ { - jerry_api_value_t jerry_val; - jerry_val.type = JERRY_API_DATA_TYPE_BOOLEAN; + jerry_value_t jerry_val; + jerry_val.type = JERRY_DATA_TYPE_BOOLEAN; jerry_val.u.v_bool = value; return jerry_val; -} /* jerry_api_create_boolean_value */ +} /* jerry_create_boolean_value */ /** - * Creates a jerry_api_value_t from the given double parameter and returns + * Creates a jerry_value_t from the given double parameter and returns * with it. - * The v_float64 member will be set and the will be JERRY_API_DATA_TYPE_FLOAT64. + * The v_float64 member will be set and the will be JERRY_DATA_TYPE_FLOAT64. */ -jerry_api_value_t -jerry_api_create_number_value (double value) /**< double value from which a jerry_api_value_t will be created */ +jerry_value_t +jerry_create_number_value (double value) /**< double value from which a jerry_value_t will be created */ { - jerry_api_value_t jerry_val; - jerry_val.type = JERRY_API_DATA_TYPE_FLOAT64; + jerry_value_t jerry_val; + jerry_val.type = JERRY_DATA_TYPE_FLOAT64; jerry_val.u.v_float64 = value; return jerry_val; -} /* jerry_api_create_number_value */ +} /* jerry_create_number_value */ /** - * Creates a JERRY_API_DATA_TYPE_OBJECT type jerry_api_value_t from the - * given jerry_api_object_t *parameter and returns with it. + * Creates a JERRY_DATA_TYPE_OBJECT type jerry_value_t from the + * given jerry_object_t *parameter and returns with it. */ -jerry_api_value_t -jerry_api_create_object_value (jerry_api_object_t *value) /**< jerry_api_object_t from which a value will be created */ +jerry_value_t +jerry_create_object_value (jerry_object_t *value) /**< jerry_object_t from which a value will be created */ { - jerry_api_value_t jerry_val; - jerry_val.type = JERRY_API_DATA_TYPE_OBJECT; + jerry_value_t jerry_val; + jerry_val.type = JERRY_DATA_TYPE_OBJECT; jerry_val.u.v_object = value; return jerry_val; -} /* jerry_api_create_object_value */ +} /* jerry_create_object_value */ /** - * Creates a JERRY_API_DATA_TYPE_STRING type jerry_api_value_t from the - * given jerry_api_string_t *parameter and returns with it. + * Creates a JERRY_DATA_TYPE_STRING type jerry_value_t from the + * given jerry_string_t *parameter and returns with it. */ -jerry_api_value_t -jerry_api_create_string_value (jerry_api_string_t *value) /**< jerry_api_string_t from which a value will be created */ +jerry_value_t +jerry_create_string_value (jerry_string_t *value) /**< jerry_string_t from which a value will be created */ { - jerry_api_value_t jerry_val; - jerry_val.type = JERRY_API_DATA_TYPE_STRING; + jerry_value_t jerry_val; + jerry_val.type = JERRY_DATA_TYPE_STRING; jerry_val.u.v_string = value; return jerry_val; -} /* jerry_api_create_string_value */ +} /* jerry_create_string_value */ /** * Convert ecma value to Jerry API value representation * * Note: * if the output value contains string / object, it should be freed - * with jerry_api_release_string / jerry_api_release_object, + * with jerry_release_string / jerry_release_object, * just when it becomes unnecessary. */ static void -jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**< [out] api value */ - ecma_value_t value) /**< ecma value (undefined, - * null, boolean, number, - * string or object */ +jerry_convert_ecma_value_to_api_value (jerry_value_t *out_value_p, /**< [out] api value */ + ecma_value_t value) /**< ecma value (undefined, + * null, boolean, number, + * string or object */ { jerry_assert_api_available (); @@ -380,19 +380,19 @@ jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**< if (ecma_is_value_empty (value)) { - out_value_p->type = JERRY_API_DATA_TYPE_VOID; + out_value_p->type = JERRY_DATA_TYPE_VOID; } else if (ecma_is_value_undefined (value)) { - out_value_p->type = JERRY_API_DATA_TYPE_UNDEFINED; + out_value_p->type = JERRY_DATA_TYPE_UNDEFINED; } else if (ecma_is_value_null (value)) { - out_value_p->type = JERRY_API_DATA_TYPE_NULL; + out_value_p->type = JERRY_DATA_TYPE_NULL; } else if (ecma_is_value_boolean (value)) { - out_value_p->type = JERRY_API_DATA_TYPE_BOOLEAN; + out_value_p->type = JERRY_DATA_TYPE_BOOLEAN; out_value_p->u.v_bool = ecma_is_value_true (value); } else if (ecma_is_value_number (value)) @@ -400,10 +400,10 @@ jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**< ecma_number_t num = ecma_get_number_from_value (value); #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 - out_value_p->type = JERRY_API_DATA_TYPE_FLOAT32; + out_value_p->type = JERRY_DATA_TYPE_FLOAT32; out_value_p->u.v_float32 = num; #elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 - out_value_p->type = JERRY_API_DATA_TYPE_FLOAT64; + out_value_p->type = JERRY_DATA_TYPE_FLOAT64; out_value_p->u.v_float64 = num; #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */ } @@ -411,7 +411,7 @@ jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**< { ecma_string_t *str = ecma_get_string_from_value (value); - out_value_p->type = JERRY_API_DATA_TYPE_STRING; + out_value_p->type = JERRY_DATA_TYPE_STRING; out_value_p->u.v_string = ecma_copy_or_ref_ecma_string (str); } else if (ecma_is_value_object (value)) @@ -419,7 +419,7 @@ jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**< ecma_object_t *obj = ecma_get_object_from_value (value); ecma_ref_object (obj); - out_value_p->type = JERRY_API_DATA_TYPE_OBJECT; + out_value_p->type = JERRY_DATA_TYPE_OBJECT; out_value_p->u.v_object = obj; } else @@ -427,7 +427,7 @@ jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**< /* Impossible type of conversion from ecma_value to api_value */ JERRY_UNREACHABLE (); } -} /* jerry_api_convert_ecma_value_to_api_value */ +} /* jerry_convert_ecma_value_to_api_value */ /** * Convert value, represented in Jerry API format, to ecma value. @@ -436,48 +436,48 @@ jerry_api_convert_ecma_value_to_api_value (jerry_api_value_t *out_value_p, /**< * the output ecma value should be freed with ecma_free_value when it becomes unnecessary. */ static void -jerry_api_convert_api_value_to_ecma_value (ecma_value_t *out_value_p, /**< [out] ecma value */ - const jerry_api_value_t *api_value_p) /**< value in Jerry API format */ +jerry_convert_api_value_to_ecma_value (ecma_value_t *out_value_p, /**< [out] ecma value */ + const jerry_value_t *api_value_p) /**< value in Jerry API format */ { switch (api_value_p->type) { - case JERRY_API_DATA_TYPE_UNDEFINED: + case JERRY_DATA_TYPE_UNDEFINED: { *out_value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED); break; } - case JERRY_API_DATA_TYPE_NULL: + case JERRY_DATA_TYPE_NULL: { *out_value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_NULL); break; } - case JERRY_API_DATA_TYPE_BOOLEAN: + case JERRY_DATA_TYPE_BOOLEAN: { *out_value_p = ecma_make_simple_value (api_value_p->u.v_bool ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE); break; } - case JERRY_API_DATA_TYPE_FLOAT32: + case JERRY_DATA_TYPE_FLOAT32: { *out_value_p = ecma_make_number_value ((ecma_number_t) (api_value_p->u.v_float32)); break; } - case JERRY_API_DATA_TYPE_FLOAT64: + case JERRY_DATA_TYPE_FLOAT64: { *out_value_p = ecma_make_number_value ((ecma_number_t) (api_value_p->u.v_float64)); break; } - case JERRY_API_DATA_TYPE_UINT32: + case JERRY_DATA_TYPE_UINT32: { *out_value_p = ecma_make_uint32_value ((uint32_t) (api_value_p->u.v_uint32)); break; } - case JERRY_API_DATA_TYPE_STRING: + case JERRY_DATA_TYPE_STRING: { ecma_string_t *str_p = ecma_copy_or_ref_ecma_string (api_value_p->u.v_string); @@ -485,7 +485,7 @@ jerry_api_convert_api_value_to_ecma_value (ecma_value_t *out_value_p, /**< [out] break; } - case JERRY_API_DATA_TYPE_OBJECT: + case JERRY_DATA_TYPE_OBJECT: { ecma_object_t *obj_p = api_value_p->u.v_object; @@ -500,25 +500,25 @@ jerry_api_convert_api_value_to_ecma_value (ecma_value_t *out_value_p, /**< [out] JERRY_UNREACHABLE (); } } -} /* jerry_api_convert_api_value_to_ecma_value */ +} /* jerry_convert_api_value_to_ecma_value */ /** * Convert completion of 'eval' to API value and completion code * * Note: - * The value returned in 'retval_p' should be freed with jerry_api_release_value + * The value returned in 'retval_p' should be freed with jerry_release_value * * @return completion code */ static jerry_completion_code_t -jerry_api_convert_eval_completion_to_retval (jerry_api_value_t *retval_p, /**< [out] api value */ - ecma_value_t completion) /**< completion of 'eval'-mode - * code execution */ +jerry_convert_eval_completion_to_retval (jerry_value_t *retval_p, /**< [out] api value */ + ecma_value_t completion) /**< completion of 'eval'-mode + * code execution */ { - jerry_api_convert_ecma_value_to_api_value (retval_p, completion); + jerry_convert_ecma_value_to_api_value (retval_p, completion); return (ecma_is_value_error (completion)) ? JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION : JERRY_COMPLETION_CODE_OK; -} /* jerry_api_convert_eval_completion_to_retval */ +} /* jerry_convert_eval_completion_to_retval */ /** * @} @@ -533,83 +533,83 @@ jerry_api_convert_eval_completion_to_retval (jerry_api_value_t *retval_p, /**< [ * * @return number of bytes, actually copied to the buffer. */ -jerry_api_size_t -jerry_api_string_to_char_buffer (const jerry_api_string_t *string_p, /**< string descriptor */ - jerry_api_char_t *buffer_p, /**< [out] output characters buffer */ - jerry_api_size_t buffer_size) /**< size of output buffer */ +jerry_size_t +jerry_string_to_char_buffer (const jerry_string_t *string_p, /**< string descriptor */ + jerry_char_t *buffer_p, /**< [out] output characters buffer */ + jerry_size_t buffer_size) /**< size of output buffer */ { jerry_assert_api_available (); return ecma_string_to_utf8_string (string_p, (lit_utf8_byte_t *) buffer_p, buffer_size); -} /* jerry_api_string_to_char_buffer */ +} /* jerry_string_to_char_buffer */ /** * Acquire string pointer for usage outside of the engine * from string retrieved in extension routine call from engine. * * Warning: - * acquired pointer should be released with jerry_api_release_string + * acquired pointer should be released with jerry_release_string * * @return pointer that may be used outside of the engine */ -jerry_api_string_t * -jerry_api_acquire_string (jerry_api_string_t *string_p) /**< pointer passed to function */ +jerry_string_t * +jerry_acquire_string (jerry_string_t *string_p) /**< pointer passed to function */ { jerry_assert_api_available (); return ecma_copy_or_ref_ecma_string (string_p); -} /* jerry_api_acquire_string */ +} /* jerry_acquire_string */ /** * Release string pointer * * See also: - * jerry_api_acquire_string - * jerry_api_call_function + * jerry_acquire_string + * jerry_call_function * */ void -jerry_api_release_string (jerry_api_string_t *string_p) /**< pointer acquired through jerry_api_acquire_string */ +jerry_release_string (jerry_string_t *string_p) /**< pointer acquired through jerry_acquire_string */ { jerry_assert_api_available (); ecma_deref_ecma_string (string_p); -} /* jerry_api_release_string */ +} /* jerry_release_string */ /** * Acquire object pointer for usage outside of the engine * from object retrieved in extension routine call from engine. * * Warning: - * acquired pointer should be released with jerry_api_release_object + * acquired pointer should be released with jerry_release_object * * @return pointer that may be used outside of the engine */ -jerry_api_object_t * -jerry_api_acquire_object (jerry_api_object_t *object_p) /**< pointer passed to function */ +jerry_object_t * +jerry_acquire_object (jerry_object_t *object_p) /**< pointer passed to function */ { jerry_assert_api_available (); ecma_ref_object (object_p); return object_p; -} /* jerry_api_acquire_object */ +} /* jerry_acquire_object */ /** * Release object pointer * * See also: - * jerry_api_acquire_object - * jerry_api_call_function - * jerry_api_get_object_field_value + * jerry_acquire_object + * jerry_call_function + * jerry_get_object_field_value */ void -jerry_api_release_object (jerry_api_object_t *object_p) /**< pointer acquired through jerry_api_acquire_object */ +jerry_release_object (jerry_object_t *object_p) /**< pointer acquired through jerry_acquire_object */ { jerry_assert_api_available (); ecma_deref_object (object_p); -} /* jerry_api_release_object */ +} /* jerry_release_object */ /** * Acquire specified Jerry API value. @@ -619,26 +619,26 @@ jerry_api_release_object (jerry_api_object_t *object_p) /**< pointer acquired th * for all other types it is a no-op. * * Warning: - * Acquired pointer should be released with jerry_api_release_value + * Acquired pointer should be released with jerry_release_value * * @return pointer that may be used outside of the engine */ -jerry_api_value_t * -jerry_api_acquire_value (jerry_api_value_t *value_p) /**< API value */ +jerry_value_t * +jerry_acquire_value (jerry_value_t *value_p) /**< API value */ { jerry_assert_api_available (); - if (value_p->type == JERRY_API_DATA_TYPE_STRING) + if (value_p->type == JERRY_DATA_TYPE_STRING) { - jerry_api_acquire_string (value_p->u.v_string); + jerry_acquire_string (value_p->u.v_string); } - else if (value_p->type == JERRY_API_DATA_TYPE_OBJECT) + else if (value_p->type == JERRY_DATA_TYPE_OBJECT) { - jerry_api_acquire_object (value_p->u.v_object); + jerry_acquire_object (value_p->u.v_object); } return value_p; -} /* jerry_api_acquire_value */ +} /* jerry_acquire_value */ /** * Release specified Jerry API value @@ -648,93 +648,93 @@ jerry_api_acquire_value (jerry_api_value_t *value_p) /**< API value */ * for all other types it is a no-op. */ void -jerry_api_release_value (jerry_api_value_t *value_p) /**< API value */ +jerry_release_value (jerry_value_t *value_p) /**< API value */ { jerry_assert_api_available (); - if (value_p->type == JERRY_API_DATA_TYPE_STRING) + if (value_p->type == JERRY_DATA_TYPE_STRING) { - jerry_api_release_string (value_p->u.v_string); + jerry_release_string (value_p->u.v_string); } - else if (value_p->type == JERRY_API_DATA_TYPE_OBJECT) + else if (value_p->type == JERRY_DATA_TYPE_OBJECT) { - jerry_api_release_object (value_p->u.v_object); + jerry_release_object (value_p->u.v_object); } -} /* jerry_api_release_value */ +} /* jerry_release_value */ /** * Create a string * * Note: - * caller should release the string with jerry_api_release_string, just when the value becomes unnecessary. + * caller should release the string with jerry_release_string, just when the value becomes unnecessary. * * @return pointer to created string */ -jerry_api_string_t * -jerry_api_create_string (const jerry_api_char_t *v) /**< string value */ +jerry_string_t * +jerry_create_string (const jerry_char_t *v) /**< string value */ { jerry_assert_api_available (); return ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) v, lit_zt_utf8_string_size ((lit_utf8_byte_t *) v)); -} /* jerry_api_create_string */ +} /* jerry_create_string */ /** * Create a string * * Note: - * caller should release the string with jerry_api_release_string, just when the value becomes unnecessary. + * caller should release the string with jerry_release_string, just when the value becomes unnecessary. * * @return pointer to created string */ -jerry_api_string_t * -jerry_api_create_string_sz (const jerry_api_char_t *v, /**< string value */ - jerry_api_size_t v_size) /**< string size */ +jerry_string_t * +jerry_create_string_sz (const jerry_char_t *v, /**< string value */ + jerry_size_t v_size) /**< string size */ { jerry_assert_api_available (); return ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) v, (lit_utf8_size_t) v_size); -} /* jerry_api_create_string_sz */ +} /* jerry_create_string_sz */ /** * Create an object * * Note: - * caller should release the object with jerry_api_release_object, just when the value becomes unnecessary. + * caller should release the object with jerry_release_object, just when the value becomes unnecessary. * * @return pointer to created object */ -jerry_api_object_t * -jerry_api_create_object (void) +jerry_object_t * +jerry_create_object (void) { jerry_assert_api_available (); return ecma_op_create_object_object_noarg (); -} /* jerry_api_create_object */ +} /* jerry_create_object */ /** * Create an array object * * Note: - * caller should release the object with jerry_api_release_object, just when the value becomes unnecessary. + * caller should release the object with jerry_release_object, just when the value becomes unnecessary. * * @return pointer to created array object */ -jerry_api_object_t * -jerry_api_create_array_object (jerry_api_size_t size) /* size of array */ +jerry_object_t * +jerry_create_array_object (jerry_size_t size) /**< size of array */ { JERRY_ASSERT (size > 0); ecma_value_t array_length = ecma_make_uint32_value (size); - jerry_api_length_t argument_size = 1; + jerry_length_t argument_size = 1; ecma_value_t new_array_completion = ecma_op_create_array_object (&array_length, argument_size, true); JERRY_ASSERT (!ecma_is_value_error (new_array_completion)); - jerry_api_object_t *obj_p = ecma_get_object_from_value (new_array_completion); + jerry_object_t *obj_p = ecma_get_object_from_value (new_array_completion); ecma_free_value (array_length); return obj_p; -} /* jerry_api_create_array_object */ +} /* jerry_create_array_object */ /** * Set value of field in the specified array object @@ -743,13 +743,13 @@ jerry_api_create_array_object (jerry_api_size_t size) /* size of array */ * throw exception, otherwise */ bool -jerry_api_set_array_index_value (jerry_api_object_t *array_obj_p, /* array object */ - jerry_api_length_t index, /* index to be written */ - jerry_api_value_t *value_p) /* value to set */ +jerry_set_array_index_value (jerry_object_t *array_obj_p, /**< array object */ + jerry_length_t index, /**< index to be written */ + jerry_value_t *value_p) /**< value to set */ { ecma_string_t *str_idx_p = ecma_new_ecma_string_from_uint32 ((uint32_t) index); ecma_value_t value; - jerry_api_convert_api_value_to_ecma_value (&value, value_p); + jerry_convert_api_value_to_ecma_value (&value, value_p); ecma_value_t set_completion = ecma_op_object_put (array_obj_p, str_idx_p, value, false); JERRY_ASSERT (!ecma_is_value_error (set_completion)); @@ -758,66 +758,66 @@ jerry_api_set_array_index_value (jerry_api_object_t *array_obj_p, /* array objec ecma_free_value (value); return true; -} /* jerry_api_set_array_index_value */ +} /* jerry_set_array_index_value */ /** * Get value of field in the specified array object * * Note: * if value was retrieved successfully, it should be freed - * with jerry_api_release_value just when it becomes unnecessary. + * with jerry_release_value just when it becomes unnecessary. * * @return true, if field value was retrieved successfully, i.e. upon the call: * - there is field with specified name in the object; * throw exception - otherwise. */ bool -jerry_api_get_array_index_value (jerry_api_object_t *array_obj_p, /* array object */ - jerry_api_length_t index, /* index to be written */ - jerry_api_value_t *value_p) /* output value at index */ +jerry_get_array_index_value (jerry_object_t *array_obj_p, /**< array object */ + jerry_length_t index, /**< index to be written */ + jerry_value_t *value_p) /**< output value at index */ { ecma_string_t *str_idx_p = ecma_new_ecma_string_from_uint32 ((uint32_t) index); ecma_value_t get_completion = ecma_op_object_get (array_obj_p, str_idx_p); JERRY_ASSERT (!ecma_is_value_error (get_completion)); - jerry_api_convert_ecma_value_to_api_value (value_p, get_completion); + jerry_convert_ecma_value_to_api_value (value_p, get_completion); ecma_free_value (get_completion); ecma_deref_ecma_string (str_idx_p); return true; -} /* jerry_api_get_array_index_value */ +} /* jerry_get_array_index_value */ /** * Create an error object * * Note: - * caller should release the object with jerry_api_release_object, just when the value becomes unnecessary. + * caller should release the object with jerry_release_object, just when the value becomes unnecessary. * * @return pointer to created error object */ -jerry_api_object_t * -jerry_api_create_error (jerry_api_error_t error_type, /**< type of error */ - const jerry_api_char_t *message_p) /**< value of 'message' property - * of constructed error object */ +jerry_object_t * +jerry_create_error (jerry_error_t error_type, /**< type of error */ + const jerry_char_t *message_p) /**< value of 'message' property + * of constructed error object */ { - return jerry_api_create_error_sz (error_type, - (lit_utf8_byte_t *) message_p, - lit_zt_utf8_string_size (message_p)); -} /* jerry_api_create_error */ + return jerry_create_error_sz (error_type, + (lit_utf8_byte_t *) message_p, + lit_zt_utf8_string_size (message_p)); +} /* jerry_create_error */ /** * Create an error object * * Note: - * caller should release the object with jerry_api_release_object, just when the value becomes unnecessary. + * caller should release the object with jerry_release_object, just when the value becomes unnecessary. * * @return pointer to created error object */ -jerry_api_object_t * -jerry_api_create_error_sz (jerry_api_error_t error_type, /**< type of error */ - const jerry_api_char_t *message_p, /**< value of 'message' property - * of constructed error object */ - jerry_api_size_t message_size) /**< size of the message in bytes */ +jerry_object_t * +jerry_create_error_sz (jerry_error_t error_type, /**< type of error */ + const jerry_char_t *message_p, /**< value of 'message' property + * of constructed error object */ + jerry_size_t message_size) /**< size of the message in bytes */ { jerry_assert_api_available (); @@ -825,37 +825,37 @@ jerry_api_create_error_sz (jerry_api_error_t error_type, /**< type of error */ switch (error_type) { - case JERRY_API_ERROR_COMMON: + case JERRY_ERROR_COMMON: { standard_error_type = ECMA_ERROR_COMMON; break; } - case JERRY_API_ERROR_EVAL: + case JERRY_ERROR_EVAL: { standard_error_type = ECMA_ERROR_EVAL; break; } - case JERRY_API_ERROR_RANGE: + case JERRY_ERROR_RANGE: { standard_error_type = ECMA_ERROR_RANGE; break; } - case JERRY_API_ERROR_REFERENCE: + case JERRY_ERROR_REFERENCE: { standard_error_type = ECMA_ERROR_REFERENCE; break; } - case JERRY_API_ERROR_SYNTAX: + case JERRY_ERROR_SYNTAX: { standard_error_type = ECMA_ERROR_SYNTAX; break; } - case JERRY_API_ERROR_TYPE: + case JERRY_ERROR_TYPE: { standard_error_type = ECMA_ERROR_TYPE; break; } - case JERRY_API_ERROR_URI: + case JERRY_ERROR_URI: { standard_error_type = ECMA_ERROR_URI; break; @@ -881,24 +881,24 @@ jerry_api_create_error_sz (jerry_api_error_t error_type, /**< type of error */ return error_object_p; } -} /* jerry_api_create_error_sz */ +} /* jerry_create_error_sz */ /** * Create an external function object * * Note: - * caller should release the object with jerry_api_release_object, just when the value becomes unnecessary. + * caller should release the object with jerry_release_object, just when the value becomes unnecessary. * * @return pointer to created external function object */ -jerry_api_object_t * -jerry_api_create_external_function (jerry_external_handler_t handler_p) /**< pointer to native handler - * for the function */ +jerry_object_t * +jerry_create_external_function (jerry_external_handler_t handler_p) /**< pointer to native handler + * for the function */ { jerry_assert_api_available (); return ecma_op_create_external_function_object ((ecma_external_pointer_t) handler_p); -} /* jerry_api_create_external_function */ +} /* jerry_create_external_function */ /** * Dispatch call to specified external function using the native handler @@ -922,7 +922,7 @@ jerry_dispatch_external_function (ecma_object_t *function_object_p, /**< externa ecma_value_t completion_value; - JMEM_DEFINE_LOCAL_ARRAY (api_arg_values, args_count, jerry_api_value_t); + JMEM_DEFINE_LOCAL_ARRAY (api_arg_values, args_count, jerry_value_t); ecma_collection_iterator_t args_iterator; ecma_collection_iterator_init (&args_iterator, arg_collection_p); @@ -932,15 +932,15 @@ jerry_dispatch_external_function (ecma_object_t *function_object_p, /**< externa bool is_moved = ecma_collection_iterator_next (&args_iterator); JERRY_ASSERT (is_moved); - jerry_api_convert_ecma_value_to_api_value (&api_arg_values[i], *args_iterator.current_value_p); + jerry_convert_ecma_value_to_api_value (&api_arg_values[i], *args_iterator.current_value_p); } - jerry_api_value_t api_this_arg_value, api_ret_value; - jerry_api_convert_ecma_value_to_api_value (&api_this_arg_value, this_arg_value); + jerry_value_t api_this_arg_value, api_ret_value; + jerry_convert_ecma_value_to_api_value (&api_this_arg_value, this_arg_value); // default return value - jerry_api_convert_ecma_value_to_api_value (&api_ret_value, - ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED)); + jerry_convert_ecma_value_to_api_value (&api_ret_value, + ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED)); bool is_successful = ((jerry_external_handler_t) handler_p) (function_object_p, &api_this_arg_value, @@ -949,7 +949,7 @@ jerry_dispatch_external_function (ecma_object_t *function_object_p, /**< externa args_count); ecma_value_t ret_value; - jerry_api_convert_api_value_to_ecma_value (&ret_value, &api_ret_value); + jerry_convert_api_value_to_ecma_value (&ret_value, &api_ret_value); if (is_successful) { @@ -960,11 +960,11 @@ jerry_dispatch_external_function (ecma_object_t *function_object_p, /**< externa completion_value = ecma_make_error_value (ret_value); } - jerry_api_release_value (&api_ret_value); - jerry_api_release_value (&api_this_arg_value); + jerry_release_value (&api_ret_value); + jerry_release_value (&api_this_arg_value); for (uint32_t i = 0; i < args_count; i++) { - jerry_api_release_value (&api_arg_values[i]); + jerry_release_value (&api_arg_values[i]); } JMEM_FINALIZE_LOCAL_ARRAY (api_arg_values); @@ -998,7 +998,7 @@ jerry_dispatch_object_free_callback (ecma_external_pointer_t freecb_p, /**< poin * false - otherwise. */ bool -jerry_api_is_function (const jerry_api_object_t *object_p) /**< an object */ +jerry_is_function (const jerry_object_t *object_p) /**< an object */ { jerry_assert_api_available (); @@ -1007,7 +1007,7 @@ jerry_api_is_function (const jerry_api_object_t *object_p) /**< an object */ ecma_value_t obj_val = ecma_make_object_value (object_p); return ecma_op_is_callable (obj_val); -} /* jerry_api_is_function */ +} /* jerry_is_function */ /** * Check if the specified object is a constructor function object. @@ -1016,7 +1016,7 @@ jerry_api_is_function (const jerry_api_object_t *object_p) /**< an object */ * false - otherwise. */ bool -jerry_api_is_constructor (const jerry_api_object_t *object_p) /**< an object */ +jerry_is_constructor (const jerry_object_t *object_p) /**< an object */ { jerry_assert_api_available (); @@ -1025,7 +1025,7 @@ jerry_api_is_constructor (const jerry_api_object_t *object_p) /**< an object */ ecma_value_t obj_val = ecma_make_object_value (object_p); return ecma_is_constructor (obj_val); -} /* jerry_api_is_constructor */ +} /* jerry_is_constructor */ /** * Create field (named data property) in the specified object @@ -1036,11 +1036,11 @@ jerry_api_is_constructor (const jerry_api_object_t *object_p) /**< an object */ * false - otherwise. */ bool -jerry_api_add_object_field (jerry_api_object_t *object_p, /**< object to add field at */ - const jerry_api_char_t *field_name_p, /**< name of the field */ - jerry_api_size_t field_name_size, /**< size of field name in bytes */ - const jerry_api_value_t *field_value_p, /**< value of the field */ - bool is_writable) /**< flag indicating whether the created field should be writable */ +jerry_add_object_field (jerry_object_t *object_p, /**< object to add field at */ + const jerry_char_t *field_name_p, /**< name of the field */ + jerry_size_t field_name_size, /**< size of field name in bytes */ + const jerry_value_t *field_value_p, /**< value of the field */ + bool is_writable) /**< flag indicating whether the created field should be writable */ { jerry_assert_api_available (); @@ -1058,7 +1058,7 @@ jerry_api_add_object_field (jerry_api_object_t *object_p, /**< object to add fie is_successful = true; ecma_value_t value_to_put; - jerry_api_convert_api_value_to_ecma_value (&value_to_put, field_value_p); + jerry_convert_api_value_to_ecma_value (&value_to_put, field_value_p); uint8_t prop_attributes = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE; @@ -1079,7 +1079,7 @@ jerry_api_add_object_field (jerry_api_object_t *object_p, /**< object to add fie } return is_successful; -} /* jerry_api_add_object_field */ +} /* jerry_add_object_field */ /** * Delete field in the specified object @@ -1089,9 +1089,9 @@ jerry_api_add_object_field (jerry_api_object_t *object_p, /**< object to add fie * false - otherwise. */ bool -jerry_api_delete_object_field (jerry_api_object_t *object_p, /**< object to delete field at */ - const jerry_api_char_t *field_name_p, /**< name of the field */ - jerry_api_size_t field_name_size) /**< size of the field name in bytes */ +jerry_delete_object_field (jerry_object_t *object_p, /**< object to delete field at */ + const jerry_char_t *field_name_p, /**< name of the field */ + jerry_size_t field_name_size) /**< size of the field name in bytes */ { jerry_assert_api_available (); @@ -1114,28 +1114,28 @@ jerry_api_delete_object_field (jerry_api_object_t *object_p, /**< object to dele ecma_deref_ecma_string (field_name_str_p); return is_successful; -} /* jerry_api_delete_object_field */ +} /* jerry_delete_object_field */ /** * Get value of field in the specified object * * Note: * if value was retrieved successfully, it should be freed - * with jerry_api_release_value just when it becomes unnecessary. + * with jerry_release_value just when it becomes unnecessary. * * @return true, if field value was retrieved successfully, i.e. upon the call: * - there is field with specified name in the object; * false - otherwise. */ -bool jerry_api_get_object_field_value (jerry_api_object_t *object_p, /**< object */ - const jerry_api_char_t *field_name_p, /**< field name */ - jerry_api_value_t *field_value_p) /**< [out] field value */ +bool jerry_get_object_field_value (jerry_object_t *object_p, /**< object */ + const jerry_char_t *field_name_p, /**< field name */ + jerry_value_t *field_value_p) /**< [out] field value */ { - return jerry_api_get_object_field_value_sz (object_p, - field_name_p, - lit_zt_utf8_string_size (field_name_p), - field_value_p); -} /* jerry_api_get_object_field_value */ + return jerry_get_object_field_value_sz (object_p, + field_name_p, + lit_zt_utf8_string_size (field_name_p), + field_value_p); +} /* jerry_get_object_field_value */ /** * Applies the given function to the every fields in the objects @@ -1147,9 +1147,9 @@ bool jerry_api_get_object_field_value (jerry_api_object_t *object_p, /**< object * if getter of field threw a exception or unhandled exceptions were thrown during traversal; */ bool -jerry_api_foreach_object_field (jerry_api_object_t *object_p, /**< object */ - jerry_object_field_foreach_t foreach_p, /**< foreach function */ - void *user_data_p) /**< user data for foreach function */ +jerry_foreach_object_field (jerry_object_t *object_p, /**< object */ + jerry_object_field_foreach_t foreach_p, /**< foreach function */ + void *user_data_p) /**< user data for foreach function */ { jerry_assert_api_available (); @@ -1169,12 +1169,12 @@ jerry_api_foreach_object_field (jerry_api_object_t *object_p, /**< object */ ECMA_TRY_CATCH (property_value, ecma_op_object_get (object_p, property_name_p), ret_value); - jerry_api_value_t field_value; - jerry_api_convert_ecma_value_to_api_value (&field_value, property_value); + jerry_value_t field_value; + jerry_convert_ecma_value_to_api_value (&field_value, property_value); continuous = foreach_p (property_name_p, &field_value, user_data_p); - jerry_api_release_value (&field_value); + jerry_release_value (&field_value); ECMA_FINALIZE (property_value); } @@ -1192,25 +1192,24 @@ jerry_api_foreach_object_field (jerry_api_object_t *object_p, /**< object */ return false; } -} /* jerry_api_foreach_object_field */ +} /* jerry_foreach_object_field */ /** * Get value of field in the specified object * * Note: * if value was retrieved successfully, it should be freed - * with jerry_api_release_value just when it becomes unnecessary. + * with jerry_release_value just when it becomes unnecessary. * * @return true, if field value was retrieved successfully, i.e. upon the call: * - there is field with specified name in the object; * false - otherwise. */ bool -jerry_api_get_object_field_value_sz (jerry_api_object_t *object_p, /**< object */ - const jerry_api_char_t *field_name_p, /**< name of the field */ - jerry_api_size_t field_name_size, /**< size of field name in bytes */ - jerry_api_value_t *field_value_p) /**< [out] field value, if retrieved - * successfully */ +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_value_t *field_value_p) /**< [out] field value, if retrieved successfully */ { jerry_assert_api_available (); @@ -1223,7 +1222,7 @@ jerry_api_get_object_field_value_sz (jerry_api_object_t *object_p, /**< object * if (!ecma_is_value_error (field_value)) { - jerry_api_convert_ecma_value_to_api_value (field_value_p, field_value); + jerry_convert_ecma_value_to_api_value (field_value_p, field_value); if (ecma_is_value_undefined (field_value)) { @@ -1240,7 +1239,7 @@ jerry_api_get_object_field_value_sz (jerry_api_object_t *object_p, /**< object * ecma_deref_ecma_string (field_name_str_p); return is_successful; -} /* jerry_api_get_object_field_value_sz */ +} /* jerry_get_object_field_value_sz */ /** * Set value of field in the specified object @@ -1250,15 +1249,15 @@ jerry_api_get_object_field_value_sz (jerry_api_object_t *object_p, /**< object * * false - otherwise. */ bool -jerry_api_set_object_field_value (jerry_api_object_t *object_p, /**< object */ - const jerry_api_char_t *field_name_p, /**< name of the field */ - const jerry_api_value_t *field_value_p) /**< field value to set */ +jerry_set_object_field_value (jerry_object_t *object_p, /**< object */ + const jerry_char_t *field_name_p, /**< name of the field */ + const jerry_value_t *field_value_p) /**< field value to set */ { - return jerry_api_set_object_field_value_sz (object_p, - field_name_p, - lit_zt_utf8_string_size (field_name_p), - field_value_p); -} /* jerry_api_set_object_field_value */ + return jerry_set_object_field_value_sz (object_p, + field_name_p, + lit_zt_utf8_string_size (field_name_p), + field_value_p); +} /* jerry_set_object_field_value */ /** * Set value of field in the specified object @@ -1268,10 +1267,10 @@ jerry_api_set_object_field_value (jerry_api_object_t *object_p, /**< object */ * false - otherwise. */ bool -jerry_api_set_object_field_value_sz (jerry_api_object_t *object_p, /**< object */ - const jerry_api_char_t *field_name_p, /**< name of the field */ - jerry_api_size_t field_name_size, /**< size of field name in bytes */ - const jerry_api_value_t *field_value_p) /**< field value to set */ +jerry_set_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 */ + const jerry_value_t *field_value_p) /**< field value to set */ { jerry_assert_api_available (); @@ -1281,7 +1280,7 @@ jerry_api_set_object_field_value_sz (jerry_api_object_t *object_p, /**< object * (lit_utf8_size_t) field_name_size); ecma_value_t value_to_put; - jerry_api_convert_api_value_to_ecma_value (&value_to_put, field_value_p); + jerry_convert_api_value_to_ecma_value (&value_to_put, field_value_p); ecma_value_t set_completion = ecma_op_object_put (object_p, field_name_str_p, @@ -1299,7 +1298,7 @@ jerry_api_set_object_field_value_sz (jerry_api_object_t *object_p, /**< object * ecma_deref_ecma_string (field_name_str_p); return is_successful; -} /* jerry_api_set_object_field_value_sz */ +} /* jerry_set_object_field_value_sz */ /** * Get native handle, associated with specified object @@ -1308,8 +1307,8 @@ jerry_api_set_object_field_value_sz (jerry_api_object_t *object_p, /**< object * * false - otherwise. */ bool -jerry_api_get_object_native_handle (jerry_api_object_t *object_p, /**< object to get handle from */ - uintptr_t *out_handle_p) /**< [out] handle value */ +jerry_get_object_native_handle (jerry_object_t *object_p, /**< object to get handle from */ + uintptr_t *out_handle_p) /**< [out] handle value */ { jerry_assert_api_available (); @@ -1325,7 +1324,7 @@ jerry_api_get_object_native_handle (jerry_api_object_t *object_p, /**< object to } return does_exist; -} /* jerry_api_get_object_native_handle */ +} /* jerry_get_object_native_handle */ /** * Set native handle and, optionally, free callback for the specified object @@ -1340,9 +1339,9 @@ jerry_api_get_object_native_handle (jerry_api_object_t *object_p, /**< object to * and, if a free callback was added earlier for the object, it is removed. */ void -jerry_api_set_object_native_handle (jerry_api_object_t *object_p, /**< object to set handle in */ - uintptr_t handle, /**< handle value */ - jerry_object_free_callback_t freecb_p) /**< object free callback or NULL */ +jerry_set_object_native_handle (jerry_object_t *object_p, /**< object to set handle in */ + uintptr_t handle, /**< handle value */ + jerry_object_free_callback_t freecb_p) /**< object free callback or NULL */ { jerry_assert_api_available (); @@ -1364,13 +1363,13 @@ jerry_api_set_object_native_handle (jerry_api_object_t *object_p, /**< object to ecma_delete_property (object_p, prop_p); } } -} /* jerry_api_set_object_native_handle */ +} /* jerry_set_object_native_handle */ /** * Invoke function specified by a function object * * Note: - * returned value should be freed with jerry_api_release_value + * returned value should be freed with jerry_release_value * just when the value becomes unnecessary. * * Note: @@ -1382,21 +1381,21 @@ jerry_api_set_object_native_handle (jerry_api_object_t *object_p, /**< object to * false - otherwise. */ static bool -jerry_api_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 */ - jerry_api_object_t *function_object_p, /**< function object to call */ - jerry_api_object_t *this_arg_p, /**< object for 'this' binding - * or NULL (set 'this' binding to newly constructed object, - * if function is invoked as constructor; - * in case of simple function call set 'this' - * binding to the global object) */ - jerry_api_value_t *retval_p, /**< pointer to place for function's - * return value / thrown exception value - * or NULL (to ignore the values) */ - const jerry_api_value_t args_p[], /**< function's call arguments - * (NULL if arguments number is zero) */ - jerry_api_length_t args_count) /**< number of the arguments */ +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 */ + 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 newly constructed object, + * 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 */ { JERRY_ASSERT (args_count == 0 || args_p != NULL); JERRY_STATIC_ASSERT (sizeof (args_count) == sizeof (ecma_length_t), @@ -1408,7 +1407,7 @@ jerry_api_invoke_function (bool is_invoke_as_constructor, /**< true - invoke fun for (uint32_t i = 0; i < args_count; ++i) { - jerry_api_convert_api_value_to_ecma_value (arguments_list_p + i, args_p + i); + jerry_convert_api_value_to_ecma_value (arguments_list_p + i, args_p + i); } ecma_value_t call_completion; @@ -1416,7 +1415,7 @@ jerry_api_invoke_function (bool is_invoke_as_constructor, /**< true - invoke fun if (is_invoke_as_constructor) { JERRY_ASSERT (this_arg_p == NULL); - JERRY_ASSERT (jerry_api_is_constructor (function_object_p)); + JERRY_ASSERT (jerry_is_constructor (function_object_p)); call_completion = ecma_op_function_construct (function_object_p, arguments_list_p, @@ -1424,7 +1423,7 @@ jerry_api_invoke_function (bool is_invoke_as_constructor, /**< true - invoke fun } else { - JERRY_ASSERT (jerry_api_is_function (function_object_p)); + JERRY_ASSERT (jerry_is_function (function_object_p)); ecma_value_t this_arg_val; @@ -1451,7 +1450,7 @@ jerry_api_invoke_function (bool is_invoke_as_constructor, /**< true - invoke fun if (retval_p != NULL) { - jerry_api_convert_ecma_value_to_api_value (retval_p, call_completion); + jerry_convert_ecma_value_to_api_value (retval_p, call_completion); } ecma_free_value (call_completion); @@ -1464,120 +1463,120 @@ jerry_api_invoke_function (bool is_invoke_as_constructor, /**< true - invoke fun JMEM_FINALIZE_LOCAL_ARRAY (arguments_list_p); return is_successful; -} /* jerry_api_invoke_function */ +} /* jerry_invoke_function */ /** * Construct new TypeError object */ static void -jerry_api_construct_type_error (jerry_api_value_t *retval_p) /**< [out] value with constructed - * TypeError object */ +jerry_construct_type_error (jerry_value_t *retval_p) /**< [out] value with constructed + * TypeError object */ { ecma_object_t *type_error_obj_p = ecma_new_standard_error (ECMA_ERROR_TYPE); ecma_value_t type_error_value = ecma_make_object_value (type_error_obj_p); - jerry_api_convert_ecma_value_to_api_value (retval_p, type_error_value); + jerry_convert_ecma_value_to_api_value (retval_p, type_error_value); ecma_deref_object (type_error_obj_p); -} /* jerry_api_construct_type_error */ +} /* jerry_construct_type_error */ /** * Call function specified by a function object * * Note: - * returned value should be freed with jerry_api_release_value + * returned value should be freed with jerry_release_value * just when the value becomes unnecessary. * * @return true, if call was performed successfully, i.e.: - * - specified object is a function object (see also jerry_api_is_function); + * - 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_api_call_function (jerry_api_object_t *function_object_p, /**< function object to call */ - jerry_api_object_t *this_arg_p, /**< object for 'this' binding - * or NULL (set 'this' binding to the global object) */ - jerry_api_value_t *retval_p, /**< pointer to place for function's - * return value / thrown exception value - * or NULL (to ignore the values) */ - const jerry_api_value_t args_p[], /**< function's call arguments - * (NULL if arguments number is zero) */ - uint16_t args_count) /**< number of the arguments */ +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 */ { jerry_assert_api_available (); - if (jerry_api_is_function (function_object_p)) + if (jerry_is_function (function_object_p)) { - return jerry_api_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, retval_p, args_p, args_count); } else { if (retval_p != NULL) { - jerry_api_construct_type_error (retval_p); + jerry_construct_type_error (retval_p); } return false; } -} /* jerry_api_call_function */ +} /* jerry_call_function */ /** * Construct object invoking specified function object as a constructor * * Note: - * returned value should be freed with jerry_api_release_value + * returned value should be freed with jerry_release_value * just when the value becomes unnecessary. * * @return true, if construction was performed successfully, i.e.: - * - specified object is a constructor function object (see also jerry_api_is_constructor); - * - no unhandled exceptions were thrown in connection with the invocation; + * - 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. + * if specified object is not a constructor function object - a TypeError instance; + * else - exception, thrown during the invocation. */ bool -jerry_api_construct_object (jerry_api_object_t *function_object_p, /**< function object to call */ - jerry_api_value_t *retval_p, /**< pointer to place for function's - * return value / thrown exception value - * or NULL (to ignore the values) */ - const jerry_api_value_t args_p[], /**< function's call arguments - * (NULL if arguments number is zero) */ - uint16_t args_count) /**< number of the arguments */ +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 */ { jerry_assert_api_available (); - if (jerry_api_is_constructor (function_object_p)) + if (jerry_is_constructor (function_object_p)) { - return jerry_api_invoke_function (true, function_object_p, NULL, retval_p, args_p, args_count); + return jerry_invoke_function (true, function_object_p, NULL, retval_p, args_p, args_count); } else { if (retval_p != NULL) { - jerry_api_construct_type_error (retval_p); + jerry_construct_type_error (retval_p); } return false; } -} /* jerry_api_construct_object */ +} /* jerry_construct_object */ /** * Get global object * * Note: - * caller should release the object with jerry_api_release_object, just when the value becomes unnecessary. + * caller should release the object with jerry_release_object, just when the value becomes unnecessary. * * @return pointer to the global object */ -jerry_api_object_t * -jerry_api_get_global (void) +jerry_object_t * +jerry_get_global (void) { jerry_assert_api_available (); return ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL); -} /* jerry_api_get_global */ +} /* jerry_get_global */ /** * Perform eval @@ -1590,11 +1589,11 @@ jerry_api_get_global (void) * @return completion status */ jerry_completion_code_t -jerry_api_eval (const jerry_api_char_t *source_p, /**< source code */ - size_t source_size, /**< length of source code */ - bool is_direct, /**< perform eval invocation in direct mode */ - bool is_strict, /**< perform eval as it is called from strict mode code */ - jerry_api_value_t *retval_p) /**< [out] returned value */ +jerry_eval (const jerry_char_t *source_p, /**< source code */ + size_t source_size, /**< length of source code */ + bool is_direct, /**< perform eval invocation in direct mode */ + bool is_strict, /**< perform eval as it is called from strict mode code */ + jerry_value_t *retval_p) /**< [out] returned value */ { jerry_assert_api_available (); @@ -1605,23 +1604,23 @@ jerry_api_eval (const jerry_api_char_t *source_p, /**< source code */ is_direct, is_strict); - status = jerry_api_convert_eval_completion_to_retval (retval_p, completion); + status = jerry_convert_eval_completion_to_retval (retval_p, completion); ecma_free_value (completion); return status; -} /* jerry_api_eval */ +} /* jerry_eval */ /** * Perform GC */ void -jerry_api_gc (void) +jerry_gc (void) { jerry_assert_api_available (); ecma_gc_run (); -} /* jerry_api_gc */ +} /* jerry_gc */ /** * Jerry engine initialization @@ -1680,7 +1679,7 @@ jerry_cleanup (void) */ void jerry_get_memory_limits (size_t *out_data_bss_brk_limit_p, /**< [out] Jerry's maximum usage of - * data + bss + brk sections */ + * data + bss + brk sections */ size_t *out_stack_limit_p) /**< [out] Jerry's maximum usage of stack */ { *out_data_bss_brk_limit_p = CONFIG_MEM_HEAP_AREA_SIZE + CONFIG_MEM_DATA_LIMIT_MINUS_HEAP_SIZE; @@ -1691,15 +1690,15 @@ jerry_get_memory_limits (size_t *out_data_bss_brk_limit_p, /**< [out] Jerry's ma * Parse script for specified context * * Note: - * returned error object should be freed with jerry_api_release_object + * returned error object should be freed with jerry_release_object * * @return true - if script was parsed successfully, * false - otherwise (SyntaxError was raised). */ bool -jerry_parse (const jerry_api_char_t *source_p, /**< script source */ +jerry_parse (const jerry_char_t *source_p, /**< script source */ size_t source_size, /**< script source size */ - jerry_api_object_t **error_obj_p) /**< [out] error object */ + jerry_object_t **error_obj_p) /**< [out] error object */ { jerry_assert_api_available (); @@ -1741,20 +1740,20 @@ jerry_parse (const jerry_api_char_t *source_p, /**< script source */ * Run Jerry in specified run context * * Note: - * returned error value should be freed with jerry_api_release_value + * returned error value should be freed with jerry_release_value * just when the value becomes unnecessary. * * @return completion status */ jerry_completion_code_t -jerry_run (jerry_api_value_t *error_value_p) /**< [out] error value */ +jerry_run (jerry_value_t *error_value_p) /**< [out] error value */ { jerry_assert_api_available (); ecma_value_t error_value; jerry_completion_code_t ret_code = vm_run_global (&error_value); - jerry_api_convert_ecma_value_to_api_value (error_value_p, error_value); + jerry_convert_ecma_value_to_api_value (error_value_p, error_value); ecma_free_value (error_value); return ret_code; @@ -1766,14 +1765,14 @@ jerry_run (jerry_api_value_t *error_value_p) /**< [out] error value */ * @return completion status */ jerry_completion_code_t -jerry_run_simple (const jerry_api_char_t *script_source, /**< script source */ +jerry_run_simple (const jerry_char_t *script_source, /**< script source */ size_t script_source_size, /**< script source size */ jerry_flag_t flags) /**< combination of Jerry flags */ { jerry_init (flags); jerry_completion_code_t ret_code = JERRY_COMPLETION_CODE_OK; - jerry_api_object_t *error_obj_p = NULL; + jerry_object_t *error_obj_p = NULL; if (!jerry_parse (script_source, script_source_size, &error_obj_p)) { @@ -1782,11 +1781,11 @@ jerry_run_simple (const jerry_api_char_t *script_source, /**< script source */ } else if ((flags & JERRY_FLAG_PARSE_ONLY) == 0) { - jerry_api_value_t error_value; + jerry_value_t error_value; ret_code = jerry_run (&error_value); - jerry_api_release_value (&error_value); + jerry_release_value (&error_value); } jerry_cleanup (); @@ -1798,10 +1797,10 @@ jerry_run_simple (const jerry_api_char_t *script_source, /**< script source */ * Register external magic string array */ void -jerry_register_external_magic_strings (const jerry_api_char_ptr_t *ex_str_items, /**< character arrays, representing - * external magic strings' contents */ - uint32_t count, /**< number of the strings */ - const jerry_api_length_t *str_lengths) /**< lengths of the strings */ +jerry_register_external_magic_strings (const jerry_char_ptr_t *ex_str_items, /**< character arrays, representing + * external magic strings' contents */ + uint32_t count, /**< number of the strings */ + const jerry_length_t *str_lengths) /**< lengths of the strings */ { lit_magic_strings_ex_set ((const lit_utf8_byte_t **) ex_str_items, count, (const lit_utf8_size_t *) str_lengths); } /* jerry_register_external_magic_strings */ @@ -2051,7 +2050,7 @@ jerry_snapshot_set_offsets (uint8_t *buffer_p, /**< buffer */ * 0 - otherwise. */ size_t -jerry_parse_and_save_snapshot (const jerry_api_char_t *source_p, /**< script source */ +jerry_parse_and_save_snapshot (const jerry_char_t *source_p, /**< script source */ size_t source_size, /**< script source size */ bool is_for_global, /**< snapshot would be executed as global (true) * or eval (false) */ @@ -2067,7 +2066,7 @@ jerry_parse_and_save_snapshot (const jerry_api_char_t *source_p, /**< script sou snapshot_error_occured = false; snapshot_buffer_p = buffer_p; snapshot_buffer_size = buffer_size; - jerry_api_object_t *error_obj_p = NULL; + jerry_object_t *error_obj_p = NULL; if (is_for_global) { @@ -2308,10 +2307,10 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */ * buffer could be freed after the call). * Otherwise (if the flag is not set) - the buffer could only be * freed after the engine stops (i.e. after call to jerry_cleanup). */ - jerry_api_value_t *retval_p) /**< [out] returned value (ECMA-262 'undefined' if - * code is executed as global scope code) */ + jerry_value_t *retval_p) /**< [out] returned value (ECMA-262 'undefined' if + * code is executed as global scope code) */ { - jerry_api_convert_ecma_value_to_api_value (retval_p, ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED)); + jerry_convert_ecma_value_to_api_value (retval_p, ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED)); #ifdef JERRY_ENABLE_SNAPSHOT_EXEC JERRY_ASSERT (snapshot_p != NULL); @@ -2391,7 +2390,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_api_convert_eval_completion_to_retval (retval_p, completion); + ret_code = jerry_convert_eval_completion_to_retval (retval_p, completion); ecma_free_value (completion); } @@ -2412,43 +2411,43 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */ * * @return string value */ -jerry_api_string_t * -jerry_api_value_to_string (const jerry_api_value_t *in_value_p) /**< input value */ +jerry_string_t * +jerry_value_to_string (const jerry_value_t *in_value_p) /**< input value */ { jerry_assert_api_available (); ecma_value_t in_value; - jerry_api_convert_api_value_to_ecma_value (&in_value, in_value_p); + jerry_convert_api_value_to_ecma_value (&in_value, in_value_p); ecma_value_t str_value = ecma_op_to_string (in_value); ecma_free_value (in_value); - return (jerry_api_string_t *) ecma_get_string_from_value (str_value); -} /* jerry_api_value_to_string */ + return (jerry_string_t *) ecma_get_string_from_value (str_value); +} /* jerry_value_to_string */ /** * Get size of Jerry string * * @return number of bytes in the buffer needed to represent the string */ -jerry_api_size_t -jerry_api_get_string_size (const jerry_api_string_t *str_p) /**< input string */ +jerry_size_t +jerry_get_string_size (const jerry_string_t *str_p) /**< input string */ { jerry_assert_api_available (); return ecma_string_get_size ((ecma_string_t *) str_p); -} /* jerry_api_get_string_size */ +} /* jerry_get_string_size */ /** * Get length of Jerry string * * @return number of characters in the string */ -jerry_api_length_t -jerry_api_get_string_length (const jerry_api_string_t *str_p) /**< input string */ +jerry_length_t +jerry_get_string_length (const jerry_string_t *str_p) /**< input string */ { jerry_assert_api_available (); return ecma_string_get_length ((ecma_string_t *) str_p); -} /* jerry_api_get_string_length */ +} /* jerry_get_string_length */ diff --git a/jerry-core/jerry.h b/jerry-core/jerry.h index 83b81a5b19..4e5e64fcc4 100644 --- a/jerry-core/jerry.h +++ b/jerry-core/jerry.h @@ -41,8 +41,7 @@ typedef enum JERRY_FLAG_SHOW_OPCODES = (1u << 0), /**< dump byte-code to stdout after parse */ JERRY_FLAG_MEM_STATS = (1u << 1), /**< dump memory statistics */ JERRY_FLAG_MEM_STATS_SEPARATE = (1u << 2), /**< dump memory statistics and reset peak values after parse */ - JERRY_FLAG_PARSE_ONLY = (1u << 3), /**< parse only, prevents script execution (only for testing) - * TODO: Remove. */ + JERRY_FLAG_PARSE_ONLY = (1u << 3), /**< parse only, prevents script execution */ JERRY_FLAG_ENABLE_LOG = (1u << 4), /**< enable logging */ } jerry_flag_t; @@ -71,9 +70,16 @@ void jerry_cleanup (void); void jerry_get_memory_limits (size_t *, size_t *); -bool jerry_parse (const jerry_api_char_t *, size_t, jerry_api_object_t **); -jerry_completion_code_t jerry_run (jerry_api_value_t *); -jerry_completion_code_t jerry_run_simple (const jerry_api_char_t *, size_t, jerry_flag_t); +bool jerry_parse (const jerry_char_t *, size_t, jerry_object_t **); +jerry_completion_code_t jerry_run (jerry_value_t *); +jerry_completion_code_t jerry_run_simple (const jerry_char_t *, size_t, jerry_flag_t); + +jerry_completion_code_t jerry_eval (const jerry_char_t *, size_t, bool, bool, jerry_value_t *); +void jerry_gc (void); +void jerry_register_external_magic_strings (const jerry_char_ptr_t *, uint32_t, const jerry_length_t *); + +size_t jerry_parse_and_save_snapshot (const jerry_char_t *, size_t, bool, uint8_t *, size_t); +jerry_completion_code_t jerry_exec_snapshot (const void *, size_t, bool, jerry_value_t *); /** * @} diff --git a/jerry-core/parser/js/js-parser.c b/jerry-core/parser/js/js-parser.c index d1a8cea52e..a51a93533b 100644 --- a/jerry-core/parser/js/js-parser.c +++ b/jerry-core/parser/js/js-parser.c @@ -2240,21 +2240,21 @@ parser_set_show_instrs (int show_instrs) /**< flag indicating whether to dump by * Parse EcamScript source code * * Note: - * returned error object should be freed with jerry_api_release_object + * returned error object should be freed with jerry_release_object */ jsp_status_t -parser_parse_script (const jerry_api_char_t *source_p, /**< source code */ +parser_parse_script (const jerry_char_t *source_p, /**< source code */ size_t size, /**< size of the source code */ ecma_compiled_code_t **bytecode_data_p, /**< [out] JS bytecode */ - jerry_api_object_t **error_obj_p) /**< [out] error object */ + jerry_object_t **error_obj_p) /**< [out] error object */ { parser_error_location parse_error; *bytecode_data_p = parser_parse_source (source_p, size, false, &parse_error); if (!*bytecode_data_p) { - *error_obj_p = jerry_api_create_error (JERRY_API_ERROR_SYNTAX, - (const jerry_api_char_t *) parser_error_to_string (parse_error.error)); + *error_obj_p = jerry_create_error (JERRY_ERROR_SYNTAX, + (const jerry_char_t *) parser_error_to_string (parse_error.error)); return JSP_STATUS_SYNTAX_ERROR; } @@ -2265,22 +2265,22 @@ parser_parse_script (const jerry_api_char_t *source_p, /**< source code */ * Parse EcamScript eval source code * * Note: - * returned error object should be freed with jerry_api_release_object + * returned error object should be freed with jerry_release_object */ jsp_status_t -parser_parse_eval (const jerry_api_char_t *source_p, /**< source code */ +parser_parse_eval (const jerry_char_t *source_p, /**< source code */ size_t size, /**< size of the source code */ bool is_strict, /**< strict mode */ ecma_compiled_code_t **bytecode_data_p, /**< [out] JS bytecode */ - jerry_api_object_t **error_obj_p) /**< [out] error object */ + jerry_object_t **error_obj_p) /**< [out] error object */ { parser_error_location parse_error; *bytecode_data_p = parser_parse_source (source_p, size, is_strict, &parse_error); if (!*bytecode_data_p) { - *error_obj_p = jerry_api_create_error (JERRY_API_ERROR_SYNTAX, - (const jerry_api_char_t *) parser_error_to_string (parse_error.error)); + *error_obj_p = jerry_create_error (JERRY_ERROR_SYNTAX, + (const jerry_char_t *) parser_error_to_string (parse_error.error)); return JSP_STATUS_SYNTAX_ERROR; } diff --git a/jerry-core/parser/js/js-parser.h b/jerry-core/parser/js/js-parser.h index 4a30688da0..73621644db 100644 --- a/jerry-core/parser/js/js-parser.h +++ b/jerry-core/parser/js/js-parser.h @@ -138,15 +138,15 @@ typedef enum } jsp_status_t; /* Note: source must be a valid UTF-8 string */ -extern jsp_status_t parser_parse_script (const jerry_api_char_t *, +extern jsp_status_t parser_parse_script (const jerry_char_t *, size_t, ecma_compiled_code_t **, - jerry_api_object_t **); -extern jsp_status_t parser_parse_eval (const jerry_api_char_t *, + jerry_object_t **); +extern jsp_status_t parser_parse_eval (const jerry_char_t *, size_t, bool, ecma_compiled_code_t **, - jerry_api_object_t **); + jerry_object_t **); const char *parser_error_to_string (parser_error_t); diff --git a/jerry-core/vm/vm.c b/jerry-core/vm/vm.c index de2033c9e1..b2a0062fef 100644 --- a/jerry-core/vm/vm.c +++ b/jerry-core/vm/vm.c @@ -176,7 +176,7 @@ static const uint16_t vm_decode_table[] = * Run global code * * Note: - * returned error value should be freed with jerry_api_release_value + * returned error value should be freed with jerry_release_value * just when the value becomes unnecessary. * * @return completion code diff --git a/main-mcu.c b/main-mcu.c index 3ece5198dc..38ea0552d5 100644 --- a/main-mcu.c +++ b/main-mcu.c @@ -1,4 +1,5 @@ -/* Copyright 2015 Samsung Electronics Co., Ltd. +/* Copyright 2015-2016 Samsung Electronics Co., Ltd. + * Copyright 2016 University of Szeged. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -31,7 +32,7 @@ main (void) const char *source_p = generated_source; const size_t source_size = sizeof (generated_source); - jerry_completion_code_t ret_code = jerry_run_simple ((jerry_api_char_t *) source_p, source_size, JERRY_FLAG_EMPTY); + jerry_completion_code_t ret_code = jerry_run_simple ((jerry_char_t *) source_p, source_size, JERRY_FLAG_EMPTY); if (ret_code == JERRY_COMPLETION_CODE_OK) { diff --git a/main-unix.c b/main-unix.c index fb14191384..e2f961f47b 100644 --- a/main-unix.c +++ b/main-unix.c @@ -72,14 +72,14 @@ read_file (const char *file_name, * @return true - if only one argument was passed and the argument is a boolean true. */ static bool -assert_handler (const jerry_api_object_t *function_obj_p __attribute__((unused)), /**< function object */ - const jerry_api_value_t *this_p __attribute__((unused)), /**< this arg */ - jerry_api_value_t *ret_val_p __attribute__((unused)), /**< return argument */ - const jerry_api_value_t args_p[], /**< function arguments */ - const jerry_api_length_t args_cnt) /**< number of function arguments */ +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 */ { if (args_cnt == 1 - && args_p[0].type == JERRY_API_DATA_TYPE_BOOLEAN + && args_p[0].type == JERRY_DATA_TYPE_BOOLEAN && args_p[0].u.v_bool == true) { return true; @@ -313,18 +313,18 @@ main (int argc, jerry_init (flags); - jerry_api_object_t *global_obj_p = jerry_api_get_global (); - jerry_api_object_t *assert_func_p = jerry_api_create_external_function (assert_handler); - jerry_api_value_t assert_value; - assert_value.type = JERRY_API_DATA_TYPE_OBJECT; + jerry_object_t *global_obj_p = jerry_get_global (); + jerry_object_t *assert_func_p = jerry_create_external_function (assert_handler); + jerry_value_t assert_value; + assert_value.type = JERRY_DATA_TYPE_OBJECT; assert_value.u.v_object = assert_func_p; - bool is_assert_added = jerry_api_set_object_field_value (global_obj_p, - (jerry_api_char_t *) "assert", - &assert_value); + bool is_assert_added = jerry_set_object_field_value (global_obj_p, + (jerry_char_t *) "assert", + &assert_value); - jerry_api_release_value (&assert_value); - jerry_api_release_object (global_obj_p); + jerry_release_value (&assert_value); + jerry_release_object (global_obj_p); if (!is_assert_added) { @@ -344,12 +344,12 @@ main (int argc, } else { - jerry_api_value_t ret_value; + jerry_value_t ret_value; ret_code = jerry_exec_snapshot ((void *) snapshot_p, snapshot_size, true, &ret_value); - assert (ret_value.type == JERRY_API_DATA_TYPE_UNDEFINED); + assert (ret_value.type == JERRY_DATA_TYPE_UNDEFINED); } if (ret_code != JERRY_COMPLETION_CODE_OK) @@ -358,15 +358,15 @@ main (int argc, } } - jerry_api_object_t *err_obj_p = NULL; - jerry_api_value_t err_value = jerry_api_create_void_value (); + jerry_object_t *err_obj_p = NULL; + jerry_value_t err_value = jerry_create_void_value (); if (ret_code == JERRY_COMPLETION_CODE_OK) { for (int i = 0; i < files_counter; i++) { size_t source_size; - const jerry_api_char_t *source_p = read_file (file_names[i], &source_size); + const jerry_char_t *source_p = read_file (file_names[i], &source_size); if (source_p == NULL) { @@ -377,7 +377,7 @@ main (int argc, { static uint8_t snapshot_save_buffer[ JERRY_BUFFER_SIZE ]; - size_t snapshot_size = jerry_parse_and_save_snapshot ((jerry_api_char_t *) source_p, + size_t snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) source_p, source_size, is_save_snapshot_mode_for_global_or_eval, snapshot_save_buffer, @@ -418,15 +418,15 @@ main (int argc, const char *prompt = "jerry> "; bool is_done = false; - jerry_api_object_t *global_obj_p = jerry_api_get_global (); - jerry_api_value_t print_function; + jerry_object_t *global_obj_p = jerry_get_global (); + jerry_value_t print_function; - if (!jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "print", &print_function)) + if (!jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "print", &print_function)) { return JERRY_STANDALONE_EXIT_CODE_FAIL; } - if (!jerry_api_is_function (print_function.u.v_object)) + if (!jerry_is_function (print_function.u.v_object)) { return JERRY_STANDALONE_EXIT_CODE_FAIL; } @@ -458,23 +458,23 @@ main (int argc, if (len > 0) { /* Evaluate the line */ - jerry_api_value_t ret_val; - ret_code = jerry_api_eval (buffer, len, false, false, &ret_val); + jerry_value_t ret_val; + ret_code = jerry_eval (buffer, len, false, false, &ret_val); /* Print return value */ - const jerry_api_value_t args[] = { ret_val }; - jerry_api_value_t ret_val_print; - if (jerry_api_call_function (print_function.u.v_object, NULL, &ret_val_print, args, 1)) + const jerry_value_t args[] = { ret_val }; + jerry_value_t ret_val_print; + if (jerry_call_function (print_function.u.v_object, NULL, &ret_val_print, args, 1)) { - jerry_api_release_value (&ret_val_print); + jerry_release_value (&ret_val_print); } - jerry_api_release_value (&ret_val); + jerry_release_value (&ret_val); } } - jerry_api_release_object (global_obj_p); - jerry_api_release_value (&print_function); + jerry_release_object (global_obj_p); + jerry_release_value (&print_function); } #ifdef JERRY_ENABLE_LOG @@ -492,33 +492,33 @@ main (int argc, } else if (ret_code == JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION) { - jerry_api_string_t *err_str_p = NULL; + jerry_string_t *err_str_p = NULL; if (err_obj_p != NULL) { - jerry_api_value_t err_value = jerry_api_create_object_value (err_obj_p); - err_str_p = jerry_api_value_to_string (&err_value); - jerry_api_release_object (err_obj_p); + jerry_value_t err_value = jerry_create_object_value (err_obj_p); + err_str_p = jerry_value_to_string (&err_value); + jerry_release_object (err_obj_p); } - else if (!jerry_api_value_is_void (&err_value)) + else if (!jerry_value_is_void (&err_value)) { - err_str_p = jerry_api_value_to_string (&err_value); - jerry_api_release_value (&err_value); + err_str_p = jerry_value_to_string (&err_value); + jerry_release_value (&err_value); } if (__builtin_expect (!!(err_str_p != NULL), 1)) { - jerry_api_char_t err_str_buf[256]; + jerry_char_t err_str_buf[256]; - jerry_api_size_t err_str_size = jerry_api_get_string_size (err_str_p); + jerry_size_t err_str_size = jerry_get_string_size (err_str_p); assert (err_str_size < 256); - jerry_api_size_t sz = jerry_api_string_to_char_buffer (err_str_p, err_str_buf, err_str_size); + jerry_size_t sz = jerry_string_to_char_buffer (err_str_p, err_str_buf, err_str_size); assert (sz == err_str_size); err_str_buf[err_str_size] = 0; jerry_port_errormsg ("Script Error: unhandled exception: %s\n", err_str_buf); - jerry_api_release_string (err_str_p); + jerry_release_string (err_str_p); } jerry_cleanup (); diff --git a/tests/unit/test-api.c b/tests/unit/test-api.c index 69b7938233..3f3bd638d6 100644 --- a/tests/unit/test-api.c +++ b/tests/unit/test-api.c @@ -1,4 +1,5 @@ /* Copyright 2015-2016 Samsung Electronics Co., Ltd. + * Copyright 2016 University of Szeged. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -66,10 +67,10 @@ bool test_api_is_free_callback_was_called = false; * Initialize Jerry API value with specified boolean value */ static void -test_api_init_api_value_bool (jerry_api_value_t *out_value_p, /**< out: API value */ +test_api_init_api_value_bool (jerry_value_t *out_value_p, /**< out: API value */ bool v) /**< boolean value to initialize with */ { - out_value_p->type = JERRY_API_DATA_TYPE_BOOLEAN; + out_value_p->type = JERRY_DATA_TYPE_BOOLEAN; out_value_p->u.v_bool = v; } /* test_api_init_api_value_bool */ @@ -77,10 +78,10 @@ test_api_init_api_value_bool (jerry_api_value_t *out_value_p, /**< out: API valu * Initialize Jerry API value with specified float64 number */ static void -test_api_init_api_value_float64 (jerry_api_value_t *out_value_p, /**< out: API value */ +test_api_init_api_value_float64 (jerry_value_t *out_value_p, /**< out: API value */ double v) /**< float64 value to initialize with */ { - out_value_p->type = JERRY_API_DATA_TYPE_FLOAT64; + out_value_p->type = JERRY_DATA_TYPE_FLOAT64; out_value_p->u.v_float64 = v; } /* test_api_init_api_value_float64 */ @@ -88,48 +89,48 @@ test_api_init_api_value_float64 (jerry_api_value_t *out_value_p, /**< out: API v * Initialize Jerry API value with specified string */ static void -test_api_init_api_value_string (jerry_api_value_t *out_value_p, /**< out: API value */ +test_api_init_api_value_string (jerry_value_t *out_value_p, /**< out: API value */ const char *v) /**< string value to initialize with */ { - out_value_p->type = JERRY_API_DATA_TYPE_STRING; - out_value_p->u.v_string = jerry_api_create_string ((jerry_api_char_t *) v); + out_value_p->type = JERRY_DATA_TYPE_STRING; + out_value_p->u.v_string = jerry_create_string ((jerry_char_t *) v); } /* test_api_init_api_value_string */ /** * Initialize Jerry API value with specified object */ static void -test_api_init_api_value_object (jerry_api_value_t *out_value_p, /**< out: API value */ - jerry_api_object_t *v) /**< object value to initialize with */ +test_api_init_api_value_object (jerry_value_t *out_value_p, /**< out: API value */ + jerry_object_t *v) /**< object value to initialize with */ { - jerry_api_acquire_object (v); + jerry_acquire_object (v); - out_value_p->type = JERRY_API_DATA_TYPE_OBJECT; + out_value_p->type = JERRY_DATA_TYPE_OBJECT; out_value_p->u.v_object = v; } /* test_api_init_api_value_object */ static bool -handler (const jerry_api_object_t *function_obj_p, - const jerry_api_value_t *this_p, - jerry_api_value_t *ret_val_p, - const jerry_api_value_t args_p[], - const jerry_api_length_t args_cnt) +handler (const jerry_object_t *function_obj_p, + const jerry_value_t *this_p, + jerry_value_t *ret_val_p, + const jerry_value_t args_p[], + const jerry_length_t args_cnt) { char buffer[32]; - jerry_api_size_t sz; + jerry_size_t sz; printf ("ok %p %p %p %d %p\n", function_obj_p, this_p, args_p, args_cnt, ret_val_p); JERRY_ASSERT (args_cnt == 2); - JERRY_ASSERT (args_p[0].type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_get_string_size (args_p[0].u.v_string); + JERRY_ASSERT (args_p[0].type == JERRY_DATA_TYPE_STRING); + sz = jerry_get_string_size (args_p[0].u.v_string); JERRY_ASSERT (sz == 1); - sz = jerry_api_string_to_char_buffer (args_p[0].u.v_string, (jerry_api_char_t *) buffer, sz); + sz = jerry_string_to_char_buffer (args_p[0].u.v_string, (jerry_char_t *) buffer, sz); JERRY_ASSERT (sz == 1); JERRY_ASSERT (!strncmp (buffer, "1", (size_t) sz)); - JERRY_ASSERT (args_p[1].type == JERRY_API_DATA_TYPE_BOOLEAN); + JERRY_ASSERT (args_p[1].type == JERRY_DATA_TYPE_BOOLEAN); JERRY_ASSERT (args_p[1].u.v_bool == true); test_api_init_api_value_string (ret_val_p, "string from handler"); @@ -138,20 +139,20 @@ handler (const jerry_api_object_t *function_obj_p, } /* handler */ static bool -handler_throw_test (const jerry_api_object_t *function_obj_p, - const jerry_api_value_t *this_p, - jerry_api_value_t *ret_val_p, - const jerry_api_value_t args_p[], - const jerry_api_length_t args_cnt) +handler_throw_test (const jerry_object_t *function_obj_p, + const jerry_value_t *this_p, + jerry_value_t *ret_val_p, + const jerry_value_t args_p[], + const jerry_length_t args_cnt) { printf ("ok %p %p %p %d %p\n", function_obj_p, this_p, args_p, args_cnt, ret_val_p); - jerry_api_object_t *error_p = jerry_api_create_error (JERRY_API_ERROR_TYPE, - (jerry_api_char_t *) "error"); + jerry_object_t *error_p = jerry_create_error (JERRY_ERROR_TYPE, + (jerry_char_t *) "error"); test_api_init_api_value_object (ret_val_p, error_p); - jerry_api_release_object (error_p); + jerry_release_object (error_p); return false; } /* handler_throw_test */ @@ -166,35 +167,35 @@ handler_construct_freecb (uintptr_t native_p) } /* handler_construct_freecb */ static bool -handler_construct (const jerry_api_object_t *function_obj_p, - const jerry_api_value_t *this_p, - jerry_api_value_t *ret_val_p, - const jerry_api_value_t args_p[], - const jerry_api_length_t args_cnt) +handler_construct (const jerry_object_t *function_obj_p, + const jerry_value_t *this_p, + jerry_value_t *ret_val_p, + const jerry_value_t args_p[], + const jerry_length_t args_cnt) { printf ("ok construct %p %p %p %d %p\n", function_obj_p, this_p, args_p, args_cnt, ret_val_p); JERRY_ASSERT (this_p != NULL); - JERRY_ASSERT (this_p->type == JERRY_API_DATA_TYPE_OBJECT); + JERRY_ASSERT (this_p->type == JERRY_DATA_TYPE_OBJECT); JERRY_ASSERT (args_cnt == 1); - JERRY_ASSERT (args_p[0].type == JERRY_API_DATA_TYPE_BOOLEAN); + JERRY_ASSERT (args_p[0].type == JERRY_DATA_TYPE_BOOLEAN); JERRY_ASSERT (args_p[0].u.v_bool == true); - jerry_api_set_object_field_value (this_p->u.v_object, (jerry_api_char_t *) "value_field", &args_p[0]); + jerry_set_object_field_value (this_p->u.v_object, (jerry_char_t *) "value_field", &args_p[0]); - jerry_api_set_object_native_handle (this_p->u.v_object, - (uintptr_t) 0x0000000000000000ull, - handler_construct_freecb); + jerry_set_object_native_handle (this_p->u.v_object, + (uintptr_t) 0x0000000000000000ull, + handler_construct_freecb); uintptr_t ptr; - bool is_ok = jerry_api_get_object_native_handle (this_p->u.v_object, &ptr); + bool is_ok = jerry_get_object_native_handle (this_p->u.v_object, &ptr); JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0000000000000000ull); /* check if setting handle for second time is handled correctly */ - jerry_api_set_object_native_handle (this_p->u.v_object, - (uintptr_t) 0x0012345678abcdefull, - handler_construct_freecb); + jerry_set_object_native_handle (this_p->u.v_object, + (uintptr_t) 0x0012345678abcdefull, + handler_construct_freecb); return true; } /* handler_construct */ @@ -215,66 +216,66 @@ JERRY_MAGIC_STRING_ITEMS #undef JERRY_MAGIC_STRING_DEF -const jerry_api_length_t magic_string_lengths[] = +const jerry_length_t magic_string_lengths[] = { #define JERRY_MAGIC_STRING_DEF(NAME, STRING) \ - (jerry_api_length_t)(sizeof(jerry_magic_string_ex_ ## NAME) - 1u), + (jerry_length_t)(sizeof(jerry_magic_string_ex_ ## NAME) - 1u), JERRY_MAGIC_STRING_ITEMS #undef JERRY_MAGIC_STRING_DEF }; -const jerry_api_char_ptr_t magic_string_items[] = +const jerry_char_ptr_t magic_string_items[] = { #define JERRY_MAGIC_STRING_DEF(NAME, STRING) \ - (const jerry_api_char_ptr_t)jerry_magic_string_ex_ ## NAME, + (const jerry_char_ptr_t)jerry_magic_string_ex_ ## NAME, JERRY_MAGIC_STRING_ITEMS #undef JERRY_MAGIC_STRING_DEF }; -static bool foreach (const jerry_api_string_t *name, - const jerry_api_value_t *value, void *user_data) +static bool foreach (const jerry_string_t *name, + const jerry_value_t *value, void *user_data) { char str_buf_p[128]; - jerry_api_size_t sz = jerry_api_string_to_char_buffer (name, (jerry_api_char_t *) str_buf_p, 128); + jerry_size_t sz = jerry_string_to_char_buffer (name, (jerry_char_t *) str_buf_p, 128); str_buf_p[sz] = '\0'; if (!strncmp (str_buf_p, "alpha", (size_t) sz)) { #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 - JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_FLOAT32); + JERRY_ASSERT (value->type == JERRY_DATA_TYPE_FLOAT32); JERRY_ASSERT (value->v_float32 == 32.0f); #elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 - JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_FLOAT64); + JERRY_ASSERT (value->type == JERRY_DATA_TYPE_FLOAT64); JERRY_ASSERT (value->u.v_float64 == 32.0); #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */ } else if (!strncmp (str_buf_p, "bravo", (size_t) sz)) { - JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_BOOLEAN); + JERRY_ASSERT (value->type == JERRY_DATA_TYPE_BOOLEAN); JERRY_ASSERT (value->u.v_bool == false); } else if (!strncmp (str_buf_p, "charlie", (size_t) sz)) { - JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_OBJECT); + JERRY_ASSERT (value->type == JERRY_DATA_TYPE_OBJECT); } else if (!strncmp (str_buf_p, "delta", (size_t) sz)) { #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 - JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_FLOAT32); + JERRY_ASSERT (value->type == JERRY_DATA_TYPE_FLOAT32); JERRY_ASSERT (value->v_float32 == 123.45f); #elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 - JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_FLOAT64); + JERRY_ASSERT (value->type == JERRY_DATA_TYPE_FLOAT64); JERRY_ASSERT (value->u.v_float64 == 123.45); #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */ } else if (!strncmp (str_buf_p, "echo", (size_t) sz)) { - JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_STRING); - jerry_api_size_t echo_sz = jerry_api_string_to_char_buffer (value->u.v_string, (jerry_api_char_t *) str_buf_p, 128); + JERRY_ASSERT (value->type == JERRY_DATA_TYPE_STRING); + jerry_size_t echo_sz = jerry_string_to_char_buffer (value->u.v_string, (jerry_char_t *) str_buf_p, 128); str_buf_p[echo_sz] = '\0'; JERRY_ASSERT (!strncmp (str_buf_p, "foobar", (size_t) echo_sz)); } @@ -289,12 +290,12 @@ static bool foreach (const jerry_api_string_t *name, #define UNUSED(x) (void)(x) -static bool foreach_exception (const jerry_api_string_t *name, const jerry_api_value_t *value, void * user_data) +static bool foreach_exception (const jerry_string_t *name, const jerry_value_t *value, void * user_data) { UNUSED (value); UNUSED (user_data); char str_buf_p[128]; - jerry_api_size_t sz = jerry_api_string_to_char_buffer (name, (jerry_api_char_t *) str_buf_p, 128); + jerry_size_t sz = jerry_string_to_char_buffer (name, (jerry_char_t *) str_buf_p, 128); str_buf_p[sz] = '\0'; if (!strncmp (str_buf_p, "foxtrot", (size_t) sz)) @@ -304,7 +305,7 @@ static bool foreach_exception (const jerry_api_string_t *name, const jerry_api_v return true; } /* foreach_exception */ -static bool foreach_subset (const jerry_api_string_t *name, const jerry_api_value_t *value, void *user_data) +static bool foreach_subset (const jerry_string_t *name, const jerry_value_t *value, void *user_data) { UNUSED (name); UNUSED (value); @@ -326,357 +327,357 @@ main (void) jerry_init (JERRY_FLAG_EMPTY); bool is_ok, is_exception; - jerry_api_size_t sz; - jerry_api_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_api_value_t val_external, val_external_construct, val_call_external; - jerry_api_object_t *global_obj_p, *obj_p; - jerry_api_object_t *external_func_p, *external_construct_p; - jerry_api_object_t *throw_test_handler_p; - jerry_api_object_t *err_obj_p = NULL; - jerry_api_value_t res, args[2]; + 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; + jerry_object_t *global_obj_p, *obj_p; + jerry_object_t *external_func_p, *external_construct_p; + jerry_object_t *throw_test_handler_p; + jerry_object_t *err_obj_p = NULL; + jerry_value_t res, args[2]; char buffer[32]; - is_ok = jerry_parse ((jerry_api_char_t *) test_source, strlen (test_source), &err_obj_p); + is_ok = jerry_parse ((jerry_char_t *) test_source, strlen (test_source), &err_obj_p); JERRY_ASSERT (is_ok && err_obj_p == NULL); is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK); JERRY_ASSERT (is_ok); - JERRY_ASSERT (jerry_api_value_is_void (&res)); + JERRY_ASSERT (jerry_value_is_void (&res)); - global_obj_p = jerry_api_get_global (); + global_obj_p = jerry_get_global (); - // Test corner case for jerry_api_string_to_char_buffer + // Test corner case for jerry_string_to_char_buffer test_api_init_api_value_string (&args[0], ""); - sz = jerry_api_get_string_size (args[0].u.v_string); + sz = jerry_get_string_size (args[0].u.v_string); JERRY_ASSERT (sz == 0); - jerry_api_release_value (&args[0]); + jerry_release_value (&args[0]); // Get global.boo (non-existing field) - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "boo", &val_t); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "boo", &val_t); JERRY_ASSERT (!is_ok); - JERRY_ASSERT (val_t.type == JERRY_API_DATA_TYPE_UNDEFINED); + JERRY_ASSERT (val_t.type == JERRY_DATA_TYPE_UNDEFINED); // Get global.t - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"t", &val_t); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *)"t", &val_t); JERRY_ASSERT (is_ok - && val_t.type == JERRY_API_DATA_TYPE_FLOAT64 + && val_t.type == JERRY_DATA_TYPE_FLOAT64 && val_t.u.v_float64 == 1.0); - jerry_api_release_value (&val_t); + jerry_release_value (&val_t); // Get global.foo - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"foo", &val_foo); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *)"foo", &val_foo); JERRY_ASSERT (is_ok - && val_foo.type == JERRY_API_DATA_TYPE_OBJECT); + && val_foo.type == JERRY_DATA_TYPE_OBJECT); // Call foo (4, 2) test_api_init_api_value_float64 (&args[0], 4); test_api_init_api_value_float64 (&args[1], 2); - is_ok = jerry_api_call_function (val_foo.u.v_object, NULL, &res, args, 2); + is_ok = jerry_call_function (val_foo.u.v_object, NULL, &res, args, 2); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_FLOAT64 + && res.type == JERRY_DATA_TYPE_FLOAT64 && res.u.v_float64 == 1.0); - jerry_api_release_value (&res); + jerry_release_value (&res); // Get global.bar - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"bar", &val_bar); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *)"bar", &val_bar); JERRY_ASSERT (is_ok - && val_bar.type == JERRY_API_DATA_TYPE_OBJECT); + && val_bar.type == JERRY_DATA_TYPE_OBJECT); // Call bar (4, 2) - is_ok = jerry_api_call_function (val_bar.u.v_object, NULL, &res, args, 2); + is_ok = jerry_call_function (val_bar.u.v_object, NULL, &res, args, 2); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_FLOAT64 + && res.type == JERRY_DATA_TYPE_FLOAT64 && res.u.v_float64 == 5.0); - jerry_api_release_value (&res); - jerry_api_release_value (&val_bar); + jerry_release_value (&res); + jerry_release_value (&val_bar); // Set global.t = "abcd" test_api_init_api_value_string (&args[0], "abcd"); - is_ok = jerry_api_set_object_field_value (global_obj_p, - (jerry_api_char_t *)"t", - &args[0]); + is_ok = jerry_set_object_field_value (global_obj_p, + (jerry_char_t *)"t", + &args[0]); JERRY_ASSERT (is_ok); - jerry_api_release_value (&args[0]); + jerry_release_value (&args[0]); // Call foo (4, 2) - is_ok = jerry_api_call_function (val_foo.u.v_object, NULL, &res, args, 2); + is_ok = jerry_call_function (val_foo.u.v_object, NULL, &res, args, 2); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_get_string_size (res.u.v_string); + && res.type == JERRY_DATA_TYPE_STRING); + sz = jerry_get_string_size (res.u.v_string); JERRY_ASSERT (sz == 4); - sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, sz); + sz = jerry_string_to_char_buffer (res.u.v_string, (jerry_char_t *) buffer, sz); JERRY_ASSERT (sz == 4); - jerry_api_release_value (&res); + jerry_release_value (&res); JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz)); // Get global.A - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *)"A", &val_A); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *)"A", &val_A); JERRY_ASSERT (is_ok - && val_A.type == JERRY_API_DATA_TYPE_OBJECT); + && val_A.type == JERRY_DATA_TYPE_OBJECT); // Get A.prototype - is_ok = jerry_api_is_constructor (val_A.u.v_object); + is_ok = jerry_is_constructor (val_A.u.v_object); JERRY_ASSERT (is_ok); - is_ok = jerry_api_get_object_field_value (val_A.u.v_object, - (jerry_api_char_t *) "prototype", - &val_A_prototype); + is_ok = jerry_get_object_field_value (val_A.u.v_object, + (jerry_char_t *) "prototype", + &val_A_prototype); JERRY_ASSERT (is_ok - && val_A_prototype.type == JERRY_API_DATA_TYPE_OBJECT); - jerry_api_release_value (&val_A); + && val_A_prototype.type == JERRY_DATA_TYPE_OBJECT); + jerry_release_value (&val_A); // Set A.prototype.foo = global.foo - is_ok = jerry_api_set_object_field_value (val_A_prototype.u.v_object, - (jerry_api_char_t *) "foo", - &val_foo); + is_ok = jerry_set_object_field_value (val_A_prototype.u.v_object, + (jerry_char_t *) "foo", + &val_foo); JERRY_ASSERT (is_ok); - jerry_api_release_value (&val_A_prototype); - jerry_api_release_value (&val_foo); + jerry_release_value (&val_A_prototype); + jerry_release_value (&val_foo); // Get global.a - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "a", &val_a); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "a", &val_a); JERRY_ASSERT (is_ok - && val_a.type == JERRY_API_DATA_TYPE_OBJECT); + && val_a.type == JERRY_DATA_TYPE_OBJECT); // Get a.t - is_ok = jerry_api_get_object_field_value (val_a.u.v_object, (jerry_api_char_t *) "t", &res); + is_ok = jerry_get_object_field_value (val_a.u.v_object, (jerry_char_t *) "t", &res); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_FLOAT64 + && res.type == JERRY_DATA_TYPE_FLOAT64 && res.u.v_float64 == 12.0); - jerry_api_release_value (&res); + jerry_release_value (&res); // foreach properties - jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "p", &val_p); - is_ok = jerry_api_foreach_object_field (val_p.u.v_object, foreach, (void *) "user_data"); + jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "p", &val_p); + is_ok = jerry_foreach_object_field (val_p.u.v_object, foreach, (void *) "user_data"); JERRY_ASSERT (is_ok); // break foreach at third element int count = 0; - is_ok = jerry_api_foreach_object_field (val_p.u.v_object, foreach_subset, &count); + is_ok = jerry_foreach_object_field (val_p.u.v_object, foreach_subset, &count); JERRY_ASSERT (is_ok); JERRY_ASSERT (count == 3); - jerry_api_release_value (&val_p); + jerry_release_value (&val_p); // foreach with throw test - jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "np", &val_np); - is_ok = !jerry_api_foreach_object_field (val_np.u.v_object, foreach_exception, NULL); + jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "np", &val_np); + is_ok = !jerry_foreach_object_field (val_np.u.v_object, foreach_exception, NULL); JERRY_ASSERT (is_ok); - jerry_api_release_value (&val_np); + jerry_release_value (&val_np); // Get a.foo - is_ok = jerry_api_get_object_field_value (val_a.u.v_object, (jerry_api_char_t *) "foo", &val_a_foo); + is_ok = jerry_get_object_field_value (val_a.u.v_object, (jerry_char_t *) "foo", &val_a_foo); JERRY_ASSERT (is_ok - && val_a_foo.type == JERRY_API_DATA_TYPE_OBJECT); + && val_a_foo.type == JERRY_DATA_TYPE_OBJECT); // Call a.foo () - is_ok = jerry_api_call_function (val_a_foo.u.v_object, val_a.u.v_object, &res, NULL, 0); + is_ok = jerry_call_function (val_a_foo.u.v_object, val_a.u.v_object, &res, NULL, 0); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_FLOAT64 + && res.type == JERRY_DATA_TYPE_FLOAT64 && res.u.v_float64 == 12.0); - jerry_api_release_value (&res); - jerry_api_release_value (&val_a_foo); + jerry_release_value (&res); + jerry_release_value (&val_a_foo); - jerry_api_release_value (&val_a); + jerry_release_value (&val_a); // Create native handler bound function object and set it to 'external' variable - external_func_p = jerry_api_create_external_function (handler); + external_func_p = jerry_create_external_function (handler); JERRY_ASSERT (external_func_p != NULL - && jerry_api_is_function (external_func_p) - && jerry_api_is_constructor (external_func_p)); + && jerry_is_function (external_func_p) + && jerry_is_constructor (external_func_p)); test_api_init_api_value_object (&val_external, external_func_p); - is_ok = jerry_api_set_object_field_value (global_obj_p, - (jerry_api_char_t *) "external", - &val_external); + is_ok = jerry_set_object_field_value (global_obj_p, + (jerry_char_t *) "external", + &val_external); JERRY_ASSERT (is_ok); - jerry_api_release_value (&val_external); - jerry_api_release_object (external_func_p); + jerry_release_value (&val_external); + jerry_release_object (external_func_p); // Call 'call_external' function that should call external function created above - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "call_external", &val_call_external); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "call_external", &val_call_external); JERRY_ASSERT (is_ok - && val_call_external.type == JERRY_API_DATA_TYPE_OBJECT); - is_ok = jerry_api_call_function (val_call_external.u.v_object, - global_obj_p, - &res, - NULL, 0); - jerry_api_release_value (&val_call_external); + && val_call_external.type == JERRY_DATA_TYPE_OBJECT); + is_ok = jerry_call_function (val_call_external.u.v_object, + global_obj_p, + &res, + NULL, 0); + jerry_release_value (&val_call_external); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_get_string_size (res.u.v_string); + && res.type == JERRY_DATA_TYPE_STRING); + sz = jerry_get_string_size (res.u.v_string); JERRY_ASSERT (sz == 19); - sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, sz); + sz = jerry_string_to_char_buffer (res.u.v_string, (jerry_char_t *) buffer, sz); JERRY_ASSERT (sz == 19); - jerry_api_release_value (&res); + jerry_release_value (&res); JERRY_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz)); // Create native handler bound function object and set it to 'external_construct' variable - external_construct_p = jerry_api_create_external_function (handler_construct); + external_construct_p = jerry_create_external_function (handler_construct); JERRY_ASSERT (external_construct_p != NULL - && jerry_api_is_function (external_construct_p) - && jerry_api_is_constructor (external_construct_p)); + && jerry_is_function (external_construct_p) + && jerry_is_constructor (external_construct_p)); test_api_init_api_value_object (&val_external_construct, external_construct_p); - is_ok = jerry_api_set_object_field_value (global_obj_p, - (jerry_api_char_t *) "external_construct", - &val_external_construct); + is_ok = jerry_set_object_field_value (global_obj_p, + (jerry_char_t *) "external_construct", + &val_external_construct); JERRY_ASSERT (is_ok); - jerry_api_release_value (&val_external_construct); - jerry_api_release_object (external_construct_p); + jerry_release_value (&val_external_construct); + jerry_release_object (external_construct_p); // Call external function created above, as constructor test_api_init_api_value_bool (&args[0], true); - is_ok = jerry_api_construct_object (external_construct_p, &res, args, 1); + is_ok = jerry_construct_object (external_construct_p, &res, args, 1); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_OBJECT); - is_ok = jerry_api_get_object_field_value (res.u.v_object, - (jerry_api_char_t *)"value_field", - &val_value_field); + && res.type == JERRY_DATA_TYPE_OBJECT); + is_ok = jerry_get_object_field_value (res.u.v_object, + (jerry_char_t *)"value_field", + &val_value_field); // Get 'value_field' of constructed object JERRY_ASSERT (is_ok - && val_value_field.type == JERRY_API_DATA_TYPE_BOOLEAN + && val_value_field.type == JERRY_DATA_TYPE_BOOLEAN && val_value_field.u.v_bool == true); - jerry_api_release_value (&val_value_field); + jerry_release_value (&val_value_field); uintptr_t ptr; - is_ok = jerry_api_get_object_native_handle (res.u.v_object, &ptr); + is_ok = jerry_get_object_native_handle (res.u.v_object, &ptr); JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0012345678abcdefull); - jerry_api_release_value (&res); + jerry_release_value (&res); // Test: Throwing exception from native handler. - throw_test_handler_p = jerry_api_create_external_function (handler_throw_test); + throw_test_handler_p = jerry_create_external_function (handler_throw_test); JERRY_ASSERT (throw_test_handler_p != NULL - && jerry_api_is_function (throw_test_handler_p)); + && jerry_is_function (throw_test_handler_p)); test_api_init_api_value_object (&val_t, throw_test_handler_p); - is_ok = jerry_api_set_object_field_value (global_obj_p, - (jerry_api_char_t *) "throw_test", - &val_t); + is_ok = jerry_set_object_field_value (global_obj_p, + (jerry_char_t *) "throw_test", + &val_t); JERRY_ASSERT (is_ok); - jerry_api_release_value (&val_t); - jerry_api_release_object (throw_test_handler_p); + jerry_release_value (&val_t); + jerry_release_object (throw_test_handler_p); - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "call_throw_test", &val_t); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "call_throw_test", &val_t); JERRY_ASSERT (is_ok - && val_t.type == JERRY_API_DATA_TYPE_OBJECT); + && val_t.type == JERRY_DATA_TYPE_OBJECT); - is_ok = jerry_api_call_function (val_t.u.v_object, - global_obj_p, - &res, - NULL, 0); + is_ok = jerry_call_function (val_t.u.v_object, + global_obj_p, + &res, + NULL, 0); JERRY_ASSERT (is_ok); - jerry_api_release_value (&val_t); - jerry_api_release_value (&res); + jerry_release_value (&val_t); + jerry_release_value (&res); // Test: Unhandled exception in called function - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "throw_reference_error", &val_t); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "throw_reference_error", &val_t); JERRY_ASSERT (is_ok - && val_t.type == JERRY_API_DATA_TYPE_OBJECT); + && val_t.type == JERRY_DATA_TYPE_OBJECT); - is_ok = jerry_api_call_function (val_t.u.v_object, - global_obj_p, - &res, - NULL, 0); + is_ok = jerry_call_function (val_t.u.v_object, + global_obj_p, + &res, + NULL, 0); is_exception = !is_ok; JERRY_ASSERT (is_exception); - jerry_api_release_value (&val_t); + jerry_release_value (&val_t); // 'res' should contain exception object - JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); - jerry_api_release_value (&res); + JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); + jerry_release_value (&res); // Test: Call of non-function - obj_p = jerry_api_create_object (); - is_ok = jerry_api_call_function (obj_p, - global_obj_p, - &res, - NULL, 0); + obj_p = jerry_create_object (); + is_ok = jerry_call_function (obj_p, + global_obj_p, + &res, + NULL, 0); is_exception = !is_ok; JERRY_ASSERT (is_exception); // 'res' should contain exception object - JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); - jerry_api_release_value (&res); + JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); + jerry_release_value (&res); - jerry_api_release_object (obj_p); + jerry_release_object (obj_p); // Test: Unhandled exception in function called, as constructor - is_ok = jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "throw_reference_error", &val_t); + is_ok = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "throw_reference_error", &val_t); JERRY_ASSERT (is_ok - && val_t.type == JERRY_API_DATA_TYPE_OBJECT); + && val_t.type == JERRY_DATA_TYPE_OBJECT); - is_ok = jerry_api_construct_object (val_t.u.v_object, - &res, - NULL, 0); + is_ok = jerry_construct_object (val_t.u.v_object, + &res, + NULL, 0); is_exception = !is_ok; JERRY_ASSERT (is_exception); - jerry_api_release_value (&val_t); + jerry_release_value (&val_t); // 'res' should contain exception object - JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); - jerry_api_release_value (&res); + JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); + jerry_release_value (&res); // Test: Call of non-function as constructor - obj_p = jerry_api_create_object (); - is_ok = jerry_api_construct_object (obj_p, - &res, - NULL, 0); + obj_p = jerry_create_object (); + is_ok = jerry_construct_object (obj_p, + &res, + NULL, 0); is_exception = !is_ok; JERRY_ASSERT (is_exception); // 'res' should contain exception object - JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); - jerry_api_release_value (&res); + JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); + jerry_release_value (&res); - jerry_api_release_object (obj_p); + jerry_release_object (obj_p); // Test: Array Object API - jerry_api_object_t *array_obj_p = jerry_api_create_array_object (10); + jerry_object_t *array_obj_p = jerry_create_array_object (10); - jerry_api_value_t v_in; + jerry_value_t v_in; test_api_init_api_value_float64 (&v_in, 10.5); - jerry_api_set_array_index_value (array_obj_p, 5, &v_in); - jerry_api_value_t v_out; - jerry_api_get_array_index_value (array_obj_p, 5, &v_out); + jerry_set_array_index_value (array_obj_p, 5, &v_in); + jerry_value_t v_out; + jerry_get_array_index_value (array_obj_p, 5, &v_out); - JERRY_ASSERT (v_out.type == JERRY_API_DATA_TYPE_FLOAT64 && v_out.u.v_float64 == 10.5); + JERRY_ASSERT (v_out.type == JERRY_DATA_TYPE_FLOAT64 && v_out.u.v_float64 == 10.5); - jerry_api_release_object (array_obj_p); + jerry_release_object (array_obj_p); // Test: eval const char *eval_code_src_p = "(function () { return 123; })"; - jerry_completion_code_t status = jerry_api_eval ((jerry_api_char_t *) eval_code_src_p, - strlen (eval_code_src_p), - false, - true, - &val_t); + jerry_completion_code_t status = jerry_eval ((jerry_char_t *) eval_code_src_p, + strlen (eval_code_src_p), + false, + true, + &val_t); JERRY_ASSERT (status == JERRY_COMPLETION_CODE_OK); - JERRY_ASSERT (val_t.type == JERRY_API_DATA_TYPE_OBJECT); - JERRY_ASSERT (jerry_api_is_function (val_t.u.v_object)); + JERRY_ASSERT (val_t.type == JERRY_DATA_TYPE_OBJECT); + JERRY_ASSERT (jerry_is_function (val_t.u.v_object)); - is_ok = jerry_api_call_function (val_t.u.v_object, - NULL, - &res, - NULL, 0); + is_ok = jerry_call_function (val_t.u.v_object, + NULL, + &res, + NULL, 0); JERRY_ASSERT (is_ok); - JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_FLOAT64 + JERRY_ASSERT (res.type == JERRY_DATA_TYPE_FLOAT64 && res.u.v_float64 == 123.0); - jerry_api_release_value (&res); + jerry_release_value (&res); - jerry_api_release_value (&val_t); + jerry_release_value (&val_t); // cleanup. - jerry_api_release_object (global_obj_p); + jerry_release_object (global_obj_p); // TEST: run gc. - jerry_api_gc (); + jerry_gc (); jerry_cleanup (); @@ -685,18 +686,18 @@ main (void) // External Magic String jerry_init (JERRY_FLAG_SHOW_OPCODES); - uint32_t num_magic_string_items = (uint32_t) (sizeof (magic_string_items) / sizeof (jerry_api_char_ptr_t)); + uint32_t num_magic_string_items = (uint32_t) (sizeof (magic_string_items) / sizeof (jerry_char_ptr_t)); jerry_register_external_magic_strings (magic_string_items, num_magic_string_items, magic_string_lengths); const char *ms_code_src_p = "var global = {}; var console = [1]; var process = 1;"; - is_ok = jerry_parse ((jerry_api_char_t *) ms_code_src_p, strlen (ms_code_src_p), &err_obj_p); + is_ok = jerry_parse ((jerry_char_t *) ms_code_src_p, strlen (ms_code_src_p), &err_obj_p); JERRY_ASSERT (is_ok && err_obj_p == NULL); is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK); JERRY_ASSERT (is_ok); - JERRY_ASSERT (jerry_api_value_is_void (&res)); + JERRY_ASSERT (jerry_value_is_void (&res)); jerry_cleanup (); @@ -710,7 +711,7 @@ main (void) const char *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();"; jerry_init (JERRY_FLAG_SHOW_OPCODES); - size_t global_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_api_char_t *) code_to_snapshot_p, + size_t global_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p, strlen (code_to_snapshot_p), true, global_mode_snapshot_buffer, @@ -719,7 +720,7 @@ main (void) jerry_cleanup (); jerry_init (JERRY_FLAG_SHOW_OPCODES); - size_t eval_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_api_char_t *) code_to_snapshot_p, + size_t eval_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p, strlen (code_to_snapshot_p), false, eval_mode_snapshot_buffer, @@ -735,8 +736,8 @@ main (void) &res) == JERRY_COMPLETION_CODE_OK); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_UNDEFINED); - jerry_api_release_value (&res); + && res.type == JERRY_DATA_TYPE_UNDEFINED); + jerry_release_value (&res); is_ok = (jerry_exec_snapshot (eval_mode_snapshot_buffer, eval_mode_snapshot_size, @@ -744,12 +745,12 @@ main (void) &res) == JERRY_COMPLETION_CODE_OK); JERRY_ASSERT (is_ok - && res.type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_get_string_size (res.u.v_string); + && res.type == JERRY_DATA_TYPE_STRING); + sz = jerry_get_string_size (res.u.v_string); JERRY_ASSERT (sz == 20); - sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, sz); + sz = jerry_string_to_char_buffer (res.u.v_string, (jerry_char_t *) buffer, sz); JERRY_ASSERT (sz == 20); - jerry_api_release_value (&res); + jerry_release_value (&res); JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz)); jerry_cleanup (); diff --git a/tests/unit/test-string-to-number.c b/tests/unit/test-string-to-number.c index d67fcab584..2a90182bca 100644 --- a/tests/unit/test-string-to-number.c +++ b/tests/unit/test-string-to-number.c @@ -1,4 +1,5 @@ -/* Copyright 2014-2015 Samsung Electronics Co., Ltd. +/* Copyright 2014-2016 Samsung Electronics Co., Ltd. + * Copyright 2016 University of Szeged. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,26 +28,26 @@ main (int __attr_unused___ argc, { TEST_INIT (); - const jerry_api_char_t *strings[] = + const jerry_char_t *strings[] = { - (const jerry_api_char_t *) "1", - (const jerry_api_char_t *) "0.5", - (const jerry_api_char_t *) "12345", - (const jerry_api_char_t *) "1e-45", - (const jerry_api_char_t *) "-2.5e+38", - (const jerry_api_char_t *) "-2.5e38", - (const jerry_api_char_t *) "- 2.5e+38", - (const jerry_api_char_t *) "-2 .5e+38", - (const jerry_api_char_t *) "-2. 5e+38", - (const jerry_api_char_t *) "-2.5e+ 38", - (const jerry_api_char_t *) "-2.5 e+38", - (const jerry_api_char_t *) "-2.5e +38", - (const jerry_api_char_t *) "NaN", - (const jerry_api_char_t *) "abc", - (const jerry_api_char_t *) " Infinity ", - (const jerry_api_char_t *) "-Infinity", - (const jerry_api_char_t *) "0", - (const jerry_api_char_t *) "0", + (const jerry_char_t *) "1", + (const jerry_char_t *) "0.5", + (const jerry_char_t *) "12345", + (const jerry_char_t *) "1e-45", + (const jerry_char_t *) "-2.5e+38", + (const jerry_char_t *) "-2.5e38", + (const jerry_char_t *) "- 2.5e+38", + (const jerry_char_t *) "-2 .5e+38", + (const jerry_char_t *) "-2. 5e+38", + (const jerry_char_t *) "-2.5e+ 38", + (const jerry_char_t *) "-2.5 e+38", + (const jerry_char_t *) "-2.5e +38", + (const jerry_char_t *) "NaN", + (const jerry_char_t *) "abc", + (const jerry_char_t *) " Infinity ", + (const jerry_char_t *) "-Infinity", + (const jerry_char_t *) "0", + (const jerry_char_t *) "0", }; const ecma_number_t nums[] =