---

yaml
---
r: 55799
b: refs/heads/master
c: dd74807
h: refs/heads/master
i:
  55797: 74158d4
  55795: 61ab742
  55791: 82efc37
v: v3

Author: Kimundi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 345d5b82351f4f8309498aa34b9f0348b898300d
+refs/heads/master: dd748079574197215da46ac164f16a392df9cc26
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a

trunk/src/compiletest/errors.rs

@@ -50,7 +50,10 @@ fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
     while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
     let start_kind = idx;
     while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
-    let kind = str::to_lower(str::slice(line, start_kind, idx).to_owned());
+
+    // FIXME: 4318 Instead of to_str_ascii, could use
+    // to_str_consume to not do a unneccessary copy.
+    let kind = str::slice(line, start_kind, idx).to_ascii().to_lower().to_str_ascii();
 
     // Extract msg:
     while idx < len && line[idx] == (' ' as u8) { idx += 1u; }

trunk/src/libcore/char.rs

@@ -100,12 +100,6 @@ pub fn is_alphanumeric(c: char) -> bool {
         unicode::general_category::No(c);
 }
 
-/// Indicates whether the character is an ASCII character
-#[inline(always)]
-pub fn is_ascii(c: char) -> bool {
-   c - ('\x7F' & c) == '\x00'
-}
-
 /// Indicates whether the character is numeric (Nd, Nl, or No)
 #[inline(always)]
 pub fn is_digit(c: char) -> bool {
@@ -116,7 +110,7 @@ pub fn is_digit(c: char) -> bool {
 
 /**
  * Checks if a character parses as a numeric digit in the given radix.
- * Compared to `is_digit()`, this function only recognizes the ascii
+ * Compared to `is_digit()`, this function only recognizes the
  * characters `0-9`, `a-z` and `A-Z`.
  *
  * Returns `true` if `c` is a valid digit under `radix`, and `false`
@@ -163,7 +157,7 @@ pub fn to_digit(c: char, radix: uint) -> Option<uint> {
 }
 
 /**
- * Converts a number to the ascii character representing it.
+ * Converts a number to the character representing it.
  *
  * Returns `Some(char)` if `num` represents one digit under `radix`,
  * using one character of `0-9` or `a-z`, or `None` if it doesn't.
@@ -316,12 +310,6 @@ fn test_to_digit() {
     assert!(to_digit('$', 36u).is_none());
 }
 
-#[test]
-fn test_is_ascii() {
-   assert!(str::all(~"banana", is_ascii));
-   assert!(! str::all(~"ประเทศไทย中华Việt Nam", is_ascii));
-}
-
 #[test]
 fn test_is_digit() {
    assert!(is_digit('2'));

trunk/src/libcore/num/uint-template/u8.rs

@@ -10,16 +10,9 @@
 
 //! Operations and constants for `u8`
 
-pub use self::inst::is_ascii;
-
 mod inst {
     pub type T = u8;
     #[allow(non_camel_case_types)]
     pub type T_SIGNED = i8;
     pub static bits: uint = 8;
-
-    // Type-specific functions here. These must be reexported by the
-    // parent module so that they appear in core::u8 and not core::u8::u8;
-
-    pub fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; }
 }

trunk/src/libcore/path.rs

@@ -753,7 +753,9 @@ impl GenericPath for WindowsPath {
     fn is_restricted(&self) -> bool {
         match self.filestem() {
             Some(stem) => {
-                match stem.to_lower() {
+                // FIXME: 4318 Instead of to_str_ascii, could use
+                // to_str_consume to not do a unneccessary copy.
+                match stem.to_ascii().to_lower().to_str_ascii() {
                     ~"con" | ~"aux" | ~"com1" | ~"com2" | ~"com3" | ~"com4" |
                     ~"lpt1" | ~"lpt2" | ~"lpt3" | ~"prn" | ~"nul" => true,
                     _ => false
@@ -809,7 +811,10 @@ impl GenericPath for WindowsPath {
             host: copy self.host,
             device: match self.device {
                 None => None,
-                Some(ref device) => Some(device.to_upper())
+
+                // FIXME: 4318 Instead of to_str_ascii, could use
+                // to_str_consume to not do a unneccessary copy.
+                Some(ref device) => Some(device.to_ascii().to_upper().to_str_ascii())
             },
             is_absolute: self.is_absolute,
             components: normalize(self.components)

trunk/src/libcore/run.rs

@@ -47,48 +47,16 @@ pub struct RunProgramResult {
     handle: *(),
 }
 
-/// A value representing a child process
-pub struct Program {
-    priv pid: pid_t,
-    priv handle: *(),
-    priv in_fd: c_int,
-    priv out_file: *libc::FILE,
-    priv err_file: *libc::FILE,
-    priv finished: bool,
-}
-
-impl Drop for Program {
-    fn finalize(&self) {
-        // FIXME #4943: transmute is bad.
-        let mut_self: &mut Program = unsafe { cast::transmute(self) };
-
-        mut_self.finish();
-        mut_self.close_outputs();
-        free_handle(self.handle);
-    }
+struct ProgRepr {
+    pid: pid_t,
+    handle: *(),
+    in_fd: c_int,
+    out_file: *libc::FILE,
+    err_file: *libc::FILE,
+    finished: bool,
 }
 
-pub impl Program {
-
-    /// Returns the process id of the program
-    fn get_id(&mut self) -> pid_t { self.pid }
-
-    /// Returns an io::Writer that can be used to write to stdin
-    fn input(&mut self) -> @io::Writer {
-        io::fd_writer(self.in_fd, false)
-    }
-
-    /// Returns an io::Reader that can be used to read from stdout
-    fn output(&mut self) -> @io::Reader {
-        io::FILE_reader(self.out_file, false)
-    }
-
-    /// Returns an io::Reader that can be used to read from stderr
-    fn err(&mut self) -> @io::Reader {
-        io::FILE_reader(self.err_file, false)
-    }
-
-    /// Closes the handle to the child processes standard input
+impl ProgRepr {
     fn close_input(&mut self) {
         let invalid_fd = -1i32;
         if self.in_fd != invalid_fd {
@@ -99,25 +67,21 @@ pub impl Program {
         }
     }
 
-    priv fn close_outputs(&mut self) {
+    fn close_outputs(&mut self) {
         unsafe {
             fclose_and_null(&mut self.out_file);
             fclose_and_null(&mut self.err_file);
         }
     }
 
-    /**
-     * Waits for the child process to terminate. Closes the handle
-     * to stdin if necessary.
-     */
     fn finish(&mut self) -> int {
         if self.finished { return 0; }
         self.finished = true;
         self.close_input();
         return waitpid(self.pid);
     }
 
-    priv fn destroy_internal(&mut self, force: bool) {
+    fn destroy(&mut self, force: bool) {
         killpid(self.pid, force);
         self.finish();
         self.close_outputs();
@@ -143,6 +107,57 @@ pub impl Program {
             }
         }
     }
+}
+
+/// A value representing a child process
+pub struct Program {
+    priv r: ProgRepr,
+}
+
+impl Drop for Program {
+    fn finalize(&self) {
+        // FIXME #4943: transmute is bad.
+        let selfr: &mut ProgRepr = unsafe { cast::transmute(&self.r) };
+
+        selfr.finish();
+        selfr.close_outputs();
+        free_handle(self.r.handle);
+    }
+}
+
+pub impl Program {
+    priv fn new(r: ProgRepr) -> Program {
+        Program {
+            r: r
+        }
+    }
+
+    /// Returns the process id of the program
+    fn get_id(&mut self) -> pid_t { self.r.pid }
+
+    /// Returns an io::Writer that can be used to write to stdin
+    fn input(&mut self) -> @io::Writer {
+        io::fd_writer(self.r.in_fd, false)
+    }
+
+    /// Returns an io::Reader that can be used to read from stdout
+    fn output(&mut self) -> @io::Reader {
+        io::FILE_reader(self.r.out_file, false)
+    }
+
+    /// Returns an io::Reader that can be used to read from stderr
+    fn err(&mut self) -> @io::Reader {
+        io::FILE_reader(self.r.err_file, false)
+    }
+
+    /// Closes the handle to the child processes standard input
+    fn close_input(&mut self) { self.r.close_input(); }
+
+    /**
+     * Waits for the child process to terminate. Closes the handle
+     * to stdin if necessary.
+     */
+    fn finish(&mut self) -> int { self.r.finish() }
 
     /**
      * Terminate the program, giving it a chance to clean itself up if
@@ -151,7 +166,7 @@ pub impl Program {
      * On Posix OSs SIGTERM will be sent to the process. On Win32
      * TerminateProcess(..) will be called.
      */
-    fn destroy(&mut self) { self.destroy_internal(false); }
+    fn destroy(&mut self) { self.r.destroy(false); }
 
     /**
      * Terminate the program as soon as possible without giving it a
@@ -160,7 +175,7 @@ pub impl Program {
      * On Posix OSs SIGKILL will be sent to the process. On Win32
      * TerminateProcess(..) will be called.
      */
-    fn force_destroy(&mut self) { self.destroy_internal(true); }
+    fn force_destroy(&mut self) { self.r.destroy(true); }
 }
 
 
@@ -351,14 +366,16 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
         libc::close(pipe_err.out);
     }
 
-    Program {
+    let repr = ProgRepr {
         pid: res.pid,
         handle: res.handle,
         in_fd: pipe_input.out,
         out_file: os::fdopen(pipe_output.in),
         err_file: os::fdopen(pipe_err.in),
         finished: false,
-    }
+    };
+
+    Program::new(repr)
 }
 
 fn read_all(rd: @io::Reader) -> ~str {

trunk/src/libcore/str.rs

@@ -787,22 +787,6 @@ pub fn each_split_within<'a>(ss: &'a str,
     }
 }
 
-/// Convert a string to lowercase. ASCII only
-pub fn to_lower(s: &str) -> ~str {
-    do map(s) |c| {
-        assert!(char::is_ascii(c));
-        (unsafe{libc::tolower(c as libc::c_char)}) as char
-    }
-}
-
-/// Convert a string to uppercase. ASCII only
-pub fn to_upper(s: &str) -> ~str {
-    do map(s) |c| {
-        assert!(char::is_ascii(c));
-        (unsafe{libc::toupper(c as libc::c_char)}) as char
-    }
-}
-
 /**
  * Replace all occurrences of one string with another
  *
@@ -1610,13 +1594,6 @@ pub fn ends_with<'a,'b>(haystack: &'a str, needle: &'b str) -> bool {
 Section: String properties
 */
 
-/// Determines if a string contains only ASCII characters
-pub fn is_ascii(s: &str) -> bool {
-    let mut i: uint = len(s);
-    while i > 0u { i -= 1u; if !u8::is_ascii(s[i]) { return false; } }
-    return true;
-}
-
 /// Returns true if the string has length 0
 pub fn is_empty(s: &str) -> bool { len(s) == 0u }
 
@@ -2403,8 +2380,6 @@ pub trait StrSlice<'self> {
     fn each_split_str<'a>(&self, sep: &'a str, it: &fn(&'self str) -> bool);
     fn starts_with<'a>(&self, needle: &'a str) -> bool;
     fn substr(&self, begin: uint, n: uint) -> &'self str;
-    fn to_lower(&self) -> ~str;
-    fn to_upper(&self) -> ~str;
     fn escape_default(&self) -> ~str;
     fn escape_unicode(&self) -> ~str;
     fn trim(&self) -> &'self str;
@@ -2565,12 +2540,6 @@ impl<'self> StrSlice<'self> for &'self str {
     fn substr(&self, begin: uint, n: uint) -> &'self str {
         substr(*self, begin, n)
     }
-    /// Convert a string to lowercase
-    #[inline]
-    fn to_lower(&self) -> ~str { to_lower(*self) }
-    /// Convert a string to uppercase
-    #[inline]
-    fn to_upper(&self) -> ~str { to_upper(*self) }
     /// Escape each char in `s` with char::escape_default.
     #[inline]
     fn escape_default(&self) -> ~str { escape_default(*self) }
@@ -3084,27 +3053,6 @@ mod tests {
         assert!(repeat(~"hi", 0) == ~"");
     }
 
-    #[test]
-    fn test_to_upper() {
-        // libc::toupper, and hence str::to_upper
-        // are culturally insensitive: they only work for ASCII
-        // (see Issue #1347)
-        let unicode = ~""; //"\u65e5\u672c"; // uncomment once non-ASCII works
-        let input = ~"abcDEF" + unicode + ~"xyz:.;";
-        let expected = ~"ABCDEF" + unicode + ~"XYZ:.;";
-        let actual = to_upper(input);
-        assert!(expected == actual);
-    }
-
-    #[test]
-    fn test_to_lower() {
-        // libc::tolower, and hence str::to_lower
-        // are culturally insensitive: they only work for ASCII
-        // (see Issue #1347)
-        assert!(~"" == to_lower(""));
-        assert!(~"ymca" == to_lower("YMCA"));
-    }
-
     #[test]
     fn test_unsafe_slice() {
         assert!("ab" == unsafe {raw::slice_bytes("abc", 0, 2)});
@@ -3337,13 +3285,6 @@ mod tests {
         assert!((!is_whitespace(~"   _   ")));
     }
 
-    #[test]
-    fn test_is_ascii() {
-        assert!((is_ascii(~"")));
-        assert!((is_ascii(~"a")));
-        assert!((!is_ascii(~"\u2009")));
-    }
-
     #[test]
     fn test_shift_byte() {
         let mut s = ~"ABC";