@fraczak/k 6.3.3 → 6.4.0

package/backends/llvm/runtime/krt.h

@@ -0,0 +1,109 @@
+#ifndef KRT_H
+#define KRT_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+typedef struct k_rt k_rt;
+typedef struct k_value k_value;
+
+typedef struct {
+  void *block;
+  size_t used;
+} k_rt_checkpoint;
+
+typedef struct {
+  const char *label;
+  size_t label_length;
+  size_t target;
+} k_pattern_edge;
+
+typedef struct {
+  int kind;
+  size_t edge_count;
+  k_pattern_edge *edges;
+} k_pattern_node;
+
+typedef struct {
+  size_t node_count;
+  k_pattern_node *nodes;
+} k_pattern;
+
+typedef struct {
+  k_value *value;
+  k_pattern *pattern;
+} k_wire_input;
+
+typedef struct {
+  unsigned char *bytes;
+  size_t length;
+  unsigned char current;
+  int bit_count;
+  int ok;
+} k_wire_prefix;
+
+enum {
+  KP_ANY,
+  KP_OPEN_PRODUCT,
+  KP_OPEN_UNION,
+  KP_CLOSED_PRODUCT,
+  KP_CLOSED_UNION
+};
+
+typedef struct {
+  int32_t status;
+  k_value *value;
+} k_result;
+
+enum {
+  K_STATUS_OK = 0,
+  K_STATUS_UNSUPPORTED = 1,
+  K_STATUS_TAIL_CALL = 2
+};
+
+k_rt *k_rt_new(void);
+void k_rt_reset(k_rt *rt);
+k_rt_checkpoint k_rt_mark(k_rt *rt);
+void k_rt_rewind(k_rt *rt, k_rt_checkpoint mark);
+void *k_rt_alloc(k_rt *rt, size_t size);
+void k_rt_free(k_rt *rt);
+
+k_value *k_unit(k_rt *rt);
+k_value *k_bit0(k_rt *rt);
+k_value *k_bit1(k_rt *rt);
+k_value *k_product(k_rt *rt, size_t count);
+void k_product_set_n(k_value *product, const char *label, size_t label_length, k_value *value);
+void k_product_set_borrowed_n(k_value *product, const char *label, size_t label_length, k_value *value);
+void k_product_set_at(k_value *product, size_t index, const char *label, size_t label_length, k_value *value);
+k_value *k_product_get_n(k_value *product, const char *label, size_t label_length);
+k_value *k_product_get_at(k_value *product, size_t index);
+void k_product_set(k_value *product, const char *label, k_value *value);
+k_value *k_product_get(k_value *product, const char *label);
+
+k_value *k_variant_n(k_rt *rt, const char *tag, size_t tag_length, k_value *payload);
+k_value *k_variant_borrowed_n(k_rt *rt, const char *tag, size_t tag_length, k_value *payload);
+k_value *k_variant_borrowed_direct_n(k_rt *rt, const char *tag, size_t tag_length, k_value *payload);
+k_value *k_variant_unit_borrowed_n(k_rt *rt, const char *tag, size_t tag_length);
+k_value *k_variant(k_rt *rt, const char *tag, k_value *payload);
+const char *k_variant_tag(k_value *value);
+size_t k_variant_tag_length(k_value *value);
+int k_variant_tag_matches(k_value *value, const char *tag, size_t tag_length);
+k_value *k_variant_payload(k_value *value);
+
+int k_equal(k_value *a, k_value *b);
+void k_print_json(FILE *out, k_value *value);
+k_value *k_read_wire(FILE *in, k_rt *rt);
+k_wire_input k_read_wire_envelope(FILE *in, k_rt *rt);
+k_wire_input k_decode_wire_envelope(const unsigned char *bytes, size_t length, k_rt *rt);
+void k_wire_input_free(k_wire_input input);
+int k_pattern_equal(k_pattern *a, k_pattern *b);
+k_wire_prefix k_wire_prefix_for_pattern(k_pattern *pattern);
+void k_wire_prefix_free(k_wire_prefix prefix);
+k_value *k_decode_wire_value_with_prefix(const unsigned char *bytes, size_t length, k_wire_prefix *prefix, k_pattern *pattern, k_rt *rt);
+unsigned char *k_encode_wire_as_with_prefix(k_wire_prefix *prefix, k_pattern *pattern, k_value *value, size_t *out_length);
+unsigned char *k_encode_wire_as(k_pattern *pattern, k_value *value, size_t *out_length);
+int k_write_wire(FILE *out, k_value *value);
+int k_write_wire_as(FILE *out, k_pattern *pattern, k_value *value);
+
+#endif

package/backends/llvm/scripts/conformance.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { argv, exit } from "node:process";
+import { fileURLToPath } from "node:url";
+import { compileObjectBuffer, decodeObject } from "@fraczak/k/object.mjs";
+import { parseValue } from "@fraczak/k/valueIO.mjs";
+import { compileObjectAndRun } from "../src/executable.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const kRoot = path.resolve(root, "../..");
+const conformanceRoot = path.join(kRoot, "conformance");
+
+function helpText() {
+  return [
+    "Run k-llvm executable conformance fixtures.",
+    "",
+    `Usage: ${argv[1]} [fixture-dir ...]`,
+    "",
+    "With no fixture dirs, every supported directory under ../../conformance is run."
+  ].join("\n");
+}
+
+function fixtureDirs(args) {
+  if (args.length > 0) return args.map((arg) => path.resolve(root, arg));
+  return fs.readdirSync(conformanceRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(conformanceRoot, entry.name))
+    .filter((dir) => fs.existsSync(path.join(dir, "case.json")))
+    .sort();
+}
+
+function readFixture(dir) {
+  const spec = JSON.parse(fs.readFileSync(path.join(dir, "case.json"), "utf8"));
+  return {
+    dir,
+    name: spec.name || path.basename(dir),
+    program: fs.readFileSync(path.join(dir, spec.program || "program.k"), "utf8"),
+    input: parseValue(fs.readFileSync(path.join(dir, spec.input || "input.kv"), "utf8")),
+    expected: parseValue(fs.readFileSync(path.join(dir, spec.expected || "expected.kv"), "utf8"))
+  };
+}
+
+function runFixture(fixture) {
+  const object = decodeObject(compileObjectBuffer(fixture.program, {
+    source: path.relative(kRoot, fixture.dir)
+  }));
+  compileObjectAndRun(object, {
+    input: fixture.input,
+    expected: fixture.expected
+  });
+}
+
+try {
+  const args = argv.slice(2);
+  if (args.includes("-h") || args.includes("--help")) {
+    console.log(helpText());
+    exit(0);
+  }
+  if (args.some((arg) => arg.startsWith("--"))) {
+    throw new Error(`Unknown option: ${args.find((arg) => arg.startsWith("--"))}`);
+  }
+
+  let count = 0;
+  for (const fixture of fixtureDirs(args).map(readFixture)) {
+    runFixture(fixture);
+    count++;
+    console.log(`ok ${fixture.name}`);
+  }
+  console.log(`OK ${count} fixtures`);
+} catch (error) {
+  console.error(error.stack || error.message || String(error));
+  console.error(helpText());
+  exit(1);
+}

package/backends/llvm/scripts/run-tests.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const node = process.execPath;
+const tests = [
+  ["tests/test-llvm.mjs", node, ["tests/test-llvm.mjs"]],
+  ["tests/integration.sh", path.join(root, "tests/integration.sh"), []],
+  ["scripts/conformance.mjs", node, ["scripts/conformance.mjs"]]
+];
+
+for (const [name, command, args] of tests) {
+  console.log(`\n==> ${name}`);
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: "inherit"
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) process.exit(result.status ?? 1);
+}
+
+console.log("\nAll tests passed");