---

yaml
---
r: 146076
b: refs/heads/try2
c: 3675e42
h: refs/heads/master
v: v3

Author: brson

[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: 6dd6623b71ccee5b24117fa14df2bf3e5533e0c7
+refs/heads/try2: 3675e42334e9e58ae16446f52b2c6c951e8e1628
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/glob.rs

@@ -39,32 +39,32 @@ pub struct GlobIterator {
     priv todo: ~[(Path,uint)]
 }
 
-///
-/// Return an iterator that produces all the Paths that match the given pattern,
-/// which may be absolute or relative to the current working directory.
-///
-/// is method uses the default match options and is equivalent to calling
-/// `glob_with(pattern, MatchOptions::new())`. Use `glob_with` directly if you
-/// want to use non-default match options.
-///
-/// # Example
-///
-/// Consider a directory `/media/pictures` containing only the files `kittens.jpg`,
-/// `puppies.jpg` and `hamsters.gif`:
-///
-/// ```rust
-/// for path in glob("/media/pictures/*.jpg") {
-///     println(path.to_str());
-/// }
-/// ```
-///
-/// The above code will print:
-///
-/// ```
-/// /media/pictures/kittens.jpg
-/// /media/pictures/puppies.jpg
-/// ```
-///
+/**
+ * Return an iterator that produces all the Paths that match the given pattern,
+ * which may be absolute or relative to the current working directory.
+ *
+ * This method uses the default match options and is equivalent to calling
+ * `glob_with(pattern, MatchOptions::new())`. Use `glob_with` directly if you
+ * want to use non-default match options.
+ *
+ * # Example
+ *
+ * Consider a directory `/media/pictures` containing only the files `kittens.jpg`,
+ * `puppies.jpg` and `hamsters.gif`:
+ *
+ * ```rust
+ * for path in glob("/media/pictures/*.jpg") {
+ *     println(path.to_str());
+ * }
+ * ```
+ *
+ * The above code will print:
+ *
+ * ```
+ * /media/pictures/kittens.jpg
+ * /media/pictures/puppies.jpg
+ * ```
+ */
 pub fn glob(pattern: &str) -> GlobIterator {
     glob_with(pattern, MatchOptions::new())
 }

branches/try2/src/librustc/middle/trans/base.rs

@@ -2797,8 +2797,8 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
 
     ifn!(intrinsics, "llvm.fabs.f32", [Type::f32()], Type::f32());
     ifn!(intrinsics, "llvm.fabs.f64", [Type::f64()], Type::f64());
-    ifn!(intrinsics, "llvm.copysign.f32", [Type::f32(), Type::f32()], Type::f32());
-    ifn!(intrinsics, "llvm.copysign.f64", [Type::f64(), Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.copysign.f32", [Type::f32()], Type::f32());
+    ifn!(intrinsics, "llvm.copysign.f64", [Type::f64()], Type::f64());
 
     ifn!(intrinsics, "llvm.floor.f32",[Type::f32()], Type::f32());
     ifn!(intrinsics, "llvm.floor.f64",[Type::f64()], Type::f64());
@@ -2807,12 +2807,12 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
     ifn!(intrinsics, "llvm.trunc.f32",[Type::f32()], Type::f32());
     ifn!(intrinsics, "llvm.trunc.f64",[Type::f64()], Type::f64());
 
-    ifn!(intrinsics, "llvm.rint.f32", [Type::f32()], Type::f32());
-    ifn!(intrinsics, "llvm.rint.f64", [Type::f64()], Type::f64());
-    ifn!(intrinsics, "llvm.nearbyint.f32", [Type::f32()], Type::f32());
-    ifn!(intrinsics, "llvm.nearbyint.f64", [Type::f64()], Type::f64());
-    ifn!(intrinsics, "llvm.round.f32", [Type::f32()], Type::f32());
-    ifn!(intrinsics, "llvm.round.f64", [Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.rint.f32",[Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.rint.f64",[Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.nearbyint.f32",[Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.nearbyint.f64",[Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.round.f32",[Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.round.f64",[Type::f64()], Type::f64());
 
     ifn!(intrinsics, "llvm.ctpop.i8", [Type::i8()], Type::i8());
     ifn!(intrinsics, "llvm.ctpop.i16",[Type::i16()], Type::i16());

branches/try2/src/librustc/middle/trans/intrinsic.rs

@@ -460,20 +460,20 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         "fmaf64" => simple_llvm_intrinsic(bcx, "llvm.fma.f64", 3),
         "fabsf32" => simple_llvm_intrinsic(bcx, "llvm.fabs.f32", 1),
         "fabsf64" => simple_llvm_intrinsic(bcx, "llvm.fabs.f64", 1),
-        "copysignf32" => simple_llvm_intrinsic(bcx, "llvm.copysign.f32", 2),
-        "copysignf64" => simple_llvm_intrinsic(bcx, "llvm.copysign.f64", 2),
+        "copysignf32" => simple_llvm_intrinsic(bcx, "llvm.copysign.f32", 1),
+        "copysignf64" => simple_llvm_intrinsic(bcx, "llvm.copysign.f64", 1),
         "floorf32" => simple_llvm_intrinsic(bcx, "llvm.floor.f32", 1),
         "floorf64" => simple_llvm_intrinsic(bcx, "llvm.floor.f64", 1),
         "ceilf32" => simple_llvm_intrinsic(bcx, "llvm.ceil.f32", 1),
         "ceilf64" => simple_llvm_intrinsic(bcx, "llvm.ceil.f64", 1),
         "truncf32" => simple_llvm_intrinsic(bcx, "llvm.trunc.f32", 1),
         "truncf64" => simple_llvm_intrinsic(bcx, "llvm.trunc.f64", 1),
-        "rintf32" => simple_llvm_intrinsic(bcx, "llvm.rint.f32", 1),
         "rintf64" => simple_llvm_intrinsic(bcx, "llvm.rint.f64", 1),
-        "nearbyintf32" => simple_llvm_intrinsic(bcx, "llvm.nearbyint.f32", 1),
-        "nearbyintf64" => simple_llvm_intrinsic(bcx, "llvm.nearbyint.f64", 1),
-        "roundf32" => simple_llvm_intrinsic(bcx, "llvm.round.f32", 1),
-        "roundf64" => simple_llvm_intrinsic(bcx, "llvm.round.f64", 1),
+        "rintf32" => simple_llvm_intrinsic(bcx, "llvm.rint.f32", 1),
+        "nearbyintf32" => simple_llvm_intrinsic(bcx, "llvm.nearbyint.f64", 1),
+        "nearbyintf64" => simple_llvm_intrinsic(bcx, "llvm.nearbyint.f32", 1),
+        "roundf32" => simple_llvm_intrinsic(bcx, "llvm.round.f64", 1),
+        "roundf64" => simple_llvm_intrinsic(bcx, "llvm.round.f32", 1),
         "ctpop8" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i8", 1),
         "ctpop16" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i16", 1),
         "ctpop32" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i32", 1),

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -3809,8 +3809,8 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
             }
             "fabsf32"      => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
             "fabsf64"      => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-            "copysignf32"  => (0, ~[ ty::mk_f32(), ty::mk_f32() ], ty::mk_f32()),
-            "copysignf64"  => (0, ~[ ty::mk_f64(), ty::mk_f64() ], ty::mk_f64()),
+            "copysignf32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "copysignf64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
             "floorf32"     => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
             "floorf64"     => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
             "ceilf32"      => (0, ~[ ty::mk_f32() ], ty::mk_f32()),

branches/try2/src/libstd/fmt/mod.rs

@@ -466,7 +466,7 @@ use rt::io::Decorator;
 use rt::io::mem::MemWriter;
 use rt::io;
 use str;
-use sys;
+use repr;
 use util;
 use vec;
 
@@ -1087,17 +1087,13 @@ impl<T> Poly for T {
     fn fmt(t: &T, f: &mut Formatter) {
         match (f.width, f.precision) {
             (None, None) => {
-                // XXX: sys::log_str should have a variant which takes a stream
-                //      and we should directly call that (avoids unnecessary
-                //      allocations)
-                let s = sys::log_str(t);
-                f.buf.write(s.as_bytes());
+                repr::write_repr(f.buf, t);
             }
 
             // If we have a specified width for formatting, then we have to make
             // this allocation of a new string
             _ => {
-                let s = sys::log_str(t);
+                let s = repr::repr_to_str(t);
                 f.pad(s);
             }
         }

branches/try2/src/libstd/os.rs

@@ -546,6 +546,12 @@ pub fn self_exe_path() -> Option<Path> {
     load_self().and_then(|path| Path::new_opt(path).map(|mut p| { p.pop(); p }))
 }
 
+
+/**
+ * Returns the path to the user's home directory, if known.
+}
+
+
 /**
  * Returns the path to the user's home directory, if known.
  *

branches/try2/src/libstd/repr.rs

@@ -616,6 +616,16 @@ pub fn write_repr<T>(writer: &mut io::Writer, object: &T) {
     }
 }
 
+pub fn repr_to_str<T>(t: &T) -> ~str {
+    use str;
+    use rt::io;
+    use rt::io::Decorator;
+
+    let mut result = io::mem::MemWriter::new();
+    write_repr(&mut result as &mut io::Writer, t);
+    str::from_utf8_owned(result.inner())
+}
+
 #[cfg(test)]
 struct P {a: int, b: f64}
 

branches/try2/src/libstd/sys.rs

@@ -15,18 +15,7 @@
 use c_str::ToCStr;
 use libc::size_t;
 use libc;
-use repr;
 use rt::task;
-use str;
-
-pub fn log_str<T>(t: &T) -> ~str {
-    use rt::io;
-    use rt::io::Decorator;
-
-    let mut result = io::mem::MemWriter::new();
-    repr::write_repr(&mut result as &mut io::Writer, t);
-    str::from_utf8_owned(result.inner())
-}
 
 /// Trait for initiating task failure.
 pub trait FailWithCause {

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

@@ -330,6 +330,9 @@ extern "rust-intrinsic" {
 
     pub fn visit_tydesc(td: *TyDesc, tv: &mut TyVisitor);
 
+    #[cfg(not(stage0))]
+    pub fn frame_address(f: &fn(*u8));
+
     /// Get the address of the `__morestack` stack growth function.
     pub fn morestack_addr() -> *();
 
@@ -411,9 +414,9 @@ extern "rust-intrinsic" {
     pub fn fabsf64(x: f64) -> f64;
 
     #[cfg(not(stage0))]
-    pub fn copysignf32(x: f32, y: f32) -> f32;
+    pub fn copysignf32(x: f32) -> f32;
     #[cfg(not(stage0))]
-    pub fn copysignf64(x: f64, y: f64) -> f64;
+    pub fn copysignf64(x: f64) -> f64;
 
     pub fn floorf32(x: f32) -> f32;
     pub fn floorf64(x: f64) -> f64;

branches/try2/src/libsyntax/ext/deriving/to_str.rs

@@ -40,9 +40,10 @@ pub fn expand_deriving_to_str(cx: @ExtCtxt,
 }
 
 // It used to be the case that this deriving implementation invoked
-// std::sys::log_str, but this isn't sufficient because it doesn't invoke the
-// to_str() method on each field. Hence we mirror the logic of the log_str()
-// method, but with tweaks to call to_str() on sub-fields.
+// std::repr::repr_to_str, but this isn't sufficient because it
+// doesn't invoke the to_str() method on each field. Hence we mirror
+// the logic of the repr_to_str() method, but with tweaks to call to_str()
+// on sub-fields.
 fn to_str_substructure(cx: @ExtCtxt, span: Span,
                        substr: &Substructure) -> @Expr {
     let to_str = cx.ident_of("to_str");

branches/try2/src/libsyntax/parse/lexer.rs

@@ -373,49 +373,49 @@ pub fn is_block_non_doc_comment(s: &str) -> bool {
 fn consume_block_comment(rdr: @mut StringReader)
                       -> Option<TokenAndSpan> {
     // block comments starting with "/**" or "/*!" are doc-comments
-    let is_doc_comment = rdr.curr == '*' || rdr.curr == '!';
-    let start_bpos = rdr.pos - BytePos(if is_doc_comment {3u} else {2u});
-
-    let mut level: int = 1;
-    while level > 0 {
-        if is_eof(rdr) {
-            let msg = if is_doc_comment {
-                ~"unterminated block doc-comment"
-            } else {
-                ~"unterminated block comment"
-            };
-            fatal_span(rdr, start_bpos, rdr.last_pos, msg);
-        } else if rdr.curr == '/' && nextch(rdr) == '*' {
-            level += 1;
-            bump(rdr);
-            bump(rdr);
-        } else if rdr.curr == '*' && nextch(rdr) == '/' {
-            level -= 1;
-            bump(rdr);
+    let res = if rdr.curr == '*' || rdr.curr == '!' {
+        let start_bpos = rdr.pos - BytePos(3u);
+        while !(rdr.curr == '*' && nextch(rdr) == '/') && !is_eof(rdr) {
             bump(rdr);
+        }
+        if is_eof(rdr) {
+            fatal_span(rdr, start_bpos, rdr.last_pos,
+                       ~"unterminated block doc-comment");
         } else {
             bump(rdr);
+            bump(rdr);
+            do with_str_from(rdr, start_bpos) |string| {
+                // but comments with only "*"s between two "/"s are not
+                if !is_block_non_doc_comment(string) {
+                    Some(TokenAndSpan{
+                         tok: token::DOC_COMMENT(str_to_ident(string)),
+                         sp: codemap::mk_sp(start_bpos, rdr.pos)
+                         })
+                } else {
+                    None
+                }
+            }
         }
-    }
-
-    let res = if is_doc_comment {
-        do with_str_from(rdr, start_bpos) |string| {
-            // but comments with only "*"s between two "/"s are not
-            if !is_block_non_doc_comment(string) {
-                Some(TokenAndSpan{
-                        tok: token::DOC_COMMENT(str_to_ident(string)),
-                        sp: codemap::mk_sp(start_bpos, rdr.pos)
-                    })
+    } else {
+        let start_bpos = rdr.last_pos - BytePos(2u);
+        loop {
+            if is_eof(rdr) {
+                fatal_span(rdr, start_bpos, rdr.last_pos,
+                           ~"unterminated block comment");
+            }
+            if rdr.curr == '*' && nextch(rdr) == '/' {
+                bump(rdr);
+                bump(rdr);
+                break;
             } else {
-                None
+                bump(rdr);
             }
         }
-    } else {
         None
     };
-
     // restart whitespace munch.
-    if res.is_some() { res } else { consume_whitespace_and_comments(rdr) }
+
+   if res.is_some() { res } else { consume_whitespace_and_comments(rdr) }
 }
 
 fn scan_exponent(rdr: @mut StringReader, start_bpos: BytePos) -> Option<~str> {
@@ -1056,12 +1056,4 @@ mod test {
         assert!(!is_line_non_doc_comment("/// blah"));
         assert!(is_line_non_doc_comment("////"));
     }
-
-    #[test] fn nested_block_comments() {
-        let env = setup(@"/* /* */ */'a'");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        assert_eq!(tok,token::LIT_CHAR('a' as u32));
-    }
-
 }

branches/try2/src/snapshots.txt

@@ -1,11 +1,3 @@
-S 2013-10-21 6e6981c
-  freebsd-x86_64 7f630581d0e881483272140e84bc2f494daf6204
-  linux-i386 5c754455610013bbe448e8f6ef8ba1a05b167919
-  linux-x86_64 d993920210413add241f7b235dec0e4d72164be5
-  macos-i386 8b48d8598f4d503e6bbc40bff52457c659d6de2b
-  macos-x86_64 e84bcd0b08af6a0ff602dca7a5bec21a001c5eb8
-  winnt-i386 3f4441509f89a794ec9b53e38756e6124df78df0
-
 S 2013-10-16 6c08cc2
   freebsd-x86_64 03caf882078eff9b4e04d116732b41a3cdfc260f
   linux-i386 ce30bb90434e9eb9920028a5408e1f986ba2ad5d

branches/try2/src/test/compile-fail/no-comment-balancing.rs

@@ -0,0 +1,26 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern:
+
+/* This is a test to ensure that we do _not_ support nested/balanced comments. I know you might be
+   thinking "but nested comments are cool", and that would be a valid point, but they are also a
+   thing that would make our lexical syntax non-regular, and we do not want that to be true.
+
+   omitting-things at a higher level (tokens) should be done via token-trees / macros,
+   not comments.
+
+   /*
+     fail here
+   */
+*/
+
+fn main() {
+}