let nelems = nbits/uint_bits +
if nbits % uint_bits == 0 {0} else {1};
let elem = if init {!0} else {0};
- let s = cast_to_mut(from_elem(nelems, elem));
+ let s = from_elem(nelems, elem);
Big(~BigBitv(move s))
};
Bitv {rep: move rep, nbits: nbits}
Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
}
Big(ref b) => {
- let st = cast_to_mut(from_elem(self.nbits / uint_bits + 1, 0));
+ let mut st = from_elem(self.nbits / uint_bits + 1, 0);
let len = st.len();
for uint::range(0, len) |i| { st[i] = b.storage[i]; };
Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: move st})}
fn rehash() {
let n_old_chains = self.chains.len();
let n_new_chains: uint = uint::next_power_of_two(n_old_chains+1u);
- let new_chains = chains(n_new_chains);
+ let mut new_chains = chains(n_new_chains);
for self.each_entry |entry| {
let idx = entry.hash % n_new_chains;
entry.next = new_chains[idx];
}
fn chains<K,V>(nchains: uint) -> ~[Option<@Entry<K,V>>] {
- vec::cast_to_mut(vec::from_elem(nchains, None))
+ vec::from_elem(nchains, None)
}
pub fn mk<K:Eq IterBytes Hash, V: Copy>() -> T<K,V> {
}
pub fn start(node: @Node) -> T {
- let stack = vec::cast_to_mut(
- vec::from_elem(height(node)+1u, node));
+ let stack = vec::from_elem(height(node)+1u, node);
T {
stack: stack,
stackpos: 0,
/// Construct a `sha` object
pub fn sha1() -> Sha1 {
type Sha1State =
- {h: ~[u32],
+ {h: ~[mut u32],
mut len_low: u32,
mut len_high: u32,
- mut msg_block: ~[u8],
+ msg_block: ~[mut u8],
mut msg_block_idx: uint,
mut computed: bool,
- work_buf: @~[u32]};
+ work_buf: @~[mut u32]};
fn add_input(st: &Sha1State, msg: &[const u8]) {
assert (!st.computed);
for num_condvars.times {
queues.push(new_waitqueue());
}
- new_sem(count, vec::cast_to_mut(move queues))
+ new_sem(count, queues)
}
#[doc(hidden)]