Make _io.buf_reader read more than 0 bytes at a time.

3 files changed, 46 insertions, 9 deletions

diff --git a/src/lib/_io.rs b/src/lib/_io.rs
index a7feba2fc5a..5583815fd59 100644
--- a/src/lib/_io.rs
+++ b/src/lib/_io.rs
@@ -48,7 +48,7 @@ fn new_buf_reader(str path) -> buf_reader {
         buf = new_buf();
       }
 
-      auto len = _vec.len[u8](buf);
+      auto len = default_bufsz();
       auto vbuf = _vec.buf[u8](buf);
       auto count = os.libc.read(fd, vbuf, len);
 
@@ -56,9 +56,10 @@ fn new_buf_reader(str path) -> buf_reader {
         log "error filling buffer";
         log sys.rustrt.last_os_error();
         fail;
-      } else {
-        ret buf;
       }
+
+      _vec.len_set[u8](buf, count as uint);
+      ret buf;
     }
 
     drop {
diff --git a/src/lib/_vec.rs b/src/lib/_vec.rs
index 509737d519c..5f1d2baaeb4 100644
--- a/src/lib/_vec.rs
+++ b/src/lib/_vec.rs
@@ -3,13 +3,25 @@ import op = util.operator;
 
 native "rust" mod rustrt {
   type vbuf;
+
   fn vec_buf[T](vec[T] v, uint offset) -> vbuf;
+
   fn vec_len[T](vec[T] v) -> uint;
-  /* The T in vec_alloc[T, U] is the type of the vec to allocate.  The
+  /**
+   * Sometimes we modify the vec internal data via vec_buf and need to update
+   * the vec's fill length accordingly.
+   */
+  fn vec_len_set[T](vec[T] v, uint n);
+
+  /**
+   * The T in vec_alloc[T, U] is the type of the vec to allocate.  The
    * U is the type of an element in the vec.  So to allocate a vec[U] we
-   * want to invoke this as vec_alloc[vec[U], U]. */
+   * want to invoke this as vec_alloc[vec[U], U].
+   */
   fn vec_alloc[T, U](uint n_elts) -> vec[U];
+
   fn refcount[T](vec[T] v) -> uint;
+
   fn vec_print_debug_info[T](vec[T] v);
 }
 
@@ -46,12 +58,16 @@ fn init_elt[T](&T t, uint n_elts) -> vec[T] {
   ret v;
 }
 
+fn buf[T](vec[T] v) -> vbuf {
+  ret rustrt.vec_buf[T](v, 0u);
+}
+
 fn len[T](vec[T] v) -> uint {
   ret rustrt.vec_len[T](v);
 }
 
-fn buf[T](vec[T] v) -> vbuf {
-  ret rustrt.vec_buf[T](v, 0u);
+fn len_set[T](vec[T] v, uint n) {
+  rustrt.vec_len_set[T](v, n);
 }
 
 fn buf_off[T](vec[T] v, uint offset) -> vbuf {
diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp
index 276ea5582d0..d2bad054014 100644
--- a/src/rt/rust_builtin.cpp
+++ b/src/rt/rust_builtin.cpp
@@ -109,14 +109,34 @@ vec_len(rust_task *task, type_desc *ty, rust_vec *v)
 }
 
 extern "C" CDECL void
+vec_len_set(rust_task *task, type_desc *ty, rust_vec *v, size_t len)
+{
+    task->log(rust_log::STDLIB,
+              "vec_len_set(0x%" PRIxPTR ", %" PRIdPTR ") on vec with "
+              "alloc = %" PRIdPTR
+              ", fill = %" PRIdPTR
+              ", len = %" PRIdPTR
+              ".  New fill is %" PRIdPTR,
+              v, len, v->alloc, v->fill, v->fill / ty->size, len * ty->size);
+    v->fill = len * ty->size;
+}
+
+extern "C" CDECL void
 vec_print_debug_info(rust_task *task, type_desc *ty, rust_vec *v)
 {
     task->log(rust_log::STDLIB,
               "vec_print_debug_info(0x%" PRIxPTR ")"
               " with tydesc 0x%" PRIxPTR
               " (size = %" PRIdPTR ", align = %" PRIdPTR ")"
-              " alloc = %" PRIdPTR ", fill = %" PRIdPTR
-              " , data = ...", v, ty, ty->size, ty->align, v->alloc, v->fill);
+              " alloc = %" PRIdPTR ", fill = %" PRIdPTR ", len = %" PRIdPTR
+              " , data = ...",
+              v,
+              ty,
+              ty->size,
+              ty->align,
+              v->alloc,
+              v->fill,
+              v->fill / ty->size);
 
     for (size_t i = 0; i < v->fill; ++i) {
         task->log(rust_log::STDLIB,