Rename stream field names

core/io/conv.odin

@@ -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;

core/io/io.odin

@@ -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;

core/io/multi.odin

@@ -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);

core/io/util.odin

@@ -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^);

core/strings/builder.odin

@@ -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,
+};
+
 
 
 

core/strings/reader.odin

@@ -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;