about summary refs log tree commit diff
path: root/src/libcore/to_bytes.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libcore/to_bytes.rs')
-rw-r--r--src/libcore/to_bytes.rs394
1 files changed, 328 insertions, 66 deletions
diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs
index 9e4da7ab488..182a03da4b1 100644
--- a/src/libcore/to_bytes.rs
+++ b/src/libcore/to_bytes.rs
@@ -21,6 +21,11 @@ use str;
 
 pub type Cb<'self> = &'self fn(buf: &[u8]) -> bool;
 
+#[cfg(stage0)]
+pub trait IterBytes {
+    fn iter_bytes(&self, lsb0: bool, f: Cb);
+}
+
 /**
  * A trait to implement in order to make a type hashable;
  * This works in combination with the trait `Hash::Hash`, and
@@ -28,6 +33,7 @@ pub type Cb<'self> = &'self fn(buf: &[u8]) -> bool;
  * modified when default methods and trait inheritence are
  * completed.
  */
+#[cfg(not(stage0))]
 pub trait IterBytes {
     /**
      * Call the provided callback `f` one or more times with
@@ -43,9 +49,10 @@ pub trait IterBytes {
      * left-to-right in declaration order, regardless of
      * underlying memory endianness.
      */
-    fn iter_bytes(&self, lsb0: bool, f: Cb);
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool;
 }
 
+#[cfg(stage0)]
 impl IterBytes for bool {
     #[inline(always)]
     fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@@ -54,7 +61,17 @@ impl IterBytes for bool {
         ]);
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for bool {
+    #[inline(always)]
+    fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
+        f([
+            *self as u8
+        ])
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for u8 {
     #[inline(always)]
     fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@@ -63,7 +80,17 @@ impl IterBytes for u8 {
         ]);
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for u8 {
+    #[inline(always)]
+    fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
+        f([
+            *self
+        ])
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for u16 {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
@@ -80,7 +107,25 @@ impl IterBytes for u16 {
         }
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for u16 {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        if lsb0 {
+            f([
+                *self as u8,
+                (*self >> 8) as u8
+            ])
+        } else {
+            f([
+                (*self >> 8) as u8,
+                *self as u8
+            ])
+        }
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for u32 {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
@@ -101,7 +146,29 @@ impl IterBytes for u32 {
         }
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for u32 {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        if lsb0 {
+            f([
+                *self as u8,
+                (*self >> 8) as u8,
+                (*self >> 16) as u8,
+                (*self >> 24) as u8,
+            ])
+        } else {
+            f([
+                (*self >> 24) as u8,
+                (*self >> 16) as u8,
+                (*self >> 8) as u8,
+                *self as u8
+            ])
+        }
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for u64 {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
@@ -130,73 +197,157 @@ impl IterBytes for u64 {
         }
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for u64 {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        if lsb0 {
+            f([
+                *self as u8,
+                (*self >> 8) as u8,
+                (*self >> 16) as u8,
+                (*self >> 24) as u8,
+                (*self >> 32) as u8,
+                (*self >> 40) as u8,
+                (*self >> 48) as u8,
+                (*self >> 56) as u8
+            ])
+        } else {
+            f([
+                (*self >> 56) as u8,
+                (*self >> 48) as u8,
+                (*self >> 40) as u8,
+                (*self >> 32) as u8,
+                (*self >> 24) as u8,
+                (*self >> 16) as u8,
+                (*self >> 8) as u8,
+                *self as u8
+            ])
+        }
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for i8 {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for i8 {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as u8).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for i16 {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (*self as u16).iter_bytes(lsb0, f)
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for i16 {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as u16).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for i32 {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (*self as u32).iter_bytes(lsb0, f)
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for i32 {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as u32).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for i64 {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (*self as u64).iter_bytes(lsb0, f)
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for i64 {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as u64).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for char {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (*self as u32).iter_bytes(lsb0, f)
     }
 }
-
-#[cfg(target_word_size = "32")]
-pub mod x32 {
-    use to_bytes::{Cb, IterBytes};
-
-    impl IterBytes for uint {
-        #[inline(always)]
-        fn iter_bytes(&self, lsb0: bool, f: Cb) {
-            (*self as u32).iter_bytes(lsb0, f)
-        }
+#[cfg(not(stage0))]
+impl IterBytes for char {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as u32).iter_bytes(lsb0, f)
     }
 }
 
-#[cfg(target_word_size = "64")]
-pub mod x64 {
-    use to_bytes::{Cb, IterBytes};
+#[cfg(target_word_size = "32", stage0)]
+impl IterBytes for uint {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) {
+        (*self as u32).iter_bytes(lsb0, f)
+    }
+}
+#[cfg(target_word_size = "32", not(stage0))]
+impl IterBytes for uint {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as u32).iter_bytes(lsb0, f)
+    }
+}
 
-    impl IterBytes for uint {
-        #[inline(always)]
-        fn iter_bytes(&self, lsb0: bool, f: Cb) {
-            (*self as u64).iter_bytes(lsb0, f)
-        }
+#[cfg(target_word_size = "64", stage0)]
+impl IterBytes for uint {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) {
+        (*self as u64).iter_bytes(lsb0, f)
+    }
+}
+#[cfg(target_word_size = "64", not(stage0))]
+impl IterBytes for uint {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as u64).iter_bytes(lsb0, f)
     }
 }
 
+#[cfg(stage0)]
 impl IterBytes for int {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (*self as uint).iter_bytes(lsb0, f)
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for int {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as uint).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl<'self,A:IterBytes> IterBytes for &'self [A] {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
@@ -207,7 +358,15 @@ impl<'self,A:IterBytes> IterBytes for &'self [A] {
         }
     }
 }
+#[cfg(not(stage0))]
+impl<'self,A:IterBytes> IterBytes for &'self [A] {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        self.each(|elt| elt.iter_bytes(lsb0, |b| f(b)))
+    }
+}
 
+#[cfg(stage0)]
 impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) {
   #[inline(always)]
   fn iter_bytes(&self, lsb0: bool, f: Cb) {
@@ -218,7 +377,17 @@ impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) {
     }
   }
 }
+#[cfg(not(stage0))]
+impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) {
+  #[inline(always)]
+  fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+    match *self {
+      (ref a, ref b) => { a.iter_bytes(lsb0, f) && b.iter_bytes(lsb0, f) }
+    }
+  }
+}
 
+#[cfg(stage0)]
 impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
   #[inline(always)]
   fn iter_bytes(&self, lsb0: bool, f: Cb) {
@@ -229,26 +398,57 @@ impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
     }
   }
 }
+#[cfg(not(stage0))]
+impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
+  #[inline(always)]
+  fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+    match *self {
+      (ref a, ref b, ref c) => {
+        a.iter_bytes(lsb0, f) && b.iter_bytes(lsb0, f) && c.iter_bytes(lsb0, f)
+      }
+    }
+  }
+}
 
 // Move this to vec, probably.
 fn borrow<'x,A>(a: &'x [A]) -> &'x [A] {
     a
 }
 
+#[cfg(stage0)]
 impl<A:IterBytes> IterBytes for ~[A] {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         borrow(*self).iter_bytes(lsb0, f)
     }
 }
+#[cfg(not(stage0))]
+impl<A:IterBytes> IterBytes for ~[A] {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        borrow(*self).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl<A:IterBytes> IterBytes for @[A] {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         borrow(*self).iter_bytes(lsb0, f)
     }
 }
+#[cfg(not(stage0))]
+impl<A:IterBytes> IterBytes for @[A] {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        borrow(*self).iter_bytes(lsb0, f)
+    }
+}
+
+// NOTE: remove all of these after a snapshot, the new for-loop iteration
+//       protocol makes these unnecessary.
 
+#[cfg(stage0)]
 pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
                                             lsb0: bool, z: Cb) {
     let mut flag = true;
@@ -256,11 +456,17 @@ pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
     if !flag { return; }
     b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
+#[cfg(not(stage0))]
+pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
+                                             lsb0: bool, z: Cb) -> bool {
+    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z)
+}
 
+#[cfg(stage0)]
 pub fn iter_bytes_3<A: IterBytes,
-                B: IterBytes,
-                C: IterBytes>(a: &A, b: &B, c: &C,
-                              lsb0: bool, z: Cb) {
+                    B: IterBytes,
+                    C: IterBytes>(a: &A, b: &B, c: &C,
+                                  lsb0: bool, z: Cb) {
     let mut flag = true;
     a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
@@ -268,7 +474,14 @@ pub fn iter_bytes_3<A: IterBytes,
     if !flag { return; }
     c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
+#[cfg(not(stage0))]
+pub fn iter_bytes_3<A: IterBytes,
+                    B: IterBytes,
+                    C: IterBytes>(a: &A, b: &B, c: &C, lsb0: bool, z: Cb) -> bool {
+    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z)
+}
 
+#[cfg(stage0)]
 pub fn iter_bytes_4<A: IterBytes,
                 B: IterBytes,
                 C: IterBytes,
@@ -284,33 +497,24 @@ pub fn iter_bytes_4<A: IterBytes,
     if !flag { return; }
     d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
-
-pub fn iter_bytes_5<A: IterBytes,
+#[cfg(not(stage0))]
+pub fn iter_bytes_4<A: IterBytes,
                 B: IterBytes,
                 C: IterBytes,
-                D: IterBytes,
-                E: IterBytes>(a: &A, b: &B, c: &C,
-                              d: &D, e: &E,
-                              lsb0: bool, z: Cb) {
-    let mut flag = true;
-    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+                D: IterBytes>(a: &A, b: &B, c: &C,
+                              d: &D,
+                              lsb0: bool, z: Cb) -> bool {
+    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
+        d.iter_bytes(lsb0, z)
 }
 
-pub fn iter_bytes_6<A: IterBytes,
+#[cfg(stage0)]
+pub fn iter_bytes_5<A: IterBytes,
                 B: IterBytes,
                 C: IterBytes,
                 D: IterBytes,
-                E: IterBytes,
-                F: IterBytes>(a: &A, b: &B, c: &C,
-                              d: &D, e: &E, f: &F,
+                E: IterBytes>(a: &A, b: &B, c: &C,
+                              d: &D, e: &E,
                               lsb0: bool, z: Cb) {
     let mut flag = true;
     a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
@@ -322,36 +526,20 @@ pub fn iter_bytes_6<A: IterBytes,
     d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
     if !flag { return; }
     e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    f.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
-
-pub fn iter_bytes_7<A: IterBytes,
+#[cfg(not(stage0))]
+pub fn iter_bytes_5<A: IterBytes,
                 B: IterBytes,
                 C: IterBytes,
                 D: IterBytes,
-                E: IterBytes,
-                F: IterBytes,
-                G: IterBytes>(a: &A, b: &B, c: &C,
-                              d: &D, e: &E, f: &F,
-                              g: &G,
-                              lsb0: bool, z: Cb) {
-    let mut flag = true;
-    a.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    c.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    d.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    e.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    f.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
-    if !flag { return; }
-    g.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
+                E: IterBytes>(a: &A, b: &B, c: &C,
+                              d: &D, e: &E,
+                              lsb0: bool, z: Cb) -> bool {
+    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
+        d.iter_bytes(lsb0, z) && e.iter_bytes(lsb0, z)
 }
 
+#[cfg(stage0)]
 impl<'self> IterBytes for &'self str {
     #[inline(always)]
     fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@@ -360,7 +548,17 @@ impl<'self> IterBytes for &'self str {
         }
     }
 }
+#[cfg(not(stage0))]
+impl<'self> IterBytes for &'self str {
+    #[inline(always)]
+    fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
+        do str::byte_slice(*self) |bytes| {
+            f(bytes)
+        }
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for ~str {
     #[inline(always)]
     fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@@ -369,7 +567,17 @@ impl IterBytes for ~str {
         }
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for ~str {
+    #[inline(always)]
+    fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
+        do str::byte_slice(*self) |bytes| {
+            f(bytes)
+        }
+    }
+}
 
+#[cfg(stage0)]
 impl IterBytes for @str {
     #[inline(always)]
     fn iter_bytes(&self, _lsb0: bool, f: Cb) {
@@ -378,7 +586,17 @@ impl IterBytes for @str {
         }
     }
 }
+#[cfg(not(stage0))]
+impl IterBytes for @str {
+    #[inline(always)]
+    fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
+        do str::byte_slice(*self) |bytes| {
+            f(bytes)
+        }
+    }
+}
 
+#[cfg(stage0)]
 impl<A:IterBytes> IterBytes for Option<A> {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
@@ -388,36 +606,80 @@ impl<A:IterBytes> IterBytes for Option<A> {
         }
     }
 }
+#[cfg(not(stage0))]
+impl<A:IterBytes> IterBytes for Option<A> {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        match *self {
+          Some(ref a) => 0u8.iter_bytes(lsb0, f) && a.iter_bytes(lsb0, f),
+          None => 1u8.iter_bytes(lsb0, f)
+        }
+    }
+}
 
+#[cfg(stage0)]
 impl<'self,A:IterBytes> IterBytes for &'self A {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (**self).iter_bytes(lsb0, f);
     }
 }
+#[cfg(not(stage0))]
+impl<'self,A:IterBytes> IterBytes for &'self A {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (**self).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl<A:IterBytes> IterBytes for @A {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (**self).iter_bytes(lsb0, f);
     }
 }
+#[cfg(not(stage0))]
+impl<A:IterBytes> IterBytes for @A {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (**self).iter_bytes(lsb0, f)
+    }
+}
 
+#[cfg(stage0)]
 impl<A:IterBytes> IterBytes for ~A {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (**self).iter_bytes(lsb0, f);
     }
 }
+#[cfg(not(stage0))]
+impl<A:IterBytes> IterBytes for ~A {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (**self).iter_bytes(lsb0, f)
+    }
+}
 
 // NB: raw-pointer IterBytes does _not_ dereference
 // to the target; it just gives you the pointer-bytes.
+#[cfg(stage0)]
 impl<A> IterBytes for *const A {
     #[inline(always)]
     fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (*self as uint).iter_bytes(lsb0, f);
     }
 }
+// NB: raw-pointer IterBytes does _not_ dereference
+// to the target; it just gives you the pointer-bytes.
+#[cfg(not(stage0))]
+impl<A> IterBytes for *const A {
+    #[inline(always)]
+    fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+        (*self as uint).iter_bytes(lsb0, f)
+    }
+}
 
 pub trait ToBytes {
     fn to_bytes(&self, lsb0: bool) -> ~[u8];
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-31 18:12:32 +0000