mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-01-04 04:02:33 +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

46
core/io/conv.odin
View File

@@ -8,14 +8,14 @@ Conversion_Error :: enum {
to_reader :: proc(s: Stream) -> (r: Reader, err: Conversion_Error) {
r.stream = s;
if s.vtable == nil || s.impl_read == nil {
if s.stream_vtable == nil || s.impl_read == nil {
err = .Missing_Procedure;
}
return;
}
to_writer :: proc(s: Stream) -> (w: Writer, err: Conversion_Error) {
w.stream = s;
if s.vtable == nil || s.impl_write == nil {
if s.stream_vtable == nil || s.impl_write == nil {
err = .Missing_Procedure;
}
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) {
c.stream = s;
if s.vtable == nil || s.impl_close == nil {
if s.stream_vtable == nil || s.impl_close == nil {
err = .Missing_Procedure;
}
return;
}
to_flusher :: proc(s: Stream) -> (f: Flusher, err: Conversion_Error) {
f.stream = s;
if s.vtable == nil || s.impl_flush == nil {
if s.stream_vtable == nil || s.impl_flush == nil {
err = .Missing_Procedure;
}
return;
}
to_seeker :: proc(s: Stream) -> (seeker: Seeker, err: Conversion_Error) {
seeker.stream = s;
if s.vtable == nil || s.impl_seek == nil {
if s.stream_vtable == nil || s.impl_seek == nil {
err = .Missing_Procedure;
}
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) {
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;
}
return;
}
to_read_closer :: proc(s: Stream) -> (r: Read_Closer, err: Conversion_Error) {
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;
}
return;
}
to_read_write_closer :: proc(s: Stream) -> (r: Read_Write_Closer, err: Conversion_Error) {
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;
}
return;
}
to_read_write_seeker :: proc(s: Stream) -> (r: Read_Write_Seeker, err: Conversion_Error) {
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;
}
return;
}
to_write_flusher :: proc(s: Stream) -> (w: Write_Flusher, err: Conversion_Error) {
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;
}
return;
}
to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, err: Conversion_Error) {
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;
}
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) {
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;
}
return;
}
to_writer_at :: proc(s: Stream) -> (w: Writer_At, err: Conversion_Error) {
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;
}
return;
}
to_reader_from :: proc(s: Stream) -> (r: Reader_From, err: Conversion_Error) {
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;
}
return;
}
to_writer_to :: proc(s: Stream) -> (w: Writer_To, err: Conversion_Error) {
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;
}
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) {
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;
if s.vtable != nil && s.impl_read != nil {
if s.stream_vtable != nil && s.impl_read != nil {
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) {
b.stream = s;
if s.vtable != nil {
if s.stream_vtable != nil {
if s.impl_unread_byte == nil {
err = .Missing_Procedure;
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) {
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;
if s.vtable != nil && s.impl_write != nil {
if s.stream_vtable != nil && s.impl_write != nil {
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) {
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;
if s.vtable != nil && s.impl_read != nil {
if s.stream_vtable != nil && s.impl_read != nil {
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) {
r.stream = s;
if s.vtable != nil {
if s.stream_vtable != nil {
if s.impl_unread_rune == nil {
err = .Missing_Procedure;
return;

42
core/io/io.odin
View File

@@ -58,8 +58,8 @@ Destroy_Proc :: distinct proc(using s: Stream) -> Error;
Stream :: struct {
using vtable: ^Stream_VTable,
data: rawptr,
using stream_vtable: ^Stream_VTable,
stream_data: rawptr,
}
Stream_VTable :: struct {
impl_close: Close_Proc,
@@ -113,7 +113,7 @@ Rune_Scanner :: struct {using stream: Stream};
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();
}
// 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) {
if s.vtable != nil && s.impl_read != nil {
if s.stream_vtable != nil && s.impl_read != nil {
return s->impl_read(p);
}
return 0, .Empty;
}
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 0, .Empty;
}
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 0, .Empty;
}
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();
}
// 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 {
if s.vtable != nil && s.impl_flush != nil {
if s.stream_vtable != nil && s.impl_flush != nil {
return s->impl_flush();
}
// 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 {
if s.vtable == nil {
if s.stream_vtable == nil {
return 0;
}
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) {
if r.vtable == nil {
if r.stream_vtable == nil {
return 0, .Empty;
}
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) {
if w.vtable == nil {
if w.stream_vtable == nil {
return 0, .Empty;
}
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) {
if r.vtable == nil || w.vtable == nil {
if r.stream_vtable == nil || w.stream_vtable == nil {
return 0, .Empty;
}
if r.impl_write_to != nil {
@@ -240,7 +240,7 @@ write_to :: proc(r: Reader, w: Writer) -> (n: i64, err: Error) {
return 0, .Empty;
}
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;
}
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) {
if r.vtable == nil {
if r.stream_vtable == nil {
return 0, .Empty;
}
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 {
if w.vtable == nil {
if w.stream_vtable == nil {
return .Empty;
}
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) {
if br.vtable == nil {
if br.stream_vtable == nil {
return 0, 0, .Empty;
}
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 {
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 .Empty;
}
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 .Empty;
@@ -408,7 +408,7 @@ copy_n :: proc(dst: Writer, src: Reader, n: i64) -> (written: i64, err: Error) {
@(private)
_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;
}
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 {
DEFAULT_SIZE :: 4 * 1024;
size := DEFAULT_SIZE;
if src.vtable == _limited_reader_vtable {
l := (^Limited_Reader)(src.data);
if src.stream_vtable == _limited_reader_vtable {
l := (^Limited_Reader)(src.stream_data);
if i64(size) > l.n {
if l.n < 1 {
size = 1;

24
core/io/multi.odin
View File

@@ -11,7 +11,7 @@ Multi_Reader :: struct {
@(private)
_multi_reader_vtable := &Stream_VTable{
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 {
r := mr.readers[0];
n, err = read(r, p);
@@ -29,7 +29,7 @@ _multi_reader_vtable := &Stream_VTable{
return 0, .EOF;
},
impl_destroy = proc(s: Stream) -> Error {
mr := (^Multi_Reader)(s.data);
mr := (^Multi_Reader)(s.stream_data);
context.allocator = mr.readers.allocator;
delete(mr.readers);
free(mr);
@@ -40,13 +40,13 @@ _multi_reader_vtable := &Stream_VTable{
mutlti_reader :: proc(readers: ..Reader, allocator := context.allocator) -> Reader {
context.allocator = allocator;
mr := new(Multi_Reader);
mr.vtable = _multi_reader_vtable;
mr.data = mr;
mr.stream_vtable = _multi_reader_vtable;
mr.stream_data = mr;
all_readers := make([dynamic]Reader, 0, len(readers));
for w in readers {
if w.vtable == _multi_reader_vtable {
other := (^Multi_Reader)(w.data);
if w.stream_vtable == _multi_reader_vtable {
other := (^Multi_Reader)(w.stream_data);
append(&all_readers, ..other.readers[:]);
} else {
append(&all_readers, w);
@@ -69,7 +69,7 @@ Multi_Writer :: struct {
@(private)
_multi_writer_vtable := &Stream_VTable{
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 {
n, err = write(w, p);
if err != nil {
@@ -84,7 +84,7 @@ _multi_writer_vtable := &Stream_VTable{
return len(p), nil;
},
impl_destroy = proc(s: Stream) -> Error {
mw := (^Multi_Writer)(s.data);
mw := (^Multi_Writer)(s.stream_data);
context.allocator = mw.allocator;
delete(mw.writers);
free(mw);
@@ -95,14 +95,14 @@ _multi_writer_vtable := &Stream_VTable{
mutlti_writer :: proc(writers: ..Writer, allocator := context.allocator) -> Writer {
context.allocator = allocator;
mw := new(Multi_Writer);
mw.vtable = _multi_writer_vtable;
mw.data = mw;
mw.stream_vtable = _multi_writer_vtable;
mw.stream_data = mw;
mw.allocator = allocator;
all_writers := make([dynamic]Writer, 0, len(writers));
for w in writers {
if w.vtable == _multi_writer_vtable {
other := (^Multi_Writer)(w.data);
if w.stream_vtable == _multi_writer_vtable {
other := (^Multi_Writer)(w.stream_data);
append(&all_writers, ..other.writers);
} else {
append(&all_writers, w);

18
core/io/util.odin
View File

@@ -13,7 +13,7 @@ Tee_Reader :: struct {
@(private)
_tee_reader_vtable := &Stream_VTable{
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);
if n > 0 {
if wn, werr := write(t.w, p[:n]); werr != nil {
@@ -23,7 +23,7 @@ _tee_reader_vtable := &Stream_VTable{
return;
},
impl_destroy = proc(s: Stream) -> Error {
t := (^Tee_Reader)(s.data);
t := (^Tee_Reader)(s.stream_data);
allocator := t.allocator;
free(t, allocator);
return .None;
@@ -36,8 +36,8 @@ tee_reader :: proc(r: Reader, w: Writer, allocator := context.allocator) -> Read
t := new(Tee_Reader, allocator);
t.r, t.w = r, w;
t.allocator = allocator;
t.data = t;
t.vtable = _tee_reader_vtable;
t.stream_data = t;
t.stream_vtable = _tee_reader_vtable;
res, _ := to_reader(t^);
return res;
}
@@ -56,7 +56,7 @@ Limited_Reader :: struct {
@(private)
_limited_reader_vtable := &Stream_VTable{
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 {
return 0, .EOF;
}
@@ -72,8 +72,8 @@ _limited_reader_vtable := &Stream_VTable{
new_limited_reader :: proc(r: Reader, n: i64) -> ^Limited_Reader {
l := new(Limited_Reader);
l.vtable = _limited_reader_vtable;
l.data = l;
l.stream_vtable = _limited_reader_vtable;
l.stream_data = l;
l.r = r;
l.n = n;
return l;
@@ -81,8 +81,8 @@ new_limited_reader :: proc(r: Reader, n: i64) -> ^Limited_Reader {
@(private="package")
inline_limited_reader :: proc(l: ^Limited_Reader, r: Reader, n: i64) -> Reader {
l.vtable = _limited_reader_vtable;
l.data = l;
l.stream_vtable = _limited_reader_vtable;
l.stream_data = l;
l.r = r;
l.n = n;
res, _ := to_reader(l^);

18
core/strings/builder.odin
View File

@@ -32,6 +32,24 @@ make_builder :: proc{
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,
};

22
core/strings/reader.odin
View File

@@ -11,7 +11,8 @@ Reader :: struct {
}
reader_reset :: proc(r: ^Reader, s: string) {
r.data = r;
r.stream_data = r;
r.stream_vtable = _reader_vtable;
r.s = s;
r.i = 0;
r.prev_rune = -1;
@@ -20,18 +21,17 @@ reader_reset :: proc(r: ^Reader, s: string) {
new_reader :: proc(s: string, allocator := context.allocator) -> ^Reader {
r := new(Reader, allocator);
reader_reset(r, s);
r.vtable = _reader_vtable;
return r;
}
@(private)
_reader_vtable := &io.Stream_VTable{
impl_size = proc(s: io.Stream) -> i64 {
r := (^Reader)(s.data);
r := (^Reader)(s.stream_data);
return i64(len(r.s));
},
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)) {
return 0, .EOF;
}
@@ -41,7 +41,7 @@ _reader_vtable := &io.Stream_VTable{
return;
},
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 {
return 0, .Invalid_Offset;
}
@@ -55,7 +55,7 @@ _reader_vtable := &io.Stream_VTable{
return;
},
impl_read_byte = proc(s: io.Stream) -> (byte, io.Error) {
r := (^Reader)(s.data);
r := (^Reader)(s.stream_data);
r.prev_rune = -1;
if r.i >= i64(len(r.s)) {
return 0, .EOF;
@@ -65,7 +65,7 @@ _reader_vtable := &io.Stream_VTable{
return b, nil;
},
impl_unread_byte = proc(s: io.Stream) -> io.Error {
r := (^Reader)(s.data);
r := (^Reader)(s.stream_data);
if r.i <= 0 {
return .Invalid_Unread;
}
@@ -74,7 +74,7 @@ _reader_vtable := &io.Stream_VTable{
return nil;
},
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)) {
r.prev_rune = -1;
return 0, 0, .EOF;
@@ -89,7 +89,7 @@ _reader_vtable := &io.Stream_VTable{
return;
},
impl_unread_rune = proc(s: io.Stream) -> io.Error {
r := (^Reader)(s.data);
r := (^Reader)(s.stream_data);
if r.i <= 0 {
return .Invalid_Unread;
}
@@ -101,7 +101,7 @@ _reader_vtable := &io.Stream_VTable{
return nil;
},
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;
abs: i64;
switch whence {
@@ -122,7 +122,7 @@ _reader_vtable := &io.Stream_VTable{
return abs, nil;
},
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;
if r.i >= i64(len(r.s)) {
return 0, nil;