From 80307576245aabf00285db020bbfbc4c3a891766 Mon Sep 17 00:00:00 2001
From: Graydon Hoare <graydon@mozilla.com>
Date: Tue, 27 Jul 2010 19:21:51 -0700
Subject: Switch machine-type lexemes to use suffixes. Remove support for
 foo(bar) as a cast notation. Closes #129.

---
 src/lib/map.rs | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'src/lib/map.rs')

diff --git a/src/lib/map.rs b/src/lib/map.rs
index 06139bb7..540dfd00 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -23,7 +23,7 @@ type hashmap[K, V] = obj {
 
 fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
 
-  let uint initial_capacity = uint(32); // 2^5
+  let uint initial_capacity = 32u; // 2^5
   let util.rational load_factor = rec(num=3, den=4);
 
   type bucket[V] = tag(nil(), deleted(), some(V));
@@ -43,13 +43,13 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   // fixed key.
 
   fn hashl[K](hashfn[K] hasher, uint nbkts, &K key) -> uint {
-    ret (hasher(key) >>> (sys.rustrt.size_of[uint]() * uint(8) / uint(2)))
+    ret (hasher(key) >>> (sys.rustrt.size_of[uint]() * 8u / 2u))
       % nbkts;
   }
 
   fn hashr[K](hashfn[K] hasher, uint nbkts, &K key) -> uint {
-    ret ((((~ uint(0)) >>> (sys.rustrt.size_of[uint]() * uint(8) / uint(2)))
-          & hasher(key)) * uint(2) + uint(1))
+    ret ((((~ 0u) >>> (sys.rustrt.size_of[uint]() * 8u / 2u))
+          & hasher(key)) * 2u + 1u)
       % nbkts;
   }
 
@@ -63,10 +63,10 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
                        &K key)
     -> util.option[V]
   {
-    let uint i = uint(0);
+    let uint i = 0u;
     while (i < nbkts) {
       // Pending fix to issue #94, remove uint coercion.
-      let int j = int(hash[K](hasher, nbkts, key, i));
+      let int j = (hash[K](hasher, nbkts, key, i)) as int;
       alt (bkts.(j)) {
         case (some[V](val)) {
           ret util.some[V](val);
@@ -75,7 +75,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
           ret util.none[V]();
         }
         case (deleted[V]()) {
-          i += uint(1);
+          i += 1u;
         }
       }
     }
@@ -91,17 +91,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   {
     fn insert(&K key, &V val) {
       // FIXME grow the table and rehash if we ought to.
-      let uint i = uint(0);
+      let uint i = 0u;
       while (i < nbkts) {
         // Issue #94, as in find_common()
-        let int j = int(hash[K](hasher, nbkts, key, i));
+        let int j = (hash[K](hasher, nbkts, key, i)) as int;
         alt (bkts.(j)) {
           case (some[V](_)) {
-            i += uint(1);
+            i += 1u;
           }
           case (_) {
             bkts.(j) = some[V](val);
-            nelts += uint(1);
+            nelts += 1u;
             ret;
           }
         }
@@ -129,17 +129,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
     }
 
     fn remove(&K key) -> util.option[V] {
-      let uint i = uint(0);
+      let uint i = 0u;
       while (i < nbkts) {
         // Issue #94, as in find_common()
-        let int j = int(hash[K](hasher, nbkts, key, i));
+        let int j = (hash[K](hasher, nbkts, key, i)) as int;
         alt (bkts.(j)) {
           case (some[V](val)) {
             bkts.(j) = deleted[V]();
             ret util.some[V](val);
           }
           case (deleted[V]()) {
-            nelts += uint(1);
+            nelts += 1u;
           }
           case (nil[V]()) {
             ret util.none[V]();
@@ -155,5 +155,5 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   let vec[mutable bucket[V]] bkts =
     _vec.init_elt[mutable bucket[V]](nil[V](), initial_capacity);
 
-  ret hashmap[K, V](hasher, eqer, bkts, uint(0), uint(0), load_factor);
+  ret hashmap[K, V](hasher, eqer, bkts, 0u, 0u, load_factor);
 }
-- 
cgit v1.2.3