mirror of
https://github.com/janet-lang/janet
synced 2024-12-01 04:19:55 +00:00
286 lines
9.1 KiB
C
286 lines
9.1 KiB
C
/*
|
|
* Copyright (c) 2017 Calvin Rose
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to
|
|
* deal in the Software without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "cache.h"
|
|
#include <dst/dst.h>
|
|
|
|
/* Get a value out af an associated data structure.
|
|
* Returns possible c error message, and NULL for no error. The
|
|
* useful return value is written to out on success */
|
|
const char *dst_value_get(DstValue ds, DstValue key, DstValue *out) {
|
|
int64_t index;
|
|
DstValue ret;
|
|
switch (ds.type) {
|
|
case DST_ARRAY:
|
|
if (key.type != DST_INTEGER) return "expected integer key";
|
|
index = dst_startrange(key.as.integer, ds.as.array->count);
|
|
if (index < 0) return "invalid array access";
|
|
ret = ds.as.array->data[index];
|
|
break;
|
|
case DST_TUPLE:
|
|
if (key.type != DST_INTEGER) return "expected integer key";
|
|
index = dst_startrange(key.as.integer, dst_tuple_length(ds.as.tuple));
|
|
if (index < 0) return "invalid tuple access";
|
|
ret = ds.as.tuple[index];
|
|
break;
|
|
case DST_BUFFER:
|
|
if (key.type != DST_INTEGER) return "expected integer key";
|
|
index = dst_startrange(key.as.integer, ds.as.buffer->count);
|
|
if (index < 0) return "invalid buffer access";
|
|
ret.type = DST_INTEGER;
|
|
ret.as.integer = ds.as.buffer->data[index];
|
|
break;
|
|
case DST_STRING:
|
|
case DST_SYMBOL:
|
|
if (key.type != DST_INTEGER) return "expected integer key";
|
|
index = dst_startrange(key.as.integer, dst_string_length(ds.as.string));
|
|
if (index < 0) return "invalid string access";
|
|
ret.type = DST_INTEGER;
|
|
ret.as.integer = ds.as.string[index];
|
|
break;
|
|
case DST_STRUCT:
|
|
ret = dst_struct_get(ds.as.st, key);
|
|
break;
|
|
case DST_TABLE:
|
|
ret = dst_table_get(ds.as.table, key);
|
|
break;
|
|
default:
|
|
return "cannot get";
|
|
}
|
|
*out = ret;
|
|
return NULL;
|
|
}
|
|
|
|
int dst_get(Dst *vm) {
|
|
DstValue ds = dst_popv(vm);
|
|
DstValue key = dst_popv(vm);
|
|
DstValue ret;
|
|
const char *err = dst_value_get(ds, key, &ret);
|
|
if (err) {
|
|
vm->flags = 1;
|
|
dst_cstring(vm, err);
|
|
} else {
|
|
dst_pushv(vm, ret);
|
|
}
|
|
}
|
|
|
|
/* Set a value in an associative data structure. Returns possible
|
|
* error message, and NULL if no error. */
|
|
const char *dst_value_set(Dst *vm, DstValue ds, DstValue key, DstValue value) {
|
|
int64_t index;
|
|
switch (ds.type) {
|
|
case DST_ARRAY:
|
|
if (key.type != DST_INTEGER) return "expected integer key";
|
|
index = dst_startrange(key.as.integer, ds.as.array->count);
|
|
if (index < 0) return "invalid array access";
|
|
ds.as.array->data[index] = value;
|
|
break;
|
|
case DST_BUFFER:
|
|
if (key.type != DST_INTEGER) return "expected integer key";
|
|
if (value.type != DST_INTEGER) return "expected integer value";
|
|
index = dst_startrange(key.as.integer, ds.as.buffer->count);
|
|
if (index < 0) return "invalid buffer access";
|
|
ds.as.buffer->data[index] = (uint8_t) value.as.integer;
|
|
break;
|
|
case DST_TABLE:
|
|
dst_table_put(vm, ds.as.table, key, value);
|
|
break;
|
|
default:
|
|
return "cannot set";
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void dst_set(Dst *vm) {
|
|
DstValue ds = dst_popv(vm);
|
|
DstValue key = dst_popv(vm);
|
|
DstValue value = dst_popv(vm);
|
|
const char *err = dst_value_set(vm, ds, key, value);
|
|
if (err) {
|
|
vm->flags = 1;
|
|
vm->ret = dst_string_cv(vm, err);
|
|
}
|
|
}
|
|
|
|
/* Get the next key in an associative data structure. Used for iterating through an
|
|
* associative data structure. */
|
|
int dst_next(Dst *vm) {
|
|
DstValue dsv = dst_popv(vm);
|
|
DstValue keyv = dst_popv(vm);
|
|
DstValue ret = keyv;
|
|
switch(dsv.type) {
|
|
default:
|
|
dst_cerr(vm, "expected table or struct");
|
|
return 0;
|
|
case DST_TABLE:
|
|
ret = dst_table_next(dsv.as.table, keyv);
|
|
break;
|
|
case DST_STRUCT:
|
|
ret = dst_struct_next(dsv.as.st, keyv);
|
|
break;
|
|
}
|
|
dst_pushv(vm, ret);
|
|
return ret.type != DST_NIL;
|
|
}
|
|
|
|
/* Ensure capacity in a datastructure */
|
|
void dst_ensure(Dst *vm, int64_t index, uint32_t capacity) {
|
|
DstValue x = dst_getv(vm, index);
|
|
switch (x.type) {
|
|
default:
|
|
dst_cerr(vm, "could not ensure capacity");
|
|
break;
|
|
case DST_ARRAY:
|
|
dst_array_ensure_(vm, x.as.array, capacity);
|
|
break;
|
|
case DST_BUFFER:
|
|
dst_buffer_ensure_(vm, x.as.buffer, capacity);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Get the length of an object. Returns errors for invalid types */
|
|
uint32_t dst_length(Dst *vm, int64_t index) {
|
|
DstValue x = dst_getv(vm, index);
|
|
uint32_t length;
|
|
switch (x.type) {
|
|
default:
|
|
dst_cerr(vm, "cannot get length");
|
|
return 0;
|
|
case DST_STRING:
|
|
length = dst_string_length(x.as.string);
|
|
break;
|
|
case DST_ARRAY:
|
|
length = x.as.array->count;
|
|
break;
|
|
case DST_BUFFER:
|
|
length = x.as.buffer->count;
|
|
break;
|
|
case DST_TUPLE:
|
|
length = dst_tuple_length(x.as.tuple);
|
|
break;
|
|
case DST_STRUCT:
|
|
length = dst_struct_length(x.as.st);
|
|
break;
|
|
case DST_TABLE:
|
|
length = x.as.table->count;
|
|
break;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
/* Get the capacity of an object. Returns errors for invalid types */
|
|
uint32_t dst_capacity(Dst *vm, int64_t index) {
|
|
DstValue x = dst_getv(vm, index);
|
|
uint32_t cap;
|
|
switch (x.type) {
|
|
default:
|
|
dst_cerr(vm, "cannot get capacity");
|
|
return 0;
|
|
case DST_STRING:
|
|
cap = dst_string_length(x.as.string);
|
|
break;
|
|
case DST_ARRAY:
|
|
cap = x.as.array->capacity;
|
|
break;
|
|
case DST_BUFFER:
|
|
cap = x.as.buffer->capacity;
|
|
break;
|
|
case DST_TUPLE:
|
|
cap = dst_tuple_length(x.as.tuple);
|
|
break;
|
|
case DST_STRUCT:
|
|
cap = dst_struct_length(x.as.st);
|
|
break;
|
|
case DST_TABLE:
|
|
cap = x.as.table->capacity;
|
|
break;
|
|
}
|
|
return cap;
|
|
}
|
|
|
|
/* Sequence functions */
|
|
const char *dst_getindex_value(DstValue ds, uint32_t index, DstValue *out) {
|
|
switch (ds.type) {
|
|
default:
|
|
return "expected sequence type";
|
|
case DST_STRING:
|
|
if (index >= dst_string_length(ds.as.string)) return "index out of bounds";
|
|
*out = dst_wrap_integer(ds.as.string[index]);
|
|
break;
|
|
case DST_ARRAY:
|
|
if (index >= ds.as.array->count) return "index out of bounds";
|
|
*out = ds.as.array->data[index];
|
|
break;
|
|
case DST_BUFFER:
|
|
if (index >= ds.as.buffer->count) return "index out of bounds";
|
|
*out = dst_wrap_integer(ds.as.buffer->data[index]);
|
|
break;
|
|
case DST_TUPLE:
|
|
if (index >= dst_tuple_length(ds.as.tuple)) return "index out of bounds";
|
|
*out = ds.as.tuple[index];
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
void dst_getindex(Dst *vm, uint32_t index) {
|
|
DstValue out;
|
|
DstValue ds = dst_popv(vm);
|
|
const char *e = dst_getindex_value(ds, index, &out);
|
|
if (e == NULL) {
|
|
dst_pushv(vm, out);
|
|
} else {
|
|
dst_cstring(vm, e);
|
|
vm->flags = 1;
|
|
}
|
|
}
|
|
|
|
const char *dst_setindex_value(Dst *vm, DstValue ds, uint32_t index, DstValue value) {
|
|
switch (ds.type) {
|
|
default:
|
|
return "expected mutable sequence type";
|
|
case DST_ARRAY:
|
|
if (index >= ds.as.array->count) {
|
|
dst_array_ensure_(vm, ds.as.array, index + 1);
|
|
}
|
|
ds.as.array->data[index] = value;
|
|
break;
|
|
case DST_BUFFER:
|
|
if (value.type != DST_INTEGER) return "expected integer type";
|
|
if (index >= ds.as.buffer->count) {
|
|
dst_buffer_ensure_(vm, ds.as.buffer, index + 1);
|
|
}
|
|
ds.as.buffer->data[index] = value.as.integer;
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
void dst_setindex(Dst *vm, uint32_t index) {
|
|
DstValue ds = dst_popv(vm);
|
|
DstValue value = dst_popv(vm);
|
|
const char *e = dst_setindex_value(vm, ds, index, value);
|
|
if (e != NULL) {
|
|
dst_cstring(vm, e);
|
|
vm->flags = 1;
|
|
}
|
|
}
|