ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/image/Buffer.rgr

@@ -0,0 +1,173 @@
+; SPDX-License-Identifier: MIT
+
+; Buffer.rgr - A growable buffer system for Ranger
+; Uses a linked list of fixed-size buffer chunks for efficient memory management
+
+class BufferChunk {
+    def data:buffer (buffer_alloc 0)
+    def used:int 0
+    def capacity:int 0
+    def next@(optional):BufferChunk
+    
+    Constructor (size:int) {
+        data = (buffer_alloc size)
+        capacity = size
+        used = 0
+    }
+    
+    fn remaining:int () {
+        return (capacity - used)
+    }
+    
+    fn isFull:boolean () {
+        return (used >= capacity)
+    }
+}
+
+class GrowableBuffer {
+    def firstChunk:BufferChunk (new BufferChunk(4096))
+    def currentChunk:BufferChunk (new BufferChunk(4096))
+    def chunkSize:int 4096       ; Default chunk size: 4KB
+    def totalSize:int 0
+    
+    Constructor () {
+        ; Create first chunk - reassign with proper size
+        def chunk (new BufferChunk(chunkSize))
+        firstChunk = chunk
+        currentChunk = chunk
+    }
+    
+    fn setChunkSize:void (size:int) {
+        chunkSize = size
+    }
+    
+    fn allocateNewChunk:void () {
+        def newChunk (new BufferChunk(chunkSize))
+        currentChunk.next = newChunk
+        currentChunk = newChunk
+    }
+    
+    fn writeByte:void (b:int) {
+        if (currentChunk.isFull()) {
+            this.allocateNewChunk()
+        }
+        def pos:int currentChunk.used
+        buffer_set currentChunk.data pos b
+        currentChunk.used = pos + 1
+        totalSize = totalSize + 1
+    }
+    
+    fn writeBytes:void (src:buffer srcOffset:int length:int) {
+        def i 0
+        while (i < length) {
+            def b:int (buffer_get src (srcOffset + i))
+            this.writeByte(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) {
+        ; Convert string to bytes and write
+        def len (strlen s)
+        def i 0
+        while (i < len) {
+            def ch:int (charAt s i)
+            this.writeByte(ch)
+            i = i + 1
+        }
+    }
+    
+    fn writeInt16BE:void (value:int) {
+        ; Write 16-bit big-endian integer
+        def highD:double (value / 256)
+        def high:int (to_int highD)
+        def low:int (value - (high * 256))
+        this.writeByte(high)
+        this.writeByte(low)
+    }
+    
+    fn writeInt32BE:void (value:int) {
+        ; Write 32-bit big-endian integer
+        def b1D:double (value / 16777216)
+        def b1:int (to_int b1D)
+        def rem1:int (value - (b1 * 16777216))
+        def b2D:double (rem1 / 65536)
+        def b2:int (to_int b2D)
+        def rem2:int (rem1 - (b2 * 65536))
+        def b3D:double (rem2 / 256)
+        def b3:int (to_int b3D)
+        def b4:int (rem2 - (b3 * 256))
+        this.writeByte(b1)
+        this.writeByte(b2)
+        this.writeByte(b3)
+        this.writeByte(b4)
+    }
+    
+    fn size:int () {
+        return totalSize
+    }
+    
+    fn toBuffer:buffer () {
+        ; Combine all chunks into a single buffer
+        def allocSize:int totalSize
+        def result:buffer (buffer_alloc allocSize)
+        def pos 0
+        def chunk:BufferChunk firstChunk
+        def done:boolean false
+        
+        while (done == false) {
+            def chunkUsed:int chunk.used
+            def i 0
+            while (i < chunkUsed) {
+                def b:int (buffer_get chunk.data i)
+                buffer_set result pos b
+                pos = pos + 1
+                i = i + 1
+            }
+            if (null? chunk.next) {
+                done = true
+            } {
+                chunk = (unwrap chunk.next)
+            }
+        }
+        
+        return result
+    }
+    
+    fn toString:string () {
+        ; Convert buffer content to string (for text-based content)
+        def result ""
+        def chunk:BufferChunk firstChunk
+        def done:boolean false
+        
+        while (done == false) {
+            def chunkUsed:int chunk.used
+            def i 0
+            while (i < chunkUsed) {
+                def b:int (buffer_get chunk.data i)
+                result = result + (strfromcode b)
+                i = i + 1
+            }
+            if (null? chunk.next) {
+                done = true
+            } {
+                chunk = (unwrap chunk.next)
+            }
+        }
+        
+        return result
+    }
+    
+    fn clear:void () {
+        ; Reset buffer - reuse first chunk, discard others
+        def chunk (new BufferChunk(chunkSize))
+        firstChunk = chunk
+        currentChunk = chunk
+        totalSize = 0
+    }
+}

package/dist/lib/image/DCT.rgr

@@ -0,0 +1,283 @@
+; SPDX-License-Identifier: MIT
+
+; DCT.rgr - Inverse Discrete Cosine Transform for JPEG decoding
+; Uses integer arithmetic with fixed-point scaling
+; Updated to use int_buffer for efficient cross-language compilation
+
+class IDCT {
+    ; Precomputed cosine table: cos((2*x+1) * u * pi / 16) * 1024
+    ; For each (x, u) pair where x,u = 0..7
+    ; Table layout: cosTable[x * 8 + u] = cos value
+    def cosTable:int_buffer (int_buffer_alloc 64)
+    
+    ; Zigzag order to row-major index mapping
+    def zigzagMap:int_buffer (int_buffer_alloc 64)
+
+    Constructor () {
+        ; Initialize full cosine table for IDCT
+        ; cos((2*x+1) * u * pi / 16) * 1024 for x=0..7, u=0..7
+        ; Row x=0: u=0,1,2,3,4,5,6,7
+        int_buffer_set cosTable 0 1024   ; cos(1*0*pi/16) = 1.000
+        int_buffer_set cosTable 1 1004   ; cos(1*1*pi/16) = 0.981
+        int_buffer_set cosTable 2 946    ; cos(1*2*pi/16) = 0.924
+        int_buffer_set cosTable 3 851    ; cos(1*3*pi/16) = 0.831
+        int_buffer_set cosTable 4 724    ; cos(1*4*pi/16) = 0.707
+        int_buffer_set cosTable 5 569    ; cos(1*5*pi/16) = 0.556
+        int_buffer_set cosTable 6 392    ; cos(1*6*pi/16) = 0.383
+        int_buffer_set cosTable 7 200    ; cos(1*7*pi/16) = 0.195
+        
+        ; Row x=1: cos((3)*u*pi/16)
+        int_buffer_set cosTable 8 1024
+        int_buffer_set cosTable 9 851
+        int_buffer_set cosTable 10 392
+        int_buffer_set cosTable 11 -200
+        int_buffer_set cosTable 12 -724
+        int_buffer_set cosTable 13 -1004
+        int_buffer_set cosTable 14 -946
+        int_buffer_set cosTable 15 -569
+        
+        ; Row x=2: cos((5)*u*pi/16)
+        int_buffer_set cosTable 16 1024
+        int_buffer_set cosTable 17 569
+        int_buffer_set cosTable 18 -392
+        int_buffer_set cosTable 19 -1004
+        int_buffer_set cosTable 20 -724
+        int_buffer_set cosTable 21 200
+        int_buffer_set cosTable 22 946
+        int_buffer_set cosTable 23 851
+        
+        ; Row x=3: cos((7)*u*pi/16)
+        int_buffer_set cosTable 24 1024
+        int_buffer_set cosTable 25 200
+        int_buffer_set cosTable 26 -946
+        int_buffer_set cosTable 27 -569
+        int_buffer_set cosTable 28 724
+        int_buffer_set cosTable 29 851
+        int_buffer_set cosTable 30 -392
+        int_buffer_set cosTable 31 -1004
+        
+        ; Row x=4: cos((9)*u*pi/16)
+        int_buffer_set cosTable 32 1024
+        int_buffer_set cosTable 33 -200
+        int_buffer_set cosTable 34 -946
+        int_buffer_set cosTable 35 569
+        int_buffer_set cosTable 36 724
+        int_buffer_set cosTable 37 -851
+        int_buffer_set cosTable 38 -392
+        int_buffer_set cosTable 39 1004
+        
+        ; Row x=5: cos((11)*u*pi/16)
+        int_buffer_set cosTable 40 1024
+        int_buffer_set cosTable 41 -569
+        int_buffer_set cosTable 42 -392
+        int_buffer_set cosTable 43 1004
+        int_buffer_set cosTable 44 -724
+        int_buffer_set cosTable 45 -200
+        int_buffer_set cosTable 46 946
+        int_buffer_set cosTable 47 -851
+        
+        ; Row x=6: cos((13)*u*pi/16)
+        int_buffer_set cosTable 48 1024
+        int_buffer_set cosTable 49 -851
+        int_buffer_set cosTable 50 392
+        int_buffer_set cosTable 51 200
+        int_buffer_set cosTable 52 -724
+        int_buffer_set cosTable 53 1004
+        int_buffer_set cosTable 54 -946
+        int_buffer_set cosTable 55 569
+        
+        ; Row x=7: cos((15)*u*pi/16)
+        int_buffer_set cosTable 56 1024
+        int_buffer_set cosTable 57 -1004
+        int_buffer_set cosTable 58 946
+        int_buffer_set cosTable 59 -851
+        int_buffer_set cosTable 60 724
+        int_buffer_set cosTable 61 -569
+        int_buffer_set cosTable 62 392
+        int_buffer_set cosTable 63 -200
+        
+        ; Zigzag to row-major mapping (JPEG standard zigzag order)
+        int_buffer_set zigzagMap 0 0
+        int_buffer_set zigzagMap 1 1
+        int_buffer_set zigzagMap 2 8
+        int_buffer_set zigzagMap 3 16
+        int_buffer_set zigzagMap 4 9
+        int_buffer_set zigzagMap 5 2
+        int_buffer_set zigzagMap 6 3
+        int_buffer_set zigzagMap 7 10
+        
+        int_buffer_set zigzagMap 8 17
+        int_buffer_set zigzagMap 9 24
+        int_buffer_set zigzagMap 10 32
+        int_buffer_set zigzagMap 11 25
+        int_buffer_set zigzagMap 12 18
+        int_buffer_set zigzagMap 13 11
+        int_buffer_set zigzagMap 14 4
+        int_buffer_set zigzagMap 15 5
+        
+        int_buffer_set zigzagMap 16 12
+        int_buffer_set zigzagMap 17 19
+        int_buffer_set zigzagMap 18 26
+        int_buffer_set zigzagMap 19 33
+        int_buffer_set zigzagMap 20 40
+        int_buffer_set zigzagMap 21 48
+        int_buffer_set zigzagMap 22 41
+        int_buffer_set zigzagMap 23 34
+        
+        int_buffer_set zigzagMap 24 27
+        int_buffer_set zigzagMap 25 20
+        int_buffer_set zigzagMap 26 13
+        int_buffer_set zigzagMap 27 6
+        int_buffer_set zigzagMap 28 7
+        int_buffer_set zigzagMap 29 14
+        int_buffer_set zigzagMap 30 21
+        int_buffer_set zigzagMap 31 28
+        
+        int_buffer_set zigzagMap 32 35
+        int_buffer_set zigzagMap 33 42
+        int_buffer_set zigzagMap 34 49
+        int_buffer_set zigzagMap 35 56
+        int_buffer_set zigzagMap 36 57
+        int_buffer_set zigzagMap 37 50
+        int_buffer_set zigzagMap 38 43
+        int_buffer_set zigzagMap 39 36
+        
+        int_buffer_set zigzagMap 40 29
+        int_buffer_set zigzagMap 41 22
+        int_buffer_set zigzagMap 42 15
+        int_buffer_set zigzagMap 43 23
+        int_buffer_set zigzagMap 44 30
+        int_buffer_set zigzagMap 45 37
+        int_buffer_set zigzagMap 46 44
+        int_buffer_set zigzagMap 47 51
+        
+        int_buffer_set zigzagMap 48 58
+        int_buffer_set zigzagMap 49 59
+        int_buffer_set zigzagMap 50 52
+        int_buffer_set zigzagMap 51 45
+        int_buffer_set zigzagMap 52 38
+        int_buffer_set zigzagMap 53 31
+        int_buffer_set zigzagMap 54 39
+        int_buffer_set zigzagMap 55 46
+        
+        int_buffer_set zigzagMap 56 53
+        int_buffer_set zigzagMap 57 60
+        int_buffer_set zigzagMap 58 61
+        int_buffer_set zigzagMap 59 54
+        int_buffer_set zigzagMap 60 47
+        int_buffer_set zigzagMap 61 55
+        int_buffer_set zigzagMap 62 62
+        int_buffer_set zigzagMap 63 63
+    }
+    
+    fn dezigzag:int_buffer (zigzag:int_buffer) {
+        ; Convert from zigzag order to row-major 8x8 block
+        ; Returns new 64-element buffer
+        def block:int_buffer (int_buffer_alloc 64)
+        
+        def i 0
+        while (i < 64) {
+            def pos:int (int_buffer_get zigzagMap i)
+            def val:int (int_buffer_get zigzag i)
+            int_buffer_set block pos val
+            i = i + 1
+        }
+        return block
+    }
+    
+    fn idct1d:void (input:int_buffer startIdx:int stride:int output:int_buffer outIdx:int outStride:int) {
+        ; 1D IDCT: output[x] = sum over u of: C(u) * input[u] * cos((2x+1)*u*pi/16)
+        ; C(0) = 1/sqrt(2), C(u>0) = 1
+        ; cosTable is scaled by 1024
+
+        ; Flat path: with every AC coefficient zero the result is the same
+        ; value eight times over, because cosTable[x * 8] is 1024 for every x.
+        ; Most rows of a photographic 8x8 block are like this, and after the
+        ; row pass most columns are too, so this skips the bulk of the work.
+        def hasAC:boolean false
+        def uc 1
+        while (uc < 8) {
+            if ((int_buffer_get input (startIdx + (uc * stride))) != 0) {
+                hasAC = true
+                uc = 8
+            }
+            uc = uc + 1
+        }
+        if (hasAC == false) {
+            def dcSum:int 0
+            def dcCoeff:int (int_buffer_get input startIdx)
+            if (dcCoeff != 0) {
+                def dcContrib:int (dcCoeff * 1024)
+                dcContrib = (bit_shr (dcContrib * 724) 10)
+                dcSum = dcSum + dcContrib
+            }
+            def flat:int (bit_shr dcSum 11)
+            def fx 0
+            while (fx < 8) {
+                int_buffer_set output (outIdx + (fx * outStride)) flat
+                fx = fx + 1
+            }
+            return
+        }
+
+        def x 0
+        while (x < 8) {
+            def sum:int 0
+            def u 0
+            while (u < 8) {
+                def coeff:int (int_buffer_get input (startIdx + (u * stride)))
+                if (coeff != 0) {
+                    def cosVal:int (int_buffer_get cosTable ((x * 8) + u))
+                    def contrib:int (coeff * cosVal)
+                    if (u == 0) {
+                        ; C(0) = 1/sqrt(2) ≈ 724/1024
+                        contrib = (bit_shr (contrib * 724) 10)
+                    }
+                    sum = sum + contrib
+                }
+                u = u + 1
+            }
+            ; Scale down by 1024 (cosine table scale) and divide by 2 for IDCT normalization
+            int_buffer_set output (outIdx + (x * outStride)) (bit_shr sum 11)
+            x = x + 1
+        }
+    }
+    
+    fn transform:void (block:int_buffer output:int_buffer) {
+        ; Perform 2D IDCT on 8x8 block using separable method
+        ; 2D IDCT = 1D IDCT on rows, then 1D IDCT on columns
+        
+        ; Temporary buffer for row transform results
+        def temp:int_buffer (int_buffer_alloc 64)
+
+        ; First pass: 1D IDCT on each row
+        def row 0
+        while (row < 8) {
+            def rowStart:int (row * 8)
+            this.idct1d(block rowStart 1 temp rowStart 1)
+            row = row + 1
+        }
+
+        ; Second pass: 1D IDCT on each column
+        def col 0
+        while (col < 8) {
+            this.idct1d(temp col 8 output col 8)
+            col = col + 1
+        }
+        
+        ; Level shift: add 128 and clamp to 0-255
+        ; The 2D transform has normalization factor of 1/4 already included via two 1D transforms
+        def i 0
+        while (i < 64) {
+            def val:int ((int_buffer_get output i) + 128)
+            if (val < 0) { val = 0 }
+            if (val > 255) { val = 255 }
+            int_buffer_set output i val
+            i = i + 1
+        }
+    }
+    
+    fn transformFast:void (coeffs:int_buffer output:int_buffer) {
+        this.transform(coeffs output)
+    }
+}