mirrors/janet
1
0
Fork 0
mirror of https://github.com/janet-lang/janet synced 2025-10-25 12:47:42 +00:00
Code Issues 1 Releases Wiki Activity

Rename to janet

Browse Source
This commit is contained in:
Calvin Rose
2018-09-05 22:18:42 -04:00
parent 285f2d7ea9
commit c8ef2a0d88
69 changed files with 6199 additions and 6259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
natives/json/build_win.bat
View File

@@ -7,7 +7,7 @@
cl /nologo /I..\..\src\include /c /O2 /W3 json.c
@if errorlevel 1 goto :BUILDFAIL
link /nologo /dll ..\..\dst.lib /out:json.dll *.obj
link /nologo /dll ..\..\janet.lib /out:json.dll *.obj
if errorlevel 1 goto :BUILDFAIL
@echo .

190
natives/json/json.c
View File

@@ -20,7 +20,7 @@
* IN THE SOFTWARE.
*/
#include <dst/dst.h>
#include <janet/janet.h>
#include <stdlib.h>
#include <errno.h>
@@ -71,8 +71,8 @@ static char *decode_utf16_escape(const char *p, uint32_t *outpoint) {
}
/* Parse a string */
const char *decode_string(const char **p, Dst *out) {
DstBuffer *buffer = dst_buffer(0);
const char *decode_string(const char **p, Janet *out) {
JanetBuffer *buffer = janet_buffer(0);
const char *cp = *p;
while (*cp != '"') {
uint8_t b = (uint8_t) *cp;
@@ -127,36 +127,36 @@ const char *decode_string(const char **p, Dst *out) {
}
/* Write codepoint */
if (codepoint <= 0x7F) {
dst_buffer_push_u8(buffer, codepoint);
janet_buffer_push_u8(buffer, codepoint);
} else if (codepoint <= 0x7FF) {
dst_buffer_push_u8(buffer, ((codepoint >> 6) & 0x1F) | 0xC0);
dst_buffer_push_u8(buffer, ((codepoint >> 0) & 0x3F) | 0x80);
janet_buffer_push_u8(buffer, ((codepoint >> 6) & 0x1F) | 0xC0);
janet_buffer_push_u8(buffer, ((codepoint >> 0) & 0x3F) | 0x80);
} else if (codepoint <= 0xFFFF) {
dst_buffer_push_u8(buffer, ((codepoint >> 12) & 0x0F) | 0xE0);
dst_buffer_push_u8(buffer, ((codepoint >> 6) & 0x3F) | 0x80);
dst_buffer_push_u8(buffer, ((codepoint >> 0) & 0x3F) | 0x80);
janet_buffer_push_u8(buffer, ((codepoint >> 12) & 0x0F) | 0xE0);
janet_buffer_push_u8(buffer, ((codepoint >> 6) & 0x3F) | 0x80);
janet_buffer_push_u8(buffer, ((codepoint >> 0) & 0x3F) | 0x80);
} else {
dst_buffer_push_u8(buffer, ((codepoint >> 18) & 0x07) | 0xF0);
dst_buffer_push_u8(buffer, ((codepoint >> 12) & 0x3F) | 0x80);
dst_buffer_push_u8(buffer, ((codepoint >> 6) & 0x3F) | 0x80);
dst_buffer_push_u8(buffer, ((codepoint >> 0) & 0x3F) | 0x80);
janet_buffer_push_u8(buffer, ((codepoint >> 18) & 0x07) | 0xF0);
janet_buffer_push_u8(buffer, ((codepoint >> 12) & 0x3F) | 0x80);
janet_buffer_push_u8(buffer, ((codepoint >> 6) & 0x3F) | 0x80);
janet_buffer_push_u8(buffer, ((codepoint >> 0) & 0x3F) | 0x80);
}
}
continue;
}
}
dst_buffer_push_u8(buffer, b);
janet_buffer_push_u8(buffer, b);
cp++;
}
*out = dst_stringv(buffer->data, buffer->count);
*out = janet_stringv(buffer->data, buffer->count);
*p = cp + 1;
return NULL;
}
static const char *decode_one(const char **p, Dst *out, int depth) {
static const char *decode_one(const char **p, Janet *out, int depth) {
/* Prevent stack overflow */
if (depth > DST_RECURSION_GUARD) goto recurdepth;
if (depth > JANET_RECURSION_GUARD) goto recurdepth;
/* Skip leading whitepspace */
skipwhite(p);
@@ -176,7 +176,7 @@ static const char *decode_one(const char **p, Dst *out, int depth) {
double x = strtod(*p, &end);
if (end == *p) goto badnum;
*p = end;
*out = dst_wrap_real(x);
*out = janet_wrap_real(x);
break;
}
/* false, null, true */
@@ -185,7 +185,7 @@ static const char *decode_one(const char **p, Dst *out, int depth) {
const char *cp = *p;
if (cp[1] != 'a' || cp[2] != 'l' || cp[3] != 's' || cp[4] != 'e')
goto badident;
*out = dst_wrap_false();
*out = janet_wrap_false();
*p = cp + 5;
break;
}
@@ -195,7 +195,7 @@ static const char *decode_one(const char **p, Dst *out, int depth) {
if (cp[1] != 'u' || cp[2] != 'l' || cp[3] != 'l')
goto badident;
*out = dst_wrap_nil();
*out = janet_wrap_nil();
*p = cp + 4;
break;
}
@@ -204,7 +204,7 @@ static const char *decode_one(const char **p, Dst *out, int depth) {
const char *cp = *p;
if (cp[1] != 'r' || cp[2] != 'u' || cp[3] != 'e')
goto badident;
*out = dst_wrap_true();
*out = janet_wrap_true();
*p = cp + 4;
break;
}
@@ -225,37 +225,37 @@ static const char *decode_one(const char **p, Dst *out, int depth) {
}
if (*cp != '"') goto badchar;
*p = cp + 1;
*out = dst_stringv((const uint8_t *)start, cp - start);
*out = janet_stringv((const uint8_t *)start, cp - start);
break;
}
/* Array */
case '[':
{
*p = *p + 1;
DstArray *array = dst_array(0);
JanetArray *array = janet_array(0);
const char *err;
Dst subval;
Janet subval;
skipwhite(p);
while (**p != ']') {
err = decode_one(p, &subval, depth + 1);
if (err) return err;
dst_array_push(array, subval);
janet_array_push(array, subval);
skipwhite(p);
if (**p == ']') break;
if (**p != ',') goto wantcomma;
*p = *p + 1;
}
*p = *p + 1;
*out = dst_wrap_array(array);
*out = janet_wrap_array(array);
}
break;
/* Object */
case '{':
{
*p = *p + 1;
DstTable *table = dst_table(0);
JanetTable *table = janet_table(0);
const char *err;
Dst subkey, subval;
Janet subkey, subval;
skipwhite(p);
while (**p != '}') {
skipwhite(p);
@@ -267,14 +267,14 @@ static const char *decode_one(const char **p, Dst *out, int depth) {
*p = *p + 1;
err = decode_one(p, &subval, depth + 1);
if (err) return err;
dst_table_put(table, subkey, subval);
janet_table_put(table, subkey, subval);
skipwhite(p);
if (**p == '}') break;
if (**p != ',') goto wantcomma;
*p = *p + 1;
}
*p = *p + 1;
*out = dst_wrap_table(table);
*out = janet_wrap_table(table);
break;
}
}
@@ -301,23 +301,23 @@ wantstring:
return "expected json string";
}
static int json_decode(DstArgs args) {
Dst ret;
DST_FIXARITY(args, 1);
static int json_decode(JanetArgs args) {
Janet ret;
JANET_FIXARITY(args, 1);
const char *err;
const char *start;
const char *p;
if (dst_checktype(args.v[0], DST_BUFFER)) {
DstBuffer *buffer = dst_unwrap_buffer(args.v[0]);
if (janet_checktype(args.v[0], JANET_BUFFER)) {
JanetBuffer *buffer = janet_unwrap_buffer(args.v[0]);
/* Ensure 0 padded */
dst_buffer_push_u8(buffer, 0);
janet_buffer_push_u8(buffer, 0);
start = p = (const char *)buffer->data;
err = decode_one(&p, &ret, 0);
buffer->count--;
} else {
const uint8_t *bytes;
int32_t len;
DST_ARG_BYTES(bytes, len, args, 0);
JANET_ARG_BYTES(bytes, len, args, 0);
start = p = (const char *)bytes;
err = decode_one(&p, &ret, 0);
}
@@ -328,12 +328,12 @@ static int json_decode(DstArgs args) {
err = "unexpected extra token";
}
if (err) {
DST_THROWV(args, dst_wrap_string(dst_formatc(
JANET_THROWV(args, janet_wrap_string(janet_formatc(
"decode error at postion %d: %s",
p - start,
err)));
}
DST_RETURN(args, ret);
JANET_RETURN(args, ret);
}
/*****************/
@@ -341,7 +341,7 @@ static int json_decode(DstArgs args) {
/*****************/
typedef struct {
DstBuffer *buffer;
JanetBuffer *buffer;
int32_t indent;
const uint8_t *tab;
const uint8_t *newline;
@@ -350,62 +350,62 @@ typedef struct {
} Encoder;
static const char *encode_newline(Encoder *e) {
if (dst_buffer_push_bytes(e->buffer, e->newline, e->newlinelen))
if (janet_buffer_push_bytes(e->buffer, e->newline, e->newlinelen))
return "buffer overflow";
for (int32_t i = 0; i < e->indent; i++)
if (dst_buffer_push_bytes(e->buffer, e->tab, e->tablen))
if (janet_buffer_push_bytes(e->buffer, e->tab, e->tablen))
return "buffer overflow";
return NULL;
}
static const char *encode_one(Encoder *e, Dst x, int depth) {
switch(dst_type(x)) {
static const char *encode_one(Encoder *e, Janet x, int depth) {
switch(janet_type(x)) {
default:
goto badtype;
case DST_NIL:
case JANET_NIL:
{
if (dst_buffer_push_cstring(e->buffer, "null"))
if (janet_buffer_push_cstring(e->buffer, "null"))
goto overflow;
}
break;
case DST_FALSE:
case JANET_FALSE:
{
if (dst_buffer_push_cstring(e->buffer, "false"))
if (janet_buffer_push_cstring(e->buffer, "false"))
goto overflow;
}
break;
case DST_TRUE:
case JANET_TRUE:
{
if (dst_buffer_push_cstring(e->buffer, "true"))
if (janet_buffer_push_cstring(e->buffer, "true"))
goto overflow;
}
break;
case DST_INTEGER:
case JANET_INTEGER:
{
char cbuf[20];
sprintf(cbuf, "%d", dst_unwrap_integer(x));
if (dst_buffer_push_cstring(e->buffer, cbuf))
sprintf(cbuf, "%d", janet_unwrap_integer(x));
if (janet_buffer_push_cstring(e->buffer, cbuf))
goto overflow;
}
break;
case DST_REAL:
case JANET_REAL:
{
char cbuf[25];
sprintf(cbuf, "%.17g", dst_unwrap_real(x));
if (dst_buffer_push_cstring(e->buffer, cbuf))
sprintf(cbuf, "%.17g", janet_unwrap_real(x));
if (janet_buffer_push_cstring(e->buffer, cbuf))
goto overflow;
}
break;
case DST_STRING:
case DST_SYMBOL:
case DST_BUFFER:
case JANET_STRING:
case JANET_SYMBOL:
case JANET_BUFFER:
{
const uint8_t *bytes;
const uint8_t *c;
const uint8_t *end;
int32_t len;
dst_bytes_view(x, &bytes, &len);
if (dst_buffer_push_u8(e->buffer, '"')) goto overflow;
janet_bytes_view(x, &bytes, &len);
if (janet_buffer_push_u8(e->buffer, '"')) goto overflow;
c = bytes;
end = bytes + len;
while (c < end) {
@@ -445,9 +445,9 @@ static const char *encode_one(Encoder *e, Dst x, int depth) {
if (codepoint > 0x1F && codepoint < 0x80) {
/* Normal, no escape */
if (codepoint == '\\' || codepoint == '"')
if (dst_buffer_push_u8(e->buffer, '\\'))
if (janet_buffer_push_u8(e->buffer, '\\'))
goto overflow;
if (dst_buffer_push_u8(e->buffer, (uint8_t) codepoint))
if (janet_buffer_push_u8(e->buffer, (uint8_t) codepoint))
goto overflow;
} else if (codepoint < 0x10000) {
/* One unicode escape */
@@ -458,7 +458,7 @@ static const char *encode_one(Encoder *e, Dst x, int depth) {
buf[3] = (codepoint >> 8) & 0xF;
buf[4] = (codepoint >> 4) & 0xF;
buf[5] = codepoint & 0xF;
if (dst_buffer_push_bytes(e->buffer, buf, sizeof(buf)))
if (janet_buffer_push_bytes(e->buffer, buf, sizeof(buf)))
goto overflow;
} else {
/* Two unicode escapes (surrogate pair) */
@@ -478,28 +478,28 @@ static const char *encode_one(Encoder *e, Dst x, int depth) {
buf[9] = (lo >> 8) & 0xF;
buf[10] = (lo >> 4) & 0xF;
buf[11] = lo & 0xF;
if (dst_buffer_push_bytes(e->buffer, buf, sizeof(buf)))
if (janet_buffer_push_bytes(e->buffer, buf, sizeof(buf)))
goto overflow;
}
}
if (dst_buffer_push_u8(e->buffer, '"')) goto overflow;
if (janet_buffer_push_u8(e->buffer, '"')) goto overflow;
}
break;
case DST_TUPLE:
case DST_ARRAY:
case JANET_TUPLE:
case JANET_ARRAY:
{
const char *err;
const Dst *items;
const Janet *items;
int32_t len;
dst_indexed_view(x, &items, &len);
if (dst_buffer_push_u8(e->buffer, '[')) goto overflow;
janet_indexed_view(x, &items, &len);
if (janet_buffer_push_u8(e->buffer, '[')) goto overflow;
e->indent++;
if ((err = encode_newline(e))) return err;
for (int32_t i = 0; i < len; i++) {
if ((err = encode_newline(e))) return err;
if ((err = encode_one(e, items[i], depth + 1)))
return err;
if (dst_buffer_push_u8(e->buffer, ','))
if (janet_buffer_push_u8(e->buffer, ','))
goto overflow;
}
e->indent--;
@@ -507,32 +507,32 @@ static const char *encode_one(Encoder *e, Dst x, int depth) {
e->buffer->count--;
if ((err = encode_newline(e))) return err;
}
if (dst_buffer_push_u8(e->buffer, ']')) goto overflow;
if (janet_buffer_push_u8(e->buffer, ']')) goto overflow;
}
break;
case DST_TABLE:
case DST_STRUCT:
case JANET_TABLE:
case JANET_STRUCT:
{
const char *err;
const DstKV *kvs;
const JanetKV *kvs;
int32_t count, capacity;
dst_dictionary_view(x, &kvs, &count, &capacity);
if (dst_buffer_push_u8(e->buffer, '{')) goto overflow;
janet_dictionary_view(x, &kvs, &count, &capacity);
if (janet_buffer_push_u8(e->buffer, '{')) goto overflow;
e->indent++;
for (int32_t i = 0; i < capacity; i++) {
if (dst_checktype(kvs[i].key, DST_NIL))
if (janet_checktype(kvs[i].key, JANET_NIL))
continue;
if (!dst_checktype(kvs[i].key, DST_STRING))
if (!janet_checktype(kvs[i].key, JANET_STRING))
return "only strings keys are allowed in objects";
if ((err = encode_newline(e))) return err;
if ((err = encode_one(e, kvs[i].key, depth + 1)))
return err;
const char *sep = e->tablen ? ": " : ":";
if (dst_buffer_push_cstring(e->buffer, sep))
if (janet_buffer_push_cstring(e->buffer, sep))
goto overflow;
if ((err = encode_one(e, kvs[i].value, depth + 1)))
return err;
if (dst_buffer_push_u8(e->buffer, ','))
if (janet_buffer_push_u8(e->buffer, ','))
goto overflow;
}
e->indent--;
@@ -540,7 +540,7 @@ static const char *encode_one(Encoder *e, Dst x, int depth) {
e->buffer->count--;
if ((err = encode_newline(e))) return err;
}
if (dst_buffer_push_u8(e->buffer, '}')) goto overflow;
if (janet_buffer_push_u8(e->buffer, '}')) goto overflow;
}
break;
}
@@ -555,42 +555,42 @@ invalidutf8:
return "string contains invalid utf-8";
}
static int json_encode(DstArgs args) {
DST_MINARITY(args, 1);
DST_MAXARITY(args, 3);
static int json_encode(JanetArgs args) {
JANET_MINARITY(args, 1);
JANET_MAXARITY(args, 3);
Encoder e;
e.indent = 0;
e.buffer = dst_buffer(10);
e.buffer = janet_buffer(10);
e.tab = NULL;
e.newline = NULL;
e.tablen = 0;
e.newlinelen = 0;
if (args.n >= 2) {
DST_ARG_BYTES(e.tab, e.tablen, args, 1);
JANET_ARG_BYTES(e.tab, e.tablen, args, 1);
if (args.n >= 3) {
DST_ARG_BYTES(e.newline, e.newlinelen, args, 2);
JANET_ARG_BYTES(e.newline, e.newlinelen, args, 2);
} else {
e.newline = (const uint8_t *)"\r\n";
e.newlinelen = 1;
}
}
const char *err = encode_one(&e, args.v[0], 0);
if (err) DST_THROW(args, err);
DST_RETURN_BUFFER(args, e.buffer);
if (err) JANET_THROW(args, err);
JANET_RETURN_BUFFER(args, e.buffer);
}
/****************/
/* Module Entry */
/****************/
static const DstReg cfuns[] = {
static const JanetReg cfuns[] = {
{"encode", json_encode},
{"decode", json_decode},
{NULL, NULL}
};
DST_MODULE_ENTRY(DstArgs args) {
DstTable *env = dst_env(args);
dst_cfuns(env, "json", cfuns);
JANET_MODULE_ENTRY(JanetArgs args) {
JanetTable *env = janet_env(args);
janet_cfuns(env, "json", cfuns);
return 0;
}

172
natives/sqlite3/main.c
View File

@@ -21,7 +21,7 @@
*/
#include "sqlite3.h"
#include <dst/dst.h>
#include <janet/janet.h>
#define FLAG_CLOSED 1
@@ -48,39 +48,39 @@ static int gcsqlite(void *p, size_t s) {
return 0;
}
static const DstAbstractType sql_conn_type = {
static const JanetAbstractType sql_conn_type = {
":sqlite3.connection",
gcsqlite,
NULL,
};
/* Open a new database connection */
static int sql_open(DstArgs args) {
static int sql_open(JanetArgs args) {
sqlite3 *conn;
const uint8_t *filename;
int status;
DST_FIXARITY(args, 1);
DST_ARG_STRING(filename, args, 0);
JANET_FIXARITY(args, 1);
JANET_ARG_STRING(filename, args, 0);
status = sqlite3_open((const char *)filename, &conn);
if (status == SQLITE_OK) {
Db *db = (Db *) dst_abstract(&sql_conn_type, sizeof(Db));
Db *db = (Db *) janet_abstract(&sql_conn_type, sizeof(Db));
db->handle = conn;
db->flags = 0;
DST_RETURN_ABSTRACT(args, db);
JANET_RETURN_ABSTRACT(args, db);
} else {
const char *err = sqlite3_errmsg(conn);
DST_THROW(args, err);
JANET_THROW(args, err);
}
}
/* Close a database connection */
static int sql_close(DstArgs args) {
static int sql_close(JanetArgs args) {
Db *db;
DST_FIXARITY(args, 1);
DST_CHECKABSTRACT(args, 0, &sql_conn_type);
db = (Db *)dst_unwrap_abstract(args.v[0]);
JANET_FIXARITY(args, 1);
JANET_CHECKABSTRACT(args, 0, &sql_conn_type);
db = (Db *)janet_unwrap_abstract(args.v[0]);
closedb(db);
DST_RETURN_NIL(args);
JANET_RETURN_NIL(args);
}
/* Check for embedded NULL bytes */
@@ -93,31 +93,31 @@ static int has_null(const uint8_t *str, int32_t len) {
}
/* Bind a single parameter */
static const char *bind1(sqlite3_stmt *stmt, int index, Dst value) {
static const char *bind1(sqlite3_stmt *stmt, int index, Janet value) {
int res;
switch (dst_type(value)) {
switch (janet_type(value)) {
default:
return "invalid sql value";
case DST_NIL:
case JANET_NIL:
res = sqlite3_bind_null(stmt, index);
break;
case DST_FALSE:
case JANET_FALSE:
res = sqlite3_bind_int(stmt, index, 0);
break;
case DST_TRUE:
case JANET_TRUE:
res = sqlite3_bind_int(stmt, index, 1);
break;
case DST_REAL:
res = sqlite3_bind_double(stmt, index, dst_unwrap_real(value));
case JANET_REAL:
res = sqlite3_bind_double(stmt, index, janet_unwrap_real(value));
break;
case DST_INTEGER:
res = sqlite3_bind_int64(stmt, index, dst_unwrap_integer(value));
case JANET_INTEGER:
res = sqlite3_bind_int64(stmt, index, janet_unwrap_integer(value));
break;
case DST_STRING:
case DST_SYMBOL:
case JANET_STRING:
case JANET_SYMBOL:
{
const uint8_t *str = dst_unwrap_string(value);
int32_t len = dst_string_length(str);
const uint8_t *str = janet_unwrap_string(value);
int32_t len = janet_string_length(str);
if (has_null(str, len)) {
return "cannot have embedded nulls in text values";
} else {
@@ -125,9 +125,9 @@ static const char *bind1(sqlite3_stmt *stmt, int index, Dst value) {
}
}
break;
case DST_BUFFER:
case JANET_BUFFER:
{
DstBuffer *buffer = dst_unwrap_buffer(value);
JanetBuffer *buffer = janet_unwrap_buffer(value);
res = sqlite3_bind_blob(stmt, index, buffer->data, buffer->count, SQLITE_STATIC);
}
break;
@@ -140,13 +140,13 @@ static const char *bind1(sqlite3_stmt *stmt, int index, Dst value) {
}
/* Bind many parameters */
static const char *bindmany(sqlite3_stmt *stmt, Dst params) {
static const char *bindmany(sqlite3_stmt *stmt, Janet params) {
/* parameters */
const Dst *seq;
const DstKV *kvs;
const Janet *seq;
const JanetKV *kvs;
int32_t len, cap;
int limitindex = sqlite3_bind_parameter_count(stmt);
if (dst_indexed_view(params, &seq, &len)) {
if (janet_indexed_view(params, &seq, &len)) {
if (len > limitindex + 1) {
return "invalid index in sql parameters";
}
@@ -156,23 +156,23 @@ static const char *bindmany(sqlite3_stmt *stmt, Dst params) {
return err;
}
}
} else if (dst_dictionary_view(params, &kvs, &len, &cap)) {
} else if (janet_dictionary_view(params, &kvs, &len, &cap)) {
for (int i = 0; i < cap; i++) {
int index = 0;
switch (dst_type(kvs[i].key)) {
switch (janet_type(kvs[i].key)) {
default:
/* Will fail */
break;
case DST_NIL:
case JANET_NIL:
/* Will skip as nil keys indicate empty hash table slot */
continue;
case DST_INTEGER:
index = dst_unwrap_integer(kvs[i].key);
case JANET_INTEGER:
index = janet_unwrap_integer(kvs[i].key);
break;
case DST_STRING:
case DST_SYMBOL:
case JANET_STRING:
case JANET_SYMBOL:
{
const uint8_t *s = dst_unwrap_string(kvs[i].key);
const uint8_t *s = janet_unwrap_string(kvs[i].key);
index = sqlite3_bind_parameter_index(
stmt,
(const char *)s);
@@ -209,57 +209,57 @@ static const char *execute(sqlite3_stmt *stmt) {
}
/* Execute and return values from prepared statement */
static const char *execute_collect(sqlite3_stmt *stmt, DstArray *rows) {
static const char *execute_collect(sqlite3_stmt *stmt, JanetArray *rows) {
/* Count number of columns in result */
int ncol = sqlite3_column_count(stmt);
int status;
const char *ret = NULL;
/* Get column names */
Dst *tupstart = dst_tuple_begin(ncol);
Janet *tupstart = janet_tuple_begin(ncol);
for (int i = 0; i < ncol; i++) {
tupstart[i] = dst_cstringv(sqlite3_column_name(stmt, i));
tupstart[i] = janet_cstringv(sqlite3_column_name(stmt, i));
}
const Dst *colnames = dst_tuple_end(tupstart);
const Janet *colnames = janet_tuple_end(tupstart);
do {
status = sqlite3_step(stmt);
if (status == SQLITE_ROW) {
DstKV *row = dst_struct_begin(ncol);
JanetKV *row = janet_struct_begin(ncol);
for (int i = 0; i < ncol; i++) {
int t = sqlite3_column_type(stmt, i);
Dst value;
Janet value;
switch (t) {
case SQLITE_NULL:
value = dst_wrap_nil();
value = janet_wrap_nil();
break;
case SQLITE_INTEGER:
value = dst_wrap_integer(sqlite3_column_int(stmt, i));
value = janet_wrap_integer(sqlite3_column_int(stmt, i));
break;
case SQLITE_FLOAT:
value = dst_wrap_real(sqlite3_column_double(stmt, i));
value = janet_wrap_real(sqlite3_column_double(stmt, i));
break;
case SQLITE_TEXT:
{
int nbytes = sqlite3_column_bytes(stmt, i) - 1;
uint8_t *str = dst_string_begin(nbytes);
uint8_t *str = janet_string_begin(nbytes);
memcpy(str, sqlite3_column_text(stmt, i), nbytes);
value = dst_wrap_string(dst_string_end(str));
value = janet_wrap_string(janet_string_end(str));
}
break;
case SQLITE_BLOB:
{
int nbytes = sqlite3_column_bytes(stmt, i);
DstBuffer *b = dst_buffer(nbytes);
JanetBuffer *b = janet_buffer(nbytes);
memcpy(b->data, sqlite3_column_blob(stmt, i), nbytes);
b->count = nbytes;
value = dst_wrap_buffer(b);
value = janet_wrap_buffer(b);
}
break;
}
dst_struct_put(row, colnames[i], value);
janet_struct_put(row, colnames[i], value);
}
dst_array_push(rows, dst_wrap_struct(dst_struct_end(row)));
janet_array_push(rows, janet_wrap_struct(janet_struct_end(row)));
}
} while (status == SQLITE_ROW);
@@ -272,24 +272,24 @@ static const char *execute_collect(sqlite3_stmt *stmt, DstArray *rows) {
}
/* Evaluate a string of sql */
static int sql_eval(DstArgs args) {
static int sql_eval(JanetArgs args) {
const char *err;
sqlite3_stmt *stmt = NULL, *stmt_next = NULL;
const uint8_t *query;
DST_MINARITY(args, 2);
DST_MAXARITY(args, 3);
DST_CHECKABSTRACT(args, 0, &sql_conn_type);
Db *db = (Db *)dst_unwrap_abstract(args.v[0]);
JANET_MINARITY(args, 2);
JANET_MAXARITY(args, 3);
JANET_CHECKABSTRACT(args, 0, &sql_conn_type);
Db *db = (Db *)janet_unwrap_abstract(args.v[0]);
if (db->flags & FLAG_CLOSED) {
DST_THROW(args, MSG_DB_CLOSED);
JANET_THROW(args, MSG_DB_CLOSED);
}
DST_ARG_STRING(query, args, 1);
if (has_null(query, dst_string_length(query))) {
JANET_ARG_STRING(query, args, 1);
if (has_null(query, janet_string_length(query))) {
err = "cannot have embedded NULL in sql statememts";
goto error;
}
DstArray *rows = dst_array(10);
JanetArray *rows = janet_array(10);
const char *c = (const char *)query;
/* Evaluate all statements in a loop */
@@ -326,12 +326,12 @@ static int sql_eval(DstArgs args) {
} while (NULL != stmt);
/* Good return path */
DST_RETURN_ARRAY(args, rows);
JANET_RETURN_ARRAY(args, rows);
error:
if (stmt) sqlite3_finalize(stmt);
if (stmt_next) sqlite3_finalize(stmt_next);
DST_THROW(args, err);
JANET_THROW(args, err);
}
/* Convert int64_t to a string */
@@ -339,8 +339,8 @@ static const uint8_t *coerce_int64(int64_t x) {
uint8_t bytes[40];
int i = 0;
/* Edge cases */
if (x == 0) return dst_cstring("0");
if (x == INT64_MIN) return dst_cstring("-9,223,372,036,854,775,808");
if (x == 0) return janet_cstring("0");
if (x == INT64_MIN) return janet_cstring("-9,223,372,036,854,775,808");
/* Negative becomes pos */
if (x < 0) {
bytes[i++] = '-';
@@ -351,40 +351,40 @@ static const uint8_t *coerce_int64(int64_t x) {
x = x / 10;
}
bytes[i] = '\0';
return dst_string(bytes, i);
return janet_string(bytes, i);
}
/* Gets the last inserted row id */
static int sql_last_insert_rowid(DstArgs args) {
DST_FIXARITY(args, 1);
DST_CHECKABSTRACT(args, 0, &sql_conn_type);
Db *db = (Db *)dst_unwrap_abstract(args.v[0]);
static int sql_last_insert_rowid(JanetArgs args) {
JANET_FIXARITY(args, 1);
JANET_CHECKABSTRACT(args, 0, &sql_conn_type);
Db *db = (Db *)janet_unwrap_abstract(args.v[0]);
if (db->flags & FLAG_CLOSED) {
DST_THROW(args, MSG_DB_CLOSED);
JANET_THROW(args, MSG_DB_CLOSED);
}
sqlite3_int64 id = sqlite3_last_insert_rowid(db->handle);
if (id >= INT32_MIN && id <= INT32_MAX) {
DST_RETURN_INTEGER(args, (int32_t) id);
JANET_RETURN_INTEGER(args, (int32_t) id);
}
/* Convert to string */
DST_RETURN_STRING(args, coerce_int64(id));
JANET_RETURN_STRING(args, coerce_int64(id));
}
/* Get the sqlite3 errcode */
static int sql_error_code(DstArgs args) {
DST_FIXARITY(args, 1);
DST_CHECKABSTRACT(args, 0, &sql_conn_type);
Db *db = (Db *)dst_unwrap_abstract(args.v[0]);
static int sql_error_code(JanetArgs args) {
JANET_FIXARITY(args, 1);
JANET_CHECKABSTRACT(args, 0, &sql_conn_type);
Db *db = (Db *)janet_unwrap_abstract(args.v[0]);
if (db->flags & FLAG_CLOSED) {
DST_THROW(args, MSG_DB_CLOSED);
JANET_THROW(args, MSG_DB_CLOSED);
}
int errcode = sqlite3_errcode(db->handle);
DST_RETURN_INTEGER(args, errcode);
JANET_RETURN_INTEGER(args, errcode);
}
/*****************************************************************************/
static const DstReg cfuns[] = {
static const JanetReg cfuns[] = {
{"open", sql_open},
{"close", sql_close},
{"eval", sql_eval},
@@ -393,8 +393,8 @@ static const DstReg cfuns[] = {
{NULL, NULL}
};
DST_MODULE_ENTRY(DstArgs args) {
DstTable *env = dst_env(args);
dst_cfuns(env, "sqlite3", cfuns);
JANET_MODULE_ENTRY(JanetArgs args) {
JanetTable *env = janet_env(args);
janet_cfuns(env, "sqlite3", cfuns);
return 0;
}