databricks
diff --git a/‎sjsonnet/src-js/sjsonnet/CharSWAR.scala‎
Lines changed: 36 additions & 0 deletions b/‎sjsonnet/src-js/sjsonnet/CharSWAR.scala‎
Lines changed: 36 additions & 0 deletions
diff --git a/‎sjsonnet/src-jvm-native/sjsonnet/SjsonnetMainBase.scala‎
Lines changed: 87 additions & 12 deletions b/‎sjsonnet/src-jvm-native/sjsonnet/SjsonnetMainBase.scala‎
Lines changed: 87 additions & 12 deletions
diff --git a/‎sjsonnet/src-jvm/sjsonnet/CharSWAR.java‎
Lines changed: 141 additions & 0 deletions b/‎sjsonnet/src-jvm/sjsonnet/CharSWAR.java‎
Lines changed: 141 additions & 0 deletions
@@ -0,0 +1,36 @@
+package sjsonnet
+
+/** Scalar fallback for Scala.js — no SWAR, per-char scan. */
+object CharSWAR {
+  def hasEscapeChar(s: String): Boolean = {
+    var i = 0
+    val len = s.length
+    while (i < len) {
+      val c = s.charAt(i)
+      if (c < 32 || c == '"' || c == '\\') return true
+      i += 1
+    }
+    false
+  }
+
+  def hasEscapeChar(arr: Array[Char], from: Int, to: Int): Boolean = {
+    var i = from
+    while (i < to) {
+      val c = arr(i)
+      if (c < 32 || c == '"' || c == '\\') return true
+      i += 1
+    }
+    false
+  }
+
+  /** Scalar scan for byte[] — used by ByteRenderer for UTF-8 encoded data. */
+  def hasEscapeChar(arr: Array[Byte], from: Int, to: Int): Boolean = {
+    var i = from
+    while (i < to) {
+      val b = arr(i) & 0xff
+      if (b < 32 || b == '"' || b == '\\') return true
+      i += 1
+    }
+    false
+  }
+}
@@ -5,6 +5,7 @@ import upickle.core.SimpleVisitor
 import java.io.{
   BufferedOutputStream,
   InputStream,
+  OutputStream,
   OutputStreamWriter,
   PrintStream,
   StringWriter,
@@ -16,6 +17,12 @@ import scala.annotation.unused
 import scala.util.Try
 
 object SjsonnetMainBase {
+
+  /**
+   * Sentinel value returned when output was already written directly to stdout via byte pipeline.
+   */
+  private val ByteRenderedSentinel = "\u0000"
+
   class SimpleImporter(
       searchRoots0: Seq[Path], // Evaluated in order, first occurrence wins
       allowedInputs: Option[Set[os.Path]] = None,
@@ -101,7 +108,33 @@ object SjsonnetMainBase {
       allowedInputs: Option[Set[os.Path]] = None,
       importer: Option[Importer] = None,
       std: Val.Obj = sjsonnet.stdlib.StdLibModule.Default.module,
-      jsonnetPathEnv: Option[String] = None): Int = {
+      jsonnetPathEnv: Option[String] = None): Int =
+    main0(
+      args,
+      parseCache,
+      null.asInstanceOf[InputStream], // stdin is @unused in the target overload
+      stdout,
+      stderr,
+      wd,
+      allowedInputs,
+      importer,
+      std,
+      jsonnetPathEnv,
+      rawOutputStream = null
+    )
+
+  def main0(
+      args: Array[String],
+      parseCache: ParseCache,
+      @unused stdin: InputStream,
+      stdout: PrintStream,
+      stderr: PrintStream,
+      wd: os.Path,
+      allowedInputs: Option[Set[os.Path]],
+      importer: Option[Importer],
+      std: Val.Obj,
+      jsonnetPathEnv: Option[String],
+      rawOutputStream: OutputStream): Int = {
 
     var hasWarnings = false
     def warn(isTrace: Boolean, msg: String): Unit = {
@@ -170,7 +203,8 @@ object SjsonnetMainBase {
         warn,
         std,
         debugStats = debugStats,
-        profileOpt = config.profile
+        profileOpt = config.profile,
+        stdoutStream = if (rawOutputStream != null) rawOutputStream else stdout
       )
       res <- {
         if (hasWarnings && config.fatalWarnings.value) Left("")
@@ -185,7 +219,20 @@ object SjsonnetMainBase {
         if (err.nonEmpty) stderr.println(err)
         1
       case Right((config, str)) =>
-        if (str.nonEmpty) {
+        if (str eq ByteRenderedSentinel) {
+          // Output was already written directly to stdout via byte pipeline.
+          // Handle trailing newline.
+          if (config.multi.isDefined || !config.noTrailingNewline.value) {
+            if (rawOutputStream != null) {
+              rawOutputStream.write('\n')
+              rawOutputStream.flush()
+            } else {
+              stdout.write('\n')
+              stdout.flush()
+            }
+          } else if (rawOutputStream != null) rawOutputStream.flush()
+          else stdout.flush()
+        } else if (str.nonEmpty) {
           config.outputFile match {
             case None =>
               // In multi mode, the file list on stdout always ends with a newline,
@@ -263,12 +310,37 @@ object SjsonnetMainBase {
       jsonnetCode: String,
       path: os.Path,
       wd: os.Path,
-      getCurrentPosition: () => Position) = {
-    writeToFile(config, wd) { writer =>
-      val renderer = rendererForConfig(writer, config, getCurrentPosition)
-      val res = interp.interpret0(jsonnetCode, OsPath(path), renderer)
-      if (config.yamlOut.value && !config.noTrailingNewline.value) writer.write('\n')
-      res
+      getCurrentPosition: () => Position,
+      stdoutStream: OutputStream) = {
+    config.outputFile match {
+      case Some(f) if !config.yamlOut.value && !config.expectString.value =>
+        // Byte[] fast path: render directly to OutputStream, bypassing OutputStreamWriter.
+        // ByteBuilder handles buffering internally (8KB threshold), no BufferedOutputStream needed.
+        handleWriteFile(
+          os.write.over.outputStream(os.Path(f, wd), createFolders = config.createDirs.value)
+        ).flatMap { out =>
+          try {
+            val renderer = new ByteRenderer(out, indent = config.indent)
+            val res = interp.interpret0(jsonnetCode, OsPath(path), renderer)
+            out.flush()
+            res.map(_ => "")
+          } finally out.close()
+        }
+      case None if stdoutStream != null && !config.yamlOut.value && !config.expectString.value =>
+        // Byte[] fast path for stdout: render directly to OutputStream,
+        // bypassing StringWriter → String → println chain.
+        val renderer = new ByteRenderer(stdoutStream, indent = config.indent)
+        val res = interp.interpret0(jsonnetCode, OsPath(path), renderer)
+        stdoutStream.flush()
+        // Return sentinel to signal main0 that output was already written.
+        res.map(_ => ByteRenderedSentinel)
+      case _ =>
+        writeToFile(config, wd) { writer =>
+          val renderer = rendererForConfig(writer, config, getCurrentPosition)
+          val res = interp.interpret0(jsonnetCode, OsPath(path), renderer)
+          if (config.yamlOut.value && !config.noTrailingNewline.value) writer.write('\n')
+          res
+        }
     }
   }
 
@@ -320,7 +392,8 @@ object SjsonnetMainBase {
       std: Val.Obj,
       evaluatorOverride: Option[Evaluator] = None,
       debugStats: DebugStats = null,
-      profileOpt: Option[String] = None): Either[String, String] = {
+      profileOpt: Option[String] = None,
+      stdoutStream: OutputStream = null): Either[String, String] = {
 
     val (jsonnetCode, path) =
       if (config.exec.value) (file, wd / Util.wrapInLessThanGreaterThan("exec"))
@@ -455,9 +528,11 @@ object SjsonnetMainBase {
               Right("")
             }
 
-          case _ => renderNormal(config, interp, jsonnetCode, path, wd, () => currentPos)
+          case _ =>
+            renderNormal(config, interp, jsonnetCode, path, wd, () => currentPos, stdoutStream)
         }
-      case _ => renderNormal(config, interp, jsonnetCode, path, wd, () => currentPos)
+      case _ =>
+        renderNormal(config, interp, jsonnetCode, path, wd, () => currentPos, stdoutStream)
     }
 
     if (profilerInstance != null)
 
@@ -0,0 +1,141 @@
+package sjsonnet;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * SWAR (SIMD Within A Register) escape-char scanner for JSON string rendering.
+ *
+ * <p>Detects characters requiring JSON escaping: control chars ({@code < 32}),
+ * double-quote ({@code '"'}), and backslash ({@code '\\'}).
+ *
+ * <p>For strings above a threshold length, converts to ISO-8859-1 bytes and
+ * processes 8 bytes at a time using {@link VarHandle} bulk reads + Hacker's
+ * Delight zero-detection formula. For shorter strings, uses a scalar charAt loop.
+ *
+ * <p>Based on the SWAR technique from Hacker's Delight Ch. 6, as used by
+ * <a href="https://github.com/netty/netty/blob/4.2/common/src/main/java/io/netty/util/internal/SWARUtil.java">
+ * Netty SWARUtil</a> and
+ * <a href="https://github.com/apache/pekko/blob/main/actor/src/main/scala/org/apache/pekko/util/SWARUtil.scala">
+ * Apache Pekko SWARUtil</a>.
+ *
+ * @see <a href="https://richardstartin.github.io/posts/finding-bytes">Finding Bytes in Arrays</a>
+ */
+final class CharSWAR {
+    private CharSWAR() {}
+
+    // VarHandle for reading longs from byte[] — replaces sun.misc.Unsafe.
+    // Following Netty VarHandleFactory pattern:
+    //   MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder)
+    private static final VarHandle LONG_VIEW =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.nativeOrder());
+
+    // --- 8-bit SWAR constants (Netty/Pekko pattern) ---
+    //
+    // Hacker's Delight zero-detection for 8-bit lanes:
+    //   input = word ^ pattern          // zero bytes where byte matches
+    //   tmp = (input & 0x7F7F...) + 0x7F7F...  // carry into bit 7 iff non-zero
+    //   result = ~(tmp | input | 0x7F7F...)     // bit 7 set iff lane was zero
+
+    private static final long HOLE  = 0x7F7F_7F7F_7F7F_7F7FL;
+
+    /** Broadcast '"' (0x22) to all 8 byte lanes. */
+    private static final long QUOTE = 0x2222_2222_2222_2222L;
+
+    /** Broadcast '\\' (0x5C) to all 8 byte lanes. */
+    private static final long BSLAS = 0x5C5C_5C5C_5C5C_5C5CL;
+
+    /** Mask for bits 5-7 of each byte; zero result means byte < 32. */
+    private static final long CTRL  = 0xE0E0_E0E0_E0E0_E0E0L;
+
+    /** Below this length, scalar charAt is faster than SWAR + byte[] conversion. */
+    private static final int SWAR_THRESHOLD = 128;
+
+    /**
+     * Check if any char in {@code str} needs JSON string escaping.
+     * Scan-first API: call on the String before copying to the output buffer.
+     */
+    static boolean hasEscapeChar(String str) {
+        int len = str.length();
+        if (len < SWAR_THRESHOLD) {
+            return hasEscapeCharScalar(str, len);
+        }
+        // ISO-8859-1 encoding is a JVM intrinsic for LATIN1 compact strings —
+        // essentially a memcpy of the internal byte[]. Chars > 255 map to '?'
+        // (0x3F), which is safe (not a control char, not '"', not '\\').
+        byte[] bytes = str.getBytes(StandardCharsets.ISO_8859_1);
+        return hasEscapeCharSWAR(bytes, 0, bytes.length);
+    }
+
+    /**
+     * Check if any byte in {@code arr[from..to)} needs JSON string escaping.
+     * Used by ByteRenderer for in-place SWAR scan on byte[] buffers.
+     * UTF-8 multi-byte sequences never produce bytes matching '"', '\\', or &lt; 0x20,
+     * so this is safe for scanning UTF-8 encoded data.
+     */
+    static boolean hasEscapeChar(byte[] arr, int from, int to) {
+        return hasEscapeCharSWAR(arr, from, to);
+    }
+
+    /**
+     * Check if any char in {@code arr[from..to)} needs JSON string escaping.
+     */
+    static boolean hasEscapeChar(char[] arr, int from, int to) {
+        for (int i = from; i < to; i++) {
+            char c = arr[i];
+            if (c < 32 || c == '"' || c == '\\') return true;
+        }
+        return false;
+    }
+
+    private static boolean hasEscapeCharSWAR(byte[] arr, int from, int to) {
+        int i = from;
+        int limit = to - 7; // 8 bytes per VarHandle.get
+        while (i < limit) {
+            long word = (long) LONG_VIEW.get(arr, i);
+            if (swarHasMatch(word)) return true;
+            i += 8;
+        }
+        // Tail: remaining 0-7 bytes
+        while (i < to) {
+            int b = arr[i] & 0xFF;
+            if (b < 32 || b == '"' || b == '\\') return true;
+            i++;
+        }
+        return false;
+    }
+
+    /**
+     * 8-bit SWAR: returns true if any byte lane in {@code word}
+     * contains '"' (0x22), '\\' (0x5C), or a control char (&lt; 0x20).
+     *
+     * <p>Uses Netty/Pekko pattern: XOR to produce zero lanes, then
+     * Hacker's Delight formula to detect zero bytes.
+     */
+    private static boolean swarHasMatch(long word) {
+        // 1. Detect '"' via XOR + zero-detection (Netty SWARUtil.applyPattern)
+        long q = word ^ QUOTE;
+        long qz = ~((q & HOLE) + HOLE | q | HOLE);
+
+        // 2. Detect '\\' via XOR + zero-detection
+        long b = word ^ BSLAS;
+        long bz = ~((b & HOLE) + HOLE | b | HOLE);
+
+        // 3. Detect control chars: byte & 0xE0 == 0 means bits 5-7 all zero → c < 32
+        long c = word & CTRL;
+        long cz = ~((c & HOLE) + HOLE | c | HOLE);
+
+        return (qz | bz | cz) != 0L;
+    }
+
+    /** Scalar scan for String (used for short strings). */
+    private static boolean hasEscapeCharScalar(String s, int len) {
+        for (int i = 0; i < len; i++) {
+            char c = s.charAt(i);
+            if (c < 32 || c == '"' || c == '\\') return true;
+        }
+        return false;
+    }
+}