mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
* stdlib: implement `std::compression::zip` and `std::compression::deflate` - C3 implementation of DEFLATE (RFC 1951) and ZIP archive handling. - Support for reading and writing archives using STORE and DEFLATE methods. - Decompression supports both fixed and dynamic Huffman blocks. - Compression using greedy LZ77 matching. - Zero dependencies on libc. - Stream-based entry reading and writing. - Full unit test coverage. NOTE: This is an initial implementation. Future improvements could be: - Optimization of the LZ77 matching (lazy matching). - Support for dynamic Huffman blocks in compression. - ZIP64 support for large files/archives. - Support for encryption and additional compression methods. * optimizations+refactoring deflate: - replace linear search with hash-based match finding. - implement support for dynamic Huffman blocks using the Package-Merge algorithm. - add streaming decompression. - add buffered StreamBitReader. zip: - add ZIP64 support. - add CP437 and UTF-8 filename encoding detection. - add DOS date/time conversion and timestamp preservation. - add ZipEntryReader for streaming entry reads. - implement ZipArchive.extract and ZipArchive.recover helpers. other: - Add `set_modified_time` to std::io; - Add benchmarks and a few more unit tests. * zip: add archive comment support add tests * forgot to rename the benchmark :( * detect utf8 names on weird zips fix method not passed to open_writer * another edge case where directory doesn't end with / * testing utilities - detect encrypted zip - `ZipArchive.open_writer` default to DEFLATE * fix zip64 creation, add tests * fix ZIP header endianness for big-endian compatibility Update ZipLFH, ZipCDH, ZipEOCD, Zip64EOCD, and Zip64Locator structs to use little-endian bitstruct types from std::core::bitorder * fix ZipEntryReader position tracking and seek logic ZIP_METHOD_STORE added a test to track this * add package-merge algorithm attribution Thanks @konimarti * standalone deflate_benchmark.c3 against `miniz` * fix integer overflows, leaks and improve safety * a few safety for 32-bit systems and tests * deflate compress optimization * improve match finding, hash updates, and buffer usage * use ulong for zip offsets * style changes (#18) * style changes * update tests * style changes in `deflate.c3` * fix typo * Allocator first. Some changes to deflate to use `copy_to` * Fix missing conversion on 32 bits. * Fix deflate stream. Formatting. Prefer switch over if-elseif * - Stream functions now use long/ulong rather than isz/usz for seek/available. - `instream.seek` is replaced by `set_cursor` and `cursor`. - `instream.available`, `cursor` etc are long/ulong rather than isz/usz to be correct on 32-bit. * Update to constdef * Fix test --------- Co-authored-by: Book-reader <thevoid@outlook.co.nz> Co-authored-by: Christoffer Lerno <christoffer@aegik.com>
44 lines
920 B
Plaintext
44 lines
920 B
Plaintext
module std::io;
|
|
|
|
struct LimitReader (InStream)
|
|
{
|
|
InStream wrapped_stream;
|
|
usz limit;
|
|
}
|
|
|
|
<*
|
|
@param [&inout] wrapped_stream : "The stream to read from"
|
|
@param limit : "The max limit to read"
|
|
*>
|
|
fn LimitReader* LimitReader.init(&self, InStream wrapped_stream, usz limit)
|
|
{
|
|
*self = { .wrapped_stream = wrapped_stream, .limit = limit };
|
|
return self;
|
|
}
|
|
|
|
fn void? LimitReader.close(&self) @dynamic
|
|
{
|
|
if (&self.wrapped_stream.close) return self.wrapped_stream.close();
|
|
}
|
|
|
|
|
|
fn usz? LimitReader.read(&self, char[] bytes) @dynamic
|
|
{
|
|
if (self.limit == 0) return io::EOF~;
|
|
usz m = min(bytes.len, self.limit);
|
|
usz n = self.wrapped_stream.read(bytes[:m])!;
|
|
self.limit -= n;
|
|
return n;
|
|
}
|
|
|
|
fn char? LimitReader.read_byte(&self) @dynamic
|
|
{
|
|
if (self.limit == 0) return io::EOF~;
|
|
defer try self.limit--;
|
|
return self.wrapped_stream.read_byte();
|
|
}
|
|
|
|
fn ulong? LimitReader.available(&self) @inline @dynamic
|
|
{
|
|
return self.limit;
|
|
} |