module szip #flag -I @VROOT/thirdparty/zip #include "zip.c" #include "zip.h" struct C.zip_t { } type Zip = C.zip_t fn C.zip_open(byteptr, int, byte) &Zip fn C.zip_close(&Zip) fn C.zip_entry_open(&Zip, byteptr) int fn C.zip_entry_close(&Zip) int fn C.zip_entry_name(&Zip) byteptr fn C.zip_entry_index(&Zip) int fn C.zip_entry_isdir(&Zip) int fn C.zip_entry_size(&Zip) u64 fn C.zip_entry_crc32(&Zip) u32 fn C.zip_entry_write(&Zip, voidptr, int) int fn C.zip_entry_fwrite(&Zip, byteptr) int fn C.zip_entry_read(&Zip, byteptr, int) int fn C.zip_entry_fread(&Zip, byteptr) int fn C.zip_total_entries(&Zip) int // Ref - miniz.h const ( no_compression = 0 best_speed = 1 best_compression = 9 uber_compression = 10 default_level = 6 default_compression = -1 ) const ( m_write = `w` m_ronly = `r` m_append = `a` ) /* open opens zip archive with compression level using the given mode. @param zipname zip archive file name. @param level compression level (0-9 are the standard zlib-style levels). @param mode file access mode. - 'r': opens a file for reading/extracting (the file must exists). - 'w': creates an empty file for writing. - 'a': appends to an existing archive. @return the zip archive handler or NULL on error */ pub fn open(name string, level int, mode byte) ?&Zip { mut nlevel := level if (nlevel & 0xF) > szip.uber_compression { nlevel = szip.default_level } if name.len == 0 { return error('szip: name of file empty') } if mode !in [szip.m_write, szip.m_ronly, szip.m_append] { return error('szip: invalid provided open mode') } p_zip := &Zip(C.zip_open(name.str, nlevel, mode)) if isnil(p_zip) { return error('szip: cannot open/create/append new zip archive') } return p_zip } /* close closes the zip archive, releases resources - always finalize. @param zip zip archive handler. */ pub fn (mut z Zip) close() { C.zip_close(z) } /* open_entry opens an entry by name in the zip archive. For zip archive opened in 'w' or 'a' mode the function will append a new entry. In readonly mode the function tries to locate the entry in global dictionary. @param zip zip archive handler. @param entryname an entry name in local dictionary. @return the return code - 0 on success, negative number (< 0) on error. */ pub fn (mut zentry Zip) open_entry(name string) ? { res := C.zip_entry_open(zentry, name.str) if res == -1 { return error('szip: cannot open archive entry') } } /* * close_entry closes a zip entry, flushes buffer and releases resources. * * @param zip zip archive handler. * * @return the return code - 0 on success, negative number (< 0) on error. */ pub fn (mut zentry Zip) close_entry() { C.zip_entry_close(zentry) } /* name returns a local name of the current zip entry. The main difference between user's entry name and local entry name is optional relative path. Following .ZIP File Format Specification - the path stored MUST not contain a drive or device letter, or a leading slash. All slashes MUST be forward slashes '/' as opposed to backwards slashes '\' for compatibility with Amiga and UNIX file systems etc. @param zip: zip archive handler. @return the pointer to the current zip entry name, or NULL on error. */ pub fn (mut zentry Zip) name() string { name := C.zip_entry_name(zentry) if name == 0 { return '' } return unsafe { tos_clone(name) } } /* index returns an index of the current zip entry. @param zip zip archive handler. @return the index on success, negative number (< 0) on error. */ pub fn (mut zentry Zip) index() ?int { index := int(C.zip_entry_index(zentry)) if index == -1 { return error('szip: cannot get current index of zip entry') } return index // must be check for INVALID_VALUE } /* isdir determines if the current zip entry is a directory entry. @param zip zip archive handler. @return the return code - 1 (true), 0 (false), negative number (< 0) on error. */ pub fn (mut zentry Zip) isdir() ?bool { isdir := C.zip_entry_isdir(zentry) if isdir < 0 { return error('szip: cannot check entry type') } return isdir == 1 } /* size returns an uncompressed size of the current zip entry. @param zip zip archive handler. @return the uncompressed size in bytes. */ pub fn (mut zentry Zip) size() u64 { return C.zip_entry_size(zentry) } /* crc32 returns CRC-32 checksum of the current zip entry. @param zip zip archive handler. @return the CRC-32 checksum. */ pub fn (mut zentry Zip) crc32() u32 { return C.zip_entry_crc32(zentry) } /* write_entry compresses an input buffer for the current zip entry. @param zip zip archive handler. @param buf input buffer. @param bufsize input buffer size (in bytes). @return the return code - 0 on success, negative number (< 0) on error. */ pub fn (mut zentry Zip) write_entry(data []byte) ? { if (data[0] & 0xff) == -1 { return error('szip: cannot write entry') } res := C.zip_entry_write(zentry, data.data, data.len) if res != 0 { return error('szip: failed to write entry') } } /* create_entry compresses a file for the current zip entry. @param zip zip archive handler. @param filename input file. @return the return code - 0 on success, negative number (< 0) on error. */ pub fn (mut zentry Zip) create_entry(name string) ? { res := C.zip_entry_fwrite(zentry, name.str) if res != 0 { return error('szip: failed to create entry') } } /* read_entry extracts the current zip entry into output buffer. The function allocates sufficient memory for an output buffer. @param zip zip archive handler. @param buf output buffer. @param bufsize output buffer size (in bytes). @note remember to release the memory allocated for an output buffer. for large entries, please take a look at zip_entry_extract function. @return the return code - the number of bytes actually read on success. Otherwise a -1 on error. */ pub fn (mut zentry Zip) read_entry() ?voidptr { mut buf := voidptr(0) mut bsize := i64(0) res := C.zip_entry_read(zentry, &buf, &bsize) if res == -1 { return error('szip: cannot read properly data from entry') } return buf } /* extract_entry extracts the current zip entry into output file. @param zip zip archive handler. @param filename output file. @return the return code - 0 on success, negative number (< 0) on error. */ pub fn (mut zentry Zip) extract_entry(path string) ? { if C.access(charptr(path.str), 0) == -1 { return error('Cannot open file for extracting, file not exists') } res := C.zip_entry_fread(zentry, path.str) if res != 0 { return error('szip: failed to extract entry') } } /* extract extracts the current zip entry using a callback function (on_extract). @param zip zip archive handler. @param on_extract callback function. @param arg opaque pointer (optional argument, which you can pass to the on_extract callback) @return the return code - 0 on success, negative number (< 0) on error. */ /* fn (mut zentry Zip) extract(path string) bool { if C.access(path.str, 0) == -1 { return false //return error('Cannot open directory for extracting, directory not exists') } res := C.zip_extract(zentry, path.str, 0, 0) return res == 0 } */ /* total returns the number of all entries (files and directories) in the zip archive. @param zip zip archive handler. @return the return code - the number of entries on success, negative number (< 0) on error. */ pub fn (mut zentry Zip) total() ?int { tentry := int(C.zip_total_entries(zentry)) if tentry == -1 { return error('szip: cannot count total entries') } return tentry }