ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-04 14:48:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename stream field names

Browse Source
This commit is contained in:
gingerBill
2020-12-02 23:17:21 +00:00
parent 8e08ae47fb
commit c4172e3914
6 changed files with 94 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/io/conv.odin
+23 -23
View File
@@ -8,14 +8,14 @@ Conversion_Error :: enum {
to_reader :: proc(s: Stream) -> (r: Reader, err: Conversion_Error) { to_reader :: proc(s: Stream) -> (r: Reader, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read == nil { if s.stream_vtable == nil || s.impl_read == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_writer :: proc(s: Stream) -> (w: Writer, err: Conversion_Error) { to_writer :: proc(s: Stream) -> (w: Writer, err: Conversion_Error) {
w.stream = s; w.stream = s;
if s.vtable == nil || s.impl_write == nil { if s.stream_vtable == nil || s.impl_write == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
@@ -23,21 +23,21 @@ to_writer :: proc(s: Stream) -> (w: Writer, err: Conversion_Error) {
to_closer :: proc(s: Stream) -> (c: Closer, err: Conversion_Error) { to_closer :: proc(s: Stream) -> (c: Closer, err: Conversion_Error) {
c.stream = s; c.stream = s;
if s.vtable == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_close == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_flusher :: proc(s: Stream) -> (f: Flusher, err: Conversion_Error) { to_flusher :: proc(s: Stream) -> (f: Flusher, err: Conversion_Error) {
f.stream = s; f.stream = s;
if s.vtable == nil || s.impl_flush == nil { if s.stream_vtable == nil || s.impl_flush == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_seeker :: proc(s: Stream) -> (seeker: Seeker, err: Conversion_Error) { to_seeker :: proc(s: Stream) -> (seeker: Seeker, err: Conversion_Error) {
seeker.stream = s; seeker.stream = s;
if s.vtable == nil || s.impl_seek == nil { if s.stream_vtable == nil || s.impl_seek == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
@@ -45,42 +45,42 @@ to_seeker :: proc(s: Stream) -> (seeker: Seeker, err: Conversion_Error) {
to_read_writer :: proc(s: Stream) -> (r: Read_Writer, err: Conversion_Error) { to_read_writer :: proc(s: Stream) -> (r: Read_Writer, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read == nil || s.impl_write == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_read_closer :: proc(s: Stream) -> (r: Read_Closer, err: Conversion_Error) { to_read_closer :: proc(s: Stream) -> (r: Read_Closer, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_close == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_read_write_closer :: proc(s: Stream) -> (r: Read_Write_Closer, err: Conversion_Error) { to_read_write_closer :: proc(s: Stream) -> (r: Read_Write_Closer, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_close == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_read_write_seeker :: proc(s: Stream) -> (r: Read_Write_Seeker, err: Conversion_Error) { to_read_write_seeker :: proc(s: Stream) -> (r: Read_Write_Seeker, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_seek == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_seek == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_write_flusher :: proc(s: Stream) -> (w: Write_Flusher, err: Conversion_Error) { to_write_flusher :: proc(s: Stream) -> (w: Write_Flusher, err: Conversion_Error) {
w.stream = s; w.stream = s;
if s.vtable == nil || s.impl_write == nil || s.impl_flush == nil { if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, err: Conversion_Error) { to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, err: Conversion_Error) {
w.stream = s; w.stream = s;
if s.vtable == nil || s.impl_write == nil || s.impl_flush == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil || s.impl_close == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
@@ -88,28 +88,28 @@ to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, err: Convers
to_reader_at :: proc(s: Stream) -> (r: Reader_At, err: Conversion_Error) { to_reader_at :: proc(s: Stream) -> (r: Reader_At, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read_at == nil { if s.stream_vtable == nil || s.impl_read_at == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_writer_at :: proc(s: Stream) -> (w: Writer_At, err: Conversion_Error) { to_writer_at :: proc(s: Stream) -> (w: Writer_At, err: Conversion_Error) {
w.stream = s; w.stream = s;
if s.vtable == nil || s.impl_write_at == nil { if s.stream_vtable == nil || s.impl_write_at == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_reader_from :: proc(s: Stream) -> (r: Reader_From, err: Conversion_Error) { to_reader_from :: proc(s: Stream) -> (r: Reader_From, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read_from == nil { if s.stream_vtable == nil || s.impl_read_from == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
} }
to_writer_to :: proc(s: Stream) -> (w: Writer_To, err: Conversion_Error) { to_writer_to :: proc(s: Stream) -> (w: Writer_To, err: Conversion_Error) {
w.stream = s; w.stream = s;
if s.vtable == nil || s.impl_write_to == nil { if s.stream_vtable == nil || s.impl_write_to == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
} }
return; return;
@@ -117,9 +117,9 @@ to_writer_to :: proc(s: Stream) -> (w: Writer_To, err: Conversion_Error) {
to_byte_reader :: proc(s: Stream) -> (b: Byte_Reader, err: Conversion_Error) { to_byte_reader :: proc(s: Stream) -> (b: Byte_Reader, err: Conversion_Error) {
b.stream = s; b.stream = s;
if s.vtable == nil || s.impl_read_byte == nil { if s.stream_vtable == nil || s.impl_read_byte == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
if s.vtable != nil && s.impl_read != nil { if s.stream_vtable != nil && s.impl_read != nil {
err = .Fallback_Possible; err = .Fallback_Possible;
} }
} }
@@ -127,7 +127,7 @@ to_byte_reader :: proc(s: Stream) -> (b: Byte_Reader, err: Conversion_Error) {
} }
to_byte_scanner :: proc(s: Stream) -> (b: Byte_Scanner, err: Conversion_Error) { to_byte_scanner :: proc(s: Stream) -> (b: Byte_Scanner, err: Conversion_Error) {
b.stream = s; b.stream = s;
if s.vtable != nil { if s.stream_vtable != nil {
if s.impl_unread_byte == nil { if s.impl_unread_byte == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
return; return;
@@ -144,9 +144,9 @@ to_byte_scanner :: proc(s: Stream) -> (b: Byte_Scanner, err: Conversion_Error) {
} }
to_byte_writer :: proc(s: Stream) -> (b: Byte_Writer, err: Conversion_Error) { to_byte_writer :: proc(s: Stream) -> (b: Byte_Writer, err: Conversion_Error) {
b.stream = s; b.stream = s;
if s.vtable == nil || s.impl_write_byte == nil { if s.stream_vtable == nil || s.impl_write_byte == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
if s.vtable != nil && s.impl_write != nil { if s.stream_vtable != nil && s.impl_write != nil {
err = .Fallback_Possible; err = .Fallback_Possible;
} }
} }
@@ -155,9 +155,9 @@ to_byte_writer :: proc(s: Stream) -> (b: Byte_Writer, err: Conversion_Error) {
to_rune_reader :: proc(s: Stream) -> (r: Rune_Reader, err: Conversion_Error) { to_rune_reader :: proc(s: Stream) -> (r: Rune_Reader, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable == nil || s.impl_read_rune == nil { if s.stream_vtable == nil || s.impl_read_rune == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
if s.vtable != nil && s.impl_read != nil { if s.stream_vtable != nil && s.impl_read != nil {
err = .Fallback_Possible; err = .Fallback_Possible;
} }
} }
@@ -166,7 +166,7 @@ to_rune_reader :: proc(s: Stream) -> (r: Rune_Reader, err: Conversion_Error) {
} }
to_rune_scanner :: proc(s: Stream) -> (r: Rune_Scanner, err: Conversion_Error) { to_rune_scanner :: proc(s: Stream) -> (r: Rune_Scanner, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.vtable != nil { if s.stream_vtable != nil {
if s.impl_unread_rune == nil { if s.impl_unread_rune == nil {
err = .Missing_Procedure; err = .Missing_Procedure;
return; return;
core/io/io.odin
+21 -21
View File
@@ -58,8 +58,8 @@ Destroy_Proc :: distinct proc(using s: Stream) -> Error;
Stream :: struct { Stream :: struct {
using vtable: ^Stream_VTable, using stream_vtable: ^Stream_VTable,
data: rawptr, stream_data: rawptr,
} }
Stream_VTable :: struct { Stream_VTable :: struct {
impl_close: Close_Proc, impl_close: Close_Proc,
@@ -113,7 +113,7 @@ Rune_Scanner :: struct {using stream: Stream};
destroy :: proc(s: Stream) -> Error { destroy :: proc(s: Stream) -> Error {
if s.vtable != nil && s.impl_destroy != nil { if s.stream_vtable != nil && s.impl_destroy != nil {
return s->impl_destroy(); return s->impl_destroy();
} }
// Instead of .Empty, .None is fine in this case // Instead of .Empty, .None is fine in this case
@@ -121,28 +121,28 @@ destroy :: proc(s: Stream) -> Error {
} }
read :: proc(s: Reader, p: []byte) -> (n: int, err: Error) { read :: proc(s: Reader, p: []byte) -> (n: int, err: Error) {
if s.vtable != nil && s.impl_read != nil { if s.stream_vtable != nil && s.impl_read != nil {
return s->impl_read(p); return s->impl_read(p);
} }
return 0, .Empty; return 0, .Empty;
} }
write :: proc(s: Writer, p: []byte) -> (n: int, err: Error) { write :: proc(s: Writer, p: []byte) -> (n: int, err: Error) {
if s.vtable != nil && s.impl_write != nil { if s.stream_vtable != nil && s.impl_write != nil {
return s->impl_write(p); return s->impl_write(p);
} }
return 0, .Empty; return 0, .Empty;
} }
seek :: proc(s: Seeker, offset: i64, whence: Seek_From) -> (n: i64, err: Error) { seek :: proc(s: Seeker, offset: i64, whence: Seek_From) -> (n: i64, err: Error) {
if s.vtable != nil && s.impl_seek != nil { if s.stream_vtable != nil && s.impl_seek != nil {
return s->impl_seek(offset, whence); return s->impl_seek(offset, whence);
} }
return 0, .Empty; return 0, .Empty;
} }
close :: proc(s: Closer, p: []byte) -> Error { close :: proc(s: Closer, p: []byte) -> Error {
if s.vtable != nil && s.impl_close != nil { if s.stream_vtable != nil && s.impl_close != nil {
return s->impl_close(); return s->impl_close();
} }
// Instead of .Empty, .None is fine in this case // Instead of .Empty, .None is fine in this case
@@ -150,7 +150,7 @@ close :: proc(s: Closer, p: []byte) -> Error {
} }
flush :: proc(s: Flusher, p: []byte) -> Error { flush :: proc(s: Flusher, p: []byte) -> Error {
if s.vtable != nil && s.impl_flush != nil { if s.stream_vtable != nil && s.impl_flush != nil {
return s->impl_flush(); return s->impl_flush();
} }
// Instead of .Empty, .None is fine in this case // Instead of .Empty, .None is fine in this case
@@ -158,7 +158,7 @@ flush :: proc(s: Flusher, p: []byte) -> Error {
} }
size :: proc(s: Stream, p: []byte) -> i64 { size :: proc(s: Stream, p: []byte) -> i64 {
if s.vtable == nil { if s.stream_vtable == nil {
return 0; return 0;
} }
if s.impl_size != nil { if s.impl_size != nil {
@@ -189,7 +189,7 @@ size :: proc(s: Stream, p: []byte) -> 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: int, err: Error) {
if r.vtable == nil { if r.stream_vtable == nil {
return 0, .Empty; return 0, .Empty;
} }
if r.impl_read_at != nil { if r.impl_read_at != nil {
@@ -210,7 +210,7 @@ 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: int, err: Error) {
if w.vtable == nil { if w.stream_vtable == nil {
return 0, .Empty; return 0, .Empty;
} }
if w.impl_write_at != nil { if w.impl_write_at != nil {
@@ -231,7 +231,7 @@ write_at :: proc(w: Writer_At, p: []byte, offset: i64) -> (n: int, err: Error) {
} }
write_to :: proc(r: Reader, w: Writer) -> (n: i64, err: Error) { write_to :: proc(r: Reader, w: Writer) -> (n: i64, err: Error) {
if r.vtable == nil || w.vtable == nil { if r.stream_vtable == nil || w.stream_vtable == nil {
return 0, .Empty; return 0, .Empty;
} }
if r.impl_write_to != nil { if r.impl_write_to != nil {
@@ -240,7 +240,7 @@ write_to :: proc(r: Reader, w: Writer) -> (n: i64, err: Error) {
return 0, .Empty; return 0, .Empty;
} }
read_from :: proc(w: Writer, r: Reader) -> (n: i64, err: Error) { read_from :: proc(w: Writer, r: Reader) -> (n: i64, err: Error) {
if r.vtable == nil || w.vtable == nil { if r.stream_vtable == nil || w.stream_vtable == nil {
return 0, .Empty; return 0, .Empty;
} }
if r.impl_read_from != nil { if r.impl_read_from != nil {
@@ -251,7 +251,7 @@ read_from :: proc(w: Writer, r: Reader) -> (n: i64, err: Error) {
read_byte :: proc(r: Byte_Reader) -> (byte, Error) { read_byte :: proc(r: Byte_Reader) -> (byte, Error) {
if r.vtable == nil { if r.stream_vtable == nil {
return 0, .Empty; return 0, .Empty;
} }
if r.impl_read_byte != nil { if r.impl_read_byte != nil {
@@ -267,7 +267,7 @@ read_byte :: proc(r: Byte_Reader) -> (byte, Error) {
} }
write_byte :: proc(w: Byte_Writer, c: byte) -> Error { write_byte :: proc(w: Byte_Writer, c: byte) -> Error {
if w.vtable == nil { if w.stream_vtable == nil {
return .Empty; return .Empty;
} }
if w.impl_write_byte != nil { if w.impl_write_byte != nil {
@@ -283,7 +283,7 @@ write_byte :: proc(w: Byte_Writer, c: byte) -> Error {
} }
read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) { read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
if br.vtable == nil { if br.stream_vtable == nil {
return 0, 0, .Empty; return 0, 0, .Empty;
} }
if br.impl_read_rune != nil { if br.impl_read_rune != nil {
@@ -324,13 +324,13 @@ read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
} }
unread_byte :: proc(s: Byte_Scanner) -> Error { unread_byte :: proc(s: Byte_Scanner) -> Error {
if s.vtable != nil && s.impl_unread_byte != nil { if s.stream_vtable != nil && s.impl_unread_byte != nil {
return s->impl_unread_byte(); return s->impl_unread_byte();
} }
return .Empty; return .Empty;
} }
unread_rune :: proc(s: Rune_Scanner) -> Error { unread_rune :: proc(s: Rune_Scanner) -> Error {
if s.vtable != nil && s.impl_unread_rune != nil { if s.stream_vtable != nil && s.impl_unread_rune != nil {
return s->impl_unread_rune(); return s->impl_unread_rune();
} }
return .Empty; return .Empty;
@@ -408,7 +408,7 @@ copy_n :: proc(dst: Writer, src: Reader, n: i64) -> (written: i64, err: Error) {
@(private) @(private)
_copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, err: Error) { _copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, err: Error) {
if dst.vtable == nil || src.vtable == nil { if dst.stream_vtable == nil || src.stream_vtable == nil {
return 0, .Empty; return 0, .Empty;
} }
if src.impl_write_to != nil { if src.impl_write_to != nil {
@@ -421,8 +421,8 @@ _copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, er
if buf == nil { if buf == nil {
DEFAULT_SIZE :: 4 * 1024; DEFAULT_SIZE :: 4 * 1024;
size := DEFAULT_SIZE; size := DEFAULT_SIZE;
if src.vtable == _limited_reader_vtable { if src.stream_vtable == _limited_reader_vtable {
l := (^Limited_Reader)(src.data); l := (^Limited_Reader)(src.stream_data);
if i64(size) > l.n { if i64(size) > l.n {
if l.n < 1 { if l.n < 1 {
size = 1; size = 1;
core/io/multi.odin
+12 -12
View File
@@ -11,7 +11,7 @@ Multi_Reader :: struct {
@(private) @(private)
_multi_reader_vtable := &Stream_VTable{ _multi_reader_vtable := &Stream_VTable{
impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) { impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
mr := (^Multi_Reader)(s.data); mr := (^Multi_Reader)(s.stream_data);
for len(mr.readers) > 0 { for len(mr.readers) > 0 {
r := mr.readers[0]; r := mr.readers[0];
n, err = read(r, p); n, err = read(r, p);
@@ -29,7 +29,7 @@ _multi_reader_vtable := &Stream_VTable{
return 0, .EOF; return 0, .EOF;
}, },
impl_destroy = proc(s: Stream) -> Error { impl_destroy = proc(s: Stream) -> Error {
mr := (^Multi_Reader)(s.data); mr := (^Multi_Reader)(s.stream_data);
context.allocator = mr.readers.allocator; context.allocator = mr.readers.allocator;
delete(mr.readers); delete(mr.readers);
free(mr); free(mr);
@@ -40,13 +40,13 @@ _multi_reader_vtable := &Stream_VTable{
mutlti_reader :: proc(readers: ..Reader, allocator := context.allocator) -> Reader { mutlti_reader :: proc(readers: ..Reader, allocator := context.allocator) -> Reader {
context.allocator = allocator; context.allocator = allocator;
mr := new(Multi_Reader); mr := new(Multi_Reader);
mr.vtable = _multi_reader_vtable; mr.stream_vtable = _multi_reader_vtable;
mr.data = mr; mr.stream_data = mr;
all_readers := make([dynamic]Reader, 0, len(readers)); all_readers := make([dynamic]Reader, 0, len(readers));
for w in readers { for w in readers {
if w.vtable == _multi_reader_vtable { if w.stream_vtable == _multi_reader_vtable {
other := (^Multi_Reader)(w.data); other := (^Multi_Reader)(w.stream_data);
append(&all_readers, ..other.readers[:]); append(&all_readers, ..other.readers[:]);
} else { } else {
append(&all_readers, w); append(&all_readers, w);
@@ -69,7 +69,7 @@ Multi_Writer :: struct {
@(private) @(private)
_multi_writer_vtable := &Stream_VTable{ _multi_writer_vtable := &Stream_VTable{
impl_write = proc(s: Stream, p: []byte) -> (n: int, err: Error) { impl_write = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
mw := (^Multi_Writer)(s.data); mw := (^Multi_Writer)(s.stream_data);
for w in mw.writers { for w in mw.writers {
n, err = write(w, p); n, err = write(w, p);
if err != nil { if err != nil {
@@ -84,7 +84,7 @@ _multi_writer_vtable := &Stream_VTable{
return len(p), nil; return len(p), nil;
}, },
impl_destroy = proc(s: Stream) -> Error { impl_destroy = proc(s: Stream) -> Error {
mw := (^Multi_Writer)(s.data); mw := (^Multi_Writer)(s.stream_data);
context.allocator = mw.allocator; context.allocator = mw.allocator;
delete(mw.writers); delete(mw.writers);
free(mw); free(mw);
@@ -95,14 +95,14 @@ _multi_writer_vtable := &Stream_VTable{
mutlti_writer :: proc(writers: ..Writer, allocator := context.allocator) -> Writer { mutlti_writer :: proc(writers: ..Writer, allocator := context.allocator) -> Writer {
context.allocator = allocator; context.allocator = allocator;
mw := new(Multi_Writer); mw := new(Multi_Writer);
mw.vtable = _multi_writer_vtable; mw.stream_vtable = _multi_writer_vtable;
mw.data = mw; mw.stream_data = mw;
mw.allocator = allocator; mw.allocator = allocator;
all_writers := make([dynamic]Writer, 0, len(writers)); all_writers := make([dynamic]Writer, 0, len(writers));
for w in writers { for w in writers {
if w.vtable == _multi_writer_vtable { if w.stream_vtable == _multi_writer_vtable {
other := (^Multi_Writer)(w.data); other := (^Multi_Writer)(w.stream_data);
append(&all_writers, ..other.writers); append(&all_writers, ..other.writers);
} else { } else {
append(&all_writers, w); append(&all_writers, w);
core/io/util.odin
+9 -9
View File
@@ -13,7 +13,7 @@ Tee_Reader :: struct {
@(private) @(private)
_tee_reader_vtable := &Stream_VTable{ _tee_reader_vtable := &Stream_VTable{
impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) { impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
t := (^Tee_Reader)(s.data); t := (^Tee_Reader)(s.stream_data);
n, err = read(t.r, p); n, err = read(t.r, p);
if n > 0 { if n > 0 {
if wn, werr := write(t.w, p[:n]); werr != nil { if wn, werr := write(t.w, p[:n]); werr != nil {
@@ -23,7 +23,7 @@ _tee_reader_vtable := &Stream_VTable{
return; return;
}, },
impl_destroy = proc(s: Stream) -> Error { impl_destroy = proc(s: Stream) -> Error {
t := (^Tee_Reader)(s.data); t := (^Tee_Reader)(s.stream_data);
allocator := t.allocator; allocator := t.allocator;
free(t, allocator); free(t, allocator);
return .None; return .None;
@@ -36,8 +36,8 @@ tee_reader :: proc(r: Reader, w: Writer, allocator := context.allocator) -> Read
t := new(Tee_Reader, allocator); t := new(Tee_Reader, allocator);
t.r, t.w = r, w; t.r, t.w = r, w;
t.allocator = allocator; t.allocator = allocator;
t.data = t; t.stream_data = t;
t.vtable = _tee_reader_vtable; t.stream_vtable = _tee_reader_vtable;
res, _ := to_reader(t^); res, _ := to_reader(t^);
return res; return res;
} }
@@ -56,7 +56,7 @@ Limited_Reader :: struct {
@(private) @(private)
_limited_reader_vtable := &Stream_VTable{ _limited_reader_vtable := &Stream_VTable{
impl_read = proc(using s: Stream, p: []byte) -> (n: int, err: Error) { impl_read = proc(using s: Stream, p: []byte) -> (n: int, err: Error) {
l := (^Limited_Reader)(s.data); l := (^Limited_Reader)(s.stream_data);
if l.n <= 0 { if l.n <= 0 {
return 0, .EOF; return 0, .EOF;
} }
@@ -72,8 +72,8 @@ _limited_reader_vtable := &Stream_VTable{
new_limited_reader :: proc(r: Reader, n: i64) -> ^Limited_Reader { new_limited_reader :: proc(r: Reader, n: i64) -> ^Limited_Reader {
l := new(Limited_Reader); l := new(Limited_Reader);
l.vtable = _limited_reader_vtable; l.stream_vtable = _limited_reader_vtable;
l.data = l; l.stream_data = l;
l.r = r; l.r = r;
l.n = n; l.n = n;
return l; return l;
@@ -81,8 +81,8 @@ new_limited_reader :: proc(r: Reader, n: i64) -> ^Limited_Reader {
@(private="package") @(private="package")
inline_limited_reader :: proc(l: ^Limited_Reader, r: Reader, n: i64) -> Reader { inline_limited_reader :: proc(l: ^Limited_Reader, r: Reader, n: i64) -> Reader {
l.vtable = _limited_reader_vtable; l.stream_vtable = _limited_reader_vtable;
l.data = l; l.stream_data = l;
l.r = r; l.r = r;
l.n = n; l.n = n;
res, _ := to_reader(l^); res, _ := to_reader(l^);
core/strings/builder.odin
+18
View File
@@ -32,6 +32,24 @@ make_builder :: proc{
make_builder_len_cap, make_builder_len_cap,
}; };
init_builder_none :: proc(b: ^Builder, allocator := context.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);
}
init_builder_len_cap :: proc(b: ^Builder, len, cap: int, allocator := context.allocator) {
b.buf = make([dynamic]byte, len, cap, allocator);
}
init_builder :: proc{
init_builder_none,
init_builder_len,
init_builder_len_cap,
};
core/strings/reader.odin
+11 -11
View File
@@ -11,7 +11,8 @@ Reader :: struct {
} }
reader_reset :: proc(r: ^Reader, s: string) { reader_reset :: proc(r: ^Reader, s: string) {
r.data = r; r.stream_data = r;
r.stream_vtable = _reader_vtable;
r.s = s; r.s = s;
r.i = 0; r.i = 0;
r.prev_rune = -1; r.prev_rune = -1;
@@ -20,18 +21,17 @@ reader_reset :: proc(r: ^Reader, s: string) {
new_reader :: proc(s: string, allocator := context.allocator) -> ^Reader { new_reader :: proc(s: string, allocator := context.allocator) -> ^Reader {
r := new(Reader, allocator); r := new(Reader, allocator);
reader_reset(r, s); reader_reset(r, s);
r.vtable = _reader_vtable;
return r; return r;
} }
@(private) @(private)
_reader_vtable := &io.Stream_VTable{ _reader_vtable := &io.Stream_VTable{
impl_size = proc(s: io.Stream) -> i64 { impl_size = proc(s: io.Stream) -> i64 {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
return i64(len(r.s)); return i64(len(r.s));
}, },
impl_read = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) { impl_read = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
if r.i >= i64(len(r.s)) { if r.i >= i64(len(r.s)) {
return 0, .EOF; return 0, .EOF;
} }
@@ -41,7 +41,7 @@ _reader_vtable := &io.Stream_VTable{
return; return;
}, },
impl_read_at = proc(s: io.Stream, p: []byte, off: i64) -> (n: int, err: io.Error) { impl_read_at = proc(s: io.Stream, p: []byte, off: i64) -> (n: int, err: io.Error) {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
if off < 0 { if off < 0 {
return 0, .Invalid_Offset; return 0, .Invalid_Offset;
} }
@@ -55,7 +55,7 @@ _reader_vtable := &io.Stream_VTable{
return; return;
}, },
impl_read_byte = proc(s: io.Stream) -> (byte, io.Error) { impl_read_byte = proc(s: io.Stream) -> (byte, io.Error) {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
r.prev_rune = -1; r.prev_rune = -1;
if r.i >= i64(len(r.s)) { if r.i >= i64(len(r.s)) {
return 0, .EOF; return 0, .EOF;
@@ -65,7 +65,7 @@ _reader_vtable := &io.Stream_VTable{
return b, nil; return b, nil;
}, },
impl_unread_byte = proc(s: io.Stream) -> io.Error { impl_unread_byte = proc(s: io.Stream) -> io.Error {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
if r.i <= 0 { if r.i <= 0 {
return .Invalid_Unread; return .Invalid_Unread;
} }
@@ -74,7 +74,7 @@ _reader_vtable := &io.Stream_VTable{
return nil; return nil;
}, },
impl_read_rune = proc(s: io.Stream) -> (ch: rune, size: int, err: io.Error) { impl_read_rune = proc(s: io.Stream) -> (ch: rune, size: int, err: io.Error) {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
if r.i >= i64(len(r.s)) { if r.i >= i64(len(r.s)) {
r.prev_rune = -1; r.prev_rune = -1;
return 0, 0, .EOF; return 0, 0, .EOF;
@@ -89,7 +89,7 @@ _reader_vtable := &io.Stream_VTable{
return; return;
}, },
impl_unread_rune = proc(s: io.Stream) -> io.Error { impl_unread_rune = proc(s: io.Stream) -> io.Error {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
if r.i <= 0 { if r.i <= 0 {
return .Invalid_Unread; return .Invalid_Unread;
} }
@@ -101,7 +101,7 @@ _reader_vtable := &io.Stream_VTable{
return nil; return nil;
}, },
impl_seek = proc(s: io.Stream, offset: i64, whence: io.Seek_From) -> (i64, io.Error) { impl_seek = proc(s: io.Stream, offset: i64, whence: io.Seek_From) -> (i64, io.Error) {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
r.prev_rune = -1; r.prev_rune = -1;
abs: i64; abs: i64;
switch whence { switch whence {
@@ -122,7 +122,7 @@ _reader_vtable := &io.Stream_VTable{
return abs, nil; return abs, nil;
}, },
impl_write_to = proc(s: io.Stream, w: io.Writer) -> (n: i64, err: io.Error) { impl_write_to = proc(s: io.Stream, w: io.Writer) -> (n: i64, err: io.Error) {
r := (^Reader)(s.data); r := (^Reader)(s.stream_data);
r.prev_rune = -1; r.prev_rune = -1;
if r.i >= i64(len(r.s)) { if r.i >= i64(len(r.s)) {
return 0, nil; return 0, nil;