pyscriptc 0.1.0__py3-none-any.whl

pyscriptc/runtime/ps_argv.c

@@ -0,0 +1,28 @@
+/* sys.argv: the process argv materialized once as a list[str] (PsSeq of
+PsBuf). The emitted main hands argc/argv to ps_argv_init before running user
+code; sys.argv reads come back through ps_argv_get. */
+
+#include "ps_rt.h"
+
+#include <string.h>
+
+static PsSeq *ps_argv_seq;
+
+void ps_argv_init(int32_t argc, char **argv) {
+    PsSeq *seq = ps_seq_new((int64_t)sizeof(PsBuf), 0);
+    for (int32_t i = 0; i < argc; i++) {
+        PsBuf b;
+        b.len = (int64_t)strlen(argv[i]);
+        b.data = ps_alloc(b.len + 1);
+        memcpy(b.data, argv[i], (size_t)b.len + 1);
+        ps_seq_push(seq, &b);
+    }
+    ps_argv_seq = seq;
+}
+
+PsSeq *ps_argv_get(void) {
+    if (ps_argv_seq == NULL) {
+        ps_argv_seq = ps_seq_new((int64_t)sizeof(PsBuf), 0);
+    }
+    return ps_argv_seq;
+}

pyscriptc/runtime/ps_b64.c

@@ -0,0 +1,168 @@
+/* base64 and urlsafe base64. Padding is required. Characters outside the
+alphabet are ignored, matching CPython's default validate=False. binascii.Error
+is reported as ValueError. */
+
+#include "ps_rt.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static int ps_b64_val(unsigned char c, int *out) {
+    if (c >= 'A' && c <= 'Z') {
+        *out = c - 'A';
+        return 1;
+    }
+    if (c >= 'a' && c <= 'z') {
+        *out = c - 'a' + 26;
+        return 1;
+    }
+    if (c >= '0' && c <= '9') {
+        *out = c - '0' + 52;
+        return 1;
+    }
+    if (c == '+' || c == '-') {
+        *out = 62;
+        return 1;
+    }
+    if (c == '/' || c == '_') {
+        *out = 63;
+        return 1;
+    }
+    return 0;
+}
+
+static void ps_b64_encode(int64_t n, const char *p, int url, PsBuf *out) {
+    static const char kStd[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    static const char kUrl[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    const char *alpha = url ? kUrl : kStd;
+    if (n < 0) {
+        ps_raise_cstr(PS_VALUE, "base64 length is negative");
+    }
+    int64_t groups = (n + 2) / 3;
+    if (groups > INT64_MAX / 4) {
+        ps_raise_cstr(PS_OVERFLOW, "base64 result does not fit");
+    }
+    int64_t total = groups * 4;
+    char *q = malloc((size_t)total + 1);
+    if (q == NULL) {
+        abort();
+    }
+    int64_t w = 0;
+    int64_t i = 0;
+    while (i + 3 <= n) {
+        unsigned int v = ((unsigned char)p[i] << 16) | ((unsigned char)p[i + 1] << 8) | (unsigned char)p[i + 2];
+        q[w++] = alpha[(v >> 18) & 63];
+        q[w++] = alpha[(v >> 12) & 63];
+        q[w++] = alpha[(v >> 6) & 63];
+        q[w++] = alpha[v & 63];
+        i += 3;
+    }
+    if (i < n) {
+        unsigned int v = (unsigned char)p[i] << 16;
+        if (i + 1 < n) {
+            v |= (unsigned char)p[i + 1] << 8;
+        }
+        q[w++] = alpha[(v >> 18) & 63];
+        q[w++] = alpha[(v >> 12) & 63];
+        if (i + 1 < n) {
+            q[w++] = alpha[(v >> 6) & 63];
+            q[w++] = '=';
+        } else {
+            q[w++] = '=';
+            q[w++] = '=';
+        }
+    }
+    q[w] = '\0';
+    out->len = w;
+    out->data = q;
+}
+
+static void ps_b64_decode(int64_t n, const char *p, int url, PsBuf *out) {
+    char *filtered = malloc((size_t)n + 1);
+    if (filtered == NULL && n > 0) {
+        abort();
+    }
+    int64_t m = 0;
+    for (int64_t i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)p[i];
+        int dummy = 0;
+        if (c == '=') {
+            filtered[m++] = '=';
+            continue;
+        }
+        if (!ps_b64_val(c, &dummy)) {
+            continue;
+        }
+        if (!url && (c == '-' || c == '_')) {
+            continue;
+        }
+        filtered[m++] = (char)c;
+    }
+    if (m % 4 != 0) {
+        free(filtered);
+        ps_raise_cstr(PS_VALUE, "incorrect base64 padding");
+    }
+    int64_t pad = 0;
+    if (m >= 1 && filtered[m - 1] == '=') {
+        pad++;
+    }
+    if (m >= 2 && filtered[m - 2] == '=') {
+        pad++;
+    }
+    for (int64_t i = 0; i < m - pad; i++) {
+        if (filtered[i] == '=') {
+            free(filtered);
+            ps_raise_cstr(PS_VALUE, "incorrect base64 padding");
+        }
+    }
+    int64_t data_chars = m - pad;
+    if (data_chars % 4 == 1) {
+        free(filtered);
+        ps_raise_cstr(PS_VALUE, "incorrect base64 padding");
+    }
+    int64_t total = m == 0 ? 0 : (m / 4) * 3 - pad;
+    char *q = malloc((size_t)total + 1);
+    if (q == NULL) {
+        free(filtered);
+        abort();
+    }
+    int64_t w = 0;
+    for (int64_t i = 0; i < m; i += 4) {
+        int v0 = 0;
+        int v1 = 0;
+        int v2 = 0;
+        int v3 = 0;
+        if (!ps_b64_val((unsigned char)filtered[i], &v0) || !ps_b64_val((unsigned char)filtered[i + 1], &v1)) {
+            free(filtered);
+            free(q);
+            ps_raise_cstr(PS_VALUE, "incorrect base64 padding");
+        }
+        if (filtered[i + 2] != '=' && !ps_b64_val((unsigned char)filtered[i + 2], &v2)) {
+            free(filtered);
+            free(q);
+            ps_raise_cstr(PS_VALUE, "incorrect base64 padding");
+        }
+        if (filtered[i + 3] != '=' && !ps_b64_val((unsigned char)filtered[i + 3], &v3)) {
+            free(filtered);
+            free(q);
+            ps_raise_cstr(PS_VALUE, "incorrect base64 padding");
+        }
+        unsigned int v = ((unsigned int)v0 << 18) | ((unsigned int)v1 << 12) | ((unsigned int)v2 << 6) | (unsigned int)v3;
+        q[w++] = (char)((v >> 16) & 0xff);
+        if (filtered[i + 2] != '=') {
+            q[w++] = (char)((v >> 8) & 0xff);
+        }
+        if (filtered[i + 3] != '=') {
+            q[w++] = (char)(v & 0xff);
+        }
+    }
+    free(filtered);
+    q[w] = '\0';
+    out->len = w;
+    out->data = q;
+}
+
+void ps_b64_std_encode(int64_t n, char *p, PsBuf *out) { ps_b64_encode(n, p, 0, out); }
+void ps_b64_url_encode(int64_t n, char *p, PsBuf *out) { ps_b64_encode(n, p, 1, out); }
+void ps_b64_std_decode(int64_t n, char *p, PsBuf *out) { ps_b64_decode(n, p, 0, out); }
+void ps_b64_url_decode(int64_t n, char *p, PsBuf *out) { ps_b64_decode(n, p, 1, out); }

pyscriptc/runtime/ps_coll.c

@@ -0,0 +1,133 @@
+/* collections.deque. The value is this struct, not a field object.
+
+Indexing follows Python: negative indexes count from the end, and an empty
+pop raises IndexError.
+*/
+
+#include "ps_rt.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    int64_t len;
+    int64_t cap;
+    int64_t start;
+    int64_t elem;
+    char *data;
+} PsDeque;
+
+static char *ps_at(PsDeque *d, int64_t i) {
+    int64_t at = d->start + i;
+    if (d->cap > 0 && at >= d->cap) {
+        at -= d->cap;
+    }
+    return d->data + (size_t)at * (size_t)d->elem;
+}
+
+static void ps_grow(PsDeque *d) {
+    int64_t cap = d->cap == 0 ? 4 : d->cap * 2;
+    char *data;
+    int64_t i;
+    if (cap < d->len + 1) {
+        ps_raise_code(PS_OVERFLOW);
+    }
+    data = calloc((size_t)cap, (size_t)d->elem);
+    if (data == NULL) {
+        abort();
+    }
+    for (i = 0; i < d->len; i++) {
+        memcpy(data + (size_t)i * (size_t)d->elem, ps_at(d, i), (size_t)d->elem);
+    }
+    free(d->data);
+    d->data = data;
+    d->start = 0;
+    d->cap = cap;
+}
+
+static PsDeque *ps_new(int64_t elem) {
+    PsDeque *d;
+    if (elem <= 0) {
+        ps_raise_code(PS_VALUE);
+    }
+    d = calloc(1, sizeof(PsDeque));
+    if (d == NULL) {
+        abort();
+    }
+    d->elem = elem;
+    return d;
+}
+
+PsDeque *ps_deque_empty(int64_t elem) { return ps_new(elem); }
+
+PsDeque *ps_deque_from(int64_t elem, PsSeq *src) {
+    PsDeque *d = ps_new(elem);
+    int64_t i;
+    if (src->elem != elem) {
+        ps_raise_cstr(PS_VALUE, "deque element size does not match");
+    }
+    for (i = 0; i < src->len; i++) {
+        if (d->len == d->cap) {
+            ps_grow(d);
+        }
+        memcpy(ps_at(d, d->len), (char *)src->data + (size_t)i * (size_t)elem, (size_t)elem);
+        d->len += 1;
+    }
+    return d;
+}
+
+int64_t ps_deque_len(PsDeque *d) { return d->len; }
+
+void ps_deque_append(PsDeque *d, void *src) {
+    if (d->len == d->cap) {
+        ps_grow(d);
+    }
+    memcpy(ps_at(d, d->len), src, (size_t)d->elem);
+    d->len += 1;
+}
+
+void ps_deque_appendleft(PsDeque *d, void *src) {
+    if (d->len == d->cap) {
+        ps_grow(d);
+    }
+    d->start = d->start == 0 ? d->cap - 1 : d->start - 1;
+    memcpy(ps_at(d, 0), src, (size_t)d->elem);
+    d->len += 1;
+}
+
+static int64_t ps_index(int64_t len, int64_t i) {
+    if (i < 0) {
+        i += len;
+    }
+    if (i < 0 || i >= len) {
+        ps_raise_code(PS_INDEX);
+    }
+    return i;
+}
+
+void ps_deque_get(PsDeque *d, int64_t i, void *out) {
+    i = ps_index(d->len, i);
+    memcpy(out, ps_at(d, i), (size_t)d->elem);
+}
+
+void ps_deque_pop(PsDeque *d, void *out) {
+    if (d->len == 0) {
+        ps_raise_code(PS_INDEX);
+    }
+    d->len -= 1;
+    memcpy(out, ps_at(d, d->len), (size_t)d->elem);
+}
+
+void ps_deque_popleft(PsDeque *d, void *out) {
+    if (d->len == 0) {
+        ps_raise_code(PS_INDEX);
+    }
+    memcpy(out, ps_at(d, 0), (size_t)d->elem);
+    d->len -= 1;
+    if (d->cap > 0) {
+        d->start += 1;
+        if (d->start == d->cap) {
+            d->start = 0;
+        }
+    }
+}

pyscriptc/runtime/ps_dt.c

@@ -0,0 +1,388 @@
+/* datetime.date, datetime.datetime, datetime.time, and timedelta.
+
+Field order matches the synthetic classes: Date is year, month, day.
+DateTime adds hour, minute, second, microsecond. TimeDelta is days, seconds,
+microseconds, normalized the way CPython normalizes them.
+*/
+
+#include "ps_rt.h"
+
+#include <stdint.h>
+
+typedef struct {
+    int64_t year;
+    int64_t month;
+    int64_t day;
+} PsDate;
+
+typedef struct {
+    int64_t year;
+    int64_t month;
+    int64_t day;
+    int64_t hour;
+    int64_t minute;
+    int64_t second;
+    int64_t microsecond;
+} PsDateTime;
+
+typedef struct {
+    int64_t hour;
+    int64_t minute;
+    int64_t second;
+    int64_t microsecond;
+} PsTod;
+
+typedef struct {
+    int64_t days;
+    int64_t seconds;
+    int64_t microseconds;
+} PsDelta;
+
+static const int64_t PS_DAY_US = 86400000000LL;
+
+static int ps_leap(int64_t year) {
+    return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0);
+}
+
+static int ps_valid_ymd(int64_t y, int64_t m, int64_t d) {
+    static const int mdays[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    int dim;
+    if (y < 1 || y > 9999 || m < 1 || m > 12 || d < 1) {
+        return 0;
+    }
+    dim = mdays[m];
+    if (m == 2 && ps_leap(y)) {
+        dim = 29;
+    }
+    return d <= dim;
+}
+
+static int64_t ps_ymd_ord(int64_t y, int64_t m, int64_t d) {
+    static const int before[] = {0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
+    int64_t y1 = y - 1;
+    int64_t days = before[m];
+    if (m > 2 && ps_leap(y)) {
+        days += 1;
+    }
+    return y1 * 365 + y1 / 4 - y1 / 100 + y1 / 400 + days + d;
+}
+
+static void ps_ord_ymd(int64_t ordinal, int64_t *year, int64_t *month, int64_t *day) {
+    static const int mdays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    int64_t n = ordinal - 1;
+    int64_t n400 = n / 146097;
+    int64_t n100;
+    int64_t n4;
+    int64_t n1;
+    int leap;
+    int m;
+    n %= 146097;
+    n100 = n / 36524;
+    n %= 36524;
+    n4 = n / 1461;
+    n %= 1461;
+    n1 = n / 365;
+    n %= 365;
+    *year = n400 * 400 + n100 * 100 + n4 * 4 + n1 + 1;
+    if (n1 == 4 || n100 == 4) {
+        *year -= 1;
+        *month = 12;
+        *day = 31;
+        return;
+    }
+    leap = n1 == 3 && (n4 != 24 || n100 == 3);
+    for (m = 1; m <= 12; m++) {
+        int dim = mdays[m - 1];
+        if (m == 2 && leap) {
+            dim += 1;
+        }
+        if (n < dim) {
+            *month = m;
+            *day = n + 1;
+            return;
+        }
+        n -= dim;
+    }
+    ps_raise_cstr(PS_VALUE, "date out of range");
+}
+
+static void ps_put_ord(int64_t ordinal, PsDate *out) {
+    int64_t max_ord = ps_ymd_ord(9999, 12, 31);
+    if (ordinal < 1 || ordinal > max_ord) {
+        ps_raise_cstr(PS_VALUE, "date out of range");
+    }
+    ps_ord_ymd(ordinal, &out->year, &out->month, &out->day);
+}
+
+static void ps_pad(char *dst, int width, int64_t value) {
+    int i;
+    for (i = width - 1; i >= 0; i--) {
+        dst[i] = (char)('0' + (value % 10));
+        value /= 10;
+    }
+}
+
+static void ps_iso_date(int64_t y, int64_t m, int64_t d, PsBuf *out) {
+    char buf[16];
+    ps_pad(buf, 4, y);
+    buf[4] = '-';
+    ps_pad(buf + 5, 2, m);
+    buf[7] = '-';
+    ps_pad(buf + 8, 2, d);
+    ps_buf_copy(out, buf, 10);
+}
+
+static void ps_iso_tod(int64_t h, int64_t m, int64_t s, int64_t us, PsBuf *out) {
+    char buf[24];
+    int n = 8;
+    ps_pad(buf, 2, h);
+    buf[2] = ':';
+    ps_pad(buf + 3, 2, m);
+    buf[5] = ':';
+    ps_pad(buf + 6, 2, s);
+    if (us != 0) {
+        buf[8] = '.';
+        ps_pad(buf + 9, 6, us);
+        n = 15;
+    }
+    ps_buf_copy(out, buf, n);
+}
+
+static int ps_digits(const char *s, int64_t n, int64_t at, int width, int64_t *out) {
+    int64_t value = 0;
+    int i;
+    if (at + width > n) {
+        return 0;
+    }
+    for (i = 0; i < width; i++) {
+        char c = s[at + i];
+        if (c < '0' || c > '9') {
+            return 0;
+        }
+        value = value * 10 + (c - '0');
+    }
+    *out = value;
+    return 1;
+}
+
+static void ps_delta_norm(__int128 us, PsDelta *out) {
+    __int128 day;
+    __int128 rem;
+    day = us / PS_DAY_US;
+    rem = us - day * PS_DAY_US;
+    if (rem < 0) {
+        rem += PS_DAY_US;
+        day -= 1;
+    }
+    if (day > INT64_MAX || day < INT64_MIN) {
+        ps_raise_cstr(PS_OVERFLOW, "timedelta out of range");
+    }
+    out->days = (int64_t)day;
+    out->seconds = (int64_t)(rem / 1000000);
+    out->microseconds = (int64_t)(rem % 1000000);
+}
+
+static __int128 ps_delta_us(const PsDelta *d) {
+    return (__int128)d->days * PS_DAY_US + (__int128)d->seconds * 1000000 + d->microseconds;
+}
+
+void ps_date_ymd(int64_t y, int64_t m, int64_t d, PsDate *out) {
+    if (!ps_valid_ymd(y, m, d)) {
+        ps_raise_cstr(PS_VALUE, "date out of range");
+    }
+    out->year = y;
+    out->month = m;
+    out->day = d;
+}
+
+void ps_date_today(PsDate *out) {
+    /* Filled by ps_time via a local date. Implemented here with time.h. */
+    extern void ps_date_today_fill(PsDate *out);
+    ps_date_today_fill(out);
+}
+
+void ps_date_fromiso(int64_t n, const char *s, PsDate *out) {
+    int64_t y, m, d;
+    if (n != 10 || s[4] != '-' || s[7] != '-' || !ps_digits(s, n, 0, 4, &y) || !ps_digits(s, n, 5, 2, &m) ||
+        !ps_digits(s, n, 8, 2, &d)) {
+        ps_raise_cstr(PS_VALUE, "invalid isoformat date");
+    }
+    ps_date_ymd(y, m, d, out);
+}
+
+void ps_date_fromord(int64_t ordinal, PsDate *out) { ps_put_ord(ordinal, out); }
+
+void ps_date_iso(PsDate *d, PsBuf *out) { ps_iso_date(d->year, d->month, d->day, out); }
+
+int64_t ps_date_ord(PsDate *d) { return ps_ymd_ord(d->year, d->month, d->day); }
+
+int64_t ps_date_weekday(PsDate *d) { return (ps_ymd_ord(d->year, d->month, d->day) + 6) % 7; }
+
+void ps_date_add(PsDate *d, PsDelta *delta, int32_t sign, PsDate *out) {
+    int64_t ord = ps_ymd_ord(d->year, d->month, d->day);
+    __int128 days = delta->days;
+    __int128 sum;
+    if (sign < 0) {
+        days = -days;
+    }
+    sum = (__int128)ord + days;
+    if (sum < 1 || sum > ps_ymd_ord(9999, 12, 31)) {
+        ps_raise_cstr(PS_VALUE, "date out of range");
+    }
+    ps_put_ord((int64_t)sum, out);
+}
+
+void ps_date_diff(PsDate *a, PsDate *b, PsDelta *out) {
+    out->days = ps_ymd_ord(a->year, a->month, a->day) - ps_ymd_ord(b->year, b->month, b->day);
+    out->seconds = 0;
+    out->microseconds = 0;
+}
+
+static void ps_check_tod(int64_t h, int64_t mi, int64_t s, int64_t us) {
+    if (h < 0 || h > 23 || mi < 0 || mi > 59 || s < 0 || s > 59 || us < 0 || us > 999999) {
+        ps_raise_cstr(PS_VALUE, "time out of range");
+    }
+}
+
+void ps_dt_new(int64_t y, int64_t m, int64_t d, int64_t h, int64_t mi, int64_t s, int64_t us, PsDateTime *out) {
+    if (!ps_valid_ymd(y, m, d)) {
+        ps_raise_cstr(PS_VALUE, "date out of range");
+    }
+    ps_check_tod(h, mi, s, us);
+    out->year = y;
+    out->month = m;
+    out->day = d;
+    out->hour = h;
+    out->minute = mi;
+    out->second = s;
+    out->microsecond = us;
+}
+
+void ps_dt_now(PsDateTime *out) {
+    extern void ps_dt_now_fill(PsDateTime *out);
+    ps_dt_now_fill(out);
+}
+
+void ps_dt_fromiso(int64_t n, const char *s, PsDateTime *out) {
+    int64_t y, m, d, h = 0, mi = 0, sec = 0, us = 0;
+    if (n != 10 && n != 19 && n != 26) {
+        ps_raise_cstr(PS_VALUE, "invalid isoformat datetime");
+    }
+    if (s[4] != '-' || s[7] != '-' || !ps_digits(s, n, 0, 4, &y) || !ps_digits(s, n, 5, 2, &m) ||
+        !ps_digits(s, n, 8, 2, &d)) {
+        ps_raise_cstr(PS_VALUE, "invalid isoformat datetime");
+    }
+    if (n >= 19) {
+        if ((s[10] != 'T' && s[10] != ' ') || s[13] != ':' || s[16] != ':' || !ps_digits(s, n, 11, 2, &h) ||
+            !ps_digits(s, n, 14, 2, &mi) || !ps_digits(s, n, 17, 2, &sec)) {
+            ps_raise_cstr(PS_VALUE, "invalid isoformat datetime");
+        }
+    }
+    if (n == 26) {
+        if (s[19] != '.' || !ps_digits(s, n, 20, 6, &us)) {
+            ps_raise_cstr(PS_VALUE, "invalid isoformat datetime");
+        }
+    }
+    ps_dt_new(y, m, d, h, mi, sec, us, out);
+}
+
+void ps_dt_iso(PsDateTime *d, PsBuf *out) {
+    char buf[40];
+    int n = 19;
+    ps_pad(buf, 4, d->year);
+    buf[4] = '-';
+    ps_pad(buf + 5, 2, d->month);
+    buf[7] = '-';
+    ps_pad(buf + 8, 2, d->day);
+    buf[10] = 'T';
+    ps_pad(buf + 11, 2, d->hour);
+    buf[13] = ':';
+    ps_pad(buf + 14, 2, d->minute);
+    buf[16] = ':';
+    ps_pad(buf + 17, 2, d->second);
+    if (d->microsecond != 0) {
+        buf[19] = '.';
+        ps_pad(buf + 20, 6, d->microsecond);
+        n = 26;
+    }
+    ps_buf_copy(out, buf, n);
+}
+
+void ps_dt_date(PsDateTime *d, PsDate *out) { ps_date_ymd(d->year, d->month, d->day, out); }
+
+void ps_dt_time(PsDateTime *d, PsTod *out) {
+    ps_check_tod(d->hour, d->minute, d->second, d->microsecond);
+    out->hour = d->hour;
+    out->minute = d->minute;
+    out->second = d->second;
+    out->microsecond = d->microsecond;
+}
+
+static void ps_dt_parts(const PsDateTime *a, int64_t *ord, __int128 *us) {
+    *ord = ps_ymd_ord(a->year, a->month, a->day);
+    *us = (((__int128)a->hour * 3600 + a->minute * 60 + a->second) * 1000000) + a->microsecond;
+}
+
+void ps_dt_add(PsDateTime *a, PsDelta *delta, int32_t sign, PsDateTime *out) {
+    int64_t ord;
+    __int128 us;
+    __int128 extra;
+    __int128 rem;
+    __int128 add = ps_delta_us(delta);
+    if (sign < 0) {
+        add = -add;
+    }
+    ps_dt_parts(a, &ord, &us);
+    us += add;
+    extra = us / PS_DAY_US;
+    rem = us - extra * PS_DAY_US;
+    if (rem < 0) {
+        rem += PS_DAY_US;
+        extra -= 1;
+    }
+    if (extra > INT64_MAX || extra < INT64_MIN || (extra > 0 && ord > INT64_MAX - (int64_t)extra) ||
+        (extra < 0 && ord < (int64_t)(-extra))) {
+        ps_raise_cstr(PS_VALUE, "datetime out of range");
+    }
+    ps_put_ord(ord + (int64_t)extra, (PsDate *)out);
+    out->hour = (int64_t)(rem / 3600000000LL);
+    rem %= 3600000000LL;
+    out->minute = (int64_t)(rem / 60000000LL);
+    rem %= 60000000LL;
+    out->second = (int64_t)(rem / 1000000LL);
+    out->microsecond = (int64_t)(rem % 1000000LL);
+}
+
+void ps_dt_diff(PsDateTime *a, PsDateTime *b, PsDelta *out) {
+    int64_t oa, ob;
+    __int128 ua, ub;
+    ps_dt_parts(a, &oa, &ua);
+    ps_dt_parts(b, &ob, &ub);
+    ps_delta_norm(((__int128)oa - ob) * PS_DAY_US + (ua - ub), out);
+}
+
+void ps_tod_new(int64_t h, int64_t mi, int64_t s, int64_t us, PsTod *out) {
+    ps_check_tod(h, mi, s, us);
+    out->hour = h;
+    out->minute = mi;
+    out->second = s;
+    out->microsecond = us;
+}
+
+void ps_tod_iso(PsTod *t, PsBuf *out) { ps_iso_tod(t->hour, t->minute, t->second, t->microsecond, out); }
+
+void ps_delta_new(int64_t days, int64_t seconds, int64_t microseconds, PsDelta *out) {
+    ps_delta_norm((__int128)days * PS_DAY_US + (__int128)seconds * 1000000 + microseconds, out);
+}
+
+void ps_delta_neg(PsDelta *d, PsDelta *out) { ps_delta_norm(-ps_delta_us(d), out); }
+
+void ps_delta_add(PsDelta *a, PsDelta *b, int32_t sign, PsDelta *out) {
+    __int128 add = ps_delta_us(b);
+    if (sign < 0) {
+        add = -add;
+    }
+    ps_delta_norm(ps_delta_us(a) + add, out);
+}
+
+double ps_delta_total(PsDelta *d) { return (double)ps_delta_us(d) / 1000000.0; }