diff options
Diffstat (limited to 'src/compile.c')
| -rw-r--r-- | src/compile.c | 268 |
1 files changed, 134 insertions, 134 deletions
diff --git a/src/compile.c b/src/compile.c index cdfaf5c6..6cb25de0 100644 --- a/src/compile.c +++ b/src/compile.c @@ -34,14 +34,14 @@ static CORD compile_none(type_t *t); static CORD compile_empty(type_t *t); static CORD compile_declared_value(env_t *env, ast_t *declaration_ast); static CORD compile_to_type(env_t *env, ast_t *ast, type_t *t); -static CORD compile_typed_array(env_t *env, ast_t *ast, type_t *array_type); +static CORD compile_typed_list(env_t *env, ast_t *ast, type_t *list_type); static CORD compile_typed_set(env_t *env, ast_t *ast, type_t *set_type); static CORD compile_typed_table(env_t *env, ast_t *ast, type_t *table_type); static CORD compile_typed_allocation(env_t *env, ast_t *ast, type_t *pointer_type); static CORD check_none(type_t *t, CORD value); static CORD optional_into_nonnone(type_t *t, CORD value); static CORD compile_string_literal(CORD literal); -static ast_t *add_to_array_comprehension(ast_t *item, ast_t *subject); +static ast_t *add_to_list_comprehension(ast_t *item, ast_t *subject); static ast_t *add_to_table_comprehension(ast_t *entry, ast_t *subject); static ast_t *add_to_set_comprehension(ast_t *item, ast_t *subject); static CORD compile_lvalue(env_t *env, ast_t *ast); @@ -174,9 +174,9 @@ static bool promote(env_t *env, ast_t *ast, CORD *code, type_t *actual, type_t * return true; } - // Set -> Array promotion: - if (needed->tag == ArrayType && actual->tag == SetType - && type_eq(Match(needed, ArrayType)->item_type, Match(actual, SetType)->item_type)) { + // Set -> List promotion: + if (needed->tag == ListType && actual->tag == SetType + && type_eq(Match(needed, ListType)->item_type, Match(actual, SetType)->item_type)) { *code = CORD_all("(", *code, ").entries"); return true; } @@ -187,8 +187,8 @@ static bool promote(env_t *env, ast_t *ast, CORD *code, type_t *actual, type_t * CORD compile_maybe_incref(env_t *env, ast_t *ast, type_t *t) { if (is_idempotent(ast) && can_be_mutated(env, ast)) { - if (t->tag == ArrayType) - return CORD_all("ARRAY_COPY(", compile_to_type(env, ast, t), ")"); + if (t->tag == ListType) + return CORD_all("LIST_COPY(", compile_to_type(env, ast, t), ")"); else if (t->tag == TableType || t->tag == SetType) return CORD_all("TABLE_COPY(", compile_to_type(env, ast, t), ")"); } @@ -253,8 +253,8 @@ static void add_closed_vars(Table_t *closed_vars, env_t *enclosing_scope, env_t add_closed_vars(closed_vars, enclosing_scope, env, Match(ast, Max)->key); break; } - case Array: { - for (ast_list_t *item = Match(ast, Array)->items; item; item = item->next) + case List: { + for (ast_list_t *item = Match(ast, List)->items; item; item = item->next) add_closed_vars(closed_vars, enclosing_scope, env, item->ast); break; } @@ -283,7 +283,7 @@ static void add_closed_vars(Table_t *closed_vars, env_t *enclosing_scope, env_t return add_closed_vars(closed_vars, enclosing_scope, env, loop); } - // Array/Set/Table comprehension: + // List/Set/Table comprehension: ast_t *body = comp->expr; if (comp->filter) body = WrapAST(comp->expr, If, .condition=comp->filter, .body=body); @@ -746,8 +746,8 @@ static CORD compile_binary_op(env_t *env, ast_t *ast) case TextType: { return CORD_all("Text$concat(", lhs, ", ", rhs, ")"); } - case ArrayType: { - return CORD_all("Array$concat(", lhs, ", ", rhs, ", sizeof(", compile_type(Match(overall_t, ArrayType)->item_type), "))"); + case ListType: { + return CORD_all("List$concat(", lhs, ", ", rhs, ", sizeof(", compile_type(Match(overall_t, ListType)->item_type), "))"); } default: code_err(ast, "Concatenation isn't supported between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t), " values"); @@ -793,7 +793,7 @@ CORD compile_type(type_t *t) else return CORD_all(namespace_prefix(text->env, text->env->namespace->parent), text->lang, "$$type"); } - case ArrayType: return "Array_t"; + case ListType: return "List_t"; case SetType: return "Table_t"; case TableType: return "Table_t"; case FunctionType: { @@ -827,7 +827,7 @@ CORD compile_type(type_t *t) case TextType: return Match(nonnull, TextType)->lang ? compile_type(nonnull) : "OptionalText_t"; case IntType: case BigIntType: case NumType: case BoolType: case ByteType: - case ArrayType: case TableType: case SetType: + case ListType: case TableType: case SetType: return CORD_all("Optional", compile_type(nonnull)); case StructType: { if (nonnull == PATH_TYPE) @@ -872,19 +872,19 @@ CORD compile_lvalue(env_t *env, ast_t *ast) container_t = value_type(container_t); type_t *index_t = get_type(env, index->index); - if (container_t->tag == ArrayType) { + if (container_t->tag == ListType) { CORD target_code = compile_to_pointer_depth(env, index->indexed, 1, false); - type_t *item_type = Match(container_t, ArrayType)->item_type; + type_t *item_type = Match(container_t, ListType)->item_type; CORD index_code = index->index->tag == Int ? compile_int_to_type(env, index->index, Type(IntType, .bits=TYPE_IBITS64)) : (index_t->tag == BigIntType ? CORD_all("Int64$from_int(", compile(env, index->index), ", no)") : CORD_all("(Int64_t)(", compile(env, index->index), ")")); if (index->unchecked) { - return CORD_all("Array_lvalue_unchecked(", compile_type(item_type), ", ", target_code, ", ", + return CORD_all("List_lvalue_unchecked(", compile_type(item_type), ", ", target_code, ", ", index_code, ", sizeof(", compile_type(item_type), "))"); } else { - return CORD_all("Array_lvalue(", compile_type(item_type), ", ", target_code, ", ", + return CORD_all("List_lvalue(", compile_type(item_type), ", ", target_code, ", ", index_code, ", ", String((int)(ast->start - ast->file->text)), ", ", String((int)(ast->end - ast->file->text)), ")"); @@ -975,7 +975,7 @@ CORD check_none(type_t *t, CORD value) return CORD_all("({(", value, ").fn == NULL;})"); else if (t->tag == NumType) return CORD_all("isnan(", value, ")"); - else if (t->tag == ArrayType) + else if (t->tag == ListType) return CORD_all("({(", value, ").length < 0;})"); else if (t->tag == TableType || t->tag == SetType) return CORD_all("({(", value, ").entries.length < 0;})"); @@ -997,7 +997,7 @@ static CORD compile_condition(env_t *env, ast_t *ast) return compile(env, ast); } else if (t->tag == TextType) { return CORD_all("(", compile(env, ast), ").length"); - } else if (t->tag == ArrayType) { + } else if (t->tag == ListType) { return CORD_all("(", compile(env, ast), ").length"); } else if (t->tag == TableType || t->tag == SetType) { return CORD_all("(", compile(env, ast), ").entries.length"); @@ -1462,7 +1462,7 @@ static CORD _compile_statement(env_t *env, ast_t *ast) auto for_ = Match(ast, For); // If we're iterating over a comprehension, that's actually just doing - // one loop, we don't need to compile the comprehension as an array + // one loop, we don't need to compile the comprehension as a list // comprehension. This is a common case for reducers like `(+: i*2 for i in 5)` // or `(and) x.is_good() for x in xs` if (for_->iter->tag == Comprehension) { @@ -1565,8 +1565,8 @@ static CORD _compile_statement(env_t *env, ast_t *ast) type_t *iter_value_t = value_type(iter_t); switch (iter_value_t->tag) { - case ArrayType: { - type_t *item_t = Match(iter_value_t, ArrayType)->item_type; + case ListType: { + type_t *item_t = Match(iter_value_t, ListType)->item_type; CORD index = CORD_EMPTY; CORD value = CORD_EMPTY; if (for_->vars) { @@ -1601,17 +1601,17 @@ static CORD _compile_statement(env_t *env, ast_t *ast) if (iter_t->tag == PointerType) { loop = CORD_all("{\n" - "Array_t *ptr = ", compile_to_pointer_depth(env, for_->iter, 1, false), ";\n" - "\nARRAY_INCREF(*ptr);\n" - "Array_t iterating = *ptr;\n", + "List_t *ptr = ", compile_to_pointer_depth(env, for_->iter, 1, false), ";\n" + "\nLIST_INCREF(*ptr);\n" + "List_t iterating = *ptr;\n", loop, stop, - "\nARRAY_DECREF(*ptr);\n" + "\nLIST_DECREF(*ptr);\n" "}\n"); } else { loop = CORD_all("{\n" - "Array_t iterating = ", compile_to_pointer_depth(env, for_->iter, 0, false), ";\n", + "List_t iterating = ", compile_to_pointer_depth(env, for_->iter, 0, false), ";\n", loop, stop, "}\n"); @@ -1657,15 +1657,15 @@ static CORD _compile_statement(env_t *env, ast_t *ast) loop = CORD_all( "{\n", "Table_t *t = ", compile_to_pointer_depth(env, for_->iter, 1, false), ";\n" - "ARRAY_INCREF(t->entries);\n" - "Array_t iterating = t->entries;\n", + "LIST_INCREF(t->entries);\n" + "List_t iterating = t->entries;\n", loop, - "ARRAY_DECREF(t->entries);\n" + "LIST_DECREF(t->entries);\n" "}\n"); } else { loop = CORD_all( "{\n", - "Array_t iterating = (", compile_to_pointer_depth(env, for_->iter, 0, false), ").entries;\n", + "List_t iterating = (", compile_to_pointer_depth(env, for_->iter, 0, false), ").entries;\n", loop, "}\n"); } @@ -1834,7 +1834,7 @@ static CORD _compile_statement(env_t *env, ast_t *ast) return compile_statement(env, loop); } - // Array/Set/Table comprehension: + // List/Set/Table comprehension: comprehension_body_t get_body = (void*)env->comprehension_action->fn; ast_t *body = get_body(comp->expr, env->comprehension_action->userdata); if (comp->filter) @@ -1911,7 +1911,7 @@ CORD expr_as_text(CORD expr, type_t *t, CORD color) return CORD_asprintf("%r$as_text(stack(%r), %r, &%r$info)", name, expr, color, name); } case TextType: return CORD_asprintf("Text$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(t)); - case ArrayType: return CORD_asprintf("Array$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(t)); + case ListType: return CORD_asprintf("List$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(t)); case SetType: return CORD_asprintf("Table$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(t)); case TableType: return CORD_asprintf("Table$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(t)); case FunctionType: case ClosureType: return CORD_asprintf("Func$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(t)); @@ -1964,8 +1964,8 @@ CORD compile_to_pointer_depth(env_t *env, ast_t *ast, int64_t target_depth, bool t = ptr->pointed; } - if (needs_incref && t->tag == ArrayType) - val = CORD_all("ARRAY_COPY(", val, ")"); + if (needs_incref && t->tag == ListType) + val = CORD_all("LIST_COPY(", val, ")"); else if (needs_incref && (t->tag == TableType || t->tag == SetType)) val = CORD_all("TABLE_COPY(", val, ")"); @@ -1991,8 +1991,8 @@ CORD compile_to_type(env_t *env, ast_t *ast, type_t *t) return compile_none(t); } else if (t->tag == PointerType && (ast->tag == HeapAllocate || ast->tag == StackReference)) { return compile_typed_allocation(env, ast, t); - } else if (t->tag == ArrayType && ast->tag == Array) { - return compile_typed_array(env, ast, t); + } else if (t->tag == ListType && ast->tag == List) { + return compile_typed_list(env, ast, t); } else if (t->tag == TableType && ast->tag == Table) { return compile_typed_table(env, ast, t); } else if (t->tag == SetType && ast->tag == Set) { @@ -2015,7 +2015,7 @@ CORD compile_to_type(env_t *env, ast_t *ast, type_t *t) type_t *self_type = get_type(env, methodcall->self); // Currently, this is only implemented for cases where you have the return type // and the self type equal to each other, because that's the main case I care - // about with array and set methods (e.g. `Array.sorted()`) + // about with list and set methods (e.g. `List.sorted()`) if (is_incomplete_type(self_type) && type_eq(self_type, actual)) { type_t *completed_self = most_complete_type(self_type, t); if (completed_self) { @@ -2037,48 +2037,48 @@ CORD compile_to_type(env_t *env, ast_t *ast, type_t *t) return code; } -CORD compile_typed_array(env_t *env, ast_t *ast, type_t *array_type) +CORD compile_typed_list(env_t *env, ast_t *ast, type_t *list_type) { - auto array = Match(ast, Array); - if (!array->items) - return "(Array_t){.length=0}"; + auto list = Match(ast, List); + if (!list->items) + return "(List_t){.length=0}"; - type_t *item_type = Match(array_type, ArrayType)->item_type; + type_t *item_type = Match(list_type, ListType)->item_type; int64_t n = 0; - for (ast_list_t *item = array->items; item; item = item->next) { + for (ast_list_t *item = list->items; item; item = item->next) { ++n; if (item->ast->tag == Comprehension) - goto array_comprehension; + goto list_comprehension; } { env_t *scope = item_type->tag == EnumType ? with_enum_scope(env, item_type) : env; if (is_incomplete_type(item_type)) - code_err(ast, "This array's type can't be inferred!"); - CORD code = CORD_all("TypedArrayN(", compile_type(item_type), CORD_asprintf(", %ld", n)); - for (ast_list_t *item = array->items; item; item = item->next) { + code_err(ast, "This list's type can't be inferred!"); + CORD code = CORD_all("TypedListN(", compile_type(item_type), CORD_asprintf(", %ld", n)); + for (ast_list_t *item = list->items; item; item = item->next) { code = CORD_all(code, ", ", compile_to_type(scope, item->ast, item_type)); } return CORD_cat(code, ")"); } - array_comprehension: + list_comprehension: { env_t *scope = item_type->tag == EnumType ? with_enum_scope(env, item_type) : fresh_scope(env); static int64_t comp_num = 1; - const char *comprehension_name = String("arr$", comp_num++); + const char *comprehension_name = String("list$", comp_num++); ast_t *comprehension_var = LiteralCode(CORD_all("&", comprehension_name), - .type=Type(PointerType, .pointed=array_type, .is_stack=true)); - Closure_t comp_action = {.fn=add_to_array_comprehension, .userdata=comprehension_var}; + .type=Type(PointerType, .pointed=list_type, .is_stack=true)); + Closure_t comp_action = {.fn=add_to_list_comprehension, .userdata=comprehension_var}; scope->comprehension_action = &comp_action; - CORD code = CORD_all("({ Array_t ", comprehension_name, " = {};"); - // set_binding(scope, comprehension_name, array_type, comprehension_name); - for (ast_list_t *item = array->items; item; item = item->next) { + CORD code = CORD_all("({ List_t ", comprehension_name, " = {};"); + // set_binding(scope, comprehension_name, list_type, comprehension_name); + for (ast_list_t *item = list->items; item; item = item->next) { if (item->ast->tag == Comprehension) code = CORD_all(code, "\n", compile_statement(scope, item->ast)); else - code = CORD_all(code, compile_statement(env, add_to_array_comprehension(item->ast, comprehension_var))); + code = CORD_all(code, compile_statement(env, add_to_list_comprehension(item->ast, comprehension_var))); } code = CORD_all(code, " ", comprehension_name, "; })"); return code; @@ -2463,7 +2463,7 @@ CORD compile_none(type_t *t) } case BoolType: return "NONE_BOOL"; case ByteType: return "NONE_BYTE"; - case ArrayType: return "NONE_ARRAY"; + case ListType: return "NONE_LIST"; case TableType: return "NONE_TABLE"; case SetType: return "NONE_TABLE"; case TextType: return "NONE_TEXT"; @@ -2505,7 +2505,7 @@ CORD compile_empty(type_t *t) } case ByteType: return "((Byte_t)0)"; case BoolType: return "((Bool_t)no)"; - case ArrayType: return "((Array_t){})"; + case ListType: return "((List_t){})"; case TableType: case SetType: return "((Table_t){})"; case TextType: return "Text(\"\")"; case CStringType: return "\"\""; @@ -2577,7 +2577,7 @@ ast_t *add_to_table_comprehension(ast_t *entry, ast_t *subject) .args=new(arg_ast_t, .value=e->key, .next=new(arg_ast_t, .value=e->value))); } -ast_t *add_to_array_comprehension(ast_t *item, ast_t *subject) +ast_t *add_to_list_comprehension(ast_t *item, ast_t *subject) { return WrapAST(item, MethodCall, .name="insert", .self=subject, .args=new(arg_ast_t, .value=item)); } @@ -2634,7 +2634,7 @@ CORD compile(env_t *env, ast_t *ast) return CORD_all("!(", compile(env, value), ")"); else if (t->tag == IntType || t->tag == ByteType) return CORD_all("~(", compile(env, value), ")"); - else if (t->tag == ArrayType) + else if (t->tag == ListType) return CORD_all("((", compile(env, value), ").length == 0)"); else if (t->tag == SetType || t->tag == TableType) return CORD_all("((", compile(env, value), ").entries.length == 0)"); @@ -2884,13 +2884,13 @@ CORD compile(env_t *env, ast_t *ast) comparison, " ? ternary$lhs : ternary$rhs;\n" "})"); } - case Array: { - auto array = Match(ast, Array); - if (!array->items) - return "(Array_t){.length=0}"; + case List: { + auto list = Match(ast, List); + if (!list->items) + return "(List_t){.length=0}"; - type_t *array_type = get_type(env, ast); - return compile_typed_array(env, ast, array_type); + type_t *list_type = get_type(env, ast); + return compile_typed_list(env, ast, list_type); } case Table: { auto table = Match(ast, Table); @@ -2919,7 +2919,7 @@ CORD compile(env_t *env, ast_t *ast) if (base->tag == TableEntry) return compile(env, WrapAST(ast, Table, .entries=new(ast_list_t, .ast=ast))); else - return compile(env, WrapAST(ast, Array, .items=new(ast_list_t, .ast=ast))); + return compile(env, WrapAST(ast, List, .items=new(ast_list_t, .ast=ast))); } case Lambda: { auto lambda = Match(ast, Lambda); @@ -2989,8 +2989,8 @@ CORD compile(env_t *env, ast_t *ast) binding_t *b = get_binding(env, entry->name); assert(b); CORD binding_code = b->code; - if (entry->b->type->tag == ArrayType) - userdata = CORD_all(userdata, ", ARRAY_COPY(", binding_code, ")"); + if (entry->b->type->tag == ListType) + userdata = CORD_all(userdata, ", LIST_COPY(", binding_code, ")"); else if (entry->b->type->tag == TableType || entry->b->type->tag == SetType) userdata = CORD_all(userdata, ", TABLE_COPY(", binding_code, ")"); else @@ -3049,66 +3049,66 @@ CORD compile(env_t *env, ast_t *ast) else if (pointer_depth > 1) code_err(call->self, "I expected "article" "name" pointer here, not a nested "name" pointer"); \ } while (0) switch (self_value_t->tag) { - case ArrayType: { - type_t *item_t = Match(self_value_t, ArrayType)->item_type; + case ListType: { + type_t *item_t = Match(self_value_t, ListType)->item_type; CORD padded_item_size = CORD_all("sizeof(", compile_type(item_t), ")"); if (streq(call->name, "insert")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); arg_t *arg_spec = new(arg_t, .name="item", .type=item_t, .next=new(arg_t, .name="at", .type=INT_TYPE, .default_val=FakeAST(Int, .str="0"))); - return CORD_all("Array$insert_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", + return CORD_all("List$insert_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); } else if (streq(call->name, "insert_all")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); arg_t *arg_spec = new(arg_t, .name="items", .type=self_value_t, .next=new(arg_t, .name="at", .type=INT_TYPE, .default_val=FakeAST(Int, .str="0"))); - return CORD_all("Array$insert_all(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", + return CORD_all("List$insert_all(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); } else if (streq(call->name, "remove_at")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); arg_t *arg_spec = new(arg_t, .name="index", .type=INT_TYPE, .default_val=FakeAST(Int, .str="-1"), .next=new(arg_t, .name="count", .type=INT_TYPE, .default_val=FakeAST(Int, .str="1"))); - return CORD_all("Array$remove_at(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", + return CORD_all("List$remove_at(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); } else if (streq(call->name, "remove_item")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); arg_t *arg_spec = new(arg_t, .name="item", .type=item_t, .next=new(arg_t, .name="max_count", .type=INT_TYPE, .default_val=FakeAST(Int, .str="-1"))); - return CORD_all("Array$remove_item_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", + return CORD_all("List$remove_item_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", compile_type_info(self_value_t), ")"); } else if (streq(call->name, "has")) { self = compile_to_pointer_depth(env, call->self, 0, false); arg_t *arg_spec = new(arg_t, .name="item", .type=item_t); - return CORD_all("Array$has_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", + return CORD_all("List$has_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", compile_type_info(self_value_t), ")"); } else if (streq(call->name, "sample")) { type_t *random_num_type = parse_type_string(env, "func(->Num)?"); self = compile_to_pointer_depth(env, call->self, 0, false); arg_t *arg_spec = new(arg_t, .name="count", .type=INT_TYPE, - .next=new(arg_t, .name="weights", .type=Type(ArrayType, .item_type=Type(NumType, .bits=TYPE_NBITS64)), + .next=new(arg_t, .name="weights", .type=Type(ListType, .item_type=Type(NumType, .bits=TYPE_NBITS64)), .default_val=FakeAST(None), .next=new(arg_t, .name="random", .type=random_num_type, .default_val=FakeAST(None)))); - return CORD_all("Array$sample(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", + return CORD_all("List$sample(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); } else if (streq(call->name, "shuffle")) { type_t *random_int64_type = parse_type_string(env, "func(min,max:Int64->Int64)?"); - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); arg_t *arg_spec = new(arg_t, .name="random", .type=random_int64_type, .default_val=FakeAST(None)); - return CORD_all("Array$shuffle(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); + return CORD_all("List$shuffle(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); } else if (streq(call->name, "shuffled")) { type_t *random_int64_type = parse_type_string(env, "func(min,max:Int64->Int64)?"); self = compile_to_pointer_depth(env, call->self, 0, false); arg_t *arg_spec = new(arg_t, .name="random", .type=random_int64_type, .default_val=FakeAST(None)); - return CORD_all("Array$shuffled(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); + return CORD_all("List$shuffled(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); } else if (streq(call->name, "random")) { type_t *random_int64_type = parse_type_string(env, "func(min,max:Int64->Int64)?"); self = compile_to_pointer_depth(env, call->self, 0, false); arg_t *arg_spec = new(arg_t, .name="random", .type=random_int64_type, .default_val=FakeAST(None)); - return CORD_all("Array$random_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", compile_type(item_t), ")"); + return CORD_all("List$random_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", compile_type(item_t), ")"); } else if (streq(call->name, "sort") || streq(call->name, "sorted")) { if (streq(call->name, "sort")) - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); else self = compile_to_pointer_depth(env, call->self, 0, false); CORD comparison; @@ -3120,9 +3120,9 @@ CORD compile(env_t *env, ast_t *ast) } else { comparison = CORD_all("((Closure_t){.fn=generic_compare, .userdata=(void*)", compile_type_info(item_t), "})"); } - return CORD_all("Array$", call->name, "(", self, ", ", comparison, ", ", padded_item_size, ")"); + return CORD_all("List$", call->name, "(", self, ", ", comparison, ", ", padded_item_size, ")"); } else if (streq(call->name, "heapify")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); CORD comparison; if (call->args) { type_t *item_ptr = Type(PointerType, .pointed=item_t, .is_stack=true); @@ -3132,9 +3132,9 @@ CORD compile(env_t *env, ast_t *ast) } else { comparison = CORD_all("((Closure_t){.fn=generic_compare, .userdata=(void*)", compile_type_info(item_t), "})"); } - return CORD_all("Array$heapify(", self, ", ", comparison, ", ", padded_item_size, ")"); + return CORD_all("List$heapify(", self, ", ", comparison, ", ", padded_item_size, ")"); } else if (streq(call->name, "heap_push")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); type_t *item_ptr = Type(PointerType, .pointed=item_t, .is_stack=true); type_t *fn_t = NewFunctionType(Type(IntType, .bits=TYPE_IBITS32), {.name="x", .type=item_ptr}, {.name="y", .type=item_ptr}); ast_t *default_cmp = LiteralCode(CORD_all("((Closure_t){.fn=generic_compare, .userdata=(void*)", @@ -3143,9 +3143,9 @@ CORD compile(env_t *env, ast_t *ast) arg_t *arg_spec = new(arg_t, .name="item", .type=item_t, .next=new(arg_t, .name="by", .type=Type(ClosureType, .fn=fn_t), .default_val=default_cmp)); CORD arg_code = compile_arguments(env, ast, arg_spec, call->args); - return CORD_all("Array$heap_push_value(", self, ", ", arg_code, ", ", padded_item_size, ")"); + return CORD_all("List$heap_push_value(", self, ", ", arg_code, ", ", padded_item_size, ")"); } else if (streq(call->name, "heap_pop")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); type_t *item_ptr = Type(PointerType, .pointed=item_t, .is_stack=true); type_t *fn_t = NewFunctionType(Type(IntType, .bits=TYPE_IBITS32), {.name="x", .type=item_ptr}, {.name="y", .type=item_ptr}); ast_t *default_cmp = LiteralCode(CORD_all("((Closure_t){.fn=generic_compare, .userdata=(void*)", @@ -3153,7 +3153,7 @@ CORD compile(env_t *env, ast_t *ast) .type=Type(ClosureType, .fn=fn_t)); arg_t *arg_spec = new(arg_t, .name="by", .type=Type(ClosureType, .fn=fn_t), .default_val=default_cmp); CORD arg_code = compile_arguments(env, ast, arg_spec, call->args); - return CORD_all("Array$heap_pop_value(", self, ", ", arg_code, ", ", compile_type(item_t), ", _, ", + return CORD_all("List$heap_pop_value(", self, ", ", arg_code, ", ", compile_type(item_t), ", _, ", promote_to_optional(item_t, "_"), ", ", compile_none(item_t), ")"); } else if (streq(call->name, "binary_search")) { self = compile_to_pointer_depth(env, call->self, 0, call->args != NULL); @@ -3166,15 +3166,15 @@ CORD compile(env_t *env, ast_t *ast) arg_t *arg_spec = new(arg_t, .name="target", .type=item_t, .next=new(arg_t, .name="by", .type=Type(ClosureType, .fn=fn_t), .default_val=default_cmp)); CORD arg_code = compile_arguments(env, ast, arg_spec, call->args); - return CORD_all("Array$binary_search_value(", self, ", ", arg_code, ")"); + return CORD_all("List$binary_search_value(", self, ", ", arg_code, ")"); } else if (streq(call->name, "clear")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); (void)compile_arguments(env, ast, NULL, call->args); - return CORD_all("Array$clear(", self, ")"); + return CORD_all("List$clear(", self, ")"); } else if (streq(call->name, "find")) { self = compile_to_pointer_depth(env, call->self, 0, false); arg_t *arg_spec = new(arg_t, .name="item", .type=item_t); - return CORD_all("Array$find_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), + return CORD_all("List$find_value(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", compile_type_info(self_value_t), ")"); } else if (streq(call->name, "first")) { self = compile_to_pointer_depth(env, call->self, 0, call->args != NULL); @@ -3182,38 +3182,38 @@ CORD compile(env_t *env, ast_t *ast) type_t *predicate_type = Type( ClosureType, .fn=NewFunctionType(Type(BoolType), {.name="item", .type=item_ptr})); arg_t *arg_spec = new(arg_t, .name="predicate", .type=predicate_type); - return CORD_all("Array$first(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ")"); + return CORD_all("List$first(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ")"); } else if (streq(call->name, "from")) { self = compile_to_pointer_depth(env, call->self, 0, true); arg_t *arg_spec = new(arg_t, .name="first", .type=INT_TYPE); - return CORD_all("Array$from(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ")"); + return CORD_all("List$from(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ")"); } else if (streq(call->name, "to")) { self = compile_to_pointer_depth(env, call->self, 0, true); arg_t *arg_spec = new(arg_t, .name="last", .type=INT_TYPE); - return CORD_all("Array$to(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ")"); + return CORD_all("List$to(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ")"); } else if (streq(call->name, "by")) { self = compile_to_pointer_depth(env, call->self, 0, true); arg_t *arg_spec = new(arg_t, .name="stride", .type=INT_TYPE); - return CORD_all("Array$by(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); + return CORD_all("List$by(", self, ", ", compile_arguments(env, ast, arg_spec, call->args), ", ", padded_item_size, ")"); } else if (streq(call->name, "reversed")) { self = compile_to_pointer_depth(env, call->self, 0, true); (void)compile_arguments(env, ast, NULL, call->args); - return CORD_all("Array$reversed(", self, ", ", padded_item_size, ")"); + return CORD_all("List$reversed(", self, ", ", padded_item_size, ")"); } else if (streq(call->name, "unique")) { self = compile_to_pointer_depth(env, call->self, 0, false); (void)compile_arguments(env, ast, NULL, call->args); return CORD_all("Table$from_entries(", self, ", Set$info(", compile_type_info(item_t), "))"); } else if (streq(call->name, "pop")) { - EXPECT_POINTER("an", "array"); + EXPECT_POINTER("a", "list"); arg_t *arg_spec = new(arg_t, .name="index", .type=INT_TYPE, .default_val=FakeAST(Int, "-1")); CORD index = compile_arguments(env, ast, arg_spec, call->args); - return CORD_all("Array$pop(", self, ", ", index, ", ", compile_type(item_t), ", _, ", + return CORD_all("List$pop(", self, ", ", index, ", ", compile_type(item_t), ", _, ", promote_to_optional(item_t, "_"), ", ", compile_none(item_t), ")"); } else if (streq(call->name, "counts")) { self = compile_to_pointer_depth(env, call->self, 0, false); (void)compile_arguments(env, ast, NULL, call->args); - return CORD_all("Array$counts(", self, ", ", compile_type_info(self_value_t), ")"); - } else code_err(ast, "There is no '", call->name, "' method for arrays"); + return CORD_all("List$counts(", self, ", ", compile_type_info(self_value_t), ")"); + } else code_err(ast, "There is no '", call->name, "' method for lists"); } case SetType: { auto set = Match(self_value_t, SetType); @@ -3229,9 +3229,9 @@ CORD compile(env_t *env, ast_t *ast) compile_type_info(self_value_t), ")"); } else if (streq(call->name, "add_all")) { EXPECT_POINTER("a", "set"); - arg_t *arg_spec = new(arg_t, .name="items", .type=Type(ArrayType, .item_type=Match(self_value_t, SetType)->item_type)); + arg_t *arg_spec = new(arg_t, .name="items", .type=Type(ListType, .item_type=Match(self_value_t, SetType)->item_type)); return CORD_all("({ Table_t *set = ", self, "; ", - "Array_t to_add = ", compile_arguments(env, ast, arg_spec, call->args), "; ", + "List_t to_add = ", compile_arguments(env, ast, arg_spec, call->args), "; ", "for (int64_t i = 0; i < to_add.length; i++)\n" "Table$set(set, to_add.data + i*to_add.stride, NULL, ", compile_type_info(self_value_t), ");\n", "(void)0; })"); @@ -3242,9 +3242,9 @@ CORD compile(env_t *env, ast_t *ast) compile_type_info(self_value_t), ")"); } else if (streq(call->name, "remove_all")) { EXPECT_POINTER("a", "set"); - arg_t *arg_spec = new(arg_t, .name="items", .type=Type(ArrayType, .item_type=Match(self_value_t, SetType)->item_type)); + arg_t *arg_spec = new(arg_t, .name="items", .type=Type(ListType, .item_type=Match(self_value_t, SetType)->item_type)); return CORD_all("({ Table_t *set = ", self, "; ", - "Array_t to_add = ", compile_arguments(env, ast, arg_spec, call->args), "; ", + "List_t to_add = ", compile_arguments(env, ast, arg_spec, call->args), "; ", "for (int64_t i = 0; i < to_add.length; i++)\n" "Table$remove(set, to_add.data + i*to_add.stride, ", compile_type_info(self_value_t), ");\n", "(void)0; })"); @@ -3417,8 +3417,8 @@ CORD compile(env_t *env, ast_t *ast) case Deserialize: { ast_t *value = Match(ast, Deserialize)->value; type_t *value_type = get_type(env, value); - if (!type_eq(value_type, Type(ArrayType, Type(ByteType)))) - code_err(value, "This value should be an array of bytes, not a ", type_to_str(value_type)); + if (!type_eq(value_type, Type(ListType, Type(ByteType)))) + code_err(value, "This value should be a list of bytes, not a ", type_to_str(value_type)); type_t *t = parse_type_ast(env, Match(ast, Deserialize)->type); return CORD_all("({ ", compile_declaration(t, "deserialized"), ";\n" "generic_deserialize(", compile(env, value), ", &deserialized, ", compile_type_info(t), ");\n" @@ -3716,14 +3716,14 @@ CORD compile(env_t *env, ast_t *ast) } code_err(ast, "The field '", f->field, "' is not a valid tag name of ", type_to_str(value_t)); } - case ArrayType: { + case ListType: { if (streq(f->field, "length")) return CORD_all("Int$from_int64((", compile_to_pointer_depth(env, f->fielded, 0, false), ").length)"); - code_err(ast, "There is no ", f->field, " field on arrays"); + code_err(ast, "There is no ", f->field, " field on lists"); } case SetType: { if (streq(f->field, "items")) - return CORD_all("ARRAY_COPY((", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries)"); + return CORD_all("LIST_COPY((", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries)"); else if (streq(f->field, "length")) return CORD_all("Int$from_int64((", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries.length)"); code_err(ast, "There is no '", f->field, "' field on sets"); @@ -3732,13 +3732,13 @@ CORD compile(env_t *env, ast_t *ast) if (streq(f->field, "length")) { return CORD_all("Int$from_int64((", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries.length)"); } else if (streq(f->field, "keys")) { - return CORD_all("ARRAY_COPY((", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries)"); + return CORD_all("LIST_COPY((", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries)"); } else if (streq(f->field, "values")) { auto table = Match(value_t, TableType); CORD offset = CORD_all("offsetof(struct { ", compile_declaration(table->key_type, "k"), "; ", compile_declaration(table->value_type, "v"), "; }, v)"); - return CORD_all("({ Array_t *entries = &(", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries;\n" - "ARRAY_INCREF(*entries);\n" - "Array_t values = *entries;\n" + return CORD_all("({ List_t *entries = &(", compile_to_pointer_depth(env, f->fielded, 0, false), ").entries;\n" + "LIST_INCREF(*entries);\n" + "List_t values = *entries;\n" "values.data += ", offset, ";\n" "values; })"); } else if (streq(f->field, "fallback")) { @@ -3762,8 +3762,8 @@ CORD compile(env_t *env, ast_t *ast) if (indexed_type->tag != PointerType) code_err(ast, "Only pointers can use the '[]' operator to dereference the entire value."); auto ptr = Match(indexed_type, PointerType); - if (ptr->pointed->tag == ArrayType) { - return CORD_all("*({ Array_t *arr = ", compile(env, indexing->indexed), "; ARRAY_INCREF(*arr); arr; })"); + if (ptr->pointed->tag == ListType) { + return CORD_all("*({ List_t *list = ", compile(env, indexing->indexed), "; LIST_INCREF(*list); list; })"); } else if (ptr->pointed->tag == TableType || ptr->pointed->tag == SetType) { return CORD_all("*({ Table_t *t = ", compile(env, indexing->indexed), "; TABLE_INCREF(*t); t; })"); } else { @@ -3773,20 +3773,20 @@ CORD compile(env_t *env, ast_t *ast) type_t *container_t = value_type(indexed_type); type_t *index_t = get_type(env, indexing->index); - if (container_t->tag == ArrayType) { + if (container_t->tag == ListType) { if (index_t->tag != IntType && index_t->tag != BigIntType && index_t->tag != ByteType) - code_err(indexing->index, "Arrays can only be indexed by integers, not ", type_to_str(index_t)); - type_t *item_type = Match(container_t, ArrayType)->item_type; - CORD arr = compile_to_pointer_depth(env, indexing->indexed, 0, false); + code_err(indexing->index, "Lists can only be indexed by integers, not ", type_to_str(index_t)); + type_t *item_type = Match(container_t, ListType)->item_type; + CORD list = compile_to_pointer_depth(env, indexing->indexed, 0, false); file_t *f = indexing->index->file; CORD index_code = indexing->index->tag == Int ? compile_int_to_type(env, indexing->index, Type(IntType, .bits=TYPE_IBITS64)) : (index_t->tag == BigIntType ? CORD_all("Int64$from_int(", compile(env, indexing->index), ", no)") : CORD_all("(Int64_t)(", compile(env, indexing->index), ")")); if (indexing->unchecked) - return CORD_all("Array_get_unchecked(", compile_type(item_type), ", ", arr, ", ", index_code, ")"); + return CORD_all("List_get_unchecked(", compile_type(item_type), ", ", list, ", ", index_code, ")"); else - return CORD_all("Array_get(", compile_type(item_type), ", ", arr, ", ", index_code, ", ", + return CORD_all("List_get(", compile_type(item_type), ", ", list, ", ", index_code, ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->start - f->text)), ", ", CORD_asprintf("%ld", (int64_t)(indexing->index->end - f->text)), ")"); @@ -3859,9 +3859,9 @@ CORD compile_type_info(type_t *t) auto e = Match(t, EnumType); return CORD_all("(&", namespace_prefix(e->env, e->env->namespace->parent), e->name, "$$info)"); } - case ArrayType: { - type_t *item_t = Match(t, ArrayType)->item_type; - return CORD_all("Array$info(", compile_type_info(item_t), ")"); + case ListType: { + type_t *item_t = Match(t, ListType)->item_type; + return CORD_all("List$info(", compile_type_info(item_t), ")"); } case SetType: { type_t *item_type = Match(t, SetType)->item_type; @@ -3950,7 +3950,7 @@ CORD compile_cli_arg_call(env_t *env, CORD fn_name, type_t *fn_type) } else { if (t->tag == BoolType || (t->tag == OptionalType && Match(t, OptionalType)->type->tag == BoolType)) usage = CORD_all(usage, "[--", flag, "]"); - else if (t->tag == ArrayType) + else if (t->tag == ListType) usage = CORD_all(usage, "[--", flag, " ", get_flag_options(t, "|"), "]"); else usage = CORD_all(usage, "[--", flag, "=", get_flag_options(t, "|"), "]"); @@ -3960,7 +3960,7 @@ CORD compile_cli_arg_call(env_t *env, CORD fn_name, type_t *fn_type) usage = CORD_all(usage, "<--", flag, "|--no-", flag, ">"); else if (t->tag == EnumType) usage = CORD_all(usage, get_flag_options(t, "|")); - else if (t->tag == ArrayType) + else if (t->tag == ListType) usage = CORD_all(usage, "[", flag, "...]"); else usage = CORD_all(usage, "<", flag, ">"); |