mirror of
https://github.com/odin-lang/Odin.git
synced 2026-06-03 01:07:56 +00:00
Allow flushing with strings.Builder; Make fmt.fprint* procedures use a custom flush procedure
This commit is contained in:
gingerBill
@@ -11,7 +11,7 @@ import "core:time"
|
||||
import "core:unicode/utf8"
|
||||
import "intrinsics"
|
||||
|
||||
DEFAULT_BUFFER_SIZE :: #config(FMT_DEFAULT_BUFFER_SIZE, 1<<12);
|
||||
DEFAULT_BUFFER_SIZE :: #config(FMT_DEFAULT_BUFFER_SIZE, 1<<10);
|
||||
|
||||
Info :: struct {
|
||||
minus: bool,
|
||||
@@ -62,29 +62,58 @@ 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 {
|
||||
data: [DEFAULT_BUFFER_SIZE]byte;
|
||||
buf := strings.builder_from_slice(data[:]);
|
||||
flush_data := Flush_Data{handle=fd};
|
||||
buf := fmt_file_builder(data[:], &flush_data);
|
||||
res := sbprint(buf=&buf, args=args, sep=sep);
|
||||
os.write_string(fd, res);
|
||||
return len(res);
|
||||
strings.flush_builder(&buf);
|
||||
return flush_data.bytes_written;
|
||||
}
|
||||
|
||||
fprintln :: proc(fd: os.Handle, args: ..any, sep := " ") -> int {
|
||||
data: [DEFAULT_BUFFER_SIZE]byte;
|
||||
buf := strings.builder_from_slice(data[:]);
|
||||
flush_data := Flush_Data{handle=fd};
|
||||
buf := fmt_file_builder(data[:], &flush_data);
|
||||
res := sbprintln(buf=&buf, args=args, sep=sep);
|
||||
os.write_string(fd, res);
|
||||
return len(res);
|
||||
strings.flush_builder(&buf);
|
||||
return flush_data.bytes_written;
|
||||
}
|
||||
fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int {
|
||||
data: [DEFAULT_BUFFER_SIZE]byte;
|
||||
buf := strings.builder_from_slice(data[:]);
|
||||
flush_data := Flush_Data{handle=fd};
|
||||
buf := fmt_file_builder(data[:], &flush_data);
|
||||
res := sbprintf(&buf, fmt, ..args);
|
||||
os.write_string(fd, res);
|
||||
return len(res);
|
||||
strings.flush_builder(&buf);
|
||||
return flush_data.bytes_written;
|
||||
}
|
||||
fprint_type :: proc(fd: os.Handle, info: ^runtime.Type_Info) -> int {
|
||||
data: [DEFAULT_BUFFER_SIZE]byte;
|
||||
flush_data := Flush_Data{handle=fd};
|
||||
buf := fmt_file_builder(data[:], &flush_data);
|
||||
reflect.write_type(&buf, info);
|
||||
strings.flush_builder(&buf);
|
||||
return flush_data.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); }
|
||||
@@ -174,12 +203,7 @@ panicf :: proc(fmt: string, args: ..any, loc := #caller_location) -> ! {
|
||||
p("Panic", message, loc);
|
||||
}
|
||||
|
||||
fprint_type :: proc(fd: os.Handle, info: ^runtime.Type_Info) {
|
||||
data: [DEFAULT_BUFFER_SIZE]byte;
|
||||
buf := strings.builder_from_slice(data[:]);
|
||||
reflect.write_type(&buf, info);
|
||||
os.write_string(fd, strings.to_string(buf));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -4,20 +4,26 @@ import "core:mem"
|
||||
import "core:unicode/utf8"
|
||||
import "core:strconv"
|
||||
|
||||
Builder_Flush_Proc :: #type proc(b: ^Builder) -> (do_reset: bool);
|
||||
|
||||
Builder :: struct {
|
||||
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 {
|
||||
return Builder{make([dynamic]byte, allocator)};
|
||||
return Builder{buf=make([dynamic]byte, allocator)};
|
||||
}
|
||||
|
||||
make_builder_len :: proc(len: int, allocator := context.allocator) -> Builder {
|
||||
return Builder{make([dynamic]byte, len, allocator)};
|
||||
return Builder{buf=make([dynamic]byte, len, allocator)};
|
||||
}
|
||||
|
||||
make_builder_len_cap :: proc(len, cap: int, allocator := context.allocator) -> Builder {
|
||||
return Builder{make([dynamic]byte, len, cap, allocator)};
|
||||
return Builder{buf=make([dynamic]byte, len, cap, allocator)};
|
||||
}
|
||||
|
||||
make_builder :: proc{
|
||||
@@ -42,6 +48,25 @@ reset_builder :: proc(b: ^Builder) {
|
||||
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 {
|
||||
s := transmute(mem.Raw_Slice)backing;
|
||||
d := mem.Raw_Dynamic_Array{
|
||||
@@ -50,7 +75,9 @@ builder_from_slice :: proc(backing: []byte) -> Builder {
|
||||
cap = s.len,
|
||||
allocator = mem.nil_allocator(),
|
||||
};
|
||||
return transmute(Builder)d;
|
||||
return Builder{
|
||||
buf = transmute([dynamic]byte)d,
|
||||
};
|
||||
}
|
||||
to_string :: proc(b: Builder) -> string {
|
||||
return string(b.buf[:]);
|
||||
@@ -62,15 +89,41 @@ builder_len :: proc(b: Builder) -> int {
|
||||
builder_cap :: proc(b: Builder) -> int {
|
||||
return cap(b.buf);
|
||||
}
|
||||
builder_space :: proc(b: Builder) -> int {
|
||||
return max(cap(b.buf), len(b.buf), 0);
|
||||
}
|
||||
|
||||
write_byte :: proc(b: ^Builder, x: byte) {
|
||||
append(&b.buf, x);
|
||||
write_byte :: proc(b: ^Builder, x: byte) -> (n: int) {
|
||||
flush_builder_check_space(b, 1);
|
||||
if builder_space(b^) > 0 {
|
||||
append(&b.buf, x);
|
||||
n += 1;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
write_bytes :: proc(b: ^Builder, x: []byte) -> (n: int) {
|
||||
x := x;
|
||||
for len(x) != 0 {
|
||||
flush_builder_check_space(b, len(x));
|
||||
space := builder_space(b^);
|
||||
if space == 0 {
|
||||
break; // No need to append
|
||||
}
|
||||
i := min(space, len(x));
|
||||
n += i;
|
||||
append(&b.buf, ..x[:i]);
|
||||
if len(x) <= i {
|
||||
break; // No more data to append
|
||||
}
|
||||
x = x[i:];
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
write_rune :: proc(b: ^Builder, r: rune) -> int {
|
||||
if r < utf8.RUNE_SELF {
|
||||
write_byte(b, byte(r));
|
||||
return 1;
|
||||
return write_byte(b, byte(r));
|
||||
}
|
||||
|
||||
s, n := utf8.encode_rune(r);
|
||||
@@ -78,12 +131,8 @@ write_rune :: proc(b: ^Builder, r: rune) -> int {
|
||||
return n;
|
||||
}
|
||||
|
||||
write_string :: proc(b: ^Builder, s: string) {
|
||||
write_bytes(b, transmute([]byte)s);
|
||||
}
|
||||
|
||||
write_bytes :: proc(b: ^Builder, x: []byte) {
|
||||
append(&b.buf, ..x);
|
||||
write_string :: proc(b: ^Builder, s: string) -> (n: int) {
|
||||
return write_bytes(b, transmute([]byte)s);
|
||||
}
|
||||
|
||||
pop_byte :: proc(b: ^Builder) -> (r: byte) {
|
||||
@@ -107,8 +156,8 @@ pop_rune :: proc(b: ^Builder) -> (r: rune, width: int) {
|
||||
@(private, static)
|
||||
DIGITS_LOWER := "0123456789abcdefx";
|
||||
|
||||
write_quoted_string :: proc(b: ^Builder, str: string, quote: byte = '"') {
|
||||
write_byte(b, quote);
|
||||
write_quoted_string :: proc(b: ^Builder, str: string, quote: byte = '"') -> (n: int) {
|
||||
n += write_byte(b, quote);
|
||||
for width, s := 0, str; len(s) > 0; s = s[width:] {
|
||||
r := rune(s[0]);
|
||||
width = 1;
|
||||
@@ -116,51 +165,57 @@ write_quoted_string :: proc(b: ^Builder, str: string, quote: byte = '"') {
|
||||
r, width = utf8.decode_rune_in_string(s);
|
||||
}
|
||||
if width == 1 && r == utf8.RUNE_ERROR {
|
||||
write_byte(b, '\\');
|
||||
write_byte(b, 'x');
|
||||
write_byte(b, DIGITS_LOWER[s[0]>>4]);
|
||||
write_byte(b, DIGITS_LOWER[s[0]&0xf]);
|
||||
n += write_byte(b, '\\');
|
||||
n += write_byte(b, 'x');
|
||||
n += write_byte(b, DIGITS_LOWER[s[0]>>4]);
|
||||
n += write_byte(b, DIGITS_LOWER[s[0]&0xf]);
|
||||
continue;
|
||||
}
|
||||
|
||||
write_escaped_rune(b, r, quote);
|
||||
n += write_escaped_rune(b, r, quote);
|
||||
|
||||
}
|
||||
write_byte(b, quote);
|
||||
n += write_byte(b, quote);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
write_encoded_rune :: proc(b: ^Builder, r: rune, write_quote := true) {
|
||||
if write_quote { write_byte(b, '\''); }
|
||||
write_encoded_rune :: proc(b: ^Builder, r: rune, write_quote := true) -> (n: int) {
|
||||
if write_quote {
|
||||
n += write_byte(b, '\'');
|
||||
}
|
||||
switch r {
|
||||
case '\a': write_string(b, `\a"`);
|
||||
case '\b': write_string(b, `\b"`);
|
||||
case '\e': write_string(b, `\e"`);
|
||||
case '\f': write_string(b, `\f"`);
|
||||
case '\n': write_string(b, `\n"`);
|
||||
case '\r': write_string(b, `\r"`);
|
||||
case '\t': write_string(b, `\t"`);
|
||||
case '\v': write_string(b, `\v"`);
|
||||
case '\a': n += write_string(b, `\a"`);
|
||||
case '\b': n += write_string(b, `\b"`);
|
||||
case '\e': n += write_string(b, `\e"`);
|
||||
case '\f': n += write_string(b, `\f"`);
|
||||
case '\n': n += write_string(b, `\n"`);
|
||||
case '\r': n += write_string(b, `\r"`);
|
||||
case '\t': n += write_string(b, `\t"`);
|
||||
case '\v': n += write_string(b, `\v"`);
|
||||
case:
|
||||
if r < 32 {
|
||||
write_string(b, `\x`);
|
||||
n += write_string(b, `\x`);
|
||||
buf: [2]byte;
|
||||
s := strconv.append_bits(buf[:], u64(r), 16, true, 64, strconv.digits, nil);
|
||||
switch len(s) {
|
||||
case 0: write_string(b, "00");
|
||||
case 1: write_byte(b, '0');
|
||||
case 2: write_string(b, s);
|
||||
case 0: n += write_string(b, "00");
|
||||
case 1: n += write_byte(b, '0');
|
||||
case 2: n += write_string(b, s);
|
||||
}
|
||||
} else {
|
||||
write_rune(b, r);
|
||||
n += write_rune(b, r);
|
||||
}
|
||||
|
||||
}
|
||||
if write_quote { write_byte(b, '\''); }
|
||||
if write_quote {
|
||||
n += write_byte(b, '\'');
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
write_escaped_rune :: proc(b: ^Builder, r: rune, quote: byte, html_safe := false) {
|
||||
write_escaped_rune :: proc(b: ^Builder, r: rune, quote: byte, html_safe := false) -> (n: int) {
|
||||
is_printable :: proc(r: rune) -> bool {
|
||||
if r <= 0xff {
|
||||
switch r {
|
||||
@@ -178,75 +233,76 @@ write_escaped_rune :: proc(b: ^Builder, r: rune, quote: byte, html_safe := false
|
||||
if html_safe {
|
||||
switch r {
|
||||
case '<', '>', '&':
|
||||
write_byte(b, '\\');
|
||||
write_byte(b, 'u');
|
||||
n += write_byte(b, '\\');
|
||||
n += write_byte(b, 'u');
|
||||
for s := 12; s >= 0; s -= 4 {
|
||||
write_byte(b, DIGITS_LOWER[r>>uint(s) & 0xf]);
|
||||
n += write_byte(b, DIGITS_LOWER[r>>uint(s) & 0xf]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if r == rune(quote) || r == '\\' {
|
||||
write_byte(b, '\\');
|
||||
write_byte(b, byte(r));
|
||||
n += write_byte(b, '\\');
|
||||
n += write_byte(b, byte(r));
|
||||
return;
|
||||
} else if is_printable(r) {
|
||||
write_encoded_rune(b, r, false);
|
||||
n += write_encoded_rune(b, r, false);
|
||||
return;
|
||||
}
|
||||
switch r {
|
||||
case '\a': write_string(b, `\a`);
|
||||
case '\b': write_string(b, `\b`);
|
||||
case '\e': write_string(b, `\e`);
|
||||
case '\f': write_string(b, `\f`);
|
||||
case '\n': write_string(b, `\n`);
|
||||
case '\r': write_string(b, `\r`);
|
||||
case '\t': write_string(b, `\t`);
|
||||
case '\v': write_string(b, `\v`);
|
||||
case '\a': n += write_string(b, `\a`);
|
||||
case '\b': n += write_string(b, `\b`);
|
||||
case '\e': n += write_string(b, `\e`);
|
||||
case '\f': n += write_string(b, `\f`);
|
||||
case '\n': n += write_string(b, `\n`);
|
||||
case '\r': n += write_string(b, `\r`);
|
||||
case '\t': n += write_string(b, `\t`);
|
||||
case '\v': n += write_string(b, `\v`);
|
||||
case:
|
||||
switch c := r; {
|
||||
case c < ' ':
|
||||
write_byte(b, '\\');
|
||||
write_byte(b, 'x');
|
||||
write_byte(b, DIGITS_LOWER[byte(c)>>4]);
|
||||
write_byte(b, DIGITS_LOWER[byte(c)&0xf]);
|
||||
n += write_byte(b, '\\');
|
||||
n += write_byte(b, 'x');
|
||||
n += write_byte(b, DIGITS_LOWER[byte(c)>>4]);
|
||||
n += write_byte(b, DIGITS_LOWER[byte(c)&0xf]);
|
||||
|
||||
case c > utf8.MAX_RUNE:
|
||||
c = 0xfffd;
|
||||
fallthrough;
|
||||
case c < 0x10000:
|
||||
write_byte(b, '\\');
|
||||
write_byte(b, 'u');
|
||||
n += write_byte(b, '\\');
|
||||
n += write_byte(b, 'u');
|
||||
for s := 12; s >= 0; s -= 4 {
|
||||
write_byte(b, DIGITS_LOWER[c>>uint(s) & 0xf]);
|
||||
n += write_byte(b, DIGITS_LOWER[c>>uint(s) & 0xf]);
|
||||
}
|
||||
case:
|
||||
write_byte(b, '\\');
|
||||
write_byte(b, 'U');
|
||||
n += write_byte(b, '\\');
|
||||
n += write_byte(b, 'U');
|
||||
for s := 28; s >= 0; s -= 4 {
|
||||
write_byte(b, DIGITS_LOWER[c>>uint(s) & 0xf]);
|
||||
n += write_byte(b, DIGITS_LOWER[c>>uint(s) & 0xf]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
write_u64 :: proc(b: ^Builder, i: u64, base: int = 10) {
|
||||
write_u64 :: proc(b: ^Builder, i: u64, base: int = 10) -> (n: int) {
|
||||
buf: [32]byte;
|
||||
s := strconv.append_bits(buf[:], u64(i), base, false, 64, strconv.digits, nil);
|
||||
write_string(b, s);
|
||||
return write_string(b, s);
|
||||
}
|
||||
write_i64 :: proc(b: ^Builder, i: i64, base: int = 10) {
|
||||
write_i64 :: proc(b: ^Builder, i: i64, base: int = 10) -> (n: int) {
|
||||
buf: [32]byte;
|
||||
s := strconv.append_bits(buf[:], u64(i), base, true, 64, strconv.digits, nil);
|
||||
write_string(b, s);
|
||||
return write_string(b, s);
|
||||
}
|
||||
|
||||
write_uint :: proc(b: ^Builder, i: uint, base: int = 10) {
|
||||
write_u64(b, u64(i), base);
|
||||
write_uint :: proc(b: ^Builder, i: uint, base: int = 10) -> (n: int) {
|
||||
return write_u64(b, u64(i), base);
|
||||
}
|
||||
write_int :: proc(b: ^Builder, i: int, base: int = 10) {
|
||||
write_i64(b, i64(i), base);
|
||||
write_int :: proc(b: ^Builder, i: int, base: int = 10) -> (n: int) {
|
||||
return write_i64(b, i64(i), base);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user