---

yaml
---
r: 83500
b: refs/heads/try
c: fe9b1e2
h: refs/heads/master
v: v3

Author: sfackler

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: c0e1c09783422870e4d6e5862459d45036bb24d7
+refs/heads/try: fe9b1e29fc9cc1983fdf17355d7b8956b63d9b55
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/etc/emacs/rust-mode.el

@@ -127,6 +127,7 @@
 (defconst rust-mode-keywords
   '("as"
     "break"
+    "continue"
     "do"
     "else" "enum" "extern"
     "false" "fn" "for"

branches/try/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -39,6 +39,7 @@
 		<keyword>assert</keyword>
 		<keyword>break</keyword>
 		<keyword>const</keyword>
+		<keyword>continue</keyword>
 		<keyword>do</keyword>
 		<keyword>drop</keyword>
 		<keyword>else</keyword>

branches/try/src/etc/kate/rust.xml

@@ -18,6 +18,7 @@
 	<list name="keywords">
 		<item> as </item>
 		<item> break </item>
+		<item> continue </item>
 		<item> do </item>
 		<item> drop </item>
 		<item> else </item>

branches/try/src/etc/vim/syntax/rust.vim

@@ -18,7 +18,7 @@ syn keyword   rustOperator    as
 
 syn match     rustAssert      "\<assert\(\w\)*!" contained
 syn match     rustFail        "\<fail\(\w\)*!" contained
-syn keyword   rustKeyword     break do extern
+syn keyword   rustKeyword     break continue do extern
 syn keyword   rustKeyword     in if impl let log
 syn keyword   rustKeyword     for impl let log
 syn keyword   rustKeyword     loop mod once priv pub

branches/try/src/librustc/metadata/decoder.rs

@@ -564,19 +564,19 @@ impl<'self> EachItemContext<'self> {
             }
         }
 
-        let mut continue = (self.callback)(*self.path_builder, def_like, vis);
+        let mut continue_ = (self.callback)(*self.path_builder, def_like, vis);
 
         let family = item_family(doc);
         if family == ForeignMod {
             // These are unnamed; pop the name now.
             self.pop_name(old_len)
         }
 
-        if continue {
+        if continue_ {
             // Recurse if necessary.
             match family {
                 Mod | ForeignMod | Trait | Impl => {
-                    continue = self.each_item_of_module(def_id);
+                    continue_ = self.each_item_of_module(def_id);
                 }
                 ImmStatic | MutStatic | Struct | UnsafeFn | Fn | ForeignFn |
                 UnsafeStaticMethod | StaticMethod | Type | ForeignType |
@@ -589,7 +589,7 @@ impl<'self> EachItemContext<'self> {
             self.pop_name(old_len)
         }
 
-        continue
+        continue_
     }
 
     fn each_item_of_module(&mut self, def_id: ast::DefId) -> bool {
@@ -612,7 +612,7 @@ impl<'self> EachItemContext<'self> {
     }
 
     fn each_child_of_module_or_crate(&mut self, item_doc: ebml::Doc) -> bool {
-        let mut continue = true;
+        let mut continue_ = true;
 
         // Iterate over all children.
         do reader::tagged_docs(item_doc, tag_mod_child) |child_info_doc| {
@@ -654,16 +654,16 @@ impl<'self> EachItemContext<'self> {
                     // Process this item.
 
                     let vis = item_visibility(child_item_doc);
-                    continue = self.process_item_and_pop_name(child_item_doc,
+                    continue_ = self.process_item_and_pop_name(child_item_doc,
                                                               child_def_id,
                                                               old_len,
                                                               vis);
                 }
             }
-            continue
+            continue_
         };
 
-        if !continue {
+        if !continue_ {
             return false
         }
 
@@ -705,18 +705,18 @@ impl<'self> EachItemContext<'self> {
             match maybe_find_item(def_id.node, other_crates_items) {
                 None => { self.pop_name(old_len); }
                 Some(reexported_item_doc) => {
-                    continue = self.process_item_and_pop_name(
+                    continue_ = self.process_item_and_pop_name(
                         reexported_item_doc,
                         def_id,
                         old_len,
                         ast::public);
                 }
             }
 
-            continue
+            continue_
         };
 
-        continue
+        continue_
     }
 }
 

branches/try/src/librustc/metadata/encoder.rs

@@ -521,12 +521,12 @@ fn encode_reexported_static_methods(ecx: &EncodeContext,
 /// * For newtype structs, iterates through the node ID of the constructor.
 fn each_auxiliary_node_id(item: @item, callback: &fn(NodeId) -> bool)
                           -> bool {
-    let mut continue = true;
+    let mut continue_ = true;
     match item.node {
         item_enum(ref enum_def, _) => {
             for variant in enum_def.variants.iter() {
-                continue = callback(variant.node.id);
-                if !continue {
+                continue_ = callback(variant.node.id);
+                if !continue_ {
                     break
                 }
             }
@@ -537,15 +537,15 @@ fn each_auxiliary_node_id(item: @item, callback: &fn(NodeId) -> bool)
                 Some(ctor_id) if struct_def.fields.len() > 0 &&
                         struct_def.fields[0].node.kind ==
                         ast::unnamed_field => {
-                    continue = callback(ctor_id);
+                    continue_ = callback(ctor_id);
                 }
                 _ => {}
             }
         }
         _ => {}
     }
 
-    continue
+    continue_
 }
 
 fn encode_reexports(ecx: &EncodeContext,

branches/try/src/libstd/logging.rs

@@ -10,11 +10,11 @@
 
 //! Logging
 
+use fmt;
 use option::*;
 use os;
 use rt;
 use rt::logging::{Logger, StdErrLogger};
-use send_str::SendStrOwned;
 
 /// Turns on logging to stdout globally
 pub fn console_on() {
@@ -37,7 +37,17 @@ pub fn console_off() {
     rt::logging::console_off();
 }
 
-fn newsched_log_str(msg: ~str) {
+#[cfg(stage0)]
+#[doc(hidden)]
+pub fn log(_level: u32, s: ~str) {
+    // this is a terrible approximation, but it gets the job done (for stage0 at
+    // least)
+    ::io::println(s);
+}
+
+#[allow(missing_doc)]
+#[cfg(not(stage0))]
+pub fn log(_level: u32, args: &fmt::Arguments) {
     use rt::task::Task;
     use rt::local::Local;
 
@@ -46,20 +56,13 @@ fn newsched_log_str(msg: ~str) {
         match optional_task {
             Some(local) => {
                 // Use the available logger
-                (*local).logger.log(SendStrOwned(msg));
+                (*local).logger.log(args);
             }
             None => {
                 // There is no logger anywhere, just write to stderr
                 let mut logger = StdErrLogger;
-                logger.log(SendStrOwned(msg));
+                logger.log(args);
             }
         }
     }
 }
-
-// XXX: This will change soon to not require an allocation. This is an unstable
-//      api which should not be used outside of the macros in ext/expand.
-#[doc(hidden)]
-pub fn log(_level: u32, msg: ~str) {
-    newsched_log_str(msg);
-}

branches/try/src/libstd/rt/io/mem.rs

@@ -22,7 +22,7 @@ use vec;
 
 /// Writes to an owned, growable byte vector
 pub struct MemWriter {
-    buf: ~[u8]
+    priv buf: ~[u8]
 }
 
 impl MemWriter {
@@ -66,8 +66,8 @@ impl Decorator<~[u8]> for MemWriter {
 
 /// Reads from an owned byte vector
 pub struct MemReader {
-    buf: ~[u8],
-    pos: uint
+    priv buf: ~[u8],
+    priv pos: uint
 }
 
 impl MemReader {
@@ -129,8 +129,8 @@ impl Decorator<~[u8]> for MemReader {
 
 /// Writes to a fixed-size byte slice
 pub struct BufWriter<'self> {
-    buf: &'self mut [u8],
-    pos: uint
+    priv buf: &'self mut [u8],
+    priv pos: uint
 }
 
 impl<'self> BufWriter<'self> {
@@ -157,8 +157,8 @@ impl<'self> Seek for BufWriter<'self> {
 
 /// Reads from a fixed-size byte slice
 pub struct BufReader<'self> {
-    buf: &'self [u8],
-    pos: uint
+    priv buf: &'self [u8],
+    priv pos: uint
 }
 
 impl<'self> BufReader<'self> {
@@ -199,9 +199,9 @@ impl<'self> Seek for BufReader<'self> {
 ///Calls a function with a MemWriter and returns
 ///the writer's stored vector.
 pub fn with_mem_writer(writeFn:&fn(&mut MemWriter)) -> ~[u8] {
-  let mut writer = MemWriter::new();
-  writeFn(&mut writer);
-  writer.inner()
+    let mut writer = MemWriter::new();
+    writeFn(&mut writer);
+    writer.inner()
 }
 
 #[cfg(test)]

branches/try/src/libstd/rt/io/net/ip.rs

@@ -15,7 +15,7 @@ use from_str::FromStr;
 use option::{Option, None, Some};
 
 
-type Port = u16;
+pub type Port = u16;
 
 #[deriving(Eq, TotalEq, Clone)]
 pub enum IpAddr {

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

@@ -7,9 +7,12 @@
 // <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.
+
+use fmt;
 use from_str::from_str;
-use libc::{uintptr_t, exit, STDERR_FILENO};
+use libc::{uintptr_t, exit};
 use option::{Some, None, Option};
+use rt;
 use rt::util::dumb_println;
 use rt::crate_map::{ModEntry, iter_crate_map};
 use rt::crate_map::get_crate_map;
@@ -18,7 +21,6 @@ use str::raw::from_c_str;
 use u32;
 use vec::ImmutableVector;
 use cast::transmute;
-use send_str::{SendStr, SendStrOwned, SendStrStatic};
 
 struct LogDirective {
     name: Option<~str>,
@@ -171,44 +173,33 @@ fn update_log_settings(crate_map: *u8, settings: ~str) {
 }
 
 pub trait Logger {
-    fn log(&mut self, msg: SendStr);
+    fn log(&mut self, args: &fmt::Arguments);
 }
 
 pub struct StdErrLogger;
 
 impl Logger for StdErrLogger {
-    fn log(&mut self, msg: SendStr) {
-        use io::{Writer, WriterUtil};
-
-        if !should_log_console() {
-            return;
+    fn log(&mut self, args: &fmt::Arguments) {
+        if should_log_console() {
+            fmt::write(self as &mut rt::io::Writer, args);
         }
+    }
+}
 
-        let s: &str = match msg {
-            SendStrOwned(ref s) => {
-                let slc: &str = *s;
-                slc
-            },
-            SendStrStatic(s) => s,
-        };
-
-        // Truncate the string
-        let buf_bytes = 2048;
-        if s.len() > buf_bytes {
-            let s = s.slice(0, buf_bytes) + "[...]";
-            print(s);
-        } else {
-            print(s)
-        };
-
-        fn print(s: &str) {
-            let dbg = STDERR_FILENO as ::io::fd_t;
-            dbg.write_str(s);
-            dbg.write_str("\n");
-            dbg.flush();
-        }
+impl rt::io::Writer for StdErrLogger {
+    fn write(&mut self, buf: &[u8]) {
+        // Nothing like swapping between I/O implementations! In theory this
+        // could use the libuv bindings for writing to file descriptors, but
+        // that may not necessarily be desirable because logging should work
+        // outside of the uv loop. (modify with caution)
+        use io::Writer;
+        let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
+        dbg.write(buf);
     }
+
+    fn flush(&mut self) {}
 }
+
 /// Configure logging by traversing the crate map and setting the
 /// per-module global logging flags based on the logging spec
 pub fn init() {

branches/try/src/libstd/std.rs

@@ -223,4 +223,5 @@ mod std {
     pub use os;
     pub use fmt;
     pub use to_bytes;
+    pub use logging;
 }