From c59f6b7d0b582131bed4450bbb9aa1a71d5a01af Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Sun, 26 Feb 2017 00:44:26 +0000 Subject: ++ -- statements; add strconv.odin (and replace some of the fmt procs); Fix ~ on 64 bit constants; Fix integer casts from smaller to larger size --- src/check_expr.c | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) (limited to 'src/check_expr.c') diff --git a/src/check_expr.c b/src/check_expr.c index f075df688..aa5222d9d 100644 --- a/src/check_expr.c +++ b/src/check_expr.c @@ -197,11 +197,11 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) { } } - // if (is_type_proc(dst)) { - // if (are_types_identical(src, dst)) { - // return 1; - // } - // } + if (is_type_proc(dst)) { + if (are_types_identical(src, dst)) { + return 3; + } + } if (is_type_any(dst)) { // NOTE(bill): Anything can cast to `Any` @@ -2827,6 +2827,16 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h goto error; } } + + if (entity == NULL && + operand->type != NULL && is_type_untyped(operand->type) && is_type_string(operand->type)) { + String s = operand->value.value_string; + operand->mode = Addressing_Constant; + operand->value = make_exact_value_integer(s.len); + operand->type = t_untyped_integer; + return NULL; + } + if (entity == NULL) { gbString op_str = expr_to_string(op_expr); gbString type_str = type_to_string(operand->type); @@ -5445,9 +5455,10 @@ gbString write_expr_to_string(gbString str, AstNode *node) { case_ast_node(at, ArrayType, node); str = gb_string_appendc(str, "["); - if (at->count->kind == AstNode_UnaryExpr && - at->count->UnaryExpr.op.kind == Token_Hash) { - str = gb_string_appendc(str, "#"); + if (at->count != NULL && + at->count->kind == AstNode_UnaryExpr && + at->count->UnaryExpr.op.kind == Token_Ellipsis) { + str = gb_string_appendc(str, "..."); } else { str = write_expr_to_string(str, at->count); } -- cgit v1.2.3 From f29e303ce7b11fbe88a4b63374c08130c6c189dd Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Sun, 26 Feb 2017 15:14:08 +0000 Subject: Slices now have a capacity. --- code/demo.odin | 18 ++--- core/_preload.odin | 35 ++++++++-- src/check_expr.c | 35 ++++++---- src/check_stmt.c | 1 + src/ir.c | 190 +++++++++++++++++++++++++++-------------------------- src/ir_print.c | 9 ++- src/parser.c | 44 +++++++++---- src/types.c | 35 ++++++---- 8 files changed, 224 insertions(+), 143 deletions(-) (limited to 'src/check_expr.c') diff --git a/code/demo.odin b/code/demo.odin index ea5e59a0d..8162fc0d3 100644 --- a/code/demo.odin +++ b/code/demo.odin @@ -8,15 +8,17 @@ #import "strconv.odin"; main :: proc() { - buf: [64]byte; - // len := strconv.generic_ftoa(buf[..], 123.5431, 'f', 4, 64); - x := 624.123; - s := strconv.format_float(buf[..], x, 'f', 6, 64); + // buf: [64]byte; + // // len := strconv.generic_ftoa(buf[..], 123.5431, 'f', 4, 64); + // x := 624.123; + // s := strconv.format_float(buf[..], x, 'f', 6, 64); + // fmt.println(s); + // fmt.printf("%3d\n", 102); + + a: [10]int; + s := a[..0]; + append(s, 1, 2, 6, 3, 6, 5, 5, 5, 5, 1, 2); fmt.println(s); - fmt.printf("%3d\n", 102); - - a := [..]int{0, 1, 2, 3, 4, 5, 6}; - fmt.println(a[0..4]); when false { diff --git a/core/_preload.odin b/core/_preload.odin index fab23057f..83ce45ce7 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -321,12 +321,12 @@ __bounds_check_error :: proc(file: string, line, column: int, index, count: int) __debug_trap(); } -__slice_expr_error :: proc(file: string, line, column: int, low, high: int) { - if 0 <= low && low <= high { +__slice_expr_error :: proc(file: string, line, column: int, low, high, max: int) { + if 0 <= low && low <= high && high <= max { return; } - fmt.fprintf(os.stderr, "%s(%d:%d) Invalid slice indices: [%d..%d]\n", - file, line, column, low, high); + fmt.fprintf(os.stderr, "%s(%d:%d) Invalid slice indices: [%d..%d..%d]\n", + file, line, column, low, high, max); __debug_trap(); } __substring_expr_error :: proc(file: string, line, column: int, low, high: int) { @@ -361,8 +361,9 @@ Raw_String :: struct #ordered { }; Raw_Slice :: struct #ordered { - data: rawptr, - count: int, + data: rawptr, + count: int, + capacity: int, }; Raw_Dynamic_Array :: struct #ordered { @@ -451,6 +452,28 @@ __dynamic_array_append_nothing :: proc(array_: rawptr, elem_size, elem_align: in return array.count; } +__slice_append :: proc(slice_: rawptr, elem_size, elem_align: int, + items: rawptr, item_count: int) -> int { + slice := cast(^Raw_Slice)slice_; + + if item_count <= 0 || items == nil { + return slice.count; + } + + + ok := true; + if item_count > (slice.capacity-slice.count) { + item_count = (slice.capacity-slice.count); + } + if item_count > 0 { + data := cast(^byte)slice.data; + assert(data != nil); + mem.copy(data + (elem_size*slice.count), items, elem_size * item_count); + slice.count += item_count; + } + return slice.count; +} + // Map stuff diff --git a/src/check_expr.c b/src/check_expr.c index aa5222d9d..264a5d072 100644 --- a/src/check_expr.c +++ b/src/check_expr.c @@ -3057,19 +3057,26 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } break; case BuiltinProc_append: { - // append :: proc([dynamic]Type, item: ...Type) + // append :: proc([dynamic]Type, item: ..Type) + // append :: proc([]Type, item: ..Type) Type *type = operand->type; type = base_type(type); - if (!is_type_dynamic_array(type)) { + if (!is_type_dynamic_array(type) && !is_type_slice(type)) { gbString str = type_to_string(type); - error_node(operand->expr, "Expected a dynamic array, got `%s`", str); + error_node(operand->expr, "Expected a slice or dynamic array, got `%s`", str); gb_string_free(str); return false; } - // TODO(bill): Semi-memory leaks - Type *elem = type->DynamicArray.elem; - Type *slice_elem = make_type_slice(c->allocator, elem); + Type *elem = NULL; + Type *slice_elem = NULL; + if (is_type_dynamic_array(type)) { + // TODO(bill): Semi-memory leaks + elem = type->DynamicArray.elem; + } else { + elem = type->Slice.elem; + } + slice_elem = make_type_slice(c->allocator, elem); Type *proc_type_params = make_type_tuple(c->allocator); proc_type_params->Tuple.variables = gb_alloc_array(c->allocator, Entity *, 2); @@ -3404,7 +3411,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } break; case BuiltinProc_swizzle: { - // swizzle :: proc(v: {N}T, T...) -> {M}T + // swizzle :: proc(v: {N}T, T..) -> {M}T Type *vector_type = base_type(operand->type); if (!is_type_vector(vector_type)) { gbString type_str = type_to_string(operand->type); @@ -5433,13 +5440,17 @@ gbString write_expr_to_string(gbString str, AstNode *node) { str = write_expr_to_string(str, se->expr); str = gb_string_appendc(str, "["); str = write_expr_to_string(str, se->low); - str = gb_string_appendc(str, ":"); + str = gb_string_appendc(str, ".."); str = write_expr_to_string(str, se->high); + if (se->index3) { + str = gb_string_appendc(str, ".."); + str = write_expr_to_string(str, se->max); + } str = gb_string_appendc(str, "]"); case_end; case_ast_node(e, Ellipsis, node); - str = gb_string_appendc(str, "..."); + str = gb_string_appendc(str, ".."); case_end; case_ast_node(fv, FieldValue, node); @@ -5458,7 +5469,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { if (at->count != NULL && at->count->kind == AstNode_UnaryExpr && at->count->UnaryExpr.op.kind == Token_Ellipsis) { - str = gb_string_appendc(str, "..."); + str = gb_string_appendc(str, ".."); } else { str = write_expr_to_string(str, at->count); } @@ -5467,7 +5478,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { case_end; case_ast_node(at, DynamicArrayType, node); - str = gb_string_appendc(str, "[...]"); + str = gb_string_appendc(str, "[..]"); str = write_expr_to_string(str, at->elem); case_end; @@ -5500,7 +5511,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { str = gb_string_appendc(str, ": "); } if (f->flags&FieldFlag_ellipsis) { - str = gb_string_appendc(str, "..."); + str = gb_string_appendc(str, ".."); } str = write_expr_to_string(str, f->type); case_end; diff --git a/src/check_stmt.c b/src/check_stmt.c index 6fd7cb925..768410803 100644 --- a/src/check_stmt.c +++ b/src/check_stmt.c @@ -1258,6 +1258,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case Entity_Variable: { Type *t = base_type(type_deref(e->type)); if (is_type_struct(t) || is_type_raw_union(t)) { + // TODO(bill): Make it work for unions too Scope **found = map_scope_get(&c->info.scopes, hash_pointer(t->Record.node)); GB_ASSERT(found != NULL); for_array(i, (*found)->elements.entries) { diff --git a/src/ir.c b/src/ir.c index 282d30efc..a455c0164 100644 --- a/src/ir.c +++ b/src/ir.c @@ -218,6 +218,7 @@ struct irProcedure { TokenPos pos; \ irValue *low; \ irValue *high; \ + irValue *max; \ bool is_substring; \ }) \ IR_INSTR_KIND(DebugDeclare, struct { \ @@ -956,11 +957,12 @@ irValue *ir_make_instr_bounds_check(irProcedure *p, TokenPos pos, irValue *index v->Instr.BoundsCheck.len = len; return v; } -irValue *ir_make_instr_slice_bounds_check(irProcedure *p, TokenPos pos, irValue *low, irValue *high, bool is_substring) { +irValue *ir_make_instr_slice_bounds_check(irProcedure *p, TokenPos pos, irValue *low, irValue *high, irValue *max, bool is_substring) { irValue *v = ir_alloc_instr(p, irInstr_SliceBoundsCheck); v->Instr.SliceBoundsCheck.pos = pos; v->Instr.SliceBoundsCheck.low = low; v->Instr.SliceBoundsCheck.high = high; + v->Instr.SliceBoundsCheck.max = max; v->Instr.SliceBoundsCheck.is_substring = is_substring; return v; } @@ -1845,6 +1847,7 @@ irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index) { switch (index) { case 0: result_type = make_type_pointer(a, make_type_pointer(a, t->Slice.elem)); break; case 1: result_type = make_type_pointer(a, t_int); break; + case 2: result_type = make_type_pointer(a, t_int); break; } } else if (is_type_string(t)) { switch (index) { @@ -2070,6 +2073,11 @@ irValue *ir_slice_count(irProcedure *proc, irValue *slice) { GB_ASSERT(t->kind == Type_Slice); return ir_emit_struct_ev(proc, slice, 1); } +irValue *ir_slice_capacity(irProcedure *proc, irValue *slice) { + Type *t = base_type(ir_type(slice)); + GB_ASSERT(t->kind == Type_Slice); + return ir_emit_struct_ev(proc, slice, 2); +} irValue *ir_dynamic_array_elem(irProcedure *proc, irValue *da) { Type *t = ir_type(da); @@ -2106,8 +2114,19 @@ irValue *ir_string_len(irProcedure *proc, irValue *string) { } +void ir_fill_slice(irProcedure *proc, irValue *slice_ptr, irValue *data, irValue *count, irValue *capacity) { + Type *t = ir_type(slice_ptr); + GB_ASSERT(is_type_pointer(t)); + t = type_deref(t); + GB_ASSERT(is_type_slice(t)); + ir_emit_store(proc, ir_emit_struct_ep(proc, slice_ptr, 0), data); + ir_emit_store(proc, ir_emit_struct_ep(proc, slice_ptr, 1), count); + ir_emit_store(proc, ir_emit_struct_ep(proc, slice_ptr, 2), capacity); +} + + -irValue *ir_add_local_slice(irProcedure *proc, Type *slice_type, irValue *base, irValue *low, irValue *high) { +irValue *ir_add_local_slice(irProcedure *proc, Type *slice_type, irValue *base, irValue *low, irValue *high, irValue *max) { // TODO(bill): array bounds checking for slice creation // TODO(bill): check that low < high <= max gbAllocator a = proc->module->allocator; @@ -2123,8 +2142,16 @@ irValue *ir_add_local_slice(irProcedure *proc, Type *slice_type, irValue *base, case Type_Pointer: high = v_one; break; } } + if (max == NULL) { + switch (bt->kind) { + case Type_Array: high = ir_array_len(proc, base); break; + case Type_Slice: high = ir_slice_capacity(proc, base); break; + case Type_Pointer: high = v_one; break; + } + } irValue *len = ir_emit_arith(proc, Token_Sub, high, low, t_int); + irValue *cap = ir_emit_arith(proc, Token_Sub, max, low, t_int); irValue *elem = NULL; switch (bt->kind) { @@ -2136,14 +2163,7 @@ irValue *ir_add_local_slice(irProcedure *proc, Type *slice_type, irValue *base, elem = ir_emit_ptr_offset(proc, elem, low); irValue *slice = ir_add_local_generated(proc, slice_type); - - irValue *gep = NULL; - gep = ir_emit_struct_ep(proc, slice, 0); - ir_emit_store(proc, gep, elem); - - gep = ir_emit_struct_ep(proc, slice, 1); - ir_emit_store(proc, gep, len); - + ir_fill_slice(proc, slice, elem, len, cap); return slice; } @@ -2386,7 +2406,8 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) { ir_emit_store(proc, elem_ptr, elem); irValue *len = ir_string_len(proc, value); - irValue *slice = ir_add_local_slice(proc, dst, elem_ptr, v_zero, len); + irValue *cap = len; + irValue *slice = ir_add_local_slice(proc, dst, elem_ptr, v_zero, len, cap); return ir_emit_load(proc, slice); } @@ -2757,7 +2778,7 @@ void ir_emit_bounds_check(irProcedure *proc, Token token, irValue *index, irValu ir_emit(proc, ir_make_instr_bounds_check(proc, token.pos, index, len)); } -void ir_emit_slice_bounds_check(irProcedure *proc, Token token, irValue *low, irValue *high, bool is_substring) { +void ir_emit_slice_bounds_check(irProcedure *proc, Token token, irValue *low, irValue *high, irValue *max, bool is_substring) { if ((proc->module->stmt_state_flags & StmtStateFlag_no_bounds_check) != 0) { return; } @@ -2765,10 +2786,11 @@ void ir_emit_slice_bounds_check(irProcedure *proc, Token token, irValue *low, ir low = ir_emit_conv(proc, low, t_int); high = ir_emit_conv(proc, high, t_int); - ir_emit(proc, ir_make_instr_slice_bounds_check(proc, token.pos, low, high, is_substring)); + ir_emit(proc, ir_make_instr_slice_bounds_check(proc, token.pos, low, high, max, is_substring)); } + //////////////////////////////////////////////////////////////// // // @Build @@ -3161,7 +3183,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv irValue *count = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t_int); - ir_emit_slice_bounds_check(proc, ast_node_token(ce->args.e[1]), v_zero, count, false); + ir_emit_slice_bounds_check(proc, ast_node_token(ce->args.e[1]), v_zero, count, count, false); irValue *slice_size = ir_emit_arith(proc, Token_Mul, elem_size, count, t_int); @@ -3173,10 +3195,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv irValue *ptr = ir_emit_conv(proc, call, ptr_type); irValue *slice = ir_add_local_generated(proc, slice_type); - irValue *gep0 = ir_emit_struct_ep(proc, slice, 0); - irValue *gep1 = ir_emit_struct_ep(proc, slice, 1); - ir_emit_store(proc, gep0, ptr); - ir_emit_store(proc, gep1, count); + ir_fill_slice(proc, slice, ptr, count, count); return ir_emit_load(proc, slice); } break; @@ -3315,8 +3334,16 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv Type *type = ir_type(array_ptr); GB_ASSERT(is_type_pointer(type)); type = base_type(type_deref(type)); - GB_ASSERT(is_type_dynamic_array(type)); - Type *elem_type = type->DynamicArray.elem; + Type *elem_type = NULL; + bool is_slice = false; + if (is_type_dynamic_array(type)) { + elem_type = type->DynamicArray.elem; + } else if (is_type_slice(type)) { + is_slice = true; + elem_type = type->Slice.elem; + } else { + GB_PANIC("Invalid type to append"); + } irValue *elem_size = ir_make_const_int(a, type_size_of(a, elem_type)); irValue *elem_align = ir_make_const_int(a, type_align_of(a, elem_type)); @@ -3373,10 +3400,8 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv } irValue *base_elem = ir_emit_array_epi(proc, base_array, 0); - irValue *slice_elem = ir_emit_struct_ep(proc, slice, 0); - ir_emit_store(proc, slice_elem, base_elem); irValue *len = ir_make_const_int(a, slice_len); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 1), len); + ir_fill_slice(proc, slice, base_elem, len, len); } arg_count = 2; @@ -3393,6 +3418,10 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv daa_args[2] = elem_align; daa_args[3] = ir_emit_conv(proc, items, t_rawptr); daa_args[4] = ir_emit_conv(proc, item_count, t_int); + + if (is_slice) { + return ir_emit_global_call(proc, "__slice_append", daa_args, 5); + } return ir_emit_global_call(proc, "__dynamic_array_append", daa_args, 5); } break; @@ -3538,8 +3567,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv Type *slice_type = make_type_slice(proc->module->allocator, type_deref(ir_type(ptr))); irValue *slice = ir_add_local_generated(proc, slice_type); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 0), ptr); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 1), count); + ir_fill_slice(proc, slice, ptr, count, count); return ir_emit_load(proc, slice); } break; @@ -3556,9 +3584,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv irValue *ptr = ir_emit_conv(proc, ir_slice_elem(proc, s), t_u8_ptr); irValue *count = ir_slice_count(proc, s); count = ir_emit_arith(proc, Token_Mul, count, ir_make_const_int(proc->module->allocator, elem_size), t_int); - - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 0), ptr); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 1), count); + ir_fill_slice(proc, slice, ptr, count, count); return ir_emit_load(proc, slice); } break; @@ -3681,11 +3707,9 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv ir_emit_store(proc, addr, args[i]); } - irValue *base_elem = ir_emit_array_epi(proc, base_array, 0); - irValue *slice_elem = ir_emit_struct_ep(proc, slice, 0); - ir_emit_store(proc, slice_elem, base_elem); + irValue *base_elem = ir_emit_array_epi(proc, base_array, 0); irValue *len = ir_make_const_int(allocator, slice_len); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 1), len); + ir_fill_slice(proc, slice, base_elem, len, len); } arg_count = type->param_count; @@ -4076,9 +4100,11 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { gbAllocator a = proc->module->allocator; irValue *low = v_zero; irValue *high = NULL; + irValue *max = NULL; if (se->low != NULL) low = ir_build_expr(proc, se->low); if (se->high != NULL) high = ir_build_expr(proc, se->high); + if (se->max != NULL) max = ir_build_expr(proc, se->max); irValue *addr = ir_build_addr(proc, se->expr).addr; irValue *base = ir_emit_load(proc, addr); Type *type = base_type(ir_type(base)); @@ -4096,16 +4122,15 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { Type *slice_type = type; if (high == NULL) high = ir_slice_count(proc, base); + if (max == NULL) max = ir_slice_capacity(proc, base); - ir_emit_slice_bounds_check(proc, se->open, low, high, false); + ir_emit_slice_bounds_check(proc, se->open, low, high, max, false); irValue *elem = ir_emit_ptr_offset(proc, ir_slice_elem(proc, base), low); irValue *len = ir_emit_arith(proc, Token_Sub, high, low, t_int); + irValue *cap = ir_emit_arith(proc, Token_Sub, max, low, t_int); irValue *slice = ir_add_local_generated(proc, slice_type); - - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 0), elem); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 1), len); - + ir_fill_slice(proc, slice, elem, len, cap); return ir_make_addr(slice); } @@ -4113,16 +4138,15 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { Type *dynamic_array = type; if (high == NULL) high = ir_dynamic_array_count(proc, base); + if (max == NULL) max = ir_dynamic_array_capacity(proc, base); - ir_emit_slice_bounds_check(proc, se->open, low, high, false); + ir_emit_slice_bounds_check(proc, se->open, low, high, max, false); irValue *elem = ir_emit_ptr_offset(proc, ir_dynamic_array_elem(proc, base), low); irValue *len = ir_emit_arith(proc, Token_Sub, high, low, t_int); + irValue *cap = ir_emit_arith(proc, Token_Sub, max, low, t_int); irValue *slice = ir_add_local_generated(proc, dynamic_array); - - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 0), elem); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 1), len); - + ir_fill_slice(proc, slice, elem, len, cap); return ir_make_addr(slice); } @@ -4131,38 +4155,31 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { Type *slice_type = make_type_slice(a, type->Array.elem); if (high == NULL) high = ir_array_len(proc, base); + if (max == NULL) max = ir_array_len(proc, base); - ir_emit_slice_bounds_check(proc, se->open, low, high, false); + ir_emit_slice_bounds_check(proc, se->open, low, high, max, false); irValue *elem = ir_emit_ptr_offset(proc, ir_array_elem(proc, addr), low); irValue *len = ir_emit_arith(proc, Token_Sub, high, low, t_int); + irValue *cap = ir_emit_arith(proc, Token_Sub, max, low, t_int); irValue *slice = ir_add_local_generated(proc, slice_type); - - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 0), elem); - ir_emit_store(proc, ir_emit_struct_ep(proc, slice, 1), len); - + ir_fill_slice(proc, slice, elem, len, cap); return ir_make_addr(slice); } case Type_Basic: { GB_ASSERT(type == t_string); - if (high == NULL) { - high = ir_string_len(proc, base); - } - - ir_emit_slice_bounds_check(proc, se->open, low, high, true); + if (high == NULL) high = ir_string_len(proc, base); + if (max == NULL) max = ir_string_len(proc, base); - irValue *elem, *len; - len = ir_emit_arith(proc, Token_Sub, high, low, t_int); + ir_emit_slice_bounds_check(proc, se->open, low, high, max, true); - elem = ir_string_elem(proc, base); - elem = ir_emit_ptr_offset(proc, elem, low); + irValue *elem = ir_emit_ptr_offset(proc, ir_string_elem(proc, base), low); + irValue *len = ir_emit_arith(proc, Token_Sub, high, low, t_int); irValue *str = ir_add_local_generated(proc, t_string); - irValue *gep0 = ir_emit_struct_ep(proc, str, 0); - irValue *gep1 = ir_emit_struct_ep(proc, str, 1); - ir_emit_store(proc, gep0, elem); - ir_emit_store(proc, gep1, len); + ir_emit_store(proc, ir_emit_struct_ep(proc, str, 0), elem); + ir_emit_store(proc, ir_emit_struct_ep(proc, str, 1), len); return ir_make_addr(str); } break; @@ -4369,13 +4386,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_store(proc, offset, ev); } - irValue *gep0 = ir_emit_struct_ep(proc, v, 0); - irValue *gep1 = ir_emit_struct_ep(proc, v, 1); - irValue *gep2 = ir_emit_struct_ep(proc, v, 1); - - ir_emit_store(proc, gep0, data); - ir_emit_store(proc, gep1, ir_make_const_int(proc->module->allocator, slice->ConstantSlice.count)); - ir_emit_store(proc, gep2, ir_make_const_int(proc->module->allocator, slice->ConstantSlice.count)); + irValue *count = ir_make_const_int(proc->module->allocator, slice->ConstantSlice.count); + ir_fill_slice(proc, v, data, count, count); } } break; @@ -6030,16 +6042,6 @@ void ir_add_foreign_library_path(irModule *m, Entity *e) { array_add(&m->foreign_library_paths, library_path); } -void ir_fill_slice(irProcedure *proc, irValue *slice_ptr, irValue *data, irValue *count) { - Type *t = ir_type(slice_ptr); - GB_ASSERT(is_type_pointer(t)); - t = type_deref(t); - GB_ASSERT(is_type_slice(t)); - irValue *elem = ir_emit_struct_ep(proc, slice_ptr, 0); - irValue *len = ir_emit_struct_ep(proc, slice_ptr, 1); - ir_emit_store(proc, elem, data); - ir_emit_store(proc, len, count); -} void ir_gen_tree(irGen *s) { irModule *m = &s->module; @@ -6376,9 +6378,10 @@ void ir_gen_tree(irGen *s) { irValue *global_type_table = ir_find_global_variable(proc, str_lit("__type_table")); Type *type = base_type(type_deref(ir_type(ir_global_type_info_data))); GB_ASSERT(is_type_array(type)); + irValue *len = ir_make_const_int(proc->module->allocator, type->Array.count); ir_fill_slice(proc, global_type_table, ir_emit_array_epi(proc, ir_global_type_info_data, 0), - ir_make_const_int(proc->module->allocator, type->Array.count)); + len, len); } @@ -6562,8 +6565,9 @@ void ir_gen_tree(irGen *s) { } } - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 0), memory_types, ir_make_const_int(a, t->Tuple.variable_count)); - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 1), memory_names, ir_make_const_int(a, t->Tuple.variable_count)); + irValue *count = ir_make_const_int(a, t->Tuple.variable_count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 0), memory_types, count, count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 1), memory_names, count, count); } break; case Type_Record: { switch (t->Record.kind) { @@ -6609,9 +6613,10 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, offset, ir_make_const_int(a, foffset)); } - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 0), memory_types, ir_make_const_int(a, t->Record.field_count)); - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 1), memory_names, ir_make_const_int(a, t->Record.field_count)); - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 2), memory_offsets, ir_make_const_int(a, t->Record.field_count)); + irValue *count = ir_make_const_int(a, t->Record.field_count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 0), memory_types, count, count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 1), memory_names, count, count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 2), memory_offsets, count, count); } break; case TypeRecord_Union: { ir_emit_comment(proc, str_lit("Type_Info_Union")); @@ -6652,9 +6657,10 @@ void ir_gen_tree(irGen *s) { } - ir_fill_slice(proc, ir_emit_struct_ep(proc, common_fields, 0), memory_types, ir_make_const_int(a, field_count)); - ir_fill_slice(proc, ir_emit_struct_ep(proc, common_fields, 1), memory_names, ir_make_const_int(a, field_count)); - ir_fill_slice(proc, ir_emit_struct_ep(proc, common_fields, 2), memory_offsets, ir_make_const_int(a, field_count)); + irValue *count = ir_make_const_int(a, field_count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, common_fields, 0), memory_types, count, count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, common_fields, 1), memory_names, count, count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, common_fields, 2), memory_offsets, count, count); } { @@ -6681,9 +6687,8 @@ void ir_gen_tree(irGen *s) { } irValue *count = ir_make_const_int(a, variant_count); - - ir_fill_slice(proc, variant_names, memory_names, count); - ir_fill_slice(proc, variant_types, memory_types, count); + ir_fill_slice(proc, variant_names, memory_names, count, count); + ir_fill_slice(proc, variant_types, memory_types, count, count); } } break; @@ -6716,9 +6721,10 @@ void ir_gen_tree(irGen *s) { } } - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 0), memory_types, ir_make_const_int(a, t->Record.field_count)); - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 1), memory_names, ir_make_const_int(a, t->Record.field_count)); - ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 2), memory_offsets, ir_make_const_int(a, t->Record.field_count)); + irValue *count = ir_make_const_int(a, t->Record.field_count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 0), memory_types, count, count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 1), memory_names, count, count); + ir_fill_slice(proc, ir_emit_struct_ep(proc, record, 2), memory_offsets, count, count); } break; case TypeRecord_Enum: ir_emit_comment(proc, str_lit("Type_Info_Enum")); diff --git a/src/ir_print.c b/src/ir_print.c index 3018e2463..9bc7e5f41 100644 --- a/src/ir_print.c +++ b/src/ir_print.c @@ -191,7 +191,7 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) { case Type_Slice: ir_fprintf(f, "{"); ir_print_type(f, m, t->Slice.elem); - ir_fprintf(f, "*, i%lld}", word_bits); + ir_fprintf(f, "*, i%lld, i%lld}", word_bits, word_bits); return; case Type_DynamicArray: ir_fprintf(f, "{"); @@ -1249,6 +1249,13 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) { ir_fprintf(f, " "); ir_print_value(f, m, bc->high, t_int); + if (!bc->is_substring) { + ir_fprintf(f, ", "); + ir_print_type(f, m, t_int); + ir_fprintf(f, " "); + ir_print_value(f, m, bc->max, t_int); + } + ir_fprintf(f, ")\n"); } break; diff --git a/src/parser.c b/src/parser.c index 23053a816..160b72ef3 100644 --- a/src/parser.c +++ b/src/parser.c @@ -151,8 +151,9 @@ AST_NODE_KIND(_ExprBegin, "", i32) \ AST_NODE_KIND(DerefExpr, "dereference expression", struct { Token op; AstNode *expr; }) \ AST_NODE_KIND(SliceExpr, "slice expression", struct { \ AstNode *expr; \ - Token open, close, interval; \ - AstNode *low, *high; \ + Token open, close; \ + bool index3; \ + AstNode *low, *high, *max; \ }) \ AST_NODE_KIND(CallExpr, "call expression", struct { \ AstNode * proc; \ @@ -667,14 +668,15 @@ AstNode *ast_index_expr(AstFile *f, AstNode *expr, AstNode *index, Token open, T } -AstNode *ast_slice_expr(AstFile *f, AstNode *expr, Token open, Token close, Token interval, AstNode *low, AstNode *high) { +AstNode *ast_slice_expr(AstFile *f, AstNode *expr, Token open, Token close, bool index3, AstNode *low, AstNode *high, AstNode *max) { AstNode *result = make_ast_node(f, AstNode_SliceExpr); result->SliceExpr.expr = expr; result->SliceExpr.open = open; result->SliceExpr.close = close; - result->SliceExpr.interval = interval; + result->SliceExpr.index3 = index3; result->SliceExpr.low = low; result->SliceExpr.high = high; + result->SliceExpr.max = max; return result; } @@ -1945,7 +1947,9 @@ AstNode *parse_atom_expr(AstFile *f, bool lhs) { // TODO(bill): Handle this } Token open = {0}, close = {0}, interval = {0}; - AstNode *indices[2] = {0}; + AstNode *indices[3] = {0}; + isize ellipsis_count = 0; + Token ellipses[2] = {0}; f->expr_level++; open = expect_token(f, Token_OpenBracket); @@ -1955,23 +1959,37 @@ AstNode *parse_atom_expr(AstFile *f, bool lhs) { } bool is_index = true; - if (f->curr_token.kind == Token_Ellipsis) { - is_index = false; - interval = f->curr_token; + while (f->curr_token.kind == Token_Ellipsis && ellipsis_count < gb_count_of(ellipses)) { + ellipses[ellipsis_count++] = f->curr_token; next_token(f); - if (f->curr_token.kind != Token_CloseBracket && + if (f->curr_token.kind != Token_Ellipsis && + f->curr_token.kind != Token_CloseBracket && f->curr_token.kind != Token_EOF) { - indices[1] = parse_expr(f, false); + indices[ellipsis_count] = parse_expr(f, false); } } + f->expr_level--; close = expect_token(f, Token_CloseBracket); - if (is_index) { - operand = ast_index_expr(f, operand, indices[0], open, close); + if (ellipsis_count > 0) { + bool index3 = false; + if (ellipsis_count == 2) { + index3 = true; + // 2nd and 3rd index must be present + if (indices[1] == NULL) { + error(ellipses[0], "2nd index required in 3-index slice expression"); + indices[1] = ast_bad_expr(f, ellipses[0], ellipses[1]); + } + if (indices[2] == NULL) { + error(ellipses[1], "3rd index required in 3-index slice expression"); + indices[2] = ast_bad_expr(f, ellipses[1], close); + } + } + operand = ast_slice_expr(f, operand, open, close, index3, indices[0], indices[1], indices[2]); } else { - operand = ast_slice_expr(f, operand, open, close, interval, indices[0], indices[1]); + operand = ast_index_expr(f, operand, indices[0], open, close); } } break; diff --git a/src/types.c b/src/types.c index a734e3c01..0142fa227 100644 --- a/src/types.c +++ b/src/types.c @@ -1090,6 +1090,7 @@ gb_global Entity *entity__any_data = NULL; gb_global Entity *entity__string_data = NULL; gb_global Entity *entity__string_count = NULL; gb_global Entity *entity__slice_count = NULL; +gb_global Entity *entity__slice_capacity = NULL; gb_global Entity *entity__dynamic_array_count = NULL; gb_global Entity *entity__dynamic_array_capacity = NULL; @@ -1251,6 +1252,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n } else if (type->kind == Type_Slice) { String data_str = str_lit("data"); String count_str = str_lit("count"); + String capacity_str = str_lit("capacity"); if (str_eq(field_name, data_str)) { selection_add_index(&sel, 0); @@ -1265,7 +1267,16 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n sel.entity = entity__slice_count; return sel; + } else if (str_eq(field_name, capacity_str)) { + selection_add_index(&sel, 2); + if (entity__slice_capacity == NULL) { + entity__slice_capacity = make_entity_field(a, NULL, make_token_ident(capacity_str), t_int, false, 2); + } + + sel.entity = entity__slice_capacity; + return sel; } + } else if (type->kind == Type_DynamicArray) { String data_str = str_lit("data"); String count_str = str_lit("count"); @@ -1779,7 +1790,7 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) { case Type_Slice: // ptr + count - return 2 * build_context.word_size; + return 3 * build_context.word_size; case Type_Map: { if (t->Map.count == 0) { // Dynamic @@ -1875,23 +1886,24 @@ i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) { } else if (t->kind == Type_Basic) { if (t->Basic.kind == Basic_string) { switch (index) { - case 0: return 0; // data + case 0: return 0; // data case 1: return build_context.word_size; // count } } else if (t->Basic.kind == Basic_any) { switch (index) { - case 0: return 0; // type_info + case 0: return 0; // type_info case 1: return build_context.word_size; // data } } } else if (t->kind == Type_Slice) { switch (index) { - case 0: return 0; // data + case 0: return 0; // data case 1: return 1*build_context.word_size; // count + case 2: return 2*build_context.word_size; // capacity } } else if (t->kind == Type_DynamicArray) { switch (index) { - case 0: return 0; // data + case 0: return 0; // data case 1: return 1*build_context.word_size; // count case 2: return 2*build_context.word_size; // capacity case 3: return 3*build_context.word_size; // allocator @@ -1928,6 +1940,13 @@ i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection s } } break; + case Type_Slice: + switch (index) { + case 0: t = t_rawptr; break; + case 1: t = t_int; break; + case 2: t = t_int; break; + } + break; case Type_DynamicArray: switch (index) { case 0: t = t_rawptr; break; @@ -1936,12 +1955,6 @@ i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection s case 3: t = t_allocator; break; } break; - case Type_Slice: - switch (index) { - case 0: t = t_rawptr; break; - case 1: t = t_int; break; - } - break; } } } -- cgit v1.2.3 From 9bc37f44002d89ed35643b2bfd8c384cb5ff1f48 Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Sun, 26 Feb 2017 15:34:02 +0000 Subject: fmt.odin uses ^[]byte rather than custom Buffer type --- core/_preload.odin | 6 +- core/fmt.odin | 409 +++++++++++++++++++++++++---------------------------- core/strconv.odin | 34 ++--- src/check_expr.c | 14 +- 4 files changed, 222 insertions(+), 241 deletions(-) (limited to 'src/check_expr.c') diff --git a/core/_preload.odin b/core/_preload.odin index 83ce45ce7..953d38c43 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -460,11 +460,7 @@ __slice_append :: proc(slice_: rawptr, elem_size, elem_align: int, return slice.count; } - - ok := true; - if item_count > (slice.capacity-slice.count) { - item_count = (slice.capacity-slice.count); - } + item_count = min(slice.capacity-slice.count, item_count); if item_count > 0 { data := cast(^byte)slice.data; assert(data != nil); diff --git a/core/fmt.odin b/core/fmt.odin index eb9233996..eb2353b72 100644 --- a/core/fmt.odin +++ b/core/fmt.odin @@ -7,37 +7,20 @@ _BUFFER_SIZE :: 1<<12; -Buffer :: struct { - data: []byte, - length: int, +write_string :: proc(buf: ^[]byte, s: string) { + append(buf^, ..cast([]byte)s); } - -buffer_write :: proc(buf: ^Buffer, b: []byte) { - if buf.length < buf.data.count { - n := min(buf.data.count-buf.length, b.count); - if n > 0 { - copy(buf.data[buf.length..], b[..n]); - buf.length += n; - } - } -} -buffer_write_string :: proc(buf: ^Buffer, s: string) { - buffer_write(buf, cast([]byte)s); -} -buffer_write_byte :: proc(buf: ^Buffer, b: byte) { - if buf.length < buf.data.count { - buf.data[buf.length] = b; - buf.length++; - } +write_byte :: proc(buf: ^[]byte, b: byte) { + append(buf^, b); } -buffer_write_rune :: proc(buf: ^Buffer, r: rune) { +write_rune :: proc(buf: ^[]byte, r: rune) { if r < utf8.RUNE_SELF { - buffer_write_byte(buf, cast(byte)r); + write_byte(buf, cast(byte)r); return; } b, n := utf8.encode_rune(r); - buffer_write(buf, b[..n]); + append(buf^, ..b[..n]); } Fmt_Info :: struct { @@ -55,7 +38,7 @@ Fmt_Info :: struct { reordered: bool, good_arg_index: bool, - buf: ^Buffer, + buf: ^[]byte, arg: any, // Temporary } @@ -63,25 +46,25 @@ Fmt_Info :: struct { fprint :: proc(fd: os.Handle, args: ..any) -> int { data: [_BUFFER_SIZE]byte; - buf := Buffer{data[..], 0}; + buf := data[..0]; bprint(^buf, ..args); - os.write(fd, buf.data[..buf.length]); - return buf.length; + os.write(fd, buf[..buf.count]); + return buf.count; } fprintln :: proc(fd: os.Handle, args: ..any) -> int { data: [_BUFFER_SIZE]byte; - buf := Buffer{data[..], 0}; + buf := data[..0]; bprintln(^buf, ..args); - os.write(fd, buf.data[..buf.length]); - return buf.length; + os.write(fd, buf[..buf.count]); + return buf.count; } fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int { data: [_BUFFER_SIZE]byte; - buf := Buffer{data[..], 0}; + buf := data[..0]; bprintf(^buf, fmt, ..args); - os.write(fd, buf.data[..buf.length]); - return buf.length; + os.write(fd, buf[..buf.count]); + return buf.count; } @@ -98,12 +81,12 @@ printf :: proc(fmt: string, args: ..any) -> int { fprint_type :: proc(fd: os.Handle, info: ^Type_Info) { data: [_BUFFER_SIZE]byte; - buf := Buffer{data[..], 0}; - buffer_write_type(^buf, info); - os.write(fd, buf.data[..buf.length]); + buf := data[..0]; + write_type(^buf, info); + os.write(fd, buf[..buf.count]); } -buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) { +write_type :: proc(buf: ^[]byte, ti: ^Type_Info) { if ti == nil { return; } @@ -111,131 +94,131 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) { using Type_Info; match info in ti { case Named: - buffer_write_string(buf, info.name); + write_string(buf, info.name); case Integer: match { - case ti == type_info(int): buffer_write_string(buf, "int"); - case ti == type_info(uint): buffer_write_string(buf, "uint"); + case ti == type_info(int): write_string(buf, "int"); + case ti == type_info(uint): write_string(buf, "uint"); default: - buffer_write_string(buf, info.signed ? "i" : "u"); + write_string(buf, info.signed ? "i" : "u"); fi := Fmt_Info{buf = buf}; fmt_int(^fi, cast(u64)(8*info.size), false, 'd'); } case Float: match info.size { - case 4: buffer_write_string(buf, "f32"); - case 8: buffer_write_string(buf, "f64"); + case 4: write_string(buf, "f32"); + case 8: write_string(buf, "f64"); } - case String: buffer_write_string(buf, "string"); - case Boolean: buffer_write_string(buf, "bool"); + case String: write_string(buf, "string"); + case Boolean: write_string(buf, "bool"); case Pointer: if info.elem == nil { - buffer_write_string(buf, "rawptr"); + write_string(buf, "rawptr"); } else { - buffer_write_string(buf, "^"); - buffer_write_type(buf, info.elem); + write_string(buf, "^"); + write_type(buf, info.elem); } case Procedure: - buffer_write_string(buf, "proc"); + write_string(buf, "proc"); if info.params == nil { - buffer_write_string(buf, "()"); + write_string(buf, "()"); } else { t := union_cast(^Tuple)info.params; - buffer_write_string(buf, "("); + write_string(buf, "("); for type, i in t.types { - if i > 0 { buffer_write_string(buf, ", "); } - buffer_write_type(buf, type); + if i > 0 { write_string(buf, ", "); } + write_type(buf, type); } - buffer_write_string(buf, ")"); + write_string(buf, ")"); } if info.results != nil { - buffer_write_string(buf, " -> "); - buffer_write_type(buf, info.results); + write_string(buf, " -> "); + write_type(buf, info.results); } case Tuple: count := info.names.count; - if count != 1 { buffer_write_string(buf, "("); } + if count != 1 { write_string(buf, "("); } for name, i in info.names { - if i > 0 { buffer_write_string(buf, ", "); } + if i > 0 { write_string(buf, ", "); } type := info.types[i]; if name.count > 0 { - buffer_write_string(buf, name); - buffer_write_string(buf, ": "); + write_string(buf, name); + write_string(buf, ": "); } - buffer_write_type(buf, type); + write_type(buf, type); } - if count != 1 { buffer_write_string(buf, ")"); } + if count != 1 { write_string(buf, ")"); } case Array: - buffer_write_string(buf, "["); + write_string(buf, "["); fi := Fmt_Info{buf = buf}; fmt_int(^fi, cast(u64)info.count, false, 'd'); - buffer_write_string(buf, "]"); - buffer_write_type(buf, info.elem); + write_string(buf, "]"); + write_type(buf, info.elem); case Dynamic_Array: - buffer_write_string(buf, "[..]"); - buffer_write_type(buf, info.elem); + write_string(buf, "[..]"); + write_type(buf, info.elem); case Slice: - buffer_write_string(buf, "["); - buffer_write_string(buf, "]"); - buffer_write_type(buf, info.elem); + write_string(buf, "["); + write_string(buf, "]"); + write_type(buf, info.elem); case Vector: - buffer_write_string(buf, "[vector "); + write_string(buf, "[vector "); fi := Fmt_Info{buf = buf}; fmt_int(^fi, cast(u64)info.count, false, 'd'); - buffer_write_string(buf, "]"); - buffer_write_type(buf, info.elem); + write_string(buf, "]"); + write_type(buf, info.elem); case Map: - buffer_write_string(buf, "map["); - buffer_write_type(buf, info.key); - buffer_write_byte(buf, ']'); - buffer_write_type(buf, info.value); + write_string(buf, "map["); + write_type(buf, info.key); + write_byte(buf, ']'); + write_type(buf, info.value); case Struct: - buffer_write_string(buf, "struct "); - if info.packed { buffer_write_string(buf, "#packed "); } - if info.ordered { buffer_write_string(buf, "#ordered "); } + write_string(buf, "struct "); + if info.packed { write_string(buf, "#packed "); } + if info.ordered { write_string(buf, "#ordered "); } if info.custom_align { - buffer_write_string(buf, "#align "); + write_string(buf, "#align "); fi := Fmt_Info{buf = buf}; fmt_int(^fi, cast(u64)info.align, false, 'd'); - buffer_write_byte(buf, ' '); + write_byte(buf, ' '); } - buffer_write_byte(buf, '{'); + write_byte(buf, '{'); for name, i in info.names { if i > 0 { - buffer_write_string(buf, ", "); + write_string(buf, ", "); } - buffer_write_string(buf, name); - buffer_write_string(buf, ": "); - buffer_write_type(buf, info.types[i]); + write_string(buf, name); + write_string(buf, ": "); + write_type(buf, info.types[i]); } - buffer_write_byte(buf, '}'); + write_byte(buf, '}'); case Union: - buffer_write_string(buf, "union {"); + write_string(buf, "union {"); cf := info.common_fields; total_count := 0; for name, i in cf.names { if i > 0 { - buffer_write_string(buf, ", "); + write_string(buf, ", "); } - buffer_write_string(buf, name); - buffer_write_string(buf, ": "); - buffer_write_type(buf, cf.types[i]); + write_string(buf, name); + write_string(buf, ": "); + write_type(buf, cf.types[i]); total_count++; } for name, i in info.variant_names { if total_count > 0 || i > 0 { - buffer_write_string(buf, ", "); + write_string(buf, ", "); } - buffer_write_string(buf, name); - buffer_write_byte(buf, '{'); - defer buffer_write_byte(buf, '}'); + write_string(buf, name); + write_byte(buf, '{'); + defer write_byte(buf, '}'); variant_type := type_info_base(info.variant_types[i]); variant := union_cast(^Struct)variant_type; @@ -243,44 +226,44 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) { vc := variant.names.count-cf.names.count; for j in 0..vc { if j > 0 { - buffer_write_string(buf, ", "); + write_string(buf, ", "); } index := j + cf.names.count; - buffer_write_string(buf, variant.names[index]); - buffer_write_string(buf, ": "); - buffer_write_type(buf, variant.types[index]); + write_string(buf, variant.names[index]); + write_string(buf, ": "); + write_type(buf, variant.types[index]); } } - buffer_write_string(buf, "}"); + write_string(buf, "}"); case Raw_Union: - buffer_write_string(buf, "raw_union {"); + write_string(buf, "raw_union {"); for name, i in info.names { if i > 0 { - buffer_write_string(buf, ", "); + write_string(buf, ", "); } - buffer_write_string(buf, name); - buffer_write_string(buf, ": "); - buffer_write_type(buf, info.types[i]); + write_string(buf, name); + write_string(buf, ": "); + write_type(buf, info.types[i]); } - buffer_write_string(buf, "}"); + write_string(buf, "}"); case Enum: - buffer_write_string(buf, "enum "); - buffer_write_type(buf, info.base); - buffer_write_string(buf, " {"); + write_string(buf, "enum "); + write_type(buf, info.base); + write_string(buf, " {"); for name, i in info.names { if i > 0 { - buffer_write_string(buf, ", "); + write_string(buf, ", "); } - buffer_write_string(buf, name); + write_string(buf, name); } - buffer_write_string(buf, "}"); + write_string(buf, "}"); } } -bprint :: proc(buf: ^Buffer, args: ..any) -> int { +bprint :: proc(buf: ^[]byte, args: ..any) -> int { fi: Fmt_Info; fi.buf = buf; @@ -288,45 +271,39 @@ bprint :: proc(buf: ^Buffer, args: ..any) -> int { for arg, i in args { is_string := arg.data != nil && types.is_string(arg.type_info); if i > 0 && !is_string && !prev_string { - buffer_write_byte(buf, ' '); + write_byte(buf, ' '); } fmt_value(^fi, args[i], 'v'); prev_string = is_string; } - return buf.length; + return buf.count; } -bprintln :: proc(buf: ^Buffer, args: ..any) -> int { +bprintln :: proc(buf: ^[]byte, args: ..any) -> int { fi: Fmt_Info; fi.buf = buf; for arg, i in args { if i > 0 { - buffer_write_byte(buf, ' '); + write_byte(buf, ' '); } fmt_value(^fi, args[i], 'v'); } - buffer_write_byte(buf, '\n'); - return buf.length; + write_byte(buf, '\n'); + return buf.count; } sprint :: proc(buf: []byte, args: ..any) -> string { - b: Buffer; - b.data = buf; - count := bprint(^b, ..args); - return cast(string)b.data[..b.length]; + count := bprint(^buf, ..args); + return cast(string)buf; } sprintln :: proc(buf: []byte, args: ..any) -> string { - b: Buffer; - b.data = buf; - count := bprintln(^b, ..args); - return cast(string)b.data[..b.length]; + count := bprintln(^buf, ..args); + return cast(string)buf; } sprintf :: proc(buf: []byte, fmt: string, args: ..any) -> string { - b: Buffer; - b.data = buf; - count := bprintf(^b, fmt, ..args); - return cast(string)b.data[..b.length]; + count := bprintf(^buf, fmt, ..args); + return cast(string)buf; } @@ -420,23 +397,23 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) { fmt_bad_verb :: proc(using fi: ^Fmt_Info, verb: rune) { assert(verb != 'v'); - buffer_write_string(buf, "%!"); - buffer_write_rune(buf, verb); - buffer_write_byte(buf, '('); + write_string(buf, "%!"); + write_rune(buf, verb); + write_byte(buf, '('); if arg.type_info != nil { - buffer_write_type(buf, arg.type_info); - buffer_write_byte(buf, '='); + write_type(buf, arg.type_info); + write_byte(buf, '='); fmt_value(fi, arg, 'v'); } else { - buffer_write_string(buf, ""); + write_string(buf, ""); } - buffer_write_byte(buf, ')'); + write_byte(buf, ')'); } fmt_bool :: proc(using fi: ^Fmt_Info, b: bool, verb: rune) { match verb { case 't', 'v': - buffer_write_string(buf, b ? "true" : "false"); + write_string(buf, b ? "true" : "false"); default: fmt_bad_verb(fi, verb); } @@ -452,12 +429,10 @@ fmt_write_padding :: proc(fi: ^Fmt_Info, width: int) { pad_byte = '0'; } - count := min(width, fi.buf.data.count-fi.buf.length); - start := fi.buf.length; - for i in start..count { - fi.buf.data[i] = pad_byte; + count := min(width, fi.buf.capacity-fi.buf.count); + for _ in 0..count { + append(fi.buf^, pad_byte); } - fi.buf.length += count; } _write_int :: proc(fi: ^Fmt_Info, u: u64, base: int, neg: bool, digits: string) { @@ -503,7 +478,7 @@ _write_int :: proc(fi: ^Fmt_Info, u: u64, base: int, neg: bool, digits: string) if fi.hash { flags |= strconv.Int_Flag.PREFIX; } if fi.plus { flags |= strconv.Int_Flag.PLUS; } if fi.space { flags |= strconv.Int_Flag.SPACE; } - s := strconv.format_bits(buf[..], u, base, neg, digits, flags); + s := strconv.append_bits(buf[..0], u, base, neg, digits, flags); prev_zero := fi.zero; defer fi.zero = prev_zero; @@ -515,7 +490,7 @@ immutable __DIGITS_LOWER := "0123456789abcdefx"; immutable __DIGITS_UPPER := "0123456789ABCDEFX"; fmt_rune :: proc(fi: ^Fmt_Info, r: rune) { - buffer_write_rune(fi.buf, r); + write_rune(fi.buf, r); } fmt_int :: proc(fi: ^Fmt_Info, u: u64, neg: bool, verb: rune) { @@ -533,7 +508,7 @@ fmt_int :: proc(fi: ^Fmt_Info, u: u64, neg: bool, verb: rune) { if r < 0 || r > utf8.MAX_RUNE { fmt_bad_verb(fi, verb); } else { - buffer_write_string(fi.buf, "U+"); + write_string(fi.buf, "U+"); _write_int(fi, u, 16, false, __DIGITS_UPPER); } @@ -544,16 +519,16 @@ fmt_int :: proc(fi: ^Fmt_Info, u: u64, neg: bool, verb: rune) { _pad :: proc(fi: ^Fmt_Info, s: string) { if !fi.width_set || fi.width == 0 { - buffer_write_string(fi.buf, s); + write_string(fi.buf, s); return; } width := fi.width - utf8.rune_count(s); if fi.minus { // right pad - buffer_write_string(fi.buf, s); + write_string(fi.buf, s); fmt_write_padding(fi, width); } else { // left pad fmt_write_padding(fi, width); - buffer_write_string(fi.buf, s); + write_string(fi.buf, s); } } @@ -570,7 +545,7 @@ fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) { prec = fi.prec; } buf: [128]byte; - str := strconv.format_float(buf[1..], v, 'f', prec, bit_size); + str := strconv.append_float(buf[1..1], v, 'f', prec, bit_size); str = cast(string)buf[..str.count+1]; if str[1] == '+' || str[1] == '-' { str = str[1..]; @@ -583,15 +558,15 @@ fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) { } if str[1] == 'N' && str[1] == 'I' { - buffer_write_string(fi.buf, str); + write_string(fi.buf, str); return; } if fi.plus || str[0] != '+' { if fi.zero && fi.width_set && fi.width > str.count { - buffer_write_byte(fi.buf, str[0]); + write_byte(fi.buf, str[0]); fmt_write_padding(fi, fi.width - str.count); - buffer_write_string(fi.buf, str[1..]); + write_string(fi.buf, str[1..]); } else { _pad(fi, str); } @@ -607,7 +582,7 @@ fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) { fmt_string :: proc(fi: ^Fmt_Info, s: string, verb: rune) { match verb { case 's', 'v': - buffer_write_string(fi.buf, s); + write_string(fi.buf, s); default: fmt_bad_verb(fi, verb); } @@ -623,14 +598,14 @@ fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) { } u := cast(u64)cast(uint)p; if !fi.hash || verb == 'v' { - buffer_write_string(fi.buf, "0x"); + write_string(fi.buf, "0x"); } _write_int(fi, u, 16, false, __DIGITS_UPPER); } fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) { if v.type_info == nil || v.data == nil { - buffer_write_string(fi.buf, ""); + write_string(fi.buf, ""); return; } @@ -666,18 +641,18 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) { if types.is_string(e.base) { for val, idx in e.values { if val.i == i { - buffer_write_string(fi.buf, e.names[idx]); + write_string(fi.buf, e.names[idx]); ok = true; break; } } } else if e.values.count == 0 { - buffer_write_string(fi.buf, ""); + write_string(fi.buf, ""); ok = true; } else { for val, idx in e.values { if val.i == i { - buffer_write_string(fi.buf, e.names[idx]); + write_string(fi.buf, e.names[idx]); ok = true; break; } @@ -685,7 +660,7 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) { } if !ok { - buffer_write_string(fi.buf, "!%(BAD ENUM VALUE)"); + write_string(fi.buf, "!%(BAD ENUM VALUE)"); } default: fmt_bad_verb(fi, verb); @@ -697,7 +672,7 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) { fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { if v.data == nil || v.type_info == nil { - buffer_write_string(fi.buf, ""); + write_string(fi.buf, ""); return; } @@ -710,18 +685,18 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { fmt_bad_verb(fi, verb); return; } - buffer_write_string(fi.buf, info.name); - buffer_write_byte(fi.buf, '{'); + write_string(fi.buf, info.name); + write_byte(fi.buf, '{'); for _, i in b.names { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } - buffer_write_string(fi.buf, b.names[i]); - buffer_write_string(fi.buf, " = "); + write_string(fi.buf, b.names[i]); + write_string(fi.buf, " = "); data := cast(^byte)v.data + b.offsets[i]; fmt_arg(fi, any{b.types[i], cast(rawptr)data}, 'v'); } - buffer_write_byte(fi.buf, '}'); + write_byte(fi.buf, '}'); default: fmt_value(fi, any{info.base, v.data}, verb); @@ -734,7 +709,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { case Pointer: if v.type_info == type_info(^Type_Info) { - buffer_write_type(fi.buf, (cast(^^Type_Info)v.data)^); + write_type(fi.buf, (cast(^^Type_Info)v.data)^); } else { fmt_pointer(fi, (cast(^rawptr)v.data)^, verb); } @@ -745,11 +720,11 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { return; } - buffer_write_byte(fi.buf, '['); - defer buffer_write_byte(fi.buf, ']'); + write_byte(fi.buf, '['); + defer write_byte(fi.buf, ']'); for i in 0..info.count { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } data := cast(^byte)v.data + i*info.elem_size; fmt_arg(fi, any{info.elem, cast(rawptr)data}, 'v'); @@ -761,12 +736,12 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { return; } - buffer_write_byte(fi.buf, '['); - defer buffer_write_byte(fi.buf, ']'); + write_byte(fi.buf, '['); + defer write_byte(fi.buf, ']'); array := cast(^Raw_Dynamic_Array)v.data; for i in 0..array.count { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } data := cast(^byte)array.data + i*info.elem_size; fmt_arg(fi, any{info.elem, cast(rawptr)data}, 'v'); @@ -778,8 +753,8 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { return; } - buffer_write_string(fi.buf, "map["); - defer buffer_write_byte(fi.buf, ']'); + write_string(fi.buf, "map["); + defer write_byte(fi.buf, ']'); entries := ^(cast(^Raw_Dynamic_Map)v.data).entries; gs := union_cast(^Struct)type_info_base(info.generated_struct); ed := union_cast(^Dynamic_Array)type_info_base(gs.types[1]); @@ -788,19 +763,19 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { entry_size := ed.elem_size; for i in 0..entries.count { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } data := cast(^byte)entries.data + i*entry_size; header := cast(^__Map_Entry_Header)data; if types.is_string(info.key) { - buffer_write_string(fi.buf, header.key.str); + write_string(fi.buf, header.key.str); } else { fi := Fmt_Info{buf = fi.buf}; fmt_arg(^fi, any{info.key, cast(rawptr)^header.key.hash}, 'v'); } - buffer_write_string(fi.buf, "="); + write_string(fi.buf, "="); value := data + entry_type.offsets[2]; fmt_arg(fi, any{info.value, cast(rawptr)value}, 'v'); @@ -812,24 +787,24 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { return; } - buffer_write_byte(fi.buf, '['); - defer buffer_write_byte(fi.buf, ']'); + write_byte(fi.buf, '['); + defer write_byte(fi.buf, ']'); slice := cast(^[]byte)v.data; for i in 0..slice.count { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } data := slice.data + i*info.elem_size; fmt_arg(fi, any{info.elem, cast(rawptr)data}, 'v'); } case Vector: - buffer_write_byte(fi.buf, '<'); - defer buffer_write_byte(fi.buf, '>'); + write_byte(fi.buf, '<'); + defer write_byte(fi.buf, '>'); for i in 0..info.count { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } data := cast(^byte)v.data + i*info.elem_size; @@ -837,51 +812,51 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) { } case Struct: - buffer_write_byte(fi.buf, '{'); - defer buffer_write_byte(fi.buf, '}'); + write_byte(fi.buf, '{'); + defer write_byte(fi.buf, '}'); for _, i in info.names { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } - buffer_write_string(fi.buf, info.names[i]); - buffer_write_string(fi.buf, " = "); + write_string(fi.buf, info.names[i]); + write_string(fi.buf, " = "); data := cast(^byte)v.data + info.offsets[i]; fmt_value(fi, any{info.types[i], cast(rawptr)data}, 'v'); } case Union: - buffer_write_byte(fi.buf, '{'); - defer buffer_write_byte(fi.buf, '}'); + write_byte(fi.buf, '{'); + defer write_byte(fi.buf, '}'); cf := info.common_fields; for _, i in cf.names { if i > 0 { - buffer_write_string(fi.buf, ", "); + write_string(fi.buf, ", "); } - buffer_write_string(fi.buf, cf.names[i]); - buffer_write_string(fi.buf, " = "); + write_string(fi.buf, cf.names[i]); + write_string(fi.buf, " = "); data := cast(^byte)v.data + cf.offsets[i]; fmt_value(fi, any{cf.types[i], cast(rawptr)data}, 'v'); } case Raw_Union: - buffer_write_string(fi.buf, "(raw_union)"); + write_string(fi.buf, "(raw_union)"); case Enum: fmt_enum(fi, v, verb); case Procedure: - buffer_write_type(fi.buf, v.type_info); - buffer_write_string(fi.buf, " @ "); + write_type(fi.buf, v.type_info); + write_string(fi.buf, " @ "); fmt_pointer(fi, (cast(^rawptr)v.data)^, 'p'); } } fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) { if arg.data == nil || arg.type_info == nil { - buffer_write_string(fi.buf, ""); + write_string(fi.buf, ""); return; } fi.arg = arg; @@ -891,7 +866,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) { match a in arg { case ^Type_Info: ti = a; } - buffer_write_type(fi.buf, ti); + write_type(fi.buf, ti); return; } @@ -920,7 +895,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) { } -bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int { +bprintf :: proc(b: ^[]byte, fmt: string, args: ..any) -> int { fi := Fmt_Info{}; end := fmt.count; arg_index := 0; @@ -933,7 +908,7 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int { i++; } if i > prev_i { - buffer_write_string(b, fmt[prev_i..i]); + write_string(b, fmt[prev_i..i]); } if i >= end { break; @@ -974,7 +949,7 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int { i++; fi.width, arg_index, fi.width_set = int_from_arg(args, arg_index); if !fi.width_set { - buffer_write_string(b, "%!(BAD WIDTH)"); + write_string(b, "%!(BAD WIDTH)"); } if fi.width < 0 { @@ -1005,7 +980,7 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int { fi.prec_set = false; } if !fi.prec_set { - buffer_write_string(fi.buf, "%!(BAD PRECISION)"); + write_string(fi.buf, "%!(BAD PRECISION)"); } was_prev_index = false; } else { @@ -1022,7 +997,7 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int { } if i >= end { - buffer_write_string(b, "%!(NO VERB)"); + write_string(b, "%!(NO VERB)"); break; } @@ -1030,11 +1005,11 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int { i += w; if verb == '%' { - buffer_write_byte(b, '%'); + write_byte(b, '%'); } else if !fi.good_arg_index { - buffer_write_string(b, "%!(BAD ARGUMENT NUMBER)"); + write_string(b, "%!(BAD ARGUMENT NUMBER)"); } else if arg_index >= args.count { - buffer_write_string(b, "%!(MISSING ARGUMENT)"); + write_string(b, "%!(MISSING ARGUMENT)"); } else { fmt_arg(^fi, args[arg_index], verb); arg_index++; @@ -1042,19 +1017,19 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int { } if !fi.reordered && arg_index < args.count { - buffer_write_string(b, "%!(EXTRA "); + write_string(b, "%!(EXTRA "); for arg, index in args[arg_index..] { if index > 0 { - buffer_write_string(b, ", "); + write_string(b, ", "); } if arg.data == nil || arg.type_info == nil { - buffer_write_string(b, ""); + write_string(b, ""); } else { fmt_arg(^fi, args[index], 'v'); } } - buffer_write_string(b, ")"); + write_string(b, ")"); } - return b.length; + return b.count; } diff --git a/core/strconv.odin b/core/strconv.odin index 57090cba9..ff78847df 100644 --- a/core/strconv.odin +++ b/core/strconv.odin @@ -18,24 +18,24 @@ parse_bool :: proc(s: string) -> (result: bool, ok: bool) { return false, false; } -format_bool :: proc(buf: []byte, b: bool) -> string { +append_bool :: proc(buf: []byte, b: bool) -> string { s := b ? "true" : "false"; - len := copy(buf, cast([]byte)s); - return cast(string)buf[..len]; + append(buf, ..cast([]byte)s); + return cast(string)buf; } -format_uint :: proc(buf: []byte, u: u64, base: int) -> string { +append_uint :: proc(buf: []byte, u: u64, base: int) -> string { using Int_Flag; - return format_bits(buf, u, base, false, digits, 0); + return append_bits(buf, u, base, false, digits, 0); } -format_int :: proc(buf: []byte, i: i64, base: int) -> string { - return format_bits(buf, cast(u64)i, base, i < 0, digits, 0); +append_int :: proc(buf: []byte, i: i64, base: int) -> string { + return append_bits(buf, cast(u64)i, base, i < 0, digits, 0); } itoa :: proc(buf: []byte, i: int) -> string { - return format_int(buf, cast(i64)i, 10); + return append_int(buf, cast(i64)i, 10); } -format_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> string { +append_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> string { return cast(string)generic_ftoa(buf, f, fmt, prec, bit_size); } @@ -87,8 +87,8 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [ } else { s = "+Inf"; } - len := copy(buf, cast([]byte)s); - return buf[..len]; + append(buf, ..cast([]byte)s); + return buf; case 0: // denormalized exp++; @@ -190,8 +190,8 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slic c: [2]byte; c[0] = '%'; c[1] = fmt; - len := copy(buf, ..c[..]); - return buf[..len]; + append(buf, ..c[..]); + return buf; } round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) { @@ -265,7 +265,7 @@ MAX_BASE :: 32; immutable digits := "0123456789abcdefghijklmnopqrstuvwxyz"; -format_bits :: proc(buf: []byte, u: u64, base: int, neg: bool, digits: string, flags: Int_Flag) -> string { +append_bits :: proc(buf: []byte, u: u64, base: int, neg: bool, digits: string, flags: Int_Flag) -> string { is_pow2 :: proc(x: i64) -> bool { if (x <= 0) { return false; @@ -274,7 +274,7 @@ format_bits :: proc(buf: []byte, u: u64, base: int, neg: bool, digits: string, f } if base < 2 || base > MAX_BASE { - panic("strconv: illegal base passed to format_bits"); + panic("strconv: illegal base passed to append_bits"); } a: [65]byte; @@ -330,7 +330,7 @@ format_bits :: proc(buf: []byte, u: u64, base: int, neg: bool, digits: string, f } - len := copy(buf, ..a[i..]); - return cast(string)buf[..len]; + append(buf, ..a[i..]); + return cast(string)buf; } diff --git a/src/check_expr.c b/src/check_expr.c index 264a5d072..0e166ef1a 100644 --- a/src/check_expr.c +++ b/src/check_expr.c @@ -5127,6 +5127,10 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint switch (t->kind) { case Type_Basic: if (is_type_string(t)) { + if (se->index3) { + error_node(node, "3-index slice on a string in not needed"); + goto error; + } valid = true; if (o->mode == Addressing_Constant) { max_count = o->value.value_string.len; @@ -5167,14 +5171,20 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint o->mode = Addressing_Value; } + if (se->index3 && (se->high == NULL || se->max == NULL)) { + error(se->close, "2nd and 3rd indices are required in a 3-index slice"); + goto error; + } + i64 indices[2] = {0}; - AstNode *nodes[2] = {se->low, se->high}; + AstNode *nodes[3] = {se->low, se->high, se->max}; for (isize i = 0; i < gb_count_of(nodes); i++) { i64 index = max_count; if (nodes[i] != NULL) { i64 capacity = -1; - if (max_count >= 0) + if (max_count >= 0) { capacity = max_count; + } i64 j = 0; if (check_index_value(c, nodes[i], capacity, &j)) { index = j; -- cgit v1.2.3