diff --git a/Makefile b/Makefile index 21226a0..6c13c0b 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ SDK = sdk/logger.h LDFLAGS = -Wl,--demangle,--allow-undefined EXPORT_FUNCS = \ --export=allocate,$\ - --export=deallocate,$\ + --export=release_objects,$\ --export=set_result_size,$\ --export=set_result_ptr,$\ --export=get_result_size,$\ @@ -29,7 +29,7 @@ EXPORT_FUNCS = \ --export=sqlite3_bind_blob_,$\ --export=sqlite3_bind_double,$\ --export=sqlite3_bind_int64,$\ - --export=sqlite3_bind_text_,$\ + --export=sqlite3_bind_text,$\ --export=sqlite3_bind_null,$\ --export=sqlite3_column_count,$\ --export=sqlite3_column_double,$\ @@ -154,7 +154,8 @@ SQLITE_FLAGS = \ -DSQLITE_ENABLE_OFFSET_SQL_FUNC\ -DSQLITE_ENABLE_DESERIALIZE\ -DSQLITE_INTROSPECTION_PRAGMAS\ - -DSQLITE_OMIT_POPEN + -DSQLITE_OMIT_POPEN\ + -DCVECTOR_LOGARITHMIC_GROWTH .PHONY: default all clean @@ -163,7 +164,7 @@ all: default $(TARGET): $(SQLITE_SRC) $(WRAPPER_SRC) $(CC) -O3 --sysroot=$(SYSROOT) --target=$(TARGET_TRIPLE) $(SQLITE_FLAGS) $(CFLAGS) $(LDFLAGS) -Wl,$(EXPORT_FUNCS) $^ -o $@.wasm - /root/.cargo/bin/fce embed -i sqlite3.wasm -w sqlite3.wit + # /root/.cargo/bin/fce embed_it -i sqlite3.wasm -w sqlite3.wit .PRECIOUS: $(TARGET) diff --git a/cvector/cvector.h b/cvector/cvector.h new file mode 100644 index 0000000..ce3ce51 --- /dev/null +++ b/cvector/cvector.h @@ -0,0 +1,197 @@ +#ifndef CVECTOR_H_ +#define CVECTOR_H_ + +#include /* for assert */ +#include /* for malloc/realloc/free */ + +/** + * @brief cvector_vector_type - The vector type used in this library + */ +#define cvector_vector_type(type) type * + +/** + * @brief cvector_set_capacity - For internal use, sets the capacity variable of the vector + * @param vec - the vector + * @param size - the new capacity to set + * @return void + */ +#define cvector_set_capacity(vec, size) \ + do { \ + if (vec) { \ + ((size_t *)(vec))[-1] = (size); \ + } \ + } while (0) + +/** + * @brief cvector_set_size - For internal use, sets the size variable of the vector + * @param vec - the vector + * @param size - the new capacity to set + * @return void + */ +#define cvector_set_size(vec, size) \ + do { \ + if (vec) { \ + ((size_t *)(vec))[-2] = (size); \ + } \ + } while (0) + +/** + * @brief cvector_capacity - gets the current capacity of the vector + * @param vec - the vector + * @return the capacity as a size_t + */ +#define cvector_capacity(vec) \ + ((vec) ? ((size_t *)(vec))[-1] : (size_t)0) + +/** + * @brief cvector_size - gets the current size of the vector + * @param vec - the vector + * @return the size as a size_t + */ +#define cvector_size(vec) \ + ((vec) ? ((size_t *)(vec))[-2] : (size_t)0) + +/** + * @brief cvector_empty - returns non-zero if the vector is empty + * @param vec - the vector + * @return non-zero if empty, zero if non-empty + */ +#define cvector_empty(vec) \ + (cvector_size(vec) == 0) + +/** + * @brief cvector_grow - For internal use, ensures that the vector is at least elements big + * @param vec - the vector + * @param count - the new capacity to set + * @return void + */ +#define cvector_grow(vec, count) \ + do { \ + const size_t cv_sz = (count) * sizeof(*(vec)) + (sizeof(size_t) * 2); \ + if (!(vec)) { \ + size_t *cv_p = malloc(cv_sz); \ + assert(cv_p); \ + (vec) = (void *)(&cv_p[2]); \ + cvector_set_capacity((vec), (count)); \ + cvector_set_size((vec), 0); \ + } else { \ + size_t *cv_p1 = &((size_t *)(vec))[-2]; \ + size_t *cv_p2 = realloc(cv_p1, (cv_sz)); \ + assert(cv_p2); \ + (vec) = (void *)(&cv_p2[2]); \ + cvector_set_capacity((vec), (count)); \ + } \ + } while (0) + +/** + * @brief cvector_pop_back - removes the last element from the vector + * @param vec - the vector + * @return void + */ +#define cvector_pop_back(vec) \ + do { \ + cvector_set_size((vec), cvector_size(vec) - 1); \ + } while (0) + +/** + * @brief cvector_erase - removes the element at index i from the vector + * @param vec - the vector + * @param i - index of element to remove + * @return void + */ +#define cvector_erase(vec, i) \ + do { \ + if (vec) { \ + const size_t cv_sz = cvector_size(vec); \ + if ((i) < cv_sz) { \ + cvector_set_size((vec), cv_sz - 1); \ + size_t cv_x; \ + for (cv_x = (i); cv_x < (cv_sz - 1); ++cv_x) { \ + (vec)[cv_x] = (vec)[cv_x + 1]; \ + } \ + } \ + } \ + } while (0) + +/** + * @brief cvector_free - frees all memory associated with the vector + * @param vec - the vector + * @return void + */ +#define cvector_free(vec) \ + do { \ + if (vec) { \ + size_t *p1 = &((size_t *)(vec))[-2]; \ + free(p1); \ + } \ + } while (0) + +/** + * @brief cvector_begin - returns an iterator to first element of the vector + * @param vec - the vector + * @return a pointer to the first element (or NULL) + */ +#define cvector_begin(vec) \ + (vec) + +/** + * @brief cvector_end - returns an iterator to one past the last element of the vector + * @param vec - the vector + * @return a pointer to one past the last element (or NULL) + */ +#define cvector_end(vec) \ + ((vec) ? &((vec)[cvector_size(vec)]) : NULL) + +/* user request to use logarithmic growth algorithm */ +#ifdef CVECTOR_LOGARITHMIC_GROWTH + +/** + * @brief cvector_push_back - adds an element to the end of the vector + * @param vec - the vector + * @param value - the value to add + * @return void + */ +#define cvector_push_back(vec, value) \ + do { \ + size_t cv_cap = cvector_capacity(vec); \ + if (cv_cap <= cvector_size(vec)) { \ + cvector_grow((vec), !cv_cap ? cv_cap + 1 : cv_cap * 2); \ + } \ + vec[cvector_size(vec)] = (value); \ + cvector_set_size((vec), cvector_size(vec) + 1); \ + } while (0) + +#else + +/** + * @brief cvector_push_back - adds an element to the end of the vector + * @param vec - the vector + * @param value - the value to add + * @return void + */ +#define cvector_push_back(vec, value) \ + do { \ + size_t cv_cap = cvector_capacity(vec); \ + if (cv_cap <= cvector_size(vec)) { \ + cvector_grow((vec), cv_cap + 1); \ + } \ + vec[cvector_size(vec)] = (value); \ + cvector_set_size((vec), cvector_size(vec) + 1); \ + } while (0) + +#endif /* CVECTOR_LOGARITHMIC_GROWTH */ + +/** + * @brief cvector_copy - copy a vector + * @param from - the original vector + * @param to - destination to which the function copy to + * @return void + */ +#define cvector_copy(from, to) \ + do { \ + for(size_t i = 0; i < cvector_size(from); i++) { \ + cvector_push_back(to, from[i]); \ + } \ + } while (0) \ + +#endif /* CVECTOR_H_ */ diff --git a/sqlite3.wit b/sqlite3.wit index d5ca550..b726881 100644 --- a/sqlite3.wit +++ b/sqlite3.wit @@ -1,9 +1,10 @@ +(@interface it_version "0.19.0") + ;; Types (@interface type (func (param $size: i32) (result i32))) ;; 0 -(@interface type (func - (param $pointer: i32 $size: i32) )) ;; 1 +(@interface type (func )) ;; 1 (@interface type (func (result i32))) ;; 2 (@interface type (func @@ -25,102 +26,110 @@ field $ret_code: s32 field $db_handle: u32 ))) ;; 8 +(@interface type (record $SecurityTetraplet ( + field $peer_pk: string + field $service_id: string + field $function_name: string + field $json_path: string +))) ;; 9 +(@interface type (record $CallParameters ( + field $init_peer_id: string + field $service_id: string + field $service_creator_peer_id: string + field $host_id: string + field $particle_id: string + field $tetraplets: array (array (record 9)) +))) ;; 10 (@interface type (func (param $stmt_handle: u32 $icol: u32) - (result string))) ;; 9 + (result string))) ;; 11 (@interface type (func (param $stmt_handle: u32 $icol: u32) - (result string))) ;; 10 + (result string))) ;; 12 (@interface type (func (param $stmt_handle: u32 $icol: u32) - (result s32))) ;; 11 -(@interface type (func - (param $stmt_handle: u32 $icol: u32) - (result s32))) ;; 12 -(@interface type (func - (param $db_handle: u32) (result s32))) ;; 13 (@interface type (func - (param $db_handle: u32) + (param $stmt_handle: u32 $icol: u32) (result s32))) ;; 14 (@interface type (func - (param $stmt_handle: u32 $pos: s32 $value: f64) + (param $db_handle: u32) (result s32))) ;; 15 (@interface type (func - (param $stmt_handle: u32 $pos: s32 $value: f64) + (param $db_handle: u32) (result s32))) ;; 16 (@interface type (func - (param $filename: string $flags: s32 $vfs: string) - (result record 8))) ;; 17 + (param $stmt_handle: u32 $pos: s32 $value: f64) + (result s32))) ;; 17 +(@interface type (func + (param $stmt_handle: u32 $pos: s32 $value: f64) + (result s32))) ;; 18 (@interface type (func (param $filename: string $flags: s32 $vfs: string) - (result record 8))) ;; 18 + (result record 8))) ;; 19 +(@interface type (func + (param $filename: string $flags: s32 $vfs: string) + (result record 8))) ;; 20 (@interface type (func (param $db_handle: u32) - (result s32))) ;; 19 -(@interface type (func - (param $db_handle: u32) - (result s32))) ;; 20 -(@interface type (func - (param $stmt_handle: u32) (result s32))) ;; 21 (@interface type (func - (param $stmt_handle: u32) + (param $db_handle: u32) (result s32))) ;; 22 (@interface type (func - (param $stmt_handle: u32 $icol: u32) - (result s64))) ;; 23 -(@interface type (func - (param $stmt_handle: u32 $icol: u32) - (result s64))) ;; 24 -(@interface type (func - (param $db: u32) - (result s32))) ;; 25 -(@interface type (func - (param $db: u32) - (result s32))) ;; 26 -(@interface type (func - (param $stmt_handle: u32 $icol: s32) - (result f64))) ;; 27 -(@interface type (func - (param $stmt_handle: u32 $icol: s32) - (result f64))) ;; 28 -(@interface type (func - (param $db_handle: u32 $ms: u32) - (result s32))) ;; 29 -(@interface type (func - (param $db_handle: u32 $ms: u32) - (result s32))) ;; 30 -(@interface type (func - (param $db_handle: u32) - (result string))) ;; 31 -(@interface type (func - (param $db_handle: u32) - (result string))) ;; 32 -(@interface type (func - (param $stmt_handle: u32 $pos: s32 $value: s64) - (result s32))) ;; 33 -(@interface type (func - (param $stmt_handle: u32 $pos: s32 $value: s64) - (result s32))) ;; 34 + (param $stmt_handle: u32) + (result s32))) ;; 23 (@interface type (func (param $stmt_handle: u32) + (result s32))) ;; 24 +(@interface type (func + (param $stmt_handle: u32 $icol: u32) + (result s64))) ;; 25 +(@interface type (func + (param $stmt_handle: u32 $icol: u32) + (result s64))) ;; 26 +(@interface type (func + (param $db: u32) + (result s32))) ;; 27 +(@interface type (func + (param $db: u32) + (result s32))) ;; 28 +(@interface type (func + (param $stmt_handle: u32 $icol: s32) + (result f64))) ;; 29 +(@interface type (func + (param $stmt_handle: u32 $icol: s32) + (result f64))) ;; 30 +(@interface type (func + (param $db_handle: u32 $ms: u32) + (result s32))) ;; 31 +(@interface type (func + (param $db_handle: u32 $ms: u32) + (result s32))) ;; 32 +(@interface type (func + (param $db_handle: u32) + (result string))) ;; 33 +(@interface type (func + (param $db_handle: u32) + (result string))) ;; 34 +(@interface type (func + (param $stmt_handle: u32 $pos: s32 $value: s64) (result s32))) ;; 35 (@interface type (func - (param $stmt_handle: u32) + (param $stmt_handle: u32 $pos: s32 $value: s64) (result s32))) ;; 36 (@interface type (func - (param $db_handle: u32 $sql: string) - (result record 7))) ;; 37 -(@interface type (func - (param $db_handle: u32 $sql: string) - (result record 7))) ;; 38 + (param $stmt_handle: u32) + (result s32))) ;; 37 (@interface type (func (param $stmt_handle: u32) - (result s32))) ;; 39 + (result s32))) ;; 38 (@interface type (func - (param $stmt_handle: u32) - (result s32))) ;; 40 + (param $db_handle: u32 $sql: string) + (result record 7))) ;; 39 +(@interface type (func + (param $db_handle: u32 $sql: string) + (result record 7))) ;; 40 (@interface type (func (param $stmt_handle: u32 $pos: s32) (result s32))) ;; 41 @@ -128,62 +137,68 @@ (param $stmt_handle: u32 $pos: s32) (result s32))) ;; 42 (@interface type (func - (param $stmt_handle: u32 $pos: s32 $blob: array (u8) $xDel: s32) + (param $stmt_handle: u32) (result s32))) ;; 43 (@interface type (func - (param $stmt_handle: u32 $pos: s32 $blob: array (u8) $xDel: s32) + (param $stmt_handle: u32) (result s32))) ;; 44 (@interface type (func - (param $db_handle: u32) + (param $stmt_handle: u32 $pos: s32 $blob: array (u8) $xDel: s32) (result s32))) ;; 45 (@interface type (func - (param $db_handle: u32) + (param $stmt_handle: u32 $pos: s32 $blob: array (u8) $xDel: s32) (result s32))) ;; 46 (@interface type (func - (param $stmt_handle: u32 $pos: s32 $text: string $xDel: s32) + (param $db_handle: u32) (result s32))) ;; 47 (@interface type (func - (param $stmt_handle: u32 $pos: s32 $text: string $xDel: s32) + (param $db_handle: u32) (result s32))) ;; 48 (@interface type (func - (param $stmt_handle: u32) + (param $stmt_handle: u32 $pos: s32 $text: string $xDel: s32) (result s32))) ;; 49 (@interface type (func - (param $stmt_handle: u32) + (param $stmt_handle: u32 $pos: s32 $text: string $xDel: s32) (result s32))) ;; 50 (@interface type (func - (param $db_handle: u32 $sql: string $callback_id: s32 $callback_arg: s32) - (result record 6))) ;; 51 + (param $stmt_handle: u32) + (result s32))) ;; 51 +(@interface type (func + (param $stmt_handle: u32) + (result s32))) ;; 52 (@interface type (func (param $db_handle: u32 $sql: string $callback_id: s32 $callback_arg: s32) - (result record 6))) ;; 52 + (result record 6))) ;; 53 (@interface type (func - (result s32))) ;; 53 + (param $db_handle: u32 $sql: string $callback_id: s32 $callback_arg: s32) + (result record 6))) ;; 54 (@interface type (func - (result s32))) ;; 54 + (result s32))) ;; 55 +(@interface type (func + (result s32))) ;; 56 (@interface type (func (param $stmt_handle: u32 $icol: s32) - (result array (u8)))) ;; 55 + (result array (u8)))) ;; 57 (@interface type (func (param $stmt_handle: u32 $icol: s32) - (result array (u8)))) ;; 56 + (result array (u8)))) ;; 58 (@interface type (func (param $stmt_handle: u32 $N: u32) - (result string))) ;; 57 + (result string))) ;; 59 (@interface type (func (param $stmt_handle: u32 $N: u32) - (result string))) ;; 58 + (result string))) ;; 60 (@interface type (func (param $stmt_handle: u32 $icol: u32) - (result s32))) ;; 59 + (result s32))) ;; 61 (@interface type (func (param $stmt_handle: u32 $icol: u32) - (result s32))) ;; 60 + (result s32))) ;; 62 ;; Adapters -(@interface func (type 9) +(@interface func (type 11) arg.get 0 i32.from_u32 arg.get 1 @@ -192,22 +207,20 @@ call-core 3 call-core 2 string.lift_memory - call-core 3 - call-core 2 call-core 1) -(@interface func (type 11) +(@interface func (type 13) arg.get 0 i32.from_u32 arg.get 1 i32.from_u32 call-core 7 s32.from_i32) -(@interface func (type 13) +(@interface func (type 15) arg.get 0 i32.from_u32 call-core 8 s32.from_i32) -(@interface func (type 15) +(@interface func (type 17) arg.get 0 i32.from_u32 arg.get 1 @@ -215,7 +228,7 @@ arg.get 2 call-core 9 s32.from_i32) -(@interface func (type 17) +(@interface func (type 19) arg.get 0 string.size call-core 0 @@ -230,53 +243,52 @@ string.lower_memory call-core 10 call-core 3 - record.lift_memory 8) -(@interface func (type 19) + record.lift_memory 8 + call-core 1) +(@interface func (type 21) arg.get 0 i32.from_u32 call-core 11 s32.from_i32) -(@interface func (type 21) +(@interface func (type 23) arg.get 0 i32.from_u32 call-core 12 s32.from_i32) -(@interface func (type 23) +(@interface func (type 25) arg.get 0 i32.from_u32 arg.get 1 i32.from_u32 call-core 13 s64.from_i64) -(@interface func (type 25) +(@interface func (type 27) arg.get 0 i32.from_u32 call-core 14 s32.from_i32) -(@interface func (type 27) +(@interface func (type 29) arg.get 0 i32.from_u32 arg.get 1 i32.from_s32 call-core 15) -(@interface func (type 29) +(@interface func (type 31) arg.get 0 i32.from_u32 arg.get 1 i32.from_u32 call-core 16 s32.from_i32) -(@interface func (type 31) +(@interface func (type 33) arg.get 0 i32.from_u32 call-core 17 call-core 3 call-core 2 string.lift_memory - call-core 3 - call-core 2 call-core 1) -(@interface func (type 33) +(@interface func (type 35) arg.get 0 i32.from_u32 arg.get 1 @@ -285,12 +297,12 @@ i64.from_s64 call-core 18 s32.from_i32) -(@interface func (type 35) +(@interface func (type 37) arg.get 0 i32.from_u32 call-core 19 s32.from_i32) -(@interface func (type 37) +(@interface func (type 39) arg.get 0 i32.from_u32 arg.get 1 @@ -300,20 +312,21 @@ string.lower_memory call-core 20 call-core 3 - record.lift_memory 7) -(@interface func (type 39) - arg.get 0 - i32.from_u32 - call-core 21 - s32.from_i32) + record.lift_memory 7 + call-core 1) (@interface func (type 41) arg.get 0 i32.from_u32 arg.get 1 i32.from_s32 - call-core 22 + call-core 21 s32.from_i32) (@interface func (type 43) + arg.get 0 + i32.from_u32 + call-core 22 + s32.from_i32) +(@interface func (type 45) arg.get 0 i32.from_u32 arg.get 1 @@ -324,12 +337,12 @@ i32.from_s32 call-core 23 s32.from_i32) -(@interface func (type 45) +(@interface func (type 47) arg.get 0 i32.from_u32 call-core 24 s32.from_i32) -(@interface func (type 47) +(@interface func (type 49) arg.get 0 i32.from_u32 arg.get 1 @@ -343,12 +356,12 @@ i32.from_s32 call-core 25 s32.from_i32) -(@interface func (type 49) +(@interface func (type 51) arg.get 0 i32.from_u32 call-core 26 s32.from_i32) -(@interface func (type 51) +(@interface func (type 53) arg.get 0 i32.from_u32 arg.get 1 @@ -362,11 +375,12 @@ i32.from_s32 call-core 27 call-core 3 - record.lift_memory 6) -(@interface func (type 53) + record.lift_memory 6 + call-core 1) +(@interface func (type 55) call-core 28 s32.from_i32) -(@interface func (type 55) +(@interface func (type 57) arg.get 0 i32.from_u32 arg.get 1 @@ -374,8 +388,9 @@ call-core 29 call-core 3 call-core 2 - array.lift_memory u8) -(@interface func (type 57) + array.lift_memory u8 + call-core 1) +(@interface func (type 59) arg.get 0 i32.from_u32 arg.get 1 @@ -384,10 +399,8 @@ call-core 3 call-core 2 string.lift_memory - call-core 3 - call-core 2 call-core 1) -(@interface func (type 59) +(@interface func (type 61) arg.get 0 i32.from_u32 arg.get 1 @@ -397,40 +410,39 @@ ;; Exports (@interface export "allocate" (func 0)) -(@interface export "deallocate" (func 1)) +(@interface export "release_objects" (func 1)) (@interface export "get_result_size" (func 2)) (@interface export "get_result_ptr" (func 3)) (@interface export "set_result_size" (func 4)) (@interface export "set_result_ptr" (func 5)) -(@interface export "sqlite3_column_text" (func 10)) -(@interface export "sqlite3_column_bytes" (func 12)) -(@interface export "sqlite3_close" (func 14)) -(@interface export "sqlite3_bind_double" (func 16)) -(@interface export "sqlite3_open_v2" (func 18)) -(@interface export "sqlite3_changes" (func 20)) -(@interface export "sqlite3_step" (func 22)) -(@interface export "sqlite3_column_int64" (func 24)) -(@interface export "sqlite3_errcode" (func 26)) -(@interface export "sqlite3_column_double" (func 28)) -(@interface export "sqlite3_busy_timeout" (func 30)) -(@interface export "sqlite3_errmsg" (func 32)) -(@interface export "sqlite3_bind_int64" (func 34)) -(@interface export "sqlite3_finalize" (func 36)) -(@interface export "sqlite3_prepare_v2" (func 38)) -(@interface export "sqlite3_column_count" (func 40)) +(@interface export "sqlite3_column_text" (func 12)) +(@interface export "sqlite3_column_bytes" (func 14)) +(@interface export "sqlite3_close" (func 16)) +(@interface export "sqlite3_bind_double" (func 18)) +(@interface export "sqlite3_open_v2" (func 20)) +(@interface export "sqlite3_changes" (func 22)) +(@interface export "sqlite3_step" (func 24)) +(@interface export "sqlite3_column_int64" (func 26)) +(@interface export "sqlite3_errcode" (func 28)) +(@interface export "sqlite3_column_double" (func 30)) +(@interface export "sqlite3_busy_timeout" (func 32)) +(@interface export "sqlite3_errmsg" (func 34)) +(@interface export "sqlite3_bind_int64" (func 36)) +(@interface export "sqlite3_finalize" (func 38)) +(@interface export "sqlite3_prepare_v2" (func 40)) (@interface export "sqlite3_bind_null" (func 42)) -(@interface export "sqlite3_bind_blob" (func 44)) -(@interface export "sqlite3_total_changes" (func 46)) -(@interface export "sqlite3_bind_text" (func 48)) -(@interface export "sqlite3_reset" (func 50)) -(@interface export "sqlite3_exec" (func 52)) -(@interface export "sqlite3_libversion_number" (func 54)) -(@interface export "sqlite3_column_blob" (func 56)) -(@interface export "sqlite3_column_name" (func 58)) -(@interface export "sqlite3_column_type" (func 60)) +(@interface export "sqlite3_column_count" (func 44)) +(@interface export "sqlite3_bind_blob" (func 46)) +(@interface export "sqlite3_total_changes" (func 48)) +(@interface export "sqlite3_bind_text" (func 50)) +(@interface export "sqlite3_reset" (func 52)) +(@interface export "sqlite3_exec" (func 54)) +(@interface export "sqlite3_libversion_number" (func 56)) +(@interface export "sqlite3_column_blob" (func 58)) +(@interface export "sqlite3_column_name" (func 60)) +(@interface export "sqlite3_column_type" (func 62)) ;; Implementations -(@interface implement (func 10) (func 9)) (@interface implement (func 12) (func 11)) (@interface implement (func 14) (func 13)) (@interface implement (func 16) (func 15)) @@ -456,3 +468,4 @@ (@interface implement (func 56) (func 55)) (@interface implement (func 58) (func 57)) (@interface implement (func 60) (func 59)) +(@interface implement (func 62) (func 61)) diff --git a/src/legacy.c b/src/legacy.c index 790571d..b931790 100644 --- a/src/legacy.c +++ b/src/legacy.c @@ -30,20 +30,18 @@ */ void sqlite3_exec_( sqlite3 *db, /* The database on which the SQL executes */ - char *zSql, /* The SQL to be executed */ + char *zSql, /* The SQL to be executed */ int zSql_len, sqlite3_callback xCallback, /* Invoke this callback routine */ void *pArg /* First argument to xCallback() */ ) __EXPORT_NAME(sqlite3_exec) { - char *new_zSql = (char *) malloc(zSql_len + 1); - memcpy(new_zSql, zSql, zSql_len); - new_zSql[zSql_len] = 0; - free((void *)zSql); + zSql = handle_input_string(zSql, zSql_len); char *pzErrMsg = 0; - const int ret_code = sqlite3_exec(db, new_zSql, xCallback, pArg, &pzErrMsg); + const int ret_code = sqlite3_exec(db, zSql, xCallback, pArg, &pzErrMsg); + + free(zSql); - free(new_zSql); int *result = malloc(3*8); result[0] = ret_code; result[1] = 0; @@ -52,7 +50,10 @@ void sqlite3_exec_( result[4] = strlen(pzErrMsg); result[5] = 0; - set_result_ptr((char *)result); + // errmsg should be managed by user + add_object_to_release((void *) pzErrMsg); + add_object_to_release((void *) result); + set_result_ptr((void *) result); } int sqlite3_exec( diff --git a/src/main.c b/src/main.c index d446447..aed5dc8 100644 --- a/src/main.c +++ b/src/main.c @@ -2452,7 +2452,8 @@ int sqlite3TempInMemory(const sqlite3 *db){ void sqlite3_errmsg_(sqlite3 *db) __EXPORT_NAME(sqlite3_errmsg) { const char *result = sqlite3_errmsg(db); - set_result_ptr((char *)result); + // result is managed by SQLite itself + set_result_ptr((void *) result); set_result_size(strlen(result)); } @@ -3436,36 +3437,29 @@ int sqlite3_open( } void sqlite3_open_v2_( - const char *filename, /* Database filename (UTF-8) */ + char *filename, /* Database filename (UTF-8) */ int filename_len, int flags, /* Flags */ - const char *zVfs, /* Name of VFS module to use */ + char *zVfs, /* Name of VFS module to use */ int zVfs_len ) __EXPORT_NAME(sqlite3_open_v2) { - char *new_filename = (char *)malloc(filename_len + 1); - memcpy(new_filename, filename, filename_len); - new_filename[filename_len] = '\x00'; - free((void *)filename); - - char *new_zVfs = 0; - if (zVfs_len != 0) { - char *new_zVfs = (char *) malloc(zVfs_len + 1); - memcpy(new_zVfs, zVfs, zVfs_len); - new_zVfs[zVfs_len] = '\x00'; - free((void *) zVfs); - } + filename = handle_input_string(filename, filename_len); + zVfs = handle_input_string(zVfs, zVfs_len); sqlite3 *ppDb; - const int ret_code = sqlite3_open_v2(new_filename, &ppDb, (unsigned int)flags, new_zVfs); - free(new_filename); - free(new_zVfs); + const int ret_code = sqlite3_open_v2(filename, &ppDb, (unsigned int)flags, zVfs); + + // cleanup strings passed from the IT side + free(filename); + free(zVfs); int *result = (int *)malloc(16); result[0] = ret_code; result[2] = (int)ppDb; - set_result_ptr((char *)result); + add_object_to_release((void *) result); + set_result_ptr((void *)result); } int sqlite3_open_v2( diff --git a/src/prepare.c b/src/prepare.c index 0100ffc..a42a2d1 100644 --- a/src/prepare.c +++ b/src/prepare.c @@ -788,11 +788,11 @@ void sqlite3_prepare_v2_( const char *zSql, /* UTF-8 encoded SQL statement. */ int nBytes /* Length of zSql in bytes. */ ) __EXPORT_NAME(sqlite3_prepare_v2) { - sqlite3_stmt *ppStmt; - const char *pzTail; + sqlite3_stmt *ppStmt = NULL; + const char *pzTail = NULL; const int ret_code = sqlite3_prepare_v2(db, zSql, nBytes, &ppStmt, &pzTail); - free((void *)zSql); + free((void *) zSql); int *result = (int *)malloc(3*8); result[0] = ret_code; @@ -800,7 +800,8 @@ void sqlite3_prepare_v2_( result[4] = (int)pzTail; result[5] = strlen(pzTail); - set_result_ptr((char *)result); + add_object_to_release((void *) result); + set_result_ptr((void *) result); } int sqlite3_prepare_v2( diff --git a/src/sqlite3.h b/src/sqlite3.h index 80780cb..7b230c4 100644 --- a/src/sqlite3.h +++ b/src/sqlite3.h @@ -37,9 +37,6 @@ #define __EXPORT_NAME(name) \ __attribute__((export_name(#name))) -void set_result_ptr(const char *ptr); -void set_result_size(int size); - /* ** Make sure we can call this stuff from C++. */ diff --git a/src/sqliteInt.h b/src/sqliteInt.h index 53e7095..64261f9 100644 --- a/src/sqliteInt.h +++ b/src/sqliteInt.h @@ -4908,4 +4908,13 @@ void sqlite3VectorErrorMsg(Parse*, Expr*); const char **sqlite3CompileOptions(int *pnOpt); #endif +#ifndef __sqlite_unmodified_upstram +void add_object_to_release(void *object); + +void set_result_ptr(void *ptr); +void set_result_size(int size); + +char *handle_input_string(char *str, int len); +#endif + #endif /* SQLITEINT_H */ diff --git a/src/vdbeapi.c b/src/vdbeapi.c index 9ea0fe8..5879664 100644 --- a/src/vdbeapi.c +++ b/src/vdbeapi.c @@ -1113,10 +1113,8 @@ void sqlite3_column_blob_(sqlite3_stmt *pStmt, int i) __EXPORT_NAME(sqlite3_colu const char *blob = sqlite3_column_blob(pStmt, i); int blob_len = sqlite3_column_bytes(pStmt, i); - unsigned char *copied_result = malloc(blob_len); - memcpy(copied_result, blob, blob_len); - - set_result_ptr((char *)copied_result); + // blob is managed by SQLite itself + set_result_ptr((void *)blob); set_result_size(blob_len); } @@ -1160,10 +1158,8 @@ void sqlite3_column_text_(sqlite3_stmt *pStmt, int i) __EXPORT_NAME(sqlite3_colu const unsigned char *text = sqlite3_column_text(pStmt, i); const unsigned int text_len = sqlite3_column_bytes(pStmt, i); - unsigned char *copied_text = malloc(text_len); - memcpy(copied_text, text, text_len); - - set_result_ptr((char *)copied_text); + // test is managed by SQLite itself + set_result_ptr((void *) text); set_result_size(text_len); } @@ -1262,7 +1258,8 @@ static const void *columnName( void sqlite3_column_name_(sqlite3_stmt *pStmt, int N) __EXPORT_NAME(sqlite3_column_name) { const char *result = sqlite3_column_name(pStmt, N); - set_result_ptr((char *)result); + // result is managed by SQLite itself + set_result_ptr((void *)result); set_result_size(strlen(result)); } @@ -1456,6 +1453,7 @@ int sqlite3_bind_blob_( for (int char_id = 0; char_id < copied_nData; ++char_id) { copied_zData[char_id] = zData[char_id * 8]; } + free(zData); const int result = sqlite3_bind_blob(pStmt, i, copied_zData, copied_nData, 0); @@ -1539,21 +1537,6 @@ int sqlite3_bind_pointer( return rc; } -int sqlite3_bind_text_( - sqlite3_stmt *pStmt, - int i, - const char *zData, - int nData, - void (*xDel)(void*) -) __EXPORT_NAME(sqlite3_bind_text) { - char *copied_zData = malloc(nData); - memcpy(copied_zData, zData, nData); - - const int result = sqlite3_bind_text(pStmt, i, copied_zData, nData, xDel); - - return result; -} - int sqlite3_bind_text( sqlite3_stmt *pStmt, int i, diff --git a/src/wrapper.c b/src/wrapper.c index 8158d9a..9ff30d8 100644 --- a/src/wrapper.c +++ b/src/wrapper.c @@ -1,18 +1,33 @@ -#include #include "sqliteInt.h" +#include "../cvector/cvector.h" -const char *RESULT_PTR; +#include + +void *RESULT_PTR; int RESULT_SIZE; +cvector_vector_type(void *) OBJECTS_TO_RELEASE; + void* allocate(size_t size) { + // this +1 is needed to append then zero byte to strings passing to this module. return malloc(size + 1); } -void deallocate(void *ptr, int size) { - free(ptr); +void release_objects() { + const unsigned int objects_count = cvector_size(OBJECTS_TO_RELEASE); + for (unsigned int obj_id = objects_count; obj_id > 0; --obj_id) { + void *object = OBJECTS_TO_RELEASE[obj_id-1]; + free(object); + + cvector_pop_back(OBJECTS_TO_RELEASE); + } } -void set_result_ptr(const char *ptr) { +void add_object_to_release(void *object) { + cvector_push_back(OBJECTS_TO_RELEASE, object); +} + +void set_result_ptr(void *ptr) { RESULT_PTR = ptr; } @@ -24,11 +39,22 @@ int get_result_size(void) { return RESULT_SIZE; } -const char *get_result_ptr() { +void *get_result_ptr() { return RESULT_PTR; } +char *handle_input_string(char *str, int len) { + if (len == 0) { + free(str); + return NULL; + } + + // this strings are supposed to be allocated by the allocate function, which allocates 1 byte more for null character + str[len] = '\x00'; + return str; +} + int main() { - // the main purpose of this empty main is to initialize WASi subsystem + // the main purpose of this empty main is to initialize WASI subsystem return 0; -} \ No newline at end of file +}