Fixed the memory functions required for LLVM to properly work.

This required the fixing of the features section to properly handle
passing on the use_std feature. It also required that the memory functions
were moved to the main library module instead of within the rust module
as was previously desired. The C module then correctly skips defining the
external C library functions.

Basic time functionality was also added.

src/c/mod.rs

@@ -0,0 +1,12 @@
+//! Handle defining the external functions from what ever C library is
+//! being linked against. These will use the C99 definitions so that
+//! this library is as up-to-date as it can be.
+
+
+mod string;
+mod time;
+
+
+
+pub use self::string::*;
+pub use self::time::*;

src/c/string.rs

@@ -0,0 +1,56 @@
+#[link(name="c")]
+extern
+{
+}
+
+#[cfg(not(feature="no_mem_manip"))]
+#[link(name="c")]
+extern
+{
+   /// Copies the values of n bytes from the location pointed to by
+   /// src directly to the memory block pointed to by dest.
+   ///
+   /// The underlying type of the objects pointed to by both the src
+   /// and dest pointers are irrelevant for this function; The
+   /// result is a binary copy of the data.
+   ///
+   /// The function does not check for any terminating null character
+   /// in source - it always copies exactly n bytes.
+   ///
+   /// To avoid overflows, the size of the arrays pointed to by both
+   /// the dest and src parameters, shall be at least n bytes,
+   /// and should not overlap (for overlapping memory blocks, memmove
+   /// is a safer approach).
+   pub fn memcpy(dest: *mut u8, src: *const u8, n: usize);
+
+   /// Copies the values of n bytes from the location pointed by src
+   /// to the memory block pointed by dest. Copying takes place
+   /// as if an intermediate buffer were used, allowing the dest
+   /// and src to overlap.
+   ///
+   /// The underlying type of the objects pointed by both the src and
+   /// dest pointers are irrelevant for this function; The result
+   /// is a binary copy of the data.
+   ///
+   /// The function does not check for any terminating null character
+   /// in source - it always copies exactly n bytes.
+   ///
+   /// To avoid overflows, the size of the arrays pointed by both
+   /// the dest and src parameters, shall be at least n bytes.
+   pub fn memmove(dest: *mut u8, src: *const u8, n: usize);
+
+
+   /// Compares the first n bytes of the block of memory pointed by
+   /// s1 to the first num bytes pointed by s2, returning zero if
+   /// they all match or a value different from zero representing which
+   /// is greater if they do not.
+   ///
+   /// Notice that, unlike strcmp, the function does not stop comparing
+   /// after finding a null character.
+   pub fn memcmp(s1: *const u8, s2: *const u8, n: usize);
+
+
+   /// Sets the first n bytes of the block of memory pointed by s
+   /// to the specified value c (interpreted as an unsigned char).
+   pub fn memset(s: *mut u8, c: i32, n: usize);
+}

src/c/time.rs

@@ -0,0 +1,55 @@
+use binding::{CInt, CLong};
+
+
+
+/// The type used for seconds in the time structures.
+pub type Seconds = CLong;
+
+
+
+/// The local time of the system. This can be used
+/// to get more specific calendar type information.
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct LocalTime
+{
+   /// Seconds [0-60]  **Note** 1 leap second.
+   second: CInt,
+
+   /// Minutes [0-59].
+   minute: CInt,
+
+   /// Hours [0-23].
+   hour: CInt,
+
+   /// Day of the month [1-31].
+   day_of_month: CInt,
+
+   /// Month of the year [0-11].
+   month: CInt,
+
+   /// Years since 1900.
+   year: CInt,
+
+   /// Days since Sunday [0-6].
+   day_of_week: CInt,
+
+   /// Days since January 1 [0-365].
+   day_of_year: CInt,
+
+   /// DST [-1/0/1]. Greater than zero if DST is in effect,
+   /// zero if DST is not in effect, and less than zero if
+   /// the information is not available.
+   is_dst: CInt,
+}
+
+
+
+#[link(name="c")]
+extern
+{
+   /// Uses the value pointed by time to fill a LocalTime structure with
+   /// the values that represent the corresponding time, expressed
+   /// for the local timezone.
+   pub fn localtime(time: *const Seconds) -> *const LocalTime;
+}

src/lib.rs

@@ -1,6 +1,41 @@
 //!
+
+// Handle using the core or the std of Rust depending on the chosen feature.
+#![cfg_attr(not(feature="use_std"), no_std)]
+
+// This crate can only use parts of Rust that are in both the core
+// and the standard library. This way the logging system will work for
+// libraries that use either.
+//
+// This is handled by coding using the std library and referencing the core
+// library as the std library if the core library is desired.
+#[cfg(not(feature="use_std"))]
+extern crate core as std;
+
 #[macro_use]
 extern crate scribe;
 
 #[macro_use]
 extern crate binding;
+
+
+
+#[cfg(feature="c_lib")]
+mod c;
+
+#[cfg(not(feature="c_lib"))]
+mod rust;
+
+#[cfg(feature="no_mem_manip")]
+mod mem;
+
+
+
+#[cfg(feature="c_lib")]
+pub use self::c::*;
+
+#[cfg(not(feature="c_lib"))]
+pub use self::rust::*;
+
+#[cfg(feature="no_mem_manip")]
+pub use self::mem::*;

src/mem.rs

@@ -0,0 +1,144 @@
+//! This section deals with the memory manipulation functions. These should
+//! be in the string module inside the rust module to more closely match
+//! the 'C' library, but the no library feature needs them as well.
+//! These functions are here so that there does not need to be
+//! any duplication of the code.
+
+// There is nothing to do on windows or macos as weak linkage seems to
+// only work with ELF objects.
+#![cfg_attr(all(feature="weak", not(windows), not(target_os="macos")),
+            feature(linkage))]
+
+
+
+/// Copies the values of n bytes from the location pointed to by
+/// src directly to the memory block pointed to by dest.
+///
+/// The underlying type of the objects pointed to by both the src
+/// and dest pointers are irrelevant for this function; The
+/// result is a binary copy of the data.
+///
+/// The function does not check for any terminating null character
+/// in source - it always copies exactly n bytes.
+///
+/// To avoid overflows, the size of the arrays pointed to by both
+/// the dest and src parameters, shall be at least n bytes,
+/// and should not overlap (for overlapping memory blocks, memmove
+/// is a safer approach).
+#[cfg_attr(all(feature="weak", not(windows), not(target_os="macos")),
+           linkage="weak")]
+#[no_mangle]
+pub unsafe extern fn memcpy(dest: *mut u8, src: *const u8, n: usize)
+   -> *mut u8
+{
+   let mut i: usize;
+
+   i = 0;
+   while i < n
+   {
+      *dest.offset(i as isize) = *src.offset(i as isize);
+      i += 1;
+   }
+
+   return dest;
+}
+
+/// Copies the values of n bytes from the location pointed by src
+/// to the memory block pointed by dest. Copying takes place
+/// as if an intermediate buffer were used, allowing the dest
+/// and src to overlap.
+///
+/// The underlying type of the objects pointed by both the src and
+/// dest pointers are irrelevant for this function; The result
+/// is a binary copy of the data.
+///
+/// The function does not check for any terminating null character
+/// in source - it always copies exactly n bytes.
+///
+/// To avoid overflows, the size of the arrays pointed by both
+/// the dest and src parameters, shall be at least n bytes.
+#[cfg_attr(all(feature = "weak", not(windows), not(target_os = "macos")),
+           linkage = "weak")]
+#[no_mangle]
+pub unsafe extern fn memmove(dest: *mut u8, src: *const u8, n: usize)
+   -> *mut u8
+{
+   let mut i: usize;
+
+   if src < dest as *const u8
+   {
+      // copy from end
+      i = n;
+      while i != 0
+      {
+         i -= 1;
+         *dest.offset(i as isize) = *src.offset(i as isize);
+      }
+   }
+   else
+   {
+      // copy from beginning
+      i = 0;
+      while i < n
+      {
+         *dest.offset(i as isize) = *src.offset(i as isize);
+         i += 1;
+      }
+   }
+
+   return dest;
+}
+
+/// Compares the first n bytes of the block of memory pointed by
+/// s1 to the first num bytes pointed by s2, returning zero if
+/// they all match or a value different from zero representing which
+/// is greater if they do not.
+///
+/// Notice that, unlike strcmp, the function does not stop comparing
+/// after finding a null character.
+#[cfg_attr(all(feature = "weak", not(windows), not(target_os = "macos")),
+           linkage = "weak")]
+#[no_mangle]
+pub unsafe extern fn memcmp(s1: *const u8, s2: *const u8, n: usize)
+   -> i32
+{
+   let mut a: u8;
+   let mut b: u8;
+   let mut i: usize;
+
+   i = 0;
+   while i < n
+   {
+      a = *s1.offset(i as isize);
+      b = *s2.offset(i as isize);
+
+      if a != b
+      {
+         return (a as i32) - (b as i32)
+      }
+
+      i += 1;
+   }
+
+   return 0;
+}
+
+/// Sets the first n bytes of the block of memory pointed by s
+/// to the specified value c (interpreted as an unsigned char).
+#[cfg_attr(all(feature = "weak", not(windows), not(target_os = "macos")),
+           linkage = "weak")]
+#[no_mangle]
+pub unsafe extern fn memset(s: *mut u8, c: i32, n: usize)
+   -> *mut u8
+{
+   let mut i: usize;
+
+   i = 0;
+   while i < n
+   {
+      *s.offset(i as isize) = c as u8;
+      i += 1;
+   }
+
+   return s;
+}