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

Update Jerry API

Browse Source 
* Removed jerry_string_t and jerry_object_t
* Updated function names
* Updated return values
* Updated function descriptions
* Added new functions
* Added new unittests

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-29 08:41:15 +02:00
parent cea3a142ac
commit 9bce5b09a9
19 changed files with 2077 additions and 2112 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/03.API-EXAMPLE.md
+108 -174
View File
@@ -6,7 +6,7 @@ This guide is intended to introduce you to JerryScript embedding API through cre
```c
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
int
main (int argc, char * argv[])
@@ -14,11 +14,9 @@ main (int argc, char * argv[])
const jerry_char_t script[] = "print ('Hello, World!');";
size_t script_size = strlen ((const char *) script);
jerry_completion_code_t return_code = jerry_run_simple (script,
script_size,
JERRY_FLAG_EMPTY);
bool ret_value = jerry_run_simple (script, script_size, JERRY_INIT_EMPTY);
return (int) return_code;
return (ret_value ? 1 : 0);
}
```
@@ -40,7 +38,7 @@ Here we perform the same actions, as `jerry_run_simple`, while splitting into se
```c
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
int
main (int argc, char * argv[])
@@ -49,28 +47,23 @@ main (int argc, char * argv[])
size_t script_size = strlen ((const char *) script);
/* Initialize engine */
jerry_init (JERRY_FLAG_EMPTY);
jerry_init (JERRY_INIT_EMPTY);
/* Setup Global scope code */
jerry_object_t *error_object_p = NULL;
if (!jerry_parse (script, script_size, &error_object_p))
{
/* Error object must be freed, if parsing failed */
jerry_release_object (error_object_p);
}
else
{
/* Execute Global scope code */
jerry_value_t error_value = jerry_create_undefined_value ();
jerry_completion_code_t return_code = jerry_run (&error_value);
jerry_value_t parsed_code = jerry_parse (script, script_size, false);
if (return_code == JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION)
{
/* Error value must be freed, if 'jerry_run' returns with an unhandled exception */
jerry_release_value (error_value);
}
if (!jerry_value_has_error_flag (parsed_code))
{
/* Execute the parsed source code in the Global scope */
jerry_value_t ret_value = jerry_run (parsed_code);
/* Returned value must be freed */
jerry_release_value (ret_value);
}
/* Parsed source code must be freed */
jerry_release_value (parsed_code);
/* Cleanup engine */
jerry_cleanup ();
@@ -84,7 +77,7 @@ Our code is more complex now, but it introduces possibilities to interact with J
```c
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
int
main (int argc, char * argv[])
@@ -93,26 +86,22 @@ main (int argc, char * argv[])
const jerry_char_t script_2[] = "print (s);";
/* Initialize engine */
jerry_init (JERRY_FLAG_EMPTY);
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t eval_ret;
/* Evaluate script1 */
jerry_eval (script_1,
strlen ((const char *) script_1),
false,
false,
&eval_ret);
eval_ret = jerry_eval (script_1,
strlen ((const char *) script_1),
false);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
/* Evaluate script2 */
jerry_eval (script_2,
strlen ((const char *) script_2),
false,
false,
&eval_ret);
eval_ret = jerry_eval (script_2,
strlen ((const char *) script_2),
false);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
@@ -130,43 +119,37 @@ This way, we execute two independent script parts in one execution environment.
```c
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
int
main (int argc, char * argv[]) {
const jerry_char_t str[] = "Hello, World!";
const jerry_char_t var_name[] = "s";
const jerry_char_t script[] = "print (s);";
/* Initializing JavaScript environment */
jerry_init (JERRY_FLAG_EMPTY);
jerry_init (JERRY_INIT_EMPTY);
/* Getting pointer to the Global object */
jerry_object_t *object_p = jerry_get_global ();
jerry_value_t global_object = jerry_get_global_object ();
/* Constructing string */
jerry_string_t *str_val_p = jerry_create_string (str);
/* Constructing strings */
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "s");
jerry_value_t prop_value = jerry_create_string (str);
/* Constructing string value descriptor */
jerry_value_t value = jerry_create_string_value (str_val_p);
/* Setting the string value as a property of the Global object */
jerry_set_property (global_object, prop_name, prop_value);
/* Setting the string value to field of the Global object */
jerry_set_object_field_value (object_p, var_name, value);
/* Releasing string values, as it is no longer necessary outside of engine */
jerry_release_value (prop_name);
jerry_release_value (prop_value);
/* Releasing string value, as it is no longer necessary outside of engine */
jerry_release_string (str_val_p);
/* Same for pointer to the Global object */
jerry_release_object (object_p);
jerry_value_t eval_ret;
/* Releasing the Global object */
jerry_release_value (global_object);
/* Now starting script that would output value of just initialized field */
jerry_eval (script,
strlen ((const char *) script),
false,
false,
&eval_ret);
jerry_value_t eval_ret = jerry_eval (script,
strlen ((const char *) script),
false);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
@@ -180,36 +163,23 @@ main (int argc, char * argv[]) {
The sample will also output 'Hello, World!'. However, now it is not just a part of the source script, but the value, dynamically supplied to the engine.
## Step 5. Description of JavaScript value descriptors
## Step 5. Description of JerryScript value descriptors
Structure, used to put values to or receive values from the engine is the following:
- `type` of the value:
- JERRY_API_DATA_TYPE_VOID (void);
- JERRY_API_DATA_TYPE_UNDEFINED (undefined);
- JERRY_API_DATA_TYPE_NULL (null);
- JERRY_API_DATA_TYPE_BOOLEAN (true / false);
- JERRY_API_DATA_TYPE_FLOAT32 (number);
- JERRY_API_DATA_TYPE_FLOAT64 (number);
- JERRY_API_DATA_TYPE_UINT32 (number);
- JERRY_API_DATA_TYPE_STRING (string);
- JERRY_API_DATA_TYPE_OBJECT (object reference);
- `v_bool` (if JERRY_API_DATA_TYPE_BOOLEAN) - boolean value;
- `v_float32` (if JERRY_API_DATA_TYPE_FLOAT32) - float value;
- `v_float64` (if JERRY_API_DATA_TYPE_FLOAT64) - double value;
- `v_uint32` (if JERRY_API_DATA_TYPE_UINT32) - 32 bit unsigned integer value;
- `v_string` (if JERRY_API_DATA_TYPE_STRING) - pointer to string;
- `v_object` (if JERRY_API_DATA_TYPE_OBJECT) - pointer to object.
Abstract values, to be sent to or received from the engine are described with the structure.
Pointers to strings or objects and values should be released just when become unnecessary, using `jerry_release_string` or `jerry_release_object` and `jerry_release_value`, correspondingly.
JerryScript value can be a boolean, number, null, object, string or undefined. The value has an error flag,
that indicates whether is an error or not. Every type has an error flag not only objects. The error flag should
be cleared before the value is passed as an argument, otherwise it can lead to a type error. The error objects
created by API functions has the error flag set.
The following example function will output a JavaScript value:
```c
#include <stdlib.h>
#include <string.h>
#include "jerry-api.h"
#include "jerry-port.h"
static void
print_value (const jerry_value_t value)
{
if (jerry_value_is_undefined (value))
@@ -240,11 +210,10 @@ print_value (const jerry_value_t value)
else if (jerry_value_is_string (value))
{
/* Determining required buffer size */
jerry_string_t *str_p = jerry_get_string_value (value);
jerry_size_t req_sz = jerry_get_string_size (str_p);
jerry_size_t req_sz = jerry_get_string_size (value);
jerry_char_t str_buf_p[req_sz];
jerry_string_to_char_buffer (str_p, str_buf_p, req_sz);
jerry_string_to_char_buffer (value, str_buf_p, req_sz);
jerry_port_logmsg (stdout, "%s", (const char *) str_buf_p);
}
@@ -273,22 +242,21 @@ Shell operation can be described with the following loop:
- loop.
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
#include "jerry-port.h"
static void print_value (const jerry_api_value_t);
int
main (int argc, char * argv[])
{
jerry_completion_code_t status = JERRY_COMPLETION_CODE_OK;
bool is_done = false;
/* Initialize engine */
jerry_init (JERRY_FLAG_EMPTY);
jerry_init (JERRY_INIT_EMPTY);
while (!is_done)
{
@@ -318,33 +286,26 @@ main (int argc, char * argv[])
jerry_value_t ret_val;
/* Evaluate entered command */
status = jerry_eval ((const jerry_char_t *) cmd,
len,
false,
false,
&ret_val);
ret_val = jerry_eval ((const jerry_char_t *) cmd,
len,
false);
/* If command evaluated successfully, print value, returned by eval */
if (status == JERRY_COMPLETION_CODE_OK)
{
/* 'eval' completed successfully */
print_value (ret_val);
}
else
if (jerry_value_has_error_flag (ret_val))
{
/* Evaluated JS code thrown an exception
* and didn't handle it with try-catch-finally */
jerry_port_errormsg ("Unhandled JS exception occured: ");
print_value (ret_val);
}
print_value (ret_val);
jerry_release_value (ret_val);
}
/* Cleanup engine */
jerry_cleanup ();
return (int) status;
return 0;
}
```
@@ -356,7 +317,7 @@ In this example we demonstrate how to use native function and structures in Java
```c
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
struct my_struct
{
@@ -366,53 +327,45 @@ struct my_struct
/**
* Get a string from a native object
*/
static bool
get_msg_handler (const jerry_object_t *function_obj_p, /**< function object */
const jerry_value_t this_p, /**< this arg */
static jerry_value_t
get_msg_handler (const jerry_value_t func_value, /**< function object */
const jerry_value_t this_value, /**< this arg */
const jerry_value_t *args_p, /**< function arguments */
const jerry_length_t args_cnt, /**< number of function arguments */
jerry_value_t *ret_val_p) /**< [out] return argument */
const jerry_length_t args_cnt) /**< number of function arguments */
{
jerry_string_t *msg_str_p = jerry_create_string ((const jerry_char_t *) my_struct.msg);
*ret_val_p = jerry_create_string_value (msg_str_p);
return true;
return jerry_create_string ((const jerry_char_t *) my_struct.msg);
} /* get_msg_handler */
int
main (int argc, char * argv[])
{
jerry_completion_code_t status = JERRY_COMPLETION_CODE_OK;
/* Initialize engine */
jerry_init (JERRY_FLAG_EMPTY);
jerry_init (JERRY_INIT_EMPTY);
/* Do something with the native object */
my_struct.msg = "Hello World";
/* Create an empty JS object */
jerry_object_t *object_p = jerry_create_object ();
jerry_value_t object = jerry_create_object ();
/* Create a JS function object and wrap into a jerry value */
jerry_object_t *func_obj_p = jerry_create_external_function (get_msg_handler);
jerry_value_t object_value = jerry_create_object_value (func_obj_p);
jerry_value_t func_obj = jerry_create_external_function (get_msg_handler);
/* Set the native function as a property of the empty JS object */
jerry_set_object_field_value (object_p,
(const jerry_char_t *) "myFunc",
object_value);
jerry_release_value (object_value);
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "myFunc");
jerry_set_property (object, prop_name, func_obj);
jerry_release_value (prop_name);
jerry_release_value (func_obj);
/* Wrap the JS object (not empty anymore) into a jerry api value */
object_value = jerry_create_object_value (object_p);
jerry_object_t *global_obj_p = jerry_get_global ();
jerry_value_t global_object = jerry_get_global_object ();
/* Add the JS object to the global context */
jerry_set_object_field_value (global_obj_p,
(const jerry_char_t *) "MyObject",
object_value);
jerry_release_value (object_value);
jerry_release_object (global_obj_p);
prop_name = jerry_create_string ((const jerry_char_t *) "MyObject");
jerry_set_property (global_object, prop_name, object);
jerry_release_value (prop_name);
jerry_release_value (object);
jerry_release_value (global_object);
/* Now we have a "builtin" object called MyObject with a function called myFunc()
*
@@ -425,14 +378,8 @@ main (int argc, char * argv[])
";
size_t script_size = strlen ((const char *) script);
jerry_value_t eval_ret;
/* Evaluate script */
status = jerry_eval (script,
script_size,
false,
false,
&eval_ret);
jerry_value_t eval_ret = jerry_eval (script, script_size, false);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
@@ -440,7 +387,7 @@ main (int argc, char * argv[])
/* Cleanup engine */
jerry_cleanup ();
return (int) status;
return 0;
}
```
@@ -456,48 +403,46 @@ Here we create a JS Object with `jerry_eval`, then extend it with a native funct
```c
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
/**
* Add param to 'this.x'
*/
static bool
add_handler (const jerry_object_t *function_obj_p, /**< function object */
const jerry_value_t this_p, /**< this arg */
static jerry_value_t
add_handler (const jerry_value_t func_value, /**< function object */
const jerry_value_t this_val, /**< this arg */
const jerry_value_t *args_p, /**< function arguments */
const jerry_length_t args_cnt, /**< number of function arguments */
jerry_value_t *ret_val_p) /**< [out] return argument */
const jerry_length_t args_cnt) /**< number of function arguments */
{
/* Get 'this.x' */
jerry_value_t x_val = jerry_get_object_field_value (jerry_get_object_value (this_p),
(const jerry_char_t *) "x");
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "x");
jerry_value_t x_val = jerry_get_property (this_val, prop_name);
if (!jerry_value_is_error (x_val))
if (!jerry_value_has_error_flag (x_val))
{
/* Convert Jerry API values to double */
double x = jerry_get_number_value (x_val);
double d = jerry_get_number_value (*args_p);
/* Add the parameter to 'x' */
jerry_value_t res_val = jerry_create_number_value (x + d);
jerry_value_t res_val = jerry_create_number (x + d);
/* Set the new value of 'this.x' */
jerry_set_object_field_value (jerry_get_object_value (this_p),
(const jerry_char_t *) "x",
res_val);
jerry_set_property (this_val, prop_name, res_val);
jerry_release_value (res_val);
}
return true;
jerry_release_value (x_val);
jerry_release_value (prop_name);
return jerry_create_undefined ();
} /* add_handler */
int
main (int argc, char * argv[])
{
jerry_completion_code_t status = JERRY_COMPLETION_CODE_OK;
/* Initialize engine */
jerry_init (JERRY_FLAG_EMPTY);
jerry_init (JERRY_INIT_EMPTY);
/* Create a JS object */
const jerry_char_t my_js_object[] = " \
@@ -514,23 +459,18 @@ main (int argc, char * argv[])
jerry_value_t my_js_obj_val;
/* Evaluate script */
status = jerry_eval (my_js_object,
strlen ((const char *) my_js_object),
false,
false,
&my_js_obj_val);
jerry_object_t *object_p = jerry_get_object_value (my_js_obj_val);
my_js_obj_val = jerry_eval (my_js_object,
strlen ((const char *) my_js_object),
false);
/* Create a JS function object and wrap into a jerry value */
jerry_object_t *add_func_obj_p = jerry_create_external_function (add_handler);
jerry_value_t object_value = jerry_create_object_value (add_func_obj_p);
jerry_value_t add_func_obj = jerry_create_external_function (add_handler);
/* Set the native function as a property of previously created MyObject */
jerry_set_object_field_value (object_p,
(const jerry_char_t *) "add2x",
object_value);
jerry_release_value (object_value);
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "add2x");
jerry_set_property (my_js_obj_val, prop_name, add_func_obj);
jerry_release_value (add_func_obj);
jerry_release_value (prop_name);
/* Free JavaScript value, returned by eval (my_js_object) */
jerry_release_value (my_js_obj_val);
@@ -543,14 +483,8 @@ main (int argc, char * argv[])
";
size_t script_size = strlen ((const char *) script);
jerry_value_t eval_ret;
/* Evaluate script */
status = jerry_eval (script,
script_size,
false,
false,
&eval_ret);
jerry_value_t eval_ret = jerry_eval (script, script_size, false);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
@@ -558,7 +492,7 @@ main (int argc, char * argv[])
/* Cleanup engine */
jerry_cleanup ();
return (int) status;
return 0;
}
```
jerry-core/ecma/base/ecma-gc.c
+2 -1
View File
@@ -1,4 +1,5 @@
/* Copyright 2014-2016 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -502,7 +503,7 @@ ecma_gc_sweep (ecma_object_t *object_p) /**< object to free */
} /* ecma_gc_sweep */
/**
* Run garbage collecting
* Run garbage collection
*/
void
ecma_gc_run (void)
jerry-core/ecma/operations/ecma-eval.c
+9 -20
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);
ret_value = ecma_op_eval_chars_buffer ((jerry_char_t *) code_utf8_buffer_p,
ret_value = ecma_op_eval_chars_buffer (code_utf8_buffer_p,
chars_num,
is_direct,
is_called_from_strict_mode_code);
@@ -77,39 +77,28 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */
* @return ecma value
*/
ecma_value_t
ecma_op_eval_chars_buffer (const jerry_char_t *code_p, /**< code characters buffer */
ecma_op_eval_chars_buffer (const lit_utf8_byte_t *code_p, /**< code characters buffer */
size_t code_buffer_size, /**< size of the buffer */
bool is_direct, /**< is eval called directly (ECMA-262 v5, 15.1.2.1.1) */
bool is_called_from_strict_mode_code) /**< is eval is called from strict mode code */
{
JERRY_ASSERT (code_p != NULL);
ecma_value_t ret_value;
ecma_compiled_code_t *bytecode_data_p;
jsp_status_t parse_status;
bool is_strict_call = (is_direct && is_called_from_strict_mode_code);
jerry_object_t *error_obj_p = NULL;
parse_status = parser_parse_eval (code_p,
code_buffer_size,
is_strict_call,
&bytecode_data_p,
&error_obj_p);
ecma_value_t parse_status = parser_parse_script (code_p,
code_buffer_size,
is_strict_call,
&bytecode_data_p);
if (parse_status == JSP_STATUS_OK)
if (ECMA_IS_VALUE_ERROR (parse_status))
{
ret_value = vm_run_eval (bytecode_data_p, is_direct);
}
else
{
JERRY_ASSERT (parse_status == JSP_STATUS_SYNTAX_ERROR);
ret_value = ecma_make_error_obj_value (error_obj_p);
return parse_status;
}
return ret_value;
return vm_run_eval (bytecode_data_p, is_direct);
} /* ecma_op_eval_chars_buffer */
/**
jerry-core/ecma/operations/ecma-eval.h
+1 -1
View File
@@ -30,7 +30,7 @@ extern ecma_value_t
ecma_op_eval (ecma_string_t *, bool, bool);
extern ecma_value_t
ecma_op_eval_chars_buffer (const jerry_char_t *, size_t, bool, bool);
ecma_op_eval_chars_buffer (const lit_utf8_byte_t *, size_t, bool, bool);
/**
* @}
jerry-core/ecma/operations/ecma-objects.c
+7 -3
View File
@@ -1,4 +1,5 @@
/* Copyright 2014-2016 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -277,8 +278,11 @@ ecma_op_object_put (ecma_object_t *obj_p, /**< the object */
* See also:
* ECMA-262 v5, 8.6.2; ECMA-262 v5, Table 8
*
* @return ecma value
* Returned value must be freed with ecma_free_value
* Note:
* returned value must be freed with ecma_free_value
*
* @return true, if deleted successfully
* false or type error otherwise (based in 'is_throw')
*/
ecma_value_t
ecma_op_object_delete (ecma_object_t *obj_p, /**< the object */
@@ -315,7 +319,7 @@ ecma_op_object_delete (ecma_object_t *obj_p, /**< the object */
{
JERRY_ASSERT (false);
return ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
return ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE);
}
}
} /* ecma_op_object_delete */
jerry-core/jerry-api.h
+165 -80
View File
@@ -20,6 +20,7 @@
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/types.h>
#ifdef __cplusplus
@@ -32,15 +33,26 @@ extern "C"
*/
/**
* Jerry completion codes
* Major version of JerryScript API
*/
#define JERRY_API_MAJOR_VERSION 1
/**
* Minor version of JerryScript API
*/
#define JERRY_API_MINOR_VERSION 0
/**
* Jerry init flags
*/
typedef enum
{
JERRY_COMPLETION_CODE_OK = 0, /**< successful completion */
JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION = 1, /**< exception occured and it was not handled */
JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_VERSION = 2, /**< snapshot version mismatch */
JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT = 3, /**< snapshot format is not valid */
} jerry_completion_code_t;
JERRY_INIT_EMPTY = (0u), /**< empty flag set */
JERRY_INIT_ENABLE_LOG = (1u << 0), /**< enable logging */
JERRY_INIT_SHOW_OPCODES = (1u << 1), /**< dump byte-code to stdout after parse */
JERRY_INIT_MEM_STATS = (1u << 2), /**< dump memory statistics */
JERRY_INIT_MEM_STATS_SEPARATE = (1u << 3), /**< dump memory statistics and reset peak values after parse */
} jerry_init_flag_t;
/**
* Jerry API Error object types
@@ -76,29 +88,61 @@ typedef uint32_t jerry_size_t;
*/
typedef uint32_t jerry_length_t;
/**
* Jerry's string value
*/
typedef struct ecma_string_t jerry_string_t;
/**
* Jerry's object value
*/
typedef struct ecma_object_t jerry_object_t;
/**
* Description of a JerryScript value
*/
typedef uint32_t jerry_value_t;
/**
* Description of ECMA property descriptor
*/
typedef struct
{
/** Is [[Value]] defined? */
bool is_value_defined;
/** Is [[Get]] defined? */
bool is_get_defined;
/** Is [[Set]] defined? */
bool is_set_defined;
/** Is [[Writable]] defined? */
bool is_writable_defined;
/** [[Writable]] */
bool is_writable;
/** Is [[Enumerable]] defined? */
bool is_enumerable_defined;
/** [[Enumerable]] */
bool is_enumerable;
/** Is [[Configurable]] defined? */
bool is_configurable_defined;
/** [[Configurable]] */
bool is_configurable;
/** [[Value]] */
jerry_value_t value;
/** [[Get]] */
jerry_value_t getter;
/** [[Set]] */
jerry_value_t setter;
} jerry_property_descriptor_t;
/**
* Type of an external function handler
*/
typedef bool (*jerry_external_handler_t) (const jerry_object_t *function_obj_p,
const jerry_value_t this_val,
const jerry_value_t args_p[],
const jerry_length_t args_count,
jerry_value_t *ret_val_p);
typedef jerry_value_t (*jerry_external_handler_t) (const jerry_value_t function_obj_p,
const jerry_value_t this_val,
const jerry_value_t args_p[],
const jerry_length_t args_count);
/**
* Native free callback of an object
@@ -106,22 +150,49 @@ typedef bool (*jerry_external_handler_t) (const jerry_object_t *function_obj_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 data property of an object
*/
typedef bool (*jerry_object_field_foreach_t) (const jerry_string_t *field_name_p,
const jerry_value_t field_value,
void *user_data_p);
typedef bool (*jerry_object_property_foreach_t) (const jerry_value_t property_name_p,
const jerry_value_t property_value,
void *user_data_p);
/**
* Logger functions
*/
#ifdef JERRY_ENABLE_LOG
extern int jerry_debug_level;
extern FILE *jerry_log_file;
#endif /* JERRY_ENABLE_LOG */
/**
* General engine functions
*/
void jerry_init (jerry_init_flag_t);
void jerry_cleanup (void);
void jerry_register_magic_strings (const jerry_char_ptr_t *, uint32_t, const jerry_length_t *);
void jerry_get_memory_limits (size_t *, size_t *);
void jerry_gc (void);
/**
* Parser and executor functions
*/
bool jerry_run_simple (const jerry_char_t *, size_t, jerry_init_flag_t);
jerry_value_t jerry_parse (const jerry_char_t *, size_t, bool);
jerry_value_t jerry_run (const jerry_value_t);
jerry_value_t jerry_eval (const jerry_char_t *, size_t, bool);
/**
* Get the global context
*/
jerry_object_t *jerry_get_global (void);
jerry_value_t jerry_get_global_object (void);
/**
* Checker functions of 'jerry_value_t'
*/
bool jerry_value_is_array (const jerry_value_t);
bool jerry_value_is_boolean (const jerry_value_t);
bool jerry_value_is_error (const jerry_value_t);
bool jerry_value_is_constructor (const jerry_value_t);
bool jerry_value_is_function (const jerry_value_t);
bool jerry_value_is_number (const jerry_value_t);
bool jerry_value_is_null (const jerry_value_t);
@@ -129,13 +200,30 @@ bool jerry_value_is_object (const jerry_value_t);
bool jerry_value_is_string (const jerry_value_t);
bool jerry_value_is_undefined (const jerry_value_t);
/**
* Error flag manipulation functions
*/
bool jerry_value_has_error_flag (const jerry_value_t);
void jerry_value_clear_error_flag (jerry_value_t *);
void jerry_value_set_error_flag (jerry_value_t *);
/**
* Getter functions of 'jerry_value_t'
*/
bool jerry_get_boolean_value (const jerry_value_t);
double jerry_get_number_value (const jerry_value_t);
jerry_string_t *jerry_get_string_value (const jerry_value_t);
jerry_object_t *jerry_get_object_value (const jerry_value_t);
/**
* Functions for string values
*/
jerry_size_t jerry_get_string_size (const jerry_value_t);
jerry_length_t jerry_get_string_length (const jerry_value_t);
jerry_size_t jerry_string_to_char_buffer (const jerry_value_t, jerry_char_t *, jerry_size_t);
/**
* Functions for array object values
*/
uint32_t jerry_get_array_length (const jerry_value_t);
/**
* Converters of 'jerry_value_t'
@@ -143,75 +231,72 @@ jerry_object_t *jerry_get_object_value (const jerry_value_t);
bool jerry_value_to_boolean (const jerry_value_t);
jerry_value_t jerry_value_to_number (const jerry_value_t);
jerry_value_t jerry_value_to_object (const jerry_value_t);
jerry_value_t jerry_value_to_primitive (const jerry_value_t);
jerry_value_t jerry_value_to_string (const jerry_value_t);
jerry_value_t jerry_value_remove_error_flag (const jerry_value_t);
/**
* Create functions of 'jerry_value_t'
*/
jerry_value_t jerry_create_null_value (void);
jerry_value_t jerry_create_undefined_value (void);
jerry_value_t jerry_create_boolean_value (bool);
jerry_value_t jerry_create_number_value (double);
jerry_value_t jerry_create_object_value (jerry_object_t *);
jerry_value_t jerry_create_string_value (jerry_string_t *);
/**
* Acquire types with reference counter (increase the references)
*/
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);
/**
* Relase the referenced values
*/
void jerry_release_object (jerry_object_t *);
void jerry_release_string (jerry_string_t *);
void jerry_release_value (jerry_value_t);
/**
* Create functions of API objects
* Create functions of API values
*/
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);
/**
* Functions of array objects
*/
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 *);
uint32_t jerry_get_array_length (const jerry_object_t *);
/**
* Functions of 'jerry_string_t'
*/
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);
jerry_value_t jerry_create_array (uint32_t);
jerry_value_t jerry_create_boolean (bool);
jerry_value_t jerry_create_error (jerry_error_t, const jerry_char_t *);
jerry_value_t jerry_create_error_sz (jerry_error_t, const jerry_char_t *, jerry_size_t);
jerry_value_t jerry_create_external_function (jerry_external_handler_t);
jerry_value_t jerry_create_number (double);
jerry_value_t jerry_create_null (void);
jerry_value_t jerry_create_object (void);
jerry_value_t jerry_create_string (const jerry_char_t *);
jerry_value_t jerry_create_string_sz (const jerry_char_t *, jerry_size_t);
jerry_value_t jerry_create_undefined (void);
/**
* General API functions of JS objects
*/
bool jerry_is_array (const jerry_object_t *);
bool jerry_is_constructor (const jerry_object_t *);
bool jerry_is_function (const jerry_object_t *);
bool jerry_add_object_field (jerry_object_t *, const jerry_char_t *, jerry_size_t, const jerry_value_t, bool);
bool jerry_delete_object_field (jerry_object_t *, const jerry_char_t *, jerry_size_t);
jerry_value_t jerry_get_object_field_value (jerry_object_t *, const jerry_char_t *);
jerry_value_t jerry_get_object_field_value_sz (jerry_object_t *, const jerry_char_t *, jerry_size_t);
bool jerry_set_object_field_value (jerry_object_t *, const jerry_char_t *, const jerry_value_t);
bool jerry_set_object_field_value_sz (jerry_object_t *, const jerry_char_t *, jerry_size_t, const jerry_value_t);
bool jerry_foreach_object_field (jerry_object_t *, jerry_object_field_foreach_t, void *);
bool jerry_get_object_native_handle (jerry_object_t *, uintptr_t *);
void jerry_set_object_native_handle (jerry_object_t *, uintptr_t, jerry_object_free_callback_t);
jerry_value_t jerry_construct_object (jerry_object_t *, const jerry_value_t[], uint16_t);
jerry_value_t jerry_call_function (jerry_object_t *, jerry_object_t *, const jerry_value_t[], uint16_t);
bool jerry_has_property (const jerry_value_t, const jerry_value_t);
bool jerry_has_own_property (const jerry_value_t, const jerry_value_t);
bool jerry_delete_property (const jerry_value_t, const jerry_value_t);
jerry_value_t jerry_get_property (const jerry_value_t, const jerry_value_t);
jerry_value_t jerry_get_property_by_index (const jerry_value_t , uint32_t);
jerry_value_t jerry_set_property (const jerry_value_t, const jerry_value_t, const jerry_value_t);
jerry_value_t jerry_set_property_by_index (const jerry_value_t, uint32_t, const jerry_value_t);
void jerry_init_property_descriptor_fields (jerry_property_descriptor_t *);
jerry_value_t jerry_define_own_property (const jerry_value_t,
const jerry_value_t,
const jerry_property_descriptor_t *);
bool jerry_get_own_property_descriptor (const jerry_value_t,
const jerry_value_t,
jerry_property_descriptor_t *);
void jerry_free_property_descriptor_fields (const jerry_property_descriptor_t *);
jerry_value_t jerry_call_function (const jerry_value_t, const jerry_value_t, const jerry_value_t[], jerry_size_t);
jerry_value_t jerry_construct_object (const jerry_value_t, const jerry_value_t[], jerry_size_t);
jerry_value_t jerry_get_object_keys (const jerry_value_t);
jerry_value_t jerry_get_prototype (const jerry_value_t);
jerry_value_t jerry_set_prototype (const jerry_value_t, const jerry_value_t);
bool jerry_get_object_native_handle (const jerry_value_t, uintptr_t *);
void jerry_set_object_native_handle (const jerry_value_t, uintptr_t, jerry_object_free_callback_t);
bool jerry_foreach_object_property (const jerry_value_t, jerry_object_property_foreach_t, void *);
/**
* Snapshot functions
*/
size_t jerry_parse_and_save_snapshot (const jerry_char_t *, size_t, bool, bool, uint8_t *, size_t);
jerry_value_t jerry_exec_snapshot (const void *, size_t, bool);
/**
* @}
jerry-core/jerry.c
+1382 -1292
View File
File diff suppressed because it is too large Load Diff
jerry-core/jerry.h
-91
View File
@@ -1,91 +0,0 @@
/* Copyright 2015-2016 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef JERRY_H
#define JERRY_H
#include <stddef.h>
#include <stdint.h>
#include "jerry-api.h"
#include "jerry-port.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/** \addtogroup jerry Jerry engine interface
* @{
*/
/**
* Jerry flags
*/
typedef enum
{
JERRY_FLAG_EMPTY = (0u), /**< empty flag set */
JERRY_FLAG_SHOW_OPCODES = (1u << 0), /**< dump byte-code to stdout after parse */
JERRY_FLAG_MEM_STATS = (1u << 1), /**< dump memory statistics */
JERRY_FLAG_MEM_STATS_SEPARATE = (1u << 2), /**< dump memory statistics and reset peak values after parse */
JERRY_FLAG_PARSE_ONLY = (1u << 3), /**< parse only, prevents script execution */
JERRY_FLAG_ENABLE_LOG = (1u << 4), /**< enable logging */
} jerry_flag_t;
/**
* Jerry engine build date
*/
extern const char * const jerry_build_date;
/**
* Jerry engine build commit hash
*/
extern const char * const jerry_commit_hash;
/**
* Jerry engine build branch name
*/
extern const char * const jerry_branch_name;
#ifdef JERRY_ENABLE_LOG
extern int jerry_debug_level;
extern FILE *jerry_log_file;
#endif /* JERRY_ENABLE_LOG */
void jerry_init (jerry_flag_t);
void jerry_cleanup (void);
void jerry_get_memory_limits (size_t *, size_t *);
bool jerry_parse (const jerry_char_t *, size_t, jerry_object_t **);
jerry_completion_code_t jerry_run (jerry_value_t *);
jerry_completion_code_t jerry_run_simple (const jerry_char_t *, size_t, jerry_flag_t);
jerry_completion_code_t jerry_eval (const jerry_char_t *, size_t, bool, bool, jerry_value_t *);
void jerry_gc (void);
void jerry_register_external_magic_strings (const jerry_char_ptr_t *, uint32_t, const jerry_length_t *);
size_t jerry_parse_and_save_snapshot (const jerry_char_t *, size_t, bool, uint8_t *, size_t);
jerry_completion_code_t jerry_exec_snapshot (const void *, size_t, bool, jerry_value_t *);
/**
* @}
*/
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* !JERRY_H */
jerry-core/jrt/jrt.h
+2 -1
View File
@@ -20,7 +20,8 @@
#include <stdio.h>
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
#include "jerry-port.h"
#include "jrt-types.h"
/**
jerry-core/lit/lit-globals.h
+1
View File
@@ -1,4 +1,5 @@
/* Copyright 2015-2016 Samsung Electronics Co., Ltd.
* Copyright 2016 University of Szeged.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
jerry-core/parser/js/js-parser-internal.h
+1
View File
@@ -19,6 +19,7 @@
#include "common.h"
#include "byte-code.h"
#include "js-parser.h"
#include "js-parser-limits.h"
#include "js-lexer.h"
jerry-core/parser/js/js-parser.c
+12 -36
View File
@@ -14,6 +14,7 @@
* limitations under the License.
*/
#include "ecma-exceptions.h"
#include "ecma-helpers.h"
#include "ecma-literal-storage.h"
#include "js-parser-internal.h"
@@ -2238,52 +2239,27 @@ parser_set_show_instrs (int show_instrs) /**< flag indicating whether to dump by
* Parse EcamScript source code
*
* Note:
* returned error object should be freed with jerry_release_object
*/
jsp_status_t
parser_parse_script (const jerry_char_t *source_p, /**< source code */
size_t size, /**< size of the source code */
ecma_compiled_code_t **bytecode_data_p, /**< [out] JS bytecode */
jerry_object_t **error_obj_p) /**< [out] error object */
{
parser_error_location parse_error;
*bytecode_data_p = parser_parse_source (source_p, size, false, &parse_error);
if (!*bytecode_data_p)
{
*error_obj_p = jerry_create_error (JERRY_ERROR_SYNTAX,
(const jerry_char_t *) parser_error_to_string (parse_error.error));
return JSP_STATUS_SYNTAX_ERROR;
}
return JSP_STATUS_OK;
} /* parser_parse_script */
/**
* Parse EcamScript eval source code
* returned value must be freed with ecma_free_value
*
* Note:
* returned error object should be freed with jerry_release_object
* @return true - if success
* syntax error - otherwise
*/
jsp_status_t
parser_parse_eval (const jerry_char_t *source_p, /**< source code */
size_t size, /**< size of the source code */
bool is_strict, /**< strict mode */
ecma_compiled_code_t **bytecode_data_p, /**< [out] JS bytecode */
jerry_object_t **error_obj_p) /**< [out] error object */
ecma_value_t
parser_parse_script (const uint8_t *source_p, /**< source code */
size_t size, /**< size of the source code */
bool is_strict, /**< strict mode */
ecma_compiled_code_t **bytecode_data_p) /**< [out] JS bytecode */
{
parser_error_location parse_error;
*bytecode_data_p = parser_parse_source (source_p, size, is_strict, &parse_error);
if (!*bytecode_data_p)
{
*error_obj_p = jerry_create_error (JERRY_ERROR_SYNTAX,
(const jerry_char_t *) parser_error_to_string (parse_error.error));
return JSP_STATUS_SYNTAX_ERROR;
return ecma_raise_syntax_error (parser_error_to_string (parse_error.error));
}
return JSP_STATUS_OK;
} /* parser_parse_eval */
return ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE);
} /* parser_parse_script */
/**
* @}
jerry-core/parser/js/js-parser.h
+2 -19
View File
@@ -17,7 +17,7 @@
#ifndef JS_PARSER_H
#define JS_PARSER_H
#include "byte-code.h"
#include "ecma-globals.h"
/** \addtogroup parser Parser
* @{
@@ -128,25 +128,8 @@ typedef struct
parser_line_counter_t column; /**< column where the error occured */
} parser_error_location;
/**
* Parser completion status
*/
typedef enum
{
JSP_STATUS_OK, /**< parse finished successfully, no early errors occured */
JSP_STATUS_SYNTAX_ERROR, /**< SyntaxError early error occured */
} jsp_status_t;
/* Note: source must be a valid UTF-8 string */
extern jsp_status_t parser_parse_script (const jerry_char_t *,
size_t,
ecma_compiled_code_t **,
jerry_object_t **);
extern jsp_status_t parser_parse_eval (const jerry_char_t *,
size_t,
bool,
ecma_compiled_code_t **,
jerry_object_t **);
extern ecma_value_t parser_parse_script (const uint8_t *, size_t, bool, ecma_compiled_code_t **);
const char *parser_error_to_string (parser_error_t);
jerry-core/vm/vm.c
+6 -53
View File
@@ -54,11 +54,6 @@ static vm_frame_ctx_t *vm_top_context_p = NULL;
*/
static bool is_direct_eval_form_call = false;
/**
* Program bytecode pointer
*/
static ecma_compiled_code_t *__program = NULL;
/**
* Get the value of object[property].
*
@@ -193,17 +188,6 @@ vm_op_set_value (ecma_value_t object, /**< base object */
return completion_value;
} /* vm_op_set_value */
/**
* Initialize interpreter.
*/
void
vm_init (ecma_compiled_code_t *program_p) /**< pointer to byte-code data */
{
JERRY_ASSERT (__program == NULL);
__program = program_p;
} /* vm_init */
#define CBC_OPCODE(arg1, arg2, arg3, arg4) arg4,
/**
@@ -221,44 +205,27 @@ static const uint16_t vm_decode_table[] =
* Run global code
*
* Note:
* returned error value should be freed with jerry_release_value
* just when the value becomes unnecessary.
* returned value must be freed with ecma_free_value, when it is no longer needed.
*
* @return completion code
* @return ecma value
*/
jerry_completion_code_t
vm_run_global (ecma_value_t *error_value_p) /**< [out] error value */
ecma_value_t
vm_run_global (const ecma_compiled_code_t *bytecode_p) /**< pointer to bytecode to run */
{
jerry_completion_code_t ret_code;
JERRY_ASSERT (__program != NULL);
ecma_object_t *glob_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL);
ecma_object_t *lex_env_p = ecma_get_global_environment ();
ecma_value_t ret_value = vm_run (__program,
ecma_value_t ret_value = vm_run (bytecode_p,
ecma_make_object_value (glob_obj_p),
lex_env_p,
false,
NULL,
0);
if (ECMA_IS_VALUE_ERROR (ret_value))
{
*error_value_p = ret_value;
ret_code = JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION;
}
else
{
ecma_free_value (ret_value);
*error_value_p = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
ret_code = JERRY_COMPLETION_CODE_OK;
}
ecma_deref_object (glob_obj_p);
ecma_deref_object (lex_env_p);
return ret_code;
return ret_value;
} /* vm_run_global */
/**
@@ -562,20 +529,6 @@ opfunc_construct (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
} \
while (0)
/**
* Cleanup interpreter
*/
void
vm_finalize (void)
{
if (__program)
{
ecma_bytecode_deref (__program);
}
__program = NULL;
} /* vm_finalize */
/**
* Run initializer byte codes.
*
jerry-core/vm/vm.h
+1 -3
View File
@@ -275,9 +275,7 @@ typedef enum
VM_EXEC_CONSTRUCT, /**< construct a new object */
} vm_call_operation;
extern void vm_init (ecma_compiled_code_t *);
extern void vm_finalize (void);
extern jerry_completion_code_t vm_run_global (ecma_value_t *);
extern ecma_value_t vm_run_global (const ecma_compiled_code_t *);
extern ecma_value_t vm_run_eval (ecma_compiled_code_t *, bool);
extern ecma_value_t vm_run (const ecma_compiled_code_t *, ecma_value_t,
main-mcu.c
+3 -10
View File
@@ -14,7 +14,7 @@
* limitations under the License.
*/
#include "jerry.h"
#include "jerry-api.h"
/**
* Standalone Jerry exit codes
@@ -32,14 +32,7 @@ main (void)
const char *source_p = generated_source;
const size_t source_size = sizeof (generated_source);
jerry_completion_code_t ret_code = jerry_run_simple ((jerry_char_t *) source_p, source_size, JERRY_FLAG_EMPTY);
bool ret_code = jerry_run_simple ((jerry_char_t *) source_p, source_size, JERRY_INIT_EMPTY);
if (ret_code == JERRY_COMPLETION_CODE_OK)
{
return JERRY_STANDALONE_EXIT_CODE_OK;
}
else
{
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
return (ret_code ? JERRY_STANDALONE_EXIT_CODE_OK : JERRY_STANDALONE_EXIT_CODE_FAIL);
} /* main */
main-unix.c
+68 -96
View File
@@ -19,7 +19,7 @@
#include <stdlib.h>
#include <string.h>
#include "jerry.h"
#include "jerry-api.h"
#include "jerry-port.h"
#include "jerry-port-default.h"
@@ -71,18 +71,17 @@ read_file (const char *file_name,
*
* @return true - if only one argument was passed and the argument is a boolean true.
*/
static bool
assert_handler (const jerry_object_t *function_obj_p __attribute__((unused)), /**< function object */
static jerry_value_t
assert_handler (const jerry_value_t func_obj_val __attribute__((unused)), /**< function object */
const jerry_value_t this_p __attribute__((unused)), /**< this arg */
const jerry_value_t args_p[], /**< function arguments */
const jerry_length_t args_cnt, /**< number of function arguments */
jerry_value_t *ret_val_p __attribute__((unused))) /**< return argument */
const jerry_length_t args_cnt) /**< number of function arguments */
{
if (args_cnt == 1
&& jerry_value_is_boolean (args_p[0])
&& jerry_get_boolean_value (args_p[0]))
{
return true;
return jerry_create_boolean (true);
}
else
{
@@ -143,11 +142,12 @@ main (int argc,
// FIXME:
// jrt_set_mem_limits (max_data_bss_size, max_stack_size);
jerry_flag_t flags = JERRY_FLAG_EMPTY;
jerry_init_flag_t flags = JERRY_INIT_EMPTY;
const char *exec_snapshot_file_names[JERRY_MAX_COMMAND_LINE_ARGS];
int exec_snapshots_count = 0;
bool is_parse_only = false;
bool is_save_snapshot_mode = false;
bool is_save_snapshot_mode_for_global_or_eval = false;
const char *save_snapshot_file_name_p = NULL;
@@ -166,27 +166,24 @@ main (int argc,
}
else if (!strcmp ("-v", argv[i]) || !strcmp ("--version", argv[i]))
{
printf ("Build date: \t%s\n", jerry_build_date);
printf ("Commit hash:\t%s\n", jerry_commit_hash);
printf ("Branch name:\t%s\n", jerry_branch_name);
printf ("\n");
printf ("Version: \t%d.%d\n\n", JERRY_API_MAJOR_VERSION, JERRY_API_MINOR_VERSION);
return JERRY_STANDALONE_EXIT_CODE_OK;
}
else if (!strcmp ("--mem-stats", argv[i]))
{
flags |= JERRY_FLAG_MEM_STATS;
flags |= JERRY_INIT_MEM_STATS;
}
else if (!strcmp ("--mem-stats-separate", argv[i]))
{
flags |= JERRY_FLAG_MEM_STATS_SEPARATE;
flags |= JERRY_INIT_MEM_STATS_SEPARATE;
}
else if (!strcmp ("--parse-only", argv[i]))
{
flags |= JERRY_FLAG_PARSE_ONLY;
is_parse_only = true;
}
else if (!strcmp ("--show-opcodes", argv[i]))
{
flags |= JERRY_FLAG_SHOW_OPCODES;
flags |= JERRY_INIT_SHOW_OPCODES;
}
else if (!strcmp ("--save-snapshot-for-global", argv[i])
|| !strcmp ("--save-snapshot-for-eval", argv[i]))
@@ -208,7 +205,6 @@ main (int argc,
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
flags |= JERRY_FLAG_PARSE_ONLY;
save_snapshot_file_name_p = argv[i];
}
else if (!strcmp ("--exec-snapshot", argv[i]))
@@ -240,7 +236,7 @@ main (int argc,
}
#ifdef JERRY_ENABLE_LOG
flags |= JERRY_FLAG_ENABLE_LOG;
flags |= JERRY_INIT_ENABLE_LOG;
jerry_debug_level = argv[i][0] - '0';
#endif /* JERRY_ENABLE_LOG */
}
@@ -254,7 +250,7 @@ main (int argc,
}
#ifdef JERRY_ENABLE_LOG
flags |= JERRY_FLAG_ENABLE_LOG;
flags |= JERRY_INIT_ENABLE_LOG;
log_file_name = argv[i];
#endif /* JERRY_ENABLE_LOG */
}
@@ -313,23 +309,22 @@ main (int argc,
jerry_init (flags);
jerry_object_t *global_obj_p = jerry_get_global ();
jerry_object_t *assert_func_p = jerry_create_external_function (assert_handler);
jerry_value_t assert_value = jerry_create_object_value (assert_func_p);
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t assert_value = jerry_create_external_function (assert_handler);
bool is_assert_added = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "assert",
assert_value);
jerry_value_t assert_func_name_val = jerry_create_string ((jerry_char_t *) "assert");
bool is_assert_added = jerry_set_property (global_obj_val, assert_func_name_val, assert_value);
jerry_release_value (assert_func_name_val);
jerry_release_value (assert_value);
jerry_release_object (global_obj_p);
jerry_release_value (global_obj_val);
if (!is_assert_added)
{
jerry_port_errormsg ("Warning: failed to register 'assert' method.");
}
jerry_completion_code_t ret_code = JERRY_COMPLETION_CODE_OK;
jerry_value_t ret_value = jerry_create_undefined ();
for (int i = 0; i < exec_snapshots_count; i++)
{
@@ -338,28 +333,22 @@ main (int argc,
if (snapshot_p == NULL)
{
ret_code = JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION;
ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) "");
}
else
{
jerry_value_t ret_value;
ret_code = jerry_exec_snapshot ((void *) snapshot_p,
snapshot_size,
true,
&ret_value);
assert (jerry_value_is_undefined (ret_value));
ret_value = jerry_exec_snapshot ((void *) snapshot_p,
snapshot_size,
true);
}
if (ret_code != JERRY_COMPLETION_CODE_OK)
if (jerry_value_has_error_flag (ret_value))
{
break;
}
}
jerry_object_t *err_obj_p = NULL;
jerry_value_t err_value = jerry_create_undefined_value ();
if (ret_code == JERRY_COMPLETION_CODE_OK)
if (!jerry_value_has_error_flag (ret_value))
{
for (int i = 0; i < files_counter; i++)
{
@@ -368,7 +357,7 @@ main (int argc,
if (source_p == NULL)
{
ret_code = JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION;
ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) "");
}
if (is_save_snapshot_mode)
@@ -378,11 +367,12 @@ main (int argc,
size_t snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) source_p,
source_size,
is_save_snapshot_mode_for_global_or_eval,
false,
snapshot_save_buffer,
JERRY_BUFFER_SIZE);
if (snapshot_size == 0)
{
ret_code = JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION;
ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) "");
}
else
{
@@ -393,18 +383,17 @@ main (int argc,
}
else
{
if (!jerry_parse (source_p, source_size, &err_obj_p))
ret_value = jerry_parse (source_p, source_size, false);
if (!jerry_value_has_error_flag (ret_value) && !is_parse_only)
{
/* unhandled SyntaxError */
ret_code = JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION;
}
else if ((flags & JERRY_FLAG_PARSE_ONLY) == 0)
{
ret_code = jerry_run (&err_value);
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
}
}
if (ret_code != JERRY_COMPLETION_CODE_OK)
if (jerry_value_has_error_flag (ret_value))
{
break;
}
@@ -416,16 +405,18 @@ main (int argc,
const char *prompt = "jerry> ";
bool is_done = false;
jerry_object_t *global_obj_p = jerry_get_global ();
jerry_value_t print_function = jerry_get_object_field_value (global_obj_p,
(jerry_char_t *) "print");
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t print_func_name_val = jerry_create_string ((jerry_char_t *) "print");
jerry_value_t print_function = jerry_get_property (global_obj_val, print_func_name_val);
if (jerry_value_is_error (print_function))
jerry_release_value (print_func_name_val);
if (jerry_value_has_error_flag (print_function))
{
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
if (!jerry_is_function (jerry_get_object_value (print_function)))
if (!jerry_value_is_function (print_function))
{
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
@@ -457,22 +448,21 @@ main (int argc,
if (len > 0)
{
/* Evaluate the line */
jerry_value_t ret_val;
ret_code = jerry_eval (buffer, len, false, false, &ret_val);
jerry_value_t ret_val_eval = jerry_eval (buffer, len, false);
/* Print return value */
const jerry_value_t args[] = { ret_val };
jerry_value_t ret_val_print = jerry_call_function (jerry_get_object_value (print_function),
NULL,
const jerry_value_t args[] = { ret_val_eval };
jerry_value_t ret_val_print = jerry_call_function (print_function,
jerry_create_undefined (),
args,
1);
jerry_release_value (ret_val_print);
jerry_release_value (ret_val);
jerry_release_value (ret_val_eval);
}
}
jerry_release_object (global_obj_p);
jerry_release_value (global_obj_val);
jerry_release_value (print_function);
}
@@ -484,49 +474,31 @@ main (int argc,
}
#endif /* JERRY_ENABLE_LOG */
if (ret_code == JERRY_COMPLETION_CODE_OK)
int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
if (jerry_value_has_error_flag (ret_value))
{
jerry_cleanup ();
return JERRY_STANDALONE_EXIT_CODE_OK;
}
else if (ret_code == JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION)
{
jerry_string_t *err_str_p = NULL;
jerry_value_clear_error_flag (&ret_value);
jerry_value_t err_str_val = jerry_value_to_string (ret_value);
if (err_obj_p != NULL)
{
jerry_value_t err_value = jerry_create_object_value (err_obj_p);
err_str_p = jerry_get_string_value (jerry_value_to_string (err_value));
jerry_release_object (err_obj_p);
}
else if (!jerry_value_is_undefined (err_value))
{
err_value = jerry_value_remove_error_flag (err_value);
err_str_p = jerry_get_string_value (jerry_value_to_string (err_value));
jerry_release_value (err_value);
}
jerry_char_t err_str_buf[256];
jerry_size_t err_str_size = jerry_get_string_size (err_str_val);
if (__builtin_expect (!!(err_str_p != NULL), 1))
{
jerry_char_t err_str_buf[256];
assert (err_str_size < 256);
jerry_size_t sz = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
assert (sz == err_str_size);
err_str_buf[err_str_size] = 0;
jerry_size_t err_str_size = jerry_get_string_size (err_str_p);
assert (err_str_size < 256);
jerry_size_t sz = jerry_string_to_char_buffer (err_str_p, err_str_buf, err_str_size);
assert (sz == err_str_size);
err_str_buf[err_str_size] = 0;
jerry_port_errormsg ("Script Error: unhandled exception: %s\n", err_str_buf);
jerry_port_errormsg ("Script Error: unhandled exception: %s\n", err_str_buf);
jerry_release_value (err_str_val);
jerry_release_string (err_str_p);
}
jerry_cleanup ();
return JERRY_STANDALONE_EXIT_CODE_FAIL;
ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
}
assert (ret_code == JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT
|| ret_code == JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_VERSION);
jerry_release_value (ret_value);
jerry_cleanup ();
return JERRY_STANDALONE_EXIT_CODE_FAIL;
return ret_code;
} /* main */
tests/unit/test-api.c
+306 -232
View File
@@ -14,9 +14,8 @@
* limitations under the License.
*/
#include "jerry.h"
#include "jerry-api.h"
#include "config.h"
#include "jerry-api.h"
#include "test-common.h"
@@ -63,24 +62,23 @@ const char *test_source = (
bool test_api_is_free_callback_was_called = false;
static bool
handler (const jerry_object_t *function_obj_p, /**< function object */
static jerry_value_t
handler (const jerry_value_t func_obj_val, /**< function object */
const jerry_value_t this_val, /**< this value */
const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt, /**< arguments length */
jerry_value_t *ret_val_p) /**< [out] return value */
const jerry_length_t args_cnt) /**< arguments length */
{
char buffer[32];
jerry_size_t sz;
printf ("ok %p %p %p %d %p\n", function_obj_p, this_val, args_p, args_cnt, ret_val_p);
printf ("ok %d %d %p %d\n", func_obj_val, this_val, args_p, args_cnt);
JERRY_ASSERT (args_cnt == 2);
JERRY_ASSERT (jerry_value_is_string (args_p[0]));
sz = jerry_get_string_size (jerry_get_string_value (args_p[0]));
sz = jerry_get_string_size (args_p[0]);
JERRY_ASSERT (sz == 1);
sz = jerry_string_to_char_buffer (jerry_get_string_value (args_p[0]),
sz = jerry_string_to_char_buffer (args_p[0],
(jerry_char_t *) buffer,
sz);
JERRY_ASSERT (sz == 1);
@@ -88,26 +86,18 @@ handler (const jerry_object_t *function_obj_p, /**< function object */
JERRY_ASSERT (jerry_value_is_boolean (args_p[1]));
*ret_val_p = jerry_create_string_value (jerry_create_string ((jerry_char_t *) "string from handler"));
return true;
return jerry_create_string ((jerry_char_t *) "string from handler");
} /* handler */
static bool
handler_throw_test (const jerry_object_t *function_obj_p, /**< function object */
static jerry_value_t
handler_throw_test (const jerry_value_t func_obj_val, /**< function object */
const jerry_value_t this_val, /**< this value */
const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt, /**< arguments length */
jerry_value_t *ret_val_p) /**< [out] return value */
const jerry_length_t args_cnt) /**< arguments length */
{
printf ("ok %p %p %p %d %p\n", function_obj_p, this_val, args_p, args_cnt, ret_val_p);
printf ("ok %d %d %p %d\n", func_obj_val, this_val, args_p, args_cnt);
jerry_object_t *error_p = jerry_create_error (JERRY_ERROR_TYPE,
(jerry_char_t *) "error");
*ret_val_p = jerry_create_object_value (error_p);
return false;
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "error");
} /* handler_throw_test */
static void
@@ -119,14 +109,13 @@ handler_construct_freecb (uintptr_t native_p)
test_api_is_free_callback_was_called = true;
} /* handler_construct_freecb */
static bool
handler_construct (const jerry_object_t *function_obj_p, /**< function object */
static jerry_value_t
handler_construct (const jerry_value_t func_obj_val, /**< function object */
const jerry_value_t this_val, /**< this value */
const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt, /**< arguments length */
jerry_value_t *ret_val_p) /**< [out] return value */
const jerry_length_t args_cnt) /**< arguments length */
{
printf ("ok construct %p %p %p %d %p\n", function_obj_p, this_val, args_p, args_cnt, ret_val_p);
printf ("ok construct %d %d %p %d\n", func_obj_val, this_val, args_p, args_cnt);
JERRY_ASSERT (jerry_value_is_object (this_val));
@@ -134,24 +123,24 @@ handler_construct (const jerry_object_t *function_obj_p, /**< function object */
JERRY_ASSERT (jerry_value_is_boolean (args_p[0]));
JERRY_ASSERT (jerry_get_boolean_value (args_p[0]) == true);
jerry_set_object_field_value (jerry_get_object_value (this_val),
(jerry_char_t *) "value_field",
args_p[0]);
jerry_value_t field_name = jerry_create_string ((jerry_char_t *) "value_field");
jerry_set_property (this_val, field_name, args_p[0]);
jerry_release_value (field_name);
jerry_set_object_native_handle (jerry_get_object_value (this_val),
jerry_set_object_native_handle (this_val,
(uintptr_t) 0x0000000000000000ull,
handler_construct_freecb);
uintptr_t ptr;
bool is_ok = jerry_get_object_native_handle (jerry_get_object_value (this_val), &ptr);
bool is_ok = jerry_get_object_native_handle (this_val, &ptr);
JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0000000000000000ull);
/* check if setting handle for second time is handled correctly */
jerry_set_object_native_handle (jerry_get_object_value (this_val),
jerry_set_object_native_handle (this_val,
(uintptr_t) 0x0012345678abcdefull,
handler_construct_freecb);
return true;
return jerry_create_boolean (true);
} /* handler_construct */
/**
@@ -190,7 +179,7 @@ const jerry_char_ptr_t magic_string_items[] =
};
static bool
foreach (const jerry_string_t *name, /**< field name */
foreach (const jerry_value_t name, /**< field name */
const jerry_value_t value, /**< field value */
void *user_data) /**< user data */
{
@@ -198,6 +187,12 @@ foreach (const jerry_string_t *name, /**< field name */
jerry_size_t sz = jerry_string_to_char_buffer (name, (jerry_char_t *) str_buf_p, 128);
str_buf_p[sz] = '\0';
if (sz == 0)
{
JERRY_ASSERT (!strncmp ((const char *) user_data, "user_data", 9));
return true;
}
if (!strncmp (str_buf_p, "alpha", (size_t) sz))
{
JERRY_ASSERT (jerry_value_is_number (value));
@@ -220,23 +215,19 @@ foreach (const jerry_string_t *name, /**< field name */
else if (!strncmp (str_buf_p, "echo", (size_t) sz))
{
JERRY_ASSERT (jerry_value_is_string (value));
jerry_size_t echo_sz = jerry_string_to_char_buffer (jerry_get_string_value (value),
jerry_size_t echo_sz = jerry_string_to_char_buffer (value,
(jerry_char_t *) str_buf_p,
128);
str_buf_p[echo_sz] = '\0';
JERRY_ASSERT (!strncmp (str_buf_p, "foobar", (size_t) echo_sz));
}
else
{
JERRY_ASSERT (false);
}
JERRY_ASSERT (!strncmp ((const char *) user_data, "user_data", 9));
return true;
JERRY_ASSERT (false);
return false;
} /* foreach */
static bool
foreach_exception (const jerry_string_t *name, /**< field name */
foreach_exception (const jerry_value_t name, /**< field name */
const jerry_value_t value, /**< field value */
void *user_data) /**< user data */
{
@@ -250,11 +241,12 @@ foreach_exception (const jerry_string_t *name, /**< field name */
{
JERRY_ASSERT (false);
}
return true;
} /* foreach_exception */
static bool
foreach_subset (const jerry_string_t *name, /**< field name */
foreach_subset (const jerry_value_t name, /**< field name */
const jerry_value_t value, /**< field value */
void *user_data) /**< user data */
{
@@ -270,73 +262,109 @@ foreach_subset (const jerry_string_t *name, /**< field name */
return true;
} /* foreach_subset */
static jerry_value_t
get_property (const jerry_value_t obj_val, /**< object value */
const char *str_p) /**< property name */
{
jerry_value_t prop_name_val = jerry_create_string ((const jerry_char_t *) str_p);
jerry_value_t ret_val = jerry_get_property (obj_val, prop_name_val);
jerry_release_value (prop_name_val);
return ret_val;
} /* get_property */
static jerry_value_t
set_property (const jerry_value_t obj_val, /**< object value */
const char *str_p, /**< property name */
const jerry_value_t val) /**< value to set */
{
jerry_value_t prop_name_val = jerry_create_string ((const jerry_char_t *) str_p);
jerry_value_t ret_val = jerry_set_property (obj_val, prop_name_val, val);
jerry_release_value (prop_name_val);
return ret_val;
} /* set_property */
static bool
test_run_simple (const char *script_p) /**< source code to run */
{
size_t script_size = strlen (script_p);
return jerry_run_simple ((const jerry_char_t *) script_p, script_size, JERRY_INIT_EMPTY);
} /* test_run_simple */
int
main (void)
{
TEST_INIT ();
jerry_init (JERRY_FLAG_EMPTY);
bool is_ok;
jerry_size_t sz;
jerry_value_t val_t, val_foo, val_bar, val_A, val_A_prototype, val_a, val_a_foo, val_value_field, val_p, val_np;
jerry_value_t val_external, val_external_construct, val_call_external;
jerry_object_t *global_obj_p, *obj_p;
jerry_object_t *external_func_p, *external_construct_p;
jerry_object_t *throw_test_handler_p;
jerry_object_t *err_obj_p = NULL;
jerry_value_t val_call_external;
jerry_value_t global_obj_val, obj_val;
jerry_value_t external_func_val, external_construct_val;
jerry_value_t throw_test_handler_val;
jerry_value_t parsed_code_val, proto_val, prim_val;
jerry_value_t res, args[2];
char buffer[32];
is_ok = jerry_parse ((jerry_char_t *) test_source, strlen (test_source), &err_obj_p);
JERRY_ASSERT (is_ok && err_obj_p == NULL);
is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK);
is_ok = test_run_simple ("print ('Hello, World!');");
JERRY_ASSERT (is_ok);
JERRY_ASSERT (jerry_value_is_undefined (res));
global_obj_p = jerry_get_global ();
is_ok = test_run_simple ("throw 'Hello World';");
JERRY_ASSERT (!is_ok);
jerry_init (JERRY_INIT_EMPTY);
parsed_code_val = jerry_parse ((jerry_char_t *) test_source, strlen (test_source), false);
JERRY_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
res = jerry_run (parsed_code_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
global_obj_val = jerry_get_global_object ();
// Test corner case for jerry_string_to_char_buffer
args[0] = jerry_create_string_value (jerry_create_string ((jerry_char_t *) ""));
sz = jerry_get_string_size (jerry_get_string_value (args[0]));
args[0] = jerry_create_string ((jerry_char_t *) "");
sz = jerry_get_string_size (args[0]);
JERRY_ASSERT (sz == 0);
jerry_release_value (args[0]);
// Get global.boo (non-existing field)
val_t = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "boo");
JERRY_ASSERT (!jerry_value_is_error (val_t));
val_t = get_property (global_obj_val, "boo");
JERRY_ASSERT (!jerry_value_has_error_flag (val_t));
JERRY_ASSERT (jerry_value_is_undefined (val_t));
// Get global.t
val_t = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "t");
JERRY_ASSERT (!jerry_value_is_error (val_t));
val_t = get_property (global_obj_val, "t");
JERRY_ASSERT (!jerry_value_has_error_flag (val_t));
JERRY_ASSERT (jerry_value_is_number (val_t)
&& jerry_get_number_value (val_t) == 1.0);
jerry_release_value (val_t);
// Get global.foo
val_foo = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "foo");
JERRY_ASSERT (!jerry_value_is_error (val_foo));
val_foo = get_property (global_obj_val, "foo");
JERRY_ASSERT (!jerry_value_has_error_flag (val_foo));
JERRY_ASSERT (jerry_value_is_object (val_foo));
// Call foo (4, 2)
args[0] = jerry_create_number_value (4);
args[1] = jerry_create_number_value (2);
res = jerry_call_function (jerry_get_object_value (val_foo), NULL, args, 2);
JERRY_ASSERT (!jerry_value_is_error (res));
args[0] = jerry_create_number (4);
args[1] = jerry_create_number (2);
res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_number (res)
&& jerry_get_number_value (res) == 1.0);
jerry_release_value (res);
// Get global.bar
val_bar = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "bar");
JERRY_ASSERT (!jerry_value_is_error (val_bar));
val_bar = get_property (global_obj_val, "bar");
JERRY_ASSERT (!jerry_value_has_error_flag (val_bar));
JERRY_ASSERT (jerry_value_is_object (val_bar));
// Call bar (4, 2)
res = jerry_call_function (jerry_get_object_value (val_bar), NULL, args, 2);
JERRY_ASSERT (!jerry_value_is_error (res));
res = jerry_call_function (val_bar, jerry_create_undefined (), args, 2);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_number (res)
&& jerry_get_number_value (res) == 5.0);
jerry_release_value (res);
@@ -344,17 +372,19 @@ main (void)
// Set global.t = "abcd"
jerry_release_value (args[0]);
args[0] = jerry_create_string_value (jerry_create_string ((jerry_char_t *) "abcd"));
is_ok = jerry_set_object_field_value (global_obj_p, (jerry_char_t *) "t", args[0]);
JERRY_ASSERT (is_ok);
args[0] = jerry_create_string ((jerry_char_t *) "abcd");
res = set_property (global_obj_val, "t", args[0]);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
jerry_release_value (res);
// Call foo (4, 2)
res = jerry_call_function (jerry_get_object_value (val_foo), NULL, args, 2);
JERRY_ASSERT (!jerry_value_is_error (res));
res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_string (res));
sz = jerry_get_string_size (jerry_get_string_value (res));
sz = jerry_get_string_size (res);
JERRY_ASSERT (sz == 4);
sz = jerry_string_to_char_buffer (jerry_get_string_value (res), (jerry_char_t *) buffer, sz);
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 4);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz));
@@ -362,69 +392,64 @@ main (void)
jerry_release_value (args[1]);
// Get global.A
val_A = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "A");
JERRY_ASSERT (!jerry_value_is_error (val_A));
val_A = get_property (global_obj_val, "A");
JERRY_ASSERT (!jerry_value_has_error_flag (val_A));
JERRY_ASSERT (jerry_value_is_object (val_A));
// Get A.prototype
is_ok = jerry_is_constructor (jerry_get_object_value (val_A));
is_ok = jerry_value_is_constructor (val_A);
JERRY_ASSERT (is_ok);
val_A_prototype = jerry_get_object_field_value (jerry_get_object_value (val_A),
(jerry_char_t *) "prototype");
JERRY_ASSERT (!jerry_value_is_error (val_A_prototype));
val_A_prototype = get_property (val_A, "prototype");
JERRY_ASSERT (!jerry_value_has_error_flag (val_A_prototype));
JERRY_ASSERT (jerry_value_is_object (val_A_prototype));
jerry_release_value (val_A);
// Set A.prototype.foo = global.foo
is_ok = jerry_set_object_field_value (jerry_get_object_value (val_A_prototype),
(jerry_char_t *) "foo",
val_foo);
JERRY_ASSERT (is_ok);
res = set_property (val_A_prototype, "foo", val_foo);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
jerry_release_value (res);
jerry_release_value (val_A_prototype);
jerry_release_value (val_foo);
// Get global.a
val_a = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "a");
JERRY_ASSERT (!jerry_value_is_error (val_a));
val_a = get_property (global_obj_val, "a");
JERRY_ASSERT (!jerry_value_has_error_flag (val_a));
JERRY_ASSERT (jerry_value_is_object (val_a));
// Get a.t
res = jerry_get_object_field_value (jerry_get_object_value (val_a), (jerry_char_t *) "t");
JERRY_ASSERT (!jerry_value_is_error (res));
res = get_property (val_a, "t");
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_number (res)
&& jerry_get_number_value (res) == 12.0);
jerry_release_value (res);
// foreach properties
val_p = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "p");
is_ok = jerry_foreach_object_field (jerry_get_object_value (val_p), foreach, (void *) "user_data");
val_p = get_property (global_obj_val, "p");
is_ok = jerry_foreach_object_property (val_p, foreach, (void *) "user_data");
JERRY_ASSERT (is_ok);
// break foreach at third element
int count = 0;
is_ok = jerry_foreach_object_field (jerry_get_object_value (val_p), foreach_subset, &count);
is_ok = jerry_foreach_object_property (val_p, foreach_subset, &count);
JERRY_ASSERT (is_ok);
JERRY_ASSERT (count == 3);
jerry_release_value (val_p);
// foreach with throw test
val_np = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "np");
is_ok = !jerry_foreach_object_field (jerry_get_object_value (val_np), foreach_exception, NULL);
val_np = get_property (global_obj_val, "np");
is_ok = !jerry_foreach_object_property (val_np, foreach_exception, NULL);
JERRY_ASSERT (is_ok);
jerry_release_value (val_np);
// Get a.foo
val_a_foo = jerry_get_object_field_value (jerry_get_object_value (val_a),
(jerry_char_t *) "foo");
JERRY_ASSERT (!jerry_value_is_error (val_a_foo));
val_a_foo = get_property (val_a, "foo");
JERRY_ASSERT (!jerry_value_has_error_flag (val_a_foo));
JERRY_ASSERT (jerry_value_is_object (val_a_foo));
// Call a.foo ()
res = jerry_call_function (jerry_get_object_value (val_a_foo),
jerry_get_object_value (val_a),
NULL,
0);
JERRY_ASSERT (!jerry_value_is_error (res));
res = jerry_call_function (val_a_foo, val_a, NULL, 0);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_number (res)
&& jerry_get_number_value (res) == 12.0);
jerry_release_value (res);
@@ -433,108 +458,88 @@ main (void)
jerry_release_value (val_a);
// Create native handler bound function object and set it to 'external' variable
external_func_p = jerry_create_external_function (handler);
JERRY_ASSERT (external_func_p != NULL
&& jerry_is_function (external_func_p)
&& jerry_is_constructor (external_func_p));
external_func_val = jerry_create_external_function (handler);
JERRY_ASSERT (jerry_value_is_function (external_func_val)
&& jerry_value_is_constructor (external_func_val));
val_external = jerry_create_object_value (external_func_p);
is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "external",
val_external);
JERRY_ASSERT (is_ok);
jerry_release_value (val_external);
res = set_property (global_obj_val, "external", external_func_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
jerry_release_value (external_func_val);
// Call 'call_external' function that should call external function created above
val_call_external = jerry_get_object_field_value (global_obj_p,
(jerry_char_t *) "call_external");
JERRY_ASSERT (!jerry_value_is_error (val_call_external));
val_call_external = get_property (global_obj_val, "call_external");
JERRY_ASSERT (!jerry_value_has_error_flag (val_call_external));
JERRY_ASSERT (jerry_value_is_object (val_call_external));
res = jerry_call_function (jerry_get_object_value (val_call_external),
global_obj_p,
NULL,
0);
res = jerry_call_function (val_call_external, global_obj_val, NULL, 0);
jerry_release_value (val_call_external);
JERRY_ASSERT (!jerry_value_is_error (res));
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_string (res));
sz = jerry_get_string_size (jerry_get_string_value (res));
sz = jerry_get_string_size (res);
JERRY_ASSERT (sz == 19);
sz = jerry_string_to_char_buffer (jerry_get_string_value (res), (jerry_char_t *) buffer, sz);
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 19);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz));
// Create native handler bound function object and set it to 'external_construct' variable
external_construct_p = jerry_create_external_function (handler_construct);
JERRY_ASSERT (external_construct_p != NULL
&& jerry_is_function (external_construct_p)
&& jerry_is_constructor (external_construct_p));
external_construct_val = jerry_create_external_function (handler_construct);
JERRY_ASSERT (jerry_value_is_function (external_construct_val)
&& jerry_value_is_constructor (external_construct_val));
val_external_construct = jerry_create_object_value (external_construct_p);
is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "external_construct",
val_external_construct);
JERRY_ASSERT (is_ok);
res = set_property (global_obj_val, "external_construct", external_construct_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
jerry_release_value (res);
// Call external function created above, as constructor
args[0] = jerry_create_boolean_value (true);
res = jerry_construct_object (external_construct_p, args, 1);
JERRY_ASSERT (!jerry_value_is_error (res));
args[0] = jerry_create_boolean (true);
res = jerry_construct_object (external_construct_val, args, 1);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_object (res));
val_value_field = jerry_get_object_field_value (jerry_get_object_value (res),
(jerry_char_t *) "value_field");
val_value_field = get_property (res, "value_field");
// Get 'value_field' of constructed object
JERRY_ASSERT (!jerry_value_is_error (val_value_field));
JERRY_ASSERT (!jerry_value_has_error_flag (val_value_field));
JERRY_ASSERT (jerry_value_is_boolean (val_value_field)
&& jerry_get_boolean_value (val_value_field));
jerry_release_value (val_value_field);
jerry_release_object (external_construct_p);
jerry_release_value (external_construct_val);
uintptr_t ptr;
is_ok = jerry_get_object_native_handle (jerry_get_object_value (res), &ptr);
is_ok = jerry_get_object_native_handle (res, &ptr);
JERRY_ASSERT (is_ok
&& ptr == (uintptr_t) 0x0012345678abcdefull);
jerry_release_value (res);
// Test: Throwing exception from native handler.
throw_test_handler_p = jerry_create_external_function (handler_throw_test);
JERRY_ASSERT (throw_test_handler_p != NULL
&& jerry_is_function (throw_test_handler_p));
throw_test_handler_val = jerry_create_external_function (handler_throw_test);
JERRY_ASSERT (jerry_value_is_function (throw_test_handler_val));
val_t = jerry_create_object_value (throw_test_handler_p);
is_ok = jerry_set_object_field_value (global_obj_p,
(jerry_char_t *) "throw_test",
val_t);
JERRY_ASSERT (is_ok);
jerry_release_value (val_t);
res = set_property (global_obj_val, "throw_test", throw_test_handler_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
jerry_release_value (res);
jerry_release_value (throw_test_handler_val);
val_t = jerry_get_object_field_value (global_obj_p, (jerry_char_t *) "call_throw_test");
JERRY_ASSERT (!jerry_value_is_error (val_t));
val_t = get_property (global_obj_val, "call_throw_test");
JERRY_ASSERT (!jerry_value_has_error_flag (val_t));
JERRY_ASSERT (jerry_value_is_object (val_t));
res = jerry_call_function (jerry_get_object_value (val_t),
global_obj_p,
NULL,
0);
JERRY_ASSERT (!jerry_value_is_error (res));
res = jerry_call_function (val_t, global_obj_val, NULL, 0);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
jerry_release_value (val_t);
jerry_release_value (res);
// Test: Unhandled exception in called function
val_t = jerry_get_object_field_value (global_obj_p,
(jerry_char_t *) "throw_reference_error");
JERRY_ASSERT (!jerry_value_is_error (val_t));
val_t = get_property (global_obj_val, "throw_reference_error");
JERRY_ASSERT (!jerry_value_has_error_flag (val_t));
JERRY_ASSERT (jerry_value_is_object (val_t));
res = jerry_call_function (jerry_get_object_value (val_t),
global_obj_p,
NULL,
0);
res = jerry_call_function (val_t, global_obj_val, NULL, 0);
JERRY_ASSERT (jerry_value_is_error (res));
JERRY_ASSERT (jerry_value_has_error_flag (res));
jerry_release_value (val_t);
// 'res' should contain exception object
@@ -542,27 +547,23 @@ main (void)
jerry_release_value (res);
// Test: Call of non-function
obj_p = jerry_create_object ();
res = jerry_call_function (obj_p,
global_obj_p,
NULL,
0);
JERRY_ASSERT (jerry_value_is_error (res));
obj_val = jerry_create_object ();
res = jerry_call_function (obj_val, global_obj_val, NULL, 0);
JERRY_ASSERT (jerry_value_has_error_flag (res));
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
jerry_release_object (obj_p);
jerry_release_value (obj_val);
// Test: Unhandled exception in function called, as constructor
val_t = jerry_get_object_field_value (global_obj_p,
(jerry_char_t *) "throw_reference_error");
JERRY_ASSERT (!jerry_value_is_error (val_t));
val_t = get_property (global_obj_val, "throw_reference_error");
JERRY_ASSERT (!jerry_value_has_error_flag (val_t));
JERRY_ASSERT (jerry_value_is_object (val_t));
res = jerry_construct_object (jerry_get_object_value (val_t), NULL, 0);
JERRY_ASSERT (jerry_value_is_error (res));
res = jerry_construct_object (val_t, NULL, 0);
JERRY_ASSERT (jerry_value_has_error_flag (res));
jerry_release_value (val_t);
// 'res' should contain exception object
@@ -570,50 +571,122 @@ main (void)
jerry_release_value (res);
// Test: Call of non-function as constructor
obj_p = jerry_create_object ();
res = jerry_construct_object (obj_p, NULL, 0);
JERRY_ASSERT (jerry_value_is_error (res));
obj_val = jerry_create_object ();
res = jerry_construct_object (obj_val, NULL, 0);
JERRY_ASSERT (jerry_value_has_error_flag (res));
// 'res' should contain exception object
JERRY_ASSERT (jerry_value_is_object (res));
jerry_release_value (res);
jerry_release_object (obj_p);
jerry_release_value (obj_val);
// Test: Array Object API
jerry_object_t *array_obj_p = jerry_create_array_object (10);
JERRY_ASSERT (jerry_is_array (array_obj_p));
JERRY_ASSERT (jerry_get_array_length (array_obj_p) == 10);
jerry_value_t array_obj_val = jerry_create_array (10);
JERRY_ASSERT (jerry_value_is_array (array_obj_val));
JERRY_ASSERT (jerry_get_array_length (array_obj_val) == 10);
jerry_value_t v_in = jerry_create_number_value (10.5);
jerry_set_array_index_value (array_obj_p, 5, v_in);
jerry_value_t v_out;
jerry_get_array_index_value (array_obj_p, 5, &v_out);
jerry_value_t v_in = jerry_create_number (10.5);
jerry_set_property_by_index (array_obj_val, 5, v_in);
jerry_value_t v_out = jerry_get_property_by_index (array_obj_val, 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_value (array_obj_val);
// Test: init property descriptor
jerry_property_descriptor_t prop_desc;
jerry_init_property_descriptor_fields (&prop_desc);
JERRY_ASSERT (prop_desc.is_value_defined == false);
JERRY_ASSERT (jerry_value_is_undefined (prop_desc.value));
JERRY_ASSERT (prop_desc.is_writable_defined == false);
JERRY_ASSERT (prop_desc.is_writable == false);
JERRY_ASSERT (prop_desc.is_enumerable_defined == false);
JERRY_ASSERT (prop_desc.is_enumerable == false);
JERRY_ASSERT (prop_desc.is_configurable_defined == false);
JERRY_ASSERT (prop_desc.is_configurable == false);
JERRY_ASSERT (prop_desc.is_get_defined == false);
JERRY_ASSERT (jerry_value_is_undefined (prop_desc.getter));
JERRY_ASSERT (prop_desc.is_set_defined == false);
JERRY_ASSERT (jerry_value_is_undefined (prop_desc.setter));
// Test: define own properties
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "my_defined_property");
prop_desc.is_value_defined = true;
prop_desc.value = jerry_acquire_value (prop_name);
res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_boolean (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
jerry_release_value (res);
jerry_free_property_descriptor_fields (&prop_desc);
// Test: get own property descriptor
is_ok = jerry_get_own_property_descriptor (global_obj_val, prop_name, &prop_desc);
JERRY_ASSERT (is_ok);
JERRY_ASSERT (prop_desc.is_value_defined == true);
JERRY_ASSERT (jerry_value_is_string (prop_desc.value));
JERRY_ASSERT (prop_desc.is_writable == false);
JERRY_ASSERT (prop_desc.is_enumerable == false);
JERRY_ASSERT (prop_desc.is_configurable == false);
JERRY_ASSERT (prop_desc.is_get_defined == false);
JERRY_ASSERT (jerry_value_is_undefined (prop_desc.getter));
JERRY_ASSERT (prop_desc.is_set_defined == false);
JERRY_ASSERT (jerry_value_is_undefined (prop_desc.setter));
jerry_release_value (prop_name);
jerry_free_property_descriptor_fields (&prop_desc);
// Test: object keys
res = jerry_get_object_keys (global_obj_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_array (res));
jerry_release_value (res);
// Test: jerry_value_to_primitive
obj_val = jerry_eval ((jerry_char_t *) "new String ('hello')", 20, false);
JERRY_ASSERT (!jerry_value_has_error_flag (obj_val));
JERRY_ASSERT (jerry_value_is_object (obj_val));
JERRY_ASSERT (!jerry_value_is_string (obj_val));
prim_val = jerry_value_to_primitive (obj_val);
JERRY_ASSERT (!jerry_value_has_error_flag (prim_val));
JERRY_ASSERT (jerry_value_is_string (prim_val));
jerry_release_value (prim_val);
// Test: jerry_get_prototype
proto_val = jerry_get_prototype (obj_val);
JERRY_ASSERT (!jerry_value_has_error_flag (proto_val));
JERRY_ASSERT (jerry_value_is_object (proto_val));
jerry_release_value (obj_val);
// Test: jerry_set_prototype
obj_val = jerry_create_object ();
res = jerry_set_prototype (obj_val, jerry_create_null ());
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_boolean (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
res = jerry_set_prototype (obj_val, jerry_create_object ());
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_boolean (res));
JERRY_ASSERT (jerry_get_boolean_value (res));
proto_val = jerry_get_prototype (obj_val);
JERRY_ASSERT (!jerry_value_has_error_flag (proto_val));
JERRY_ASSERT (jerry_value_is_object (proto_val));
jerry_release_value (proto_val);
jerry_release_value (obj_val);
// Test: eval
const char *eval_code_src_p = "(function () { return 123; })";
jerry_completion_code_t status = jerry_eval ((jerry_char_t *) eval_code_src_p,
strlen (eval_code_src_p),
false,
true,
&val_t);
JERRY_ASSERT (status == JERRY_COMPLETION_CODE_OK);
val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), true);
JERRY_ASSERT (!jerry_value_has_error_flag (val_t));
JERRY_ASSERT (jerry_value_is_object (val_t));
JERRY_ASSERT (jerry_is_function (jerry_get_object_value (val_t)));
JERRY_ASSERT (jerry_value_is_function (val_t));
res = jerry_call_function (jerry_get_object_value (val_t),
NULL,
NULL,
0);
JERRY_ASSERT (!jerry_value_is_error (res));
res = jerry_call_function (val_t, jerry_create_undefined (), NULL, 0);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_number (res)
&& jerry_get_number_value (res) == 123.0);
jerry_release_value (res);
@@ -621,7 +694,7 @@ main (void)
jerry_release_value (val_t);
// cleanup.
jerry_release_object (global_obj_p);
jerry_release_value (global_obj_val);
// TEST: run gc.
jerry_gc ();
@@ -631,20 +704,21 @@ main (void)
JERRY_ASSERT (test_api_is_free_callback_was_called);
// External Magic String
jerry_init (JERRY_FLAG_SHOW_OPCODES);
jerry_init (JERRY_INIT_SHOW_OPCODES);
uint32_t num_magic_string_items = (uint32_t) (sizeof (magic_string_items) / sizeof (jerry_char_ptr_t));
jerry_register_external_magic_strings (magic_string_items,
num_magic_string_items,
magic_string_lengths);
jerry_register_magic_strings (magic_string_items,
num_magic_string_items,
magic_string_lengths);
const char *ms_code_src_p = "var global = {}; var console = [1]; var process = 1;";
is_ok = jerry_parse ((jerry_char_t *) ms_code_src_p, strlen (ms_code_src_p), &err_obj_p);
JERRY_ASSERT (is_ok && err_obj_p == NULL);
parsed_code_val = jerry_parse ((jerry_char_t *) ms_code_src_p, strlen (ms_code_src_p), false);
JERRY_ASSERT (!jerry_value_has_error_flag (parsed_code_val));
is_ok = (jerry_run (&res) == JERRY_COMPLETION_CODE_OK);
JERRY_ASSERT (is_ok);
JERRY_ASSERT (jerry_value_is_undefined (res));
res = jerry_run (parsed_code_val);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
jerry_release_value (res);
jerry_release_value (parsed_code_val);
jerry_cleanup ();
@@ -657,45 +731,45 @@ main (void)
const char *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();";
jerry_init (JERRY_FLAG_SHOW_OPCODES);
jerry_init (JERRY_INIT_SHOW_OPCODES);
size_t global_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
true,
false,
global_mode_snapshot_buffer,
sizeof (global_mode_snapshot_buffer));
JERRY_ASSERT (global_mode_snapshot_size != 0);
jerry_cleanup ();
jerry_init (JERRY_FLAG_SHOW_OPCODES);
jerry_init (JERRY_INIT_SHOW_OPCODES);
size_t eval_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p,
strlen (code_to_snapshot_p),
false,
false,
eval_mode_snapshot_buffer,
sizeof (eval_mode_snapshot_buffer));
JERRY_ASSERT (eval_mode_snapshot_size != 0);
jerry_cleanup ();
jerry_init (JERRY_FLAG_SHOW_OPCODES);
jerry_init (JERRY_INIT_SHOW_OPCODES);
is_ok = (jerry_exec_snapshot (global_mode_snapshot_buffer,
global_mode_snapshot_size,
false,
&res) == JERRY_COMPLETION_CODE_OK);
res = jerry_exec_snapshot (global_mode_snapshot_buffer,
global_mode_snapshot_size,
false);
JERRY_ASSERT (is_ok);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_undefined (res));
jerry_release_value (res);
is_ok = (jerry_exec_snapshot (eval_mode_snapshot_buffer,
eval_mode_snapshot_size,
false,
&res) == JERRY_COMPLETION_CODE_OK);
res = jerry_exec_snapshot (eval_mode_snapshot_buffer,
eval_mode_snapshot_size,
false);
JERRY_ASSERT (is_ok);
JERRY_ASSERT (!jerry_value_has_error_flag (res));
JERRY_ASSERT (jerry_value_is_string (res));
sz = jerry_get_string_size (jerry_get_string_value (res));
sz = jerry_get_string_size (res);
JERRY_ASSERT (sz == 20);
sz = jerry_string_to_char_buffer (jerry_get_string_value (res), (jerry_char_t *) buffer, sz);
sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz);
JERRY_ASSERT (sz == 20);
jerry_release_value (res);
JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz));
tests/unit/test-string-to-number.c
+1
View File
@@ -16,6 +16,7 @@
#include "ecma-globals.h"
#include "ecma-helpers.h"
#include "jerry-api.h"
#include "test-common.h"