mirror of
https://github.com/Ed94/Odin.git
synced 2026-08-02 12:48:14 +00:00
Add an extra optional ^int parameter to most io read/write calls allowing for simplified or_return use with incrementing byte usage
This commit is contained in:
gingerBill
+67
-21
@@ -139,16 +139,24 @@ destroy :: proc(s: Stream) -> Error {
|
||||
return .Empty
|
||||
}
|
||||
|
||||
read :: proc(s: Reader, p: []byte) -> (n: int, err: Error) {
|
||||
read :: proc(s: Reader, p: []byte, n_read: ^int = nil) -> (n: int, err: Error) {
|
||||
if s.stream_vtable != nil && s.impl_read != nil {
|
||||
return s->impl_read(p)
|
||||
n, err = s->impl_read(p)
|
||||
if n_read != nil {
|
||||
n_read^ += n
|
||||
}
|
||||
return
|
||||
}
|
||||
return 0, .Empty
|
||||
}
|
||||
|
||||
write :: proc(s: Writer, p: []byte) -> (n: int, err: Error) {
|
||||
write :: proc(s: Writer, p: []byte, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
if s.stream_vtable != nil && s.impl_write != nil {
|
||||
return s->impl_write(p)
|
||||
n, err = s->impl_write(p)
|
||||
if n_written != nil {
|
||||
n_written^ += n
|
||||
}
|
||||
return
|
||||
}
|
||||
return 0, .Empty
|
||||
}
|
||||
@@ -207,12 +215,16 @@ size :: proc(s: Stream) -> i64 {
|
||||
|
||||
|
||||
|
||||
read_at :: proc(r: Reader_At, p: []byte, offset: i64) -> (n: int, err: Error) {
|
||||
read_at :: proc(r: Reader_At, p: []byte, offset: i64, n_read: ^int = nil) -> (n: int, err: Error) {
|
||||
if r.stream_vtable == nil {
|
||||
return 0, .Empty
|
||||
}
|
||||
if r.impl_read_at != nil {
|
||||
return r->impl_read_at(p, offset)
|
||||
n, err = r->impl_read_at(p, offset)
|
||||
if n_read != nil {
|
||||
n_read^ += n
|
||||
}
|
||||
return
|
||||
}
|
||||
if r.impl_seek == nil || r.impl_read == nil {
|
||||
return 0, .Empty
|
||||
@@ -225,6 +237,9 @@ read_at :: proc(r: Reader_At, p: []byte, offset: i64) -> (n: int, err: Error) {
|
||||
}
|
||||
|
||||
n, err = r->impl_read(p)
|
||||
if n_read != nil {
|
||||
n_read^ += n
|
||||
}
|
||||
_, err1 := r->impl_seek(curr_offset, .Start)
|
||||
if err1 != nil && err == nil {
|
||||
err = err1
|
||||
@@ -233,12 +248,16 @@ read_at :: proc(r: Reader_At, p: []byte, offset: i64) -> (n: int, err: Error) {
|
||||
|
||||
}
|
||||
|
||||
write_at :: proc(w: Writer_At, p: []byte, offset: i64) -> (n: int, err: Error) {
|
||||
write_at :: proc(w: Writer_At, p: []byte, offset: i64, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
if w.stream_vtable == nil {
|
||||
return 0, .Empty
|
||||
}
|
||||
if w.impl_write_at != nil {
|
||||
return w->impl_write_at(p, offset)
|
||||
n, err = w->impl_write_at(p, offset)
|
||||
if n_written != nil {
|
||||
n_written^ += n
|
||||
}
|
||||
return
|
||||
}
|
||||
if w.impl_seek == nil || w.impl_write == nil {
|
||||
return 0, .Empty
|
||||
@@ -251,6 +270,9 @@ write_at :: proc(w: Writer_At, p: []byte, offset: i64) -> (n: int, err: Error) {
|
||||
}
|
||||
|
||||
n, err = w->impl_write(p)
|
||||
if n_written != nil {
|
||||
n_written^ += n
|
||||
}
|
||||
_, err1 := w->impl_seek(curr_offset, .Start)
|
||||
if err1 != nil && err == nil {
|
||||
err = err1
|
||||
@@ -278,7 +300,7 @@ read_from :: proc(w: Reader_From, r: Reader) -> (n: i64, err: Error) {
|
||||
}
|
||||
|
||||
|
||||
read_byte :: proc(r: Byte_Reader) -> (byte, Error) {
|
||||
read_byte :: proc(r: Byte_Reader, n_read: ^int = nil) -> (byte, Error) {
|
||||
if r.stream_vtable == nil {
|
||||
return 0, .Empty
|
||||
}
|
||||
@@ -291,6 +313,9 @@ read_byte :: proc(r: Byte_Reader) -> (byte, Error) {
|
||||
|
||||
b: [1]byte
|
||||
_, err := r->impl_read(b[:])
|
||||
if err == nil && n_read != nil {
|
||||
n_read^ += 1
|
||||
}
|
||||
return b[0], err
|
||||
}
|
||||
|
||||
@@ -299,16 +324,16 @@ write_byte :: proc{
|
||||
write_byte_to_writer,
|
||||
}
|
||||
|
||||
write_byte_to_byte_writer :: proc(w: Byte_Writer, c: byte) -> Error {
|
||||
return _write_byte(w, c)
|
||||
write_byte_to_byte_writer :: proc(w: Byte_Writer, c: byte, n_written: ^int = nil) -> Error {
|
||||
return _write_byte(w, c, n_written)
|
||||
}
|
||||
|
||||
write_byte_to_writer :: proc(w: Writer, c: byte) -> Error {
|
||||
return _write_byte(auto_cast w, c)
|
||||
write_byte_to_writer :: proc(w: Writer, c: byte, n_written: ^int = nil) -> Error {
|
||||
return _write_byte(auto_cast w, c, n_written)
|
||||
}
|
||||
|
||||
@(private)
|
||||
_write_byte :: proc(w: Byte_Writer, c: byte) -> Error {
|
||||
_write_byte :: proc(w: Byte_Writer, c: byte, n_written: ^int = nil) -> Error {
|
||||
if w.stream_vtable == nil {
|
||||
return .Empty
|
||||
}
|
||||
@@ -321,15 +346,22 @@ _write_byte :: proc(w: Byte_Writer, c: byte) -> Error {
|
||||
|
||||
b := [1]byte{c}
|
||||
_, err := w->impl_write(b[:])
|
||||
if err == nil && n_written != nil {
|
||||
n_written^ += 1
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
|
||||
read_rune :: proc(br: Rune_Reader, n_read: ^int = nil) -> (ch: rune, size: int, err: Error) {
|
||||
if br.stream_vtable == nil {
|
||||
return 0, 0, .Empty
|
||||
}
|
||||
if br.impl_read_rune != nil {
|
||||
return br->impl_read_rune()
|
||||
ch, size, err = br->impl_read_rune()
|
||||
if n_read != nil {
|
||||
n_read^ += size
|
||||
}
|
||||
return
|
||||
}
|
||||
if br.impl_read == nil {
|
||||
return 0, 0, .Empty
|
||||
@@ -337,6 +369,7 @@ read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
|
||||
|
||||
b: [utf8.UTF_MAX]byte
|
||||
_, err = br->impl_read(b[:1])
|
||||
|
||||
|
||||
s0 := b[0]
|
||||
ch = rune(s0)
|
||||
@@ -344,6 +377,9 @@ read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if n_read != nil {
|
||||
n_read^ += 1
|
||||
}
|
||||
if ch < utf8.RUNE_SELF {
|
||||
return
|
||||
}
|
||||
@@ -356,6 +392,9 @@ read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
|
||||
sz := int(x&7)
|
||||
n: int
|
||||
n, err = br->impl_read(b[1:sz])
|
||||
if n_read != nil {
|
||||
n_read^ += n
|
||||
}
|
||||
if err != nil || n+1 < sz {
|
||||
ch = utf8.RUNE_ERROR
|
||||
return
|
||||
@@ -379,24 +418,31 @@ unread_rune :: proc(s: Rune_Scanner) -> Error {
|
||||
}
|
||||
|
||||
|
||||
write_string :: proc(s: Writer, str: string) -> (n: int, err: Error) {
|
||||
return write(s, transmute([]byte)str)
|
||||
write_string :: proc(s: Writer, str: string, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
return write(s, transmute([]byte)str, n_written)
|
||||
}
|
||||
|
||||
write_rune :: proc(s: Writer, r: rune) -> (size: int, err: Error) {
|
||||
write_rune :: proc(s: Writer, r: rune, n_written: ^int = nil) -> (size: int, err: Error) {
|
||||
if s.stream_vtable != nil && s.impl_write_rune != nil {
|
||||
return s->impl_write_rune(r)
|
||||
size, err = s->impl_write_rune(r)
|
||||
if n_written != nil {
|
||||
n_written^ += size
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
if r < utf8.RUNE_SELF {
|
||||
err = write_byte(s, byte(r))
|
||||
if err == nil {
|
||||
size = 1
|
||||
if n_written != nil {
|
||||
n_written^ += size
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
buf, w := utf8.encode_rune(r)
|
||||
return write(s, buf[:w])
|
||||
return write(s, buf[:w], n_written)
|
||||
}
|
||||
|
||||
|
||||
|
||||
+77
-77
@@ -3,49 +3,49 @@ package io
|
||||
import "core:strconv"
|
||||
import "core:unicode/utf8"
|
||||
|
||||
read_ptr :: proc(r: Reader, p: rawptr, byte_size: int) -> (n: int, err: Error) {
|
||||
return read(r, ([^]byte)(p)[:byte_size])
|
||||
read_ptr :: proc(r: Reader, p: rawptr, byte_size: int, n_read: ^int = nil) -> (n: int, err: Error) {
|
||||
return read(r, ([^]byte)(p)[:byte_size], n_read)
|
||||
}
|
||||
|
||||
write_ptr :: proc(w: Writer, p: rawptr, byte_size: int) -> (n: int, err: Error) {
|
||||
return write(w, ([^]byte)(p)[:byte_size])
|
||||
write_ptr :: proc(w: Writer, p: rawptr, byte_size: int, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
return write(w, ([^]byte)(p)[:byte_size], n_written)
|
||||
}
|
||||
|
||||
read_ptr_at :: proc(r: Reader_At, p: rawptr, byte_size: int, offset: i64) -> (n: int, err: Error) {
|
||||
return read_at(r, ([^]byte)(p)[:byte_size], offset)
|
||||
read_ptr_at :: proc(r: Reader_At, p: rawptr, byte_size: int, offset: i64, n_read: ^int = nil) -> (n: int, err: Error) {
|
||||
return read_at(r, ([^]byte)(p)[:byte_size], offset, n_read)
|
||||
}
|
||||
|
||||
write_ptr_at :: proc(w: Writer_At, p: rawptr, byte_size: int, offset: i64) -> (n: int, err: Error) {
|
||||
return write_at(w, ([^]byte)(p)[:byte_size], offset)
|
||||
write_ptr_at :: proc(w: Writer_At, p: rawptr, byte_size: int, offset: i64, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
return write_at(w, ([^]byte)(p)[:byte_size], offset, n_written)
|
||||
}
|
||||
|
||||
write_u64 :: proc(w: Writer, i: u64, base: int = 10) -> (n: int, err: Error) {
|
||||
write_u64 :: proc(w: Writer, i: u64, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
buf: [32]byte
|
||||
s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil)
|
||||
return write_string(w, s)
|
||||
return write_string(w, s, n_written)
|
||||
}
|
||||
write_i64 :: proc(w: Writer, i: i64, base: int = 10) -> (n: int, err: Error) {
|
||||
write_i64 :: proc(w: Writer, i: i64, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
buf: [32]byte
|
||||
s := strconv.append_bits(buf[:], u64(i), base, true, 64, strconv.digits, nil)
|
||||
return write_string(w, s)
|
||||
return write_string(w, s, n_written)
|
||||
}
|
||||
|
||||
write_uint :: proc(w: Writer, i: uint, base: int = 10) -> (n: int, err: Error) {
|
||||
return write_u64(w, u64(i), base)
|
||||
write_uint :: proc(w: Writer, i: uint, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
return write_u64(w, u64(i), base, n_written)
|
||||
}
|
||||
write_int :: proc(w: Writer, i: int, base: int = 10) -> (n: int, err: Error) {
|
||||
return write_i64(w, i64(i), base)
|
||||
write_int :: proc(w: Writer, i: int, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
return write_i64(w, i64(i), base, n_written)
|
||||
}
|
||||
|
||||
write_u128 :: proc(w: Writer, i: u128, base: int = 10) -> (n: int, err: Error) {
|
||||
write_u128 :: proc(w: Writer, i: u128, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
buf: [32]byte
|
||||
s := strconv.append_bits_128(buf[:], i, base, false, 128, strconv.digits, nil)
|
||||
return write_string(w, s)
|
||||
return write_string(w, s, n_written)
|
||||
}
|
||||
write_i128 :: proc(w: Writer, i: i128, base: int = 10) -> (n: int, err: Error) {
|
||||
write_i128 :: proc(w: Writer, i: i128, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
buf: [32]byte
|
||||
s := strconv.append_bits_128(buf[:], u128(i), base, true, 128, strconv.digits, nil)
|
||||
return write_string(w, s)
|
||||
return write_string(w, s, n_written)
|
||||
}
|
||||
|
||||
|
||||
@@ -54,57 +54,51 @@ write_i128 :: proc(w: Writer, i: i128, base: int = 10) -> (n: int, err: Error) {
|
||||
@(private="file")
|
||||
DIGITS_LOWER := "0123456789abcdefx"
|
||||
|
||||
@(private="file")
|
||||
n_write_byte :: proc(w: Writer, b: byte, bytes_processed: ^int) -> Error {
|
||||
err := write_byte(w, b)
|
||||
if err == nil {
|
||||
bytes_processed^ += 1
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
n_wrapper :: proc(n: int, err: Error, bytes_processed: ^int) -> Error {
|
||||
bytes_processed^ += n
|
||||
return err
|
||||
}
|
||||
|
||||
|
||||
write_encoded_rune :: proc(w: Writer, r: rune, write_quote := true) -> (n: int, err: Error) {
|
||||
write_encoded_rune :: proc(w: Writer, r: rune, write_quote := true, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
defer if n_written != nil {
|
||||
n_written^ += n
|
||||
}
|
||||
if write_quote {
|
||||
n_write_byte(w, '\'', &n) or_return
|
||||
write_byte(w, '\'', &n) or_return
|
||||
}
|
||||
switch r {
|
||||
case '\a': n_wrapper(write_string(w, `\a"`), &n) or_return
|
||||
case '\b': n_wrapper(write_string(w, `\b"`), &n) or_return
|
||||
case '\e': n_wrapper(write_string(w, `\e"`), &n) or_return
|
||||
case '\f': n_wrapper(write_string(w, `\f"`), &n) or_return
|
||||
case '\n': n_wrapper(write_string(w, `\n"`), &n) or_return
|
||||
case '\r': n_wrapper(write_string(w, `\r"`), &n) or_return
|
||||
case '\t': n_wrapper(write_string(w, `\t"`), &n) or_return
|
||||
case '\v': n_wrapper(write_string(w, `\v"`), &n) or_return
|
||||
case '\a': write_string(w, `\a"`, &n) or_return
|
||||
case '\b': write_string(w, `\b"`, &n) or_return
|
||||
case '\e': write_string(w, `\e"`, &n) or_return
|
||||
case '\f': write_string(w, `\f"`, &n) or_return
|
||||
case '\n': write_string(w, `\n"`, &n) or_return
|
||||
case '\r': write_string(w, `\r"`, &n) or_return
|
||||
case '\t': write_string(w, `\t"`, &n) or_return
|
||||
case '\v': write_string(w, `\v"`, &n) or_return
|
||||
case:
|
||||
if r < 32 {
|
||||
n_wrapper(write_string(w, `\x`), &n) or_return
|
||||
write_string(w, `\x`, &n) or_return
|
||||
|
||||
buf: [2]byte
|
||||
s := strconv.append_bits(buf[:], u64(r), 16, true, 64, strconv.digits, nil)
|
||||
switch len(s) {
|
||||
case 0: n_wrapper(write_string(w, "00"), &n) or_return
|
||||
case 1: n_write_byte(w, '0', &n) or_return
|
||||
case 2: n_wrapper(write_string(w, s), &n) or_return
|
||||
case 0: write_string(w, "00", &n) or_return
|
||||
case 1: write_byte(w, '0', &n) or_return
|
||||
case 2: write_string(w, s, &n) or_return
|
||||
}
|
||||
} else {
|
||||
n_wrapper(write_rune(w, r), &n) or_return
|
||||
write_rune(w, r, &n) or_return
|
||||
}
|
||||
|
||||
}
|
||||
if write_quote {
|
||||
n_write_byte(w, '\'', &n) or_return
|
||||
write_byte(w, '\'', &n) or_return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
write_escaped_rune :: proc(w: Writer, r: rune, quote: byte, html_safe := false) -> (n: int, err: Error) {
|
||||
write_escaped_rune :: proc(w: Writer, r: rune, quote: byte, html_safe := false, n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
is_printable :: proc(r: rune) -> bool {
|
||||
if r <= 0xff {
|
||||
switch r {
|
||||
@@ -118,66 +112,72 @@ write_escaped_rune :: proc(w: Writer, r: rune, quote: byte, html_safe := false)
|
||||
// TODO(bill): A proper unicode library will be needed!
|
||||
return false
|
||||
}
|
||||
defer if n_written != nil {
|
||||
n_written^ += n
|
||||
}
|
||||
|
||||
if html_safe {
|
||||
switch r {
|
||||
case '<', '>', '&':
|
||||
n_write_byte(w, '\\', &n) or_return
|
||||
n_write_byte(w, 'u', &n) or_return
|
||||
write_byte(w, '\\', &n) or_return
|
||||
write_byte(w, 'u', &n) or_return
|
||||
for s := 12; s >= 0; s -= 4 {
|
||||
n_write_byte(w, DIGITS_LOWER[r>>uint(s) & 0xf], &n) or_return
|
||||
write_byte(w, DIGITS_LOWER[r>>uint(s) & 0xf], &n) or_return
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if r == rune(quote) || r == '\\' {
|
||||
n_write_byte(w, '\\', &n) or_return
|
||||
n_write_byte(w, byte(r), &n) or_return
|
||||
write_byte(w, '\\', &n) or_return
|
||||
write_byte(w, byte(r), &n) or_return
|
||||
return
|
||||
} else if is_printable(r) {
|
||||
n_wrapper(write_encoded_rune(w, r, false), &n) or_return
|
||||
write_encoded_rune(w, r, false, &n) or_return
|
||||
return
|
||||
}
|
||||
switch r {
|
||||
case '\a': n_wrapper(write_string(w, `\a`), &n) or_return
|
||||
case '\b': n_wrapper(write_string(w, `\b`), &n) or_return
|
||||
case '\e': n_wrapper(write_string(w, `\e`), &n) or_return
|
||||
case '\f': n_wrapper(write_string(w, `\f`), &n) or_return
|
||||
case '\n': n_wrapper(write_string(w, `\n`), &n) or_return
|
||||
case '\r': n_wrapper(write_string(w, `\r`), &n) or_return
|
||||
case '\t': n_wrapper(write_string(w, `\t`), &n) or_return
|
||||
case '\v': n_wrapper(write_string(w, `\v`), &n) or_return
|
||||
case '\a': write_string(w, `\a`, &n) or_return
|
||||
case '\b': write_string(w, `\b`, &n) or_return
|
||||
case '\e': write_string(w, `\e`, &n) or_return
|
||||
case '\f': write_string(w, `\f`, &n) or_return
|
||||
case '\n': write_string(w, `\n`, &n) or_return
|
||||
case '\r': write_string(w, `\r`, &n) or_return
|
||||
case '\t': write_string(w, `\t`, &n) or_return
|
||||
case '\v': write_string(w, `\v`, &n) or_return
|
||||
case:
|
||||
switch c := r; {
|
||||
case c < ' ':
|
||||
n_write_byte(w, '\\', &n) or_return
|
||||
n_write_byte(w, 'x', &n) or_return
|
||||
n_write_byte(w, DIGITS_LOWER[byte(c)>>4], &n) or_return
|
||||
n_write_byte(w, DIGITS_LOWER[byte(c)&0xf], &n) or_return
|
||||
write_byte(w, '\\', &n) or_return
|
||||
write_byte(w, 'x', &n) or_return
|
||||
write_byte(w, DIGITS_LOWER[byte(c)>>4], &n) or_return
|
||||
write_byte(w, DIGITS_LOWER[byte(c)&0xf], &n) or_return
|
||||
|
||||
case c > utf8.MAX_RUNE:
|
||||
c = 0xfffd
|
||||
fallthrough
|
||||
case c < 0x10000:
|
||||
n_write_byte(w, '\\', &n) or_return
|
||||
n_write_byte(w, 'u', &n) or_return
|
||||
write_byte(w, '\\', &n) or_return
|
||||
write_byte(w, 'u', &n) or_return
|
||||
for s := 12; s >= 0; s -= 4 {
|
||||
n_write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf], &n) or_return
|
||||
write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf], &n) or_return
|
||||
}
|
||||
case:
|
||||
n_write_byte(w, '\\', &n) or_return
|
||||
n_write_byte(w, 'U', &n) or_return
|
||||
write_byte(w, '\\', &n) or_return
|
||||
write_byte(w, 'U', &n) or_return
|
||||
for s := 28; s >= 0; s -= 4 {
|
||||
n_write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf], &n) or_return
|
||||
write_byte(w, DIGITS_LOWER[c>>uint(s) & 0xf], &n) or_return
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
write_quoted_string :: proc(w: Writer, str: string, quote: byte = '"') -> (n: int, err: Error) {
|
||||
n_write_byte(w, quote, &n) or_return
|
||||
write_quoted_string :: proc(w: Writer, str: string, quote: byte = '"', n_written: ^int = nil) -> (n: int, err: Error) {
|
||||
defer if n_written != nil {
|
||||
n_written^ += n
|
||||
}
|
||||
write_byte(w, quote, &n) or_return
|
||||
for width, s := 0, str; len(s) > 0; s = s[width:] {
|
||||
r := rune(s[0])
|
||||
width = 1
|
||||
@@ -185,17 +185,17 @@ write_quoted_string :: proc(w: Writer, str: string, quote: byte = '"') -> (n: in
|
||||
r, width = utf8.decode_rune_in_string(s)
|
||||
}
|
||||
if width == 1 && r == utf8.RUNE_ERROR {
|
||||
n_write_byte(w, '\\', &n) or_return
|
||||
n_write_byte(w, 'x', &n) or_return
|
||||
n_write_byte(w, DIGITS_LOWER[s[0]>>4], &n) or_return
|
||||
n_write_byte(w, DIGITS_LOWER[s[0]&0xf], &n) or_return
|
||||
write_byte(w, '\\', &n) or_return
|
||||
write_byte(w, 'x', &n) or_return
|
||||
write_byte(w, DIGITS_LOWER[s[0]>>4], &n) or_return
|
||||
write_byte(w, DIGITS_LOWER[s[0]&0xf], &n) or_return
|
||||
continue
|
||||
}
|
||||
|
||||
n_wrapper(write_escaped_rune(w, r, quote), &n) or_return
|
||||
|
||||
}
|
||||
n_write_byte(w, quote, &n) or_return
|
||||
write_byte(w, quote, &n) or_return
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user