Bruce/tomo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity
4d3ea3f73e
tomo/repl.c

534 lines
19 KiB
C
Raw Blame History

// A Read-Evaluate-Print-Loop
#include <dlfcn.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "builtins/tomo.h"
#include "typecheck.h"
#include "parse.h"
typedef union {
int8_t i8;
int16_t i16;
int32_t i32;
int64_t i64;
double n64;
float n32;
} number_t;
static jmp_buf on_err;
static void run(env_t *env, ast_t *ast);
static void eval(env_t *env, ast_t *ast, void *dest);
void repl(void)
{
env_t *env = new_compilation_unit(NULL);
void *dl = dlopen("libtomo.so", RTLD_LAZY);
if (!dl) errx(1, "I couldn't find libtomo.so in your library paths");
size_t buf_size = 0;
char *line = NULL;
ssize_t len = 0;
if (setjmp(on_err))
printf("\n");
printf("\x1b[33;1m>>\x1b[m ");
fflush(stdout);
while ((len=getline(&line, &buf_size, stdin)) >= 0) {
if (len > 1) {
char *code = line;
#define starts_with(line, prefix) (strncmp(line, prefix " ", strlen(prefix)+1) == 0)
if (starts_with(line, "if") || starts_with(line, "for") || starts_with(line, "while")
|| starts_with(line, "func") || starts_with(line, "struct") || starts_with(line, "lang")) {
printf("\x1b[33;1m..\x1b[m ");
fflush(stdout);
code = heap_str(line);
while ((len=getline(&line, &buf_size, stdin)) >= 0) {
if (len == 1) break;
code = heap_strf("%s%s", code, line);
printf("\x1b[33;1m..\x1b[m ");
fflush(stdout);
}
} else {
code = heap_strf("func main(): >> %s", code);
}
file_t *f = spoof_file("<repl>", code);
ast_t *ast = parse_file(f, &on_err);
ast_t *doctest = Match(Match(Match(ast, Block)->statements->ast, FunctionDef)->body, Block)->statements->ast;
if (doctest->tag == DocTest) doctest->__data.DocTest.skip_source = 1;
run(env, doctest);
}
printf("\x1b[33;1m>>\x1b[m ");
fflush(stdout);
}
if (line) free(line);
printf("\n");
}
__attribute__((noreturn))
static void repl_err(ast_t *node, const char *fmt, ...)
{
bool color = isatty(STDERR_FILENO) && !getenv("NO_COLOR");
if (color)
fputs("\x1b[31;7;1m", stderr);
if (node)
fprintf(stderr, "%s:%ld.%ld: ", node->file->relative_filename, get_line_number(node->file, node->start),
get_line_column(node->file, node->start));
va_list args;
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
if (color)
fputs(" \x1b[m", stderr);
fputs("\n\n", stderr);
if (node)
highlight_error(node->file, node->start, node->end, "\x1b[31;1m", 2, color);
longjmp(on_err, 1);
}
const TypeInfo *type_to_type_info(type_t *t)
{
switch (t->tag) {
case AbortType: return &$Abort;
case VoidType: return &$Void;
case MemoryType: return &$Memory;
case BoolType: return &$Bool;
case IntType:
switch (Match(t, IntType)->bits) {
case 0: case 64: return &$Int;
case 32: return &$Int32;
case 16: return &$Int16;
case 8: return &$Int8;
default: errx(1, "Invalid bits");
}
case NumType:
switch (Match(t, NumType)->bits) {
case 0: case 64: return &$Num;
case 32: return &$Num32;
default: errx(1, "Invalid bits");
}
case TextType: return &$Text;
case ArrayType: {
const TypeInfo *item_info = type_to_type_info(Match(t, ArrayType)->item_type);
const TypeInfo array_info = {.size=sizeof(array_t), .align=__alignof__(array_t),
.tag=ArrayInfo, .ArrayInfo.item=item_info};
return memcpy(GC_MALLOC(sizeof(TypeInfo)), &array_info, sizeof(TypeInfo));
}
case TableType: {
const TypeInfo *key_info = type_to_type_info(Match(t, TableType)->key_type);
const TypeInfo *value_info = type_to_type_info(Match(t, TableType)->value_type);
const TypeInfo table_info = {
.size=sizeof(table_t), .align=__alignof__(table_t),
.tag=TableInfo, .TableInfo.key=key_info, .TableInfo.value=value_info};
return memcpy(GC_MALLOC(sizeof(TypeInfo)), &table_info, sizeof(TypeInfo));
}
case PointerType: {
auto ptr = Match(t, PointerType);
CORD sigil = ptr->is_stack ? "&" : "@";
if (ptr->is_readonly) sigil = CORD_cat(sigil, "%");
const TypeInfo *pointed_info = type_to_type_info(ptr->pointed);
const TypeInfo pointer_info = {.size=sizeof(void*), .align=__alignof__(void*),
.tag=PointerInfo, .PointerInfo={.sigil=sigil, .pointed=pointed_info, .is_optional=ptr->is_optional}};
return memcpy(GC_MALLOC(sizeof(TypeInfo)), &pointer_info, sizeof(TypeInfo));
}
default: errx(1, "Unsupported type: %T", t);
}
}
static void *get_address(env_t *env, ast_t *ast)
{
switch (ast->tag) {
case Var: {
binding_t *b = get_binding(env, Match(ast, Var)->name);
if (!b) repl_err(ast, "No such variable");
return b->value;
}
default: errx(1, "Address not implemented for %W", ast);
}
}
static int64_t ast_to_int(env_t *env, ast_t *ast)
{
type_t *t = get_type(env, ast);
switch (t->tag) {
case IntType: {
number_t num;
eval(env, ast, &num);
switch (Match(t, IntType)->bits) {
case 0: case 64: return (int64_t)num.i64;
case 32: return (int64_t)num.i32;
case 16: return (int64_t)num.i16;
case 8: return (int64_t)num.i8;
default: errx(1, "Invalid int bits");
}
}
default: repl_err(NULL, "Cannot convert to integer");
}
}
static double ast_to_num(env_t *env, ast_t *ast)
{
type_t *t = get_type(env, ast);
switch (t->tag) {
case IntType: {
number_t num;
eval(env, ast, &num);
switch (Match(t, IntType)->bits) {
case 0: case 64: return (double)num.i64;
case 32: return (double)num.i32;
case 16: return (double)num.i16;
case 8: return (double)num.i8;
default: errx(1, "Invalid int bits");
}
}
case NumType: {
number_t num;
eval(env, ast, &num);
return Match(t, NumType)->bits == 32 ? (double)num.n32 : (double)num.n64;
}
default: repl_err(NULL, "Cannot convert to number");
}
}
static CORD obj_to_text(type_t *t, const void *obj, bool use_color)
{
const TypeInfo *info = type_to_type_info(t);
return generic_as_text(obj, use_color, info);
}
void run(env_t *env, ast_t *ast)
{
switch (ast->tag) {
case Declare: {
auto decl = Match(ast, Declare);
const char *name = Match(decl->var, Var)->name;
type_t *type = get_type(env, decl->value);
binding_t *binding = new(binding_t, .type=type, .value=GC_MALLOC(type_size(type)));
eval(env, decl->value, binding->value);
set_binding(env, name, binding);
break;
}
case Assign: {
auto assign = Match(ast, Assign);
int64_t n = 0;
for (ast_list_t *t = assign->targets; t; t = t->next)
++n;
for (ast_list_t *val = assign->values, *target = assign->targets; val && target; val = val->next, target = target->next) {
type_t *t_target = get_type(env, target->ast);
type_t *t_val = get_type(env, val->ast);
if (!type_eq(t_val, t_target))
repl_err(target->ast, "This value has type %T but I expected a %T", t_val, t_target);
if (!can_be_mutated(env, target->ast)) {
if (target->ast->tag == Index || target->ast->tag == FieldAccess) {
ast_t *subject = target->ast->tag == Index ? Match(target->ast, Index)->indexed : Match(target->ast, FieldAccess)->fielded;
repl_err(subject, "This is an immutable value, you can't assign to it");
} else {
repl_err(target->ast, "This is a value of type %T and can't be assigned to", get_type(env, target->ast));
}
}
}
for (ast_list_t *val = assign->values, *target = assign->targets; val && target; val = val->next, target = target->next) {
switch (target->ast->tag) {
case Var: {
void *dest = get_address(env, target->ast);
eval(env, val->ast, dest);
break;
}
// case Index: {
// auto index = Match(target->ast, Index);
// type_t *obj_t = get_type(env, index->indexed);
// TypeInfo *table_info = type_to_type_info(t);
// }
default: errx(1, "Assignment not implemented: %W", target->ast);
}
}
break;
}
case DocTest: {
auto doctest = Match(ast, DocTest);
type_t *t = get_type(env, doctest->expr);
size_t size = t ? type_size(t) : 0;
if (size == 0) {
run(env, doctest->expr);
} else {
void *value = GC_MALLOC(size);
eval(env, doctest->expr, value);
CORD c = obj_to_text(t, value, true);
printf("= %s \x1b[2m: %T\x1b[m\n", CORD_to_const_char_star(c), t);
fflush(stdout);
}
break;
}
case Block: {
auto block = Match(ast, Block);
for (ast_list_t *stmt = block->statements; stmt; stmt = stmt->next) {
run(env, stmt->ast);
}
break;
}
// UpdateAssign,
// FunctionDef,
// For, While, If, When,
// Skip, Stop, Pass,
// Return,
// Extern,
// StructDef, EnumDef, LangDef,
// DocTest,
// Use,
// LinkerDirective,
// InlineCCode,
case If: {
auto if_ = Match(ast, If);
bool condition;
type_t *cond_t = get_type(env, if_->condition);
assert(cond_t->tag == BoolType);
eval(env, if_->condition, &condition);
if (condition) {
run(env, if_->body);
} else if (if_->else_body) {
run(env, if_->else_body);
}
break;
}
case While: {
auto while_ = Match(ast, While);
bool condition;
type_t *cond_t = get_type(env, while_->condition);
assert(cond_t->tag == BoolType);
for (;;) {
eval(env, while_->condition, &condition);
if (!condition) break;
run(env, while_->body);
}
break;
}
// case For: {
// auto for_ = Match(ast, For);
// }
default: {
eval(env, ast, NULL);
break;
}
}
}
void eval(env_t *env, ast_t *ast, void *dest)
{
type_t *t = get_type(env, ast);
size_t size = type_size(t);
switch (ast->tag) {
case Nil:
if (dest) *(void**)dest = 0;
break;
case Bool:
if (dest) *(bool*)dest = Match(ast, Bool)->b;
break;
case Var: {
if (!dest) return;
binding_t *b = get_binding(env, Match(ast, Var)->name);
if (!b)
repl_err(ast, "No such variable: %s", Match(ast, Var)->name);
memcpy(dest, b->value, size);
break;
}
case Int: {
if (!dest) return;
switch (Match(ast, Int)->bits) {
case 0: case 64: *(int64_t*)dest = Match(ast, Int)->i; break;
case 32: *(int32_t*)dest = Match(ast, Int)->i; break;
case 16: *(int16_t*)dest = Match(ast, Int)->i; break;
case 8: *(int8_t*)dest = Match(ast, Int)->i; break;
default: errx(1, "Invalid int bits: %ld", Match(ast, Int)->bits);
}
break;
}
case Num: {
if (!dest) return;
switch (Match(ast, Num)->bits) {
case 0: case 64: *(double*)dest = Match(ast, Num)->n; break;
case 32: *(float*)dest = Match(ast, Num)->n; break;
default: errx(1, "Invalid num bits: %ld", Match(ast, Num)->bits);
}
break;
}
case TextLiteral:
if (dest) *(CORD*)dest = Match(ast, TextLiteral)->cord;
break;
case TextJoin: {
CORD ret = CORD_EMPTY;
for (ast_list_t *chunk = Match(ast, TextJoin)->children; chunk; chunk = chunk->next) {
type_t *chunk_t = get_type(env, chunk->ast);
if (chunk_t->tag == TextType) {
CORD c;
eval(env, chunk->ast, &c);
ret = CORD_cat(ret, c);
} else {
size_t chunk_size = type_size(chunk_t);
char buf[chunk_size];
eval(env, chunk->ast, buf);
ret = CORD_cat(ret, obj_to_text(chunk_t, buf, false));
}
}
if (dest) *(CORD*)dest = ret;
break;
}
#define CASE_OP(OP_NAME, C_OP) case BINOP_##OP_NAME: {\
if (t->tag == IntType) { \
int64_t lhs = ast_to_int(env, binop->lhs); \
int64_t rhs = ast_to_int(env, binop->rhs); \
switch (Match(t, IntType)->bits) { \
case 64: *(int64_t*)dest = lhs C_OP rhs; break; \
case 32: *(int32_t*)dest = (int32_t)(lhs C_OP rhs); break; \
case 16: *(int16_t*)dest = (int16_t)(lhs C_OP rhs); break; \
case 8: *(int8_t*)dest = (int8_t)(lhs C_OP rhs); break; \
default: errx(1, "Invalid int bits"); \
} \
} else if (t->tag == NumType) { \
double lhs = ast_to_num(env, binop->lhs); \
double rhs = ast_to_num(env, binop->rhs); \
if (Match(t, NumType)->bits == 64) \
*(double*)dest = (double)(lhs C_OP rhs); \
else \
*(float*)dest = (float)(lhs C_OP rhs); \
} else { \
errx(1, "Binary ops are not yet supported for %W", ast); \
} \
break; \
}
case BinaryOp: {
auto binop = Match(ast, BinaryOp);
switch (binop->op) {
CASE_OP(MULT, *) CASE_OP(DIVIDE, /) CASE_OP(PLUS, +) CASE_OP(MINUS, -)
case BINOP_EQ: case BINOP_NE: case BINOP_LT: case BINOP_LE: case BINOP_GT: case BINOP_GE: {
type_t *t_lhs = get_type(env, binop->lhs);
if (!type_eq(t_lhs, get_type(env, binop->rhs)))
repl_err(ast, "Comparisons between different types aren't supported");
const TypeInfo *info = type_to_type_info(t_lhs);
size_t value_size = type_size(t_lhs);
char lhs[value_size], rhs[value_size];
eval(env, binop->lhs, lhs);
eval(env, binop->rhs, rhs);
int cmp = generic_compare(lhs, rhs, info);
switch (binop->op) {
case BINOP_EQ: *(bool*)dest = (cmp == 0); break;
case BINOP_NE: *(bool*)dest = (cmp != 0); break;
case BINOP_GT: *(bool*)dest = (cmp > 0); break;
case BINOP_GE: *(bool*)dest = (cmp >= 0); break;
case BINOP_LT: *(bool*)dest = (cmp < 0); break;
case BINOP_LE: *(bool*)dest = (cmp <= 0); break;
default: break;
}
break;
}
default: errx(1, "Binary op not implemented: %W");
}
break;
}
case Index: {
auto index = Match(ast, Index);
type_t *indexed_t = get_type(env, index->indexed);
// type_t *index_t = get_type(env, index->index);
switch (indexed_t->tag) {
case ArrayType: {
array_t arr;
eval(env, index->indexed, &arr);
int64_t raw_index = ast_to_int(env, index->index);
int64_t index_int = raw_index;
if (index_int < 1) index_int = arr.length + index_int + 1;
if (index_int < 1 || index_int > arr.length)
repl_err(index->index, "%ld is an invalid index for an array with length %ld",
raw_index, arr.length);
size_t item_size = type_size(Match(indexed_t, ArrayType)->item_type);
memcpy(dest, arr.data + arr.stride*(index_int-1), item_size);
break;
}
case TableType: {
table_t table;
eval(env, index->indexed, &table);
type_t *key_type = Match(indexed_t, TableType)->key_type;
size_t key_size = type_size(key_type);
char key_buf[key_size];
eval(env, index->index, key_buf);
const TypeInfo *table_info = type_to_type_info(indexed_t);
memcpy(dest, Table$get(table, key_buf, table_info), key_size);
break;
}
case PointerType: {
auto ptr = Match(indexed_t, PointerType);
if (ptr->is_optional)
repl_err(ast, "You can't dereference an optional pointer because it might be null");
size_t pointed_size = type_size(ptr->pointed);
void *pointer;
eval(env, index->indexed, &pointer);
memcpy(dest, pointer, pointed_size);
break;
}
default: errx(1, "Indexing is not supported for %T", indexed_t);
}
break;
}
case Array: {
assert(t->tag == ArrayType);
array_t arr = {};
size_t item_size = type_size(Match(t, ArrayType)->item_type);
char item_buf[item_size] = {};
const TypeInfo *type_info = type_to_type_info(t);
for (ast_list_t *item = Match(ast, Array)->items; item; item = item->next) {
eval(env, item->ast, item_buf);
Array$insert(&arr, item_buf, 0, type_info);
}
memcpy(dest, &arr, sizeof(array_t));
break;
}
case Table: {
assert(t->tag == TableType);
auto table_ast = Match(ast, Table);
table_t table = {};
size_t key_size = type_size(Match(t, TableType)->key_type);
size_t value_size = type_size(Match(t, TableType)->value_type);
char key_buf[key_size] = {};
char value_buf[value_size] = {};
const TypeInfo *table_info = type_to_type_info(t);
assert(table_info->tag == TableInfo);
for (ast_list_t *entry = table_ast->entries; entry; entry = entry->next) {
auto e = Match(entry->ast, TableEntry);
eval(env, e->key, key_buf);
eval(env, e->value, value_buf);
Table$set(&table, key_buf, value_buf, table_info);
}
if (table_ast->fallback)
eval(env, table_ast->fallback, &table.fallback);
if (table_ast->default_value) {
table.default_value = GC_MALLOC(value_size);
eval(env, table_ast->default_value, table.default_value);
}
memcpy(dest, &table, sizeof(table_t));
break;
}
case Block: {
auto block = Match(ast, Block);
for (ast_list_t *stmt = block->statements; stmt; stmt = stmt->next) {
if (stmt->next)
run(env, stmt->ast);
else
eval(env, stmt->ast, dest);
}
break;
}
default:
errx(1, "Eval not implemented for %W", ast);
}
}
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
Reference in New Issue View Git Blame Copy Permalink