Merge branch 'master' of git://github.com/graydon/rust

Conflicts:
	src/boot/fe/ast.ml

5 files changed, 102 insertions, 24 deletions

diff --git a/src/lib/_int.rs b/src/lib/_int.rs
index 9b756675..e76c2bf5 100644
--- a/src/lib/_int.rs
+++ b/src/lib/_int.rs
@@ -44,3 +44,47 @@ fn next_power_of_two(uint n) -> uint {
   }
   ret tmp + 1u;
 }
+
+fn uto_str(mutable uint n, uint radix) -> str
+{
+  check (0u < radix && radix <= 16u);
+  fn digit(uint n) -> str {
+    alt (n) {
+      case (0u) { ret "0"; }
+      case (1u) { ret "1"; }
+      case (2u) { ret "2"; }
+      case (3u) { ret "3"; }
+      case (4u) { ret "4"; }
+      case (5u) { ret "5"; }
+      case (6u) { ret "6"; }
+      case (7u) { ret "7"; }
+      case (8u) { ret "8"; }
+      case (9u) { ret "9"; }
+      case (10u) { ret "a"; }
+      case (11u) { ret "b"; }
+      case (12u) { ret "c"; }
+      case (13u) { ret "d"; }
+      case (14u) { ret "e"; }
+      case (15u) { ret "f"; }
+    }
+  }
+
+  if (n == 0u) { ret "0"; }
+
+  let str s = "";
+  while (n > 0u) {
+    s = digit(n % radix) + s;
+    n /= radix;
+  }
+  ret s;
+}
+
+fn to_str(mutable int n, uint radix) -> str
+{
+  check (0u < radix && radix <= 16u);
+  if (n < 0) {
+    ret "-" + uto_str((-n) as uint, radix);
+  } else {
+    ret uto_str(n as uint, radix);
+  }
+}
diff --git a/src/lib/_io.rs b/src/lib/_io.rs
index 142f808a..93d06d41 100644
--- a/src/lib/_io.rs
+++ b/src/lib/_io.rs
@@ -1,3 +1,7 @@
+import std.os;
+import std._str;
+import std._vec;
+
 type buf_reader = unsafe obj {
   fn read() -> vec[u8];
 };
@@ -107,3 +111,22 @@ fn new_buf_writer(str path, vec[fileflag] flags) -> buf_writer {
   }
   ret fd_buf_writer(fd);
 }
+
+type writer =
+  unsafe obj {
+    fn write_str(str s);
+    fn write_int(int n);
+    fn write_uint(uint n);
+  };
+
+fn file_writer(str path,
+               vec[fileflag] flags)
+  -> writer
+{
+  unsafe obj fw(buf_writer out) {
+    fn write_str(str s)   { out.write(_str.bytes(s)); }
+    fn write_int(int n)   { out.write(_str.bytes(_int.to_str(n, 10u))); }
+    fn write_uint(uint n) { out.write(_str.bytes(_int.uto_str(n, 10u))); }
+  }
+  ret fw(new_buf_writer(path, flags));
+}
diff --git a/src/lib/_str.rs b/src/lib/_str.rs
index 062d8bf1..a607c7d5 100644
--- a/src/lib/_str.rs
+++ b/src/lib/_str.rs
@@ -3,7 +3,7 @@ import rustrt.sbuf;
 native "rust" mod rustrt {
   type sbuf;
   fn str_buf(str s) -> sbuf;
-  fn str_len(str s) -> uint;
+  fn str_byte_len(str s) -> uint;
   fn str_alloc(uint n_bytes) -> str;
   fn refcount[T](str s) -> uint;
 }
@@ -12,14 +12,37 @@ fn is_utf8(vec[u8] v) -> bool {
   fail; // FIXME
 }
 
+fn is_ascii(str s) -> bool {
+  let uint i = byte_len(s);
+  while (i > 0u) {
+    i -= 1u;
+    if ((s.(i) & 0x80u8) != 0u8) {
+      ret false;
+    }
+  }
+  ret true;
+}
+
 fn alloc(uint n_bytes) -> str {
   ret rustrt.str_alloc(n_bytes);
 }
 
-fn len(str s) -> uint {
-  ret rustrt.str_len(s);
+// Returns the number of bytes (a.k.a. UTF-8 code units) in s.
+// Contrast with a function that would return the number of code
+// points (char's), combining character sequences, words, etc.  See
+// http://icu-project.org/apiref/icu4c/classBreakIterator.html for a
+// way to implement those.
+fn byte_len(str s) -> uint {
+  ret rustrt.str_byte_len(s);
 }
 
 fn buf(str s) -> sbuf {
   ret rustrt.str_buf(s);
 }
+
+fn bytes(&str s) -> vec[u8] {
+  fn ith(str s, uint i) -> u8 {
+    ret s.(i);
+  }
+  ret _vec.init_fn[u8](bind ith(s, _), _str.byte_len(s));
+}
diff --git a/src/lib/deque.rs b/src/lib/deque.rs
index bd42d7cb..bf7acb53 100644
--- a/src/lib/deque.rs
+++ b/src/lib/deque.rs
@@ -36,7 +36,7 @@ fn create[T]() -> t[T] {
 
     fn fill[T](uint i, uint nelts, uint lo, &vec[cell[T]] old) -> cell[T] {
       if (i < nelts) {
-        ret old.(((lo + i) % nelts) as int);
+        ret old.((lo + i) % nelts);
       } else {
         ret util.none[T]();
       }
@@ -47,14 +47,8 @@ fn create[T]() -> t[T] {
     ret _vec.init_fn[cell[T]](copy_op, nalloc);
   }
 
-  /**
-   * FIXME (issue #94): We're converting to int every time we index into the
-   * vec, but we really want to index with the lo and hi uints that we have
-   * around.
-   */
-
   fn get[T](&vec[cell[T]] elts, uint i) -> T {
-    alt (elts.(i as int)) {
+    alt (elts.(i)) {
       case (util.some[T](t)) { ret t; }
       case (_) { fail; }
     }
@@ -82,7 +76,7 @@ fn create[T]() -> t[T] {
         hi = nelts;
       }
 
-      elts.(lo as int) = util.some[T](t);
+      elts.(lo) = util.some[T](t);
       nelts += 1u;
     }
 
@@ -93,7 +87,7 @@ fn create[T]() -> t[T] {
         hi = nelts;
       }
 
-      elts.(hi as int) = util.some[T](t);
+      elts.(hi) = util.some[T](t);
       hi = (hi + 1u) % _vec.len[cell[T]](elts);
       nelts += 1u;
     }
@@ -104,7 +98,7 @@ fn create[T]() -> t[T] {
      */
     fn pop_front() -> T {
       let T t = get[T](elts, lo);
-      elts.(lo as int) = util.none[T]();
+      elts.(lo) = util.none[T]();
       lo = (lo + 1u) % _vec.len[cell[T]](elts);
       ret t;
     }
@@ -117,7 +111,7 @@ fn create[T]() -> t[T] {
       }
 
       let T t = get[T](elts, hi);
-      elts.(hi as int) = util.none[T]();
+      elts.(hi) = util.none[T]();
       ret t;
     }
 
diff --git a/src/lib/map.rs b/src/lib/map.rs
index f9574176..ff7b4411 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -75,8 +75,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   {
     let uint i = 0u;
     while (i < nbkts) {
-      // FIXME (issue #94): as in find_common()
-      let int j = (hash[K](hasher, nbkts, key, i)) as int;
+      let uint j = (hash[K](hasher, nbkts, key, i));
       alt (bkts.(j)) {
         case (some[K, V](k, _)) {
           if (eqer(key, k)) {
@@ -103,8 +102,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   {
     let uint i = 0u;
     while (i < nbkts) {
-      // FIXME (issue #94):  Pending bugfix, remove uint coercion.
-      let int j = (hash[K](hasher, nbkts, key, i)) as int;
+      let uint j = (hash[K](hasher, nbkts, key, i));
       alt (bkts.(j)) {
         case (some[K, V](k, v)) {
           if (eqer(key, k)) {
@@ -149,9 +147,6 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
       if (!util.rational_leq(load, lf)) {
         let uint nnewbkts = _int.next_power_of_two(nbkts + 1u);
 
-        // FIXME (issue #94):  Enforce our workaround to issue #94.
-        check ((nnewbkts as int) > 0);
-
         let vec[mutable bucket[K, V]] newbkts = make_buckets[K, V](nnewbkts);
         rehash[K, V](hasher, eqer, bkts, nbkts, newbkts, nnewbkts);
       }
@@ -183,8 +178,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
     fn remove(&K key) -> util.option[V] {
       let uint i = 0u;
       while (i < nbkts) {
-        // FIXME (issue #94): as in find_common()
-        let int j = (hash[K](hasher, nbkts, key, i)) as int;
+        let uint j = (hash[K](hasher, nbkts, key, i));
         alt (bkts.(j)) {
           case (some[K, V](_, val)) {
             bkts.(j) = deleted[K, V]();