Bruce/tomo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Updates and functionality

Browse Source
This commit is contained in:
Bruce Hill 2024-02-04 18:04:41 -05:00
parent 98f0c51119
commit b08a0d3e2b
9 changed files with 217 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
*.o
nextlang
tags

9
ast.c
View File

@ -9,6 +9,7 @@
static const char *OP_NAMES[] = {
[BINOP_UNKNOWN]="unknown",
[UNOP_NOT]="not", [UNOP_NEGATIVE]="negative",
[UNOP_HEAP_ALLOCATE]="@", [UNOP_STACK_REFERENCE]="&",
[BINOP_POWER]="^", [BINOP_MULT]="*", [BINOP_DIVIDE]="/",
[BINOP_MOD]="mod", [BINOP_MOD1]="mod1", [BINOP_PLUS]="+", [BINOP_MINUS]="minus",
[BINOP_CONCAT]="++", [BINOP_LSHIFT]="<<", [BINOP_RSHIFT]=">>", [BINOP_MIN]="min",
@ -52,8 +53,8 @@ CORD ast_list_to_cord(ast_list_t *asts)
CORD arg_list_to_cord(arg_list_t *args) {
CORD c = "Args(";
for (; args; args = args->next) {
if (args->var && args->var->name)
c = CORD_cat(c, args->var->name);
if (args->var.name)
c = CORD_cat(c, args->var.name);
if (args->type)
CORD_sprintf(&c, "%r:%s", c, type_ast_to_cord(args->type));
if (args->default_val)
@ -86,8 +87,8 @@ CORD ast_to_cord(ast_t *ast)
T(Nil, "(%r)", type_ast_to_cord(data.type))
T(Bool, "(\x1b[35m%s\x1b[m)", data.b ? "yes" : "no")
T(Var, "(\x1b[36;1m%s\x1b[m)", data.var.name)
T(Int, "(\x1b[35m%ld\x1b[m, precision=%ld)", data.i, data.precision)
T(Num, "(\x1b[35m%ld\x1b[m, precision=%ld)", data.n, data.precision)
T(Int, "(\x1b[35m%ld\x1b[m, precision=\x1b[35m%ld\x1b[m)", data.i, data.precision)
T(Num, "(\x1b[35m%ld\x1b[m, precision=\x1b[35m%ld\x1b[m)", data.n, data.precision)
T(Char, "(\x1b[35m'%c'\x1b[m)", data.c)
T(StringLiteral, "\x1b[35m\"%s\"\x1b[m", data.str)
T(StringJoin, "(%r)", ast_list_to_cord(data.children))

2
ast.h
View File

@ -30,7 +30,7 @@ typedef struct ast_list_s {
} ast_list_t;
typedef struct arg_list_s {
var_t *var;
var_t var;
type_ast_t *type;
ast_t *default_val;
struct arg_list_s *next;

104
compile.c
View File

@ -5,16 +5,28 @@
#include <stdio.h>
#include "ast.h"
#include "compile.h"
#include "util.h"
static CORD compile_type(type_ast_t *t)
CORD compile_type(type_ast_t *t)
{
switch (t->tag) {
case TypeVar: return Match(t, TypeVar)->var.name;
case TypeVar: return CORD_cat(Match(t, TypeVar)->var.name, "_t");
default: errx(1, "Not implemented");
}
}
static inline CORD compile_statement(ast_t *ast)
{
CORD code = compile(ast);
switch (ast->tag) {
case If: case For: case While: case FunctionDef:
return code;
default:
return CORD_cat(code, ";");
}
}
CORD compile(ast_t *ast)
{
switch (ast->tag) {
@ -86,86 +98,96 @@ CORD compile(ast_t *ast)
}
case StringLiteral: {
const char *str = Match(ast, StringLiteral)->str;
CORD c = "\"";
CORD code = "\"";
for (; *str; ++str) {
switch (*str) {
case '\\': c = CORD_cat(c, "\\\\"); break;
case '"': c = CORD_cat(c, "\\\""); break;
case '\a': c = CORD_cat(c, "\\a"); break;
case '\b': c = CORD_cat(c, "\\b"); break;
case '\n': c = CORD_cat(c, "\\n"); break;
case '\r': c = CORD_cat(c, "\\r"); break;
case '\t': c = CORD_cat(c, "\\t"); break;
case '\v': c = CORD_cat(c, "\\v"); break;
case '\\': code = CORD_cat(code, "\\\\"); break;
case '"': code = CORD_cat(code, "\\\""); break;
case '\a': code = CORD_cat(code, "\\a"); break;
case '\b': code = CORD_cat(code, "\\b"); break;
case '\n': code = CORD_cat(code, "\\n"); break;
case '\r': code = CORD_cat(code, "\\r"); break;
case '\t': code = CORD_cat(code, "\\t"); break;
case '\v': code = CORD_cat(code, "\\v"); break;
default: {
if (isprint(*str))
c = CORD_cat_char(c, *str);
code = CORD_cat_char(code, *str);
else
CORD_sprintf(&c, "%r\\x%02X", *str);
CORD_sprintf(&code, "%r\\x%02X", *str);
break;
}
}
}
return CORD_cat_char(c, '"');
return CORD_cat_char(code, '"');
}
case StringJoin: {
CORD c = NULL;
CORD code = NULL;
for (ast_list_t *chunk = Match(ast, StringJoin)->children; chunk; chunk = chunk->next) {
if (c) CORD_sprintf(&c, "CORD_cat(%r, %r)", c, compile(chunk->ast));
else c = compile(chunk->ast);
if (code) CORD_sprintf(&code, "CORD_cat(%r, %r)", code, compile(chunk->ast));
else code = compile(chunk->ast);
}
return c;
return code;
}
case Interp: {
return CORD_asprintf("__cord(%r)", compile(Match(ast, Interp)->value));
}
case Block: {
CORD c = NULL;
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
c = CORD_cat(c, compile(stmt->ast));
c = CORD_cat(c, ";\n");
ast_list_t *stmts = Match(ast, Block)->statements;
if (stmts && !stmts->next)
return compile_statement(stmts->ast);
CORD code = "{\n";
for (ast_list_t *stmt = stmts; stmt; stmt = stmt->next) {
code = CORD_cat(code, compile_statement(stmt->ast));
code = CORD_cat(code, "\n");
}
return c;
return CORD_cat(code, "}");
}
case Declare: {
auto decl = Match(ast, Declare);
return CORD_asprintf("auto %r = %r", decl->var, decl->value);
return CORD_asprintf("__declare(%r, %r)", compile(decl->var), compile(decl->value));
}
case Assign: {
auto assign = Match(ast, Assign);
CORD c = NULL;
CORD code = NULL;
for (ast_list_t *target = assign->targets, *value = assign->values; target && value; target = target->next, value = value->next) {
CORD_sprintf(&c, "%r = %r", compile(target->ast), compile(value->ast));
if (target->next) c = CORD_cat(c, ", ");
CORD_sprintf(&code, "%r = %r", compile(target->ast), compile(value->ast));
if (target->next) code = CORD_cat(code, ", ");
}
return c;
return code;
}
// Min, Max,
// Array, Table, TableEntry,
case FunctionDef: {
auto fndef = Match(ast, FunctionDef);
CORD c = CORD_asprintf("%r %r(", fndef->ret_type ? compile_type(fndef->ret_type) : "void", compile(fndef->name));
CORD code = CORD_asprintf("%r %r(", fndef->ret_type ? compile_type(fndef->ret_type) : "void", compile(fndef->name));
for (arg_list_t *arg = fndef->args; arg; arg = arg->next) {
CORD_sprintf(&c, "%r%r %s", c, compile_type(arg->type), arg->var->name);
if (arg->next) c = CORD_cat(c, ", ");
CORD_sprintf(&code, "%r%r %s", code, compile_type(arg->type), arg->var.name);
if (arg->next) code = CORD_cat(code, ", ");
}
c = CORD_cat(c, ") {\n");
c = CORD_cat(c, compile(fndef->body));
c = CORD_cat(c, "}");
return c;
code = CORD_cat(code, ") ");
code = CORD_cat(code, compile(fndef->body));
return code;
}
case FunctionCall: {
auto call = Match(ast, FunctionCall);
CORD c = CORD_cat_char(compile(call->fn), '(');
CORD code = CORD_cat_char(compile(call->fn), '(');
for (ast_list_t *arg = call->args; arg; arg = arg->next) {
c = CORD_cat(c, compile(arg->ast));
if (arg->next) c = CORD_cat(c, ", ");
code = CORD_cat(code, compile(arg->ast));
if (arg->next) code = CORD_cat(code, ", ");
}
return CORD_cat_char(c, ')');
return CORD_cat_char(code, ')');
}
// Lambda,
// FunctionCall, KeywordArg,
// Block,
// KeywordArg,
case If: {
auto if_ = Match(ast, If);
CORD code;
CORD_sprintf(&code, "if (%r) %r", compile(if_->condition), compile(if_->body));
if (if_->else_body)
CORD_sprintf(&code, "%r\nelse %r", code, compile(if_->else_body));
return code;
}
// For, While, If,
// Reduction,
// Skip, Stop, Pass,

1
compile.h
View File

@ -6,6 +6,7 @@
#include "util.h"
CORD compile_type(type_ast_t *t);
CORD compile(ast_t *ast);
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

24
foo.c
View File

@ -1,12 +1,18 @@
#include <stdio.h>
#include "nextlang.h"
static void foo(Int64 x);
void foo(Int64 x)
{
say("Hello world!");
}
int main(int argc, const char *argv[])
{
(void) argc;
(void) argv;
foo(((Int64_t) 5));
int main(void) {
int x = 23;
const char *s = "Hi";
#define say(x) _Generic(x, int: printf("%d\n", x), char *: puts(s), default: puts("???"))
say(x);
say(s);
#define all(...) { __VA_ARGS__; }
all(say("one"); say(2))
return 0;
}

79
nextlang.c
View File

@ -11,12 +11,83 @@ int main(int argc, char *argv[])
{
if (argc < 2) return 1;
const char *autofmt = getenv("AUTOFMT");
if (!autofmt) autofmt = "indent -kr -nut | bat --file-name=out.c";
setenv("SSSPATH", ".", 0);
sss_file_t *f = sss_load_file(argv[1]);
ast_t *ast = parse_file(f, NULL);
const char *s = ast_to_str(ast);
puts(s);
CORD c = compile(ast);
CORD_put(c, stdout);
if (!ast)
errx(1, "Could not compile!");
if (getenv("VERBOSE")) {
FILE *out = popen("bat --file-name=AST", "w");
fputs(ast_to_str(ast), out);
fclose(out);
}
// Predeclare funcs:
CORD code = "#include \"nextlang.h\"\n\n";
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
switch (stmt->ast->tag) {
case FunctionDef: {
auto fndef = Match(stmt->ast, FunctionDef);
CORD_sprintf(&code, "%rstatic %r %r(", code, fndef->ret_type ? compile_type(fndef->ret_type) : "void", compile(fndef->name));
for (arg_list_t *arg = fndef->args; arg; arg = arg->next) {
CORD_sprintf(&code, "%r%r %s", code, compile_type(arg->type), arg->var.name);
if (arg->next) code = CORD_cat(code, ", ");
}
code = CORD_cat(code, ");\n");
break;
}
default: break;
}
}
// Declare funcs:
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
switch (stmt->ast->tag) {
case FunctionDef: {
CORD_sprintf(&code, "%r\n\n%r", code, compile(stmt->ast));
break;
}
default: break;
}
}
// Main body:
code = CORD_cat(code, "\n\nint main(int argc, const char *argv[]) {\n"
"(void)argc;\n"
"(void)argv;\n"
"GC_INIT();\n\n");
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
switch (stmt->ast->tag) {
case FunctionDef: break;
default: {
code = CORD_cat(code, compile(stmt->ast));
code = CORD_cat(code, ";\n");
break;
}
}
}
code = CORD_cat(code, "\nreturn 0;\n}\n");
if (getenv("VERBOSE")) {
FILE *out = popen(autofmt, "w");
CORD_put(code, out);
fclose(out);
}
const char *flags = getenv("CFLAGS");
if (!flags) flags = "-std=c11 -lm -lgc -lcord";
const char *run = heap_strf(getenv("VERBOSE") ? "tcc %s -run - | bat --file-name=output.txt" : "tcc %s -run -", flags);
FILE *cc = popen(run, "w");
CORD_put(code, cc);
fclose(cc);
return 0;
}

40
nextlang.h Normal file
View File

@ -0,0 +1,40 @@
#pragma once
#include <gc.h>
#include <gc/cord.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#define Int64_t int64_t
#define Int32_t int32_t
#define Int16_t int16_t
#define Int8_t int8_t
#define Num64_t double
#define Num32_t float
#define String_t CORD
#define Char_t char
#define Bool_t bool
#define Void_t void
#ifndef auto
#define auto __auto_type
#endif
#define CORD_asprintf(...) ({ CORD __c; CORD_sprintf(&__c, __VA_ARGS__); __c; })
#define __declare(var, val) __typeof(val) var = val
#define __cord(x) _Generic(x, bool: x ? "yes" : "no", \
int16_t: CORD_asprintf("%d", x), int32_t: CORD_asprintf("%d", x), int64_t: CORD_asprintf("%ld", x), \
double: CORD_asprintf("%g", x), float: CORD_asprintf("%g", x), \
CORD: x, \
default: "???")
#define __heap(x) (__typeof(x)*)memcpy(GC_MALLOC(sizeof(x)), (__typeof(x)[1]){x}, sizeof(x))
#define __stack(x) (&(__typeof(x)){x})
#define say(str) puts(CORD_to_const_char_star(str))

28
parse.c
View File

@ -1529,12 +1529,12 @@ arg_list_t *parse_args(parse_ctx_t *ctx, const char **pos, bool allow_unnamed)
ast_t *default_val = NULL;
type_ast_t *type = NULL;
typedef struct var_list_s {
var_t *var;
struct var_list_s *next;
} var_list_t;
typedef struct name_list_s {
const char *name;
struct name_list_s *next;
} name_list_t;
var_list_t *vars = NULL;
name_list_t *names = NULL;
for (;;) {
whitespace(pos);
const char *name_start = *pos;
@ -1543,34 +1543,34 @@ arg_list_t *parse_args(parse_ctx_t *ctx, const char **pos, bool allow_unnamed)
whitespace(pos);
if (strncmp(*pos, "==", 2) != 0 && match(pos, "=")) {
default_val = expect(ctx, *pos-1, pos, parse_term, "I expected a value after this '='");
vars = new(var_list_t, .var=new(var_t, .name=name), .next=vars);
names = new(name_list_t, .name=name, .next=names);
break;
} else if (match(pos, ":")) {
type = expect(ctx, *pos-1, pos, parse_type, "I expected a type here");
vars = new(var_list_t, .var=new(var_t, .name=name), .next=vars);
names = new(name_list_t, .name=name, .next=names);
break;
} else if (allow_unnamed) {
*pos = name_start;
type = optional(ctx, pos, parse_type);
if (type)
vars = new(var_list_t, .var=NULL, .next=vars);
names = new(name_list_t, .name=NULL, .next=names);
break;
} else if (name) {
vars = new(var_list_t, .var=new(var_t, .name=name), .next=vars);
names = new(name_list_t, .name=name, .next=names);
spaces(pos);
if (!match(pos, ",")) break;
} else {
break;
}
}
if (!vars) break;
if (!names) break;
if (!default_val && !type)
parser_err(ctx, batch_start, *pos, "I expected a ':' and type, or '=' and a default value after this parameter (%s)",
vars->var->name);
names->name);
REVERSE_LIST(vars);
for (; vars; vars = vars->next)
args = new(arg_list_t, .var=vars->var, .type=type, .default_val=default_val);
REVERSE_LIST(names);
for (; names; names = names->next)
args = new(arg_list_t, .var.name=names->name, .type=type, .default_val=default_val);
whitespace(pos);
match(pos, ",");
}