Add Gloat/Glojure build for libyamlstar

Replace GraalVM native-image with Gloat (Glojure AOT → Go →
c-shared) for the shared library build:

- Replace Java interop with Go interop in core Clojure files
  - prelude.clj: os.Getenv, fmt.Sprintf, fmt.Fprintln
  - parser.clj: TRACE uses os.Getenv comparison
  - receiver.clj: strconv.ParseInt for hex/Unicode escapes
  - constructor.clj: strconv.ParseInt/ParseFloat, math.Inf/NaN
- Fix debug env checks: (not-empty (os.Getenv key)) so empty
  string is treated as falsy
- Fix empty-mapping construction: use reduce/partition instead
  of array-map which fails in Glojure
- Add libyamlstar.clj: Gloat EXPORT bridge replacing gen-class
  and GraalVM @centrypoint, exports yamlstar_load and
  yamlstar_version as C-compatible functions

Author: ingydotnet

core/src/yamlstar/constructor.clj

@@ -10,19 +10,23 @@
   Each constructor takes a node and returns native Clojure data.
   Supports both short form (!!null) and fully qualified (tag:yaml.org,2002:null) tags."
   (let [null-fn  (fn [_node] nil)
-        bool-fn  (fn [node] (Boolean/parseBoolean (:value node)))
-        int-fn   (fn [node] (Long/parseLong (:value node)))
+        bool-fn  (fn [node]
+                   (contains? #{"true" "True" "TRUE"} (:value node)))
+        int-fn   (fn [node]
+                   (let [[n _] (strconv.ParseInt (:value node) 10 64)]
+                     n))
         float-fn (fn [node]
                    (let [value (:value node)]
                      (cond
                        (re-matches #"[+-]?\.inf|\.Inf|\.INF" value)
-                       (if (= (first value) \-) Double/NEGATIVE_INFINITY Double/POSITIVE_INFINITY)
+                       (if (= (first value) \-) (math.Inf -1) (math.Inf 1))
 
                        (re-matches #"\.nan|\.NaN|\.NAN" value)
-                       Double/NaN
+                       (math.NaN)
 
                        :else
-                       (Double/parseDouble value))))
+                       (let [[f _] (strconv.ParseFloat value 64)]
+                         f))))
         str-fn   (fn [node] (:value node))]
     {"!!null"                  null-fn
      "tag:yaml.org,2002:null"  null-fn
@@ -65,7 +69,7 @@
                                           (construct-node val-node anchors)))
                                   []
                                   pairs)]
-              (apply array-map entries))
+              (reduce (fn [m [k v]] (assoc m k v)) {} (partition 2 entries)))
 
             :sequence
             (let [items (:value node)]

core/src/yamlstar/parser/grammar.clj

@@ -272,8 +272,8 @@
       "\uFFFD"
     ),
     (p/rng parser
-       (String. (int-array [0x010000]) 0 1),
-      (String. (int-array [0x10FFFF]) 0 1)
+       "𐀀",
+      "􏿿"
     )
   ))
     {:trace "c_printable" :name "c_printable"}))
@@ -291,7 +291,7 @@
     ),
     (p/rng parser
        "\u0020",
-      (String. (int-array [0x10FFFF]) 0 1)
+      "􏿿"
     )
   ))
     {:trace "nb_json" :name "nb_json"}))

core/src/yamlstar/parser/parser.clj

@@ -6,7 +6,7 @@
 (declare auto-detect auto-detect-indent trace-start trace-flush)
 
 ;; TRACE flag from environment
-(def TRACE (Boolean/parseBoolean (or (env "TRACE") "false")))
+(def TRACE (= (os.Getenv "TRACE") "true"))
 
 ;; Default state when stack is empty
 (def default-state
@@ -202,8 +202,13 @@
   (or (end-of-stream* parser)
       (and (:doc (state-curr parser))
            (start-of-line* parser)
-           (let [remaining (subs @(:input parser) @(:pos parser))]
-             (re-find #"^(?:---|\.\.\.)(?=\s|$)" remaining)))))
+           ;; RE2 doesn't support lookaheads; check the char after manually
+           (let [remaining (subs @(:input parser) @(:pos parser))
+                 prefix (re-find #"^(?:---|\.\.\.)" remaining)]
+             (when prefix
+               (let [after (subs remaining (count prefix))]
+                 (or (empty? after)
+                     (re-find #"^\s" after))))))))
 
 ;; Grammar-callable versions (return functions)
 (defn start-of-line [parser]
@@ -240,9 +245,9 @@
               remaining (subs input pos)
               pattern (re-pattern (str "^[" low "-" high "]"))]
           (when (re-find pattern remaining)
-            ;; Handle surrogate pairs
-            (let [cp (.codePointAt remaining 0)]
-              (when (> cp 65535)
+            ;; Handle multi-byte runes (Go uses UTF-8, advance by rune width)
+            (let [[r _] (unicode:utf8.DecodeRuneInString remaining)]
+              (when (> (int r) 65535)
                 (swap! (:pos p) inc)))
             (swap! (:pos p) inc)
             true))))

core/src/yamlstar/parser/prelude.clj

@@ -1,13 +1,13 @@
 (ns yamlstar.parser.prelude
   (:require [clojure.string :as str]))
 
-;; Environment access
+;; Environment access - returns nil (falsy) when not set
 (defn env [key]
-  (System/getenv key))
+  (not-empty (os.Getenv key)))
 
 ;; Type checking predicates
 (defn is-null? [x] (nil? x))
-(defn is-boolean? [x] (instance? Boolean x))
+(defn is-boolean? [x] (or (true? x) (false? x)))
 (defn is-number? [x] (number? x))
 (defn is-string? [x] (string? x))
 (defn is-function? [x] (fn? x))
@@ -17,15 +17,15 @@
 (defn typeof* [value]
   (cond
     (nil? value) "null"
-    (instance? Boolean value) "boolean"
+    (or (true? value) (false? value)) "boolean"
     (number? value) "number"
     (string? value) "string"
     (keyword? value) "string"  ;; Keywords treated as strings
     (symbol? value) "string"   ;; Symbols treated as strings
     (fn? value) "function"
     (or (vector? value) (seq? value)) "array"
     (map? value) "object"
-    :else (throw (ex-info "Unknown type" {:value value :type (type value)}))))
+    :else (throw (ex-info "Unknown type" {:value value}))))
 
 ;; String helpers
 (defn stringify [o]
@@ -38,18 +38,17 @@
     :else (pr-str o)))
 
 (defn hex-char [chr]
-  (format "%x" (int (first chr))))
+  (fmt.Sprintf "%x" (int (first chr))))
 
 ;; Debug and error functions
 (defn warn [msg]
-  (binding [*out* *err*]
-    (println msg)))
+  (fmt.Fprintln os.Stderr msg))
 
 (defn die [msg]
   (throw (ex-info msg {})))
 
 (defn die* [msg]
-  (die (str (.getStackTrace (Thread/currentThread)) "\n" msg)))
+  (die msg))
 
 (defn debug [msg]
   (warn (str ">>> " msg)))
@@ -68,7 +67,7 @@
 (defn name* [name func trace]
   (with-meta func {:trace (or trace name)}))
 
-;; Timer (for performance measurement)
+;; Timer (for performance measurement - stubbed, tracing not used in Glojure)
 (defn timer
-  ([] (System/nanoTime))
-  ([start] (/ (- (System/nanoTime) start) 1000000000.0)))
+  ([] 0)
+  ([start] 0.0))

core/src/yamlstar/parser/receiver.clj

@@ -1,10 +1,16 @@
 (ns yamlstar.parser.receiver
   (:require [clojure.string :as str]
-            [yamlstar.parser.prelude :refer :all]))
+            [yamlstar.parser.prelude :refer :all]
+            [yamlstar.parser.parser :as parser]))
 
 ;; Forward declarations
 (declare push-event check-document-start check-document-end)
 
+;; Helper: convert hex string to Unicode character string
+(defn hex->char [hex-val]
+  (let [[n _] (strconv.ParseInt hex-val 16 32)]
+    (str (go/rune n))))
+
 ;; Event constructors
 (defn stream-start-event []
   {:event "stream_start"})
@@ -190,15 +196,17 @@
                        ;; hex escapes
                        (re-matches (re-pattern (str "\\\\x(" hex "{2})")) match)
                        (let [[_ hex-val] (re-matches (re-pattern (str "\\\\x(" hex "{2})")) match)]
-                         (str (char (Integer/parseInt hex-val 16))))
+                         (hex->char hex-val))
 
                        (re-matches (re-pattern (str "\\\\u(" hex "{4})")) match)
                        (let [[_ hex-val] (re-matches (re-pattern (str "\\\\u(" hex "{4})")) match)]
-                         (str (char (Integer/parseInt hex-val 16))))
+                         (hex->char hex-val))
 
                        (re-matches (re-pattern (str "\\\\U(" hex "{8})")) match)
                        (let [[_ hex-val] (re-matches (re-pattern (str "\\\\U(" hex "{8})")) match)]
-                         (String. (Character/toChars (Integer/parseInt hex-val 16))))
+                         ;; go/rune handles all Unicode including above U+FFFF
+                         (let [[n _] (strconv.ParseInt hex-val 16 32)]
+                           (str (go/rune n))))
 
                        ;; line continuation
                        (re-matches #"(?:\\ ?\r?\n[ \t]*)" match)
@@ -440,9 +448,8 @@
            lines (map #(str (:text %) "\n") lines)
            text (apply str lines)
            ;; :parser is stored directly (not as atom) in the receiver passed to callbacks
-           parser (:parser receiver)
-           state-curr @(requiring-resolve 'yamlstar.parser.parser/state-curr)
-           t (:t (state-curr parser))
+           p (:parser receiver)
+           t (:t (parser/state-curr p))
            text (cond
                   (= t "clip") (str/replace text #"\n+$" "\n")
                   (= t "strip") (str/replace text #"\n+$" "")
@@ -485,15 +492,15 @@
      (reset! (:in-scalar receiver) false)
      (let [lines (map :text (cache-drop receiver))
            text (str/join "\n" lines)
+           ;; RE2 doesn't support lookaheads; capture and reinsert next char
            text (-> text
-                    (str/replace #"(?m)^(\S.*)\n(?=\S)" "$1 ")
+                    (str/replace #"(?m)^(\S.*)\n(\S)" "$1 $2")
                     (str/replace #"(?m)^(\S.*)\n(\n+)" "$1$2")
-                    (str/replace #"(?m)^([ \t]+\S.*)\n(\n+)(?=\S)" "$1$2"))
+                    (str/replace #"(?m)^([ \t]+\S.*)\n(\n+)(\S)" "$1$2$3"))
            text (str text "\n")
            ;; :parser is stored directly (not as atom) in the receiver passed to callbacks
-           parser (:parser receiver)
-           state-curr @(requiring-resolve 'yamlstar.parser.parser/state-curr)
-           t (:t (state-curr parser))
+           p (:parser receiver)
+           t (:t (parser/state-curr p))
            text (cond
                   (= t "clip") (let [t (str/replace text #"\n+$" "\n")]
                                  (if (= t "\n") "" t))
@@ -557,7 +564,7 @@
            ;; URL-decode percent escapes
            resolved-tag (str/replace resolved-tag #"%([0-9a-fA-F]{2})"
                                      (fn [[_ hex]]
-                                       (str (char (Integer/parseInt hex 16)))))]
+                                       (hex->char hex)))]
        (reset! (:tag receiver) resolved-tag)))
 
    ;; Alias node

libyamlstar/src/libyamlstar.clj

@@ -0,0 +1,38 @@
+(ns libyamlstar
+  "Shared library bridge - Gloat EXPORT-based C API for YAMLStar"
+  (:require [clojure.string :as str]
+            [yamlstar.core :as yaml]
+            [ys.json :as json]))
+
+(def EXPORT
+  {"yamlstar-load"    [:str :str :str]
+   "yamlstar-version" [:str]})
+
+(defn nil-keys->string
+  "Replace nil keys with string 'null' for JSON serialization.
+  JSON allows null values but not null keys."
+  [x]
+  (cond
+    (map? x) (into {} (map (fn [[k v]]
+                              [(if (nil? k) "null" (nil-keys->string k))
+                               (nil-keys->string v)])
+                            x))
+    (vector? x) (mapv nil-keys->string x)
+    (sequential? x) (map nil-keys->string x)
+    :else x))
+
+(defn yamlstar-load
+  "Load YAML string, return JSON string with {:data ...} or {:error ...}"
+  [yaml-str opts-json]
+  (try
+    (let [result (yaml/load yaml-str)]
+      (json/dump {:data (nil-keys->string result)}))
+    (catch go/any e
+      (json/dump {:error {:cause (str e)
+                          :type "Exception"
+                          :message (str e)}}))))
+
+(defn yamlstar-version
+  "Return the YAMLStar version string"
+  []
+  (yaml/version))