Espresso 0.0.1b

lib/math/software_float.c

@@ -15,12 +15,3 @@ soft_float32_t decode_float(uint32_t raw)
   f.mantissa = raw & 0x7FFFFF;
   return f;
 }
-
-soft_float64_t decode_double(uint64_t raw)
-{
-    soft_float64_t d;
-    d.sign = (raw >> 63) & 1;
-    d.exponent = (raw >> 52) & 0x7FF;
-    d.mantissa = raw & 0xFFFFFFFFFFFFF;
-    return d;
-}

lib/processes.c

@@ -1,5 +1,15 @@
-#include <stdint.h>
+
 
 #include <processes.h>
 
 
+int32_t next_id = 9; /* 0 through 8 are reserved for kernel operations */
+
+int32_t make_process(char* name, char* group, elf_executable_t* exe)
+{
+  if (!name || !group || !exe)
+  {
+    return -1;
+  }
+  return 0;
+}

lib/stdio.c

@@ -37,7 +37,7 @@ char* fgets(char* buf, int n, FILE file)
 
   while (total_read < n - 1)
   {
-    int bytes = read_file(file, &c, 1);
+    int bytes = 0/*read_file(file, &c, 1)*/;
 
     if (bytes <= 0)
     {

lib/string.c

@@ -1,32 +1,33 @@
 #include <stdlib.h>
+#include <stdio.h>
 #include <vector_extentions/sse.h>
 
 #include <string.h>
 
 
-extern int16_t sse_initialized;
+extern int32_t sse_initialized;
 
 size_t strlen(const char* str)
 {
-    size_t len = 0;
-    while (str[len]) len++;
-    return len;
-}
-
-size_t strcmp(const char *s1, const char *s2)
-{
-  int32_t i = 0;
-
-  while ((s1[i] == s2[i]))
+  size_t len = 0;
+  while (str[len])
   {
-      if (s2[i++] == 0)
-      {
-        return 0;
-      }
+    len++;
   }
-  return 1;
+  return len;
 }
 
+int32_t strcmp(const char *s1, const char *s2)
+{
+  while (*s1 && (*s1 == *s2))
+  {
+    s1++;
+    s2++;
+  }
+  return (unsigned char)*s1 - (unsigned char)*s2;
+}
+
+
 int32_t strncmp(const char *s1, const char *s2, size_t n)
 {
   while (n--)
@@ -45,16 +46,36 @@ int32_t strncmp(const char *s1, const char *s2, size_t n)
   return 0;
 }
 
-
-size_t strcpy(char *dst, const char *src)
+int32_t strcasecmp(const char* s1, const char* s2)
 {
-    int32_t i = 0;
-    while ((*dst++ = *src++) != 0)
-        i++;
-    return i;
+  unsigned char c1, c2;
+
+  while (*s1 && *s2)
+  {
+    c1 = lower((unsigned char)*s1);
+    c2 = lower((unsigned char)*s2);
+
+    if (c1 != c2)
+    {
+      return c1 - c2;
+    }
+
+    s1++;
+    s2++;
+  }
+
+  return lower((unsigned char)*s1) - lower((unsigned char)*s2);
 }
 
-char *strncpy(char *dest, const char *src, uint32_t n)
+char* strcpy(char *dst, const char *src)
+{
+  char *ret = dst;
+  while ((*dst++ = *src++) != 0);
+  return ret;
+}
+
+
+char* strncpy(char *dest, const char *src, uint32_t n)
 {
   if (sse_initialized > 0)
   {
@@ -63,22 +84,31 @@ char *strncpy(char *dest, const char *src, uint32_t n)
 
   uint32_t i = 0;
   for (; i < n && src[i]; ++i)
+  {
     dest[i] = src[i];
+  }
 
   for (; i < n; ++i)
+  {
     dest[i] = '\0';
+  }
 
   return dest;
 }
 
-void strcat(char *dest, const char *src)
+char* strcat(char *dest, const char *src)
 {
-    char *end = (char *)dest + strlen(dest);
-    memcpy((void *)end, (void *)src, strlen(src));
-    end = end + strlen(src);
-    *end = '\0';
+  char *end = dest + strlen(dest);
+  while (*src)
+  {
+    *end++ = *src++;
+  }
+  
+  *end = '\0';
+  return dest;
 }
 
+
 char* strdup(const char* s)
 {
   if (!s)
@@ -143,11 +173,11 @@ char* strchr(const char* s, int c)
 {
   while (*s)
   {
-      if (*s == (char)c)
-      {
-        return (char*)s;
-      }
-      s++;
+    if (*s == (char)c)
+    {
+      return (char*)s;
+    }
+    s++;
   }
 
   return NULL;
@@ -155,43 +185,54 @@ char* strchr(const char* s, int c)
 
 
 
-void *memset(void *dst, char c, uint32_t n)
+void* memset(void *dst, char c, uint32_t n)
 {
   char *temp = dst;
-  for (; n != 0; n--) *temp++ = c;
+  for (; n != 0; n--)
+  {
+    *temp++ = c;
+  }
   return dst;
 }
 
-void *memcpy(void *dst, const void *src, uint32_t n)
+void* memcpy(void *dst, const void *src, uint32_t n)
 {
-  if (sse_initialized > 0)
+  if (sse_initialized > 1)
   {
     return sse2_memcpy(dst, src, n);
   }
-    
-  char *ret = dst;
-  char *p = dst;
-  const char *q = src;
+
+  char *d = dst;
+  const char *s = src;
   while (n--)
-    *p++ = *q++;
-  return ret;
+  {
+    *d++ = *s++;
+  }
+  
+  return dst;
 }
 
-int32_t memcmp(uint8_t *s1, uint8_t *s2, uint32_t n)
+int32_t memcmp(const void *s1, const void *s2, size_t n)
 {
-    while (n--)
+  const uint8_t *p1 = (const uint8_t *)s1;
+  const uint8_t *p2 = (const uint8_t *)s2;
+  
+  printf("p1: %i, p2: %i\n", (int32_t)*p1, (int32_t)*p2);
+
+  for (size_t i = 0; i < n; i++)
+  {
+    if (p1[i] != p2[i])
     {
-        if (*s1 != *s2)
-            return 0;
-        s1++;
-        s2++;
+      return (int32_t)p1[i] - (int32_t)p2[i];
     }
-    return 1;
+  }
+  return 0;
 }
 
-void* memclr(const void * const m_start, const size_t m_count)
+
+void* memclr(void* m_start, size_t m_count)
 {
-  if (sse_initialized > 0)
+  if (sse_initialized > 1)
   {
     return memclr_sse2(m_start, m_count);
   }
@@ -215,13 +256,6 @@ int32_t ischar(int32_t c)
 }
 
 char upper(char c)
-{
-    if ((c >= 'a') && (c <= 'z'))
-        return (c - 32);
-    return c;
-}
-
-char toupper(char c)
 {
   if ((c >= 'a') && (c <= 'z'))
   {
@@ -232,7 +266,19 @@ char toupper(char c)
 
 char lower(char c)
 {
-    if ((c >= 'A') && (c <= 'Z'))
-        return (c + 32);
-    return c;
+  if ((c >= 'A') && (c <= 'Z'))
+  {
+    return (c + 32);
+  }
+  return c;
+}
+
+char toupper(char c)
+{
+  return upper(c);
+}
+
+char tolower(char c)
+{
+  return lower(c);
 }

lib/time.c

@@ -0,0 +1,10 @@
+#include <drivers/pit.h>
+#include <port_io.h>
+
+#include <time.h>
+
+
+void ksleep(uint64_t millis)
+{
+  pit_sleep(millis);
+}

lib/vector_extentions/sse.c

@@ -7,23 +7,25 @@
 #include <vector_extentions/sse.h>
 
 
-void enable_sse(void) {
-    uint32_t cr0, cr4;
+void enable_sse(void)
+{
+  uint32_t cr0, cr4;
 
-    __asm__ volatile ("mov %%cr0, %0" : "=r"(cr0));
-    cr0 &= ~(1 << 2); // EM = 0
-    cr0 |=  (1 << 1); // MP = 1
-    __asm__ volatile ("mov %0, %%cr0" :: "r"(cr0));
+  __asm__ volatile ("mov %%cr0, %0" : "=r"(cr0));
+  cr0 &= ~(1 << 2); // EM = 0
+  cr0 |=  (1 << 1); // MP = 1
+  __asm__ volatile ("mov %0, %%cr0" :: "r"(cr0));
 
-    __asm__ volatile ("mov %%cr4, %0" : "=r"(cr4));
-    cr4 |= (1 << 9);  // OSFXSR = 1
-    cr4 |= (1 << 10); // OSXMMEXCPT = 1
-    __asm__ volatile ("mov %0, %%cr4" :: "r"(cr4));
+  __asm__ volatile ("mov %%cr4, %0" : "=r"(cr4));
+  cr4 |= (1 << 9);  // OSFXSR = 1
+  cr4 |= (1 << 10); // OSXMMEXCPT = 1
+  __asm__ volatile ("mov %0, %%cr4" :: "r"(cr4));
 }
 
 // Basic SSE test: add two arrays of 4 floats using xmm registers
 __attribute__((force_align_arg_pointer))
-int32_t test_sse(void) {
+int32_t test_sse(void)
+{
   float a[4] __attribute__((aligned(16))) = {1.0f, 2.0f, 3.0f, 4.0f};
   float b[4] __attribute__((aligned(16))) = {5.0f, 6.0f, 7.0f, 8.0f};
   float result[4] __attribute__((aligned(16)));
@@ -141,7 +143,8 @@ char *sse2_strncpy(char *dest, const char *src, uint32_t n)
   uint32_t i = 0;
 
   /* Align initial copy */
-  while (((uintptr_t)(dest + i) & 15) && i < n && src[i]) {
+  while (((uintptr_t)(dest + i) & 15) && i < n && src[i])
+  {
     dest[i] = src[i];
     i++;
   }