---

yaml
---
r: 89217
b: refs/heads/snap-stage3
c: 0daaeab
h: refs/heads/master
i:
  89215: a747265
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: deeca5d586bfaa4aa60246f671a8d611d38f6248
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b3b49d9873afaa600ba9dc00566dba73c3eae195
+refs/heads/snap-stage3: 0daaeab244a583b6bb5b88c41ad0fdd51388619d
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -3806,6 +3806,25 @@ As a convenience, the logging spec can also be set to a special pseudo-crate,
 `::help`. In this case, when the application starts, the runtime will
 simply output a list of loaded modules containing log expressions, then exit.
 
+The Rust runtime itself generates logging information. The runtime's logs are
+generated for a number of artificial modules in the `::rt` pseudo-crate,
+and can be enabled just like the logs for any standard module. The full list
+of runtime logging modules follows.
+
+* `::rt::mem` Memory management
+* `::rt::comm` Messaging and task communication
+* `::rt::task` Task management
+* `::rt::dom` Task scheduling
+* `::rt::trace` Unused
+* `::rt::cache` Type descriptor cache
+* `::rt::upcall` Compiler-generated runtime calls
+* `::rt::timer` The scheduler timer
+* `::rt::gc` Garbage collection
+* `::rt::stdlib` Functions used directly by the standard library
+* `::rt::kern` The runtime kernel
+* `::rt::backtrace` Log a backtrace on task failure
+* `::rt::callback` Unused
+
 #### Logging Expressions
 
 Rust provides several macros to log information. Here's a simple Rust program

branches/snap-stage3/src/driver/driver.rs

@@ -19,4 +19,7 @@ extern mod this = "rustdoc";
 #[cfg(rustc)]
 extern mod this = "rustc";
 
+#[cfg(rustdoc_ng)]
+extern mod this = "rustdoc_ng";
+
 fn main() { this::main() }

branches/snap-stage3/src/etc/emacs/rust-mode.el

@@ -54,9 +54,7 @@
     ;; We don't want to indent out to the open bracket if the
     ;; open bracket ends the line
     (when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
-      (when (looking-at "[[:space:]]")
-	(forward-word 1)
-	(backward-word 1))
+      (when (looking-at "[[:space:]]") (forward-to-word 1))
       (current-column))))
 
 (defun rust-mode-indent-line ()

branches/snap-stage3/src/libextra/getopts.rs

@@ -31,7 +31,7 @@
 //!
 //! ~~~{.rust}
 //! extern mod extra;
-//! use extra::getopts::{optopt,optflag,getopts,Opt};
+//! use extra::getopts::*;
 //! use std::os;
 //!
 //! fn do_work(inp: &str, out: Option<~str>) {

branches/snap-stage3/src/libextra/num/rational.rs

@@ -14,7 +14,7 @@
 use std::cmp;
 use std::from_str::FromStr;
 use std::num::{Zero,One,ToStrRadix,FromStrRadix,Round};
-use super::bigint::{BigInt, BigUint, Sign, Plus, Minus};
+use super::bigint::BigInt;
 
 /// Represents the ratio between 2 numbers.
 #[deriving(Clone)]
@@ -107,27 +107,6 @@ impl<T: Clone + Integer + Ord>
     }
 }
 
-impl Ratio<BigInt> {
-    /// Converts a float into a rational number
-    pub fn from_float<T: Float>(f: T) -> Option<BigRational> {
-        if !f.is_finite() {
-            return None;
-        }
-        let (mantissa, exponent, sign) = f.integer_decode();
-        let bigint_sign: Sign = if sign == 1 { Plus } else { Minus };
-        if exponent < 0 {
-            let one: BigInt = One::one();
-            let denom: BigInt = one << ((-exponent) as uint);
-            let numer: BigUint = FromPrimitive::from_u64(mantissa).unwrap();
-            Some(Ratio::new(BigInt::from_biguint(bigint_sign, numer), denom))
-        } else {
-            let mut numer: BigUint = FromPrimitive::from_u64(mantissa).unwrap();
-            numer = numer << (exponent as uint);
-            Some(Ratio::from_integer(BigInt::from_biguint(bigint_sign, numer)))
-        }
-    }
-}
-
 /* Comparisons */
 
 // comparing a/b and c/d is the same as comparing a*d and b*c, so we
@@ -642,42 +621,4 @@ mod test {
             test(s);
         }
     }
-
-    #[test]
-    fn test_from_float() {
-        fn test<T: Float>(given: T, (numer, denom): (&str, &str)) {
-            let ratio: BigRational = Ratio::from_float(given).unwrap();
-            assert_eq!(ratio, Ratio::new(
-                FromStr::from_str(numer).unwrap(),
-                FromStr::from_str(denom).unwrap()));
-        }
-
-        // f32
-        test(3.14159265359f32, ("13176795", "4194304"));
-        test(2f32.pow(&100.), ("1267650600228229401496703205376", "1"));
-        test(-2f32.pow(&100.), ("-1267650600228229401496703205376", "1"));
-        test(1.0 / 2f32.pow(&100.), ("1", "1267650600228229401496703205376"));
-        test(684729.48391f32, ("1369459", "2"));
-        test(-8573.5918555f32, ("-4389679", "512"));
-
-        // f64
-        test(3.14159265359f64, ("3537118876014453", "1125899906842624"));
-        test(2f64.pow(&100.), ("1267650600228229401496703205376", "1"));
-        test(-2f64.pow(&100.), ("-1267650600228229401496703205376", "1"));
-        test(684729.48391f64, ("367611342500051", "536870912"));
-        test(-8573.5918555, ("-4713381968463931", "549755813888"));
-        test(1.0 / 2f64.pow(&100.), ("1", "1267650600228229401496703205376"));
-    }
-
-    #[test]
-    fn test_from_float_fail() {
-        use std::{f32, f64};
-
-        assert_eq!(Ratio::from_float(f32::NAN), None);
-        assert_eq!(Ratio::from_float(f32::INFINITY), None);
-        assert_eq!(Ratio::from_float(f32::NEG_INFINITY), None);
-        assert_eq!(Ratio::from_float(f64::NAN), None);
-        assert_eq!(Ratio::from_float(f64::INFINITY), None);
-        assert_eq!(Ratio::from_float(f64::NEG_INFINITY), None);
-    }
 }

branches/snap-stage3/src/libextra/time.rs

@@ -12,16 +12,17 @@
 
 use std::io::Reader;
 use std::io::mem::BufReader;
-use std::libc;
 use std::num;
 use std::str;
 
 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 
-mod rustrt {
+pub mod rustrt {
     use super::Tm;
 
     extern {
+        pub fn rust_get_time(sec: &mut i64, nsec: &mut i32);
+        pub fn rust_precise_time_ns(ns: &mut u64);
         pub fn rust_tzset();
         pub fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
         pub fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
@@ -30,31 +31,6 @@ mod rustrt {
     }
 }
 
-#[cfg(unix, not(target_os = "macos"))]
-mod imp {
-    use std::libc::{c_int, timespec};
-
-    // Apparently android provides this in some other library?
-    #[cfg(not(target_os = "android"))]
-    #[link(name = "rt")]
-    extern {}
-
-    extern {
-        pub fn clock_gettime(clk_id: c_int, tp: *mut timespec) -> c_int;
-    }
-
-}
-#[cfg(target_os = "macos")]
-mod imp {
-    use std::libc::{timeval, timezone, c_int, mach_timebase_info};
-
-    extern {
-        pub fn gettimeofday(tp: *mut timeval, tzp: *mut timezone) -> c_int;
-        pub fn mach_absolute_time() -> u64;
-        pub fn mach_timebase_info(info: *mut mach_timebase_info) -> c_int;
-    }
-}
-
 /// A record specifying a time value in seconds and nanoseconds.
 
 
@@ -88,45 +64,11 @@ impl Ord for Timespec {
  */
 pub fn get_time() -> Timespec {
     unsafe {
-        let (sec, nsec) = os_get_time();
+        let mut sec = 0i64;
+        let mut nsec = 0i32;
+        rustrt::rust_get_time(&mut sec, &mut nsec);
         return Timespec::new(sec, nsec);
     }
-
-    #[cfg(windows)]
-    unsafe fn os_get_time() -> (i64, i32) {
-        static NANOSECONDS_FROM_1601_TO_1970: u64 = 11644473600000000;
-
-        let mut time = libc::FILETIME {
-            dwLowDateTime: 0,
-            dwHighDateTime: 0,
-        };
-        libc::GetSystemTimeAsFileTime(&mut time);
-
-        // A FILETIME contains a 64-bit value representing the number of
-        // hectonanosecond (100-nanosecond) intervals since 1601-01-01T00:00:00Z.
-        // http://support.microsoft.com/kb/167296/en-us
-        let ns_since_1601 = ((time.dwHighDateTime as u64 << 32) |
-                             (time.dwLowDateTime  as u64 <<  0)) / 10;
-        let ns_since_1970 = ns_since_1601 - NANOSECONDS_FROM_1601_TO_1970;
-
-        ((ns_since_1970 / 1000000) as i64,
-         ((ns_since_1970 % 1000000) * 1000) as i32)
-    }
-
-    #[cfg(target_os = "macos")]
-    unsafe fn os_get_time() -> (i64, i32) {
-        use std::ptr;
-        let mut tv = libc::timeval { tv_sec: 0, tv_usec: 0 };
-        imp::gettimeofday(&mut tv, ptr::mut_null());
-        (tv.tv_sec as i64, tv.tv_usec * 1000)
-    }
-
-    #[cfg(not(target_os = "macos"), not(windows))]
-    unsafe fn os_get_time() -> (i64, i32) {
-        let mut tv = libc::timespec { tv_sec: 0, tv_nsec: 0 };
-        imp::clock_gettime(libc::CLOCK_REALTIME, &mut tv);
-        (tv.tv_sec as i64, tv.tv_nsec as i32)
-    }
 }
 
 
@@ -135,38 +77,10 @@ pub fn get_time() -> Timespec {
  * in nanoseconds since an unspecified epoch.
  */
 pub fn precise_time_ns() -> u64 {
-    return os_precise_time_ns();
-
-    #[cfg(windows)]
-    fn os_precise_time_ns() -> u64 {
-        let mut ticks_per_s = 0;
-        assert_eq!(unsafe {
-            libc::QueryPerformanceFrequency(&mut ticks_per_s)
-        }, 1);
-        let ticks_per_s = if ticks_per_s == 0 {1} else {ticks_per_s};
-        let mut ticks = 0;
-        assert_eq!(unsafe {
-            libc::QueryPerformanceCounter(&mut ticks)
-        }, 1);
-
-        return (ticks as u64 * 1000000000) / (ticks_per_s as u64);
-    }
-
-    #[cfg(target_os = "macos")]
-    fn os_precise_time_ns() -> u64 {
-        let time = unsafe { imp::mach_absolute_time() };
-        let mut info = libc::mach_timebase_info { numer: 0, denom: 0 };
-        unsafe { imp::mach_timebase_info(&mut info); }
-        return time * ((info.numer / info.denom) as u64);
-    }
-
-    #[cfg(not(windows), not(target_os = "macos"))]
-    fn os_precise_time_ns() -> u64 {
-        let mut ts = libc::timespec { tv_sec: 0, tv_nsec: 0 };
-        unsafe {
-            imp::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts);
-        }
-        return (ts.tv_sec as u64) * 1000000000 + (ts.tv_nsec as u64)
+    unsafe {
+        let mut ns = 0u64;
+        rustrt::rust_precise_time_ns(&mut ns);
+        ns
     }
 }