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

Use 'ecma_value_t' in API too

Browse Source 
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-09 15:43:26 +02:00
parent b828d4a463
commit a816ab8bb0
7 changed files with 364 additions and 750 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/ecma/operations/ecma-function-object.c
+2 -7
View File
@@ -655,16 +655,11 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
&handler_p); &handler_p);
JERRY_ASSERT (is_retrieved); JERRY_ASSERT (is_retrieved);
ecma_collection_header_t *arg_collection_p = ecma_new_values_collection (arguments_list_p,
arguments_list_len,
true);
ret_value = jerry_dispatch_external_function (func_obj_p, ret_value = jerry_dispatch_external_function (func_obj_p,
handler_p, handler_p,
this_arg_value, this_arg_value,
arg_collection_p); arguments_list_p,
arguments_list_len);
ecma_free_values_collection (arg_collection_p, true);
} }
else else
{ {
jerry-core/jerry-api.h
+27 -61
View File
@@ -42,22 +42,6 @@ typedef enum
JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT = 3, /**< snapshot format is not valid */ JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT = 3, /**< snapshot format is not valid */
} jerry_completion_code_t; } jerry_completion_code_t;
/**
* Jerry API data types
*/
typedef enum
{
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 * Jerry API Error object types
*/ */
@@ -103,32 +87,15 @@ typedef struct ecma_string_t jerry_string_t;
typedef struct ecma_object_t jerry_object_t; typedef struct ecma_object_t jerry_object_t;
/** /**
* Description of an extension function's argument * Description of a JerryScript value
*/ */
typedef struct jerry_value_t typedef uint32_t jerry_value_t;
{
jerry_data_type_t type; /**< argument data type */
union
{
bool v_bool; /**< boolean */
float v_float32; /**< 32-bit float */
double v_float64; /**< 64-bit float */
uint32_t v_uint32; /**< number converted 32-bit unsigned integer */
jerry_string_t *v_string; /**< pointer to a JS string */
jerry_object_t *v_object; /**< pointer to a JS object */
} u;
} jerry_value_t;
/** /**
* Type of an external function handler * Type of an external function handler
*/ */
typedef bool (*jerry_external_handler_t) (const jerry_object_t *function_obj_p, typedef bool (*jerry_external_handler_t) (const jerry_object_t *function_obj_p,
const jerry_value_t *this_p, const jerry_value_t this_val,
jerry_value_t *ret_val_p, jerry_value_t *ret_val_p,
const jerry_value_t args_p[], const jerry_value_t args_p[],
const jerry_length_t args_count); const jerry_length_t args_count);
@@ -142,7 +109,7 @@ 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_string_t *field_name_p, typedef bool (*jerry_object_field_foreach_t) (const jerry_string_t *field_name_p,
const jerry_value_t *field_value_p, const jerry_value_t field_value_p,
void *user_data_p); void *user_data_p);
/** /**
@@ -153,52 +120,51 @@ jerry_object_t *jerry_get_global (void);
/** /**
* Checker functions of 'jerry_value_t' * Checker functions of 'jerry_value_t'
*/ */
bool jerry_value_is_void (const jerry_value_t *value_p); bool jerry_value_is_boolean (const jerry_value_t);
bool jerry_value_is_null (const jerry_value_t *value_p); bool jerry_value_is_error (const jerry_value_t);
bool jerry_value_is_undefined (const jerry_value_t *value_p); bool jerry_value_is_function (const jerry_value_t);
bool jerry_value_is_boolean (const jerry_value_t *value_p); bool jerry_value_is_number (const jerry_value_t);
bool jerry_value_is_number (const jerry_value_t *value_p); bool jerry_value_is_null (const jerry_value_t);
bool jerry_value_is_string (const jerry_value_t *value_p); bool jerry_value_is_object (const jerry_value_t);
bool jerry_value_is_object (const jerry_value_t *value_p); bool jerry_value_is_string (const jerry_value_t);
bool jerry_value_is_function (const jerry_value_t *value_p); bool jerry_value_is_undefined (const jerry_value_t);
/** /**
* Getter functions of 'jerry_value_t' * Getter functions of 'jerry_value_t'
*/ */
bool jerry_get_boolean_value (const jerry_value_t *value_p); bool jerry_get_boolean_value (const jerry_value_t);
double jerry_get_number_value (const jerry_value_t *value_p); double jerry_get_number_value (const jerry_value_t);
jerry_string_t *jerry_get_string_value (const jerry_value_t *value_p); jerry_string_t *jerry_get_string_value (const jerry_value_t);
jerry_object_t *jerry_get_object_value (const jerry_value_t *value_p); jerry_object_t *jerry_get_object_value (const jerry_value_t);
/** /**
* Converters of 'jerry_value_t' * Converters of 'jerry_value_t'
*/ */
jerry_string_t *jerry_value_to_string (const jerry_value_t *); jerry_value_t jerry_value_to_string (const jerry_value_t);
/** /**
* Create functions of 'jerry_value_t' * Create functions of 'jerry_value_t'
*/ */
jerry_value_t jerry_create_void_value (void);
jerry_value_t jerry_create_null_value (void); jerry_value_t jerry_create_null_value (void);
jerry_value_t jerry_create_undefined_value (void); jerry_value_t jerry_create_undefined_value (void);
jerry_value_t jerry_create_boolean_value (bool value); jerry_value_t jerry_create_boolean_value (bool);
jerry_value_t jerry_create_number_value (double value); jerry_value_t jerry_create_number_value (double);
jerry_value_t jerry_create_object_value (jerry_object_t *value); jerry_value_t jerry_create_object_value (jerry_object_t *);
jerry_value_t jerry_create_string_value (jerry_string_t *value); jerry_value_t jerry_create_string_value (jerry_string_t *);
/** /**
* Acquire types with reference counter (increase the references) * Acquire types with reference counter (increase the references)
*/ */
jerry_string_t *jerry_acquire_string (jerry_string_t *); jerry_string_t *jerry_acquire_string (jerry_string_t *);
jerry_object_t *jerry_acquire_object (jerry_object_t *); jerry_object_t *jerry_acquire_object (jerry_object_t *);
jerry_value_t *jerry_acquire_value (jerry_value_t *); jerry_value_t jerry_acquire_value (jerry_value_t);
/** /**
* Relase the referenced values * Relase the referenced values
*/ */
void jerry_release_object (jerry_object_t *); void jerry_release_object (jerry_object_t *);
void jerry_release_string (jerry_string_t *); void jerry_release_string (jerry_string_t *);
void jerry_release_value (jerry_value_t *); void jerry_release_value (jerry_value_t);
/** /**
* Create functions of API objects * Create functions of API objects
@@ -214,7 +180,7 @@ jerry_string_t *jerry_create_string_sz (const jerry_char_t *, jerry_size_t);
/** /**
* Functions of array objects * Functions of array objects
*/ */
bool jerry_set_array_index_value (jerry_object_t *, jerry_length_t, jerry_value_t *); 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 *); bool jerry_get_array_index_value (jerry_object_t *, jerry_length_t, jerry_value_t *);
/** /**
@@ -229,12 +195,12 @@ jerry_size_t jerry_string_to_char_buffer (const jerry_string_t *, jerry_char_t *
*/ */
bool jerry_is_constructor (const jerry_object_t *); bool jerry_is_constructor (const jerry_object_t *);
bool jerry_is_function (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_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_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 (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_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 (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_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_foreach_object_field (jerry_object_t *, jerry_object_field_foreach_t, void *);
bool jerry_get_object_native_handle (jerry_object_t *, uintptr_t *); 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); void jerry_set_object_native_handle (jerry_object_t *, uintptr_t, jerry_object_free_callback_t);
jerry-core/jerry-internal.h
+5 -1
View File
@@ -24,7 +24,11 @@
#include "jerry-api.h" #include "jerry-api.h"
extern ecma_value_t extern ecma_value_t
jerry_dispatch_external_function (ecma_object_t *, ecma_external_pointer_t, ecma_value_t, ecma_collection_header_t *); jerry_dispatch_external_function (ecma_object_t *,
ecma_external_pointer_t,
ecma_value_t,
const ecma_value_t *,
ecma_length_t);
extern void extern void
jerry_dispatch_object_free_callback (ecma_external_pointer_t, ecma_external_pointer_t); jerry_dispatch_object_free_callback (ecma_external_pointer_t, ecma_external_pointer_t);
jerry-core/jerry.c
+94 -405
View File
@@ -124,40 +124,31 @@ jerry_make_api_unavailable (void)
jerry_api_available = false; jerry_api_available = false;
} /* jerry_make_api_unavailable */ } /* jerry_make_api_unavailable */
/**
* Returns whether the given jerry_value_t is void.
*/
bool
jerry_value_is_void (const jerry_value_t *value_p) /**< pointer to api value */
{
return value_p->type == JERRY_DATA_TYPE_VOID;
} /* jerry_value_is_void */
/** /**
* Returns whether the given jerry_value_t is null. * Returns whether the given jerry_value_t is null.
*/ */
bool bool
jerry_value_is_null (const jerry_value_t *value_p) /**< pointer to api value */ jerry_value_is_null (const jerry_value_t value) /**< api value */
{ {
return value_p->type == JERRY_DATA_TYPE_NULL; return ecma_is_value_null (value);
} /* jerry_value_is_null */ } /* jerry_value_is_null */
/** /**
* Returns whether the given jerry_value_t is undefined. * Returns whether the given jerry_value_t is undefined.
*/ */
bool bool
jerry_value_is_undefined (const jerry_value_t *value_p) /**< pointer to api value */ jerry_value_is_undefined (const jerry_value_t value) /**< api value */
{ {
return value_p->type == JERRY_DATA_TYPE_UNDEFINED; return ecma_is_value_undefined (value);
} /* jerry_value_is_undefined */ } /* jerry_value_is_undefined */
/** /**
* Returns whether the given jerry_value_t has boolean type. * Returns whether the given jerry_value_t has boolean type.
*/ */
bool bool
jerry_value_is_boolean (const jerry_value_t *value_p) /**< pointer to api value */ jerry_value_is_boolean (const jerry_value_t value) /**< api value */
{ {
return value_p->type == JERRY_DATA_TYPE_BOOLEAN; return ecma_is_value_boolean (value);
} /* jerry_value_is_boolean */ } /* jerry_value_is_boolean */
/** /**
@@ -167,43 +158,36 @@ jerry_value_is_boolean (const jerry_value_t *value_p) /**< pointer to api value
* JERRY_DATA_TYPE_FLOAT64 or JERRY_DATA_TYPE_UINT32, false otherwise. * JERRY_DATA_TYPE_FLOAT64 or JERRY_DATA_TYPE_UINT32, false otherwise.
*/ */
bool bool
jerry_value_is_number (const jerry_value_t *value_p) /**< pointer to api value */ jerry_value_is_number (const jerry_value_t value) /**< api value */
{ {
return value_p->type == JERRY_DATA_TYPE_FLOAT32 return ecma_is_value_number (value);
|| value_p->type == JERRY_DATA_TYPE_FLOAT64
|| value_p->type == JERRY_DATA_TYPE_UINT32;
} /* jerry_value_is_number */ } /* jerry_value_is_number */
/** /**
* Returns whether the given jerry_value_t is string. * Returns whether the given jerry_value_t is string.
*/ */
bool bool
jerry_value_is_string (const jerry_value_t *value_p) /**< pointer to api value */ jerry_value_is_string (const jerry_value_t value) /**< api value */
{ {
return value_p->type == JERRY_DATA_TYPE_STRING; return ecma_is_value_string (value);
} /* jerry_value_is_string */ } /* jerry_value_is_string */
/** /**
* Returns whether the given jerry_value_t is object. * Returns whether the given jerry_value_t is object.
*/ */
bool bool
jerry_value_is_object (const jerry_value_t *value_p) /**< pointer to api value */ jerry_value_is_object (const jerry_value_t value) /**< api value */
{ {
return value_p->type == JERRY_DATA_TYPE_OBJECT; return ecma_is_value_object (value);
} /* jerry_value_is_object */ } /* jerry_value_is_object */
/** /**
* Returns whether the given jerry_value_t is a function object. * Returns whether the given jerry_value_t is a function object.
*
* 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 bool
jerry_value_is_function (const jerry_value_t *value_p) /**< pointer to api value */ jerry_value_is_function (const jerry_value_t value) /**< api value */
{ {
return jerry_value_is_object (value_p) && jerry_is_function (value_p->u.v_object); return ecma_op_is_callable (value);
} /* jerry_value_is_function */ } /* jerry_value_is_function */
/** /**
@@ -212,39 +196,22 @@ jerry_value_is_function (const jerry_value_t *value_p) /**< pointer to api value
* JERRY_DATA_TYPE_BOOLEAN, JERRY_ASSERT fails. * JERRY_DATA_TYPE_BOOLEAN, JERRY_ASSERT fails.
*/ */
bool bool
jerry_get_boolean_value (const jerry_value_t *value_p) /**< pointer to api value */ jerry_get_boolean_value (const jerry_value_t value) /**< api value */
{ {
JERRY_ASSERT (jerry_value_is_boolean (value_p)); JERRY_ASSERT (jerry_value_is_boolean (value));
return value_p->u.v_bool;
return ecma_is_value_true (value);
} /* jerry_get_boolean_value */ } /* jerry_get_boolean_value */
/** /**
* Returns the number value of the given jerry_value_t structure * Returns the number value of the given jerry_value_t structure as a double.
* as a double.
*
* 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_value_t structure has type JERRY_DATA_TYPE_FLOAT32
* v_float32 member will be returned as a double and if tpye is
* 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 double
jerry_get_number_value (const jerry_value_t *value_p) /**< pointer to api value */ jerry_get_number_value (const jerry_value_t value) /**< api value */
{ {
JERRY_ASSERT (jerry_value_is_number (value_p)); JERRY_ASSERT (jerry_value_is_number (value));
if (value_p->type == JERRY_DATA_TYPE_UINT32)
{ return (double) ecma_get_number_from_value (value);
return value_p->u.v_uint32;
}
else if (value_p->type == JERRY_DATA_TYPE_FLOAT32)
{
return value_p->u.v_float32;
}
else
{
return value_p->u.v_float64;
}
} /* jerry_get_number_value */ } /* jerry_get_number_value */
/** /**
@@ -253,10 +220,11 @@ jerry_get_number_value (const jerry_value_t *value_p) /**< pointer to api value
* JERRY_DATA_TYPE_STRING, JERRY_ASSERT fails. * JERRY_DATA_TYPE_STRING, JERRY_ASSERT fails.
*/ */
jerry_string_t * jerry_string_t *
jerry_get_string_value (const jerry_value_t *value_p) /**< pointer to api value */ jerry_get_string_value (const jerry_value_t value) /**< api value */
{ {
JERRY_ASSERT (jerry_value_is_string (value_p)); JERRY_ASSERT (jerry_value_is_string (value));
return value_p->u.v_string;
return ecma_get_string_from_value (value);
} /* jerry_get_string_value */ } /* jerry_get_string_value */
/** /**
@@ -265,23 +233,12 @@ jerry_get_string_value (const jerry_value_t *value_p) /**< pointer to api value
* JERRY_DATA_TYPE_OBJECT, JERRY_ASSERT fails. * JERRY_DATA_TYPE_OBJECT, JERRY_ASSERT fails.
*/ */
jerry_object_t * jerry_object_t *
jerry_get_object_value (const jerry_value_t *value_p) /**< pointer to api value */ jerry_get_object_value (const jerry_value_t value) /**< api value */
{ {
JERRY_ASSERT (jerry_value_is_object (value_p)); JERRY_ASSERT (jerry_value_is_object (value));
return value_p->u.v_object;
} /* jerry_get_object_value */
/** return ecma_get_object_from_value (value);
* Creates and returns a jerry_value_t with type } /* jerry_get_object_value */
* JERRY_DATA_TYPE_VOID.
*/
jerry_value_t
jerry_create_void_value (void)
{
jerry_value_t jerry_val;
jerry_val.type = JERRY_DATA_TYPE_VOID;
return jerry_val;
} /* jerry_create_void_value */
/** /**
* Creates and returns a jerry_value_t with type * Creates and returns a jerry_value_t with type
@@ -290,9 +247,7 @@ jerry_create_void_value (void)
jerry_value_t jerry_value_t
jerry_create_null_value (void) jerry_create_null_value (void)
{ {
jerry_value_t jerry_val; return ecma_make_simple_value (ECMA_SIMPLE_VALUE_NULL);
jerry_val.type = JERRY_DATA_TYPE_NULL;
return jerry_val;
} /* jerry_create_null_value */ } /* jerry_create_null_value */
/** /**
@@ -302,9 +257,7 @@ jerry_create_null_value (void)
jerry_value_t jerry_value_t
jerry_create_undefined_value (void) jerry_create_undefined_value (void)
{ {
jerry_value_t jerry_val; return ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
jerry_val.type = JERRY_DATA_TYPE_UNDEFINED;
return jerry_val;
} /* jerry_create_undefined_value */ } /* jerry_create_undefined_value */
/** /**
@@ -314,10 +267,8 @@ jerry_create_undefined_value (void)
jerry_value_t jerry_value_t
jerry_create_boolean_value (bool value) /**< bool value from which a jerry_value_t will be created */ jerry_create_boolean_value (bool value) /**< bool value from which a jerry_value_t will be created */
{ {
jerry_value_t jerry_val; return (value ? ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE)
jerry_val.type = JERRY_DATA_TYPE_BOOLEAN; : ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE));
jerry_val.u.v_bool = value;
return jerry_val;
} /* jerry_create_boolean_value */ } /* jerry_create_boolean_value */
/** /**
@@ -328,10 +279,7 @@ jerry_create_boolean_value (bool value) /**< bool value from which a jerry_value
jerry_value_t jerry_value_t
jerry_create_number_value (double value) /**< double value from which a jerry_value_t will be created */ jerry_create_number_value (double value) /**< double value from which a jerry_value_t will be created */
{ {
jerry_value_t jerry_val; return ecma_make_number_value ((ecma_number_t) value);
jerry_val.type = JERRY_DATA_TYPE_FLOAT64;
jerry_val.u.v_float64 = value;
return jerry_val;
} /* jerry_create_number_value */ } /* jerry_create_number_value */
/** /**
@@ -339,12 +287,9 @@ jerry_create_number_value (double value) /**< double value from which a jerry_va
* given jerry_object_t *parameter and returns with it. * given jerry_object_t *parameter and returns with it.
*/ */
jerry_value_t jerry_value_t
jerry_create_object_value (jerry_object_t *value) /**< jerry_object_t from which a value will be created */ jerry_create_object_value (jerry_object_t *obj_p) /**< jerry_object_t from which a value will be created */
{ {
jerry_value_t jerry_val; return ecma_make_object_value (obj_p);
jerry_val.type = JERRY_DATA_TYPE_OBJECT;
jerry_val.u.v_object = value;
return jerry_val;
} /* jerry_create_object_value */ } /* jerry_create_object_value */
/** /**
@@ -352,156 +297,11 @@ jerry_create_object_value (jerry_object_t *value) /**< jerry_object_t from which
* given jerry_string_t *parameter and returns with it. * given jerry_string_t *parameter and returns with it.
*/ */
jerry_value_t jerry_value_t
jerry_create_string_value (jerry_string_t *value) /**< jerry_string_t from which a value will be created */ jerry_create_string_value (jerry_string_t *str_p) /**< jerry_string_t from which a value will be created */
{ {
jerry_value_t jerry_val; return ecma_make_string_value (str_p);
jerry_val.type = JERRY_DATA_TYPE_STRING;
jerry_val.u.v_string = value;
return jerry_val;
} /* jerry_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_release_string / jerry_release_object,
* just when it becomes unnecessary.
*/
static void
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 ();
JERRY_ASSERT (out_value_p != NULL);
if (ecma_is_value_empty (value))
{
out_value_p->type = JERRY_DATA_TYPE_VOID;
}
else if (ecma_is_value_undefined (value))
{
out_value_p->type = JERRY_DATA_TYPE_UNDEFINED;
}
else if (ecma_is_value_null (value))
{
out_value_p->type = JERRY_DATA_TYPE_NULL;
}
else if (ecma_is_value_boolean (value))
{
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))
{
ecma_number_t num = ecma_get_number_from_value (value);
#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_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_DATA_TYPE_FLOAT64;
out_value_p->u.v_float64 = num;
#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
}
else if (ecma_is_value_string (value))
{
ecma_string_t *str = ecma_get_string_from_value (value);
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))
{
ecma_object_t *obj = ecma_get_object_from_value (value);
ecma_ref_object (obj);
out_value_p->type = JERRY_DATA_TYPE_OBJECT;
out_value_p->u.v_object = obj;
}
else
{
/* Impossible type of conversion from ecma_value to api_value */
JERRY_UNREACHABLE ();
}
} /* jerry_convert_ecma_value_to_api_value */
/**
* Convert value, represented in Jerry API format, to ecma value.
*
* Note:
* the output ecma value should be freed with ecma_free_value when it becomes unnecessary.
*/
static void
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_DATA_TYPE_UNDEFINED:
{
*out_value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
break;
}
case JERRY_DATA_TYPE_NULL:
{
*out_value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_NULL);
break;
}
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_DATA_TYPE_FLOAT32:
{
*out_value_p = ecma_make_number_value ((ecma_number_t) (api_value_p->u.v_float32));
break;
}
case JERRY_DATA_TYPE_FLOAT64:
{
*out_value_p = ecma_make_number_value ((ecma_number_t) (api_value_p->u.v_float64));
break;
}
case JERRY_DATA_TYPE_UINT32:
{
*out_value_p = ecma_make_uint32_value ((uint32_t) (api_value_p->u.v_uint32));
break;
}
case JERRY_DATA_TYPE_STRING:
{
ecma_string_t *str_p = ecma_copy_or_ref_ecma_string (api_value_p->u.v_string);
*out_value_p = ecma_make_string_value (str_p);
break;
}
case JERRY_DATA_TYPE_OBJECT:
{
ecma_object_t *obj_p = api_value_p->u.v_object;
ecma_ref_object (obj_p);
*out_value_p = ecma_make_object_value (obj_p);
break;
}
default:
{
JERRY_UNREACHABLE ();
}
}
} /* jerry_convert_api_value_to_ecma_value */
/** /**
* Convert completion of 'eval' to API value and completion code * Convert completion of 'eval' to API value and completion code
* *
@@ -510,12 +310,12 @@ jerry_convert_api_value_to_ecma_value (ecma_value_t *out_value_p, /**< [out] ecm
* *
* @return completion code * @return completion code
*/ */
static jerry_completion_code_t inline static jerry_completion_code_t __attr_always_inline___
jerry_convert_eval_completion_to_retval (jerry_value_t *retval_p, /**< [out] api value */ jerry_convert_eval_completion_to_retval (jerry_value_t *retval_p, /**< [out] api value */
ecma_value_t completion) /**< completion of 'eval'-mode ecma_value_t completion) /**< completion of 'eval'-mode
* code execution */ * code execution */
{ {
jerry_convert_ecma_value_to_api_value (retval_p, completion); *retval_p = completion;
return (ECMA_IS_VALUE_ERROR (completion)) ? JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION : JERRY_COMPLETION_CODE_OK; return (ECMA_IS_VALUE_ERROR (completion)) ? JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION : JERRY_COMPLETION_CODE_OK;
} /* jerry_convert_eval_completion_to_retval */ } /* jerry_convert_eval_completion_to_retval */
@@ -620,24 +420,23 @@ jerry_release_object (jerry_object_t *object_p) /**< pointer acquired through je
* *
* Warning: * Warning:
* Acquired pointer should be released with jerry_release_value * Acquired pointer should be released with jerry_release_value
*
* @return pointer that may be used outside of the engine
*/ */
jerry_value_t * jerry_value_t
jerry_acquire_value (jerry_value_t *value_p) /**< API value */ jerry_acquire_value (jerry_value_t value) /**< API value */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
if (value_p->type == JERRY_DATA_TYPE_STRING) if (jerry_value_is_string (value))
{ {
jerry_acquire_string (value_p->u.v_string); jerry_string_t *str_p = jerry_acquire_string (jerry_get_string_value (value));
return jerry_create_string_value (str_p);
} }
else if (value_p->type == JERRY_DATA_TYPE_OBJECT) else if (jerry_value_is_object (value))
{ {
jerry_acquire_object (value_p->u.v_object); jerry_acquire_object (jerry_get_object_value (value));
} }
return value_p; return value;
} /* jerry_acquire_value */ } /* jerry_acquire_value */
/** /**
@@ -648,18 +447,11 @@ jerry_acquire_value (jerry_value_t *value_p) /**< API value */
* for all other types it is a no-op. * for all other types it is a no-op.
*/ */
void void
jerry_release_value (jerry_value_t *value_p) /**< API value */ jerry_release_value (jerry_value_t value) /**< API value */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
if (value_p->type == JERRY_DATA_TYPE_STRING) ecma_free_value (value);
{
jerry_release_string (value_p->u.v_string);
}
else if (value_p->type == JERRY_DATA_TYPE_OBJECT)
{
jerry_release_object (value_p->u.v_object);
}
} /* jerry_release_value */ } /* jerry_release_value */
/** /**
@@ -745,17 +537,14 @@ jerry_create_array_object (jerry_size_t size) /**< size of array */
bool bool
jerry_set_array_index_value (jerry_object_t *array_obj_p, /**< array object */ jerry_set_array_index_value (jerry_object_t *array_obj_p, /**< array object */
jerry_length_t index, /**< index to be written */ jerry_length_t index, /**< index to be written */
jerry_value_t *value_p) /**< value to set */ jerry_value_t value) /**< value to set */
{ {
ecma_string_t *str_idx_p = ecma_new_ecma_string_from_uint32 ((uint32_t) index); ecma_string_t *str_idx_p = ecma_new_ecma_string_from_uint32 ((uint32_t) index);
ecma_value_t value;
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); 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)); JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (set_completion));
ecma_free_value (set_completion); ecma_free_value (set_completion);
ecma_deref_ecma_string (str_idx_p); ecma_deref_ecma_string (str_idx_p);
ecma_free_value (value);
return true; return true;
} /* jerry_set_array_index_value */ } /* jerry_set_array_index_value */
@@ -774,17 +563,20 @@ jerry_set_array_index_value (jerry_object_t *array_obj_p, /**< array object */
bool bool
jerry_get_array_index_value (jerry_object_t *array_obj_p, /**< array object */ jerry_get_array_index_value (jerry_object_t *array_obj_p, /**< array object */
jerry_length_t index, /**< index to be written */ jerry_length_t index, /**< index to be written */
jerry_value_t *value_p) /**< output value at index */ jerry_value_t *value_p) /**< [out] value at index */
{ {
ecma_string_t *str_idx_p = ecma_new_ecma_string_from_uint32 ((uint32_t) 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); ecma_value_t get_completion = ecma_op_object_get (array_obj_p, str_idx_p);
JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (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); ecma_deref_ecma_string (str_idx_p);
return true; if (!ECMA_IS_VALUE_ERROR (get_completion))
{
*value_p = get_completion;
return true;
}
*value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
return false;
} /* jerry_get_array_index_value */ } /* jerry_get_array_index_value */
/** /**
@@ -914,62 +706,25 @@ ecma_value_t
jerry_dispatch_external_function (ecma_object_t *function_object_p, /**< external function object */ jerry_dispatch_external_function (ecma_object_t *function_object_p, /**< external function object */
ecma_external_pointer_t handler_p, /**< pointer to the function's native handler */ ecma_external_pointer_t handler_p, /**< pointer to the function's native handler */
ecma_value_t this_arg_value, /**< 'this' argument */ ecma_value_t this_arg_value, /**< 'this' argument */
ecma_collection_header_t *arg_collection_p) /**< arguments collection */ const ecma_value_t *arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len) /**< arguments list length */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
const ecma_length_t args_count = (arg_collection_p != NULL ? arg_collection_p->unit_number : 0); ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
ecma_value_t completion_value;
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);
for (uint32_t i = 0; i < args_count; ++i)
{
bool is_moved = ecma_collection_iterator_next (&args_iterator);
JERRY_ASSERT (is_moved);
jerry_convert_ecma_value_to_api_value (&api_arg_values[i], *args_iterator.current_value_p);
}
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_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, bool is_successful = ((jerry_external_handler_t) handler_p) (function_object_p,
&api_this_arg_value, this_arg_value,
&api_ret_value, &ret_value,
api_arg_values, arguments_list_p,
args_count); arguments_list_len);
ecma_value_t ret_value; if (!is_successful)
jerry_convert_api_value_to_ecma_value (&ret_value, &api_ret_value);
if (is_successful)
{ {
completion_value = ret_value; ret_value = ecma_make_error_value (ret_value);
}
else
{
completion_value = ecma_make_error_value (ret_value);
} }
jerry_release_value (&api_ret_value); return ret_value;
jerry_release_value (&api_this_arg_value);
for (uint32_t i = 0; i < args_count; i++)
{
jerry_release_value (&api_arg_values[i]);
}
JMEM_FINALIZE_LOCAL_ARRAY (api_arg_values);
return completion_value;
} /* jerry_dispatch_external_function */ } /* jerry_dispatch_external_function */
/** /**
@@ -1039,7 +794,7 @@ bool
jerry_add_object_field (jerry_object_t *object_p, /**< object to add field at */ 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 */ const jerry_char_t *field_name_p, /**< name of the field */
jerry_size_t field_name_size, /**< size of field name in bytes */ jerry_size_t field_name_size, /**< size of field name in bytes */
const jerry_value_t *field_value_p, /**< value of the field */ const jerry_value_t field_value, /**< value of the field */
bool is_writable) /**< flag indicating whether the created field should be writable */ bool is_writable) /**< flag indicating whether the created field should be writable */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
@@ -1057,9 +812,6 @@ jerry_add_object_field (jerry_object_t *object_p, /**< object to add field at */
{ {
is_successful = true; is_successful = true;
ecma_value_t value_to_put;
jerry_convert_api_value_to_ecma_value (&value_to_put, field_value_p);
uint8_t prop_attributes = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE; uint8_t prop_attributes = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE;
if (is_writable) if (is_writable)
@@ -1070,9 +822,7 @@ jerry_add_object_field (jerry_object_t *object_p, /**< object to add field at */
prop_p = ecma_create_named_data_property (object_p, prop_p = ecma_create_named_data_property (object_p,
field_name_str_p, field_name_str_p,
prop_attributes); prop_attributes);
ecma_named_data_property_assign_value (object_p, prop_p, value_to_put); ecma_named_data_property_assign_value (object_p, prop_p, field_value);
ecma_free_value (value_to_put);
} }
ecma_deref_ecma_string (field_name_str_p); ecma_deref_ecma_string (field_name_str_p);
@@ -1169,12 +919,7 @@ jerry_foreach_object_field (jerry_object_t *object_p, /**< object */
ECMA_TRY_CATCH (property_value, ecma_op_object_get (object_p, property_name_p), ret_value); ECMA_TRY_CATCH (property_value, ecma_op_object_get (object_p, property_name_p), ret_value);
jerry_value_t field_value; continuous = foreach_p (property_name_p, property_value, user_data_p);
jerry_convert_ecma_value_to_api_value (&field_value, property_value);
continuous = foreach_p (property_name_p, &field_value, user_data_p);
jerry_release_value (&field_value);
ECMA_FINALIZE (property_value); ECMA_FINALIZE (property_value);
} }
@@ -1213,32 +958,15 @@ jerry_get_object_field_value_sz (jerry_object_t *object_p, /**< object */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
bool is_successful = true;
ecma_string_t *field_name_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) field_name_p, ecma_string_t *field_name_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) field_name_p,
(lit_utf8_size_t) field_name_size); (lit_utf8_size_t) field_name_size);
ecma_value_t field_value = ecma_op_object_get (object_p, field_name_str_p); *field_value_p = ecma_op_object_get (object_p, field_name_str_p);
if (!ECMA_IS_VALUE_ERROR (field_value))
{
jerry_convert_ecma_value_to_api_value (field_value_p, field_value);
if (ecma_is_value_undefined (field_value))
{
is_successful = false;
}
}
else
{
is_successful = false;
}
ecma_free_value (field_value);
ecma_deref_ecma_string (field_name_str_p); ecma_deref_ecma_string (field_name_str_p);
return is_successful; return (!ECMA_IS_VALUE_ERROR (*field_value_p)
&& !ecma_is_value_undefined (*field_value_p));
} /* jerry_get_object_field_value_sz */ } /* jerry_get_object_field_value_sz */
/** /**
@@ -1251,12 +979,12 @@ jerry_get_object_field_value_sz (jerry_object_t *object_p, /**< object */
bool bool
jerry_set_object_field_value (jerry_object_t *object_p, /**< object */ jerry_set_object_field_value (jerry_object_t *object_p, /**< object */
const jerry_char_t *field_name_p, /**< name of the field */ const jerry_char_t *field_name_p, /**< name of the field */
const jerry_value_t *field_value_p) /**< field value to set */ const jerry_value_t field_value) /**< field value to set */
{ {
return jerry_set_object_field_value_sz (object_p, return jerry_set_object_field_value_sz (object_p,
field_name_p, field_name_p,
lit_zt_utf8_string_size (field_name_p), lit_zt_utf8_string_size (field_name_p),
field_value_p); field_value);
} /* jerry_set_object_field_value */ } /* jerry_set_object_field_value */
/** /**
@@ -1270,7 +998,7 @@ bool
jerry_set_object_field_value_sz (jerry_object_t *object_p, /**< object */ jerry_set_object_field_value_sz (jerry_object_t *object_p, /**< object */
const jerry_char_t *field_name_p, /**< name of the field */ const jerry_char_t *field_name_p, /**< name of the field */
jerry_size_t field_name_size, /**< size of field name in bytes */ jerry_size_t field_name_size, /**< size of field name in bytes */
const jerry_value_t *field_value_p) /**< field value to set */ const jerry_value_t field_value) /**< field value to set */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
@@ -1279,12 +1007,9 @@ jerry_set_object_field_value_sz (jerry_object_t *object_p, /**< object */
ecma_string_t *field_name_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) field_name_p, ecma_string_t *field_name_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) field_name_p,
(lit_utf8_size_t) field_name_size); (lit_utf8_size_t) field_name_size);
ecma_value_t value_to_put;
jerry_convert_api_value_to_ecma_value (&value_to_put, field_value_p);
ecma_value_t set_completion = ecma_op_object_put (object_p, ecma_value_t set_completion = ecma_op_object_put (object_p,
field_name_str_p, field_name_str_p,
value_to_put, field_value,
true); true);
if (ECMA_IS_VALUE_ERROR (set_completion)) if (ECMA_IS_VALUE_ERROR (set_completion))
@@ -1293,8 +1018,6 @@ jerry_set_object_field_value_sz (jerry_object_t *object_p, /**< object */
} }
ecma_free_value (set_completion); ecma_free_value (set_completion);
ecma_free_value (value_to_put);
ecma_deref_ecma_string (field_name_str_p); ecma_deref_ecma_string (field_name_str_p);
return is_successful; return is_successful;
@@ -1369,8 +1092,7 @@ jerry_set_object_native_handle (jerry_object_t *object_p, /**< object to set han
* Invoke function specified by a function object * Invoke function specified by a function object
* *
* Note: * Note:
* returned value should be freed with jerry_release_value * returned value must be freed with jerry_release_value
* just when the value becomes unnecessary.
* *
* Note: * Note:
* If function is invoked as constructor, it should support [[Construct]] method, * If function is invoked as constructor, it should support [[Construct]] method,
@@ -1403,13 +1125,6 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
bool is_successful = true; bool is_successful = true;
JMEM_DEFINE_LOCAL_ARRAY (arguments_list_p, args_count, ecma_value_t);
for (uint32_t i = 0; i < args_count; ++i)
{
jerry_convert_api_value_to_ecma_value (arguments_list_p + i, args_p + i);
}
ecma_value_t call_completion; ecma_value_t call_completion;
if (is_invoke_as_constructor) if (is_invoke_as_constructor)
@@ -1418,7 +1133,7 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
JERRY_ASSERT (jerry_is_constructor (function_object_p)); JERRY_ASSERT (jerry_is_constructor (function_object_p));
call_completion = ecma_op_function_construct (function_object_p, call_completion = ecma_op_function_construct (function_object_p,
arguments_list_p, args_p,
args_count); args_count);
} }
else else
@@ -1438,7 +1153,7 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
call_completion = ecma_op_function_call (function_object_p, call_completion = ecma_op_function_call (function_object_p,
this_arg_val, this_arg_val,
arguments_list_p, args_p,
args_count); args_count);
} }
@@ -1450,18 +1165,9 @@ jerry_invoke_function (bool is_invoke_as_constructor, /**< true - invoke functio
if (retval_p != NULL) if (retval_p != NULL)
{ {
jerry_convert_ecma_value_to_api_value (retval_p, call_completion); *retval_p = call_completion;
} }
ecma_free_value (call_completion);
for (uint32_t i = 0; i < args_count; ++i)
{
ecma_free_value (arguments_list_p[i]);
}
JMEM_FINALIZE_LOCAL_ARRAY (arguments_list_p);
return is_successful; return is_successful;
} /* jerry_invoke_function */ } /* jerry_invoke_function */
@@ -1473,11 +1179,7 @@ jerry_construct_type_error (jerry_value_t *retval_p) /**< [out] value with const
* TypeError object */ * TypeError object */
{ {
ecma_object_t *type_error_obj_p = ecma_new_standard_error (ECMA_ERROR_TYPE); 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); *retval_p = ecma_make_object_value (type_error_obj_p);
jerry_convert_ecma_value_to_api_value (retval_p, type_error_value);
ecma_deref_object (type_error_obj_p);
} /* jerry_construct_type_error */ } /* jerry_construct_type_error */
/** /**
@@ -1606,8 +1308,6 @@ jerry_eval (const jerry_char_t *source_p, /**< source code */
status = jerry_convert_eval_completion_to_retval (retval_p, completion); status = jerry_convert_eval_completion_to_retval (retval_p, completion);
ecma_free_value (completion);
return status; return status;
} /* jerry_eval */ } /* jerry_eval */
@@ -1750,11 +1450,7 @@ jerry_run (jerry_value_t *error_value_p) /**< [out] error value */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
ecma_value_t error_value; jerry_completion_code_t ret_code = vm_run_global (error_value_p);
jerry_completion_code_t ret_code = vm_run_global (&error_value);
jerry_convert_ecma_value_to_api_value (error_value_p, error_value);
ecma_free_value (error_value);
return ret_code; return ret_code;
} /* jerry_run */ } /* jerry_run */
@@ -1785,7 +1481,7 @@ jerry_run_simple (const jerry_char_t *script_source, /**< script source */
ret_code = jerry_run (&error_value); ret_code = jerry_run (&error_value);
jerry_release_value (&error_value); jerry_release_value (error_value);
} }
jerry_cleanup (); jerry_cleanup ();
@@ -2310,7 +2006,7 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
jerry_value_t *retval_p) /**< [out] returned value (ECMA-262 'undefined' if jerry_value_t *retval_p) /**< [out] returned value (ECMA-262 'undefined' if
* code is executed as global scope code) */ * code is executed as global scope code) */
{ {
jerry_convert_ecma_value_to_api_value (retval_p, ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED)); *retval_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
#ifdef JERRY_ENABLE_SNAPSHOT_EXEC #ifdef JERRY_ENABLE_SNAPSHOT_EXEC
JERRY_ASSERT (snapshot_p != NULL); JERRY_ASSERT (snapshot_p != NULL);
@@ -2380,7 +2076,7 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
else else
{ {
JERRY_ASSERT (ret_code == JERRY_COMPLETION_CODE_OK); JERRY_ASSERT (ret_code == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (ecma_is_value_empty (error_value)); JERRY_ASSERT (ecma_is_value_undefined (error_value));
} }
vm_finalize (); vm_finalize ();
@@ -2411,19 +2107,12 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
* *
* @return string value * @return string value
*/ */
jerry_string_t * jerry_value_t
jerry_value_to_string (const jerry_value_t *in_value_p) /**< input value */ jerry_value_to_string (const jerry_value_t value) /**< input value */
{ {
jerry_assert_api_available (); jerry_assert_api_available ();
ecma_value_t in_value; return ecma_op_to_string (value);
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_string_t *) ecma_get_string_from_value (str_value);
} /* jerry_value_to_string */ } /* jerry_value_to_string */
/** /**
jerry-core/vm/vm.c
+1 -1
View File
@@ -229,7 +229,7 @@ vm_run_global (ecma_value_t *error_value_p) /**< [out] error value */
else else
{ {
ecma_free_value (ret_value); ecma_free_value (ret_value);
*error_value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY); *error_value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
ret_code = JERRY_COMPLETION_CODE_OK; ret_code = JERRY_COMPLETION_CODE_OK;
} }
main-unix.c
+21 -19
View File
@@ -73,14 +73,14 @@ read_file (const char *file_name,
*/ */
static bool static bool
assert_handler (const jerry_object_t *function_obj_p __attribute__((unused)), /**< function object */ assert_handler (const jerry_object_t *function_obj_p __attribute__((unused)), /**< function object */
const jerry_value_t *this_p __attribute__((unused)), /**< this arg */ const jerry_value_t this_p __attribute__((unused)), /**< this arg */
jerry_value_t *ret_val_p __attribute__((unused)), /**< return argument */ jerry_value_t *ret_val_p __attribute__((unused)), /**< return argument */
const jerry_value_t args_p[], /**< function arguments */ const jerry_value_t args_p[], /**< function arguments */
const jerry_length_t args_cnt) /**< number of function arguments */ const jerry_length_t args_cnt) /**< number of function arguments */
{ {
if (args_cnt == 1 if (args_cnt == 1
&& args_p[0].type == JERRY_DATA_TYPE_BOOLEAN && jerry_value_is_boolean (args_p[0])
&& args_p[0].u.v_bool == true) && jerry_get_boolean_value (args_p[0]))
{ {
return true; return true;
} }
@@ -315,15 +315,13 @@ main (int argc,
jerry_object_t *global_obj_p = jerry_get_global (); jerry_object_t *global_obj_p = jerry_get_global ();
jerry_object_t *assert_func_p = jerry_create_external_function (assert_handler); jerry_object_t *assert_func_p = jerry_create_external_function (assert_handler);
jerry_value_t assert_value; jerry_value_t assert_value = jerry_create_object_value (assert_func_p);
assert_value.type = JERRY_DATA_TYPE_OBJECT;
assert_value.u.v_object = assert_func_p;
bool is_assert_added = jerry_set_object_field_value (global_obj_p, bool is_assert_added = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "assert", (jerry_char_t *) "assert",
&assert_value); assert_value);
jerry_release_value (&assert_value); jerry_release_value (assert_value);
jerry_release_object (global_obj_p); jerry_release_object (global_obj_p);
if (!is_assert_added) if (!is_assert_added)
@@ -349,7 +347,7 @@ main (int argc,
snapshot_size, snapshot_size,
true, true,
&ret_value); &ret_value);
assert (ret_value.type == JERRY_DATA_TYPE_UNDEFINED); assert (jerry_value_is_undefined (ret_value));
} }
if (ret_code != JERRY_COMPLETION_CODE_OK) if (ret_code != JERRY_COMPLETION_CODE_OK)
@@ -359,7 +357,7 @@ main (int argc,
} }
jerry_object_t *err_obj_p = NULL; jerry_object_t *err_obj_p = NULL;
jerry_value_t err_value = jerry_create_void_value (); jerry_value_t err_value = jerry_create_undefined_value ();
if (ret_code == JERRY_COMPLETION_CODE_OK) if (ret_code == JERRY_COMPLETION_CODE_OK)
{ {
@@ -426,7 +424,7 @@ main (int argc,
return JERRY_STANDALONE_EXIT_CODE_FAIL; return JERRY_STANDALONE_EXIT_CODE_FAIL;
} }
if (!jerry_is_function (print_function.u.v_object)) if (!jerry_is_function (jerry_get_object_value (print_function)))
{ {
return JERRY_STANDALONE_EXIT_CODE_FAIL; return JERRY_STANDALONE_EXIT_CODE_FAIL;
} }
@@ -464,17 +462,21 @@ main (int argc,
/* Print return value */ /* Print return value */
const jerry_value_t args[] = { ret_val }; const jerry_value_t args[] = { ret_val };
jerry_value_t ret_val_print; jerry_value_t ret_val_print;
if (jerry_call_function (print_function.u.v_object, NULL, &ret_val_print, args, 1)) if (jerry_call_function (jerry_get_object_value (print_function),
NULL,
&ret_val_print,
args,
1))
{ {
jerry_release_value (&ret_val_print); jerry_release_value (ret_val_print);
} }
jerry_release_value (&ret_val); jerry_release_value (ret_val);
} }
} }
jerry_release_object (global_obj_p); jerry_release_object (global_obj_p);
jerry_release_value (&print_function); jerry_release_value (print_function);
} }
#ifdef JERRY_ENABLE_LOG #ifdef JERRY_ENABLE_LOG
@@ -497,13 +499,13 @@ main (int argc,
if (err_obj_p != NULL) if (err_obj_p != NULL)
{ {
jerry_value_t err_value = jerry_create_object_value (err_obj_p); jerry_value_t err_value = jerry_create_object_value (err_obj_p);
err_str_p = jerry_value_to_string (&err_value); err_str_p = jerry_get_string_value (jerry_value_to_string (err_value));
jerry_release_object (err_obj_p); jerry_release_object (err_obj_p);
} }
else if (!jerry_value_is_void (&err_value)) else if (!jerry_value_is_undefined (err_value))
{ {
err_str_p = jerry_value_to_string (&err_value); err_str_p = jerry_get_string_value (jerry_value_to_string (err_value));
jerry_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))
tests/unit/test-api.c
+214 -256
View File
@@ -63,96 +63,49 @@ const char *test_source = (
bool test_api_is_free_callback_was_called = false; 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_value_t *out_value_p, /**< out: API value */
bool v) /**< boolean value to initialize with */
{
out_value_p->type = JERRY_DATA_TYPE_BOOLEAN;
out_value_p->u.v_bool = v;
} /* test_api_init_api_value_bool */
/**
* Initialize Jerry API value with specified float64 number
*/
static void
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_DATA_TYPE_FLOAT64;
out_value_p->u.v_float64 = v;
} /* test_api_init_api_value_float64 */
/**
* Initialize Jerry API value with specified string
*/
static void
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_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_value_t *out_value_p, /**< out: API value */
jerry_object_t *v) /**< object value to initialize with */
{
jerry_acquire_object (v);
out_value_p->type = JERRY_DATA_TYPE_OBJECT;
out_value_p->u.v_object = v;
} /* test_api_init_api_value_object */
static bool static bool
handler (const jerry_object_t *function_obj_p, handler (const jerry_object_t *function_obj_p, /**< function object */
const jerry_value_t *this_p, const jerry_value_t this_val, /**< this value */
jerry_value_t *ret_val_p, jerry_value_t *ret_val_p, /**< [out] return value */
const jerry_value_t args_p[], const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt) const jerry_length_t args_cnt) /**< arguments length */
{ {
char buffer[32]; char buffer[32];
jerry_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_val, args_p, args_cnt, ret_val_p);
JERRY_ASSERT (args_cnt == 2); JERRY_ASSERT (args_cnt == 2);
JERRY_ASSERT (args_p[0].type == JERRY_DATA_TYPE_STRING); JERRY_ASSERT (jerry_value_is_string (args_p[0]));
sz = jerry_get_string_size (args_p[0].u.v_string); sz = jerry_get_string_size (jerry_get_string_value (args_p[0]));
JERRY_ASSERT (sz == 1); JERRY_ASSERT (sz == 1);
sz = jerry_string_to_char_buffer (args_p[0].u.v_string, (jerry_char_t *) buffer, sz); sz = jerry_string_to_char_buffer (jerry_get_string_value (args_p[0]),
(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_DATA_TYPE_BOOLEAN); JERRY_ASSERT (jerry_value_is_boolean (args_p[1]));
JERRY_ASSERT (args_p[1].u.v_bool == true);
test_api_init_api_value_string (ret_val_p, "string from handler"); *ret_val_p = jerry_create_string_value (jerry_create_string ((jerry_char_t *) "string from handler"));
return true; return true;
} /* handler */ } /* handler */
static bool static bool
handler_throw_test (const jerry_object_t *function_obj_p, handler_throw_test (const jerry_object_t *function_obj_p, /**< function object */
const jerry_value_t *this_p, const jerry_value_t this_val, /**< this value */
jerry_value_t *ret_val_p, jerry_value_t *ret_val_p, /**< [out] return value */
const jerry_value_t args_p[], const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt) const jerry_length_t args_cnt) /**< arguments length */
{ {
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_val, args_p, args_cnt, ret_val_p);
jerry_object_t *error_p = jerry_create_error (JERRY_ERROR_TYPE, jerry_object_t *error_p = jerry_create_error (JERRY_ERROR_TYPE,
(jerry_char_t *) "error"); (jerry_char_t *) "error");
test_api_init_api_value_object (ret_val_p, error_p); *ret_val_p = jerry_create_object_value (error_p);
jerry_release_object (error_p);
return false; return false;
} /* handler_throw_test */ } /* handler_throw_test */
@@ -167,40 +120,40 @@ handler_construct_freecb (uintptr_t native_p)
} /* handler_construct_freecb */ } /* handler_construct_freecb */
static bool static bool
handler_construct (const jerry_object_t *function_obj_p, handler_construct (const jerry_object_t *function_obj_p, /**< function object */
const jerry_value_t *this_p, const jerry_value_t this_val, /**< this value */
jerry_value_t *ret_val_p, jerry_value_t *ret_val_p, /**< [out] return value */
const jerry_value_t args_p[], const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt) const jerry_length_t args_cnt) /**< arguments length */
{ {
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_val, args_p, args_cnt, ret_val_p);
JERRY_ASSERT (this_p != NULL); JERRY_ASSERT (jerry_value_is_object (this_val));
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_DATA_TYPE_BOOLEAN); JERRY_ASSERT (jerry_value_is_boolean (args_p[0]));
JERRY_ASSERT (args_p[0].u.v_bool == true); JERRY_ASSERT (jerry_get_boolean_value (args_p[0]) == true);
jerry_set_object_field_value (this_p->u.v_object, (jerry_char_t *) "value_field", &args_p[0]); jerry_set_object_field_value (jerry_get_object_value (this_val),
(jerry_char_t *) "value_field",
args_p[0]);
jerry_set_object_native_handle (this_p->u.v_object, jerry_set_object_native_handle (jerry_get_object_value (this_val),
(uintptr_t) 0x0000000000000000ull, (uintptr_t) 0x0000000000000000ull,
handler_construct_freecb); handler_construct_freecb);
uintptr_t ptr; uintptr_t ptr;
bool is_ok = jerry_get_object_native_handle (this_p->u.v_object, &ptr); bool is_ok = jerry_get_object_native_handle (jerry_get_object_value (this_val), &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_set_object_native_handle (this_p->u.v_object, jerry_set_object_native_handle (jerry_get_object_value (this_val),
(uintptr_t) 0x0012345678abcdefull, (uintptr_t) 0x0012345678abcdefull,
handler_construct_freecb); handler_construct_freecb);
return true; return true;
} /* handler_construct */ } /* handler_construct */
/** /**
* Extended Magic Strings * Extended Magic Strings
*/ */
@@ -219,7 +172,7 @@ JERRY_MAGIC_STRING_ITEMS
const jerry_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_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
@@ -229,15 +182,17 @@ const jerry_length_t magic_string_lengths[] =
const jerry_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_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_string_t *name, static bool
const jerry_value_t *value, void *user_data) foreach (const jerry_string_t *name, /**< field name */
const jerry_value_t value, /**< field value */
void *user_data) /**< user data */
{ {
char str_buf_p[128]; char str_buf_p[128];
jerry_size_t sz = jerry_string_to_char_buffer (name, (jerry_char_t *) str_buf_p, 128); jerry_size_t sz = jerry_string_to_char_buffer (name, (jerry_char_t *) str_buf_p, 128);
@@ -245,37 +200,29 @@ static bool foreach (const jerry_string_t *name,
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 JERRY_ASSERT (jerry_value_is_number (value));
JERRY_ASSERT (value->type == JERRY_DATA_TYPE_FLOAT32); JERRY_ASSERT (jerry_get_number_value (value) == 32.0);
JERRY_ASSERT (value->v_float32 == 32.0f);
#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_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)) else if (!strncmp (str_buf_p, "bravo", (size_t) sz))
{ {
JERRY_ASSERT (value->type == JERRY_DATA_TYPE_BOOLEAN); JERRY_ASSERT (jerry_value_is_boolean (value));
JERRY_ASSERT (value->u.v_bool == false); JERRY_ASSERT (jerry_get_boolean_value (value) == 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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (value));
} }
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 JERRY_ASSERT (jerry_value_is_number (value));
JERRY_ASSERT (value->type == JERRY_DATA_TYPE_FLOAT32); JERRY_ASSERT (jerry_get_number_value (value) == 123.45);
JERRY_ASSERT (value->v_float32 == 123.45f);
#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_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)) else if (!strncmp (str_buf_p, "echo", (size_t) sz))
{ {
JERRY_ASSERT (value->type == JERRY_DATA_TYPE_STRING); JERRY_ASSERT (jerry_value_is_string (value));
jerry_size_t echo_sz = jerry_string_to_char_buffer (value->u.v_string, (jerry_char_t *) str_buf_p, 128); jerry_size_t echo_sz = jerry_string_to_char_buffer (jerry_get_string_value (value),
(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));
} }
@@ -288,7 +235,10 @@ static bool foreach (const jerry_string_t *name,
return true; return true;
} /* foreach */ } /* foreach */
static bool foreach_exception (const jerry_string_t *name, const jerry_value_t *value, void * user_data) static bool
foreach_exception (const jerry_string_t *name, /**< field name */
const jerry_value_t value, /**< field value */
void *user_data) /**< user data */
{ {
JERRY_UNUSED (value); JERRY_UNUSED (value);
JERRY_UNUSED (user_data); JERRY_UNUSED (user_data);
@@ -303,7 +253,10 @@ static bool foreach_exception (const jerry_string_t *name, const jerry_value_t *
return true; return true;
} /* foreach_exception */ } /* foreach_exception */
static bool foreach_subset (const jerry_string_t *name, const jerry_value_t *value, void *user_data) static bool
foreach_subset (const jerry_string_t *name, /**< field name */
const jerry_value_t value, /**< field value */
void *user_data) /**< user data */
{ {
JERRY_UNUSED (name); JERRY_UNUSED (name);
JERRY_UNUSED (value); JERRY_UNUSED (value);
@@ -340,141 +293,147 @@ main (void)
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_value_is_void (&res)); JERRY_ASSERT (jerry_value_is_undefined (res));
global_obj_p = jerry_get_global (); global_obj_p = jerry_get_global ();
// Test corner case for jerry_string_to_char_buffer // Test corner case for jerry_string_to_char_buffer
test_api_init_api_value_string (&args[0], ""); args[0] = jerry_create_string_value (jerry_create_string ((jerry_char_t *) ""));
sz = jerry_get_string_size (args[0].u.v_string); sz = jerry_get_string_size (jerry_get_string_value (args[0]));
JERRY_ASSERT (sz == 0); JERRY_ASSERT (sz == 0);
jerry_release_value (&args[0]); jerry_release_value (args[0]);
// Get global.boo (non-existing field) // Get global.boo (non-existing field)
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_UNDEFINED); JERRY_ASSERT (jerry_value_is_undefined (val_t));
// Get global.t // Get global.t
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_FLOAT64 JERRY_ASSERT (jerry_value_is_number (val_t)
&& val_t.u.v_float64 == 1.0); && jerry_get_number_value (val_t) == 1.0);
jerry_release_value (&val_t); jerry_release_value (val_t);
// Get global.foo // Get global.foo
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_foo));
// Call foo (4, 2) // Call foo (4, 2)
test_api_init_api_value_float64 (&args[0], 4); args[0] = jerry_create_number_value (4);
test_api_init_api_value_float64 (&args[1], 2); args[1] = jerry_create_number_value (2);
is_ok = jerry_call_function (val_foo.u.v_object, NULL, &res, args, 2); is_ok = jerry_call_function (jerry_get_object_value (val_foo), NULL, &res, args, 2);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok);
&& res.type == JERRY_DATA_TYPE_FLOAT64 JERRY_ASSERT (jerry_value_is_number (res)
&& res.u.v_float64 == 1.0); && jerry_get_number_value (res) == 1.0);
jerry_release_value (&res); jerry_release_value (res);
// Get global.bar // Get global.bar
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_bar));
// Call bar (4, 2) // Call bar (4, 2)
is_ok = jerry_call_function (val_bar.u.v_object, NULL, &res, args, 2); is_ok = jerry_call_function (jerry_get_object_value (val_bar), NULL, &res, args, 2);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok);
&& res.type == JERRY_DATA_TYPE_FLOAT64 JERRY_ASSERT (jerry_value_is_number (res)
&& res.u.v_float64 == 5.0); && jerry_get_number_value (res) == 5.0);
jerry_release_value (&res); jerry_release_value (res);
jerry_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"); jerry_release_value (args[0]);
is_ok = jerry_set_object_field_value (global_obj_p, args[0] = jerry_create_string_value (jerry_create_string ((jerry_char_t *) "abcd"));
(jerry_char_t *)"t", is_ok = jerry_set_object_field_value (global_obj_p, (jerry_char_t *) "t", args[0]);
&args[0]);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_release_value (&args[0]);
// Call foo (4, 2) // Call foo (4, 2)
is_ok = jerry_call_function (val_foo.u.v_object, NULL, &res, args, 2); is_ok = jerry_call_function (jerry_get_object_value (val_foo), NULL, &res, args, 2);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok);
&& res.type == JERRY_DATA_TYPE_STRING); JERRY_ASSERT (jerry_value_is_string (res));
sz = jerry_get_string_size (res.u.v_string); sz = jerry_get_string_size (jerry_get_string_value (res));
JERRY_ASSERT (sz == 4); JERRY_ASSERT (sz == 4);
sz = jerry_string_to_char_buffer (res.u.v_string, (jerry_char_t *) buffer, sz); sz = jerry_string_to_char_buffer (jerry_get_string_value (res), (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 4); JERRY_ASSERT (sz == 4);
jerry_release_value (&res); jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz)); JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz));
jerry_release_value (args[0]);
jerry_release_value (args[1]);
// Get global.A // Get global.A
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_A));
// Get A.prototype // Get A.prototype
is_ok = jerry_is_constructor (val_A.u.v_object); is_ok = jerry_is_constructor (jerry_get_object_value (val_A));
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
is_ok = jerry_get_object_field_value (val_A.u.v_object, is_ok = jerry_get_object_field_value (jerry_get_object_value (val_A),
(jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_A_prototype));
jerry_release_value (&val_A); jerry_release_value (val_A);
// Set A.prototype.foo = global.foo // Set A.prototype.foo = global.foo
is_ok = jerry_set_object_field_value (val_A_prototype.u.v_object, is_ok = jerry_set_object_field_value (jerry_get_object_value (val_A_prototype),
(jerry_char_t *) "foo", (jerry_char_t *) "foo",
&val_foo); val_foo);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_release_value (&val_A_prototype); jerry_release_value (val_A_prototype);
jerry_release_value (&val_foo); jerry_release_value (val_foo);
// Get global.a // Get global.a
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_a));
// Get a.t // Get a.t
is_ok = jerry_get_object_field_value (val_a.u.v_object, (jerry_char_t *) "t", &res); is_ok = jerry_get_object_field_value (jerry_get_object_value (val_a), (jerry_char_t *) "t", &res);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok);
&& res.type == JERRY_DATA_TYPE_FLOAT64 JERRY_ASSERT (jerry_value_is_number (res)
&& res.u.v_float64 == 12.0); && jerry_get_number_value (res) == 12.0);
jerry_release_value (&res); jerry_release_value (res);
// foreach properties // foreach properties
jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "p", &val_p); 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"); is_ok = jerry_foreach_object_field (jerry_get_object_value (val_p), 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_foreach_object_field (val_p.u.v_object, foreach_subset, &count); is_ok = jerry_foreach_object_field (jerry_get_object_value (val_p), foreach_subset, &count);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
JERRY_ASSERT (count == 3); JERRY_ASSERT (count == 3);
jerry_release_value (&val_p); jerry_release_value (val_p);
// foreach with throw test // foreach with throw test
jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "np", &val_np); 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); is_ok = !jerry_foreach_object_field (jerry_get_object_value (val_np), foreach_exception, NULL);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_release_value (&val_np); jerry_release_value (val_np);
// Get a.foo // Get a.foo
is_ok = jerry_get_object_field_value (val_a.u.v_object, (jerry_char_t *) "foo", &val_a_foo); is_ok = jerry_get_object_field_value (jerry_get_object_value (val_a),
JERRY_ASSERT (is_ok (jerry_char_t *) "foo",
&& val_a_foo.type == JERRY_DATA_TYPE_OBJECT); &val_a_foo);
JERRY_ASSERT (is_ok);
JERRY_ASSERT (jerry_value_is_object (val_a_foo));
// Call a.foo () // Call a.foo ()
is_ok = jerry_call_function (val_a_foo.u.v_object, val_a.u.v_object, &res, NULL, 0); is_ok = jerry_call_function (jerry_get_object_value (val_a_foo),
JERRY_ASSERT (is_ok jerry_get_object_value (val_a),
&& res.type == JERRY_DATA_TYPE_FLOAT64 &res,
&& res.u.v_float64 == 12.0); NULL,
jerry_release_value (&res); 0);
jerry_release_value (&val_a_foo); JERRY_ASSERT (is_ok);
JERRY_ASSERT (jerry_value_is_number (res)
&& jerry_get_number_value (res) == 12.0);
jerry_release_value (res);
jerry_release_value (val_a_foo);
jerry_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_create_external_function (handler); external_func_p = jerry_create_external_function (handler);
@@ -482,30 +441,30 @@ main (void)
&& jerry_is_function (external_func_p) && jerry_is_function (external_func_p)
&& jerry_is_constructor (external_func_p)); && jerry_is_constructor (external_func_p));
test_api_init_api_value_object (&val_external, external_func_p); val_external = jerry_create_object_value (external_func_p);
is_ok = jerry_set_object_field_value (global_obj_p, is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "external", (jerry_char_t *) "external",
&val_external); val_external);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_release_value (&val_external); jerry_release_value (val_external);
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_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_call_external));
is_ok = jerry_call_function (val_call_external.u.v_object, is_ok = jerry_call_function (jerry_get_object_value (val_call_external),
global_obj_p, global_obj_p,
&res, &res,
NULL, 0); NULL,
jerry_release_value (&val_call_external); 0);
JERRY_ASSERT (is_ok jerry_release_value (val_call_external);
&& res.type == JERRY_DATA_TYPE_STRING); JERRY_ASSERT (is_ok);
sz = jerry_get_string_size (res.u.v_string); JERRY_ASSERT (jerry_value_is_string (res));
sz = jerry_get_string_size (jerry_get_string_value (res));
JERRY_ASSERT (sz == 19); JERRY_ASSERT (sz == 19);
sz = jerry_string_to_char_buffer (res.u.v_string, (jerry_char_t *) buffer, sz); sz = jerry_string_to_char_buffer (jerry_get_string_value (res), (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 19); JERRY_ASSERT (sz == 19);
jerry_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
@@ -514,35 +473,34 @@ main (void)
&& jerry_is_function (external_construct_p) && jerry_is_function (external_construct_p)
&& jerry_is_constructor (external_construct_p)); && jerry_is_constructor (external_construct_p));
test_api_init_api_value_object (&val_external_construct, external_construct_p); val_external_construct = jerry_create_object_value (external_construct_p);
is_ok = jerry_set_object_field_value (global_obj_p, is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "external_construct", (jerry_char_t *) "external_construct",
&val_external_construct); val_external_construct);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_release_value (&val_external_construct);
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); args[0] = jerry_create_boolean_value (true);
is_ok = jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (res));
is_ok = jerry_get_object_field_value (res.u.v_object, is_ok = jerry_get_object_field_value (jerry_get_object_value (res),
(jerry_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_DATA_TYPE_BOOLEAN JERRY_ASSERT (jerry_value_is_boolean (val_value_field)
&& val_value_field.u.v_bool == true); && jerry_get_boolean_value (val_value_field));
jerry_release_value (&val_value_field); jerry_release_value (val_value_field);
jerry_release_object (external_construct_p);
uintptr_t ptr; uintptr_t ptr;
is_ok = jerry_get_object_native_handle (res.u.v_object, &ptr); is_ok = jerry_get_object_native_handle (jerry_get_object_value (res), &ptr);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok
&& ptr == (uintptr_t) 0x0012345678abcdefull); && ptr == (uintptr_t) 0x0012345678abcdefull);
jerry_release_value (&res); jerry_release_value (res);
// Test: Throwing exception from native handler. // Test: Throwing exception from native handler.
@@ -550,43 +508,42 @@ main (void)
JERRY_ASSERT (throw_test_handler_p != NULL JERRY_ASSERT (throw_test_handler_p != NULL
&& jerry_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); val_t = jerry_create_object_value (throw_test_handler_p);
is_ok = jerry_set_object_field_value (global_obj_p, is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "throw_test", (jerry_char_t *) "throw_test",
&val_t); val_t);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_release_value (&val_t); jerry_release_value (val_t);
jerry_release_object (throw_test_handler_p);
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_t));
is_ok = jerry_call_function (val_t.u.v_object, is_ok = jerry_call_function (jerry_get_object_value (val_t),
global_obj_p, global_obj_p,
&res, &res,
NULL, 0); NULL, 0);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
jerry_release_value (&val_t); jerry_release_value (val_t);
jerry_release_value (&res); jerry_release_value (res);
// Test: Unhandled exception in called function // Test: Unhandled exception in called function
is_ok = jerry_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_t));
is_ok = jerry_call_function (val_t.u.v_object, is_ok = jerry_call_function (jerry_get_object_value (val_t),
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_release_value (&val_t); jerry_release_value (val_t);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (&res); jerry_release_value (res);
// Test: Call of non-function // Test: Call of non-function
obj_p = jerry_create_object (); obj_p = jerry_create_object ();
@@ -598,27 +555,27 @@ main (void)
JERRY_ASSERT (is_exception); JERRY_ASSERT (is_exception);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (&res); jerry_release_value (res);
jerry_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_get_object_field_value (global_obj_p, (jerry_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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_t));
is_ok = jerry_construct_object (val_t.u.v_object, is_ok = jerry_construct_object (jerry_get_object_value (val_t),
&res, &res,
NULL, 0); NULL, 0);
is_exception = !is_ok; is_exception = !is_ok;
JERRY_ASSERT (is_exception); JERRY_ASSERT (is_exception);
jerry_release_value (&val_t); jerry_release_value (val_t);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (&res); jerry_release_value (res);
// Test: Call of non-function as constructor // Test: Call of non-function as constructor
obj_p = jerry_create_object (); obj_p = jerry_create_object ();
@@ -629,8 +586,8 @@ main (void)
JERRY_ASSERT (is_exception); JERRY_ASSERT (is_exception);
// 'res' should contain exception object // 'res' should contain exception object
JERRY_ASSERT (res.type == JERRY_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (&res); jerry_release_value (res);
jerry_release_object (obj_p); jerry_release_object (obj_p);
@@ -638,17 +595,18 @@ main (void)
// Test: Array Object API // Test: Array Object API
jerry_object_t *array_obj_p = jerry_create_array_object (10); jerry_object_t *array_obj_p = jerry_create_array_object (10);
jerry_value_t v_in; jerry_value_t v_in = jerry_create_number_value (10.5);
test_api_init_api_value_float64 (&v_in, 10.5); jerry_set_array_index_value (array_obj_p, 5, v_in);
jerry_set_array_index_value (array_obj_p, 5, &v_in);
jerry_value_t v_out; jerry_value_t v_out;
jerry_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_DATA_TYPE_FLOAT64 && v_out.u.v_float64 == 10.5); JERRY_ASSERT (jerry_value_is_number (v_out)
&& jerry_get_number_value (v_out) == 10.5);
jerry_release_value (v_in);
jerry_release_value (v_out);
jerry_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_eval ((jerry_char_t *) eval_code_src_p, jerry_completion_code_t status = jerry_eval ((jerry_char_t *) eval_code_src_p,
@@ -657,19 +615,19 @@ main (void)
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_DATA_TYPE_OBJECT); JERRY_ASSERT (jerry_value_is_object (val_t));
JERRY_ASSERT (jerry_is_function (val_t.u.v_object)); JERRY_ASSERT (jerry_is_function (jerry_get_object_value (val_t)));
is_ok = jerry_call_function (val_t.u.v_object, is_ok = jerry_call_function (jerry_get_object_value (val_t),
NULL, NULL,
&res, &res,
NULL, 0); NULL, 0);
JERRY_ASSERT (is_ok); JERRY_ASSERT (is_ok);
JERRY_ASSERT (res.type == JERRY_DATA_TYPE_FLOAT64 JERRY_ASSERT (jerry_value_is_number (res)
&& res.u.v_float64 == 123.0); && jerry_get_number_value (res) == 123.0);
jerry_release_value (&res); jerry_release_value (res);
jerry_release_value (&val_t); jerry_release_value (val_t);
// cleanup. // cleanup.
jerry_release_object (global_obj_p); jerry_release_object (global_obj_p);
@@ -695,7 +653,7 @@ main (void)
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_value_is_void (&res)); JERRY_ASSERT (jerry_value_is_undefined (res));
jerry_cleanup (); jerry_cleanup ();
@@ -733,22 +691,22 @@ main (void)
false, false,
&res) == JERRY_COMPLETION_CODE_OK); &res) == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok);
&& res.type == JERRY_DATA_TYPE_UNDEFINED); JERRY_ASSERT (jerry_value_is_undefined (res));
jerry_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,
false, false,
&res) == JERRY_COMPLETION_CODE_OK); &res) == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (is_ok JERRY_ASSERT (is_ok);
&& res.type == JERRY_DATA_TYPE_STRING); JERRY_ASSERT (jerry_value_is_string (res));
sz = jerry_get_string_size (res.u.v_string); sz = jerry_get_string_size (jerry_get_string_value (res));
JERRY_ASSERT (sz == 20); JERRY_ASSERT (sz == 20);
sz = jerry_string_to_char_buffer (res.u.v_string, (jerry_char_t *) buffer, sz); sz = jerry_string_to_char_buffer (jerry_get_string_value (res), (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 20); JERRY_ASSERT (sz == 20);
jerry_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 ();