SPVM::Document::NativeAPI - SPVM Native APIs
The SPVM native APIs are public APIs that are used in native language sources such as C/C++.
C/C++
The native APIs are writen in the C language, but the languages that have compatibility of the C language such as <C++>, CUDA/nvcc can call the native APIs.
CUDA/nvcc
The native APIs is used when native methods are implemented.
Native APIs have its IDs. These IDs are permanently same for the binary compatibility after the future release v1.0.
v1.0
0 class_vars_heap 1 object_header_size 2 object_weaken_backref_head_offset 3 object_ref_count_offset 4 object_basic_type_id_offset 5 object_type_dimension_offset 6 object_flag_offset 7 object_length_offset 8 api 9 allocator 10 new_env_raw 11 free_env_raw 12 isa 13 elem_isa 14 runtime 15 get_basic_type_id 16 get_field_id 17 get_field_offset 18 get_class_var_id 19 get_class_method_id 20 get_instance_method_id 21 new_object_raw 22 new_object 23 new_byte_array_raw 24 new_byte_array 25 new_short_array_raw 26 new_short_array 27 new_int_array_raw 28 new_int_array 29 new_long_array_raw 30 new_long_array 31 new_float_array_raw 32 new_float_array 33 new_double_array_raw 34 new_double_array 35 new_object_array_raw 36 new_object_array 37 new_muldim_array_raw 38 new_muldim_array 39 new_mulnum_array_raw 40 new_mulnum_array 41 new_string_nolen_raw 42 new_string_nolen 43 new_string_raw 44 new_string 45 concat_raw 46 concat 47 new_stack_trace_raw 48 new_stack_trace 49 length 50 get_elems_byte 51 get_elems_short 52 get_elems_int 53 get_elems_long 54 get_elems_float 55 get_elems_double 56 get_elem_object 57 set_elem_object 58 get_field_byte 59 get_field_short 60 get_field_int 61 get_field_long 62 get_field_float 63 get_field_double 64 get_field_object 65 set_field_byte 66 set_field_short 67 set_field_int 68 set_field_long 69 set_field_float 70 set_field_double 71 set_field_object 72 get_class_var_byte 73 get_class_var_short 74 get_class_var_int 75 get_class_var_long 76 get_class_var_float 77 get_class_var_double 78 get_class_var_object 79 set_class_var_byte 80 set_class_var_short 81 set_class_var_int 82 set_class_var_long 83 set_class_var_float 84 set_class_var_double 85 set_class_var_object 86 get_pointer 87 set_pointer 88 call_method_raw 89 get_exception 90 set_exception 91 get_ref_count 92 inc_ref_count 93 dec_ref_count 94 enter_scope 95 push_mortal 96 leave_scope 97 remove_mortal 98 is_type 99 is_object_array 100 get_object_basic_type_id 101 get_object_type_dimension 102 weaken 103 isweak 104 unweaken 105 alloc_memory_block_zero 106 free_memory_block 107 get_memory_blocks_count 108 get_type_name_raw 109 get_type_name 110 new_env 111 free_env 112 memory_blocks_count 113 get_chars 114 die 115 new_object_by_name 116 set_field_byte_by_name 117 set_field_short_by_name 118 set_field_int_by_name 119 set_field_long_by_name 120 set_field_float_by_name 121 set_field_double_by_name 122 set_field_object_by_name 123 get_field_byte_by_name 124 get_field_short_by_name 125 get_field_int_by_name 126 get_field_long_by_name 127 get_field_float_by_name 128 get_field_double_by_name 129 get_field_object_by_name 130 set_class_var_byte_by_name 131 set_class_var_short_by_name 132 set_class_var_int_by_name 133 set_class_var_long_by_name 134 set_class_var_float_by_name 135 set_class_var_double_by_name 136 set_class_var_object_by_name 137 get_class_var_byte_by_name 138 get_class_var_short_by_name 139 get_class_var_int_by_name 140 get_class_var_long_by_name 141 get_class_var_float_by_name 142 get_class_var_double_by_name 143 get_class_var_object_by_name 144 call_class_method_by_name 145 call_instance_method_by_name 146 get_field_string_chars_by_name 147 free_env_prepared 148 dump_raw 149 dump 150 get_instance_method_id_static 151 get_bool_object_value 152 cleanup_global_vars 153 make_read_only 154 is_read_only 155 is_array 156 is_string 157 is_numeric_array 158 is_mulnum_array 159 get_elem_size 160 new_array_proto_raw 161 new_array_proto 162 copy_raw 163 copy 164 shorten 165 has_interface 166 print 167 print_stderr 168 init_env 169 call_init_blocks 170 get_class_id 171 new_stack 172 free_stack 173 new_memory_env 174 free_memory_env 175 get_memory_blocks_count_env 176 new_memory_stack 177 free_memory_stack 178 get_memory_blocks_count_stack 179 set_command_info_program_name 180 set_command_info_argv 181 get_class_id_by_name 182 strerror 183 new_string_array 184 get_args_stack_length 185 set_args_stack_length 186 dumpc 187 new_pointer_object_raw 188 new_pointer_object 189 new_pointer_object_by_name 190 get_elem_string 191 set_elem_string 192 is_class 193 is_pointer_class 194 strerror_string 195 get_basic_type_id_by_name 196 get_field_id_static 197 items 198 call_instance_method_static_by_name 199 get_method_id 200 strerror_nolen 201 strerror_string_nolen 202 get_compile_type_name_raw 203 get_compile_type_name 204 set_command_info_base_time 205 get_spvm_version_string 206 get_spvm_version_number 207 get_version_string 208 get_version_number 209 call_method 210 class_init_flags
void* class_vars_heap;
The pointer to the storage area of the class variables. This is used internally.
void* object_header_size;
The byte size of the object's header. This is used internally.
void* object_weaken_backref_head_offset;
The offset to a pointer to the back reference of the weak reference in the object structure. This is used internally.
void* object_ref_count_offset;
The reference count offset in the object structure. This is used internally.
void* object_basic_type_id_offset;
The offset of basic type ID in object structure. This is used internally.
void* object_type_dimension_offset;
The offset of type dimension in object structure. This is used internally.
void* object_type_category_offset;
The offset of runtime type category in object structure. This is used internally.
This value is always NULL, because SPVM 0.9511+, this value is any more used.
NULL
void* object_flag_offset;
The offset of flag in object structure. This is used internally.
void* object_length_offset;
The length offset in the object structure. This is used internally.
void* api;
The environment of APIs such as compiler native APIs, precompile native APIs, runtime native APIs, string buffer native APIs, allocator native APIs.
Examples:
// Compiler native APIs void* compiler_api = env->api->compiler; // Precompile native APIs void* precompile_api = env->api->precompile; // Runtime native APIs void* runtime_api = env->api->runtime; // String buffer native APIs void* string_buffer_api = env->api->string_buffer; // Allocator native APIs void* allocator_api = env->api->allocator;
void* allocator;
The memory allocator for this environment.
SPVM_ENV* (*new_env_raw)();
Creates a new raw envriment.
void (*free_env_raw)(SPVM_ENV* env);
Frees the raw environemt that is created by "new_env_raw".
int32_t (*isa)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t cast_basic_type_id, int32_t cast_type_dimension);
Performs isa operation.
isa
int32_t (*elem_isa)(SPVM_ENV* env, SPVM_VALUE* stack, void* array, void* element);
Checks the runtime type assignability of an array element.
void* runtime;
A pointer to the runtime information. This is used internally.
int32_t (*get_basic_type_id)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name);
Gets the ID of the base type given the name of the base type. If it does not exist, a value less than 0 is returned.
int32_t basic_type_id = env->get_basic_type_id(env, "Int");
int32_t (*get_field_id)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name);
Gets the ID of the field given an object and field name. If the field does not exist, a value less than 0 is returned.
int32_t field_id = env->get_field_id(env, object, "x");
int32_t (*get_field_offset)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t field_id);
Gets the offset of the field given the field ID. The field ID must be a valid field ID obtained with the field_id function.
int32_t (*get_class_var_id)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name);
Gets the class variable ID given the class name, class variable name. If the class variable does not exist, a value less than 0 is returned.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR");
int32_t (*get_class_method_id)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* method_name);
Gets a class method ID by the class name, the method name. If the class method does not exists, a negative value is returned.
This ID is used by "call_method_raw".
int32_t method_id = env->get_class_method_id(env, "Foo", "get");
int32_t (*get_instance_method_id)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* method_name);
Gets a instance method ID by the object, the method name. If the instance method does not exist, a negative value is returned.
int32_t method_id = env->get_instance_method_id(env, object, "get");
void* (*new_object_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id);
Creates a new object with a basic type ID. The basic type ID must be the correct base type ID return by get_basic_type_id function.
get_basic_type_id
void* (*new_object)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id);
The same as new_object_raw, and add the created object to the mortal stack of the environment. Use this function in normal use instead of new_object_raw.
new_object_raw
int32_t basic_type_id = env->get_basic_type_id(env, "Int"); void* object = env->new_object(env, stack, basic_type_id);
void* (*new_byte_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new byte[] type array by specifying the length.
void* (*new_byte_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
The same as new_byte_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_byte_array_raw.
new_byte_array_raw
void* byte_array = env->new_byte_array(env, stack, 100);
void* (*new_short_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new short[] type array by specifying the length.
void* (*new_short_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
The same as new_short_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_short_array_raw.
new_short_array_raw
void* short_array = env->new_short_array(env, stack, 100);
void* (*new_int_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new int[] type array by specifying the length.
void* (*new_int_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
The same as new_int_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_int_array_raw.
new_int_array_raw
void* int_array = env->new_int_array(env, stack, 100);
void* (*new_long_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new long[] type array by specifying the length.
void* (*new_long_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
The same as new_long_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_long_array_raw.
new_long_array_raw
void* long_array = env->new_long_array(env, stack, 100);
void* (*new_float_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new float[] type array by specifying the length.
void* (*new_float_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
The same as new_float_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_float_array_raw.
new_float_array_raw
void* float_array = env->new_float_array(env, stack, 100);
void* (*new_double_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new double[] type array by specifying the length.
void* (*new_double_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
The same as new_double_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_double_array_raw.
new_double_array_raw
void* double_array = env->new_double_array(env, stack, 100);
void* (*new_object_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, int32_t length);
Creates a new object type array by specifying the basic type ID and the array length. The basic type ID must be the correct basic type ID got by get_basic_type_id function.
void* (*new_object_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, int32_t length);
The same as new_object_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_object_array_raw.
new_object_array_raw
int32_t basic_type_id = env->get_basic_type_id(env, "Int"); void* object_array = env->new_object_array(env, stack, basic_type_id, 100);
void* (*new_muldim_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, int32_t type_dimension, int32_t length);
Creates a new multi-dimensional array by specifying the basic type ID and the type dimension, and the array length. The basic type ID must be the correct basic type ID got bu get_basic_type_id function. the type dimension of the element must be less than or equals to 255.
The same as new_muldim_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_muldim_array_raw.
new_muldim_array_raw
// Creates 2-dimensional array - The same as "new Int[][100]". int32_t basic_type_id = env->get_basic_type_id(env, "Int"); void* multi_array = env->new_muldim_array(env, stack, basic_type_id, 2, 100);
void* (*new_mulnum_array_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, int32_t length);
Creates a new multi-numeric array by specifying the basic type ID and the array length. The basic type ID must be the correct basic type ID got by basic_type_id function.
basic_type_id
void* (*new_mulnum_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, int32_t length);
The same as new_mulnum_array_raw, and add the created array to the mortal stack of the environment. Use this function in normal use instead of new_mulnum_array_raw.
new_mulnum_array_raw
int32_t basic_type_id = env->get_basic_type_id(env, "Complex_2d"); void* value_array = env->new_mulnum_array(env, stack, basic_type_id, 100);
void* (*new_string_nolen_raw)(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".
void* (*new_string_nolen)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes);
The same as new_string_nolen_raw, and push the created object to the mortal stack. Use this function in normal use instead of new_string_nolen_raw.
new_string_nolen_raw
void* str_obj = env->new_string_nolen(env, stack, "Hello World");
void* (*new_string_raw)(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.
\0
void* (*new_string)(SPVM_ENV* env, SPVM_VALUE* stack, const char* bytes, int32_t length);
The same as new_string_raw, and push the created object to the mortal stack. Usually use this function instead of new_string_raw.
new_string_raw
void* str_obj = env->new_string(env, stack, "Hello \0World", 11);
void* (*concat_raw)(SPVM_ENV* env, SPVM_VALUE* stack, void* string1, void* string2);
Concats two strings.
void* (*concat)(SPVM_ENV* env, SPVM_VALUE* stack, void* string1, void* string2);
The same as concat_raw, and push the created object to the mortal stack. Use this function in normal use instead of concat_raw.
concat_raw
void* (*new_stack_trace_raw)(SPVM_ENV* env, SPVM_VALUE* stack, void* exception, int32_t method_id, 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.
void* (*new_stack_trace)(SPVM_ENV* env, SPVM_VALUE* stack, void* exception, int32_t method_id, int32_t line);
The same as "new_stack_trace_raw", and push the created object to the mortal stack.
int32_t (*length)(SPVM_ENV*, void* array);
If you specify an array, the length of the array is returned.
int32_t length = env->length(env, stack, array);
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.
int8_t* values = env->get_elems_byte(env, stack, array); values[3] = 5;
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.
int16_t* values = env->get_elems_short(env, stack, array); values[3] = 5;
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.
int32_t* values = env->get_elems_int(env, stack, array); values[3] = 5;
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.
int64_t* values = env->get_elems_long(env, stack, array); values[3] = 5;
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.
float* values = env->get_elems_float(env, stack, array); values[3] = 1.5f;
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.
double* values = env->get_elems_double(env, stack, array); values[3] = 1.5;
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.
void* object = env->get_elem_object(env, stack, array, 3);
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.
env->get_elem_object(env, stack, array, 3, object);
int8_t (*get_field_byte)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id);
If an object and field ID are specified, the byte field value will be returned as a C language int8_t type value. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int8_t field_value = env->get_field_byte(env, stack, object, field_id);
int16_t (*get_field_short)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id);
If you specify the object and field ID, the value of the short type field will be returned as the int16_t type value of C language. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int16_t field_value = env->get_field_short(env, stack, object, field_id);
int32_t (*get_field_int)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id);
If an object and a field ID are specified, the value of the int type field will be returned as a C language int32_t type value. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int32_t field_value = env->get_field_int(env, stack, object, field_id);
int64_t (*get_field_long)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id);
If you specify the object and field ID, the value of the long type field will be returned as the value of int64_t type of C language. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int64_t field_value = env->get_field_long(env, stack, object, field_id);
float (*get_field_float)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id);
If you specify the object and field ID, the value of the float type field will be returned as a C language float type value. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); float field_value = env->get_field_float(env, stack, object, field_id);
double (*get_field_double)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id);
If you specify the object and field ID, the value of the double type field will be returned as a double type value in C language. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); double field_value = env->get_field_double(env, stack, object, field_id);
void* (*get_field_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id);
If you specify the object and field ID, the value of the object type field is returned as a void* type value in C language. The field ID must be a valid field ID obtained with the field_id function. If the field is a weak reference, it will be removed.
int32_t field_id = env->get_field_id(env, object, "x"); void* field_value = env->get_field_object(env, stack, object, field_id);
void (*set_field_byte)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id, int8_t value);
If you specify the object and field ID and the value of the field, the value is set to the byte type field. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int8_t field_value = 5; env->set_field_byte(env, stack, object, field_id, field_value);
void (*set_field_short)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id, int16_t value);
If you specify the object and field ID and the value of the field, the value is set to the short type field. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int16_t field_value = 5; env->set_field_short(env, stack, object, field_id, field_value);
void (*set_field_int)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id, int32_t value);
If you specify the object and field ID and the value of the field, the value is set to the int type field. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int32_t field_value = 5; env->set_field_int(env, stack, object, field_id, field_value);
void (*set_field_long)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id, int64_t value);
If you specify the object and field ID and the value of the field, the value is set to the long type field. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); int64_t field_value = 5; env->set_field_long(env, stack, object, field_id, field_value);
void (*set_field_float)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id, float value);
If you specify the object and field ID and the value of the field, the value is set to the float type field. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); float field_value = 1.5f; env->set_field_float(env, stack, object, field_id, field_value);
void (*set_field_double)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id, double value);
If you specify the object and field ID and the value of the field, the value is set to the double type field. The field ID must be a valid field ID obtained with the field_id function.
int32_t field_id = env->get_field_id(env, object, "x"); double field_value = 1.55; env->set_field_double(env, stack, object, field_id, field_value);
void (*set_field_object)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t field_id, void* value);
The object and field Specifies the ID and the value of the field and set the value to the object type field. The field ID must be a valid field ID obtained with the field_id function. After setting, the reference count is incremented by 1. The original value has the reference count decremented by 1.
int32_t field_id = env->get_field_id(env, object, "x"); int32_t basic_type_id = env->get_basic_type_id(env, "Int"); void* object = env->new_object(env, stack, basic_type_id); env->set_field_object(env, stack, object, field_id, object);
int8_t (*get_class_var_byte)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id);
If an object and a class variable ID are specified, the value of the byte type class variable is returned as a C language int8_t type value. The class variable ID must be a valid class variable ID obtained with the field_id function.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int8_t class_var_value = env->get_class_var_byte(env, stack, object, class_var_id);
int16_t (*get_class_var_short)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id);
If an object and a class variable ID are specified, the value of the short type class variable will be returned as a C language int16_t type value. The class variable ID must be a valid class variable ID obtained with the field_id function.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int16_t class_var_value = env->get_class_var_short(env, stack, object, class_var_id);
int32_t (*get_class_var_int)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id);
If an object and a class variable ID are specified, the value of the int type class variable will be returned as a C language int32_t type value. The class variable ID must be a valid class variable ID obtained with the field_id function.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int32_t class_var_value = env->get_class_var_int(env, stack, object, class_var_id);
int64_t (*get_class_var_long)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id);
If an object and a class variable ID are specified, the value of the long type class variable will be returned as a C language int64_t type value. The class variable ID must be a valid class variable ID obtained with the field_id function.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int64_t class_var_value = env->get_class_var_long(env, stack, object, class_var_id);
float (*get_class_var_float)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id);
If an object and a class variable ID are specified, the value of the float type class variable will be returned as a C language float type value. The class variable ID must be a valid class variable ID obtained with the field_id function.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); float class_var_value = env->get_class_var_float(env, stack, object, class_var_id);
double (*get_class_var_double)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id);
If you specify an object and a class variable ID, the value of the double type class variable is returned as a C type double type value. The class variable ID must be a valid class variable ID obtained with the field_id function.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); double class_var_value = env->get_class_var_double(env, stack, object, class_var_id);
void* (*get_class_var_object)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id);
When an object and a class variable ID are specified, the value of the object type class variable is returned as a C language void* type value. The class variable ID must be a valid class variable ID obtained with the field_id function.
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); void* class_var_value = env->get_class_var_byte(env, stack, object, class_var_id);
void (*set_class_var_byte)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id, int8_t value);
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int8_t class_var_value = 5; env->set_class_var_byte(env, stack, class_var_id, class_var_value);
void (*set_class_var_short)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id, int16_t value);
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int16_t class_var_value = 5; env->set_class_var_short(env, stack, class_var_id, class_var_value);
void (*set_class_var_int)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id, int32_t value);
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int32_t class_var_value = 5; env->set_class_var_int(env, stack, class_var_id, class_var_value);
void (*set_class_var_long)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id, int64_t value);
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int64_t class_var_value = 5; env->set_class_var_long(env, stack, class_var_id, class_var_value);
void (*set_class_var_float)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id, float value);
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); float class_var_value = 5; env->set_class_var_float(env, stack, class_var_id, class_var_value);
void (*set_class_var_double)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id, double value);
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); double class_var_value = 5; env->set_class_var_double(env, stack, class_var_id, class_var_value);
void (*set_class_var_object)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_var_id, void* value);
int32_t class_var_id = env->get_class_var_id(env, "Foo", "$VAR"); int32_t basic_type_id = env->get_basic_type_id(env, "Int"); void* object = env->new_object(env, stack, basic_type_id); env->set_class_var_object(env, stack, class_var_id, class_var_value);
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.
strcut tm* tm_ptr = (struct tm*) env->get_pointer(env, stack, tm_obj);
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.
int32_t (*call_method_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t method_id, int32_t args_stack_length);
Call a method by specifying the method ID 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].
void* (*get_exception)(SPVM_ENV* env, SPVM_VALUE* stack);
Gets a exception message which type is byte[].
void (*set_exception)(SPVM_ENV* env, SPVM_VALUE* stack, void* exception);
Sets a exception message which type is byte[].
int32_t (*get_ref_count)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
Gets the refernce count of the object.
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.
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.
int32_t (*enter_scope)(SPVM_ENV* env, SPVM_VALUE* stack);
Creates a new scope and return the scope ID.
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.
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.
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.
int32_t (*is_type)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t basic_type_id, int32_t type_dimension);
Given an object and a base type ID and a type dimension, returns a nonzero value if the object matches both the base type ID and the type dimension, and 0 otherwise.
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.
int32_t (*get_object_basic_type_id)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
Gets the base type ID of the object.
int32_t (*get_object_type_dimension)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
Gets the dimension of the type of object.
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.
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.
void (*unweaken)(SPVM_ENV* env, SPVM_VALUE* stack, void** object_address);
Specifying the address of the object releases the weak reference to the object.
void* (*alloc_memory_block_zero)(SPVM_ENV* env, size_t size);
Creates a new memory block that is managed by the environment with the byte size and return the address. If it fails, return NULL.
The count of the memory block that is managed by the environment is incremented by 1.
void (*free_memory_block)(SPVM_ENV* env, void* block);
Frees the memory block that is managed by the environment.
The count of the memory block that is managed by the environment is decremented by 1.
int32_t (*get_memory_blocks_count)(SPVM_ENV* env);
Returns the count of the memory blocks on the environment.
void* (*get_type_name_raw)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
Gets a new string object that is the type name of the object.
string
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.
void* (*get_type_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
SPVM_ENV* (*new_env)(SPVM_ENV* env);
Creates a new environment that is ready to call methods.
1. Create a new environment using the "new_env_raw" native API.
2. Set the current compiler to the new enviroment.
3. Initialize the environment using the "init_env" native API
The number of memory blocks is shared with the original execution environment.
If this method cannnot allocate memory for the new environment, return NULL.
Note that "call_init_blocks" need to be called before calling user methods by yourself.
void (*free_env)(SPVM_ENV* env);
Frees an environment that is created by the "new_env" native API.
void* memory_blocks_count;
Unused from v0.9508+. The count of memory blocks is managed in "runtime".
const char* (*get_chars)(SPVM_ENV* env, SPVM_VALUE* stack, void* string_object);
Gets characters in the string object.
const char* bytes = env->get_chars(env, stack, string_object);
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.
sprintf
Last three arguments are the function name, the file name, and the line number.
Returns value is always 1;
return env->die(env, stack, "Value must be %d", 3, __func__, __FILE__, __LINE__);
void* (*new_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as new_object function, but you can specify class name directly.
new_object
If function is succeeded, error is set to 0. If a exception occurs, error is set to 1.
error
int32_t e; void* minimal = env->new_object_by_name(env, stack, "TestCase::Minimal", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_field_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int8_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_field_byte function, but you can specify field name directly.
set_field_byte
int32_t e; env->set_field_byte_by_name(env, stack, object, "byte_value", 13, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_field_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int16_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_field_short function, but you can specify field name directly.
set_field_short
int32_t e; env->set_field_short_by_name(env, stack, object, "short_value", 13, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_field_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_field_int function, but you can specify field name directly.
set_field_int
int32_t e; env->set_field_int_by_name(env, stack, object, "int_value", 13, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_field_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int64_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_field_long function, but you can specify field name directly.
set_field_long
int32_t e; env->set_field_long_by_name(env, stack, object, "long_value", 13, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_field_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, float value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_field_float function, but you can specify field name directly.
set_field_float
int32_t e; env->set_field_float_by_name(env, stack, object, "float_value", 13, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_field_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, double value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_field_double function, but you can specify field name directly.
set_field_double
int32_t e; env->set_field_double_by_name(env, stack, object, "double_value", 13, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_field_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, void* value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_field_object function, but you can specify field name directly.
set_field_object
int32_t e; env->set_field_object_by_name(env, stack, object_simple, "object_value", object_minimal, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int8_t (*get_field_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_field_byte function, but you can specify field name directly.
get_field_byte
If function is succeeded, error is get to 0. If a exception occurs, error is get to 1.
int32_t e; int8_t byte_value = env->get_field_byte_by_name(env, stack, object, "byte_value", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int16_t (*get_field_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_field_short function, but you can specify field name directly.
get_field_short
int32_t e; int8_t short_value = env->get_field_short_by_name(env, stack, object, "short_value", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int32_t (*get_field_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_field_int function, but you can specify field name directly.
get_field_int
int32_t e; int8_t int_value = env->get_field_int_by_name(env, stack, object, "int_value", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int64_t (*get_field_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_field_long function, but you can specify field name directly.
get_field_long
int32_t e; int8_t long_value = env->get_field_long_by_name(env, stack, object, "long_value", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
float (*get_field_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_field_float function, but you can specify field name directly.
get_field_float
int32_t e; int8_t float_value = env->get_field_float_by_name(env, stack, object, "float_value", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
double (*get_field_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_field_double function, but you can specify field name directly.
get_field_double
int32_t e; int8_t double_value = env->get_field_double_by_name(env, stack, object, "double_value", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void* (*get_field_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_field_object function, but you can specify field name directly.
get_field_object
int32_t e; void* object_minimal = env->get_field_object_by_name(env, stack, object_simple, "object_value", "TestCase::Minimal", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_class_var_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int8_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_class_var_byte function, but you can specify the class name directly.
set_class_var_byte
int32_t e; env->set_class_var_byte_by_name(env, stack, "TestCase::NativeAPI", "$BYTE_VALUE", 15, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_class_var_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int16_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_class_var_short function, but you can specify the class name directly.
set_class_var_short
int32_t e; env->set_class_var_short_by_name(env, stack, "TestCase::NativeAPI", "$SHORT_VALUE", 15, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_class_var_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_class_var_int function, but you can specify the class name directly.
set_class_var_int
int32_t e; env->set_class_var_int_by_name(env, stack, "TestCase::NativeAPI", "$INT_VALUE", 15, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_class_var_long_by_name)(SPVM_ENV* env const char* class_name, const char* class_var_name, int64_t value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_class_var_long function, but you can specify the class name directly.
set_class_var_long
int32_t e; env->set_class_var_long_by_name(env, stack, "TestCase::NativeAPI", "$LONG_VALUE", 15, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_class_var_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, float value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_class_var_float function, but you can specify the class name directly.
set_class_var_float
int32_t e; env->set_class_var_float_by_name(env, stack, "TestCase::NativeAPI", "$FLOAT_VALUE", 15, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_class_var_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, double value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_class_var_double function, but you can specify the class name directly.
set_class_var_double
int32_t e; env->set_class_var_double_by_name(env, stack, "TestCase::NativeAPI", "$DOUBLE_VALUE", 15, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void (*set_class_var_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, void* value, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as set_class_var_object function, but you can specify the class name directly.
set_class_var_object
int32_t e; env->set_class_var_object_by_name(env, stack, "TestCase::NativeAPI", "$MINIMAL_VALUE", "TestCase::Minimal", minimal, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int8_t (*get_class_var_byte_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_class_var_byte function, but you can specify the class name directly.
get_class_var_byte
int32_t e; int8_t value = env->get_class_var_byte_by_name(env, stack, "TestCase::NativeAPI", "$BYTE_VALUE", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int16_t (*get_class_var_short_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_class_var_short function, but you can specify the class name directly.
get_class_var_short
int32_t e; int16_t value = env->get_class_var_short_by_name(env, stack, "TestCase::NativeAPI", "$SHORT_VALUE", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int32_t (*get_class_var_int_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_class_var_int function, but you can specify the class name directly.
get_class_var_int
int64_t (*get_class_var_long_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_class_var_long function, but you can specify the class name directly.
get_class_var_long
int32_t e; int64_t value = env->get_class_var_long_by_name(env, stack, "TestCase::NativeAPI", "$LONG_VALUE", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
float (*get_class_var_float_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_class_var_float function, but you can specify the class name directly.
get_class_var_float
int32_t e; float value = env->get_class_var_float_by_name(env, stack, "TestCase::NativeAPI", "$FLOAT_VALUE", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
double (*get_class_var_double_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_class_var_double function, but you can specify the class name directly.
get_class_var_double
int32_t e; double value = env->get_class_var_double_by_name(env, stack, "TestCase::NativeAPI", "$DOUBLE_VALUE", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void* (*get_class_var_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* class_var_name, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as get_class_var_object function, but you can specify the class name directly.
get_class_var_object
int32_t e; void* value = env->get_class_var_object_by_name(env, stack, "TestCase::NativeAPI", "$MINIMAL_VALUE", &e, __func__, __FILE__, __LINE__); if (e) { return e; }
int32_t (*call_class_method_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* method_name, int32_t args_stack_length, const char* func_name, const char* file, int32_t line);
This is same as call_method_raw function, but you can specify the class name and method name directly.
call_method_raw
int32_t output; { int32_t args_stack_length = 1; stack[0].ival = 5; int32_t error = env->call_class_method_by_name(env, stack, "TestCase::NativeAPI", "my_value", args_stack_length, __func__, __FILE__, __LINE__); if (error) { return error; } output = stack[0].ival; }
int32_t (*call_instance_method_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* method_name, int32_t args_stack_length, const char* func_name, const char* file, int32_t line);
const char* (*get_field_string_chars_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, const char* field_name, int32_t* error, const char* func_name, const char* file, int32_t line);
void (*free_env_prepared)(SPVM_ENV* env);
Frees the environment prepared by SPVM_NATIVE_new_env_prepared function.
SPVM_NATIVE_new_env_prepared
void* (*dump_raw)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
Gets the string which dump the object. The string is the same as the return value of dump operator.
dump
void* (*dump)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
The same as dump_raw, and push the created object to the mortal stack. Use this function in normal use instead of dump_raw.
dump_raw
int32_t (*get_instance_method_id_static)(SPVM_ENV* env, const char* class_name, const char* method_name);
Gets a instance method ID by the class name, the method name. If the instance method does not exists, a negative value is returned.
int32_t method_id = env->get_instance_method_id_static(env, "Foo", "get");
int32_t (*get_bool_object_value)(SPVM_ENV* env, SPVM_VALUE* stack, void* bool_object);
Gets the value of a Bool object. If the Bool object is true, return 1, otherwise return 0.
int32_t bool_value = env->get_bool_object_value(env, stack, bool_object);
void (*cleanup_global_vars)(SPVM_ENV* env, SPVM_VALUE* stack);
Cleanup gloval variable, such as class variables and the exception variable.
void (*make_read_only)(SPVM_ENV* env, SPVM_VALUE* stack, void* string)
Make the string read-only.
If the string is read-only, returns 1, otherwise returns 0.
int32_t (*is_array)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
If the object is an array, returns 1, otherwise returns 0.
int32_t (*is_string)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
If the object is a string, returns 1, otherwise returns 0.
int32_t (*is_numeric_array)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
If the object is a numeric array, returns 1, otherwise returns 0.
int32_t (*is_mulnum_array)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
If the object is a multi numeric array, returns 1, otherwise returns 0.
int32_t (*get_elem_size)(SPVM_ENV* env, SPVM_VALUE* stack, void* array);
Gets the byte size of the element of the array.
void* (*new_array_proto)(SPVM_ENV* env, SPVM_VALUE* stack, void* array, int32_t length);
Creates a new array that have the type of the given array and the given length.
The given array must be the object that is an array type.
If the given array is NULL, returns NULL.
If the given length is lower than 0, returns NULL.
void* (*copy)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
Copy the object. The type of the object must be a string type, a numeric array, or a multi numeric array.
If the given object is NULL, returns NULL.
void (*shorten)(SPVM_ENV* env, SPVM_VALUE* stack, void* string, int32_t new_length);
Shorten the string with the given length.
If the string is null, does nothing.
If the given length is greater than the length of the string, does nothing.
If the given length is lower than 0, the given length become 0.
The charaters of the after the given length are filled with \0.
int32_t (*has_interface)(SPVM_ENV* env, SPVM_VALUE* stack, void* object, int32_t interface_basic_type_id);
Check the type of the object has the interface.
void (*print)(SPVM_ENV* env, SPVM_VALUE* stack, void* string);
Prints the characters of the string to stdout.
If the string is NULL, nothing is printed.
void (*print_stderr)(SPVM_ENV* env, SPVM_VALUE* stack, void* string);
Prints the characters of the string to stderr.
int32_t (*init_env)(SPVM_ENV* env);
Initialize the environment.
int32_t (*call_init_blocks)(SPVM_ENV* env, SPVM_VALUE* stack);
Calls all INIT blocks. If an exception is thrown, returns 1. Otherwise returns 0.
INIT
int32_t (*get_class_id)(SPVM_ENV* env, const char* class_name);
SPVM_VALUE* (*new_stack)(SPVM_ENV* env);
void (*free_stack)(SPVM_ENV* env, SPVM_VALUE* stack);
void* (*new_memory_env)(SPVM_ENV* env, size_t size);
This is the same as "alloc_memory_block_zero". This is more understandable name that memories are managed by the environment.
void (*free_memory_env)(SPVM_ENV* env, void* block);
This is the same as "free_memory_block". This is more understandable name that memories are managed by the environment.
int32_t (*get_memory_blocks_count_env)(SPVM_ENV* env);
This is the same as "get_memory_blocks_count". This is more understandable name that memories are managed by the environment.
void* (*new_memory_stack)(SPVM_ENV* env, SPVM_VALUE* stack, size_t size);
Creates a new memory block that is managed by the stack of the environment with the byte size and return the address. If it fails, return NULL.
The count of the memory block that is managed by the stack is incremented by 1.
void (*free_memory_stack)(SPVM_ENV* env, SPVM_VALUE* stack, void* block);
The count of the memory block that is managed by the stack is decremented by 1.
int32_t (*get_memory_blocks_count_stack)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the count of the memory blocks on the stack.
int32_t (*set_command_info_program_name)(SPVM_ENV* env, SPVM_VALUE* stack, void* obj_program_name);
Sets the program name. This value is got by CommandInfo-PROGRAM_NAME|SPVM::CommandInfo/"PROGRAM_NAME">.
If it succeed, return 0.
The program name must be a string object. Otherwise return non-zero value.
int32_t (*set_command_info_argv)(SPVM_ENV* env, SPVM_VALUE* stack, void* obj_argv);
Sets the argv. This value is got by CommandInfo-ARGV|SPVM::CommandInfo/"ARGV">.
The argv must be a string[] object. Otherwise return non-zero value.
string[]
int32_t (*get_class_id_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, int32_t* error, const char* func_name, const char* file, int32_t line);
Gets the class id by the class name.
If the class is not loaded, The error is set to 1. Otherwise set to 0.
const char* (*strerror)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value, int32_t length);
Gets the value of strerror of the C language on thread-safely.
strerror
If the length is 0, the length is set to 64.
void* (*new_string_array)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t length);
Creates a new string array. This is alias for the following code using "new_object_array".
void* obj_string_array = env->new_object_array(env, stack, SPVM_NATIVE_C_BASIC_TYPE_ID_STRING, length);
int32_t (*get_args_stack_length)(SPVM_ENV* env, SPVM_VALUE* stack);
Gets the stack length of the arguments specified by the caller.
void (*set_args_stack_length)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t args_length);
Sets the stack length of the arguments for a method call.
const char* (*dumpc)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
The alias for the following code using "dump".
const char* ret = env->get_chars(env, stack, SPVM_API_dump(env, stack, object));
void* (*new_pointer_object_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, void* pointer);
Creates a pointer object by specifying a basic type ID and a C language pointer. The basic type ID must be the correct basic type ID got by get_basic_type_id function.
void* (*new_pointer_object)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, void* pointer);
The same as "new_pointer_raw", and push the created object to the mortal stack. Use this function in normal use instead of new_pointer_raw.
new_pointer_raw
int32_t basic_type_id = env->get_basic_type_id(env, "MyTime"); void* pointer = malloc(sizeof (struct tm)); void* pointer_obj = env->new_pointer(env, stack, basic_type_id, pointer);
void* (*new_pointer_object_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, void* pointer, int32_t* error, const char* func_name, const char* file, int32_t line);
This is same as "new_pointer" function, but you can specify class name directly.
int32_t e; void* minimal = env->new_pointer_by_name(env, stack, "TestCase::Pointer", pointer, &e, __func__, __FILE__, __LINE__); if (e) { return e; }
void* (*get_elem_string)(SPVM_ENV* env, SPVM_VALUE* stack, void* array, int32_t index);
The same as "get_elem_object".
void (*set_elem_string)(SPVM_ENV* env, SPVM_VALUE* stack, void* array, int32_t index, void* string);
The same as "set_elem_object".
int32_t (*is_class)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
If the object is a instance of a class, returns 1, otherwise returns 0.
int32_t (*is_pointer_class)(SPVM_ENV* env, SPVM_VALUE* stack, void* object);
If the object is a instance of a pointer class, returns 1, otherwise returns 0.
void* (*strerror_string)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value, int32_t length);
The same as the "strerror" function, but return a string object.
int32_t (*get_basic_type_id_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* basic_type_name, int32_t* error, const char* func_name, const char* file, int32_t line);
Gets the basic_type id by the basic_type name.
If the basic_type is not loaded, The error is set to 1. Otherwise set to 0.
int32_t (*get_field_id_static)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* field_name);
Gets the ID of the field given an class name and field name. If the field does not exist, a value less than 0 is returned.
int32_t field_id = env->get_field_id_static(env, stack, "Point", "x");
int32_t (*items)(SPVM_ENV* env, SPVM_VALUE* stack);
The alias for the "get_args_stack_length".
int32_t items = env->items(env, stack);
int32_t (*call_instance_method_static_by_name)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* method_name, int32_t args_stack_length, const char* func_name, const char* file, int32_t line);
Calls a instance method by the class name and the method name.
int32_t output; { int32_t args_stack_length = 1; stack[0].oval = obj_point; int32_t error = env->call_instance_method_static_by_name(env, stack, "Point", "x", args_stack_length, __func__, __FILE__, __LINE__); if (error) { return error; } output = stack[0].ival; }
int32_t (*get_method_id)(SPVM_ENV* env, SPVM_VALUE* stack, const char* class_name, const char* method_name);
Gets a method ID by the class name and the method name. If the method does not exists, a negative value is returned.
int32_t method_id = env->get_method_id(env, "Foo", "get");
const char* (*strerror_nolen)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value);
The same as "strerror" given the length to 0.
void* (*strerror_string_nolen)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t errno_value);
The same as "strerror_string" given the length to 0.
void* (*get_compile_type_name_raw)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, int32_t type_dimension, int32_t type_flag);
Gets a new string object that is the compile-time type name with a basic type id, a type dimension, a type flag.
This function does not add the returned object to the mortal stack, so use the get_compile_type_name Native API for normal use to avoid memory leaks.
void* (*get_compile_type_name)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t basic_type_id, int32_t type_dimension, int32_t type_flag);
int32_t (*set_command_info_base_time)(SPVM_ENV* env, SPVM_VALUE* stack, int64_t base_time);
Sets the time when the program starts. This value is got by CommandInfo-BASE_TIME|SPVM::CommandInfo/"BASE_TIME">.
const char* (*get_spvm_version_string)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the version string of the SPVM language.
double (*get_spvm_version_number)(SPVM_ENV* env, SPVM_VALUE* stack);
Returns the version number of the SPVM language.
const char* (*get_version_string)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_id);
Returns the version string of a class. The class_id must be a valid class id.
class_id
If the version string in the class is not defined, returns NULL.
double (*get_version_number)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t class_id);
Returns the version number of a class. The class_id must be a valid class id.
If the version string in the class is not defined, returns -1.
int32_t (*call_method)(SPVM_ENV* env, SPVM_VALUE* stack, int32_t method_id, int32_t args_stack_length);
If stack[0] is a value of an object type, the object is pushed to the mortal stack.
Internally Used.
SPVM::Document::NativeAPI::Compiler
SPVM::Document::NativeAPI::Precompile
SPVM::Document::NativeAPI::Runtime
SPVM::Document::NativeAPI::StringBuffer
SPVM::Document::NativeAPI::Allocator
0 SPVM_NATIVE_C_BASIC_TYPE_ID_UNKNOWN 1 SPVM_NATIVE_C_BASIC_TYPE_ID_UNDEF 2 SPVM_NATIVE_C_BASIC_TYPE_ID_VOID 3 SPVM_NATIVE_C_BASIC_TYPE_ID_BYTE 4 SPVM_NATIVE_C_BASIC_TYPE_ID_SHORT 5 SPVM_NATIVE_C_BASIC_TYPE_ID_INT 6 SPVM_NATIVE_C_BASIC_TYPE_ID_LONG 7 SPVM_NATIVE_C_BASIC_TYPE_ID_FLOAT 8 SPVM_NATIVE_C_BASIC_TYPE_ID_DOUBLE 9 SPVM_NATIVE_C_BASIC_TYPE_ID_STRING 10 SPVM_NATIVE_C_BASIC_TYPE_ID_ANY_OBJECT 11 SPVM_NATIVE_C_BASIC_TYPE_ID_BYTE_CLASS 12 SPVM_NATIVE_C_BASIC_TYPE_ID_SHORT_CLASS 13 SPVM_NATIVE_C_BASIC_TYPE_ID_INT_CLASS 14 SPVM_NATIVE_C_BASIC_TYPE_ID_LONG_CLASS 15 SPVM_NATIVE_C_BASIC_TYPE_ID_FLOAT_CLASS 16 SPVM_NATIVE_C_BASIC_TYPE_ID_DOUBLE_CLASS 17 SPVM_NATIVE_C_BASIC_TYPE_ID_BOOL_CLASS 18 SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_CLASS 19 SPVM_NATIVE_C_BASIC_TYPE_ID_COMMAND_INFO_CLASS 20 SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_SYSTEM_CLASS 21 SPVM_NATIVE_C_BASIC_TYPE_ID_ERROR_NOT_SUPPORTED_CLASS 22 SPVM_NATIVE_C_BASIC_TYPE_ID_ADDRESS_CLASS
These IDs are permanently same for the binary compatibility after the future release v1.0.
The basic type is unknown.
The basic type ID of undef type.
The basic type ID of void type.
void
The basic type ID of byte type.
byte
The basic type ID of short type.
short
The basic type ID of int type.
int
The basic type ID of long type.
long
The basic type ID of float type.
float
The basic type ID of double type.
double
The basic type ID of string type.
The basic type ID of object type.
object
The basic type ID of Byte type.
The basic type ID of Short type.
The basic type ID of Int type.
The basic type ID of Long type.
The basic type ID of Float type.
The basic type ID of Double type.
The basic type ID of BOOL type.
The basic type ID of Error type.
The basic type ID of Error::System type.
The basic type ID of Error::NotSupported type.
The basic type ID of Address type.
0 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_UNKNOWN 1 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_NOT_FOUND_CLASS 2 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_UNDEF 3 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_VOID 4 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_NUMERIC 5 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_MULNUM 6 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_STRING 7 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_CLASS 8 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_INTERFACE 9 SPVM_NATIVE_C_BASIC_TYPE_CATEGORY_ANY_OBJECT
The basic type category for unknown types.
The basic type category for not found class types.
The basic type category for the undefined type.
The basic type category for the void type.
The basic type category for the numeric types.
The basic type category for the multi-numeric types.
The basic type category for the string type.
The basic type category for the class types.
The basic type category for the interface types.
The basic type category for the any object type.
1 SPVM_NATIVE_C_TYPE_FLAG_REF 2 SPVM_NATIVE_C_TYPE_FLAG_MUTABLE
The type flags.
1 SPVM_NATIVE_C_CLASS_ID_ERROR 2 SPVM_NATIVE_C_CLASS_ID_ERROR_SYSTEM 3 SPVM_NATIVE_C_CLASS_ID_ERROR_NOT_SUPPORTED
The class id of Error class.
The class id of Error::System class.
The class id of Error::NotSupported class.
void spvm_warn(const char* format, ...)
Prints the formatted message to stderr with a new line.
stderr
spvm_warn("Hello"); spvm_warn("Hello %s%d", "Foo", 3);
Examples using SPVM native APIs
Copyright (c) 2023 Yuki Kimoto
MIT License
To install SPVM, copy and paste the appropriate command in to your terminal.
cpanm
cpanm SPVM
CPAN shell
perl -MCPAN -e shell install SPVM
For more information on module installation, please visit the detailed CPAN module installation guide.