M2compiler-V3/runtime/syslib/shim.c

/* m2compiler-V3 runtime shim (C).
 *
 * Bridges Modula-2 external procedures to the host. Memory layout
 * matches the compiler's: a STRING (ARRAY OF CHAR) value is a
 * descriptor [0] = LONGCARD element count, then the bytes; the
 * compiler passes the descriptor's address as an `l`.
 *
 * Linked with every V3 program image.
 */

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/* Write the contents of a string descriptor to fd 1. Returns the
   number of bytes written. */
long m2write(long *desc)
{
    long n = desc[0];
    if (n > 0)
        write(1, (char *)(desc + 1), (size_t)n);
    return n;
}

/* Write a newline to fd 1. */
long m2writeln(void)
{
    write(1, "\n", 1);
    return 0;
}

/* Read one character from stdin (0 at EOF). */
long m2readchar(void)
{
    int c = getchar();
    return (c == EOF) ? 0 : c;
}

/* Read a signed decimal integer from stdin, skipping leading
   whitespace. The first non-digit after the number is consumed. */
long m2readint(void)
{
    long v = 0;
    int c;
    int neg = 0;

    do { c = getchar(); } while (c == ' ' || c == '\t' ||
                                 c == '\n' || c == '\r');
    if (c == '-') { neg = 1; c = getchar(); }
    while (c >= '0' && c <= '9') {
        v = v * 10 + (c - '0');
        c = getchar();
    }
    return neg ? -v : v;
}

/* ---------------- sequential files (stdio) ---------------- */

/* Copy a descriptor string into a NUL-terminated buffer. */
static void m2cstr(long *desc, char *buf, size_t cap)
{
    long n = desc[0];
    if ((size_t)n >= cap) n = (long)(cap - 1);
    if (n > 0) memcpy(buf, (char *)(desc + 1), (size_t)n);
    buf[n] = 0;
}

long m2fopenread(long *desc)
{
    char buf[4096];
    m2cstr(desc, buf, sizeof buf);
    return (long)fopen(buf, "r");
}

long m2fopenwrite(long *desc)
{
    char buf[4096];
    m2cstr(desc, buf, sizeof buf);
    return (long)fopen(buf, "w");
}

long m2fclose(long h)
{
    if (h != 0) fclose((FILE *)h);
    return 0;
}

/* A handle of 0 means the open failed (Modula-2 NIL). Every file
   operation degrades to a safe no-op instead of dereferencing NULL. */

long m2fgetc(long h)
{
    int c;
    if (h == 0) return 0;
    c = fgetc((FILE *)h);
    return (c == EOF) ? 0 : c;
}

long m2fputc(long h, long c)
{
    if (h != 0) fputc((int)c, (FILE *)h);
    return 0;
}

long m2fputs(long h, long *desc)
{
    long n = desc[0];
    if (h == 0) return 0;
    if (n > 0) fwrite((char *)(desc + 1), 1, (size_t)n, (FILE *)h);
    return n;
}

long m2freadint(long h)
{
    long v = 0;
    int c, neg = 0;
    if (h == 0) return 0;
    do { c = fgetc((FILE *)h); } while (c == ' ' || c == '\t' ||
                                        c == '\n' || c == '\r');
    if (c == '-') { neg = 1; c = fgetc((FILE *)h); }
    while (c >= '0' && c <= '9') {
        v = v * 10 + (c - '0');
        c = fgetc((FILE *)h);
    }
    return neg ? -v : v;
}

long m2fwriteint(long h, long v)
{
    char buf[32];
    int i = 0, neg = 0;
    unsigned long u;
    if (h == 0) return 0;
    if (v < 0) { neg = 1; u = (unsigned long)(-v); }
    else u = (unsigned long)v;
    do { buf[i++] = (char)('0' + u % 10); u /= 10; } while (u != 0);
    if (neg) buf[i++] = '-';
    while (i > 0) fputc(buf[--i], (FILE *)h);
    return 0;
}

long m2fwriteln(long h)
{
    if (h != 0) fputc('\n', (FILE *)h);
    return 0;
}

/* Bulk read: up to max bytes into the descriptor's data area; the
   descriptor's header is set to the number actually read. */
long m2fread(long h, long *desc, long max)
{
    long n;
    if (max < 0) max = 0;
    if (h == 0) { desc[0] = 0; return 0; }
    n = (long)fread((char *)(desc + 1), 1, (size_t)max, (FILE *)h);
    desc[0] = n;
    return n;
}

/* Write a signed integer right-justified in a field of width `wid`.
   wid = 0 means exactly one leading space (FileIO convention). */
long m2fwriteintw(long h, long v, long wid)
{
    char buf[64];
    int n;
    if (h == 0) return 0;
    if (wid == 0)
        n = snprintf(buf, sizeof buf, " %ld", v);
    else
        n = snprintf(buf, sizeof buf, "%*ld", (int)wid, v);
    if (n > 0) fwrite(buf, 1, (size_t)n, (FILE *)h);
    return 0;
}

/* Standard streams as file handles. */
long m2stdout(void) { return (long)stdout; }
long m2stderr(void) { return (long)stderr; }

/* Command-line arguments, read from /proc/self/cmdline (Linux). */
static char *m2_args[1024];
static long m2_nargs = -1;

static void m2_argv_init(void)
{
    static char cmd[65536];
    FILE *f;
    long i, n;
    int c;

    if (m2_nargs >= 0) return;
    m2_nargs = 0;
    f = fopen("/proc/self/cmdline", "rb");
    if (f == NULL) return;
    n = (long)fread(cmd, 1, sizeof cmd - 1, f);
    fclose(f);
    if (n <= 0) return;
    cmd[n] = 0;
    i = 0;
    while (i < n && m2_nargs < 1024) {
        while (i < n && cmd[i] == 0) i++;      /* skip separators */
        if (i >= n) break;
        m2_args[m2_nargs++] = &cmd[i];
        while (i < n && cmd[i] != 0) i++;      /* to end of arg */
    }
}

long m2argc(void)
{
    m2_argv_init();
    return m2_nargs;
}

long m2arg(long i, long *desc, long cap)
{
    const char *a;
    long n;

    m2_argv_init();
    if (i < 0 || i >= m2_nargs) { desc[0] = 0; return 0; }
    a = m2_args[i];
    n = (long)strlen(a);
    if (cap > 0 && n >= cap) n = cap - 1;
    if (n < 0) n = 0;
    memcpy((char *)(desc + 1), a, (size_t)n);
    desc[0] = n;
    return 1;
}

/* Set a string descriptor's logical length (header). */
long m2setlen(long *desc, long n)
{
    desc[0] = n;
    return n;
}

/* Write a single character (byte) to fd 1. */
long m2writechar(long c)
{
    char ch = (char)c;
    write(1, &ch, 1);
    return 0;
}

/* Write a signed decimal integer to fd 1. */
long m2writeint(long v)
{
    char buf[32];
    int i = 0;
    int neg = 0;
    unsigned long u;

    if (v < 0) { neg = 1; u = (unsigned long)(-v); }
    else u = (unsigned long)v;

    do { buf[i++] = (char)('0' + (u % 10)); u /= 10; } while (u != 0);
    if (neg) buf[i++] = '-';
    while (i > 0)
        write(1, &buf[--i], 1);
    return 0;
}

/* Terminate the process. */
long m2exit(long code)
{
    exit((int)code);
    return 0;
}