---

yaml
---
r: 144859
b: refs/heads/try2
c: 3eaf750
h: refs/heads/master
i:
  144857: 90c13ef
  144855: 76ddf2e
v: v3

Author: sfackler

[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: 82b6ef66c22ac876cfc319eae7010648468919b9
+refs/heads/try2: 3eaf750a0de8acd5662d725b651e366fb703e5fa
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -3385,11 +3385,9 @@ 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. 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`.
+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.
 
 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/try2/mk/rt.mk

@@ -178,7 +178,7 @@ export PYTHONPATH := $(PYTHONPATH):$$(S)src/gyp/pylib
 
 $$(LIBUV_MAKEFILE_$(1)_$(2)):
 	(cd $(S)src/libuv/ && \
-	 $$(CFG_PYTHON) ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja \
+	 ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja \
 	   -Goutput_dir=$$(@D) --generator-output $$(@D))
 
 # XXX: Shouldn't need platform-specific conditions here

branches/try2/src/libextra/uuid.rs

@@ -210,7 +210,7 @@ impl Uuid {
     ///
     /// # Arguments
     /// * `b` An array or slice of 16 bytes
-    pub fn from_utf8(b: &[u8]) -> Option<Uuid> {
+    pub fn from_bytes(b: &[u8]) -> Option<Uuid> {
         if b.len() != 16 {
             return None
         }
@@ -413,7 +413,7 @@ impl Uuid {
             ub[i] = FromStrRadix::from_str_radix(vs.slice(i*2, (i+1)*2), 16).unwrap();
         }
 
-        Ok(Uuid::from_utf8(ub).unwrap())
+        Ok(Uuid::from_bytes(ub).unwrap())
     }
 }
 
@@ -705,11 +705,11 @@ mod test {
     }
 
     #[test]
-    fn test_from_utf8() {
+    fn test_from_bytes() {
         let b = ~[ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
                    0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
 
-        let u = Uuid::from_utf8(b).unwrap();
+        let u = Uuid::from_bytes(b).unwrap();
         let expected = ~"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
 
         assert!(u.to_simple_str() == expected);
@@ -729,7 +729,7 @@ mod test {
         let b_in: [u8, ..16] = [ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
                                  0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
 
-        let u = Uuid::from_utf8(b_in.clone()).unwrap();
+        let u = Uuid::from_bytes(b_in.clone()).unwrap();
 
         let b_out = u.to_bytes();
 

branches/try2/src/libstd/rt/logging.rs

@@ -10,7 +10,7 @@
 use cast::transmute;
 use either::*;
 use libc::{c_void, uintptr_t, c_char, exit, STDERR_FILENO};
-use option::{Some, None, Option};
+use option::{Some, None};
 use rt::util::dumb_println;
 use str::StrSlice;
 use str::raw::from_c_str;
@@ -20,7 +20,7 @@ use vec::ImmutableVector;
 
 
 struct LogDirective {
-    name: Option<~str>,
+    name: ~str,
     level: u32
 }
 
@@ -30,6 +30,7 @@ struct ModEntry{
     log_level: *mut u32
 }
 
+static MAX_LOG_DIRECTIVES: u32 = 255;
 static MAX_LOG_LEVEL: u32 = 255;
 static DEFAULT_LOG_LEVEL: u32 = 1;
 
@@ -67,82 +68,42 @@ 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(u32::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 1-4 (defined in std::).
-/// Also supports string log levels of error, warn, info, and debug
-
+/// Valid log levels are 0-255, with the most likely ones being 0-3 (defined in std::).
 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 log_level;
-        let mut name = Some(parts[0].to_owned());
+        let mut loglevel;
         match parts.len() {
-            1 => {
-                //if the single argument is a log-level string or number,
-                //treat that as a global fallback
-                let possible_log_level = parse_log_level(parts[0]);
-                match possible_log_level {
-                    Some(num) => {
-                        name = None;
-                        log_level = num;
-                    },
-                    _ => {
-                        log_level = MAX_LOG_LEVEL
-                    }
-                }
-            }
+            1 => loglevel = MAX_LOG_LEVEL,
             2 => {
-                let possible_log_level = parse_log_level(parts[1]);
-                match possible_log_level {
+                let num = u32::from_str(parts[1]);
+                match (num) {
                     Some(num) => {
-                        log_level = num;
-                    },
+                        if num < MAX_LOG_LEVEL {
+                            loglevel = num;
+                        } else {
+                            loglevel = MAX_LOG_LEVEL;
+                        }
+                    }
                     _ => {
-                        dumb_println(fmt!("warning: invalid logging spec \
-                                           '%s', ignoring it", parts[1]));
-                        loop;
+                         dumb_println(fmt!("warning: invalid logging spec \
+                                           '%s', ignoring it", s));
+                         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: name, level: log_level};
+        let dir = LogDirective {name: parts[0].to_owned(), level: loglevel};
         dirs.push(dir);
     }
     return dirs;
@@ -152,30 +113,18 @@ fn parse_logging_spec(spec: ~str) -> ~[LogDirective]{
 /// of log directives
 fn update_entry(dirs: &[LogDirective], entry: *mut ModEntry) -> u32 {
     let mut new_lvl: u32 = DEFAULT_LOG_LEVEL;
-    let mut longest_match = -1i;
+    let mut longest_match = 0;
     unsafe {
         for dir in dirs.iter() {
-            match dir.name {
-                None => {
-                    if longest_match == -1 {
-                        longest_match = 0;
-                        new_lvl = dir.level;
-                    }
-                }
-                Some(ref dir_name) => {
-                    let name = from_c_str((*entry).name);
-                    let len = dir_name.len() as int;
-                    if name.starts_with(*dir_name) &&
-                        len >= longest_match {
-                        longest_match = len;
-                        new_lvl = dir.level;
-                    }
-                }
-            };
+            let name = from_c_str((*entry).name);
+            if name.starts_with(dir.name) && dir.name.len() > longest_match {
+                longest_match = dir.name.len();
+                new_lvl = dir.level;
+            }
         }
         *(*entry).log_level = new_lvl;
     }
-    if longest_match >= 0 { return 1; } else { return 0; }
+    if longest_match > 0 { return 1; } else { return 0; }
 }
 
 #[fixed_stack_segment] #[inline(never)]
@@ -289,66 +238,45 @@ extern {
 // Tests for parse_logging_spec()
 #[test]
 fn parse_logging_spec_valid() {
-    let dirs = parse_logging_spec(~"crate1::mod1=1,crate1::mod2,crate2=4");
+    let dirs: ~[LogDirective] = parse_logging_spec(~"crate1::mod1=1,crate1::mod2,crate2=4");
     assert_eq!(dirs.len(), 3);
-    assert!(dirs[0].name == Some(~"crate1::mod1"));
+    assert!(dirs[0].name == ~"crate1::mod1");
     assert_eq!(dirs[0].level, 1);
 
-    assert!(dirs[1].name == Some(~"crate1::mod2"));
+    assert!(dirs[1].name == ~"crate1::mod2");
     assert_eq!(dirs[1].level, MAX_LOG_LEVEL);
 
-    assert!(dirs[2].name == Some(~"crate2"));
+    assert!(dirs[2].name == ~"crate2");
     assert_eq!(dirs[2].level, 4);
 }
 
 #[test]
 fn parse_logging_spec_invalid_crate() {
     // test parse_logging_spec with multiple = in specification
-    let dirs = parse_logging_spec(~"crate1::mod1=1=2,crate2=4");
+    let dirs: ~[LogDirective] = parse_logging_spec(~"crate1::mod1=1=2,crate2=4");
     assert_eq!(dirs.len(), 1);
-    assert!(dirs[0].name == Some(~"crate2"));
+    assert!(dirs[0].name == ~"crate2");
     assert_eq!(dirs[0].level, 4);
 }
 
 #[test]
 fn parse_logging_spec_invalid_log_level() {
     // test parse_logging_spec with 'noNumber' as log level
-    let dirs = parse_logging_spec(~"crate1::mod1=noNumber,crate2=4");
+    let dirs: ~[LogDirective] = parse_logging_spec(~"crate1::mod1=noNumber,crate2=4");
     assert_eq!(dirs.len(), 1);
-    assert!(dirs[0].name == Some(~"crate2"));
+    assert!(dirs[0].name == ~"crate2");
     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 = parse_logging_spec(~"crate1::mod1=wrong,crate2=warn");
-    assert_eq!(dirs.len(), 1);
-    assert!(dirs[0].name == Some(~"crate2"));
-    assert_eq!(dirs[0].level, 2);
-}
-
-#[test]
-fn parse_logging_spec_global() {
-    // test parse_logging_spec with no crate
-    let dirs = parse_logging_spec(~"warn,crate2=4");
-    assert_eq!(dirs.len(), 2);
-    assert!(dirs[0].name == None);
-    assert_eq!(dirs[0].level, 2);
-    assert!(dirs[1].name == Some(~"crate2"));
-    assert_eq!(dirs[1].level, 4);
-}
-
 // Tests for update_entry
 #[test]
 fn update_entry_match_full_path() {
     use c_str::ToCStr;
-    let dirs = ~[LogDirective {name: Some(~"crate1::mod1"), level: 2 },
-                 LogDirective {name: Some(~"crate2"), level: 3}];
-    let level = &mut 0;
+    let dirs = ~[LogDirective {name: ~"crate1::mod1", level: 2 },
+    LogDirective {name: ~"crate2", level: 3}];
     unsafe {
         do "crate1::mod1".to_c_str().with_ref |ptr| {
-            let entry= &ModEntry {name: ptr, log_level: level};
+            let entry= &ModEntry {name: ptr, log_level: &mut 0};
             let m = update_entry(dirs, transmute(entry));
             assert!(*entry.log_level == 2);
             assert!(m == 1);
@@ -359,12 +287,11 @@ fn update_entry_match_full_path() {
 #[test]
 fn update_entry_no_match() {
     use c_str::ToCStr;
-    let dirs = ~[LogDirective {name: Some(~"crate1::mod1"), level: 2 },
-                 LogDirective {name: Some(~"crate2"), level: 3}];
-    let level = &mut 0;
+    let dirs = ~[LogDirective {name: ~"crate1::mod1", level: 2 },
+        LogDirective {name: ~"crate2", level: 3}];
     unsafe {
         do "crate3::mod1".to_c_str().with_ref |ptr| {
-            let entry= &ModEntry {name: ptr, log_level: level};
+            let entry= &ModEntry {name: ptr, log_level: &mut 0};
             let m = update_entry(dirs, transmute(entry));
             assert!(*entry.log_level == DEFAULT_LOG_LEVEL);
             assert!(m == 0);
@@ -375,12 +302,11 @@ fn update_entry_no_match() {
 #[test]
 fn update_entry_match_beginning() {
     use c_str::ToCStr;
-    let dirs = ~[LogDirective {name: Some(~"crate1::mod1"), level: 2 },
-                 LogDirective {name: Some(~"crate2"), level: 3}];
-    let level = &mut 0;
+    let dirs = ~[LogDirective {name: ~"crate1::mod1", level: 2 },
+        LogDirective {name: ~"crate2", level: 3}];
     unsafe {
         do "crate2::mod1".to_c_str().with_ref |ptr| {
-            let entry= &ModEntry {name: ptr, log_level: level};
+            let entry= &ModEntry {name: ptr, log_level: &mut 0};
             let m = update_entry(dirs, transmute(entry));
             assert!(*entry.log_level == 3);
             assert!(m == 1);
@@ -391,39 +317,14 @@ fn update_entry_match_beginning() {
 #[test]
 fn update_entry_match_beginning_longest_match() {
     use c_str::ToCStr;
-    let dirs = ~[LogDirective {name: Some(~"crate1::mod1"), level: 2 },
-                 LogDirective {name: Some(~"crate2"), level: 3},
-                 LogDirective {name: Some(~"crate2::mod"), level: 4}];
-    let level = &mut 0;
+    let dirs = ~[LogDirective {name: ~"crate1::mod1", level: 2 },
+        LogDirective {name: ~"crate2", level: 3}, LogDirective {name: ~"crate2::mod", level: 4}];
     unsafe {
         do "crate2::mod1".to_c_str().with_ref |ptr| {
-            let entry = &ModEntry {name: ptr, log_level: level};
+            let entry = &ModEntry {name: ptr, log_level: &mut 0};
             let m = update_entry(dirs, transmute(entry));
             assert!(*entry.log_level == 4);
             assert!(m == 1);
         }
     }
 }
-
-#[test]
-fn update_entry_match_default() {
-    use c_str::ToCStr;
-    let dirs = ~[LogDirective {name: Some(~"crate1::mod1"), level: 2 },
-                 LogDirective {name: None, level: 3}
-                ];
-    let level = &mut 0;
-    unsafe {
-        do "crate1::mod1".to_c_str().with_ref |ptr| {
-            let entry= &ModEntry {name: ptr, log_level: level};
-            let m = update_entry(dirs, transmute(entry));
-            assert!(*entry.log_level == 2);
-            assert!(m == 1);
-        }
-        do "crate2::mod2".to_c_str().with_ref |ptr| {
-            let entry= &ModEntry {name: ptr, log_level: level};
-            let m = update_entry(dirs, transmute(entry));
-            assert!(*entry.log_level == 3);
-            assert!(m == 1);
-        }
-    }
-}

branches/try2/src/libstd/unstable/raw.rs

@@ -49,7 +49,6 @@ pub trait Repr<T> {
     /// struct representation. This can be used to read/write different values
     /// for the struct. This is a safe method because by default it does not
     /// give write-access to the struct returned.
-    #[inline]
     fn repr(&self) -> T { unsafe { cast::transmute_copy(self) } }
 }