Name
SPVM::Document::NativeAPI - Native APIs
Description
The native APIs in SPVM are the APIs written by the C language for SPVM operations.
These APIs are available in native classes.
Native APIs
runtime
The runtime for this runtime environment.
Examples:
SPVM_NATIVE_RUNTIME* runtime = env->runtime;api
SPVM_ENV_API* api;
Returns SPVM_ENV_API object. This object have the following fields for other native APIs.
Examples:
SPVM_API_BASIC_TYPE* api_basic_type = env->api->basic_type;new_env
SPVM_ENV* (*new_env)();
Creates a new runtime environment.
This native API should not be used unless special purposes are intended.
free_env
void (*free_env)(SPVM_ENV* env);
Frees the runtime environment env.
This native API should not be used unless special purposes are intended.
call_init_methods
int32_t (*call_init_methods)(SPVM_ENV* env, SPVM_VALUE* stack);
Calls the consolidated INIT method for each class.
All INIT blocks in a class are merged into a single INIT method at compile time. This native API calls these methods for all classes that have them.
If an exception is thrown, returns a non-zero value. Otherwise, returns 0.
This native API should not be used unless special purposes are intended.
set_command_info_program_name
int32_t (*set_command_info_program_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* obj_program_name);
Sets the program name obj_program_name to CommandInfo#PROGRAM_NAME class variable.
If an exception is thrown, returns a non-zero value. Otherwise, returns 0.
This native API should not be used unless special purposes are intended.
call_end_methods
int32_t (*call_end_methods)(SPVM_ENV* env, SPVM_VALUE* stack);
Calls the consolidated END method for each class.
All END blocks in a class are merged into a single END method in reverse order (LIFO) at compile time. This native API calls these methods for all classes that have them.
If an exception is thrown in an END method, it is converted to a warning message and printed to stderr, and the execution continues for the remaining classes.
This method always returns 0 because all exceptions are caught internally.
This native API should not be used unless special purposes are intended.
set_command_info_argv
int32_t (*set_command_info_argv)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* obj_argv);
Sets the command line arguments obj_argv to CommandInfo#ARGV class variable.
If an exception is thrown, returns a non-zero value. Otherwise, returns 0.
This native API should not be used unless special purposes are intended.
set_command_info_basetime
int32_t (*set_command_info_basetime)(SPVM_ENV* env, SPVM_VALUE* stack, int64_t base_time);
Sets the base time base_time to CommandInfo#BASE_TIME class variable.
If an exception is thrown, returns a non-zero value. Otherwise, returns 0.
This native API should not be used unless special purposes are intended.
destroy_class_vars
void (*destroy_class_vars)(SPVM_ENV* env, SPVM_VALUE* stack);
Sets all class variables of all classes that is a object type to undef.
This native API should not be used unless special purposes are intended.
args_width
int32_t (*args_width)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the width of the arguments given by the caller.
Examples:
int32_t args_width = env->args_width(env, stack);get_object_basic_type
SPVM_NATIVE_BASIC_TYPE* (*get_object_basic_type)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns the basic type of the object object.
get_object_basic_type_id
int32_t (*get_object_basic_type_id)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns the basic type ID of the object object.
get_object_basic_type_name
const char* (*get_object_basic_type_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns the basic type name of the object object.
get_object_type_dimension
int32_t (*get_object_type_dimension)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns the type dimension of the object object.
get_basic_type
SPVM_NATIVE_BASIC_TYPE* (*get_basic_type)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name);
Searches a basic type given the basic type name basic_type_name.
If it is found, returns it. Otherwise, returns NULL.
get_basic_type_by_name
SPVM_NATIVE_BASIC_TYPE* (*get_basic_type_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Searches a basic type given the basic type name basic_type_name.
If it is found, returns it. Otherwise, an exception is thrown.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
get_basic_type_by_id
SPVM_NATIVE_BASIC_TYPE* (*get_basic_type_by_id)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id);
Searches a basic type given the basic type ID basic_type_id.
If it is found, returns it. Otherwise, returns NULL.
get_basic_type_id
int32_t (*get_basic_type_id)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name);
Searches a basic type given the basic type name basic_type_name.
If it is found, returns the basic type id of it. Otherwise, returns a negative value.
Examples:
int32_t basic_type_id = env->get_basic_type_id(env, stack, "Int");get_basic_type_id_by_name
int32_t (*get_basic_type_id_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Searches a basic type ID given the basic type name basic_type_name.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
get_class_var
SPVM_NATIVE_CLASS_VAR* (*get_class_var)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name);
Searches a class variable given the basic type name basic_type_name and the class variable name class_var_name.
If it is found, returns it. Otherwise, returns NULL.
Examples:
SPVM_NATIVE_CLASS_VAR* class_var = env->get_class_var(env, stack, "MyClass", "$VAR");get_class_var_byte
int8_t (*get_class_var_byte)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is byte type.
get_class_var_short
int16_t (*get_class_var_short)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is short type.
get_class_var_int
int32_t (*get_class_var_int)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is int type.
get_class_var_long
int64_t (*get_class_var_long)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is long type.
get_class_var_float
float (*get_class_var_float)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is float type.
get_class_var_double
double (*get_class_var_double)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is double type.
get_class_var_object
SPVM_OBJ* (*get_class_var_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is an object type.
get_class_var_string
SPVM_OBJ* (*get_class_var_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the value of the class variable class_var interpreting its type is string type.
set_class_var_byte
void (*set_class_var_byte)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, int8_t value);
Sets value to the class variable class_var interpreting its type is byte type.
set_class_var_short
void (*set_class_var_short)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, int16_t value);
Sets value to the class variable class_var interpreting its type is short type.
set_class_var_int
void (*set_class_var_int)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, int32_t value);
Sets value to the class variable class_var interpreting its type is int type.
set_class_var_long
void (*set_class_var_long)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, int64_t value);
Sets value to the class variable class_var interpreting its type is long type.
set_class_var_float
void (*set_class_var_float)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, float value);
Sets value to the class variable class_var interpreting its type is float type.
set_class_var_double
void (*set_class_var_double)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, double value);
Sets value to the class variable class_var interpreting its type is double type.
set_class_var_object
void (*set_class_var_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, SPVM_OBJ* value);
Sets value to the class variable class_var interpreting its type is an object type.
set_class_var_string
void (*set_class_var_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var, SPVM_OBJ* value);
Sets value to the class variable class_var interpreting its type is string type.
get_class_var_object_ref
SPVM_OBJ** (*get_class_var_object_ref)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_CLASS_VAR* class_var);
Returns the address where the value of the class variable class_var is stored.
get_class_var_byte_by_name
int8_t (*get_class_var_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the class variable specified by the basic type name basic_type_name and the class variable name class_var_name, and returns the value.
The type of the field must be byte type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int8_t value = env->get_class_var_byte_by_name(env, stack, "TestCase::NativeAPI", "$BYTE_VALUE", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_class_var_short_by_name
int16_t (*get_class_var_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the class variable specified by the basic type name basic_type_name and the class variable name class_var_name, and returns the value casting to short type.
The type of the field must be short type or smaller numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int16_t value = env->get_class_var_short_by_name(env, stack, "TestCase::NativeAPI", "$SHORT_VALUE", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_class_var_int_by_name
int32_t (*get_class_var_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the class variable specified by the basic type name basic_type_name and the class variable name class_var_name, and returns the value casting to int type.
The type of the field must be int type or smaller numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int8_t value = env->get_class_var_int_by_name(env, stack, "TestCase::NativeAPI", "$BYTE_VALUE", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_class_var_long_by_name
int64_t (*get_class_var_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the class variable specified by the basic type name basic_type_name and the class variable name class_var_name, and returns the value casting to long type.
The type of the field must be long type or smaller numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int64_t value = env->get_class_var_long_by_name(env, stack, "TestCase::NativeAPI", "$LONG_VALUE", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_class_var_float_by_name
float (*get_class_var_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the class variable specified by the basic type name basic_type_name and the class variable name class_var_name, and returns the value casting to float type.
The type of the field must be float type or smaller numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
float value = env->get_class_var_float_by_name(env, stack, "TestCase::NativeAPI", "$FLOAT_VALUE", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_class_var_double_by_name
double (*get_class_var_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the class variable specified by the basic type name basic_type_name and the class variable name class_var_name, and returns the value casting to double type.
The type of the field must be double type or smaller numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
double value = env->get_class_var_double_by_name(env, stack, "TestCase::NativeAPI", "$DOUBLE_VALUE", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_class_var_object_by_name
SPVM_OBJ* (*get_class_var_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the class variable specified by the basic type name basic_type_name and the class variable name class_var_name, and returns the value.
The type of the field must be an object type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
SPVM_OBJ* value = env->get_class_var_object_by_name(env, stack, "TestCase::NativeAPI", "$MINIMAL_VALUE", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_class_var_string_by_name
SPVM_OBJ* (*get_class_var_string_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
The same as "get_class_var_object_by_name" native API.
set_class_var_byte_by_name
void (*set_class_var_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int8_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the class variable specified by the basic type name basic_type_name and the class variable name class_var_name to the value value casting to the field type.
The type of the field must be byte type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_class_var_byte_by_name(env, stack, "TestCase::NativeAPI", "$BYTE_VALUE", 15, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_class_var_short_by_name
void (*set_class_var_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int16_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the class variable specified by the basic type name basic_type_name and the class variable name class_var_name to the value value casting to the field type.
The type of the field must be short type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_class_var_short_by_name(env, stack, "TestCase::NativeAPI", "$SHORT_VALUE", 15, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_class_var_int_by_name
void (*set_class_var_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int32_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the class variable specified by the basic type name basic_type_name and the class variable name class_var_name to the value value casting to the field type.
The type of the field must be int type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_class_var_int_by_name(env, stack, "TestCase::NativeAPI", "$INT_VALUE", 15, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_class_var_long_by_name
void (*set_class_var_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, int64_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the class variable specified by the basic type name basic_type_name and the class variable name class_var_name to the value value casting to the field type.
The type of the field must be long type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_class_var_long_by_name(env, stack, "TestCase::NativeAPI", "$LONG_VALUE", 15, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_class_var_float_by_name
void (*set_class_var_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, float value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the class variable specified by the basic type name basic_type_name and the class variable name class_var_name to the value value casting to the field type.
The type of the field must be float type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_class_var_float_by_name(env, stack, "TestCase::NativeAPI", "$FLOAT_VALUE", 15, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_class_var_double_by_name
void (*set_class_var_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, double value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the class variable specified by the basic type name basic_type_name and the class variable name class_var_name to the value value.
The type of the field must be double type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_class_var_double_by_name(env, stack, "TestCase::NativeAPI", "$DOUBLE_VALUE", 15, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_class_var_object_by_name
void (*set_class_var_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, SPVM_OBJ* value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the class variable specified by the basic type name basic_type_name and the class variable name class_var_name to the value value.
The type of the field must be an object type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If basic_type_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If class_var_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the class variable type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_class_var_object_by_name(env, stack, "TestCase::NativeAPI", "$MINIMAL_VALUE", minimal, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_class_var_string_by_name
void (*set_class_var_string_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name, SPVM_OBJ* value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
The same as "set_class_var_object_by_name" native API.
get_field
SPVM_NATIVE_FIELD* (*get_field)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name);
Searches a field object given the object object and the field name field_name.
If it is found, returns it. Otherwise, returns NULL.
Examples:
SPVM_NATIVE_FIELD* field = env->get_field(env, stack, object, "x");get_field_static
SPVM_NATIVE_FIELD* (*get_field_static)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* field_name);
Searches a field object given the basic type name basic_type_name and the field name field_name.
If it is found, returns it. Otherwise, returns NULL.
Examples:
SPVM_NATIVE_FIELD* field = env->get_field_static(env, stack, "Point", "x");get_field_byte
int8_t (*get_field_byte)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is byte type.
get_field_short
int16_t (*get_field_short)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is short type.
get_field_int
int32_t (*get_field_int)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is int type.
get_field_long
int64_t (*get_field_long)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is long type.
get_field_float
float (*get_field_float)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is float type.
get_field_double
double (*get_field_double)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is double type.
get_field_object
SPVM_OBJ* (*get_field_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is an object type.
get_field_string
SPVM_OBJ* (*get_field_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the value of the field field of the object object interpreting its type is string type.
set_field_byte
void (*set_field_byte)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, int8_t value);
Sets value to the field field of the object object.
value must be a numeric type. It is cast to byte type.
And the field existence flag is set to 1.
set_field_short
void (*set_field_short)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, int16_t value);
Sets value to the field field of the object object.
value must be a numeric type. It is cast to short type.
And the field existence flag is set to 1.
set_field_int
void (*set_field_int)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, int32_t value);
Sets value to the field field of the object object.
value must be a numeric type. It is cast to int type.
And the field existence flag is set to 1.
set_field_long
void (*set_field_long)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, int64_t value);
Sets value to the field field of the object object.
value must be a numeric type. It is cast to long type.
And the field existence flag is set to 1.
set_field_float
void (*set_field_float)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, float value);
Sets value to the field field of the object object.
value must be a numeric type. It is cast to float type.
And the field existence flag is set to 1.
set_field_double
void (*set_field_double)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, double value);
Sets value to the field field of the object object.
value must be a numeric type. It is cast to double type.
And the field existence flag is set to 1.
set_field_object
void (*set_field_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, SPVM_OBJ* value);
Sets value to the field field of the object object interpreting its type is an object type.
And the field existence flag is set to 1.
set_field_string
void (*set_field_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field, SPVM_OBJ* value);
Alias for "set_field_object"
get_field_byte_by_name
int8_t (*get_field_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Returns the value of the field specified by the invocant object and the field name field_name.
The type of the field must be a numeric type. The value is cast to byte type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int8_t byte_value = env->get_field_byte_by_name(env, stack, object, "byte_value", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_field_short_by_name
int16_t (*get_field_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the field specified by the invocant object and the field name field_name, and returns the value casting to short type.
The type of the field must be a numeric type. The value is cast to short type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int16_t short_value = env->get_field_short_by_name(env, stack, object, "short_value", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_field_int_by_name
int32_t (*get_field_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the field specified by the invocant object and the field name field_name, and returns the value casting to int type.
The type of the field must be a numeric type. The value is cast to int type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int32_t int_value = env->get_field_int_by_name(env, stack, object, "int_value", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_field_long_by_name
int64_t (*get_field_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the field specified by the invocant object and the field name field_name, and returns the value casting to long type.
The type of the field must be a numeric type. The value is cast to long type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
int64_t long_value = env->get_field_long_by_name(env, stack, object, "long_value", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_field_float_by_name
float (*get_field_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the field specified by the invocant object and the field name field_name, and returns the value casting to float type.
The type of the field must be a numeric type. The value is cast to float type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
float float_value = env->get_field_float_by_name(env, stack, object, "float_value", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_field_double_by_name
double (*get_field_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the field specified by the invocant object and the field name field_name, and returns the value casting to double type.
The type of the field must be a numeric type. The value is cast to double type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
double double_value = env->get_field_double_by_name(env, stack, object, "double_value", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_field_object_by_name
SPVM_OBJ* (*get_field_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Gets the value of the field specified by the invocant object and the field name field_name.
The type of the field must be an object type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
SPVM_OBJ* object_minimal = env->get_field_object_by_name(env, stack, object_simple, "object_value", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_field_string_by_name
SPVM_OBJ* (*get_field_string_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
The same as "get_field_object_by_name" native API.
set_field_byte_by_name
void (*set_field_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int8_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the field specified by the invocant object and the field name field_name to the value value casting to the field type.
The type of the field must be byte type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_field_byte_by_name(env, stack, object, "byte_value", 13, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_field_short_by_name
void (*set_field_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int16_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the field specified by the invocant object and the field name field_name to the value value casting to the field type.
The type of the field must be short type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_field_short_by_name(env, stack, object, "short_value", 13, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_field_int_by_name
void (*set_field_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the field specified by the invocant object and the field name field_name to the value value casting to the field type.
The type of the field must be int type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_field_int_by_name(env, stack, object, "int_value", 13, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_field_long_by_name
void (*set_field_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int64_t value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the field specified by the invocant object and the field name field_name to the value value casting to the field type.
The type of the field must be long type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_field_long_by_name(env, stack, object, "long_value", 13, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_field_float_by_name
void (*set_field_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, float value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the field specified by the invocant object and the field name field_name to the value value casting to the field type.
The type of the field must be float type or larger numeric type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_field_float_by_name(env, stack, object, "float_value", 13.0f, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_field_double_by_name
void (*set_field_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, double value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the field specified by the invocant object and the field name field_name to the value value.
The type of the field must be double type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_field_double_by_name(env, stack, object, "double_value", 13.0, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_field_object_by_name
void (*set_field_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, SPVM_OBJ* value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Sets the field specified by the invocant object and the field name field_name to the value value.
The type of the field must be an object type.
The function name func_name, the file path file, and the line number line are needed for the exception stack trace.
If this function succeeds, error_id is set to 0.
Exceptions:
If object is not a class type, an exception is set and error_id is set to the basic type id of Error class.
If field_name is not found, an exception is set and error_id is set to the basic type id of Error class.
If the field type is invalid, an exception is set and error_id is set to the basic type id of Error class.
Examples:
int32_t error_id = 0;
env->set_field_object_by_name(env, stack, object_simple, "object_value", object_minimal, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }set_field_string_by_name
void (*set_field_string_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, SPVM_OBJ* value, int32_t* error_id, const char* func_name, const char* file, int32_t line);
The same as "set_field_object_by_name" native API.
get_field_string_chars_by_name
const char* (*get_field_string_chars_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Calls the "get_field_string_by_name". If the return value is NULL, returns NULL. Otherwise, calls the "get_chars" given the return value, and returns the return value of "get_chars" native API.
get_method
SPVM_NATIVE_METHOD* (*get_method)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* method_name);
Searches a method given the basic type name basic_type_name and the method name method_name.
If it is found, returns it. Otherwise, returns NULL.
Examples:
SPVM_NATIVE_METHOD* method = env->get_method(env, stack, "Foo", "get");get_class_method
SPVM_NATIVE_METHOD* (*get_class_method)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* method_name);
Searches a class method given the basic type name basic_type_name and the method name method_name.
If it is found, returns it. Otherwise, returns NULL.
Examples:
SPVM_NATIVE_METHOD* method = env->get_class_method(env, stack, "Foo", "get");get_instance_method_static
SPVM_NATIVE_METHOD* (*get_instance_method_static)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* method_name);
Searches an instance method given the basic type name basic_type_name and the method name method_name.
If found, returns it. Otherwise, returns NULL.
Examples:
SPVM_NATIVE_METHOD* method = env->get_instance_method_static(env, stack, "Foo", "get");get_instance_method
SPVM_NATIVE_METHOD* (*get_instance_method)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* method_name);
Searches an instance method given the object object and the method name method_name.
If it is found, returns it. Otherwise, returns NULL.
Examples:
SPVM_NATIVE_METHOD* method = env->get_instance_method(env, stack, object, "get");call_method_no_mortal
int32_t (*call_method_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_METHOD* method, int32_t args_width, const char* func_name, const char* file, int32_t line);
Calls the method method given the width of the argument args_width.
The func_name, file, and line arguments are used to store the caller information of this method call. These are used by the caller operator.
If the method throws an exception, returns a basic type ID of an error class. Otherwise, returns 0.
stack[0] is set to the return value of the method.
This native API should not be used unless special purposes are intended. Normally, use "call_method" native API.
call_method
int32_t (*call_method)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_METHOD* method, int32_t args_width, const char* func_name, const char* file, int32_t line);
Calls "call_method_no_mortal" native API and if the type of its return value is an object type, it is pushed to the native mortal stack.
Returns the return value of "call_method_no_mortal".
call_class_method_by_name
void (*call_class_method_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* method_name, int32_t args_width, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Calls a class method given the basic type name basic_type_name and the method name method_name.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If the method given by method_name is not found, an exception is thrown.
If the found method is not a class method, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
Examples:
// Call a class method
int32_t error_id = 0;
int32_t total;
{
int32_t args_width = 2;
stack[0].ival = 5;
stack[1].ival = 10;
env->call_class_method_by_name(env, stack, "MyClass", "sum", args_width, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }
total = stack[0].ival;
}call_instance_method_static_by_name
void (*call_instance_method_static_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* method_name, int32_t args_width, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Calls an instance method by the basic type name basic_type_name and the method name method_name.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If the method given by method_name is not found, an exception is thrown.
If the found method is not an instance method, an exception is thrown.
If stack[0].oval is NULL, an exception is thrown.
If stack[0].oval cannot be assigned to the class given by basic_type_name, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
Examples:
int32_t error_id = 0;
int32_t output;
{
int32_t args_width = 1;
stack[0].oval = obj_point;
env->call_instance_method_static_by_name(env, stack, "Point", "x", args_width, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }
output = stack[0].ival;
}call_instance_method_by_name
void (*call_instance_method_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* method_name, int32_t args_width, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Calls an instance method given the method name method_name.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If stack[0].oval is NULL, an exception is thrown.
The type dimension of stack[0].oval must be 0. Otherwise, an exception is thrown.
If the instance method given by method_name is not found in the class of the object or its superclasses, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
new_object_no_mortal
SPVM_OBJ* (*new_object_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type);
Creates a new object given the basic type basic_type.
basic_type must not be NULL.
basic_type must be a class type.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_object" native API.
new_object
SPVM_OBJ* (*new_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type);
Calls "new_object_no_mortal" and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_NATIVE_BASIC_TYPE* basic_type = env->get_basic_type(env, stack, "Int");
SPVM_OBJ* object = env->new_object(env, stack, basic_type);new_object_by_name
SPVM_OBJ* (*new_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Creates a new object given the basic type name basic_type_name, and returns it.
The created object is pushed to the native mortal stack.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If the creation of the object failed, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
Examples:
int32_t error_id = 0;
SPVM_OBJ* obj_point = env->new_object_by_name(env, stack, "Point", &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }new_pointer_object_no_mortal
SPVM_OBJ* (*new_pointer_object_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, void* pointer);
Calls "new_object_no_mortal" native API and sets the pointer pointer to a native data to the created object, and returns it.
This native API should not be used unless special purposes are intended. Normally, use "new_pointer_object" native API.
new_pointer_object
SPVM_OBJ* (*new_pointer_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, void* pointer);
Calls "new_pointer_object_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_NATIVE_BASIC_TYPE* basic_type = env->get_basic_type(env, stack, "MyTm");
void* native_ptr = env->new_memory_block(env, stack, sizeof(struct tm));
SPVM_OBJ* obj_tm = env->new_pointer_object(env, stack, basic_type, native_ptr);new_pointer_object_by_name
SPVM_OBJ* (*new_pointer_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, void* pointer, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Calls "new_object_by_name" native API and sets the pointer pointer to a native data to the created object, and returns it.
Examples:
int32_t error_id = 0;
void* native_ptr = env->new_memory_block(env, stack, 16);
SPVM_OBJ* obj = env->new_pointer_object_by_name(env, stack, "TestCase::Pointer", native_ptr, &error_id, __func__, FILE_NAME, __LINE__);
if (error_id) { return error_id; }get_pointer
void* (*get_pointer)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns pointer value of the object object.
Examples:
struct tm* tm = (struct tm*)env->get_pointer(env, stack, obj_tm);set_pointer
void (*set_pointer)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, void* pointer);
Sets the pointer value of the object object to the pointer pointer.
new_string_nolen_no_mortal
SPVM_OBJ* (*new_string_nolen_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes);
Creates a new string object given a C string bytes. bytes must end with \0.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_string_nolen" native API.
new_string_nolen
SPVM_OBJ* (*new_string_nolen)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes);
Calls "new_string_nolen_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* str_obj = env->new_string_nolen(env, stack, "Hello World");new_string_no_mortal
SPVM_OBJ* (*new_string_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes, int32_t length);
Creates a new string object given the C string bytes and the length length, and returns it.
If its memory allocation failed, returns NULL.
If the actual length of bytes is less than length, or if bytes is NULL, the remaining part up to length is filled with \0.
This native API should not be used unless special purposes are intended. Normally, use "new_string" native API.
new_string
SPVM_OBJ* (*new_string)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes, int32_t length);
Calls "new_string_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* str_obj = env->new_string(env, stack, "Hello \0World", 11);new_byte_array_no_mortal
SPVM_OBJ* (*new_byte_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new array of the byte[] type given the length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_byte_array" native API.
new_byte_array
SPVM_OBJ* (*new_byte_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Calls "new_byte_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* byte_array = env->new_byte_array(env, stack, 100);new_short_array_no_mortal
SPVM_OBJ* (*new_short_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new array of the short[] type given the length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_short_array" native API.
new_short_array
SPVM_OBJ* (*new_short_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Calls "new_short_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* short_array = env->new_short_array(env, stack, 100);new_int_array_no_mortal
SPVM_OBJ* (*new_int_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new array of the int[] type given the length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_int_array" native API.
new_int_array
SPVM_OBJ* (*new_int_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Calls "new_int_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* int_array = env->new_int_array(env, stack, 100);new_long_array_no_mortal
SPVM_OBJ* (*new_long_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new array of the long[] type given the length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_long_array" native API.
new_long_array
SPVM_OBJ* (*new_long_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Calls "new_long_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* long_array = env->new_long_array(env, stack, 100);new_float_array_no_mortal
SPVM_OBJ* (*new_float_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new array of the float[] type given the length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_float_array" native API.
new_float_array
SPVM_OBJ* (*new_float_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Calls "new_float_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* float_array = env->new_float_array(env, stack, 100);new_double_array_no_mortal
SPVM_OBJ* (*new_double_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new array of the double[] type given the length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_double_array" native API.
new_double_array
SPVM_OBJ* (*new_double_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Calls "new_double_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_OBJ* double_array = env->new_double_array(env, stack, 100);new_object_array_no_mortal
SPVM_OBJ* (*new_object_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t length);
Creates a new array of an object type given the basic type basic_type and the array length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_object_array" native API.
new_object_array
SPVM_OBJ* (*new_object_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t length);
Calls "new_object_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_NATIVE_BASIC_TYPE* basic_type = env->get_basic_type(env, stack, "Int");
SPVM_OBJ* object_array = env->new_object_array(env, stack, basic_type, 100);new_object_array_by_name
SPVM_OBJ* (*new_object_array_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t length, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Creates a new object array given the basic type name basic_type_name and the array length length, and returns it.
The created array is pushed to the native mortal stack.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If the creation of the array failed, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
new_string_array
SPVM_OBJ* (*new_string_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Calls "new_string_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
new_muldim_array_no_mortal
SPVM_OBJ* (*new_muldim_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t type_dimension, int32_t length);
Creates a new multi-dimensional array given the basic type basic_type, the type dimension type_dimension, and the array length length, and returns it.
If its memory allocation failed, returns NULL.
type_dimension must be less than or equal to 255.
This native API should not be used unless special purposes are intended. Normally, use "new_muldim_array" native API.
new_muldim_array
SPVM_OBJ* (*new_muldim_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t type_dimension, int32_t length);
Calls "new_muldim_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
// Creates 2-dimensional array - new Int[][100].
SPVM_NATIVE_BASIC_TYPE* basic_type = env->get_basic_type(env, stack, "Int");
SPVM_OBJ* multi_array = env->new_muldim_array(env, stack, basic_type, 2, 100);new_muldim_array_by_name
SPVM_OBJ* (*new_muldim_array_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t type_dimension, int32_t length, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Creates a new multi-dimensional array given the basic type name basic_type_name, the type dimension type_dimension, and the array length length, and returns it.
The created array is pushed to the native mortal stack.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If the creation of the array failed, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
new_mulnum_array_no_mortal
SPVM_OBJ* (*new_mulnum_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t length);
Creates a new multi-numeric array given the basic type basic_type and the array length length, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_mulnum_array" native API.
new_mulnum_array
SPVM_OBJ* (*new_mulnum_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t length);
Calls "new_mulnum_array_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
Examples:
SPVM_NATIVE_BASIC_TYPE* basic_type = env->get_basic_type(env, stack, "Complex_2d");
SPVM_OBJ* value_array = env->new_mulnum_array(env, stack, basic_type, 100);new_mulnum_array_by_name
SPVM_OBJ* (*new_mulnum_array_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t length, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Creates a new multi-numeric array given the basic type name basic_type_name and the array length length, and returns it.
The created array is pushed to the native mortal stack.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If the basic type given by basic_type_name is not found, an exception is thrown.
If the creation of the array failed, an exception is thrown.
If an exception is thrown, error_id is set to a non-zero value. Otherwise, it is set to 0.
new_array_proto_no_mortal
SPVM_OBJ* (*new_array_proto_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array, int32_t length);
Creates a new array given the prototype array array and the length length, and returns it.
If array is NULL, returns NULL.
If the type of array is not an array type, returns NULL.
If length is less than 0, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_array_proto" native API.
new_array_proto
SPVM_OBJ* (*new_array_proto)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array, int32_t length);
Calls "new_array_proto_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
length
int32_t (*length)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns the length of the object object.
object must be defined.
If object is an array, its array length is returned.
If object is a string, its string length is returned.
Otherwise 0 is returned.
Examples:
int32_t length = env->length(env, stack, object);get_elems_byte
int8_t* (*get_elems_byte)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array);
Returns the pointer to the elements of the byte array array.
Examples:
int8_t* values = env->get_elems_byte(env, stack, array);
values[3] = 5;get_elems_short
int16_t* (*get_elems_short)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array);
Returns the pointer to the elements of the short array array.
Examples:
int16_t* values = env->get_elems_short(env, stack, array);
values[3] = 5;get_elems_int
int32_t* (*get_elems_int)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array);
Returns the pointer to the elements of the int array array.
Examples:
int32_t* values = env->get_elems_int(env, stack, array);
values[3] = 5;get_elems_long
int64_t* (*get_elems_long)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array);
Returns the pointer to the elements of the long array array.
Examples:
int64_t* values = env->get_elems_long(env, stack, array);
values[3] = 5;get_elems_float
float* (*get_elems_float)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array);
Returns the pointer to the elements of the float array array.
Examples:
float* values = env->get_elems_float(env, stack, array);
values[3] = 1.5f;get_elems_double
double* (*get_elems_double)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array);
Returns the pointer to the elements of the double array array.
Examples:
double* values = env->get_elems_double(env, stack, array);
values[3] = 1.5;get_elem_object
SPVM_OBJ* (*get_elem_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array, int32_t index);
Returns the element of the array array at the index index.
Examples:
SPVM_OBJ* object = env->get_elem_object(env, stack, array, 3);get_elem_string
SPVM_OBJ* (*get_elem_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array, int32_t index);
Calls "get_elem_object" native API, and returns its return value.
set_elem_object
void (*set_elem_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array, int32_t index, SPVM_OBJ* object);
Sets object to the element of the array array at the index index.
Examples:
env->set_elem_object(env, stack, array, 3, object);set_elem_string
void (*set_elem_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array, int32_t index, SPVM_OBJ* string);
Calls "set_elem_object" native API.
get_chars
const char* (*get_chars)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string_object);
Returns the pointer to the characters stored in the string string_object.
Examples:
const char* chars = env->get_chars(env, stack, obj_string);get_bool_object_value
int32_t (*get_bool_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* bool_object);
Returns the value stored in Bool object bool_object.
bool_object must not be NULL.
Examples:
int32_t bool_value = env->get_bool_object_value(env, stack, bool_object);concat_no_mortal
SPVM_OBJ* (*concat_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string1, SPVM_OBJ* string2);
Creates a new string by concatenating two strings string1 and string2, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "concat" native API.
concat
SPVM_OBJ* (*concat)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string1, SPVM_OBJ* string2);
Calls "concat_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
shorten
void (*shorten)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string, int32_t new_length);
Shortens the string string to the length new_length.
Characters whose index is greater than or equal to new_length are filled with \0.
If the string string is NULL, nothing is performed.
If the type of string is not the string type, nothing is performed.
If string is read-only, nothing is performed.
If new_length is not greater than or equal to 0, nothing is performed.
If new_length is greater than the current length of string, nothing is performed.
make_read_only
void (*make_read_only)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string);
Makes the string string read-only.
If string is NULL, no operation is performed.
is_read_only
int32_t (*is_read_only)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string);
If the string string is not NULL and it is read-only, returns 1, otherwise returns 0.
void (*print)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string);
Prints the string string to SPVM's standard output.
print_stderr
void (*print_stderr)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string);
Prints the string string to SPVM's standard error.
If string is NULL, no output is produced.
dump_no_mortal
SPVM_OBJ* (*dump_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Performs the dump operation, and returns its return value.
This native API should not be used unless special purposes are intended. Normally, use "dump" native API.
dump
SPVM_OBJ* (*dump)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Calls "dump_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
dumpc
const char* (*dumpc)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Calls "dump" native API, then calls "get_chars" native API with the returned string object, and returns the character pointer.
copy_no_mortal
SPVM_OBJ* (*copy_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
The type of the object object must be a string type, a numeric array type, or a multi-numeric array type.
If the type of the object object is the string type, creates a new string and copies the characters stored in object to it, and returns the new string object.
If the type of the object object is a numeric array type or a multi-numeric array type, creates a new array using the type of object as a prototype and copies the elements stored in object to it, and returns the new array object.
If object is NULL, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "copy" native API.
copy
SPVM_OBJ* (*copy)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Calls "copy_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
get_spvm_version_string
const char* (*get_spvm_version_string)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the version string of the SPVM language.
get_spvm_version_number
double (*get_spvm_version_number)(SPVM_ENV* env, SPVM_VALUE* stack);
Calls "get_spvm_version_string" native API and converts its return value to a double value.
get_version_string
const char* (*get_version_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type);
Returns the version string of the basic type basic_type.
If the version string is not defined, returns NULL.
get_version_number
double (*get_version_number)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type);
Calls "get_version_string" native API and converts its return value to a double value.
If the version string is not defined, returns -1.
die
int32_t (*die)(SPVM_ENV* env, SPVM_VALUE* stack, const char* exception_format, const char* func_name, const char* file, int32_t line, ...);
Sets an exception message using a format string and its metadata, then returns the basic type ID of the error class.
exception_format is a format string in the style of printf.
func_name, file, and line are metadata that indicate where the exception occurred.
The subsequent arguments are values to be formatted according to exception_format.
Examples:
return env->die(env, stack, "Error: %s", __func__, FILE_NAME, __LINE__, "Something went wrong");
int32_t id = 10;
return env->die(env, stack, "Invalid ID %d", __func__, FILE_NAME, __LINE__, id);get_exception
SPVM_OBJ* (*get_exception)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the value of the exception variable.
The return value is an SPVM string object.
set_exception
void (*set_exception)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* exception);
Sets exception to the exception variable.
exception must be an SPVM string object or NULL.
new_stack_trace_no_mortal
SPVM_OBJ* (*new_stack_trace_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* exception, SPVM_NATIVE_METHOD* method, int32_t line);
Creates a new string by appending a stack trace line (including the method and the line number) to the end of the exception exception, and returns it.
If its memory allocation failed, returns NULL.
exception must be an SPVM string object. The return value is an SPVM string object.
This native API should not be used unless special purposes are intended. Normally, use "new_stack_trace" native API.
new_stack_trace
SPVM_OBJ* (*new_stack_trace)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* exception, SPVM_NATIVE_METHOD* method, int32_t line);
Calls "new_stack_trace_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
is_string
int32_t (*is_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its type is the string type, returns 1, otherwise returns 0.
is_class
int32_t (*is_class)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its type is a class type, returns 1, otherwise returns 0.
is_pointer_class
int32_t (*is_pointer_class)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its class has the pointer attribute, returns 1, otherwise returns 0.
is_array
int32_t (*is_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its type is an array type, returns 1, otherwise returns 0.
is_object_array
int32_t (*is_object_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its type is an object array type, returns 1, otherwise returns 0.
is_numeric_array
int32_t (*is_numeric_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its type is a numeric array type, returns 1, otherwise returns 0.
is_mulnum_array
int32_t (*is_mulnum_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its type is a multi-numeric array type, returns 1, otherwise returns 0.
isa
int32_t (*isa)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t type_dimension);
If the object object satisfies the assignment requirement without data conversion to the type given by the basic type basic_type and the type dimension type_dimension, returns 1, otherwise returns 0.
isa_by_name
int32_t (*isa_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* basic_type_name, int32_t type_dimension);
If the basic type given by basic_type_name is not found, returns 0.
If the object object satisfies the assignment requirement without data conversion to the type given by basic_type_name and the type dimension type_dimension, returns 1, otherwise returns 0.
is_type
int32_t (*is_type)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_BASIC_TYPE* basic_type, int32_t type_dimension);
If the type of the object object is equal to the type given by the basic type basic_type and the type dimension type_dimension, returns 1, otherwise returns 0.
object must not be NULL.
is_type_by_name
int32_t (*is_type_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* basic_type_name, int32_t type_dimension);
If the basic type given by basic_type_name is not found, returns 0.
If the object object is not NULL and its type is equal to the type given by basic_type_name and the type dimension type_dimension, returns 1, otherwise returns 0.
elem_isa
int32_t (*elem_isa)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array, SPVM_OBJ* element);
If the element element satisfies the assignment requirement without data conversion to the element type of the array array, returns 1, otherwise returns 0.
get_elem_size
int32_t (*get_elem_size)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* array);
Returns the byte size of an element of the array array.
get_type_name_no_mortal
SPVM_OBJ* (*get_type_name_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Creates a new string object that represents the type name of the object object, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "get_type_name" native API.
get_type_name
SPVM_OBJ* (*get_type_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Calls "get_type_name_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
get_compile_type_name_no_mortal
SPVM_OBJ* (*get_compile_type_name_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t type_dimension, int32_t type_flag);
Creates a new string object that represents the compile-time type name of the type given by basic_type_name, type_dimension, and type_flag, and returns it.
If its memory allocation failed, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "get_compile_type_name" native API.
get_compile_type_name
SPVM_OBJ* (*get_compile_type_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t type_dimension, int32_t type_flag);
Calls "get_compile_type_name_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
enter_scope
int32_t (*enter_scope)(SPVM_ENV* env, SPVM_VALUE* stack);
Performs an entering scope operation and returns the current top position of the native mortal stack. This value is used as an argument to "leave_scope" native API.
leave_scope
void (*leave_scope)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t mortal_stack_top);
Performs a leaving scope operation given the top position of the native mortal stack mortal_stack_top.
Normally, mortal_stack_top is the return value from "enter_scope" native API.
push_mortal
int32_t (*push_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Pushes the object object to the native mortal stack.
If object is NULL, no operation is performed.
If successful, returns 0. Otherwise, returns a non-zero value.
weaken
int32_t (*weaken)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ** ref);
Weakens the reference ref.
ref must not be NULL.
If the object referenced by ref is NULL, no operation is performed.
If ref is already weakened, no operation is performed.
See the documentation of weak reference for more details.
isweak
int32_t (*isweak)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ** ref);
If the reference ref is weakened, returns 1, otherwise returns 0.
ref must not be NULL.
If the object referenced by ref is NULL, returns 0.
unweaken
void (*unweaken)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ** ref);
Unweakens the reference ref.
ref must not be NULL.
If the object referenced by ref is NULL, no operation is performed.
If ref is not weakened, no operation is performed.
strerror_string
SPVM_OBJ* (*strerror_string)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value, int32_t length);
Calls "strerror" and creates an SPVM string object from its return value, pushes it to the native mortal stack, and returns it.
strerror_string_nolen
SPVM_OBJ* (*strerror_string_nolen)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value);
Calls "strerror_string" with length set to 0, and returns its return value.
strerror
const char* (*strerror)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value, int32_t length);
Returns the error string corresponding to errno_value, similar to the strerror function in C.
If length is 0, the internal buffer length is set to 128.
If the operation fails, errno is set to a positive value.
This native API is thread-safe.
strerror_nolen
const char* (*strerror_nolen)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value);
Calls "strerror" with length set to 0, and returns its return value.
is_binary_compatible_object
int32_t (*is_binary_compatible_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is binary compatible with the current runtime environment, returns 1, otherwise returns 0.
new_stack
SPVM_VALUE* (*new_stack)(SPVM_ENV* env);
Creates a new runtime stack, and returns it.
free_stack
void (*free_stack)(SPVM_ENV* env, SPVM_VALUE* stack);
Frees the runtime stack stack.
get_field_object_defined_and_has_pointer_by_name
SPVM_OBJ* (*get_field_object_defined_and_has_pointer_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Calls "get_field_object_by_name" native API, and returns its return value.
If the return value is NULL, an exception is thrown.
If the pointer stored in the return value is NULL, an exception is thrown.
get_field_object_ref
SPVM_OBJ** (*get_field_object_ref)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns the address where the value of the field field is stored.
get_field_object_ref_by_name
SPVM_OBJ** (*get_field_object_ref_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Searches for a field given the object object and the field name field_name.
If it is found, returns the address where the value of the field is stored. Otherwise, an exception is thrown.
The function name func_name, the file path file, and the line number line must be given for the exception stack trace.
If an exception is thrown, the value referenced by error_id is set to a non-zero value. Otherwise, it is set to 0.
is_binary_compatible_stack
int32_t (*is_binary_compatible_stack)(SPVM_ENV* env, SPVM_VALUE* stack);
If the runtime stack stack is binary compatible with the runtime environment env, returns 1, otherwise returns 0.
assign_object
void (*assign_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ** ref, SPVM_OBJ* object);
Assigns the object object to the place referenced by the reference ref.
This native API should not be used unless special purposes are intended.
new_string_array_no_mortal
SPVM_OBJ* (*new_string_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new string array given the length length, and returns it.
This native API should not be used unless special purposes are intended. Normally, use "new_string_array" native API.
new_memory_block
void* (*new_memory_block)(SPVM_ENV* env, SPVM_VALUE* stack, size_t size);
Creates a new memory block given the byte size size and returns its address.
If size is 0, returns NULL.
If size is greater than SIZE_MAX defined in the system, returns NULL.
If the system memory allocation function returns NULL, this native API returns NULL.
The count of the memory blocks managed by this runtime is incremented by 1.
free_memory_block
void (*free_memory_block)(SPVM_ENV* env, SPVM_VALUE* stack, void* block);
Frees the memory block block.
If block is NULL, no operation is performed.
The count of the memory blocks managed by this runtime is decremented by 1.
get_memory_blocks_count
int32_t (*get_memory_blocks_count)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the count of the memory blocks managed by this runtime.
say
void (*say)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string);
Prints the string string followed by a newline (\n) to SPVM's standard output.
warn
void (*warn)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string, const char* func_name, const char* file, int32_t line);
Performs the warn operation given the string string, the function name func_name, the file path file, and the line number line.
spvm_stdin
FILE* (*spvm_stdin)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns SPVM's standard input.
spvm_stdout
FILE* (*spvm_stdout)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns SPVM's standard output.
spvm_stderr
FILE* (*spvm_stderr)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns SPVM's standard error.
check_bootstrap_method
int32_t (*check_bootstrap_method)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name);
Checks the definition of the bootstrap method.
If it is invalid, an exception is thrown.
If an exception is thrown, returns a non-zero value. Otherwise, returns 0.
new_array_proto_element_no_mortal
SPVM_OBJ* (*new_array_proto_element_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* element, int32_t length);
Creates a new array given the prototype element element and the length length, and returns it.
If element is NULL, returns NULL.
The type of element must be an object type.
If length is less than 0, returns NULL.
This native API should not be used unless special purposes are intended. Normally, use "new_array_proto_element" native API.
new_array_proto_element
SPVM_OBJ* (*new_array_proto_element)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* element, int32_t length);
Calls "new_array_proto_element_no_mortal" native API and pushes its return value to the native mortal stack, and returns it.
get_byte_object_value
int8_t (*get_byte_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* byte_object);
Returns the value of the value field of Byte object byte_object.
byte_object must be a Byte object.
get_short_object_value
int16_t (*get_short_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* short_object);
Returns the value of the value field of Short object short_object.
short_object must be a Short object.
get_int_object_value
int32_t (*get_int_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* int_object);
Returns the value of the value field of Int object int_object.
int_object must be an Int object.
get_long_object_value
int64_t (*get_long_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* long_object);
Returns the value of the value field of Long object long_object.
long_object must be a Long object.
get_float_object_value
float (*get_float_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* float_object);
Returns the value of the value field of Float object float_object.
float_object must be a Float object.
get_double_object_value
double (*get_double_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* double_object);
Returns the value of the value field of Double object double_object.
double_object must be a Double object.
no_free
int32_t (*no_free)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the no_free flag of the object object is enabled, returns 1, otherwise returns 0.
set_no_free
void (*set_no_free)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t no_free);
If no_free is a true value, enables the no_free flag of the object object, otherwise disables it.
get_stack_tmp_buffer
char* (*get_stack_tmp_buffer)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the temporary buffer on the runtime stack stack.
The byte size of the temporary buffer is "SPVM_NATIVE_C_STACK_TMP_BUFFER_SIZE".
print_exception_to_stderr
void (*print_exception_to_stderr)(SPVM_ENV* env, SPVM_VALUE* stack);
Prints "[An exception is converted to a warning]\n", the current exception, and "\n" to SPVM's standard error.
dump_object_internal
SPVM_OBJ* (*dump_object_internal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Dumps the internal information of the object object, creates a new SPVM string from the information, and returns it.
The dumped internal information looks like the following:
[Object Internal:0x55dd87806090]
pointer:(nil)
weaken_backrefs_length:0
ref_count:1
basic_type_name:Point
type_dimension:0
flag:
length:2If object is NULL, returns a string "undef".
get_seed
int32_t (*get_seed)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the value of the seed stack variable on the runtime stack stack.
set_seed
void (*set_seed)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t seed);
Sets the value of the seed stack variable on the runtime stack stack to seed.
If the value of the seed_initialized stack variable on the runtime stack stack is 0, it is set to 1.
seed_initialized
int32_t (*seed_initialized)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the value of the seed_initialized stack variable on the runtime stack stack.
get_basic_type_name_in_version_from
const char* (*get_basic_type_name_in_version_from)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_BASIC_TYPE* basic_type);
Returns the basic type name specified by the version_from statement. If it is not specified, returns NULL.
set_command_info_warning
int32_t (*set_command_info_warning)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t warning);
Sets the CommandInfo#WARNING class variable to warning.
If an exception is thrown, returns the basic type ID of the Error class, otherwise returns 0.
This native API should not be used unless special purposes are intended.
destroy_cache_class_vars
void (*destroy_cache_class_vars)(SPVM_ENV* env, SPVM_VALUE* stack);
Sets all class variables that have the cache attribute and are of an object type to undef.
new_stack_with_all_method_call_permitted
SPVM_VALUE* (*new_stack_with_all_method_call_permitted)(SPVM_ENV* env);
Creates a new runtime stack where all method calls are permitted.
This native API is intended for use by applications (such as browsers) that implement a security sandbox.
call_instance_method_no_mortal
int32_t (*call_instance_method_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, const char* method_name, int32_t args_width);
Calls an instance method by its name method_name with the specified argument width args_width.
stack[0].oval must contain the invocant object.
If the method throws an exception, returns the basic type ID of the error class. Otherwise, returns 0.
The return value of the method is set to stack[0].
This native API should not be used unless special purposes are intended. Normally, use "call_instance_method" native API.
call_instance_method
int32_t (*call_instance_method)(SPVM_ENV* env, SPVM_VALUE* stack, const char* method_name, int32_t args_width);
Calls "call_instance_method_no_mortal". If the return value is an object type, it is pushed to the native mortal stack.
call_method_no_mortal_no_check_args
int32_t (*call_method_no_mortal_no_check_args)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_NATIVE_METHOD* method, int32_t args_width, const char* func_name, const char* file_name, int32_t line);
Same as "call_method_no_mortal", but performs no type checking on arguments.
call_instance_method_no_mortal_less_check_args
int32_t (*call_instance_method_no_mortal_less_check_args)(SPVM_ENV* env, SPVM_VALUE* stack, const char* method_name, int32_t args_width, const char* decl_args_signature, const char* func_name, const char* file_name, int32_t line);
Same as "call_instance_method_no_mortal", but performs reduced type checking using the hint decl_args_signature.
enable_options
void (*enable_options)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Turns on the options flag if the type of object is an object array (object[]).
disable_options
void (*disable_options)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Turns off the options flag of the object object.
is_options
int32_t (*is_options)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the options flag of the object object is set, returns 1; otherwise returns 0.
is_any_object_array
int32_t (*is_any_object_array)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
If the object object is not NULL and its type is an object array type (object[]), returns 1; otherwise returns 0.
exists_field
int32_t (*exists_field)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Returns 1 if the field existence flag of the field field in object is true, otherwise returns 0.
exists_field_by_name
int32_t (*exists_field_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Same as "exists_field", but the field is specified by its name field_name.
delete_field
void (*delete_field)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, SPVM_NATIVE_FIELD* field);
Deletes the field field from object.
The field existence flag is set to 0. The value of the field is reset to 0 (for numeric types) or undef (for object types).
delete_field_by_name
void (*delete_field_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, const char* field_name, int32_t* error_id, const char* func_name, const char* file, int32_t line);
Same as "delete_field", but the field is specified by its name field_name.
make_fixed_length
void (*make_fixed_length)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Sets the fixed-length flag of the object object.
is_fixed_length
int32_t (*is_fixed_length)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns 1 if the fixed-length flag of the object object is set, otherwise returns 0.
set_length
int32_t (*set_length)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t length);
Sets the length of the object object. object must be a string or an array.
If the length is extended, "set_capacity" is called automatically if needed. If shortened, unused elements are destroyed.
If successful, returns 0. Otherwise, sets an exception and returns a basic type ID of an error class.
capacity
int32_t (*capacity)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns the value of the capacity member in the SPVM_OBJECT structure.
set_capacity
int32_t (*set_capacity)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t capacity);
Sets the capacity of the object object. object must be a string or an array.
A new memory area is allocated, and existing elements are copied to it.
If successful, returns 0. Otherwise, sets an exception and returns a basic type ID of an error class.
numeric_object_to_byte
int8_t (*numeric_object_to_byte)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Converts a numeric object (Box object) to an int8_t value.
If successful, error_id is set to 0. Otherwise, it is set to a non-zero value.
numeric_object_to_short
int16_t (*numeric_object_to_short)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Converts a numeric object to an int16_t value.
numeric_object_to_int
int32_t (*numeric_object_to_int)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Converts a numeric object to an int32_t value.
numeric_object_to_long
int64_t (*numeric_object_to_long)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Converts a numeric object to an int64_t value.
numeric_object_to_float
float (*numeric_object_to_float)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Converts a numeric object to a float value.
numeric_object_to_double
double (*numeric_object_to_double)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Converts a numeric object to a double value.
numeric_object_to_string_no_mortal
SPVM_OBJ* (*numeric_object_to_string_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Converts a numeric object to an SPVM string object.
If successful, error_id is set to 0. Otherwise, it is set to a non-zero value.
numeric_object_to_string
SPVM_OBJ* (*numeric_object_to_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object, int32_t* error_id);
Same as "numeric_object_to_string_no_mortal", but the return value is pushed to the native mortal stack.
is_numeric_object
int32_t (*is_numeric_object)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* object);
Returns 1 if object is not NULL and is a numeric object (Box object), otherwise returns 0.
say_stderr
void (*say_stderr)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* string);
Same as "say", but prints the output to SPVM's standard error.
get_call_depth
int32_t (*get_call_depth)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the current call depth on the runtime stack stack.
get_caller_info_stack
SPVM_VALUE* (*get_caller_info_stack)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the address of the caller_info_stack internal variable on the runtime stack stack.
Note: String fields in the records (e.g., method name or file name) may not be null-terminated. Perform NULL checks and use strncpy for safe copying.
get_caller_info_stack_record_size
int32_t (*get_caller_info_stack_record_size)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the size of a single record in the caller info stack.
get_current_method
SPVM_OBJ* (*get_current_method)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t level, int32_t* error_id);
Returns the method object at the specified level on the runtime stack stack.
level 0 is the current method, 1 is its caller, and so on.
If level is out of range or an internal error occurs, returns NULL and sets error_id to a non-zero value.
caller
SPVM_OBJ* (*caller)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t level, int32_t* error_id);
Returns a CallerInfo object containing information about the caller at the specified level.
The object is automatically pushed to the native mortal stack.
* 0 represents the caller of the current method. * 1 represents the caller of the caller.
If successful, returns the CallerInfo object and sets error_id to 0. Otherwise, returns NULL and sets error_id to a non-zero value.
caller_no_mortal
SPVM_OBJ* (*caller_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t level, int32_t* error_id);
This is the same as "caller", but the returned object is not pushed to the native mortal stack.
die_with_string
int32_t (*die_with_string)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* obj_exception, const char* func_name, const char* file, int32_t line);
Sets an exception with an existing string object obj_exception and its metadata, then returns the basic type ID of an error class.
This is the same as "die", but it takes an SPVM string object instead of a format string.
Examples:
SPVM_OBJ* obj_exception = env->new_string_nolen(env, stack, "Custom error message");
return env->die_with_string(env, stack, obj_exception, __func__, __FILE__, __LINE__);build_exception_message_no_mortal
SPVM_OBJ* (*build_exception_message_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t level);
This is the same as "build_exception_message", but the returned object is not pushed to the native mortal stack.
build_exception_message
SPVM_OBJ* (*build_exception_message)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t level);
Reconstructs a full exception message including a stack trace by using the metadata stored in the runtime stack.
This function creates a new SPVM string object by combining the original exception message (stored in the exception slot of the stack) with caller information retrieved from the metadata slots.
The level argument specifies the range of the stack trace relative to the current call depth:
* Positive values or zero: The trace starts from the exception origin down to the depth calculated as current_call_depth + level.
This is useful for eval blocks or Fn#build_exception_message to limit the trace depth.
The metadata used for reconstruction includes the function name, file path, line number, and the caller information stack.
Returns the newly created string object. This object is automatically pushed to the native mortal stack.
Examples:
SPVM_OBJ* obj_full_message = env->build_exception_message(env, stack, 0);
env->set_exception(env, stack, obj_full_message);is_utf8
int32_t (*is_utf8)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* obj_string, int32_t* error_id);
Checks if the given string obj_string is a valid UTF-8 sequence.
If it is a valid UTF-8 sequence, returns 1, otherwise returns 0.
If obj_string is NULL, error_id is set to a non-zero value and returns 0. Otherwise, error_id is set to 0.
set_byte_object_value
void (*set_byte_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* byte_object, int8_t value);
Sets the value of the value field of the Byte object byte_object.
Note: This method sets the value even if the object is marked as read-only.
set_short_object_value
void (*set_short_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* short_object, int16_t value);
Sets the value of the value field of the Short object short_object.
Note: This method sets the value even if the object is marked as read-only.
set_int_object_value
void (*set_int_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* int_object, int32_t value);
Sets the value of the value field of the Int object int_object.
Note: This method sets the value even if the object is marked as read-only.
set_long_object_value
void (*set_long_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* long_object, int64_t value);
Sets the value of the value field of the Long object long_object.
Note: This method sets the value even if the object is marked as read-only.
set_float_object_value
void (*set_float_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* float_object, float value);
Sets the value of the value field of the Float object float_object.
Note: This method sets the value even if the object is marked as read-only.
set_double_object_value
void (*set_double_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_OBJ* double_object, double value);
Sets the value of the value field of the Double object double_object.
Note: This method sets the value even if the object is marked as read-only.
Examples:
int32_t error_id = 0;
SPVM_OBJ* obj_int = env->new_object_by_name(env, stack, "Int", &error_id);
env->set_int_object_value(env, stack, obj_int, 10);Native API IDs
Native APIs have its IDs.
0 runtime
1 api
2 new_env
3 free_env
4 call_init_methods
5 set_command_info_program_name
6 set_command_info_argv
7 set_command_info_basetime
8 destroy_class_vars
9 args_width
10 get_object_basic_type
11 get_object_basic_type_id
12 get_object_basic_type_name
13 get_object_type_dimension
14 get_basic_type
15 get_basic_type_by_name
16 get_basic_type_by_id
17 get_basic_type_id
18 get_basic_type_id_by_name
19 get_class_var
20 get_class_var_byte
21 get_class_var_short
22 get_class_var_int
23 get_class_var_long
24 get_class_var_float
25 get_class_var_double
26 get_class_var_object
27 get_class_var_string
28 set_class_var_byte
29 set_class_var_short
30 set_class_var_int
31 set_class_var_long
32 set_class_var_float
33 set_class_var_double
34 set_class_var_object
35 set_class_var_string
36 get_class_var_object_ref
37 get_class_var_byte_by_name
38 get_class_var_short_by_name
39 get_class_var_int_by_name
40 get_class_var_long_by_name
41 get_class_var_float_by_name
42 get_class_var_double_by_name
43 get_class_var_object_by_name
44 get_class_var_string_by_name
45 set_class_var_byte_by_name
46 set_class_var_short_by_name
47 set_class_var_int_by_name
48 set_class_var_long_by_name
49 set_class_var_float_by_name
50 set_class_var_double_by_name
51 set_class_var_object_by_name
52 set_class_var_string_by_name
53 get_field
54 get_field_static
55 get_field_byte
56 get_field_short
57 get_field_int
58 get_field_long
59 get_field_float
60 get_field_double
61 get_field_object
62 get_field_string
63 set_field_byte
64 set_field_short
65 set_field_int
66 set_field_long
67 set_field_float
68 set_field_double
69 set_field_object
70 set_field_string
71 get_field_byte_by_name
72 get_field_short_by_name
73 get_field_int_by_name
74 get_field_long_by_name
75 get_field_float_by_name
76 get_field_double_by_name
77 get_field_object_by_name
78 get_field_string_by_name
79 set_field_byte_by_name
80 set_field_short_by_name
81 set_field_int_by_name
82 set_field_long_by_name
83 set_field_float_by_name
84 set_field_double_by_name
85 set_field_object_by_name
86 set_field_string_by_name
87 get_field_string_chars_by_name
88 get_method
89 get_class_method
90 get_instance_method_static
91 get_instance_method
92 call_method_no_mortal
93 call_method
94 call_class_method_by_name
95 call_instance_method_static_by_name
96 call_instance_method_by_name
97 new_object_no_mortal
98 new_object
99 new_object_by_name
100 new_pointer_object_no_mortal
101 new_pointer_object
102 new_pointer_object_by_name
103 get_pointer
104 set_pointer
105 new_string_nolen_no_mortal
106 new_string_nolen
107 new_string_no_mortal
108 new_string
109 new_byte_array_no_mortal
110 new_byte_array
111 new_short_array_no_mortal
112 new_short_array
113 new_int_array_no_mortal
114 new_int_array
115 new_long_array_no_mortal
116 new_long_array
117 new_float_array_no_mortal
118 new_float_array
119 new_double_array_no_mortal
120 new_double_array
121 new_object_array_no_mortal
122 new_object_array
123 new_object_array_by_name
124 new_string_array
125 new_muldim_array_no_mortal
126 new_muldim_array
127 new_muldim_array_by_name
128 new_mulnum_array_no_mortal
129 new_mulnum_array
130 new_mulnum_array_by_name
131 new_array_proto_no_mortal
132 new_array_proto
133 length
134 get_elems_byte
135 get_elems_short
136 get_elems_int
137 get_elems_long
138 get_elems_float
139 get_elems_double
140 get_elem_object
141 get_elem_string
142 set_elem_object
143 set_elem_string
144 get_chars
145 get_bool_object_value
146 concat_no_mortal
147 concat
148 shorten
149 make_read_only
150 is_read_only
151 print
152 print_stderr
153 dump_no_mortal
154 dump
155 dumpc
156 copy_no_mortal
157 copy
158 get_spvm_version_string
159 get_spvm_version_number
160 get_version_string
161 get_version_number
162 die
163 get_exception
164 set_exception
165 new_stack_trace_no_mortal
166 new_stack_trace
167 is_string
168 is_class
169 is_pointer_class
170 is_array
171 is_object_array
172 is_numeric_array
173 is_mulnum_array
174 isa
175 isa_by_name
176 is_type
177 is_type_by_name
178 elem_isa
179 get_elem_size
180 get_type_name_no_mortal
181 get_type_name
182 get_compile_type_name_no_mortal
183 get_compile_type_name
184 enter_scope
185 leave_scope
186 push_mortal
187 weaken
188 isweak
189 unweaken
190 strerror_string
191 strerror_string_nolen
192 strerror
193 strerror_nolen
194 is_binary_compatible_object
195 is_binary_compatible_stack
196 new_stack
197 free_stack
198 get_field_object_defined_and_has_pointer_by_name
199 get_field_object_ref
200 get_field_object_ref_by_name
201 check_bootstrap_method
202 assign_object
203 new_string_array_no_mortal
204 new_memory_block
205 free_memory_block
206 get_memory_blocks_count
207 say
208 warn
209 spvm_stdin
210 spvm_stdout
211 spvm_stderr
212 new_array_proto_element_no_mortal
213 new_array_proto_element
214 get_byte_object_value
215 get_short_object_value
216 get_int_object_value
217 get_long_object_value
218 get_float_object_value
219 get_double_object_value
220 no_free
221 set_no_free
222 get_stack_tmp_buffer
223 print_exception_to_stderr
224 dump_object_internal
225 get_seed
226 set_seed
227 seed_initialized
228 get_basic_type_name_in_version_from
229 set_command_info_warning
230 destroy_cache_class_vars
231 new_stack_with_all_method_call_permitted
232 call_instance_method_no_mortal
233 call_instance_method
234 call_method_no_mortal_no_check_args
235 call_instance_method_no_mortal_less_check_args
236 enable_options
237 disable_options
238 is_options
239 is_any_object_array
240 exists_field
241 exists_field_by_name
242 delete_field
243 delete_field_by_name
244 make_fixed_length
245 is_fixed_length
246 set_length
247 capacity
248 set_capacity
249 numeric_object_to_byte
250 numeric_object_to_short
251 numeric_object_to_int
252 numeric_object_to_long
253 numeric_object_to_float
254 numeric_object_to_double
255 numeric_object_to_string_no_mortal
256 numeric_object_to_string
257 is_numeric_object
258 say_stderr
259 get_call_depth
260 get_caller_info_stack
261 get_caller_info_stack_record_size
262 get_current_method
263 caller_no_mortal
264 caller
265 die_with_string
266 build_exception_message_no_mortal
267 build_exception_message
268 call_end_methods
269 is_utf8
270 set_byte_object_value
271 set_short_object_value
272 set_int_object_value
273 set_long_object_value
274 set_float_object_value
275 set_double_object_valueConstant Values
Basic Type IDs
| ID | Name | Description |
|---|---|---|
| 0 | SPVM_NATIVE_C_BASIC_TYPE_ID_UNKNOWN | The basic type ID for unknown types |
| 1 | SPVM_NATIVE_C_BASIC_TYPE_ID_UNDEF | The basic type ID of the undef type |
| 2 | SPVM_NATIVE_C_BASIC_TYPE_ID_VOID | The basic type ID of the void type |
| 3 | SPVM_NATIVE_C_BASIC_TYPE_ID_BYTE | The basic type ID of byte type |
| 4 | SPVM_NATIVE_C_BASIC_TYPE_ID_SHORT | The basic type ID of short type |
| 5 | SPVM_NATIVE_C_BASIC_TYPE_ID_INT | The basic type ID of int type |
| 6 | SPVM_NATIVE_C_BASIC_TYPE_ID_LONG | The basic type ID of long type |
| 7 | SPVM_NATIVE_C_BASIC_TYPE_ID_FLOAT | The basic type ID of float type |
| 8 | SPVM_NATIVE_C_BASIC_TYPE_ID_DOUBLE | The basic type ID of double type |
| 9 | SPVM_NATIVE_C_BASIC_TYPE_ID_STRING | The basic type ID of string type |
| 10 | SPVM_NATIVE_C_BASIC_TYPE_ID_ANY_OBJECT | The basic type ID of the any object type |
| 11 | SPVM_NATIVE_C_BASIC_TYPE_ID_BYTE_CLASS | The basic type ID of the Byte class |
| 12 | SPVM_NATIVE_C_BASIC_TYPE_ID_SHORT_CLASS | The basic type ID of the Short class |
| 13 | SPVM_NATIVE_C_BASIC_TYPE_ID_INT_CLASS | The basic type ID of the Int class |
| 14 | SPVM_NATIVE_C_BASIC_TYPE_ID_LONG_CLASS | The basic type ID of the Long class |
| 15 | SPVM_NATIVE_C_BASIC_TYPE_ID_FLOAT_CLASS | The basic type ID of the Float class |
| 16 | SPVM_NATIVE_C_BASIC_TYPE_ID_DOUBLE_CLASS | The basic type ID of the Double class |
| 17 | SPVM_NATIVE_C_BASIC_TYPE_ID_BOOL_CLASS | The basic type ID of the Bool class |
| 18 | SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_CLASS | The basic type ID of the Error class |
| 19 | SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_SYSTEM_CLASS | The basic type ID of the Error::System class |
| 20 | SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_NOT_SUPPORTED_CLASS | The basic type ID of the Error::NotSupported class |
| 21 | SPVM_NATIVE_C_BASIC_TYPE_ID_COMMAND_INFO_CLASS | The basic type ID of the CommandInfo class |
| 22 | SPVM_NATIVE_C_BASIC_TYPE_ID_ADDRESS_CLASS | The basic type ID of the Address class |
| 23 | SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_COMPILE_CLASS | The basic type ID of the Error::Compile class |
| 24 | SPVM_NATIVE_C_BASIC_TYPE_ID_SPVM_CLASS | The basic type ID of the Error::Compile class |
| 25 | SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_METHOD_CALL_NOT_PERMITTED_CLASS | The basic type ID of the Error::MethodCallNotPermitted class |
| 26 | SPVM_NATIVE_C_BASIC_TYPE_ID_STRINGABLE_CLASS | The basic type ID of the Stringable class |
| 27 | SPVM_NATIVE_C_BASIC_TYPE_ID_COUNTABLE_CLASS | The basic type ID of the Countable class |
| 28 | SPVM_NATIVE_C_BASIC_TYPE_ID_CALLER_INFO_CLASS | The basic type ID of the CallerInfo class |
| 29 | SPVM_NATIVE_C_BASIC_TYPE_ID_CLONEABLE_CLASS | The basic type ID of the Cloneable class |
Basic Type Category IDs
| ID | Name | Description |
|---|---|---|
| 0 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_UNKNOWN | The basic type category for unknown types |
| 1 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_UNDEF | The basic type category for the undef type |
| 2 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_VOID | The basic type category for the void type |
| 3 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_NUMERIC | The basic type category for numeric types |
| 4 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_MULNUM | The basic type category for multi-numeric types |
| 5 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_STRING | The basic type category for string type |
| 6 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_CLASS | The basic type category for class types |
| 7 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_INTERFACE | The basic type category for interface types |
| 8 | SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_ANY_OBJECT | The basic type category for the any object type |
Type Flag IDs
| ID | Name | Description |
|---|---|---|
| 1 | SPVM_NATIVE_C_TYPE_FLAG_REF | A flag indicating that it is a reference type |
| 2 | SPVM_NATIVE_C_TYPE_FLAG_MUTABLE | A flag indicating that a mutable modifier is present |
| 4 | SPVM_NATIVE_C_TYPE_FLAG_VARARGS | A flag indicating that a variable length type |
SPVM_NATIVE_VERSION_NUMBER
SPVM_NATIVE_VERSION_NUMBER
The version number of the SPVM language.
Examples:
// 0.989062
double spvm_version_number = SPVM_NATIVE_VERSION_NUMBER;SPVM_NATIVE_VERSION_STRING
SPVM_NATIVE_VERSION_STRING
The version string of the SPVM language. This is a constant string.
Examples:
// "0.989062"
const char* spvm_version_string = SPVM_NATIVE_VERSION_STRING;SPVM_NATIVE_C_STACK_TMP_BUFFER_SIZE
SPVM_NATIVE_C_STACK_TMP_BUFFER_SIZE
The byte size of the temporary buffer in a runtime stack. This value is 512.
Macro Functions
spvm_warn
#define spvm_warn(format, ...)
Prints the formatted message format to stderr with the current function name, the current file name, and the current line number.
format must be the char* type.
Examples:
spvm_warn("Hello");
spvm_warn("Hello %s%d", "Foo", 3);spvm_warnf
#define spvm_warnf(stream, format, ...)
Prints the formatted message format to the stream stream with the current function name, the current file name, and the current line number.
format must be the char* type.
stream must be FILE type.
Examples:
spvm_warnf(env->spvm_stderr(env, stack), "Hello");
spvm_warnf(env->spvm_stderr(env, stack), "Hello %s%d", "Foo", 3);SPVM_NATIVE_GET_POINTER
#define SPVM_NATIVE_GET_POINTER(object)
Returns the pointer stored in the object object and returns it.
The return type is the SPVM_OBJ* type.
SPVM_NATIVE_SET_POINTER
#define SPVM_NATIVE_SET_POINTER(object, pointer)
Sets the pointer pointer of the object object.
Data Structures
SPVM_OBJECT
SPVM_OBJECT is an internal data structure for an SPVM object.
typedef struct spvm_object SPVM_OBJECT
struct spvm_object {
void* pointer;
SPVM_WEAKEN_BACKREF* weaken_backref_head;
SPVM_RUNTIME_BASIC_TYPE* basic_type;
int32_t ref_count;
uint8_t type_dimension;
uint8_t flag;
int32_t length;
};See Also
Copyright & License
Copyright (c) 2023 Yuki Kimoto
MIT License