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

   1 /*
   2 visor - lightweight system-independent embeddable text editor framework
   3 Copyright (C)  2019 John Tsiombikas <nuclear@member.fsf.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program.  If not, see <https://www.gnu.org/licenses/>.
  17 */
  18 #include "vilibc.h"
  19 #include "vimpl.h"
  20
  21 #ifndef HAVE_LIBC
  22
  23 int atoi(const char *str)
  24 {
  25         return strtol(str, 0, 10);
  26 }
  27
  28 long atol(const char *str)
  29 {
  30         return strtol(str, 0, 10);
  31 }
  32
  33 long strtol(const char *str, char **endp, int base)
  34 {
  35         long acc = 0;
  36         int sign = 1;
  37         int valid = 0;
  38         const char *start = str;
  39
  40         while(isspace(*str)) str++;
  41
  42         if(base == 0) {
  43                 if(str[0] == '0') {
  44                         if(str[1] == 'x' || str[1] == 'X') {
  45                                 base = 16;
  46                         } else {
  47                                 base = 8;
  48                         }
  49                 } else {
  50                         base = 10;
  51                 }
  52         }
  53
  54         if(*str == '+') {
  55                 str++;
  56         } else if(*str == '-') {
  57                 sign = -1;
  58                 str++;
  59         }
  60
  61         while(*str) {
  62                 long val = 0x7fffffff;
  63                 char c = tolower(*str);
  64
  65                 if(isdigit(c)) {
  66                         val = *str - '0';
  67                 } else if(c >= 'a' && c <= 'f') {
  68                         val = 10 + c - 'a';
  69                 } else {
  70                         break;
  71                 }
  72                 if(val >= base) {
  73                         break;
  74                 }
  75                 valid = 1;
  76
  77                 acc = acc * base + val;
  78                 str++;
  79         }
  80
  81         if(endp) {
  82                 *endp = (char*)(valid ? str : start);
  83         }
  84
  85         return sign > 0 ? acc : -acc;
  86 }
  87
  88
  89 void *memset(void *s, int c, unsigned long n)
  90 {
  91         char *p = s;
  92         while(n--) *p++ = c;
  93         return s;
  94 }
  95
  96 void *memcpy(void *dest, const void *src, unsigned long n)
  97 {
  98         char *d = dest;
  99         const char *s = src;
 100         while(n--) *d++ = *s++;
 101         return dest;
 102 }
 103
 104 void *memmove(void *dest, const void *src, unsigned long n)
 105 {
 106         unsigned long i;
 107         char *dptr;
 108         const char *sptr;
 109
 110         if(dest <= src) {
 111                 /* forward copy */
 112                 dptr = dest;
 113                 sptr = src;
 114                 for(i=0; i<n; i++) {
 115                         *dptr++ = *sptr++;
 116                 }
 117         } else {
 118                 /* backwards copy */
 119                 dptr = (char*)dest + n - 1;
 120                 sptr = (const char*)src + n - 1;
 121                 for(i=0; i<n; i++) {
 122                         *dptr-- = *sptr--;
 123                 }
 124         }
 125
 126         return dest;
 127 }
 128
 129 unsigned long strlen(const char *s)
 130 {
 131         unsigned long len = 0;
 132         while(*s++) len++;
 133         return len;
 134 }
 135
 136 char *strchr(const char *s, int c)
 137 {
 138         while(*s) {
 139                 if(*s == c) {
 140                         return (char*)s;
 141                 }
 142                 s++;
 143         }
 144         return 0;
 145 }
 146
 147 int strcmp(const char *s1, const char *s2)
 148 {
 149         while(*s1 && *s1 == *s2) {
 150                 s1++;
 151                 s2++;
 152         }
 153         return *s1 - *s2;
 154 }
 155
 156 char *strcpy(char *dest, const char *src)
 157 {
 158         char *dptr = dest;
 159         while((*dptr++ = *src++));
 160         return dest;
 161 }
 162
 163
 164 int isalnum(int c)
 165 {
 166         return isalpha(c) || isdigit(c);
 167 }
 168
 169 int isalpha(int c)
 170 {
 171         return isupper(c) || islower(c);
 172 }
 173
 174 int isblank(int c)
 175 {
 176         return c == ' ' || c == '\t';
 177 }
 178
 179 int isdigit(int c)
 180 {
 181         return c >= '0' && c <= '9';
 182 }
 183
 184 int isupper(int c)
 185 {
 186         return c >= 'A' && c <= 'Z';
 187 }
 188
 189 int islower(int c)
 190 {
 191         return c >= 'a' && c <= 'z';
 192 }
 193
 194 int isgraph(int c)
 195 {
 196         return c > ' ' && c <= '~';
 197 }
 198
 199 int isprint(int c)
 200 {
 201         return isgraph(c) || c == ' ';
 202 }
 203
 204 int isspace(int c)
 205 {
 206         return isblank(c) || c == '\f' || c == '\n' || c == '\r' || c == '\v';
 207 }
 208
 209 int toupper(int c)
 210 {
 211         return islower(c) ? (c + ('A' - 'a')) : c;
 212 }
 213
 214 int tolower(int c)
 215 {
 216         return isupper(c) ? (c - ('A' - 'a')) : c;
 217 }
 218
 219 #endif  /* !def HAVE_LIBC */
 220
 221 static char errstr_buf[256];
 222
 223 void vi_error(struct visor *vi, const char *fmt, ...)
 224 {
 225         va_list ap;
 226
 227         va_start(ap, fmt);
 228         vsnprintf(errstr_buf, sizeof errstr_buf, fmt, ap);
 229         va_end(ap);
 230
 231         if(vi->tty.status) {
 232                 vi->tty.status(errstr_buf, vi->tty_cls);
 233         }
 234 }