From c3377032f8bcc01b9f283292f198a02b5d9040c0 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Sun, 18 Jan 2015 12:16:01 -0600 Subject: [PATCH] Many syntax changes for rustc, incomplete --- src/blockdata/block.rs | 12 +- src/blockdata/blockchain.rs | 12 +- src/blockdata/constants.rs | 2 +- src/blockdata/opcodes.rs | 16 +- src/blockdata/script.rs | 312 +++++++++++++++---------------- src/blockdata/transaction.rs | 32 ++-- src/blockdata/utxoset.rs | 66 +++---- src/internal_macros.rs | 40 ++-- src/lib.rs | 11 +- src/macros.rs | 16 +- src/network/address.rs | 4 +- src/network/constants.rs | 12 +- src/network/encodable.rs | 72 +++---- src/network/listener.rs | 4 +- src/network/message.rs | 4 +- src/network/message_blockdata.rs | 6 +- src/network/message_network.rs | 2 +- src/network/socket.rs | 2 +- src/util/base58.rs | 26 +-- src/util/error.rs | 2 +- src/util/hash.rs | 135 ++++++------- src/util/iter.rs | 2 +- src/util/misc.rs | 6 +- src/util/mod.rs | 8 +- src/util/patricia_tree.rs | 104 +++++------ src/util/thinvec.rs | 72 +++---- src/util/uint.rs | 104 +++++------ src/wallet/address.rs | 25 ++- src/wallet/address_index.rs | 58 +++++- src/wallet/bip32.rs | 46 ++--- src/wallet/wallet.rs | 10 +- 31 files changed, 621 insertions(+), 602 deletions(-) diff --git a/src/blockdata/block.rs b/src/blockdata/block.rs index 2687c5a9..fe3ffd98 100644 --- a/src/blockdata/block.rs +++ b/src/blockdata/block.rs @@ -79,7 +79,7 @@ impl BlockHeader { let (mant, expt) = { let unshifted_expt = self.bits >> 24; if unshifted_expt <= 3 { - ((self.bits & 0xFFFFFF) >> 8 * (3 - unshifted_expt as uint), 0) + ((self.bits & 0xFFFFFF) >> 8 * (3 - unshifted_expt as usize), 0) } else { (self.bits & 0xFFFFFF, 8 * ((self.bits >> 24) - 3)) } @@ -89,7 +89,7 @@ impl BlockHeader { if mant > 0x7FFFFF { Zero::zero() } else { - from_u64::(mant as u64).unwrap() << (expt as uint) + from_u64::(mant as u64).unwrap() << (expt as usize) } } @@ -130,10 +130,10 @@ impl BitcoinHash for Block { } } -impl_consensus_encoding!(BlockHeader, version, prev_blockhash, merkle_root, time, bits, nonce) -impl_json!(BlockHeader, version, prev_blockhash, merkle_root, time, bits, nonce) -impl_consensus_encoding!(Block, header, txdata) -impl_consensus_encoding!(LoneBlockHeader, header, tx_count) +impl_consensus_encoding!(BlockHeader, version, prev_blockhash, merkle_root, time, bits, nonce); +impl_json!(BlockHeader, version, prev_blockhash, merkle_root, time, bits, nonce); +impl_consensus_encoding!(Block, header, txdata); +impl_consensus_encoding!(LoneBlockHeader, header, tx_count); #[cfg(test)] mod tests { diff --git a/src/blockdata/blockchain.rs b/src/blockdata/blockchain.rs index c73ef6f5..f4614b62 100644 --- a/src/blockdata/blockchain.rs +++ b/src/blockdata/blockchain.rs @@ -193,8 +193,8 @@ impl, E> ConsensusDecodable for Blockchain { // with a ContravariantLifetime marker tying it to the tree's lifetime. struct LocatorHashIter { index: NodePtr, - count: uint, - skip: uint + count: usize, + skip: usize } impl LocatorHashIter { @@ -341,7 +341,7 @@ impl Blockchain { pub fn new(network: Network) -> Blockchain { let genesis = genesis_block(network); let genhash = genesis.header.bitcoin_hash(); - let new_node = box BlockchainNode { + let new_node = Box::new(BlockchainNode { total_work: Zero::zero(), required_difficulty: genesis.header.target(), block: genesis, @@ -349,7 +349,7 @@ impl Blockchain { has_txdata: true, prev: RawPtr::null(), next: RawPtr::null() - }; + }); let raw_ptr = &*new_node as NodePtr; Blockchain { network: network, @@ -490,7 +490,7 @@ impl Blockchain { unsafe { (*prev).required_difficulty } }; // Create node - let ret = box BlockchainNode { + let ret = Box::new(BlockchainNode { total_work: block.header.work().add(unsafe { &(*prev).total_work }), block: block, required_difficulty: difficulty, @@ -498,7 +498,7 @@ impl Blockchain { has_txdata: has_txdata, prev: prev, next: RawPtr::null() - }; + }); unsafe { let prev = prev as *mut BlockchainNode; (*prev).next = &*ret as NodePtr; diff --git a/src/blockdata/constants.rs b/src/blockdata/constants.rs index 28464008..ce574de0 100644 --- a/src/blockdata/constants.rs +++ b/src/blockdata/constants.rs @@ -39,7 +39,7 @@ pub static DIFFCHANGE_TIMESPAN: u32 = 14 * 24 * 3600; /// In Bitcoind this is insanely described as ~((u256)0 >> 32) pub fn max_target(_: Network) -> Uint256 { - from_u64::(0xFFFF).unwrap() << 208u + from_u64::(0xFFFF).unwrap() << 208 } /// The maximum value allowed in an output (useful for sanity checking, diff --git a/src/blockdata/opcodes.rs b/src/blockdata/opcodes.rs index e922b1e9..e3f3b5a2 100644 --- a/src/blockdata/opcodes.rs +++ b/src/blockdata/opcodes.rs @@ -594,10 +594,10 @@ pub mod all { super::PushNum(-1) // 16 opcodes } else if OP_PUSHNUM_1 as u8 <= *self as u8 && *self as u8 <= OP_PUSHNUM_16 as u8 { - super::PushNum(1 + *self as int - OP_PUSHNUM_1 as int) + super::PushNum(1 + *self as isize - OP_PUSHNUM_1 as isize) // 76 opcodes } else if *self as u8 <= OP_PUSHBYTES_75 as u8 { - super::PushBytes(*self as uint) + super::PushBytes(*self as usize) // 60 opcodes } else { super::Ordinary(unsafe { transmute(*self) }) @@ -635,9 +635,9 @@ pub mod all { #[deriving(Clone, PartialEq, Eq, Show)] pub enum OpcodeClass { /// Pushes the given number onto the stack - PushNum(int), + PushNum(isize), /// Pushes the given number of bytes onto the stack - PushBytes(uint), + PushBytes(usize), /// Fails the script if executed ReturnOp, /// Fails the script even if not executed @@ -654,7 +654,7 @@ impl json::ToJson for OpcodeClass { } } -macro_rules! ordinary_opcode( +macro_rules! ordinary_opcode { ($($op:ident),*) => ( #[repr(u8)] #[doc(hidden)] @@ -663,10 +663,10 @@ macro_rules! ordinary_opcode( $( $op = all::$op as u8 ),* } ); -) +} /// "Ordinary" opcodes -- should be 60 of these -ordinary_opcode!( +ordinary_opcode! { // pushdata OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4, // control flow @@ -688,6 +688,6 @@ ordinary_opcode!( OP_RIPEMD160, OP_SHA1, OP_SHA256, OP_HASH160, OP_HASH256, OP_CODESEPARATOR, OP_CHECKSIG, OP_CHECKSIGVERIFY, OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY -) +} diff --git a/src/blockdata/script.rs b/src/blockdata/script.rs index 489ed13b..bbbf2380 100644 --- a/src/blockdata/script.rs +++ b/src/blockdata/script.rs @@ -98,9 +98,9 @@ pub enum ScriptError { /// An OP_RETURN or synonym was executed ExecutedReturn, /// A multisig tx with negative or too many keys - MultisigBadKeyCount(int), + MultisigBadKeyCount(isize), /// A multisig tx with negative or too many signatures - MultisigBadSigCount(int), + MultisigBadSigCount(isize), /// Used OP_PICK with a negative index NegativePick, /// Used OP_ROLL with a negative index @@ -126,15 +126,15 @@ pub enum ScriptError { /// A rule for validating an abstract stack element pub struct Validator { /// List of other elements to pass to both `check` and `update` - args: Vec, + args: Vec, /// Function which confirms that the current value is consistent with /// the stack state, returning `false` if not. - check: fn(&AbstractStackElem, &[uint]) -> bool, + check: fn(&AbstractStackElem, &[usize]) -> bool, /// Function which updates the current stack based on the element's /// value, if it has a value, otherwise updates the element's value /// based on the current stack, if possible. Returns `false` if it /// is forced to do something inconsistent. - update: fn(&mut AbstractStackElem, &[uint]) -> Result<(), ScriptError> + update: fn(&mut AbstractStackElem, &[usize]) -> Result<(), ScriptError> } impl Clone for Validator { @@ -148,13 +148,13 @@ impl Clone for Validator { } // Validators -fn check_op_size(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_size(elem: &AbstractStackElem, others: &[usize]) -> bool { let other = unsafe { elem.lookup(others[0]) }; elem.num_hi() >= other.len_lo() as i64 && elem.num_lo() <= other.len_hi() as i64 } -fn update_op_size(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_size(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { let (lo, hi) = { let one = unsafe { elem.lookup(others[0]) }; @@ -165,7 +165,7 @@ fn update_op_size(elem: &mut AbstractStackElem, others: &[uint]) elem.set_num_hi(hi) } -fn check_op_equal(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_equal(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; match elem.bool_value() { @@ -207,7 +207,7 @@ fn update_boolean(elem: &mut AbstractStackElem) } } -fn update_op_equal(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_equal(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => update_boolean(elem), @@ -240,8 +240,8 @@ fn update_op_equal(elem: &mut AbstractStackElem, others: &[uint]) (Some(_), Some(_)) => { return Err(Unsatisfiable); } } // Equalize full values - match (one.raw_value().map(|r| Vec::from_slice(r)), - two.raw_value().map(|r| Vec::from_slice(r))) { + match (one.raw_value().map(|r| r.to_vec()), + two.raw_value().map(|r| r.to_vec())) { (None, None) => {}, (None, Some(x)) => try!(one.set_value(x.as_slice())), (Some(x), None) => try!(two.set_value(x.as_slice())), @@ -252,7 +252,7 @@ fn update_op_equal(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_not(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_not(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; if !one.may_be_numeric() { return false; @@ -265,7 +265,7 @@ fn check_op_not(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_not(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_not(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => update_boolean(elem), @@ -290,7 +290,7 @@ fn update_op_not(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_0notequal(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_0notequal(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; if !one.may_be_numeric() { return false; } match elem.bool_value() { @@ -300,7 +300,7 @@ fn check_op_0notequal(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_0notequal(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_0notequal(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => update_boolean(elem), @@ -325,7 +325,7 @@ fn update_op_0notequal(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_numequal(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_numequal(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; if !one.may_be_numeric() { return false; } @@ -349,7 +349,7 @@ fn check_op_numequal(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_numequal(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_numequal(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => update_boolean(elem), @@ -370,7 +370,7 @@ fn update_op_numequal(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_numnotequal(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_numnotequal(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; if !one.may_be_numeric() { return false; } @@ -382,7 +382,7 @@ fn check_op_numnotequal(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_numnotequal(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_numnotequal(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => update_boolean(elem), @@ -403,7 +403,7 @@ fn update_op_numnotequal(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_numlt(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_numlt(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; if !one.may_be_numeric() { return false; } @@ -415,7 +415,7 @@ fn check_op_numlt(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_numlt(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_numlt(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => update_boolean(elem), @@ -440,7 +440,7 @@ fn update_op_numlt(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_numgt(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_numgt(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; if !one.may_be_numeric() { return false; } @@ -452,7 +452,7 @@ fn check_op_numgt(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_numgt(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_numgt(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => try!(update_boolean(elem)), @@ -478,7 +478,7 @@ fn update_op_numgt(elem: &mut AbstractStackElem, others: &[uint]) Ok(()) } -fn check_op_numlteq(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_numlteq(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; if !one.may_be_numeric() { return false; } @@ -490,7 +490,7 @@ fn check_op_numlteq(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_numlteq(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_numlteq(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => try!(update_boolean(elem)), @@ -516,7 +516,7 @@ fn update_op_numlteq(elem: &mut AbstractStackElem, others: &[uint]) Ok(()) } -fn check_op_numgteq(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_numgteq(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; if !one.may_be_numeric() { return false; } @@ -528,7 +528,7 @@ fn check_op_numgteq(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_numgteq(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_numgteq(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => try!(update_boolean(elem)), @@ -554,11 +554,11 @@ fn update_op_numgteq(elem: &mut AbstractStackElem, others: &[uint]) Ok(()) } -fn check_op_ripemd160(elem: &AbstractStackElem, _: &[uint]) -> bool { +fn check_op_ripemd160(elem: &AbstractStackElem, _: &[usize]) -> bool { elem.may_be_hash160() } -fn update_op_ripemd160(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_ripemd160(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { try!(elem.set_len_lo(20)); try!(elem.set_len_hi(20)); @@ -580,11 +580,11 @@ fn update_op_ripemd160(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_sha1(elem: &AbstractStackElem, _: &[uint]) -> bool { +fn check_op_sha1(elem: &AbstractStackElem, _: &[usize]) -> bool { elem.may_be_hash160() } -fn update_op_sha1(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_sha1(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { try!(elem.set_len_lo(20)); try!(elem.set_len_hi(20)); @@ -606,11 +606,11 @@ fn update_op_sha1(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_hash160(elem: &AbstractStackElem, _: &[uint]) -> bool { +fn check_op_hash160(elem: &AbstractStackElem, _: &[usize]) -> bool { elem.may_be_hash160() } -fn update_op_hash160(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_hash160(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { try!(elem.set_len_lo(20)); try!(elem.set_len_hi(20)); @@ -636,11 +636,11 @@ fn update_op_hash160(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_sha256(elem: &AbstractStackElem, _: &[uint]) -> bool { +fn check_op_sha256(elem: &AbstractStackElem, _: &[usize]) -> bool { elem.may_be_hash256() } -fn update_op_sha256(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_sha256(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { try!(elem.set_len_lo(32)); try!(elem.set_len_hi(32)); @@ -662,11 +662,11 @@ fn update_op_sha256(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_hash256(elem: &AbstractStackElem, _: &[uint]) -> bool { +fn check_op_hash256(elem: &AbstractStackElem, _: &[usize]) -> bool { elem.may_be_hash256() } -fn update_op_hash256(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_hash256(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { try!(elem.set_len_lo(32)); try!(elem.set_len_hi(32)); @@ -691,7 +691,7 @@ fn update_op_hash256(elem: &mut AbstractStackElem, others: &[uint]) } } -fn check_op_checksig(elem: &AbstractStackElem, others: &[uint]) -> bool { +fn check_op_checksig(elem: &AbstractStackElem, others: &[usize]) -> bool { let one = unsafe { elem.lookup(others[0]) }; let two = unsafe { elem.lookup(others[1]) }; match elem.bool_value() { @@ -701,7 +701,7 @@ fn check_op_checksig(elem: &AbstractStackElem, others: &[uint]) -> bool { } } -fn update_op_checksig(elem: &mut AbstractStackElem, others: &[uint]) +fn update_op_checksig(elem: &mut AbstractStackElem, others: &[usize]) -> Result<(), ScriptError> { match elem.bool_value() { None => update_boolean(elem), @@ -732,13 +732,13 @@ pub struct AbstractStackElem { /// Upper bound when read as number num_hi: i64, /// Length lower bound - len_lo: uint, + len_lo: usize, /// Length upper bound - len_hi: uint, + len_hi: usize, /// Relations this must satisfy validators: Vec, /// Index of the element in its stack allocator - alloc_index: Option + alloc_index: Option } impl AbstractStackElem { @@ -771,7 +771,7 @@ impl AbstractStackElem { len_lo: data.len(), len_hi: data.len(), bool_val: Some(read_scriptbool(data)), - raw: Some(Vec::from_slice(data)), + raw: Some(data.to_vec()), validators: vec![], alloc_index: None } @@ -792,17 +792,17 @@ impl AbstractStackElem { } /// Looks up another stack item by index - unsafe fn lookup<'a>(&'a self, idx: uint) -> &'a AbstractStackElem { + unsafe fn lookup<'a>(&'a self, idx: usize) -> &'a AbstractStackElem { let mypos = self as *const _; - let myidx = self.alloc_index.unwrap() as int; - &*mypos.offset(idx as int - myidx) + let myidx = self.alloc_index.unwrap() as isize; + &*mypos.offset(idx as isize - myidx) } /// Looks up another stack item by index - unsafe fn lookup_mut<'a>(&'a self, idx: uint) -> &'a mut AbstractStackElem { + unsafe fn lookup_mut<'a>(&'a self, idx: usize) -> &'a mut AbstractStackElem { let mypos = self as *const _ as *mut _; - let myidx = self.alloc_index.unwrap() as int; - &mut *mypos.offset(idx as int - myidx) + let myidx = self.alloc_index.unwrap() as isize; + &mut *mypos.offset(idx as isize - myidx) } /// Retrieve the boolean value of the stack element, if it can be determined @@ -832,13 +832,13 @@ impl AbstractStackElem { /// Retrieve the upper bound for this element's length. This always /// exists as a finite value, though the default upper limit is some /// impractically large number - pub fn len_hi(&self) -> uint { + pub fn len_hi(&self) -> usize { self.len_hi } /// Retrieve the lower bound for this element's length. This always /// exists since it is at least zero :) - pub fn len_lo(&self) -> uint { + pub fn len_lo(&self) -> usize { self.len_lo } @@ -901,7 +901,7 @@ impl AbstractStackElem { /// Sets the entire value of the pub fn set_value(&mut self, val: &[u8]) -> Result<(), ScriptError> { - match self.raw_value().map(|x| Vec::from_slice(x)) { + match self.raw_value().map(|x| x.to_vec()) { Some(x) => { if x.as_slice() == val { Ok(()) } else { Err(Unsatisfiable) } } None => { try!(self.set_len_lo(val.len())); @@ -915,7 +915,7 @@ impl AbstractStackElem { Err(_) => {} } try!(self.set_bool_value(read_scriptbool(val))); - self.raw = Some(Vec::from_slice(val)); + self.raw = Some(val.to_vec()); Ok(()) } } @@ -1012,7 +1012,7 @@ impl AbstractStackElem { } /// Sets a lower length bound on a value - pub fn set_len_lo(&mut self, value: uint) -> Result<(), ScriptError> { + pub fn set_len_lo(&mut self, value: usize) -> Result<(), ScriptError> { if self.len_lo < value { self.len_lo = value; if value > 0 { try!(self.set_bool_value(true)); } @@ -1023,7 +1023,7 @@ impl AbstractStackElem { } /// Sets a upper length bound on a value - pub fn set_len_hi(&mut self, value: uint) -> Result<(), ScriptError> { + pub fn set_len_hi(&mut self, value: usize) -> Result<(), ScriptError> { if self.len_hi > value { self.len_hi = value; try!(self.update()); @@ -1043,11 +1043,11 @@ impl AbstractStackElem { #[deriving(Clone)] pub struct AbstractStack { /// Actual elements on the stack - stack: Vec, + stack: Vec, /// Actual elements on the altstack - alt_stack: Vec, + alt_stack: Vec, /// Stack needed to satisfy the script before execution - initial_stack: Vec, + initial_stack: Vec, /// Local allocator to allow cloning; refs are indices into here alloc: Vec } @@ -1063,7 +1063,7 @@ impl AbstractStack { } } - fn allocate(&mut self, mut elem: AbstractStackElem) -> uint { + fn allocate(&mut self, mut elem: AbstractStackElem) -> usize { elem.alloc_index = Some(self.alloc.len()); self.alloc.push(elem); self.alloc.len() - 1 @@ -1084,24 +1084,24 @@ impl AbstractStack { /// Increase the stack size to `n`, adding elements to the initial /// stack as necessary - pub fn require_n_elems(&mut self, n: uint) { + pub fn require_n_elems(&mut self, n: usize) { while self.stack.len() < n { self.push_initial(AbstractStackElem::new_unknown()); } } /// Lookup an element by index - pub fn get_elem(&self, alloc_index: uint) -> &AbstractStackElem { + pub fn get_elem(&self, alloc_index: usize) -> &AbstractStackElem { &self.alloc[alloc_index] } /// Lookup an element by index - pub fn get_elem_mut(&mut self, alloc_index: uint) -> &mut AbstractStackElem { + pub fn get_elem_mut(&mut self, alloc_index: usize) -> &mut AbstractStackElem { self.alloc.get_mut(alloc_index) } /// Push a copy of an existing element by index - pub fn push(&mut self, elem: uint) { + pub fn push(&mut self, elem: usize) { self.stack.push(elem); } @@ -1123,7 +1123,7 @@ impl AbstractStack { } /// Obtain a stackref to the current top element - pub fn peek_index(&mut self) -> uint { + pub fn peek_index(&mut self) -> usize { if self.stack.len() == 0 { self.push_initial(AbstractStackElem::new_unknown()); } @@ -1131,7 +1131,7 @@ impl AbstractStack { } /// Drop the top stack item - fn pop(&mut self) -> uint { + fn pop(&mut self) -> usize { if self.stack.len() == 0 { self.push_initial(AbstractStackElem::new_unknown()); } @@ -1171,28 +1171,28 @@ impl AbstractStack { /// Immutable view of the current stack as a slice (to be compatible /// with the `stack_opcode!` macro - pub fn as_slice<'a>(&'a self) -> &'a [uint] { + pub fn as_slice<'a>(&'a self) -> &'a [usize] { self.stack.as_slice() } /// Immutable view of the current stack as a slice of bytes - pub fn slice_to<'a>(&'a self, n: uint) -> &'a [uint] { + pub fn slice_to<'a>(&'a self, n: usize) -> &'a [usize] { self.stack.slice_to(n) } /// Mutable view of the current stack as a slice (to be compatible /// with the `stack_opcode!` macro - fn as_mut_slice<'a>(&'a mut self) -> &'a mut [uint] { + fn as_mut_slice<'a>(&'a mut self) -> &'a mut [usize] { self.stack.as_mut_slice() } /// Length of the current stack - fn len(&self) -> uint { + fn len(&self) -> usize { self.stack.len() } /// Delete an element from the middle of the current stack - fn remove(&mut self, idx: uint) { + fn remove(&mut self, idx: usize) { self.stack.remove(idx); } } @@ -1206,8 +1206,8 @@ impl json::ToJson for ScriptError { /// A single iteration of a script execution #[deriving(PartialEq, Eq, Show, Clone)] pub struct TraceIteration { - index: uint, - op_count: uint, + index: usize, + op_count: usize, opcode: allops::Opcode, executed: bool, errored: bool, @@ -1228,7 +1228,7 @@ pub struct ScriptTrace { pub error: Option } -impl_json!(TraceIteration, index, opcode, op_count, executed, errored, effect, stack) +impl_json!(TraceIteration, index, opcode, op_count, executed, errored, effect, stack); /// Hashtype of a transaction, encoded in the last byte of a signature, /// specifically in the last 5 bits `byte & 31` @@ -1269,7 +1269,7 @@ pub enum MaybeOwned<'a> { /// Freshly allocated memory Owned(Vec), /// Pointer into the original script - Slice(&'a [u8]) + Borrowed(&'a [u8]) } impl<'a> PartialEq for MaybeOwned<'a> { @@ -1284,17 +1284,17 @@ impl<'a> Slice for MaybeOwned<'a> { fn as_slice<'a>(&'a self) -> &'a [u8] { match *self { Owned(ref v) => v.as_slice(), - Slice(ref s) => s.as_slice() + Borrowed(ref s) => s.as_slice() } } } impl<'a> Collection for MaybeOwned<'a> { #[inline] - fn len(&self) -> uint { + fn len(&self) -> usize { match *self { Owned(ref v) => v.len(), - Slice(ref s) => s.len() + Borrowed(ref s) => s.len() } } } @@ -1308,7 +1308,7 @@ fn build_scriptint(n: i64) -> Vec { let neg = n < 0; - let mut abs = if neg { -n } else { n } as uint; + let mut abs = if neg { -n } else { n } as usize; let mut v = vec![]; while abs > 0xFF { v.push((abs & 0xFF) as u8); @@ -1348,7 +1348,7 @@ pub fn read_scriptint(v: &[u8]) -> Result { if len > 4 { return Err(NumericOverflow); } let (mut ret, sh) = v.iter() - .fold((0, 0), |(acc, sh), n| (acc + (*n as i64 << sh), sh + 8)); + .fold((0, 0), |(acc, sh), n| (acc + ((*n as i64) << sh), sh + 8)); if v[len - 1] & 0x80 != 0 { ret &= (1 << sh - 1) - 1; ret = -ret; @@ -1366,12 +1366,12 @@ pub fn read_scriptbool(v: &[u8]) -> bool { } /// Read a script-encoded unsigned integer -pub fn read_uint<'a, I:Iterator<&'a u8>>(mut iter: I, size: uint) - -> Result { +pub fn read_uint<'a, I:Iterator<&'a u8>>(mut iter: I, size: usize) + -> Result { let mut ret = 0; for i in range(0, size) { match iter.next() { - Some(&n) => ret += n as uint << (i * 8), + Some(&n) => ret += (n as usize) << (i * 8), None => { return Err(EarlyEndOfScript); } } } @@ -1381,7 +1381,7 @@ pub fn read_uint<'a, I:Iterator<&'a u8>>(mut iter: I, size: uint) /// Check a signature -- returns an error that is currently just translated /// into a 0/1 to push onto the script stack fn check_signature(sig_slice: &[u8], pk_slice: &[u8], script: Vec, - tx: &Transaction, input_index: uint) -> Result<(), ScriptError> { + tx: &Transaction, input_index: usize) -> Result<(), ScriptError> { // Check public key let pubkey = PublicKey::from_slice(pk_slice); @@ -1478,13 +1478,13 @@ fn check_signature(sig_slice: &[u8], pk_slice: &[u8], script: Vec, // were really hard to read and verify -- see OP_PICK and OP_ROLL // for an example of what Rust vector-stack manipulation looks // like. -macro_rules! stack_opcode( +macro_rules! stack_opcode { ($stack:ident($min:expr): - $(require $r:expr)* - $(copy $c:expr)* - $(swap ($a:expr, $b:expr))* - $(perm ($first:expr $(->$i:expr)*) )* - $(drop $d:expr)* + $(require $r:expr);* + $(copy $c:expr);* + $(swap ($a:expr, $b:expr));* + $(perm ($first:expr, $($i:expr),*) );* + $(drop $d:expr);* ) => ({ $( $stack.require_n_elems($r); )* // Record top @@ -1502,10 +1502,10 @@ macro_rules! stack_opcode( // Do drops last so that dropped values will be available above $( $stack.remove(top - $d); )* }); -) +} /// Macro to translate numerical operations into stack ones -macro_rules! num_opcode( +macro_rules! num_opcode { ($stack:ident($($var:ident),*): $op:expr) => ({ $( let $var = try!(read_scriptint(match $stack.pop() { @@ -1517,9 +1517,9 @@ macro_rules! num_opcode( // Return a tuple of all the variables ($( $var ),*) }); -) +} -macro_rules! unary_opcode_satisfy( +macro_rules! unary_opcode_satisfy { ($stack:ident, $op:ident) => ({ let one = $stack.pop(); let cond = $stack.push_alloc(AbstractStackElem::new_unknown()); @@ -1527,9 +1527,9 @@ macro_rules! unary_opcode_satisfy( check: concat_idents!(check_, $op), update: concat_idents!(update_, $op) })); }) -) +} -macro_rules! boolean_opcode_satisfy( +macro_rules! boolean_opcode_satisfy { ($stack:ident, unary $op:ident) => ({ let one = $stack.pop(); let cond = $stack.push_alloc(AbstractStackElem::new_unknown()); @@ -1557,10 +1557,10 @@ macro_rules! boolean_opcode_satisfy( check: concat_idents!(check_, $op), update: concat_idents!(update_, $op) })); }); -) +} /// Macro to translate hashing operations into stack ones -macro_rules! hash_opcode( +macro_rules! hash_opcode { ($stack:ident, $hash:ident) => ({ match $stack.pop() { None => { return Err(PopEmptyStack); } @@ -1576,10 +1576,10 @@ macro_rules! hash_opcode( } } }); -) +} // OP_VERIFY macro -macro_rules! op_verify ( +macro_rules! op_verify { ($stack:expr, $err:expr) => ( match $stack.last().map(|v| read_scriptbool(v.as_slice())) { None => { return Err(VerifyEmptyStack); } @@ -1587,14 +1587,14 @@ macro_rules! op_verify ( Some(true) => { $stack.pop(); } } ) -) +} -macro_rules! op_verify_satisfy ( +macro_rules! op_verify_satisfy { ($stack:expr) => ({ try!($stack.peek_mut().set_bool_value(true)); $stack.pop(); }) -) +} impl Script { /// Creates a new empty script @@ -1604,7 +1604,7 @@ impl Script { pub fn from_vec(v: Vec) -> Script { Script(ThinVec::from_vec(v)) } /// The length in bytes of the script - pub fn len(&self) -> uint { + pub fn len(&self) -> usize { let &Script(ref raw) = self; raw.len() } @@ -1640,7 +1640,7 @@ impl Script { let &Script(ref mut raw) = self; // Start with a PUSH opcode match data.len() { - n if n < opcodes::OP_PUSHDATA1 as uint => { raw.push(n as u8); }, + n if n < opcodes::OP_PUSHDATA1 as usize => { raw.push(n as u8); }, n if n < 0x100 => { raw.push(opcodes::OP_PUSHDATA1 as u8); raw.push(n as u8); @@ -1657,7 +1657,7 @@ impl Script { raw.push(((n / 0x10000) % 0x100) as u8); raw.push((n / 0x1000000) as u8); } - _ => fail!("tried to put a 4bn+ sized object into a script!") + _ => panic!("tried to put a 4bn+ sized object into a script!") } // Then push the acraw raw.extend(data.iter().map(|n| *n)); @@ -1676,26 +1676,26 @@ impl Script { } /// Returns a view into the script as a slice - pub fn slice_to(&self, n: uint) -> &[u8] { + pub fn slice_to(&self, n: usize) -> &[u8] { let &Script(ref raw) = self; raw.slice_to(n) } /// Returns a view into the script as a slice - pub fn slice_from(&self, n: uint) -> &[u8] { + pub fn slice_from(&self, n: usize) -> &[u8] { let &Script(ref raw) = self; raw.slice_from(n) } /// Returns a view into the script as a slice - pub fn slice(&self, s: uint, e: uint) -> &[u8] { + pub fn slice(&self, s: usize, e: usize) -> &[u8] { let &Script(ref raw) = self; raw.slice(s, e) } /// Trace a script pub fn trace<'a>(&'a self, stack: &mut Vec>, - input_context: Option<(&Transaction, uint)>) + input_context: Option<(&Transaction, usize)>) -> ScriptTrace { let mut trace = ScriptTrace { script: self.clone(), @@ -1713,12 +1713,12 @@ impl Script { /// Evaluate the script, modifying the stack in place pub fn evaluate<'a>(&'a self, stack: &mut Vec>, - input_context: Option<(&Transaction, uint)>, + input_context: Option<(&Transaction, usize)>, mut trace: Option<&mut Vec>) -> Result<(), ScriptError> { let &Script(ref raw) = self; - let mut codeseparator_index = 0u; + let mut codeseparator_index = 0; let mut exec_stack = vec![]; let mut alt_stack = vec![]; @@ -1757,35 +1757,35 @@ impl Script { // Data-reading statements still need to read, even when not executing (_, opcodes::PushBytes(n)) => { if raw.len() < index + n { return Err(EarlyEndOfScript); } - if executing { stack.push(Slice(raw.slice(index, index + n))); } + if executing { stack.push(Borrowed(raw.slice(index, index + n))); } index += n; } (_, opcodes::Ordinary(opcodes::OP_PUSHDATA1)) => { if raw.len() < index + 1 { return Err(EarlyEndOfScript); } let n = try!(read_uint(raw.slice_from(index).iter(), 1)); if raw.len() < index + 1 + n { return Err(EarlyEndOfScript); } - if executing { stack.push(Slice(raw.slice(index + 1, index + n + 1))); } + if executing { stack.push(Borrowed(raw.slice(index + 1, index + n + 1))); } index += 1 + n; } (_, opcodes::Ordinary(opcodes::OP_PUSHDATA2)) => { if raw.len() < index + 2 { return Err(EarlyEndOfScript); } let n = try!(read_uint(raw.slice_from(index).iter(), 2)); if raw.len() < index + 2 + n { return Err(EarlyEndOfScript); } - if executing { stack.push(Slice(raw.slice(index + 2, index + n + 2))); } + if executing { stack.push(Borrowed(raw.slice(index + 2, index + n + 2))); } index += 2 + n; } (_, opcodes::Ordinary(opcodes::OP_PUSHDATA4)) => { if raw.len() < index + 4 { return Err(EarlyEndOfScript); } let n = try!(read_uint(raw.slice_from(index).iter(), 4)); if raw.len() < index + 4 + n { return Err(EarlyEndOfScript); } - if executing { stack.push(Slice(raw.slice(index + 4, index + n + 4))); } + if executing { stack.push(Borrowed(raw.slice(index + 4, index + n + 4))); } index += 4 + n; } // If-statements take effect when not executing (false, opcodes::Ordinary(opcodes::OP_IF)) => exec_stack.push(false), (false, opcodes::Ordinary(opcodes::OP_NOTIF)) => exec_stack.push(false), (false, opcodes::Ordinary(opcodes::OP_ELSE)) => { - match exec_stack.mut_last() { + match exec_stack.last_mut() { Some(ref_e) => { *ref_e = !*ref_e } None => { return Err(ElseWithoutIf); } } @@ -1816,7 +1816,7 @@ impl Script { } } opcodes::OP_ELSE => { - match exec_stack.mut_last() { + match exec_stack.last_mut() { Some(ref_e) => { *ref_e = !*ref_e } None => { return Err(ElseWithoutIf); } } @@ -1839,13 +1839,13 @@ impl Script { Some(elem) => { stack.push(elem); } } } - opcodes::OP_2DROP => stack_opcode!(stack(2): drop 1 drop 2), - opcodes::OP_2DUP => stack_opcode!(stack(2): copy 2 copy 1), - opcodes::OP_3DUP => stack_opcode!(stack(3): copy 3 copy 2 copy 1), - opcodes::OP_2OVER => stack_opcode!(stack(4): copy 4 copy 3), - opcodes::OP_2ROT => stack_opcode!(stack(6): perm (1 -> 3 -> 5) - perm (2 -> 4 -> 6)), - opcodes::OP_2SWAP => stack_opcode!(stack(4): swap (2, 4) swap (1, 3)), + opcodes::OP_2DROP => stack_opcode!(stack(2): drop 1; drop 2), + opcodes::OP_2DUP => stack_opcode!(stack(2): copy 2; copy 1), + opcodes::OP_3DUP => stack_opcode!(stack(3): copy 3; copy 2; copy 1), + opcodes::OP_2OVER => stack_opcode!(stack(4): copy 4; copy 3), + opcodes::OP_2ROT => stack_opcode!(stack(6): perm (1, 3, 5); + perm (2, 4, 6)), + opcodes::OP_2SWAP => stack_opcode!(stack(4): swap (2, 4); swap (1, 3)), opcodes::OP_DROP => stack_opcode!(stack(1): drop 1), opcodes::OP_DUP => stack_opcode!(stack(1): copy 1), opcodes::OP_NIP => stack_opcode!(stack(2): drop 2), @@ -1856,7 +1856,7 @@ impl Script { None => { return Err(PopEmptyStack); } }; if n < 0 { return Err(NegativePick); } - let n = n as uint; + let n = n as usize; stack_opcode!(stack(n + 1): copy n + 1) } opcodes::OP_ROLL => { @@ -1865,12 +1865,12 @@ impl Script { None => { return Err(PopEmptyStack); } }; if n < 0 { return Err(NegativeRoll); } - let n = n as uint; + let n = n as usize; stack_opcode!(stack(n + 1): copy n + 1 drop n + 1) } - opcodes::OP_ROT => stack_opcode!(stack(3): perm (1 -> 2 -> 3)), + opcodes::OP_ROT => stack_opcode!(stack(3): perm (1, 2, 3)), opcodes::OP_SWAP => stack_opcode!(stack(2): swap (1, 2)), - opcodes::OP_TUCK => stack_opcode!(stack(2): copy 2 copy 1 drop 2), + opcodes::OP_TUCK => stack_opcode!(stack(2): copy 2; copy 1 drop 2), opcodes::OP_IFDUP => { match stack.last().map(|v| read_scriptbool(v.as_slice())) { None => { return Err(IfEmptyStack); } @@ -1892,7 +1892,7 @@ impl Script { if stack.len() < 2 { return Err(PopEmptyStack); } let a = stack.pop().unwrap(); let b = stack.pop().unwrap(); - stack.push(Slice(if a == b { SCRIPT_TRUE } else { SCRIPT_FALSE })); + stack.push(Borrowed(if a == b { SCRIPT_TRUE } else { SCRIPT_FALSE })); if op == opcodes::OP_EQUALVERIFY { op_verify!(stack, EqualVerifyFailed(a.as_slice().to_hex(), b.as_slice().to_hex())); @@ -1943,7 +1943,7 @@ impl Script { // Compute the section of script that needs to be hashed: everything // from the last CODESEPARATOR, except the signature itself. - let mut script = Vec::from_slice(raw.slice_from(codeseparator_index)); + let mut script = raw.slice_from(codeseparator_index).to_vec(); let mut remove = Script::new(); remove.push_slice(sig_slice); script_find_and_remove(&mut script, remove.as_slice()); @@ -1955,8 +1955,8 @@ impl Script { let (tx, input_index) = input_context.unwrap(); match check_signature( sig_slice, pk_slice, script, tx, input_index) { - Ok(()) => stack.push(Slice(SCRIPT_TRUE)), - _ => stack.push(Slice(SCRIPT_FALSE)), + Ok(()) => stack.push(Borrowed(SCRIPT_TRUE)), + _ => stack.push(Borrowed(SCRIPT_FALSE)), } if op == opcodes::OP_CHECKSIGVERIFY { op_verify!(stack, VerifyFailed); } } @@ -1965,11 +1965,11 @@ impl Script { if stack.len() < 1 { return Err(PopEmptyStack); } let n_keys = try!(read_scriptint(stack.pop().unwrap().as_slice())); if n_keys < 0 || n_keys > 20 { - return Err(MultisigBadKeyCount(n_keys as int)); + return Err(MultisigBadKeyCount(n_keys as isize)); } if (stack.len() as i64) < n_keys { return Err(PopEmptyStack); } - let mut keys = Vec::with_capacity(n_keys as uint); + let mut keys = Vec::with_capacity(n_keys as usize); for _ in range(0, n_keys) { keys.push(stack.pop().unwrap()); } @@ -1978,11 +1978,11 @@ impl Script { if stack.len() < 1 { return Err(PopEmptyStack); } let n_sigs = try!(read_scriptint(stack.pop().unwrap().as_slice())); if n_sigs < 0 || n_sigs > n_keys { - return Err(MultisigBadSigCount(n_sigs as int)); + return Err(MultisigBadSigCount(n_sigs as isize)); } if (stack.len() as i64) < n_sigs { return Err(PopEmptyStack); } - let mut sigs = Vec::with_capacity(n_sigs as uint); + let mut sigs = Vec::with_capacity(n_sigs as usize); for _ in range(0, n_sigs) { sigs.push(stack.pop().unwrap()); } @@ -1992,7 +1992,7 @@ impl Script { // Compute the section of script that needs to be hashed: everything // from the last CODESEPARATOR, except the signatures themselves. - let mut script = Vec::from_slice(raw.slice_from(codeseparator_index)); + let mut script = raw.slice_from(codeseparator_index).to_vec(); for sig in sigs.iter() { let mut remove = Script::new(); remove.push_slice(sig.as_slice()); @@ -2024,12 +2024,12 @@ impl Script { } // Run out of signatures, success (_, None) => { - stack.push(Slice(SCRIPT_TRUE)); + stack.push(Borrowed(SCRIPT_TRUE)); break; } // Run out of keys to match to signatures, fail (None, Some(_)) => { - stack.push(Slice(SCRIPT_FALSE)); + stack.push(Borrowed(SCRIPT_FALSE)); break; } } @@ -2041,7 +2041,7 @@ impl Script { } // end loop // Store the stack in the trace trace.as_mut().map(|t| - t.mut_last().map(|t| { + t.last_mut().map(|t| { t.errored = false; t.stack = stack.iter().map(|elem| elem.as_slice().to_hex()).collect(); }) @@ -2077,7 +2077,7 @@ impl Script { fn recurse<'a>(script: &'a [u8], mut stack: AbstractStack, mut exec_stack: Vec, - depth: uint) -> Result, ScriptError> { + depth: usize) -> Result, ScriptError> { // Avoid doing more than 64k forks if depth > 16 { return Err(InterpreterStackOverflow); } @@ -2143,7 +2143,7 @@ impl Script { (false, opcodes::Ordinary(opcodes::OP_IF)) => exec_stack.push(false), (false, opcodes::Ordinary(opcodes::OP_NOTIF)) => exec_stack.push(false), (false, opcodes::Ordinary(opcodes::OP_ELSE)) => { - match exec_stack.mut_last() { + match exec_stack.last_mut() { Some(ref_e) => { *ref_e = !*ref_e } None => { return Err(ElseWithoutIf); } } @@ -2212,7 +2212,7 @@ impl Script { } } opcodes::OP_ELSE => { - match exec_stack.mut_last() { + match exec_stack.last_mut() { Some(ref_e) => { *ref_e = !*ref_e } None => { return Err(ElseWithoutIf); } } @@ -2225,15 +2225,15 @@ impl Script { opcodes::OP_VERIFY => op_verify_satisfy!(stack), opcodes::OP_TOALTSTACK => { stack.to_altstack(); } opcodes::OP_FROMALTSTACK => { try!(stack.from_altstack()); } - opcodes::OP_2DROP => stack_opcode!(stack(2): require 2 drop 1 drop 2), - opcodes::OP_2DUP => stack_opcode!(stack(2): require 2 copy 2 copy 1), - opcodes::OP_3DUP => stack_opcode!(stack(3): require 3 copy 3 copy 2 copy 1), - opcodes::OP_2OVER => stack_opcode!(stack(4): require 4 copy 4 copy 3), + opcodes::OP_2DROP => stack_opcode!(stack(2): require 2 drop 1; drop 2), + opcodes::OP_2DUP => stack_opcode!(stack(2): require 2 copy 2; copy 1), + opcodes::OP_3DUP => stack_opcode!(stack(3): require 3 copy 3; copy 2; copy 1), + opcodes::OP_2OVER => stack_opcode!(stack(4): require 4 copy 4; copy 3), opcodes::OP_2ROT => stack_opcode!(stack(6): require 6 - perm (1 -> 3 -> 5) - perm (2 -> 4 -> 6)), + perm (1, 3, 5); + perm (2, 4, 6)), opcodes::OP_2SWAP => stack_opcode!(stack(4): require 4 - swap (2, 4) + swap (2, 4); swap (1, 3)), opcodes::OP_DROP => stack_opcode!(stack(1): require 1 drop 1), opcodes::OP_DUP => stack_opcode!(stack(1): require 1 copy 1), @@ -2244,7 +2244,7 @@ impl Script { let top = stack.peek_mut(); try!(top.set_numeric()); try!(top.set_num_lo(0)); - top.num_value().map(|n| n as uint) + top.num_value().map(|n| n as usize) }; stack.pop(); match top_n { @@ -2262,7 +2262,7 @@ impl Script { let top = stack.peek_mut(); try!(top.set_numeric()); try!(top.set_num_lo(0)); - top.num_value().map(|n| n as uint) + top.num_value().map(|n| n as usize) }; stack.pop(); match top_n { @@ -2274,9 +2274,9 @@ impl Script { None => { return Err(Unanalyzable); } } } - opcodes::OP_ROT => stack_opcode!(stack(3): require 3 perm (1 -> 2 -> 3)), + opcodes::OP_ROT => stack_opcode!(stack(3): require 3 perm (1, 2, 3)), opcodes::OP_SWAP => stack_opcode!(stack(2): require 3 swap (1, 2)), - opcodes::OP_TUCK => stack_opcode!(stack(2): require 2 copy 2 copy 1 drop 2), + opcodes::OP_TUCK => stack_opcode!(stack(2): require 2 copy 2; copy 1 drop 2), opcodes::OP_IFDUP => { let top_bool = { let top = stack.peek_mut(); @@ -2423,8 +2423,8 @@ impl json::ToJson for Script { let &Script(ref raw) = self; let mut ret = String::new(); for dat in raw.iter() { - ret.push_char(from_digit((dat / 0x10) as uint, 16).unwrap()); - ret.push_char(from_digit((dat & 0x0f) as uint, 16).unwrap()); + ret.push_char(from_digit((dat / 0x10) as usize, 16).unwrap()); + ret.push_char(from_digit((dat & 0x0f) as usize, 16).unwrap()); } json::String(ret) } diff --git a/src/blockdata/transaction.rs b/src/blockdata/transaction.rs index a5c423c2..f900533c 100644 --- a/src/blockdata/transaction.rs +++ b/src/blockdata/transaction.rs @@ -27,7 +27,7 @@ use std::default::Default; use serialize::json; use util::hash::Sha256dHash; -use blockdata::script::{mod, Script, ScriptError, ScriptTrace, read_scriptbool}; +use blockdata::script::{self, Script, ScriptError, ScriptTrace, read_scriptbool}; use blockdata::utxoset::UtxoSet; use network::encodable::ConsensusEncodable; use network::serialize::BitcoinHash; @@ -81,7 +81,7 @@ impl TxOut { if self.script_pubkey.len() == 25 && self.script_pubkey.slice_to(3) == &[0x76, 0xa9, 0x14] && self.script_pubkey.slice_from(23) == &[0x88, 0xac] { - PayToPubkeyHash(Address::from_slice(network, self.script_pubkey.slice(3, 23))) + PayToPubkeyHash(self.script_pubkey.slice(3, 23).to_address(network)) } else { Unknown } @@ -133,16 +133,16 @@ impl json::ToJson for TransactionError { #[deriving(PartialEq, Eq, Clone, Show)] pub struct InputTrace { input_txid: Sha256dHash, - input_vout: uint, + input_vout: usize, sig_trace: ScriptTrace, pubkey_trace: Option, p2sh_trace: Option, error: Option } -impl_json!(ScriptTrace, script, initial_stack, iterations, error) +impl_json!(ScriptTrace, script, initial_stack, iterations, error); impl_json!(InputTrace, input_txid, input_vout, sig_trace, - pubkey_trace, p2sh_trace, error) + pubkey_trace, p2sh_trace, error); /// A trace of a transaction's execution #[deriving(PartialEq, Eq, Clone, Show)] @@ -151,14 +151,14 @@ pub struct TransactionTrace { inputs: Vec } -impl_json!(TransactionTrace, txid, inputs) +impl_json!(TransactionTrace, txid, inputs); impl TxIn { /// Check an input's script for validity pub fn validate(&self, utxoset: &UtxoSet, txn: &Transaction, - index: uint) -> Result<(), TransactionError> { + index: usize) -> Result<(), TransactionError> { let txo = utxoset.get_utxo(self.prev_hash, self.prev_index); match txo { Some((_, txo)) => { @@ -174,7 +174,7 @@ impl TxIn { p2sh_stack = stack.clone(); p2sh_script = match p2sh_stack.pop() { Some(script::Owned(v)) => Script::from_vec(v), - Some(script::Slice(s)) => Script::from_vec(Vec::from_slice(s)), + Some(script::Borrowed(s)) => Script::from_vec(s.to_vec()), None => unreachable!() }; } @@ -228,7 +228,7 @@ impl Transaction { // Setup trace let mut trace = InputTrace { input_txid: input.prev_hash, - input_vout: input.prev_index as uint, + input_vout: input.prev_index as usize, sig_trace: ScriptTrace { script: Script::new(), initial_stack: vec![], @@ -255,7 +255,7 @@ impl Transaction { p2sh_stack = stack.clone(); p2sh_script = match p2sh_stack.pop() { Some(script::Owned(v)) => Script::from_vec(v), - Some(script::Slice(s)) => Script::from_vec(Vec::from_slice(s)), + Some(script::Borrowed(s)) => Script::from_vec(s.to_vec()), None => unreachable!() }; } @@ -303,12 +303,12 @@ impl BitcoinHash for Transaction { } } -impl_consensus_encoding!(TxIn, prev_hash, prev_index, script_sig, sequence) -impl_json!(TxIn, prev_hash, prev_index, script_sig, sequence) -impl_consensus_encoding!(TxOut, value, script_pubkey) -impl_json!(TxOut, value, script_pubkey) -impl_consensus_encoding!(Transaction, version, input, output, lock_time) -impl_json!(Transaction, version, input, output, lock_time) +impl_consensus_encoding!(TxIn, prev_hash, prev_index, script_sig, sequence); +impl_json!(TxIn, prev_hash, prev_index, script_sig, sequence); +impl_consensus_encoding!(TxOut, value, script_pubkey); +impl_json!(TxOut, value, script_pubkey); +impl_consensus_encoding!(Transaction, version, input, output, lock_time); +impl_json!(Transaction, version, input, output, lock_time); #[cfg(test)] diff --git a/src/blockdata/utxoset.rs b/src/blockdata/utxoset.rs index bb71470e..dbb4eed0 100644 --- a/src/blockdata/utxoset.rs +++ b/src/blockdata/utxoset.rs @@ -65,27 +65,27 @@ struct UtxoNode { /// Vector of outputs; None indicates a nonexistent or already spent output outputs: ThinVec> } -impl_consensus_encoding!(UtxoNode, height, outputs) +impl_consensus_encoding!(UtxoNode, height, outputs); /// An iterator over UTXOs pub struct UtxoIterator<'a> { tx_iter: Entries<'a, Sha256dHash, UtxoNode>, current_key: Sha256dHash, current: Option<&'a UtxoNode>, - tx_index: uint + tx_index: u32 } -impl<'a> Iterator<(Sha256dHash, uint, &'a TxOut, uint)> for UtxoIterator<'a> { - fn next(&mut self) -> Option<(Sha256dHash, uint, &'a TxOut, uint)> { +impl<'a> Iterator<(Sha256dHash, u32, &'a TxOut, u32)> for UtxoIterator<'a> { + fn next(&mut self) -> Option<(Sha256dHash, u32, &'a TxOut, u32)> { while self.current.is_some() { let current = &self.current.unwrap().outputs; - while self.tx_index < current.len() { + while self.tx_index < current.len() as u32 { self.tx_index += 1; - if unsafe { current.get(self.tx_index - 1) }.is_some() { + if unsafe { current.get(self.tx_index as usize - 1) }.is_some() { return Some((self.current_key, self.tx_index, - unsafe { current.get(self.tx_index - 1) }.as_ref().unwrap(), - self.current.unwrap().height as uint)); + unsafe { current.get(self.tx_index as usize - 1) }.as_ref().unwrap(), + self.current.unwrap().height)); } } match self.tx_iter.next() { @@ -113,11 +113,11 @@ pub struct UtxoSet { n_pruned: u64 } -impl_consensus_encoding!(UtxoSet, last_hash, n_utxos, n_pruned, spent_txos, spent_idx, table) +impl_consensus_encoding!(UtxoSet, last_hash, n_utxos, n_pruned, spent_txos, spent_idx, table); impl UtxoSet { /// Constructs a new UTXO set - pub fn new(network: Network, rewind_limit: uint) -> UtxoSet { + pub fn new(network: Network, rewind_limit: usize) -> UtxoSet { // There is in fact a transaction in the genesis block, but the Bitcoin // reference client does not add its sole output to the UTXO set. We // must follow suit, otherwise we will accept a transaction spending it @@ -141,11 +141,11 @@ impl UtxoSet { for (vout, txo) in tx.output.iter().enumerate() { // Unsafe since we are not uninitializing the old data in the vector if txo.script_pubkey.is_provably_unspendable() { - new_node.init(vout as uint, None); + new_node.init(vout as usize, None); self.n_utxos -= 1; self.n_pruned += 1; } else { - new_node.init(vout as uint, Some(txo.clone())); + new_node.init(vout as usize, Some(txo.clone())); } } UtxoNode { outputs: new_node, height: height } @@ -171,8 +171,8 @@ impl UtxoSet { let ret = { // Check that this specific output is there - if vout as uint >= node.outputs.len() { return None; } - let replace = unsafe { node.outputs.get_mut(vout as uint) }; + if vout as usize >= node.outputs.len() { return None; } + let replace = unsafe { node.outputs.get_mut(vout as usize) }; replace.take() }; @@ -190,20 +190,20 @@ impl UtxoSet { } /// Get a reference to a UTXO in the set - pub fn get_utxo<'a>(&'a self, txid: Sha256dHash, vout: u32) -> Option<(uint, &'a TxOut)> { + pub fn get_utxo<'a>(&'a self, txid: Sha256dHash, vout: u32) -> Option<(usize, &'a TxOut)> { // Locate the UTXO, failing if not found let node = match self.table.find(&txid) { Some(node) => node, None => return None }; // Check that this specific output is there - if vout as uint >= node.outputs.len() { return None; } - let replace = unsafe { node.outputs.get(vout as uint) }; - Some((node.height as uint, replace.as_ref().unwrap())) + if vout as usize >= node.outputs.len() { return None; } + let replace = unsafe { node.outputs.get(vout as usize) }; + Some((node.height as usize, replace.as_ref().unwrap())) } /// Apply the transactions contained in a block - pub fn update(&mut self, block: &Block, blockheight: uint, validation: ValidationLevel) + pub fn update(&mut self, block: &Block, blockheight: usize, validation: ValidationLevel) -> Result<(), UtxoSetError> { // Make sure we are extending the UTXO set in order if validation >= ChainValidation && @@ -214,7 +214,7 @@ impl UtxoSet { // Set the next hash immediately so that if anything goes wrong, // we can rewind from the point that we're at. self.last_hash = block.header.bitcoin_hash(); - let spent_idx = self.spent_idx as uint; + let spent_idx = self.spent_idx as usize; self.spent_idx = (self.spent_idx + 1) % self.spent_txos.len() as u64; self.spent_txos.get_mut(spent_idx).clear(); @@ -240,7 +240,7 @@ impl UtxoSet { // Otherwise put the replaced txouts into the `deleted` cache // so that rewind will put them back. self.spent_txos.get_mut(spent_idx).reserve_additional(replace.outputs.len()); - for (n, input) in replace.outputs.mut_iter().enumerate() { + for (n, input) in replace.outputs.iter_mut().enumerate() { match input.take() { Some(txo) => { self.spent_txos.get_mut(spent_idx).push(((txid, n as u32), (replace.height, txo))); } None => {} @@ -269,7 +269,7 @@ impl UtxoSet { let s = self as *mut _ as *const UtxoSet; let txes = &block.txdata as *const _; - future_vec.push(Future::spawn(proc() { + future_vec.push(Future::spawn(move || { let txes = unsafe {&*txes}; for tx in txes.slice(start, end).iter() { match tx.validate(unsafe {&*s}) { @@ -283,7 +283,7 @@ impl UtxoSet { // Return the last error since we need to finish every future before // leaving this function, and given that, it's easier to return the last. let mut last_error = Ok(()); - for res in future_vec.mut_iter().map(|f| f.get()) { + for res in future_vec.iter_mut().map(|f| f.get()) { if res.is_err() { last_error = res; } @@ -348,8 +348,8 @@ impl UtxoSet { // Read deleted txouts if skipped_genesis { let mut extract_vec = vec![]; - mem::swap(&mut extract_vec, self.spent_txos.get_mut(self.spent_idx as uint)); - for ((txid, n), (height, txo)) in extract_vec.move_iter() { + mem::swap(&mut extract_vec, self.spent_txos.get_mut(self.spent_idx as usize)); + for ((txid, n), (height, txo)) in extract_vec.into_iter() { // Remove the tx's utxo list and patch the txo into place let new_node = match self.table.pop(&txid) { @@ -359,20 +359,20 @@ impl UtxoSet { unsafe { node.outputs.reserve(n + 1); for i in range(old_len, n + 1) { - node.outputs.init(i as uint, None); + node.outputs.init(i as usize, None); } } } - unsafe { *node.outputs.get_mut(n as uint) = Some(txo); } + unsafe { *node.outputs.get_mut(n as usize) = Some(txo); } node } None => { unsafe { let mut thinvec = ThinVec::with_capacity(n + 1); for i in range(0, n) { - thinvec.init(i as uint, None); + thinvec.init(i as usize, None); } - thinvec.init(n as uint, Some(txo)); + thinvec.init(n as usize, Some(txo)); UtxoNode { outputs: thinvec, height: height } } } @@ -397,14 +397,14 @@ impl UtxoSet { } /// Get the number of UTXOs in the set - pub fn n_utxos(&self) -> uint { - self.n_utxos as uint + pub fn n_utxos(&self) -> usize { + self.n_utxos as usize } /// Get the number of UTXOs ever pruned from the set (this is not updated /// during reorgs, so it may return a higher number than is realistic). - pub fn n_pruned(&self) -> uint { - self.n_pruned as uint + pub fn n_pruned(&self) -> usize { + self.n_pruned as usize } /// Get an iterator over all UTXOs diff --git a/src/internal_macros.rs b/src/internal_macros.rs index 25137011..a9b79f1f 100644 --- a/src/internal_macros.rs +++ b/src/internal_macros.rs @@ -12,9 +12,7 @@ // If not, see . // -#![macro_escape] - -macro_rules! impl_consensus_encoding( +macro_rules! impl_consensus_encoding { ($thing:ident, $($field:ident),+) => ( impl, E> ::network::encodable::ConsensusEncodable for $thing { #[inline] @@ -34,9 +32,9 @@ macro_rules! impl_consensus_encoding( } } ); -) +} -macro_rules! impl_newtype_consensus_encoding( +macro_rules! impl_newtype_consensus_encoding { ($thing:ident) => ( impl, E> ::network::encodable::ConsensusEncodable for $thing { #[inline] @@ -53,9 +51,9 @@ macro_rules! impl_newtype_consensus_encoding( } } ); -) +} -macro_rules! impl_json( +macro_rules! impl_json { ($thing:ident, $($field:ident),+) => ( impl ::serialize::json::ToJson for $thing { fn to_json(&self) -> ::serialize::json::Json { @@ -67,9 +65,9 @@ macro_rules! impl_json( } } ); -) +} -macro_rules! impl_array_newtype( +macro_rules! impl_array_newtype { ($thing:ident, $ty:ty, $len:expr) => { impl $thing { #[inline] @@ -81,21 +79,21 @@ macro_rules! impl_array_newtype( #[inline] /// Provides an immutable view into the object from index `s` inclusive to `e` exclusive - pub fn slice<'a>(&'a self, s: uint, e: uint) -> &'a [$ty] { + pub fn slice<'a>(&'a self, s: usize, e: usize) -> &'a [$ty] { let &$thing(ref dat) = self; dat.slice(s, e) } #[inline] /// Provides an immutable view into the object, up to index `n` exclusive - pub fn slice_to<'a>(&'a self, n: uint) -> &'a [$ty] { + pub fn slice_to<'a>(&'a self, n: usize) -> &'a [$ty] { let &$thing(ref dat) = self; dat.slice_to(n) } #[inline] /// Provides an immutable view into the object, starting from index `n` - pub fn slice_from<'a>(&'a self, n: uint) -> &'a [$ty] { + pub fn slice_from<'a>(&'a self, n: usize) -> &'a [$ty] { let &$thing(ref dat) = self; dat.slice_from(n) } @@ -116,7 +114,7 @@ macro_rules! impl_array_newtype( #[inline] /// Returns the length of the object as an array - pub fn len(&self) -> uint { $len } + pub fn len(&self) -> usize { $len } /// Constructs a new object from raw data pub fn from_slice(data: &[$ty]) -> $thing { @@ -133,9 +131,9 @@ macro_rules! impl_array_newtype( } } - impl Index for $thing { + impl Index for $thing { #[inline] - fn index<'a>(&'a self, idx: &uint) -> &'a $ty { + fn index<'a>(&'a self, idx: &usize) -> &'a $ty { let &$thing(ref data) = self; &data[*idx] } @@ -157,9 +155,9 @@ macro_rules! impl_array_newtype( } } } -) +} -macro_rules! impl_array_newtype_encodable( +macro_rules! impl_array_newtype_encodable { ($thing:ident, $ty:ty, $len:expr) => { impl, E> ::serialize::Decodable for $thing { fn decode(d: &mut D) -> ::std::prelude::Result<$thing, E> { @@ -173,7 +171,7 @@ macro_rules! impl_array_newtype_encodable( } else { unsafe { use std::mem; - let mut ret: [$ty, ..$len] = mem::uninitialized(); + let mut ret: [$ty; $len] = mem::uninitialized(); for i in range(0, len) { ret[i] = try!(d.read_seq_elt(i, |d| Decodable::decode(d))); } @@ -190,9 +188,9 @@ macro_rules! impl_array_newtype_encodable( } } } -) +} -macro_rules! impl_array_newtype_show( +macro_rules! impl_array_newtype_show { ($thing:ident) => { impl ::std::fmt::Show for $thing { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { @@ -200,5 +198,5 @@ macro_rules! impl_array_newtype_show( } } } -) +} diff --git a/src/lib.rs b/src/lib.rs index cf1fa7e7..74f7011c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,12 +28,8 @@ #![crate_type = "rlib"] // Experimental features we need -#![feature(globs)] -#![feature(macro_rules)] #![feature(overloaded_calls)] #![feature(unsafe_destructor)] -#![feature(default_type_params)] -#![feature(struct_variant)] #![feature(unboxed_closure_sugar)] #![feature(unboxed_closures)] @@ -50,18 +46,17 @@ extern crate alloc; extern crate collections; extern crate core; -extern crate num; extern crate rand; -extern crate rustrt; extern crate serialize; -extern crate sync; extern crate test; extern crate time; extern crate "bitcoin-secp256k1-rs" as secp256k1; -extern crate "rust-crypto" as crypto; +extern crate crypto; +#[macro_use] mod internal_macros; +#[macro_use] pub mod macros; pub mod network; pub mod blockdata; diff --git a/src/macros.rs b/src/macros.rs index 2dab6e8d..08ebc7f7 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -16,14 +16,12 @@ //! //! Macros available to users of the Bitcoin library -#![macro_escape] - #[macro_export] -macro_rules! nu_select( - ($($name:pat from $rx:expr => $code:expr),+) => ({ - nu_select!{ $($name from $rx using recv => $code),+ } +macro_rules! nu_select { + ($($name:pat = $rx:expr => $code:expr),+) => ({ + nu_select!{ $($name = $rx, recv => $code),+ } }); - ($($name:pat from $rx:expr using $meth:ident => $code:expr),+) => ({ + ($($name:pat = $rx:expr, $meth:ident => $code:expr),+) => ({ use rustrt::local::Local; use rustrt::task::Task; use sync::comm::Packet; @@ -82,10 +80,10 @@ macro_rules! nu_select( ret } }) -) +} #[macro_export] -macro_rules! user_enum( +macro_rules! user_enum { ($(#[$attr:meta])* pub enum $name:ident { $(#[$doc:meta] $elem:ident <-> $txt:expr),* }) => ( $(#[$attr])* pub enum $name { @@ -114,5 +112,5 @@ macro_rules! user_enum( } } ); -) +} diff --git a/src/network/address.rs b/src/network/address.rs index 7a102696..6a42d7e2 100644 --- a/src/network/address.rs +++ b/src/network/address.rs @@ -28,7 +28,7 @@ pub struct Address { /// Services provided by the peer whose address this is pub services: u64, /// Network byte-order ipv6 address, or ipv4-mapped ipv6 address - pub address: [u8, ..16], + pub address: [u8; 16], /// Network port pub port: u16 } @@ -117,7 +117,7 @@ mod test { let mut addr: IoResult
= deserialize(vec![1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1, 0x20, 0x8d]); - assert!(addr.is_ok()) + assert!(addr.is_ok()); let full = addr.unwrap(); assert!(full.services == 1); assert!(full.address == [0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1]); diff --git a/src/network/constants.rs b/src/network/constants.rs index 9188eeac..c214ad89 100644 --- a/src/network/constants.rs +++ b/src/network/constants.rs @@ -21,7 +21,7 @@ use network::encodable::{ConsensusDecodable, ConsensusEncodable}; use network::serialize::{SimpleEncoder, SimpleDecoder}; -user_enum!( +user_enum! { #[deriving(PartialEq, Eq, Clone, Hash)] #[doc="The cryptocurrency to act on"] pub enum Network { @@ -30,11 +30,11 @@ user_enum!( #[doc="Bitcoin's testnet"] BitcoinTestnet <-> "testnet" } -) +} -pub static PROTOCOL_VERSION: u32 = 70001; -pub static SERVICES: u64 = 0; -pub static USER_AGENT: &'static str = "bitcoin-rust v0.1"; +pub const PROTOCOL_VERSION: u32 = 70001; +pub const SERVICES: u64 = 0; +pub const USER_AGENT: &'static str = "bitcoin-rust v0.1"; /// Return the network magic bytes, which should be encoded little-endian /// at the start of every message @@ -79,7 +79,7 @@ mod tests { assert_eq!(deserialize(vec![0xf9, 0xbe, 0xb4, 0xd9]), Ok(Bitcoin)); assert_eq!(deserialize(vec![0x0b, 0x11, 0x09, 0x07]), Ok(BitcoinTestnet)); - let bad: Result = deserialize(Vec::from_slice("fakenet".as_bytes())); + let bad: Result = deserialize("fakenet".as_bytes().to_vec()); assert!(bad.is_err()); } } diff --git a/src/network/encodable.rs b/src/network/encodable.rs index 9f02581a..ea772a7a 100644 --- a/src/network/encodable.rs +++ b/src/network/encodable.rs @@ -94,10 +94,10 @@ impl, E> ConsensusEncodable for VarInt { fn consensus_encode(&self, s: &mut S) -> Result<(), E> { let &VarInt(n) = self; match n { - 0..0xFC => { (n as u8).consensus_encode(s) } - 0xFD..0xFFFF => { try!(s.emit_u8(0xFD)); (n as u16).consensus_encode(s) } - 0x10000..0xFFFFFFFF => { try!(s.emit_u8(0xFE)); (n as u32).consensus_encode(s) } - _ => { try!(s.emit_u8(0xFF)); (n as u64).consensus_encode(s) } + 0...0xFC => { (n as u8).consensus_encode(s) } + 0xFD...0xFFFF => { try!(s.emit_u8(0xFD)); (n as u16).consensus_encode(s) } + 0x10000...0xFFFFFFFF => { try!(s.emit_u8(0xFE)); (n as u32).consensus_encode(s) } + _ => { try!(s.emit_u8(0xFF)); (n as u64).consensus_encode(s) } } } } @@ -173,9 +173,9 @@ impl, E> ConsensusDecodable for String { // Arrays -macro_rules! impl_array( +macro_rules! impl_array { ( $size:expr ) => ( - impl, E, T:ConsensusEncodable> ConsensusEncodable for [T, ..$size] { + impl, E, T:ConsensusEncodable> ConsensusEncodable for [T; $size] { #[inline] fn consensus_encode(&self, s: &mut S) -> Result<(), E> { for i in self.iter() { try!(i.consensus_encode(s)); } @@ -183,25 +183,25 @@ macro_rules! impl_array( } } - impl, E, T:ConsensusDecodable+Copy> ConsensusDecodable for [T, ..$size] { + impl, E, T:ConsensusDecodable+Copy> ConsensusDecodable for [T; $size] { #[inline] - fn consensus_decode(d: &mut D) -> Result<[T, ..$size], E> { + fn consensus_decode(d: &mut D) -> Result<[T; $size], E> { // Set everything to the first decode - let mut ret = [try!(ConsensusDecodable::consensus_decode(d)), ..$size]; + let mut ret = [try!(ConsensusDecodable::consensus_decode(d)); $size]; // Set the rest for i in range(1, $size) { ret[i] = try!(ConsensusDecodable::consensus_decode(d)); } Ok(ret) } } ); -) +} -impl_array!(2) -impl_array!(4) -impl_array!(8) -impl_array!(12) -impl_array!(16) -impl_array!(32) +impl_array!(2); +impl_array!(4); +impl_array!(8); +impl_array!(12); +impl_array!(16); +impl_array!(32); impl<'a, S:SimpleEncoder, E, T:ConsensusEncodable> ConsensusEncodable for &'a [T] { #[inline] @@ -224,7 +224,7 @@ impl, E, T:ConsensusDecodable> ConsensusDecodable #[inline] fn consensus_decode(d: &mut D) -> Result, E> { let VarInt(len): VarInt = try!(ConsensusDecodable::consensus_decode(d)); - let mut ret = Vec::with_capacity(len as uint); + let mut ret = Vec::with_capacity(len as usize); for _ in range(0, len) { ret.push(try!(ConsensusDecodable::consensus_decode(d))); } Ok(ret) } @@ -247,7 +247,7 @@ impl, E, T:ConsensusDecodable> ConsensusDecodable // Huge danger: if this fails, the remaining uninitialized part of the ThinVec // will be freed. This is ok, but only because the memory is u8, which has no // destructor...and assuming there are no trap representations...very fragile. - for i in range(0, len as uint) { ret.init(i, try!(ConsensusDecodable::consensus_decode(d))); } + for i in range(0, len as usize) { ret.init(i, try!(ConsensusDecodable::consensus_decode(d))); } Ok(ret) } } @@ -282,9 +282,9 @@ impl, E, T:ConsensusDecodable> ConsensusDecodable /// Do a double-SHA256 on some data and return the first 4 bytes -fn sha2_checksum(data: &[u8]) -> [u8, ..4] { +fn sha2_checksum(data: &[u8]) -> [u8; 4] { let checksum = Sha256dHash::from_data(data); - [checksum[0u], checksum[1u], checksum[2u], checksum[3u]] + [checksum[0], checksum[1], checksum[2], checksum[3]] } // Checked data @@ -293,7 +293,7 @@ impl, E> ConsensusEncodable for CheckedData { fn consensus_encode(&self, s: &mut S) -> Result<(), E> { let &CheckedData(ref data) = self; try!((data.len() as u32).consensus_encode(s)); - try!(sha2_checksum(data.as_slice()).consensus_encode(s)) + try!(sha2_checksum(data.as_slice()).consensus_encode(s)); // We can't just pass to the slice encoder since it'll insert a length for ch in data.iter() { try!(ch.consensus_encode(s)); @@ -306,8 +306,8 @@ impl, E> ConsensusDecodable for CheckedData { #[inline] fn consensus_decode(d: &mut D) -> Result { let len: u32 = try!(ConsensusDecodable::consensus_decode(d)); - let checksum: [u8, ..4] = try!(ConsensusDecodable::consensus_decode(d)); - let mut ret = Vec::with_capacity(len as uint); + let checksum: [u8; 4] = try!(ConsensusDecodable::consensus_decode(d)); + let mut ret = Vec::with_capacity(len as usize); for _ in range(0, len) { ret.push(try!(ConsensusDecodable::consensus_decode(d))); } let expected_checksum = sha2_checksum(ret.as_slice()); if expected_checksum != checksum { @@ -319,7 +319,7 @@ impl, E> ConsensusDecodable for CheckedData { } // Tuples -macro_rules! tuple_encode( +macro_rules! tuple_encode { ($($x:ident),*) => ( impl , EE, $($x: ConsensusEncodable),*> ConsensusEncodable for ($($x),*) { #[inline] @@ -339,12 +339,12 @@ macro_rules! tuple_encode( } } ); -) +} -tuple_encode!(A, B) -tuple_encode!(A, B, C, D) -tuple_encode!(A, B, C, D, E, F) -tuple_encode!(A, B, C, D, E, F, G, H) +tuple_encode!(A, B); +tuple_encode!(A, B, C, D); +tuple_encode!(A, B, C, D, E, F); +tuple_encode!(A, B, C, D, E, F, G, H); // References @@ -356,7 +356,7 @@ impl, E, T: ConsensusEncodable> ConsensusEncodable, E, T: ConsensusDecodable> ConsensusDecodable for Box { #[inline] fn consensus_decode(d: &mut D) -> Result, E> { - ConsensusDecodable::consensus_decode(d).map(|res| box res) + ConsensusDecodable::consensus_decode(d).map(|res| Box::new(res)) } } @@ -385,7 +385,7 @@ impl, E, T, fn consensus_decode(d: &mut D) -> Result, E> { let VarInt(len): VarInt = try!(ConsensusDecodable::consensus_decode(d)); - let mut ret = HashMap::with_capacity_and_hasher(len as uint, Default::default()); + let mut ret = HashMap::with_capacity_and_hasher(len as usize, Default::default()); for _ in range(0, len) { ret.insert(try!(ConsensusDecodable::consensus_decode(d)), try!(ConsensusDecodable::consensus_decode(d))); @@ -474,9 +474,9 @@ mod tests { #[test] fn serialize_box_test() { - assert_eq!(serialize(&box 1u8), Ok(vec![1u8])); - assert_eq!(serialize(&box 1u16), Ok(vec![1u8, 0])); - assert_eq!(serialize(&box 1u64), Ok(vec![1u8, 0, 0, 0, 0, 0, 0, 0])); + assert_eq!(serialize(&Box::new(1u8)), Ok(vec![1u8])); + assert_eq!(serialize(&Box::new(1u16)), Ok(vec![1u8, 0])); + assert_eq!(serialize(&Box::new(1u64)), Ok(vec![1u8, 0, 0, 0, 0, 0, 0, 0])); } #[test] @@ -560,8 +560,8 @@ mod tests { fn deserialize_box_test() { let zero: IoResult> = deserialize(vec![0u8]); let one: IoResult> = deserialize(vec![1u8]); - assert_eq!(zero, Ok(box 0)); - assert_eq!(one, Ok(box 1)); + assert_eq!(zero, Ok(Box::new(0))); + assert_eq!(one, Ok(Box::new(1))); } } diff --git a/src/network/listener.rs b/src/network/listener.rs index 3152df31..259f66a5 100644 --- a/src/network/listener.rs +++ b/src/network/listener.rs @@ -21,7 +21,7 @@ use std::io::{IoResult, standard_error, ConnectionFailed}; use network::constants::Network; -use network::message::{mod, SocketResponse, MessageReceived, Verack}; +use network::message::{self, SocketResponse, MessageReceived, Verack}; use network::socket::Socket; /// A message which can be sent on the Bitcoin network @@ -49,7 +49,7 @@ pub trait Listener { try!(sock.send_message(version_message)); // Message loop - spawn(proc() { + spawn(move || { let mut handshake_complete = false; let mut sock = sock; loop { diff --git a/src/network/message.rs b/src/network/message.rs index c0ebd7a1..12f63a71 100644 --- a/src/network/message.rs +++ b/src/network/message.rs @@ -41,7 +41,7 @@ impl, E> ConsensusEncodable for CommandString { #[inline] fn consensus_encode(&self, s: &mut S) -> Result<(), E> { let &CommandString(ref inner_str) = self; - let mut rawbytes = [0u8, ..12]; + let mut rawbytes = [0u8; 12]; rawbytes.clone_from_slice(inner_str.as_bytes().as_slice()); rawbytes.consensus_encode(s) } @@ -50,7 +50,7 @@ impl, E> ConsensusEncodable for CommandString { impl, E> ConsensusDecodable for CommandString { #[inline] fn consensus_decode(d: &mut D) -> Result { - let rawbytes: [u8, ..12] = try!(ConsensusDecodable::consensus_decode(d)); + let rawbytes: [u8; 12] = try!(ConsensusDecodable::consensus_decode(d)); let rv = FromIterator::from_iter(rawbytes.iter().filter_map(|&u| if u > 0 { Some(u as char) } else { None })); Ok(CommandString(rv)) } diff --git a/src/network/message_blockdata.rs b/src/network/message_blockdata.rs index 70a73ad3..c9dbaeb1 100644 --- a/src/network/message_blockdata.rs +++ b/src/network/message_blockdata.rs @@ -82,7 +82,7 @@ impl GetBlocksMessage { } } -impl_consensus_encoding!(GetBlocksMessage, version, locator_hashes, stop_hash) +impl_consensus_encoding!(GetBlocksMessage, version, locator_hashes, stop_hash); impl GetHeadersMessage { /// Construct a new `getheaders` message @@ -95,7 +95,7 @@ impl GetHeadersMessage { } } -impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash) +impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash); impl, E> ConsensusEncodable for Inventory { #[inline] @@ -119,7 +119,7 @@ impl, E> ConsensusDecodable for Inventory { 1 => InvTransaction, 2 => InvBlock, // TODO do not fail here - _ => { fail!("bad inventory type field") } + _ => { panic!("bad inventory type field") } }, hash: try!(ConsensusDecodable::consensus_decode(d)) }) diff --git a/src/network/message_network.rs b/src/network/message_network.rs index 996de6a7..5c093746 100644 --- a/src/network/message_network.rs +++ b/src/network/message_network.rs @@ -82,7 +82,7 @@ impl VersionMessage { impl_consensus_encoding!(VersionMessage, version, services, timestamp, receiver, sender, nonce, - user_agent, start_height, relay) + user_agent, start_height, relay); #[cfg(test)] mod tests { diff --git a/src/network/socket.rs b/src/network/socket.rs index 74815901..7fbc5a5d 100644 --- a/src/network/socket.rs +++ b/src/network/socket.rs @@ -34,7 +34,7 @@ use network::serialize::{RawEncoder, RawDecoder}; use util::misc::prepend_err; /// Format an IP address in the 16-byte bitcoin protocol serialization -fn ipaddr_to_bitcoin_addr(ipaddr: &ip::IpAddr) -> [u8, ..16] { +fn ipaddr_to_bitcoin_addr(ipaddr: &ip::IpAddr) -> [u8; 16] { match *ipaddr { ip::Ipv4Addr(a, b, c, d) => [0, 0, 0, 0, 0, 0, 0, 0, diff --git a/src/util/base58.rs b/src/util/base58.rs index 53ac5509..77d26455 100644 --- a/src/util/base58.rs +++ b/src/util/base58.rs @@ -28,18 +28,18 @@ pub enum Base58Error { /// Checksum was not correct (expected, actual) BadChecksum(u32, u32), /// The length (in bytes) of the object was not correct - InvalidLength(uint), + InvalidLength(usize), /// Version byte(s) were not recognized InvalidVersion(Vec), /// Checked data was less than 4 bytes - TooShort(uint), + TooShort(usize), /// Any other error OtherBase58Error(String) } static BASE58_CHARS: &'static [u8] = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; -static BASE58_DIGITS: [Option, ..128] = [ +static BASE58_DIGITS: [Option; 128] = [ None, None, None, None, None, None, None, None, // 0-7 None, None, None, None, None, None, None, None, // 8-15 None, None, None, None, None, None, None, None, // 16-23 @@ -71,14 +71,14 @@ pub trait FromBase58 { // Build in base 256 for d58 in data.bytes() { // Compute "X = X * 58 + next_digit" in base 256 - if d58 as uint > BASE58_DIGITS.len() { + if d58 as usize > BASE58_DIGITS.len() { return Err(BadByte(d58)); } - let mut carry = match BASE58_DIGITS[d58 as uint] { + let mut carry = match BASE58_DIGITS[d58 as usize] { Some(d58) => d58 as u32, None => { return Err(BadByte(d58)); } }; - for d256 in scratch.mut_iter().rev() { + for d256 in scratch.iter_mut().rev() { carry += *d256 as u32 * 58; *d256 = carry as u8; carry /= 256; @@ -91,7 +91,7 @@ pub trait FromBase58 { .map(|_| 0) .collect(); // Copy rest of string - ret.extend(scratch.move_iter().skip_while(|&x| x == 0)); + ret.extend(scratch.into_iter().skip_while(|&x| x == 0)); FromBase58::from_base58_layout(ret) } @@ -121,8 +121,8 @@ pub fn base58_encode_slice(data: &[u8]) -> String { for &d256 in data.base58_layout().iter() { // Compute "X = X * 256 + next_digit" in base 58 let mut carry = d256 as u32; - for d58 in scratch.mut_iter().rev() { - carry += *d58 as u32 << 8; + for d58 in scratch.iter_mut().rev() { + carry += (*d58 as u32) << 8; *d58 = (carry % 58) as u8; carry /= 58; } @@ -136,8 +136,8 @@ pub fn base58_encode_slice(data: &[u8]) -> String { .map(|_| BASE58_CHARS[0]) .collect()); // Copy rest of string - ret.as_mut_vec().extend(scratch.move_iter().skip_while(|&x| x == 0) - .map(|x| BASE58_CHARS[x as uint])); + ret.as_mut_vec().extend(scratch.into_iter().skip_while(|&x| x == 0) + .map(|x| BASE58_CHARS[x as usize])); ret } } @@ -164,7 +164,7 @@ pub trait ToBase58 { // Trivial implementations for slices and vectors impl<'a> ToBase58 for &'a [u8] { - fn base58_layout(&self) -> Vec { Vec::from_slice(*self) } + fn base58_layout(&self) -> Vec { self.to_vec() } fn to_base58(&self) -> String { base58_encode_slice(*self) } } @@ -174,7 +174,7 @@ impl ToBase58 for Vec { } impl ToBase58 for ThinVec { - fn base58_layout(&self) -> Vec { Vec::from_slice(self.as_slice()) } + fn base58_layout(&self) -> Vec { self.as_slice().to_vec() } fn to_base58(&self) -> String { base58_encode_slice(self.as_slice()) } } diff --git a/src/util/error.rs b/src/util/error.rs index fafb5d26..0a6c88fb 100644 --- a/src/util/error.rs +++ b/src/util/error.rs @@ -25,7 +25,7 @@ pub type BitcoinResult = Result; #[deriving(PartialEq, Eq, Show, Clone)] pub enum BitcoinError { /// An I/O error - IoError(IoError), + InputOutput(IoError), /// An object was attempted to be added twice DuplicateHash, /// Some operation was attempted on a block (or blockheader) that doesn't exist diff --git a/src/util/hash.rs b/src/util/hash.rs index ca1c385d..30b4a77f 100644 --- a/src/util/hash.rs +++ b/src/util/hash.rs @@ -19,10 +19,11 @@ use core::char::from_digit; use core::cmp::min; use std::default::Default; use std::fmt; +use std::io::extensions::u64_from_be_bytes; use std::io::MemWriter; use std::mem::transmute; use std::hash; -use serialize::json::{mod, ToJson}; +use serialize::json::{self, ToJson}; use crypto::digest::Digest; use crypto::sha2::Sha256; @@ -30,12 +31,11 @@ use crypto::ripemd160::Ripemd160; use network::encodable::{ConsensusDecodable, ConsensusEncodable}; use network::serialize::{RawEncoder, BitcoinHash, SimpleDecoder}; -use util::uint::Uint128; use util::uint::Uint256; /// A Bitcoin hash, 32-bytes, computed from x as SHA256(SHA256(x)) -pub struct Sha256dHash([u8, ..32]); -impl_array_newtype!(Sha256dHash, u8, 32) +pub struct Sha256dHash([u8; 32]); +impl_array_newtype!(Sha256dHash, u8, 32); impl ::std::fmt::Show for Sha256dHash { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { @@ -44,12 +44,18 @@ impl ::std::fmt::Show for Sha256dHash { } /// A RIPEMD-160 hash -pub struct Ripemd160Hash([u8, ..20]); -impl_array_newtype!(Ripemd160Hash, u8, 20) +pub struct Ripemd160Hash([u8; 20]); +impl_array_newtype!(Ripemd160Hash, u8, 20); -/// A "hasher" which just truncates +/// A "hasher" which just truncates and adds data to its state. Should +/// only be used for hashtables indexed by "already random" data such +/// as SHA2 hashes +#[deriving(Clone, PartialEq, Eq, Show)] pub struct DumbHasher; +/// The state of a `DumbHasher` +pub struct DumbHasherState([u8; 8]); + /// A 32-bit hash obtained by truncating a real hash #[deriving(Clone, PartialEq, Eq, Show)] pub struct Hash32((u8, u8, u8, u8)); @@ -64,65 +70,34 @@ pub struct Hash64((u8, u8, u8, u8, u8, u8, u8, u8)); // Allow these to be used as a key for Rust's HashMap et. al. -impl hash::Hash for Sha256dHash { +impl hash::Hash for Sha256dHash { #[inline] - fn hash(&self, state: &mut u64) { - use std::mem; - let myarr: [u64, ..4] = unsafe { mem::transmute(*self) }; - *state = myarr[0]; + fn hash(&self, state: &mut DumbHasherState) { + let &Sha256dHash(ref hash) = self; + let &DumbHasherState(ref mut arr) = state; + for i in range(0, 8) { + arr[i] += hash[i]; + } } } -impl hash::Hash for Uint256 { +impl hash::Hasher for DumbHasher { #[inline] - fn hash(&self, state: &mut u64) { - use std::mem; - let myarr: [u64, ..4] = unsafe { mem::transmute(*self) }; - *state = myarr[0]; - } -} - -impl hash::Hash for Uint128 { - #[inline] - fn hash(&self, state: &mut u64) { - use std::mem; - let myarr: [u64, ..2] = unsafe { mem::transmute(*self) }; - *state = myarr[0]; - } -} - -impl hash::Hash for Hash32 { - #[inline] - fn hash(&self, state: &mut u64) { - let &Hash32((a, b, c, d)) = self; - *state = a as u64 + (b as u64 << 8) + (c as u64 << 16) + (d as u64 << 24); - } -} - -impl hash::Hash for Hash48 { - #[inline] - fn hash(&self, state: &mut u64) { - let &Hash48((a, b, c, d, e, f)) = self; - *state = a as u64 + (b as u64 << 8) + (c as u64 << 16) + (d as u64 << 24) + - (e as u64 << 32) + (f as u64 << 40); - } -} - -impl hash::Hash for Hash64 { - #[inline] - fn hash(&self, state: &mut u64) { - let &Hash64((a, b, c, d, e, f, g, h)) = self; - *state = a as u64 + (b as u64 << 8) + (c as u64 << 16) + (d as u64 << 24) + - (e as u64 << 32) + (f as u64 << 40) + (g as u64 << 48) + (h as u64 << 56); - } -} - -impl hash::Hasher for DumbHasher { - #[inline] - fn hash>(&self, value: &T) -> u64 { - let mut ret = 0u64; + fn hash>(&self, value: &T) -> u64 { + let mut ret = DumbHasherState([0; 8]); value.hash(&mut ret); - ret + let DumbHasherState(res) = ret; + u64_from_be_bytes(res.as_slice(), 0, 8) + } +} + +impl hash::Writer for DumbHasherState { + #[inline] + fn write(&mut self, msg: &[u8]) { + let &DumbHasherState(ref mut arr) = self; + for (n, &ch) in msg.iter().enumerate() { + arr[n % 8] += ch; + } } } @@ -134,7 +109,7 @@ impl Default for DumbHasher { impl Ripemd160Hash { /// Create a hash by hashing some data pub fn from_data(data: &[u8]) -> Ripemd160Hash { - let mut ret = [0, ..20]; + let mut ret = [0; 20]; let mut rmd = Ripemd160::new(); rmd.input(data); rmd.result(ret.as_mut_slice()); @@ -146,7 +121,7 @@ impl Ripemd160Hash { // in the C++ reference client impl Default for Sha256dHash { #[inline] - fn default() -> Sha256dHash { Sha256dHash([0u8, ..32]) } + fn default() -> Sha256dHash { Sha256dHash([0u8; 32]) } } impl Sha256dHash { @@ -166,8 +141,8 @@ impl Sha256dHash { #[inline] pub fn into_le(self) -> Uint256 { let Sha256dHash(data) = self; - let mut ret: [u64, ..4] = unsafe { transmute(data) }; - for x in ret.as_mut_slice().mut_iter() { *x = x.to_le(); } + let mut ret: [u64; 4] = unsafe { transmute(data) }; + for x in ret.as_mut_slice().iter_mut() { *x = x.to_le(); } Uint256(ret) } @@ -176,8 +151,8 @@ impl Sha256dHash { pub fn into_be(self) -> Uint256 { let Sha256dHash(mut data) = self; data.reverse(); - let mut ret: [u64, ..4] = unsafe { transmute(data) }; - for x in ret.mut_iter() { *x = x.to_be(); } + let mut ret: [u64; 4] = unsafe { transmute(data) }; + for x in ret.iter_mut() { *x = x.to_be(); } Uint256(ret) } @@ -209,9 +184,9 @@ impl Sha256dHash { pub fn le_hex_string(&self) -> String { let &Sha256dHash(data) = self; let mut ret = String::with_capacity(64); - for i in range(0u, 32) { - ret.push_char(from_digit((data[i] / 0x10) as uint, 16).unwrap()); - ret.push_char(from_digit((data[i] & 0x0f) as uint, 16).unwrap()); + for i in range(0, 32) { + ret.push_char(from_digit((data[i] / 0x10) as usize, 16).unwrap()); + ret.push_char(from_digit((data[i] & 0x0f) as usize, 16).unwrap()); } ret } @@ -220,9 +195,9 @@ impl Sha256dHash { pub fn be_hex_string(&self) -> String { let &Sha256dHash(data) = self; let mut ret = String::with_capacity(64); - for i in range(0u, 32).rev() { - ret.push_char(from_digit((data[i] / 0x10) as uint, 16).unwrap()); - ret.push_char(from_digit((data[i] & 0x0f) as uint, 16).unwrap()); + for i in range(0, 32).rev() { + ret.push_char(from_digit((data[i] / 0x10) as usize, 16).unwrap()); + ret.push_char(from_digit((data[i] & 0x0f) as usize, 16).unwrap()); } ret } @@ -258,7 +233,7 @@ impl, E> ::serialize::Decodable for Sha256dHash } let raw_str = try!(hex_str.as_slice().from_hex() .map_err(|_| d.error("non-hexadecimal hash string"))); - let mut ret = [0u8, ..32]; + let mut ret = [0u8; 32]; for i in range(0, 32) { ret[i] = raw_str[31 - i]; } @@ -267,19 +242,19 @@ impl, E> ::serialize::Decodable for Sha256dHash } // Consensus encoding (little-endian) -impl_newtype_consensus_encoding!(Hash32) -impl_newtype_consensus_encoding!(Hash48) -impl_newtype_consensus_encoding!(Hash64) -impl_newtype_consensus_encoding!(Sha256dHash) +impl_newtype_consensus_encoding!(Hash32); +impl_newtype_consensus_encoding!(Hash48); +impl_newtype_consensus_encoding!(Hash64); +impl_newtype_consensus_encoding!(Sha256dHash); impl fmt::LowerHex for Sha256dHash { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let &Sha256dHash(data) = self; - let mut rv = [0, ..64]; + let mut rv = [0; 64]; let mut hex = data.iter().rev().map(|n| *n).enumerate(); for (i, ch) in hex { - rv[2*i] = from_digit(ch as uint / 16, 16).unwrap() as u8; - rv[2*i + 1] = from_digit(ch as uint % 16, 16).unwrap() as u8; + rv[2*i] = from_digit(ch as usize / 16, 16).unwrap() as u8; + rv[2*i + 1] = from_digit(ch as usize % 16, 16).unwrap() as u8; } f.write(rv.as_slice()) } diff --git a/src/util/iter.rs b/src/util/iter.rs index 12ff0d50..d7a83a3e 100644 --- a/src/util/iter.rs +++ b/src/util/iter.rs @@ -41,7 +41,7 @@ impl> Iterator<(A, A)> for Pair { } #[inline] - fn size_hint(&self) -> (uint, Option) { + fn size_hint(&self) -> (usize, Option) { match self.iter.size_hint() { (n, None) => (n/2, None), (n, Some(m)) => (n/2, Some(m/2)) diff --git a/src/util/misc.rs b/src/util/misc.rs index 10ed1b75..68b970e8 100644 --- a/src/util/misc.rs +++ b/src/util/misc.rs @@ -62,7 +62,7 @@ pub fn prepend_err(s: &str, res: IoResult) -> IoResult { IoError { kind: err.kind, desc: err.desc, - detail: Some(format!("{:s}: {:}", s, match err.detail { Some(s) => s, None => String::new() })) + detail: Some(format!("{}: {}", s, match err.detail { Some(s) => s, None => String::new() })) } }) } @@ -71,14 +71,14 @@ pub fn prepend_err(s: &str, res: IoResult) -> IoResult { pub fn consume_err(s: &str, res: IoResult) { match res { Ok(_) => {}, - Err(e) => { println!("{:s}: {:}", s, e); } + Err(e) => { println!("{}: {}", s, e); } }; } /// Search for `needle` in the vector `haystack` and remove every /// instance of it, returning the number of instances removed. /// Loops through the vector opcode by opcode, skipping pushed data. -pub fn script_find_and_remove(haystack: &mut Vec, needle: &[u8]) -> uint { +pub fn script_find_and_remove(haystack: &mut Vec, needle: &[u8]) -> usize { if needle.len() > haystack.len() { return 0; } if needle.len() == 0 { return 0; } diff --git a/src/util/mod.rs b/src/util/mod.rs index 167ae696..846d75ce 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -28,15 +28,15 @@ pub mod uint; /// A trait which allows numbers to act as fixed-size bit arrays pub trait BitArray { /// Is bit set? - fn bit(&self, idx: uint) -> bool; + fn bit(&self, idx: usize) -> bool; /// Returns an array which is just the bits from start to end - fn bit_slice(&self, start: uint, end: uint) -> Self; + fn bit_slice(&self, start: usize, end: usize) -> Self; /// Bitwise and with `n` ones - fn mask(&self, n: uint) -> Self; + fn mask(&self, n: usize) -> Self; /// Trailing zeros - fn trailing_zeros(&self) -> uint; + fn trailing_zeros(&self) -> usize; } diff --git a/src/util/patricia_tree.rs b/src/util/patricia_tree.rs index 61312107..e4bce52b 100644 --- a/src/util/patricia_tree.rs +++ b/src/util/patricia_tree.rs @@ -38,7 +38,7 @@ pub struct PatriciaTree { skip_len: u8 } -impl+Shl+Shr, V> PatriciaTree { +impl+Shl+Shr, V> PatriciaTree { /// Constructs a new Patricia tree pub fn new() -> PatriciaTree { PatriciaTree { @@ -51,7 +51,7 @@ impl+Shl+Shr, V> PatriciaTree } /// Lookup a value by exactly matching `key` and return a referenc - pub fn lookup_mut<'a>(&'a mut self, key: &K, key_len: uint) -> Option<&'a mut V> { + pub fn lookup_mut<'a>(&'a mut self, key: &K, key_len: usize) -> Option<&'a mut V> { // Caution: `lookup_mut` never modifies its self parameter (in fact its // internal recursion uses a non-mutable self, so we are OK to just // transmute our self pointer into a mutable self before passing it in. @@ -60,28 +60,28 @@ impl+Shl+Shr, V> PatriciaTree } /// Lookup a value by exactly matching `key` and return a mutable reference - pub fn lookup<'a>(&'a self, key: &K, key_len: uint) -> Option<&'a V> { + pub fn lookup<'a>(&'a self, key: &K, key_len: usize) -> Option<&'a V> { let mut node = self; let mut key_idx = 0; loop { // If the search key is shorter than the node prefix, there is no // way we can match, so fail. - if key_len - key_idx < node.skip_len as uint { + if key_len - key_idx < node.skip_len as usize { return None; } // Key fails to match prefix --- no match - if node.skip_prefix != key.bit_slice(key_idx, key_idx + node.skip_len as uint) { + if node.skip_prefix != key.bit_slice(key_idx, key_idx + node.skip_len as usize) { return None; } // Key matches prefix: if they are an exact match, return the data - if node.skip_len as uint == key_len - key_idx { + if node.skip_len as usize == key_len - key_idx { return node.data.as_ref(); } else { // Key matches prefix: search key longer than node key, recurse - key_idx += 1 + node.skip_len as uint; + key_idx += 1 + node.skip_len as usize; let subtree = if key.bit(key_idx - 1) { &node.child_r } else { &node.child_l }; match subtree { &Some(ref bx) => { @@ -96,23 +96,23 @@ impl+Shl+Shr, V> PatriciaTree /// Inserts a value with key `key`, returning true on success. If a value is already /// stored against `key`, do nothing and return false. #[inline] - pub fn insert(&mut self, key: &K, key_len: uint, value: V) -> bool { + pub fn insert(&mut self, key: &K, key_len: usize, value: V) -> bool { self.real_insert(key, key_len, value, false) } /// Inserts a value with key `key`, returning true on success. If a value is already /// stored against `key`, overwrite it and return false. #[inline] - pub fn insert_or_update(&mut self, key: &K, key_len: uint, value: V) -> bool { + pub fn insert_or_update(&mut self, key: &K, key_len: usize, value: V) -> bool { self.real_insert(key, key_len, value, true) } - fn real_insert(&mut self, key: &K, key_len: uint, value: V, overwrite: bool) -> bool { + fn real_insert(&mut self, key: &K, key_len: usize, value: V, overwrite: bool) -> bool { let mut node = self; let mut idx = 0; loop { // Mask in case search key is shorter than node key - let slice_len = cmp::min(node.skip_len as uint, key_len - idx); + let slice_len = cmp::min(node.skip_len as usize, key_len - idx); let masked_prefix = node.skip_prefix.mask(slice_len); let key_slice = key.bit_slice(idx, idx + slice_len); @@ -128,20 +128,20 @@ impl+Shl+Shr, V> PatriciaTree let (insert, neighbor) = if key_slice.bit(diff) { (&mut tmp.child_r, &mut tmp.child_l) } else { (&mut tmp.child_l, &mut tmp.child_r) }; - *insert = Some(box PatriciaTree { + *insert = Some(Box::new(PatriciaTree { data: None, child_l: None, child_r: None, skip_prefix: key.bit_slice(idx + diff + 1, key_len), skip_len: (key_len - idx - diff - 1) as u8 - }); - *neighbor = Some(box PatriciaTree { + })); + *neighbor = Some(Box::new(PatriciaTree { data: value_neighbor, child_l: child_l, child_r: child_r, skip_prefix: tmp.skip_prefix >> (diff + 1), skip_len: tmp.skip_len - diff as u8 - 1 - }); + })); // Chop the prefix down tmp.skip_len = diff as u8; tmp.skip_prefix = tmp.skip_prefix.mask(diff); @@ -154,7 +154,7 @@ impl+Shl+Shr, V> PatriciaTree let slice_len = key_len - idx; // Search key is shorter than skip prefix: truncate the prefix and attach // the old data as a child - if node.skip_len as uint > slice_len { + if node.skip_len as usize > slice_len { // Remove the old node's children let child_l = node.child_l.take(); let child_r = node.child_r.take(); @@ -162,13 +162,13 @@ impl+Shl+Shr, V> PatriciaTree // Put the old data in a new child, with the remainder of the prefix let new_child = if node.skip_prefix.bit(slice_len) { &mut node.child_r } else { &mut node.child_l }; - *new_child = Some(box PatriciaTree { + *new_child = Some(Box::new(PatriciaTree { data: value_neighbor, child_l: child_l, child_r: child_r, skip_prefix: node.skip_prefix >> (slice_len + 1), skip_len: node.skip_len - slice_len as u8 - 1 - }); + })); // Chop the prefix down and put the new data in place node.skip_len = slice_len as u8; node.skip_prefix = key_slice; @@ -176,7 +176,7 @@ impl+Shl+Shr, V> PatriciaTree return true; } // If we have an exact match, great, insert it - else if node.skip_len as uint == slice_len { + else if node.skip_len as usize == slice_len { if node.data.is_none() { node.data = Some(value); return true; @@ -189,18 +189,18 @@ impl+Shl+Shr, V> PatriciaTree // Search key longer than node key, recurse else { let tmp = node; // hack to appease borrowck - idx += tmp.skip_len as uint + 1; + idx += tmp.skip_len as usize + 1; let subtree = if key.bit(idx - 1) { &mut tmp.child_r } else { &mut tmp.child_l }; // Recurse, adding a new node if necessary if subtree.is_none() { - *subtree = Some(box PatriciaTree { + *subtree = Some(Box::new(PatriciaTree { data: None, child_l: None, child_r: None, skip_prefix: key.bit_slice(idx, key_len), skip_len: key_len as u8 - idx as u8 - }); + })); } // subtree.get_mut_ref is a &mut Box here, so &mut ** gets a &mut U node = &mut **subtree.as_mut().unwrap(); @@ -211,23 +211,23 @@ impl+Shl+Shr, V> PatriciaTree /// Deletes a value with key `key`, returning it on success. If no value with /// the given key is found, return None - pub fn delete(&mut self, key: &K, key_len: uint) -> Option { + pub fn delete(&mut self, key: &K, key_len: usize) -> Option { /// Return value is (deletable, actual return value), where `deletable` is true /// is true when the entire node can be deleted (i.e. it has no children) - fn recurse+Shr+Shl, V>(tree: &mut PatriciaTree, key: &K, key_len: uint) -> (bool, Option) { + fn recurse+Shr+Shl, V>(tree: &mut PatriciaTree, key: &K, key_len: usize) -> (bool, Option) { // If the search key is shorter than the node prefix, there is no // way we can match, so fail. - if key_len < tree.skip_len as uint { + if key_len < tree.skip_len as usize { return (false, None); } // Key fails to match prefix --- no match - if tree.skip_prefix != key.mask(tree.skip_len as uint) { + if tree.skip_prefix != key.mask(tree.skip_len as usize) { return (false, None); } // If we are here, the key matches the prefix - if tree.skip_len as uint == key_len { + if tree.skip_len as usize == key_len { // Exact match -- delete and return let ret = tree.data.take(); let bit = tree.child_r.is_some(); @@ -238,17 +238,17 @@ impl+Shl+Shr, V> PatriciaTree } match (tree.child_l.take(), tree.child_r.take()) { (Some(_), Some(_)) => unreachable!(), - (Some(box PatriciaTree { data, child_l, child_r, skip_prefix, skip_len }), None) | - (None, Some(box PatriciaTree { data, child_l, child_r, skip_prefix, skip_len })) => { + (Some(Box::new(PatriciaTree { data, child_l, child_r, skip_prefix, skip_len })), None) | + (None, Some(Box::new(PatriciaTree { data, child_l, child_r, skip_prefix, skip_len }))) => { tree.data = data; tree.child_l = child_l; tree.child_r = child_r; let new_bit = if bit { let ret: K = One::one(); - ret << (tree.skip_len as uint) } + ret << (tree.skip_len as usize) } else { Zero::zero() }; tree.skip_prefix = tree.skip_prefix + new_bit + - (skip_prefix << (1 + tree.skip_len as uint)); + (skip_prefix << (1 + tree.skip_len as usize)); tree.skip_len += 1 + skip_len; return (false, ret); } @@ -258,7 +258,7 @@ impl+Shl+Shr, V> PatriciaTree } // Otherwise, the key is longer than the prefix and we need to recurse - let next_bit = key.bit(tree.skip_len as uint); + let next_bit = key.bit(tree.skip_len as usize); // Recursively get the return value. This awkward scope is required // to shorten the time we mutably borrow the node's children -- we // might want to borrow the sibling later, so the borrow needs to end. @@ -271,8 +271,8 @@ impl+Shl+Shr, V> PatriciaTree } // Otherwise, do it let (delete_child, ret) = recurse(&mut **target.as_mut().unwrap(), - &key.shr(&(tree.skip_len as uint + 1)), - key_len - tree.skip_len as uint - 1); + &key.shr(&(tree.skip_len as usize + 1)), + key_len - tree.skip_len as usize - 1); if delete_child { target.take(); } @@ -296,17 +296,17 @@ impl+Shl+Shr, V> PatriciaTree return (false, ret); } // One child? Consolidate - (bit, Some(box PatriciaTree { data, child_l, child_r, skip_prefix, skip_len }), None) | - (bit, None, Some(box PatriciaTree { data, child_l, child_r, skip_prefix, skip_len })) => { + (bit, Some(Box::new(PatriciaTree { data, child_l, child_r, skip_prefix, skip_len })), None) | + (bit, None, Some(Box::new(PatriciaTree { data, child_l, child_r, skip_prefix, skip_len }))) => { tree.data = data; tree.child_l = child_l; tree.child_r = child_r; let new_bit = if bit { let ret: K = One::one(); - ret << (tree.skip_len as uint) } + ret << (tree.skip_len as usize) } else { Zero::zero() }; tree.skip_prefix = tree.skip_prefix + new_bit + - (skip_prefix << (1 + tree.skip_len as uint)); + (skip_prefix << (1 + tree.skip_len as usize)); tree.skip_len += 1 + skip_len; return (false, ret); } @@ -321,8 +321,8 @@ impl+Shl+Shr, V> PatriciaTree } /// Count all the nodes - pub fn node_count(&self) -> uint { - fn recurse(node: &Option>>) -> uint { + pub fn node_count(&self) -> usize { + fn recurse(node: &Option>>) -> usize { match node { &Some(ref node) => { 1 + recurse(&node.child_l) + recurse(&node.child_r) } &None => 0 @@ -354,30 +354,30 @@ impl+Shl+Shr, V> PatriciaTree impl PatriciaTree { /// Print the entire tree pub fn print<'a>(&'a self) { - fn recurse<'a, K:BitArray, V:Show>(tree: &'a PatriciaTree, depth: uint) { - for i in range(0, tree.skip_len as uint) { - print!("{:}", if tree.skip_prefix.bit(i) { 1u } else { 0 }); + fn recurse<'a, K:BitArray, V:Show>(tree: &'a PatriciaTree, depth: usize) { + for i in range(0, tree.skip_len as usize) { + print!("{:}", if tree.skip_prefix.bit(i) { 1 } else { 0 }); } println!(": {:}", tree.data); // left gets no indentation match tree.child_l { Some(ref t) => { - for _ in range(0, depth + tree.skip_len as uint) { + for _ in range(0, depth + tree.skip_len as usize) { print!("-"); } print!("0"); - recurse(&**t, depth + tree.skip_len as uint + 1); + recurse(&**t, depth + tree.skip_len as usize + 1); } None => { } } // right one gets indentation match tree.child_r { Some(ref t) => { - for _ in range(0, depth + tree.skip_len as uint) { + for _ in range(0, depth + tree.skip_len as usize) { print!("_"); } print!("1"); - recurse(&**t, depth + tree.skip_len as uint + 1); + recurse(&**t, depth + tree.skip_len as usize + 1); } None => { } } @@ -529,8 +529,8 @@ mod tests { use network::serialize::{deserialize, serialize}; use util::hash::Sha256dHash; - use util::uint::Uint128; - use util::uint::Uint256; + use util::usize::Uint128; + use util::usize::Uint256; use util::patricia_tree::PatriciaTree; #[test] @@ -601,14 +601,14 @@ mod tests { // Do the actual test -- note that we also test insertion and deletion // at the root here. for i in range(0u32, 10) { - tree.insert(&Zero::zero(), i as uint, i); + tree.insert(&Zero::zero(), i as usize, i); } for i in range(0u32, 10) { - let m = tree.lookup(&Zero::zero(), i as uint); + let m = tree.lookup(&Zero::zero(), i as usize); assert_eq!(m, Some(&i)); } for i in range(0u32, 10) { - let m = tree.delete(&Zero::zero(), i as uint); + let m = tree.delete(&Zero::zero(), i as usize); assert_eq!(m, Some(i)); } // Check that the chunder was unharmed diff --git a/src/util/thinvec.rs b/src/util/thinvec.rs index 201d1af7..29750a87 100644 --- a/src/util/thinvec.rs +++ b/src/util/thinvec.rs @@ -44,7 +44,7 @@ impl ThinVec { } else if capacity == 0 { ThinVec::new() } else { - let size = (capacity as uint).checked_mul(&mem::size_of::()) + let size = (capacity as usize).checked_mul(&mem::size_of::()) .expect("ThinVec::reserve: capacity overflow"); let ptr = allocate(size, mem::min_align_of::()); ThinVec { ptr: ptr as *mut T, cap: capacity } @@ -55,7 +55,7 @@ impl ThinVec { #[inline] pub fn from_vec(mut v: Vec) -> ThinVec { v.shrink_to_fit(); - assert!(v.len() <= u32::MAX as uint); + assert!(v.len() <= u32::MAX as usize); let ret = ThinVec { ptr: v.as_mut_ptr(), cap: v.len() as u32 }; unsafe { mem::forget(v); } ret @@ -69,49 +69,49 @@ impl ThinVec { /// Mutable iterator over elements of the vector #[inline] - pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> { - self.as_mut_slice().mut_iter() + pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> { + self.as_mut_slice().iter_mut() } /// Get vector as mutable slice #[inline] pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { - unsafe { mem::transmute(raw::Slice { data: self.ptr as *const T, len: self.cap as uint }) } + unsafe { mem::transmute(raw::Slice { data: self.ptr as *const T, len: self.cap as usize }) } } /// Accessor #[inline] - pub unsafe fn get<'a>(&'a self, index: uint) -> &'a T { + pub unsafe fn get<'a>(&'a self, index: usize) -> &'a T { &self.as_slice()[index] } /// Mutable accessor NOT for first use #[inline] - pub unsafe fn get_mut<'a>(&'a mut self, index: uint) -> &'a mut T { + pub unsafe fn get_mut<'a>(&'a mut self, index: usize) -> &'a mut T { &mut self.as_mut_slice()[index] } /// Mutable accessor for first use #[inline] - pub unsafe fn init<'a>(&'a mut self, index: uint, value: T) { - ptr::write(&mut *self.ptr.offset(index as int), value); + pub unsafe fn init<'a>(&'a mut self, index: usize, value: T) { + ptr::write(&mut *self.ptr.offset(index as isize), value); } /// Returns a slice starting from `index` #[inline] - pub fn slice_from<'a>(&'a self, index: uint) -> &'a [T] { + pub fn slice_from<'a>(&'a self, index: usize) -> &'a [T] { self.as_slice().slice_from(index) } /// Returns a slice ending just before `index` #[inline] - pub fn slice_to<'a>(&'a self, index: uint) -> &'a [T] { + pub fn slice_to<'a>(&'a self, index: usize) -> &'a [T] { self.as_slice().slice_to(index) } /// Returns a slice starting from `s` ending just before `e` #[inline] - pub fn slice<'a>(&'a self, s: uint, e: uint) -> &'a [T] { + pub fn slice<'a>(&'a self, s: usize, e: usize) -> &'a [T] { self.as_slice().slice(s, e) } @@ -122,18 +122,18 @@ impl ThinVec { if mem::size_of::() == 0 { unsafe { mem::forget(value); } } else { - let old_size = (self.cap - 1) as uint * mem::size_of::(); - let new_size = self.cap as uint * mem::size_of::(); - if new_size < old_size { fail!("ThinVec::push: cap overflow") } + let old_size = (self.cap - 1) as usize * mem::size_of::(); + let new_size = self.cap as usize * mem::size_of::(); + if new_size < old_size { panic!("ThinVec::push: cap overflow") } unsafe { self.ptr = if old_size == 0 { allocate(new_size, mem::min_align_of::()) as *mut T } else { reallocate(self.ptr as *mut u8, new_size, - mem::min_align_of::(), self.cap as uint) as *mut T + mem::min_align_of::(), self.cap as usize) as *mut T }; - ptr::write(&mut *self.ptr.offset((self.cap - 1) as int), value); + ptr::write(&mut *self.ptr.offset((self.cap - 1) as isize), value); } } } @@ -141,14 +141,14 @@ impl ThinVec { /// Set the length of the vector to the minimum of the current capacity and new capacity pub unsafe fn reserve(&mut self, new_cap: u32) { if new_cap > self.cap { - let new_size = (new_cap as uint).checked_mul(&mem::size_of::()) + let new_size = (new_cap as usize).checked_mul(&mem::size_of::()) .expect("ThinVec::reserve: capacity overflow"); self.ptr = if self.cap == 0 { allocate(new_size, mem::min_align_of::()) as *mut T } else { reallocate(self.ptr as *mut u8, new_size, - mem::min_align_of::(), self.cap as uint) as *mut T + mem::min_align_of::(), self.cap as usize) as *mut T }; self.cap = new_cap; } @@ -165,29 +165,33 @@ impl ThinVec { /// Push an entire slice onto the ThinVec #[inline] pub fn push_all(&mut self, other: &[T]) { - let old_cap = self.cap as uint; + let old_cap = self.cap as usize; unsafe { self.reserve_additional(other.len() as u32); } // Copied from vec.rs, which claims this will be optimized to a memcpy // if T is Copy for i in range(0, other.len()) { unsafe { - ptr::write(self.as_mut_slice().unsafe_mut_ref(old_cap + i), + ptr::write(self.as_mut_slice().unsafe_mut(old_cap + i), other.unsafe_get(i).clone()); } } } +} - /// Constructor from a slice - #[inline] - pub fn from_slice(v: &[T]) -> ThinVec { - ThinVec::from_vec(Vec::from_slice(v)) +impl CloneableVector for ThinVec { + fn to_vec(&self) -> Vec { + self.as_slice().to_vec() + } + + fn into_vec(self) -> Vec { + unsafe { Vec::from_raw_parts(self.cap as usize, self.cap as usize, self.ptr) } } } impl Slice for ThinVec { #[inline] fn as_slice<'a>(&'a self) -> &'a [T] { - unsafe { mem::transmute(raw::Slice { data: self.ptr as *const T, len: self.cap as uint }) } + unsafe { mem::transmute(raw::Slice { data: self.ptr as *const T, len: self.cap as usize }) } } } @@ -198,7 +202,7 @@ impl Clone for ThinVec { // Copied from vec.rs, which claims this will be optimized to a memcpy // if T is Copy for i in range(0, self.len()) { - ptr::write(ret.as_mut_slice().unsafe_mut_ref(i), + ptr::write(ret.as_mut_slice().unsafe_mut(i), self.as_slice().unsafe_get(i).clone()); } ret @@ -212,7 +216,7 @@ impl FromIterator for ThinVec { #[inline] fn from_iter>(iter: I) -> ThinVec { let (lower, _) = iter.size_hint(); - assert!(lower <= u32::MAX as uint); + assert!(lower <= u32::MAX as usize); unsafe { let mut vector = ThinVec::with_capacity(lower as u32); for (n, elem) in iter.enumerate() { @@ -235,7 +239,7 @@ impl Extendable for ThinVec { unsafe { self.reserve_additional(lower as u32); } for (n, elem) in iter.enumerate() { if n < lower { - unsafe { self.init(old_cap as uint + n, elem) }; + unsafe { self.init(old_cap as usize + n, elem) }; } else { self.push(elem); } @@ -245,7 +249,7 @@ impl Extendable for ThinVec { impl Collection for ThinVec { #[inline] - fn len(&self) -> uint { self.cap as uint } + fn len(&self) -> usize { self.cap as usize } } impl fmt::Show for ThinVec { @@ -273,7 +277,7 @@ impl Drop for ThinVec { } if mem::size_of::() != 0 { deallocate(self.ptr as *mut u8, - self.cap as uint * mem::size_of::(), + self.cap as usize * mem::size_of::(), mem::min_align_of::()); } } @@ -292,12 +296,12 @@ mod tests { let mut thinvec = ThinVec::with_capacity(cap); for i in range(0, cap) { - thinvec.init(i as uint, Some(box i)); + thinvec.init(i, Some(Box::new(i))); } for i in range(0, cap) { - assert_eq!(thinvec.get_mut(i as uint).take(), Some(box i)); - assert_eq!(thinvec.get_mut(i as uint).take(), None); + assert_eq!(thinvec.get_mut(i).take(), Some(Box::new(i))); + assert_eq!(thinvec.get_mut(i).take(), None); } } } diff --git a/src/util/uint.rs b/src/util/uint.rs index c15add6c..4fc92b4d 100644 --- a/src/util/uint.rs +++ b/src/util/uint.rs @@ -24,12 +24,12 @@ use std::num::{Zero, One}; use network::serialize::RawEncoder; use util::BitArray; -macro_rules! construct_uint( +macro_rules! construct_uint { ($name:ident, $n_words:expr) => ( /// Little-endian large integer type #[repr(C)] - pub struct $name(pub [u64, ..$n_words]); - impl_array_newtype!($name, u64, $n_words) + pub struct $name(pub [u64; $n_words]); + impl_array_newtype!($name, u64, $n_words); impl $name { /// Conversion to u32 @@ -41,20 +41,20 @@ macro_rules! construct_uint( /// Return the least number of bits needed to represent the number #[inline] - pub fn bits(&self) -> uint { + pub fn bits(&self) -> uzise { let &$name(ref arr) = self; - for i in range(1u, $n_words) { - if arr[$n_words - i] > 0 { return (0x40 * ($n_words - i + 1)) - arr[$n_words - i].leading_zeros() as uint; } + for i in range(1, $n_words) { + if arr[$n_words - i] > 0 { return (0x40 * ($n_words - i + 1)) - arr[$n_words - i].leading_zeros() as usize; } } - 0x40 - arr[0].leading_zeros() as uint + 0x40 - arr[0].leading_zeros() } /// Multiplication by u32 pub fn mul_u32(&self, other: u32) -> $name { let &$name(ref arr) = self; - let mut carry = [0u64, ..$n_words]; - let mut ret = [0u64, ..$n_words]; - for i in range(0u, $n_words) { + let mut carry = [0u64; $n_words]; + let mut ret = [0u64; $n_words]; + for i in range(0, $n_words) { let upper = other as u64 * (arr[i] >> 32); let lower = other as u64 * (arr[i] & 0xFFFFFFFF); if i < 3 { @@ -69,7 +69,7 @@ macro_rules! construct_uint( impl FromPrimitive for $name { #[inline] fn from_u64(init: u64) -> Option<$name> { - let mut ret = [0, ..$n_words]; + let mut ret = [0; $n_words]; ret[0] = init; Some($name(ret)) } @@ -81,13 +81,13 @@ macro_rules! construct_uint( } impl Zero for $name { - fn zero() -> $name { $name([0, ..$n_words]) } + fn zero() -> $name { $name([0; $n_words]) } fn is_zero(&self) -> bool { *self == Zero::zero() } } impl One for $name { fn one() -> $name { - $name({ let mut ret = [0, ..$n_words]; ret[0] = 1; ret }) + $name({ let mut ret = [0; $n_words]; ret[0] = 1; ret }) } } @@ -95,10 +95,10 @@ macro_rules! construct_uint( fn add(&self, other: &$name) -> $name { let &$name(ref me) = self; let &$name(ref you) = other; - let mut ret = [0u64, ..$n_words]; - let mut carry = [0u64, ..$n_words]; + let mut ret = [0u64; $n_words]; + let mut carry = [0u64; $n_words]; let mut b_carry = false; - for i in range(0u, $n_words) { + for i in range(0, $n_words) { ret[i] = me[i] + you[i]; if i < $n_words - 1 && ret[i] < me[i] { carry[i + 1] = 1; @@ -120,7 +120,7 @@ macro_rules! construct_uint( fn mul(&self, other: &$name) -> $name { let mut me = *self; // TODO: be more efficient about this - for i in range(0u, 2 * $n_words) { + for i in range(0, 2 * $n_words) { me = me + me.mul_u32((other >> (32 * i)).low_u32()) << (32 * i); } me @@ -131,7 +131,7 @@ macro_rules! construct_uint( fn div(&self, other: &$name) -> $name { let mut sub_copy = *self; let mut shift_copy = *other; - let mut ret = [0u64, ..$n_words]; + let mut ret = [0u64; $n_words]; let my_bits = self.bits(); let your_bits = other.bits(); @@ -163,21 +163,21 @@ macro_rules! construct_uint( impl BitArray for $name { #[inline] - fn bit(&self, index: uint) -> bool { + fn bit(&self, index: usize) -> bool { let &$name(ref arr) = self; arr[index / 64] & (1 << (index % 64)) != 0 } #[inline] - fn bit_slice(&self, start: uint, end: uint) -> $name { + fn bit_slice(&self, start: usize, end: usize) -> $name { (self >> start).mask(end - start) } #[inline] - fn mask(&self, n: uint) -> $name { + fn mask(&self, n: usize) -> $name { let &$name(ref arr) = self; - let mut ret = [0, ..$n_words]; - for i in range(0u, $n_words) { + let mut ret = [0; $n_words]; + for i in range(0, $n_words) { if n >= 0x40 * (i + 1) { ret[i] = arr[i]; } else { @@ -189,12 +189,12 @@ macro_rules! construct_uint( } #[inline] - fn trailing_zeros(&self) -> uint { + fn trailing_zeros(&self) -> usize { let &$name(ref arr) = self; - for i in range(0u, $n_words - 1) { - if arr[i] > 0 { return (0x40 * i) + arr[i].trailing_zeros() as uint; } + for i in range(0, $n_words - 1) { + if arr[i] > 0 { return (0x40 * i) + arr[i].trailing_zeros(); } } - (0x40 * ($n_words - 1)) + arr[3].trailing_zeros() as uint + (0x40 * ($n_words - 1)) + arr[3].trailing_zeros() } } @@ -203,8 +203,8 @@ macro_rules! construct_uint( fn bitand(&self, other: &$name) -> $name { let &$name(ref arr1) = self; let &$name(ref arr2) = other; - let mut ret = [0u64, ..$n_words]; - for i in range(0u, $n_words) { + let mut ret = [0u64; $n_words]; + for i in range(0, $n_words) { ret[i] = arr1[i] & arr2[i]; } $name(ret) @@ -216,8 +216,8 @@ macro_rules! construct_uint( fn bitxor(&self, other: &$name) -> $name { let &$name(ref arr1) = self; let &$name(ref arr2) = other; - let mut ret = [0u64, ..$n_words]; - for i in range(0u, $n_words) { + let mut ret = [0u64; $n_words]; + for i in range(0, $n_words) { ret[i] = arr1[i] ^ arr2[i]; } $name(ret) @@ -229,8 +229,8 @@ macro_rules! construct_uint( fn bitor(&self, other: &$name) -> $name { let &$name(ref arr1) = self; let &$name(ref arr2) = other; - let mut ret = [0u64, ..$n_words]; - for i in range(0u, $n_words) { + let mut ret = [0u64; $n_words]; + for i in range(0, $n_words) { ret[i] = arr1[i] | arr2[i]; } $name(ret) @@ -241,21 +241,21 @@ macro_rules! construct_uint( #[inline] fn not(&self) -> $name { let &$name(ref arr) = self; - let mut ret = [0u64, ..$n_words]; - for i in range(0u, $n_words) { + let mut ret = [0u64; $n_words]; + for i in range(0, $n_words) { ret[i] = !arr[i]; } $name(ret) } } - impl Shl for $name { - fn shl(&self, shift: &uint) -> $name { + impl Shl for $name { + fn shl(&self, shift: &usize) -> $name { let &$name(ref original) = self; - let mut ret = [0u64, ..$n_words]; + let mut ret = [0u64; $n_words]; let word_shift = *shift / 64; let bit_shift = *shift % 64; - for i in range(0u, $n_words) { + for i in range(0, $n_words) { // Shift if bit_shift < 64 && i + word_shift < $n_words { ret[i + word_shift] += original[i] << bit_shift; @@ -269,14 +269,14 @@ macro_rules! construct_uint( } } - impl Shr for $name { + impl Shr for $name { #[allow(unsigned_negate)] - fn shr(&self, shift: &uint) -> $name { + fn shr(&self, shift: &usize) -> $name { let &$name(ref original) = self; - let mut ret = [0u64, ..$n_words]; + let mut ret = [0u64; $n_words]; let word_shift = *shift / 64; let bit_shift = *shift % 64; - for i in range(0u, $n_words) { + for i in range(0, $n_words) { // Shift if bit_shift < 64 && i - word_shift < $n_words { ret[i - word_shift] += original[i] >> bit_shift; @@ -330,15 +330,15 @@ macro_rules! construct_uint( impl, E> ::network::encodable::ConsensusDecodable for $name { fn consensus_decode(d: &mut D) -> Result<$name, E> { use network::encodable::ConsensusDecodable; - let ret: [u64, ..$n_words] = try!(ConsensusDecodable::consensus_decode(d)); + let ret: [u64; $n_words] = try!(ConsensusDecodable::consensus_decode(d)); Ok($name(ret)) } } ); -) +} -construct_uint!(Uint256, 4) -construct_uint!(Uint128, 2) +construct_uint!(Uint256, 4); +construct_uint!(Uint128, 2); impl Uint256 { /// Increment by 1 @@ -384,11 +384,11 @@ mod tests { // Try to read the following lines out loud quickly let mut shl: Uint256 = from_u64(70000).unwrap(); - shl = shl << 100u; + shl = shl << 100; assert_eq!(shl.bits(), 117); - shl = shl << 100u; + shl = shl << 100; assert_eq!(shl.bits(), 217); - shl = shl << 100u; + shl = shl << 100; assert_eq!(shl.bits(), 0); // Bit set check @@ -424,9 +424,9 @@ mod tests { let add = init.add(©); assert_eq!(add, Uint256([0xBD5B7DDFBD5B7DDEu64, 1, 0, 0])); // Bitshifts - let shl = add << 88u; + let shl = add << 88; assert_eq!(shl, Uint256([0u64, 0xDFBD5B7DDE000000, 0x1BD5B7D, 0])); - let shr = shl >> 40u; + let shr = shl >> 40; assert_eq!(shr, Uint256([0x7DDE000000000000u64, 0x0001BD5B7DDFBD5B, 0, 0])); // Increment let mut incr = shr; diff --git a/src/wallet/address.rs b/src/wallet/address.rs index d75dbc0b..53d07a0d 100644 --- a/src/wallet/address.rs +++ b/src/wallet/address.rs @@ -38,15 +38,6 @@ pub struct Address { } impl Address { - /// Creates an address the raw 20 bytes of a hash - #[inline] - pub fn from_slice(network: Network, data: &[u8]) -> Address { - Address { - network: network, - hash: Ripemd160Hash::from_slice(data) - } - } - /// Returns a byteslice view of the `Address` --- note that no network information /// is contained in this. #[inline] @@ -80,6 +71,22 @@ impl Address { } } +/// Conversion from other types into an address +pub trait ToAddress { + /// Copies `self` into a new `Address` + fn to_address(&self, network: Network) -> Address; +} + +impl<'a> ToAddress for &'a [u8] { + #[inline] + fn to_address(&self, network: Network) -> Address { + Address { + network: network, + hash: Ripemd160Hash::from_slice(*self) + } + } +} + impl ToBase58 for Address { fn base58_layout(&self) -> Vec { let mut ret = vec![ diff --git a/src/wallet/address_index.rs b/src/wallet/address_index.rs index b03c5fad..8ea66376 100644 --- a/src/wallet/address_index.rs +++ b/src/wallet/address_index.rs @@ -21,18 +21,46 @@ use std::collections::HashMap; use collections::hash::sip::hash_with_keys; +use secp256k1::key::SecretKey; + use blockdata::transaction::{TxOut, PayToPubkeyHash}; use blockdata::utxoset::UtxoSet; use blockdata::script::Script; use network::constants::Network; use wallet::address::Address; use wallet::wallet::Wallet; -use util::hash::Sha256dHash; +use util::hash::{DumbHasher, Sha256dHash}; + +/// The type of a wallet-spendable txout +#[deriving(Clone, PartialEq, Eq, Show)] +pub enum WalletTxOutType { + /// Pay-to-address transaction redeemable using an ECDSA key + PayToAddress(SecretKey), + /// Undetermined + Unknown +} + + +/// A txout that is spendable by the wallet +#[deriving(Clone, PartialEq, Eq, Show)] +pub struct WalletTxOut { + /// The TXID of the transaction this output is part of + pub txid: Sha256dHash, + /// The index of the output in its transaction + pub vout: u32, + /// The blockheight at which this output appeared in the blockchain + pub height: u32, + /// The actual output + pub txo: TxOut, + /// A classification of the output + pub kind: WalletTxOutType +} /// An address index #[deriving(Clone, PartialEq, Eq, Show)] pub struct AddressIndex { - index: HashMap>, + tentative_index: HashMap>, + index: HashMap<(Sha256dHash, u32), Vec, DumbHasher>, network: Network, k1: u64, k2: u64 @@ -44,21 +72,35 @@ impl AddressIndex { pub fn new(utxo_set: &UtxoSet, wallet: &Wallet) -> AddressIndex { let (k1, k2) = wallet.siphash_key(); let mut ret = AddressIndex { - index: HashMap::with_capacity(utxo_set.n_utxos() / 256), + tentative_index: HashMap::with_capacity(utxo_set.n_utxos() / 256), + index: HashMap::with_hasher(DumbHasher), network: wallet.network(), k1: k1, k2: k2 }; for (key, idx, txo, height) in utxo_set.iter() { if ret.admissible_txo(txo) { - ret.index.insert_or_update_with(txo.script_pubkey.clone(), - vec![(key, idx, txo.clone(), height)], - |_, v| v.push((key, idx, txo.clone(), height))); + let new = WalletTxOut { + txid: key, + vout: idx, + height: height, + txo: txo.clone(), + kind: Unknown + }; + ret.tentative_index.find_or_insert(txo.script_pubkey.clone(), vec![]).push(new); } } ret } + /// + #[inline] + pub fn index_wallet_txo(&mut self, wtx: &WalletTxOut, kind: WalletTxOutType) { + let mut new = wtx.clone(); + new.kind = kind; + self.index.find_or_insert((wtx.txid, wtx.vout), vec![]).push(new); + } + /// A filtering function used for creating a small address index. #[inline] pub fn admissible_address(&self, addr: &Address) -> bool { @@ -77,8 +119,8 @@ impl AddressIndex { /// Lookup a txout by its scriptpubkey. Returns a slice because there /// may be more than one for any given scriptpubkey. #[inline] - pub fn find_by_script<'a>(&'a self, pubkey: &Script) -> &'a [(Sha256dHash, uint, TxOut, uint)] { - self.index.find(pubkey).map(|v| v.as_slice()).unwrap_or(&[]) + pub fn find_by_script<'a>(&'a self, pubkey: &Script) -> &'a [WalletTxOut] { + self.tentative_index.find(pubkey).map(|v| v.as_slice()).unwrap_or(&[]) } } diff --git a/src/wallet/bip32.rs b/src/wallet/bip32.rs index 358aa5c6..f7bfde55 100644 --- a/src/wallet/bip32.rs +++ b/src/wallet/bip32.rs @@ -35,16 +35,16 @@ use util::base58::{Base58Error, FromBase58, ToBase58}; /// A chain code -pub struct ChainCode([u8, ..32]); -impl_array_newtype!(ChainCode, u8, 32) -impl_array_newtype_show!(ChainCode) -impl_array_newtype_encodable!(ChainCode, u8, 32) +pub struct ChainCode([u8; 32]); +impl_array_newtype!(ChainCode, u8, 32); +impl_array_newtype_show!(ChainCode); +impl_array_newtype_encodable!(ChainCode, u8, 32); /// A fingerprint -pub struct Fingerprint([u8, ..4]); -impl_array_newtype!(Fingerprint, u8, 4) -impl_array_newtype_show!(Fingerprint) -impl_array_newtype_encodable!(Fingerprint, u8, 4) +pub struct Fingerprint([u8; 4]); +impl_array_newtype!(Fingerprint, u8, 4); +impl_array_newtype_show!(Fingerprint); +impl_array_newtype_encodable!(Fingerprint, u8, 4); impl Default for Fingerprint { fn default() -> Fingerprint { Fingerprint([0, 0, 0, 0]) } @@ -56,7 +56,7 @@ pub struct ExtendedPrivKey { /// The network this key is to be used on pub network: Network, /// How many derivations this key is from the master (which is 0) - pub depth: uint, + pub depth: u8, /// Fingerprint of the parent key (0 for master) pub parent_fingerprint: Fingerprint, /// Child number of the key used to derive from parent (0 for master) @@ -73,7 +73,7 @@ pub struct ExtendedPubKey { /// The network this key is to be used on pub network: Network, /// How many derivations this key is from the master (which is 0) - pub depth: uint, + pub depth: u8, /// Fingerprint of the parent key pub parent_fingerprint: Fingerprint, /// Child number of the key used to derive from parent (0 for master) @@ -129,7 +129,7 @@ pub enum Error { impl ExtendedPrivKey { /// Construct a new master key from a seed value pub fn new_master(network: Network, seed: &[u8]) -> Result { - let mut result = [0, ..64]; + let mut result = [0; 64]; let mut hmac = Hmac::new(Sha512::new(), b"Bitcoin seed".as_slice()); hmac.input(seed); hmac.raw_result(result.as_mut_slice()); @@ -156,7 +156,7 @@ impl ExtendedPrivKey { /// Private->Private child key derivation pub fn ckd_priv(&self, i: ChildNumber) -> Result { - let mut result = [0, ..64]; + let mut result = [0; 64]; let mut hmac = Hmac::new(Sha512::new(), self.chain_code.as_slice()); match i { Normal(n) => { @@ -190,9 +190,9 @@ impl ExtendedPrivKey { } /// Returns the HASH160 of the chaincode - pub fn identifier(&self) -> [u8, ..20] { - let mut sha2_res = [0, ..32]; - let mut ripemd_res = [0, ..20]; + pub fn identifier(&self) -> [u8; 20] { + let mut sha2_res = [0; 32]; + let mut ripemd_res = [0; 20]; // Compute extended public key let pk = ExtendedPubKey::from_private(self); // Do SHA256 of just the ECDSA pubkey @@ -242,7 +242,7 @@ impl ExtendedPubKey { hmac.input(self.public_key.as_slice()); u64_to_be_bytes(n as u64, 4, |raw| hmac.input(raw)); - let mut result = [0, ..64]; + let mut result = [0; 64]; hmac.raw_result(result.as_mut_slice()); let sk = try!(SecretKey::from_slice(result.slice_to(32)).map_err(EcdsaError)); @@ -262,9 +262,9 @@ impl ExtendedPubKey { } /// Returns the HASH160 of the chaincode - pub fn identifier(&self) -> [u8, ..20] { - let mut sha2_res = [0, ..32]; - let mut ripemd_res = [0, ..20]; + pub fn identifier(&self) -> [u8; 20] { + let mut sha2_res = [0; 32]; + let mut ripemd_res = [0; 20]; // Do SHA256 of just the ECDSA pubkey let mut sha2 = Sha256::new(); sha2.input(self.public_key.as_slice()); @@ -321,9 +321,9 @@ impl FromBase58 for ExtendedPrivKey { network: match data.slice_to(4) { [0x04, 0x88, 0xAD, 0xE4] => Bitcoin, [0x04, 0x35, 0x83, 0x94] => BitcoinTestnet, - _ => { return Err(InvalidVersion(Vec::from_slice(data.slice_to(4)))); } + _ => { return Err(InvalidVersion(data.slice_to(4).to_vec())); } }, - depth: data[4] as uint, + depth: data[4], parent_fingerprint: Fingerprint::from_slice(data.slice(5, 9)), child_number: child_number, chain_code: ChainCode::from_slice(data.slice(13, 45)), @@ -372,9 +372,9 @@ impl FromBase58 for ExtendedPubKey { network: match data.slice_to(4) { [0x04, 0x88, 0xB2, 0x1E] => Bitcoin, [0x04, 0x35, 0x87, 0xCF] => BitcoinTestnet, - _ => { return Err(InvalidVersion(Vec::from_slice(data.slice_to(4)))); } + _ => { return Err(InvalidVersion(data.slice_to(4).to_vec())); } }, - depth: data[4] as uint, + depth: data[4], parent_fingerprint: Fingerprint::from_slice(data.slice(5, 9)), child_number: child_number, chain_code: ChainCode::from_slice(data.slice(13, 45)), diff --git a/src/wallet/wallet.rs b/src/wallet/wallet.rs index 329ead4c..0544740d 100644 --- a/src/wallet/wallet.rs +++ b/src/wallet/wallet.rs @@ -25,7 +25,7 @@ use secp256k1::key::PublicKey; use blockdata::utxoset::UtxoSet; use network::constants::Network; -use wallet::bip32::{mod, ChildNumber, ExtendedPrivKey, ExtendedPubKey, Normal, Hardened}; +use wallet::bip32::{self, ChildNumber, ExtendedPrivKey, ExtendedPubKey, Normal, Hardened}; use wallet::address::Address; use wallet::address_index::AddressIndex; @@ -273,8 +273,8 @@ impl Wallet { let sk = try!(master.ckd_priv(cnum).map_err(Bip32Error)); let pk = ExtendedPubKey::from_private(&sk); let addr = Address::from_key(pk.network, &pk.public_key); - for &(_, _, ref out, _) in index.find_by_script(&addr.script_pubkey()).iter() { - ret += out.value; + for out in index.find_by_script(&addr.script_pubkey()).iter() { + ret += out.txo.value; } } // Sum external balance @@ -285,8 +285,8 @@ impl Wallet { let sk = try!(master.ckd_priv(cnum).map_err(Bip32Error)); let pk = ExtendedPubKey::from_private(&sk); let addr = Address::from_key(pk.network, &pk.public_key); - for &(_, _, ref out, _) in index.find_by_script(&addr.script_pubkey()).iter() { - ret += out.value; + for out in index.find_by_script(&addr.script_pubkey()).iter() { + ret += out.txo.value; } }