---

yaml
---
r: 145229
b: refs/heads/try2
c: 604667f
h: refs/heads/master
i:
  145227: dece025
v: v3

Author: DanielRosenwasser

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: cbd1eefbd350797b783df119fed7956d7e1c74ad
+refs/heads/try2: 604667fa82f72309ee692c77086e22766cc3a8ee
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -248,7 +248,7 @@ string_body : non_double_quote
             | '\x5c' [ '\x22' | common_escape ] ;
 
 common_escape : '\x5c'
-              | 'n' | 'r' | 't'
+              | 'n' | 'r' | 't' | '0'
               | 'x' hex_digit 2
               | 'u' hex_digit 4
               | 'U' hex_digit 8 ;

branches/try2/src/libextra/num/bigint.rs

@@ -697,13 +697,6 @@ impl BigUint {
         }
         return BigUint::new(shifted);
     }
-
-    /// Determines the fewest bits necessary to express the BigUint.
-    pub fn bits(&self) -> uint {
-        if self.is_zero() { return 0; }
-        let zeros = self.data.last().leading_zeros();
-        return self.data.len()*BigDigit::bits - (zeros as uint);
-    }
 }
 
 #[cfg(target_word_size = "64")]
@@ -1122,23 +1115,10 @@ trait RandBigInt {
 
     /// Generate a random BigInt of the given bit size.
     fn gen_bigint(&mut self, bit_size: uint) -> BigInt;
-
-    /// Generate a random BigUint less than the given bound. Fails
-    /// when the bound is zero.
-    fn gen_biguint_below(&mut self, bound: &BigUint) -> BigUint;
-
-    /// Generate a random BigUint within the given range. The lower
-    /// bound is inclusive; the upper bound is exclusive. Fails when
-    /// the upper bound is not greater than the lower bound.
-    fn gen_biguint_range(&mut self, lbound: &BigUint, ubound: &BigUint) -> BigUint;
-
-    /// Generate a random BigInt within the given range. The lower
-    /// bound is inclusive; the upper bound is exclusive. Fails when
-    /// the upper bound is not greater than the lower bound.
-    fn gen_bigint_range(&mut self, lbound: &BigInt, ubound: &BigInt) -> BigInt;
 }
 
 impl<R: Rng> RandBigInt for R {
+    /// Generate a random BigUint of the given bit size.
     fn gen_biguint(&mut self, bit_size: uint) -> BigUint {
         let (digits, rem) = bit_size.div_rem(&BigDigit::bits);
         let mut data = vec::with_capacity(digits+1);
@@ -1152,6 +1132,7 @@ impl<R: Rng> RandBigInt for R {
         return BigUint::new(data);
     }
 
+    /// Generate a random BigInt of the given bit size.
     fn gen_bigint(&mut self, bit_size: uint) -> BigInt {
         // Generate a random BigUint...
         let biguint = self.gen_biguint(bit_size);
@@ -1173,32 +1154,6 @@ impl<R: Rng> RandBigInt for R {
         };
         return BigInt::from_biguint(sign, biguint);
     }
-
-    fn gen_biguint_below(&mut self, bound: &BigUint) -> BigUint {
-        assert!(!bound.is_zero());
-        let bits = bound.bits();
-        loop {
-            let n = self.gen_biguint(bits);
-            if n < *bound { return n; }
-        }
-    }
-
-    fn gen_biguint_range(&mut self,
-                         lbound: &BigUint,
-                         ubound: &BigUint)
-                         -> BigUint {
-        assert!(*lbound < *ubound);
-        return *lbound + self.gen_biguint_below(&(*ubound - *lbound));
-    }
-
-    fn gen_bigint_range(&mut self,
-                        lbound: &BigInt,
-                        ubound: &BigInt)
-                        -> BigInt {
-        assert!(*lbound < *ubound);
-        let delta = (*ubound - *lbound).to_biguint();
-        return *lbound + self.gen_biguint_below(&delta).to_bigint();
-    }
 }
 
 impl BigInt {
@@ -1825,63 +1780,12 @@ mod biguint_tests {
         check(30, "265252859812191058636308480000000");
     }
 
-    #[test]
-    fn test_bits() {
-        assert_eq!(BigUint::new(~[0,0,0,0]).bits(), 0);
-        assert_eq!(BigUint::from_uint(0).bits(), 0);
-        assert_eq!(BigUint::from_uint(1).bits(), 1);
-        assert_eq!(BigUint::from_uint(3).bits(), 2);
-        let n: BigUint = FromStrRadix::from_str_radix("4000000000", 16).unwrap();
-        assert_eq!(n.bits(), 39);
-        let one: BigUint = One::one();
-        assert_eq!((one << 426).bits(), 427);
-    }
-
     #[test]
     fn test_rand() {
         let mut rng = task_rng();
         let _n: BigUint = rng.gen_biguint(137);
         assert!(rng.gen_biguint(0).is_zero());
     }
-
-    #[test]
-    fn test_rand_range() {
-        let mut rng = task_rng();
-
-        do 10.times {
-            assert_eq!(rng.gen_bigint_range(&BigInt::from_uint(236),
-                                            &BigInt::from_uint(237)),
-                       BigInt::from_uint(236));
-        }
-
-        let l = BigUint::from_uint(403469000 + 2352);
-        let u = BigUint::from_uint(403469000 + 3513);
-        do 1000.times {
-            let n: BigUint = rng.gen_biguint_below(&u);
-            assert!(n < u);
-
-            let n: BigUint = rng.gen_biguint_range(&l, &u);
-            assert!(n >= l);
-            assert!(n < u);
-        }
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_zero_rand_range() {
-        task_rng().gen_biguint_range(&BigUint::from_uint(54),
-                                     &BigUint::from_uint(54));
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_negative_rand_range() {
-        let mut rng = task_rng();
-        let l = BigUint::from_uint(2352);
-        let u = BigUint::from_uint(3513);
-        // Switching u and l should fail:
-        let _n: BigUint = rng.gen_biguint_range(&u, &l);
-    }
 }
 
 #[cfg(test)]
@@ -2333,48 +2237,6 @@ mod bigint_tests {
         let _n: BigInt = rng.gen_bigint(137);
         assert!(rng.gen_bigint(0).is_zero());
     }
-
-    #[test]
-    fn test_rand_range() {
-        let mut rng = task_rng();
-
-        do 10.times {
-            assert_eq!(rng.gen_bigint_range(&BigInt::from_uint(236),
-                                            &BigInt::from_uint(237)),
-                       BigInt::from_uint(236));
-        }
-
-        fn check(l: BigInt, u: BigInt) {
-            let mut rng = task_rng();
-            do 1000.times {
-                let n: BigInt = rng.gen_bigint_range(&l, &u);
-                assert!(n >= l);
-                assert!(n < u);
-            }
-        }
-        let l = BigInt::from_uint(403469000 + 2352);
-        let u = BigInt::from_uint(403469000 + 3513);
-        check( l.clone(),  u.clone());
-        check(-l.clone(),  u.clone());
-        check(-u.clone(), -l.clone());
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_zero_rand_range() {
-        task_rng().gen_bigint_range(&IntConvertible::from_int(54),
-                                    &IntConvertible::from_int(54));
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_negative_rand_range() {
-        let mut rng = task_rng();
-        let l = BigInt::from_uint(2352);
-        let u = BigInt::from_uint(3513);
-        // Switching u and l should fail:
-        let _n: BigInt = rng.gen_bigint_range(&u, &l);
-    }
 }
 
 #[cfg(test)]

branches/try2/src/libstd/str.rs

@@ -1107,8 +1107,8 @@ pub mod raw {
             Some(limit) => (true, limit),
             None => (false, 0)
         };
-        while(((limited_count && ctr < limit) || !limited_count)
-              && *(curr_ptr as *libc::c_char) != 0 as libc::c_char) {
+        while(*(curr_ptr as *libc::c_char) != 0 as libc::c_char
+             && ((limited_count && ctr < limit) || !limited_count)) {
             let env_pair = from_c_str(
                 curr_ptr as *libc::c_char);
             result.push(env_pair);

branches/try2/src/libsyntax/parse/lexer.rs

@@ -699,6 +699,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
               '\\' => { c2 = '\\'; }
               '\'' => { c2 = '\''; }
               '"' => { c2 = '"'; }
+              '0' => { c2 = '\x00'; }
               'x' => { c2 = scan_numeric_escape(rdr, 2u); }
               'u' => { c2 = scan_numeric_escape(rdr, 4u); }
               'U' => { c2 = scan_numeric_escape(rdr, 8u); }
@@ -738,6 +739,7 @@ fn next_token_inner(rdr: @mut StringReader) -> token::Token {
                   '\'' => accum_str.push_char('\''),
                   '"' => accum_str.push_char('"'),
                   '\n' => consume_whitespace(rdr),
+                  '0' => accum_str.push_char('\x00'),
                   'x' => {
                     accum_str.push_char(scan_numeric_escape(rdr, 2u));
                   }

branches/try2/src/test/run-pass/nul-characters.rs

@@ -0,0 +1,44 @@
+// Copyright 2013 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.
+
+pub fn main()
+{
+    let all_nuls1 = "\0\x00\u0000\U00000000";
+    let all_nuls2 = "\U00000000\u0000\x00\0";
+    let all_nuls3 = "\u0000\U00000000\x00\0";
+    let all_nuls4 = "\x00\u0000\0\U00000000";
+
+    // sizes for two should suffice
+    assert_eq!(all_nuls1.len(), 4); 
+    assert_eq!(all_nuls2.len(), 4);
+
+    // string equality should pass between the strings
+    assert_eq!(all_nuls1, all_nuls2);
+    assert_eq!(all_nuls2, all_nuls3);
+    assert_eq!(all_nuls3, all_nuls4);
+    
+    // all extracted characters in all_nuls are equivalent to each other
+    for c1 in all_nuls1.iter()
+    {
+        for c2 in all_nuls1.iter()
+        {
+            assert_eq!(c1,c2);
+        }
+    }
+    
+    // testing equality between explicit character literals
+    assert_eq!('\0', '\x00');
+    assert_eq!('\u0000', '\x00');
+    assert_eq!('\u0000', '\U00000000');
+
+    // NUL characters should make a difference
+    assert!("Hello World" != "Hello \0World");
+    assert!("Hello World" != "Hello World\0");
+}