Remove unneeded semicolons from the core library

core/io/conv.odin

@@ -1,194 +1,194 @@
 package io
 
 to_reader :: proc(s: Stream) -> (r: Reader, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_writer :: proc(s: Stream) -> (w: Writer, ok: bool = true) {
-	w.stream = s;
+	w.stream = s
 	if s.stream_vtable == nil || s.impl_write == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 
 to_closer :: proc(s: Stream) -> (c: Closer, ok: bool = true) {
-	c.stream = s;
+	c.stream = s
 	if s.stream_vtable == nil || s.impl_close == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_flusher :: proc(s: Stream) -> (f: Flusher, ok: bool = true) {
-	f.stream = s;
+	f.stream = s
 	if s.stream_vtable == nil || s.impl_flush == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_seeker :: proc(s: Stream) -> (seeker: Seeker, ok: bool = true) {
-	seeker.stream = s;
+	seeker.stream = s
 	if s.stream_vtable == nil || s.impl_seek == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 
 to_read_writer :: proc(s: Stream) -> (r: Read_Writer, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_read_closer :: proc(s: Stream) -> (r: Read_Closer, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_close == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_read_write_closer :: proc(s: Stream) -> (r: Read_Write_Closer, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_close == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_read_write_seeker :: proc(s: Stream) -> (r: Read_Write_Seeker, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_seek == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_write_flusher :: proc(s: Stream) -> (w: Write_Flusher, ok: bool = true) {
-	w.stream = s;
+	w.stream = s
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, ok: bool = true) {
-	w.stream = s;
+	w.stream = s
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil || s.impl_close == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 
 to_reader_at :: proc(s: Stream) -> (r: Reader_At, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read_at == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_writer_at :: proc(s: Stream) -> (w: Writer_At, ok: bool = true) {
-	w.stream = s;
+	w.stream = s
 	if s.stream_vtable == nil || s.impl_write_at == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_reader_from :: proc(s: Stream) -> (r: Reader_From, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read_from == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_writer_to :: proc(s: Stream) -> (w: Writer_To, ok: bool = true) {
-	w.stream = s;
+	w.stream = s
 	if s.stream_vtable == nil || s.impl_write_to == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_write_closer :: proc(s: Stream) -> (w: Write_Closer, ok: bool = true) {
-	w.stream = s;
+	w.stream = s
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_close == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 to_write_seeker :: proc(s: Stream) -> (w: Write_Seeker, ok: bool = true) {
-	w.stream = s;
+	w.stream = s
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_seek == nil {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }
 
 
 to_byte_reader :: proc(s: Stream) -> (b: Byte_Reader, ok: bool = true) {
-	b.stream = s;
+	b.stream = s
 	if s.stream_vtable == nil || s.impl_read_byte == nil {
-		ok = false;
+		ok = false
 		if s.stream_vtable != nil && s.impl_read != nil {
-			ok = true;
+			ok = true
 		}
 	}
-	return;
+	return
 }
 to_byte_scanner :: proc(s: Stream) -> (b: Byte_Scanner, ok: bool = true) {
-	b.stream = s;
+	b.stream = s
 	if s.stream_vtable != nil {
 		if s.impl_unread_byte == nil {
-			ok = false;
-			return;
+			ok = false
+			return
 		}
 		if s.impl_read_byte != nil {
-			ok = true;
+			ok = true
 		} else if s.impl_read != nil {
-			ok = true;
+			ok = true
 		} else {
-			ok = false;
+			ok = false
 		}
 	}
-	return;
+	return
 }
 to_byte_writer :: proc(s: Stream) -> (b: Byte_Writer, ok: bool = true) {
-	b.stream = s;
+	b.stream = s
 	if s.stream_vtable == nil || s.impl_write_byte == nil {
-		ok = false;
+		ok = false
 		if s.stream_vtable != nil && s.impl_write != nil {
-			ok = true;
+			ok = true
 		}
 	}
-	return;
+	return
 }
 
 to_rune_reader :: proc(s: Stream) -> (r: Rune_Reader, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable == nil || s.impl_read_rune == nil {
-		ok = false;
+		ok = false
 		if s.stream_vtable != nil && s.impl_read != nil {
-			ok = true;
+			ok = true
 		}
 	}
-	return;
+	return
 
 }
 to_rune_scanner :: proc(s: Stream) -> (r: Rune_Scanner, ok: bool = true) {
-	r.stream = s;
+	r.stream = s
 	if s.stream_vtable != nil {
 		if s.impl_unread_rune == nil {
-			ok = false;
-			return;
+			ok = false
+			return
 		}
 		if s.impl_read_rune != nil {
-			ok = true;
+			ok = true
 		} else if s.impl_read != nil {
-			ok = true;
+			ok = true
 		} else {
-			ok = false;
+			ok = false
 		}
 	} else {
-		ok = false;
+		ok = false
 	}
-	return;
+	return
 }

core/io/io.odin

@@ -50,23 +50,23 @@ Error :: enum i32 {
 	Empty = -1,
 }
 
-Close_Proc       :: proc(using s: Stream) -> Error;
-Flush_Proc       :: proc(using s: Stream) -> Error;
-Seek_Proc        :: proc(using s: Stream, offset: i64, whence: Seek_From) -> (n: i64, err: Error);
-Size_Proc        :: proc(using s: Stream) -> i64;
-Read_Proc        :: proc(using s: Stream, p: []byte) -> (n: int, err: Error);
-Read_At_Proc     :: proc(using s: Stream, p: []byte, off: i64) -> (n: int, err: Error);
-Read_From_Proc   :: proc(using s: Stream, r: Reader) -> (n: i64, err: Error);
-Read_Byte_Proc   :: proc(using s: Stream) -> (byte, Error);
-Read_Rune_Proc   :: proc(using s: Stream) -> (ch: rune, size: int, err: Error);
-Unread_Byte_Proc :: proc(using s: Stream) -> Error;
-Unread_Rune_Proc :: proc(using s: Stream) -> Error;
-Write_Proc       :: proc(using s: Stream, p: []byte) -> (n: int, err: Error);
-Write_At_Proc    :: proc(using s: Stream, p: []byte, off: i64) -> (n: int, err: Error);
-Write_To_Proc    :: proc(using s: Stream, w: Writer) -> (n: i64, err: Error);
-Write_Byte_Proc  :: proc(using s: Stream, c: byte) -> Error;
-Write_Rune_Proc  :: proc(using s: Stream, r: rune) -> (size: int, err: Error);
-Destroy_Proc     :: proc(using s: Stream) -> Error;
+Close_Proc       :: proc(using s: Stream) -> Error
+Flush_Proc       :: proc(using s: Stream) -> Error
+Seek_Proc        :: proc(using s: Stream, offset: i64, whence: Seek_From) -> (n: i64, err: Error)
+Size_Proc        :: proc(using s: Stream) -> i64
+Read_Proc        :: proc(using s: Stream, p: []byte) -> (n: int, err: Error)
+Read_At_Proc     :: proc(using s: Stream, p: []byte, off: i64) -> (n: int, err: Error)
+Read_From_Proc   :: proc(using s: Stream, r: Reader) -> (n: i64, err: Error)
+Read_Byte_Proc   :: proc(using s: Stream) -> (byte, Error)
+Read_Rune_Proc   :: proc(using s: Stream) -> (ch: rune, size: int, err: Error)
+Unread_Byte_Proc :: proc(using s: Stream) -> Error
+Unread_Rune_Proc :: proc(using s: Stream) -> Error
+Write_Proc       :: proc(using s: Stream, p: []byte) -> (n: int, err: Error)
+Write_At_Proc    :: proc(using s: Stream, p: []byte, off: i64) -> (n: int, err: Error)
+Write_To_Proc    :: proc(using s: Stream, w: Writer) -> (n: i64, err: Error)
+Write_Byte_Proc  :: proc(using s: Stream, c: byte) -> Error
+Write_Rune_Proc  :: proc(using s: Stream, r: rune) -> (size: int, err: Error)
+Destroy_Proc     :: proc(using s: Stream) -> Error
 
 
 Stream :: struct {
@@ -99,109 +99,109 @@ Stream_VTable :: struct {
 }
 
 
-Reader             :: struct {using stream: Stream};
-Writer             :: struct {using stream: Stream};
-Closer             :: struct {using stream: Stream};
-Flusher            :: struct {using stream: Stream};
-Seeker             :: struct {using stream: Stream};
+Reader             :: struct {using stream: Stream}
+Writer             :: struct {using stream: Stream}
+Closer             :: struct {using stream: Stream}
+Flusher            :: struct {using stream: Stream}
+Seeker             :: struct {using stream: Stream}
 
-Read_Writer        :: struct {using stream: Stream};
-Read_Closer        :: struct {using stream: Stream};
-Read_Write_Closer  :: struct {using stream: Stream};
-Read_Write_Seeker  :: struct {using stream: Stream};
+Read_Writer        :: struct {using stream: Stream}
+Read_Closer        :: struct {using stream: Stream}
+Read_Write_Closer  :: struct {using stream: Stream}
+Read_Write_Seeker  :: struct {using stream: Stream}
 
-Write_Closer       :: struct {using stream: Stream};
-Write_Seeker       :: struct {using stream: Stream};
-Write_Flusher      :: struct {using stream: Stream};
-Write_Flush_Closer :: struct {using stream: Stream};
+Write_Closer       :: struct {using stream: Stream}
+Write_Seeker       :: struct {using stream: Stream}
+Write_Flusher      :: struct {using stream: Stream}
+Write_Flush_Closer :: struct {using stream: Stream}
 
-Reader_At          :: struct {using stream: Stream};
-Writer_At          :: struct {using stream: Stream};
-Reader_From        :: struct {using stream: Stream};
-Writer_To          :: struct {using stream: Stream};
+Reader_At          :: struct {using stream: Stream}
+Writer_At          :: struct {using stream: Stream}
+Reader_From        :: struct {using stream: Stream}
+Writer_To          :: struct {using stream: Stream}
 
-Byte_Reader        :: struct {using stream: Stream};
-Byte_Scanner       :: struct {using stream: Stream};
-Byte_Writer        :: struct {using stream: Stream};
+Byte_Reader        :: struct {using stream: Stream}
+Byte_Scanner       :: struct {using stream: Stream}
+Byte_Writer        :: struct {using stream: Stream}
 
-Rune_Reader        :: struct {using stream: Stream};
-Rune_Scanner       :: struct {using stream: Stream};
+Rune_Reader        :: struct {using stream: Stream}
+Rune_Scanner       :: struct {using stream: Stream}
 
 
 destroy :: proc(s: Stream) -> Error {
-	close_err := close({s});
+	close_err := close({s})
 	if s.stream_vtable != nil && s.impl_destroy != nil {
-		return s->impl_destroy();
+		return s->impl_destroy()
 	}
 	if close_err != .None {
-		return close_err;
+		return close_err
 	}
-	return .Empty;
+	return .Empty
 }
 
 read :: proc(s: Reader, p: []byte) -> (n: int, err: Error) {
 	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) {
 	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) {
 	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) -> Error {
 	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
-	return .None;
+	return .None
 }
 
 flush :: proc(s: Flusher) -> Error {
 	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
-	return .None;
+	return .None
 }
 
 size :: proc(s: Stream) -> i64 {
 	if s.stream_vtable == nil {
-		return 0;
+		return 0
 	}
 	if s.impl_size != nil {
-		return s->impl_size();
+		return s->impl_size()
 	}
 	if s.impl_seek == nil {
-		return 0;
+		return 0
 	}
 
-	curr, end: i64;
-	err: Error;
+	curr, end: i64
+	err: Error
 	if curr, err = s->impl_seek(0, .Current); err != nil {
-		return 0;
+		return 0
 	}
 
 	if end, err = s->impl_seek(0, .End); err != nil {
-		return 0;
+		return 0
 	}
 
 	if _, err = s->impl_seek(curr, .Start); err != nil {
-		return 0;
+		return 0
 	}
 
-	return end;
+	return end
 }
 
 
@@ -209,225 +209,225 @@ size :: proc(s: Stream) -> i64 {
 
 read_at :: proc(r: Reader_At, p: []byte, offset: i64) -> (n: int, err: Error) {
 	if r.stream_vtable == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 	if r.impl_read_at != nil {
-		return r->impl_read_at(p, offset);
+		return r->impl_read_at(p, offset)
 	}
 	if r.impl_seek == nil || r.impl_read == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 
-	curr_offset: i64;
-	curr_offset, err = r->impl_seek(offset, .Current);
+	curr_offset: i64
+	curr_offset, err = r->impl_seek(offset, .Current)
 	if err != nil {
-		return 0, err;
+		return 0, err
 	}
 
-	n, err = r->impl_read(p);
-	_, err1 := r->impl_seek(curr_offset, .Start);
+	n, err = r->impl_read(p)
+	_, err1 := r->impl_seek(curr_offset, .Start)
 	if err1 != nil && err == nil {
-		err = err1;
+		err = err1
 	}
-	return;
+	return
 
 }
 
 write_at :: proc(w: Writer_At, p: []byte, offset: i64) -> (n: int, err: Error) {
 	if w.stream_vtable == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 	if w.impl_write_at != nil {
-		return w->impl_write_at(p, offset);
+		return w->impl_write_at(p, offset)
 	}
 	if w.impl_seek == nil || w.impl_write == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 
-	curr_offset: i64;
-	curr_offset, err = w->impl_seek(offset, .Current);
+	curr_offset: i64
+	curr_offset, err = w->impl_seek(offset, .Current)
 	if err != nil {
-		return 0, err;
+		return 0, err
 	}
 
-	n, err = w->impl_write(p);
-	_, err1 := w->impl_seek(curr_offset, .Start);
+	n, err = w->impl_write(p)
+	_, err1 := w->impl_seek(curr_offset, .Start)
 	if err1 != nil && err == nil {
-		err = err1;
+		err = err1
 	}
-	return;
+	return
 }
 
 write_to :: proc(r: Writer_To, w: Writer) -> (n: i64, err: Error) {
 	if r.stream_vtable == nil || w.stream_vtable == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 	if r.impl_write_to != nil {
-		return r->impl_write_to(w);
+		return r->impl_write_to(w)
 	}
-	return 0, .Empty;
+	return 0, .Empty
 }
 read_from :: proc(w: Reader_From, r: Reader) -> (n: i64, err: Error) {
 	if r.stream_vtable == nil || w.stream_vtable == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 	if r.impl_read_from != nil {
-		return w->impl_read_from(r);
+		return w->impl_read_from(r)
 	}
-	return 0, .Empty;
+	return 0, .Empty
 }
 
 
 read_byte :: proc(r: Byte_Reader) -> (byte, Error) {
 	if r.stream_vtable == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 	if r.impl_read_byte != nil {
-		return r->impl_read_byte();
+		return r->impl_read_byte()
 	}
 	if r.impl_read == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 
-	b: [1]byte;
-	_, err := r->impl_read(b[:]);
-	return b[0], err;
+	b: [1]byte
+	_, err := r->impl_read(b[:])
+	return b[0], err
 }
 
 write_byte :: proc{
 	write_byte_to_byte_writer,
 	write_byte_to_writer,
-};
+}
 
 write_byte_to_byte_writer :: proc(w: Byte_Writer, c: byte) -> Error {
-	return _write_byte(w, c);
+	return _write_byte(w, c)
 }
 
 write_byte_to_writer :: proc(w: Writer, c: byte) -> Error {
-	return _write_byte(auto_cast w, c);
+	return _write_byte(auto_cast w, c)
 }
 
 @(private)
 _write_byte :: proc(w: Byte_Writer, c: byte) -> Error {
 	if w.stream_vtable == nil {
-		return .Empty;
+		return .Empty
 	}
 	if w.impl_write_byte != nil {
-		return w->impl_write_byte(c);
+		return w->impl_write_byte(c)
 	}
 	if w.impl_write == nil {
-		return .Empty;
+		return .Empty
 	}
 
-	b := [1]byte{c};
-	_, err := w->impl_write(b[:]);
-	return err;
+	b := [1]byte{c}
+	_, err := w->impl_write(b[:])
+	return err
 }
 
 read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
 	if br.stream_vtable == nil {
-		return 0, 0, .Empty;
+		return 0, 0, .Empty
 	}
 	if br.impl_read_rune != nil {
-		return br->impl_read_rune();
+		return br->impl_read_rune()
 	}
 	if br.impl_read == nil {
-		return 0, 0, .Empty;
+		return 0, 0, .Empty
 	}
 
-	b: [utf8.UTF_MAX]byte;
-	_, err = br->impl_read(b[:1]);
+	b: [utf8.UTF_MAX]byte
+	_, err = br->impl_read(b[:1])
 
-	s0 := b[0];
-	ch = rune(s0);
-	size = 1;
+	s0 := b[0]
+	ch = rune(s0)
+	size = 1
 	if err != nil {
-		return;
+		return
 	}
 	if ch < utf8.RUNE_SELF {
-		return;
+		return
 	}
-	x := utf8.accept_sizes[s0];
+	x := utf8.accept_sizes[s0]
 	if x >= 0xf0 {
-		mask := rune(x) << 31 >> 31;
-		ch = ch &~ mask | utf8.RUNE_ERROR&mask;
-		return;
+		mask := rune(x) << 31 >> 31
+		ch = ch &~ mask | utf8.RUNE_ERROR&mask
+		return
 	}
-	sz := int(x&7);
-	n: int;
-	n, err = br->impl_read(b[1:sz]);
+	sz := int(x&7)
+	n: int
+	n, err = br->impl_read(b[1:sz])
 	if err != nil || n+1 < sz {
-		ch = utf8.RUNE_ERROR;
-		return;
+		ch = utf8.RUNE_ERROR
+		return
 	}
 
-	ch, size = utf8.decode_rune(b[:sz]);
-	return;
+	ch, size = utf8.decode_rune(b[:sz])
+	return
 }
 
 unread_byte :: proc(s: Byte_Scanner) -> Error {
 	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 {
 	if s.stream_vtable != nil && s.impl_unread_rune != nil {
-		return s->impl_unread_rune();
+		return s->impl_unread_rune()
 	}
-	return .Empty;
+	return .Empty
 }
 
 
 write_string :: proc(s: Writer, str: string) -> (n: int, err: Error) {
-	return write(s, transmute([]byte)str);
+	return write(s, transmute([]byte)str)
 }
 
 write_rune :: proc(s: Writer, r: rune) -> (size: int, err: Error) {
 	if s.stream_vtable != nil && s.impl_write_rune != nil {
-		return s->impl_write_rune(r);
+		return s->impl_write_rune(r)
 	}
 
 	if r < utf8.RUNE_SELF {
-		err = write_byte(s, byte(r));
+		err = write_byte(s, byte(r))
 		if err == nil {
-			size = 1;
+			size = 1
 		}
-		return;
+		return
 	}
-	buf, w := utf8.encode_rune(r);
-	return write(s, buf[:w]);
+	buf, w := utf8.encode_rune(r)
+	return write(s, buf[:w])
 }
 
 
 
 read_full :: proc(r: Reader, buf: []byte) -> (n: int, err: Error) {
-	return read_at_least(r, buf, len(buf));
+	return read_at_least(r, buf, len(buf))
 }
 
 
 read_at_least :: proc(r: Reader, buf: []byte, min: int) -> (n: int, err: Error) {
 	if len(buf) < min {
-		return 0, .Short_Buffer;
+		return 0, .Short_Buffer
 	}
 	for n < min && err == nil {
-		nn: int;
-		nn, err = read(r, buf[n:]);
-		n += n;
+		nn: int
+		nn, err = read(r, buf[n:])
+		n += n
 	}
 
 	if n >= min {
-		err = nil;
+		err = nil
 	} else if n > 0 && err == .EOF {
-		err = .Unexpected_EOF;
+		err = .Unexpected_EOF
 	}
-	return;
+	return
 }
 
 // copy copies from src to dst till either EOF is reached on src or an error occurs
 // It returns the number of bytes copied and the first error that occurred whilst copying, if any.
 copy :: proc(dst: Writer, src: Reader) -> (written: i64, err: Error) {
-	return _copy_buffer(dst, src, nil);
+	return _copy_buffer(dst, src, nil)
 }
 
 // copy_buffer is the same as copy except that it stages through the provided buffer (if one is required)
@@ -435,9 +435,9 @@ copy :: proc(dst: Writer, src: Reader) -> (written: i64, err: Error) {
 // If buf is `nil`, it is allocate through `intrinsics.alloca`; otherwise if it has zero length, it will panic
 copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, err: Error) {
 	if buf != nil && len(buf) == 0 {
-		panic("empty buffer in io.copy_buffer");
+		panic("empty buffer in io.copy_buffer")
 	}
-	return _copy_buffer(dst, src, buf);
+	return _copy_buffer(dst, src, buf)
 }
 
 
@@ -446,69 +446,69 @@ copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, err
 // It returns the number of bytes copied and the first error that occurred whilst copying, if any.
 // On return, written == n IFF err == nil
 copy_n :: proc(dst: Writer, src: Reader, n: i64) -> (written: i64, err: Error) {
-	nsrc := limited_reader_init(&Limited_Reader{}, src, n);
-	written, err = copy(dst, nsrc);
+	nsrc := limited_reader_init(&Limited_Reader{}, src, n)
+	written, err = copy(dst, nsrc)
 	if written == n {
-		return n, nil;
+		return n, nil
 	}
 	if written < n && err == nil {
 		// src stopped early and must have been an EOF
-		err = .EOF;
+		err = .EOF
 	}
-	return;
+	return
 }
 
 
 @(private)
 _copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, err: Error) {
 	if dst.stream_vtable == nil || src.stream_vtable == nil {
-		return 0, .Empty;
+		return 0, .Empty
 	}
 	if src.impl_write_to != nil {
-		return src->impl_write_to(dst);
+		return src->impl_write_to(dst)
 	}
 	if src.impl_read_from != nil {
-		return dst->impl_read_from(src);
+		return dst->impl_read_from(src)
 	}
-	buf := buf;
+	buf := buf
 	if buf == nil {
-		DEFAULT_SIZE :: 4 * 1024;
-		size := DEFAULT_SIZE;
+		DEFAULT_SIZE :: 4 * 1024
+		size := DEFAULT_SIZE
 		if src.stream_vtable == _limited_reader_vtable {
-			l := (^Limited_Reader)(src.stream_data);
+			l := (^Limited_Reader)(src.stream_data)
 			if i64(size) > l.n {
 				if l.n < 1 {
-					size = 1;
+					size = 1
 				} else {
-					size = int(l.n);
+					size = int(l.n)
 				}
 			}
 		}
 		// NOTE(bill): alloca is fine here
-		buf = transmute([]byte)runtime.Raw_Slice{intrinsics.alloca(size, 2*align_of(rawptr)), size};
+		buf = transmute([]byte)runtime.Raw_Slice{intrinsics.alloca(size, 2*align_of(rawptr)), size}
 	}
 	for {
-		nr, er := read(src, buf);
+		nr, er := read(src, buf)
 		if nr > 0 {
-			nw, ew := write(dst, buf[0:nr]);
+			nw, ew := write(dst, buf[0:nr])
 			if nw > 0 {
-				written += i64(nw);
+				written += i64(nw)
 			}
 			if ew != nil {
-				err = ew;
-				break;
+				err = ew
+				break
 			}
 			if nr != nw {
-				err = .Short_Write;
-				break;
+				err = .Short_Write
+				break
 			}
 		}
 		if er != nil {
 			if er != .EOF {
-				err = er;
+				err = er
 			}
-			break;
+			break
 		}
 	}
-	return;
+	return
 }

core/io/multi.odin

@@ -7,46 +7,46 @@ Multi_Reader :: struct {
 @(private)
 _multi_reader_vtable := &Stream_VTable{
 	impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
-		mr := (^Multi_Reader)(s.stream_data);
+		mr := (^Multi_Reader)(s.stream_data)
 		for len(mr.readers) > 0 {
-			r := mr.readers[0];
-			n, err = read(r, p);
+			r := mr.readers[0]
+			n, err = read(r, p)
 			if err == .EOF {
-				ordered_remove(&mr.readers, 0);
+				ordered_remove(&mr.readers, 0)
 			}
 			if n > 0 || err != .EOF {
 				if err == .EOF && len(mr.readers) > 0 {
 					// Don't return EOF yet, more readers remain
-					err = nil;
+					err = nil
 				}
-				return;
+				return
 			}
 		}
-		return 0, .EOF;
+		return 0, .EOF
 	},
-};
+}
 
 multi_reader_init :: proc(mr: ^Multi_Reader, readers: ..Reader, allocator := context.allocator) -> (r: Reader) {
-	all_readers := make([dynamic]Reader, 0, len(readers), allocator);
+	all_readers := make([dynamic]Reader, 0, len(readers), allocator)
 
 	for w in readers {
 		if w.stream_vtable == _multi_reader_vtable {
-			other := (^Multi_Reader)(w.stream_data);
-			append(&all_readers, ..other.readers[:]);
+			other := (^Multi_Reader)(w.stream_data)
+			append(&all_readers, ..other.readers[:])
 		} else {
-			append(&all_readers, w);
+			append(&all_readers, w)
 		}
 	}
 
-	mr.readers = all_readers;
+	mr.readers = all_readers
 
-	r.stream_vtable = _multi_reader_vtable;
-	r.stream_data = mr;
-	return;
+	r.stream_vtable = _multi_reader_vtable
+	r.stream_data = mr
+	return
 }
 
 multi_reader_destroy :: proc(mr: ^Multi_Reader) {
-	delete(mr.readers);
+	delete(mr.readers)
 }
 
 
@@ -57,39 +57,39 @@ Multi_Writer :: struct {
 @(private)
 _multi_writer_vtable := &Stream_VTable{
 	impl_write = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
-		mw := (^Multi_Writer)(s.stream_data);
+		mw := (^Multi_Writer)(s.stream_data)
 		for w in mw.writers {
-			n, err = write(w, p);
+			n, err = write(w, p)
 			if err != nil {
-				return;
+				return
 			}
 			if n != len(p) {
-				err = .Short_Write;
-				return;
+				err = .Short_Write
+				return
 			}
 		}
 
-		return len(p), nil;
+		return len(p), nil
 	},
-};
+}
 
 multi_writer_init :: proc(mw: ^Multi_Writer, writers: ..Writer, allocator := context.allocator) -> (out: Writer) {
-	mw.writers = make([dynamic]Writer, 0, len(writers), allocator);
+	mw.writers = make([dynamic]Writer, 0, len(writers), allocator)
 
 	for w in writers {
 		if w.stream_vtable == _multi_writer_vtable {
-			other := (^Multi_Writer)(w.stream_data);
-			append(&mw.writers, ..other.writers[:]);
+			other := (^Multi_Writer)(w.stream_data)
+			append(&mw.writers, ..other.writers[:])
 		} else {
-			append(&mw.writers, w);
+			append(&mw.writers, w)
 		}
 	}
 
-	out.stream_vtable = _multi_writer_vtable;
-	out.stream_data = mw;
-	return;
+	out.stream_vtable = _multi_writer_vtable
+	out.stream_data = mw
+	return
 }
 
 multi_writer_destroy :: proc(mw: ^Multi_Writer) {
-	delete(mw.writers);
+	delete(mw.writers)
 }

core/io/util.odin

@@ -5,37 +5,37 @@ import "core:strconv"
 
 
 read_ptr :: proc(r: Reader, p: rawptr, byte_size: int) -> (n: int, err: Error) {
-	return read(r, mem.byte_slice(p, byte_size));
+	return read(r, mem.byte_slice(p, byte_size))
 }
 
 write_ptr :: proc(w: Writer, p: rawptr, byte_size: int) -> (n: int, err: Error) {
-	return write(w, mem.byte_slice(p, byte_size));
+	return write(w, mem.byte_slice(p, byte_size))
 }
 
 read_ptr_at :: proc(r: Reader_At, p: rawptr, byte_size: int, offset: i64) -> (n: int, err: Error) {
-	return read_at(r, mem.byte_slice(p, byte_size), offset);
+	return read_at(r, mem.byte_slice(p, byte_size), offset)
 }
 
 write_ptr_at :: proc(w: Writer_At, p: rawptr, byte_size: int, offset: i64) -> (n: int, err: Error) {
-	return write_at(w, mem.byte_slice(p, byte_size), offset);
+	return write_at(w, mem.byte_slice(p, byte_size), offset)
 }
 
 write_u64 :: proc(w: Writer, i: u64, base: int = 10) -> (n: int, err: Error) {
-	buf: [32]byte;
-	s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil);
-	return write_string(w, s);
+	buf: [32]byte
+	s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil)
+	return write_string(w, s)
 }
 write_i64 :: proc(w: Writer, i: i64, base: int = 10) -> (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);
+	buf: [32]byte
+	s := strconv.append_bits(buf[:], u64(i), base, true, 64, strconv.digits, nil)
+	return write_string(w, s)
 }
 
 write_uint :: proc(w: Writer, i: uint, base: int = 10) -> (n: int, err: Error) {
-	return write_u64(w, u64(i), base);
+	return write_u64(w, u64(i), base)
 }
 write_int :: proc(w: Writer, i: int, base: int = 10) -> (n: int, err: Error) {
-	return write_i64(w, i64(i), base);
+	return write_i64(w, i64(i), base)
 }
 
 Tee_Reader :: struct {
@@ -46,16 +46,16 @@ Tee_Reader :: struct {
 @(private)
 _tee_reader_vtable := &Stream_VTable{
 	impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
-		t := (^Tee_Reader)(s.stream_data);
-		n, err = read(t.r, p);
+		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 {
-				return wn, werr;
+				return wn, werr
 			}
 		}
-		return;
+		return
 	},
-};
+}
 
 // tee_reader_init returns a Reader that writes to 'w' what it reads from 'r'
 // All reads from 'r' performed through it are matched with a corresponding write to 'w'
@@ -64,14 +64,14 @@ _tee_reader_vtable := &Stream_VTable{
 // Any error encountered whilst writing is reported as a 'read' error
 // tee_reader_init must call io.destroy when done with
 tee_reader_init :: proc(t: ^Tee_Reader, r: Reader, w: Writer, allocator := context.allocator) -> Reader {
-	t.r, t.w = r, w;
-	return tee_reader_to_reader(t);
+	t.r, t.w = r, w
+	return tee_reader_to_reader(t)
 }
 
 tee_reader_to_reader :: proc(t: ^Tee_Reader) -> (r: Reader) {
-	r.stream_data = t;
-	r.stream_vtable = _tee_reader_vtable;
-	return;
+	r.stream_data = t
+	r.stream_vtable = _tee_reader_vtable
+	return
 }
 
 
@@ -86,30 +86,30 @@ Limited_Reader :: struct {
 @(private)
 _limited_reader_vtable := &Stream_VTable{
 	impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
-		l := (^Limited_Reader)(s.stream_data);
+		l := (^Limited_Reader)(s.stream_data)
 		if l.n <= 0 {
-			return 0, .EOF;
+			return 0, .EOF
 		}
-		p := p;
+		p := p
 		if i64(len(p)) > l.n {
-			p = p[0:l.n];
+			p = p[0:l.n]
 		}
-		n, err = read(l.r, p);
-		l.n -= i64(n);
-		return;
+		n, err = read(l.r, p)
+		l.n -= i64(n)
+		return
 	},
-};
+}
 
 limited_reader_init :: proc(l: ^Limited_Reader, r: Reader, n: i64) -> Reader {
-	l.r = r;
-	l.n = n;
-	return limited_reader_to_reader(l);
+	l.r = r
+	l.n = n
+	return limited_reader_to_reader(l)
 }
 
 limited_reader_to_reader :: proc(l: ^Limited_Reader) -> (r: Reader) {
-	r.stream_vtable = _limited_reader_vtable;
-	r.stream_data = l;
-	return;
+	r.stream_vtable = _limited_reader_vtable
+	r.stream_data = l
+	return
 }
 
 // Section_Reader implements read, seek, and read_at on a section of an underlying Reader_At
@@ -121,74 +121,74 @@ Section_Reader :: struct {
 }
 
 section_reader_init :: proc(s: ^Section_Reader, r: Reader_At, off: i64, n: i64) {
-	s.r = r;
-	s.off = off;
-	s.limit = off + n;
-	return;
+	s.r = r
+	s.off = off
+	s.limit = off + n
+	return
 }
 section_reader_to_stream :: proc(s: ^Section_Reader) -> (out: Stream) {
-	out.stream_data = s;
-	out.stream_vtable = _section_reader_vtable;
-	return;
+	out.stream_data = s
+	out.stream_vtable = _section_reader_vtable
+	return
 }
 
 @(private)
 _section_reader_vtable := &Stream_VTable{
 	impl_read = proc(stream: Stream, p: []byte) -> (n: int, err: Error) {
-		s := (^Section_Reader)(stream.stream_data);
+		s := (^Section_Reader)(stream.stream_data)
 		if s.off >= s.limit {
-			return 0, .EOF;
+			return 0, .EOF
 		}
-		p := p;
+		p := p
 		if max := s.limit - s.off; i64(len(p)) > max {
-			p = p[0:max];
+			p = p[0:max]
 		}
-		n, err = read_at(s.r, p, s.off);
-		s.off += i64(n);
-		return;
+		n, err = read_at(s.r, p, s.off)
+		s.off += i64(n)
+		return
 	},
 	impl_read_at = proc(stream: Stream, p: []byte, off: i64) -> (n: int, err: Error) {
-		s := (^Section_Reader)(stream.stream_data);
-		p, off := p, off;
+		s := (^Section_Reader)(stream.stream_data)
+		p, off := p, off
 
 		if off < 0 || off >= s.limit - s.base {
-			return 0, .EOF;
+			return 0, .EOF
 		}
-		off += s.base;
+		off += s.base
 		if max := s.limit - off; i64(len(p)) > max {
-			p = p[0:max];
-			n, err = read_at(s.r, p, off);
+			p = p[0:max]
+			n, err = read_at(s.r, p, off)
 			if err == nil {
-				err = .EOF;
+				err = .EOF
 			}
-			return;
+			return
 		}
-		return read_at(s.r, p, off);
+		return read_at(s.r, p, off)
 	},
 	impl_seek = proc(stream: Stream, offset: i64, whence: Seek_From) -> (n: i64, err: Error) {
-		s := (^Section_Reader)(stream.stream_data);
+		s := (^Section_Reader)(stream.stream_data)
 
-		offset := offset;
+		offset := offset
 		switch whence {
 		case:
-			return 0, .Invalid_Whence;
+			return 0, .Invalid_Whence
 		case .Start:
-			offset += s.base;
+			offset += s.base
 		case .Current:
-			offset += s.off;
+			offset += s.off
 		case .End:
-			offset += s.limit;
+			offset += s.limit
 		}
 		if offset < s.base {
-			return 0, .Invalid_Offset;
+			return 0, .Invalid_Offset
 		}
-		s.off = offset;
-		n = offset - s.base;
-		return;
+		s.off = offset
+		n = offset - s.base
+		return
 	},
 	impl_size = proc(stream: Stream) -> i64 {
-		s := (^Section_Reader)(stream.stream_data);
-		return s.limit - s.base;
+		s := (^Section_Reader)(stream.stream_data)
+		return s.limit - s.base
 	},
-};
+}