YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update API functions

Browse Source 
* Rename 'jerry_api_' prefix to 'jerry_'
 * Fix minor style issues
 * Group the API functions and add comment to each group
 * Move engine behaviour related funtions to 'jerry.h'

JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com
This commit is contained in:
László Langó
2016-06-06 11:48:30 +02:00
parent 3e0572e433
commit 824d39c2a2
12 changed files with 867 additions and 942 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/ecma/operations/ecma-eval.c
+3 -3
View File
@@ -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); 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, chars_num,
is_direct, is_direct,
is_called_from_strict_mode_code); is_called_from_strict_mode_code);
@@ -77,7 +77,7 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */
* @return ecma value * @return ecma value
*/ */
ecma_value_t 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 */ 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_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 */ 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; jsp_status_t parse_status;
bool is_strict_call = (is_direct && is_called_from_strict_mode_code); 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, parse_status = parser_parse_eval (code_p,
code_buffer_size, code_buffer_size,
jerry-core/ecma/operations/ecma-eval.h
+2 -1
View File
@@ -1,4 +1,5 @@
/* Copyright 2015-2016 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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with 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); ecma_op_eval (ecma_string_t *, bool, bool);
extern ecma_value_t 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);
/** /**
* @} * @}
jerry-core/jerry-api.h
+105 -189
View File
@@ -47,67 +47,67 @@ typedef enum
*/ */
typedef enum typedef enum
{ {
JERRY_API_DATA_TYPE_VOID, /**< no return value */ JERRY_DATA_TYPE_VOID, /**< no return value */
JERRY_API_DATA_TYPE_UNDEFINED, /**< undefined */ JERRY_DATA_TYPE_UNDEFINED, /**< undefined */
JERRY_API_DATA_TYPE_NULL, /**< null */ JERRY_DATA_TYPE_NULL, /**< null */
JERRY_API_DATA_TYPE_BOOLEAN, /**< bool */ JERRY_DATA_TYPE_BOOLEAN, /**< bool */
JERRY_API_DATA_TYPE_FLOAT32, /**< 32-bit float */ JERRY_DATA_TYPE_FLOAT32, /**< 32-bit float */
JERRY_API_DATA_TYPE_FLOAT64, /**< 64-bit float */ JERRY_DATA_TYPE_FLOAT64, /**< 64-bit float */
JERRY_API_DATA_TYPE_UINT32, /**< number converted to 32-bit unsigned integer */ JERRY_DATA_TYPE_UINT32, /**< number converted to 32-bit unsigned integer */
JERRY_API_DATA_TYPE_STRING, /**< string */ JERRY_DATA_TYPE_STRING, /**< string */
JERRY_API_DATA_TYPE_OBJECT /**< object */ JERRY_DATA_TYPE_OBJECT /**< object */
} jerry_api_data_type_t; } jerry_data_type_t;
/** /**
* Jerry API Error object types * Jerry API Error object types
*/ */
typedef enum typedef enum
{ {
JERRY_API_ERROR_COMMON, /**< Error */ JERRY_ERROR_COMMON, /**< Error */
JERRY_API_ERROR_EVAL, /**< EvalError */ JERRY_ERROR_EVAL, /**< EvalError */
JERRY_API_ERROR_RANGE, /**< RangeError */ JERRY_ERROR_RANGE, /**< RangeError */
JERRY_API_ERROR_REFERENCE, /**< ReferenceError */ JERRY_ERROR_REFERENCE, /**< ReferenceError */
JERRY_API_ERROR_SYNTAX, /**< SyntaxError */ JERRY_ERROR_SYNTAX, /**< SyntaxError */
JERRY_API_ERROR_TYPE, /**< TypeError */ JERRY_ERROR_TYPE, /**< TypeError */
JERRY_API_ERROR_URI /**< URIError */ JERRY_ERROR_URI /**< URIError */
} jerry_api_error_t; } jerry_error_t;
/** /**
* Jerry's char value * Jerry's char value
*/ */
typedef uint8_t jerry_api_char_t; typedef uint8_t jerry_char_t;
/** /**
* Pointer to an array of character values * 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 * Jerry's size
*/ */
typedef uint32_t jerry_api_size_t; typedef uint32_t jerry_size_t;
/** /**
* Jerry's length * Jerry's length
*/ */
typedef uint32_t jerry_api_length_t; typedef uint32_t jerry_length_t;
/** /**
* Jerry's string value * 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 * 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 * 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 union
{ {
@@ -118,212 +118,128 @@ typedef struct jerry_api_value_t
uint32_t v_uint32; /**< number converted 32-bit unsigned integer */ uint32_t v_uint32; /**< number converted 32-bit unsigned integer */
jerry_api_string_t *v_string; /**< pointer to a JS string */ jerry_string_t *v_string; /**< pointer to a JS string */
jerry_api_object_t *v_object; /**< pointer to a JS object */ jerry_object_t *v_object; /**< pointer to a JS object */
} u; } 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, typedef bool (*jerry_external_handler_t) (const jerry_object_t *function_obj_p,
const jerry_api_value_t *this_p, const jerry_value_t *this_p,
jerry_api_value_t *ret_val_p, jerry_value_t *ret_val_p,
const jerry_api_value_t args_p[], const jerry_value_t args_p[],
const jerry_api_length_t args_count); 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); 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, typedef bool (*jerry_object_field_foreach_t) (const jerry_string_t *field_name_p,
const jerry_api_value_t *field_value_p, const jerry_value_t *field_value_p,
void *user_data_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. * Get the global context
*/ */
bool jerry_api_value_is_null (const jerry_api_value_t *value_p); jerry_object_t *jerry_get_global (void);
/** /**
* Returns whether the given jerry_api_value_t is undefined. * Checker functions of 'jerry_value_t'
*/ */
bool jerry_api_value_is_undefined (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 has boolean type. * Getter functions of 'jerry_value_t'
*/ */
bool jerry_api_value_is_boolean (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 number. * Converters of 'jerry_value_t'
*
* 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); jerry_string_t *jerry_value_to_string (const jerry_value_t *);
/** /**
* Returns whether the given jerry_api_value_t is string. * Create functions of 'jerry_value_t'
*/ */
bool jerry_api_value_is_string (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 whether the given jerry_api_value_t is object. * Acquire types with reference counter (increase the references)
*/ */
bool jerry_api_value_is_object (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 whether the given jerry_api_value_t is a function object. * Relase the referenced values
*
* 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.
*/ */
bool jerry_api_value_is_function (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 boolean v_bool member of the given jerry_api_value_t structure. * Create functions of API objects
* If the given jerry_api_value_t structure has type other than
* JERRY_API_DATA_TYPE_BOOLEAN, JERRY_ASSERT fails.
*/ */
bool jerry_api_get_boolean_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);
/** /**
* Returns the number value of the given jerry_api_value_t structure * Functions of array objects
* 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.
*/ */
double jerry_api_get_number_value (const jerry_api_value_t *value_p); 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 *);
/** /**
* Returns the v_string member of the given jerry_api_value_t structure. * Functions of 'jerry_string_t'
* If the given jerry_api_value_t structure has type other than
* JERRY_API_DATA_TYPE_STRING, JERRY_ASSERT fails.
*/ */
jerry_api_string_t *jerry_api_get_string_value (const jerry_api_value_t *value_p); 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);
/** /**
* Returns the v_object member of the given jerry_api_value_t structure. * General API functions of JS objects
* If the given jerry_api_value_t structure has type other than
* JERRY_API_DATA_TYPE_OBJECT, JERRY_ASSERT fails.
*/ */
jerry_api_object_t *jerry_api_get_object_value (const jerry_api_value_t *value_p); 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);
* Creates and returns a jerry_api_value_t with type bool jerry_delete_object_field (jerry_object_t *, const jerry_char_t *, jerry_size_t);
* JERRY_API_DATA_TYPE_VOID. 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 *);
jerry_api_value_t jerry_api_create_void_value (void); 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 *);
* Creates and returns a jerry_api_value_t with type bool jerry_get_object_native_handle (jerry_object_t *, uintptr_t *);
* JERRY_API_DATA_TYPE_NULL. void jerry_set_object_native_handle (jerry_object_t *, uintptr_t, jerry_object_free_callback_t);
*/ bool jerry_construct_object (jerry_object_t *, jerry_value_t *, const jerry_value_t[], uint16_t);
jerry_api_value_t jerry_api_create_null_value (void); bool jerry_call_function (jerry_object_t *, jerry_object_t *, jerry_value_t *, const jerry_value_t[], uint16_t);
/**
* Creates and returns a jerry_api_value_t with type
* JERRY_API_DATA_TYPE_UNDEFINED.
*/
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 *);
/** /**
* @} * @}
jerry-core/jerry.c
+411 -412
View File
File diff suppressed because it is too large Load Diff
jerry-core/jerry.h
+11 -5
View File
@@ -41,8 +41,7 @@ typedef enum
JERRY_FLAG_SHOW_OPCODES = (1u << 0), /**< dump byte-code to stdout after parse */ 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 = (1u << 1), /**< dump memory statistics */
JERRY_FLAG_MEM_STATS_SEPARATE = (1u << 2), /**< dump memory statistics and reset peak values after parse */ 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) JERRY_FLAG_PARSE_ONLY = (1u << 3), /**< parse only, prevents script execution */
* TODO: Remove. */
JERRY_FLAG_ENABLE_LOG = (1u << 4), /**< enable logging */ JERRY_FLAG_ENABLE_LOG = (1u << 4), /**< enable logging */
} jerry_flag_t; } jerry_flag_t;
@@ -71,9 +70,16 @@ void jerry_cleanup (void);
void jerry_get_memory_limits (size_t *, size_t *); void jerry_get_memory_limits (size_t *, size_t *);
bool jerry_parse (const jerry_api_char_t *, size_t, jerry_api_object_t **); bool jerry_parse (const jerry_char_t *, size_t, jerry_object_t **);
jerry_completion_code_t jerry_run (jerry_api_value_t *); jerry_completion_code_t jerry_run (jerry_value_t *);
jerry_completion_code_t jerry_run_simple (const jerry_api_char_t *, size_t, jerry_flag_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 *);
/** /**
* @} * @}
jerry-core/parser/js/js-parser.c
+10 -10
View File
@@ -2240,21 +2240,21 @@ parser_set_show_instrs (int show_instrs) /**< flag indicating whether to dump by
* Parse EcamScript source code * Parse EcamScript source code
* *
* Note: * 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 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 */ size_t size, /**< size of the source code */
ecma_compiled_code_t **bytecode_data_p, /**< [out] JS bytecode */ 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; parser_error_location parse_error;
*bytecode_data_p = parser_parse_source (source_p, size, false, &parse_error); *bytecode_data_p = parser_parse_source (source_p, size, false, &parse_error);
if (!*bytecode_data_p) if (!*bytecode_data_p)
{ {
*error_obj_p = jerry_api_create_error (JERRY_API_ERROR_SYNTAX, *error_obj_p = jerry_create_error (JERRY_ERROR_SYNTAX,
(const jerry_api_char_t *) parser_error_to_string (parse_error.error)); (const jerry_char_t *) parser_error_to_string (parse_error.error));
return JSP_STATUS_SYNTAX_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 * Parse EcamScript eval source code
* *
* Note: * 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 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 */ size_t size, /**< size of the source code */
bool is_strict, /**< strict mode */ bool is_strict, /**< strict mode */
ecma_compiled_code_t **bytecode_data_p, /**< [out] JS bytecode */ 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; parser_error_location parse_error;
*bytecode_data_p = parser_parse_source (source_p, size, is_strict, &parse_error); *bytecode_data_p = parser_parse_source (source_p, size, is_strict, &parse_error);
if (!*bytecode_data_p) if (!*bytecode_data_p)
{ {
*error_obj_p = jerry_api_create_error (JERRY_API_ERROR_SYNTAX, *error_obj_p = jerry_create_error (JERRY_ERROR_SYNTAX,
(const jerry_api_char_t *) parser_error_to_string (parse_error.error)); (const jerry_char_t *) parser_error_to_string (parse_error.error));
return JSP_STATUS_SYNTAX_ERROR; return JSP_STATUS_SYNTAX_ERROR;
} }
jerry-core/parser/js/js-parser.h
+4 -4
View File
@@ -138,15 +138,15 @@ typedef enum
} jsp_status_t; } jsp_status_t;
/* Note: source must be a valid UTF-8 string */ /* 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, size_t,
ecma_compiled_code_t **, ecma_compiled_code_t **,
jerry_api_object_t **); jerry_object_t **);
extern jsp_status_t parser_parse_eval (const jerry_api_char_t *, extern jsp_status_t parser_parse_eval (const jerry_char_t *,
size_t, size_t,
bool, bool,
ecma_compiled_code_t **, ecma_compiled_code_t **,
jerry_api_object_t **); jerry_object_t **);
const char *parser_error_to_string (parser_error_t); const char *parser_error_to_string (parser_error_t);
jerry-core/vm/vm.c
+1 -1
View File
@@ -176,7 +176,7 @@ static const uint16_t vm_decode_table[] =
* Run global code * Run global code
* *
* Note: * 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. * just when the value becomes unnecessary.
* *
* @return completion code * @return completion code
main-mcu.c
+3 -2
View File
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with 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 char *source_p = generated_source;
const size_t source_size = sizeof (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) if (ret_code == JERRY_COMPLETION_CODE_OK)
{ {
main-unix.c
+45 -45
View File
@@ -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. * @return true - if only one argument was passed and the argument is a boolean true.
*/ */
static bool static bool
assert_handler (const jerry_api_object_t *function_obj_p __attribute__((unused)), /**< function object */ assert_handler (const jerry_object_t *function_obj_p __attribute__((unused)), /**< function object */
const jerry_api_value_t *this_p __attribute__((unused)), /**< this arg */ const jerry_value_t *this_p __attribute__((unused)), /**< this arg */
jerry_api_value_t *ret_val_p __attribute__((unused)), /**< return argument */ jerry_value_t *ret_val_p __attribute__((unused)), /**< return argument */
const jerry_api_value_t args_p[], /**< function arguments */ const jerry_value_t args_p[], /**< function arguments */
const jerry_api_length_t args_cnt) /**< number of function arguments */ const jerry_length_t args_cnt) /**< number of function arguments */
{ {
if (args_cnt == 1 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) && args_p[0].u.v_bool == true)
{ {
return true; return true;
@@ -313,18 +313,18 @@ main (int argc,
jerry_init (flags); jerry_init (flags);
jerry_api_object_t *global_obj_p = jerry_api_get_global (); jerry_object_t *global_obj_p = jerry_get_global ();
jerry_api_object_t *assert_func_p = jerry_api_create_external_function (assert_handler); jerry_object_t *assert_func_p = jerry_create_external_function (assert_handler);
jerry_api_value_t assert_value; jerry_value_t assert_value;
assert_value.type = JERRY_API_DATA_TYPE_OBJECT; assert_value.type = JERRY_DATA_TYPE_OBJECT;
assert_value.u.v_object = assert_func_p; assert_value.u.v_object = assert_func_p;
bool is_assert_added = jerry_api_set_object_field_value (global_obj_p, bool is_assert_added = jerry_set_object_field_value (global_obj_p,
(jerry_api_char_t *) "assert", (jerry_char_t *) "assert",
&assert_value); &assert_value);
jerry_api_release_value (&assert_value); jerry_release_value (&assert_value);
jerry_api_release_object (global_obj_p); jerry_release_object (global_obj_p);
if (!is_assert_added) if (!is_assert_added)
{ {
@@ -344,12 +344,12 @@ main (int argc,
} }
else else
{ {
jerry_api_value_t ret_value; jerry_value_t ret_value;
ret_code = jerry_exec_snapshot ((void *) snapshot_p, ret_code = jerry_exec_snapshot ((void *) snapshot_p,
snapshot_size, snapshot_size,
true, true,
&ret_value); &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) if (ret_code != JERRY_COMPLETION_CODE_OK)
@@ -358,15 +358,15 @@ main (int argc,
} }
} }
jerry_api_object_t *err_obj_p = NULL; jerry_object_t *err_obj_p = NULL;
jerry_api_value_t err_value = jerry_api_create_void_value (); jerry_value_t err_value = jerry_create_void_value ();
if (ret_code == JERRY_COMPLETION_CODE_OK) if (ret_code == JERRY_COMPLETION_CODE_OK)
{ {
for (int i = 0; i < files_counter; i++) for (int i = 0; i < files_counter; i++)
{ {
size_t source_size; 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) if (source_p == NULL)
{ {
@@ -377,7 +377,7 @@ main (int argc,
{ {
static uint8_t snapshot_save_buffer[ JERRY_BUFFER_SIZE ]; 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, source_size,
is_save_snapshot_mode_for_global_or_eval, is_save_snapshot_mode_for_global_or_eval,
snapshot_save_buffer, snapshot_save_buffer,
@@ -418,15 +418,15 @@ main (int argc,
const char *prompt = "jerry> "; const char *prompt = "jerry> ";
bool is_done = false; bool is_done = false;
jerry_api_object_t *global_obj_p = jerry_api_get_global (); jerry_object_t *global_obj_p = jerry_get_global ();
jerry_api_value_t print_function; 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; 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; return JERRY_STANDALONE_EXIT_CODE_FAIL;
} }
@@ -458,23 +458,23 @@ main (int argc,
if (len > 0) if (len > 0)
{ {
/* Evaluate the line */ /* Evaluate the line */
jerry_api_value_t ret_val; jerry_value_t ret_val;
ret_code = jerry_api_eval (buffer, len, false, false, &ret_val); ret_code = jerry_eval (buffer, len, false, false, &ret_val);
/* Print return value */ /* Print return value */
const jerry_api_value_t args[] = { ret_val }; const jerry_value_t args[] = { ret_val };
jerry_api_value_t ret_val_print; jerry_value_t ret_val_print;
if (jerry_api_call_function (print_function.u.v_object, NULL, &ret_val_print, args, 1)) 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_release_object (global_obj_p);
jerry_api_release_value (&print_function); jerry_release_value (&print_function);
} }
#ifdef JERRY_ENABLE_LOG #ifdef JERRY_ENABLE_LOG
@@ -492,33 +492,33 @@ main (int argc,
} }
else if (ret_code == JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION) 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) if (err_obj_p != NULL)
{ {
jerry_api_value_t err_value = jerry_api_create_object_value (err_obj_p); jerry_value_t err_value = jerry_create_object_value (err_obj_p);
err_str_p = jerry_api_value_to_string (&err_value); err_str_p = jerry_value_to_string (&err_value);
jerry_api_release_object (err_obj_p); 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); err_str_p = jerry_value_to_string (&err_value);
jerry_api_release_value (&err_value); jerry_release_value (&err_value);
} }
if (__builtin_expect (!!(err_str_p != NULL), 1)) 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); 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); assert (sz == err_str_size);
err_str_buf[err_str_size] = 0; err_str_buf[err_str_size] = 0;
jerry_port_errormsg ("Script Error: unhandled exception: %s\n", err_str_buf); 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 (); jerry_cleanup ();
tests/unit/test-api.c
+251 -250
View File
@@ -1,4 +1,5 @@
/* Copyright 2015-2016 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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with 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 * Initialize Jerry API value with specified boolean value
*/ */
static void 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 */ 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; out_value_p->u.v_bool = v;
} /* test_api_init_api_value_bool */ } /* 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 * Initialize Jerry API value with specified float64 number
*/ */
static void 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 */ 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; out_value_p->u.v_float64 = v;
} /* test_api_init_api_value_float64 */ } /* 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 * Initialize Jerry API value with specified string
*/ */
static void 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 */ const char *v) /**< string value to initialize with */
{ {
out_value_p->type = JERRY_API_DATA_TYPE_STRING; out_value_p->type = JERRY_DATA_TYPE_STRING;
out_value_p->u.v_string = jerry_api_create_string ((jerry_api_char_t *) v); out_value_p->u.v_string = jerry_create_string ((jerry_char_t *) v);
} /* test_api_init_api_value_string */ } /* test_api_init_api_value_string */
/** /**
* Initialize Jerry API value with specified object * Initialize Jerry API value with specified object
*/ */
static void static void
test_api_init_api_value_object (jerry_api_value_t *out_value_p, /**< out: API value */ test_api_init_api_value_object (jerry_value_t *out_value_p, /**< out: API value */
jerry_api_object_t *v) /**< object value to initialize with */ 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; out_value_p->u.v_object = v;
} /* test_api_init_api_value_object */ } /* test_api_init_api_value_object */
static bool static bool
handler (const jerry_api_object_t *function_obj_p, handler (const jerry_object_t *function_obj_p,
const jerry_api_value_t *this_p, const jerry_value_t *this_p,
jerry_api_value_t *ret_val_p, jerry_value_t *ret_val_p,
const jerry_api_value_t args_p[], const jerry_value_t args_p[],
const jerry_api_length_t args_cnt) const jerry_length_t args_cnt)
{ {
char buffer[32]; 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); 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_cnt == 2);
JERRY_ASSERT (args_p[0].type == JERRY_API_DATA_TYPE_STRING); JERRY_ASSERT (args_p[0].type == JERRY_DATA_TYPE_STRING);
sz = jerry_api_get_string_size (args_p[0].u.v_string); sz = jerry_get_string_size (args_p[0].u.v_string);
JERRY_ASSERT (sz == 1); 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 (sz == 1);
JERRY_ASSERT (!strncmp (buffer, "1", (size_t) sz)); 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); JERRY_ASSERT (args_p[1].u.v_bool == true);
test_api_init_api_value_string (ret_val_p, "string from handler"); 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 */ } /* handler */
static bool static bool
handler_throw_test (const jerry_api_object_t *function_obj_p, handler_throw_test (const jerry_object_t *function_obj_p,
const jerry_api_value_t *this_p, const jerry_value_t *this_p,
jerry_api_value_t *ret_val_p, jerry_value_t *ret_val_p,
const jerry_api_value_t args_p[], const jerry_value_t args_p[],
const jerry_api_length_t args_cnt) 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); 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_object_t *error_p = jerry_create_error (JERRY_ERROR_TYPE,
(jerry_api_char_t *) "error"); (jerry_char_t *) "error");
test_api_init_api_value_object (ret_val_p, error_p); test_api_init_api_value_object (ret_val_p, error_p);
jerry_api_release_object (error_p); jerry_release_object (error_p);
return false; return false;
} /* handler_throw_test */ } /* handler_throw_test */
@@ -166,35 +167,35 @@ handler_construct_freecb (uintptr_t native_p)
} /* handler_construct_freecb */ } /* handler_construct_freecb */
static bool static bool
handler_construct (const jerry_api_object_t *function_obj_p, handler_construct (const jerry_object_t *function_obj_p,
const jerry_api_value_t *this_p, const jerry_value_t *this_p,
jerry_api_value_t *ret_val_p, jerry_value_t *ret_val_p,
const jerry_api_value_t args_p[], const jerry_value_t args_p[],
const jerry_api_length_t args_cnt) 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); 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 != 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_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_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, jerry_set_object_native_handle (this_p->u.v_object,
(uintptr_t) 0x0000000000000000ull, (uintptr_t) 0x0000000000000000ull,
handler_construct_freecb); handler_construct_freecb);
uintptr_t ptr; 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); JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0000000000000000ull);
/* check if setting handle for second time is handled correctly */ /* check if setting handle for second time is handled correctly */
jerry_api_set_object_native_handle (this_p->u.v_object, jerry_set_object_native_handle (this_p->u.v_object,
(uintptr_t) 0x0012345678abcdefull, (uintptr_t) 0x0012345678abcdefull,
handler_construct_freecb); handler_construct_freecb);
return true; return true;
} /* handler_construct */ } /* handler_construct */
@@ -215,66 +216,66 @@ JERRY_MAGIC_STRING_ITEMS
#undef JERRY_MAGIC_STRING_DEF #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) \ #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 JERRY_MAGIC_STRING_ITEMS
#undef JERRY_MAGIC_STRING_DEF #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) \ #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 JERRY_MAGIC_STRING_ITEMS
#undef JERRY_MAGIC_STRING_DEF #undef JERRY_MAGIC_STRING_DEF
}; };
static bool foreach (const jerry_api_string_t *name, static bool foreach (const jerry_string_t *name,
const jerry_api_value_t *value, void *user_data) const jerry_value_t *value, void *user_data)
{ {
char str_buf_p[128]; 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'; str_buf_p[sz] = '\0';
if (!strncmp (str_buf_p, "alpha", (size_t) sz)) if (!strncmp (str_buf_p, "alpha", (size_t) sz))
{ {
#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 #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); JERRY_ASSERT (value->v_float32 == 32.0f);
#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 #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); JERRY_ASSERT (value->u.v_float64 == 32.0);
#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */ #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
} }
else if (!strncmp (str_buf_p, "bravo", (size_t) sz)) 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); JERRY_ASSERT (value->u.v_bool == false);
} }
else if (!strncmp (str_buf_p, "charlie", (size_t) sz)) 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)) else if (!strncmp (str_buf_p, "delta", (size_t) sz))
{ {
#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 #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); JERRY_ASSERT (value->v_float32 == 123.45f);
#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 #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); JERRY_ASSERT (value->u.v_float64 == 123.45);
#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */ #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
} }
else if (!strncmp (str_buf_p, "echo", (size_t) sz)) else if (!strncmp (str_buf_p, "echo", (size_t) sz))
{ {
JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_STRING); JERRY_ASSERT (value->type == JERRY_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_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'; str_buf_p[echo_sz] = '\0';
JERRY_ASSERT (!strncmp (str_buf_p, "foobar", (size_t) echo_sz)); 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) #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 (value);
UNUSED (user_data); UNUSED (user_data);
char str_buf_p[128]; 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'; str_buf_p[sz] = '\0';
if (!strncmp (str_buf_p, "foxtrot", (size_t) sz)) 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; return true;
} /* foreach_exception */ } /* 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 (name);
UNUSED (value); UNUSED (value);
@@ -326,357 +327,357 @@ main (void)
jerry_init (JERRY_FLAG_EMPTY); jerry_init (JERRY_FLAG_EMPTY);
bool is_ok, is_exception; bool is_ok, is_exception;
jerry_api_size_t sz; jerry_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_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_value_t val_external, val_external_construct, val_call_external;
jerry_api_object_t *global_obj_p, *obj_p; jerry_object_t *global_obj_p, *obj_p;
jerry_api_object_t *external_func_p, *external_construct_p; jerry_object_t *external_func_p, *external_construct_p;
jerry_api_object_t *throw_test_handler_p; jerry_object_t *throw_test_handler_p;
jerry_api_object_t *err_obj_p = NULL; jerry_object_t *err_obj_p = NULL;
jerry_api_value_t res, args[2]; jerry_value_t res, args[2];
char buffer[32]; 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); JERRY_ASSERT (is_ok && err_obj_p == NULL);
is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK); is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (is_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], ""); 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_ASSERT (sz == 0);
jerry_api_release_value (&args[0]); jerry_release_value (&args[0]);
// Get global.boo (non-existing field) // 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 (!is_ok);
JERRY_ASSERT (val_t.type == JERRY_API_DATA_TYPE_UNDEFINED); JERRY_ASSERT (val_t.type == JERRY_DATA_TYPE_UNDEFINED);
// Get global.t // 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 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); && val_t.u.v_float64 == 1.0);
jerry_api_release_value (&val_t); jerry_release_value (&val_t);
// Get global.foo // 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 JERRY_ASSERT (is_ok
&& val_foo.type == JERRY_API_DATA_TYPE_OBJECT); && val_foo.type == JERRY_DATA_TYPE_OBJECT);
// Call foo (4, 2) // Call foo (4, 2)
test_api_init_api_value_float64 (&args[0], 4); test_api_init_api_value_float64 (&args[0], 4);
test_api_init_api_value_float64 (&args[1], 2); 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 JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_FLOAT64 && res.type == JERRY_DATA_TYPE_FLOAT64
&& res.u.v_float64 == 1.0); && res.u.v_float64 == 1.0);
jerry_api_release_value (&res); jerry_release_value (&res);
// Get global.bar // 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 JERRY_ASSERT (is_ok
&& val_bar.type == JERRY_API_DATA_TYPE_OBJECT); && val_bar.type == JERRY_DATA_TYPE_OBJECT);
// Call bar (4, 2) // 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 JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_FLOAT64 && res.type == JERRY_DATA_TYPE_FLOAT64
&& res.u.v_float64 == 5.0); && res.u.v_float64 == 5.0);
jerry_api_release_value (&res); jerry_release_value (&res);
jerry_api_release_value (&val_bar); jerry_release_value (&val_bar);
// Set global.t = "abcd" // Set global.t = "abcd"
test_api_init_api_value_string (&args[0], "abcd"); test_api_init_api_value_string (&args[0], "abcd");
is_ok = jerry_api_set_object_field_value (global_obj_p, is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_api_char_t *)"t", (jerry_char_t *)"t",
&args[0]); &args[0]);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_api_release_value (&args[0]); jerry_release_value (&args[0]);
// Call foo (4, 2) // 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 JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_STRING); && res.type == JERRY_DATA_TYPE_STRING);
sz = jerry_api_get_string_size (res.u.v_string); sz = jerry_get_string_size (res.u.v_string);
JERRY_ASSERT (sz == 4); 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_ASSERT (sz == 4);
jerry_api_release_value (&res); jerry_release_value (&res);
JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz)); JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz));
// Get global.A // 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 JERRY_ASSERT (is_ok
&& val_A.type == JERRY_API_DATA_TYPE_OBJECT); && val_A.type == JERRY_DATA_TYPE_OBJECT);
// Get A.prototype // 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); JERRY_ASSERT (is_ok);
is_ok = jerry_api_get_object_field_value (val_A.u.v_object, is_ok = jerry_get_object_field_value (val_A.u.v_object,
(jerry_api_char_t *) "prototype", (jerry_char_t *) "prototype",
&val_A_prototype); &val_A_prototype);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok
&& val_A_prototype.type == JERRY_API_DATA_TYPE_OBJECT); && val_A_prototype.type == JERRY_DATA_TYPE_OBJECT);
jerry_api_release_value (&val_A); jerry_release_value (&val_A);
// Set A.prototype.foo = global.foo // Set A.prototype.foo = global.foo
is_ok = jerry_api_set_object_field_value (val_A_prototype.u.v_object, is_ok = jerry_set_object_field_value (val_A_prototype.u.v_object,
(jerry_api_char_t *) "foo", (jerry_char_t *) "foo",
&val_foo); &val_foo);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_A_prototype); jerry_release_value (&val_A_prototype);
jerry_api_release_value (&val_foo); jerry_release_value (&val_foo);
// Get global.a // 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 JERRY_ASSERT (is_ok
&& val_a.type == JERRY_API_DATA_TYPE_OBJECT); && val_a.type == JERRY_DATA_TYPE_OBJECT);
// Get a.t // 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 JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_FLOAT64 && res.type == JERRY_DATA_TYPE_FLOAT64
&& res.u.v_float64 == 12.0); && res.u.v_float64 == 12.0);
jerry_api_release_value (&res); jerry_release_value (&res);
// foreach properties // foreach properties
jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "p", &val_p); jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "p", &val_p);
is_ok = jerry_api_foreach_object_field (val_p.u.v_object, foreach, (void *) "user_data"); is_ok = jerry_foreach_object_field (val_p.u.v_object, foreach, (void *) "user_data");
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
// break foreach at third element // break foreach at third element
int count = 0; 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 (is_ok);
JERRY_ASSERT (count == 3); JERRY_ASSERT (count == 3);
jerry_api_release_value (&val_p); jerry_release_value (&val_p);
// foreach with throw test // foreach with throw test
jerry_api_get_object_field_value (global_obj_p, (jerry_api_char_t *) "np", &val_np); jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "np", &val_np);
is_ok = !jerry_api_foreach_object_field (val_np.u.v_object, foreach_exception, NULL); is_ok = !jerry_foreach_object_field (val_np.u.v_object, foreach_exception, NULL);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_np); jerry_release_value (&val_np);
// Get a.foo // 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 JERRY_ASSERT (is_ok
&& val_a_foo.type == JERRY_API_DATA_TYPE_OBJECT); && val_a_foo.type == JERRY_DATA_TYPE_OBJECT);
// Call a.foo () // 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 JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_FLOAT64 && res.type == JERRY_DATA_TYPE_FLOAT64
&& res.u.v_float64 == 12.0); && res.u.v_float64 == 12.0);
jerry_api_release_value (&res); jerry_release_value (&res);
jerry_api_release_value (&val_a_foo); 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 // 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_ASSERT (external_func_p != NULL
&& jerry_api_is_function (external_func_p) && jerry_is_function (external_func_p)
&& jerry_api_is_constructor (external_func_p)); && jerry_is_constructor (external_func_p));
test_api_init_api_value_object (&val_external, 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, is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_api_char_t *) "external", (jerry_char_t *) "external",
&val_external); &val_external);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_external); jerry_release_value (&val_external);
jerry_api_release_object (external_func_p); jerry_release_object (external_func_p);
// Call 'call_external' function that should call external function created above // 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 JERRY_ASSERT (is_ok
&& val_call_external.type == JERRY_API_DATA_TYPE_OBJECT); && val_call_external.type == JERRY_DATA_TYPE_OBJECT);
is_ok = jerry_api_call_function (val_call_external.u.v_object, is_ok = jerry_call_function (val_call_external.u.v_object,
global_obj_p, global_obj_p,
&res, &res,
NULL, 0); NULL, 0);
jerry_api_release_value (&val_call_external); jerry_release_value (&val_call_external);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_STRING); && res.type == JERRY_DATA_TYPE_STRING);
sz = jerry_api_get_string_size (res.u.v_string); sz = jerry_get_string_size (res.u.v_string);
JERRY_ASSERT (sz == 19); 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_ASSERT (sz == 19);
jerry_api_release_value (&res); jerry_release_value (&res);
JERRY_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz)); JERRY_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz));
// Create native handler bound function object and set it to 'external_construct' variable // 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_ASSERT (external_construct_p != NULL
&& jerry_api_is_function (external_construct_p) && jerry_is_function (external_construct_p)
&& jerry_api_is_constructor (external_construct_p)); && jerry_is_constructor (external_construct_p));
test_api_init_api_value_object (&val_external_construct, 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, is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_api_char_t *) "external_construct", (jerry_char_t *) "external_construct",
&val_external_construct); &val_external_construct);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_external_construct); jerry_release_value (&val_external_construct);
jerry_api_release_object (external_construct_p); jerry_release_object (external_construct_p);
// Call external function created above, as constructor // Call external function created above, as constructor
test_api_init_api_value_bool (&args[0], true); 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 JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_OBJECT); && res.type == JERRY_DATA_TYPE_OBJECT);
is_ok = jerry_api_get_object_field_value (res.u.v_object, is_ok = jerry_get_object_field_value (res.u.v_object,
(jerry_api_char_t *)"value_field", (jerry_char_t *)"value_field",
&val_value_field); &val_value_field);
// Get 'value_field' of constructed object // Get 'value_field' of constructed object
JERRY_ASSERT (is_ok 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); && val_value_field.u.v_bool == true);
jerry_api_release_value (&val_value_field); jerry_release_value (&val_value_field);
uintptr_t ptr; 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 JERRY_ASSERT (is_ok
&& ptr == (uintptr_t) 0x0012345678abcdefull); && ptr == (uintptr_t) 0x0012345678abcdefull);
jerry_api_release_value (&res); jerry_release_value (&res);
// Test: Throwing exception from native handler. // 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_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); test_api_init_api_value_object (&val_t, throw_test_handler_p);
is_ok = jerry_api_set_object_field_value (global_obj_p, is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_api_char_t *) "throw_test", (jerry_char_t *) "throw_test",
&val_t); &val_t);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_t); jerry_release_value (&val_t);
jerry_api_release_object (throw_test_handler_p); 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 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, is_ok = jerry_call_function (val_t.u.v_object,
global_obj_p, global_obj_p,
&res, &res,
NULL, 0); NULL, 0);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_api_release_value (&val_t); jerry_release_value (&val_t);
jerry_api_release_value (&res); jerry_release_value (&res);
// Test: Unhandled exception in called function // 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 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, is_ok = jerry_call_function (val_t.u.v_object,
global_obj_p, global_obj_p,
&res, &res,
NULL, 0); NULL, 0);
is_exception = !is_ok; is_exception = !is_ok;
JERRY_ASSERT (is_exception); JERRY_ASSERT (is_exception);
jerry_api_release_value (&val_t); jerry_release_value (&val_t);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT);
jerry_api_release_value (&res); jerry_release_value (&res);
// Test: Call of non-function // Test: Call of non-function
obj_p = jerry_api_create_object (); obj_p = jerry_create_object ();
is_ok = jerry_api_call_function (obj_p, is_ok = jerry_call_function (obj_p,
global_obj_p, global_obj_p,
&res, &res,
NULL, 0); NULL, 0);
is_exception = !is_ok; is_exception = !is_ok;
JERRY_ASSERT (is_exception); JERRY_ASSERT (is_exception);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT);
jerry_api_release_value (&res); jerry_release_value (&res);
jerry_api_release_object (obj_p); jerry_release_object (obj_p);
// Test: Unhandled exception in function called, as constructor // 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 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, is_ok = jerry_construct_object (val_t.u.v_object,
&res, &res,
NULL, 0); NULL, 0);
is_exception = !is_ok; is_exception = !is_ok;
JERRY_ASSERT (is_exception); JERRY_ASSERT (is_exception);
jerry_api_release_value (&val_t); jerry_release_value (&val_t);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT);
jerry_api_release_value (&res); jerry_release_value (&res);
// Test: Call of non-function as constructor // Test: Call of non-function as constructor
obj_p = jerry_api_create_object (); obj_p = jerry_create_object ();
is_ok = jerry_api_construct_object (obj_p, is_ok = jerry_construct_object (obj_p,
&res, &res,
NULL, 0); NULL, 0);
is_exception = !is_ok; is_exception = !is_ok;
JERRY_ASSERT (is_exception); JERRY_ASSERT (is_exception);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_API_DATA_TYPE_OBJECT); JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT);
jerry_api_release_value (&res); jerry_release_value (&res);
jerry_api_release_object (obj_p); jerry_release_object (obj_p);
// Test: Array Object API // 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); test_api_init_api_value_float64 (&v_in, 10.5);
jerry_api_set_array_index_value (array_obj_p, 5, &v_in); jerry_set_array_index_value (array_obj_p, 5, &v_in);
jerry_api_value_t v_out; jerry_value_t v_out;
jerry_api_get_array_index_value (array_obj_p, 5, &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 // Test: eval
const char *eval_code_src_p = "(function () { return 123; })"; 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, jerry_completion_code_t status = jerry_eval ((jerry_char_t *) eval_code_src_p,
strlen (eval_code_src_p), strlen (eval_code_src_p),
false, false,
true, true,
&val_t); &val_t);
JERRY_ASSERT (status == JERRY_COMPLETION_CODE_OK); JERRY_ASSERT (status == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (val_t.type == JERRY_API_DATA_TYPE_OBJECT); JERRY_ASSERT (val_t.type == JERRY_DATA_TYPE_OBJECT);
JERRY_ASSERT (jerry_api_is_function (val_t.u.v_object)); JERRY_ASSERT (jerry_is_function (val_t.u.v_object));
is_ok = jerry_api_call_function (val_t.u.v_object, is_ok = jerry_call_function (val_t.u.v_object,
NULL, NULL,
&res, &res,
NULL, 0); NULL, 0);
JERRY_ASSERT (is_ok); 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); && 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. // cleanup.
jerry_api_release_object (global_obj_p); jerry_release_object (global_obj_p);
// TEST: run gc. // TEST: run gc.
jerry_api_gc (); jerry_gc ();
jerry_cleanup (); jerry_cleanup ();
@@ -685,18 +686,18 @@ main (void)
// External Magic String // External Magic String
jerry_init (JERRY_FLAG_SHOW_OPCODES); 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, jerry_register_external_magic_strings (magic_string_items,
num_magic_string_items, num_magic_string_items,
magic_string_lengths); magic_string_lengths);
const char *ms_code_src_p = "var global = {}; var console = [1]; var process = 1;"; 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); JERRY_ASSERT (is_ok && err_obj_p == NULL);
is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK); is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
JERRY_ASSERT (jerry_api_value_is_void (&res)); JERRY_ASSERT (jerry_value_is_void (&res));
jerry_cleanup (); jerry_cleanup ();
@@ -710,7 +711,7 @@ main (void)
const char *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();"; const char *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();";
jerry_init (JERRY_FLAG_SHOW_OPCODES); 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), strlen (code_to_snapshot_p),
true, true,
global_mode_snapshot_buffer, global_mode_snapshot_buffer,
@@ -719,7 +720,7 @@ main (void)
jerry_cleanup (); jerry_cleanup ();
jerry_init (JERRY_FLAG_SHOW_OPCODES); 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), strlen (code_to_snapshot_p),
false, false,
eval_mode_snapshot_buffer, eval_mode_snapshot_buffer,
@@ -735,8 +736,8 @@ main (void)
&res) == JERRY_COMPLETION_CODE_OK); &res) == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_UNDEFINED); && res.type == JERRY_DATA_TYPE_UNDEFINED);
jerry_api_release_value (&res); jerry_release_value (&res);
is_ok = (jerry_exec_snapshot (eval_mode_snapshot_buffer, is_ok = (jerry_exec_snapshot (eval_mode_snapshot_buffer,
eval_mode_snapshot_size, eval_mode_snapshot_size,
@@ -744,12 +745,12 @@ main (void)
&res) == JERRY_COMPLETION_CODE_OK); &res) == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok
&& res.type == JERRY_API_DATA_TYPE_STRING); && res.type == JERRY_DATA_TYPE_STRING);
sz = jerry_api_get_string_size (res.u.v_string); sz = jerry_get_string_size (res.u.v_string);
JERRY_ASSERT (sz == 20); 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_ASSERT (sz == 20);
jerry_api_release_value (&res); jerry_release_value (&res);
JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz)); JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz));
jerry_cleanup (); jerry_cleanup ();
tests/unit/test-string-to-number.c
+21 -20
View File
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with 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 (); TEST_INIT ();
const jerry_api_char_t *strings[] = const jerry_char_t *strings[] =
{ {
(const jerry_api_char_t *) "1", (const jerry_char_t *) "1",
(const jerry_api_char_t *) "0.5", (const jerry_char_t *) "0.5",
(const jerry_api_char_t *) "12345", (const jerry_char_t *) "12345",
(const jerry_api_char_t *) "1e-45", (const jerry_char_t *) "1e-45",
(const jerry_api_char_t *) "-2.5e+38", (const jerry_char_t *) "-2.5e+38",
(const jerry_api_char_t *) "-2.5e38", (const jerry_char_t *) "-2.5e38",
(const jerry_api_char_t *) "- 2.5e+38", (const jerry_char_t *) "- 2.5e+38",
(const jerry_api_char_t *) "-2 .5e+38", (const jerry_char_t *) "-2 .5e+38",
(const jerry_api_char_t *) "-2. 5e+38", (const jerry_char_t *) "-2. 5e+38",
(const jerry_api_char_t *) "-2.5e+ 38", (const jerry_char_t *) "-2.5e+ 38",
(const jerry_api_char_t *) "-2.5 e+38", (const jerry_char_t *) "-2.5 e+38",
(const jerry_api_char_t *) "-2.5e +38", (const jerry_char_t *) "-2.5e +38",
(const jerry_api_char_t *) "NaN", (const jerry_char_t *) "NaN",
(const jerry_api_char_t *) "abc", (const jerry_char_t *) "abc",
(const jerry_api_char_t *) " Infinity ", (const jerry_char_t *) " Infinity ",
(const jerry_api_char_t *) "-Infinity", (const jerry_char_t *) "-Infinity",
(const jerry_api_char_t *) "0", (const jerry_char_t *) "0",
(const jerry_api_char_t *) "0", (const jerry_char_t *) "0",
}; };
const ecma_number_t nums[] = const ecma_number_t nums[] =