|
| 1 | +package sjsonnet.stdlib |
| 2 | + |
| 3 | +import scala.scalanative.unsafe._ |
| 4 | +import scala.scalanative.unsigned._ |
| 5 | + |
| 6 | +/** |
| 7 | + * Scala Native implementation of base64 encode/decode. |
| 8 | + * |
| 9 | + * Uses the aklomp/base64 C library (BSD-2-Clause) which provides SIMD-accelerated base64 via |
| 10 | + * runtime CPU detection: |
| 11 | + * - x86_64: SSSE3 / SSE4.1 / SSE4.2 / AVX / AVX2 / AVX-512 |
| 12 | + * - AArch64: NEON |
| 13 | + * - Fallback: optimized generic C implementation |
| 14 | + * |
| 15 | + * The static library is built by CMake and linked via nativeLinkingOptions. |
| 16 | + * |
| 17 | + * Both aklomp/base64 and C++ jsonnet (the reference implementation) use strict RFC 4648 mode: |
| 18 | + * padding is required, unpadded input is rejected. This differs from java.util.Base64 on JVM which |
| 19 | + * is more lenient (accepts unpadded input) — that JVM leniency is a pre-existing sjsonnet bug, not |
| 20 | + * something we replicate here. |
| 21 | + */ |
| 22 | +@extern |
| 23 | +private[stdlib] object libbase64 { |
| 24 | + def base64_encode( |
| 25 | + src: Ptr[CChar], |
| 26 | + srclen: CSize, |
| 27 | + out: Ptr[CChar], |
| 28 | + outlen: Ptr[CSize], |
| 29 | + flags: CInt |
| 30 | + ): Unit = extern |
| 31 | + |
| 32 | + def base64_decode( |
| 33 | + src: Ptr[CChar], |
| 34 | + srclen: CSize, |
| 35 | + out: Ptr[CChar], |
| 36 | + outlen: Ptr[CSize], |
| 37 | + flags: CInt |
| 38 | + ): CInt = extern |
| 39 | +} |
| 40 | + |
| 41 | +object PlatformBase64 { |
| 42 | + |
| 43 | + // Base64 alphabet lookup: A-Z(0-25), a-z(26-51), 0-9(52-61), +(62), /(63) |
| 44 | + // -1 = invalid character |
| 45 | + private val DECODE_TABLE: Array[Int] = { |
| 46 | + val t = Array.fill[Int](256)(-1) |
| 47 | + var i = 0 |
| 48 | + while (i < 26) { t('A' + i) = i; i += 1 } |
| 49 | + i = 0 |
| 50 | + while (i < 26) { t('a' + i) = i + 26; i += 1 } |
| 51 | + i = 0 |
| 52 | + while (i < 10) { t('0' + i) = i + 52; i += 1 } |
| 53 | + t('+') = 62 |
| 54 | + t('/') = 63 |
| 55 | + t |
| 56 | + } |
| 57 | + |
| 58 | + /** |
| 59 | + * Diagnose why base64 decode failed and throw a JVM-compatible error message. Only called on the |
| 60 | + * error path (after aklomp/base64 returns failure), so zero overhead on the hot path. |
| 61 | + * |
| 62 | + * Error messages match java.util.Base64.Decoder behavior for golden test compatibility: |
| 63 | + * - Invalid character: "Illegal base64 character XX" (hex) |
| 64 | + * - Wrong length/padding: "Last unit does not have enough valid bits" |
| 65 | + */ |
| 66 | + private def throwDecodeError(srcBytes: Array[Byte]): Nothing = { |
| 67 | + val len = srcBytes.length |
| 68 | + |
| 69 | + // Scan for invalid characters (first error wins) |
| 70 | + var i = 0 |
| 71 | + while (i < len) { |
| 72 | + val b = srcBytes(i) & 0xff |
| 73 | + if (b != '='.toInt) { |
| 74 | + if (b >= DECODE_TABLE.length || DECODE_TABLE(b) < 0) { |
| 75 | + throw new IllegalArgumentException( |
| 76 | + "Illegal base64 character " + Integer.toHexString(b) |
| 77 | + ) |
| 78 | + } |
| 79 | + } |
| 80 | + i += 1 |
| 81 | + } |
| 82 | + |
| 83 | + // No invalid characters found — must be a length/padding issue |
| 84 | + throw new IllegalArgumentException( |
| 85 | + "Last unit does not have enough valid bits" |
| 86 | + ) |
| 87 | + } |
| 88 | + |
| 89 | + def encodeToString(input: Array[Byte]): String = { |
| 90 | + if (input.length == 0) return "" |
| 91 | + val maxOutLen = ((input.length + 2) / 3) * 4 |
| 92 | + Zone.acquire { implicit z => |
| 93 | + val srcPtr = alloc[Byte](input.length.toUSize) |
| 94 | + var i = 0 |
| 95 | + while (i < input.length) { |
| 96 | + !(srcPtr + i) = input(i) |
| 97 | + i += 1 |
| 98 | + } |
| 99 | + val outPtr = alloc[Byte]((maxOutLen + 1).toUSize) |
| 100 | + val outLenPtr = alloc[CSize](1.toUSize) |
| 101 | + libbase64.base64_encode(srcPtr, input.length.toUSize, outPtr, outLenPtr, 0) |
| 102 | + val actualLen = (!outLenPtr).toInt |
| 103 | + val result = new Array[Byte](actualLen) |
| 104 | + i = 0 |
| 105 | + while (i < actualLen) { |
| 106 | + result(i) = !(outPtr + i) |
| 107 | + i += 1 |
| 108 | + } |
| 109 | + new String(result, "US-ASCII") |
| 110 | + } |
| 111 | + } |
| 112 | + |
| 113 | + def decode(input: String): Array[Byte] = { |
| 114 | + if (input.isEmpty) return Array.emptyByteArray |
| 115 | + val srcBytes = input.getBytes("US-ASCII") |
| 116 | + val maxOutLen = ((srcBytes.length / 4) * 3) + 3 |
| 117 | + Zone.acquire { implicit z => |
| 118 | + val srcPtr = alloc[Byte](srcBytes.length.toUSize) |
| 119 | + var i = 0 |
| 120 | + while (i < srcBytes.length) { |
| 121 | + !(srcPtr + i) = srcBytes(i) |
| 122 | + i += 1 |
| 123 | + } |
| 124 | + val outPtr = alloc[Byte]((maxOutLen + 1).toUSize) |
| 125 | + val outLenPtr = alloc[CSize](1.toUSize) |
| 126 | + val ret = |
| 127 | + libbase64.base64_decode(srcPtr, srcBytes.length.toUSize, outPtr, outLenPtr, 0) |
| 128 | + if (ret == 0) { |
| 129 | + throwDecodeError(srcBytes) |
| 130 | + } |
| 131 | + val actualLen = (!outLenPtr).toInt |
| 132 | + val result = new Array[Byte](actualLen) |
| 133 | + i = 0 |
| 134 | + while (i < actualLen) { |
| 135 | + result(i) = !(outPtr + i) |
| 136 | + i += 1 |
| 137 | + } |
| 138 | + result |
| 139 | + } |
| 140 | + } |
| 141 | +} |
0 commit comments