---

yaml
---
r: 77054
b: refs/heads/snap-stage3
c: 1860efb
h: refs/heads/master
v: v3

Author: vadimcn

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: f1132496dddbdd88f321a7919eec3d65136b3f75
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: f51d30d7295507d5075a61d8bf9f17be8ad3fbe9
+refs/heads/snap-stage3: 1860efbfc62465ca096e67ee64ba9b2f71c5e1a8
 refs/heads/try: ebfe63cd1c0b5d23f7ea60c69b4fde2e30cfd42a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -61,7 +61,6 @@ impl Url {
 }
 
 impl UserInfo {
-    #[inline]
     pub fn new(user: ~str, pass: Option<~str>) -> UserInfo {
         UserInfo { user: user, pass: pass }
     }
@@ -461,14 +460,11 @@ fn get_authority(rawurl: &str) ->
               }
               InHost => {
                 pos = i;
+                // can't be sure whether this is an ipv6 address or a port
                 if input == Unreserved {
-                    // must be port
-                    host = rawurl.slice(begin, i).to_owned();
-                    st = InPort;
-                } else {
-                    // can't be sure whether this is an ipv6 address or a port
-                    st = Ip6Port;
+                    return Err(~"Illegal characters in authority.");
                 }
+                st = Ip6Port;
               }
               Ip6Port => {
                 if input == Unreserved {
@@ -518,12 +514,25 @@ fn get_authority(rawurl: &str) ->
           }
           _ => ()
         }
+        end = i;
     }
 
+    let end = end; // make end immutable so it can be captured
+
+    let host_is_end_plus_one: &fn() -> bool = || {
+        let xs = ['?', '#', '/'];
+        end+1 == len
+            && !xs.iter().any(|x| *x == (rawurl[end] as char))
+    };
+
     // finish up
     match st {
       Start => {
-        host = rawurl.slice(begin, end).to_owned();
+        if host_is_end_plus_one() {
+            host = rawurl.slice(begin, end+1).to_owned();
+        } else {
+            host = rawurl.slice(begin, end).to_owned();
+        }
       }
       PassHostPort | Ip6Port => {
         if input != Digit {
@@ -543,7 +552,8 @@ fn get_authority(rawurl: &str) ->
       }
     }
 
-    let rest = rawurl.slice(end, len).to_owned();
+    let rest = if host_is_end_plus_one() { ~"" }
+    else { rawurl.slice(end, len).to_owned() };
     return Ok((userinfo, host, port, rest));
 }
 
@@ -796,17 +806,18 @@ mod tests {
 
     #[test]
     fn test_url_parse() {
-        let url = ~"http://user:[email protected]:8080/doc?s=v#something";
+        let url = ~"http://user:[email protected]/doc?s=v#something";
 
         let up = from_str(url);
         let u = up.unwrap();
-        assert_eq!(&u.scheme, &~"http");
-        assert_eq!(&u.user, &Some(UserInfo::new(~"user", Some(~"pass"))));
-        assert_eq!(&u.host, &~"rust-lang.org");
-        assert_eq!(&u.port, &Some(~"8080"));
-        assert_eq!(&u.path, &~"/doc");
-        assert_eq!(&u.query, &~[(~"s", ~"v")]);
-        assert_eq!(&u.fragment, &Some(~"something"));
+        assert!(u.scheme == ~"http");
+        let userinfo = u.user.get_ref();
+        assert!(userinfo.user == ~"user");
+        assert!(userinfo.pass.get_ref() == &~"pass");
+        assert!(u.host == ~"rust-lang.org");
+        assert!(u.path == ~"/doc");
+        assert!(u.query == ~[(~"s", ~"v")]);
+        assert!(u.fragment.get_ref() == &~"something");
     }
 
     #[test]
@@ -817,22 +828,6 @@ mod tests {
         assert!(url.path == ~"/");
     }
 
-    #[test]
-    fn test_url_host_with_port() {
-        let urlstr = ~"scheme://host:1234";
-        let url = from_str(urlstr).unwrap();
-        assert_eq!(&url.scheme, &~"scheme");
-        assert_eq!(&url.host, &~"host");
-        assert_eq!(&url.port, &Some(~"1234"));
-        assert_eq!(&url.path, &~""); // is empty path really correct? Other tests think so
-        let urlstr = ~"scheme://host:1234/";
-        let url = from_str(urlstr).unwrap();
-        assert_eq!(&url.scheme, &~"scheme");
-        assert_eq!(&url.host, &~"host");
-        assert_eq!(&url.port, &Some(~"1234"));
-        assert_eq!(&url.path, &~"/");
-    }
-
     #[test]
     fn test_url_with_underscores() {
         let urlstr = ~"http://dotcom.com/file_name.html";

branches/snap-stage3/src/librustc/back/link.rs

@@ -822,9 +822,10 @@ pub fn link_binary(sess: Session,
     // In the future, FreeBSD will use clang as default compiler.
     // It would be flexible to use cc (system's default C compiler)
     // instead of hard-coded gcc.
-    // For win32, there is no cc command,
-    // so we add a condition to make it use gcc.
-    let cc_prog: ~str = match sess.opts.linker {
+    // For win32, there is no cc command, so we add a condition to make it use g++.
+    // We use g++ rather than gcc because it automatically adds linker options required
+    // for generation of dll modules that correctly register stack unwind tables.
+    match sess.opts.linker {
         Some(ref linker) => linker.to_str(),
         None => match sess.targ_cfg.os {
             session::os_android =>
@@ -837,7 +838,7 @@ pub fn link_binary(sess: Session,
                                     (--android-cross-path)")
                     }
                 },
-            session::os_win32 => ~"gcc",
+            session::os_win32 => ~"g++",
             _ => ~"cc"
         }
     };