From cdfdc1eb6b9ff58b4a264d1c112dfcbf6e9187ae Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 24 Jan 2014 21:00:31 -0800 Subject: Move extra::flate to libflate This is hopefully the beginning of the long-awaited dissolution of libextra. Using the newly created build infrastructure for building libraries, I decided to move the first module out of libextra. While not being a particularly meaty module in and of itself, the flate module is required by rustc and additionally has a native C dependency. I was able to very easily split out the C dependency from rustrt, update librustc, and magically everything gets installed to the right locations and built automatically. This is meant to be a proof-of-concept commit to how easy it is to remove modules from libextra now. I didn't put any effort into modernizing the interface of libflate or updating it other than to remove the one glob import it had. --- src/libextra/flate.rs | 129 ------------------------------------ src/libextra/lib.rs | 1 - src/libflate/lib.rs | 133 ++++++++++++++++++++++++++++++++++++++ src/librustc/lib.rs | 1 + src/librustc/metadata/loader.rs | 2 +- src/librustc/middle/trans/base.rs | 2 +- src/librustdoc/html/markdown.rs | 4 +- 7 files changed, 139 insertions(+), 133 deletions(-) delete mode 100644 src/libextra/flate.rs create mode 100644 src/libflate/lib.rs (limited to 'src') diff --git a/src/libextra/flate.rs b/src/libextra/flate.rs deleted file mode 100644 index faceb17af47..00000000000 --- a/src/libextra/flate.rs +++ /dev/null @@ -1,129 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! - -Simple compression - -*/ - -#[allow(missing_doc)]; - -use std::libc::{c_void, size_t, c_int}; -use std::libc; -use std::vec; - -pub mod rustrt { - use std::libc::{c_int, c_void, size_t}; - - #[link(name = "rustrt", kind = "static")] - extern { - pub fn tdefl_compress_mem_to_heap(psrc_buf: *c_void, - src_buf_len: size_t, - pout_len: *mut size_t, - flags: c_int) - -> *c_void; - - pub fn tinfl_decompress_mem_to_heap(psrc_buf: *c_void, - src_buf_len: size_t, - pout_len: *mut size_t, - flags: c_int) - -> *c_void; - } -} - -static LZ_NORM : c_int = 0x80; // LZ with 128 probes, "normal" -static TINFL_FLAG_PARSE_ZLIB_HEADER : c_int = 0x1; // parse zlib header and adler32 checksum -static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum - -fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] { - unsafe { - let mut outsz : size_t = 0; - let res = rustrt::tdefl_compress_mem_to_heap(bytes.as_ptr() as *c_void, - bytes.len() as size_t, - &mut outsz, - flags); - assert!(res as int != 0); - let out = vec::raw::from_buf_raw(res as *u8, - outsz as uint); - libc::free(res as *mut c_void); - out - } -} - -pub fn deflate_bytes(bytes: &[u8]) -> ~[u8] { - deflate_bytes_internal(bytes, LZ_NORM) -} - -pub fn deflate_bytes_zlib(bytes: &[u8]) -> ~[u8] { - deflate_bytes_internal(bytes, LZ_NORM | TDEFL_WRITE_ZLIB_HEADER) -} - -fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] { - unsafe { - let mut outsz : size_t = 0; - let res = rustrt::tinfl_decompress_mem_to_heap(bytes.as_ptr() as *c_void, - bytes.len() as size_t, - &mut outsz, - flags); - assert!(res as int != 0); - let out = vec::raw::from_buf_raw(res as *u8, - outsz as uint); - libc::free(res as *mut c_void); - out - } -} - -pub fn inflate_bytes(bytes: &[u8]) -> ~[u8] { - inflate_bytes_internal(bytes, 0) -} - -pub fn inflate_bytes_zlib(bytes: &[u8]) -> ~[u8] { - inflate_bytes_internal(bytes, TINFL_FLAG_PARSE_ZLIB_HEADER) -} - -#[cfg(test)] -mod tests { - use super::*; - use std::rand; - use std::rand::Rng; - - #[test] - fn test_flate_round_trip() { - let mut r = rand::rng(); - let mut words = ~[]; - 20.times(|| { - let range = r.gen_range(1u, 10); - words.push(r.gen_vec::(range)); - }); - 20.times(|| { - let mut input = ~[]; - 2000.times(|| { - input.push_all(r.choose(words)); - }); - debug!("de/inflate of {} bytes of random word-sequences", - input.len()); - let cmp = deflate_bytes(input); - let out = inflate_bytes(cmp); - debug!("{} bytes deflated to {} ({:.1f}% size)", - input.len(), cmp.len(), - 100.0 * ((cmp.len() as f64) / (input.len() as f64))); - assert_eq!(input, out); - }); - } - - #[test] - fn test_zlib_flate() { - let bytes = ~[1, 2, 3, 4, 5]; - let deflated = deflate_bytes(bytes); - let inflated = inflate_bytes(deflated); - assert_eq!(inflated, bytes); - } -} diff --git a/src/libextra/lib.rs b/src/libextra/lib.rs index fc0cc045175..5a4fedd2b2a 100644 --- a/src/libextra/lib.rs +++ b/src/libextra/lib.rs @@ -82,7 +82,6 @@ pub mod rational; pub mod complex; pub mod stats; pub mod semver; -pub mod flate; pub mod hex; pub mod uuid; diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs new file mode 100644 index 00000000000..f746fe4ec32 --- /dev/null +++ b/src/libflate/lib.rs @@ -0,0 +1,133 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/*! + +Simple compression + +*/ + +#[crate_id = "flate#0.10-pre"]; +#[crate_type = "rlib"]; +#[crate_type = "dylib"]; +#[license = "MIT/ASL2"]; +#[allow(missing_doc)]; + +use std::libc::{c_void, size_t, c_int}; +use std::libc; +use std::vec; + +pub mod rustrt { + use std::libc::{c_int, c_void, size_t}; + + #[link(name = "miniz", kind = "static")] + extern { + pub fn tdefl_compress_mem_to_heap(psrc_buf: *c_void, + src_buf_len: size_t, + pout_len: *mut size_t, + flags: c_int) + -> *c_void; + + pub fn tinfl_decompress_mem_to_heap(psrc_buf: *c_void, + src_buf_len: size_t, + pout_len: *mut size_t, + flags: c_int) + -> *c_void; + } +} + +static LZ_NORM : c_int = 0x80; // LZ with 128 probes, "normal" +static TINFL_FLAG_PARSE_ZLIB_HEADER : c_int = 0x1; // parse zlib header and adler32 checksum +static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum + +fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] { + unsafe { + let mut outsz : size_t = 0; + let res = rustrt::tdefl_compress_mem_to_heap(bytes.as_ptr() as *c_void, + bytes.len() as size_t, + &mut outsz, + flags); + assert!(res as int != 0); + let out = vec::raw::from_buf_raw(res as *u8, + outsz as uint); + libc::free(res as *mut c_void); + out + } +} + +pub fn deflate_bytes(bytes: &[u8]) -> ~[u8] { + deflate_bytes_internal(bytes, LZ_NORM) +} + +pub fn deflate_bytes_zlib(bytes: &[u8]) -> ~[u8] { + deflate_bytes_internal(bytes, LZ_NORM | TDEFL_WRITE_ZLIB_HEADER) +} + +fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] { + unsafe { + let mut outsz : size_t = 0; + let res = rustrt::tinfl_decompress_mem_to_heap(bytes.as_ptr() as *c_void, + bytes.len() as size_t, + &mut outsz, + flags); + assert!(res as int != 0); + let out = vec::raw::from_buf_raw(res as *u8, + outsz as uint); + libc::free(res as *mut c_void); + out + } +} + +pub fn inflate_bytes(bytes: &[u8]) -> ~[u8] { + inflate_bytes_internal(bytes, 0) +} + +pub fn inflate_bytes_zlib(bytes: &[u8]) -> ~[u8] { + inflate_bytes_internal(bytes, TINFL_FLAG_PARSE_ZLIB_HEADER) +} + +#[cfg(test)] +mod tests { + use super::{inflate_bytes, deflate_bytes}; + use std::rand; + use std::rand::Rng; + + #[test] + fn test_flate_round_trip() { + let mut r = rand::rng(); + let mut words = ~[]; + 20.times(|| { + let range = r.gen_range(1u, 10); + words.push(r.gen_vec::(range)); + }); + 20.times(|| { + let mut input = ~[]; + 2000.times(|| { + input.push_all(r.choose(words)); + }); + debug!("de/inflate of {} bytes of random word-sequences", + input.len()); + let cmp = deflate_bytes(input); + let out = inflate_bytes(cmp); + debug!("{} bytes deflated to {} ({:.1f}% size)", + input.len(), cmp.len(), + 100.0 * ((cmp.len() as f64) / (input.len() as f64))); + assert_eq!(input, out); + }); + } + + #[test] + fn test_zlib_flate() { + let bytes = ~[1, 2, 3, 4, 5]; + let deflated = deflate_bytes(bytes); + let inflated = inflate_bytes(deflated); + assert_eq!(inflated, bytes); + } +} diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index f7ee736f144..62232360c33 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -30,6 +30,7 @@ This API is completely unstable and subject to change. #[feature(macro_rules, globs, struct_variant, managed_boxes)]; extern mod extra; +extern mod flate; extern mod syntax; use back::link; diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 72f2e1baddd..8b7da1f8310 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -33,7 +33,7 @@ use std::os::consts::{macos, freebsd, linux, android, win32}; use std::ptr; use std::str; use std::vec; -use extra::flate; +use flate; pub enum Os { OsMacos, diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 5b246daa6c5..9744c395b7c 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -2683,7 +2683,7 @@ pub fn crate_ctxt_to_encode_parms<'r>(cx: &'r CrateContext, ie: encoder::encode_ } pub fn write_metadata(cx: &CrateContext, crate: &ast::Crate) -> ~[u8] { - use extra::flate; + use flate; if !cx.sess.building_library.get() { return ~[] diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 5d0728c8cdf..d53adb78a30 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -16,7 +16,9 @@ //! functionality through a unit-struct, `Markdown`, which has an implementation //! of `fmt::Default`. Example usage: //! -//! ```rust +//! ```rust,ignore +//! use rustdoc::html::markdown::Markdown; +//! //! let s = "My *markdown* _text_"; //! let html = format!("{}", Markdown(s)); //! // ... something using html -- cgit 1.4.1-3-g733a5