ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/image/PNGEncoder.rgr

@@ -0,0 +1,388 @@
+; SPDX-License-Identifier: MIT
+
+Import "RasterBuffer.rgr"
+Import "Deflate.rgr"
+Import "Buffer.rgr"
+
+; PNG Encoder - Lossless image output
+; Implements basic PNG format with uncompressed DEFLATE
+
+class PNGEncoder {
+    def output:GrowableBuffer
+    def crcTable:[int]
+    def crcTableInit:boolean false
+    ; Emit uncompressed deflate blocks instead of compressing. What this file
+    ; used to do always.
+    def stored:boolean false
+    
+    Constructor () {
+        output = (new GrowableBuffer())
+    }
+    
+    ; Initialize CRC32 lookup table
+    fn initCRCTable:void () {
+        if crcTableInit {
+            return
+        }
+        def n:int 0
+        while (n < 256) {
+            def c:int n
+            def k:int 0
+            while (k < 8) {
+                if ((bit_and c 1) != 0) {
+                    ; EDB88320 in decimal = 3988292384
+                    c = (bit_xor (bit_ushr c 1) 3988292384)
+                } {
+                    c = (bit_ushr c 1)
+                }
+                k = k + 1
+            }
+            push crcTable c
+            n = n + 1
+        }
+        crcTableInit = true
+    }
+    
+    ; Calculate CRC32 of a GrowableBuffer section
+    fn crc32Buffer:int (data:GrowableBuffer) {
+        this.initCRCTable()
+        ; FFFFFFFF in decimal = 4294967295
+        def crc:int 4294967295
+        def buf:buffer (data.toBuffer())
+        def len:int (data.size())
+        def i:int 0
+        while (i < len) {
+            def byte:int (buffer_get buf i)
+            def idx:int (bit_and (bit_xor crc byte) 255)
+            crc = (bit_xor (bit_ushr crc 8) (itemAt crcTable idx))
+            i = i + 1
+        }
+        return (bit_xor crc 4294967295)
+    }
+    
+    ; Write PNG signature
+    fn writeSignature:void () {
+        output.writeByte(137)  ; 0x89
+        output.writeByte(80)   ; P
+        output.writeByte(78)   ; N
+        output.writeByte(71)   ; G
+        output.writeByte(13)   ; 0x0D
+        output.writeByte(10)   ; 0x0A
+        output.writeByte(26)   ; 0x1A
+        output.writeByte(10)   ; 0x0A
+    }
+    
+    ; Write 32-bit big-endian integer
+    fn writeUInt32:void (value:int) {
+        output.writeByte((bit_and (bit_shr value 24) 255))
+        output.writeByte((bit_and (bit_shr value 16) 255))
+        output.writeByte((bit_and (bit_shr value 8) 255))
+        output.writeByte((bit_and value 255))
+    }
+    
+    ; Write 32-bit big-endian to a GrowableBuffer
+    fn writeUInt32To:void (buf:GrowableBuffer value:int) {
+        buf.writeByte((bit_and (bit_shr value 24) 255))
+        buf.writeByte((bit_and (bit_shr value 16) 255))
+        buf.writeByte((bit_and (bit_shr value 8) 255))
+        buf.writeByte((bit_and value 255))
+    }
+    
+    ; Write a PNG chunk
+    fn writeChunk:void (chunkType:string data:GrowableBuffer) {
+        def dataLen:int (data.size())
+        
+        ; Length
+        this.writeUInt32(dataLen)
+        
+        ; Build chunk type + data for CRC
+        def crcData:GrowableBuffer (new GrowableBuffer())
+        def i:int 0
+        while (i < 4) {
+            def ch:int (charAt chunkType i)
+            crcData.writeByte(ch)
+            output.writeByte(ch)
+            i = i + 1
+        }
+        
+        ; Data
+        def dataBuf:buffer (data.toBuffer())
+        i = 0
+        while (i < dataLen) {
+            def b:int (buffer_get dataBuf i)
+            crcData.writeByte(b)
+            output.writeByte(b)
+            i = i + 1
+        }
+        
+        ; CRC
+        def crc:int (this.crc32Buffer(crcData))
+        this.writeUInt32(crc)
+    }
+    
+    ; Write IHDR chunk (colorType 2 = RGB).
+    fn writeIHDR:void (width:int height:int) {
+        this.writeIHDRColor(width height 2)
+    }
+
+    fn writeIHDRColor:void (width:int height:int colorType:int) {
+        def data:GrowableBuffer (new GrowableBuffer())
+        
+        ; Width (4 bytes)
+        this.writeUInt32To(data width)
+        
+        ; Height (4 bytes)
+        this.writeUInt32To(data height)
+        
+        ; Bit depth: 8
+        data.writeByte(8)
+        data.writeByte(colorType)
+        ; Compression method: 0 = deflate
+        data.writeByte(0)
+        ; Filter method: 0
+        data.writeByte(0)
+        ; Interlace method: 0 = none
+        data.writeByte(0)
+        
+        this.writeChunk("IHDR" data)
+    }
+    
+    ; Adler32 checksum for zlib
+    fn adler32:int (data:GrowableBuffer) {
+        def a:int 1
+        def b:int 0
+        def buf:buffer (data.toBuffer())
+        def len:int (data.size())
+        def i:int 0
+        while (i < len) {
+            a = ((a + (buffer_get buf i)) % 65521)
+            b = ((b + a) % 65521)
+            i = i + 1
+        }
+        return (bit_or (bit_shl b 16) a)
+    }
+    
+    ; Create uncompressed DEFLATE blocks (store mode)
+    ; Compressed with fixed-Huffman deflate. Stored blocks are the fallback,
+    ; kept because they are the one encoding that cannot be wrong — a bug here
+    ; would be a file nothing opens, and `stored` is one flag away.
+    fn createDeflateData:void (rawData:GrowableBuffer compressed:GrowableBuffer) {
+        if (stored == false) {
+            def dz (new Deflate)
+            def w (new DeflateWriter)
+            dz.compress((rawData.toBuffer()) (rawData.size()) w)
+            def packed:buffer (w.out.toBuffer())
+            def pi:int 0
+            def pn:int (w.out.size())
+            while (pi < pn) {
+                compressed.writeByte((buffer_get packed pi))
+                pi = (pi + 1)
+            }
+            return
+        }
+        def rawBuf:buffer (rawData.toBuffer())
+        def dataLen:int (rawData.size())
+        def blockSize:int 65535  ; Max block size
+        def offset:int 0
+        
+        while (offset < dataLen) {
+            def remaining:int (dataLen - offset)
+            def len:int blockSize
+            if (remaining < len) {
+                len = remaining
+            }
+            
+            def isFinal:int 0
+            if ((offset + len) >= dataLen) {
+                isFinal = 1
+            }
+            
+            ; Block header: BFINAL=1/0, BTYPE=00 (stored)
+            compressed.writeByte(isFinal)
+            
+            ; LEN (2 bytes, little-endian)
+            compressed.writeByte((bit_and len 255))
+            compressed.writeByte((bit_and (bit_shr len 8) 255))
+            
+            ; NLEN (one's complement of LEN)
+            def nlen:int (bit_xor len 65535)
+            compressed.writeByte((bit_and nlen 255))
+            compressed.writeByte((bit_and (bit_shr nlen 8) 255))
+            
+            ; Data
+            def i:int 0
+            while (i < len) {
+                compressed.writeByte((buffer_get rawBuf (offset + i)))
+                i = i + 1
+            }
+            
+            offset = offset + len
+        }
+    }
+    
+    ; Write IDAT chunk with image data
+    fn writeIDAT:void (buf:RasterBuffer) {
+        ; Build raw scanline data with filter bytes
+        def rawData:GrowableBuffer (new GrowableBuffer())
+        
+        def y:int 0
+        while (y < buf.height) {
+            ; Filter type: 0 = None
+            rawData.writeByte(0)
+            
+            def x:int 0
+            while (x < buf.width) {
+                def idx:int ((y * buf.width + x) * 4)
+                def r:int (buffer_get buf.pixels idx)
+                def g:int (buffer_get buf.pixels (idx + 1))
+                def b:int (buffer_get buf.pixels (idx + 2))
+                def a:int (buffer_get buf.pixels (idx + 3))
+                ; A three-channel PNG cannot carry alpha, so a translucent
+                ; pixel has to be composited against something. White: this is
+                ; the format a picture is pasted into a document as, and a
+                ; document's page is white. It used to premultiply against
+                ; black with `>> 8`, which is a divide by 256 rather than 255 —
+                ; so a pixel the text renderer left at alpha 254, which every
+                ; antialiased glyph edge is, came out two levels darker than it
+                ; was drawn, and a round trip through our own decoder could not
+                ; get back what was painted.
+                if (a < 255) {
+                    def inv:int (255 - a)
+                    r = (idiv (((r * a) + (255 * inv)) + 127) 255)
+                    g = (idiv (((g * a) + (255 * inv)) + 127) 255)
+                    b = (idiv (((b * a) + (255 * inv)) + 127) 255)
+                }
+                rawData.writeByte(r)
+                rawData.writeByte(g)
+                rawData.writeByte(b)
+                x = x + 1
+            }
+            y = y + 1
+        }
+        
+        ; Wrap in zlib format
+        def zlibData:GrowableBuffer (new GrowableBuffer())
+        
+        ; Zlib header (CMF, FLG)
+        zlibData.writeByte(120)  ; 0x78 CMF: CM=8 (deflate), CINFO=7 (32K window)
+        zlibData.writeByte(1)    ; 0x01 FLG: no dict, level 0
+        
+        ; DEFLATE data
+        this.createDeflateData(rawData zlibData)
+        
+        ; Adler32 checksum (big-endian)
+        def adler:int (this.adler32(rawData))
+        zlibData.writeByte((bit_and (bit_shr adler 24) 255))
+        zlibData.writeByte((bit_and (bit_shr adler 16) 255))
+        zlibData.writeByte((bit_and (bit_shr adler 8) 255))
+        zlibData.writeByte((bit_and adler 255))
+        
+        this.writeChunk("IDAT" zlibData)
+    }
+
+    ; Write IDAT chunk with RGBA scanlines (color type 6).
+    fn writeIDATRgba:void (buf:RasterBuffer) {
+        def rawData:GrowableBuffer (new GrowableBuffer())
+        
+        def y:int 0
+        while (y < buf.height) {
+            rawData.writeByte(0)
+            def x:int 0
+            while (x < buf.width) {
+                def idx:int ((y * buf.width + x) * 4)
+                rawData.writeByte((buffer_get buf.pixels idx))
+                rawData.writeByte((buffer_get buf.pixels (idx + 1)))
+                rawData.writeByte((buffer_get buf.pixels (idx + 2)))
+                rawData.writeByte((buffer_get buf.pixels (idx + 3)))
+                x = (x + 1)
+            }
+            y = (y + 1)
+        }
+        
+        def zlibData:GrowableBuffer (new GrowableBuffer())
+        zlibData.writeByte(120)
+        zlibData.writeByte(1)
+        this.createDeflateData(rawData zlibData)
+        def adler:int (this.adler32(rawData))
+        zlibData.writeByte((bit_and (bit_shr adler 24) 255))
+        zlibData.writeByte((bit_and (bit_shr adler 16) 255))
+        zlibData.writeByte((bit_and (bit_shr adler 8) 255))
+        zlibData.writeByte((bit_and adler 255))
+        this.writeChunk("IDAT" zlibData)
+    }
+    fn writeIEND:void () {
+        def data:GrowableBuffer (new GrowableBuffer())
+        this.writeChunk("IEND" data)
+    }
+    
+    ; The same, without the running commentary. A chart copied to the clipboard
+    ; encodes a PNG on every Ctrl+C, and three lines of log per keystroke is
+    ; noise in a server that is otherwise quiet.
+    fn encodeQuiet:buffer (buf:RasterBuffer) {
+        output = (new GrowableBuffer())
+        this.writeSignature()
+        this.writeIHDR(buf.width buf.height)
+        this.writeIDAT(buf)
+        this.writeIEND()
+        return (output.toBuffer())
+    }
+
+    ; Encode buffer to PNG and return as buffer (for HTTP responses)
+    fn encodeToBuffer:buffer (buf:RasterBuffer) {
+        print ("Encoding PNG to buffer")
+        print ("  Image size: " + (to_string buf.width) + "x" + (to_string buf.height))
+        
+        ; Reset output
+        output = (new GrowableBuffer())
+        
+        this.writeSignature()
+        this.writeIHDR(buf.width buf.height)
+        this.writeIDAT(buf)
+        this.writeIEND()
+        
+        def finalSize:int (output.size())
+        print ("  Encoded size: " + (to_string finalSize) + " bytes")
+        
+        return (output.toBuffer())
+    }
+    
+    ; Encode buffer to PNG and save to file
+    fn encode:void (buf:RasterBuffer dirPath:string fileName:string) {
+        print ("Encoding PNG: " + fileName)
+        print ("  Image size: " + (to_string buf.width) + "x" + (to_string buf.height))
+        
+        ; Reset output
+        output = (new GrowableBuffer())
+        
+        this.writeSignature()
+        this.writeIHDR(buf.width buf.height)
+        this.writeIDAT(buf)
+        this.writeIEND()
+        
+        def finalSize:int (output.size())
+        print ("  Encoded size: " + (to_string finalSize) + " bytes")
+        
+        ; Write to file
+        def outBuf:buffer (output.toBuffer())
+        buffer_write_file dirPath fileName outBuf
+        print ("  Saved: " + dirPath + "/" + fileName)
+    }
+
+    ; Encode RGBA PNG (preserves alpha — use for LPC compose sheets).
+    fn encodeRgba:void (buf:RasterBuffer dirPath:string fileName:string) {
+        print ("Encoding RGBA PNG: " + fileName)
+        print ("  Image size: " + (to_string buf.width) + "x" + (to_string buf.height))
+        
+        output = (new GrowableBuffer())
+        this.writeSignature()
+        this.writeIHDRColor(buf.width buf.height 6)
+        this.writeIDATRgba(buf)
+        this.writeIEND()
+        
+        def finalSize:int (output.size())
+        print ("  Encoded size: " + (to_string finalSize) + " bytes")
+        def outBuf:buffer (output.toBuffer())
+        buffer_write_file dirPath fileName outBuf
+        print ("  Saved: " + dirPath + "/" + fileName)
+    }
+}

package/dist/lib/image/PPMImage.rgr

@@ -0,0 +1,224 @@
+; SPDX-License-Identifier: MIT
+
+; PPMImage.rgr - PPM (Portable Pixmap) image reader/writer
+; PPM is a simple uncompressed image format - easy to read/write
+;
+; Format: P6 (binary RGB) or P3 (ASCII RGB)
+; Header: P6\n<width> <height>\n<maxval>\n<binary RGB data>
+
+Import "Buffer.rgr"
+Import "ImageBuffer.rgr"
+
+class PPMImage {
+    
+    Constructor () {
+    }
+    
+    fn parseNumber:int (data:buffer startPos:int endPos:[int]) {
+        ; Parse ASCII number, skip whitespace, return value and update endPos
+        def len:int (buffer_length data)
+        def pos:int startPos
+        
+        ; Skip whitespace
+        def skipping:boolean true
+        while (skipping && (pos < len)) {
+            def ch:int (buffer_get data pos)
+            if ((ch == 32) || (ch == 10) || (ch == 13) || (ch == 9)) {
+                pos = pos + 1
+            } {
+                skipping = false
+            }
+        }
+        
+        ; Parse digits
+        def value:int 0
+        def parsing:boolean true
+        while (parsing && (pos < len)) {
+            def ch:int (buffer_get data pos)
+            if ((ch >= 48) && (ch <= 57)) {
+                value = (value * 10) + (ch - 48)
+                pos = pos + 1
+            } {
+                parsing = false
+            }
+        }
+        
+        set endPos 0 pos
+        return value
+    }
+    
+    fn skipToNextLine:int (data:buffer pos:int) {
+        def len:int (buffer_length data)
+        while (pos < len) {
+            def ch:int (buffer_get data pos)
+            pos = pos + 1
+            if (ch == 10) {
+                return pos
+            }
+        }
+        return pos
+    }
+    
+    fn load:ImageBuffer (dirPath:string fileName:string) {
+        def data:buffer (buffer_read_file dirPath fileName)
+        def len:int (buffer_length data)
+        
+        if (len < 10) {
+            print ("Error: File too small: " + fileName)
+            def errImg (new ImageBuffer())
+            errImg.init(1 1)
+            return errImg
+        }
+        
+        ; Check magic number (P6 for binary PPM)
+        def m1:int (buffer_get data 0)
+        def m2:int (buffer_get data 1)
+        
+        if ((m1 != 80) || ((m2 != 54) && (m2 != 51))) {
+            ; Not P6 or P3
+            print ("Error: Not a PPM file (P3 or P6): " + fileName)
+            def errImg (new ImageBuffer())
+            errImg.init(1 1)
+            return errImg
+        }
+        
+        def isBinary:boolean (m2 == 54)
+        def pos:int 2
+        
+        ; Skip comments and whitespace, parse width, height, maxval
+        def endPos:[int]
+        push endPos 0
+        
+        ; Skip any comments
+        def skippingComments:boolean true
+        while (skippingComments && (pos < len)) {
+            def ch:int (buffer_get data pos)
+            if ((ch == 32) || (ch == 10) || (ch == 13) || (ch == 9)) {
+                pos = pos + 1
+            } {
+                if (ch == 35) {
+                    ; Comment line starting with #
+                    pos = (this.skipToNextLine(data pos))
+                } {
+                    skippingComments = false
+                }
+            }
+        }
+        
+        def width:int (this.parseNumber(data pos endPos))
+        pos = (at endPos 0)
+        
+        def height:int (this.parseNumber(data pos endPos))
+        pos = (at endPos 0)
+        
+        def maxVal:int (this.parseNumber(data pos endPos))
+        pos = (at endPos 0)
+        
+        ; Skip single whitespace after maxval
+        if (pos < len) {
+            pos = pos + 1
+        }
+        
+        print ("Loading PPM: " + (to_string width) + "x" + (to_string height) + ", maxval=" + (to_string maxVal))
+        
+        def img (new ImageBuffer())
+        img.init(width height)
+        
+        if isBinary {
+            ; P6: Binary RGB data
+            def y 0
+            while (y < height) {
+                def x 0
+                while (x < width) {
+                    if ((pos + 2) < len) {
+                        def r:int (buffer_get data pos)
+                        def g:int (buffer_get data (pos + 1))
+                        def b:int (buffer_get data (pos + 2))
+                        img.setPixelRGB(x y r g b)
+                        pos = pos + 3
+                    }
+                    x = x + 1
+                }
+                y = y + 1
+            }
+        } {
+            ; P3: ASCII RGB data
+            def y 0
+            while (y < height) {
+                def x 0
+                while (x < width) {
+                    def r:int (this.parseNumber(data pos endPos))
+                    pos = (at endPos 0)
+                    def g:int (this.parseNumber(data pos endPos))
+                    pos = (at endPos 0)
+                    def b:int (this.parseNumber(data pos endPos))
+                    pos = (at endPos 0)
+                    img.setPixelRGB(x y r g b)
+                    x = x + 1
+                }
+                y = y + 1
+            }
+        }
+        
+        return img
+    }
+    
+    fn save:void (img:ImageBuffer dirPath:string fileName:string) {
+        ; Save as P6 (binary PPM)
+        def buf (new GrowableBuffer())
+        
+        ; Header
+        buf.writeString("P6\n")
+        buf.writeString((to_string img.width) + " " + (to_string img.height) + "\n")
+        buf.writeString("255\n")
+        
+        ; Pixel data (RGB only, no alpha)
+        def y 0
+        while (y < img.height) {
+            def x 0
+            while (x < img.width) {
+                def c:Color (img.getPixel(x y))
+                buf.writeByte(c.r)
+                buf.writeByte(c.g)
+                buf.writeByte(c.b)
+                x = x + 1
+            }
+            y = y + 1
+        }
+        
+        def data:buffer (buf.toBuffer())
+        buffer_write_file dirPath fileName data
+        print ("Saved PPM: " + dirPath + "/" + fileName)
+    }
+    
+    fn saveP3:void (img:ImageBuffer dirPath:string fileName:string) {
+        ; Save as P3 (ASCII PPM) - larger but human-readable
+        def buf (new GrowableBuffer())
+        
+        ; Header
+        buf.writeString("P3\n")
+        buf.writeString("# Created by Ranger ImageEditor\n")
+        buf.writeString((to_string img.width) + " " + (to_string img.height) + "\n")
+        buf.writeString("255\n")
+        
+        ; Pixel data as ASCII
+        def y 0
+        while (y < img.height) {
+            def x 0
+            while (x < img.width) {
+                def c:Color (img.getPixel(x y))
+                buf.writeString((to_string c.r) + " " + (to_string c.g) + " " + (to_string c.b))
+                if (x < (img.width - 1)) {
+                    buf.writeString("  ")
+                }
+                x = x + 1
+            }
+            buf.writeString("\n")
+            y = y + 1
+        }
+        
+        def data:buffer (buf.toBuffer())
+        buffer_write_file dirPath fileName data
+        print ("Saved PPM (ASCII): " + dirPath + "/" + fileName)
+    }
+}