---

yaml
---
r: 30158
b: refs/heads/incoming
c: b769e29
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 31bbcf026727cf69e2c4b756a6d2ddc584274056
+refs/heads/incoming: b769e296803f578d99654e9fc271c4109e50ab75
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/LICENSE.txt

@@ -235,6 +235,11 @@ included:
   BSD-compatible licenses. See src/libuv/LICENSE for
   details.
 
+* The src/rt/miniz.c file, carrying an implementation of
+  RFC1950/RFC1951 DEFLATE, by Rich Geldreich
+  <[email protected]>. All uses of this file are
+  permitted by the embedded "unlicense" notice
+  (effectively: public domain with warranty disclaimer).
 
 * LLVM and Clang. Code for this package is found in
   src/llvm.

branches/incoming/mk/rt.mk

@@ -65,6 +65,7 @@ RUNTIME_CS_$(1) := \
               rt/rust_util.cpp \
               rt/circular_buffer.cpp \
               rt/isaac/randport.cpp \
+              rt/miniz.cpp \
               rt/rust_kernel.cpp \
               rt/rust_shape.cpp \
               rt/rust_abi.cpp \

branches/incoming/mk/tests.mk

@@ -121,6 +121,7 @@ ALL_CS := $(wildcard $(S)src/rt/*.cpp \
                      $(S)srcrustllvm/*.cpp)
 ALL_CS := $(filter-out $(S)src/rt/bigint/bigint_ext.cpp \
                        $(S)src/rt/bigint/bigint_int.cpp \
+                       $(S)src/rt/miniz.cpp \
 	,$(ALL_CS))
 ALL_HS := $(wildcard $(S)src/rt/*.h \
                      $(S)src/rt/*/*.h \

branches/incoming/src/libcore/core.rc

@@ -56,6 +56,7 @@ export cmp;
 export num;
 export path, path2;
 export managed;
+export flate;
 
 // NDM seems to be necessary for resolve to work
 export option_iter;
@@ -265,6 +266,8 @@ mod unsafe;
 
 mod managed;
 
+mod flate;
+
 // Modules supporting compiler-generated code
 // Exported but not part of the public interface
 

branches/incoming/src/libcore/flate.rs

@@ -0,0 +1,78 @@
+import libc::{c_void, size_t, c_int};
+
+extern mod rustrt {
+
+    fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,
+                                  src_buf_len: size_t,
+                                  pout_len: *size_t,
+                                  flags: c_int) -> *c_void;
+
+    fn tinfl_decompress_mem_to_heap(psrc_buf: *const c_void,
+                                    src_buf_len: size_t,
+                                    pout_len: *size_t,
+                                    flags: c_int) -> *c_void;
+}
+
+const lz_none : c_int = 0x0;   // Huffman-coding only.
+const lz_fast : c_int = 0x1;   // LZ with only one probe
+const lz_norm : c_int = 0x80;  // LZ with 128 probes, "normal"
+const lz_best : c_int = 0xfff; // LZ with 4095 probes, "best"
+
+fn deflate_buf(buf: &[const u8]) -> ~[u8] {
+    do vec::as_const_buf(buf) |b, len| {
+        unsafe {
+            let mut outsz : size_t = 0;
+            let res =
+                rustrt::tdefl_compress_mem_to_heap(b as *c_void,
+                                                   len as size_t,
+                                                   ptr::addr_of(outsz),
+                                                   lz_norm);
+            assert res as int != 0;
+            let out = vec::unsafe::from_buf(res as *u8,
+                                            outsz as uint);
+            libc::free(res);
+            out
+        }
+    }
+}
+
+fn inflate_buf(buf: &[const u8]) -> ~[u8] {
+    do vec::as_const_buf(buf) |b, len| {
+        unsafe {
+            let mut outsz : size_t = 0;
+            let res =
+                rustrt::tinfl_decompress_mem_to_heap(b as *c_void,
+                                                     len as size_t,
+                                                     ptr::addr_of(outsz),
+                                                     0);
+            assert res as int != 0;
+            let out = vec::unsafe::from_buf(res as *u8,
+                                            outsz as uint);
+            libc::free(res);
+            out
+        }
+    }
+}
+
+#[test]
+fn test_flate_round_trip() {
+    let r = rand::Rng();
+    let mut words = ~[];
+    for 20.times {
+        vec::push(words, r.gen_bytes(r.gen_uint_range(1, 10)));
+    }
+    for 20.times {
+        let mut in = ~[];
+        for 2000.times {
+            vec::push_all(in, r.choose(words));
+        }
+        debug!("de/inflate of %u bytes of random word-sequences",
+               in.len());
+        let cmp = flate::deflate_buf(in);
+        let out = flate::inflate_buf(cmp);
+        debug!("%u bytes deflated to %u (%.1f%% size)",
+               in.len(), cmp.len(),
+               100.0 * ((cmp.len() as float) / (in.len() as float)));
+        assert(in == out);
+    }
+}