ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-05 15:18:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Clean up fmt usage with io.Writer and strings.Builder

Browse Source
This commit is contained in:
gingerBill
2020-12-04 15:04:54 +00:00
parent 05a3bdad58
commit 5d0db4c63a
3 changed files with 169 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/fmt/fmt.odin
+35 -49
View File
@@ -63,55 +63,28 @@ register_user_formatter :: proc(id: typeid, formatter: User_Formatter) -> Regist
} }
Flush_Data :: struct {
handle: os.Handle,
bytes_written: int,
}
fmt_file_builder :: proc(data: []byte, fd: ^Flush_Data) -> strings.Builder {
b := strings.builder_from_slice(data);
b.flush_data = rawptr(fd);
b.flush_proc = proc(b: ^strings.Builder) -> (do_reset: bool) {
fd := (^Flush_Data)(b.flush_data);
res := strings.to_string(b^);
n, _ := os.write_string(fd.handle, res);
fd.bytes_written += max(n, 0);
return true;
};
return b;
}
fprint :: proc(fd: os.Handle, args: ..any, sep := " ") -> int { fprint :: proc(fd: os.Handle, args: ..any, sep := " ") -> int {
data: [DEFAULT_BUFFER_SIZE]byte; w, _ := io.to_writer(os.stream_from_handle(fd));
flush_data := Flush_Data{handle=fd}; return wprint(w=w, args=args, sep=sep);
buf := fmt_file_builder(data[:], &flush_data);
_ = sbprint(buf=&buf, args=args, sep=sep);
return flush_data.bytes_written;
} }
fprintln :: proc(fd: os.Handle, args: ..any, sep := " ") -> int { fprintln :: proc(fd: os.Handle, args: ..any, sep := " ") -> int {
data: [DEFAULT_BUFFER_SIZE]byte; w, _ := io.to_writer(os.stream_from_handle(fd));
flush_data := Flush_Data{handle=fd}; return wprintln(w=w, args=args, sep=sep);
buf := fmt_file_builder(data[:], &flush_data);
_ = sbprintln(buf=&buf, args=args, sep=sep);
return flush_data.bytes_written;
} }
fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int { fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int {
data: [DEFAULT_BUFFER_SIZE]byte; w, _ := io.to_writer(os.stream_from_handle(fd));
flush_data := Flush_Data{handle=fd}; return wprintf(w, fmt, ..args);
buf := fmt_file_builder(data[:], &flush_data);
_ = sbprintf(&buf, fmt, ..args);
return flush_data.bytes_written;
} }
fprint_type :: proc(fd: os.Handle, info: ^runtime.Type_Info) -> int { fprint_type :: proc(fd: os.Handle, info: ^runtime.Type_Info) -> int {
data: [DEFAULT_BUFFER_SIZE]byte; w, _ := io.to_writer(os.stream_from_handle(fd));
flush_data := Flush_Data{handle=fd}; return wprint_type(w, info);
buf := fmt_file_builder(data[:], &flush_data);
reflect.write_type(&buf, info);
strings.flush_builder(&buf);
return flush_data.bytes_written;
} }
fprint_typeid :: proc(fd: os.Handle, id: typeid) -> int {
w, _ := io.to_writer(os.stream_from_handle(fd));
return wprint_typeid(w, id);
}
// print* procedures return the number of bytes written // print* procedures return the number of bytes written
print :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stdout, args=args, sep=sep); } print :: proc(args: ..any, sep := " ") -> int { return fprint(fd=os.stdout, args=args, sep=sep); }
println :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stdout, args=args, sep=sep); } println :: proc(args: ..any, sep := " ") -> int { return fprintln(fd=os.stdout, args=args, sep=sep); }
@@ -212,19 +185,16 @@ panicf :: proc(fmt: string, args: ..any, loc := #caller_location) -> ! {
sbprint :: proc(buf: ^strings.Builder, args: ..any, sep := " ") -> string { sbprint :: proc(buf: ^strings.Builder, args: ..any, sep := " ") -> string {
wprint(w=strings.to_writer(buf), args=args, sep=sep); wprint(w=strings.to_writer(buf), args=args, sep=sep);
strings.flush_builder(buf);
return strings.to_string(buf^); return strings.to_string(buf^);
} }
sbprintln :: proc(buf: ^strings.Builder, args: ..any, sep := " ") -> string { sbprintln :: proc(buf: ^strings.Builder, args: ..any, sep := " ") -> string {
wprintln(w=strings.to_writer(buf), args=args, sep=sep); wprintln(w=strings.to_writer(buf), args=args, sep=sep);
strings.flush_builder(buf);
return strings.to_string(buf^); return strings.to_string(buf^);
} }
sbprintf :: proc(buf: ^strings.Builder, fmt: string, args: ..any) -> string { sbprintf :: proc(buf: ^strings.Builder, fmt: string, args: ..any) -> string {
wprintf(w=strings.to_writer(buf), fmt=fmt, args=args); wprintf(w=strings.to_writer(buf), fmt=fmt, args=args);
strings.flush_builder(buf);
return strings.to_string(buf^); return strings.to_string(buf^);
} }
@@ -246,6 +216,10 @@ wprint :: proc(w: io.Writer, args: ..any, sep := " ") -> int {
// NOTE(bill, 2020-06-19): I have found that the previous approach was not what people were expecting // NOTE(bill, 2020-06-19): I have found that the previous approach was not what people were expecting
// and were expecting `*print` to be the same `*println` except for the added newline // and were expecting `*print` to be the same `*println` except for the added newline
// so I am going to keep the same behaviour as `*println` for `*print` // so I am going to keep the same behaviour as `*println` for `*print`
size0 := io.size(auto_cast w);
for _, i in args { for _, i in args {
if i > 0 { if i > 0 {
io.write_string(fi.writer, sep); io.write_string(fi.writer, sep);
@@ -254,13 +228,15 @@ wprint :: proc(w: io.Writer, args: ..any, sep := " ") -> int {
fmt_value(&fi, args[i], 'v'); fmt_value(&fi, args[i], 'v');
} }
io.flush(auto_cast w); io.flush(auto_cast w);
return int(io.size(auto_cast w)); return int(io.size(auto_cast w) - size0);
} }
wprintln :: proc(w: io.Writer, args: ..any, sep := " ") -> int { wprintln :: proc(w: io.Writer, args: ..any, sep := " ") -> int {
fi: Info; fi: Info;
fi.writer = w; fi.writer = w;
size0 := io.size(auto_cast w);
for _, i in args { for _, i in args {
if i > 0 { if i > 0 {
io.write_string(fi.writer, sep); io.write_string(fi.writer, sep);
@@ -270,7 +246,7 @@ wprintln :: proc(w: io.Writer, args: ..any, sep := " ") -> int {
} }
io.write_byte(fi.writer, '\n'); io.write_byte(fi.writer, '\n');
io.flush(auto_cast w); io.flush(auto_cast w);
return int(io.size(auto_cast w)); return int(io.size(auto_cast w) - size0);
} }
wprintf :: proc(w: io.Writer, fmt: string, args: ..any) -> int { wprintf :: proc(w: io.Writer, fmt: string, args: ..any) -> int {
@@ -279,6 +255,8 @@ wprintf :: proc(w: io.Writer, fmt: string, args: ..any) -> int {
end := len(fmt); end := len(fmt);
was_prev_index := false; was_prev_index := false;
size0 := io.size(auto_cast w);
loop: for i := 0; i < end; /**/ { loop: for i := 0; i < end; /**/ {
fi = Info{writer = w, good_arg_index = true, reordered = fi.reordered}; fi = Info{writer = w, good_arg_index = true, reordered = fi.reordered};
@@ -544,12 +522,20 @@ wprintf :: proc(w: io.Writer, fmt: string, args: ..any) -> int {
io.write_string(fi.writer, ")"); io.write_string(fi.writer, ")");
} }
io.flush(auto_cast fi.writer); io.flush(auto_cast w);
return int(io.size(auto_cast fi.writer)); return int(io.size(auto_cast w) - size0);
} }
wprint_type :: proc(w: io.Writer, info: ^runtime.Type_Info) -> int {
n := reflect.write_type(w, info);
io.flush(auto_cast w);
return n;
}
wprint_typeid :: proc(w: io.Writer, id: typeid) -> int {
n := reflect.write_type(w, type_info_of(id));
io.flush(auto_cast w);
return n;
}
core/reflect/types.odin
+134 -129
View File
@@ -378,67 +378,70 @@ write_type :: proc{
write_type_writer, write_type_writer,
}; };
write_type_builder :: proc(buf: ^strings.Builder, ti: ^Type_Info) { write_type_builder :: proc(buf: ^strings.Builder, ti: ^Type_Info) -> int {
write_type_writer(strings.to_writer(buf), ti); return write_type_writer(strings.to_writer(buf), ti);
} }
write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) { write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
using strings; using strings;
if ti == nil { if ti == nil {
write_string(w, "nil"); return write_string(w, "nil");
return;
} }
_n1 :: proc(err: io.Error) -> int { return 1 if err == nil else 0; };
_n2 :: proc(n: int, _: io.Error) -> int { return n; };
_n :: proc{_n1, _n2};
switch info in ti.variant { switch info in ti.variant {
case Type_Info_Named: case Type_Info_Named:
write_string(w, info.name); return write_string(w, info.name);
case Type_Info_Integer: case Type_Info_Integer:
switch ti.id { switch ti.id {
case int: write_string(w, "int"); case int: return write_string(w, "int");
case uint: write_string(w, "uint"); case uint: return write_string(w, "uint");
case uintptr: write_string(w, "uintptr"); case uintptr: return write_string(w, "uintptr");
case: case:
io.write_byte(w, 'i' if info.signed else 'u'); n += _n(io.write_byte(w, 'i' if info.signed else 'u'));
io.write_i64(w, i64(8*ti.size), 10); n += _n(io.write_i64(w, i64(8*ti.size), 10));
switch info.endianness { switch info.endianness {
case .Platform: // Okay case .Platform: // Okay
case .Little: write_string(w, "le"); case .Little: n += write_string(w, "le");
case .Big: write_string(w, "be"); case .Big: n += write_string(w, "be");
} }
} }
case Type_Info_Rune: case Type_Info_Rune:
io.write_string(w, "rune"); n += _n(io.write_string(w, "rune"));
case Type_Info_Float: case Type_Info_Float:
io.write_byte(w, 'f'); n += _n(io.write_byte(w, 'f'));
io.write_i64(w, i64(8*ti.size), 10); n += _n(io.write_i64(w, i64(8*ti.size), 10));
switch info.endianness { switch info.endianness {
case .Platform: // Okay case .Platform: // Okay
case .Little: write_string(w, "le"); case .Little: n += write_string(w, "le");
case .Big: write_string(w, "be"); case .Big: n += write_string(w, "be");
} }
case Type_Info_Complex: case Type_Info_Complex:
io.write_string(w, "complex"); n += _n(io.write_string(w, "complex"));
io.write_i64(w, i64(8*ti.size), 10); n += _n(io.write_i64(w, i64(8*ti.size), 10));
case Type_Info_Quaternion: case Type_Info_Quaternion:
io.write_string(w, "quaternion"); n += _n(io.write_string(w, "quaternion"));
io.write_i64(w, i64(8*ti.size), 10); n += _n(io.write_i64(w, i64(8*ti.size), 10));
case Type_Info_String: case Type_Info_String:
if info.is_cstring { if info.is_cstring {
write_string(w, "cstring"); n += write_string(w, "cstring");
} else { } else {
write_string(w, "string"); n += write_string(w, "string");
} }
case Type_Info_Boolean: case Type_Info_Boolean:
switch ti.id { switch ti.id {
case bool: write_string(w, "bool"); case bool: n += write_string(w, "bool");
case: case:
io.write_byte(w, 'b'); n += _n(io.write_byte(w, 'b'));
io.write_i64(w, i64(8*ti.size), 10); n += _n(io.write_i64(w, i64(8*ti.size), 10));
} }
case Type_Info_Any: case Type_Info_Any:
write_string(w, "any"); n += write_string(w, "any");
case Type_Info_Type_Id: case Type_Info_Type_Id:
write_string(w, "typeid"); n += write_string(w, "typeid");
case Type_Info_Pointer: case Type_Info_Pointer:
if info.elem == nil { if info.elem == nil {
@@ -448,186 +451,188 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) {
write_type(w, info.elem); write_type(w, info.elem);
} }
case Type_Info_Procedure: case Type_Info_Procedure:
write_string(w, "proc"); n += write_string(w, "proc");
if info.params == nil { if info.params == nil {
write_string(w, "()"); n += write_string(w, "()");
} else { } else {
t := info.params.variant.(Type_Info_Tuple); t := info.params.variant.(Type_Info_Tuple);
write_string(w, "("); n += write_string(w, "(");
for t, i in t.types { for t, i in t.types {
if i > 0 { if i > 0 {
write_string(w, ", "); n += write_string(w, ", ");
} }
write_type(w, t); n += write_type(w, t);
} }
write_string(w, ")"); n += write_string(w, ")");
} }
if info.results != nil { if info.results != nil {
write_string(w, " -> "); n += write_string(w, " -> ");
write_type(w, info.results); n += write_type(w, info.results);
} }
case Type_Info_Tuple: case Type_Info_Tuple:
count := len(info.names); count := len(info.names);
if count != 1 { write_string(w, "("); } if count != 1 { n += write_string(w, "("); }
for name, i in info.names { for name, i in info.names {
if i > 0 { write_string(w, ", "); } if i > 0 { n += write_string(w, ", "); }
t := info.types[i]; t := info.types[i];
if len(name) > 0 { if len(name) > 0 {
write_string(w, name); n += write_string(w, name);
write_string(w, ": "); n += write_string(w, ": ");
} }
write_type(w, t); n += write_type(w, t);
} }
if count != 1 { write_string(w, ")"); } if count != 1 { n += write_string(w, ")"); }
case Type_Info_Array: case Type_Info_Array:
io.write_string(w, "["); n += _n(io.write_string(w, "["));
io.write_i64(w, i64(info.count), 10); n += _n(io.write_i64(w, i64(info.count), 10));
io.write_string(w, "]"); n += _n(io.write_string(w, "]"));
write_type(w, info.elem); n += write_type(w, info.elem);
case Type_Info_Enumerated_Array: case Type_Info_Enumerated_Array:
write_string(w, "["); n += write_string(w, "[");
write_type(w, info.index); n += write_type(w, info.index);
write_string(w, "]"); n += write_string(w, "]");
write_type(w, info.elem); n += write_type(w, info.elem);
case Type_Info_Dynamic_Array: case Type_Info_Dynamic_Array:
io.write_string(w, "[dynamic]"); n += _n(io.write_string(w, "[dynamic]"));
write_type(w, info.elem); n += write_type(w, info.elem);
case Type_Info_Slice: case Type_Info_Slice:
io.write_string(w, "[]"); n += _n(io.write_string(w, "[]"));
write_type(w, info.elem); n += write_type(w, info.elem);
case Type_Info_Map: case Type_Info_Map:
io.write_string(w, "map["); n += _n(io.write_string(w, "map["));
write_type(w, info.key); n += write_type(w, info.key);
io.write_byte(w, ']'); n += _n(io.write_byte(w, ']'));
write_type(w, info.value); n += write_type(w, info.value);
case Type_Info_Struct: case Type_Info_Struct:
switch info.soa_kind { switch info.soa_kind {
case .None: // Ignore case .None: // Ignore
case .Fixed: case .Fixed:
io.write_string(w, "#soa["); n += _n(io.write_string(w, "#soa["));
io.write_i64(w, i64(info.soa_len)); n += _n(io.write_i64(w, i64(info.soa_len)));
io.write_byte(w, ']'); n += _n(io.write_byte(w, ']'));
write_type(w, info.soa_base_type); n += write_type(w, info.soa_base_type);
return; return;
case .Slice: case .Slice:
io.write_string(w, "#soa[]"); n += _n(io.write_string(w, "#soa[]"));
write_type(w, info.soa_base_type); n += write_type(w, info.soa_base_type);
return; return;
case .Dynamic: case .Dynamic:
io.write_string(w, "#soa[dynamic]"); n += _n(io.write_string(w, "#soa[dynamic]"));
write_type(w, info.soa_base_type); n += write_type(w, info.soa_base_type);
return; return;
} }
write_string(w, "struct "); n += write_string(w, "struct ");
if info.is_packed { write_string(w, "#packed "); } if info.is_packed { n += write_string(w, "#packed "); }
if info.is_raw_union { write_string(w, "#raw_union "); } if info.is_raw_union { n += write_string(w, "#raw_union "); }
if info.custom_align { if info.custom_align {
io.write_string(w, "#align "); n += _n(io.write_string(w, "#align "));
io.write_i64(w, i64(ti.align), 10); n += _n(io.write_i64(w, i64(ti.align), 10));
io.write_byte(w, ' '); n += _n(io.write_byte(w, ' '));
} }
io.write_byte(w, '{'); n += _n(io.write_byte(w, '{'));
for name, i in info.names { for name, i in info.names {
if i > 0 { write_string(w, ", "); } if i > 0 { n += write_string(w, ", "); }
io.write_string(w, name); n += _n(io.write_string(w, name));
io.write_string(w, ": "); n += _n(io.write_string(w, ": "));
write_type(w, info.types[i]); n += write_type(w, info.types[i]);
} }
io.write_byte(w, '}'); n += _n(io.write_byte(w, '}'));
case Type_Info_Union: case Type_Info_Union:
write_string(w, "union "); n += write_string(w, "union ");
if info.custom_align { if info.custom_align {
write_string(w, "#align "); n += write_string(w, "#align ");
io.write_i64(w, i64(ti.align), 10); n += _n(io.write_i64(w, i64(ti.align), 10));
io.write_byte(w, ' '); n += _n(io.write_byte(w, ' '));
} }
io.write_byte(w, '{'); n += _n(io.write_byte(w, '{'));
for variant, i in info.variants { for variant, i in info.variants {
if i > 0 { write_string(w, ", "); } if i > 0 { n += write_string(w, ", "); }
write_type(w, variant); n += write_type(w, variant);
} }
io.write_byte(w, '}'); n += _n(io.write_byte(w, '}'));
case Type_Info_Enum: case Type_Info_Enum:
write_string(w, "enum "); n += write_string(w, "enum ");
write_type(w, info.base); n += write_type(w, info.base);
write_string(w, " {"); n += write_string(w, " {");
for name, i in info.names { for name, i in info.names {
if i > 0 { write_string(w, ", "); } if i > 0 { n += write_string(w, ", "); }
write_string(w, name); n += write_string(w, name);
} }
io.write_byte(w, '}'); n += _n(io.write_byte(w, '}'));
case Type_Info_Bit_Field: case Type_Info_Bit_Field:
write_string(w, "bit_field "); n += write_string(w, "bit_field ");
if ti.align != 1 { if ti.align != 1 {
write_string(w, "#align "); n += write_string(w, "#align ");
io.write_i64(w, i64(ti.align), 10); n += _n(io.write_i64(w, i64(ti.align), 10));
io.write_byte(w, ' '); n += _n(io.write_byte(w, ' '));
} }
write_string(w, " {"); n += write_string(w, " {");
for name, i in info.names { for name, i in info.names {
if i > 0 { write_string(w, ", "); } if i > 0 { n += write_string(w, ", "); }
write_string(w, name); n += write_string(w, name);
write_string(w, ": "); n += write_string(w, ": ");
io.write_i64(w, i64(info.bits[i]), 10); n += _n(io.write_i64(w, i64(info.bits[i]), 10));
} }
io.write_byte(w, '}'); n += _n(io.write_byte(w, '}'));
case Type_Info_Bit_Set: case Type_Info_Bit_Set:
write_string(w, "bit_set["); n += write_string(w, "bit_set[");
switch { switch {
case is_enum(info.elem): case is_enum(info.elem):
write_type(w, info.elem); n += write_type(w, info.elem);
case is_rune(info.elem): case is_rune(info.elem):
write_encoded_rune(w, rune(info.lower)); n += write_encoded_rune(w, rune(info.lower));
write_string(w, ".."); n += write_string(w, "..");
write_encoded_rune(w, rune(info.upper)); n += write_encoded_rune(w, rune(info.upper));
case: case:
io.write_i64(w, info.lower, 10); n += _n(io.write_i64(w, info.lower, 10));
write_string(w, ".."); n += write_string(w, "..");
io.write_i64(w, info.upper, 10); n += _n(io.write_i64(w, info.upper, 10));
} }
if info.underlying != nil { if info.underlying != nil {
write_string(w, "; "); n += write_string(w, "; ");
write_type(w, info.underlying); n += write_type(w, info.underlying);
} }
io.write_byte(w, ']'); n += _n(io.write_byte(w, ']'));
case Type_Info_Opaque: case Type_Info_Opaque:
write_string(w, "opaque "); n += write_string(w, "opaque ");
write_type(w, info.elem); n += write_type(w, info.elem);
case Type_Info_Simd_Vector: case Type_Info_Simd_Vector:
if info.is_x86_mmx { if info.is_x86_mmx {
write_string(w, "intrinsics.x86_mmx"); n += write_string(w, "intrinsics.x86_mmx");
} else { } else {
write_string(w, "#simd["); n += write_string(w, "#simd[");
io.write_i64(w, i64(info.count)); n += _n(io.write_i64(w, i64(info.count)));
io.write_byte(w, ']'); n += _n(io.write_byte(w, ']'));
write_type(w, info.elem); n += write_type(w, info.elem);
} }
case Type_Info_Relative_Pointer: case Type_Info_Relative_Pointer:
write_string(w, "#relative("); n += write_string(w, "#relative(");
write_type(w, info.base_integer); n += write_type(w, info.base_integer);
write_string(w, ") "); n += write_string(w, ") ");
write_type(w, info.pointer); n += write_type(w, info.pointer);
case Type_Info_Relative_Slice: case Type_Info_Relative_Slice:
write_string(w, "#relative("); n += write_string(w, "#relative(");
write_type(w, info.base_integer); n += write_type(w, info.base_integer);
write_string(w, ") "); n += write_string(w, ") ");
write_type(w, info.slice); n += write_type(w, info.slice);
} }
return;
} }
core/strings/builder.odin
-30
View File
@@ -9,10 +9,6 @@ Builder_Flush_Proc :: #type proc(b: ^Builder) -> (do_reset: bool);
Builder :: struct { Builder :: struct {
buf: [dynamic]byte, buf: [dynamic]byte,
// The custom flush procedure allows for the ability to flush the buffer, i.e. write to file
flush_proc: Builder_Flush_Proc,
flush_data: rawptr,
} }
make_builder_none :: proc(allocator := context.allocator) -> Builder { make_builder_none :: proc(allocator := context.allocator) -> Builder {
@@ -53,11 +49,6 @@ init_builder :: proc{
@(private) @(private)
_builder_stream_vtable := &io.Stream_VTable{ _builder_stream_vtable := &io.Stream_VTable{
impl_flush = proc(s: io.Stream) -> io.Error {
b := (^Builder)(s.stream_data);
flush_builder(b);
return nil;
},
impl_write = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) { impl_write = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
b := (^Builder)(s.stream_data); b := (^Builder)(s.stream_data);
n = write_bytes(b, p); n = write_bytes(b, p);
@@ -80,7 +71,6 @@ _builder_stream_vtable := &io.Stream_VTable{
}, },
impl_destroy = proc(s: io.Stream) -> io.Error { impl_destroy = proc(s: io.Stream) -> io.Error {
b := (^Builder)(s.stream_data); b := (^Builder)(s.stream_data);
flush_builder(b);
delete(b.buf); delete(b.buf);
return .None; return .None;
}, },
@@ -110,24 +100,6 @@ reset_builder :: proc(b: ^Builder) {
clear(&b.buf); clear(&b.buf);
} }
flush_builder :: proc(b: ^Builder) -> (was_reset: bool) {
if b.flush_proc != nil {
was_reset = b.flush_proc(b);
if was_reset {
reset_builder(b);
}
}
return;
}
flush_builder_check_space :: proc(b: ^Builder, required: int) -> (was_reset: bool) {
if n := max(cap(b.buf) - len(b.buf), 0); n < required {
was_reset = flush_builder(b);
}
return;
}
builder_from_slice :: proc(backing: []byte) -> Builder { builder_from_slice :: proc(backing: []byte) -> Builder {
s := transmute(mem.Raw_Slice)backing; s := transmute(mem.Raw_Slice)backing;
@@ -156,7 +128,6 @@ builder_space :: proc(b: Builder) -> int {
} }
write_byte :: proc(b: ^Builder, x: byte) -> (n: int) { write_byte :: proc(b: ^Builder, x: byte) -> (n: int) {
flush_builder_check_space(b, 1);
if builder_space(b^) > 0 { if builder_space(b^) > 0 {
append(&b.buf, x); append(&b.buf, x);
n += 1; n += 1;
@@ -167,7 +138,6 @@ write_byte :: proc(b: ^Builder, x: byte) -> (n: int) {
write_bytes :: proc(b: ^Builder, x: []byte) -> (n: int) { write_bytes :: proc(b: ^Builder, x: []byte) -> (n: int) {
x := x; x := x;
for len(x) != 0 { for len(x) != 0 {
flush_builder_check_space(b, len(x));
space := builder_space(b^); space := builder_space(b^);
if space == 0 { if space == 0 {
break; // No need to append break; // No need to append