ZLib and Mojo help needed

[toiletsandpaper]

Hello! Can somebody help me with zlib compression with Mojo ffi module?

I don't really get C, because I came mostly from Python and C# and I don't really understand how to work with C types.

ZLib docs says (https://arc.net/l/quote/shbynbdx):

ZEXTERN int ZEXPORT compress(Bytef *dest, uLongf *destLen,
                             const Bytef *source, uLong sourceLen);

I don't understand how to pass to zlib a pointer to variable that should be modified, aka *dest above or _out below

I've tried my best and still doesn't get it - code below runs perfectly, but compressed is still empty after all:

from sys import ffi, external_call

alias Bytef = Pointer[SIMD[DType.int8, 1]]
alias zlib_compress_type = fn(_out: Bytef, _out_len: Pointer[Int64], _in: Bytef, _in_len: Int64) -> NoneType

fn main() raises:
    var handle = ffi.DLHandle('/Users/toiletsandpaper/Documents/mojo_test/zlib-1.3.1/libz.dylib')
    var zlib_compress = handle.get_function[zlib_compress_type]('compress')

    var text: StringRef = StringRef("some text")
    var compressed: StringRef = StringRef("")
    var comp_len = Pointer[Int64].alloc(1)
    _ = zlib_compress(
        compressed.data._as_scalar_pointer(),
        comp_len,
        text.data._as_scalar_pointer(), 
        len(text),
    )
    print(text)
    print(compressed)

Asking for help - I really need an example of how to call compress and uncompress with C version of zlib, not Python.

[toiletsandpaper]

So, with the help of @jackos in Discord

I've managed to finally wrote it: https://gist.github.com/toiletsandpaper/591dcd934d028440cafea22d5690d19f

from sys import ffi, external_call
from memory import memset_zero, memset

#Z_OK            0
#Z_STREAM_END    1
#Z_NEED_DICT     2
#Z_ERRNO        (-1)
#Z_STREAM_ERROR (-2)
#Z_DATA_ERROR   (-3)
#Z_MEM_ERROR    (-4)
#Z_BUF_ERROR    (-5)
#Z_VERSION_ERROR (-6)

alias Bytef = Scalar[DType.int8]
alias uLong = UInt64
alias zlib_type = fn(
    _out: Pointer[Bytef], 
    _out_len: Pointer[UInt64], 
    _in: Pointer[Bytef], 
    _in_len: uLong
) -> Int
alias ResultType = Tuple[Pointer[Bytef], Pointer[uLong]]

fn log_zlib_result(Z_RES: Int, compressing: Bool = True) raises -> NoneType:
    var prefix: String = ''
    if not compressing:
        prefix = "un"

    if Z_RES == 0:
        print('OK ' + prefix.upper() + 'COMPRESSING: Everything ' + prefix + 'compressed fine')
    elif Z_RES == -4:
        raise Error('ERROR ' + prefix.upper() + 'COMPRESSING: Not enought memory')
    elif Z_RES == -5:
        raise Error('ERROR ' + prefix.upper() + 'COMPRESSING: Buffer have not enough memory')
    else:
        raise Error('ERROR ' + prefix.upper() + 'COMPRESSING: Unhandled exception')
        


fn compress(text: StringLiteral) raises -> ResultType:
    var data_memory_amount: Int = 1024
    var handle = ffi.DLHandle('/Users/toiletsandpaper/Documents/mojo_test/zlib-1.3.1/libz.dylib')
    var zlib_compress = handle.get_function[zlib_type]('compress')

    var compressed = Pointer[Bytef].alloc(data_memory_amount)
    var compressed_len = Pointer[uLong].alloc(1)
    memset_zero(compressed, data_memory_amount)
    memset_zero(compressed_len, 1)
    compressed_len[0] = data_memory_amount

    var Z_RES = zlib_compress(
        compressed,
        compressed_len,
        text.data()._as_scalar_pointer(),
        len(text) + 1,
    )
    log_zlib_result(Z_RES)
    return Tuple(compressed, compressed_len)

fn uncompress(data: DynamicVector[Int8]) raises -> String:
    var data_memory_amount: Int = 2048
    var handle = ffi.DLHandle('/Users/toiletsandpaper/Documents/mojo_test/zlib-1.3.1/libz.dylib')
    var zlib_uncompress = handle.get_function[zlib_type]('uncompress')

    var uncompressed = Pointer[Bytef].alloc(data_memory_amount)
    var compressed = Pointer[Bytef].alloc(len(data))
    var uncompressed_len = Pointer[uLong].alloc(1)
    memset_zero(uncompressed, data_memory_amount)
    memset_zero(uncompressed_len, 1)
    uncompressed_len[0] = data_memory_amount
    for i in range(len(data)):
        compressed.store(i, data[i])

    var Z_RES = zlib_uncompress(
        uncompressed,
        uncompressed_len,
        compressed,
        len(data),
    )
    log_zlib_result(Z_RES, compressing=False)
    var res: String = ''
    for i in range(uncompressed_len[0]):
        res = res + chr(uncompressed[i].to_int())
    return res



fn main() raises:
    var text = 'test teeeeeeeeeeext'
    var res = compress(text)
    var res_data_pointer = res.get[0, Pointer[Bytef]]()
    var res_len = res.get[1, Pointer[uLong]]().load(0)
    var res_data = DynamicVector[Bytef]()
    print_no_newline('compressed data is ')
    for i in range(res_len):
        res_data.append(
            res_data_pointer.load(i)
        )
        print_no_newline(hex(res_data[i]))
    print('\ncompressed lenght is ' + String(res_len) + '\n')

    var uncompressed = uncompress(res_data)
    print('uncompressed string: ' + uncompressed)