---

yaml
---
r: 46868
b: refs/heads/auto
c: b69fb75
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -14,4 +14,4 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 8453f3110c7b84fe4a29c743b57f846fb5f654d3
+refs/heads/auto: b69fb75348b5aeb0988489d748373b1900f2766b

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

@@ -7,7 +7,6 @@
 
 (require 'cm-mode)
 (require 'cc-mode)
-(eval-when-compile (require 'cl))
 
 (defun rust-electric-brace (arg)
   (interactive "*P")

branches/auto/src/libcore/core.rc

@@ -142,8 +142,6 @@ pub mod option;
 pub mod result;
 pub mod either;
 pub mod dlist;
-#[path="iter-trait.rs"] #[merge = "iter-trait/dlist.rs"]
-pub mod dlist_iter;
 pub mod hashmap;
 pub mod cell;
 pub mod trie;

branches/auto/src/libcore/dlist.rs

@@ -18,6 +18,8 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 
 */
 
+use iter;
+use iter::BaseIter;
 use kinds::Copy;
 use managed;
 use option::{None, Option, Some};
@@ -489,14 +491,54 @@ pub impl<T:Copy> DList<T> {
         let mut v = vec::with_capacity(self.size);
         unsafe {
             // Take this out of the unchecked when iter's functions are pure
-            for self.eachi |index,data| {
+            for iter::eachi(&self) |index,data| {
                 v[index] = *data;
             }
         }
         v
     }
 }
 
+impl<T> BaseIter<T> for @mut DList<T> {
+    /**
+    * Iterates through the current contents.
+    *
+    * Attempts to access this dlist during iteration are allowed (to
+    * allow for e.g. breadth-first search with in-place enqueues), but
+    * removing the current node is forbidden.
+    */
+    pure fn each(&self, f: fn(v: &T) -> bool) {
+        let mut link = self.peek_n();
+        while option::is_some(&link) {
+            let nobe = option::get(link);
+            fail_unless!(nobe.linked);
+
+            {
+                let frozen_nobe = &*nobe;
+                if !f(&frozen_nobe.data) { break; }
+            }
+
+            // Check (weakly) that the user didn't do a remove.
+            if self.size == 0 {
+                fail!(~"The dlist became empty during iteration??")
+            }
+            if !nobe.linked ||
+                (!((nobe.prev.is_some()
+                    || managed::mut_ptr_eq(self.hd.expect(~"headless dlist?"),
+                                           nobe))
+                   && (nobe.next.is_some()
+                    || managed::mut_ptr_eq(self.tl.expect(~"tailless dlist?"),
+                                           nobe)))) {
+                fail!(~"Removing a dlist node during iteration is forbidden!")
+            }
+            link = nobe.next_link();
+        }
+    }
+
+    #[inline(always)]
+    pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
+}
+
 #[cfg(test)]
 mod tests {
     use dlist::{DList, concat, from_vec, new_dlist_node};

branches/auto/src/libcore/iter-trait.rs

@@ -409,14 +409,38 @@ pub fn core_macros() -> ~str {
 ~"pub mod macros {
     macro_rules! ignore (($($x:tt)*) => (()))
 
-    macro_rules! error ( ($( $arg:expr ),+) => (
-        log(::core::error, fmt!( $($arg),+ )) ))
-    macro_rules! warn ( ($( $arg:expr ),+) => (
-        log(::core::warn, fmt!( $($arg),+ )) ))
-    macro_rules! info ( ($( $arg:expr ),+) => (
-        log(::core::info, fmt!( $($arg),+ )) ))
-    macro_rules! debug ( ($( $arg:expr ),+) => (
-        log(::core::debug, fmt!( $($arg),+ )) ))
+    macro_rules! error (
+        ($arg:expr) => (
+            log(::core::error, fmt!( \"%?\", $arg ))
+        );
+        ($( $arg:expr ),+) => (
+            log(::core::error, fmt!( $($arg),+ ))
+        )
+    )
+    macro_rules! warn (
+        ($arg:expr) => (
+            log(::core::warn, fmt!( \"%?\", $arg ))
+        );
+        ($( $arg:expr ),+) => (
+            log(::core::warn, fmt!( $($arg),+ ))
+        )
+    )
+    macro_rules! info (
+        ($arg:expr) => (
+            log(::core::info, fmt!( \"%?\", $arg ))
+        );
+        ($( $arg:expr ),+) => (
+            log(::core::info, fmt!( $($arg),+ ))
+        )
+    )
+    macro_rules! debug (
+        ($arg:expr) => (
+            log(::core::debug, fmt!( \"%?\", $arg ))
+        );
+        ($( $arg:expr ),+) => (
+            log(::core::debug, fmt!( $($arg),+ ))
+        )
+    )
 
     macro_rules! fail(
         ($msg: expr) => (

branches/auto/src/libcore/iter-trait/dlist.rs

@@ -0,0 +1,10 @@
+enum Numbers {
+    Three
+}
+
+fn main() {
+    debug!(1);
+    info!(2.0);
+    warn!(Three);
+    error!(~[4]);
+}