ranger-compiler 3.2.0 → 3.5.0

package/dist/lib/zip/ZipBuffer.rgr

@@ -0,0 +1,358 @@
+; SPDX-License-Identifier: MIT
+
+; ZipBuffer.rgr - Little-endian buffer utilities for ZIP format
+; ZIP uses little-endian byte order (unlike JPEG which uses big-endian)
+
+class ZipBuffer {
+    def data:buffer (buffer_alloc 0)
+    def pos:int 0
+    def length:int 0
+    
+    Constructor () {
+    }
+    
+    fn initWithBuffer:void (buf:buffer) {
+        data = buf
+        length = (buffer_length buf)
+        pos = 0
+    }
+    
+    fn initWithSize:void (size:int) {
+        data = (buffer_alloc size)
+        length = size
+        pos = 0
+    }
+    
+    ; === Position Management ===
+    
+    fn getPosition:int () {
+        return pos
+    }
+    
+    fn setPosition:void (newPos:int) {
+        pos = newPos
+    }
+    
+    fn seek:void (offset:int) {
+        pos = offset
+    }
+    
+    fn skip:void (count:int) {
+        pos = pos + count
+    }
+    
+    fn remaining:int () {
+        return (length - pos)
+    }
+    
+    fn isEOF:boolean () {
+        return (pos >= length)
+    }
+    
+    ; === Little-Endian Read Operations ===
+    
+    fn readUint8:int () {
+        if (pos >= length) {
+            return 0
+        }
+        def value:int (buffer_get data pos)
+        pos = pos + 1
+        return value
+    }
+    
+    fn readUint16LE:int () {
+        ; Read 16-bit unsigned integer, little-endian (low byte first)
+        def b0:int (this.readUint8())
+        def b1:int (this.readUint8())
+        return (b0 + (b1 * 256))
+    }
+    
+    fn readUint32LE:int () {
+        ; Read 32-bit unsigned integer, little-endian
+        def b0:int (this.readUint8())
+        def b1:int (this.readUint8())
+        def b2:int (this.readUint8())
+        def b3:int (this.readUint8())
+        return (b0 + (b1 * 256) + (b2 * 65536) + (b3 * 16777216))
+    }
+    
+    fn readBytes:buffer (count:int) {
+        ; Read count bytes into a new buffer
+        def result:buffer (buffer_alloc count)
+        def i 0
+        while (i < count) {
+            if (pos < length) {
+                def b:int (buffer_get data pos)
+                buffer_set result i b
+                pos = pos + 1
+            }
+            i = i + 1
+        }
+        return result
+    }
+    
+    fn readString:string (count:int) {
+        ; Read count bytes as ASCII string
+        def result:string ""
+        def i 0
+        while (i < count) {
+            if (pos < length) {
+                def ch:int (buffer_get data pos)
+                result = (result + (strfromcode ch))
+                pos = pos + 1
+            }
+            i = i + 1
+        }
+        return result
+    }
+    
+    fn peekUint8:int () {
+        if (pos >= length) {
+            return 0
+        }
+        return (buffer_get data pos)
+    }
+    
+    fn peekUint32LE:int () {
+        def savedPos:int pos
+        def value:int (this.readUint32LE())
+        pos = savedPos
+        return value
+    }
+    
+    ; === Little-Endian Write Operations ===
+    
+    fn writeUint8:void (value:int) {
+        if (pos < length) {
+            buffer_set data pos value
+            pos = pos + 1
+        }
+    }
+    
+    fn writeUint16LE:void (value:int) {
+        ; Write 16-bit unsigned integer, little-endian (low byte first).
+        ; Use bit ops — signed `%` / `/` on C++ break for values with the high bit set.
+        def b0:int (bit_and value 255)
+        def b1:int (bit_and (bit_ushr value 8) 255)
+        this.writeUint8(b0)
+        this.writeUint8(b1)
+    }
+    
+    fn writeUint32LE:void (value:int) {
+        ; Write 32-bit unsigned integer, little-endian.
+        def b0:int (bit_and value 255)
+        def b1:int (bit_and (bit_ushr value 8) 255)
+        def b2:int (bit_and (bit_ushr value 16) 255)
+        def b3:int (bit_and (bit_ushr value 24) 255)
+        this.writeUint8(b0)
+        this.writeUint8(b1)
+        this.writeUint8(b2)
+        this.writeUint8(b3)
+    }
+    
+    fn writeBytes:void (src:buffer srcOffset:int count:int) {
+        def i 0
+        while (i < count) {
+            def b:int (buffer_get src (srcOffset + i))
+            this.writeUint8(b)
+            i = i + 1
+        }
+    }
+    
+    fn writeBuffer:void (src:buffer) {
+        def len:int (buffer_length src)
+        this.writeBytes(src 0 len)
+    }
+    
+    fn writeString:void (s:string) {
+        def len:int (strlen s)
+        def i 0
+        while (i < len) {
+            def ch:int (charAt s i)
+            this.writeUint8(ch)
+            i = i + 1
+        }
+    }
+    
+    ; === Buffer Access ===
+    
+    fn getBuffer:buffer () {
+        return data
+    }
+    
+    fn getLength:int () {
+        return length
+    }
+    
+    ; === Search Operations ===
+    
+    fn findSignatureBackward:int (sig:int startPos:int) {
+        ; Search backward from startPos for a 4-byte signature (little-endian)
+        ; Returns position of signature or -1 if not found
+        def searchPos:int startPos
+        while (searchPos >= 0) {
+            def savedPos:int pos
+            pos = searchPos
+            def value:int (this.readUint32LE())
+            pos = savedPos
+            if (value == sig) {
+                return searchPos
+            }
+            searchPos = searchPos - 1
+        }
+        return -1
+    }
+}
+
+; GrowableZipBuffer - Dynamic buffer that grows as needed
+; A ZIP is written front to back and its size is not known until it is
+; finished, so the bytes land in a chain of fixed chunks and are consolidated
+; once at the end. Two things matter for a big sheet — a 500,000-row export is
+; well over a hundred megabytes — and neither is about the chunking itself:
+;
+;   * Bytes move in BLOCKS. `buffer_copy` is memmove on the native target and
+;     a tight loop on the others; copying a hundred megabytes one
+;     `writeUint8` call at a time is the same work with a function call
+;     around every byte of it.
+;   * A chunk remembers how full it is. The old code assumed every chunk in
+;     the list was exactly `chunkSize` long, which is true only while nobody
+;     changes the chunk size — and silently writes garbage the moment
+;     somebody does.
+class GrowableZipBuffer {
+    def chunks:[buffer]
+    def chunkLens:[int]
+    def chunkSize:int 65536
+    def currentChunk:buffer (buffer_alloc 0)
+    def currentPos:int 0
+    def totalSize:int 0
+
+    Constructor () {
+        currentPos = 0
+        totalSize = 0
+        def initSize:int chunkSize
+        currentChunk = (buffer_alloc initSize)
+    }
+
+    ; Only meaningful before the first byte: the chunk being filled was
+    ; allocated at the old size and cannot be re-cut underneath itself.
+    fn setChunkSize:void (size:int) {
+        if (size < 1) {
+            return
+        }
+        if (totalSize > 0) {
+            return
+        }
+        chunkSize = size
+        currentChunk = (buffer_alloc size)
+        currentPos = 0
+    }
+
+    fn allocateNewChunk:void () {
+        push chunks currentChunk
+        push chunkLens currentPos
+        def size:int chunkSize
+        currentChunk = (buffer_alloc size)
+        currentPos = 0
+    }
+
+    fn writeUint8:void (value:int) {
+        if (currentPos >= chunkSize) {
+            this.allocateNewChunk()
+        }
+        buffer_set currentChunk currentPos value
+        currentPos = (currentPos + 1)
+        totalSize = (totalSize + 1)
+    }
+
+    fn writeUint16LE:void (value:int) {
+        def b0:int (value % 256)
+        def b1D:double ((to_double value) / 256.0)
+        def b1:int ((to_int b1D) % 256)
+        this.writeUint8(b0)
+        this.writeUint8(b1)
+    }
+
+    fn writeUint32LE:void (value:int) {
+        def b0:int (value % 256)
+        def rem1D:double ((to_double value) / 256.0)
+        def rem1:int (to_int rem1D)
+        def b1:int (rem1 % 256)
+        def rem2D:double ((to_double rem1) / 256.0)
+        def rem2:int (to_int rem2D)
+        def b2:int (rem2 % 256)
+        def rem3D:double ((to_double rem2) / 256.0)
+        def b3:int (to_int rem3D)
+        this.writeUint8(b0)
+        this.writeUint8(b1)
+        this.writeUint8(b2)
+        this.writeUint8(b3)
+    }
+
+    fn writeBytes:void (src:buffer srcOffset:int count:int) {
+        def left:int count
+        def at:int srcOffset
+        while (left > 0) {
+            if (currentPos >= chunkSize) {
+                this.allocateNewChunk()
+            }
+            def room:int (chunkSize - currentPos)
+            def take:int left
+            if (take > room) {
+                take = room
+            }
+            buffer_copy currentChunk currentPos src at take
+            currentPos = (currentPos + take)
+            totalSize = (totalSize + take)
+            at = (at + take)
+            left = (left - take)
+        }
+    }
+
+    fn writeBuffer:void (src:buffer) {
+        def len:int (buffer_length src)
+        this.writeBytes(src 0 len)
+    }
+
+    fn writeString:void (s:string) {
+        def len:int (strlen s)
+        def i 0
+        while (i < len) {
+            def ch:int (charAt s i)
+            this.writeUint8(ch)
+            i = i + 1
+        }
+    }
+
+    fn getSize:int () {
+        return totalSize
+    }
+
+    fn toBuffer:buffer () {
+        ; Consolidate all chunks into a single buffer
+        def size:int totalSize
+        def result:buffer (buffer_alloc size)
+        def destPos:int 0
+
+        def numChunks:int (array_length chunks)
+        def i 0
+        while (i < numChunks) {
+            def chunk:buffer (itemAt chunks i)
+            def used:int (itemAt chunkLens i)
+            if (used > 0) {
+                buffer_copy result destPos chunk 0 used
+                destPos = (destPos + used)
+            }
+            i = i + 1
+        }
+
+        ; Copy current chunk (partial)
+        def curPos:int currentPos
+        if (curPos > 0) {
+            def curChunk:buffer currentChunk
+            buffer_copy result destPos curChunk 0 curPos
+            destPos = (destPos + curPos)
+        }
+
+        return result
+    }
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ranger-compiler",
-  "version": "3.2.0",
+  "version": "3.5.0",
   "description": "Ranger cross-language compiler - compile once, run anywhere. Write code in Ranger and compile to JavaScript, TypeScript, Python, Go, Rust, Swift, C++, Java, Kotlin, C#, PHP, and Scala.",
   "main": "api.js",
   "types": "api.d.ts",