boot2

libc.c (24406B)

---

 /* libc.c — slim libc closure for tcc-boot2.
  *
  * What's here: just enough libc for tcc.flat.c, the cc-libc tests, and
  * the boot4 hello smoke binary to link. Started from mes-libc 0.24.
  *
  * Provides:
  *   syscalls      _read _write _open3 close lseek brk unlink _exit
  *                 raise abort environ getenv __libc_init
  *                 ENOSYS stubs: access execve execvp fsync rmdir stat strtod
  *   I/O           stdin/stdout/stderr (FILE *), FILE = long alias for fd
  *                 fopen fdopen fclose fflush fseek ftell remove
  *                 fread fwrite fputs fputc fgetc puts strdup
  *                 fprintf printf snprintf sprintf
  *                 vfprintf vsnprintf vprintf vsprintf
  *   stdlib        malloc free realloc qsort exit atoi
  *                 strtol strtoul strtoll strtoull strtof
  *   string        strlen strcmp strcpy strncmp strncpy strchr strrchr
  *                 strstr strcat strdup memmem
  *   ctype         isdigit islower isnumber isspace isxdigit toupper
  *   assertions    __assert_fail
  *
  * External: memcpy memmove memset memcmp come from libp1pp / cc/mem.c.
  *           sys_read sys_write sys_open sys_close sys_lseek sys_brk
  *           sys_unlink sys_exit are P1pp.P1pp labels.
  *
  * Order constraints:
  *   1. The syscall + FILE-globals block has to come first — globals
  *      (errno, stdin/stdout/stderr, __brk, __FILEDES_MAX-sized arrays)
  *      are referenced by everything below.
  *   2. malloc must precede the file-IO helpers because __read_cache is
  *      lazy-malloc'd on first read.
  *
  * License: GPLv3+ (mes upstream); see LICENSE.
  */
 
 #include <fcntl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #define __FILEDES_MAX 4096
 
 /* ───────── globals ───────────────────────────────────────────────── */
 
 /* Our sysinclude stdio.h declares stdin/stdout/stderr as extern FILE*
    (not macros). The #undefs below are no-ops kept for compatibility. */
 #undef stdin
 #undef stdout
 #undef stderr
 FILE *stdin  = (FILE *) 0;
 FILE *stdout = (FILE *) 1;
 FILE *stderr = (FILE *) 2;
 
 int errno;
 char *__brk = 0;
 char **environ;
 
 
 /* ───────── P1pp syscall labels and thin wrappers ─────────────────── */
 
 /* forward decl: defined in the stdio block, but _open3/close need it. */
 static size_t read_cache_clear_ (int fd);
 
 extern long sys_read   (long fd, long buf, long n);
 extern long sys_write  (long fd, long buf, long n);
 extern long sys_open   (long path, long flags, long mode);
 extern long sys_close  (long fd);
 extern long sys_lseek  (long fd, long off, long whence);
 extern long sys_brk    (long addr);
 extern long sys_unlink (long path);
 extern long sys_exit   (long code);
 
 ssize_t
 _read (int fd, void *buf, size_t n)
 {
   return sys_read (fd, (long) buf, (long) n);
 }
 
 ssize_t
 _write (int fd, void const *buf, size_t n)
 {
   return sys_write (fd, (long) buf, (long) n);
 }
 
 int
 _open3 (char const *path, int flags, int mode)
 {
   long r = sys_open ((long) path, flags, mode);
   if (r >= __FILEDES_MAX) {
     errno = EMFILE;
     return -1;
   }
   /* fd numbers are kernel-recycled; if we hand out a fd whose previous
      life left bytes in the per-fd read buffer, the next read on the
      new file picks them up and tcc_object_type sees a corrupted ELF
      header. Mes's _open3 clears the cache for the same reason. */
   if (r > 2)
     read_cache_clear_ (r);
   return (int) r;
 }
 
 int
 close (int fd)
 {
   long r = sys_close (fd);
   if (r < 0) {
     errno = -r;
     return -1;
   }
   errno = 0;
   return (int) r;
 }
 
 /* mes's lseek drains a per-fd read buffer before letting the kernel
    see the seek; we replicate that in fseek directly (it owns the
    buffer state), so this layer is just the raw syscall. */
 off_t
 _lseek (int fd, off_t off, int whence)
 {
   return sys_lseek (fd, off, whence);
 }
 
 long
 brk (void *addr)
 {
   return sys_brk ((long) addr);
 }
 
 int
 unlink (char const *path)
 {
   long r = sys_unlink ((long) path);
   if (r < 0) {
     errno = -r;
     return -1;
   }
   errno = 0;
   return 0;
 }
 
 void
 _exit (int status)
 {
   sys_exit (status);
 }
 
 /* abort() (mes's version) calls raise(SIGABRT). We don't ship signals
    so just exit; tcc's tcc_error path goes here on hard failures. */
 int
 raise (int sig)
 {
   sys_exit (128 + sig);
   return -1;
 }
 
 void
 abort (void)
 {
   sys_exit (128 + 6);
 }
 
 void
 __libc_init (int argc, char **argv)
 {
   /* Linux exec entry stack: argc, argv[0..argc-1], NULL, envp[..], NULL.
      :_start passes (argc, argv); environ follows argv's NULL.
      Without it, getenv() dereferences NULL on first call. */
   char **p;
   (void) argc;
   p = argv;
   while (*p)
     p++;
   environ = p + 1;
 }
 
 /* Stubs for libc-internal references not exercised by the tcc-boot2
    golden path (fread/fopen/etc. include <sys/stat.h>; the closure
    we pull in references these). If any surfaces in a real workload,
    replace with a P1pp label + thin wrapper. */
 char *
 _getcwd (char *buf, size_t size)
 {
   (void) buf; (void) size; errno = ENOSYS; return 0;
 }
 
 int
 access (char const *path, int mode)
 {
   (void) path; (void) mode; errno = ENOSYS; return -1;
 }
 
 int
 execve (char const *path, char *const argv[], char *const envp[])
 {
   (void) path; (void) argv; (void) envp; errno = ENOSYS; return -1;
 }
 
 int
 execvp (char const *file, char *const argv[])
 {
   (void) file; (void) argv; errno = ENOSYS; return -1;
 }
 
 int
 fsync (int fd)
 {
   (void) fd; return 0;
 }
 
 int
 rmdir (char const *path)
 {
   (void) path; errno = ENOSYS; return -1;
 }
 
 int
 stat (char const *path, struct stat *buf)
 {
   (void) path; (void) buf; errno = ENOSYS; return -1;
 }
 
 double
 strtod (char const *s, char **tail)
 {
   /* tcc.flat.c never reaches strtod under our defines (HAVE_FLOAT off);
      stdlib/strtof.c only forwards. cc.scm rejects FP literals, so we
      cast a zero int — same numeric value, no `0.0` token. */
   if (tail)
     *tail = (char *) s;
   return (double) 0;
 }
 
 
 /* ───────── ctype ────────────────────────────────────────────────── */
 
 int isdigit  (int c) { return c >= '0' && c <= '9'; }
 int islower  (int c) { return c >= 'a' && c <= 'z'; }
 int isspace  (int c) { return c == ' ' || (c >= '\t' && c <= '\r'); }
 int isxdigit (int c) { return isdigit (c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); }
 int toupper  (int c) { return islower (c) ? c - 'a' + 'A' : c; }
 
 int
 isnumber (int c, int base)
 {
   if (base <= 10)
     return c >= '0' && c < '0' + base;
   return isdigit (c)
     || (c >= 'a' && c < 'a' + base - 10)
     || (c >= 'A' && c < 'A' + base - 10);
 }
 
 
 /* ───────── string ───────────────────────────────────────────────── */
 
 size_t
 strlen (char const *s)
 {
   size_t n = 0;
   while (s[n])
     n++;
   return n;
 }
 
 int
 strcmp (char const *a, char const *b)
 {
   while (*a && *a == *b) { a++; b++; }
   return *(unsigned char *) a - *(unsigned char *) b;
 }
 
 int
 strncmp (char const *a, char const *b, size_t n)
 {
   while (n && *a && *a == *b) { a++; b++; n--; }
   if (!n) return 0;
   return *(unsigned char *) a - *(unsigned char *) b;
 }
 
 char *
 strcpy (char *dst, char const *src)
 {
   char *r = dst;
   while ((*dst++ = *src++)) ;
   return r;
 }
 
 char *
 strncpy (char *dst, char const *src, size_t n)
 {
   char *r = dst;
   while (n && (*dst++ = *src++)) n--;
   while (n--) *dst++ = 0;
   return r;
 }
 
 char *
 strcat (char *dst, char const *src)
 {
   char *r = dst;
   while (*dst) dst++;
   while ((*dst++ = *src++)) ;
   return r;
 }
 
 char *
 strchr (char const *s, int c)
 {
   for (; *s; s++)
     if (*s == (char) c)
       return (char *) s;
   return c ? 0 : (char *) s;
 }
 
 char *
 strrchr (char const *s, int c)
 {
   char const *last = 0;
   for (; *s; s++)
     if (*s == (char) c)
       last = s;
   if (!c) return (char *) s;
   return (char *) last;
 }
 
 char *
 strstr (char const *hay, char const *needle)
 {
   size_t n = strlen (needle);
   if (!n) return (char *) hay;
   for (; *hay; hay++)
     if (!strncmp (hay, needle, n))
       return (char *) hay;
   return 0;
 }
 
 void *
 memmem (void const *hay, int haylen, void const *needle, int needlelen)
 {
   char const *h = hay;
   char const *n = needle;
   int i;
   if (needlelen <= 0) return (void *) hay;
   if (needlelen > haylen) return 0;
   for (i = 0; i + needlelen <= haylen; i++) {
     int j = 0;
     while (j < needlelen && h[i + j] == n[j])
       j++;
     if (j == needlelen)
       return (char *) h + i;
   }
   return 0;
 }
 
 char *
 strdup (char const *s)
 {
   size_t n = strlen (s) + 1;
   char *p = malloc (n);
   if (p) memcpy (p, s, n);
   return p;
 }
 
 
 /* ───────── malloc — bump allocator on top of brk ─────────────────── */
 
 void *
 malloc (size_t size)
 {
   long want;
   char *p;
   if (!__brk)
     __brk = (char *) brk (0);
   /* 16-byte align — matches the largest scalar (long long / pointer / double). */
   __brk = (char *) (((uintptr_t) __brk + 16 - 1) & -16);
   /* Linux brk(2) returns the (unchanged) break on failure rather than
      -1, so compare against the requested address — a refused growth
      surfaces here as malloc returning NULL. */
   want = (long) (__brk + size);
   if (brk (__brk + size) < want)
     return 0;
   p = __brk;
   __brk += size;
   return p;
 }
 
 void
 free (void *p)
 {
   (void) p; /* bump allocator; reclamation is not implemented. */
 }
 
 void *
 realloc (void *p, size_t size)
 {
   void *q = malloc (size);
   if (p && q)
     memcpy (q, p, size);
   return q;
 }
 
 
 /* ───────── stdlib: integer parsing and exit ──────────────────────── */
 
 /* Internal parser shared by atoi / strtol / strtoul / strtoull and the
    width/precision parser inside vformat_. `long long` accumulator so
    values that don't fit in 32-bit signed don't sign-extend through the
    parse — tcc3 needs this for `-Wl,-Ttext=0x80200000` and the like. */
 static long long
 parse_int_ (char const **p, int base)
 {
   char const *s = *p;
   long long n = 0;
   int neg = 0;
   if (base == 0) base = 10;
   while (isspace (*s)) s++;
   if (*s == '+') s++;
   else if (*s == '-') { neg = 1; s++; }
   while (isnumber (*s, base)) {
     int d;
     if      (*s >= 'a') d = *s - 'a' + 10;
     else if (*s >= 'A') d = *s - 'A' + 10;
     else                d = *s - '0';
     n = n * base + d;
     s++;
   }
   *p = s;
   return neg ? -n : n;
 }
 
 int
 atoi (char const *s)
 {
   return (int) parse_int_ (&s, 10);
 }
 
 long
 strtol (char const *s, char **tail, int base)
 {
   char const *p;
   long r;
   if (!strncmp (s, "0x", 2)) { s += 2; base = 16; }
   p = s;
   r = (long) parse_int_ (&p, base);
   if (tail) *tail = (char *) p;
   return r;
 }
 
 unsigned long      strtoul  (char const *s, char **tail, int base) { return strtol (s, tail, base); }
 long long          strtoll  (char const *s, char **tail, int base) { return strtol (s, tail, base); }
 unsigned long long strtoull (char const *s, char **tail, int base) { return strtol (s, tail, base); }
 float              strtof   (char const *s, char **tail)           { return strtod (s, tail); }
 
 void (*__call_at_exit) (void);
 
 void
 exit (int status)
 {
   if (__call_at_exit)
     __call_at_exit ();
   _exit (status);
   /* not reached */
   while (1) ;
 }
 
 /* qsort: lifted from mes — straightforward Lomuto-partition recursion. */
 static void
 qswap_ (char *a, char *b, size_t size)
 {
   do {
     char t = *a;
     *a++ = *b;
     *b++ = t;
   } while (--size);
 }
 
 static size_t
 qpart_ (char *base, size_t count, size_t size, int (*cmp) (void *, void *))
 {
   char *pivot = base + count * size;
   size_t i = 0;
   size_t j;
   int c;
   for (j = 0; j < count; j++) {
     c = cmp (base + j * size, pivot);
     if (c < 0) {
       qswap_ (base + i * size, base + j * size, size);
       i++;
     } else if (c == 0) {
       i++;
     }
   }
   if (cmp (pivot, base + i * size) < 0)
     qswap_ (base + i * size, pivot, size);
   return i;
 }
 
 void
 qsort (void *base, size_t count, size_t size, int (*cmp) (void *, void *))
 {
   size_t p;
   if (count > 1) {
     p = qpart_ (base, count - 1, size, cmp);
     qsort (base, p, size, cmp);
     qsort ((char *) base + p * size, count - p, size, cmp);
   }
 }
 
 
 /* ───────── getenv ────────────────────────────────────────────────── */
 
 char *
 getenv (char const *name)
 {
   size_t n = strlen (name);
   char **p;
   for (p = environ; p && *p; p++) {
     if (!strncmp (*p, name, n) && (*p)[n] == '=')
       return *p + n + 1;
   }
   return 0;
 }
 
 
 /* ───────── stdio: FILE * = (long) fd ─────────────────────────────── */
 
 /* Block-buffered read, per fd. Without it, tcc lexing tcc.flat.c does
    ~500K single-byte syscalls; with a 128-byte cache it's ~4K. */
 #define READ_BUFFER_MAX 128
 
 struct read_buffer {
   ssize_t size;
   char    bytes[READ_BUFFER_MAX];
 };
 static struct read_buffer *read_cache;
 
 static void
 read_cache_init_ (void)
 {
   if (!read_cache)
     read_cache = malloc (sizeof (struct read_buffer) * __FILEDES_MAX);
 }
 
 /* Returns how many buffered bytes were dropped — fseek/lseek need that
    to back out the unconsumed portion. */
 static size_t
 read_cache_clear_ (int fd)
 {
   size_t n;
   read_cache_init_ ();
   n = read_cache[fd].size;
   read_cache[fd].size = 0;
   return n;
 }
 
 static ssize_t
 read_buffered_ (int fd, void *buf, size_t size)
 {
   struct read_buffer *c;
   char *p = buf;
   size_t todo = size;
   read_cache_init_ ();
   c = &read_cache[fd];
   if (!c->size && size > READ_BUFFER_MAX)
     return _read (fd, buf, size);
   while (c->size > 0 && todo) {
     todo--;
     *p++ = c->bytes[READ_BUFFER_MAX - c->size--];
   }
   if (todo) {
     ssize_t got;
     if (todo > READ_BUFFER_MAX)
       return size - todo + _read (fd, p, todo);
     got = _read (fd, c->bytes, READ_BUFFER_MAX);
     if (got < 0) return -1;
     if (got > 0) {
       c->size = got;
       if (got < READ_BUFFER_MAX)
         memmove (c->bytes + READ_BUFFER_MAX - got, c->bytes, got);
       return size - todo + read_buffered_ (fd, p, todo);
     }
   }
   return size - todo;
 }
 
 ssize_t
 read (int fd, void *buf, size_t size)
 {
   return read_buffered_ (fd, buf, size);
 }
 
 ssize_t
 write (int fd, void const *buf, size_t size)
 {
   size_t skip = read_cache_clear_ (fd);
   ssize_t r;
   if (skip)
     sys_lseek (fd, -(long) skip, SEEK_CUR);
   r = _write (fd, buf, size);
   if (r < 0) {
     errno = -r;
     return -1;
   }
   errno = 0;
   return r;
 }
 
 off_t
 lseek (int fd, off_t off, int whence)
 {
   size_t skip = read_cache_clear_ (fd);
   if (whence == SEEK_CUR)
     off -= skip;
   return sys_lseek (fd, off, whence);
 }
 
 int
 open (char const *path, int flags, ...)
 {
   int mode = 0;
   if (flags & O_CREAT) {
     va_list ap;
     va_start (ap, flags);
     mode = va_arg (ap, int);
     va_end (ap);
   }
   return _open3 (path, flags, mode);
 }
 
 FILE *
 fopen (char const *path, char const *opentype)
 {
   int fd;
   int mode = 0600;
   if ((opentype[0] == 'a' || !strcmp (opentype, "r+")) && !access (path, O_RDONLY)) {
     int flags = O_RDWR;
     if (opentype[0] == 'a') flags |= O_APPEND;
     fd = _open3 (path, flags, mode);
   } else if (opentype[0] == 'w' || opentype[0] == 'a' || !strcmp (opentype, "r+")) {
     int flags = strchr (opentype, '+') ? O_RDWR | O_CREAT : O_WRONLY | O_CREAT | O_TRUNC;
     fd = _open3 (path, flags, mode);
   } else {
     fd = _open3 (path, O_RDONLY, 0);
   }
   if (fd < 0) fd = 0;
   return (FILE *) (long) fd;
 }
 
 FILE *fdopen (int fd, char const *mode) { (void) mode; return (FILE *) (long) fd; }
 
 int fclose (FILE * f)                          { return close ((long) f); }
 int fflush (FILE * f)                          { int fd = (long) f; return fd < 3 ? 0 : fsync (fd); }
 
 long ftell (FILE * f)                          { return lseek ((long) f, 0, SEEK_CUR); }
 
 int
 fseek (FILE * f, long off, int whence)
 {
   return lseek ((long) f, off, whence) >= 0 ? 0 : -1;
 }
 
 int
 fgetc (FILE * f)
 {
   unsigned char c;
   if (read_buffered_ ((long) f, &c, 1) != 1)
     return -1;
   return c;
 }
 
 size_t
 fread (void *data, size_t size, size_t count, FILE * f)
 {
   ssize_t got;
   if (!size || !count) return 0;
   got = read_buffered_ ((long) f, data, size * count);
   return got > 0 ? got / size : 0;
 }
 
 size_t
 fwrite (void const *data, size_t size, size_t count, FILE * f)
 {
   ssize_t put;
   if (!size || !count) return 0;
   put = write ((long) f, data, size * count);
   return put > 0 ? put / size : 0;
 }
 
 int
 fputc (int c, FILE * f)
 {
   unsigned char b = c;
   return write ((long) f, &b, 1) == 1 ? c : -1;
 }
 
 int
 fputs (char const *s, FILE * f)
 {
   size_t n = strlen (s);
   return (size_t) write ((long) f, s, n) == n ? (int) n : -1;
 }
 
 int
 puts (char const *s)
 {
   if (fputs (s, stdout) < 0) return -1;
   return fputc ('\n', stdout);
 }
 
 int
 remove (char const *path)
 {
   return unlink (path);
 }
 
 
 /* ───────── printf family ─────────────────────────────────────────── */
 
 /* One sink type for both fd-backed (fprintf/printf) and buffer-backed
    (snprintf/sprintf) output. emit_() drops bytes once a buffer sink
    is full; vsnprintf still has to count them so the C99 return value
    (bytes that would have been written) is correct. */
 struct sink {
   int    fd;       /* -1 if buffer sink */
   char  *buf;
   size_t cap;      /* SIZE_MAX for unbounded sprintf */
   size_t len;      /* bytes counted (may exceed cap) */
 };
 
 static void
 emit_ (struct sink *s, char c)
 {
   if (s->fd >= 0) {
     sys_write (s->fd, (long) &c, 1);
   } else if (s->len < s->cap) {
     s->buf[s->len] = c;
   }
   s->len++;
 }
 
 static void
 emit_str_ (struct sink *s, char const *p, size_t n)
 {
   while (n--) emit_ (s, *p++);
 }
 
 /* unsigned 64-bit → ASCII into `out` (at least 24 bytes). Returns
    pointer to first character; signed prefix is added by caller. */
 static char *
 utoa_ (unsigned long long u, unsigned base, char *out)
 {
   char *p = out + 23;
   *p = 0;
   do {
     unsigned d = u % base;
     u /= base;
     *--p = d > 9 ? 'a' + d - 10 : '0' + d;
   } while (u);
   return p;
 }
 
 static int
 vformat_ (struct sink *s, char const *fmt, va_list ap)
 {
   size_t start = s->len;
   while (*fmt) {
     int  left, long_p, precision, width;
     char pad;
     char c;
     char nbuf[24];
     char const *body;
     size_t bodylen;
     char sign;
 
     if (*fmt != '%') { emit_ (s, *fmt++); continue; }
     fmt++;
 
     left = 0; long_p = 0; precision = -1; width = -1;
     pad = ' ';
     body = 0;
     bodylen = 0;
     sign = 0;
 
     if (*fmt == '-') { left = 1; fmt++; }
     if (*fmt == ' ') { pad  = ' '; fmt++; }
     if (*fmt == '0') { pad  = '0'; fmt++; }
     if (*fmt >= '0' && *fmt <= '9') {
       width = (int) parse_int_ (&fmt, 10);
     } else if (*fmt == '*') {
       width = va_arg (ap, int);
       fmt++;
     }
     if (*fmt == '.') {
       fmt++;
       if (*fmt >= '0' && *fmt <= '9') {
         precision = (int) parse_int_ (&fmt, 10);
       } else if (*fmt == '*') {
         precision = va_arg (ap, int);
         fmt++;
       }
     }
     /* `l` length modifier; LP64 → ll == l, so collapse. Tracking it
        matters: amd64 SysV spills an `int` arg into the low 32 bits of
        an 8-byte slot, leaving the upper bits unspecified. va_arg(long)
        on a `%d` would then leak garbage. */
     if (*fmt == 'l') { long_p = 1; fmt++; }
     if (*fmt == 'l') fmt++;
 
     c = *fmt;
 
     switch (c) {
     case '%': emit_ (s, '%'); break;
     case 'c': emit_ (s, (char) va_arg (ap, int)); break;
 
     case 's': {
       body = va_arg (ap, char const *);
       if (!body) body = "(null)";
       bodylen = strlen (body);
       if (precision >= 0 && (size_t) precision < bodylen)
         bodylen = precision;
       goto pad_emit;
     }
 
     case 'd': case 'i': {
       long long v = long_p ? va_arg (ap, long long) : (long long) va_arg (ap, int);
       unsigned long long u = v < 0 ? -(unsigned long long) v : (unsigned long long) v;
       if (v < 0) sign = '-';
       body = utoa_ (u, 10, nbuf);
       bodylen = strlen (body);
       goto numeric_emit;
     }
 
     case 'u': case 'o': case 'x': case 'X': case 'p': {
       unsigned long long u;
       unsigned base = c == 'o' ? 8 : (c == 'x' || c == 'X' || c == 'p') ? 16 : 10;
       if (c == 'p') {
         u = (unsigned long long) (uintptr_t) va_arg (ap, void *);
         long_p = 1;
       } else if (long_p) {
         u = (unsigned long long) va_arg (ap, unsigned long long);
       } else {
         u = (unsigned long long) va_arg (ap, unsigned int);
       }
       body = utoa_ (u, base, nbuf);
       bodylen = strlen (body);
       if (c == 'X') {
         char *t;
         for (t = (char *) body; *t; t++)
           *t = toupper (*t);
       }
       goto numeric_emit;
     }
 
     default:
       /* Unsupported specifier — emit %X for diagnostics. tcc's only
          use of an exotic specifier is %p in an unreachable error
          path. */
       emit_ (s, '%');
       emit_ (s, c);
       break;
     }
     fmt++;
     continue;
 
   numeric_emit: {
       int total = (sign ? 1 : 0) + (int) bodylen;
       int npad;
       int zpad;
       if (precision < 0) precision = (int) bodylen;
       npad = width > total ? width - (precision > (int) bodylen ? precision : total) : 0;
       zpad = precision > (int) bodylen ? precision - (int) bodylen : 0;
       if (!left && pad == ' ') {
         while (npad-- > 0) emit_ (s, ' ');
       }
       if (sign) emit_ (s, sign);
       if (!left && pad == '0') {
         while (npad-- > 0) emit_ (s, '0');
       }
       while (zpad-- > 0) emit_ (s, '0');
       emit_str_ (s, body, bodylen);
       while (left && npad-- > 0) emit_ (s, ' ');
       fmt++;
       continue;
     }
 
   pad_emit: {
       int npad = width > (int) bodylen ? width - (int) bodylen : 0;
       if (!left) while (npad-- > 0) emit_ (s, pad);
       emit_str_ (s, body, bodylen);
       if (left) while (npad-- > 0) emit_ (s, pad);
       fmt++;
       continue;
     }
   }
   if (s->fd < 0 && s->len < s->cap)
     s->buf[s->len] = 0;
   else if (s->fd < 0 && s->cap)
     s->buf[s->cap - 1] = 0;
   return (int) (s->len - start);
 }
 
 int
 vfprintf (FILE * f, char const *fmt, va_list ap)
 {
   struct sink s = { .fd = (int) (long) f, .buf = 0, .cap = 0, .len = 0 };
   return vformat_ (&s, fmt, ap);
 }
 
 int
 vprintf (char const *fmt, va_list ap)
 {
   return vfprintf (stdout, fmt, ap);
 }
 
 int
 vsnprintf (char *str, size_t size, char const *fmt, va_list ap)
 {
   struct sink s = { .fd = -1, .buf = str, .cap = size, .len = 0 };
   return vformat_ (&s, fmt, ap);
 }
 
 int
 vsprintf (char *str, char const *fmt, va_list ap)
 {
   return vsnprintf (str, (size_t) -1, fmt, ap);
 }
 
 int
 fprintf (FILE * f, char const *fmt, ...)
 {
   va_list ap;
   int r;
   va_start (ap, fmt);
   r = vfprintf (f, fmt, ap);
   va_end (ap);
   return r;
 }
 
 int
 printf (char const *fmt, ...)
 {
   va_list ap;
   int r;
   va_start (ap, fmt);
   r = vfprintf (stdout, fmt, ap);
   va_end (ap);
   return r;
 }
 
 int
 snprintf (char *str, size_t size, char const *fmt, ...)
 {
   va_list ap;
   int r;
   va_start (ap, fmt);
   r = vsnprintf (str, size, fmt, ap);
   va_end (ap);
   return r;
 }
 
 int
 sprintf (char *str, char const *fmt, ...)
 {
   va_list ap;
   int r;
   va_start (ap, fmt);
   r = vsprintf (str, fmt, ap);
   va_end (ap);
   return r;
 }
 
 
 /* ───────── assertions ────────────────────────────────────────────── */
 
 void
 __assert_fail (char const *msg, char const *file, unsigned line, char const *func)
 {
   fprintf (stderr, "%s:%u:", file, line);
   if (func) fprintf (stderr, "%s:", func);
   fprintf (stderr, "assert fail: %s\n", msg);
   exit (1);
 }
 
 /* mes/lib.h declares assert_msg as the no-include-needed assert form
    used inside libc. Provide a body here so anything still calling it
    (e.g. mes-style builtins under cc.scm) links. */
 void
 assert_msg (int check, char *msg)
 {
   if (!check) {
     fputs (msg, stderr);
     exit (1);
   }
 }