kit

stdlib.c (5621B)

---

 //===-- stdlib.c - kit freestanding stdlib primitives -------------------===//
 //
 // SPDX-License-Identifier: 0BSD
 //===----------------------------------------------------------------------===//
 
 #include <stddef.h>
 
 typedef struct {
   int quot;
   int rem;
 } div_t;
 
 typedef struct {
   long quot;
   long rem;
 } ldiv_t;
 
 typedef struct {
   long long quot;
   long long rem;
 } lldiv_t;
 
 static int kit_isspace(char c) { return c == ' ' || (c >= '\t' && c <= '\r'); }
 
 static int kit_digit_value(char c) {
   if (c >= '0' && c <= '9') return c - '0';
   if (c >= 'a' && c <= 'z') return c - 'a' + 10;
   if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
   return -1;
 }
 
 static int kit_match_ci(const char* s, const char* word) {
   while (*word != '\0') {
     char a = *s++;
     char b = *word++;
     if (a >= 'A' && a <= 'Z') a = (char)(a - 'A' + 'a');
     if (a != b) return 0;
   }
   return 1;
 }
 
 __attribute__((weak)) unsigned long long strtoull(const char* nptr,
                                                   char** endptr, int base) {
   const char* s = nptr;
   int neg = 0;
   unsigned long long value = 0;
   int any = 0;
 
   while (kit_isspace(*s)) s++;
   if (*s == '+' || *s == '-') neg = *s++ == '-';
 
   if ((base == 0 || base == 16) && s[0] == '0' &&
       (s[1] == 'x' || s[1] == 'X')) {
     int d = kit_digit_value(s[2]);
     if (d >= 0 && d < 16) {
       s += 2;
       base = 16;
     }
   }
   if (base == 0) base = (*s == '0') ? 8 : 10;
   if (base < 2 || base > 36) {
     if (endptr) *endptr = (char*)nptr;
     return 0;
   }
 
   for (;;) {
     int d = kit_digit_value(*s);
     if (d < 0 || d >= base) break;
     value = value * (unsigned)base + (unsigned)d;
     s++;
     any = 1;
   }
 
   if (endptr) *endptr = (char*)(any ? s : nptr);
   return neg ? 0 - value : value;
 }
 
 __attribute__((weak)) unsigned long strtoul(const char* nptr, char** endptr,
                                             int base) {
   return (unsigned long)strtoull(nptr, endptr, base);
 }
 
 __attribute__((weak)) long long strtoll(const char* nptr, char** endptr,
                                         int base) {
   return (long long)strtoull(nptr, endptr, base);
 }
 
 __attribute__((weak)) long strtol(const char* nptr, char** endptr, int base) {
   return (long)strtoull(nptr, endptr, base);
 }
 
 __attribute__((weak)) long long atoll(const char* nptr) {
   return strtoll(nptr, NULL, 10);
 }
 __attribute__((weak)) long atol(const char* nptr) {
   return strtol(nptr, NULL, 10);
 }
 __attribute__((weak)) int atoi(const char* nptr) {
   return (int)strtol(nptr, NULL, 10);
 }
 
 static long double kit_strtold_impl(const char* nptr, char** endptr) {
   const char* s = nptr;
   int neg = 0;
   int any = 0;
   long double value = 0.0L;
 
   while (kit_isspace(*s)) s++;
   if (*s == '+' || *s == '-') neg = *s++ == '-';
 
   if (kit_match_ci(s, "infinity")) {
     if (endptr) *endptr = (char*)(s + 8);
     return neg ? -(1.0L / 0.0L) : (1.0L / 0.0L);
   }
   if (kit_match_ci(s, "inf")) {
     if (endptr) *endptr = (char*)(s + 3);
     return neg ? -(1.0L / 0.0L) : (1.0L / 0.0L);
   }
   if (kit_match_ci(s, "nan")) {
     if (endptr) *endptr = (char*)(s + 3);
     return 0.0L / 0.0L;
   }
 
   while (*s >= '0' && *s <= '9') {
     value = value * 10.0L + (long double)(*s - '0');
     s++;
     any = 1;
   }
 
   if (*s == '.') {
     long double place = 0.1L;
     s++;
     while (*s >= '0' && *s <= '9') {
       value += (long double)(*s - '0') * place;
       place *= 0.1L;
       s++;
       any = 1;
     }
   }
 
   if (!any) {
     if (endptr) *endptr = (char*)nptr;
     return 0.0L;
   }
 
   if (*s == 'e' || *s == 'E') {
     const char* exp_start = s;
     int exp_neg = 0;
     int exp_any = 0;
     int exp = 0;
     s++;
     if (*s == '+' || *s == '-') exp_neg = *s++ == '-';
     while (*s >= '0' && *s <= '9') {
       exp = exp * 10 + (*s - '0');
       s++;
       exp_any = 1;
     }
     if (exp_any) {
       while (exp-- > 0) value = exp_neg ? value / 10.0L : value * 10.0L;
     } else {
       s = exp_start;
     }
   }
 
   if (endptr) *endptr = (char*)s;
   return neg ? -value : value;
 }
 
 __attribute__((weak)) long double strtold(const char* nptr, char** endptr) {
   return kit_strtold_impl(nptr, endptr);
 }
 
 __attribute__((weak)) double strtod(const char* nptr, char** endptr) {
   return (double)kit_strtold_impl(nptr, endptr);
 }
 
 __attribute__((weak)) float strtof(const char* nptr, char** endptr) {
   return (float)kit_strtold_impl(nptr, endptr);
 }
 
 __attribute__((weak)) int abs(int j) { return j < 0 ? -j : j; }
 __attribute__((weak)) long labs(long j) { return j < 0 ? -j : j; }
 __attribute__((weak)) long long llabs(long long j) { return j < 0 ? -j : j; }
 
 __attribute__((weak)) div_t div(int numer, int denom) {
   div_t r;
   r.quot = numer / denom;
   r.rem = numer % denom;
   return r;
 }
 
 __attribute__((weak)) ldiv_t ldiv(long numer, long denom) {
   ldiv_t r;
   r.quot = numer / denom;
   r.rem = numer % denom;
   return r;
 }
 
 __attribute__((weak)) lldiv_t lldiv(long long numer, long long denom) {
   lldiv_t r;
   r.quot = numer / denom;
   r.rem = numer % denom;
   return r;
 }
 
 __attribute__((weak)) void* bsearch(const void* key, const void* base,
                                     size_t nmemb, size_t size,
                                     int (*compar)(const void*, const void*)) {
   const unsigned char* b = (const unsigned char*)base;
   size_t low = 0;
   size_t high = nmemb;
 
   while (low < high) {
     size_t mid = low + (high - low) / 2;
     const void* elem = b + mid * size;
     int cmp = compar(key, elem);
     if (cmp < 0) {
       high = mid;
     } else if (cmp > 0) {
       low = mid + 1;
     } else {
       return (void*)elem;
     }
   }
   return NULL;
 }