git.mutantstargoat.com Git - visor/blob - libvisor/src/vilibc.c

   1 #include "vilibc.h"
   2 #include "vimpl.h"
   3
   4 #ifndef HAVE_LIBC
   5
   6 int atoi(const char *str)
   7 {
   8         return strtol(str, 0, 10);
   9 }
  10
  11 long atol(const char *str)
  12 {
  13         return strtol(str, 0, 10);
  14 }
  15
  16 long strtol(const char *str, char **endp, int base)
  17 {
  18         long acc = 0;
  19         int sign = 1;
  20         int valid = 0;
  21         const char *start = str;
  22
  23         while(isspace(*str)) str++;
  24
  25         if(base == 0) {
  26                 if(str[0] == '0') {
  27                         if(str[1] == 'x' || str[1] == 'X') {
  28                                 base = 16;
  29                         } else {
  30                                 base = 8;
  31                         }
  32                 } else {
  33                         base = 10;
  34                 }
  35         }
  36
  37         if(*str == '+') {
  38                 str++;
  39         } else if(*str == '-') {
  40                 sign = -1;
  41                 str++;
  42         }
  43
  44         while(*str) {
  45                 long val = 0x7fffffff;
  46                 char c = tolower(*str);
  47
  48                 if(isdigit(c)) {
  49                         val = *str - '0';
  50                 } else if(c >= 'a' && c <= 'f') {
  51                         val = 10 + c - 'a';
  52                 } else {
  53                         break;
  54                 }
  55                 if(val >= base) {
  56                         break;
  57                 }
  58                 valid = 1;
  59
  60                 acc = acc * base + val;
  61                 str++;
  62         }
  63
  64         if(endp) {
  65                 *endp = (char*)(valid ? str : start);
  66         }
  67
  68         return sign > 0 ? acc : -acc;
  69 }
  70
  71
  72 void *memset(void *s, int c, unsigned long n)
  73 {
  74         char *p = s;
  75         while(n--) *p++ = c;
  76         return s;
  77 }
  78
  79 void *memcpy(void *dest, const void *src, unsigned long n)
  80 {
  81         char *d = dest;
  82         const char *s = src;
  83         while(n--) *d++ = *s++;
  84         return dest;
  85 }
  86
  87 void *memmove(void *dest, const void *src, unsigned long n)
  88 {
  89         unsigned long i;
  90         char *dptr;
  91         const char *sptr;
  92
  93         if(dest <= src) {
  94                 /* forward copy */
  95                 dptr = dest;
  96                 sptr = src;
  97                 for(i=0; i<n; i++) {
  98                         *dptr++ = *sptr++;
  99                 }
 100         } else {
 101                 /* backwards copy */
 102                 dptr = (char*)dest + n - 1;
 103                 sptr = (const char*)src + n - 1;
 104                 for(i=0; i<n; i++) {
 105                         *dptr-- = *sptr--;
 106                 }
 107         }
 108
 109         return dest;
 110 }
 111
 112 unsigned long strlen(const char *s)
 113 {
 114         unsigned long len = 0;
 115         while(*s++) len++;
 116         return len;
 117 }
 118
 119 char *strchr(const char *s, int c)
 120 {
 121         while(*s) {
 122                 if(*s == c) {
 123                         return (char*)s;
 124                 }
 125                 s++;
 126         }
 127         return 0;
 128 }
 129
 130 int strcmp(const char *s1, const char *s2)
 131 {
 132         while(*s1 && *s1 == *s2) {
 133                 s1++;
 134                 s2++;
 135         }
 136         return *s1 - *s2;
 137 }
 138
 139 char *strcpy(char *dest, const char *src)
 140 {
 141         char *dptr = dest;
 142         while((*dptr++ = *src++));
 143         return dest;
 144 }
 145
 146
 147 int isalnum(int c)
 148 {
 149         return isalpha(c) || isdigit(c);
 150 }
 151
 152 int isalpha(int c)
 153 {
 154         return isupper(c) || islower(c);
 155 }
 156
 157 int isblank(int c)
 158 {
 159         return c == ' ' || c == '\t';
 160 }
 161
 162 int isdigit(int c)
 163 {
 164         return c >= '0' && c <= '9';
 165 }
 166
 167 int isupper(int c)
 168 {
 169         return c >= 'A' && c <= 'Z';
 170 }
 171
 172 int islower(int c)
 173 {
 174         return c >= 'a' && c <= 'z';
 175 }
 176
 177 int isgraph(int c)
 178 {
 179         return c > ' ' && c <= '~';
 180 }
 181
 182 int isprint(int c)
 183 {
 184         return isgraph(c) || c == ' ';
 185 }
 186
 187 int isspace(int c)
 188 {
 189         return isblank(c) || c == '\f' || c == '\n' || c == '\r' || c == '\v';
 190 }
 191
 192 int toupper(int c)
 193 {
 194         return islower(c) ? (c + ('A' - 'a')) : c;
 195 }
 196
 197 int tolower(int c)
 198 {
 199         return isupper(c) ? (c - ('A' - 'a')) : c;
 200 }
 201
 202 #endif  /* !def HAVE_LIBC */
 203
 204 static char errstr_buf[256];
 205
 206 void vi_error(struct visor *vi, const char *fmt, ...)
 207 {
 208         va_list ap;
 209
 210         va_start(ap, fmt);
 211         vsnprintf(errstr_buf, sizeof errstr_buf, fmt, ap);
 212         va_end(ap);
 213
 214         if(vi->tty.status) {
 215                 vi->tty.status(errstr_buf, vi->tty_cls);
 216         }
 217 }