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.
* [The Rust parser, `libsyntax`](syntax/index.html)
* [The Rust compiler, `librustc`](rustc/index.html)
+* [The `flate` compression library](flate/index.html)
+
# Tooling
* [The `rustdoc` manual](rustdoc.html)
* [Language FAQ](complement-lang-faq.html)
* [Project FAQ](complement-project-faq.html)
* [Usage FAQ](complement-usage-faq.html)
-* [Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"
+* [Code cheatsheet](complement-cheatsheet.html) - "How do I do X?"
* [How to submit a bug report](complement-bugreport.html)
# External resources
-* The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org
+* The Rust [IRC channel](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - `#rust` on irc.mozilla.org
* The Rust community on [Reddit](http://reddit.com/r/rust)
* The Rust [wiki](http://github.com/mozilla/rust/wiki)
# automatically generated for all stage/host/target combinations.
################################################################################
-TARGET_CRATES := std extra green rustuv native
+TARGET_CRATES := std extra green rustuv native flate
HOST_CRATES := syntax rustc rustdoc rustpkg
CRATES := $(TARGET_CRATES) $(HOST_CRATES)
TOOLS := compiletest rustpkg rustdoc rustc
DEPS_rustuv := std native:uv native:uv_support
DEPS_native := std
DEPS_syntax := std extra
-DEPS_rustc := syntax native:rustllvm
+DEPS_rustc := syntax native:rustllvm flate
DEPS_rustdoc := rustc native:sundown
DEPS_rustpkg := rustc
+DEPS_flate := std native:miniz
TOOL_DEPS_compiletest := extra green rustuv
TOOL_DEPS_rustpkg := rustpkg green rustuv
# that's per-target so you're allowed to conditionally add files based on the
# target.
################################################################################
-NATIVE_LIBS := rustrt sundown uv_support morestack
+NATIVE_LIBS := rustrt sundown uv_support morestack miniz
# $(1) is the target triple
define NATIVE_LIBRARIES
sundown/html/html_smartypants.c \
sundown/html/html.c
NATIVE_DEPS_uv_support_$(1) := rust_uv.c
+NATIVE_DEPS_miniz_$(1) = miniz.c
NATIVE_DEPS_rustrt_$(1) := rust_builtin.c \
- miniz.c \
rust_android_dummy.c \
rust_test_helpers.c \
rust_try.ll \
tmp/$$(FT).rc \
$$(SREQ2_T_$(2)_H_$(3))
@$$(call E, compile_and_link: $$@)
- $$(STAGE2_T_$(2)_H_$(3)) --lib -o $$@ $$<
+ $$(STAGE2_T_$(2)_H_$(3)) --lib -o $$@ $$< \
+ -L "$$(RT_OUTPUT_DIR_$(2))"
$(3)/test/$$(FT_DRIVER)-$(2)$$(X_$(2)): \
tmp/$$(FT_DRIVER).rs \
$$(TLIB2_T_$(2)_H_$(3))/$$(FT_LIB) \
$$(SREQ2_T_$(2)_H_$(3))
@$$(call E, compile_and_link: $$@ $$<)
- $$(STAGE2_T_$(2)_H_$(3)) -o $$@ $$<
+ $$(STAGE2_T_$(2)_H_$(3)) -o $$@ $$< \
+ -L "$$(RT_OUTPUT_DIR_$(2))"
$(3)/test/$$(FT_DRIVER)-$(2).out: \
$(3)/test/$$(FT_DRIVER)-$(2)$$(X_$(2)) \
+++ /dev/null
-// 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 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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::<u8>(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);
- }
-}
pub mod complex;
pub mod stats;
pub mod semver;
-pub mod flate;
pub mod hex;
pub mod uuid;
--- /dev/null
+// 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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::<u8>(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);
+ }
+}
#[feature(macro_rules, globs, struct_variant, managed_boxes)];
extern mod extra;
+extern mod flate;
extern mod syntax;
use back::link;
use std::ptr;
use std::str;
use std::vec;
-use extra::flate;
+use flate;
pub enum Os {
OsMacos,
}
pub fn write_metadata(cx: &CrateContext, crate: &ast::Crate) -> ~[u8] {
- use extra::flate;
+ use flate;
if !cx.sess.building_library.get() {
return ~[]
//! 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
projects / rust.git / commitdiff