pyscriptc 0.1.0__py3-none-any.whl

pyscriptc/runtime/ps_rt.h

@@ -0,0 +1,189 @@
+/* Shared layout for the runtime linked beside emitted LLVM.
+
+%ps.str is { i64, ptr }. PsBuf must stay 16 bytes. PsSeq keeps len, elem, and
+data in that order; cap is appended so existing stores still line up.
+*/
+
+#ifndef PYSCRIPTC_PS_RT_H
+#define PYSCRIPTC_PS_RT_H
+
+#include <stdint.h>
+
+enum {
+    PS_VALUE = 1,
+    PS_INDEX = 2,
+    PS_KEY = 3,
+    PS_OVERFLOW = 4,
+    PS_ZERO_DIV = 5,
+    PS_RUNTIME = 6,
+    PS_EXCEPTION = 7,
+    PS_USER_BASE = 8
+};
+
+/* longjmp payload once an exception is pending; the class code lives on the
+PsExc record, not on the wire. */
+enum { PS_RAISED = -1 };
+
+enum {
+    PS_JSON_INT = 1,
+    PS_JSON_BOOL = 2,
+    PS_JSON_STR = 3,
+    PS_JSON_LIST = 4,
+    PS_JSON_DICT = 5
+};
+
+typedef struct PsBuf {
+    int64_t len;
+    char *data;
+} PsBuf;
+
+typedef struct PsSeq {
+    int64_t len;
+    int64_t elem;
+    void *data;
+    int64_t cap;
+} PsSeq;
+
+typedef struct PsMap {
+    int64_t len;
+    int64_t cap;
+    int32_t key_kind;
+    int64_t key_size;
+    int64_t val_size;
+    void *keys;
+    void *vals;
+} PsMap;
+
+typedef struct PsType {
+    int32_t kind;
+    int32_t child;
+} PsType;
+
+typedef struct PsArg {
+    int32_t kind;
+    int32_t pad;
+    int64_t i;
+    double f;
+    PsBuf b;
+} PsArg;
+
+typedef struct PsGrow {
+    char *data;
+    int64_t len;
+    int64_t cap;
+} PsGrow;
+
+/* Raised exception. name and message are borrowed storage: name points at the
+static class-name table, message at a 256-byte owned buffer like the old
+ps_msg channel. cause and args stay NULL until M3/E3. */
+typedef struct PsExc {
+    int32_t code;
+    int32_t flags;
+    PsBuf name;
+    PsBuf message;
+    struct PsExc *cause;
+    PsSeq *args;
+} PsExc;
+
+extern char ps_empty_byte;
+
+__attribute__((noreturn)) void ps_raise_cstr(int32_t code, const char *msg);
+__attribute__((noreturn)) void ps_raise_code(int32_t code);
+__attribute__((noreturn)) void ps_reraise(void);
+int32_t ps_exc_code(void);
+int32_t ps_exc_isa(int32_t raised, int32_t wanted);
+void *ps_alloc(int64_t n);
+
+PsSeq *ps_seq_new(int64_t elem, int64_t n);
+int64_t ps_seq_len(PsSeq *s);
+void ps_seq_get(PsSeq *s, int64_t i, void *out);
+void ps_seq_set(PsSeq *s, int64_t i, void *src);
+void ps_seq_push(PsSeq *s, const void *src);
+
+PsMap *ps_map_new(int32_t key_kind, int64_t key_size, int64_t val_size, int64_t cap);
+void ps_map_put(PsMap *m, void *key, void *val);
+int64_t ps_map_len(PsMap *m);
+void ps_map_key_at(PsMap *m, int64_t i, void *out);
+PsSeq *ps_dict_keys(PsMap *m);
+void ps_map_val_at(PsMap *m, int64_t i, void *out);
+
+void ps_buf_view(PsBuf *out, const char *p, int64_t n);
+void ps_buf_copy(PsBuf *out, const char *p, int64_t n);
+
+void ps_grow_init(PsGrow *g);
+void ps_grow_add(PsGrow *g, const char *p, int64_t n);
+void ps_grow_byte(PsGrow *g, unsigned char c);
+void ps_grow_finish(PsGrow *g, PsBuf *out);
+
+void ps_str_slice(
+    int64_t n, const char *p, int64_t start, int64_t stop, int64_t has_start, int64_t has_stop, int64_t step, PsBuf *out
+);
+PsSeq *ps_seq_slice(PsSeq *s, int64_t start, int64_t stop, int64_t has_start, int64_t has_stop, int64_t step);
+PsSeq *ps_str_split(int64_t n, const char *p, int64_t sn, const char *sp, int64_t mode);
+void ps_str_join(int64_t n, const char *sep, PsSeq *parts, PsBuf *out);
+void ps_utf8_encode(int64_t n, const char *p, PsBuf *out);
+void ps_utf8_decode(int64_t n, const char *p, PsBuf *out);
+void ps_i64_str(int64_t v, PsBuf *out);
+void ps_f64_str(double v, PsBuf *out);
+int64_t ps_bisect_left(PsSeq *s, int64_t key);
+int64_t ps_bisect_right(PsSeq *s, int64_t key);
+int64_t ps_int_from_bytes(int64_t n, const char *s);
+
+/* ps_more.c: R1-R5 helpers */
+PsSeq *ps_seq_concat(PsSeq *a, PsSeq *b);
+PsSeq *ps_seq_repeat(PsSeq *s, int64_t n);
+void ps_seq_extend(PsSeq *dst, PsSeq *src);
+void ps_seq_insert(PsSeq *s, int64_t i, void *src);
+void ps_seq_reverse(PsSeq *s);
+void ps_seq_sort_i64(PsSeq *s, int64_t desc);
+void ps_seq_sort_f64(PsSeq *s, int64_t desc);
+void ps_seq_sort_buf(PsSeq *s, int64_t desc);
+int64_t ps_seq_index_i64(PsSeq *s, int64_t needle);
+int64_t ps_seq_index_f64(PsSeq *s, double needle);
+int64_t ps_seq_index_buf(PsSeq *s, int64_t n, char *p);
+int64_t ps_seq_count_i64(PsSeq *s, int64_t needle);
+int64_t ps_seq_count_f64(PsSeq *s, double needle);
+int64_t ps_seq_count_buf(PsSeq *s, int64_t n, char *p);
+void ps_seq_remove_i64(PsSeq *s, int64_t needle);
+void ps_seq_remove_f64(PsSeq *s, double needle);
+void ps_seq_remove_buf(PsSeq *s, int64_t n, char *p);
+void ps_seq_insert_i64(PsSeq *s, int64_t i, int64_t v);
+void ps_seq_insert_f64(PsSeq *s, int64_t i, double v);
+void ps_seq_insert_buf(PsSeq *s, int64_t i, int64_t n, char *p);
+int64_t ps_seq_pop_i64(PsSeq *s, int64_t i);
+double ps_seq_pop_f64(PsSeq *s, int64_t i);
+void ps_seq_pop_buf(PsSeq *s, int64_t i, PsBuf *out);
+void ps_map_del(PsMap *m, void *key);
+void ps_map_clear(PsMap *m);
+void ps_map_update(PsMap *dst, PsMap *src);
+PsSeq *ps_dict_values(PsMap *m);
+PsSeq *ps_dict_items(PsMap *m, int64_t voff, int64_t esz);
+PsSeq *ps_str_split_m(
+    int64_t n, const char *p, int64_t sn, const char *sp, int64_t mode, int64_t maxsplit, int64_t right
+);
+PsSeq *ps_str_splitlines(int64_t n, const char *p, int64_t keepends);
+int64_t ps_str_count(int64_t n, const char *p, int64_t sn, const char *sp);
+int64_t ps_str_index(int64_t n, const char *p, int64_t sn, const char *sp);
+int64_t ps_str_rfind(int64_t n, const char *p, int64_t sn, const char *sp);
+int64_t ps_str_isdigit(int64_t n, const char *p);
+int64_t ps_str_isalpha(int64_t n, const char *p);
+int64_t ps_str_isalnum(int64_t n, const char *p);
+int64_t ps_str_isspace(int64_t n, const char *p);
+int64_t ps_str_isupper(int64_t n, const char *p);
+int64_t ps_str_islower(int64_t n, const char *p);
+void ps_str_title(int64_t n, const char *p, PsBuf *out);
+void ps_str_capitalize(int64_t n, const char *p, PsBuf *out);
+void ps_str_casefold(int64_t n, const char *p, PsBuf *out);
+void ps_str_swapcase(int64_t n, const char *p, PsBuf *out);
+void ps_str_zfill(int64_t n, const char *p, int64_t width, PsBuf *out);
+void ps_str_justify(
+    int64_t n, const char *p, int64_t width, int64_t fn, const char *fc, int64_t side, PsBuf *out
+);
+void ps_str_removeprefix(int64_t n, const char *p, int64_t sn, const char *sp, PsBuf *out);
+void ps_str_removesuffix(int64_t n, const char *p, int64_t sn, const char *sp, PsBuf *out);
+void ps_str_expandtabs(int64_t n, const char *p, int64_t tabsize, PsBuf *out);
+void ps_str_partition(int64_t n, const char *p, int64_t sn, const char *sp, int64_t right, PsBuf *out);
+void ps_repr_bytes(int64_t n, const char *p, PsBuf *out);
+double ps_float_from_str(int64_t n, const char *p);
+
+#endif

pyscriptc/runtime/ps_struct.c

@@ -0,0 +1,291 @@
+/* struct.pack / struct.unpack for a literal format. Standard sizes.
+'@' is refused by the lowerer. Out of range values are ValueError. */
+
+#include "ps_rt.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+static int ps_little(void) {
+    uint16_t x = 1;
+    return *(unsigned char *)&x == 1;
+}
+
+static int ps_code_size(char code) {
+    switch (code) {
+    case 'x':
+    case 'b':
+    case 'B':
+    case 's':
+        return 1;
+    case 'h':
+    case 'H':
+        return 2;
+    case 'i':
+    case 'I':
+    case 'l':
+    case 'L':
+    case 'f':
+        return 4;
+    case 'q':
+    case 'Q':
+    case 'd':
+        return 8;
+    default:
+        return -1;
+    }
+}
+
+static int ps_code_kind(char code) {
+    if (code == 'x') {
+        return 0;
+    }
+    if (code == 'f' || code == 'd') {
+        return 2;
+    }
+    if (code == 's') {
+        return 3;
+    }
+    return 1;
+}
+
+static void ps_put_bytes(unsigned char *dst, uint64_t v, int size, int le) {
+    for (int i = 0; i < size; i++) {
+        int shift = le ? i : (size - 1 - i);
+        dst[i] = (unsigned char)((v >> (8 * shift)) & 0xff);
+    }
+}
+
+static uint64_t ps_get_bytes(const unsigned char *src, int size, int le) {
+    uint64_t v = 0;
+    for (int i = 0; i < size; i++) {
+        int shift = le ? i : (size - 1 - i);
+        v |= (uint64_t)src[i] << (8 * shift);
+    }
+    return v;
+}
+
+static int ps_in_range(char code, int64_t v) {
+    switch (code) {
+    case 'b':
+        return v >= -128 && v <= 127;
+    case 'B':
+        return v >= 0 && v <= 255;
+    case 'h':
+        return v >= -32768 && v <= 32767;
+    case 'H':
+        return v >= 0 && v <= 65535;
+    case 'i':
+    case 'l':
+        return v >= -2147483648LL && v <= 2147483647LL;
+    case 'I':
+    case 'L':
+        return v >= 0 && v <= 4294967295LL;
+    case 'q':
+        return 1;
+    case 'Q':
+        return v >= 0;
+    default:
+        return 0;
+    }
+}
+
+static void ps_walk(const char *fmt, int64_t fn, int pack, PsArg *args, int64_t nargs, const char *data, int64_t dn,
+                    PsBuf *packed, PsSeq **unpacked, int want) {
+    int le = ps_little();
+    int64_t i = 0;
+    int64_t argi = 0;
+    int64_t cursor = 0;
+    PsGrow g;
+    PsSeq *seq = NULL;
+    if (pack) {
+        ps_grow_init(&g);
+    } else {
+        int64_t elem = want == 2 ? 8 : want == 3 ? 16 : 8;
+        seq = ps_seq_new(elem, 0);
+    }
+    while (i < fn) {
+        char c = fmt[i];
+        if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+            i++;
+            continue;
+        }
+        if (c == '<' ) {
+            le = 1;
+            i++;
+            continue;
+        }
+        if (c == '>' || c == '!') {
+            le = 0;
+            i++;
+            continue;
+        }
+        if (c == '=') {
+            le = ps_little();
+            i++;
+            continue;
+        }
+        if (c == '@') {
+            ps_raise_cstr(PS_VALUE, "struct native alignment is not lowered");
+        }
+        int64_t count = 1;
+        if (c >= '0' && c <= '9') {
+            count = 0;
+            while (i < fn && fmt[i] >= '0' && fmt[i] <= '9') {
+                count = count * 10 + (fmt[i] - '0');
+                i++;
+            }
+            if (i >= fn) {
+                ps_raise_cstr(PS_VALUE, "bad struct format");
+            }
+            c = fmt[i];
+        }
+        i++;
+        int size = ps_code_size(c);
+        if (size < 0) {
+            ps_raise_cstr(PS_VALUE, "bad struct format");
+        }
+        int kind = ps_code_kind(c);
+        if (!pack && kind != 0 && want != 0 && kind != want) {
+            ps_raise_cstr(PS_VALUE, "struct.unpack result types are mixed");
+        }
+        if (c == 's') {
+            int64_t nbytes = count;
+            if (pack) {
+                if (argi >= nargs || args[argi].kind != 3) {
+                    ps_raise_cstr(PS_VALUE, "struct.pack expected bytes");
+                }
+                PsBuf b = args[argi++].b;
+                int64_t take = b.len < nbytes ? b.len : nbytes;
+                if (take > 0) {
+                    ps_grow_add(&g, b.data, take);
+                }
+                for (int64_t z = take; z < nbytes; z++) {
+                    ps_grow_byte(&g, 0);
+                }
+            } else {
+                if (cursor + nbytes > dn) {
+                    ps_raise_cstr(PS_VALUE, "struct.unpack buffer is too small");
+                }
+                PsBuf piece;
+                ps_buf_copy(&piece, data + cursor, nbytes);
+                ps_seq_push(seq, &piece);
+                cursor += nbytes;
+            }
+            continue;
+        }
+        for (int64_t k = 0; k < count; k++) {
+            if (c == 'x') {
+                if (pack) {
+                    ps_grow_byte(&g, 0);
+                } else {
+                    if (cursor + 1 > dn) {
+                        ps_raise_cstr(PS_VALUE, "struct.unpack buffer is too small");
+                    }
+                    cursor += 1;
+                }
+                continue;
+            }
+            if (pack) {
+                if (argi >= nargs) {
+                    ps_raise_cstr(PS_VALUE, "struct.pack is missing an argument");
+                }
+                unsigned char tmp[8];
+                if (kind == 1) {
+                    if (args[argi].kind != 1) {
+                        ps_raise_cstr(PS_VALUE, "struct.pack expected an int");
+                    }
+                    int64_t v = args[argi++].i;
+                    if (!ps_in_range(c, v)) {
+                        ps_raise_cstr(PS_VALUE, "struct format argument out of range");
+                    }
+                    ps_put_bytes(tmp, (uint64_t)v, size, le);
+                    ps_grow_add(&g, (char *)tmp, size);
+                } else {
+                    double dv;
+                    if (args[argi].kind == 2) {
+                        dv = args[argi++].f;
+                    } else if (args[argi].kind == 1) {
+                        dv = (double)args[argi++].i;
+                    } else {
+                        ps_raise_cstr(PS_VALUE, "struct.pack expected a float");
+                    }
+                    if (c == 'f') {
+                        float f = (float)dv;
+                        uint32_t bits = 0;
+                        memcpy(&bits, &f, 4);
+                        ps_put_bytes(tmp, bits, 4, le);
+                        ps_grow_add(&g, (char *)tmp, 4);
+                    } else {
+                        uint64_t bits = 0;
+                        memcpy(&bits, &dv, 8);
+                        ps_put_bytes(tmp, bits, 8, le);
+                        ps_grow_add(&g, (char *)tmp, 8);
+                    }
+                }
+            } else {
+                if (cursor + size > dn) {
+                    ps_raise_cstr(PS_VALUE, "struct.unpack buffer is too small");
+                }
+                uint64_t bits = ps_get_bytes((const unsigned char *)data + cursor, size, le);
+                cursor += size;
+                if (kind == 1) {
+                    int64_t v = 0;
+                    if (c == 'b') {
+                        v = (int8_t)bits;
+                    } else if (c == 'B') {
+                        v = (uint8_t)bits;
+                    } else if (c == 'h') {
+                        v = (int16_t)bits;
+                    } else if (c == 'H') {
+                        v = (uint16_t)bits;
+                    } else if (c == 'i' || c == 'l') {
+                        v = (int32_t)bits;
+                    } else if (c == 'I' || c == 'L') {
+                        v = (uint32_t)bits;
+                    } else if (c == 'q') {
+                        v = (int64_t)bits;
+                    } else {
+                        if (bits > (uint64_t)INT64_MAX) {
+                            ps_raise_cstr(PS_VALUE, "struct Q result does not fit in i64");
+                        }
+                        v = (int64_t)bits;
+                    }
+                    ps_seq_push(seq, &v);
+                } else if (c == 'f') {
+                    uint32_t u = (uint32_t)bits;
+                    float f = 0;
+                    memcpy(&f, &u, 4);
+                    double d = (double)f;
+                    ps_seq_push(seq, &d);
+                } else {
+                    double d = 0;
+                    memcpy(&d, &bits, 8);
+                    ps_seq_push(seq, &d);
+                }
+            }
+        }
+    }
+    if (pack) {
+        if (argi != nargs) {
+            free(g.data);
+            ps_raise_cstr(PS_VALUE, "struct.pack has too many arguments");
+        }
+        ps_grow_finish(&g, packed);
+        return;
+    }
+    if (cursor != dn) {
+        ps_raise_cstr(PS_VALUE, "struct.unpack buffer has trailing bytes");
+    }
+    *unpacked = seq;
+}
+
+void ps_struct_pack(int64_t fn, char *fmt, PsArg *args, int64_t nargs, PsBuf *out) {
+    ps_walk(fmt, fn, 1, args, nargs, NULL, 0, out, NULL, 0);
+}
+
+PsSeq *ps_struct_unpack(int64_t fn, char *fmt, int64_t dn, char *data, int32_t want) {
+    PsSeq *seq = NULL;
+    ps_walk(fmt, fn, 0, NULL, 0, data, dn, NULL, &seq, want);
+    return seq;
+}

pyscriptc/runtime/ps_time.c

@@ -0,0 +1,207 @@
+/* time.time, sleep, gmtime, localtime, strftime, and mktime.
+
+struct_time fields match CPython: tm_mon is 1-12, tm_wday is Monday 0,
+tm_yday is 1-366. C's tm_* is converted at the boundary.
+*/
+
+#include "ps_rt.h"
+
+#include <errno.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.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 tm_year;
+    int64_t tm_mon;
+    int64_t tm_mday;
+    int64_t tm_hour;
+    int64_t tm_min;
+    int64_t tm_sec;
+    int64_t tm_wday;
+    int64_t tm_yday;
+    int64_t tm_isdst;
+} PsStructTime;
+
+static void ps_fill_stm(const struct tm *tm, PsStructTime *out) {
+    out->tm_year = (int64_t)tm->tm_year + 1900;
+    out->tm_mon = (int64_t)tm->tm_mon + 1;
+    out->tm_mday = tm->tm_mday;
+    out->tm_hour = tm->tm_hour;
+    out->tm_min = tm->tm_min;
+    out->tm_sec = tm->tm_sec;
+    out->tm_wday = (tm->tm_wday + 6) % 7;
+    out->tm_yday = (int64_t)tm->tm_yday + 1;
+    out->tm_isdst = tm->tm_isdst;
+}
+
+static int ps_read_stm(const PsStructTime *in, struct tm *tm) {
+    if (in->tm_year < 1900 || in->tm_mon < 1 || in->tm_mon > 12 || in->tm_mday < 1 || in->tm_mday > 31 ||
+        in->tm_hour < 0 || in->tm_hour > 23 || in->tm_min < 0 || in->tm_min > 59 || in->tm_sec < 0 ||
+        in->tm_sec > 60) {
+        return 0;
+    }
+    tm->tm_year = (int)(in->tm_year - 1900);
+    tm->tm_mon = (int)(in->tm_mon - 1);
+    tm->tm_mday = (int)in->tm_mday;
+    tm->tm_hour = (int)in->tm_hour;
+    tm->tm_min = (int)in->tm_min;
+    tm->tm_sec = (int)in->tm_sec;
+    tm->tm_wday = (int)((in->tm_wday + 1) % 7);
+    tm->tm_yday = (int)(in->tm_yday - 1);
+    tm->tm_isdst = (int)in->tm_isdst;
+    return 1;
+}
+
+static time_t ps_as_time(double ts) {
+    if (!isfinite(ts) || ts >= 9223372036854775808.0 || ts < -9223372036854775808.0) {
+        ps_raise_cstr(PS_VALUE, "timestamp out of range");
+    }
+    return (time_t)ts;
+}
+
+static double ps_clock(clockid_t id) {
+    struct timespec ts;
+    if (clock_gettime(id, &ts) != 0) {
+        ps_raise_cstr(PS_RUNTIME, "clock_gettime failed");
+    }
+    return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0;
+}
+
+double ps_time_time(void) { return ps_clock(CLOCK_REALTIME); }
+
+double ps_time_monotonic(void) { return ps_clock(CLOCK_MONOTONIC); }
+
+void ps_time_sleep(double seconds) {
+    struct timespec req;
+    if (!isfinite(seconds) || seconds < 0) {
+        ps_raise_cstr(PS_VALUE, "sleep length must be non-negative");
+    }
+    req.tv_sec = (time_t)seconds;
+    req.tv_nsec = (long)((seconds - (double)req.tv_sec) * 1000000000.0);
+    if (req.tv_nsec < 0) {
+        req.tv_nsec = 0;
+    }
+    if (req.tv_nsec > 999999999) {
+        req.tv_nsec = 999999999;
+    }
+    while (nanosleep(&req, &req) != 0) {
+        if (errno != EINTR) {
+            ps_raise_cstr(PS_RUNTIME, "sleep failed");
+        }
+    }
+}
+
+static void ps_gm(double ts, PsStructTime *out) {
+    time_t t = ps_as_time(ts);
+    struct tm tm;
+    if (gmtime_r(&t, &tm) == NULL) {
+        ps_raise_cstr(PS_VALUE, "timestamp out of range");
+    }
+    ps_fill_stm(&tm, out);
+}
+
+static void ps_local(double ts, PsStructTime *out) {
+    time_t t = ps_as_time(ts);
+    struct tm tm;
+    if (localtime_r(&t, &tm) == NULL) {
+        ps_raise_cstr(PS_VALUE, "timestamp out of range");
+    }
+    ps_fill_stm(&tm, out);
+}
+
+void ps_time_gm(double ts, PsStructTime *out) { ps_gm(ts, out); }
+
+void ps_time_local(double ts, PsStructTime *out) { ps_local(ts, out); }
+
+void ps_time_strftime(int64_t n, const char *fmt, PsStructTime *st, PsBuf *out) {
+    struct tm tm;
+    char buf[1024];
+    size_t wrote;
+    char *text;
+    if (n < 0 || n > 200) {
+        ps_raise_cstr(PS_VALUE, "strftime format is too long");
+    }
+    text = malloc((size_t)n + 1);
+    if (text == NULL) {
+        abort();
+    }
+    if (n > 0) {
+        memcpy(text, fmt, (size_t)n);
+    }
+    text[n] = '\0';
+    if (!ps_read_stm(st, &tm)) {
+        free(text);
+        ps_raise_cstr(PS_VALUE, "struct_time out of range");
+    }
+    wrote = strftime(buf, sizeof buf, text, &tm);
+    free(text);
+    if (wrote == 0) {
+        ps_raise_cstr(PS_VALUE, "strftime failed");
+    }
+    ps_buf_copy(out, buf, (int64_t)wrote);
+}
+
+double ps_time_mktime(PsStructTime *st) {
+    struct tm tm;
+    time_t t;
+    if (!ps_read_stm(st, &tm)) {
+        ps_raise_cstr(PS_VALUE, "struct_time out of range");
+    }
+    t = mktime(&tm);
+    if (t == (time_t)-1) {
+        ps_raise_cstr(PS_VALUE, "mktime failed");
+    }
+    return (double)t;
+}
+
+void ps_date_today_fill(PsDate *out) {
+    PsStructTime st;
+    ps_local(ps_time_time(), &st);
+    out->year = st.tm_year;
+    out->month = st.tm_mon;
+    out->day = st.tm_mday;
+}
+
+void ps_dt_now_fill(PsDateTime *out) {
+    double now = ps_time_time();
+    double whole = floor(now);
+    double frac = now - whole;
+    PsStructTime st;
+    int64_t us;
+    if (frac < 0) {
+        frac = 0;
+    }
+    us = (int64_t)(frac * 1000000.0);
+    if (us < 0) {
+        us = 0;
+    }
+    if (us > 999999) {
+        us = 999999;
+    }
+    ps_local(whole, &st);
+    out->year = st.tm_year;
+    out->month = st.tm_mon;
+    out->day = st.tm_mday;
+    out->hour = st.tm_hour;
+    out->minute = st.tm_min;
+    out->second = st.tm_sec;
+    out->microsecond = us;
+}