Reformat standard library; no code changes.

src/lib/_int.rs

@@ -34,3 +34,12 @@ fn to_str(mutable int n, uint radix) -> str
         ret _uint.to_str(n as uint, radix);
     }
 }
+
+// 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:

src/lib/_str.rs

@@ -216,6 +216,7 @@ fn connect(vec[str] v, str sep) -> str {
 // 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:

src/lib/_task.rs

@@ -10,3 +10,12 @@ native "rust" mod rustrt {
 fn sleep(uint time_in_us) {
     ret rustrt.task_sleep(time_in_us);
 }
+
+// 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:

src/lib/_u8.rs

@@ -18,3 +18,11 @@ iter range(mutable u8 lo, u8 hi) -> u8 {
     }
 }
 
+// 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:

src/lib/_uint.rs

@@ -84,3 +84,12 @@ fn to_str(mutable uint n, uint radix) -> str
 
     ret s;
 }
+
+// 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:

src/lib/_vec.rs

@@ -8,8 +8,8 @@ native "rust" mod rustrt {
 
     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.
+     * 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);
 
@@ -113,3 +113,12 @@ fn map[T, U](&op[T,U] f, &vec[T] v) -> vec[U] {
     }
     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:

src/lib/dbg.rs

@@ -57,3 +57,12 @@ fn debug_fn[T](&T x) {
 fn ptr_cast[T, U](@T x) -> @U {
     ret rustrt.debug_ptrcast[T, U](x);
 }
+
+// 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:

src/lib/deque.rs

@@ -34,7 +34,8 @@ fn create[T]() -> t[T] {
     fn grow[T](uint nelts, uint lo, vec[cell[T]] elts) -> vec[cell[T]] {
         check (nelts == _vec.len[cell[T]](elts));
 
-    fn fill[T](uint i, uint nelts, uint lo, &vec[cell[T]] old) -> cell[T] {
+        fn fill[T](uint i, uint nelts, uint lo,
+                   &vec[cell[T]] old) -> cell[T] {
             if (i < nelts) {
                 ret old.((lo + i) % nelts);
             } else {
@@ -93,8 +94,8 @@ fn create[T]() -> t[T] {
             }
 
             /**
-     * We actually release (turn to none()) the T we're popping so that we
-     * don't keep anyone's refcount up unexpectedly.
+             * We actually release (turn to none()) the T we're popping so
+             * that we don't keep anyone's refcount up unexpectedly.
              */
             fn pop_front() -> T {
                 let T t = get[T](elts, lo);
@@ -136,3 +137,12 @@ fn create[T]() -> t[T] {
 
     ret deque[T](0u, 0u, 0u, v);
 }
+
+// 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:

src/lib/linux_os.rs

@@ -38,3 +38,13 @@ mod libc_constants {
     fn S_IRUSR() -> uint { ret 0x0100u; }
     fn S_IWUSR() -> uint { ret 0x0080u; }
 }
+
+
+// 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:

src/lib/macos_os.rs

@@ -38,3 +38,12 @@ mod libc_constants {
     fn S_IRUSR() -> uint { ret 0x0400u; }
     fn S_IWUSR() -> uint { ret 0x0200u; }
 }
+
+// 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:

src/lib/map.rs

@@ -132,7 +132,8 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
             for (bucket[K, V] b in oldbkts) {
                 alt (b) {
                     case (some[K, V](?k, ?v)) {
-          insert_common[K, V](hasher, eqer, newbkts, nnewbkts, k, v);
+                        insert_common[K, V](hasher, eqer, newbkts,
+                                            nnewbkts, k, v);
                     }
                     case (_) { }
                 }
@@ -149,16 +150,20 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
             fn size() -> uint { ret nelts; }
 
             fn insert(&K key, &V val) -> bool {
-      let util.rational load = rec(num=(nelts + 1u) as int, den=nbkts as int);
+                let util.rational load = rec(num=(nelts + 1u) as int,
+                                             den=nbkts as int);
                 if (!util.rational_leq(load, lf)) {
                     let uint nnewbkts = _uint.next_power_of_two(nbkts + 1u);
-        let vec[mutable bucket[K, V]] newbkts = make_buckets[K, V](nnewbkts);
-        rehash[K, V](hasher, eqer, bkts, nbkts, newbkts, nnewbkts);
+                    let vec[mutable bucket[K, V]] newbkts =
+                        make_buckets[K, V](nnewbkts);
+                    rehash[K, V](hasher, eqer, bkts, nbkts,
+                                 newbkts, nnewbkts);
                     bkts = newbkts;
                     nbkts = nnewbkts;
                 }
 
-      if (insert_common[K, V](hasher, eqer, bkts, nbkts, key, val)) {
+                if (insert_common[K, V](hasher, eqer, bkts,
+                                        nbkts, key, val)) {
                     nelts += 1u;
                     ret true;
                 }
@@ -206,13 +211,25 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
             }
 
             fn rehash() {
-      let vec[mutable bucket[K, V]] newbkts = make_buckets[K, V](nbkts);
+                let vec[mutable bucket[K, V]] newbkts =
+                    make_buckets[K, V](nbkts);
                 rehash[K, V](hasher, eqer, bkts, nbkts, newbkts, nbkts);
                 bkts = newbkts;
             }
         }
 
-  let vec[mutable bucket[K, V]] bkts = make_buckets[K, V](initial_capacity);
+    let vec[mutable bucket[K, V]] bkts =
+        make_buckets[K, V](initial_capacity);
 
     ret hashmap[K, V](hasher, eqer, bkts, initial_capacity, 0u, load_factor);
 }
+
+
+// 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:

src/lib/rand.rs

@@ -23,3 +23,12 @@ fn mk_rng() -> rng {
 
     ret rt_rng(rustrt.rand_new());
 }
+
+// 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:

src/lib/std.rc

@@ -52,3 +52,12 @@ mod map;
 mod deque;
 mod rand;
 mod dbg;
+
+// 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:

src/lib/sys.rs

@@ -20,3 +20,11 @@ native "rust" mod rustrt {
     fn unsupervise();
 }
 
+// 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:

src/lib/util.rs

@@ -28,3 +28,12 @@ fn rational_leq(&rational x, &rational y) -> bool {
     // NB: Uses the fact that rationals have positive denominators WLOG.
     ret x.num * y.den <= y.num * x.den;
 }
+
+// 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:

src/lib/win32_os.rs

@@ -28,3 +28,12 @@ mod libc_constants {
     fn S_IRUSR() -> uint { ret 0x0100u; } // really _S_IREAD  in win32
     fn S_IWUSR() -> uint { ret 0x0080u; } // really _S_IWRITE in win32
 }
+
+// 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: