Reorganize

4 files changed, 0 insertions, 318 deletions

diff --git a/src/c/mod.rs b/src/c/mod.rs
deleted file mode 100644
index 3694561..0000000
--- a/src/c/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod posix;
-pub mod stdio;
-pub mod string;
diff --git a/src/c/posix.rs b/src/c/posix.rs
deleted file mode 100644
index 6b63ea7..0000000
--- a/src/c/posix.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-extern "C" {
-	pub fn strndup(cs: *const libc::c_char, n: libc::size_t) -> *mut libc::c_char;
-
-	// pub static stdin: *mut libc::FILE;
-	pub static stdout: *mut libc::FILE;
-	pub static stderr: *mut libc::FILE;
-}
diff --git a/src/c/stdio.rs b/src/c/stdio.rs
deleted file mode 100644
index c878f19..0000000
--- a/src/c/stdio.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use core::fmt;
-
-use super::posix;
-use super::string;
-
-pub struct OStream {
-	file: *mut libc::FILE
-}
-
-pub unsafe fn stdout() -> OStream {
-	OStream { file: posix::stdout }
-}
-
-pub unsafe fn stderr() -> OStream {
-	OStream { file: posix::stderr }
-}
-
-impl OStream {
-	pub fn write(&mut self, b: &[u8]) {
-		unsafe {
-			libc::fwrite(
-				b.as_ptr() as *const libc::c_void,
-				1,
-				b.len(),
-				self.file,
-			);
-		}
-	}
-
-	pub fn puts(&mut self, s: &string::CStr) {
-		unsafe {
-			libc::fputs(s.as_ptr(), self.file);
-		}
-	}
-}
-
-impl fmt::Write for OStream {
-	fn write_str(&mut self, s: &str) -> fmt::Result {
-		self.write(s.as_bytes());
-		Ok(())
-	}
-}
diff --git a/src/c/string.rs b/src/c/string.rs
deleted file mode 100644
index 3d991dc..0000000
--- a/src/c/string.rs
+++ /dev/null
@@ -1,266 +0,0 @@
-use super::posix;
-use core::{mem, ptr, slice};
-use core::ops::{Deref, DerefMut};
-
-fn must_succeed<T>(p: *mut T) -> *mut T {
-	assert!(!p.is_null(), "allocation failure");
-	p
-}
-
-fn zst<T>(count: usize) -> bool {
-	mem::size_of::<T>() == 0 || count == 0
-}
-
-fn alloc<T>(count: usize) -> *mut T {
-	if zst::<T>(count) {
-		return ptr::null_mut();
-	}
-	let size = count * mem::size_of::<T>();
-	let align = mem::align_of::<T>();
-	must_succeed(
-		unsafe {
-			libc::memalign(align as libc::size_t, size as libc::size_t) as *mut T
-		}
-	)
-}
-
-fn dangling<T>() -> *mut T {
-	mem::align_of::<T>() as *mut T
-}
-
-fn check_ptr<T>(p: *const T, len: usize) {
-	debug_assert!((p as usize) % mem::align_of::<T>() == 0, "unaligned ptr");
-	assert!(zst::<T>(len) || !p.is_null(), "NULL ptr");
-}
-
-fn slice_len<T>(p: *const [T]) -> usize {
-	unsafe { mem::transmute::<*const [T], [usize; 2]>(p)[1] }
-}
-
-pub struct CBox<T: ?Sized>(*mut T);
-
-impl<T: ?Sized> CBox<T> {
-	pub unsafe fn from_raw_unchecked(p: *mut T) -> CBox<T> {
-		CBox(p)
-	}
-
-	pub fn into_raw(self) -> *mut T {
-		let p = self.0;
-		mem::forget(self);
-		p
-	}
-
-	pub fn as_ptr(&self) -> *const T {
-		self.0
-	}
-
-	pub fn as_mut_ptr(&mut self) -> *mut T {
-		self.0
-	}
-}
-
-impl<T> CBox<T> {
-	pub fn new(value: T) -> CBox<T> {
-		let p = alloc(1);
-		unsafe {
-			ptr::write(p, value);
-			CBox::from_raw_unchecked(p)
-		}
-	}
-
-	pub unsafe fn from_raw(p: *mut T) -> CBox<T> {
-		check_ptr(p, 1);
-		CBox(p)
-	}
-
-	pub unsafe fn slice_from_raw_parts_unchecked(p: *mut T, len: usize) -> CBox<[T]> {
-		CBox(ptr::slice_from_raw_parts_mut(p, len))
-	}
-
-	pub unsafe fn slice_from_raw_parts(p: *mut T, len: usize) -> CBox<[T]> {
-		check_ptr(p, len);
-		CBox::slice_from_raw_parts_unchecked(p, len)
-	}
-
-	fn safe_ptr(&self) -> *mut T {
-		if self.0.is_null() {
-			debug_assert!(zst::<T>(1), "NULL ptr");
-			return dangling();
-		}
-
-		self.0
-	}
-}
-
-impl<T> CBox<[T]> {
-	fn safe_ptr(&self) -> *mut [T] {
-		if self.0.is_null() {
-			let len = slice_len(self.0);
-			debug_assert!(zst::<T>(len), "NULL ptr");
-			return ptr::slice_from_raw_parts_mut(dangling(), len);
-		}
-
-		self.0
-	}
-}
-
-impl<T: ?Sized> Drop for CBox<T> {
-	fn drop(&mut self) {
-		unsafe {
-			ptr::drop_in_place(self.0);
-			libc::free(self.0 as *mut libc::c_void);
-		}
-	}
-}
-
-impl<T> Deref for CBox<T> {
-	type Target = T;
-
-	fn deref(&self) -> &T {
-		unsafe { &*self.safe_ptr() }
-	}
-}
-
-impl<T> DerefMut for CBox<T> {
-	fn deref_mut(&mut self) -> &mut T {
-		unsafe { &mut *self.safe_ptr() }
-	}
-}
-
-impl<T> Deref for CBox<[T]> {
-	type Target = [T];
-
-	fn deref(&self) -> &[T] {
-		unsafe { &*self.safe_ptr() }
-	}
-}
-
-impl<T> DerefMut for CBox<[T]> {
-	fn deref_mut(&mut self) -> &mut [T] {
-		unsafe { &mut *self.safe_ptr() }
-	}
-}
-
-//pub struct FromBytesWithNulError {}
-
-pub struct CStr { inner: libc::c_char }
-
-impl CStr {
-	pub unsafe fn from_ptr_unchecked<'a>(p: *const libc::c_char) -> &'a CStr {
-		&*(p as *const CStr)
-	}
-
-	pub unsafe fn from_ptr<'a>(p: *const libc::c_char) -> &'a CStr {
-		check_ptr(p, 1);
-		CStr::from_ptr_unchecked(p)
-	}
-
-	pub unsafe fn from_mut_ptr_unchecked<'a>(p: *mut libc::c_char) -> &'a mut CStr {
-		&mut *(p as *mut CStr)
-	}
-
-	pub unsafe fn from_mut_ptr<'a>(p: *mut libc::c_char) -> &'a mut CStr {
-		check_ptr(p, 1);
-		CStr::from_mut_ptr_unchecked(p)
-	}
-
-	pub unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr {
-		CStr::from_ptr_unchecked(bytes.as_ptr() as *const libc::c_char)
-	}
-
-	// TODO
-	//pub fn from_bytes_with_nul(bytes: &[u8]) -> Result<&CStr, FromBytesWithNulError> {
-	//}
-
-	pub fn len(&self) -> usize {
-		unsafe { libc::strlen(self.as_ptr()) as usize }
-	}
-
-	pub const fn as_ptr(&self) -> *const libc::c_char {
-		&self.inner
-	}
-
-	pub fn as_mut_ptr(&mut self) -> *mut libc::c_char {
-		&mut self.inner
-	}
-
-	pub fn as_bytes(&self) -> &[u8] {
-		unsafe { slice::from_raw_parts(
-			self.as_ptr() as *const u8,
-			self.len(),
-		) }
-	}
-
-	pub fn as_mut_bytes(&mut self) -> &mut [u8] {
-		unsafe { slice::from_raw_parts_mut(
-			self.as_mut_ptr() as *mut u8,
-			self.len(),
-		) }
-	}
-
-	pub fn to_owned(self: &CStr) -> CString {
-		CString::from(self)
-	}
-}
-
-#[macro_export]
-macro_rules! cstr {
-	($s:expr) => (
-		unsafe { $crate::c::string::CStr::from_bytes_with_nul_unchecked(concat!($s, "\0").as_bytes()) }
-	)
-}
-
-pub struct CString { inner: CBox<libc::c_char> }
-
-impl CString {
-	pub unsafe fn from_raw_unchecked(p: *mut libc::c_char) -> CString {
-		CString { inner: CBox::from_raw_unchecked(p) }
-	}
-
-	pub unsafe fn from_raw(p: *mut libc::c_char) -> CString {
-		CString { inner: CBox::from_raw(p) }
-	}
-
-	pub fn into_raw(self) -> *mut libc::c_char {
-		self.inner.into_raw()
-	}
-}
-
-impl Deref for CString {
-	type Target = CStr;
-
-	fn deref(&self) -> &CStr {
-		unsafe { CStr::from_ptr(&*self.inner) }
-	}
-}
-
-impl DerefMut for CString {
-	fn deref_mut(&mut self) -> &mut CStr {
-		unsafe { CStr::from_mut_ptr(&mut *self.inner) }
-	}
-}
-
-impl From<&[u8]> for CString {
-	fn from(s: &[u8]) -> CString {
-		unsafe {
-			CString::from_raw_unchecked(must_succeed(posix::strndup(
-				s.as_ptr() as *const libc::c_char,
-				s.len() as libc::size_t,
-			)))
-		}
-	}
-}
-
-impl From<&str> for CString {
-	fn from(s: &str) -> CString {
-		CString::from(s.as_bytes())
-	}
-}
-
-impl From<&CStr> for CString {
-	fn from(s: &CStr) -> CString {
-		unsafe {
-			CString::from_raw_unchecked(must_succeed(libc::strdup(s.as_ptr())))
-		}
-	}
-}