---

yaml
---
r: 79517
b: refs/heads/snap-stage3
c: c891fa3
h: refs/heads/master
i:
  79515: 2bf79d0
v: v3

Author: novalis

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 124eb2119c78651cfaaa7a046a101fa2e20f83ca
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 25f3b29c61122bcf160d273348327723cd783419
+refs/heads/snap-stage3: c891fa326d28818582a653e588463c45f82e5795
 refs/heads/try: ac820906c0e53eab79a98ee64f7231f57c3887b4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -3385,9 +3385,11 @@ The path to a module consists of the crate name, any parent modules,
 then the module itself, all separated by double colons (`::`).  The
 optional log level can be appended to the module path with an equals
 sign (`=`) followed by the log level, from 1 to 4, inclusive. Level 1
-is the error level, 2 is warning, 3 info, and 4 debug. Any logs
-less than or equal to the specified level will be output. If not
-specified then log level 4 is assumed.
+is the error level, 2 is warning, 3 info, and 4 debug. You can also
+use the symbolic constants `error`, `warn`, `info`, and `debug`.  Any
+logs less than or equal to the specified level will be output. If not
+specified then log level 4 is assumed.  However, debug messages are
+only available if `--cfg=debug` is passed to `rustc`.
 
 As an example, to see all the logs generated by the compiler, you would set
 `RUST_LOG` to `rustc`, which is the crate name (as specified in its `link`

branches/snap-stage3/src/libstd/num/strconv.rs

@@ -552,18 +552,8 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+
                 // Detect overflow by comparing to last value, except
                 // if we've not seen any non-zero digits.
                 if last_accum != _0 {
-                    if accum_positive && accum <= last_accum { return NumStrConv::inf(); }
-                    if !accum_positive && accum >= last_accum { return NumStrConv::neg_inf(); }
-
-                    // Detect overflow by reversing the shift-and-add proccess
-                    if accum_positive &&
-                        (last_accum != ((accum - cast(digit as int))/radix_gen.clone())) {
-                        return NumStrConv::inf();
-                    }
-                    if !accum_positive &&
-                        (last_accum != ((accum + cast(digit as int))/radix_gen.clone())) {
-                        return NumStrConv::neg_inf();
-                    }
+                    if accum_positive && accum <= last_accum { return None; }
+                    if !accum_positive && accum >= last_accum { return None; }
                 }
                 last_accum = accum.clone();
             }
@@ -607,8 +597,8 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+
                     }
 
                     // Detect overflow by comparing to last value
-                    if accum_positive && accum < last_accum { return NumStrConv::inf(); }
-                    if !accum_positive && accum > last_accum { return NumStrConv::neg_inf(); }
+                    if accum_positive && accum < last_accum { return None; }
+                    if !accum_positive && accum > last_accum { return None; }
                     last_accum = accum.clone();
                 }
                 None => match c {
@@ -712,23 +702,6 @@ mod test {
                                              ExpNone, false, false);
         assert_eq!(n, None);
     }
-
-    #[test]
-    fn from_str_issue7588() {
-        let u : Option<u8> = from_str_common("1000", 10, false, false, false,
-                                            ExpNone, false, false);
-        assert_eq!(u, None);
-        let s : Option<i16> = from_str_common("80000", 10, false, false, false,
-                                             ExpNone, false, false);
-        assert_eq!(s, None);
-        let f : Option<f32> = from_str_common(
-            "10000000000000000000000000000000000000000", 10, false, false, false,
-            ExpNone, false, false);
-        assert_eq!(f, NumStrConv::inf())
-        let fe : Option<f32> = from_str_common("1e40", 10, false, false, false,
-                                            ExpDec, false, false);
-        assert_eq!(fe, NumStrConv::inf())
-    }
 }
 
 #[cfg(test)]

branches/snap-stage3/src/libstd/rt/logging.rs

@@ -10,11 +10,12 @@
 use cast::transmute;
 use either::*;
 use libc::{c_void, uintptr_t, c_char, exit, STDERR_FILENO};
-use option::{Some, None};
+use option::{Some, None, Option};
 use rt::util::dumb_println;
 use str::StrSlice;
 use str::raw::from_c_str;
 use u32;
+use u32::{min};
 use unstable::raw::Closure;
 use vec::ImmutableVector;
 
@@ -30,7 +31,6 @@ struct ModEntry{
     log_level: *mut u32
 }
 
-static MAX_LOG_DIRECTIVES: u32 = 255;
 static MAX_LOG_LEVEL: u32 = 255;
 static DEFAULT_LOG_LEVEL: u32 = 1;
 
@@ -68,42 +68,68 @@ fn iter_crate_map(map: *u8, f: &fn(*mut ModEntry)) {
                     data: *c_void);
     }
 }
+static log_level_names : &'static[&'static str] = &'static["error", "warn", "info", "debug"];
+
+/// Parse an individual log level that is either a number or a symbolic log level
+fn parse_log_level(level: &str) -> Option<u32> {
+    let num = u32::from_str(level);
+    let mut log_level;
+    match (num) {
+        Some(num) => {
+            if num < MAX_LOG_LEVEL {
+                log_level = Some(num);
+            } else {
+                log_level = Some(MAX_LOG_LEVEL);
+            }
+        }
+        _ => {
+            let position = log_level_names.iter().position(|&name| name == level);
+            match (position) {
+                Some(position) => {
+                    log_level = Some(min(MAX_LOG_LEVEL, (position + 1) as u32))
+                },
+                _ => {
+                    log_level = None;
+                }
+            }
+        }
+    }
+    log_level
+}
+
 
 /// Parse a logging specification string (e.g: "crate1,crate2::mod3,crate3::x=1")
 /// and return a vector with log directives.
-/// Valid log levels are 0-255, with the most likely ones being 0-3 (defined in std::).
+/// Valid log levels are 0-255, with the most likely ones being 1-4 (defined in std::).
+/// Also supports string log levels of error, warn, info, and debug
+
 fn parse_logging_spec(spec: ~str) -> ~[LogDirective]{
     let mut dirs = ~[];
     for s in spec.split_iter(',') {
         let parts: ~[&str] = s.split_iter('=').collect();
-        let mut loglevel;
+        let mut log_level;
         match parts.len() {
-            1 => loglevel = MAX_LOG_LEVEL,
+            1 => log_level = MAX_LOG_LEVEL,
             2 => {
-                let num = u32::from_str(parts[1]);
-                match (num) {
+                let possible_log_level = parse_log_level(parts[1]);
+                match possible_log_level {
                     Some(num) => {
-                        if num < MAX_LOG_LEVEL {
-                            loglevel = num;
-                        } else {
-                            loglevel = MAX_LOG_LEVEL;
-                        }
-                    }
+                        log_level = num;
+                    },
                     _ => {
-                         dumb_println(fmt!("warning: invalid logging spec \
-                                           '%s', ignoring it", s));
-                         loop;
+                        dumb_println(fmt!("warning: invalid logging spec \
+                                           '%s', ignoring it", parts[1]));
+                        loop;
                     }
                 }
-                if loglevel > MAX_LOG_LEVEL { loglevel = MAX_LOG_LEVEL}
             },
             _ => {
                 dumb_println(fmt!("warning: invalid logging spec '%s',\
                                   ignoring it", s));
                 loop;
             }
         }
-        let dir = LogDirective {name: parts[0].to_owned(), level: loglevel};
+        let dir = LogDirective {name: parts[0].to_owned(), level: log_level};
         dirs.push(dir);
     }
     return dirs;
@@ -268,6 +294,15 @@ fn parse_logging_spec_invalid_log_level() {
     assert_eq!(dirs[0].level, 4);
 }
 
+#[test]
+fn parse_logging_spec_string_log_level() {
+    // test parse_logging_spec with 'warn' as log level
+    let dirs: ~[LogDirective] = parse_logging_spec(~"crate1::mod1=wrong,crate2=warn");
+    assert_eq!(dirs.len(), 1);
+    assert!(dirs[0].name == ~"crate2");
+    assert_eq!(dirs[0].level, 2);
+}
+
 // Tests for update_entry
 #[test]
 fn update_entry_match_full_path() {