mirror of
https://github.com/janet-lang/janet
synced 2024-06-23 13:43:16 +00:00
Many updates to the sqlite module.
This commit is contained in:
Calvin Rose
parent
363a17ff8c
commit
4e6fc341dc
8
Makefile
8
Makefile
|
|
@ -127,6 +127,14 @@ valtest: $(DST_TARGET)
|
|||
valgrind --leak-check=full -v ./$(DST_TARGET) test/suite0.dst
|
||||
valgrind --leak-check=full -v ./$(DST_TARGET) test/suite1.dst
|
||||
|
||||
###################
|
||||
##### Natives #####
|
||||
###################
|
||||
|
||||
natives: $(DST_TARGET)
|
||||
$(MAKE) -C natives/hello
|
||||
$(MAKE) -j 8 -C natives/sqlite3
|
||||
|
||||
#################
|
||||
##### Other #####
|
||||
#################
|
||||
|
|
|
|||
|
|
@ -18,7 +18,9 @@
|
|||
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||
# IN THE SOFTWARE.
|
||||
|
||||
CFLAGS=-std=c99 -Wall -Wextra -I../../src/include -O2 -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION -shared -fpic
|
||||
CFLAGS=-std=c99 -Wall -Wextra -I../../src/include -O2 -shared -fpic \
|
||||
-DSQLITE_THREADSAFE=0 \
|
||||
-DSQLITE_OMIT_LOAD_EXTENSION
|
||||
TARGET=sqlite3.so
|
||||
|
||||
# MacOS specifics
|
||||
|
|
@ -27,19 +29,29 @@ ifeq ($(UNAME), Darwin)
|
|||
CFLAGS:=$(CFLAGS) -undefined dynamic_lookup
|
||||
endif
|
||||
|
||||
# Default target
|
||||
all: $(TARGET)
|
||||
|
||||
OBJECTS:=main.o sqlite3.o
|
||||
$(TARGET): $(OBJECTS)
|
||||
$(CC) $(CFLAGS) -o $@ $^
|
||||
|
||||
sqlite-autoconf-3230100/sqlite3.%:
|
||||
curl https://www.sqlite.org/2018/sqlite-autoconf-3230100.tar.gz | tar -xvz
|
||||
|
||||
sqlite3.%: sqlite-autoconf-3230100/sqlite3.%
|
||||
sqlite3.c: sqlite-autoconf-3230100/sqlite3.c
|
||||
cp $< $@
|
||||
sqlite3.h: sqlite-autoconf-3230100/sqlite3.h
|
||||
cp $< $@
|
||||
|
||||
$(TARGET): main.c sqlite3.c sqlite3.h
|
||||
$(CC) $(CFLAGS) -o $@ main.c
|
||||
%.o: %.c
|
||||
$(CC) $(CFLAGS) -c $<
|
||||
|
||||
clean:
|
||||
rm -rf sqlite-autoconf-3230100
|
||||
rm *.o
|
||||
rm sqlite3.c
|
||||
rm sqlite3.h
|
||||
rm $(TARGET)
|
||||
|
||||
.PHONY: clean
|
||||
.PHONY: clean all
|
||||
|
|
|
|||
|
|
@ -20,17 +20,50 @@
|
|||
* IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "sqlite3.c"
|
||||
|
||||
#include "sqlite3.h"
|
||||
|
||||
#include <dst/dst.h>
|
||||
|
||||
#define FLAG_CLOSED 1
|
||||
|
||||
typedef struct {
|
||||
sqlite3* handle;
|
||||
int flags;
|
||||
} Db;
|
||||
|
||||
typedef struct {
|
||||
sqlite3_stmt* handle;
|
||||
int flags;
|
||||
} Stmt;
|
||||
|
||||
/* Close a db, noop if already closed */
|
||||
static void closedb(Db *db) {
|
||||
if (!(db->flags & FLAG_CLOSED)) {
|
||||
db->flags |= FLAG_CLOSED;
|
||||
sqlite3_close_v2(db->handle);
|
||||
}
|
||||
}
|
||||
|
||||
/* Close prepared statement, noop if already closed */
|
||||
static void closestmt(Stmt *stmt) {
|
||||
if (!(stmt->flags & FLAG_CLOSED)) {
|
||||
stmt->flags |= FLAG_CLOSED;
|
||||
sqlite3_finalize(stmt->handle);
|
||||
}
|
||||
}
|
||||
|
||||
/* Called to garbage collect a sqlite3 connection */
|
||||
static int gcsqlite(void *p, size_t s) {
|
||||
(void) s;
|
||||
sqlite3 *conn = *((sqlite3 **)p);
|
||||
sqlite3_close_v2(conn);
|
||||
Db *db = (Db *)p;
|
||||
closedb(db);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Called to collect a sqlite3 prepared statement */
|
||||
static int gcstmt(void *p, size_t s) {
|
||||
(void) s;
|
||||
Stmt *stmt = (Stmt *)p;
|
||||
closestmt(stmt);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -40,77 +73,378 @@ static const DstAbstractType sql_conn_type = {
|
|||
NULL,
|
||||
};
|
||||
|
||||
|
||||
static const DstAbstractType sql_stmt_type = {
|
||||
":sqlite3.statement",
|
||||
gcstmt,
|
||||
NULL
|
||||
};
|
||||
|
||||
/* Open a new database connection */
|
||||
static int sql_open(DstArgs args) {
|
||||
sqlite3 **conn;
|
||||
sqlite3 *conn;
|
||||
const uint8_t *filename;
|
||||
int status;
|
||||
DST_FIXARITY(args, 1);
|
||||
DST_ARG_STRING(filename, args, 0);
|
||||
conn = (sqlite3 **) dst_abstract(&sql_conn_type, sizeof(sqlite3 *));
|
||||
status = sqlite3_open((const char *)filename, conn);
|
||||
status = sqlite3_open((const char *)filename, &conn);
|
||||
if (status == SQLITE_OK) {
|
||||
DST_RETURN_ABSTRACT(args, conn);
|
||||
Db *db = (Db *) dst_abstract(&sql_conn_type, sizeof(Db));
|
||||
db->handle = conn;
|
||||
db->flags = 0;
|
||||
DST_RETURN_ABSTRACT(args, db);
|
||||
} else {
|
||||
const char *err = sqlite3_errmsg(*conn);
|
||||
const char *err = sqlite3_errmsg(conn);
|
||||
DST_THROW(args, err);
|
||||
}
|
||||
}
|
||||
|
||||
/* Close a database connection */
|
||||
static int sql_close(DstArgs args) {
|
||||
sqlite3 **conn;
|
||||
int status;
|
||||
Db *db;
|
||||
DST_FIXARITY(args, 1);
|
||||
DST_CHECKABSTRACT(args, 0, &sql_conn_type);
|
||||
conn = (sqlite3 **)dst_unwrap_abstract(args.v[0]);
|
||||
status = sqlite3_close_v2(*conn);
|
||||
if (status == SQLITE_OK) {
|
||||
DST_RETURN_NIL(args);
|
||||
} else {
|
||||
DST_THROW(args, "unable to close the sqlite3 connection");
|
||||
}
|
||||
db = (Db *)dst_unwrap_abstract(args.v[0]);
|
||||
closedb(db);
|
||||
DST_RETURN_NIL(args);
|
||||
}
|
||||
|
||||
static int sql_execute_callback(void *rowsp, int n, char **vals, char **colnames) {
|
||||
int i;
|
||||
DstArray *rows = (DstArray *)rowsp;
|
||||
DstKV *row = dst_struct_begin(n);
|
||||
for (i = 0; i < n; i++) {
|
||||
dst_struct_put(row, dst_cstringv(colnames[i]), dst_cstringv(vals[i]));
|
||||
/* Check for embedded NULL bytes */
|
||||
static int has_null(const uint8_t *str, int32_t len) {
|
||||
while (len--) {
|
||||
if (!str[len])
|
||||
return 1;
|
||||
}
|
||||
dst_array_push(rows, dst_wrap_struct(dst_struct_end(row)));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sql_sql(DstArgs args) {
|
||||
/* Create a prepared statement */
|
||||
static int sql_prepare(DstArgs args) {
|
||||
Db *db;
|
||||
sqlite3_stmt *stmt;
|
||||
const uint8_t *zSql;
|
||||
int status;
|
||||
char *errmsg = "connection closed";
|
||||
const uint8_t *str;
|
||||
DstArray *rows;
|
||||
sqlite3 **conn;
|
||||
DST_FIXARITY(args, 2);
|
||||
DST_CHECKABSTRACT(args, 0, &sql_conn_type);
|
||||
conn = (sqlite3 **)dst_unwrap_abstract(args.v[0]);
|
||||
DST_ARG_STRING(str, args, 1);
|
||||
rows = dst_array(10);
|
||||
status = sqlite3_exec(
|
||||
*conn,
|
||||
(const char *)str,
|
||||
sql_execute_callback,
|
||||
rows,
|
||||
&errmsg);
|
||||
db = (Db *)dst_unwrap_abstract(args.v[0]);
|
||||
DST_ARG_STRING(zSql, args, 1);
|
||||
status = sqlite3_prepare_v2(db->handle, (const char *)zSql, -1, &stmt, NULL);
|
||||
if (status == SQLITE_OK) {
|
||||
DST_RETURN_ARRAY(args, rows);
|
||||
} else {
|
||||
DST_THROW(args, errmsg);
|
||||
Stmt *sp = (Stmt *)dst_abstract(&sql_stmt_type, sizeof(Stmt));
|
||||
sp->handle = stmt;
|
||||
sp->flags = 0;
|
||||
DST_RETURN_ABSTRACT(args, sp);
|
||||
}
|
||||
DST_THROW(args, sqlite3_errmsg(db->handle));
|
||||
}
|
||||
|
||||
/* Finalize a prepared statement */
|
||||
static int sql_finalize(DstArgs args) {
|
||||
DST_FIXARITY(args, 1);
|
||||
DST_CHECKABSTRACT(args, 0, &sql_stmt_type);
|
||||
Stmt *stmt = (Stmt *) dst_unwrap_abstract(args.v[0]);
|
||||
closestmt(stmt);
|
||||
DST_RETURN_NIL(args);
|
||||
}
|
||||
|
||||
/* Bind a single parameter */
|
||||
static const char *bind1(sqlite3_stmt *stmt, int index, Dst value) {
|
||||
int res;
|
||||
switch (dst_type(value)) {
|
||||
default:
|
||||
return "invalid sql value";
|
||||
case DST_NIL:
|
||||
res = sqlite3_bind_null(stmt, index);
|
||||
break;
|
||||
case DST_FALSE:
|
||||
res = sqlite3_bind_int(stmt, index, 0);
|
||||
break;
|
||||
case DST_TRUE:
|
||||
res = sqlite3_bind_int(stmt, index, 1);
|
||||
break;
|
||||
case DST_REAL:
|
||||
res = sqlite3_bind_double(stmt, index, dst_unwrap_real(value));
|
||||
break;
|
||||
case DST_INTEGER:
|
||||
res = sqlite3_bind_int64(stmt, index, dst_unwrap_integer(value));
|
||||
break;
|
||||
case DST_STRING:
|
||||
case DST_SYMBOL:
|
||||
{
|
||||
const uint8_t *str = dst_unwrap_string(value);
|
||||
int32_t len = dst_string_length(str);
|
||||
if (has_null(str, len)) {
|
||||
return "cannot have embedded nulls in text values";
|
||||
} else {
|
||||
res = sqlite3_bind_text(stmt, index, (const char *)str, len + 1, SQLITE_STATIC);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case DST_BUFFER:
|
||||
{
|
||||
DstBuffer *buffer = dst_unwrap_buffer(value);
|
||||
res = sqlite3_bind_blob(stmt, index, buffer->data, buffer->count, SQLITE_STATIC);
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (res != SQLITE_OK) {
|
||||
sqlite3 *db = sqlite3_db_handle(stmt);
|
||||
return sqlite3_errmsg(db);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Bind many parameters */
|
||||
static const char *bindmany(sqlite3_stmt *stmt, Dst params) {
|
||||
/* parameters */
|
||||
const Dst *seq;
|
||||
const DstKV *kvs;
|
||||
int32_t len, cap;
|
||||
int limitindex = sqlite3_bind_parameter_count(stmt);
|
||||
if (dst_seq_view(params, &seq, &len)) {
|
||||
if (len > limitindex + 1) {
|
||||
return "invalid index in sql parameters";
|
||||
}
|
||||
for (int i = 0; i < len; i++) {
|
||||
const char *err = bind1(stmt, i + 1, seq[i]);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
} else if (dst_hashtable_view(params, &kvs, &len, &cap)) {
|
||||
for (int i = 0; i < cap; i++) {
|
||||
int index = 0;
|
||||
switch (dst_type(kvs[i].key)) {
|
||||
default:
|
||||
/* Will fail */
|
||||
break;
|
||||
case DST_NIL:
|
||||
/* Will skip as nil keys indicate empty hash table slot */
|
||||
continue;
|
||||
case DST_INTEGER:
|
||||
index = dst_unwrap_integer(kvs[i].key);
|
||||
break;
|
||||
case DST_STRING:
|
||||
case DST_SYMBOL:
|
||||
{
|
||||
const uint8_t *s = dst_unwrap_string(kvs[i].key);
|
||||
index = sqlite3_bind_parameter_index(
|
||||
stmt,
|
||||
(const char *)s);
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (index <= 0 || index > limitindex) {
|
||||
return "invalid index in sql parameters";
|
||||
}
|
||||
const char *err = bind1(stmt, index, kvs[i].value);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return "invalid type for sql parameters";
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Execute a statement but don't collect results */
|
||||
static const char *execute_drop(sqlite3_stmt *stmt) {
|
||||
int status;
|
||||
const char *ret = NULL;
|
||||
do {
|
||||
status = sqlite3_step(stmt);
|
||||
} while (status == SQLITE_ROW);
|
||||
/* Check for errors */
|
||||
if (status != SQLITE_DONE) {
|
||||
sqlite3 *db = sqlite3_db_handle(stmt);
|
||||
ret = sqlite3_errmsg(db);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Execute and return values from prepared statement */
|
||||
static const char *execute(sqlite3_stmt *stmt, DstArray *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);
|
||||
for (int i = 0; i < ncol; i++) {
|
||||
tupstart[i] = dst_cstringv(sqlite3_column_name(stmt, i));
|
||||
}
|
||||
const Dst *colnames = dst_tuple_end(tupstart);
|
||||
|
||||
do {
|
||||
status = sqlite3_step(stmt);
|
||||
if (status == SQLITE_ROW) {
|
||||
DstKV *row = dst_struct_begin(ncol);
|
||||
for (int i = 0; i < ncol; i++) {
|
||||
int t = sqlite3_column_type(stmt, i);
|
||||
Dst value;
|
||||
switch (t) {
|
||||
case SQLITE_NULL:
|
||||
value = dst_wrap_nil();
|
||||
break;
|
||||
case SQLITE_INTEGER:
|
||||
value = dst_wrap_integer(sqlite3_column_int(stmt, i));
|
||||
break;
|
||||
case SQLITE_FLOAT:
|
||||
value = dst_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);
|
||||
memcpy(str, sqlite3_column_text(stmt, i), nbytes);
|
||||
value = dst_wrap_string(dst_string_end(str));
|
||||
}
|
||||
break;
|
||||
case SQLITE_BLOB:
|
||||
{
|
||||
int nbytes = sqlite3_column_bytes(stmt, i);
|
||||
DstBuffer *b = dst_buffer(nbytes);
|
||||
memcpy(b->data, sqlite3_column_blob(stmt, i), nbytes);
|
||||
b->count = nbytes;
|
||||
value = dst_wrap_buffer(b);
|
||||
}
|
||||
break;
|
||||
}
|
||||
dst_struct_put(row, colnames[i], value);
|
||||
}
|
||||
dst_array_push(rows, dst_wrap_struct(dst_struct_end(row)));
|
||||
}
|
||||
} while (status == SQLITE_ROW);
|
||||
|
||||
/* Check for errors */
|
||||
if (status != SQLITE_DONE) {
|
||||
sqlite3 *db = sqlite3_db_handle(stmt);
|
||||
ret = sqlite3_errmsg(db);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Run a prepared statement */
|
||||
static int sql_exec(DstArgs args) {
|
||||
DST_MINARITY(args, 1);
|
||||
DST_MAXARITY(args, 2);
|
||||
DST_CHECKABSTRACT(args, 0, &sql_stmt_type);
|
||||
Stmt *stmt = (Stmt *)dst_unwrap_abstract(args.v[0]);
|
||||
if (args.n == 2) {
|
||||
const char *err = bindmany(stmt->handle, args.v[1]);
|
||||
if (err) {
|
||||
DST_THROW(args, err);
|
||||
}
|
||||
}
|
||||
DstArray *rows = dst_array(10);
|
||||
const char *err = execute(stmt->handle, rows);
|
||||
/* Reset the statement */
|
||||
sqlite3_reset(stmt->handle);
|
||||
sqlite3_clear_bindings(stmt->handle);
|
||||
if (err) {
|
||||
DST_THROW(args, err);
|
||||
}
|
||||
DST_RETURN_ARRAY(args, rows);
|
||||
}
|
||||
|
||||
/* Evaluate a string of sql */
|
||||
static int sql_eval(DstArgs 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]);
|
||||
DST_ARG_STRING(query, args, 1);
|
||||
if (has_null(query, dst_string_length(query))) {
|
||||
err = "cannot have embedded NULL in sql statememts";
|
||||
goto error;
|
||||
}
|
||||
DstArray *rows = dst_array(10);
|
||||
const char *c = (const char *)query;
|
||||
|
||||
/* Evaluate all statements in a loop */
|
||||
do {
|
||||
/* Compile the next statement */
|
||||
if (sqlite3_prepare_v2(db->handle, c, -1, &stmt_next, &c) != SQLITE_OK) {
|
||||
err = sqlite3_errmsg(db->handle);
|
||||
goto error;
|
||||
}
|
||||
/* Check if we have found last statement */
|
||||
if (NULL == stmt_next) {
|
||||
/* Execute current statement and collect results */
|
||||
if (stmt) {
|
||||
err = execute(stmt, rows);
|
||||
if (err) goto error;
|
||||
}
|
||||
} else {
|
||||
/* Execute and finalize current statement */
|
||||
if (stmt) {
|
||||
err = execute_drop(stmt);
|
||||
if (err) goto error;
|
||||
}
|
||||
/* Bind params to next statement*/
|
||||
if (args.n == 3) {
|
||||
/* parameters */
|
||||
err = bindmany(stmt_next, args.v[2]);
|
||||
if (err) goto error;
|
||||
}
|
||||
}
|
||||
/* rotate stmt and stmt_next */
|
||||
if (stmt) sqlite3_finalize(stmt);
|
||||
stmt = stmt_next;
|
||||
stmt_next = NULL;
|
||||
} while (NULL != stmt);
|
||||
|
||||
/* Good return path */
|
||||
DST_RETURN_ARRAY(args, rows);
|
||||
|
||||
error:
|
||||
if (stmt) sqlite3_finalize(stmt);
|
||||
if (stmt_next) sqlite3_finalize(stmt_next);
|
||||
DST_THROW(args, err);
|
||||
}
|
||||
|
||||
/* Convert int64_t to a string */
|
||||
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");
|
||||
/* Negative becomes pos */
|
||||
if (x < 0) {
|
||||
bytes[i++] = '-';
|
||||
x = -x;
|
||||
}
|
||||
while (x) {
|
||||
bytes[i++] = x % 10;
|
||||
x = x / 10;
|
||||
}
|
||||
bytes[i++] = '\0';
|
||||
return dst_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]);
|
||||
sqlite3_int64 id = sqlite3_last_insert_rowid(db->handle);
|
||||
if (id >= INT32_MIN && id <= INT32_MAX) {
|
||||
DST_RETURN_INTEGER(args, (int32_t) id);
|
||||
}
|
||||
/* Convert to string */
|
||||
DST_RETURN_STRING(args, coerce_int64(id));
|
||||
}
|
||||
|
||||
/*
|
||||
static int sql_tables(DstArgs args) {}
|
||||
static int sql_changes(DstArgs args) {}
|
||||
static int sql_timeout(DstArgs args) {}
|
||||
static int sql_rowid(DstArgs args) {}
|
||||
*/
|
||||
|
||||
/*****************************************************************************/
|
||||
|
|
@ -118,8 +452,11 @@ static int sql_rowid(DstArgs args) {}
|
|||
static const DstReg cfuns[] = {
|
||||
{"open", sql_open},
|
||||
{"close", sql_close},
|
||||
{"sql", sql_sql},
|
||||
/*{"tables", sql_tables},*/
|
||||
{"eval", sql_eval},
|
||||
{"prepare", sql_prepare},
|
||||
{"exec", sql_exec},
|
||||
{"finalize", sql_finalize},
|
||||
{"last-insert-rowid", sql_last_insert_rowid},
|
||||
/*{"changes", sql_changes},*/
|
||||
/*{"timeout", sql_timeout},*/
|
||||
/*{"rowid", sql_rowid},*/
|
||||
|
|
|
|||
|
|
@ -1093,7 +1093,7 @@ returned from compiling and running the file."
|
|||
|
||||
(def cache @{})
|
||||
(def loading @{})
|
||||
(fn [path args]
|
||||
(fn require [path args]
|
||||
(when (get loading path)
|
||||
(error (string "circular dependency: module " path " is loading")))
|
||||
(def {
|
||||
|
|
|
|||
|
|
@ -127,7 +127,7 @@ extern "C" {
|
|||
/* What to do when out of memory */
|
||||
#ifndef DST_OUT_OF_MEMORY
|
||||
#include <stdio.h>
|
||||
#define DST_OUT_OF_MEMORY do { printf("out of memory\n"); exit(1); } while (0)
|
||||
#define DST_OUT_OF_MEMORY do { printf("dst out of memory\n"); exit(1); } while (0)
|
||||
#endif
|
||||
|
||||
/* Helper for debugging */
|
||||
|
|
|
|||
|
|
@ -1,141 +0,0 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width" />
|
||||
<title>Dst</title>
|
||||
<style type="text/css" media="screen">
|
||||
/* http://meyerweb.com/eric/tools/css/reset/
|
||||
v2.0 | 20110126
|
||||
License: none (public domain)
|
||||
*/
|
||||
|
||||
html, body, div, span, applet, object, iframe,
|
||||
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
|
||||
a, abbr, acronym, address, big, cite, code,
|
||||
del, dfn, em, img, ins, kbd, q, s, samp,
|
||||
small, strike, strong, sub, sup, tt, var,
|
||||
b, u, i, center,
|
||||
dl, dt, dd, ol, ul, li,
|
||||
fieldset, form, label, legend,
|
||||
table, caption, tbody, tfoot, thead, tr, th, td,
|
||||
article, aside, canvas, details, embed,
|
||||
figure, figcaption, footer, header, hgroup,
|
||||
menu, nav, output, ruby, section, summary,
|
||||
time, mark, audio, video {
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
border: 0;
|
||||
font-size: 100%;
|
||||
font: inherit;
|
||||
vertical-align: baseline;
|
||||
}
|
||||
/* HTML5 display-role reset for older browsers */
|
||||
article, aside, details, figcaption, figure,
|
||||
footer, header, hgroup, menu, nav, section {
|
||||
display: block;
|
||||
}
|
||||
body {
|
||||
line-height: 1;
|
||||
}
|
||||
ol, ul {
|
||||
list-style: none;
|
||||
}
|
||||
blockquote, q {
|
||||
quotes: none;
|
||||
}
|
||||
blockquote:before, blockquote:after,
|
||||
q:before, q:after {
|
||||
content: '';
|
||||
content: none;
|
||||
}
|
||||
table {
|
||||
border-collapse: collapse;
|
||||
border-spacing: 0;
|
||||
}
|
||||
|
||||
#prompt {
|
||||
white-space: nowrap;
|
||||
width: calc(100% - 14px);
|
||||
overflow: hidden;
|
||||
font-family: monospace;
|
||||
border: solid 2px black;
|
||||
padding: 5px;
|
||||
}
|
||||
#prompt br {
|
||||
display:none;
|
||||
}
|
||||
#prompt * {
|
||||
display:inline;
|
||||
white-space:nowrap;
|
||||
}
|
||||
|
||||
|
||||
#console {
|
||||
border: solid 2px black;
|
||||
width: calc(100% - 4px);
|
||||
min-height: 200px;
|
||||
font-family: monospace;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<pre id="console"></pre>
|
||||
<div contenteditable="true" id="prompt"></div>
|
||||
<script>
|
||||
var con = document.getElementById('console');
|
||||
var Module = {
|
||||
|
||||
preRun: function() {
|
||||
var input = "";
|
||||
var i = 0;
|
||||
function stdin() {
|
||||
if (input === "") {
|
||||
input = prompt('Input:');
|
||||
}
|
||||
if (i < input.length) {
|
||||
var code = input.charCodeAt(i);
|
||||
++i;
|
||||
return code;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function appendChunk(chunk) {
|
||||
con.innerText += chunk + '\n';
|
||||
}
|
||||
|
||||
var outbuf = "";
|
||||
function stdout(asciiCode) {
|
||||
if (asciiCode === 10) {
|
||||
appendChunk(outbuf);
|
||||
outbuf = '';
|
||||
} else if (asciiCode === null) {
|
||||
appendChunk(outbuf);
|
||||
outbuf = ' ... ';
|
||||
} else {
|
||||
outbuf += String.fromCharCode(asciiCode);
|
||||
}
|
||||
}
|
||||
|
||||
var errbuf = "";
|
||||
function stderr(asciiCode) {
|
||||
if (asciiCode == 10) {
|
||||
appendChunk(errbuf);
|
||||
errbuf = '';
|
||||
} else if (asciiCode === null) {
|
||||
appendChunk(errbuf);
|
||||
errbuf = ' ... ';
|
||||
} else {
|
||||
errbuf += String.fromCharCode(asciiCode);
|
||||
}
|
||||
}
|
||||
|
||||
FS.init(stdin, stdout, stderr);
|
||||
}
|
||||
};
|
||||
</script>
|
||||
<script src="dst.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2018 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 <dst/dst.h>
|
||||
#include <dst/dstcompile.h>
|
||||
|
||||
// emscripten client code to go here
|
||||
Loading…
Reference in New Issue
Block a user