lib/libc+tcc.c

   1 /* -*-comment-start: "//";comment-end:""-*-
   2  * Mes --- Maxwell Equations of Software
   3  * Copyright © 2017,2018 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 <setjmp.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <time.h>
  27 #include <signal.h>
  28 #include <sys/mman.h>
  29 #include <sys/time.h>
  30 #include <unistd.h>
  31
  32 int
  33 dlclose (void *handle)
  34 {
  35   return 0;
  36 }
  37
  38 void *
  39 dlopen (char const *filename, int flags)
  40 {
  41   return 0;
  42 }
  43
  44 int
  45 execvp (char const *file, char *const argv[])
  46 {
  47   eputs ("execvp stub\n");
  48   return 0;
  49 }
  50
  51 int
  52 fclose (FILE *stream)
  53 {
  54   int fd = (int)stream;
  55   return close (fd);
  56 }
  57
  58 FILE *
  59 fdopen (int fd, char const *mode)
  60 {
  61   return (FILE*)fd;
  62 }
  63
  64 int
  65 ferror (FILE *stream)
  66 {
  67   int fd = (int)stream;
  68   if (fd == -1) return -1;
  69   return 0;
  70 }
  71
  72 int
  73 fflush (FILE *stream)
  74 {
  75   eputs ("fflush stub\n");
  76   return 0;
  77 }
  78
  79 int
  80 fprintf (FILE *stream, char const *format, ...)
  81 {
  82   va_list ap;
  83   va_start (ap, format);
  84   int r = vfprintf (stream, format, ap);
  85   va_end (ap);
  86   return r;
  87 }
  88
  89 size_t
  90 fread (void *ptr, size_t size, size_t nmemb, FILE *stream)
  91 {
  92   eputs ("fread stub\n");
  93   return 0;
  94 }
  95
  96 int
  97 fseek (FILE *stream, long offset, int whence)
  98 {
  99   eputs ("fseek stub\n");
 100   return 0;
 101 }
 102
 103 long
 104 ftell (FILE *stream)
 105 {
 106   eputs ("ftell stub\n");
 107   return 0;
 108 }
 109
 110 size_t
 111 fwrite (void const *ptr, size_t size, size_t nmemb, FILE *stream)
 112 {
 113   int fd = (int)stream;
 114   return write (fd, ptr, size * nmemb);
 115 }
 116
 117 int
 118 gettimeofday (struct timeval *tv, struct timezone *tz)
 119 {
 120   return 0;
 121 }
 122
 123 double
 124 ldexp (double x, int exp)
 125 {
 126   eputs ("ldexp stub\n");
 127   return 0;
 128 }
 129
 130 struct tm *
 131 localtime (time_t const *timep)
 132 {
 133   eputs ("localtime stub\n");
 134   return 0;
 135 }
 136
 137 void *
 138 memmove (void *dest, void const *src, size_t n)
 139 {
 140   if (dest < src)
 141     return memcpy (dest, src, n);
 142   char *p = dest + n;
 143   char const *q = src +n;
 144   while (n--)
 145     *--p = *--q;
 146   return dest;
 147 }
 148
 149 void *
 150 memset (void *s, int c, size_t n)
 151 {
 152   char *p = s;
 153   while (n--) *p++ = c;
 154   return s;
 155 }
 156
 157 int
 158 memcmp (void const *s1, void const *s2, size_t n)
 159 {
 160   char *a = s1;
 161   char *b = s2;
 162   while (*a == *b && --n) {a++;b++;}
 163   return *a - *b;
 164 }
 165
 166 int
 167 mprotect (void *addr, size_t len, int prot)
 168 {
 169   return 0;
 170 }
 171
 172 void
 173 qswap (void *a, void *b, size_t size)
 174 {
 175   char *buf[8];
 176   memcpy (buf, a, size);
 177   memcpy (a, b, size);
 178   memcpy (b, buf, size);
 179 }
 180
 181 size_t
 182 qpart (void *base, size_t count, size_t size, int (*compare)(void const *, void const *))
 183 {
 184   void* p = base + count*size;
 185   size_t i = 0;
 186   for (size_t j = 0; j < count; j++)
 187     {
 188       if (compare (base+j*size, p) < 0)
 189         {
 190           qswap (base+i*size, base+j*size, size);
 191           i++;
 192         }
 193     }
 194   if (compare (base+count*size, base+i*size) < 0)
 195     qswap (base+i*size, base+count*size, size);
 196   return i;
 197 }
 198
 199 void
 200 qsort (void *base, size_t count, size_t size, int (*compare)(void const *, void const *))
 201 {
 202   if (count > 1)
 203     {
 204       int p = qpart (base, count-1, size, compare);
 205       qsort (base, p, size, compare);
 206       qsort (base+p*size, count-p, size, compare);
 207     }
 208 }
 209
 210 int
 211 remove (char const *file_name)
 212 {
 213   eputs ("remove stub\n");
 214   return 0;
 215 }
 216
 217 int
 218 sigaction (int signum, struct sigaction const *act, struct sigaction *oldact)
 219 {
 220   return 0;
 221 }
 222
 223 int
 224 sigemptyset (sigset_t *set)
 225 {
 226   return 0;
 227 }
 228
 229 int
 230 snprintf(char *str,  size_t size,  char const *format, ...)
 231 {
 232   va_list ap;
 233   va_start (ap, format);
 234   int r = vsprintf (str, format, ap);
 235   va_end (ap);
 236   return r;
 237 }
 238
 239 int
 240 sscanf (char const *str, const char *format, ...)
 241 {
 242   eputs ("sscanf stub\n");
 243   return 0;
 244 }
 245
 246 char *
 247 strcat (char *dest, char const *src)
 248 {
 249   char *p = strchr (dest, '\0');
 250   while (*src++) *p++ = *src++;
 251   *p = 0;
 252   return dest;
 253 }
 254
 255 char *
 256 strchr (char const *s, int c)
 257 {
 258   char const *p = s;
 259   while (*p || !c)
 260     {
 261       if (c == *p) return p;
 262       *p++;
 263     }
 264   return 0;
 265 }
 266
 267 char *
 268 strncpy (char *dest, char const *src, size_t length)
 269 {
 270   char *p = dest;
 271   while (*src && length--)
 272     *p++ = *src++;
 273   if (*src)
 274     length++;
 275   while (length--)
 276     *p++ = 0;
 277   return dest;
 278 }
 279
 280 char *
 281 strrchr (char const *s, int c)
 282 {
 283   int n = strlen (s);
 284   if (!n) return 0;
 285   char const *p = s + n - 1;
 286   while (*p || !c)
 287     {
 288       if (c == *p) return p;
 289       *p--;
 290     }
 291   return 0;
 292 }
 293
 294 char *
 295 strstr (char const *haystack, char const *needle)
 296 {
 297   eputs ("strstr stub\n");
 298   return 0;
 299 }
 300
 301 double
 302 strtod (char const *nptr, char **endptr)
 303 {
 304   eputs ("strtoul stub\n");
 305 }
 306
 307 float
 308 strtof (char const *nptr, char **endptr)
 309 {
 310   return strtod (nptr, endptr);
 311 }
 312
 313 long double
 314 strtold (char const *nptr, char **endptr)
 315 {
 316   return strtod (nptr, endptr);
 317 }
 318
 319 long
 320 strtol (char const *nptr, char **endptr, int base)
 321 {
 322   if (!strncmp (nptr, "0x", 2))
 323     {
 324       char const *p = nptr + 2;
 325       return abtoi (&p, 16);
 326     }
 327   return abtoi (&nptr, base);
 328 }
 329
 330 long long int
 331 strtoll (char const *nptr, char **endptr, int base)
 332 {
 333   eputs ("strtoll stub\n");
 334   return 0;
 335 }
 336
 337 unsigned long
 338 strtoul (char const *nptr, char **endptr, int base)
 339 {
 340   eputs ("strtoul stub\n");
 341   return 0;
 342 }
 343
 344 unsigned long long
 345 strtoull (char const *p, char **endptr, int base)
 346 {
 347   *endptr = p;
 348   return abtoi (endptr, base);
 349 }
 350
 351 time_t time (time_t *tloc)
 352 {
 353   return 0;
 354 }
 355
 356 int
 357 vsnprintf (char *str, size_t size, char const *format, va_list ap)
 358 {
 359   return vsprintf (str, format, ap);
 360 }
 361
 362 void *
 363 calloc (size_t nmemb, size_t size)
 364 {
 365   size_t count = nmemb * size;
 366   void *p = malloc (count);
 367   memset (p, 0, count);
 368   return p;
 369 }
 370
 371 int
 372 vfprintf (FILE* f, char const* format, va_list ap)
 373 {
 374   int fd = (int)f;
 375   char const *p = format;
 376   while (*p)
 377     if (*p != '%')
 378       fputc (*p++, fd);
 379     else
 380       {
 381         p++;
 382         char c = *p;
 383         switch (c)
 384           {
 385           case '%': {fputc (*p, fd); break;}
 386           case 'c': {char c; c = va_arg (ap, char); fputc (c, fd); break;}
 387           case 'd': {int d; d = va_arg (ap, int); fputs (itoa (d), fd); break;}
 388           case 's': {char *s; s = va_arg (ap, char *); fputs (s, fd); break;}
 389           default: {fputc (*p, fd); break;}
 390           }
 391         p++;
 392       }
 393   va_end (ap);
 394   return 0;
 395 }