Name

SPVM::Document::NativeAPI - Native APIs

Description

The native APIs of SPVM are the APIs written by the C language for various operations.

These APIs are used in native modules.

Native APIs

runtime

void* runtime;

The runtime object for this environment.

Examples:

env->runtime;

api

void* api;

Access to other native APIs.

Allocator Native API

env->api->allocator;

SPVM::Document::NativeAPI::Allocator

String Buffer Native API

env->api->string_buffer;

SPVM::Document::NativeAPI::StringBuffer

Compiler Native API

env->api->compiler;

SPVM::Document::NativeAPI::Compiler

Module File Native API

env->api->module_file;

SPVM::Document::NativeAPI::ModuleFile

Runtime Native API

env->api->runtime;

SPVM::Document::NativeAPI::Runtime

Basic Type Native API

env->api->basic_type;

SPVM::Document::NativeAPI::BasicType

Class Variable Native API

env->api->clsas_var;

SPVM::Document::NativeAPI::ClassVariable

Field Native API

env->api->field;

SPVM::Document::NativeAPI::Field

Method Native API

env->api->method;

SPVM::Document::NativeAPI::Method

Argument Native API

env->api->arg;

SPVM::Document::NativeAPI::Argument

allocator

void* allocator;

The memory allocator for this environment.

new_env

SPVM_ENV* (*new_env)();

Creates a new environment.

free_env

void (*free_env)(SPVM_ENV* env);

Frees an environment.

call_init_methods

int32_t (*call_init_methods)(SPVM_ENV* env, SPVM_VALUE* stack);

Calls all INIT methods defined by INIT blocks.

If an exception is thrown, returns non-zero value. Otherwise returns 0.

set_command_info_program_name

int32_t (*set_command_info_program_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* obj_program_name);

Sets the CommandInfo-PROGRAM_NAME|SPVM::CommandInfo/"PROGRAM_NAME"> class variable to the program name.

If an exception is thrown, returns non-zero value. Otherwise returns 0.

set_command_info_argv

int32_t (*set_command_info_argv)(SPVM_ENV* env, SPVM_VALUE* stack, void* obj_argv);

Sets the CommandInfo-PROGRAM_NAME|SPVM::CommandInfo/"ARGV"> class variable to the command line arguments.

If an exception is thrown, returns non-zero value. Otherwise returns 0.

set_command_info_base_time

int32_t (*set_command_info_base_time)(SPVM_ENV* env, SPVM_VALUE* stack, int64_t base_time);

Sets the CommandInfo-BASE_TIME|SPVM::CommandInfo/"BASE_TIME"> class variable to the time when the program starts.

If an exception is thrown, returns non-zero value. Otherwise returns 0.

destroy_class_vars

void (*destroy_class_vars)(SPVM_ENV* env, SPVM_VALUE* stack);

Destroys all class variables.

items

int32_t (*items)(SPVM_ENV* env, SPVM_VALUE* stack);

Returns the total width of the arguments given by the caller.

Examples:

int32_t items = env->items(env, stack);

get_object_basic_type

void* (*get_object_basic_type)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Returns the basic type of the object.

get_object_basic_type_id

int32_t (*get_object_basic_type_id)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Returns the basic type ID of the object.

get_object_basic_type_name

const char* (*get_object_basic_type_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Returns the basic type name of the object.

get_object_type_dimension

int32_t (*get_object_type_dimension)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Returns the type dimension of the object.

get_basic_type

void* (*get_basic_type)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name);

Gets a basic type by a basic type name.

get_basic_type_by_name

void* (*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);

Gets a basic type by a basic type name.

If an exception is thrown, error_id is set to non-zero value. Otherwise it is set to 0.

get_basic_type_by_id

void* (*get_basic_type_by_id)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id);

Gets a basic type by a basic type ID.

get_basic_type_id

int32_t (*get_basic_type_id)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name);

Gets a basic type ID by a basic type name.

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);

Gets a basic type ID by a basic type name.

If an exception is thrown, error_id is set to non-zero value. Otherwise it is set to 0.

get_field

void* (*get_field_by_index)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name);

Returns a field given an object and field name. If the field does not exist, returns NULL.

Examples:

void* field = env->get_field(env, stack, object, "x");

get_class_var_by_index

void* (*get_class_var_by_index)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* class_var_name);

Returns a class variable given a basic type name and a class variable name. If the class variable does not exist, returns NULL.

Examples:

void* class_var = env->get_class_var(env, stack, "MyClass", "$VAR");

get_class_method

void* (*get_class_method)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, const char* method_name);

Returns a class method given a basic type name and a method name. If the class method does not exists, returns NULL.

Examples:

void* method = env->get_class_method(env, stack, "Foo", "get");

get_instance_method

void* (*get_instance_method)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* method_name);

Gets an instance method address by the object and the method name. If the instance method does not exist, a negative value is returned.

Examples:

void* method = env->get_instance_method(env, stack, object, "get");

new_object_no_mortal

void* (*new_object_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type);

Creates a new object with a basic type. The basic type must be the correct basic type ID return by the "get_basic_type_id" Native API.

new_object

void* (*new_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type);

The same as new_object_no_mortal, and add the created object to the mortal stack of the environment. Use this function in normal use instead of new_object_no_mortal.

Examples:

void* basic_type = env->get_basic_type(env, stack, "Int");
void* object = env->new_object(env, stack, basic_type);

new_byte_array_no_mortal

void* (*new_byte_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

Creates a new byte[] type array by specifying the length.

new_byte_array

void* (*new_byte_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

The same as new_byte_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_byte_array_no_mortal.

Examples:

void* byte_array = env->new_byte_array(env, stack, 100);

new_short_array_no_mortal

void* (*new_short_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

Creates a new short[] type array by specifying the length.

new_short_array

void* (*new_short_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

The same as new_short_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_short_array_no_mortal.

Examples:

void* short_array = env->new_short_array(env, stack, 100);

new_int_array_no_mortal

void* (*new_int_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

Creates a new int[] type array by specifying the length.

new_int_array

void* (*new_int_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

The same as new_int_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_int_array_no_mortal.

Examples:

void* int_array = env->new_int_array(env, stack, 100);

new_long_array_no_mortal

void* (*new_long_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

Creates a new long[] type array by specifying the length.

new_long_array

void* (*new_long_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

The same as new_long_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_long_array_no_mortal.

Examples:

void* long_array = env->new_long_array(env, stack, 100);

new_float_array_no_mortal

void* (*new_float_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

Creates a new float[] type array by specifying the length.

new_float_array

void* (*new_float_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

The same as new_float_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_float_array_no_mortal.

Examples:

void* float_array = env->new_float_array(env, stack, 100);

new_double_array_no_mortal

void* (*new_double_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

Creates a new double[] type array by specifying the length.

new_double_array

void* (*new_double_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);

The same as new_double_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_double_array_no_mortal.

Examples:

void* double_array = env->new_double_array(env, stack, 100);

new_object_array_no_mortal

void* (*new_object_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type, int32_t length);

Creates a new object type array by specifying the basic type and the array length. The basic type must be the correct basic type got by the "get_basic_type" Native API.

new_object_array

void* (*new_object_array)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type, int32_t length);

The same as new_object_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_object_array_no_mortal.

Examples:

int32_t basic_type_id = env->get_basic_type_id(env, stack, "Int");
void* object_array = env->new_object_array(env, stack, basic_type_id, 100);

new_muldim_array_no_mortal

void* (*new_muldim_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type, int32_t type_dimension, int32_t length);

Creates a new multi-dimensional array by specifying the basic type and the type dimension, and the array length. The basic type must be the correct basic type got bu the "get_basic_type_id" Native API. the type dimension of the element must be less than or equals to 255.

new_muldim_array

void* (*new_muldim_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type, int32_t type_dimension, int32_t length);

The same as new_muldim_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_muldim_array_no_mortal.

Examples:

// Creates 2-dimensional array - The same as "new Int[][100]".
int32_t basic_type_id = env->get_basic_type_id(env, stack, "Int");
void* multi_array = env->new_muldim_array(env, stack, basic_type_id, 2, 100);

new_mulnum_array_no_mortal

void* (*new_mulnum_array_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type, int32_t length);

Creates a new multi-numeric array by specifying the basic type and the array length. The basic type must be the correct basic type got by the "basic_type_id" Native API.

new_mulnum_array

void* (*new_mulnum_array)(SPVM_ENV* env, SPVM_VALUE* stack, void* basic_type, int32_t length);

The same as new_mulnum_array_no_mortal, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_mulnum_array_no_mortal.

Examples:

int32_t basic_type_id = env->get_basic_type_id(env, stack, "Complex_2d");
void* value_array = env->new_mulnum_array(env, stack, basic_type_id, 100);

new_string_nolen_no_mortal

void* (*new_string_nolen_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes);

Creates a new string object by specifying C language char* type value. this value must end with "\0".

new_string_nolen

void* (*new_string_nolen)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes);

The same as new_string_nolen_no_mortal, and push the created object to the mortal stack. Use this function in normal use instead of new_string_nolen_no_mortal.

Examples:

void* str_obj = env->new_string_nolen(env, stack, "Hello World");

new_string_no_mortal

void* (*new_string_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes, int32_t length);

Creates a new string object with the bytes and the length.

If the length of bytes is lower than the specified length or the bytes is NULL, The part that longer than the length of bytes will be filled with \0.

new_string

void* (*new_string)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes, int32_t length);

The same as new_string_no_mortal, and push the created object to the mortal stack. Usually use this function instead of new_string_no_mortal.

Examples:

void* str_obj = env->new_string(env, stack, "Hello \0World", 11);

concat_no_mortal

void* (*concat_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* string1, void* string2);

Concats two strings.

concat

void* (*concat)(SPVM_ENV* env, SPVM_VALUE* stack, void* string1, void* string2);

The same as concat_no_mortal, and push the created object to the mortal stack. Use this function in normal use instead of concat_no_mortal.

new_stack_trace_no_mortal

void* (*new_stack_trace_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* exception, void* method, int32_t line);

Creates a string object that represents a stack trace by adding the file and line the method is called to the end of the exception message.

new_stack_trace

void* (*new_stack_trace)(SPVM_ENV* env, SPVM_VALUE* stack, void* exception, void* method, int32_t line);

The same as "new_stack_trace_no_mortal", and push the created object to the mortal stack.

length

int32_t (*length)(SPVM_ENV*, void* array);

If you specify an array, the length of the array is returned.

Examples:

int32_t length = env->length(env, stack, array);

get_elems_byte

int8_t* (*get_elems_byte)(SPVM_ENV* env, SPVM_VALUE* stack, void* array);

If you specify a byte[] type array, the pointer at the beginning of the internally stored C language int8_t[] type array is returned.

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, void* array);

If a short[] type array is specified, the pointer at the beginning of the internally stored C language int16_t[] type array is returned.

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, void* array);

When an int[] type array is specified, the pointer at the beginning of the internally stored C language int32_t[] type array is returned.

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, void* array);

When a long[] type array is specified, the pointer at the beginning of the internally stored C language int64_t[] type array is returned.

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, void* array);

When a float[] type array is specified, the pointer at the beginning of the C language float[] type array internally held is returned.

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, void* array);

If a double[] type array is specified, the pointer at the beginning of the internally stored C double[] type array is returned.

Examples:

double* values = env->get_elems_double(env, stack, array);
values[3] = 1.5;

get_elem_object

void* (*get_elem_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* array, int32_t index);

Gets an object of an element given an array of object types and a methodscript. If the element is a weak reference, the weak reference is removed.

Examples:

void* object = env->get_elem_object(env, stack, array, 3);

set_elem_object

void (*set_elem_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* array, int32_t index, void* object);

If you specify an array of object type and methodscript and element objects, the element object is assigned to the corresponding methodscript position. If the element's object has a weak reference, the weak reference is removed. The reference count of the originally assigned object is decremented by 1.

Examples:

env->get_elem_object(env, stack, array, 3, object);

get_field_byte

int8_t (*get_field_byte)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field);

If an object and a field are specified, the byte field value will be returned as a C language int8_t type value. The field must be a valid field obtained with the "get_field_by_index" Native API

get_field_short

int16_t (*get_field_short)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field);

If an object and a field, the value of the short type field will be returned as the int16_t type value of C language. The field must be a valid field obtained with the "get_field_by_index" Native API

get_field_int

int32_t (*get_field_int)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field);

If an object and a field are specified, the value of the int type field will be returned as a C language int32_t type value. The field must be a valid field obtained with the "get_field_by_index" Native API

get_field_long

int64_t (*get_field_long)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field);

If an object and a field, the value of the long type field will be returned as the value of int64_t type of C language. The field must be a valid field obtained with the "get_field_by_index" Native API

get_field_float

float (*get_field_float)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field);

If an object and a field, the value of the float type field will be returned as a C language float type value. The field must be a valid field obtained with the "get_field_by_index" Native API

get_field_double

double (*get_field_double)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field);

If an object and a field, the value of the double type field will be returned as a double type value in C language. The field must be a valid field obtained with the "get_field_by_index" Native API

get_field_object

void* (*get_field_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field);

If an object and a field, the value of the object type field is returned as a void* type value in C language. The field must be a valid field obtained with the "get_field_by_index" Native API If the field is a weak reference, it will be removed.

set_field_byte

void (*set_field_byte)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field, int8_t value);

If an object and a field is given, the value is set to the byte type field. The field must be a valid field obtained with the "get_field_by_index" Native API

set_field_short

void (*set_field_short)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field, int16_t value);

If an object and a field is given, the value is set to the short type field. The field must be a valid field obtained with the "get_field_by_index" Native API

set_field_int

void (*set_field_int)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field, int32_t value);

If an object and a field is given, the value is set to the int type field. The field must be a valid field obtained with the "get_field_by_index" Native API

set_field_long

void (*set_field_long)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field, int64_t value);

If an object and a field is given, the value is set to the long type field. The field must be a valid field obtained with the "get_field_by_index" Native API

set_field_float

void (*set_field_float)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field, float value);

If an object and a field is given, the value is set to the float type field. The field must be a valid field obtained with the "get_field_by_index" Native API

set_field_double

void (*set_field_double)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field, double value);

If an object and a field is given, the value is set to the double type field. The field must be a valid field obtained with the "get_field_by_index" Native API

set_field_object

void (*set_field_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* field, void* value);

An object and a field Specifies the ID and the value of the field and set the value to the object type field. The field must be a valid field obtained with the "get_field_by_index" Native API After setting, the reference count is incremented by 1. The original value has the reference count decremented by 1.

get_class_var_byte

int8_t (*get_class_var_byte)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var);

If a class variable is given, the value of the byte type class variable is returned as a C language int8_t type value. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API.

get_class_var_short

int16_t (*get_class_var_short)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var);

If a class variable is given, the value of the short type class variable will be returned as a C language int16_t type value. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API.

get_class_var_int

int32_t (*get_class_var_int)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var);

If a class variable is given, the value of the int type class variable will be returned as a C language int32_t type value. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API.

get_class_var_long

int64_t (*get_class_var_long)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var);

If a class variable is given, the value of the long type class variable will be returned as a C language int64_t type value. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API.

get_class_var_float

float (*get_class_var_float)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var);

If a class variable is given, the value of the float type class variable will be returned as a C language float type value. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API.

get_class_var_double

double (*get_class_var_double)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var);

If you specify an object and a class variable, the value of the double type class variable is returned as a C type double type value. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API.

get_class_var_object

void* (*get_class_var_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var);

When an object and a class variable are specified, the value of the object type class variable is returned as a C language void* type value. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API.

set_class_var_byte

void (*set_class_var_byte)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var, int8_t value);

If a class variable is given, the value is set to the byte type class variable.

set_class_var_short

void (*set_class_var_short)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var, int16_t value);

If a class variable is given, the value is set to the short type class variable.

set_class_var_int

void (*set_class_var_int)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var, int32_t value);

If a class variable is given, the value is set to the int type class variable.

set_class_var_long

void (*set_class_var_long)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var, int64_t value);

If a class variable is given, the value is set to the long type class variable.

set_class_var_float

void (*set_class_var_float)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var, float value);

If a class variable is given, the value is set to the float type class variable.

set_class_var_double

void (*set_class_var_double)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var, double value);

If a class variable is given, the value is set to the double type class variable.

set_class_var_object

void (*set_class_var_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* class_var, void* value);

If a class variable is given, the value of the class variable and set the value to the object type class variable. The class variable must be a valid class variable obtained with the "get_class_var_by_index" Native API. After setting, the reference count is incremented by 1. The original value has the reference count decremented by 1.

get_pointer

void* (*get_pointer)(SPVM_ENV* env, SPVM_VALUE* stack, void* pointer_object);

Specifies a pointer object and return the C language pointer stored inside the object.

Examples:

strcut tm* tm_ptr = (struct tm*) env->get_pointer(env, stack, tm_obj);

set_pointer

void (*set_pointer)(SPVM_ENV* env, SPVM_VALUE* stack, void* pointer_object, void* pointer);

If you specify a pointer object and a C language pointer, the C language pointer is saved in the internal data of the pointer type object.

call_method_no_mortal

int32_t (*call_method_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* method, int32_t items);

Call a method by specifying the method address and the stack length of the argument. If an exception occurs in the method, The return value is 1. If not, return 0.

The return value of the method is set to stack[0].

get_exception

void* (*get_exception)(SPVM_ENV* env, SPVM_VALUE* stack);

Gets a exception message which type is byte[].

set_exception

void (*set_exception)(SPVM_ENV* env, SPVM_VALUE* stack, void* exception);

Sets a exception message which type is byte[].

get_ref_count

int32_t (*get_ref_count)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Gets the refernce count of the object.

inc_ref_count

void (*inc_ref_count)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Specifying an object increments the reference count of the object.

Use this method only if you have a specific reason to use it. Normally, the reference count is managed automatically.

dec_ref_count

void (*dec_ref_count)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Specifying an object decrements the object's reference count by 1. When the reference count reaches 0, the object is released.

Use this method only if you have a specific reason to use it. Normally, the reference count is managed automatically.

enter_scope

int32_t (*enter_scope)(SPVM_ENV* env, SPVM_VALUE* stack);

Creates a new scope and return the scope ID.

push_mortal

int32_t (*push_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Add an object to the mortal stack.

If this method succeed, return 0.

If this method don't alloc memory for new mortal information, return 1.

leave_scope

void (*leave_scope)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t scope_id);

Specifies a scope ID to exit that scope and decrement the object's reference count stored in the mortal stack. Objects with a reference count of 0 are released. The scope ID must be the ID obtained by the enter_scope function.

remove_mortal

int32_t (*remove_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t scope_id, void* remove_object);

Given a scope ID and an object, delete the specified object from the mortal stack.

isa

int32_t (*isa)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* cast_basic_type, int32_t cast_type_dimension);

Checks if the object object can be assigned to the type given by the basic type cast_basic_type and the type dimension cast_type_dimension.

If it is ok, returns 1. Otherwise returns 0.

elem_isa

int32_t (*elem_isa)(SPVM_ENV* env, SPVM_VALUE* stack, void* array, void* element);

Checks if the element element can be assigned to the element of the array array.

If it is ok, returns 1. Otherwise returns 0.

is_type

int32_t (*is_type)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, void* basic_type, int32_t type_dimension);

Given an object and a basic type and a type dimension, returns a nonzero value if the object matches both the basic type and the type dimension, and 0 otherwise.

is_object_array

int32_t (*is_object_array)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

If the object is a object array, returns 1, otherwise returns 0.

If the object is NULL, returns 0.

weaken

int32_t (*weaken)(SPVM_ENV* env, SPVM_VALUE* stack, void** object_address);

Creates weak reference to the object which is specified by object address.

The reference count of the object is decrimented by 1 and weaken flag is added to the object address.

If the reference count is 1, "dec_ref_count" is called to the object.

If object_address is NULL, this method do nothing.

If the object is already weaken, this method do nothing.

This method allocate memory internally to add the back reference from the object to the object address.

This method success return 0.

If failing memory allocation of back reference, return 1.

isweak

int32_t (*isweak()SPVM_ENV* env, void** object);

Given the address of an object, returns non-zero if the object is a weak reference, 0 otherwise.

unweaken

void (*unweaken)(SPVM_ENV* env, SPVM_VALUE* stack, void** object_address);

Specifying the address of the object releases the weak reference to the object.

get_type_name_no_mortal

void* (*get_type_name_no_mortal)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Gets a new string object that is the type name of the object.

This function does not add the returned object to the mortal stack, so use the get_type_name Native API for normal use to avoid memory leaks.

get_type_name

void* (*get_type_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);

Gets a new string object that is the type name of the object.

get_chars

const char* (*get_chars)(SPVM_ENV* env, SPVM_VALUE* stack, void* string_object);

Gets characters in the string object.

Examples:

const char* bytes = env->get_chars(env, stack, string_object);

die

int32_t (*die)(SPVM_ENV* env, SPVM_VALUE* stack, const char* message, ...);

Creates a sprintf formatted message with file name and line number and set it to the exception.

Last three arguments are the function name, the file name, and the line number.

Returns value is the basic type ID of the Error class.

Examples:

return env->die(env, stack, "Value must be %d", 3, __func__, __FILE__, __LINE__);

new_object_by_name

void* (*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);

This is the same as the "new_object" Native API, but you can specify basic type name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
void* minimal = env->new_object_by_name(env, stack, "TestCase::Minimal", &error, __func__, __FILE__, __LINE__);
if (error) { return error; }

set_field_byte_by_name

void (*set_field_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack,
  void* object, const char* field_name, int8_t value,
  int32_t* error_id, const char* func_name, const char* file, int32_t line);

This is the same as the "set_field_byte" Native API, but you can specify field name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
env->set_field_byte_by_name(env, stack, object, "byte_value", 13, &error, __func__, __FILE__, __LINE__);
if (error) { return error; }

set_field_short_by_name

void (*set_field_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack,
  void* object, const char* field_name, int16_t value,
  int32_t* error_id, const char* func_name, const char* file, int32_t line);

This is the same as the "set_field_short" Native API, but you can specify field name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
env->set_field_short_by_name(env, stack, object, "short_value", 13, &error, __func__, __FILE__, __LINE__);
if (error) { return error; }

set_field_int_by_name

void (*set_field_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack,
  void* object, const char* field_name, int32_t value,
  int32_t* error_id, const char* func_name, const char* file, int32_t line);

This is the same as the "set_field_int" Native API, but you can specify field name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
env->set_field_int_by_name(env, stack, object, "int_value", 13, &error, __func__, __FILE__, __LINE__);
if (error) { return error; }

set_field_long_by_name

void (*set_field_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack,
  void* object, const char* field_name, int64_t value,
  int32_t* error_id, const char* func_name, const char* file, int32_t line);

This is the same as the "set_field_long" Native API, but you can specify field name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
env->set_field_long_by_name(env, stack, object, "long_value", 13, &error, __func__, __FILE__, __LINE__);
if (error) { return error; }

set_field_float_by_name

void (*set_field_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack,
  void* object, const char* field_name, float value,
  int32_t* error_id, const char* func_name, const char* file, int32_t line);

This is the same as the "set_field_float" Native API, but you can specify field name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
env->set_field_float_by_name(env, stack, object, "float_value", 13, &error, __func__, __FILE__, __LINE__);
if (error) { return error; }

set_field_double_by_name

void (*set_field_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack,
  void* object, const char* field_name, double value,
  int32_t* error_id, const char* func_name, const char* file, int32_t line);

This is the same as the "set_field_double" Native API, but you can specify field name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
env->set_field_double_by_name(env, stack, object, "double_value", 13, &error, __func__, __FILE__, __LINE__);
if (error) { return error; }

set_field_object_by_name

void (*set_field_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack,
  void* object, const char* field_name, void* value,
  int32_t* error_id, const char* func_name, const char* file, int32_t line);

This is the same as the "set_field_object" Native API, but you can specify field name directly.

If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.

Examples:

int32_t error = 0;
env->set_field_object_by_name(env, stack, object_simple, "object_value", object_minimal, &error, __func__, __FILE__, __LINE__);
if (error) { return error; }