From a9e7669cdc551588144a5b56db0b42dd35b71876 Mon Sep 17 00:00:00 2001
From: Aaron Turon <aturon@mozilla.com>
Date: Thu, 18 Dec 2014 19:41:20 -0800
Subject: Rebasing fixes.

---
 src/libstd/sys/common/backtrace.rs   | 28 ++++++++++++++++++----------
 src/libstd/sys/common/thread_info.rs |  2 +-
 src/libstd/sys/windows/backtrace.rs  |  4 ++--
 3 files changed, 21 insertions(+), 13 deletions(-)

(limited to 'src/libstd/sys')

diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs
index 2ff82bfd7a9..a39c8d6d8fe 100644
--- a/src/libstd/sys/common/backtrace.rs
+++ b/src/libstd/sys/common/backtrace.rs
@@ -40,8 +40,18 @@ pub fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> {
     // expecting, we just print it literally. Note that we must handle non-rust
     // symbols because we could have any function in the backtrace.
     let mut valid = true;
+    let mut inner = s;
     if s.len() > 4 && s.starts_with("_ZN") && s.ends_with("E") {
-        let mut chars = s.slice(3, s.len() - 1).chars();
+        inner = s.slice(3, s.len() - 1);
+    // On Windows, dbghelp strips leading underscores, so we accept "ZN...E" form too.
+    } else if s.len() > 3 && s.starts_with("ZN") && s.ends_with("E") {
+        inner = s.slice(2, s.len() - 1);
+    } else {
+        valid = false;
+    }
+
+    if valid {
+        let mut chars = inner.chars();
         while valid {
             let mut i = 0;
             for c in chars {
@@ -58,32 +68,29 @@ pub fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> {
                 valid = false;
             }
         }
-    } else {
-        valid = false;
     }
 
     // Alright, let's do this.
     if !valid {
         try!(writer.write_str(s));
     } else {
-        let mut s = s.slice_from(3);
         let mut first = true;
-        while s.len() > 1 {
+        while inner.len() > 0 {
             if !first {
                 try!(writer.write_str("::"));
             } else {
                 first = false;
             }
-            let mut rest = s;
+            let mut rest = inner;
             while rest.char_at(0).is_numeric() {
                 rest = rest.slice_from(1);
             }
-            let i: uint = from_str(s.slice_to(s.len() - rest.len())).unwrap();
-            s = rest.slice_from(i);
+            let i: uint = from_str(inner.slice_to(inner.len() - rest.len())).unwrap();
+            inner = rest.slice_from(i);
             rest = rest.slice_to(i);
             while rest.len() > 0 {
                 if rest.starts_with("$") {
-                    macro_rules! demangle(
+                    macro_rules! demangle {
                         ($($pat:expr => $demangled:expr),*) => ({
                             $(if rest.starts_with($pat) {
                                 try!(writer.write_str($demangled));
@@ -95,7 +102,8 @@ pub fn demangle(writer: &mut Writer, s: &str) -> IoResult<()> {
                             }
 
                         })
-                    )
+                    }
+
                     // see src/librustc/back/link.rs for these mappings
                     demangle! (
                         "$SP$" => "@",
diff --git a/src/libstd/sys/common/thread_info.rs b/src/libstd/sys/common/thread_info.rs
index 0519bc56f0a..dc21feb17a8 100644
--- a/src/libstd/sys/common/thread_info.rs
+++ b/src/libstd/sys/common/thread_info.rs
@@ -23,7 +23,7 @@ struct ThreadInfo {
     thread: Thread,
 }
 
-thread_local!(static THREAD_INFO: RefCell<Option<ThreadInfo>> = RefCell::new(None))
+thread_local! { static THREAD_INFO: RefCell<Option<ThreadInfo>> = RefCell::new(None) }
 
 impl ThreadInfo {
     fn with<R>(f: |&mut ThreadInfo| -> R) -> R {
diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs
index b5961d783ff..f2f543dd969 100644
--- a/src/libstd/sys/windows/backtrace.rs
+++ b/src/libstd/sys/windows/backtrace.rs
@@ -304,12 +304,12 @@ pub fn write(w: &mut Writer) -> IoResult<()> {
         Err(..) => return Ok(()),
     };
 
-    macro_rules! sym( ($e:expr, $t:ident) => (unsafe {
+    macro_rules! sym{ ($e:expr, $t:ident) => (unsafe {
         match lib.symbol($e) {
             Ok(f) => mem::transmute::<*mut u8, $t>(f),
             Err(..) => return Ok(())
         }
-    }) )
+    }) }
 
     // Fetch the symbols necessary from dbghelp.dll
     let SymFromAddr = sym!("SymFromAddr", SymFromAddrFn);
-- 
cgit 1.4.1-3-g733a5