Reformat standard library; no code changes.

1 files changed, 75 insertions, 66 deletions

diff --git a/src/lib/_vec.rs b/src/lib/_vec.rs
index 39dc8617..55020684 100644
--- a/src/lib/_vec.rs
+++ b/src/lib/_vec.rs
@@ -2,114 +2,123 @@ import vbuf = rustrt.vbuf;
 import op = util.operator;
 
 native "rust" mod rustrt {
-  type vbuf;
+    type vbuf;
 
-  fn vec_buf[T](vec[T] v, uint offset) -> vbuf;
+    fn vec_buf[T](vec[T] v, uint offset) -> vbuf;
 
-  fn vec_len[T](vec[T] v) -> uint;
-  /**
-   * 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);
+    fn vec_len[T](vec[T] v) -> uint;
+    /**
+     * 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].
-   */
-  fn vec_alloc[T, U](uint n_elts) -> vec[U];
+    /**
+     * 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].
+     */
+    fn vec_alloc[T, U](uint n_elts) -> vec[U];
 
-  fn refcount[T](vec[T] v) -> uint;
+    fn refcount[T](vec[T] v) -> uint;
 
-  fn vec_print_debug_info[T](vec[T] v);
+    fn vec_print_debug_info[T](vec[T] v);
 }
 
 fn alloc[T](uint n_elts) -> vec[T] {
-  ret rustrt.vec_alloc[vec[T], T](n_elts);
+    ret rustrt.vec_alloc[vec[T], T](n_elts);
 }
 
 fn refcount[T](vec[T] v) -> uint {
-  // -1 because calling this function incremented the refcount.
-  ret rustrt.refcount[T](v) - 1u;
+    // -1 because calling this function incremented the refcount.
+    ret rustrt.refcount[T](v) - 1u;
 }
 
 type init_op[T] = fn(uint i) -> T;
 
 fn init_fn[T](&init_op[T] op, uint n_elts) -> vec[T] {
-  let vec[T] v = alloc[T](n_elts);
-  let uint i = 0u;
-  while (i < n_elts) {
-    v += vec(op(i));
-    i += 1u;
-  }
-  ret v;
+    let vec[T] v = alloc[T](n_elts);
+    let uint i = 0u;
+    while (i < n_elts) {
+        v += vec(op(i));
+        i += 1u;
+    }
+    ret v;
 }
 
 fn init_elt[T](&T t, uint n_elts) -> vec[T] {
-  /**
-   * FIXME (issue #81): should be:
-   *
-   * fn elt_op[T](&T x, uint i) -> T { ret x; }
-   * let init_op[T] inner = bind elt_op[T](t, _);
-   * ret init_fn[T](inner, n_elts);
-   */
-  let vec[T] v = alloc[T](n_elts);
-  let uint i = n_elts;
-  while (i > 0u) {
-    i -= 1u;
-    v += vec(t);
-  }
-  ret v;
+    /**
+     * FIXME (issue #81): should be:
+     *
+     * fn elt_op[T](&T x, uint i) -> T { ret x; }
+     * let init_op[T] inner = bind elt_op[T](t, _);
+     * ret init_fn[T](inner, n_elts);
+     */
+    let vec[T] v = alloc[T](n_elts);
+    let uint i = n_elts;
+    while (i > 0u) {
+        i -= 1u;
+        v += vec(t);
+    }
+    ret v;
 }
 
 fn buf[T](vec[T] v) -> vbuf {
-  ret rustrt.vec_buf[T](v, 0u);
+    ret rustrt.vec_buf[T](v, 0u);
 }
 
 fn len[T](vec[T] v) -> uint {
-  ret rustrt.vec_len[T](v);
+    ret rustrt.vec_len[T](v);
 }
 
 fn len_set[T](vec[T] v, uint n) {
-  rustrt.vec_len_set[T](v, n);
+    rustrt.vec_len_set[T](v, n);
 }
 
 fn buf_off[T](vec[T] v, uint offset) -> vbuf {
-  check (offset < len[T](v));
-  ret rustrt.vec_buf[T](v, offset);
+    check (offset < len[T](v));
+    ret rustrt.vec_buf[T](v, offset);
 }
 
 fn print_debug_info[T](vec[T] v) {
-  rustrt.vec_print_debug_info[T](v);
+    rustrt.vec_print_debug_info[T](v);
 }
 
 // Returns elements from [start..end) from v.
 fn slice[T](vec[T] v, int start, int end) -> vec[T] {
-  check (0 <= start);
-  check (start <= end);
-  check (end <= (len[T](v) as int));
-  auto result = alloc[T]((end - start) as uint);
-  let int i = start;
-  while (i < end) {
-    result += vec(v.(i));
-    i += 1;
-  }
-  ret result;
+    check (0 <= start);
+    check (start <= end);
+    check (end <= (len[T](v) as int));
+    auto result = alloc[T]((end - start) as uint);
+    let int i = start;
+    while (i < end) {
+        result += vec(v.(i));
+        i += 1;
+    }
+    ret result;
 }
 
 fn grow[T](&mutable vec[T] v, int n, &T initval) {
-  let int i = n;
-  while (i > 0) {
-    i -= 1;
-    v += vec(initval);
-  }
+    let int i = n;
+    while (i > 0) {
+        i -= 1;
+        v += vec(initval);
+    }
 }
 
 fn map[T, U](&op[T,U] f, &vec[T] v) -> vec[U] {
-  let vec[U] u = alloc[U](len[T](v));
-  for (T ve in v) {
-    u += vec(f(ve));
-  }
-  ret u;
+    let vec[U] u = alloc[U](len[T](v));
+    for (T ve in v) {
+        u += vec(f(ve));
+    }
+    ret u;
 }
+
+// Local Variables:
+// mode: rust;
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End: