Idenfity devices by name, not by char [1/3]
[akaros.git] / kern / src / string.c
index 4e3db1e..6964240 100644 (file)
@@ -1,9 +1,5 @@
 // Basic string routines.  Not hardware optimized, but not shabby.
 
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
 #include <stdio.h>
 #include <string.h>
 #include <ros/memlayout.h>
@@ -56,7 +52,6 @@ strncpy(char *dst, const char *src, size_t size) {
 
        ret = dst;
        for (i = 0; i < size; i++) {
-               // TODO: ivy bitches about this
                *dst++ = *src;
                // If strlen(src) < size, null-pad 'dst' out to 'size' chars
                if (*src != '\0')
@@ -109,6 +104,19 @@ strchr(const char *s, char c)
        return 0;
 }
 
+// Return a pointer to the last occurrence of 'c' in 's',
+// or a null pointer if the string has no 'c'.
+char *
+strrchr(const char *s, char c)
+{
+       char *lastc = NULL;
+       for (; *s; s++)
+               if (*s == c){
+                       lastc = (char*)s;
+               }
+       return lastc;
+}
+
 void *
 memchr(void* mem, int chr, int len)
 {
@@ -139,7 +147,7 @@ memsetw(long* _v, long c, size_t n)
        start = _v;
        end = _v + n/sizeof(long);
        v = _v;
-       c = (char)c;
+       c = c & 0xff;
        c = c | c<<8;
        c = c | c<<16;
        #if NUM_ADDR_BITS == 64
@@ -188,9 +196,9 @@ memsetw(long* _v, long c, size_t n)
   } while(0)
 
 void *
-memset(void *COUNT(_n) v, int c, size_t _n)
+memset(void *v, int c, size_t _n)
 {
-       char *BND(v,v+_n) p;
+       char *p;
        size_t n0;
        size_t n = _n;
 
@@ -260,10 +268,14 @@ memcpy(void* dst, const void* src, size_t _n)
 }
 
 void *
-memmove(void *COUNT(_n) dst, const void *COUNT(_n) src, size_t _n)
+memmove(void *dst, const void *src, size_t _n)
 {
-       const char *BND(src,src+_n) s;
-       char *BND(dst,dst+_n) d;
+#ifdef CONFIG_X86
+       bcopy(src, dst, _n);
+       return dst;
+#else
+       const char *s;
+       char *d;
        size_t n = _n;
        
        s = src;
@@ -278,13 +290,14 @@ memmove(void *COUNT(_n) dst, const void *COUNT(_n) src, size_t _n)
                        *d++ = *s++;
 
        return dst;
+#endif
 }
 
 int
-memcmp(const void *COUNT(n) v1, const void *COUNT(n) v2, size_t n)
+memcmp(const void *v1, const void *v2, size_t n)
 {
-       const uint8_t *BND(v1,v1+n) s1 = (const uint8_t *) v1;
-       const uint8_t *BND(v2,v2+n) s2 = (const uint8_t *) v2;
+       const uint8_t *s1 = (const uint8_t *) v1;
+       const uint8_t *s2 = (const uint8_t *) v2;
 
        while (n-- > 0) {
                if (*s1 != *s2)
@@ -296,14 +309,14 @@ memcmp(const void *COUNT(n) v1, const void *COUNT(n) v2, size_t n)
 }
 
 void *
-memfind(const void *COUNT(n) _s, int c, size_t n)
+memfind(const void *_s, int c, size_t n)
 {
-       const void *SNT ends = (const char *) _s + n;
-       const void *BND(_s,_s + n) s = _s;
+       const void *ends = (const char *) _s + n;
+       const void *s = _s;
        for (; s < ends; s++)
                if (*(const unsigned char *) s == (unsigned char) c)
                        break;
-       return (void *BND(_s,_s+n)) s;
+       return (void *)s;
 }
 
 long
@@ -353,9 +366,86 @@ strtol(const char *s, char **endptr, int base)
        return (neg ? -val : val);
 }
 
-int
-atoi(const char* s)
+unsigned long
+strtoul(const char *s, char **endptr, int base)
 {
+       int neg = 0;
+       unsigned long val = 0;
+
+       // gobble initial whitespace
+       while (*s == ' ' || *s == '\t')
+               s++;
+
+       // plus/minus sign
+       if (*s == '+')
+               s++;
+       else if (*s == '-')
+               s++, neg = 1;
+
+       // hex or octal base prefix
+       if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x'))
+               s += 2, base = 16;
+       else if (base == 0 && s[0] == '0')
+               s++, base = 8;
+       else if (base == 0)
+               base = 10;
+
+       // digits
+       while (1) {
+               int dig;
+
+               if (*s >= '0' && *s <= '9')
+                       dig = *s - '0';
+               else if (*s >= 'a' && *s <= 'z')
+                       dig = *s - 'a' + 10;
+               else if (*s >= 'A' && *s <= 'Z')
+                       dig = *s - 'A' + 10;
+               else
+                       break;
+               if (dig >= base)
+                       break;
+               s++, val = (val * base) + dig;
+               // we don't properly detect overflow!
+       }
+
+       if (endptr)
+               *endptr = (char *) s;
+       return (neg ? -val : val);
+}
+
+int atoi(const char *s)
+{
+       if (!s)
+               return 0;
+       if (s[0] == '0' && s[1] == 'x')
+               warn("atoi() used on a hex string!");
        // no overflow detection
        return (int)strtol(s,NULL,10);
 }
+
+int sigchecksum(void *address, int length)
+{
+       uint8_t *p, sum;
+
+       sum = 0;
+       for (p = address; length-- > 0; p++)
+               sum += *p;
+
+       return sum;
+}
+
+void *sigscan(uint8_t *address, int length, char *signature)
+{
+       uint8_t *e, *p;
+       int siglength;
+
+       e = address + length;
+       siglength = strlen(signature);
+       for (p = address; p + siglength < e; p += 16) {
+               if (memcmp(p, signature, siglength))
+                       continue;
+               return p;
+       }
+
+       return NULL;
+}