libc: Solid-C совместимость (П3) + rename/isatty (П4); scanf-семейство

- <dos.h>: getdate/gettime/setdate/settime (структуры Turbo-C, обёртки
  над getdatetime), getdisk/setdisk (ESTEX $02/$01), absread/abswrite
  (BIOS $55/$56, rst 8 — номера найдены в solid-c DOS.ASM; сектор 0 =
  boot логического диска)
- scanf/fscanf/sscanf: своё C-ядро _scanf_core (%d %u %x %o %c %s,
  модификатор l, ширина, подавление '*', %%); в SDCC z80 scanf нет,
  asm solid-c не портируем из-за чужого ABI; 22 хост-теста ядра
- хвост П2: fdopen/freopen/fclosall/fgetpos/fsetpos поверх таблицы
  FILE; парсер режима и выдача слота вынесены в _file_mode/_file_slot
- rename() — ESTEX RENAME $10; isatty(fd) = fd <= 0 (tty только
  псевдо-fd 0/-1/-2: из CLI DSS манипуляторы идут с 1 — verified,
  fd 1 не резерв, под Flex Navigator его держит навигатор)
- errno.h: Solid-C имена ошибок (EZERO/EINVFNC/ENOFILE/...) как алиасы
- <sprinter_solid.h> — зонтичный заголовок для портирования;
  ltell/_setargv в sprinter_compat.h; div/ldiv — из SDCC (проверено)
- tests/solidt — smoke всех П3/П4 API, зелёный в MAME (вкл. absread
  boot-сектора с сигнатурой 55AA)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

libc/stdio/_scanf.h

@@ -0,0 +1,22 @@
+/*
+ * _scanf.h — внутреннее ядро scanf-семейства (НЕ публичный заголовок).
+ *
+ * Одно C-ядро на scanf/fscanf/sscanf; источник символов абстрагирован
+ * парой колбэков (ядру нужен putback максимум на 1 символ).
+ * Семантика — по Solid-C/ANSI: %d %u %x %o %c %s, модификатор l,
+ * ширина, подавление '*', %%, пробелы в формате = скип пробелов ввода.
+ */
+#ifndef _SCANF_INTERNAL_H
+#define _SCANF_INTERNAL_H
+
+#include <stdarg.h>
+
+/* Следующий символ источника или EOF. */
+typedef int  (*_sc_get)(void *ctx);
+/* Вернуть символ (гарантированно не EOF; максимум 1 подряд). */
+typedef void (*_sc_unget)(void *ctx, int c);
+
+int _scanf_core(_sc_get get, _sc_unget unget, void *ctx,
+                const char *fmt, va_list ap);
+
+#endif

libc/stdio/_scanf_core.c

@@ -0,0 +1,176 @@
+/*
+ * _scanf_core — ядро scanf-семейства (см. _scanf.h).
+ *
+ * Поддержано: %d (знак ±), %u, %x, %o, %c (ширина = число символов,
+ * по умолчанию 1, пробелы НЕ скипаются), %s (скип пробелов, до
+ * пробела/ширины, NUL добавляется), модификатор l (long), ширина,
+ * '*' — подавление присваивания, %% — литерал.  Пробельный символ в
+ * формате съедает любую цепочку пробелов ввода; прочие символы
+ * формата должны совпасть с вводом (иначе стоп).
+ *
+ * Возврат: число присвоенных полей; EOF, если ввод кончился до
+ * первого присваивания/совпадения (ANSI-семантика).
+ */
+
+#include <ctype.h>
+#include "_scanf.h"
+
+/* Цифра c в базе base или -1. */
+static signed char digit_val(int c, unsigned char base)
+{
+    unsigned char v;
+    if (c >= '0' && c <= '9')      v = (unsigned char)(c - '0');
+    else if (c >= 'a' && c <= 'f') v = (unsigned char)(c - 'a' + 10);
+    else if (c >= 'A' && c <= 'F') v = (unsigned char)(c - 'A' + 10);
+    else return -1;
+    return v < base ? (signed char)v : -1;
+}
+
+/* Пропустить пробелы ввода; вернуть первый непробельный символ
+ * (или EOF), НЕ возвращая его в источник. */
+static int skip_ws(_sc_get get, void *ctx)
+{
+    int c;
+    do { c = get(ctx); } while (c != -1 && isspace(c));
+    return c;
+}
+
+int _scanf_core(_sc_get get, _sc_unget unget, void *ctx,
+                const char *fmt, va_list ap)
+{
+    int assigned = 0;
+    int touched  = 0;              /* было ли хоть одно чтение ввода */
+    int c;
+
+    for (; *fmt; fmt++) {
+        if (isspace((unsigned char)*fmt)) {
+            c = skip_ws(get, ctx);
+            if (c != -1) unget(ctx, c);
+            continue;
+        }
+        if (*fmt != '%') {
+            /* Литерал формата должен совпасть с вводом. */
+            c = get(ctx);
+            touched = 1;
+            if (c != (unsigned char)*fmt) {
+                if (c != -1) { unget(ctx, c); goto out; }
+                goto out_eof;
+            }
+            continue;
+        }
+
+        /* ---- %-конверсия ---- */
+        fmt++;
+        if (*fmt == '%') {
+            c = get(ctx);
+            touched = 1;
+            if (c != '%') {
+                if (c != -1) { unget(ctx, c); goto out; }
+                goto out_eof;
+            }
+            continue;
+        }
+
+        unsigned char suppress = 0;
+        if (*fmt == '*') { suppress = 1; fmt++; }
+
+        unsigned width = 0;
+        while (*fmt >= '0' && *fmt <= '9') {
+            width = width * 10 + (unsigned)(*fmt - '0');
+            fmt++;
+        }
+
+        unsigned char lng = 0;
+        if (*fmt == 'l') { lng = 1; fmt++; }
+
+        switch (*fmt) {
+
+        case 'c': {
+            unsigned w = width ? width : 1;
+            char *dst = suppress ? 0 : va_arg(ap, char *);
+            while (w--) {
+                c = get(ctx);
+                touched = 1;
+                if (c == -1) {
+                    if (!assigned) goto out_eof;
+                    goto out;
+                }
+                if (dst) *dst++ = (char)c;
+            }
+            if (!suppress) assigned++;
+            break;
+        }
+
+        case 's': {
+            char *dst = suppress ? 0 : va_arg(ap, char *);
+            unsigned w = width ? width : 0xFFFF;
+            c = skip_ws(get, ctx);
+            touched = 1;
+            if (c == -1) {
+                if (!assigned) goto out_eof;
+                goto out;
+            }
+            unsigned n = 0;
+            while (c != -1 && !isspace(c) && n < w) {
+                if (dst) dst[n] = (char)c;
+                n++;
+                c = get(ctx);
+            }
+            if (c != -1) unget(ctx, c);
+            if (n == 0) goto out;
+            if (dst) { dst[n] = '\0'; assigned++; }
+            break;
+        }
+
+        case 'd': case 'u': case 'x': case 'o': {
+            unsigned char base = 10;
+            if (*fmt == 'x') base = 16;
+            else if (*fmt == 'o') base = 8;
+
+            unsigned w = width ? width : 0xFFFF;
+            unsigned char neg = 0;
+            unsigned long val = 0;
+            unsigned ndig = 0;
+
+            c = skip_ws(get, ctx);
+            touched = 1;
+            if (c == -1) {
+                if (!assigned) goto out_eof;
+                goto out;
+            }
+            if (*fmt == 'd' && (c == '-' || c == '+') && w) {
+                neg = (c == '-');
+                w--;
+                c = get(ctx);
+            }
+            while (c != -1 && w) {
+                signed char d = digit_val(c, base);
+                if (d < 0) break;
+                val = val * base + (unsigned char)d;
+                ndig++;
+                w--;
+                c = get(ctx);
+            }
+            if (c != -1) unget(ctx, c);
+            if (ndig == 0) goto out;      /* цифр не было — стоп */
+            if (neg) val = (unsigned long)(-(long)val);
+            if (!suppress) {
+                if (lng) *va_arg(ap, long *) = (long)val;
+                else     *va_arg(ap, int  *) = (int)val;
+                assigned++;
+            }
+            break;
+        }
+
+        default:
+            /* Незнакомая конверсия — прекратить разбор. */
+            goto out;
+        }
+    }
+
+out:
+    return assigned;
+out_eof:
+    /* Ввод кончился до первого присвоенного поля. */
+    return (assigned == 0 && touched) ? -1 : assigned;
+}

libc/stdio/sscanf.c

@@ -0,0 +1,32 @@
+/*
+ * sscanf — форматированный разбор строки; ядро — _scanf_core,
+ * источник — движущийся указатель по ASCIIZ-строке.
+ */
+
+#include <stdarg.h>
+#include "_scanf.h"
+
+static const char *ss_p;
+
+static int ss_get(void *ctx)
+{
+    (void)ctx;
+    if (!*ss_p) return -1;
+    return (unsigned char)*ss_p++;
+}
+
+static void ss_unget(void *ctx, int c)
+{
+    (void)ctx; (void)c;
+    ss_p--;
+}
+
+int sscanf(const char *s, const char *fmt, ...)
+{
+    ss_p = s;
+    va_list ap;
+    va_start(ap, fmt);
+    int r = _scanf_core(ss_get, ss_unget, 0, fmt, ap);
+    va_end(ap);
+    return r;
+}