---

yaml
---
r: 23447
b: refs/heads/master
c: aa024ac
h: refs/heads/master
i:
  23445: b8b4bc9
  23443: edc259a
  23439: 76f177e
v: v3

Author: paulstansifer

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2dc9be7a142e68550a71086104f7dc5104c1dbf9
+refs/heads/master: aa024acae3912d7d58e38fdd8185a115f2ab4e8f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libstd/time.rs

@@ -1,6 +1,3 @@
-#[forbid(deprecated_mode)];
-#[forbid(deprecated_pattern)];
-
 import libc::{c_char, c_int, c_long, size_t, time_t};
 import io::Reader;
 import result::{result, ok, err};
@@ -131,7 +128,7 @@ fn now() -> tm {
 }
 
 /// Parses the time from the string according to the format string.
-fn strptime(s: &str, format: &str) -> result<tm, ~str> {
+fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
     type tm_mut = {
        mut tm_sec: i32,
        mut tm_min: i32,
@@ -147,7 +144,7 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
        mut tm_nsec: i32,
     };
 
-    fn match_str(s: &str, pos: uint, needle: &str) -> bool {
+    fn match_str(s: ~str, pos: uint, needle: ~str) -> bool {
         let mut i = pos;
         for str::each(needle) |ch| {
             if s[i] != ch {
@@ -158,14 +155,14 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
         return true;
     }
 
-    fn match_strs(ss: &str, pos: uint, strs: &[(~str, i32)])
+    fn match_strs(s: ~str, pos: uint, strs: ~[(~str, i32)])
       -> option<(i32, uint)> {
         let mut i = 0u;
         let len = vec::len(strs);
         while i < len {
             let (needle, value) = strs[i];
 
-            if match_str(ss, pos, needle) {
+            if match_str(s, pos, needle) {
                 return some((value, pos + str::len(needle)));
             }
             i += 1u;
@@ -174,14 +171,14 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
         none
     }
 
-    fn match_digits(ss: &str, pos: uint, digits: uint, ws: bool)
+    fn match_digits(s: ~str, pos: uint, digits: uint, ws: bool)
       -> option<(i32, uint)> {
         let mut pos = pos;
         let mut value = 0_i32;
 
         let mut i = 0u;
         while i < digits {
-            let {ch, next} = str::char_range_at(str::from_slice(ss), pos);
+            let {ch, next} = str::char_range_at(s, pos);
             pos = next;
 
             match ch {
@@ -197,7 +194,7 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
         some((value, pos))
     }
 
-    fn parse_char(s: &str, pos: uint, c: char) -> result<uint, ~str> {
+    fn parse_char(s: ~str, pos: uint, c: char) -> result<uint, ~str> {
         let {ch, next} = str::char_range_at(s, pos);
 
         if c == ch {
@@ -209,7 +206,7 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
         }
     }
 
-    fn parse_type(s: &str, pos: uint, ch: char, tm: &tm_mut)
+    fn parse_type(s: ~str, pos: uint, ch: char, tm: tm_mut)
       -> result<uint, ~str> {
         match ch {
           'A' => match match_strs(s, pos, ~[
@@ -519,7 +516,7 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
         }
     }
 
-    do io::with_str_reader(str::from_slice(format)) |rdr| {
+    do io::with_str_reader(format) |rdr| {
         let tm = {
             mut tm_sec: 0_i32,
             mut tm_min: 0_i32,
@@ -542,7 +539,7 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
             let {ch, next} = str::char_range_at(s, pos);
 
             match rdr.read_char() {
-              '%' => match parse_type(s, pos, rdr.read_char(), &tm) {
+              '%' => match parse_type(s, pos, rdr.read_char(), tm) {
                 ok(next) => pos = next,
                   err(e) => { result = err(e); break; }
               },
@@ -572,8 +569,8 @@ fn strptime(s: &str, format: &str) -> result<tm, ~str> {
     }
 }
 
-fn strftime(format: &str, +tm: tm) -> ~str {
-    fn parse_type(ch: char, tm: &tm) -> ~str {
+fn strftime(format: ~str, tm: tm) -> ~str {
+    fn parse_type(ch: char, tm: tm) -> ~str {
         //FIXME (#2350): Implement missing types.
       let die = || #fmt("strftime: can't understand this format %c ",
                              ch);
@@ -728,10 +725,10 @@ fn strftime(format: &str, +tm: tm) -> ~str {
 
     let mut buf = ~"";
 
-    do io::with_str_reader(str::from_slice(format)) |rdr| {
+    do io::with_str_reader(format) |rdr| {
         while !rdr.eof() {
             match rdr.read_char() {
-                '%' => buf += parse_type(rdr.read_char(), &tm),
+                '%' => buf += parse_type(rdr.read_char(), tm),
                 ch => str::push_char(buf, ch)
             }
         }
@@ -769,7 +766,7 @@ impl tm {
     fn ctime() -> ~str { self.strftime(~"%c") }
 
     /// Formats the time according to the format string.
-    fn strftime(format: &str) -> ~str { strftime(format, self) }
+    fn strftime(format: ~str) -> ~str { strftime(format, self) }
 
     /**
      * Returns a time string formatted according to RFC 822.
@@ -986,9 +983,9 @@ mod tests {
           }
         }
 
-        fn test(s: &str, format: &str) -> bool {
+        fn test(s: ~str, format: ~str) -> bool {
             match strptime(s, format) {
-              ok(tm) => tm.strftime(format) == str::from_slice(s),
+              ok(tm) => tm.strftime(format) == s,
               err(e) => fail e
             }
         }

trunk/src/libsyntax/ast.rs

@@ -30,16 +30,24 @@ fn deserialize_span<D>(_d: D) -> span {
 #[auto_serialize]
 type spanned<T> = {node: T, span: span};
 
+
+/* can't import macros yet, so this is copied from token.rs. See its comment
+ * there. */
+macro_rules! interner_key (
+    () => (unsafe::transmute::<(uint, uint), &fn(+@@token::ident_interner)>(
+        (-3 as uint, 0u)))
+)
+
 fn serialize_ident<S: serializer>(s: S, i: ident) {
-    let intr = match unsafe{task::local_data_get(parse::token::interner_key)}{
+    let intr = match unsafe{task::local_data_get(interner_key!())}{
         none => fail ~"serialization: TLS interner not set up",
         some(intr) => intr
     };
 
     s.emit_str(*(*intr).get(i));
 }
 fn deserialize_ident<D: deserializer>(d: D) -> ident  {
-    let intr = match unsafe{task::local_data_get(parse::token::interner_key)}{
+    let intr = match unsafe{task::local_data_get(interner_key!())}{
         none => fail ~"deserialization: TLS interner not set up",
         some(intr) => intr
     };

trunk/src/libsyntax/parse/token.rs

@@ -325,8 +325,14 @@ mod special_idents {
 type ident_interner = util::interner::interner<@~str>;
 
 /** Key for thread-local data for sneaking interner information to the
- * serializer/deserializer. It sounds like a hack because it is one. */
-fn interner_key(+_x: @@ident_interner) { }
+ * serializer/deserializer. It sounds like a hack because it is one.
+ * Bonus ultra-hack: functions as keys don't work across crates,
+ * so we have to use a unique number. See taskgroup_key! in task.rs
+ * for another case of this. */
+macro_rules! interner_key (
+    () => (unsafe::transmute::<(uint, uint), &fn(+@@token::ident_interner)>(
+        (-3 as uint, 0u)))
+)
 
 fn mk_ident_interner() -> ident_interner {
     /* the indices here must correspond to the numbers in special_idents */
@@ -343,8 +349,8 @@ fn mk_ident_interner() -> ident_interner {
                                            |x,y| str::eq(*x, *y), init_vec);
 
     /* having multiple interners will just confuse the serializer */
-    unsafe{ assert task::local_data_get(interner_key) == none };
-    unsafe{ task::local_data_set(interner_key, @rv) };
+    unsafe{ assert task::local_data_get(interner_key!()) == none };
+    unsafe{ task::local_data_set(interner_key!(), @rv) };
     rv
 }
 

trunk/src/rustdoc/extract.rs

@@ -5,18 +5,24 @@ import doc::item_utils;
 
 export from_srv, extract, to_str, interner;
 
+
+/* can't import macros yet, so this is copied from token.rs. See its comment
+ * there. */
+macro_rules! interner_key (
+    () => (unsafe::transmute::<(uint, uint),
+           &fn(+@@syntax::parse::token::ident_interner)>((-3 as uint, 0u)))
+)
+
 // Hack; rather than thread an interner through everywhere, rely on
 // thread-local data
 fn to_str(id: ast::ident) -> ~str {
-    let intr = unsafe{ task::local_data_get(
-        syntax::parse::token::interner_key) };
+    let intr = unsafe{ task::local_data_get(interner_key!()) };
 
     return *(*intr.get()).get(id);
 }
 
 fn interner() -> syntax::parse::token::ident_interner {
-    return *(unsafe{ task::local_data_get(
-        syntax::parse::token::interner_key) }).get();
+    return *(unsafe{ task::local_data_get(interner_key!()) }).get();
 }
 
 fn from_srv(