aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Makefile6
-rw-r--r--builtins/array.h70
-rw-r--r--builtins/functions.c2
-rw-r--r--builtins/functions.h2
-rw-r--r--builtins/macros.h8
-rw-r--r--builtins/pointer.h2
-rw-r--r--builtins/table.h36
-rw-r--r--builtins/util.h14
-rw-r--r--compile.c278
-rw-r--r--environment.c36
-rw-r--r--typecheck.c6
11 files changed, 232 insertions, 228 deletions
diff --git a/Makefile b/Makefile
index ce9ff6d5..96c33f44 100644
--- a/Makefile
+++ b/Makefile
@@ -42,7 +42,11 @@ tags:
test: tomo
rm -f test/*.tm.[cho]
- for f in $$(ls test/*.tm | shuf); do echo -e "\x1b[1;4m$$f\x1b[m"; VERBOSE=0 CC=tcc ./tomo "$$f" || break; done
+ for f in $$(ls test/*.tm | shuf); do echo -e "\x1b[1;4m$$f\x1b[m"; \
+ if ! VERBOSE=0 CC=tcc ./tomo "$$f"; then \
+ echo "FAILURE!"; break; \
+ fi; \
+ done; echo -e '\x1b[32;7m ALL TESTS PASSED! \x1b[m'
clean:
rm -f tomo *.o SipHash/halfsiphash.o builtins/*.o libtomo.so
diff --git a/builtins/array.h b/builtins/array.h
index 18757850..711b89c4 100644
--- a/builtins/array.h
+++ b/builtins/array.h
@@ -11,48 +11,48 @@
#include "types.h"
// Convert negative indices to back-indexed without branching: index0 = index + (index < 0)*(len+1)) - 1
-#define $Array_get(item_type, arr_expr, index_expr, filename, start, end) *({ \
- const array_t $arr = arr_expr; int64_t $index = (int64_t)(index_expr); \
- int64_t $off = $index + ($index < 0) * ($arr.length + 1) - 1; \
- if (__builtin_expect($off < 0 || $off >= $arr.length, 0)) \
- fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int$as_text(&$index, USE_COLOR, NULL), $arr.length); \
- (item_type*)($arr.data + $arr.stride * $off);})
-#define $Array_lvalue(item_type, arr_expr, index_expr, typeinfo, filename, start, end) { \
- array_t *$arr = arr_expr; int64_t $index = (int64_t)(index_expr); \
- int64_t $off = $index + ($index < 0) * ($arr->length + 1) - 1; \
- if (__builtin_expect($off < 0 || $off >= $arr->length, 0)) \
- fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int$as_text(&$index, USE_COLOR, NULL), $arr->length); \
- if ($arr->data_refcount > 0) \
- Array$compact($arr, typeinfo); \
- *(item_type*)($arr->data + $arr->stride * $off); }
-#define $Array_set(item_type, arr, index, value, typeinfo, filename, start, end) \
- $Array_lvalue(item_type, arr_expr, index, typeinfo, filename, start, end) = value
-#define $Array_get_unchecked(type, x, i) *({ const array_t $arr = x; int64_t $index = (int64_t)(i); \
- int64_t $off = $index + ($index < 0) * ($arr.length + 1) - 1; \
- (type*)($arr.data + $arr.stride * $off);})
-#define $is_atomic(x) _Generic(x, bool: true, int8_t: true, int16_t: true, int32_t: true, int64_t: true, float: true, double: true, default: false)
-#define $TypedArray(t, ...) ({ t $items[] = {__VA_ARGS__}; \
- (array_t){.length=sizeof($items)/sizeof($items[0]), \
- .stride=(int64_t)&$items[1] - (int64_t)&$items[0], \
- .data=memcpy(GC_MALLOC(sizeof($items)), $items, sizeof($items)), \
+#define Array_get(item_type, arr_expr, index_expr, filename, start, end) *({ \
+ const array_t arr = arr_expr; int64_t index = (int64_t)(index_expr); \
+ int64_t off = index + (index < 0) * (arr.length + 1) - 1; \
+ if (__builtin_expect(off < 0 || off >= arr.length, 0)) \
+ fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int$as_text(&index, USE_COLOR, NULL), arr.length); \
+ (item_type*)(arr.data + arr.stride * off);})
+#define Array_lvalue(item_type, arr_expr, index_expr, typeinfo, filename, start, end) { \
+ array_t *arr = arr_expr; int64_t index = (int64_t)(index_expr); \
+ int64_t off = index + (index < 0) * (arr->length + 1) - 1; \
+ if (__builtin_expect(off < 0 || off >= arr->length, 0)) \
+ fail_source(filename, start, end, "Invalid array index: %r (array has length %ld)\n", Int$as_text(&index, USE_COLOR, NULL), arr->length); \
+ if (arr->data_refcount > 0) \
+ Array$compact(arr, typeinfo); \
+ *(item_type*)(arr->data + arr->stride * off); }
+#define Array_set(item_type, arr, index, value, typeinfo, filename, start, end) \
+ Array_lvalue(item_type, arr_expr, index, typeinfo, filename, start, end) = value
+#define Array_get_unchecked(type, x, i) *({ const array_t arr = x; int64_t index = (int64_t)(i); \
+ int64_t off = index + (index < 0) * (arr.length + 1) - 1; \
+ (type*)(arr.data + arr.stride * off);})
+#define is_atomic(x) _Generic(x, bool: true, int8_t: true, int16_t: true, int32_t: true, int64_t: true, float: true, double: true, default: false)
+#define TypedArray(t, ...) ({ t items[] = {__VA_ARGS__}; \
+ (array_t){.length=sizeof(items)/sizeof(items[0]), \
+ .stride=(int64_t)&items[1] - (int64_t)&items[0], \
+ .data=memcpy(GC_MALLOC(sizeof(items)), items, sizeof(items)), \
.atomic=0, \
.data_refcount=1}; })
-#define $TypedArrayN(t, N, ...) ({ t $items[N] = {__VA_ARGS__}; \
+#define TypedArrayN(t, N, ...) ({ t items[N] = {__VA_ARGS__}; \
(array_t){.length=N, \
- .stride=(int64_t)&$items[1] - (int64_t)&$items[0], \
- .data=memcpy(GC_MALLOC(sizeof($items)), $items, sizeof($items)), \
+ .stride=(int64_t)&items[1] - (int64_t)&items[0], \
+ .data=memcpy(GC_MALLOC(sizeof(items)), items, sizeof(items)), \
.atomic=0, \
.data_refcount=1}; })
-#define $Array(x, ...) ({ __typeof(x) $items[] = {x, __VA_ARGS__}; \
- (array_t){.length=sizeof($items)/sizeof($items[0]), \
- .stride=(int64_t)&$items[1] - (int64_t)&$items[0], \
- .data=memcpy($is_atomic(x) ? GC_MALLOC_ATOMIC(sizeof($items)) : GC_MALLOC(sizeof($items)), $items, sizeof($items)), \
- .atomic=$is_atomic(x), \
+#define Array(x, ...) ({ __typeof(x) items[] = {x, __VA_ARGS__}; \
+ (array_t){.length=sizeof(items)/sizeof(items[0]), \
+ .stride=(int64_t)&items[1] - (int64_t)&items[0], \
+ .data=memcpy(is_atomic(x) ? GC_MALLOC_ATOMIC(sizeof(items)) : GC_MALLOC(sizeof(items)), items, sizeof(items)), \
+ .atomic=is_atomic(x), \
.data_refcount=1}; })
-#define $ARRAY_INCREF(arr) (arr).data_refcount |= ((arr).data_refcount << 1) | 1
-#define $ARRAY_DECREF(arr) (arr).data_refcount &= 2
+#define ARRAY_INCREF(arr) (arr).data_refcount |= ((arr).data_refcount << 1) | 1
+#define ARRAY_DECREF(arr) (arr).data_refcount &= 2
-#define Array$insert_value(arr, item_expr, index, type) ({ __typeof(item_expr) $item = item_expr; Array$insert(arr, &$item, index, type); })
+#define Array$insert_value(arr, item_expr, index, type) ({ __typeof(item_expr) item = item_expr; Array$insert(arr, &item, index, type); })
void Array$insert(array_t *arr, const void *item, int64_t index, const TypeInfo *type);
void Array$insert_all(array_t *arr, array_t to_insert, int64_t index, const TypeInfo *type);
void Array$remove(array_t *arr, int64_t index, int64_t count, const TypeInfo *type);
diff --git a/builtins/functions.c b/builtins/functions.c
index b292f511..a1ebc6a8 100644
--- a/builtins/functions.c
+++ b/builtins/functions.c
@@ -153,7 +153,7 @@ public CORD builtin_last_err()
return CORD_from_char_star(strerror(errno));
}
-public void $test(void *expr, const TypeInfo *type, CORD expected, const char *filename, int64_t start, int64_t end)
+public void test(void *expr, const TypeInfo *type, CORD expected, const char *filename, int64_t start, int64_t end)
{
static file_t *file = NULL;
if (filename && (file == NULL || strcmp(file->filename, filename) != 0))
diff --git a/builtins/functions.h b/builtins/functions.h
index cd1771a8..ed63ec36 100644
--- a/builtins/functions.h
+++ b/builtins/functions.h
@@ -13,7 +13,7 @@ extern const char *TOMO_HASH_VECTOR;
void fail(CORD fmt, ...);
void fail_source(const char *filename, int64_t start, int64_t end, CORD fmt, ...);
CORD builtin_last_err();
-void $test(void *expr, const TypeInfo *type, CORD expected, const char *filename, int64_t start, int64_t end);
+void test(void *expr, const TypeInfo *type, CORD expected, const char *filename, int64_t start, int64_t end);
void say(CORD text);
uint32_t generic_hash(const void *obj, const TypeInfo *type);
diff --git a/builtins/macros.h b/builtins/macros.h
index 6128480a..4fbaa5f5 100644
--- a/builtins/macros.h
+++ b/builtins/macros.h
@@ -5,7 +5,7 @@
#include <gc.h>
#include <string.h>
-#define $heap(x) (__typeof(x)*)memcpy(GC_MALLOC(sizeof(x)), (__typeof(x)[1]){x}, sizeof(x))
-#define $stack(x) (__typeof(x)*)((__typeof(x)[1]){x})
-#define $tagged(obj_expr, type_name, tag_name) ({ __typeof(obj_expr) $obj = obj_expr; \
- $obj.$tag == $tag$##type_name##$##tag_name ? &$obj.tag_name : NULL; })
+#define heap(x) (__typeof(x)*)memcpy(GC_MALLOC(sizeof(x)), (__typeof(x)[1]){x}, sizeof(x))
+#define stack(x) (__typeof(x)*)((__typeof(x)[1]){x})
+#define tagged(obj_expr, type_name, tag_name) ({ __typeof(obj_expr) obj = obj_expr; \
+ obj.$tag == $tag$##type_name##$##tag_name ? &obj.tag_name : NULL; })
diff --git a/builtins/pointer.h b/builtins/pointer.h
index e5705d20..538960b3 100644
--- a/builtins/pointer.h
+++ b/builtins/pointer.h
@@ -13,7 +13,7 @@ int32_t Pointer$compare(const void *x, const void *y, const TypeInfo *type);
bool Pointer$equal(const void *x, const void *y, const TypeInfo *type);
uint32_t Pointer$hash(const void *x, const TypeInfo *type);
-#define $Null(t) (t*)NULL
+#define Null(t) (t*)NULL
#define POINTER_TYPE(_sigil, _pointed) (&(TypeInfo){\
.size=sizeof(void*), .align=alignof(void*), .tag=PointerInfo, .PointerInfo.sigil=_sigil, .PointerInfo.pointed=_pointed})
diff --git a/builtins/table.h b/builtins/table.h
index fdde32ae..0d7af587 100644
--- a/builtins/table.h
+++ b/builtins/table.h
@@ -10,22 +10,22 @@
#include "datatypes.h"
#include "array.h"
-#define $Table(key_t, val_t, key_info, value_info, fb, def, N, ...) ({ \
- struct { key_t k; val_t v; } $ents[N] = {__VA_ARGS__}; \
- table_t $table = Table$from_entries((array_t){ \
- .data=memcpy(GC_MALLOC(sizeof($ents)), $ents, sizeof($ents)), \
- .length=sizeof($ents)/sizeof($ents[0]), \
- .stride=(void*)&$ents[1] - (void*)&$ents[0], \
+#define Table(key_t, val_t, key_info, value_info, fb, def, N, ...) ({ \
+ struct { key_t k; val_t v; } ents[N] = {__VA_ARGS__}; \
+ table_t table = Table$from_entries((array_t){ \
+ .data=memcpy(GC_MALLOC(sizeof(ents)), ents, sizeof(ents)), \
+ .length=sizeof(ents)/sizeof(ents[0]), \
+ .stride=(void*)&ents[1] - (void*)&ents[0], \
}, $TableInfo(key_info, value_info)); \
- $table.fallback = fb; \
- $table.default_value = def; \
- $table; })
-#define $Table_get(table_expr, key_t, val_t, key_expr, info_expr, filename, start, end) ({ \
- const table_t $t = table_expr; key_t $k = key_expr; const TypeInfo* $info = info_expr; \
- const val_t *$v = Table$get($t, &$k, $info); \
- if (__builtin_expect($v == NULL, 0)) \
- fail_source(filename, start, end, "The key %r is not in this table\n", generic_as_text(&$k, USE_COLOR, $info->TableInfo.key)); \
- *$v; })
+ table.fallback = fb; \
+ table.default_value = def; \
+ table; })
+#define Table_get(table_expr, key_t, val_t, key_expr, info_expr, filename, start, end) ({ \
+ const table_t t = table_expr; key_t k = key_expr; const TypeInfo* info = info_expr; \
+ const val_t *v = Table$get(t, &k, info); \
+ if (__builtin_expect(v == NULL, 0)) \
+ fail_source(filename, start, end, "The key %r is not in this table\n", generic_as_text(&k, USE_COLOR, info->TableInfo.key)); \
+ *v; })
table_t Table$from_entries(array_t entries, const TypeInfo *type);
void *Table$get(table_t t, const void *key, const TypeInfo *type);
@@ -33,9 +33,9 @@ void *Table$get_raw(table_t t, const void *key, const TypeInfo *type);
void *Table$entry(table_t t, int64_t n);
void *Table$reserve(table_t *t, const void *key, const void *value, const TypeInfo *type);
void Table$set(table_t *t, const void *key, const void *value, const TypeInfo *type);
-#define Table$set_value(t, key_expr, value_expr, type) ({ __typeof(key_expr) $k = key_expr; __typeof(value_expr) $v = value_expr; \
- Table$set(t, &$k, &$v, type); })
-#define Table$reserve_value(t, key_expr, type) ({ __typeof(key_expr) $k = key_expr; Table$reserve(t, &$k, NULL, type); })
+#define Table$set_value(t, key_expr, value_expr, type) ({ __typeof(key_expr) k = key_expr; __typeof(value_expr) v = value_expr; \
+ Table$set(t, &k, &v, type); })
+#define Table$reserve_value(t, key_expr, type) ({ __typeof(key_expr) k = key_expr; Table$reserve(t, &k, NULL, type); })
void Table$remove(table_t *t, const void *key, const TypeInfo *type);
void Table$clear(table_t *t);
void Table$mark_copy_on_write(table_t *t);
diff --git a/builtins/util.h b/builtins/util.h
index 5344a7c9..79925a51 100644
--- a/builtins/util.h
+++ b/builtins/util.h
@@ -47,15 +47,15 @@ CORD CORD_asprintf(CORD fmt, ...);
} while(0)
#define LIST_MAP(src, var, ...) ({\
- __typeof(src) $mapped = NULL; \
- __typeof(src) *$next = &$mapped; \
+ __typeof(src) mapped = NULL; \
+ __typeof(src) *next = &mapped; \
for (__typeof(src) var = src; var; var = var->next) { \
- *$next = GC_MALLOC(sizeof(__typeof(*(src)))); \
- **$next = *var; \
- **$next = (__typeof(*(src))){__VA_ARGS__}; \
- $next = &((*$next)->next); \
+ *next = GC_MALLOC(sizeof(__typeof(*(src)))); \
+ **next = *var; \
+ **next = (__typeof(*(src))){__VA_ARGS__}; \
+ next = &((*next)->next); \
} \
- $mapped; })
+ mapped; })
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/compile.c b/compile.c
index 4c31bcad..6000faae 100644
--- a/compile.c
+++ b/compile.c
@@ -58,7 +58,7 @@ static bool promote(env_t *env, CORD *code, type_t *actual, type_t *needed)
return false;
}
-CORD compile_declaration(env_t *env, type_t *t, const char *name)
+CORD compile_declaration(env_t *env, type_t *t, CORD name)
{
if (t->tag == FunctionType) {
auto fn = Match(t, FunctionType);
@@ -135,7 +135,7 @@ static CORD compile_lvalue(env_t *env, ast_t *ast)
if (container_t->tag == ArrayType) {
CORD target_code = compile_to_pointer_depth(env, index->indexed, 1, false);
type_t *item_type = Match(container_t, ArrayType)->item_type;
- return CORD_all("$Array_lvalue(", compile_type(env, item_type), ", ", target_code, ", ",
+ return CORD_all("Array_lvalue(", compile_type(env, item_type), ", ", target_code, ", ",
compile(env, index->index), ", ", compile_type_info(env, container_t),
", ", Text$quoted(ast->file->filename, false), ", ", heap_strf("%ld", ast->start - ast->file->text),
", ", heap_strf("%ld", ast->end - ast->file->text), ")");
@@ -166,8 +166,8 @@ CORD compile_statement(env_t *env, ast_t *ast)
auto when = Match(ast, When);
type_t *subject_t = get_type(env, when->subject);
auto enum_t = Match(subject_t, EnumType);
- CORD code = CORD_all("{ ", compile_type(env, subject_t), " $subject = ", compile(env, when->subject), ";\n"
- "switch ($subject.$tag) {");
+ CORD code = CORD_all("{ ", compile_type(env, subject_t), " subject = ", compile(env, when->subject), ";\n"
+ "switch (subject.$tag) {");
type_t *result_t = get_type(env, ast);
(void)result_t;
for (when_clause_t *clause = when->clauses; clause; clause = clause->next) {
@@ -183,7 +183,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
assert(tag_type);
env_t *scope = env;
if (clause->var) {
- code = CORD_all(code, compile_type(env, tag_type), " ", compile(env, clause->var), " = $subject.", clause_tag_name, ";\n");
+ code = CORD_all(code, compile_type(env, tag_type), " ", compile(env, clause->var), " = subject.", clause_tag_name, ";\n");
scope = fresh_scope(env);
set_binding(scope, Match(clause->var, Var)->name, new(binding_t, .type=tag_type));
}
@@ -216,7 +216,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
auto decl = Match(test->expr, Declare);
return CORD_asprintf(
"%r\n"
- "$test(&%r, %r, %r, %r, %ld, %ld);",
+ "test(&%r, %r, %r, %r, %ld, %ld);",
compile_statement(env, test->expr),
compile(env, decl->var),
compile_type_info(env, get_type(env, decl->value)),
@@ -230,7 +230,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
// Common case: assigning to one variable:
CORD var = compile(env, assign->targets->ast);
CORD code = compile_assignment(env, assign->targets->ast, compile(env, assign->values->ast));
- CORD_appendf(&code, "$test(&%r, %r, %r, %r, %ld, %ld);",
+ CORD_appendf(&code, "test(&%r, %r, %r, %r, %ld, %ld);",
var, compile_type_info(env, get_type(env, assign->targets->ast)),
compile(env, WrapAST(test->expr, TextLiteral, .cord=test->output)),
compile(env, WrapAST(test->expr, TextLiteral, .cord=test->expr->file->filename)),
@@ -250,7 +250,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
for (ast_list_t *target = assign->targets; target; target = target->next)
code = CORD_all(code, compile_assignment(env, target->ast, CORD_asprintf("$%ld", i++)));
- CORD_appendf(&code, "$test(&$1, %r, %r, %r, %ld, %ld);",
+ CORD_appendf(&code, "test(&$1, %r, %r, %r, %ld, %ld);",
compile_type_info(env, get_type(env, assign->targets->ast)),
compile(env, WrapAST(test->expr, TextLiteral, .cord=test->output)),
compile(env, WrapAST(test->expr, TextLiteral, .cord=test->expr->file->filename)),
@@ -261,7 +261,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
} else if (expr_t->tag == VoidType || expr_t->tag == AbortType) {
return CORD_asprintf(
"%r\n"
- "$test(NULL, NULL, NULL, %r, %ld, %ld);",
+ "test(NULL, NULL, NULL, %r, %ld, %ld);",
compile_statement(env, test->expr),
compile(env, WrapAST(test->expr, TextLiteral, .cord=test->expr->file->filename)),
(int64_t)(test->expr->start - test->expr->file->text),
@@ -270,9 +270,9 @@ CORD compile_statement(env_t *env, ast_t *ast)
return CORD_asprintf(
"{ // Test:\n"
"%r = %r;\n"
- "$test(&$expr, %r, %r, %r, %ld, %ld);\n"
+ "test(&expr, %r, %r, %r, %ld, %ld);\n"
"}",
- compile_declaration(env, expr_t, "$expr"),
+ compile_declaration(env, expr_t, "expr"),
compile(env, test->expr),
compile_type_info(env, expr_t),
compile(env, WrapAST(test->expr, TextLiteral, .cord=output)),
@@ -299,7 +299,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
type_t *t = get_type(env, decl->value);
if (t->tag == AbortType || t->tag == VoidType)
code_err(ast, "You can't declare a variable with a %T value", t);
- return CORD_all(compile_declaration(env, t, Match(decl->var, Var)->name), " = ", compile(env, decl->value), ";");
+ return CORD_all(compile_declaration(env, t, CORD_cat("$", Match(decl->var, Var)->name)), " = ", compile(env, decl->value), ";");
}
}
case Assign: {
@@ -376,9 +376,9 @@ CORD compile_statement(env_t *env, ast_t *ast)
if (promote(env, &rhs, rhs_t, Match(lhs_t, ArrayType)->item_type)) {
// arr ++= item
if (update->lhs->tag == Var)
- return CORD_all("Array$insert(&", lhs, ", $stack(", rhs, "), 0, ", compile_type_info(env, operand_t), ");");
+ return CORD_all("Array$insert(&", lhs, ", stack(", rhs, "), 0, ", compile_type_info(env, operand_t), ");");
else
- return CORD_all(lhs, "Array$concat(", lhs, ", $Array(", rhs, "), ", compile_type_info(env, operand_t), ");");
+ return CORD_all(lhs, "Array$concat(", lhs, ", Array(", rhs, "), ", compile_type_info(env, operand_t), ");");
} else {
// arr ++= [...]
if (update->lhs->tag == Var)
@@ -420,7 +420,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
CORD arg_signature = "(";
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
- arg_signature = CORD_cat(arg_signature, compile_declaration(env, arg_type, arg->name));
+ arg_signature = CORD_cat(arg_signature, compile_declaration(env, arg_type, CORD_cat("$", arg->name)));
if (arg->next) arg_signature = CORD_cat(arg_signature, ", ");
}
arg_signature = CORD_cat(arg_signature, ")");
@@ -446,7 +446,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
env_t *body_scope = fresh_scope(env);
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
- set_binding(body_scope, arg->name, new(binding_t, .type=arg_type, .code=arg->name));
+ set_binding(body_scope, arg->name, new(binding_t, .type=arg_type, .code=CORD_cat("$", arg->name)));
}
fn_ctx_t fn_ctx = (fn_ctx_t){
@@ -471,25 +471,25 @@ CORD compile_statement(env_t *env, ast_t *ast)
CORD all_args = CORD_EMPTY;
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next)
- all_args = CORD_all(all_args, arg->name, arg->next ? ", " : CORD_EMPTY);
+ all_args = CORD_all(all_args, "$", arg->name, arg->next ? ", " : CORD_EMPTY);
CORD pop_code = CORD_EMPTY;
if (fndef->cache->tag == Int && Match(fndef->cache, Int)->i < INT64_MAX) {
- pop_code = CORD_all("if (Table$length($cache) > ", compile(body_scope, fndef->cache),
- ") Table$remove(&$cache, NULL, $table_info);\n");
+ pop_code = CORD_all("if (Table$length(cache) > ", compile(body_scope, fndef->cache),
+ ") Table$remove(&cache, NULL, table_info);\n");
}
CORD wrapper = CORD_all(
fndef->is_private ? CORD_EMPTY : "public ", ret_type_code, " ", name, arg_signature, "{\n"
- "static table_t $cache = {};\n",
- compile_type(env, args_t), " $args = {", all_args, "};\n"
- "static const TypeInfo *$table_type = $TableInfo(", compile_type_info(env, args_t), ", ", compile_type_info(env, ret_t), ");\n",
- ret_type_code, "*$cached = Table$get_raw($cache, &$args, $table_type);\n"
- "if ($cached) return *$cached;\n",
- ret_type_code, " $ret = ", name, "$uncached(", all_args, ");\n",
+ "static table_t cache = {};\n",
+ compile_type(env, args_t), " args = {", all_args, "};\n"
+ "static const TypeInfo *table_type = $TableInfo(", compile_type_info(env, args_t), ", ", compile_type_info(env, ret_t), ");\n",
+ ret_type_code, "*cached = Table$get_raw(cache, &args, table_type);\n"
+ "if (cached) return *cached;\n",
+ ret_type_code, " ret = ", name, "$uncached(", all_args, ");\n",
pop_code,
- "Table$set(&$cache, &$args, &$ret, $table_type);\n"
- "return $ret;\n"
+ "Table$set(&cache, &args, &ret, table_type);\n"
+ "return ret;\n"
"}\n");
env->code->funcs = CORD_cat(env->code->funcs, wrapper);
}
@@ -578,8 +578,8 @@ CORD compile_statement(env_t *env, ast_t *ast)
env_t *body_scope = for_scope(env, ast);
loop_ctx_t loop_ctx = (loop_ctx_t){
.loop_name="for",
- .key_name=for_->index ? compile(env, for_->index) : CORD_EMPTY,
- .value_name=for_->value ? compile(env, for_->value) : CORD_EMPTY,
+ .key_name=for_->index ? Match(for_->index, Var)->name : CORD_EMPTY,
+ .value_name=for_->value ? Match(for_->value, Var)->name : CORD_EMPTY,
.next=body_scope->loop_ctx,
};
body_scope->loop_ctx = &loop_ctx;
@@ -591,17 +591,17 @@ CORD compile_statement(env_t *env, ast_t *ast)
switch (iter_t->tag) {
case ArrayType: {
type_t *item_t = Match(iter_t, ArrayType)->item_type;
- CORD index = for_->index ? compile(env, for_->index) : "$i";
+ CORD index = for_->index ? compile(env, for_->index) : "i";
CORD value = compile(env, for_->value);
- CORD array = is_idempotent(for_->iter) ? compile(env, for_->iter) : "$arr";
- CORD loop = CORD_all("$ARRAY_INCREF(", array, ");\n"
+ CORD array = is_idempotent(for_->iter) ? compile(env, for_->iter) : "arr";
+ CORD loop = CORD_all("ARRAY_INCREF(", array, ");\n"
"for (int64_t ", index, " = 1; ", index, " <= ", array, ".length; ++", index, ") {\n",
compile_type(env, item_t), " ", value,
" = *(", compile_type(env, item_t), "*)(", array, ".data + (",index,"-1)*", array, ".stride);\n",
body, "\n}");
if (for_->empty)
loop = CORD_all("if (", array, ".length > 0) {\n", loop, "\n} else ", compile_statement(env, for_->empty));
- loop = CORD_all(loop, stop, "\n$ARRAY_DECREF(", array, ");\n");
+ loop = CORD_all(loop, stop, "\nARRAY_DECREF(", array, ");\n");
if (!is_idempotent(for_->iter))
loop = CORD_all("{\narray_t ",array," = ", compile(env, for_->iter), ";\n", loop, "\n}");
return loop;
@@ -610,26 +610,26 @@ CORD compile_statement(env_t *env, ast_t *ast)
type_t *key_t = Match(iter_t, TableType)->key_type;
type_t *value_t = Match(iter_t, TableType)->value_type;
- CORD table = is_idempotent(for_->iter) ? compile(env, for_->iter) : "$table";
- CORD loop = CORD_all("$ARRAY_INCREF(", table, ".entries);\n"
- "for (int64_t $i = 0; $i < ",table,".entries.length; ++$i) {\n");
+ CORD table = is_idempotent(for_->iter) ? compile(env, for_->iter) : "table";
+ CORD loop = CORD_all("ARRAY_INCREF(", table, ".entries);\n"
+ "for (int64_t i = 0; i < ",table,".entries.length; ++i) {\n");
if (for_->index) {
loop = CORD_all(loop, compile_type(env, key_t), " ", compile(env, for_->index), " = *(", compile_type(env, key_t), "*)(",
- table,".entries.data + $i*", table, ".entries.stride);\n");
+ table,".entries.data + i*", table, ".entries.stride);\n");
size_t value_offset = type_size(key_t);
if (type_align(value_t) > 1 && value_offset % type_align(value_t))
value_offset += type_align(value_t) - (value_offset % type_align(value_t)); // padding
loop = CORD_all(loop, compile_type(env, value_t), " ", compile(env, for_->value), " = *(", compile_type(env, value_t), "*)(",
- table,".entries.data + $i*", table, ".entries.stride + ", heap_strf("%zu", value_offset), ");\n");
+ table,".entries.data + i*", table, ".entries.stride + ", heap_strf("%zu", value_offset), ");\n");
} else {
loop = CORD_all(loop, compile_type(env, key_t), " ", compile(env, for_->value), " = *(", compile_type(env, key_t), "*)(",
- table,".entries.data + $i*", table, ".entries.stride);\n");
+ table,".entries.data + i*", table, ".entries.stride);\n");
}
loop = CORD_all(loop, body, "\n}");
if (for_->empty)
loop = CORD_all("if (", table, ".entries.length > 0) {\n", loop, "\n} else ", compile_statement(env, for_->empty));
- loop = CORD_all(loop, stop, "\n$ARRAY_DECREF(", table, ".entries);\n");
+ loop = CORD_all(loop, stop, "\nARRAY_DECREF(", table, ".entries);\n");
if (!is_idempotent(for_->iter))
loop = CORD_all("{\ntable_t ",table," = ", compile(env, for_->iter), ";\n", loop, "\n}");
return loop;
@@ -641,18 +641,18 @@ CORD compile_statement(env_t *env, ast_t *ast)
if (for_->empty && index) {
return CORD_all(
"{\n"
- "int64_t $n = ", n, ";\n"
- "if ($n > 0) {\n"
- "for (int64_t ", index, " = 1, ", value, "; (", value, "=", index,") <= $n; ++", index, ") {\n"
+ "int64_t n = ", n, ";\n"
+ "if (n > 0) {\n"
+ "for (int64_t ", index, " = 1, ", value, "; (", value, "=", index,") <= n; ++", index, ") {\n"
"\t", body, "\n}"
"\n} else ", compile_statement(env, for_->empty),
stop, "\n}");
} else if (for_->empty) {
return CORD_all(
"{\n"
- "int64_t $n = ", n, ";\n"
- "if ($n > 0) {\n"
- "for (int64_t ", value, " = 1; ", value, " <= $n; ++", value, ") {\n"
+ "int64_t n = ", n, ";\n"
+ "if (n > 0) {\n"
+ "for (int64_t ", value, " = 1; ", value, " <= n; ++", value, ") {\n"
"\t", body,
"\n}"
"\n} else ", compile_statement(env, for_->empty),
@@ -660,14 +660,14 @@ CORD compile_statement(env_t *env, ast_t *ast)
"\n}");
} else if (index) {
return CORD_all(
- "for (int64_t ", value, ", ", index, " = 1, $n = ", n, "; (", value, "=", index,") <= $n; ++", value, ") {\n"
+ "for (int64_t ", value, ", ", index, " = 1, n = ", n, "; (", value, "=", index,") <= n; ++", value, ") {\n"
"\t", body,
"\n}",
stop,
"\n");
} else {
return CORD_all(
- "for (int64_t ", value, " = 1, $n = ", compile(env, for_->iter), "; ", value, " <= $n; ++", value, ") {\n"
+ "for (int64_t ", value, " = 1, n = ", compile(env, for_->iter), "; ", value, " <= n; ++", value, ") {\n"
"\t", body,
"\n}",
stop,
@@ -789,25 +789,25 @@ CORD compile_statement(env_t *env, ast_t *ast)
CORD expr_as_text(env_t *env, CORD expr, type_t *t, CORD color)
{
switch (t->tag) {
- case MemoryType: return CORD_asprintf("Memory$as_text($stack(%r), %r, &$Memory)", expr, color);
- case BoolType: return CORD_asprintf("Bool$as_text($stack(%r), %r, &$Bool)", expr, color);
+ case MemoryType: return CORD_asprintf("Memory$as_text(stack(%r), %r, &$Memory)", expr, color);
+ case BoolType: return CORD_asprintf("Bool$as_text(stack(%r), %r, &$Bool)", expr, color);
case IntType: {
CORD name = type_to_cord(t);
- return CORD_asprintf("%r$as_text($stack(%r), %r, &$%r)", name, expr, color, name);
+ return CORD_asprintf("%r$as_text(stack(%r), %r, &$%r)", name, expr, color, name);
}
case NumType: {
CORD name = type_to_cord(t);
- return CORD_asprintf("%r$as_text($stack(%r), %r, &$Num%r)", name, expr, color, name);
+ return CORD_asprintf("%r$as_text(stack(%r), %r, &$Num%r)", name, expr, color, name);
}
case TextType: {
const char *lang = Match(t, TextType)->lang;
- return CORD_asprintf("Text$as_text($stack(%r), %r, &%s)", expr, color, lang ? lang : "$Text");
+ return CORD_asprintf("Text$as_text(stack(%r), %r, &%s)", expr, color, lang ? lang : "$Text");
}
- case ArrayType: return CORD_asprintf("Array$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
- case TableType: return CORD_asprintf("Table$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
- case FunctionType: return CORD_asprintf("Func$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
- case PointerType: return CORD_asprintf("Pointer$as_text($stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
- case StructType: case EnumType: return CORD_asprintf("(%r)->CustomInfo.as_text($stack(%r), %r, %r)",
+ case ArrayType: return CORD_asprintf("Array$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+ case TableType: return CORD_asprintf("Table$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+ case FunctionType: return CORD_asprintf("Func$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+ case PointerType: return CORD_asprintf("Pointer$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+ case StructType: case EnumType: return CORD_asprintf("(%r)->CustomInfo.as_text(stack(%r), %r, %r)",
compile_type_info(env, t), expr, color, compile_type_info(env, t));
default: compiler_err(NULL, NULL, NULL, "Stringifying is not supported for %T", t);
}
@@ -833,7 +833,7 @@ CORD compile_to_pointer_depth(env_t *env, ast_t *ast, int64_t target_depth, bool
if (ast->tag == Var && target_depth == 1)
val = CORD_all("(&", val, ")");
else
- val = CORD_all("$stack(", val, ")");
+ val = CORD_all("stack(", val, ")");
t = Type(PointerType, .pointed=t, .is_stack=true);
++depth;
} else {
@@ -931,8 +931,8 @@ CORD compile(env_t *env, ast_t *ast)
case Var: {
binding_t *b = get_binding(env, Match(ast, Var)->name);
if (b)
- return b->code ? b->code : Match(ast, Var)->name;
- return Match(ast, Var)->name;
+ return b->code ? b->code : CORD_cat("$", Match(ast, Var)->name);
+ return CORD_cat("$", Match(ast, Var)->name);
// code_err(ast, "I don't know of any variable by this name");
}
case Int: return CORD_asprintf("I%ld(%ld)", Match(ast, Int)->bits, Match(ast, Int)->i);
@@ -987,12 +987,12 @@ CORD compile(env_t *env, ast_t *ast)
code_err(ast, "I don't know how to negate values of type %T", t);
}
case Negative: return CORD_asprintf("-(%r)", compile(env, Match(ast, Negative)->value));
- case HeapAllocate: return CORD_asprintf("$heap(%r)", compile(env, Match(ast, HeapAllocate)->value));
+ case HeapAllocate: return CORD_asprintf("heap(%r)", compile(env, Match(ast, HeapAllocate)->value));
case StackReference: {
ast_t *subject = Match(ast, StackReference)->value;
if (can_be_mutated(env, subject))
return CORD_all("(&", compile(env, subject), ")");
- return CORD_all("$stack(", compile(env, subject), ")");
+ return CORD_all("stack(", compile(env, subject), ")");
}
case BinaryOp: {
auto binop = Match(ast, BinaryOp);
@@ -1063,7 +1063,7 @@ CORD compile(env_t *env, ast_t *ast)
case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
return CORD_asprintf("(%r == %r)", lhs, rhs);
default:
- return CORD_asprintf("generic_equal($stack(%r), $stack(%r), %r)", lhs, rhs, compile_type_info(env, operand_t));
+ return CORD_asprintf("generic_equal(stack(%r), stack(%r), %r)", lhs, rhs, compile_type_info(env, operand_t));
}
}
case BINOP_NE: {
@@ -1071,7 +1071,7 @@ CORD compile(env_t *env, ast_t *ast)
case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
return CORD_asprintf("(%r != %r)", lhs, rhs);
default:
- return CORD_asprintf("!generic_equal($stack(%r), $stack(%r), %r)", lhs, rhs, compile_type_info(env, operand_t));
+ return CORD_asprintf("!generic_equal(stack(%r), stack(%r), %r)", lhs, rhs, compile_type_info(env, operand_t));
}
}
case BINOP_LT: {
@@ -1079,7 +1079,7 @@ CORD compile(env_t *env, ast_t *ast)
case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
return CORD_asprintf("(%r < %r)", lhs, rhs);
default:
- return CORD_asprintf("(generic_compare($stack(%r), $stack(%r), %r) < 0)", lhs, rhs, compile_type_info(env, operand_t));
+ return CORD_asprintf("(generic_compare(stack(%r), stack(%r), %r) < 0)", lhs, rhs, compile_type_info(env, operand_t));
}
}
case BINOP_LE: {
@@ -1087,7 +1087,7 @@ CORD compile(env_t *env, ast_t *ast)
case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
return CORD_asprintf("(%r <= %r)", lhs, rhs);
default:
- return CORD_asprintf("(generic_compare($stack(%r), $stack(%r), %r) <= 0)", lhs, rhs, compile_type_info(env, operand_t));
+ return CORD_asprintf("(generic_compare(stack(%r), stack(%r), %r) <= 0)", lhs, rhs, compile_type_info(env, operand_t));
}
}
case BINOP_GT: {
@@ -1095,7 +1095,7 @@ CORD compile(env_t *env, ast_t *ast)
case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
return CORD_asprintf("(%r > %r)", lhs, rhs);
default:
- return CORD_asprintf("(generic_compare($stack(%r), $stack(%r), %r) > 0)", lhs, rhs, compile_type_info(env, operand_t));
+ return CORD_asprintf("(generic_compare(stack(%r), stack(%r), %r) > 0)", lhs, rhs, compile_type_info(env, operand_t));
}
}
case BINOP_GE: {
@@ -1103,7 +1103,7 @@ CORD compile(env_t *env, ast_t *ast)
case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
return CORD_asprintf("(%r >= %r)", lhs, rhs);
default:
- return CORD_asprintf("(generic_compare($stack(%r), $stack(%r), %r) >= 0)", lhs, rhs, compile_type_info(env, operand_t));
+ return CORD_asprintf("(generic_compare(stack(%r), stack(%r), %r) >= 0)", lhs, rhs, compile_type_info(env, operand_t));
}
}
case BINOP_AND: {
@@ -1115,7 +1115,7 @@ CORD compile(env_t *env, ast_t *ast)
code_err(ast, "Boolean operators are only supported for Bool and integer types");
}
case BINOP_CMP: {
- return CORD_all("generic_compare($stack(", lhs, "), $stack(", rhs, "), ", compile_type_info(env, operand_t), ")");
+ return CORD_all("generic_compare(stack(", lhs, "), stack(", rhs, "), ", compile_type_info(env, operand_t), ")");
}
case BINOP_OR: {
if (operand_t->tag == BoolType)
@@ -1249,10 +1249,10 @@ CORD compile(env_t *env, ast_t *ast)
if (key == NULL) key = FakeAST(Var, key_name);
env_t *expr_env = fresh_scope(env);
- set_binding(expr_env, key_name, new(binding_t, .type=t, .code="$ternary$lhs"));
+ set_binding(expr_env, key_name, new(binding_t, .type=t, .code="ternary$lhs"));
CORD lhs_key = compile(expr_env, key);
- set_binding(expr_env, key_name, new(binding_t, .type=t, .code="$ternary$rhs"));
+ set_binding(expr_env, key_name, new(binding_t, .type=t, .code="ternary$rhs"));
CORD rhs_key = compile(expr_env, key);
type_t *key_t = get_type(expr_env, key);
@@ -1262,13 +1262,13 @@ CORD compile(env_t *env, ast_t *ast)
else if (key_t->tag == TextType)
comparison = CORD_all("CORD_cmp(", lhs_key, ", ", rhs_key, ")", (ast->tag == Min ? "<=" : ">="), "0");
else
- comparison = CORD_all("generic_compare($stack(", lhs_key, "), $stack(", rhs_key, "), ", compile_type_info(env, key_t), ")",
+ comparison = CORD_all("generic_compare(stack(", lhs_key, "), stack(", rhs_key, "), ", compile_type_info(env, key_t), ")",
(ast->tag == Min ? "<=" : ">="), "0");
return CORD_all(
"({\n",
- compile_type(env, t), " $ternary$lhs = ", compile(env, lhs), ", $ternary$rhs = ", compile(env, rhs), ";\n",
- comparison, " ? $ternary$lhs : $ternary$rhs;\n"
+ compile_type(env, t), " ternary$lhs = ", compile(env, lhs), ", ternary$rhs = ", compile(env, rhs), ";\n",
+ comparison, " ? ternary$lhs : ternary$rhs;\n"
"})");
}
case Array: {
@@ -1287,7 +1287,7 @@ CORD compile(env_t *env, ast_t *ast)
{
type_t *item_type = Match(array_type, ArrayType)->item_type;
- CORD code = CORD_all("$TypedArrayN(", compile_type(env, item_type), CORD_asprintf(", %ld", n));
+ CORD code = CORD_all("TypedArrayN(", compile_type(env, item_type), CORD_asprintf(", %ld", n));
for (ast_list_t *item = array->items; item; item = item->next)
code = CORD_all(code, ", ", compile(env, item->ast));
return CORD_cat(code, ")");
@@ -1297,7 +1297,7 @@ CORD compile(env_t *env, ast_t *ast)
{
env_t *scope = fresh_scope(env);
static int64_t comp_num = 1;
- scope->comprehension_var = heap_strf("$arr$%ld", comp_num++);
+ scope->comprehension_var = heap_strf("arr$%ld", comp_num++);
CORD code = CORD_all("({ array_t ", scope->comprehension_var, " = {};");
set_binding(scope, scope->comprehension_var, new(binding_t, .type=array_type, .code=scope->comprehension_var));
for (ast_list_t *item = array->items; item; item = item->next) {
@@ -1321,7 +1321,7 @@ CORD compile(env_t *env, ast_t *ast)
if (table->fallback)
code = CORD_all(code, ".fallback=", compile(env, table->fallback),",");
if (table->default_value)
- code = CORD_all(code, ".default_value=$heap(", compile(env, table->default_value),"),");
+ code = CORD_all(code, ".default_value=heap(", compile(env, table->default_value),"),");
return CORD_cat(code, "}");
}
@@ -1335,18 +1335,18 @@ CORD compile(env_t *env, ast_t *ast)
}
{ // No comprehension:
- CORD code = CORD_all("$Table(",
+ CORD code = CORD_all("Table(",
compile_type(env, key_t), ", ",
compile_type(env, value_t), ", ",
compile_type_info(env, key_t), ", ",
compile_type_info(env, value_t));
if (table->fallback)
- code = CORD_all(code, ", /*fallback:*/ $heap(", compile(env, table->fallback), ")");
+ code = CORD_all(code, ", /*fallback:*/ heap(", compile(env, table->fallback), ")");
else
code = CORD_all(code, ", /*fallback:*/ NULL");
if (table->default_value)
- code = CORD_all(code, ", /*default:*/ $heap(", compile(env, table->default_value), ")");
+ code = CORD_all(code, ", /*default:*/ heap(", compile(env, table->default_value), ")");
else
code = CORD_all(code, ", /*default:*/ NULL");
@@ -1366,14 +1366,14 @@ CORD compile(env_t *env, ast_t *ast)
{
static int64_t comp_num = 1;
env_t *scope = fresh_scope(env);
- scope->comprehension_var = heap_strf("$table$%ld", comp_num++);
+ scope->comprehension_var = heap_strf("table$%ld", comp_num++);
CORD code = CORD_all("({ table_t ", scope->comprehension_var, " = {");
if (table->fallback)
- code = CORD_all(code, ".fallback=$heap(", compile(env, table->fallback), "), ");
+ code = CORD_all(code, ".fallback=heap(", compile(env, table->fallback), "), ");
if (table->default_value)
- code = CORD_all(code, ".default_value=$heap(", compile(env, table->default_value), "), ");
+ code = CORD_all(code, ".default_value=heap(", compile(env, table->default_value), "), ");
code = CORD_cat(code, "};");
set_binding(scope, scope->comprehension_var, new(binding_t, .type=table_type, .code=scope->comprehension_var));
@@ -1410,7 +1410,7 @@ CORD compile(env_t *env, ast_t *ast)
env_t *body_scope = fresh_scope(env);
for (arg_ast_t *arg = lambda->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
- set_binding(body_scope, arg->name, new(binding_t, .type=arg_type, .code=arg->name));
+ set_binding(body_scope, arg->name, new(binding_t, .type=arg_type, .code=CORD_cat("$", arg->name)));
}
type_t *ret_t = get_type(body_scope, lambda->body);
@@ -1426,7 +1426,7 @@ CORD compile(env_t *env, ast_t *ast)
CORD code = CORD_all("static ", compile_type(env, ret_t), " ", name, "(");
for (arg_ast_t *arg = lambda->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
- code = CORD_all(code, compile_type(env, arg_type), " ", arg->name, ", ");
+ code = CORD_all(code, compile_type(env, arg_type), " $", arg->name, ", ");
}
for (ast_list_t *stmt = Match(lambda->body, Block)->statements; stmt; stmt = stmt->next)
@@ -1434,7 +1434,7 @@ CORD compile(env_t *env, ast_t *ast)
CORD userdata;
if (Table$length(*fn_ctx.closed_vars) == 0) {
- code = CORD_cat(code, "void *$userdata)");
+ code = CORD_cat(code, "void *userdata)");
userdata = "NULL";
} else {
CORD def = "typedef struct {";
@@ -1447,7 +1447,7 @@ CORD compile(env_t *env, ast_t *ast)
userdata = CORD_all(userdata, ")");
def = CORD_all(def, "} ", name, "$userdata_t;");
env->code->typedefs = CORD_cat(env->code->typedefs, def);
- code = CORD_all(code, name, "$userdata_t *$userdata)");
+ code = CORD_all(code, name, "$userdata_t *userdata)");
}
CORD body = CORD_EMPTY;
@@ -1585,7 +1585,7 @@ CORD compile(env_t *env, ast_t *ast)
arg_t *closure_fn_args = NULL;
for (arg_t *arg = Match(fn_t, FunctionType)->args; arg; arg = arg->next)
closure_fn_args = new(arg_t, .name=arg->name, .type=arg->type, .default_val=arg->default_val, .next=closure_fn_args);
- closure_fn_args = new(arg_t, .name="$userdata", .type=Type(PointerType, .pointed=Type(MemoryType)), .next=closure_fn_args);
+ closure_fn_args = new(arg_t, .name="userdata", .type=Type(PointerType, .pointed=Type(MemoryType)), .next=closure_fn_args);
REVERSE_LIST(closure_fn_args);
CORD fn_type_code = compile_type(env, Type(FunctionType, .args=closure_fn_args, .ret=Match(fn_t, FunctionType)->ret));
@@ -1595,8 +1595,8 @@ CORD compile(env_t *env, ast_t *ast)
if (call->fn->tag == Var) {
return CORD_all("((", fn_type_code, ")", closure, ".fn)(", arg_code, closure, ".userdata)");
} else {
- return CORD_all("({ closure_t $closure = ", closure, "; ((", fn_type_code, ")$closure.fn)(",
- arg_code, "$closure.userdata); })");
+ return CORD_all("({ closure_t closure = ", closure, "; ((", fn_type_code, ")closure.fn)(",
+ arg_code, "closure.userdata); })");
}
} else {
code_err(call->fn, "This is not a function, it's a %T", fn_t);
@@ -1651,11 +1651,11 @@ CORD compile(env_t *env, ast_t *ast)
type_t *t = get_type(env, ast);
CORD code = CORD_all(
"({ // Reduction:\n",
- compile_declaration(env, t, "$reduction"), ";\n"
+ compile_declaration(env, t, "reduction"), ";\n"
);
env_t *scope = fresh_scope(env);
ast_t *result = FakeAST(Var, "$reduction");
- set_binding(scope, "$reduction", new(binding_t, .type=t));
+ set_binding(scope, "$reduction", new(binding_t, .type=t, .code="reduction"));
ast_t *empty = NULL;
if (reduction->fallback) {
type_t *fallback_type = get_type(scope, reduction->fallback);
@@ -1673,10 +1673,10 @@ CORD compile(env_t *env, ast_t *ast)
}
ast_t *i = FakeAST(Var, "$i");
ast_t *item = FakeAST(Var, "$iter_value");
- set_binding(scope, "$iter_value", new(binding_t, .type=t));
- ast_t *body = FakeAST(InlineCCode, CORD_all("$reduction = $i == 1 ? $iter_value : ", compile(scope, reduction->combination), ";"));
+ set_binding(scope, "$iter_value", new(binding_t, .type=t, .code="iter_value"));
+ ast_t *body = FakeAST(InlineCCode, CORD_all("reduction = $$i == 1 ? iter_value : ", compile(scope, reduction->combination), ";"));
ast_t *loop = FakeAST(For, .index=i, .value=item, .iter=reduction->iter, .body=body, .empty=empty);
- code = CORD_all(code, compile_statement(scope, loop), "\n$reduction;})");
+ code = CORD_all(code, compile_statement(scope, loop), "\nreduction;})");
return code;
}
case FieldAccess: {
@@ -1717,19 +1717,19 @@ CORD compile(env_t *env, ast_t *ast)
}
case TableType: {
if (streq(f->field, "keys")) {
- return CORD_all("({ table_t *$t = ", compile_to_pointer_depth(env, f->fielded, 1, false), ";\n"
- "$t->entries.data_refcount = 3;\n"
- "$t->entries; })");
+ return CORD_all("({ table_t *t = ", compile_to_pointer_depth(env, f->fielded, 1, false), ";\n"
+ "t->entries.data_refcount = 3;\n"
+ "t->entries; })");
} else if (streq(f->field, "values")) {
auto table = Match(value_t, TableType);
size_t offset = type_size(table->key_type);
size_t align = type_align(table->value_type);
if (align > 1 && offset % align > 0)
offset += align - (offset % align);
- return CORD_all("({ table_t *$t = ", compile_to_pointer_depth(env, f->fielded, 1, false), ";\n"
- "$t->entries.data_refcount = 3;\n"
- "(array_t){.data = $t->entries.data + ", CORD_asprintf("%zu", offset),
- ",\n .length=$t->entries.length,\n .stride=$t->entries.stride,\n .data_refcount=3};})");
+ return CORD_all("({ table_t *t = ", compile_to_pointer_depth(env, f->fielded, 1, false), ";\n"
+ "t->entries.data_refcount = 3;\n"
+ "(array_t){.data = t->entries.data + ", CORD_asprintf("%zu", offset),
+ ",\n .length=t->entries.length,\n .stride=t->entries.stride,\n .data_refcount=3};})");
} else if (streq(f->field, "fallback")) {
return CORD_all("(", compile_to_pointer_depth(env, f->fielded, 0, false), ").fallback");
} else if (streq(f->field, "default")) {
@@ -1754,9 +1754,9 @@ CORD compile(env_t *env, ast_t *ast)
if (ptr->is_optional)
code_err(ast, "This pointer is potentially null, so it can't be safely dereferenced");
if (ptr->pointed->tag == ArrayType) {
- return CORD_all("({ array_t *$arr = ", compile(env, indexing->indexed), "; $arr->data_refcount = 3; *$arr; })");
+ return CORD_all("({ array_t *arr = ", compile(env, indexing->indexed), "; arr->data_refcount = 3; *arr; })");
} else if (ptr->pointed->tag == TableType) {
- return CORD_all("({ table_t *$t = ", compile(env, indexing->indexed), "; Table$mark_copy_on_write($t); *$t; })");
+ return CORD_all("({ table_t *t = ", compile(env, indexing->indexed), "; Table$mark_copy_on_write(t); *t; })");
} else {
return CORD_all("*(", compile(env, indexing->indexed), ")");
}
@@ -1772,9 +1772,9 @@ CORD compile(env_t *env, ast_t *ast)
CORD index = compile(env, indexing->index);
file_t *f = indexing->index->file;
if (indexing->unchecked)
- return CORD_all("$Array_get_unchecked", compile_type(env, item_type), ", ", arr, ", ", index, ")");
+ return CORD_all("Array_get_unchecked", compile_type(env, item_type), ", ", arr, ", ", index, ")");
else
- return CORD_all("$Array_get(", compile_type(env, item_type), ", ", arr, ", ", index, ", ",
+ return CORD_all("Array_get(", compile_type(env, item_type), ", ", arr, ", ", index, ", ",
Text$quoted(f->filename, false), ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->start - f->text)), ", ",
CORD_asprintf("%ld", (int64_t)(indexing->index->end - f->text)),
")");
@@ -1787,7 +1787,7 @@ CORD compile(env_t *env, ast_t *ast)
if (!promote(env, &key, index_t, key_t))
code_err(indexing->index, "This value has type %T, but this table can only be index with keys of type %T", index_t, key_t);
file_t *f = indexing->index->file;
- return CORD_all("$Table_get(", table, ", ", compile_type(env, key_t), ", ", compile_type(env, value_t), ", ",
+ return CORD_all("Table_get(", table, ", ", compile_type(env, key_t), ", ", compile_type(env, value_t), ", ",
key, ", ", compile_type_info(env, container_t), ", ",
Text$quoted(f->filename, false), ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->start - f->text)), ", ",
CORD_asprintf("%ld", (int64_t)(indexing->index->end - f->text)),
@@ -1910,21 +1910,21 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
usage = CORD_all(usage, "<", flag, ">");
}
}
- code = CORD_all(code, "CORD $usage = CORD_all(\"Usage: \", argv[0], ", usage ? Text$quoted(usage, false) : "CORD_EMPTY", ");\n",
- "#define $USAGE_ERR(...) errx(1, CORD_to_const_char_star(CORD_all(__VA_ARGS__)))\n"
- "#define $IS_FLAG(str, flag) (strncmp(str, flag, strlen(flag) == 0 && (str[strlen(flag)] == 0 || str[strlen(flag)] == '=')) == 0)\n");
+ code = CORD_all(code, "CORD usage = CORD_all(\"Usage: \", argv[0], ", usage ? Text$quoted(usage, false) : "CORD_EMPTY", ");\n",
+ "#define USAGE_ERR(...) errx(1, CORD_to_const_char_star(CORD_all(__VA_ARGS__)))\n"
+ "#define IS_FLAG(str, flag) (strncmp(str, flag, strlen(flag) == 0 && (str[strlen(flag)] == 0 || str[strlen(flag)] == '=')) == 0)\n");
// Declare args:
for (arg_t *arg = fn_info->args; arg; arg = arg->next) {
type_t *t = get_arg_type(main_env, arg);
assert(arg->name);
code = CORD_all(
- code, compile_declaration(env, t, arg->name), ";\n",
+ code, compile_declaration(env, t, CORD_cat("$", arg->name)), ";\n",
"bool ", arg->name, "$is_set = no;\n");
- set_binding(env, arg->name, new(binding_t, .type=t, .code=arg->name));
+ set_binding(env, arg->name, new(binding_t, .type=t, .code=CORD_cat("$", arg->name)));
}
// Provide --flags:
- code = CORD_all(code, "CORD $flag;\n"
+ code = CORD_all(code, "CORD flag;\n"
"for (int i = 1; i < argc; ) {\n"
"if (streq(argv[i], \"--\")) {\n"
"argv[i] = NULL;\n"
@@ -1936,11 +1936,11 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
CORD flag = Text$replace(arg->name, "_", "-", INT64_MAX);
switch (t->tag) {
case BoolType: {
- code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &$flag)) {\n"
- "if ($flag) {\n",
- arg->name, " = Bool$from_text($flag, &", arg->name, "$is_set", ");\n"
+ code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &flag)) {\n"
+ "if (flag) {\n",
+ arg->name, " = Bool$from_text(flag, &", arg->name, "$is_set", ");\n"
"if (!", arg->name, "$is_set) \n"
- "$USAGE_ERR(\"Invalid argument for '--", flag, "'\\n\", $usage);\n",
+ "USAGE_ERR(\"Invalid argument for '--", flag, "'\\n\", usage);\n",
"} else {\n",
arg->name, " = yes;\n",
arg->name, "$is_set = yes;\n"
@@ -1949,8 +1949,8 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
break;
}
case TextType: {
- code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &$flag)) {\n",
- arg->name, " = CORD_to_const_char_star($flag);\n",
+ code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &flag)) {\n",
+ arg->name, " = CORD_to_const_char_star(flag);\n",
arg->name, "$is_set = yes;\n"
"}\n");
break;
@@ -1958,21 +1958,21 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
case ArrayType: {
if (Match(t, ArrayType)->item_type->tag != TextType)
compiler_err(NULL, NULL, NULL, "Main function has unsupported argument type: %T (only arrays of Text are supported)", t);
- code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &$flag)) {\n",
- arg->name, " = Text$split(CORD_to_const_char_star($flag), \",\");\n",
+ code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &flag)) {\n",
+ arg->name, " = Text$split(CORD_to_const_char_star(flag), \",\");\n",
arg->name, "$is_set = yes;\n"
"}\n");
break;
}
case IntType: case NumType: {
CORD type_name = type_to_cord(t);
- code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &$flag)) {\n",
- "if ($flag == CORD_EMPTY)\n"
- "$USAGE_ERR(\"No value provided for '--", flag, "'\\n\", $usage);\n"
- "CORD $invalid = CORD_EMPTY;\n",
- arg->name, " = ", type_name, "$from_text($flag, &$invalid);\n"
- "if ($invalid != CORD_EMPTY)\n"
- "$USAGE_ERR(\"Invalid value provided for '--", flag, "'\\n\", $usage);\n",
+ code = CORD_all(code, "else if (pop_flag(argv, &i, \"", flag, "\", &flag)) {\n",
+ "if (flag == CORD_EMPTY)\n"
+ "USAGE_ERR(\"No value provided for '--", flag, "'\\n\", usage);\n"
+ "CORD invalid = CORD_EMPTY;\n",
+ arg->name, " = ", type_name, "$from_text(flag, &invalid);\n"
+ "if (invalid != CORD_EMPTY)\n"
+ "USAGE_ERR(\"Invalid value provided for '--", flag, "'\\n\", usage);\n",
arg->name, "$is_set = yes;\n"
"}\n");
break;
@@ -1984,7 +1984,7 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
code = CORD_all(
code, "else {\n"
- "$USAGE_ERR(\"Unrecognized argument: \", argv[i], \"\\n\", $usage);\n"
+ "USAGE_ERR(\"Unrecognized argument: \", argv[i], \"\\n\", usage);\n"
"}\n"
"}\n"
"int i = 1;\n"
@@ -1999,8 +1999,8 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
code, arg->name, " = (array_t){};\n"
"for (; i < argc; i++) {\n"
"if (argv[i]) {\n"
- "CORD $arg = CORD_from_char_star(argv[i]);\n"
- "Array$insert(&", arg->name, ", &$arg, 0, $ArrayInfo(&$Text));\n"
+ "CORD arg = CORD_from_char_star(argv[i]);\n"
+ "Array$insert(&", arg->name, ", &arg, 0, $ArrayInfo(&$Text));\n"
"argv[i] = NULL;\n"
"}\n"
"}\n",
@@ -2016,17 +2016,17 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
} else {
code = CORD_all(
code,
- "CORD $invalid;\n",
- arg->name, " = ", type_to_cord(t), "$from_text(argv[i], &$invalid)", ";\n"
- "if ($invalid != CORD_EMPTY)\n"
- "$USAGE_ERR(\"Unable to parse this argument as a ", type_to_cord(t), ": \", CORD_from_char_star(argv[i]));\n");
+ "CORD invalid;\n",
+ arg->name, " = ", type_to_cord(t), "$from_text(argv[i], &invalid)", ";\n"
+ "if (invalid != CORD_EMPTY)\n"
+ "USAGE_ERR(\"Unable to parse this argument as a ", type_to_cord(t), ": \", CORD_from_char_star(argv[i]));\n");
}
code = CORD_all(
code,
"argv[i++] = NULL;\n"
"while (i < argc && argv[i] == NULL)\n"
"++i;\n} else {\n"
- "$USAGE_ERR(\"Required argument '", arg->name, "' was not provided!\\n\", $usage);\n",
+ "USAGE_ERR(\"Required argument '", arg->name, "' was not provided!\\n\", usage);\n",
"}\n");
}
code = CORD_all(code, "}\n");
@@ -2034,7 +2034,7 @@ static CORD compile_main_arg_parser(env_t *env, const char *module_name, type_t
code = CORD_all(code, "for (; i < argc; i++) {\n"
- "if (argv[i])\n$USAGE_ERR(\"Unexpected argument: \", Text$quoted(argv[i], false), \"\\n\", $usage);\n}\n");
+ "if (argv[i])\nUSAGE_ERR(\"Unexpected argument: \", Text$quoted(argv[i], false), \"\\n\", usage);\n}\n");
code = CORD_all(code, module_name, "$main(");
for (arg_t *arg = fn_info->args; arg; arg = arg->next) {
@@ -2066,7 +2066,7 @@ module_code_t compile_file(ast_t *ast)
code_err(decl->value, "This value is not a valid constant initializer.");
env->code->fndefs = CORD_all(
env->code->fndefs,
- compile_declaration(env, t, Match(decl->var, Var)->name), ";\n");
+ compile_declaration(env, t, CORD_cat("$", Match(decl->var, Var)->name)), ";\n");
env->code->staticdefs = CORD_all(
env->code->staticdefs,
"extern ", compile_type(env, t), " ", Match(decl->var, Var)->name, " = ",
diff --git a/environment.c b/environment.c
index 81824710..08274d8d 100644
--- a/environment.c
+++ b/environment.c
@@ -49,10 +49,10 @@ env_t *new_compilation_unit(void)
CORD struct_val;
array_t namespace;
} global_types[] = {
- {"Bool", Type(BoolType), "Bool_t", "$Bool", $TypedArray(ns_entry_t,
+ {"Bool", Type(BoolType), "Bool_t", "$Bool", TypedArray(ns_entry_t,
{"from_text", "Bool$from_text", "func(text:Text, success=!Bool)->Bool"},
)},
- {"Int", Type(IntType, .bits=64), "Int_t", "$Int", $TypedArray(ns_entry_t,
+ {"Int", Type(IntType, .bits=64), "Int_t", "$Int", TypedArray(ns_entry_t,
{"format", "Int$format", "func(i:Int, digits=0)->Text"},
{"hex", "Int$hex", "func(i:Int, digits=0, uppercase=yes, prefix=yes)->Text"},
{"octal", "Int$octal", "func(i:Int, digits=0, prefix=yes)->Text"},
@@ -63,7 +63,7 @@ env_t *new_compilation_unit(void)
{"min", "Int$min", "Int"},
{"max", "Int$max", "Int"},
)},
- {"Int32", Type(IntType, .bits=32), "Int32_t", "$Int32", $TypedArray(ns_entry_t,
+ {"Int32", Type(IntType, .bits=32), "Int32_t", "$Int32", TypedArray(ns_entry_t,
{"format", "Int32$format", "func(i:Int32, digits=0)->Text"},
{"hex", "Int32$hex", "func(i:Int32, digits=0, uppercase=yes, prefix=yes)->Text"},
{"octal", "Int32$octal", "func(i:Int32, digits=0, prefix=yes)->Text"},
@@ -74,7 +74,7 @@ env_t *new_compilation_unit(void)
{"min", "Int32$min", "Int32"},
{"max", "Int32$max", "Int32"},
)},
- {"Int16", Type(IntType, .bits=16), "Int16_t", "$Int16", $TypedArray(ns_entry_t,
+ {"Int16", Type(IntType, .bits=16), "Int16_t", "$Int16", TypedArray(ns_entry_t,
{"format", "Int16$format", "func(i:Int16, digits=0)->Text"},
{"hex", "Int16$hex", "func(i:Int16, digits=0, uppercase=yes, prefix=yes)->Text"},
{"octal", "Int16$octal", "func(i:Int16, digits=0, prefix=yes)->Text"},
@@ -85,7 +85,7 @@ env_t *new_compilation_unit(void)
{"min", "Int16$min", "Int16"},
{"max", "Int16$max", "Int16"},
)},
- {"Int8", Type(IntType, .bits=8), "Int8_t", "$Int8", $TypedArray(ns_entry_t,
+ {"Int8", Type(IntType, .bits=8), "Int8_t", "$Int8", TypedArray(ns_entry_t,
{"format", "Int8$format", "func(i:Int8, digits=0)->Text"},
{"hex", "Int8$hex", "func(i:Int8, digits=0, uppercase=yes, prefix=yes)->Text"},
{"octal", "Int8$octal", "func(i:Int8, digits=0, prefix=yes)->Text"},
@@ -99,7 +99,7 @@ env_t *new_compilation_unit(void)
#define C(name) {#name, "M_"#name, "Num"}
#define F(name) {#name, #name, "func(n:Num)->Num"}
#define F2(name) {#name, #name, "func(x:Num, y:Num)->Num"}
- {"Num", Type(NumType, .bits=64), "Num_t", "$Num", $TypedArray(ns_entry_t,
+ {"Num", Type(NumType, .bits=64), "Num_t", "$Num", TypedArray(ns_entry_t,
{"near", "Num$near", "func(x:Num, y:Num, ratio=1e-9, min_epsilon=1e-9)->Bool"},
{"format", "Num$format", "func(n:Num, precision=0)->Text"},
{"scientific", "Num$scientific", "func(n:Num, precision=0)->Text"},
@@ -126,7 +126,7 @@ env_t *new_compilation_unit(void)
#define C(name) {#name, "(Num32_t)(M_"#name")", "Num32"}
#define F(name) {#name, #name"f", "func(n:Num32)->Num32"}
#define F2(name) {#name, #name"f", "func(x:Num32, y:Num32)->Num32"}
- {"Num32", Type(NumType, .bits=32), "Num32_t", "$Num32", $TypedArray(ns_entry_t,
+ {"Num32", Type(NumType, .bits=32), "Num32_t", "$Num32", TypedArray(ns_entry_t,
{"near", "Num32$near", "func(x:Num32, y:Num32, ratio=1e-9f32, min_epsilon=1e-9f32)->Bool"},
{"format", "Num32$format", "func(n:Num32, precision=0)->Text"},
{"scientific", "Num32$scientific", "func(n:Num32, precision=0)->Text"},
@@ -150,7 +150,7 @@ env_t *new_compilation_unit(void)
#undef F2
#undef F
#undef C
- {"Text", TEXT_TYPE, "Text_t", "$Text", $TypedArray(ns_entry_t,
+ {"Text", TEXT_TYPE, "Text_t", "$Text", TypedArray(ns_entry_t,
{"quoted", "Text$quoted", "func(text:Text, color=no)->Text"},
{"upper", "Text$upper", "func(text:Text)->Text"},
{"lower", "Text$lower", "func(text:Text)->Text"},
@@ -224,20 +224,20 @@ env_t *for_scope(env_t *env, ast_t *ast)
switch (iter_t->tag) {
case ArrayType: {
type_t *item_t = Match(iter_t, ArrayType)->item_type;
- set_binding(scope, index, new(binding_t, .type=Type(IntType, .bits=64), .code=index));
- set_binding(scope, value, new(binding_t, .type=item_t, .code=value));
+ set_binding(scope, index, new(binding_t, .type=Type(IntType, .bits=64), .code=CORD_cat("$", index)));
+ set_binding(scope, value, new(binding_t, .type=item_t, .code=CORD_cat("$", value)));
return scope;
}
case TableType: {
type_t *key_t = Match(iter_t, TableType)->key_type;
type_t *value_t = Match(iter_t, TableType)->value_type;
- set_binding(scope, index, new(binding_t, .type=key_t, .code=index));
- set_binding(scope, value, new(binding_t, .type=value_t, .code=value));
+ set_binding(scope, index, new(binding_t, .type=key_t, .code=CORD_cat("$", index)));
+ set_binding(scope, value, new(binding_t, .type=value_t, .code=CORD_cat("$", value)));
return scope;
}
case IntType: {
- set_binding(scope, index, new(binding_t, .type=Type(IntType, .bits=64), .code=index));
- set_binding(scope, value, new(binding_t, .type=iter_t, .code=value));
+ set_binding(scope, index, new(binding_t, .type=Type(IntType, .bits=64), .code=CORD_cat("$", index)));
+ set_binding(scope, value, new(binding_t, .type=iter_t, .code=CORD_cat("$", value)));
return scope;
}
default: code_err(for_->iter, "Iteration is not implemented for type: %T", iter_t);
@@ -246,16 +246,16 @@ env_t *for_scope(env_t *env, ast_t *ast)
switch (iter_t->tag) {
case ArrayType: {
type_t *item_t = Match(iter_t, ArrayType)->item_type;
- set_binding(scope, value, new(binding_t, .type=item_t, .code=value));
+ set_binding(scope, value, new(binding_t, .type=item_t, .code=CORD_cat("$", value)));
return scope;
}
case TableType: {
type_t *key_t = Match(iter_t, TableType)->key_type;
- set_binding(scope, value, new(binding_t, .type=key_t, .code=value));
+ set_binding(scope, value, new(binding_t, .type=key_t, .code=CORD_cat("$", value)));
return scope;
}
case IntType: {
- set_binding(scope, value, new(binding_t, .type=iter_t, .code=value));
+ set_binding(scope, value, new(binding_t, .type=iter_t, .code=CORD_cat("$", value)));
return scope;
}
default: code_err(for_->iter, "Iteration is not implemented for type: %T", iter_t);
@@ -283,7 +283,7 @@ binding_t *get_binding(env_t *env, const char *name)
b = Table$str_get(*env->fn_ctx->closure_scope, name);
if (b) {
Table$str_set(env->fn_ctx->closed_vars, name, b);
- return new(binding_t, .type=b->type, .code=CORD_all("$userdata->", name));
+ return new(binding_t, .type=b->type, .code=CORD_all("userdata->", name));
}
}
return b;
diff --git a/typecheck.c b/typecheck.c
index 35bdef19..518b7ce4 100644
--- a/typecheck.c
+++ b/typecheck.c
@@ -101,7 +101,7 @@ void bind_statement(env_t *env, ast_t *statement)
bind_statement(env, decl->value);
type_t *type = get_type(env, decl->value);
const char *name = Match(decl->var, Var)->name;
- CORD code = CORD_cat(env->scope_prefix, name);
+ CORD code = CORD_cat(env->scope_prefix ? env->scope_prefix : "$", name);
set_binding(env, name, new(binding_t, .type=type, .code=code));
break;
}
@@ -673,8 +673,8 @@ type_t *get_type(env_t *env, ast_t *ast)
type_t *iter_t = get_type(env, reduction->iter);
type_t *value_t = iteration_value_type(iter_t);
env_t *scope = fresh_scope(env);
- set_binding(scope, "$reduction", new(binding_t, .type=value_t, .code="$reduction"));
- set_binding(scope, "$iter_value", new(binding_t, .type=value_t, .code="$iter_value"));
+ set_binding(scope, "$reduction", new(binding_t, .type=value_t, .code="reduction"));
+ set_binding(scope, "$iter_value", new(binding_t, .type=value_t, .code="iter_value"));
type_t *t = get_type(scope, reduction->combination);
if (!reduction->fallback)
return t;
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-01 15:59:07 +0000