1 files changed, 172 insertions, 0 deletions
diff --git a/libc/src/dox.rs b/libc/src/dox.rs
new file mode 100644
index 0000000..fbec3f2
--- /dev/null
+++ b/libc/src/dox.rs
@@ -0,0 +1,172 @@
+pub use self::imp::*;
+
+#[cfg(not(dox))]
+mod imp {
+    pub use core::option::Option;
+    pub use core::clone::Clone;
+    pub use core::marker::Copy;
+    pub use core::mem;
+}
+
+#[cfg(dox)]
+mod imp {
+    pub enum Option<T> {
+        Some(T),
+        None,
+    }
+    impl<T: Copy> Copy for Option<T> {}
+    impl<T: Clone> Clone for Option<T> {
+        fn clone(&self) -> Option<T> { loop {} }
+    }
+
+    pub trait Clone {
+        fn clone(&self) -> Self;
+    }
+
+    #[lang = "copy"]
+    pub trait Copy {}
+
+    #[lang = "sync"]
+    pub trait Sync {}
+    impl<T> Sync for T {}
+
+    #[lang = "sized"]
+    pub trait Sized {}
+
+    macro_rules! each_int {
+        ($mac:ident) => (
+            $mac!(u8);
+            $mac!(u16);
+            $mac!(u32);
+            $mac!(u64);
+            $mac!(usize);
+            each_signed_int!($mac);
+        )
+    }
+
+    macro_rules! each_signed_int {
+        ($mac:ident) => (
+            $mac!(i8);
+            $mac!(i16);
+            $mac!(i32);
+            $mac!(i64);
+            $mac!(isize);
+        )
+    }
+
+    #[lang = "div"]
+    pub trait Div<RHS> {
+        type Output;
+        fn div(self, rhs: RHS) -> Self::Output;
+    }
+
+    macro_rules! impl_div {
+        ($($i:ident)*) => ($(
+            impl Div<$i> for $i {
+                type Output = $i;
+                fn div(self, rhs: $i) -> $i { self / rhs }
+            }
+        )*)
+    }
+    each_int!(impl_div);
+
+    #[lang = "shl"]
+    pub trait Shl<RHS> {
+        type Output;
+        fn shl(self, rhs: RHS) -> Self::Output;
+    }
+
+    macro_rules! impl_shl {
+        ($($i:ident)*) => ($(
+            impl Shl<$i> for $i {
+                type Output = $i;
+                fn shl(self, rhs: $i) -> $i { self << rhs }
+            }
+        )*)
+    }
+    each_int!(impl_shl);
+
+    #[lang = "mul"]
+    pub trait Mul<RHS=Self> {
+        type Output;
+        fn mul(self, rhs: RHS) -> Self::Output;
+    }
+
+    macro_rules! impl_mul {
+        ($($i:ident)*) => ($(
+            impl Mul for $i {
+                type Output = $i;
+                fn mul(self, rhs: $i) -> $i { self * rhs }
+            }
+        )*)
+    }
+    each_int!(impl_mul);
+
+    #[lang = "sub"]
+    pub trait Sub<RHS=Self> {
+        type Output;
+        fn sub(self, rhs: RHS) -> Self::Output;
+    }
+
+    macro_rules! impl_sub {
+        ($($i:ident)*) => ($(
+            impl Sub for $i {
+                type Output = $i;
+                fn sub(self, rhs: $i) -> $i { self - rhs }
+            }
+        )*)
+    }
+    each_int!(impl_sub);
+
+    #[lang = "bitor"]
+    pub trait Bitor<RHS=Self> {
+        type Output;
+        fn bitor(self, rhs: RHS) -> Self::Output;
+    }
+
+    macro_rules! impl_bitor {
+        ($($i:ident)*) => ($(
+            impl Bitor for $i {
+                type Output = $i;
+                fn bitor(self, rhs: $i) -> $i { self | rhs }
+            }
+        )*)
+    }
+    each_int!(impl_bitor);
+
+    #[lang = "neg"]
+    pub trait Neg {
+        type Output;
+        fn neg(self) -> Self::Output;
+    }
+
+    macro_rules! impl_neg {
+        ($($i:ident)*) => ($(
+            impl Neg for $i {
+                type Output = $i;
+                fn neg(self) -> $i { -self }
+            }
+        )*)
+    }
+    each_signed_int!(impl_neg);
+
+    #[lang = "not"]
+    pub trait Not {
+        type Output;
+        fn not(self) -> Self::Output;
+    }
+
+    macro_rules! impl_not {
+        ($($i:ident)*) => ($(
+            impl Not for $i {
+                type Output = $i;
+                fn not(self) -> $i { !self }
+            }
+        )*)
+    }
+    each_int!(impl_not);
+
+    pub mod mem {
+        pub fn size_of_val<T>(_: &T) -> usize { 4 }
+    }
+}