mirror of
https://github.com/Ed94/Odin.git
synced 2026-08-05 15:18:49 +00:00
Remove unneeded semicolons from the core library
This commit is contained in:
gingerBill
+155
-155
@@ -5,199 +5,199 @@ import "core:unicode/utf8"
|
||||
import "core:strconv"
|
||||
import "core:io"
|
||||
|
||||
Builder_Flush_Proc :: #type proc(b: ^Builder) -> (do_reset: bool);
|
||||
Builder_Flush_Proc :: #type proc(b: ^Builder) -> (do_reset: bool)
|
||||
|
||||
Builder :: struct {
|
||||
buf: [dynamic]byte,
|
||||
}
|
||||
|
||||
make_builder_none :: proc(allocator := context.allocator) -> Builder {
|
||||
return Builder{buf=make([dynamic]byte, allocator)};
|
||||
return Builder{buf=make([dynamic]byte, allocator)}
|
||||
}
|
||||
|
||||
make_builder_len :: proc(len: int, allocator := context.allocator) -> Builder {
|
||||
return Builder{buf=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{buf=make([dynamic]byte, len, cap, allocator)};
|
||||
return Builder{buf=make([dynamic]byte, len, cap, allocator)}
|
||||
}
|
||||
|
||||
make_builder :: proc{
|
||||
make_builder_none,
|
||||
make_builder_len,
|
||||
make_builder_len_cap,
|
||||
};
|
||||
}
|
||||
|
||||
init_builder_none :: proc(b: ^Builder, allocator := context.allocator) {
|
||||
b.buf = make([dynamic]byte, allocator);
|
||||
b.buf = make([dynamic]byte, allocator)
|
||||
}
|
||||
|
||||
init_builder_len :: proc(b: ^Builder, len: int, allocator := context.allocator) {
|
||||
b.buf = make([dynamic]byte, len, allocator);
|
||||
b.buf = make([dynamic]byte, len, allocator)
|
||||
}
|
||||
|
||||
init_builder_len_cap :: proc(b: ^Builder, len, cap: int, allocator := context.allocator) {
|
||||
b.buf = make([dynamic]byte, len, cap, allocator);
|
||||
b.buf = make([dynamic]byte, len, cap, allocator)
|
||||
}
|
||||
|
||||
init_builder :: proc{
|
||||
init_builder_none,
|
||||
init_builder_len,
|
||||
init_builder_len_cap,
|
||||
};
|
||||
}
|
||||
|
||||
@(private)
|
||||
_builder_stream_vtable := &io.Stream_VTable{
|
||||
impl_write = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
|
||||
b := (^Builder)(s.stream_data);
|
||||
n = write_bytes(b, p);
|
||||
b := (^Builder)(s.stream_data)
|
||||
n = write_bytes(b, p)
|
||||
if len(b.buf) == cap(b.buf) {
|
||||
err = .EOF;
|
||||
err = .EOF
|
||||
}
|
||||
return;
|
||||
return
|
||||
},
|
||||
impl_write_byte = proc(s: io.Stream, c: byte) -> io.Error {
|
||||
b := (^Builder)(s.stream_data);
|
||||
_ = write_byte(b, c);
|
||||
b := (^Builder)(s.stream_data)
|
||||
_ = write_byte(b, c)
|
||||
if len(b.buf) == cap(b.buf) {
|
||||
return .EOF;
|
||||
return .EOF
|
||||
}
|
||||
return nil;
|
||||
return nil
|
||||
},
|
||||
impl_size = proc(s: io.Stream) -> i64 {
|
||||
b := (^Builder)(s.stream_data);
|
||||
return i64(len(b.buf));
|
||||
b := (^Builder)(s.stream_data)
|
||||
return i64(len(b.buf))
|
||||
},
|
||||
impl_destroy = proc(s: io.Stream) -> io.Error {
|
||||
b := (^Builder)(s.stream_data);
|
||||
delete(b.buf);
|
||||
return .None;
|
||||
b := (^Builder)(s.stream_data)
|
||||
delete(b.buf)
|
||||
return .None
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
to_stream :: proc(b: ^Builder) -> io.Stream {
|
||||
return io.Stream{stream_vtable=_builder_stream_vtable, stream_data=b};
|
||||
return io.Stream{stream_vtable=_builder_stream_vtable, stream_data=b}
|
||||
}
|
||||
to_writer :: proc(b: ^Builder) -> io.Writer {
|
||||
w, _ := io.to_writer(to_stream(b));
|
||||
return w;
|
||||
w, _ := io.to_writer(to_stream(b))
|
||||
return w
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
destroy_builder :: proc(b: ^Builder) {
|
||||
delete(b.buf);
|
||||
clear(&b.buf);
|
||||
delete(b.buf)
|
||||
clear(&b.buf)
|
||||
}
|
||||
|
||||
grow_builder :: proc(b: ^Builder, cap: int) {
|
||||
reserve(&b.buf, cap);
|
||||
reserve(&b.buf, cap)
|
||||
}
|
||||
|
||||
reset_builder :: proc(b: ^Builder) {
|
||||
clear(&b.buf);
|
||||
clear(&b.buf)
|
||||
}
|
||||
|
||||
|
||||
builder_from_slice :: proc(backing: []byte) -> Builder {
|
||||
s := transmute(mem.Raw_Slice)backing;
|
||||
s := transmute(mem.Raw_Slice)backing
|
||||
d := mem.Raw_Dynamic_Array{
|
||||
data = s.data,
|
||||
len = 0,
|
||||
cap = s.len,
|
||||
allocator = mem.nil_allocator(),
|
||||
};
|
||||
}
|
||||
return Builder{
|
||||
buf = transmute([dynamic]byte)d,
|
||||
};
|
||||
}
|
||||
}
|
||||
to_string :: proc(b: Builder) -> string {
|
||||
return string(b.buf[:]);
|
||||
return string(b.buf[:])
|
||||
}
|
||||
|
||||
builder_len :: proc(b: Builder) -> int {
|
||||
return len(b.buf);
|
||||
return len(b.buf)
|
||||
}
|
||||
builder_cap :: proc(b: Builder) -> int {
|
||||
return cap(b.buf);
|
||||
return cap(b.buf)
|
||||
}
|
||||
builder_space :: proc(b: Builder) -> int {
|
||||
return max(cap(b.buf), len(b.buf), 0);
|
||||
return max(cap(b.buf), len(b.buf), 0)
|
||||
}
|
||||
|
||||
write_byte :: proc(b: ^Builder, x: byte) -> (n: int) {
|
||||
if builder_space(b^) > 0 {
|
||||
append(&b.buf, x);
|
||||
n += 1;
|
||||
append(&b.buf, x)
|
||||
n += 1
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
write_bytes :: proc(b: ^Builder, x: []byte) -> (n: int) {
|
||||
x := x;
|
||||
x := x
|
||||
for len(x) != 0 {
|
||||
space := builder_space(b^);
|
||||
space := builder_space(b^)
|
||||
if space == 0 {
|
||||
break; // No need to append
|
||||
break // No need to append
|
||||
}
|
||||
i := min(space, len(x));
|
||||
n += i;
|
||||
append(&b.buf, ..x[:i]);
|
||||
i := min(space, len(x))
|
||||
n += i
|
||||
append(&b.buf, ..x[:i])
|
||||
if len(x) <= i {
|
||||
break; // No more data to append
|
||||
break // No more data to append
|
||||
}
|
||||
x = x[i:];
|
||||
x = x[i:]
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
write_rune_builder :: proc(b: ^Builder, r: rune) -> (int, io.Error) {
|
||||
return io.write_rune(to_writer(b), r);
|
||||
return io.write_rune(to_writer(b), r)
|
||||
}
|
||||
|
||||
|
||||
write_quoted_rune_builder :: proc(b: ^Builder, r: rune) -> (n: int) {
|
||||
return write_quoted_rune(to_writer(b), r);
|
||||
return write_quoted_rune(to_writer(b), r)
|
||||
}
|
||||
|
||||
@(private)
|
||||
_write_byte :: proc(w: io.Writer, c: byte) -> int {
|
||||
err := io.write_byte(w, c);
|
||||
return 1 if err == nil else 0;
|
||||
err := io.write_byte(w, c)
|
||||
return 1 if err == nil else 0
|
||||
}
|
||||
|
||||
|
||||
write_quoted_rune :: proc(w: io.Writer, r: rune) -> (n: int) {
|
||||
quote := byte('\'');
|
||||
n += _write_byte(w, quote);
|
||||
buf, width := utf8.encode_rune(r);
|
||||
quote := byte('\'')
|
||||
n += _write_byte(w, quote)
|
||||
buf, width := utf8.encode_rune(r)
|
||||
if width == 1 && r == utf8.RUNE_ERROR {
|
||||
n += _write_byte(w, '\\');
|
||||
n += _write_byte(w, 'x');
|
||||
n += _write_byte(w, DIGITS_LOWER[buf[0]>>4]);
|
||||
n += _write_byte(w, DIGITS_LOWER[buf[0]&0xf]);
|
||||
n += _write_byte(w, '\\')
|
||||
n += _write_byte(w, 'x')
|
||||
n += _write_byte(w, DIGITS_LOWER[buf[0]>>4])
|
||||
n += _write_byte(w, DIGITS_LOWER[buf[0]&0xf])
|
||||
} else {
|
||||
n += write_escaped_rune(w, r, quote);
|
||||
n += write_escaped_rune(w, r, quote)
|
||||
}
|
||||
n += _write_byte(w, quote);
|
||||
return;
|
||||
n += _write_byte(w, quote)
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
write_string :: proc{
|
||||
write_string_builder,
|
||||
write_string_writer,
|
||||
};
|
||||
}
|
||||
|
||||
write_string_builder :: proc(b: ^Builder, s: string) -> (n: int) {
|
||||
return write_string_writer(to_writer(b), s);
|
||||
return write_string_writer(to_writer(b), s)
|
||||
}
|
||||
|
||||
write_string_writer :: proc(w: io.Writer, s: string) -> (n: int) {
|
||||
n, _ = io.write(w, transmute([]byte)s);
|
||||
return;
|
||||
n, _ = io.write(w, transmute([]byte)s)
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@@ -205,109 +205,109 @@ write_string_writer :: proc(w: io.Writer, s: string) -> (n: int) {
|
||||
|
||||
pop_byte :: proc(b: ^Builder) -> (r: byte) {
|
||||
if len(b.buf) == 0 {
|
||||
return 0;
|
||||
return 0
|
||||
}
|
||||
r = b.buf[len(b.buf)-1];
|
||||
d := cast(^mem.Raw_Dynamic_Array)&b.buf;
|
||||
d.len = max(d.len-1, 0);
|
||||
return;
|
||||
r = b.buf[len(b.buf)-1]
|
||||
d := cast(^mem.Raw_Dynamic_Array)&b.buf
|
||||
d.len = max(d.len-1, 0)
|
||||
return
|
||||
}
|
||||
|
||||
pop_rune :: proc(b: ^Builder) -> (r: rune, width: int) {
|
||||
r, width = utf8.decode_last_rune(b.buf[:]);
|
||||
d := cast(^mem.Raw_Dynamic_Array)&b.buf;
|
||||
d.len = max(d.len-width, 0);
|
||||
return;
|
||||
r, width = utf8.decode_last_rune(b.buf[:])
|
||||
d := cast(^mem.Raw_Dynamic_Array)&b.buf
|
||||
d.len = max(d.len-width, 0)
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
@(private)
|
||||
DIGITS_LOWER := "0123456789abcdefx";
|
||||
DIGITS_LOWER := "0123456789abcdefx"
|
||||
|
||||
write_quoted_string :: proc{
|
||||
write_quoted_string_builder,
|
||||
write_quoted_string_writer,
|
||||
};
|
||||
}
|
||||
|
||||
write_quoted_string_builder :: proc(b: ^Builder, str: string, quote: byte = '"') -> (n: int) {
|
||||
return write_quoted_string_writer(to_writer(b), str, quote);
|
||||
return write_quoted_string_writer(to_writer(b), str, quote)
|
||||
}
|
||||
|
||||
write_quoted_string_writer :: proc(w: io.Writer, str: string, quote: byte = '"') -> (n: int) {
|
||||
n += _write_byte(w, quote);
|
||||
n += _write_byte(w, quote)
|
||||
for width, s := 0, str; len(s) > 0; s = s[width:] {
|
||||
r := rune(s[0]);
|
||||
width = 1;
|
||||
r := rune(s[0])
|
||||
width = 1
|
||||
if r >= utf8.RUNE_SELF {
|
||||
r, width = utf8.decode_rune_in_string(s);
|
||||
r, width = utf8.decode_rune_in_string(s)
|
||||
}
|
||||
if width == 1 && r == utf8.RUNE_ERROR {
|
||||
n += _write_byte(w, '\\');
|
||||
n += _write_byte(w, 'x');
|
||||
n += _write_byte(w, DIGITS_LOWER[s[0]>>4]);
|
||||
n += _write_byte(w, DIGITS_LOWER[s[0]&0xf]);
|
||||
continue;
|
||||
n += _write_byte(w, '\\')
|
||||
n += _write_byte(w, 'x')
|
||||
n += _write_byte(w, DIGITS_LOWER[s[0]>>4])
|
||||
n += _write_byte(w, DIGITS_LOWER[s[0]&0xf])
|
||||
continue
|
||||
}
|
||||
|
||||
n += write_escaped_rune(w, r, quote);
|
||||
n += write_escaped_rune(w, r, quote)
|
||||
|
||||
}
|
||||
n += _write_byte(w, quote);
|
||||
return;
|
||||
n += _write_byte(w, quote)
|
||||
return
|
||||
}
|
||||
|
||||
write_encoded_rune :: proc{
|
||||
write_encoded_rune_builder,
|
||||
write_encoded_rune_writer,
|
||||
};
|
||||
}
|
||||
|
||||
write_encoded_rune_builder :: proc(b: ^Builder, r: rune, write_quote := true) -> (n: int) {
|
||||
return write_encoded_rune_writer(to_writer(b), r, write_quote);
|
||||
return write_encoded_rune_writer(to_writer(b), r, write_quote)
|
||||
|
||||
}
|
||||
write_encoded_rune_writer :: proc(w: io.Writer, r: rune, write_quote := true) -> (n: int) {
|
||||
if write_quote {
|
||||
n += _write_byte(w, '\'');
|
||||
n += _write_byte(w, '\'')
|
||||
}
|
||||
switch r {
|
||||
case '\a': n += write_string(w, `\a"`);
|
||||
case '\b': n += write_string(w, `\b"`);
|
||||
case '\e': n += write_string(w, `\e"`);
|
||||
case '\f': n += write_string(w, `\f"`);
|
||||
case '\n': n += write_string(w, `\n"`);
|
||||
case '\r': n += write_string(w, `\r"`);
|
||||
case '\t': n += write_string(w, `\t"`);
|
||||
case '\v': n += write_string(w, `\v"`);
|
||||
case '\a': n += write_string(w, `\a"`)
|
||||
case '\b': n += write_string(w, `\b"`)
|
||||
case '\e': n += write_string(w, `\e"`)
|
||||
case '\f': n += write_string(w, `\f"`)
|
||||
case '\n': n += write_string(w, `\n"`)
|
||||
case '\r': n += write_string(w, `\r"`)
|
||||
case '\t': n += write_string(w, `\t"`)
|
||||
case '\v': n += write_string(w, `\v"`)
|
||||
case:
|
||||
if r < 32 {
|
||||
n += write_string(w, `\x`);
|
||||
buf: [2]byte;
|
||||
s := strconv.append_bits(buf[:], u64(r), 16, true, 64, strconv.digits, nil);
|
||||
n += write_string(w, `\x`)
|
||||
buf: [2]byte
|
||||
s := strconv.append_bits(buf[:], u64(r), 16, true, 64, strconv.digits, nil)
|
||||
switch len(s) {
|
||||
case 0: n += write_string(w, "00");
|
||||
case 1: n += _write_byte(w, '0');
|
||||
case 2: n += write_string(w, s);
|
||||
case 0: n += write_string(w, "00")
|
||||
case 1: n += _write_byte(w, '0')
|
||||
case 2: n += write_string(w, s)
|
||||
}
|
||||
} else {
|
||||
rn, _ := io.write_rune(w, r);
|
||||
n += rn;
|
||||
rn, _ := io.write_rune(w, r)
|
||||
n += rn
|
||||
}
|
||||
|
||||
}
|
||||
if write_quote {
|
||||
n += _write_byte(w, '\'');
|
||||
n += _write_byte(w, '\'')
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
write_escaped_rune :: proc{
|
||||
write_escaped_rune_builder,
|
||||
write_escaped_rune_writer,
|
||||
};
|
||||
}
|
||||
|
||||
write_escaped_rune_builder :: proc(b: ^Builder, r: rune, quote: byte, html_safe := false) -> (n: int) {
|
||||
return write_escaped_rune_writer(to_writer(b), r, quote, html_safe);
|
||||
return write_escaped_rune_writer(to_writer(b), r, quote, html_safe)
|
||||
}
|
||||
|
||||
write_escaped_rune_writer :: proc(w: io.Writer, r: rune, quote: byte, html_safe := false) -> (n: int) {
|
||||
@@ -315,89 +315,89 @@ write_escaped_rune_writer :: proc(w: io.Writer, r: rune, quote: byte, html_safe
|
||||
if r <= 0xff {
|
||||
switch r {
|
||||
case 0x20..=0x7e:
|
||||
return true;
|
||||
return true
|
||||
case 0xa1..=0xff: // ¡ through ÿ except for the soft hyphen
|
||||
return r != 0xad; //
|
||||
return r != 0xad //
|
||||
}
|
||||
}
|
||||
|
||||
// TODO(bill): A proper unicode library will be needed!
|
||||
return false;
|
||||
return false
|
||||
}
|
||||
|
||||
if html_safe {
|
||||
switch r {
|
||||
case '<', '>', '&':
|
||||
n += _write_byte(w, '\\');
|
||||
n += _write_byte(w, 'u');
|
||||
n += _write_byte(w, '\\')
|
||||
n += _write_byte(w, 'u')
|
||||
for s := 12; s >= 0; s -= 4 {
|
||||
n += _write_byte(w, DIGITS_LOWER[r>>uint(s) & 0xf]);
|
||||
n += _write_byte(w, DIGITS_LOWER[r>>uint(s) & 0xf])
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if r == rune(quote) || r == '\\' {
|
||||
n += _write_byte(w, '\\');
|
||||
n += _write_byte(w, byte(r));
|
||||
return;
|
||||
n += _write_byte(w, '\\')
|
||||
n += _write_byte(w, byte(r))
|
||||
return
|
||||
} else if is_printable(r) {
|
||||
n += write_encoded_rune(w, r, false);
|
||||
return;
|
||||
n += write_encoded_rune(w, r, false)
|
||||
return
|
||||
}
|
||||
switch r {
|
||||
case '\a': n += write_string(w, `\a`);
|
||||
case '\b': n += write_string(w, `\b`);
|
||||
case '\e': n += write_string(w, `\e`);
|
||||
case '\f': n += write_string(w, `\f`);
|
||||
case '\n': n += write_string(w, `\n`);
|
||||
case '\r': n += write_string(w, `\r`);
|
||||
case '\t': n += write_string(w, `\t`);
|
||||
case '\v': n += write_string(w, `\v`);
|
||||
case '\a': n += write_string(w, `\a`)
|
||||
case '\b': n += write_string(w, `\b`)
|
||||
case '\e': n += write_string(w, `\e`)
|
||||
case '\f': n += write_string(w, `\f`)
|
||||
case '\n': n += write_string(w, `\n`)
|
||||
case '\r': n += write_string(w, `\r`)
|
||||
case '\t': n += write_string(w, `\t`)
|
||||
case '\v': n += write_string(w, `\v`)
|
||||
case:
|
||||
switch c := r; {
|
||||
case c < ' ':
|
||||
n += _write_byte(w, '\\');
|
||||
n += _write_byte(w, 'x');
|
||||
n += _write_byte(w, DIGITS_LOWER[byte(c)>>4]);
|
||||
n += _write_byte(w, DIGITS_LOWER[byte(c)&0xf]);
|
||||
n += _write_byte(w, '\\')
|
||||
n += _write_byte(w, 'x')
|
||||
n += _write_byte(w, DIGITS_LOWER[byte(c)>>4])
|
||||
n += _write_byte(w, DIGITS_LOWER[byte(c)&0xf])
|
||||
|
||||
case c > utf8.MAX_RUNE:
|
||||
c = 0xfffd;
|
||||
fallthrough;
|
||||
c = 0xfffd
|
||||
fallthrough
|
||||
case c < 0x10000:
|
||||
n += _write_byte(w, '\\');
|
||||
n += _write_byte(w, 'u');
|
||||
n += _write_byte(w, '\\')
|
||||
n += _write_byte(w, 'u')
|
||||
for s := 12; s >= 0; s -= 4 {
|
||||
n += _write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf]);
|
||||
n += _write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf])
|
||||
}
|
||||
case:
|
||||
n += _write_byte(w, '\\');
|
||||
n += _write_byte(w, 'U');
|
||||
n += _write_byte(w, '\\')
|
||||
n += _write_byte(w, 'U')
|
||||
for s := 28; s >= 0; s -= 4 {
|
||||
n += _write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf]);
|
||||
n += _write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf])
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
write_u64 :: proc(b: ^Builder, i: u64, base: int = 10) -> (n: int) {
|
||||
buf: [32]byte;
|
||||
s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil);
|
||||
return write_string(b, s);
|
||||
buf: [32]byte
|
||||
s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil)
|
||||
return write_string(b, s)
|
||||
}
|
||||
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);
|
||||
return write_string(b, s);
|
||||
buf: [32]byte
|
||||
s := strconv.append_bits(buf[:], u64(i), base, true, 64, strconv.digits, nil)
|
||||
return write_string(b, s)
|
||||
}
|
||||
|
||||
write_uint :: proc(b: ^Builder, i: uint, base: int = 10) -> (n: int) {
|
||||
return write_u64(b, u64(i), base);
|
||||
return write_u64(b, u64(i), base)
|
||||
}
|
||||
write_int :: proc(b: ^Builder, i: int, base: int = 10) -> (n: int) {
|
||||
return write_i64(b, i64(i), base);
|
||||
return write_i64(b, i64(i), base)
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user