kernel/general.c

   1 #include "general.h"
   2 #include "stdint.h"
   3 #include "stdlib.h"
   4 #include "console.h"
   5
   6 int strcmp(const char *str1, const char *str2)
   7 {
   8     // the actual compare is done by memcmp()
   9     size_t len1, len2, smallest_len;
  10     int cmp;
  11     len1 = strlen(str1);
  12     len2 = strlen(str2);
  13     smallest_len = len1;
  14     if (len2 < smallest_len){
  15         smallest_len = len2;
  16     }
  17     // compare as many bytes as both strings have
  18     cmp = memcmp(str1, str2, smallest_len);
  19     if (cmp == 0){
  20         // the bits we compared were identical, but...
  21         if (len1 > len2){
  22             // str1 was longer than str2
  23             return -1;
  24         } else if (len1 < len2){
  25             // str2 was longer than str1
  26             return 1;
  27         } else {
  28             // yes, they were exactly the same
  29             return 0;
  30         }
  31     } else {
  32         // the bits we compared weren't the same
  33         // any extra bits after what we compared
  34         // won't make any difference
  35         return cmp;
  36     }
  37 }
  38
  39 void panic_internal(const char *file, int line, const char *fmt, ...)
  40 {
  41     cli();
  42     va_list ap;
  43     console_set_fcolour(get_vterm(0), COLOR_BRIGHT_RED); // set a noticable colour
  44     console_printf(get_vterm(0), "*** PANIC (%s:%d): ", file, line);
  45     // print the actual message
  46     va_start(ap, fmt);
  47     console_vprintf(get_vterm(0), fmt, ap);
  48     va_end(ap);
  49     // print a newline
  50     console_putchar(get_vterm(0), '\n');
  51     // completely halt
  52     hlt();
  53 }
  54
  55 // Compare two strings. Should return -1 if
  56 // str1 < str2, 0 if they are equal or 1 otherwise.
  57 /*
  58 int strcmp(char *str1, char *str2)
  59 {
  60       int i = 0;
  61       int failed = 0;
  62       while(str1[i] != '\0' && str2[i] != '\0')
  63       {
  64           if(str1[i] != str2[i])
  65           {
  66               failed = 1;
  67               break;
  68           }
  69           i++;
  70       }
  71       // why did the loop exit?
  72       if( (str1[i] == '\0' && str2[i] != '\0') || (str1[i] != '\0' && str2[i] == '\0') )
  73           failed = 1;
  74
  75       return failed;
  76 }
  77 */
  78
  79 // Copy the NULL-terminated string src into dest, and
  80 // return dest.
  81 char *strcpy(char *dest, const char *src)
  82 {
  83     memcpy(dest, src, strlen(src) + 1); // copy entire string + null byte
  84     return dest;
  85 }
  86
  87 char *strncpy(char *dest, const char *src, size_t n)
  88 {
  89     size_t len = strlen(src);
  90     if (len > n){
  91         len = n;
  92     }
  93     memcpy(dest, src, len);
  94     // pad the remainder of the string with null bytes!
  95     memset(dest + len, 0, n - len);
  96     return dest;
  97 }
  98
  99 // Concatenate the NULL-terminated string src onto
 100 // the end of dest, and return dest.
 101 /*
 102 char *strcat(char *dest, const char *src)
 103 {
 104     while (*dest != 0)
 105     {
 106         *dest = *dest++;
 107     }
 108
 109     do
 110     {
 111         *dest++ = *src++;
 112     }
 113     while (*src != 0);
 114     return dest;
 115 }
 116 */
 117 /*
 118 int strlen(char *src)
 119 {
 120     int i = 0;
 121     while (*src++)
 122         i++;
 123     return i;
 124 }
 125 */
 126 char * strtok( char * s1, const char * s2 )
 127 {
 128     static char * tmp = NULL;
 129     const char * p = s2;
 130
 131     if ( s1 != NULL )
 132     {
 133         /* new string */
 134         tmp = s1;
 135     }
 136     else
 137     {
 138         /* old string continued */
 139         if ( tmp == NULL )
 140         {
 141             /* No old string, no new string, nothing to do */
 142             return NULL;
 143         }
 144         s1 = tmp;
 145     }
 146
 147     /* skipping leading s2 characters */
 148     while ( *p && *s1 )
 149     {
 150         if ( *s1 == *p )
 151         {
 152             /* found seperator; skip and start over */
 153             ++s1;
 154             p = s2;
 155             continue;
 156         }
 157         ++p;
 158     }
 159
 160     if ( ! *s1 )
 161     {
 162         /* no more to parse */
 163         return ( tmp = NULL );
 164     }
 165
 166     /* skipping non-s2 characters */
 167     tmp = s1;
 168     while ( *tmp )
 169     {
 170         p = s2;
 171         while ( *p )
 172         {
 173             if ( *tmp == *p++ )
 174             {
 175                 /* found seperator; overwrite with '\0', position tmp, return */
 176                 *tmp++ = '\0';
 177                 return s1;
 178             }
 179         }
 180         ++tmp;
 181     }
 182
 183     /* parsed to end of string */
 184     return ( tmp = NULL );
 185 }