lib/libc.c

   1 /* -*-comment-start: "//";comment-end:""-*-
   2  * Mes --- Maxwell Equations of Software
   3  * Copyright © 2016,2017 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
   4  *
   5  * This file is part of Mes.
   6  *
   7  * Mes is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or (at
  10  * your option) any later version.
  11  *
  12  * Mes is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Mes.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <sys/ioctl.h>
  22 #include <stdarg.h>
  23 #include <stdlib.h>
  24
  25 #if POSIX
  26 #define _GNU_SOURCE
  27 #include <assert.h>
  28 #include <fcntl.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #endif // POSIX
  32
  33 int
  34 isdigit (int c)
  35 {
  36   return (c>='0') && (c<='9');
  37 }
  38
  39 int
  40 isxdigit (int c)
  41 {
  42   return isdigit (c) || (c>='a') && (c<='f');
  43 }
  44
  45 int
  46 isspace (int c)
  47 {
  48   return (c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r' || c == ' ');
  49 }
  50
  51 int
  52 isnumber (int c, int base)
  53 {
  54   if (base == 2)
  55     return (c>='0') && (c<='1');
  56   if (base == 8)
  57     return (c>='0') && (c<='7');
  58   if (base == 10)
  59     return isdigit (c);
  60   if (base == 16)
  61     return isxdigit (c);
  62 }
  63
  64 int
  65 abtoi (char const **p, int base)
  66 {
  67   char const *s = *p;
  68   int i = 0;
  69   int sign = 1;
  70   if (!base) base = 10;
  71   if (*s && *s == '-')
  72     {
  73       sign = -1;
  74       s++;
  75     }
  76   while (isnumber (*s, base))
  77     {
  78       i *= base;
  79       int m = *s > '9' ? 'a' - 10 : '0';
  80       i += *s - m;
  81       s++;
  82     }
  83   *p = s;
  84   return i * sign;
  85 }
  86
  87 int
  88 atoi (char const *s)
  89 {
  90   char const *p = s;
  91   return abtoi (&p, 0);
  92 }
  93
  94 char itoa_buf[10];
  95
  96 char const*
  97 itoa (int x)
  98 {
  99   //static char itoa_buf[10];
 100   //char *p = buf+9;
 101   char *p = itoa_buf;
 102   p += 9;
 103   *p-- = 0;
 104
 105   //int sign = x < 0; // FIXME
 106   int sign = 0;
 107   if (x < 0) sign = 1;
 108   if (sign)
 109     x = -x;
 110
 111   do
 112      {
 113        *p-- = '0' + (x % 10);
 114        x = x / 10;
 115      } while (x);
 116
 117   if (sign && *(p + 1) != '0')
 118     *p-- = '-';
 119
 120   return p+1;
 121 }
 122
 123 char const*
 124 itoab (int x, int base)
 125 {
 126   //static char itoa_buf[10];
 127   //char *p = buf+9;
 128   char *p = itoa_buf;
 129   p += 9;
 130   *p-- = 0;
 131
 132   //int sign = x < 0; // FIXME
 133   int sign = 0;
 134   if (x < 0) sign = 1;
 135   if (sign)
 136     x = -x;
 137
 138   do
 139      {
 140        int i = x % base;
 141        *p-- = i > 9 ? 'a' + i - 10 : '0' + i;
 142        x = x / base;
 143      } while (x);
 144
 145   if (sign && *(p + 1) != '0')
 146     *p-- = '-';
 147
 148   return p+1;
 149 }
 150
 151 int
 152 fdputc (int c, int fd)
 153 {
 154   write (fd, (char*)&c, 1);
 155   return 0;
 156 }
 157
 158 int
 159 fdputs (char const* s, int fd)
 160 {
 161   int i = strlen (s);
 162   write (fd, s, i);
 163   return 0;
 164 }
 165
 166 #if !POSIX
 167
 168 ///char **g_environment = 0; // FIXME: todo extern
 169 int g_stdin = 0;
 170
 171 void _env ();
 172
 173 int
 174 eputc (int c)
 175 {
 176   return fdputc (c, STDERR);
 177 }
 178
 179 int
 180 putchar (int c)
 181 {
 182   write (STDOUT, (char*)&c, 1);
 183   return 0;
 184 }
 185
 186 void
 187 assert_fail (char* s)
 188 {
 189   eputs ("assert fail: ");
 190   eputs (s);
 191   eputs ("\n");
 192   //*((int*)0) = 0;
 193   char *fail = s;
 194   fail = 0;
 195   *fail = 0;
 196 }
 197
 198 int ungetc_char = -1;
 199 char ungetc_buf[2];
 200
 201 int
 202 getchar ()
 203 {
 204   char c;
 205   int i;
 206   if (ungetc_char == -1)
 207     {
 208       int r = read (g_stdin, &c, 1);
 209       if (r < 1) return -1;
 210       i = c;
 211    }
 212   else
 213     {
 214        //FIXME
 215        //i = ungetc_buf[ungetc_char--];
 216        i = ungetc_buf[ungetc_char];
 217        //ungetc_char--;
 218        ungetc_char = ungetc_char - 1;
 219      }
 220   if (i < 0) i += 256;
 221
 222   return i;
 223 }
 224
 225 int
 226 fgetc (int fd)
 227 {
 228   char c;
 229   int i;
 230   int r = read (fd, &c, 1);
 231   if (r < 1) return -1;
 232   i = c;
 233   return i;
 234 }
 235
 236 void
 237 free (void *ptr)
 238 {
 239 }
 240
 241 //#define assert(x) ((x) ? (void)0 : assert_fail (#x))
 242 int
 243 ungetc (int c, int fd)
 244 {
 245   //FIXME
 246   //assert (ungetc_char < 2);
 247   //assert (ungetc_char == -1 || ungetc_char < 2);
 248   //FIXME
 249   //ungetc_buf[++ungetc_char] = c;
 250   ungetc_char++;
 251   ungetc_buf[ungetc_char] = c;
 252   return c;
 253 }
 254
 255 int
 256 strcmp (char const* a, char const* b)
 257 {
 258   while (*a && *b && *a == *b)
 259     {
 260       a++;b++;
 261     }
 262   return *a - *b;
 263 }
 264
 265
 266 char *
 267 strcpy (char *dest, char const *src)
 268 {
 269   char *p = dest;
 270   while (*src) *p++ = *src++;
 271   *p = 0;
 272   return dest;
 273 }
 274
 275 char *g_brk = 0;
 276
 277 void *
 278 malloc (size_t size)
 279 {
 280   if (!g_brk)
 281     g_brk = brk (0);
 282   if (brk (g_brk + size) == -1)
 283     return 0;
 284   char *p = g_brk;
 285   g_brk += size;
 286   return p;
 287 }
 288
 289 void *
 290 memcpy (void *dest, void const *src, size_t n)
 291 {
 292   char* p = dest;
 293   char* q = src;
 294   while (n--) *p++ = *q++;
 295   return dest;
 296 }
 297
 298 void *
 299 realloc (void *ptr, size_t size)
 300 {
 301   void *new = malloc (size);
 302   if (ptr && new)
 303     {
 304       memcpy (new, ptr, size);
 305       free (ptr);
 306     }
 307   return new;
 308 }
 309
 310 int
 311 strncmp (char const* a, char const* b, size_t length)
 312 {
 313   while (*a && *b && *a == *b && --length) {a++;b++;}
 314   return *a - *b;
 315 }
 316
 317 char *
 318 getenv (char const* s)
 319 {
 320   char **p = g_environment;
 321   int length = strlen (s);
 322   while (*p)
 323     {
 324       if (!strncmp (s, *p, length) && *(*p + length) == '=') return (*p + length + 1);
 325       p++;
 326     }
 327   return 0;
 328 }
 329
 330 int
 331 setenv (char const* s, char const* v, int overwrite_p)
 332 {
 333   char **p = g_environment;
 334   int length = strlen (s);
 335   while (*p)
 336     {
 337       if (!strncmp (s, *p, length) && *(*p + length) == '=')
 338         break;
 339       p++;
 340     }
 341   char *entry = malloc (length + strlen (v) + 2);
 342   int end_p = *p == 0;
 343   *p = entry;
 344   strcpy (entry, s);
 345   strcpy (entry + length, "=");
 346   strcpy (entry + length + 1, v);
 347   *(entry + length + strlen (v) + 2) = 0;
 348   if (end_p)
 349     *++p = 0;
 350   return 0;
 351 }
 352
 353 int
 354 vprintf (char const* format, va_list ap)
 355 {
 356   char const *p = format;
 357   while (*p)
 358     if (*p != '%')
 359       putchar (*p++);
 360     else
 361       {
 362         p++;
 363         char c = *p;
 364         switch (c)
 365           {
 366           case '%': {putchar (*p); break;}
 367           case 'c': {char c; c = va_arg (ap, char); putchar (c); break;}
 368           case 'd': {int d; d = va_arg (ap, int); puts (itoa (d)); break;}
 369           case 's': {char *s; s = va_arg (ap, char *); puts (s); break;}
 370           default: {putchar (*p); break;}
 371           }
 372         p++;
 373       }
 374   va_end (ap);
 375   return 0;
 376 }
 377
 378 int
 379 printf (char const* format, ...)
 380 {
 381   va_list ap;
 382   va_start (ap, format);
 383   int r = vprintf (format, ap);
 384   va_end (ap);
 385   return r;
 386 }
 387
 388 int
 389 vsprintf (char *str, char const* format, va_list ap)
 390 {
 391   char const *p = format;
 392   while (*p)
 393     if (*p != '%')
 394       *str++ = *p++;
 395     else
 396       {
 397         p++;
 398         char c = *p;
 399         switch (c)
 400           {
 401           case '%': {*str++ = *p; break;}
 402           case 'c': {char c; c = va_arg (ap, char); *str++ = c; break;}
 403           case 'd': {int d; d = va_arg (ap, int); char const *s; s = itoa (d); while (*s) *str++ = *s++; break;}
 404           case 's': {char *s; s = va_arg (ap, char *); while (*s) *str++ = *s++; break;}
 405           default: {*str++ = *p; break;}
 406           }
 407         p++;
 408       }
 409   va_end (ap);
 410   *str = 0;
 411   return strlen (str);
 412 }
 413
 414 int
 415 sprintf (char *str, char const* format, ...)
 416 {
 417   va_list ap;
 418   va_start (ap, format);
 419   int r = vsprintf (str, format, ap);
 420   va_end (ap);
 421   return r;
 422 }
 423
 424 int
 425 isatty (int fd)
 426 {
 427   return ioctl (fd, TCGETS, 0) & 0xf0;
 428 }
 429
 430 #endif //!POSIX