1472 lines
45 KiB
C++
1472 lines
45 KiB
C++
#include "lib.h"
|
|
#include "rawlist.cc"
|
|
|
|
TypeTree DB_TYPE;
|
|
NameTree DB_NAME;
|
|
SparseList<Type::SchemaBinding> DB_SCHEMA;
|
|
Pool<Reference> DB_REFERENCE;
|
|
|
|
extern "C" void test() { }
|
|
|
|
extern "C" size_t type_outer(size_t type_id, size_t key)
|
|
{
|
|
return DB_TYPE.outer(type_id, key);
|
|
}
|
|
|
|
extern "C" size_t type_inner(size_t type_id)
|
|
{
|
|
return DB_TYPE.inner(type_id);
|
|
}
|
|
|
|
extern "C" size_t type_key(size_t type_id)
|
|
{
|
|
return DB_TYPE.key(type_id);
|
|
}
|
|
|
|
extern "C" size_t type_innerkey(size_t type_id)
|
|
{
|
|
return DB_TYPE.key(DB_TYPE.inner(type_id));
|
|
}
|
|
|
|
extern "C" size_t type_size(size_t type_id)
|
|
{
|
|
if(DB_TYPE.has(type_id)) {
|
|
size_t type = DB_TYPE.key(type_id);
|
|
|
|
switch(type) {
|
|
case Type::Tag::Null: return 0;
|
|
case Type::Tag::Varying: return sizeof(Reference);
|
|
case Type::Tag::Boolean: return sizeof(Type::Boolean);
|
|
case Type::Tag::Natural: return sizeof(Type::Natural);
|
|
case Type::Tag::Integer: return sizeof(Type::Integer);
|
|
case Type::Tag::Significant: return sizeof(Type::Significant);
|
|
case Type::Tag::Decimal: return sizeof(Type::Decimal);
|
|
case Type::Tag::Block: return type_innerkey(type_id);
|
|
case Type::Tag::Sequence: return sizeof(Type::Sequence);
|
|
|
|
case Type::Tag::Array: {
|
|
size_t length = DB_TYPE.inner(type_id);
|
|
size_t inner = DB_TYPE.inner(length);
|
|
if(inner == Type::Tag::Null) {
|
|
return sizeof(Reference);
|
|
}
|
|
else {
|
|
return static_cast<size_t>(DB_TYPE.key(length)) * type_size(inner);
|
|
}
|
|
}
|
|
|
|
case Type::Tag::List:
|
|
case Type::Tag::Sparse:
|
|
case Type::Tag::Record:
|
|
{
|
|
size_t innerkey = type_innerkey(type_id);
|
|
if(innerkey == Type::Tag::Null) {
|
|
return sizeof(Reference);
|
|
}
|
|
else {
|
|
switch(type) {
|
|
case Type::Tag::List: return sizeof(Type::List);
|
|
case Type::Tag::Sparse: return sizeof(Type::Sparse);
|
|
case Type::Tag::Record: {
|
|
auto binding = DB_SCHEMA.get(type_innerkey(type_id));
|
|
if(binding != nullptr) {
|
|
return binding->size;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
case Type::Tag::Schema: return sizeof(Type::Schema);
|
|
default: return 0;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t type_alignment(size_t type_id)
|
|
{
|
|
if(DB_TYPE.has(type_id)) {
|
|
size_t type = DB_TYPE.key(type_id);
|
|
|
|
switch(type) {
|
|
case Type::Tag::Null: return 0;
|
|
|
|
case Type::Tag::Boolean: return sizeof(Type::Boolean);
|
|
case Type::Tag::Natural: return sizeof(Type::Natural);
|
|
case Type::Tag::Integer: return sizeof(Type::Integer);
|
|
case Type::Tag::Significant: return sizeof(Type::Significant);
|
|
case Type::Tag::Decimal: return sizeof(Type::Decimal);
|
|
case Type::Tag::Block: return sizeof(uint8_t);
|
|
case Type::Tag::Array: return type_alignment(type_inner(type_id));
|
|
|
|
case Type::Tag::Varying:
|
|
case Type::Tag::Sequence:
|
|
case Type::Tag::List:
|
|
case Type::Tag::Sparse:
|
|
case Type::Tag::Schema:
|
|
return sizeof(size_t);
|
|
|
|
case Type::Tag::Record: {
|
|
auto binding = DB_SCHEMA.get(type_innerkey(type_id));
|
|
return (binding != nullptr)? binding->alignment : 0;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" size_t kind_hasinner(size_t kind)
|
|
{
|
|
switch(kind) {
|
|
case Type::Tag::Array:
|
|
return 2;
|
|
case Type::Tag::Decimal:
|
|
case Type::Tag::Block:
|
|
case Type::Tag::List:
|
|
case Type::Tag::Sparse:
|
|
case Type::Tag::Record:
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" size_t type_hasinner(size_t type_id)
|
|
{
|
|
return kind_hasinner(type_key(type_id));
|
|
}
|
|
|
|
extern "C" size_t name_indexof(const uint8_t* bytes, size_t length)
|
|
{
|
|
std::string str(reinterpret_cast<const char*>(bytes), length);
|
|
if(str.size() > 0) {
|
|
return DB_NAME.indexof(str);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" Str name_keyof(size_t index)
|
|
{
|
|
Str result {0};
|
|
std::string str = DB_NAME.keyof(index);
|
|
if(str.length() > 0) {
|
|
result.bytes = new uint8_t[str.length()];
|
|
}
|
|
for(size_t i = 0; i < str.length(); ++i) {
|
|
result.bytes[i] = str[i];
|
|
}
|
|
result.length = str.length();
|
|
return result;
|
|
}
|
|
|
|
std::string name_keyof_internal(size_t index)
|
|
{
|
|
return DB_NAME.keyof(index);
|
|
}
|
|
|
|
extern "C" void name_release(Str data)
|
|
{
|
|
if(data.bytes != nullptr) {
|
|
delete[] data.bytes;
|
|
}
|
|
}
|
|
|
|
uint8_t* allocate(size_t type_id, size_t count)
|
|
{
|
|
uint8_t* mem = nullptr;
|
|
size_t size = type_size(type_id) * count;
|
|
if(size > 0) {
|
|
mem = reinterpret_cast<uint8_t*>(malloc(size));
|
|
if(mem != nullptr) {
|
|
memset(mem, 0, size);
|
|
}
|
|
return mem;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
extern "C" Reference acquire(size_t type_id)
|
|
{
|
|
Reference addr {0};
|
|
addr.address = allocate(type_id, 1);
|
|
if(addr.address != nullptr) {
|
|
addr.type = type_id;
|
|
}
|
|
return addr;
|
|
}
|
|
|
|
void drop(Reference addr)
|
|
{
|
|
if(addr.address != nullptr) {
|
|
switch(type_key(addr.type)) {
|
|
case Type::Tag::Varying: {
|
|
varying_clear(addr);
|
|
} break;
|
|
|
|
case Type::Tag::Sequence: {
|
|
sequence_clear(addr);
|
|
} break;
|
|
|
|
case Type::Tag::List: {
|
|
list_clear(addr);
|
|
} break;
|
|
|
|
case Type::Tag::Sparse: {
|
|
sparse_clear(addr);
|
|
} break;
|
|
|
|
case Type::Tag::Record: {
|
|
size_t schema_id = type_innerkey(addr.type);
|
|
auto binding = DB_SCHEMA.get(schema_id);
|
|
if(binding != nullptr) {
|
|
for(size_t i = 0; i < binding->data.size(); ++i) {
|
|
auto cell = record_cell(addr, i);
|
|
drop(cell);
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case Type::Tag::Schema: {
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
rawlist_clear(object.data);
|
|
rawlist_clear(object.map);
|
|
} break;
|
|
}
|
|
memset(addr.address, 0, type_size(addr.type));
|
|
}
|
|
}
|
|
|
|
extern "C" void release(Reference addr)
|
|
{
|
|
if(addr.address != nullptr) {
|
|
drop(addr);
|
|
free(addr.address);
|
|
}
|
|
}
|
|
|
|
extern "C" bool copy(Reference dst, Reference src)
|
|
{
|
|
if(src.address != dst.address) {
|
|
Reference source = src;
|
|
Reference destination = dst;
|
|
|
|
// dereference varying data
|
|
if(type_key(src.type) == Type::Tag::Varying) {
|
|
source = *reinterpret_cast<Reference*>(src.address);
|
|
}
|
|
|
|
// prepare destination for varying data
|
|
if(type_key(dst.type) == Type::Tag::Varying) {
|
|
auto& dest_ref = *reinterpret_cast<Reference*>(dst.address);
|
|
|
|
// determine if memory can be reused, otherwise free and reallocate
|
|
if(source.type != dest_ref.type) {
|
|
if(dest_ref.address != nullptr) {
|
|
free(dest_ref.address);
|
|
dest_ref.type = Type::Tag::Null;
|
|
dest_ref.address = nullptr;
|
|
}
|
|
dest_ref = acquire(source.type);
|
|
}
|
|
}
|
|
|
|
// copy data into destination
|
|
if(source.type == destination.type) {
|
|
drop(destination);
|
|
|
|
switch(type_key(destination.type)) {
|
|
case Type::Tag::Null: { } break;
|
|
|
|
case Type::Tag::Sequence: {
|
|
auto& src_seq = *reinterpret_cast<Type::Sequence*>(source.address);
|
|
auto& dst_seq = *reinterpret_cast<Type::Sequence*>(destination.address);
|
|
|
|
rawlist_clear(dst_seq.data);
|
|
rawlist_reserve(dst_seq.data, sizeof(uint8_t), src_seq.data.length);
|
|
memcpy(dst_seq.data.data, src_seq.data.data, sizeof(uint8_t) * src_seq.data.length);
|
|
dst_seq.data.length = src_seq.data.length;
|
|
} break;
|
|
|
|
case Type::Tag::Array: {
|
|
for(size_t i = 0; i < array_length(source); ++i) {
|
|
copy(array_cell(destination, i), array_cell(source, i));
|
|
}
|
|
} break;
|
|
|
|
case Type::Tag::List: {
|
|
auto& src_list = *reinterpret_cast<Type::List*>(source.address);
|
|
auto& dst_list = *reinterpret_cast<Type::List*>(destination.address);
|
|
|
|
rawlist_reserve(dst_list.data, type_size(type_inner(source.type)), src_list.data.capacity);
|
|
dst_list.data.length = src_list.data.length;
|
|
|
|
for(size_t i = 0; i < src_list.data.length; ++i) {
|
|
copy(list_at(destination, i), list_at(source, i));
|
|
}
|
|
} break;
|
|
|
|
case Type::Tag::Sparse: {
|
|
auto& src_list = *reinterpret_cast<Type::Sparse*>(source.address);
|
|
auto& dst_list = *reinterpret_cast<Type::Sparse*>(destination.address);
|
|
|
|
rawlist_reserve(dst_list.header, sizeof(Type::SparseHeader), src_list.header.capacity);
|
|
dst_list.header.length = src_list.header.length;
|
|
|
|
for(size_t i = 0; i < src_list.header.length; ++i) {
|
|
Type::SparseHeader& src_header = *reinterpret_cast<Type::SparseHeader*>(rawlist_cell(src_list.header, sizeof(Type::SparseHeader), i));
|
|
Type::SparseHeader& dst_header = *reinterpret_cast<Type::SparseHeader*>(rawlist_cell(dst_list.header, sizeof(Type::SparseHeader), i));
|
|
dst_header = src_header;
|
|
}
|
|
|
|
rawlist_reserve(dst_list.data, type_size(type_inner(source.type)), src_list.data.capacity);
|
|
dst_list.data.length = src_list.data.length;
|
|
|
|
for(size_t i = 0; i < src_list.data.length; ++i) {
|
|
copy(list_at(destination, i), list_at(source, i));
|
|
}
|
|
} break;
|
|
|
|
case Type::Tag::Record: {
|
|
size_t schema_id = type_innerkey(source.type);
|
|
auto binding = DB_SCHEMA.get(schema_id);
|
|
if(binding != nullptr) {
|
|
for(size_t i = 0; i < binding->data.size(); ++i) {
|
|
auto src_cell = record_cell(source, i);
|
|
auto dst_cell = record_cell(destination, i);
|
|
copy(dst_cell, src_cell);
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case Type::Tag::Schema: {
|
|
auto& src_schema = *reinterpret_cast<Type::Schema*>(source.address);
|
|
auto& dst_schema = *reinterpret_cast<Type::Schema*>(destination.address);
|
|
|
|
rawlist_clear(dst_schema.data);
|
|
rawlist_clear(dst_schema.map);
|
|
rawlist_reserve(dst_schema.data, sizeof(size_t), src_schema.data.length);
|
|
rawlist_reserve(dst_schema.map, sizeof(size_t), src_schema.map.length);
|
|
|
|
for(size_t i = 0; i < src_schema.data.length; ++i) {
|
|
auto src_cell = reinterpret_cast<size_t*>(rawlist_cell(src_schema.data, sizeof(size_t), i));
|
|
auto dst_cell = reinterpret_cast<size_t*>(rawlist_cell(dst_schema.data, sizeof(size_t), i));
|
|
if(src_cell != nullptr && dst_cell != nullptr) {
|
|
*dst_cell = *src_cell;
|
|
}
|
|
}
|
|
|
|
for(size_t i = 0; i < src_schema.map.length; ++i) {
|
|
auto src_cell = reinterpret_cast<size_t*>(rawlist_cell(src_schema.map, sizeof(size_t), i));
|
|
auto dst_cell = reinterpret_cast<size_t*>(rawlist_cell(dst_schema.map, sizeof(size_t), i));
|
|
if(src_cell != nullptr && dst_cell != nullptr) {
|
|
*dst_cell = *src_cell;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
default: {
|
|
memcpy(destination.address, source.address, type_size(source.type));
|
|
} break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
extern "C" bool transfer(Reference dst, Reference src)
|
|
{
|
|
if(src.address != dst.address && src.type != 0 && dst.type != 0) {
|
|
Reference source = src;
|
|
Reference destination = dst;
|
|
|
|
// dereference varying data
|
|
if(type_key(src.type) == Type::Tag::Varying) {
|
|
source = *reinterpret_cast<Reference*>(src.address);
|
|
}
|
|
|
|
// prepare destination for varying data
|
|
if(type_key(dst.type) == Type::Tag::Varying) {
|
|
auto& dest_ref = *reinterpret_cast<Reference*>(dst.address);
|
|
|
|
// determine if memory can be reused, otherwise free and reallocate
|
|
if(source.type != dest_ref.type) {
|
|
if(dest_ref.address != nullptr) {
|
|
free(dest_ref.address);
|
|
dest_ref.type = Type::Tag::Null;
|
|
dest_ref.address = nullptr;
|
|
}
|
|
dest_ref = acquire(source.type);
|
|
}
|
|
}
|
|
|
|
// copy data into destination
|
|
if(source.type == destination.type) {
|
|
drop(destination);
|
|
memcpy(destination.address, source.address, type_size(source.type));
|
|
memset(source.address, 0, type_size(source.type));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Reference resolve_addr(Reference addr)
|
|
{
|
|
Reference result = addr;
|
|
if(result.type == Type::Tag::Null) {
|
|
if(result.address != nullptr) {
|
|
result = *reinterpret_cast<Reference*>(result.address);
|
|
}
|
|
else {
|
|
result = Reference {0};
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// Varying //
|
|
|
|
extern "C" Reference varying_get(Reference addr)
|
|
{
|
|
Reference result {0};
|
|
result = *reinterpret_cast<Reference*>(addr.address);
|
|
return result;
|
|
}
|
|
|
|
extern "C" void varying_set(Reference addr, Reference source)
|
|
{
|
|
Reference& var = *reinterpret_cast<Reference*>(addr.address);
|
|
|
|
if(var.address != nullptr) {
|
|
drop(var);
|
|
}
|
|
|
|
if(var.type != source.type || var.address == nullptr) {
|
|
if(var.address != nullptr) {
|
|
free(var.address);
|
|
}
|
|
var.type = source.type;
|
|
var.address = allocate(source.type, 1);
|
|
}
|
|
|
|
copy(var, source);
|
|
}
|
|
|
|
extern "C" void varying_clear(Reference addr)
|
|
{
|
|
Reference& var = *reinterpret_cast<Reference*>(addr.address);
|
|
|
|
if(var.address != nullptr) {
|
|
drop(var);
|
|
free(var.address);
|
|
}
|
|
var.type = 0;
|
|
var.address = nullptr;
|
|
}
|
|
|
|
|
|
// Boolean //
|
|
|
|
extern "C" void bool_set(Reference addr, Type::Boolean value)
|
|
{
|
|
*(reinterpret_cast<Type::Boolean*>(addr.address)) = value;
|
|
}
|
|
|
|
extern "C" Type::Boolean bool_get(Reference addr)
|
|
{
|
|
return *(reinterpret_cast<Type::Boolean*>(addr.address));
|
|
}
|
|
|
|
|
|
// Natural //
|
|
|
|
extern "C" void natural_set(Reference addr, Type::Natural value)
|
|
{
|
|
*(reinterpret_cast<Type::Natural*>(addr.address)) = value;
|
|
}
|
|
|
|
extern "C" Type::Natural natural_get(Reference addr)
|
|
{
|
|
return *(reinterpret_cast<Type::Natural*>(addr.address));
|
|
}
|
|
|
|
|
|
// Integer //
|
|
|
|
extern "C" void integer_set(Reference addr, Type::Integer value)
|
|
{
|
|
*(reinterpret_cast<Type::Integer*>(addr.address)) = value;
|
|
}
|
|
|
|
extern "C" Type::Integer integer_get(Reference addr)
|
|
{
|
|
return *(reinterpret_cast<Type::Integer*>(addr.address));
|
|
}
|
|
|
|
|
|
// Significant //
|
|
|
|
extern "C" void significant_set(Reference addr, Type::Significant value)
|
|
{
|
|
*(reinterpret_cast<Type::Significant*>(addr.address)) = value;
|
|
}
|
|
|
|
extern "C" Type::Significant significant_get(Reference addr)
|
|
{
|
|
return *(reinterpret_cast<Type::Significant*>(addr.address));
|
|
}
|
|
|
|
|
|
// Decimal //
|
|
|
|
extern "C" void decimal_set(Reference addr, Type::Decimal value)
|
|
{
|
|
*(reinterpret_cast<Type::Decimal*>(addr.address)) = value;
|
|
}
|
|
|
|
extern "C" Type::Decimal decimal_get(Reference addr)
|
|
{
|
|
return *(reinterpret_cast<Type::Decimal*>(addr.address));
|
|
}
|
|
|
|
|
|
// Block //
|
|
|
|
extern "C" size_t block_length(Reference addr)
|
|
{
|
|
return type_innerkey(addr.type);
|
|
}
|
|
|
|
extern "C" uint8_t block_get(Reference addr, size_t index)
|
|
{
|
|
size_t length = type_innerkey(addr.type);
|
|
if(index < length) {
|
|
return reinterpret_cast<uint8_t*>(addr.address)[index];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" uint64_t block_get_natural(Reference addr)
|
|
{
|
|
size_t length = type_innerkey(addr.type);
|
|
uint8_t* data = reinterpret_cast<uint8_t*>(addr.address);
|
|
uint64_t result = 0;
|
|
|
|
for(size_t i = 0; i < length; ++i) {
|
|
result <<= 8;
|
|
result |= data[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
extern "C" int64_t block_get_integer(Reference addr)
|
|
{
|
|
size_t length = type_innerkey(addr.type);
|
|
uint8_t* data = reinterpret_cast<uint8_t*>(addr.address);
|
|
int64_t result = 0;
|
|
|
|
for(size_t i = 0; i < length; ++i) {
|
|
result <<= 8;
|
|
result |= data[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
extern "C" uint64_t block_get_field(Reference addr, size_t index, size_t length)
|
|
{
|
|
size_t data_length = type_innerkey(addr.type);
|
|
size_t byte_start = index >> 3;
|
|
size_t bit_offset = index & 0x07;
|
|
size_t byte_length = 1 + ((bit_offset + length) >> 3);
|
|
size_t byte_end = byte_start + byte_length;
|
|
size_t mask_offset = ((8 * byte_length) - (length + bit_offset));
|
|
|
|
uint64_t mask = ((1 << length) - 1) << mask_offset;
|
|
uint64_t bits = 0;
|
|
|
|
uint8_t* data = reinterpret_cast<uint8_t*>(addr.address);
|
|
|
|
size_t i = byte_start;
|
|
for(; i < data_length && i < byte_end; ++i) {
|
|
bits <<= 8;
|
|
bits |= data[i];
|
|
}
|
|
for(; i < byte_end; ++i) {
|
|
bits <<= 8;
|
|
}
|
|
|
|
return (bits & mask) >> mask_offset;
|
|
}
|
|
|
|
extern "C" void block_set(Reference addr, size_t index, uint8_t value)
|
|
{
|
|
size_t length = type_innerkey(addr.type);
|
|
if(index < length) {
|
|
reinterpret_cast<uint8_t*>(addr.address)[index] = value;
|
|
}
|
|
}
|
|
|
|
extern "C" void block_set_natural(Reference addr, uint64_t data)
|
|
{
|
|
size_t length = type_innerkey(addr.type);
|
|
uint8_t* dest = reinterpret_cast<uint8_t*>(addr.address);
|
|
|
|
for(size_t i = length; i > 0; --i) {
|
|
dest[i - 1] = data & 0xFF;
|
|
data >>= 8;
|
|
}
|
|
}
|
|
|
|
extern "C" void block_set_integer(Reference addr, int64_t data)
|
|
{
|
|
size_t length = type_innerkey(addr.type);
|
|
uint8_t* dest = reinterpret_cast<uint8_t*>(addr.address);
|
|
|
|
for(size_t i = length; i > 0; --i) {
|
|
dest[i - 1] = data & 0xFF;
|
|
data >>= 8;
|
|
}
|
|
}
|
|
|
|
extern "C" void block_set_field(Reference addr, size_t index, size_t length, uint64_t value)
|
|
{
|
|
size_t data_length = type_innerkey(addr.type);
|
|
size_t byte_start = index >> 3;
|
|
size_t bit_offset = index & 0x07;
|
|
size_t byte_length = 1 + ((bit_offset + length) >> 3);
|
|
size_t byte_end = byte_start + byte_length;
|
|
size_t mask_offset = ((8 * byte_length) - (length + bit_offset));
|
|
|
|
uint64_t mask = ((1 << length) - 1) << mask_offset;
|
|
uint64_t bits = 0;
|
|
|
|
uint8_t* data = reinterpret_cast<uint8_t*>(addr.address);
|
|
|
|
size_t byte_index = byte_start;
|
|
for(; byte_index < data_length && byte_index < byte_end; ++byte_index) {
|
|
bits <<= 8;
|
|
bits |= data[byte_index];
|
|
}
|
|
for(; byte_index < byte_end; ++byte_index) {
|
|
bits <<= 8;
|
|
}
|
|
|
|
bits &= ~mask;
|
|
bits |= mask & (value << mask_offset);
|
|
|
|
for(; byte_index > data_length; --byte_index) {
|
|
bits >>= 8;
|
|
}
|
|
for(; byte_index > byte_start; --byte_index) {
|
|
data[byte_index - 1] = bits & 0xFF;
|
|
bits >>= 8;
|
|
}
|
|
}
|
|
|
|
|
|
// Sequence //
|
|
|
|
extern "C" size_t sequence_capacity(Reference addr)
|
|
{
|
|
Type::Sequence& seq = *reinterpret_cast<Type::Sequence*>(addr.address);
|
|
return seq.data.capacity;
|
|
}
|
|
|
|
extern "C" size_t sequence_length(Reference addr)
|
|
{
|
|
Type::Sequence& seq = *reinterpret_cast<Type::Sequence*>(addr.address);
|
|
return seq.data.length;
|
|
}
|
|
|
|
extern "C" uint8_t sequence_get(Reference addr, size_t index)
|
|
{
|
|
Type::Sequence& seq = *reinterpret_cast<Type::Sequence*>(addr.address);
|
|
if(index < seq.data.length) {
|
|
return *reinterpret_cast<uint8_t*>(rawlist_cell(seq.data, 1, index));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" void sequence_clear(Reference addr)
|
|
{
|
|
Type::Sequence& seq = *reinterpret_cast<Type::Sequence*>(addr.address);
|
|
rawlist_clear(seq.data);
|
|
}
|
|
|
|
extern "C" void sequence_set(Reference addr, size_t index, uint8_t value)
|
|
{
|
|
Type::Sequence& seq = *reinterpret_cast<Type::Sequence*>(addr.address);
|
|
auto cell = reinterpret_cast<uint8_t*>(rawlist_cell(seq.data, 1, index));
|
|
if(cell != nullptr) {
|
|
*cell = value;
|
|
}
|
|
}
|
|
|
|
extern "C" void sequence_insert(Reference addr, size_t index, uint8_t value)
|
|
{
|
|
Type::Sequence& seq = *reinterpret_cast<Type::Sequence*>(addr.address);
|
|
auto cell = reinterpret_cast<uint8_t*>(rawlist_insert(seq.data, 1, index));
|
|
if(cell != nullptr) {
|
|
*cell = value;
|
|
}
|
|
}
|
|
|
|
extern "C" void sequence_reserve(Reference addr, size_t capacity)
|
|
{
|
|
Type::Sequence& seq = *reinterpret_cast<Type::Sequence*>(addr.address);
|
|
rawlist_reserve(seq.data, 1, capacity);
|
|
}
|
|
|
|
|
|
// Array //
|
|
|
|
extern "C" size_t array_length(Reference addr)
|
|
{
|
|
return type_innerkey(addr.type);
|
|
}
|
|
|
|
Reference array_cell(Reference addr, size_t index)
|
|
{
|
|
Reference result {0};
|
|
size_t length_n = type_inner(addr.type);
|
|
size_t length = type_key(length_n);
|
|
size_t type = type_inner(length_n);
|
|
size_t offset = type_size(type);
|
|
|
|
// validate for overflow
|
|
if(addr.address != nullptr && offset > 0 && index < length) {
|
|
result.type = type;
|
|
result.address = addr.address + (offset * index);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
extern "C" Reference array_at(Reference addr, size_t index)
|
|
{
|
|
Reference result {0};
|
|
Reference cell = array_cell(addr, index);
|
|
if(cell.address != nullptr) {
|
|
if(type_key(cell.type) == Type::Tag::Varying) {
|
|
result = varying_get(cell);
|
|
}
|
|
else {
|
|
result = cell;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
extern "C" void array_update(Reference addr, size_t index, Reference source)
|
|
{
|
|
Reference cell = array_cell(addr, index);
|
|
if(type_key(cell.type) == Type::Tag::Varying) {
|
|
varying_set(cell, source);
|
|
}
|
|
else {
|
|
copy(cell, source);
|
|
}
|
|
}
|
|
|
|
|
|
// List //
|
|
|
|
extern "C" size_t list_capacity(Reference addr)
|
|
{
|
|
return (*reinterpret_cast<Type::List*>(addr.address)).data.capacity;
|
|
}
|
|
|
|
extern "C" size_t list_length(Reference addr)
|
|
{
|
|
return (*reinterpret_cast<Type::List*>(addr.address)).data.length;
|
|
}
|
|
|
|
Reference list_cell(Reference addr, size_t index)
|
|
{
|
|
Reference result {0};
|
|
Type::List& list = *reinterpret_cast<Type::List*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
size_t offset = type_size(inner);
|
|
|
|
// validate for overflow
|
|
if(list.data.data != nullptr && offset > 0 && index < list.data.capacity) {
|
|
result.type = inner;
|
|
result.address = rawlist_cell(list.data, offset, index);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
extern "C" Reference list_at(Reference addr, size_t index)
|
|
{
|
|
Reference result {0};
|
|
Reference cell = list_cell(addr, index);
|
|
|
|
if(cell.address != nullptr) {
|
|
if(type_key(cell.type) == Type::Tag::Varying) {
|
|
result = *reinterpret_cast<Reference*>(cell.address);
|
|
} else {
|
|
result = cell;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
extern "C" void list_clear(Reference addr)
|
|
{
|
|
Type::List& list = *reinterpret_cast<Type::List*>(addr.address);
|
|
for(size_t i = 0; i < list.data.length; ++i) {
|
|
drop(list_cell(addr, i));
|
|
}
|
|
rawlist_clear(list.data);
|
|
}
|
|
|
|
extern "C" void list_insert(Reference addr, size_t index, Reference source)
|
|
{
|
|
auto& list = (*reinterpret_cast<Type::List*>(addr.address));
|
|
size_t inner = type_inner(addr.type);
|
|
size_t offset = type_size(inner);
|
|
|
|
if(index > list.data.length) { index = list.data.length; }
|
|
|
|
Reference cell {0};
|
|
cell.type = inner;
|
|
cell.address = rawlist_insert(list.data, offset, index);
|
|
|
|
if(type_key(inner) == Type::Tag::Varying) {
|
|
varying_set(cell, source);
|
|
}
|
|
else {
|
|
copy(cell, source);
|
|
}
|
|
}
|
|
|
|
extern "C" void list_prepend(Reference addr, Reference source)
|
|
{
|
|
list_insert(addr, 0, source);
|
|
}
|
|
|
|
extern "C" void list_append(Reference addr, Reference source)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::List*>(addr.address);
|
|
list_insert(addr, list.data.length, source);
|
|
}
|
|
|
|
extern "C" void list_update(Reference addr, size_t index, Reference source)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::List*>(addr.address);
|
|
if(index < list.data.length) {
|
|
size_t inner = type_inner(addr.type);
|
|
|
|
if(type_key(inner) == Type::Tag::Varying) {
|
|
varying_set(list_cell(addr, index), source);
|
|
}
|
|
else {
|
|
copy(list_cell(addr, index), source);
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" void list_remove(Reference addr, size_t index)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::List*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
size_t offset = type_size(inner);
|
|
if(index < list.data.length) {
|
|
drop(list_at(addr, index));
|
|
rawlist_remove(list.data, offset, index);
|
|
}
|
|
}
|
|
|
|
extern "C" void list_reserve(Reference addr, size_t capacity)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::List*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
size_t offset = type_size(inner);
|
|
|
|
rawlist_reserve(list.data, offset, capacity);
|
|
}
|
|
|
|
|
|
// Sparse //
|
|
|
|
extern "C" size_t sparse_header_length(Reference addr)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
return list.header.length;
|
|
}
|
|
|
|
extern "C" Type::SparseHeader sparse_header_data(Reference addr, size_t index)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
Type::SparseHeader header {0};
|
|
|
|
if(index < list.header.length) {
|
|
header = *reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), index));
|
|
}
|
|
|
|
return header;
|
|
}
|
|
|
|
extern "C" size_t sparse_length(Reference addr)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
return list.data.length;
|
|
}
|
|
|
|
extern "C" void sparse_clear(Reference addr)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
|
|
Reference ref {0};
|
|
ref.type = inner;
|
|
|
|
for(size_t i = 0; i < list.data.length; ++i) {
|
|
ref.address = rawlist_cell(list.data, type_size(inner), i);
|
|
drop(ref);
|
|
}
|
|
|
|
rawlist_clear(list.data);
|
|
rawlist_clear(list.header);
|
|
}
|
|
|
|
extern "C" size_t sparse_first(Reference addr)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
|
|
if(list.header.length > 0) {
|
|
auto cell = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), 0));
|
|
if(cell != nullptr) {
|
|
return cell->start;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" size_t sparse_next(Reference addr)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
|
|
if(list.header.length > 0) {
|
|
auto cell = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), 0));
|
|
if(cell != nullptr) {
|
|
return cell->start + cell->length;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" size_t sparse_last(Reference addr)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
|
|
if(list.header.length > 0) {
|
|
auto cell = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), list.header.length - 1));
|
|
if(cell != nullptr) {
|
|
return cell->start + cell->length - 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" Reference sparse_at(Reference addr, size_t index)
|
|
{
|
|
Reference result {0};
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
|
|
if(index < list.data.length) {
|
|
auto cell = rawlist_cell(list.data, type_size(inner), index);
|
|
if(cell != nullptr) {
|
|
result.type = inner;
|
|
result.address = cell;
|
|
}
|
|
|
|
if(type_key(inner) == Type::Tag::Varying) {
|
|
result = varying_get(result);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
extern "C" Reference sparse_get(Reference addr, size_t index)
|
|
{
|
|
Reference result {0};
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
|
|
size_t bound_lower = 0;
|
|
size_t bound_upper = list.header.length;
|
|
size_t header_index = 0;
|
|
Type::SparseHeader* header = nullptr;
|
|
|
|
while(bound_lower != bound_upper) {
|
|
header_index = bound_lower + ((bound_upper - bound_lower) / 2);
|
|
header = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), header_index));
|
|
|
|
if(index >= header->start && index < (header->start + header->length)) {
|
|
break;
|
|
}
|
|
else if(index < header->start) {
|
|
bound_upper = header_index;
|
|
}
|
|
else {
|
|
bound_lower = header_index + 1;
|
|
}
|
|
|
|
header = nullptr;
|
|
}
|
|
|
|
if(header != nullptr) {
|
|
result.type = inner;
|
|
size_t data_index = header->index + (index - header->start);
|
|
result.address = rawlist_cell(list.data, type_size(inner), data_index);
|
|
|
|
if(type_key(result.type) == Type::Tag::Varying) {
|
|
result = varying_get(result);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
extern "C" void sparse_set(Reference addr, size_t index, Reference source)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
|
|
size_t header_index = 0;
|
|
Type::SparseHeader* header = nullptr;
|
|
for(; header_index < list.header.length; ++header_index) {
|
|
header = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), header_index));
|
|
if(index <= (header->start + header->length)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
Type::SparseHeader header_new;
|
|
|
|
Reference new_data {0};
|
|
new_data.type = inner;
|
|
|
|
if(header_index == list.header.length) {
|
|
// append header to end
|
|
header_new.start = index;
|
|
header_new.length = 1;
|
|
header_new.index = list.data.length;
|
|
|
|
new_data.address = rawlist_insert(list.data, type_size(inner), list.data.length);
|
|
copy(new_data, source);
|
|
|
|
auto& h_cell = *reinterpret_cast<Type::SparseHeader*>(rawlist_insert(list.header, sizeof(Type::SparseHeader), list.header.length));
|
|
h_cell = header_new;
|
|
} else {
|
|
if(index < header->start) {
|
|
// insert header before current
|
|
header_new.start = index;
|
|
header_new.length = 1;
|
|
header_new.index = header->index;
|
|
|
|
new_data.address = rawlist_insert(list.data, type_size(inner), header->index);
|
|
copy(new_data, source);
|
|
|
|
header = reinterpret_cast<Type::SparseHeader*>(rawlist_insert(list.header, sizeof(Type::SparseHeader), header_index));
|
|
*header = header_new;
|
|
|
|
for(size_t i = header_index + 1; i < list.header.length; ++i) {
|
|
auto hcell = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), i));
|
|
hcell->index++;
|
|
}
|
|
} else {
|
|
size_t offset = index - header->start;
|
|
if(offset < header->length) {
|
|
// update existing value
|
|
new_data.address = rawlist_cell(list.data, type_size(inner), header->index + offset);
|
|
drop(new_data);
|
|
copy(new_data, source);
|
|
} else {
|
|
// append value to current
|
|
new_data.address = rawlist_insert(list.data, type_size(inner), header->index + offset);
|
|
copy(new_data, source);
|
|
header->length++;
|
|
|
|
for(size_t i = header_index + 1; i < list.header.length; ++i) {
|
|
auto hcell = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), i));
|
|
hcell->index++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// join headers if ranges intersect
|
|
if(header_index + 1 < list.header.length) {
|
|
auto next_header = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), header_index + 1));
|
|
if(next_header->start == header->start + header->length) {
|
|
header->length += next_header->length;
|
|
rawlist_remove(list.header, sizeof(Type::SparseHeader), header_index + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" void sparse_unset(Reference addr, size_t index)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
size_t inner = type_inner(addr.type);
|
|
|
|
size_t header_index = 0;
|
|
Type::SparseHeader* header = nullptr;
|
|
for(; header_index < list.header.length; ++header_index) {
|
|
header = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), header_index));
|
|
if(index <= (header->start + header->length)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
Type::SparseHeader header_new;
|
|
|
|
Reference cell {0};
|
|
cell.type = inner;
|
|
|
|
if(header_index < list.header.length && index >= header->start) {
|
|
size_t offset = index - header->start;
|
|
size_t data_index = header->index + offset;
|
|
if(offset == 0) {
|
|
// shift start of range
|
|
header->start++;
|
|
} else if(offset < header->length - 1) {
|
|
// split header at index
|
|
header_new.start = index + 1;
|
|
header_new.length = header->length - offset - 1;
|
|
header_new.index = header->index + offset + 1;
|
|
header->length = offset + 1;
|
|
|
|
auto header_insert = reinterpret_cast<Type::SparseHeader*>(rawlist_insert(list.header, sizeof(Type::SparseHeader), header_index + 1));
|
|
*header_insert = header_new;
|
|
}
|
|
|
|
cell.address = rawlist_cell(list.data, type_size(inner), data_index);
|
|
drop(cell);
|
|
rawlist_remove(list.data, type_size(inner), data_index);
|
|
header->length--;
|
|
|
|
for(size_t i = header_index + 1; i < list.header.length; ++i) {
|
|
auto hcell = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), i));
|
|
hcell->index--;
|
|
}
|
|
|
|
if(header->length == 0) {
|
|
rawlist_remove(list.header, sizeof(Type::SparseHeader), header_index);
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" size_t sparse_indexof(Reference addr, size_t index)
|
|
{
|
|
auto& list = *reinterpret_cast<Type::Sparse*>(addr.address);
|
|
|
|
for(size_t i = 0; i < list.header.length; ++i) {
|
|
auto hcell = reinterpret_cast<Type::SparseHeader*>(rawlist_cell(list.header, sizeof(Type::SparseHeader), i));
|
|
|
|
if(index < hcell->length) {
|
|
return hcell->start + index;
|
|
} else {
|
|
index -= hcell->length;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Record //
|
|
|
|
extern "C" size_t record_length(Reference addr)
|
|
{
|
|
auto binding = DB_SCHEMA.get(type_innerkey(addr.type));
|
|
if(binding != nullptr) {
|
|
return binding->data.size();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" size_t record_type(Reference addr, size_t index)
|
|
{
|
|
auto binding = DB_SCHEMA.get(type_innerkey(addr.type));
|
|
if(binding != nullptr && index < binding->data.size()) {
|
|
return binding->data[index].type;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Reference record_cell(Reference addr, size_t index)
|
|
{
|
|
Reference result {0};
|
|
auto binding = DB_SCHEMA.get(type_innerkey(addr.type));
|
|
if(binding != nullptr) {
|
|
if(index < binding->data.size()) {
|
|
result.type = binding->data[index].type;
|
|
result.address = addr.address + binding->data[index].offset;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
extern "C" Reference record_at(Reference addr, size_t index)
|
|
{
|
|
Reference result = record_cell(addr, index);
|
|
if(type_key(result.type) == Type::Tag::Varying) {
|
|
result = varying_get(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
extern "C" void record_update(Reference addr, size_t index, Reference source)
|
|
{
|
|
Reference destination {0};
|
|
size_t schid = type_innerkey(addr.type);
|
|
auto binding = DB_SCHEMA.get(schid);
|
|
if(binding != nullptr) {
|
|
if(index < binding->data.size()) {
|
|
destination.type = binding->data[index].type;
|
|
destination.address = addr.address + binding->data[index].offset;
|
|
copy(destination, source);
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" size_t record_keyof(Reference addr, size_t index)
|
|
{
|
|
Reference destination {0};
|
|
auto binding = DB_SCHEMA.get(type_innerkey(addr.type));
|
|
if(binding != nullptr) {
|
|
if(index < binding->data.size()) {
|
|
return binding->data[index].key;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" size_t record_indexof(Reference addr, size_t key)
|
|
{
|
|
Reference destination {0};
|
|
auto binding = DB_SCHEMA.get(type_innerkey(addr.type));
|
|
if(binding != nullptr) {
|
|
auto result = binding->map.get(key);
|
|
if(result != nullptr) {
|
|
return *result;
|
|
}
|
|
return binding->data.size();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Schema //
|
|
|
|
extern "C" size_t schema_length(Reference addr)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
return object.data.length;
|
|
}
|
|
|
|
extern "C" size_t schema_insert(Reference addr, size_t index, size_t type_id)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
if(index >= object.data.length) {
|
|
index = object.data.length;
|
|
}
|
|
void* cell = rawlist_insert(object.data, sizeof(size_t), index);
|
|
*reinterpret_cast<size_t*>(cell) = type_id;
|
|
return index;
|
|
}
|
|
|
|
extern "C" void schema_update(Reference addr, size_t index, size_t type_id)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
if(index < object.data.length) {
|
|
auto cell = reinterpret_cast<size_t*>(rawlist_cell(object.data, sizeof(size_t), index));
|
|
if(cell != nullptr) {
|
|
*cell = type_id;
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" size_t schema_get(Reference addr, size_t index)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
if(index < object.data.length) {
|
|
auto cell = reinterpret_cast<size_t*>(rawlist_cell(object.data, sizeof(size_t), index));
|
|
if(cell != nullptr) {
|
|
return *cell;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" void schema_remove(Reference addr, size_t index)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
if(index < object.data.length) {
|
|
rawlist_remove(object.data, sizeof(size_t), index);
|
|
|
|
// remove mapping
|
|
for(size_t i = 0; i < object.map.length; i++) {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_cell(object.data, sizeof(Type::Schema::Mapping), i));
|
|
if(cell != nullptr) {
|
|
if(cell->index == index) {
|
|
rawlist_remove(object.map, sizeof(Type::Schema::Mapping), i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" void schema_clear(Reference addr)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
rawlist_clear(object.data);
|
|
rawlist_clear(object.map);
|
|
}
|
|
|
|
extern "C" void schema_map(Reference addr, size_t key, size_t index)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
if(index < object.data.length) {
|
|
size_t find_index = 0;
|
|
for(; find_index < object.map.length; find_index++) {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_cell(object.map, sizeof(Type::Schema::Mapping), find_index));
|
|
if(cell != nullptr) {
|
|
if(cell->key == key) { break; }
|
|
}
|
|
}
|
|
|
|
// if key is not found, add new mapping
|
|
if(find_index == object.map.length) {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_insert(object.map, sizeof(Type::Schema::Mapping), object.map.length));
|
|
cell->key = key;
|
|
cell->index = index;
|
|
}
|
|
// otherwise, update existing key
|
|
else {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_cell(object.map, sizeof(Type::Schema::Mapping), find_index));
|
|
cell->index = index;
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" void schema_unmap(Reference addr, size_t key)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
for(size_t i; i < object.map.length; ++i) {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_cell(object.map, sizeof(Type::Schema::Mapping), i));
|
|
if(cell != nullptr) {
|
|
if(cell->key == key) {
|
|
rawlist_remove(object.map, sizeof(Type::Schema::Mapping), i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" size_t schema_indexof(Reference addr, size_t key)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
for(size_t i = 0; i < object.map.length; i++) {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_cell(object.map, sizeof(Type::Schema::Mapping), i));
|
|
if(cell != nullptr) {
|
|
if(cell->key == key) {
|
|
return cell->index;
|
|
}
|
|
}
|
|
}
|
|
return object.data.length;
|
|
}
|
|
|
|
extern "C" size_t schema_keyof(Reference addr, size_t index)
|
|
{
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
for(size_t i = 0; i < object.map.length; i++) {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_cell(object.map, sizeof(Type::Schema::Mapping), i));
|
|
if(cell != nullptr) {
|
|
if(cell->index == index) {
|
|
return cell->key;
|
|
}
|
|
}
|
|
}
|
|
return object.data.length;
|
|
}
|
|
|
|
extern "C" size_t schema_bind(Reference addr, size_t id)
|
|
{
|
|
if(id > 0) {
|
|
Type::SchemaBinding binding {0};
|
|
auto& object = (*reinterpret_cast<Type::Schema*>(addr.address));
|
|
|
|
// prepare binding
|
|
binding.binding = id;
|
|
for(size_t i = 0; i < object.data.length; ++i) {
|
|
Type::SchemaBinding::Row row {0};
|
|
|
|
size_t type_id = *reinterpret_cast<size_t*>(rawlist_cell(object.data, sizeof(size_t), i));
|
|
size_t size = type_size(type_id);
|
|
|
|
// fail if size is not valid
|
|
if(size == 0) { return 0; }
|
|
|
|
size_t alignment = type_alignment(type_id);
|
|
binding.alignment = std::max(alignment, binding.alignment);
|
|
size_t position = ((binding.size + (alignment - 1)) & ~(alignment - 1));
|
|
binding.size = size + position;
|
|
|
|
row.type = type_id;
|
|
row.offset = position;
|
|
binding.data.push_back(row);
|
|
}
|
|
binding.size = ((binding.size + (binding.alignment - 1)) & ~(binding.alignment - 1));
|
|
binding.references = 0;
|
|
|
|
for(size_t i = 0; i < object.map.length; ++i) {
|
|
auto cell = reinterpret_cast<Type::Schema::Mapping*>(rawlist_cell(object.map, sizeof(Type::Schema::Mapping), i));
|
|
binding.map.set(cell->key, cell->index);
|
|
binding.data[cell->index].key = cell->key;
|
|
}
|
|
|
|
/* printf("[Binding]\n");
|
|
printf(" Id: %zu\n", binding.binding);
|
|
printf(" Size: %zu\n", binding.size);
|
|
printf(" Align: %zu\n", binding.alignment);
|
|
printf(" Data:\n");
|
|
for(size_t i = 0; i < binding.data.size(); ++i) {
|
|
printf(" - %zu:%#x +%zu\n",
|
|
binding.data[i].type,
|
|
type_key(binding.data[i].type),
|
|
binding.data[i].offset
|
|
);
|
|
}
|
|
printf(" Map:\n");
|
|
for(size_t key : binding.map.indices()) {
|
|
printf(" - %zu -> %zu\n",
|
|
key,
|
|
*binding.map.get(key)
|
|
);
|
|
} */
|
|
|
|
// add binding to pool
|
|
DB_SCHEMA.set(id, binding);
|
|
return id;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
extern "C" bool schema_has(size_t id)
|
|
{
|
|
return DB_SCHEMA.has(id);
|
|
}
|