aboutsummaryrefslogtreecommitdiff
path: root/src/lib
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib')
-rw-r--r--src/lib/_int.rs12
-rw-r--r--src/lib/_io.rs10
-rw-r--r--src/lib/_u8.rs2
-rw-r--r--src/lib/_vec.rs10
-rw-r--r--src/lib/deque.rs44
-rw-r--r--src/lib/map.rs30
6 files changed, 54 insertions, 54 deletions
diff --git a/src/lib/_int.rs b/src/lib/_int.rs
index b6399669..29144a82 100644
--- a/src/lib/_int.rs
+++ b/src/lib/_int.rs
@@ -23,19 +23,19 @@ iter range(mutable int lo, int hi) -> int {
iter urange(mutable uint lo, uint hi) -> uint {
while (lo < hi) {
put lo;
- lo += uint(1);
+ lo += 1u;
}
}
fn next_power_of_two(uint n) -> uint {
// FIXME change |* uint(4)| below to |* uint(8) / uint(2)| and watch the
// world explode.
- let uint halfbits = sys.rustrt.size_of[uint]() * uint(4);
- let uint tmp = n - uint(1);
- let uint shift = uint(1);
+ let uint halfbits = sys.rustrt.size_of[uint]() * 4u;
+ let uint tmp = n - 1u;
+ let uint shift = 1u;
while (shift <= halfbits) {
tmp |= tmp >> shift;
- shift <<= uint(1);
+ shift <<= 1u;
}
- ret tmp + uint(1);
+ ret tmp + 1u;
}
diff --git a/src/lib/_io.rs b/src/lib/_io.rs
index e171e617..94021aa6 100644
--- a/src/lib/_io.rs
+++ b/src/lib/_io.rs
@@ -3,15 +3,15 @@ type buf_reader = unsafe obj {
};
fn default_bufsz() -> uint {
- ret uint(4096);
+ ret 4096u;
}
fn new_buf() -> vec[u8] {
let vec[u8] v = vec();
let uint i = default_bufsz();
- while (i > uint(0)) {
- i -= uint(1);
- v += vec(u8(0));
+ while (i > 0u) {
+ i -= 1u;
+ v += vec(0u8);
}
// FIXME (issue #93): should be:
// ret _vec.alloc[u8](default_bufsz());
@@ -25,7 +25,7 @@ fn new_buf_reader(str s) -> buf_reader {
fn read() -> vec[u8] {
// Ensure our buf is singly-referenced.
- if (_vec.rustrt.refcount[u8](buf) != uint(1)) {
+ if (_vec.rustrt.refcount[u8](buf) != 1u) {
buf = new_buf();
}
diff --git a/src/lib/_u8.rs b/src/lib/_u8.rs
index e1f671e7..7749e30e 100644
--- a/src/lib/_u8.rs
+++ b/src/lib/_u8.rs
@@ -14,7 +14,7 @@ fn gt(u8 x, u8 y) -> bool { ret x > y; }
iter range(mutable u8 lo, u8 hi) -> u8 {
while (lo < hi) {
put lo;
- lo += u8(1);
+ lo += 1u8;
}
}
diff --git a/src/lib/_vec.rs b/src/lib/_vec.rs
index 849e750a..0008295f 100644
--- a/src/lib/_vec.rs
+++ b/src/lib/_vec.rs
@@ -21,8 +21,8 @@ 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 = n_elts;
- while (i > uint(0)) {
- i -= uint(1);
+ while (i > 0u) {
+ i -= 1u;
v += vec(op(i));
}
ret v;
@@ -38,8 +38,8 @@ fn init_elt[T](&T t, uint n_elts) -> vec[T] {
*/
let vec[T] v = alloc[T](n_elts);
let uint i = n_elts;
- while (i > uint(0)) {
- i -= uint(1);
+ while (i > 0u) {
+ i -= 1u;
v += vec(t);
}
ret v;
@@ -59,7 +59,7 @@ fn slice[T](vec[T] v, int start, int end) -> vec[T] {
check(start <= end);
// FIXME #108: This doesn't work yet.
//check(end <= int(len[T](v)));
- auto result = alloc[T](uint(end - start));
+ auto result = alloc[T]((end - start) as uint);
let mutable int i = start;
while (i < end) {
result += vec(v.(i));
diff --git a/src/lib/deque.rs b/src/lib/deque.rs
index b41c051f..699b3f0d 100644
--- a/src/lib/deque.rs
+++ b/src/lib/deque.rs
@@ -23,7 +23,7 @@ fn create[T]() -> t[T] {
type cell[T] = mutable util.option[T];
- let uint initial_capacity = uint(32); // 2^5
+ let uint initial_capacity = 32u; // 2^5
/**
* Grow is only called on full elts, so nelts is also len(elts), unlike
@@ -34,13 +34,13 @@ 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.(int((lo + i) % nelts));
+ ret old.(((lo + i) % nelts) as int);
} else {
ret util.none[T]();
}
}
- let uint nalloc = _int.next_power_of_two(nelts + uint(1));
+ let uint nalloc = _int.next_power_of_two(nelts + 1u);
let _vec.init_op[cell[T]] copy_op = bind fill[T](_, nelts, lo, elts);
ret _vec.init_fn[cell[T]](copy_op, nalloc);
}
@@ -52,7 +52,7 @@ fn create[T]() -> t[T] {
*/
fn get[T](&vec[cell[T]] elts, uint i) -> T {
- alt (elts.(int(i))) {
+ alt (elts.(i as int)) {
case (util.some[T](t)) { ret t; }
case (_) { fail; }
}
@@ -68,33 +68,33 @@ fn create[T]() -> t[T] {
fn add_front(&T t) {
let uint oldlo = lo;
- if (lo == uint(0)) {
- lo = _vec.len[cell[T]](elts) - uint(1);
+ if (lo == 0u) {
+ lo = _vec.len[cell[T]](elts) - 1u;
} else {
- lo -= uint(1);
+ lo -= 1u;
}
if (lo == hi) {
elts = grow[T](nelts, oldlo, elts);
- lo = _vec.len[cell[T]](elts) - uint(1);
- hi = nelts - uint(1);
+ lo = _vec.len[cell[T]](elts) - 1u;
+ hi = nelts - 1u;
}
- elts.(int(lo)) = util.some[T](t);
- nelts += uint(1);
+ elts.(lo as int) = util.some[T](t);
+ nelts += 1u;
}
fn add_back(&T t) {
- hi = (hi + uint(1)) % _vec.len[cell[T]](elts);
+ hi = (hi + 1u) % _vec.len[cell[T]](elts);
if (lo == hi) {
elts = grow[T](nelts, lo, elts);
- lo = uint(0);
+ lo = 0u;
hi = nelts;
}
- elts.(int(hi)) = util.some[T](t);
- nelts += uint(1);
+ elts.(hi as int) = util.some[T](t);
+ nelts += 1u;
}
/**
@@ -103,19 +103,19 @@ fn create[T]() -> t[T] {
*/
fn pop_front() -> T {
let T t = get[T](elts, lo);
- elts.(int(lo)) = util.none[T]();
- lo = (lo + uint(1)) % _vec.len[cell[T]](elts);
+ elts.(lo as int) = util.none[T]();
+ lo = (lo + 1u) % _vec.len[cell[T]](elts);
ret t;
}
fn pop_back() -> T {
let T t = get[T](elts, hi);
- elts.(int(hi)) = util.none[T]();
+ elts.(hi as int) = util.none[T]();
- if (hi == uint(0)) {
- hi = _vec.len[cell[T]](elts) - uint(1);
+ if (hi == 0u) {
+ hi = _vec.len[cell[T]](elts) - 1u;
} else {
- hi -= uint(1);
+ hi -= 1u;
}
ret t;
@@ -133,5 +133,5 @@ fn create[T]() -> t[T] {
let vec[cell[T]] v = _vec.init_elt[cell[T]](util.none[T](),
initial_capacity);
- ret deque[T](uint(0), uint(0), uint(0), v);
+ ret deque[T](0u, 0u, 0u, v);
}
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);
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-11 11:24:54 +0000