tranfi 0.0.2 → 0.2.0

package/csrc/compiler.c

@@ -0,0 +1,130 @@
+/*
+ * compiler.c — L2 IR → L1 native target compilation.
+ *
+ * Iterates IR nodes, looks up each op in the registry,
+ * and calls create_native() to build live decoder/steps/encoder structs.
+ * This is the single native construction path for JSON IR plans.
+ */
+
+#include "ir.h"
+#include "internal.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+static void set_error(char **error, const char *msg) {
+    if (error) {
+        free(*error);
+        size_t len = strlen(msg) + 1;
+        *error = malloc(len);
+        if (*error) memcpy(*error, msg, len);
+    }
+}
+
+int tf_compile_native(const tf_ir_plan *plan,
+                      tf_decoder **out_decoder, tf_step ***out_steps,
+                      size_t *out_n_steps, tf_encoder **out_encoder,
+                      char **error) {
+    *out_decoder = NULL;
+    *out_steps = NULL;
+    *out_n_steps = 0;
+    *out_encoder = NULL;
+    if (error) *error = NULL;
+
+    if (!plan || plan->n_nodes == 0) {
+        set_error(error, "empty plan");
+        return TF_ERROR;
+    }
+
+    /* Allocate steps array (max = n_nodes, since some are decoder/encoder) */
+    tf_step **steps = calloc(plan->n_nodes, sizeof(tf_step *));
+    if (!steps) {
+        set_error(error, "out of memory");
+        return TF_ERROR;
+    }
+    size_t n_steps = 0;
+    tf_decoder *decoder = NULL;
+    tf_encoder *encoder = NULL;
+
+    for (size_t i = 0; i < plan->n_nodes; i++) {
+        const tf_ir_node *node = &plan->nodes[i];
+        const tf_op_entry *entry = tf_op_registry_find(node->op);
+
+        if (!entry) {
+            char buf[256];
+            snprintf(buf, sizeof(buf), "unknown op: '%s'", node->op);
+            set_error(error, buf);
+            goto fail;
+        }
+
+        if (!entry->create_native) {
+            if (entry->tier == TF_TIER_ECOSYSTEM) {
+                /* Ecosystem stubs are skipped — host must handle */
+                char buf[256];
+                snprintf(buf, sizeof(buf), "op '%s' has no native target", node->op);
+                set_error(error, buf);
+                goto fail;
+            }
+            /* Core ops with NULL constructor are no-ops (e.g. flatten) */
+            continue;
+        }
+
+        void *obj = entry->create_native(node->args);
+        if (!obj) {
+            const char *detail = tf_last_error();
+            char buf[512];
+            if (detail && detail[0])
+                snprintf(buf, sizeof(buf), "failed to create '%s': %s", node->op, detail);
+            else
+                snprintf(buf, sizeof(buf), "failed to create '%s'", node->op);
+            set_error(error, buf);
+            goto fail;
+        }
+
+        switch (entry->kind) {
+        case TF_OP_DECODER:
+            if (decoder) {
+                ((tf_decoder *)obj)->destroy((tf_decoder *)obj);
+                set_error(error, "multiple decoders");
+                goto fail;
+            }
+            decoder = (tf_decoder *)obj;
+            break;
+        case TF_OP_ENCODER:
+            if (encoder) {
+                ((tf_encoder *)obj)->destroy((tf_encoder *)obj);
+                set_error(error, "multiple encoders");
+                goto fail;
+            }
+            encoder = (tf_encoder *)obj;
+            break;
+        case TF_OP_TRANSFORM:
+            steps[n_steps++] = (tf_step *)obj;
+            break;
+        }
+    }
+
+    if (!decoder) {
+        set_error(error, "plan missing decoder");
+        goto fail;
+    }
+    if (!encoder) {
+        set_error(error, "plan missing encoder");
+        goto fail;
+    }
+
+    *out_decoder = decoder;
+    *out_steps = steps;
+    *out_n_steps = n_steps;
+    *out_encoder = encoder;
+    return TF_OK;
+
+fail:
+    if (decoder) decoder->destroy(decoder);
+    if (encoder) encoder->destroy(encoder);
+    for (size_t i = 0; i < n_steps; i++) {
+        if (steps[i]) steps[i]->destroy(steps[i]);
+    }
+    free(steps);
+    return TF_ERROR;
+}

package/csrc/config.h

@@ -0,0 +1,21 @@
+/*
+ * config.h -- Tranfi C feature-test configuration.
+ *
+ * Build files also define these macros at compile-command level so they are
+ * visible before any system header in every translation unit. This header
+ * documents the source contract and protects internal/public headers included
+ * first.
+ */
+
+#ifndef TF_CONFIG_H
+#define TF_CONFIG_H
+
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 700
+#endif
+
+#endif /* TF_CONFIG_H */

package/csrc/date_utils.h

@@ -0,0 +1,94 @@
+/*
+ * date_utils.h — Date/timestamp conversion utilities (header-only).
+ *
+ * Uses Howard Hinnant's civil date algorithms (public domain).
+ * Epoch: 1970-01-01.  Date = int32_t days.  Timestamp = int64_t microseconds.
+ */
+
+#ifndef TF_DATE_UTILS_H
+#define TF_DATE_UTILS_H
+
+#include <stdint.h>
+#include <stdio.h>
+
+/* Days from civil date to epoch (1970-01-01 = 0). */
+static inline int32_t tf_date_from_ymd(int y, int m, int d) {
+    y -= (m <= 2);
+    int era = (y >= 0 ? y : y - 399) / 400;
+    unsigned yoe = (unsigned)(y - era * 400);
+    unsigned doy = (153 * (m > 2 ? m - 3 : m + 9) + 2) / 5 + (unsigned)d - 1;
+    unsigned doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    return era * 146097 + (int)doe - 719468;
+}
+
+/* Epoch days back to civil date. */
+static inline void tf_date_to_ymd(int32_t days, int *y, int *m, int *d) {
+    days += 719468;
+    int era = (days >= 0 ? days : days - 146096) / 146097;
+    unsigned doe = (unsigned)(days - era * 146097);
+    unsigned yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    *y = (int)yoe + era * 400;
+    unsigned doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    unsigned mp = (5 * doy + 2) / 153;
+    *d = (int)(doy - (153 * mp + 2) / 5 + 1);
+    *m = (int)(mp < 10 ? mp + 3 : mp - 9);
+    *y += (*m <= 2);
+}
+
+/* Microseconds since epoch to date/time components. */
+static inline void tf_timestamp_to_parts(int64_t us, int *y, int *mo, int *d,
+                                          int *h, int *mi, int *s, int *frac_us) {
+    int64_t day_us = 86400LL * 1000000LL;
+    int32_t days = (int32_t)(us / day_us);
+    int64_t rem = us % day_us;
+    if (rem < 0) { days--; rem += day_us; }
+    tf_date_to_ymd(days, y, mo, d);
+    *frac_us = (int)(rem % 1000000);
+    rem /= 1000000;
+    *s = (int)(rem % 60); rem /= 60;
+    *mi = (int)(rem % 60); rem /= 60;
+    *h = (int)rem;
+}
+
+/* Date/time components to microseconds since epoch. */
+static inline int64_t tf_timestamp_from_parts(int y, int mo, int d,
+                                               int h, int mi, int s, int frac_us) {
+    int32_t days = tf_date_from_ymd(y, mo, d);
+    return (int64_t)days * 86400LL * 1000000LL
+         + (int64_t)h * 3600000000LL
+         + (int64_t)mi * 60000000LL
+         + (int64_t)s * 1000000LL
+         + frac_us;
+}
+
+/* Weekday: 0=Sunday..6=Saturday. */
+static inline int tf_date_weekday(int32_t days) {
+    return days >= -4 ? (days + 4) % 7 : (days + 5) % 7 + 6;
+}
+
+/* Format date as YYYY-MM-DD into buf (must be >= 11 bytes). Returns buf. */
+static inline char *tf_date_format(int32_t days, char *buf, size_t buflen) {
+    int y, m, d;
+    tf_date_to_ymd(days, &y, &m, &d);
+    snprintf(buf, buflen, "%04d-%02d-%02d", y, m, d);
+    return buf;
+}
+
+/* Format timestamp as ISO 8601 into buf (must be >= 32 bytes). Returns buf. */
+static inline char *tf_timestamp_format(int64_t us, char *buf, size_t buflen) {
+    int y, mo, d, h, mi, s, frac;
+    tf_timestamp_to_parts(us, &y, &mo, &d, &h, &mi, &s, &frac);
+    if (frac > 0) {
+        int len = snprintf(buf, buflen, "%04d-%02d-%02dT%02d:%02d:%02d.%06d",
+                           y, mo, d, h, mi, s, frac);
+        /* Trim trailing zeros */
+        while (len > 0 && buf[len - 1] == '0') len--;
+        buf[len++] = 'Z';
+        buf[len] = '\0';
+    } else {
+        snprintf(buf, buflen, "%04d-%02d-%02dT%02d:%02d:%02dZ", y, mo, d, h, mi, s);
+    }
+    return buf;
+}
+
+#endif /* TF_DATE_UTILS_H */