// -*- rust -*- fn main() { let int a = 1; let int b = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; check (b == 1); check (a == 2); check (~(0xf0) & 0xff == 0xf); check (0xf0 | 0xf == 0xff); check (0xf << 4 == 0xf0); check (0xf0 >> 4 == 0xf); check (-16 >>> 2 == -4); check (0b1010_1010 | 0b0101_0101 == 0xff); } // -*- rust -*- fn main() { let int a = 1; let int b = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (~(0xf0) & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } // -*- rust -*- fn main() { let int a = 1; let int b = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; check (b == 1); check (a == 2); check (~(0xf0) & 0xff == 0xf); check (0xf0 | 0xf == 0xff); check (0xf << 4 == 0xf0); check (0xf0 >> 4 == 0xf); check (-16 >>> 2 == -4); check (0b1010_1010 | 0b0101_0101 == 0xff); } // -*- rust -*- fn main() { let int a = 1; let int b = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (~(0xf0) & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } // -*- rust -*- fn main() { let int a = 1; let int b = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (!(0xf0) & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } // -*- rust -*- fn main() { let int a = 1; let int b = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } // -*- rust -*- fn main() { let int a = 1; let int b = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); assert (-1000 >> 3 == 536870787); } // -*- rust -*- fn main() { let a: int = 1; let b: int = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); assert (-1000 >> 3 == 536870787); } // -*- rust -*- fn main() { let a: int = 1; let b: int = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); assert (-1000 >> 3 == 536870787); } // -*- rust -*- #[cfg(target_arch = "x86")] fn target() { assert (-1000 >> 3 == 536870787); } #[cfg(target_arch = "x86_64")] fn target() { // FIXME (974) Can't lex this as a single integer assert (-1000 >> 3 == 23058430 * 1000000000 * 100 + 92 * 100000000 + 13693827); } fn general() { let a: int = 1; let b: int = 2; a ^= b; b ^= a; a = a ^ b; log a; log b; assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } fn main() { general(); target(); } // -*- rust -*- #[cfg(target_arch = "x86")] fn target() { assert (-1000 >> 3 == 536870787); } #[cfg(target_arch = "x86_64")] fn target() { // FIXME (974) Can't lex this as a single integer assert (-1000 >> 3 == 23058430 * 1000000000 * 100 + 92 * 100000000 + 13693827); } fn general() { let a: int = 1; let b: int = 2; a ^= b; b ^= a; a = a ^ b; log_full(core::debug, a); log_full(core::debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } fn main() { general(); target(); } // -*- rust -*- #[cfg(target_arch = "x86")] fn target() { assert (-1000 >> 3 == 536870787); } #[cfg(target_arch = "x86_64")] fn target() { // FIXME (974) Can't lex this as a single integer assert (-1000 >> 3 == 23058430 * 1000000000 * 100 + 92 * 100000000 + 13693827); } fn general() { let a: int = 1; let b: int = 2; a ^= b; b ^= a; a = a ^ b; log(debug, a); log(debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } fn main() { general(); target(); } // -*- rust -*- #[cfg(target_arch = "x86")] fn target() { assert (-1000 >> 3 == 536870787); } #[cfg(target_arch = "x86_64")] fn target() { assert (-1000 >> 3 == 2305843009213693827); } fn general() { let a: int = 1; let b: int = 2; a ^= b; b ^= a; a = a ^ b; log(debug, a); log(debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } fn main() { general(); target(); } // -*- rust -*- #[cfg(target_arch = "x86")] fn target() { assert (-1000 >> 3 == 536870787); } #[cfg(target_arch = "x86_64")] fn target() { assert (-1000 >> 3 == 2305843009213693827); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; log(debug, a); log(debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >>> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } fn main() { general(); target(); } // -*- rust -*- #[cfg(target_arch = "x86")] fn target() { assert (-1000 as uint >> 3u == 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert (-1000 as uint >> 3u == 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; log(debug, a); log(debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] fn target() { assert (-1000 as uint >> 3u == 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert (-1000 as uint >> 3u == 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; log(debug, a); log(debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] fn target() { assert (-1000 as uint >> 3u == 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert (-1000 as uint >> 3u == 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; log(debug, a); log(debug, b); assert (b == 1); assert (a == 2); assert (!0xf0 & 0xff == 0xf); assert (0xf0 | 0xf == 0xff); assert (0xf << 4 == 0xf0); assert (0xf0 >> 4 == 0xf); assert (-16 >> 2 == -4); assert (0b1010_1010 | 0b0101_0101 == 0xff); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] fn target() { fail_unless!((-1000 as uint >> 3u == 536870787u)); } #[cfg(target_arch = "x86_64")] fn target() { fail_unless!((-1000 as uint >> 3u == 2305843009213693827u)); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; log(debug, a); log(debug, b); fail_unless!((b == 1)); fail_unless!((a == 2)); fail_unless!((!0xf0 & 0xff == 0xf)); fail_unless!((0xf0 | 0xf == 0xff)); fail_unless!((0xf << 4 == 0xf0)); fail_unless!((0xf0 >> 4 == 0xf)); fail_unless!((-16 >> 2 == -4)); fail_unless!((0b1010_1010 | 0b0101_0101 == 0xff)); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] fn target() { fail_unless!((-1000 as uint >> 3u == 536870787u)); } #[cfg(target_arch = "x86_64")] fn target() { fail_unless!((-1000 as uint >> 3u == 2305843009213693827u)); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; debug!(a); debug!(b); fail_unless!((b == 1)); fail_unless!((a == 2)); fail_unless!((!0xf0 & 0xff == 0xf)); fail_unless!((0xf0 | 0xf == 0xff)); fail_unless!((0xf << 4 == 0xf0)); fail_unless!((0xf0 >> 4 == 0xf)); fail_unless!((-16 >> 2 == -4)); fail_unless!((0b1010_1010 | 0b0101_0101 == 0xff)); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] fn target() { assert!((-1000 as uint >> 3u == 536870787u)); } #[cfg(target_arch = "x86_64")] fn target() { assert!((-1000 as uint >> 3u == 2305843009213693827u)); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; debug!(a); debug!(b); assert!((b == 1)); assert!((a == 2)); assert!((!0xf0 & 0xff == 0xf)); assert!((0xf0 | 0xf == 0xff)); assert!((0xf << 4 == 0xf0)); assert!((0xf0 >> 4 == 0xf)); assert!((-16 >> 2 == -4)); assert!((0b1010_1010 | 0b0101_0101 == 0xff)); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert!((-1000 as uint >> 3u == 536870787u)); } #[cfg(target_arch = "x86_64")] fn target() { assert!((-1000 as uint >> 3u == 2305843009213693827u)); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; debug!(a); debug!(b); assert!((b == 1)); assert!((a == 2)); assert!((!0xf0 & 0xff == 0xf)); assert!((0xf0 | 0xf == 0xff)); assert!((0xf << 4 == 0xf0)); assert!((0xf0 >> 4 == 0xf)); assert!((-16 >> 2 == -4)); assert!((0b1010_1010 | 0b0101_0101 == 0xff)); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; debug!(a); debug!(b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0 & 0xff, 0xf); assert_eq!(0xf0 | 0xf, 0xff); assert_eq!(0xf << 4, 0xf0); assert_eq!(0xf0 >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010 | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; info!(a); info!(b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0 & 0xff, 0xf); assert_eq!(0xf0 | 0xf, 0xff); assert_eq!(0xf << 4, 0xf0); assert_eq!(0xf0 >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010 | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; info2!("{}", a); info2!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0 & 0xff, 0xf); assert_eq!(0xf0 | 0xf, 0xff); assert_eq!(0xf << 4, 0xf0); assert_eq!(0xf0 >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010 | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; info!("{}", a); info!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0 & 0xff, 0xf); assert_eq!(0xf0 | 0xf, 0xff); assert_eq!(0xf << 4, 0xf0); assert_eq!(0xf0 >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010 | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; info!("{}", a); info!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0 & 0xff, 0xf); assert_eq!(0xf0 | 0xf, 0xff); assert_eq!(0xf << 4, 0xf0); assert_eq!(0xf0 >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010 | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0 & 0xff, 0xf); assert_eq!(0xf0 | 0xf, 0xff); assert_eq!(0xf << 4, 0xf0); assert_eq!(0xf0 >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010 | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0i & 0xff, 0xf); assert_eq!(0xf0i | 0xf, 0xff); assert_eq!(0xfi << 4, 0xf0); assert_eq!(0xf0i >> 4, 0xf); assert_eq!(-16i >> 2, -4); assert_eq!(0b1010_1010i | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(any(target_arch = "x86", target_arch = "arm"))] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0i & 0xff, 0xf); assert_eq!(0xf0i | 0xf, 0xff); assert_eq!(0xfi << 4, 0xf0); assert_eq!(0xf0i >> 4, 0xf); assert_eq!(-16i >> 2, -4); assert_eq!(0b1010_1010i | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(any(target_arch = "x86", target_arch = "arm"))] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0i & 0xff, 0xf); assert_eq!(0xf0i | 0xf, 0xff); assert_eq!(0xfi << 4, 0xf0); assert_eq!(0xf0i >> 4, 0xf); assert_eq!(-16i >> 2, -4); assert_eq!(0b1010_1010i | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(any(target_arch = "x86", target_arch = "arm"))] fn target() { assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] fn target() { assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0i & 0xff, 0xf); assert_eq!(0xf0i | 0xf, 0xff); assert_eq!(0xfi << 4, 0xf0); assert_eq!(0xf0i >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010i | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(any(target_arch = "x86", target_arch = "arm"))] fn target() { assert_eq!(-1000 as uint >> 3_usize, 536870787_usize); } #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] fn target() { assert_eq!(-1000 as uint >> 3_usize, 2305843009213693827_usize); } fn general() { let mut a: int = 1; let mut b: int = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0_isize & 0xff, 0xf); assert_eq!(0xf0_isize | 0xf, 0xff); assert_eq!(0xf_isize << 4, 0xf0); assert_eq!(0xf0_isize >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010_isize | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[cfg(any(target_arch = "x86", target_arch = "arm"))] fn target() { assert_eq!(-1000 as usize >> 3_usize, 536870787_usize); } #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] fn target() { assert_eq!(-1000 as usize >> 3_usize, 2305843009213693827_usize); } fn general() { let mut a: isize = 1; let mut b: isize = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0_isize & 0xff, 0xf); assert_eq!(0xf0_isize | 0xf, 0xff); assert_eq!(0xf_isize << 4, 0xf0); assert_eq!(0xf0_isize >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010_isize | 0b0101_0101, 0xff); } pub fn main() { general(); target(); } // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(negate_unsigned)] #[cfg(any(target_arch = "x86", target_arch = "arm"))] fn target() { assert_eq!(-1000 as usize >> 3_usize, 536870787_usize); } #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] fn target() { assert_eq!(-1000 as usize >> 3_usize, 2305843009213693827_usize); } fn general() { let mut a: isize = 1; let mut b: isize = 2; a ^= b; b ^= a; a = a ^ b; println!("{}", a); println!("{}", b); assert_eq!(b, 1); assert_eq!(a, 2); assert_eq!(!0xf0_isize & 0xff, 0xf); assert_eq!(0xf0_isize | 0xf, 0xff); assert_eq!(0xf_isize << 4, 0xf0); assert_eq!(0xf0_isize >> 4, 0xf); assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010_isize | 0b0101_0101, 0xff); } pub fn main() { general(); target(); }