nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-06-05 11:48:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

CamelCasify lots of std

Browse Source
This commit is contained in:
Ben Striegel 2012-08-11 10:08:42 -04:00 committed by Brian Anderson
parent ecb646477b
commit a605fd0cad
30 changed files with 783 additions and 763 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/cargo/cargo.rs
View File

@ -74,7 +74,7 @@ type options = {
enum mode { system_mode, user_mode, local_mode } enum mode { system_mode, user_mode, local_mode }
fn opts() -> ~[getopts::opt] { fn opts() -> ~[getopts::Opt] {
~[optflag(~"g"), optflag(~"G"), optflag(~"test"), ~[optflag(~"g"), optflag(~"G"), optflag(~"test"),
optflag(~"h"), optflag(~"help")] optflag(~"h"), optflag(~"help")]
} }
@ -387,27 +387,27 @@ fn valid_pkg_name(s: ~str) -> bool {
s.all(is_valid_digit) s.all(is_valid_digit)
} }
fn parse_source(name: ~str, j: json::json) -> source { fn parse_source(name: ~str, j: json::Json) -> source {
if !valid_pkg_name(name) { if !valid_pkg_name(name) {
fail fmt!("'%s' is an invalid source name", name); fail fmt!("'%s' is an invalid source name", name);
} }
match j { match j {
json::dict(j) => { json::Dict(j) => {
let mut url = match j.find(~"url") { let mut url = match j.find(~"url") {
Some(json::string(u)) => *u, Some(json::String(u)) => *u,
_ => fail ~"needed 'url' field in source" _ => fail ~"needed 'url' field in source"
}; };
let method = match j.find(~"method") { let method = match j.find(~"method") {
Some(json::string(u)) => *u, Some(json::String(u)) => *u,
_ => assume_source_method(url) _ => assume_source_method(url)
}; };
let key = match j.find(~"key") { let key = match j.find(~"key") {
Some(json::string(u)) => Some(*u), Some(json::String(u)) => Some(*u),
_ => None _ => None
}; };
let keyfp = match j.find(~"keyfp") { let keyfp = match j.find(~"keyfp") {
Some(json::string(u)) => Some(*u), Some(json::String(u)) => Some(*u),
_ => None _ => None
}; };
if method == ~"file" { if method == ~"file" {
@ -429,7 +429,7 @@ fn try_parse_sources(filename: &Path, sources: map::hashmap<~str, source>) {
if !os::path_exists(filename) { return; } if !os::path_exists(filename) { return; }
let c = io::read_whole_file_str(filename); let c = io::read_whole_file_str(filename);
match json::from_str(result::get(c)) { match json::from_str(result::get(c)) {
Ok(json::dict(j)) => { Ok(json::Dict(j)) => {
for j.each |k, v| { for j.each |k, v| {
sources.insert(k, parse_source(k, v)); sources.insert(k, parse_source(k, v));
debug!("source: %s", k); debug!("source: %s", k);
@ -440,9 +440,9 @@ fn try_parse_sources(filename: &Path, sources: map::hashmap<~str, source>) {
} }
} }
fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) { fn load_one_source_package(src: source, p: map::hashmap<~str, json::Json>) {
let name = match p.find(~"name") { let name = match p.find(~"name") {
Some(json::string(n)) => { Some(json::String(n)) => {
if !valid_pkg_name(*n) { if !valid_pkg_name(*n) {
warn(~"malformed source json: " warn(~"malformed source json: "
+ src.name + ~", '" + *n + ~"'"+ + src.name + ~", '" + *n + ~"'"+
@ -459,7 +459,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}; };
let uuid = match p.find(~"uuid") { let uuid = match p.find(~"uuid") {
Some(json::string(n)) => { Some(json::String(n)) => {
if !is_uuid(*n) { if !is_uuid(*n) {
warn(~"malformed source json: " warn(~"malformed source json: "
+ src.name + ~", '" + *n + ~"'"+ + src.name + ~", '" + *n + ~"'"+
@ -475,7 +475,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}; };
let url = match p.find(~"url") { let url = match p.find(~"url") {
Some(json::string(n)) => *n, Some(json::String(n)) => *n,
_ => { _ => {
warn(~"malformed source json: " + src.name + ~" (missing url)"); warn(~"malformed source json: " + src.name + ~" (missing url)");
return; return;
@ -483,7 +483,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}; };
let method = match p.find(~"method") { let method = match p.find(~"method") {
Some(json::string(n)) => *n, Some(json::String(n)) => *n,
_ => { _ => {
warn(~"malformed source json: " warn(~"malformed source json: "
+ src.name + ~" (missing method)"); + src.name + ~" (missing method)");
@ -492,16 +492,16 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}; };
let reference = match p.find(~"ref") { let reference = match p.find(~"ref") {
Some(json::string(n)) => Some(*n), Some(json::String(n)) => Some(*n),
_ => None _ => None
}; };
let mut tags = ~[]; let mut tags = ~[];
match p.find(~"tags") { match p.find(~"tags") {
Some(json::list(js)) => { Some(json::List(js)) => {
for (*js).each |j| { for (*js).each |j| {
match j { match j {
json::string(j) => vec::grow(tags, 1u, *j), json::String(j) => vec::grow(tags, 1u, *j),
_ => () _ => ()
} }
} }
@ -510,7 +510,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
} }
let description = match p.find(~"description") { let description = match p.find(~"description") {
Some(json::string(n)) => *n, Some(json::String(n)) => *n,
_ => { _ => {
warn(~"malformed source json: " + src.name warn(~"malformed source json: " + src.name
+ ~" (missing description)"); + ~" (missing description)");
@ -548,8 +548,8 @@ fn load_source_info(c: cargo, src: source) {
if !os::path_exists(&srcfile) { return; } if !os::path_exists(&srcfile) { return; }
let srcstr = io::read_whole_file_str(&srcfile); let srcstr = io::read_whole_file_str(&srcfile);
match json::from_str(result::get(srcstr)) { match json::from_str(result::get(srcstr)) {
Ok(json::dict(s)) => { Ok(json::Dict(s)) => {
let o = parse_source(src.name, json::dict(s)); let o = parse_source(src.name, json::Dict(s));
src.key = o.key; src.key = o.key;
src.keyfp = o.keyfp; src.keyfp = o.keyfp;
@ -570,10 +570,10 @@ fn load_source_packages(c: cargo, src: source) {
if !os::path_exists(&pkgfile) { return; } if !os::path_exists(&pkgfile) { return; }
let pkgstr = io::read_whole_file_str(&pkgfile); let pkgstr = io::read_whole_file_str(&pkgfile);
match json::from_str(result::get(pkgstr)) { match json::from_str(result::get(pkgstr)) {
Ok(json::list(js)) => { Ok(json::List(js)) => {
for (*js).each |j| { for (*js).each |j| {
match j { match j {
json::dict(p) => { json::Dict(p) => {
load_one_source_package(src, p); load_one_source_package(src, p);
} }
_ => { _ => {
@ -1551,7 +1551,7 @@ fn dump_cache(c: cargo) {
need_dir(&c.root); need_dir(&c.root);
let out = c.root.push("cache.json"); let out = c.root.push("cache.json");
let _root = json::dict(map::str_hash()); let _root = json::Dict(map::str_hash());
if os::path_exists(&out) { if os::path_exists(&out) {
copy_warn(&out, &c.root.push("cache.json.old")); copy_warn(&out, &c.root.push("cache.json.old"));
@ -1573,24 +1573,24 @@ fn dump_sources(c: cargo) {
match io::buffered_file_writer(&out) { match io::buffered_file_writer(&out) {
result::Ok(writer) => { result::Ok(writer) => {
let hash = map::str_hash(); let hash = map::str_hash();
let root = json::dict(hash); let root = json::Dict(hash);
for c.sources.each |k, v| { for c.sources.each |k, v| {
let chash = map::str_hash(); let chash = map::str_hash();
let child = json::dict(chash); let child = json::Dict(chash);
chash.insert(~"url", json::string(@v.url)); chash.insert(~"url", json::String(@v.url));
chash.insert(~"method", json::string(@v.method)); chash.insert(~"method", json::String(@v.method));
match copy v.key { match copy v.key {
Some(key) => { Some(key) => {
chash.insert(~"key", json::string(@key)); chash.insert(~"key", json::String(@key));
} }
_ => () _ => ()
} }
match copy v.keyfp { match copy v.keyfp {
Some(keyfp) => { Some(keyfp) => {
chash.insert(~"keyfp", json::string(@keyfp)); chash.insert(~"keyfp", json::String(@keyfp));
} }
_ => () _ => ()
} }

2
src/compiletest/compiletest.rs
View File

@ -42,7 +42,7 @@ fn parse_config(args: ~[~str]) -> config {
Err(f) => fail getopts::fail_str(f) Err(f) => fail getopts::fail_str(f)
}; };
fn opt_path(m: getopts::matches, nm: ~str) -> Path { fn opt_path(m: getopts::Matches, nm: ~str) -> Path {
Path(getopts::opt_str(m, nm)) Path(getopts::opt_str(m, nm))
} }

29
src/libstd/arena.rs
View File

@ -1,4 +1,5 @@
// Dynamic arenas. // Dynamic arenas.
#[warn(non_camel_case_types)];
// Arenas are used to quickly allocate objects that share a // Arenas are used to quickly allocate objects that share a
// lifetime. The arena uses ~[u8] vectors as a backing store to // lifetime. The arena uses ~[u8] vectors as a backing store to
@ -22,7 +23,7 @@
// overhead when initializing plain-old-data and means we don't need // overhead when initializing plain-old-data and means we don't need
// to waste time running the destructors of POD. // to waste time running the destructors of POD.
export arena, arena_with_size; export Arena, arena_with_size;
import list; import list;
import list::{list, cons, nil}; import list::{list, cons, nil};
@ -46,15 +47,15 @@ const tydesc_drop_glue_index: size_t = 3 as size_t;
// The way arena uses arrays is really deeply awful. The arrays are // The way arena uses arrays is really deeply awful. The arrays are
// allocated, and have capacities reserved, but the fill for the array // allocated, and have capacities reserved, but the fill for the array
// will always stay at 0. // will always stay at 0.
type chunk = {data: @[u8], mut fill: uint, is_pod: bool}; type Chunk = {data: @[u8], mut fill: uint, is_pod: bool};
struct arena { struct Arena {
// The head is seperated out from the list as a unbenchmarked // The head is seperated out from the list as a unbenchmarked
// microoptimization, to avoid needing to case on the list to // microoptimization, to avoid needing to case on the list to
// access the head. // access the head.
priv mut head: chunk; priv mut head: Chunk;
priv mut pod_head: chunk; priv mut pod_head: Chunk;
priv mut chunks: @list<chunk>; priv mut chunks: @list<Chunk>;
drop { drop {
unsafe { unsafe {
destroy_chunk(self.head); destroy_chunk(self.head);
@ -65,19 +66,19 @@ struct arena {
} }
} }
fn chunk(size: uint, is_pod: bool) -> chunk { fn chunk(size: uint, is_pod: bool) -> Chunk {
let mut v = @[]; let mut v = @[];
unsafe { at_vec::unsafe::reserve(v, size); } unsafe { at_vec::unsafe::reserve(v, size); }
{ data: v, mut fill: 0u, is_pod: is_pod } { data: v, mut fill: 0u, is_pod: is_pod }
} }
fn arena_with_size(initial_size: uint) -> arena { fn arena_with_size(initial_size: uint) -> Arena {
return arena {mut head: chunk(initial_size, false), return Arena {mut head: chunk(initial_size, false),
mut pod_head: chunk(initial_size, true), mut pod_head: chunk(initial_size, true),
mut chunks: @nil}; mut chunks: @nil};
} }
fn arena() -> arena { fn Arena() -> Arena {
arena_with_size(32u) arena_with_size(32u)
} }
@ -88,7 +89,7 @@ fn round_up_to(base: uint, align: uint) -> uint {
// Walk down a chunk, running the destructors for any objects stored // Walk down a chunk, running the destructors for any objects stored
// in it. // in it.
unsafe fn destroy_chunk(chunk: chunk) { unsafe fn destroy_chunk(chunk: Chunk) {
let mut idx = 0; let mut idx = 0;
let buf = vec::unsafe::to_ptr_slice(chunk.data); let buf = vec::unsafe::to_ptr_slice(chunk.data);
let fill = chunk.fill; let fill = chunk.fill;
@ -129,7 +130,7 @@ unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TypeDesc, bool) {
} }
// The duplication between the POD and non-POD functions is annoying. // The duplication between the POD and non-POD functions is annoying.
impl &arena { impl &Arena {
// Functions for the POD part of the arena // Functions for the POD part of the arena
fn alloc_pod_grow(n_bytes: uint, align: uint) -> *u8 { fn alloc_pod_grow(n_bytes: uint, align: uint) -> *u8 {
// Allocate a new chunk. // Allocate a new chunk.
@ -238,7 +239,7 @@ impl &arena {
#[test] #[test]
fn test_arena_destructors() { fn test_arena_destructors() {
let arena = arena::arena(); let arena = arena::Arena();
for uint::range(0, 10) |i| { for uint::range(0, 10) |i| {
// Arena allocate something with drop glue to make sure it // Arena allocate something with drop glue to make sure it
// doesn't leak. // doesn't leak.
@ -251,7 +252,7 @@ fn test_arena_destructors() {
#[test] #[should_fail] #[ignore(cfg(windows))] #[test] #[should_fail] #[ignore(cfg(windows))]
fn test_arena_destructors_fail() { fn test_arena_destructors_fail() {
let arena = arena::arena(); let arena = arena::Arena();
// Put some stuff in the arena. // Put some stuff in the arena.
for uint::range(0, 10) |i| { for uint::range(0, 10) |i| {
// Arena allocate something with drop glue to make sure it // Arena allocate something with drop glue to make sure it

13
src/libstd/base64.rs
View File

@ -1,10 +1,11 @@
#[deny(non_camel_case_types)];
import io::Reader; import io::Reader;
trait to_base64 { trait ToBase64 {
fn to_base64() -> ~str; fn to_base64() -> ~str;
} }
impl ~[u8]: to_base64 { impl ~[u8]: ToBase64 {
fn to_base64() -> ~str { fn to_base64() -> ~str {
let chars = str::chars( let chars = str::chars(
~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
@ -55,17 +56,17 @@ impl ~[u8]: to_base64 {
} }
} }
impl ~str: to_base64 { impl ~str: ToBase64 {
fn to_base64() -> ~str { fn to_base64() -> ~str {
str::to_bytes(self).to_base64() str::to_bytes(self).to_base64()
} }
} }
trait from_base64 { trait FromBase64 {
fn from_base64() -> ~[u8]; fn from_base64() -> ~[u8];
} }
impl ~[u8]: from_base64 { impl ~[u8]: FromBase64 {
fn from_base64() -> ~[u8] { fn from_base64() -> ~[u8] {
if self.len() % 4u != 0u { fail ~"invalid base64 length"; } if self.len() % 4u != 0u { fail ~"invalid base64 length"; }
@ -127,7 +128,7 @@ impl ~[u8]: from_base64 {
} }
} }
impl ~str: from_base64 { impl ~str: FromBase64 {
fn from_base64() -> ~[u8] { fn from_base64() -> ~[u8] {
str::to_bytes(self).from_base64() str::to_bytes(self).from_base64()
} }

209
src/libstd/bitv.rs
View File

@ -1,16 +1,21 @@
#[deny(non_camel_case_types)];
import vec::{to_mut, from_elem}; import vec::{to_mut, from_elem};
export bitv; export Bitv;
export union; export union;
export Union;
export intersect; export intersect;
export Intersect;
export assign; export assign;
export Assign;
export difference;
export Difference;
export clone; export clone;
export get; export get;
export equal; export equal;
export clear; export clear;
export set_all; export set_all;
export invert; export invert;
export difference;
export set; export set;
export is_true; export is_true;
export is_false; export is_false;
@ -25,7 +30,7 @@ fn small_mask(nbits: uint) -> u32 {
(1 << nbits) - 1 (1 << nbits) - 1
} }
struct small_bitv { struct SmallBitv {
/// only the lowest nbits of this value are used. the rest is undefined. /// only the lowest nbits of this value are used. the rest is undefined.
let mut bits: u32; let mut bits: u32;
new(bits: u32) { self.bits = bits; } new(bits: u32) { self.bits = bits; }
@ -41,19 +46,19 @@ struct small_bitv {
} }
} }
#[inline(always)] #[inline(always)]
fn union(s: &small_bitv, nbits: uint) -> bool { fn union(s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |u1, u2| u1 | u2) self.bits_op(s.bits, nbits, |u1, u2| u1 | u2)
} }
#[inline(always)] #[inline(always)]
fn intersect(s: &small_bitv, nbits: uint) -> bool { fn intersect(s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |u1, u2| u1 & u2) self.bits_op(s.bits, nbits, |u1, u2| u1 & u2)
} }
#[inline(always)] #[inline(always)]
fn become(s: &small_bitv, nbits: uint) -> bool { fn become(s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |_u1, u2| u2) self.bits_op(s.bits, nbits, |_u1, u2| u2)
} }
#[inline(always)] #[inline(always)]
fn difference(s: &small_bitv, nbits: uint) -> bool { fn difference(s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |u1, u2| u1 ^ u2) self.bits_op(s.bits, nbits, |u1, u2| u1 ^ u2)
} }
#[inline(always)] #[inline(always)]
@ -70,7 +75,7 @@ struct small_bitv {
} }
} }
#[inline(always)] #[inline(always)]
fn equals(b: &small_bitv, nbits: uint) -> bool { fn equals(b: &SmallBitv, nbits: uint) -> bool {
let mask = small_mask(nbits); let mask = small_mask(nbits);
mask & self.bits == mask & b.bits mask & self.bits == mask & b.bits
} }
@ -106,7 +111,7 @@ fn big_mask(nbits: uint, elem: uint) -> uint {
} }
} }
struct big_bitv { struct BigBitv {
// only mut b/c of clone and lack of other constructor // only mut b/c of clone and lack of other constructor
let mut storage: ~[mut uint]; let mut storage: ~[mut uint];
new(-storage: ~[mut uint]) { new(-storage: ~[mut uint]) {
@ -114,7 +119,7 @@ struct big_bitv {
} }
priv { priv {
#[inline(always)] #[inline(always)]
fn process(b: &big_bitv, nbits: uint, op: fn(uint, uint) -> uint) fn process(b: &BigBitv, nbits: uint, op: fn(uint, uint) -> uint)
-> bool { -> bool {
let len = b.storage.len(); let len = b.storage.len();
assert (self.storage.len() == len); assert (self.storage.len() == len);
@ -145,19 +150,19 @@ struct big_bitv {
#[inline(always)] #[inline(always)]
fn invert() { for self.each_storage() |w| { w = !w } } fn invert() { for self.each_storage() |w| { w = !w } }
#[inline(always)] #[inline(always)]
fn union(b: &big_bitv, nbits: uint) -> bool { fn union(b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, lor) self.process(b, nbits, lor)
} }
#[inline(always)] #[inline(always)]
fn intersect(b: &big_bitv, nbits: uint) -> bool { fn intersect(b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, land) self.process(b, nbits, land)
} }
#[inline(always)] #[inline(always)]
fn become(b: &big_bitv, nbits: uint) -> bool { fn become(b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, right) self.process(b, nbits, right)
} }
#[inline(always)] #[inline(always)]
fn difference(b: &big_bitv, nbits: uint) -> bool { fn difference(b: &BigBitv, nbits: uint) -> bool {
self.invert(); self.invert();
let b = self.intersect(b, nbits); let b = self.intersect(b, nbits);
self.invert(); self.invert();
@ -179,7 +184,7 @@ struct big_bitv {
else { self.storage[w] & !flag }; else { self.storage[w] & !flag };
} }
#[inline(always)] #[inline(always)]
fn equals(b: &big_bitv, nbits: uint) -> bool { fn equals(b: &BigBitv, nbits: uint) -> bool {
let len = b.storage.len(); let len = b.storage.len();
for uint::iterate(0, len) |i| { for uint::iterate(0, len) |i| {
let mask = big_mask(nbits, i); let mask = big_mask(nbits, i);
@ -190,26 +195,26 @@ struct big_bitv {
} }
} }
enum a_bitv { big(~big_bitv), small(~small_bitv) } enum BitvVariant { Big(~BigBitv), Small(~SmallBitv) }
enum op {union, intersect, assign, difference} enum Op {Union, Intersect, Assign, Difference}
// The bitvector type // The bitvector type
struct bitv { struct Bitv {
let rep: a_bitv; let rep: BitvVariant;
let nbits: uint; let nbits: uint;
new(nbits: uint, init: bool) { new(nbits: uint, init: bool) {
self.nbits = nbits; self.nbits = nbits;
if nbits <= 32 { if nbits <= 32 {
self.rep = small(~small_bitv(if init {!0} else {0})); self.rep = Small(~SmallBitv(if init {!0} else {0}));
} }
else { else {
let nelems = nbits/uint_bits + let nelems = nbits/uint_bits +
if nbits % uint_bits == 0 {0} else {1}; if nbits % uint_bits == 0 {0} else {1};
let elem = if init {!0} else {0}; let elem = if init {!0} else {0};
let s = to_mut(from_elem(nelems, elem)); let s = to_mut(from_elem(nelems, elem));
self.rep = big(~big_bitv(s)); self.rep = Big(~BigBitv(s));
}; };
} }
@ -219,27 +224,27 @@ struct bitv {
different sizes"; different sizes";
} }
#[inline(always)] #[inline(always)]
fn do_op(op: op, other: &bitv) -> bool { fn do_op(op: Op, other: &Bitv) -> bool {
if self.nbits != other.nbits { if self.nbits != other.nbits {
self.die(); self.die();
} }
match self.rep { match self.rep {
small(s) => match other.rep { Small(s) => match other.rep {
small(s1) => match op { Small(s1) => match op {
union => s.union(s1, self.nbits), Union => s.union(s1, self.nbits),
intersect => s.intersect(s1, self.nbits), Intersect => s.intersect(s1, self.nbits),
assign => s.become(s1, self.nbits), Assign => s.become(s1, self.nbits),
difference => s.difference(s1, self.nbits) Difference => s.difference(s1, self.nbits)
}, },
big(_) => self.die() Big(_) => self.die()
}, },
big(s) => match other.rep { Big(s) => match other.rep {
small(_) => self.die(), Small(_) => self.die(),
big(s1) => match op { Big(s1) => match op {
union => s.union(s1, self.nbits), Union => s.union(s1, self.nbits),
intersect => s.intersect(s1, self.nbits), Intersect => s.intersect(s1, self.nbits),
assign => s.become(s1, self.nbits), Assign => s.become(s1, self.nbits),
difference => s.difference(s1, self.nbits) Difference => s.difference(s1, self.nbits)
} }
} }
} }
@ -253,7 +258,7 @@ struct bitv {
* the same length. Returns 'true' if `self` changed. * the same length. Returns 'true' if `self` changed.
*/ */
#[inline(always)] #[inline(always)]
fn union(v1: &bitv) -> bool { self.do_op(union, v1) } fn union(v1: &Bitv) -> bool { self.do_op(Union, v1) }
/** /**
* Calculates the intersection of two bitvectors * Calculates the intersection of two bitvectors
@ -262,7 +267,7 @@ struct bitv {
* the same length. Returns 'true' if `self` changed. * the same length. Returns 'true' if `self` changed.
*/ */
#[inline(always)] #[inline(always)]
fn intersect(v1: &bitv) -> bool { self.do_op(intersect, v1) } fn intersect(v1: &Bitv) -> bool { self.do_op(Intersect, v1) }
/** /**
* Assigns the value of `v1` to `self` * Assigns the value of `v1` to `self`
@ -271,20 +276,20 @@ struct bitv {
* changed * changed
*/ */
#[inline(always)] #[inline(always)]
fn assign(v: &bitv) -> bool { self.do_op(assign, v) } fn assign(v: &Bitv) -> bool { self.do_op(Assign, v) }
/// Makes a copy of a bitvector /// Makes a copy of a bitvector
#[inline(always)] #[inline(always)]
fn clone() -> ~bitv { fn clone() -> ~Bitv {
~match self.rep { ~match self.rep {
small(b) => { Small(b) => {
bitv{nbits: self.nbits, rep: small(~small_bitv{bits: b.bits})} Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})}
} }
big(b) => { Big(b) => {
let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0)); let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0));
let len = st.len(); let len = st.len();
for uint::range(0, len) |i| { st[i] = b.storage[i]; }; for uint::range(0, len) |i| { st[i] = b.storage[i]; };
bitv{nbits: self.nbits, rep: big(~big_bitv{storage: st})} Bitv{nbits: self.nbits, rep: Big(~BigBitv{storage: st})}
} }
} }
} }
@ -294,8 +299,8 @@ struct bitv {
pure fn get(i: uint) -> bool { pure fn get(i: uint) -> bool {
assert (i < self.nbits); assert (i < self.nbits);
match self.rep { match self.rep {
big(b) => b.get(i), Big(b) => b.get(i),
small(s) => s.get(i) Small(s) => s.get(i)
} }
} }
@ -308,8 +313,8 @@ struct bitv {
fn set(i: uint, x: bool) { fn set(i: uint, x: bool) {
assert (i < self.nbits); assert (i < self.nbits);
match self.rep { match self.rep {
big(b) => b.set(i, x), Big(b) => b.set(i, x),
small(s) => s.set(i, x) Small(s) => s.set(i, x)
} }
} }
@ -320,16 +325,16 @@ struct bitv {
* contain identical elements. * contain identical elements.
*/ */
#[inline(always)] #[inline(always)]
fn equal(v1: bitv) -> bool { fn equal(v1: Bitv) -> bool {
if self.nbits != v1.nbits { return false; } if self.nbits != v1.nbits { return false; }
match self.rep { match self.rep {
small(b) => match v1.rep { Small(b) => match v1.rep {
small(b1) => b.equals(b1, self.nbits), Small(b1) => b.equals(b1, self.nbits),
_ => false _ => false
}, },
big(s) => match v1.rep { Big(s) => match v1.rep {
big(s1) => s.equals(s1, self.nbits), Big(s1) => s.equals(s1, self.nbits),
small(_) => return false Small(_) => return false
} }
} }
} }
@ -338,8 +343,8 @@ struct bitv {
#[inline(always)] #[inline(always)]
fn clear() { fn clear() {
match self.rep { match self.rep {
small(b) => b.clear(), Small(b) => b.clear(),
big(s) => for s.each_storage() |w| { w = 0u } Big(s) => for s.each_storage() |w| { w = 0u }
} }
} }
@ -347,16 +352,16 @@ struct bitv {
#[inline(always)] #[inline(always)]
fn set_all() { fn set_all() {
match self.rep { match self.rep {
small(b) => b.set_all(), Small(b) => b.set_all(),
big(s) => for s.each_storage() |w| { w = !0u } } Big(s) => for s.each_storage() |w| { w = !0u } }
} }
/// Invert all bits /// Invert all bits
#[inline(always)] #[inline(always)]
fn invert() { fn invert() {
match self.rep { match self.rep {
small(b) => b.invert(), Small(b) => b.invert(),
big(s) => for s.each_storage() |w| { w = !w } } Big(s) => for s.each_storage() |w| { w = !w } }
} }
/** /**
@ -368,13 +373,13 @@ struct bitv {
* Returns `true` if `v0` was changed. * Returns `true` if `v0` was changed.
*/ */
#[inline(always)] #[inline(always)]
fn difference(v: ~bitv) -> bool { self.do_op(difference, v) } fn difference(v: ~Bitv) -> bool { self.do_op(Difference, v) }
/// Returns true if all bits are 1 /// Returns true if all bits are 1
#[inline(always)] #[inline(always)]
fn is_true() -> bool { fn is_true() -> bool {
match self.rep { match self.rep {
small(b) => b.is_true(self.nbits), Small(b) => b.is_true(self.nbits),
_ => { _ => {
for self.each() |i| { if !i { return false; } } for self.each() |i| { if !i { return false; } }
true true
@ -395,8 +400,8 @@ struct bitv {
fn is_false() -> bool { fn is_false() -> bool {
match self.rep { match self.rep {
small(b) => b.is_false(self.nbits), Small(b) => b.is_false(self.nbits),
big(_) => { Big(_) => {
for self.each() |i| { if i { return false; } } for self.each() |i| { if i { return false; } }
true true
} }
@ -465,7 +470,7 @@ pure fn land(w0: uint, w1: uint) -> uint { return w0 & w1; }
pure fn right(_w0: uint, w1: uint) -> uint { return w1; } pure fn right(_w0: uint, w1: uint) -> uint { return w1; }
impl bitv: ops::index<uint,bool> { impl Bitv: ops::index<uint,bool> {
pure fn index(&&i: uint) -> bool { pure fn index(&&i: uint) -> bool {
self.get(i) self.get(i)
} }
@ -475,10 +480,10 @@ impl bitv: ops::index<uint,bool> {
mod tests { mod tests {
#[test] #[test]
fn test_to_str() { fn test_to_str() {
let zerolen = bitv(0u, false); let zerolen = Bitv(0u, false);
assert zerolen.to_str() == ~""; assert zerolen.to_str() == ~"";
let eightbits = bitv(8u, false); let eightbits = Bitv(8u, false);
assert eightbits.to_str() == ~"00000000"; assert eightbits.to_str() == ~"00000000";
} }
@ -486,7 +491,7 @@ mod tests {
fn test_0_elements() { fn test_0_elements() {
let mut act; let mut act;
let mut exp; let mut exp;
act = bitv(0u, false); act = Bitv(0u, false);
exp = vec::from_elem::<uint>(0u, 0u); exp = vec::from_elem::<uint>(0u, 0u);
assert act.eq_vec(exp); assert act.eq_vec(exp);
} }
@ -494,15 +499,15 @@ mod tests {
#[test] #[test]
fn test_1_element() { fn test_1_element() {
let mut act; let mut act;
act = bitv(1u, false); act = Bitv(1u, false);
assert act.eq_vec(~[0u]); assert act.eq_vec(~[0u]);
act = bitv(1u, true); act = Bitv(1u, true);
assert act.eq_vec(~[1u]); assert act.eq_vec(~[1u]);
} }
#[test] #[test]
fn test_2_elements() { fn test_2_elements() {
let b = bitv::bitv(2, false); let b = bitv::Bitv(2, false);
b.set(0, true); b.set(0, true);
b.set(1, false); b.set(1, false);
assert b.to_str() == ~"10"; assert b.to_str() == ~"10";
@ -513,15 +518,15 @@ mod tests {
let mut act; let mut act;
// all 0 // all 0
act = bitv(10u, false); act = Bitv(10u, false);
assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
// all 1 // all 1
act = bitv(10u, true); act = Bitv(10u, true);
assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])); assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
// mixed // mixed
act = bitv(10u, false); act = Bitv(10u, false);
act.set(0u, true); act.set(0u, true);
act.set(1u, true); act.set(1u, true);
act.set(2u, true); act.set(2u, true);
@ -530,7 +535,7 @@ mod tests {
assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u])); assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]));
// mixed // mixed
act = bitv(10u, false); act = Bitv(10u, false);
act.set(5u, true); act.set(5u, true);
act.set(6u, true); act.set(6u, true);
act.set(7u, true); act.set(7u, true);
@ -539,7 +544,7 @@ mod tests {
assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u])); assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]));
// mixed // mixed
act = bitv(10u, false); act = Bitv(10u, false);
act.set(0u, true); act.set(0u, true);
act.set(3u, true); act.set(3u, true);
act.set(6u, true); act.set(6u, true);
@ -552,21 +557,21 @@ mod tests {
let mut act; let mut act;
// all 0 // all 0
act = bitv(31u, false); act = Bitv(31u, false);
assert (act.eq_vec( assert (act.eq_vec(
~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u]));
// all 1 // all 1
act = bitv(31u, true); act = Bitv(31u, true);
assert (act.eq_vec( assert (act.eq_vec(
~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u])); 1u, 1u, 1u, 1u, 1u]));
// mixed // mixed
act = bitv(31u, false); act = Bitv(31u, false);
act.set(0u, true); act.set(0u, true);
act.set(1u, true); act.set(1u, true);
act.set(2u, true); act.set(2u, true);
@ -581,7 +586,7 @@ mod tests {
0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u]));
// mixed // mixed
act = bitv(31u, false); act = Bitv(31u, false);
act.set(16u, true); act.set(16u, true);
act.set(17u, true); act.set(17u, true);
act.set(18u, true); act.set(18u, true);
@ -596,7 +601,7 @@ mod tests {
0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u]));
// mixed // mixed
act = bitv(31u, false); act = Bitv(31u, false);
act.set(24u, true); act.set(24u, true);
act.set(25u, true); act.set(25u, true);
act.set(26u, true); act.set(26u, true);
@ -610,7 +615,7 @@ mod tests {
1u, 1u, 1u, 1u, 1u])); 1u, 1u, 1u, 1u, 1u]));
// mixed // mixed
act = bitv(31u, false); act = Bitv(31u, false);
act.set(3u, true); act.set(3u, true);
act.set(17u, true); act.set(17u, true);
act.set(30u, true); act.set(30u, true);
@ -625,21 +630,21 @@ mod tests {
let mut act; let mut act;
// all 0 // all 0
act = bitv(32u, false); act = Bitv(32u, false);
assert (act.eq_vec( assert (act.eq_vec(
~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u, 0u]));
// all 1 // all 1
act = bitv(32u, true); act = Bitv(32u, true);
assert (act.eq_vec( assert (act.eq_vec(
~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u])); 1u, 1u, 1u, 1u, 1u, 1u]));
// mixed // mixed
act = bitv(32u, false); act = Bitv(32u, false);
act.set(0u, true); act.set(0u, true);
act.set(1u, true); act.set(1u, true);
act.set(2u, true); act.set(2u, true);
@ -654,7 +659,7 @@ mod tests {
0u, 0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u, 0u]));
// mixed // mixed
act = bitv(32u, false); act = Bitv(32u, false);
act.set(16u, true); act.set(16u, true);
act.set(17u, true); act.set(17u, true);
act.set(18u, true); act.set(18u, true);
@ -669,7 +674,7 @@ mod tests {
0u, 0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u, 0u]));
// mixed // mixed
act = bitv(32u, false); act = Bitv(32u, false);
act.set(24u, true); act.set(24u, true);
act.set(25u, true); act.set(25u, true);
act.set(26u, true); act.set(26u, true);
@ -684,7 +689,7 @@ mod tests {
1u, 1u, 1u, 1u, 1u, 1u])); 1u, 1u, 1u, 1u, 1u, 1u]));
// mixed // mixed
act = bitv(32u, false); act = Bitv(32u, false);
act.set(3u, true); act.set(3u, true);
act.set(17u, true); act.set(17u, true);
act.set(30u, true); act.set(30u, true);
@ -700,21 +705,21 @@ mod tests {
let mut act; let mut act;
// all 0 // all 0
act = bitv(33u, false); act = Bitv(33u, false);
assert (act.eq_vec( assert (act.eq_vec(
~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
// all 1 // all 1
act = bitv(33u, true); act = Bitv(33u, true);
assert (act.eq_vec( assert (act.eq_vec(
~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u])); 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
// mixed // mixed
act = bitv(33u, false); act = Bitv(33u, false);
act.set(0u, true); act.set(0u, true);
act.set(1u, true); act.set(1u, true);
act.set(2u, true); act.set(2u, true);
@ -729,7 +734,7 @@ mod tests {
0u, 0u, 0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
// mixed // mixed
act = bitv(33u, false); act = Bitv(33u, false);
act.set(16u, true); act.set(16u, true);
act.set(17u, true); act.set(17u, true);
act.set(18u, true); act.set(18u, true);
@ -744,7 +749,7 @@ mod tests {
0u, 0u, 0u, 0u, 0u, 0u, 0u])); 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
// mixed // mixed
act = bitv(33u, false); act = Bitv(33u, false);
act.set(24u, true); act.set(24u, true);
act.set(25u, true); act.set(25u, true);
act.set(26u, true); act.set(26u, true);
@ -759,7 +764,7 @@ mod tests {
1u, 1u, 1u, 1u, 1u, 1u, 0u])); 1u, 1u, 1u, 1u, 1u, 1u, 0u]));
// mixed // mixed
act = bitv(33u, false); act = Bitv(33u, false);
act.set(3u, true); act.set(3u, true);
act.set(17u, true); act.set(17u, true);
act.set(30u, true); act.set(30u, true);
@ -773,24 +778,24 @@ mod tests {
#[test] #[test]
fn test_equal_differing_sizes() { fn test_equal_differing_sizes() {
let v0 = bitv(10u, false); let v0 = Bitv(10u, false);
let v1 = bitv(11u, false); let v1 = Bitv(11u, false);
assert !v0.equal(v1); assert !v0.equal(v1);
} }
#[test] #[test]
fn test_equal_greatly_differing_sizes() { fn test_equal_greatly_differing_sizes() {
let v0 = bitv(10u, false); let v0 = Bitv(10u, false);
let v1 = bitv(110u, false); let v1 = Bitv(110u, false);
assert !v0.equal(v1); assert !v0.equal(v1);
} }
#[test] #[test]
fn test_equal_sneaky_small() { fn test_equal_sneaky_small() {
let a = bitv::bitv(1, false); let a = bitv::Bitv(1, false);
a.set(0, true); a.set(0, true);
let b = bitv::bitv(1, true); let b = bitv::Bitv(1, true);
b.set(0, true); b.set(0, true);
assert a.equal(b); assert a.equal(b);
@ -798,12 +803,12 @@ mod tests {
#[test] #[test]
fn test_equal_sneaky_big() { fn test_equal_sneaky_big() {
let a = bitv::bitv(100, false); let a = bitv::Bitv(100, false);
for uint::range(0, 100) |i| { for uint::range(0, 100) |i| {
a.set(i, true); a.set(i, true);
} }
let b = bitv::bitv(100, true); let b = bitv::Bitv(100, true);
for uint::range(0, 100) |i| { for uint::range(0, 100) |i| {
b.set(i, true); b.set(i, true);
} }

37
src/libstd/c_vec.rs
View File

@ -1,3 +1,4 @@
#[deny(non_camel_case_types)];
/*! /*!
* Library to interface with chunks of memory allocated in C. * Library to interface with chunks of memory allocated in C.
* *
@ -19,14 +20,14 @@
* obvious reason (they act on a pointer that cannot be checked inside the * obvious reason (they act on a pointer that cannot be checked inside the
* method), but the elimination form is somewhat more subtle in its unsafety. * method), but the elimination form is somewhat more subtle in its unsafety.
* By using a pointer taken from a c_vec::t without keeping a reference to the * By using a pointer taken from a c_vec::t without keeping a reference to the
* c_vec::t itself around, the c_vec could be garbage collected, and the * c_vec::t itself around, the CVec could be garbage collected, and the
* memory within could be destroyed. There are legitimate uses for the * memory within could be destroyed. There are legitimate uses for the
* pointer elimination form -- for instance, to pass memory back into C -- but * pointer elimination form -- for instance, to pass memory back into C -- but
* great care must be taken to ensure that a reference to the c_vec::t is * great care must be taken to ensure that a reference to the c_vec::t is
* still held if needed. * still held if needed.
*/ */
export c_vec; export CVec;
export c_vec, c_vec_with_dtor; export c_vec, c_vec_with_dtor;
export get, set; export get, set;
export len; export len;
@ -38,11 +39,11 @@ export ptr;
* Wrapped in a enum for opacity; FIXME #818 when it is possible to have * Wrapped in a enum for opacity; FIXME #818 when it is possible to have
* truly opaque types, this should be revisited. * truly opaque types, this should be revisited.
*/ */
enum c_vec<T> { enum CVec<T> {
c_vec_({ base: *mut T, len: uint, rsrc: @dtor_res}) CVecCtor({ base: *mut T, len: uint, rsrc: @DtorRes})
} }
struct dtor_res { struct DtorRes {
let dtor: Option<fn@()>; let dtor: Option<fn@()>;
new(dtor: Option<fn@()>) { self.dtor = dtor; } new(dtor: Option<fn@()>) { self.dtor = dtor; }
drop { drop {
@ -58,23 +59,23 @@ struct dtor_res {
*/ */
/** /**
* Create a `c_vec` from a foreign buffer with a given length. * Create a `CVec` from a foreign buffer with a given length.
* *
* # Arguments * # Arguments
* *
* * base - A foreign pointer to a buffer * * base - A foreign pointer to a buffer
* * len - The number of elements in the buffer * * len - The number of elements in the buffer
*/ */
unsafe fn c_vec<T>(base: *mut T, len: uint) -> c_vec<T> { unsafe fn c_vec<T>(base: *mut T, len: uint) -> CVec<T> {
return c_vec_({ return CVecCtor({
base: base, base: base,
len: len, len: len,
rsrc: @dtor_res(option::None) rsrc: @DtorRes(option::None)
}); });
} }
/** /**
* Create a `c_vec` from a foreign buffer, with a given length, * Create a `CVec` from a foreign buffer, with a given length,
* and a function to run upon destruction. * and a function to run upon destruction.
* *
* # Arguments * # Arguments
@ -85,11 +86,11 @@ unsafe fn c_vec<T>(base: *mut T, len: uint) -> c_vec<T> {
* for freeing the buffer, etc. * for freeing the buffer, etc.
*/ */
unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: fn@()) unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: fn@())
-> c_vec<T> { -> CVec<T> {
return c_vec_({ return CVecCtor({
base: base, base: base,
len: len, len: len,
rsrc: @dtor_res(option::Some(dtor)) rsrc: @DtorRes(option::Some(dtor))
}); });
} }
@ -102,7 +103,7 @@ unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: fn@())
* *
* Fails if `ofs` is greater or equal to the length of the vector * Fails if `ofs` is greater or equal to the length of the vector
*/ */
fn get<T: copy>(t: c_vec<T>, ofs: uint) -> T { fn get<T: copy>(t: CVec<T>, ofs: uint) -> T {
assert ofs < len(t); assert ofs < len(t);
return unsafe { *ptr::mut_offset((*t).base, ofs) }; return unsafe { *ptr::mut_offset((*t).base, ofs) };
} }
@ -112,7 +113,7 @@ fn get<T: copy>(t: c_vec<T>, ofs: uint) -> T {
* *
* Fails if `ofs` is greater or equal to the length of the vector * Fails if `ofs` is greater or equal to the length of the vector
*/ */
fn set<T: copy>(t: c_vec<T>, ofs: uint, v: T) { fn set<T: copy>(t: CVec<T>, ofs: uint, v: T) {
assert ofs < len(t); assert ofs < len(t);
unsafe { *ptr::mut_offset((*t).base, ofs) = v }; unsafe { *ptr::mut_offset((*t).base, ofs) = v };
} }
@ -122,12 +123,12 @@ fn set<T: copy>(t: c_vec<T>, ofs: uint, v: T) {
*/ */
/// Returns the length of the vector /// Returns the length of the vector
fn len<T>(t: c_vec<T>) -> uint { fn len<T>(t: CVec<T>) -> uint {
return (*t).len; return (*t).len;
} }
/// Returns a pointer to the first element of the vector /// Returns a pointer to the first element of the vector
unsafe fn ptr<T>(t: c_vec<T>) -> *mut T { unsafe fn ptr<T>(t: CVec<T>) -> *mut T {
return (*t).base; return (*t).base;
} }
@ -135,7 +136,7 @@ unsafe fn ptr<T>(t: c_vec<T>) -> *mut T {
mod tests { mod tests {
import libc::*; import libc::*;
fn malloc(n: size_t) -> c_vec<u8> { fn malloc(n: size_t) -> CVec<u8> {
let mem = libc::malloc(n); let mem = libc::malloc(n);
assert mem as int != 0; assert mem as int != 0;

9
src/libstd/cmp.rs
View File

@ -1,24 +1,25 @@
#[deny(non_camel_case_types)];
/// Additional general-purpose comparison functionality. /// Additional general-purpose comparison functionality.
const fuzzy_epsilon: float = 1.0e-6; const fuzzy_epsilon: float = 1.0e-6;
trait fuzzy_eq { trait FuzzyEq {
pure fn fuzzy_eq(&&other: self) -> bool; pure fn fuzzy_eq(&&other: self) -> bool;
} }
impl float: fuzzy_eq { impl float: FuzzyEq {
pure fn fuzzy_eq(&&other: float) -> bool { pure fn fuzzy_eq(&&other: float) -> bool {
return float::abs(self - other) < fuzzy_epsilon; return float::abs(self - other) < fuzzy_epsilon;
} }
} }
impl f32: fuzzy_eq { impl f32: FuzzyEq {
pure fn fuzzy_eq(&&other: f32) -> bool { pure fn fuzzy_eq(&&other: f32) -> bool {
return f32::abs(self - other) < (fuzzy_epsilon as f32); return f32::abs(self - other) < (fuzzy_epsilon as f32);
} }
} }
impl f64: fuzzy_eq { impl f64: FuzzyEq {
pure fn fuzzy_eq(&&other: f64) -> bool { pure fn fuzzy_eq(&&other: f64) -> bool {
return f64::abs(self - other) < (fuzzy_epsilon as f64); return f64::abs(self - other) < (fuzzy_epsilon as f64);
} }

1
src/libstd/dbg.rs
View File

@ -1,3 +1,4 @@
#[deny(non_camel_case_types)];
//! Unsafe debugging functions for inspecting values. //! Unsafe debugging functions for inspecting values.
import unsafe::reinterpret_cast; import unsafe::reinterpret_cast;

104
src/libstd/deque.rs
View File

@ -1,9 +1,11 @@
#[deny(non_camel_case_types)];
//! A deque. Untested as of yet. Likely buggy //! A deque. Untested as of yet. Likely buggy
import option::{Some, None}; import option::{Some, None};
import dvec::DVec; import dvec::DVec;
trait t<T> { trait Deque<T> {
fn size() -> uint; fn size() -> uint;
fn add_front(T); fn add_front(T);
fn add_back(T); fn add_back(T);
@ -16,16 +18,16 @@ trait t<T> {
// FIXME (#2343) eventually, a proper datatype plus an exported impl would // FIXME (#2343) eventually, a proper datatype plus an exported impl would
// be preferrable. // be preferrable.
fn create<T: copy>() -> t<T> { fn create<T: copy>() -> Deque<T> {
type cell<T> = Option<T>; type Cell<T> = Option<T>;
let initial_capacity: uint = 32u; // 2^5 let initial_capacity: uint = 32u; // 2^5
/** /**
* Grow is only called on full elts, so nelts is also len(elts), unlike * Grow is only called on full elts, so nelts is also len(elts), unlike
* elsewhere. * elsewhere.
*/ */
fn grow<T: copy>(nelts: uint, lo: uint, -elts: ~[mut cell<T>]) -> fn grow<T: copy>(nelts: uint, lo: uint, -elts: ~[mut Cell<T>]) ->
~[mut cell<T>] { ~[mut Cell<T>] {
assert (nelts == vec::len(elts)); assert (nelts == vec::len(elts));
let mut rv = ~[mut]; let mut rv = ~[mut];
@ -40,16 +42,16 @@ fn create<T: copy>() -> t<T> {
return rv; return rv;
} }
fn get<T: copy>(elts: DVec<cell<T>>, i: uint) -> T { fn get<T: copy>(elts: DVec<Cell<T>>, i: uint) -> T {
match elts.get_elt(i) { Some(t) => t, _ => fail } match elts.get_elt(i) { Some(t) => t, _ => fail }
} }
type repr<T> = {mut nelts: uint, type Repr<T> = {mut nelts: uint,
mut lo: uint, mut lo: uint,
mut hi: uint, mut hi: uint,
elts: DVec<cell<T>>}; elts: DVec<Cell<T>>};
impl <T: copy> repr<T>: t<T> { impl <T: copy> Repr<T>: Deque<T> {
fn size() -> uint { return self.nelts; } fn size() -> uint { return self.nelts; }
fn add_front(t: T) { fn add_front(t: T) {
let oldlo: uint = self.lo; let oldlo: uint = self.lo;
@ -102,7 +104,7 @@ fn create<T: copy>() -> t<T> {
} }
} }
let repr: repr<T> = { let repr: Repr<T> = {
mut nelts: 0u, mut nelts: 0u,
mut lo: 0u, mut lo: 0u,
mut hi: 0u, mut hi: 0u,
@ -111,14 +113,14 @@ fn create<T: copy>() -> t<T> {
vec::to_mut( vec::to_mut(
vec::from_elem(initial_capacity, None))) vec::from_elem(initial_capacity, None)))
}; };
repr as t::<T> repr as Deque::<T>
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let d: deque::t<int> = deque::create::<int>(); let d: deque::Deque<int> = deque::create::<int>();
assert (d.size() == 0u); assert (d.size() == 0u);
d.add_front(17); d.add_front(17);
d.add_front(42); d.add_front(42);
@ -162,7 +164,7 @@ mod tests {
} }
fn test_boxes(a: @int, b: @int, c: @int, d: @int) { fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
let deq: deque::t<@int> = deque::create::<@int>(); let deq: deque::Deque<@int> = deque::create::<@int>();
assert (deq.size() == 0u); assert (deq.size() == 0u);
deq.add_front(a); deq.add_front(a);
deq.add_front(b); deq.add_front(b);
@ -191,12 +193,12 @@ mod tests {
assert (deq.get(3) == d); assert (deq.get(3) == d);
} }
type eqfn<T> = fn@(T, T) -> bool; type EqFn<T> = fn@(T, T) -> bool;
fn test_parameterized<T: copy owned>( fn test_parameterized<T: copy owned>(
e: eqfn<T>, a: T, b: T, c: T, d: T) { e: EqFn<T>, a: T, b: T, c: T, d: T) {
let deq: deque::t<T> = deque::create::<T>(); let deq: deque::Deque<T> = deque::create::<T>();
assert (deq.size() == 0u); assert (deq.size() == 0u);
deq.add_front(a); deq.add_front(a);
deq.add_front(b); deq.add_front(b);
@ -225,85 +227,85 @@ mod tests {
assert (e(deq.get(3), d)); assert (e(deq.get(3), d));
} }
enum taggy { one(int), two(int, int), three(int, int, int), } enum Taggy { One(int), Two(int, int), Three(int, int, int), }
enum taggypar<T> { enum Taggypar<T> {
onepar(int), twopar(int, int), threepar(int, int, int), Onepar(int), Twopar(int, int), Threepar(int, int, int),
} }
type reccy = {x: int, y: int, t: taggy}; type RecCy = {x: int, y: int, t: Taggy};
#[test] #[test]
fn test() { fn test() {
fn inteq(&&a: int, &&b: int) -> bool { return a == b; } fn inteq(&&a: int, &&b: int) -> bool { return a == b; }
fn intboxeq(&&a: @int, &&b: @int) -> bool { return a == b; } fn intboxeq(&&a: @int, &&b: @int) -> bool { return a == b; }
fn taggyeq(a: taggy, b: taggy) -> bool { fn taggyeq(a: Taggy, b: Taggy) -> bool {
match a { match a {
one(a1) => match b { One(a1) => match b {
one(b1) => return a1 == b1, One(b1) => return a1 == b1,
_ => return false _ => return false
}, },
two(a1, a2) => match b { Two(a1, a2) => match b {
two(b1, b2) => return a1 == b1 && a2 == b2, Two(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false _ => return false
}, },
three(a1, a2, a3) => match b { Three(a1, a2, a3) => match b {
three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3, Three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3,
_ => return false _ => return false
} }
} }
} }
fn taggypareq<T>(a: taggypar<T>, b: taggypar<T>) -> bool { fn taggypareq<T>(a: Taggypar<T>, b: Taggypar<T>) -> bool {
match a { match a {
onepar::<T>(a1) => match b { Onepar::<T>(a1) => match b {
onepar::<T>(b1) => return a1 == b1, Onepar::<T>(b1) => return a1 == b1,
_ => return false _ => return false
}, },
twopar::<T>(a1, a2) => match b { Twopar::<T>(a1, a2) => match b {
twopar::<T>(b1, b2) => return a1 == b1 && a2 == b2, Twopar::<T>(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false _ => return false
}, },
threepar::<T>(a1, a2, a3) => match b { Threepar::<T>(a1, a2, a3) => match b {
threepar::<T>(b1, b2, b3) => { Threepar::<T>(b1, b2, b3) => {
return a1 == b1 && a2 == b2 && a3 == b3 return a1 == b1 && a2 == b2 && a3 == b3
} }
_ => return false _ => return false
} }
} }
} }
fn reccyeq(a: reccy, b: reccy) -> bool { fn reccyeq(a: RecCy, b: RecCy) -> bool {
return a.x == b.x && a.y == b.y && taggyeq(a.t, b.t); return a.x == b.x && a.y == b.y && taggyeq(a.t, b.t);
} }
debug!("*** test boxes"); debug!("*** test boxes");
test_boxes(@5, @72, @64, @175); test_boxes(@5, @72, @64, @175);
debug!("*** end test boxes"); debug!("*** end test boxes");
debug!("test parameterized: int"); debug!("test parameterized: int");
let eq1: eqfn<int> = inteq; let eq1: EqFn<int> = inteq;
test_parameterized::<int>(eq1, 5, 72, 64, 175); test_parameterized::<int>(eq1, 5, 72, 64, 175);
debug!("*** test parameterized: @int"); debug!("*** test parameterized: @int");
let eq2: eqfn<@int> = intboxeq; let eq2: EqFn<@int> = intboxeq;
test_parameterized::<@int>(eq2, @5, @72, @64, @175); test_parameterized::<@int>(eq2, @5, @72, @64, @175);
debug!("*** end test parameterized @int"); debug!("*** end test parameterized @int");
debug!("test parameterized: taggy"); debug!("test parameterized: taggy");
let eq3: eqfn<taggy> = taggyeq; let eq3: EqFn<Taggy> = taggyeq;
test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3), test_parameterized::<Taggy>(eq3, One(1), Two(1, 2), Three(1, 2, 3),
two(17, 42)); Two(17, 42));
debug!("*** test parameterized: taggypar<int>"); debug!("*** test parameterized: taggypar<int>");
let eq4: eqfn<taggypar<int>> = |x,y| taggypareq::<int>(x, y); let eq4: EqFn<Taggypar<int>> = |x,y| taggypareq::<int>(x, y);
test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1), test_parameterized::<Taggypar<int>>(eq4, Onepar::<int>(1),
twopar::<int>(1, 2), Twopar::<int>(1, 2),
threepar::<int>(1, 2, 3), Threepar::<int>(1, 2, 3),
twopar::<int>(17, 42)); Twopar::<int>(17, 42));
debug!("*** end test parameterized: taggypar::<int>"); debug!("*** end test parameterized: taggypar::<int>");
debug!("*** test parameterized: reccy"); debug!("*** test parameterized: reccy");
let reccy1: reccy = {x: 1, y: 2, t: one(1)}; let reccy1: RecCy = {x: 1, y: 2, t: One(1)};
let reccy2: reccy = {x: 345, y: 2, t: two(1, 2)}; let reccy2: RecCy = {x: 345, y: 2, t: Two(1, 2)};
let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)}; let reccy3: RecCy = {x: 1, y: 777, t: Three(1, 2, 3)};
let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)}; let reccy4: RecCy = {x: 19, y: 252, t: Two(17, 42)};
let eq5: eqfn<reccy> = reccyeq; let eq5: EqFn<RecCy> = reccyeq;
test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4); test_parameterized::<RecCy>(eq5, reccy1, reccy2, reccy3, reccy4);
debug!("*** end test parameterized: reccy"); debug!("*** end test parameterized: reccy");
debug!("*** done"); debug!("*** done");
} }

194
src/libstd/ebml.rs
View File

@ -1,4 +1,4 @@
#[deny(non_camel_case_types)];
// Simple Extensible Binary Markup Language (ebml) reader and writer on a // Simple Extensible Binary Markup Language (ebml) reader and writer on a
// cursor model. See the specification here: // cursor model. See the specification here:
@ -7,6 +7,7 @@ import core::Option;
import option::{Some, None}; import option::{Some, None};
export doc; export doc;
export Doc;
export doc_at; export doc_at;
export maybe_get_doc; export maybe_get_doc;
export get_doc; export get_doc;
@ -22,28 +23,29 @@ export doc_as_i8;
export doc_as_i16; export doc_as_i16;
export doc_as_i32; export doc_as_i32;
export doc_as_i64; export doc_as_i64;
export writer; export Writer;
export serializer; export serializer;
export ebml_deserializer; export ebml_deserializer;
export EbmlDeserializer;
export deserializer; export deserializer;
export with_doc_data; export with_doc_data;
export get_doc; export get_doc;
export extensions; export extensions;
type ebml_tag = {id: uint, size: uint}; type EbmlTag = {id: uint, size: uint};
type ebml_state = {ebml_tag: ebml_tag, tag_pos: uint, data_pos: uint}; type EbmlState = {ebml_tag: EbmlTag, tag_pos: uint, data_pos: uint};
// FIXME (#2739): When we have module renaming, make "reader" and "writer" // FIXME (#2739): When we have module renaming, make "reader" and "writer"
// separate modules within this file. // separate modules within this file.
// ebml reading // ebml reading
type doc = {data: @~[u8], start: uint, end: uint}; type Doc = {data: @~[u8], start: uint, end: uint};
type tagged_doc = {tag: uint, doc: doc}; type TaggedDoc = {tag: uint, doc: Doc};
impl doc: ops::index<uint,doc> { impl Doc: ops::index<uint,Doc> {
pure fn index(&&tag: uint) -> doc { pure fn index(&&tag: uint) -> Doc {
unchecked { unchecked {
get_doc(self, tag) get_doc(self, tag)
} }
@ -73,11 +75,11 @@ fn vuint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
} else { error!("vint too big"); fail; } } else { error!("vint too big"); fail; }
} }
fn doc(data: @~[u8]) -> doc { fn doc(data: @~[u8]) -> Doc {
return {data: data, start: 0u, end: vec::len::<u8>(*data)}; return {data: data, start: 0u, end: vec::len::<u8>(*data)};
} }
fn doc_at(data: @~[u8], start: uint) -> tagged_doc { fn doc_at(data: @~[u8], start: uint) -> TaggedDoc {
let elt_tag = vuint_at(*data, start); let elt_tag = vuint_at(*data, start);
let elt_size = vuint_at(*data, elt_tag.next); let elt_size = vuint_at(*data, elt_tag.next);
let end = elt_size.next + elt_size.val; let end = elt_size.next + elt_size.val;
@ -85,24 +87,24 @@ fn doc_at(data: @~[u8], start: uint) -> tagged_doc {
doc: {data: data, start: elt_size.next, end: end}}; doc: {data: data, start: elt_size.next, end: end}};
} }
fn maybe_get_doc(d: doc, tg: uint) -> Option<doc> { fn maybe_get_doc(d: Doc, tg: uint) -> Option<Doc> {
let mut pos = d.start; let mut pos = d.start;
while pos < d.end { while pos < d.end {
let elt_tag = vuint_at(*d.data, pos); let elt_tag = vuint_at(*d.data, pos);
let elt_size = vuint_at(*d.data, elt_tag.next); let elt_size = vuint_at(*d.data, elt_tag.next);
pos = elt_size.next + elt_size.val; pos = elt_size.next + elt_size.val;
if elt_tag.val == tg { if elt_tag.val == tg {
return Some::<doc>({ return Some::<Doc>({
data: d.data, data: d.data,
start: elt_size.next, start: elt_size.next,
end: pos end: pos
}); });
} }
} }
return None::<doc>; return None::<Doc>;
} }
fn get_doc(d: doc, tg: uint) -> doc { fn get_doc(d: Doc, tg: uint) -> Doc {
match maybe_get_doc(d, tg) { match maybe_get_doc(d, tg) {
Some(d) => return d, Some(d) => return d,
None => { None => {
@ -112,7 +114,7 @@ fn get_doc(d: doc, tg: uint) -> doc {
} }
} }
fn docs(d: doc, it: fn(uint, doc) -> bool) { fn docs(d: Doc, it: fn(uint, Doc) -> bool) {
let mut pos = d.start; let mut pos = d.start;
while pos < d.end { while pos < d.end {
let elt_tag = vuint_at(*d.data, pos); let elt_tag = vuint_at(*d.data, pos);
@ -124,7 +126,7 @@ fn docs(d: doc, it: fn(uint, doc) -> bool) {
} }
} }
fn tagged_docs(d: doc, tg: uint, it: fn(doc) -> bool) { fn tagged_docs(d: Doc, tg: uint, it: fn(Doc) -> bool) {
let mut pos = d.start; let mut pos = d.start;
while pos < d.end { while pos < d.end {
let elt_tag = vuint_at(*d.data, pos); let elt_tag = vuint_at(*d.data, pos);
@ -138,44 +140,44 @@ fn tagged_docs(d: doc, tg: uint, it: fn(doc) -> bool) {
} }
} }
fn doc_data(d: doc) -> ~[u8] { vec::slice::<u8>(*d.data, d.start, d.end) } fn doc_data(d: Doc) -> ~[u8] { vec::slice::<u8>(*d.data, d.start, d.end) }
fn with_doc_data<T>(d: doc, f: fn(x: &[u8]) -> T) -> T { fn with_doc_data<T>(d: Doc, f: fn(x: &[u8]) -> T) -> T {
return f(vec::view(*d.data, d.start, d.end)); return f(vec::view(*d.data, d.start, d.end));
} }
fn doc_as_str(d: doc) -> ~str { return str::from_bytes(doc_data(d)); } fn doc_as_str(d: Doc) -> ~str { return str::from_bytes(doc_data(d)); }
fn doc_as_u8(d: doc) -> u8 { fn doc_as_u8(d: Doc) -> u8 {
assert d.end == d.start + 1u; assert d.end == d.start + 1u;
return (*d.data)[d.start]; return (*d.data)[d.start];
} }
fn doc_as_u16(d: doc) -> u16 { fn doc_as_u16(d: Doc) -> u16 {
assert d.end == d.start + 2u; assert d.end == d.start + 2u;
return io::u64_from_be_bytes(*d.data, d.start, 2u) as u16; return io::u64_from_be_bytes(*d.data, d.start, 2u) as u16;
} }
fn doc_as_u32(d: doc) -> u32 { fn doc_as_u32(d: Doc) -> u32 {
assert d.end == d.start + 4u; assert d.end == d.start + 4u;
return io::u64_from_be_bytes(*d.data, d.start, 4u) as u32; return io::u64_from_be_bytes(*d.data, d.start, 4u) as u32;
} }
fn doc_as_u64(d: doc) -> u64 { fn doc_as_u64(d: Doc) -> u64 {
assert d.end == d.start + 8u; assert d.end == d.start + 8u;
return io::u64_from_be_bytes(*d.data, d.start, 8u); return io::u64_from_be_bytes(*d.data, d.start, 8u);
} }
fn doc_as_i8(d: doc) -> i8 { doc_as_u8(d) as i8 } fn doc_as_i8(d: Doc) -> i8 { doc_as_u8(d) as i8 }
fn doc_as_i16(d: doc) -> i16 { doc_as_u16(d) as i16 } fn doc_as_i16(d: Doc) -> i16 { doc_as_u16(d) as i16 }
fn doc_as_i32(d: doc) -> i32 { doc_as_u32(d) as i32 } fn doc_as_i32(d: Doc) -> i32 { doc_as_u32(d) as i32 }
fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 } fn doc_as_i64(d: Doc) -> i64 { doc_as_u64(d) as i64 }
// ebml writing // ebml writing
type writer_ = {writer: io::Writer, mut size_positions: ~[uint]}; type Writer_ = {writer: io::Writer, mut size_positions: ~[uint]};
enum writer { enum Writer {
writer_(writer_) Writer_(Writer_)
} }
fn write_sized_vuint(w: io::Writer, n: uint, size: uint) { fn write_sized_vuint(w: io::Writer, n: uint, size: uint) {
@ -198,13 +200,13 @@ fn write_vuint(w: io::Writer, n: uint) {
fail fmt!("vint to write too big: %?", n); fail fmt!("vint to write too big: %?", n);
} }
fn writer(w: io::Writer) -> writer { fn Writer(w: io::Writer) -> Writer {
let size_positions: ~[uint] = ~[]; let size_positions: ~[uint] = ~[];
return writer_({writer: w, mut size_positions: size_positions}); return Writer_({writer: w, mut size_positions: size_positions});
} }
// FIXME (#2741): Provide a function to write the standard ebml header. // FIXME (#2741): Provide a function to write the standard ebml header.
impl writer { impl Writer {
fn start_tag(tag_id: uint) { fn start_tag(tag_id: uint) {
debug!("Start tag %u", tag_id); debug!("Start tag %u", tag_id);
@ -306,26 +308,26 @@ impl writer {
// Totally lame approach. // Totally lame approach.
const debug: bool = false; const debug: bool = false;
enum ebml_serializer_tag { enum EbmlSerializerTag {
es_uint, es_u64, es_u32, es_u16, es_u8, EsUint, EsU64, EsU32, EsU16, EsU8,
es_int, es_i64, es_i32, es_i16, es_i8, EsInt, EsI64, EsI32, EsI16, EsI8,
es_bool, EsBool,
es_str, EsStr,
es_f64, es_f32, es_float, EsF64, EsF32, EsFloat,
es_enum, es_enum_vid, es_enum_body, EsEnum, EsEnumVid, EsEnumBody,
es_vec, es_vec_len, es_vec_elt, EsVec, EsVecLen, EsVecElt,
es_label // Used only when debugging EsLabel // Used only when debugging
} }
trait serializer_priv { trait SerializerPriv {
fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint); fn _emit_tagged_uint(t: EbmlSerializerTag, v: uint);
fn _emit_label(label: &str); fn _emit_label(label: &str);
} }
impl ebml::writer: serializer_priv { impl ebml::Writer: SerializerPriv {
// used internally to emit things like the vector length and so on // used internally to emit things like the vector length and so on
fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint) { fn _emit_tagged_uint(t: EbmlSerializerTag, v: uint) {
assert v <= 0xFFFF_FFFF_u; assert v <= 0xFFFF_FFFF_u;
self.wr_tagged_u32(t as uint, v as u32); self.wr_tagged_u32(t as uint, v as u32);
} }
@ -337,53 +339,53 @@ impl ebml::writer: serializer_priv {
// efficiency. When debugging, though, we can emit such // efficiency. When debugging, though, we can emit such
// labels and then they will be checked by deserializer to // labels and then they will be checked by deserializer to
// try and check failures more quickly. // try and check failures more quickly.
if debug { self.wr_tagged_str(es_label as uint, label) } if debug { self.wr_tagged_str(EsLabel as uint, label) }
} }
} }
impl ebml::writer: serialization::serializer { impl ebml::Writer: serialization::serializer {
fn emit_nil() {} fn emit_nil() {}
fn emit_uint(v: uint) { self.wr_tagged_u64(es_uint as uint, v as u64); } fn emit_uint(v: uint) { self.wr_tagged_u64(EsUint as uint, v as u64); }
fn emit_u64(v: u64) { self.wr_tagged_u64(es_u64 as uint, v); } fn emit_u64(v: u64) { self.wr_tagged_u64(EsU64 as uint, v); }
fn emit_u32(v: u32) { self.wr_tagged_u32(es_u32 as uint, v); } fn emit_u32(v: u32) { self.wr_tagged_u32(EsU32 as uint, v); }
fn emit_u16(v: u16) { self.wr_tagged_u16(es_u16 as uint, v); } fn emit_u16(v: u16) { self.wr_tagged_u16(EsU16 as uint, v); }
fn emit_u8(v: u8) { self.wr_tagged_u8 (es_u8 as uint, v); } fn emit_u8(v: u8) { self.wr_tagged_u8 (EsU8 as uint, v); }
fn emit_int(v: int) { self.wr_tagged_i64(es_int as uint, v as i64); } fn emit_int(v: int) { self.wr_tagged_i64(EsInt as uint, v as i64); }
fn emit_i64(v: i64) { self.wr_tagged_i64(es_i64 as uint, v); } fn emit_i64(v: i64) { self.wr_tagged_i64(EsI64 as uint, v); }
fn emit_i32(v: i32) { self.wr_tagged_i32(es_i32 as uint, v); } fn emit_i32(v: i32) { self.wr_tagged_i32(EsI32 as uint, v); }
fn emit_i16(v: i16) { self.wr_tagged_i16(es_i16 as uint, v); } fn emit_i16(v: i16) { self.wr_tagged_i16(EsI16 as uint, v); }
fn emit_i8(v: i8) { self.wr_tagged_i8 (es_i8 as uint, v); } fn emit_i8(v: i8) { self.wr_tagged_i8 (EsI8 as uint, v); }
fn emit_bool(v: bool) { self.wr_tagged_u8(es_bool as uint, v as u8) } fn emit_bool(v: bool) { self.wr_tagged_u8(EsBool as uint, v as u8) }
// FIXME (#2742): implement these // FIXME (#2742): implement these
fn emit_f64(_v: f64) { fail ~"Unimplemented: serializing an f64"; } fn emit_f64(_v: f64) { fail ~"Unimplemented: serializing an f64"; }
fn emit_f32(_v: f32) { fail ~"Unimplemented: serializing an f32"; } fn emit_f32(_v: f32) { fail ~"Unimplemented: serializing an f32"; }
fn emit_float(_v: float) { fail ~"Unimplemented: serializing a float"; } fn emit_float(_v: float) { fail ~"Unimplemented: serializing a float"; }
fn emit_str(v: &str) { self.wr_tagged_str(es_str as uint, v) } fn emit_str(v: &str) { self.wr_tagged_str(EsStr as uint, v) }
fn emit_enum(name: &str, f: fn()) { fn emit_enum(name: &str, f: fn()) {
self._emit_label(name); self._emit_label(name);
self.wr_tag(es_enum as uint, f) self.wr_tag(EsEnum as uint, f)
} }
fn emit_enum_variant(_v_name: &str, v_id: uint, _cnt: uint, f: fn()) { fn emit_enum_variant(_v_name: &str, v_id: uint, _cnt: uint, f: fn()) {
self._emit_tagged_uint(es_enum_vid, v_id); self._emit_tagged_uint(EsEnumVid, v_id);
self.wr_tag(es_enum_body as uint, f) self.wr_tag(EsEnumBody as uint, f)
} }
fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() } fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() }
fn emit_vec(len: uint, f: fn()) { fn emit_vec(len: uint, f: fn()) {
do self.wr_tag(es_vec as uint) { do self.wr_tag(EsVec as uint) {
self._emit_tagged_uint(es_vec_len, len); self._emit_tagged_uint(EsVecLen, len);
f() f()
} }
} }
fn emit_vec_elt(_idx: uint, f: fn()) { fn emit_vec_elt(_idx: uint, f: fn()) {
self.wr_tag(es_vec_elt as uint, f) self.wr_tag(EsVecElt as uint, f)
} }
fn emit_box(f: fn()) { f() } fn emit_box(f: fn()) { f() }
@ -397,23 +399,23 @@ impl ebml::writer: serialization::serializer {
fn emit_tup_elt(_idx: uint, f: fn()) { f() } fn emit_tup_elt(_idx: uint, f: fn()) { f() }
} }
type ebml_deserializer_ = {mut parent: ebml::doc, type EbmlDeserializer_ = {mut parent: ebml::Doc,
mut pos: uint}; mut pos: uint};
enum ebml_deserializer { enum EbmlDeserializer {
ebml_deserializer_(ebml_deserializer_) EbmlDeserializer_(EbmlDeserializer_)
} }
fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer { fn ebml_deserializer(d: ebml::Doc) -> EbmlDeserializer {
ebml_deserializer_({mut parent: d, mut pos: d.start}) EbmlDeserializer_({mut parent: d, mut pos: d.start})
} }
priv impl ebml_deserializer { priv impl EbmlDeserializer {
fn _check_label(lbl: ~str) { fn _check_label(lbl: ~str) {
if self.pos < self.parent.end { if self.pos < self.parent.end {
let {tag: r_tag, doc: r_doc} = let {tag: r_tag, doc: r_doc} =
ebml::doc_at(self.parent.data, self.pos); ebml::doc_at(self.parent.data, self.pos);
if r_tag == (es_label as uint) { if r_tag == (EsLabel as uint) {
self.pos = r_doc.end; self.pos = r_doc.end;
let str = ebml::doc_as_str(r_doc); let str = ebml::doc_as_str(r_doc);
if lbl != str { if lbl != str {
@ -423,7 +425,7 @@ priv impl ebml_deserializer {
} }
} }
fn next_doc(exp_tag: ebml_serializer_tag) -> ebml::doc { fn next_doc(exp_tag: EbmlSerializerTag) -> ebml::Doc {
debug!(". next_doc(exp_tag=%?)", exp_tag); debug!(". next_doc(exp_tag=%?)", exp_tag);
if self.pos >= self.parent.end { if self.pos >= self.parent.end {
fail ~"no more documents in current node!"; fail ~"no more documents in current node!";
@ -445,7 +447,7 @@ priv impl ebml_deserializer {
return r_doc; return r_doc;
} }
fn push_doc<T>(d: ebml::doc, f: fn() -> T) -> T{ fn push_doc<T>(d: ebml::Doc, f: fn() -> T) -> T{
let old_parent = self.parent; let old_parent = self.parent;
let old_pos = self.pos; let old_pos = self.pos;
self.parent = d; self.parent = d;
@ -456,60 +458,60 @@ priv impl ebml_deserializer {
return r; return r;
} }
fn _next_uint(exp_tag: ebml_serializer_tag) -> uint { fn _next_uint(exp_tag: EbmlSerializerTag) -> uint {
let r = ebml::doc_as_u32(self.next_doc(exp_tag)); let r = ebml::doc_as_u32(self.next_doc(exp_tag));
debug!("_next_uint exp_tag=%? result=%?", exp_tag, r); debug!("_next_uint exp_tag=%? result=%?", exp_tag, r);
return r as uint; return r as uint;
} }
} }
impl ebml_deserializer: serialization::deserializer { impl EbmlDeserializer: serialization::deserializer {
fn read_nil() -> () { () } fn read_nil() -> () { () }
fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(es_u64)) } fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(EsU64)) }
fn read_u32() -> u32 { ebml::doc_as_u32(self.next_doc(es_u32)) } fn read_u32() -> u32 { ebml::doc_as_u32(self.next_doc(EsU32)) }
fn read_u16() -> u16 { ebml::doc_as_u16(self.next_doc(es_u16)) } fn read_u16() -> u16 { ebml::doc_as_u16(self.next_doc(EsU16)) }
fn read_u8 () -> u8 { ebml::doc_as_u8 (self.next_doc(es_u8 )) } fn read_u8 () -> u8 { ebml::doc_as_u8 (self.next_doc(EsU8 )) }
fn read_uint() -> uint { fn read_uint() -> uint {
let v = ebml::doc_as_u64(self.next_doc(es_uint)); let v = ebml::doc_as_u64(self.next_doc(EsUint));
if v > (core::uint::max_value as u64) { if v > (core::uint::max_value as u64) {
fail fmt!("uint %? too large for this architecture", v); fail fmt!("uint %? too large for this architecture", v);
} }
return v as uint; return v as uint;
} }
fn read_i64() -> i64 { ebml::doc_as_u64(self.next_doc(es_i64)) as i64 } fn read_i64() -> i64 { ebml::doc_as_u64(self.next_doc(EsI64)) as i64 }
fn read_i32() -> i32 { ebml::doc_as_u32(self.next_doc(es_i32)) as i32 } fn read_i32() -> i32 { ebml::doc_as_u32(self.next_doc(EsI32)) as i32 }
fn read_i16() -> i16 { ebml::doc_as_u16(self.next_doc(es_i16)) as i16 } fn read_i16() -> i16 { ebml::doc_as_u16(self.next_doc(EsI16)) as i16 }
fn read_i8 () -> i8 { ebml::doc_as_u8 (self.next_doc(es_i8 )) as i8 } fn read_i8 () -> i8 { ebml::doc_as_u8 (self.next_doc(EsI8 )) as i8 }
fn read_int() -> int { fn read_int() -> int {
let v = ebml::doc_as_u64(self.next_doc(es_int)) as i64; let v = ebml::doc_as_u64(self.next_doc(EsInt)) as i64;
if v > (int::max_value as i64) || v < (int::min_value as i64) { if v > (int::max_value as i64) || v < (int::min_value as i64) {
fail fmt!("int %? out of range for this architecture", v); fail fmt!("int %? out of range for this architecture", v);
} }
return v as int; return v as int;
} }
fn read_bool() -> bool { ebml::doc_as_u8(self.next_doc(es_bool)) as bool } fn read_bool() -> bool { ebml::doc_as_u8(self.next_doc(EsBool)) as bool }
fn read_f64() -> f64 { fail ~"read_f64()"; } fn read_f64() -> f64 { fail ~"read_f64()"; }
fn read_f32() -> f32 { fail ~"read_f32()"; } fn read_f32() -> f32 { fail ~"read_f32()"; }
fn read_float() -> float { fail ~"read_float()"; } fn read_float() -> float { fail ~"read_float()"; }
fn read_str() -> ~str { ebml::doc_as_str(self.next_doc(es_str)) } fn read_str() -> ~str { ebml::doc_as_str(self.next_doc(EsStr)) }
// Compound types: // Compound types:
fn read_enum<T>(name: ~str, f: fn() -> T) -> T { fn read_enum<T>(name: ~str, f: fn() -> T) -> T {
debug!("read_enum(%s)", name); debug!("read_enum(%s)", name);
self._check_label(name); self._check_label(name);
self.push_doc(self.next_doc(es_enum), f) self.push_doc(self.next_doc(EsEnum), f)
} }
fn read_enum_variant<T>(f: fn(uint) -> T) -> T { fn read_enum_variant<T>(f: fn(uint) -> T) -> T {
debug!("read_enum_variant()"); debug!("read_enum_variant()");
let idx = self._next_uint(es_enum_vid); let idx = self._next_uint(EsEnumVid);
debug!(" idx=%u", idx); debug!(" idx=%u", idx);
do self.push_doc(self.next_doc(es_enum_body)) { do self.push_doc(self.next_doc(EsEnumBody)) {
f(idx) f(idx)
} }
} }
@ -521,8 +523,8 @@ impl ebml_deserializer: serialization::deserializer {
fn read_vec<T>(f: fn(uint) -> T) -> T { fn read_vec<T>(f: fn(uint) -> T) -> T {
debug!("read_vec()"); debug!("read_vec()");
do self.push_doc(self.next_doc(es_vec)) { do self.push_doc(self.next_doc(EsVec)) {
let len = self._next_uint(es_vec_len); let len = self._next_uint(EsVecLen);
debug!(" len=%u", len); debug!(" len=%u", len);
f(len) f(len)
} }
@ -530,7 +532,7 @@ impl ebml_deserializer: serialization::deserializer {
fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T { fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T {
debug!("read_vec_elt(idx=%u)", idx); debug!("read_vec_elt(idx=%u)", idx);
self.push_doc(self.next_doc(es_vec_elt), f) self.push_doc(self.next_doc(EsVecElt), f)
} }
fn read_box<T>(f: fn() -> T) -> T { fn read_box<T>(f: fn() -> T) -> T {
@ -615,7 +617,7 @@ fn test_option_int() {
fn test_v(v: Option<int>) { fn test_v(v: Option<int>) {
debug!("v == %?", v); debug!("v == %?", v);
let mbuf = io::mem_buffer(); let mbuf = io::mem_buffer();
let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf)); let ebml_w = ebml::Writer(io::mem_buffer_writer(mbuf));
serialize_0(ebml_w, v); serialize_0(ebml_w, v);
let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf)); let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
let deser = ebml_deserializer(ebml_doc); let deser = ebml_deserializer(ebml_doc);

38
src/libstd/fun_treemap.rs
View File

@ -1,3 +1,5 @@
#[deny(non_camel_case_types)];
/*! /*!
* A functional key,value store that works on anything. * A functional key,value store that works on anything.
* *
@ -12,41 +14,41 @@
import option::{Some, None}; import option::{Some, None};
import option = option; import option = option;
export treemap; export Treemap;
export init; export init;
export insert; export insert;
export find; export find;
export traverse; export traverse;
type treemap<K, V> = @tree_node<K, V>; type Treemap<K, V> = @TreeNode<K, V>;
enum tree_node<K, V> { enum TreeNode<K, V> {
empty, Empty,
node(@K, @V, @tree_node<K, V>, @tree_node<K, V>) Node(@K, @V, @TreeNode<K, V>, @TreeNode<K, V>)
} }
/// Create a treemap /// Create a treemap
fn init<K, V>() -> treemap<K, V> { @empty } fn init<K, V>() -> Treemap<K, V> { @Empty }
/// Insert a value into the map /// Insert a value into the map
fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> { fn insert<K: copy, V: copy>(m: Treemap<K, V>, k: K, v: V) -> Treemap<K, V> {
@match m { @match m {
@empty => node(@k, @v, @empty, @empty), @Empty => Node(@k, @v, @Empty, @Empty),
@node(@kk, vv, left, right) => { @Node(@kk, vv, left, right) => {
if k < kk { if k < kk {
node(@kk, vv, insert(left, k, v), right) Node(@kk, vv, insert(left, k, v), right)
} else if k == kk { } else if k == kk {
node(@kk, @v, left, right) Node(@kk, @v, left, right)
} else { node(@kk, vv, left, insert(right, k, v)) } } else { Node(@kk, vv, left, insert(right, k, v)) }
} }
} }
} }
/// Find a value based on the key /// Find a value based on the key
fn find<K, V: copy>(m: treemap<K, V>, k: K) -> Option<V> { fn find<K, V: copy>(m: Treemap<K, V>, k: K) -> Option<V> {
match *m { match *m {
empty => None, Empty => None,
node(@kk, @v, left, right) => { Node(@kk, @v, left, right) => {
if k == kk { if k == kk {
Some(v) Some(v)
} else if k < kk { find(left, k) } else { find(right, k) } } else if k < kk { find(left, k) } else { find(right, k) }
@ -55,15 +57,15 @@ fn find<K, V: copy>(m: treemap<K, V>, k: K) -> Option<V> {
} }
/// Visit all pairs in the map in order. /// Visit all pairs in the map in order.
fn traverse<K, V: copy>(m: treemap<K, V>, f: fn(K, V)) { fn traverse<K, V: copy>(m: Treemap<K, V>, f: fn(K, V)) {
match *m { match *m {
empty => (), Empty => (),
/* /*
Previously, this had what looked like redundant Previously, this had what looked like redundant
matches to me, so I changed it. but that may be a matches to me, so I changed it. but that may be a
de-optimization -- tjc de-optimization -- tjc
*/ */
node(@k, @v, left, right) => { Node(@k, @v, left, right) => {
// copy v to make aliases work out // copy v to make aliases work out
let v1 = v; let v1 = v;
traverse(left, f); traverse(left, f);

232
src/libstd/getopts.rs
View File

@ -1,3 +1,5 @@
#[deny(non_camel_case_types)];
/*! /*!
* Simple getopt alternative. * Simple getopt alternative.
* *
@ -68,15 +70,15 @@
import core::result::{Err, Ok}; import core::result::{Err, Ok};
import core::option; import core::option;
import core::option::{Some, None}; import core::option::{Some, None};
export opt; export Opt;
export reqopt; export reqopt;
export optopt; export optopt;
export optflag; export optflag;
export optflagopt; export optflagopt;
export optmulti; export optmulti;
export getopts; export getopts;
export matches; export Matches;
export fail_; export Fail_;
export fail_str; export fail_str;
export opt_present; export opt_present;
export opts_present; export opts_present;
@ -85,72 +87,72 @@ export opts_str;
export opt_strs; export opt_strs;
export opt_maybe_str; export opt_maybe_str;
export opt_default; export opt_default;
export result; //NDM export Result; //NDM
enum name { long(~str), short(char), } enum Name { Long(~str), Short(char), }
enum hasarg { yes, no, maybe, } enum HasArg { Yes, No, Maybe, }
enum occur { req, optional, multi, } enum Occur { Req, Optional, Multi, }
/// A description of a possible option /// A description of a possible option
type opt = {name: name, hasarg: hasarg, occur: occur}; type Opt = {name: Name, hasarg: HasArg, occur: Occur};
fn mkname(nm: &str) -> name { fn mkname(nm: &str) -> Name {
let unm = str::from_slice(nm); let unm = str::from_slice(nm);
return if str::len(nm) == 1u { return if str::len(nm) == 1u {
short(str::char_at(unm, 0u)) Short(str::char_at(unm, 0u))
} else { long(unm) }; } else { Long(unm) };
} }
/// Create an option that is required and takes an argument /// Create an option that is required and takes an argument
fn reqopt(name: &str) -> opt { fn reqopt(name: &str) -> Opt {
return {name: mkname(name), hasarg: yes, occur: req}; return {name: mkname(name), hasarg: Yes, occur: Req};
} }
/// Create an option that is optional and takes an argument /// Create an option that is optional and takes an argument
fn optopt(name: &str) -> opt { fn optopt(name: &str) -> Opt {
return {name: mkname(name), hasarg: yes, occur: optional}; return {name: mkname(name), hasarg: Yes, occur: Optional};
} }
/// Create an option that is optional and does not take an argument /// Create an option that is optional and does not take an argument
fn optflag(name: &str) -> opt { fn optflag(name: &str) -> Opt {
return {name: mkname(name), hasarg: no, occur: optional}; return {name: mkname(name), hasarg: No, occur: Optional};
} }
/// Create an option that is optional and takes an optional argument /// Create an option that is optional and takes an optional argument
fn optflagopt(name: &str) -> opt { fn optflagopt(name: &str) -> Opt {
return {name: mkname(name), hasarg: maybe, occur: optional}; return {name: mkname(name), hasarg: Maybe, occur: Optional};
} }
/** /**
* Create an option that is optional, takes an argument, and may occur * Create an option that is optional, takes an argument, and may occur
* multiple times * multiple times
*/ */
fn optmulti(name: &str) -> opt { fn optmulti(name: &str) -> Opt {
return {name: mkname(name), hasarg: yes, occur: multi}; return {name: mkname(name), hasarg: Yes, occur: Multi};
} }
enum optval { val(~str), given, } enum Optval { Val(~str), Given, }
/** /**
* The result of checking command line arguments. Contains a vector * The result of checking command line arguments. Contains a vector
* of matches and a vector of free strings. * of matches and a vector of free strings.
*/ */
type matches = {opts: ~[opt], vals: ~[~[optval]], free: ~[~str]}; type Matches = {opts: ~[Opt], vals: ~[~[Optval]], free: ~[~str]};
fn is_arg(arg: &str) -> bool { fn is_arg(arg: &str) -> bool {
return str::len(arg) > 1u && arg[0] == '-' as u8; return str::len(arg) > 1u && arg[0] == '-' as u8;
} }
fn name_str(nm: &name) -> ~str { fn name_str(nm: &Name) -> ~str {
return match *nm { return match *nm {
short(ch) => str::from_char(ch), Short(ch) => str::from_char(ch),
long(s) => s Long(s) => s
}; };
} }
fn find_opt(opts: &[opt], +nm: name) -> Option<uint> { fn find_opt(opts: &[Opt], +nm: Name) -> Option<uint> {
vec::position(opts, |opt| opt.name == nm) vec::position(opts, |opt| opt.name == nm)
} }
@ -158,22 +160,22 @@ fn find_opt(opts: &[opt], +nm: name) -> Option<uint> {
* The type returned when the command line does not conform to the * The type returned when the command line does not conform to the
* expected format. Pass this value to <fail_str> to get an error message. * expected format. Pass this value to <fail_str> to get an error message.
*/ */
enum fail_ { enum Fail_ {
argument_missing(~str), ArgumentMissing(~str),
unrecognized_option(~str), UnrecognizedOption(~str),
option_missing(~str), OptionMissing(~str),
option_duplicated(~str), OptionDuplicated(~str),
unexpected_argument(~str), UnexpectedArgument(~str),
} }
/// Convert a `fail_` enum into an error string /// Convert a `fail_` enum into an error string
fn fail_str(+f: fail_) -> ~str { fn fail_str(+f: Fail_) -> ~str {
return match f { return match f {
argument_missing(nm) => ~"Argument to option '" + nm + ~"' missing.", ArgumentMissing(nm) => ~"Argument to option '" + nm + ~"' missing.",
unrecognized_option(nm) => ~"Unrecognized option: '" + nm + ~"'.", UnrecognizedOption(nm) => ~"Unrecognized option: '" + nm + ~"'.",
option_missing(nm) => ~"Required option '" + nm + ~"' missing.", OptionMissing(nm) => ~"Required option '" + nm + ~"' missing.",
option_duplicated(nm) => ~"Option '" + nm + ~"' given more than once.", OptionDuplicated(nm) => ~"Option '" + nm + ~"' given more than once.",
unexpected_argument(nm) => { UnexpectedArgument(nm) => {
~"Option " + nm + ~" does not take an argument." ~"Option " + nm + ~" does not take an argument."
} }
}; };
@ -181,20 +183,20 @@ fn fail_str(+f: fail_) -> ~str {
/** /**
* The result of parsing a command line with a set of options * The result of parsing a command line with a set of options
* (result::t<matches, fail_>) * (result::t<Matches, Fail_>)
*/ */
type result = result::Result<matches, fail_>; type Result = result::Result<Matches, Fail_>;
/** /**
* Parse command line arguments according to the provided options * Parse command line arguments according to the provided options
* *
* On success returns `ok(opt)`. Use functions such as `opt_present` * On success returns `ok(Opt)`. Use functions such as `opt_present`
* `opt_str`, etc. to interrogate results. Returns `err(fail_)` on failure. * `opt_str`, etc. to interrogate results. Returns `err(Fail_)` on failure.
* Use <fail_str> to get an error message. * Use <fail_str> to get an error message.
*/ */
fn getopts(args: &[~str], opts: &[opt]) -> result unsafe { fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
let n_opts = vec::len::<opt>(opts); let n_opts = vec::len::<Opt>(opts);
fn f(_x: uint) -> ~[optval] { return ~[]; } fn f(_x: uint) -> ~[Optval] { return ~[]; }
let vals = vec::to_mut(vec::from_fn(n_opts, f)); let vals = vec::to_mut(vec::from_fn(n_opts, f));
let mut free: ~[~str] = ~[]; let mut free: ~[~str] = ~[];
let l = vec::len(args); let l = vec::len(args);
@ -215,10 +217,10 @@ fn getopts(args: &[~str], opts: &[opt]) -> result unsafe {
let tail = str::slice(cur, 2u, curlen); let tail = str::slice(cur, 2u, curlen);
let tail_eq = str::splitn_char(tail, '=', 1u); let tail_eq = str::splitn_char(tail, '=', 1u);
if vec::len(tail_eq) <= 1u { if vec::len(tail_eq) <= 1u {
names = ~[long(tail)]; names = ~[Long(tail)];
} else { } else {
names = names =
~[long(tail_eq[0])]; ~[Long(tail_eq[0])];
i_arg = i_arg =
option::Some::<~str>(tail_eq[1]); option::Some::<~str>(tail_eq[1]);
} }
@ -228,7 +230,7 @@ fn getopts(args: &[~str], opts: &[opt]) -> result unsafe {
names = ~[]; names = ~[];
while j < curlen { while j < curlen {
let range = str::char_range_at(cur, j); let range = str::char_range_at(cur, j);
let opt = short(range.ch); let opt = Short(range.ch);
/* In a series of potential options (eg. -aheJ), if we see /* In a series of potential options (eg. -aheJ), if we see
one which takes an argument, we assume all subsequent one which takes an argument, we assume all subsequent
@ -245,8 +247,8 @@ fn getopts(args: &[~str], opts: &[opt]) -> result unsafe {
match opts[option::get(last_valid_opt_id)] match opts[option::get(last_valid_opt_id)]
.hasarg { .hasarg {
yes | maybe => true, Yes | Maybe => true,
no => false No => false
}; };
if arg_follows && j + 1 < curlen { if arg_follows && j + 1 < curlen {
i_arg = option::Some(str::slice(cur, j, curlen)); i_arg = option::Some(str::slice(cur, j, curlen));
@ -265,30 +267,30 @@ fn getopts(args: &[~str], opts: &[opt]) -> result unsafe {
name_pos += 1u; name_pos += 1u;
let optid = match find_opt(opts, nm) { let optid = match find_opt(opts, nm) {
Some(id) => id, Some(id) => id,
None => return Err(unrecognized_option(name_str(&nm))) None => return Err(UnrecognizedOption(name_str(&nm)))
}; };
match opts[optid].hasarg { match opts[optid].hasarg {
no => { No => {
if !option::is_none::<~str>(i_arg) { if !option::is_none::<~str>(i_arg) {
return Err(unexpected_argument(name_str(&nm))); return Err(UnexpectedArgument(name_str(&nm)));
} }
vec::push(vals[optid], given); vec::push(vals[optid], Given);
} }
maybe => { Maybe => {
if !option::is_none::<~str>(i_arg) { if !option::is_none::<~str>(i_arg) {
vec::push(vals[optid], val(option::get(i_arg))); vec::push(vals[optid], Val(option::get(i_arg)));
} else if name_pos < vec::len::<name>(names) || } else if name_pos < vec::len::<Name>(names) ||
i + 1u == l || is_arg(args[i + 1u]) { i + 1u == l || is_arg(args[i + 1u]) {
vec::push(vals[optid], given); vec::push(vals[optid], Given);
} else { i += 1u; vec::push(vals[optid], val(args[i])); } } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
} }
yes => { Yes => {
if !option::is_none::<~str>(i_arg) { if !option::is_none::<~str>(i_arg) {
vec::push(vals[optid], vec::push(vals[optid],
val(option::get::<~str>(i_arg))); Val(option::get::<~str>(i_arg)));
} else if i + 1u == l { } else if i + 1u == l {
return Err(argument_missing(name_str(&nm))); return Err(ArgumentMissing(name_str(&nm)));
} else { i += 1u; vec::push(vals[optid], val(args[i])); } } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
} }
} }
} }
@ -297,16 +299,16 @@ fn getopts(args: &[~str], opts: &[opt]) -> result unsafe {
} }
i = 0u; i = 0u;
while i < n_opts { while i < n_opts {
let n = vec::len::<optval>(vals[i]); let n = vec::len::<Optval>(vals[i]);
let occ = opts[i].occur; let occ = opts[i].occur;
if occ == req { if occ == Req {
if n == 0u { if n == 0u {
return Err(option_missing(name_str(&(opts[i].name)))); return Err(OptionMissing(name_str(&(opts[i].name))));
} }
} }
if occ != multi { if occ != Multi {
if n > 1u { if n > 1u {
return Err(option_duplicated(name_str(&(opts[i].name)))); return Err(OptionDuplicated(name_str(&(opts[i].name))));
} }
} }
i += 1u; i += 1u;
@ -316,7 +318,7 @@ fn getopts(args: &[~str], opts: &[opt]) -> result unsafe {
free: free}); free: free});
} }
fn opt_vals(+mm: matches, nm: &str) -> ~[optval] { fn opt_vals(+mm: Matches, nm: &str) -> ~[Optval] {
return match find_opt(mm.opts, mkname(nm)) { return match find_opt(mm.opts, mkname(nm)) {
Some(id) => mm.vals[id], Some(id) => mm.vals[id],
None => { None => {
@ -326,15 +328,15 @@ fn opt_vals(+mm: matches, nm: &str) -> ~[optval] {
}; };
} }
fn opt_val(+mm: matches, nm: &str) -> optval { return opt_vals(mm, nm)[0]; } fn opt_val(+mm: Matches, nm: &str) -> Optval { return opt_vals(mm, nm)[0]; }
/// Returns true if an option was matched /// Returns true if an option was matched
fn opt_present(+mm: matches, nm: &str) -> bool { fn opt_present(+mm: Matches, nm: &str) -> bool {
return vec::len::<optval>(opt_vals(mm, nm)) > 0u; return vec::len::<Optval>(opt_vals(mm, nm)) > 0u;
} }
/// Returns true if any of several options were matched /// Returns true if any of several options were matched
fn opts_present(+mm: matches, names: &[~str]) -> bool { fn opts_present(+mm: Matches, names: &[~str]) -> bool {
for vec::each(names) |nm| { for vec::each(names) |nm| {
match find_opt(mm.opts, mkname(nm)) { match find_opt(mm.opts, mkname(nm)) {
Some(_) => return true, Some(_) => return true,
@ -351,8 +353,8 @@ fn opts_present(+mm: matches, names: &[~str]) -> bool {
* Fails if the option was not matched or if the match did not take an * Fails if the option was not matched or if the match did not take an
* argument * argument
*/ */
fn opt_str(+mm: matches, nm: &str) -> ~str { fn opt_str(+mm: Matches, nm: &str) -> ~str {
return match opt_val(mm, nm) { val(s) => s, _ => fail }; return match opt_val(mm, nm) { Val(s) => s, _ => fail };
} }
/** /**
@ -361,10 +363,10 @@ fn opt_str(+mm: matches, nm: &str) -> ~str {
* Fails if the no option was provided from the given list, or if the no such * Fails if the no option was provided from the given list, or if the no such
* option took an argument * option took an argument
*/ */
fn opts_str(+mm: matches, names: &[~str]) -> ~str { fn opts_str(+mm: Matches, names: &[~str]) -> ~str {
for vec::each(names) |nm| { for vec::each(names) |nm| {
match opt_val(mm, nm) { match opt_val(mm, nm) {
val(s) => return s, Val(s) => return s,
_ => () _ => ()
} }
} }
@ -378,19 +380,19 @@ fn opts_str(+mm: matches, names: &[~str]) -> ~str {
* *
* Used when an option accepts multiple values. * Used when an option accepts multiple values.
*/ */
fn opt_strs(+mm: matches, nm: &str) -> ~[~str] { fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] {
let mut acc: ~[~str] = ~[]; let mut acc: ~[~str] = ~[];
for vec::each(opt_vals(mm, nm)) |v| { for vec::each(opt_vals(mm, nm)) |v| {
match v { val(s) => vec::push(acc, s), _ => () } match v { Val(s) => vec::push(acc, s), _ => () }
} }
return acc; return acc;
} }
/// Returns the string argument supplied to a matching option or none /// Returns the string argument supplied to a matching option or none
fn opt_maybe_str(+mm: matches, nm: &str) -> Option<~str> { fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> {
let vals = opt_vals(mm, nm); let vals = opt_vals(mm, nm);
if vec::len::<optval>(vals) == 0u { return None::<~str>; } if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
return match vals[0] { val(s) => Some::<~str>(s), _ => None::<~str> }; return match vals[0] { Val(s) => Some::<~str>(s), _ => None::<~str> };
} }
@ -401,10 +403,10 @@ fn opt_maybe_str(+mm: matches, nm: &str) -> Option<~str> {
* present but no argument was provided, and the argument if the option was * present but no argument was provided, and the argument if the option was
* present and an argument was provided. * present and an argument was provided.
*/ */
fn opt_default(+mm: matches, nm: &str, def: &str) -> Option<~str> { fn opt_default(+mm: Matches, nm: &str, def: &str) -> Option<~str> {
let vals = opt_vals(mm, nm); let vals = opt_vals(mm, nm);
if vec::len::<optval>(vals) == 0u { return None::<~str>; } if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
return match vals[0] { val(s) => Some::<~str>(s), return match vals[0] { Val(s) => Some::<~str>(s),
_ => Some::<~str>(str::from_slice(def)) } _ => Some::<~str>(str::from_slice(def)) }
} }
@ -413,21 +415,21 @@ mod tests {
import opt = getopts; import opt = getopts;
import result::{Err, Ok}; import result::{Err, Ok};
enum fail_type { enum FailType {
argument_missing_, ArgumentMissing_,
unrecognized_option_, UnrecognizedOption_,
option_missing_, OptionMissing_,
option_duplicated_, OptionDuplicated_,
unexpected_argument_, UnexpectedArgument_,
} }
fn check_fail_type(+f: fail_, ft: fail_type) { fn check_fail_type(+f: Fail_, ft: FailType) {
match f { match f {
argument_missing(_) => assert ft == argument_missing_, ArgumentMissing(_) => assert ft == ArgumentMissing_,
unrecognized_option(_) => assert ft == unrecognized_option_, UnrecognizedOption(_) => assert ft == UnrecognizedOption_,
option_missing(_) => assert ft == option_missing_, OptionMissing(_) => assert ft == OptionMissing_,
option_duplicated(_) => assert ft == option_duplicated_, OptionDuplicated(_) => assert ft == OptionDuplicated_,
unexpected_argument(_) => assert ft == unexpected_argument_ UnexpectedArgument(_) => assert ft == UnexpectedArgument_
} }
} }
@ -453,7 +455,7 @@ mod tests {
let opts = ~[reqopt(~"test")]; let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_missing_), Err(f) => check_fail_type(f, OptionMissing_),
_ => fail _ => fail
} }
} }
@ -464,7 +466,7 @@ mod tests {
let opts = ~[reqopt(~"test")]; let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, argument_missing_), Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail _ => fail
} }
} }
@ -475,7 +477,7 @@ mod tests {
let opts = ~[reqopt(~"test")]; let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_duplicated_), Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail _ => fail
} }
} }
@ -500,7 +502,7 @@ mod tests {
let opts = ~[reqopt(~"t")]; let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_missing_), Err(f) => check_fail_type(f, OptionMissing_),
_ => fail _ => fail
} }
} }
@ -511,7 +513,7 @@ mod tests {
let opts = ~[reqopt(~"t")]; let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, argument_missing_), Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail _ => fail
} }
} }
@ -522,7 +524,7 @@ mod tests {
let opts = ~[reqopt(~"t")]; let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_duplicated_), Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail _ => fail
} }
} }
@ -560,7 +562,7 @@ mod tests {
let opts = ~[optopt(~"test")]; let opts = ~[optopt(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, argument_missing_), Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail _ => fail
} }
} }
@ -571,7 +573,7 @@ mod tests {
let opts = ~[optopt(~"test")]; let opts = ~[optopt(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_duplicated_), Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail _ => fail
} }
} }
@ -607,7 +609,7 @@ mod tests {
let opts = ~[optopt(~"t")]; let opts = ~[optopt(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, argument_missing_), Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail _ => fail
} }
} }
@ -618,7 +620,7 @@ mod tests {
let opts = ~[optopt(~"t")]; let opts = ~[optopt(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_duplicated_), Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail _ => fail
} }
} }
@ -655,7 +657,7 @@ mod tests {
match rs { match rs {
Err(f) => { Err(f) => {
log(error, fail_str(f)); log(error, fail_str(f));
check_fail_type(f, unexpected_argument_); check_fail_type(f, UnexpectedArgument_);
} }
_ => fail _ => fail
} }
@ -667,7 +669,7 @@ mod tests {
let opts = ~[optflag(~"test")]; let opts = ~[optflag(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_duplicated_), Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail _ => fail
} }
} }
@ -715,7 +717,7 @@ mod tests {
let opts = ~[optflag(~"t")]; let opts = ~[optflag(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, option_duplicated_), Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail _ => fail
} }
} }
@ -753,7 +755,7 @@ mod tests {
let opts = ~[optmulti(~"test")]; let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, argument_missing_), Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail _ => fail
} }
} }
@ -805,7 +807,7 @@ mod tests {
let opts = ~[optmulti(~"t")]; let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, argument_missing_), Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail _ => fail
} }
} }
@ -832,7 +834,7 @@ mod tests {
let opts = ~[optmulti(~"t")]; let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, unrecognized_option_), Err(f) => check_fail_type(f, UnrecognizedOption_),
_ => fail _ => fail
} }
} }
@ -843,7 +845,7 @@ mod tests {
let opts = ~[optmulti(~"test")]; let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(f) => check_fail_type(f, unrecognized_option_), Err(f) => check_fail_type(f, UnrecognizedOption_),
_ => fail _ => fail
} }
} }

358
src/libstd/json.rs
View File

@ -1,3 +1,5 @@
#[deny(non_camel_case_types)];
// Rust JSON serialization library // Rust JSON serialization library
// Copyright (c) 2011 Google Inc. // Copyright (c) 2011 Google Inc.
@ -10,45 +12,45 @@ import map;
import map::hashmap; import map::hashmap;
import map::map; import map::map;
export json; export Json;
export error; export Error;
export to_writer; export to_writer;
export to_str; export to_str;
export from_reader; export from_reader;
export from_str; export from_str;
export eq; export eq;
export to_json; export ToJson;
export num; export Num;
export string; export String;
export boolean; export Boolean;
export list; export List;
export dict; export Dict;
export null; export Null;
/// Represents a json value /// Represents a json value
enum json { enum Json {
num(float), Num(float),
string(@~str), String(@~str),
boolean(bool), Boolean(bool),
list(@~[json]), List(@~[Json]),
dict(map::hashmap<~str, json>), Dict(map::hashmap<~str, Json>),
null, Null,
} }
type error = { type Error = {
line: uint, line: uint,
col: uint, col: uint,
msg: @~str, msg: @~str,
}; };
/// Serializes a json value into a io::writer /// Serializes a json value into a io::writer
fn to_writer(wr: io::Writer, j: json) { fn to_writer(wr: io::Writer, j: Json) {
match j { match j {
num(n) => wr.write_str(float::to_str(n, 6u)), Num(n) => wr.write_str(float::to_str(n, 6u)),
string(s) => wr.write_str(escape_str(*s)), String(s) => wr.write_str(escape_str(*s)),
boolean(b) => wr.write_str(if b { ~"true" } else { ~"false" }), Boolean(b) => wr.write_str(if b { ~"true" } else { ~"false" }),
list(v) => { List(v) => {
wr.write_char('['); wr.write_char('[');
let mut first = true; let mut first = true;
for (*v).each |item| { for (*v).each |item| {
@ -60,7 +62,7 @@ fn to_writer(wr: io::Writer, j: json) {
}; };
wr.write_char(']'); wr.write_char(']');
} }
dict(d) => { Dict(d) => {
if d.size() == 0u { if d.size() == 0u {
wr.write_str(~"{}"); wr.write_str(~"{}");
return; return;
@ -79,7 +81,7 @@ fn to_writer(wr: io::Writer, j: json) {
}; };
wr.write_str(~" }"); wr.write_str(~" }");
} }
null => wr.write_str(~"null") Null => wr.write_str(~"null")
} }
} }
@ -104,22 +106,22 @@ fn escape_str(s: ~str) -> ~str {
} }
/// Serializes a json value into a string /// Serializes a json value into a string
fn to_str(j: json) -> ~str { fn to_str(j: Json) -> ~str {
io::with_str_writer(|wr| to_writer(wr, j)) io::with_str_writer(|wr| to_writer(wr, j))
} }
type parser_ = { type Parser_ = {
rdr: io::Reader, rdr: io::Reader,
mut ch: char, mut ch: char,
mut line: uint, mut line: uint,
mut col: uint, mut col: uint,
}; };
enum parser { enum Parser {
parser_(parser_) Parser_(Parser_)
} }
impl parser { impl Parser {
fn eof() -> bool { self.ch == -1 as char } fn eof() -> bool { self.ch == -1 as char }
fn bump() { fn bump() {
@ -138,11 +140,11 @@ impl parser {
self.ch self.ch
} }
fn error<T>(+msg: ~str) -> Result<T, error> { fn error<T>(+msg: ~str) -> Result<T, Error> {
Err({ line: self.line, col: self.col, msg: @msg }) Err({ line: self.line, col: self.col, msg: @msg })
} }
fn parse() -> Result<json, error> { fn parse() -> Result<Json, Error> {
match self.parse_value() { match self.parse_value() {
Ok(value) => { Ok(value) => {
// Skip trailing whitespaces. // Skip trailing whitespaces.
@ -158,18 +160,18 @@ impl parser {
} }
} }
fn parse_value() -> Result<json, error> { fn parse_value() -> Result<Json, Error> {
self.parse_whitespace(); self.parse_whitespace();
if self.eof() { return self.error(~"EOF while parsing value"); } if self.eof() { return self.error(~"EOF while parsing value"); }
match self.ch { match self.ch {
'n' => self.parse_ident(~"ull", null), 'n' => self.parse_ident(~"ull", Null),
't' => self.parse_ident(~"rue", boolean(true)), 't' => self.parse_ident(~"rue", Boolean(true)),
'f' => self.parse_ident(~"alse", boolean(false)), 'f' => self.parse_ident(~"alse", Boolean(false)),
'0' to '9' | '-' => self.parse_number(), '0' to '9' | '-' => self.parse_number(),
'"' => match self.parse_str() { '"' => match self.parse_str() {
Ok(s) => Ok(string(s)), Ok(s) => Ok(String(s)),
Err(e) => Err(e) Err(e) => Err(e)
}, },
'[' => self.parse_list(), '[' => self.parse_list(),
@ -182,7 +184,7 @@ impl parser {
while char::is_whitespace(self.ch) { self.bump(); } while char::is_whitespace(self.ch) { self.bump(); }
} }
fn parse_ident(ident: ~str, value: json) -> Result<json, error> { fn parse_ident(ident: ~str, value: Json) -> Result<Json, Error> {
if str::all(ident, |c| c == self.next_char()) { if str::all(ident, |c| c == self.next_char()) {
self.bump(); self.bump();
Ok(value) Ok(value)
@ -191,7 +193,7 @@ impl parser {
} }
} }
fn parse_number() -> Result<json, error> { fn parse_number() -> Result<Json, Error> {
let mut neg = 1f; let mut neg = 1f;
if self.ch == '-' { if self.ch == '-' {
@ -218,10 +220,10 @@ impl parser {
} }
} }
Ok(num(neg * res)) Ok(Num(neg * res))
} }
fn parse_integer() -> Result<float, error> { fn parse_integer() -> Result<float, Error> {
let mut res = 0f; let mut res = 0f;
match self.ch { match self.ch {
@ -253,7 +255,7 @@ impl parser {
Ok(res) Ok(res)
} }
fn parse_decimal(res: float) -> Result<float, error> { fn parse_decimal(res: float) -> Result<float, Error> {
self.bump(); self.bump();
// Make sure a digit follows the decimal place. // Make sure a digit follows the decimal place.
@ -279,7 +281,7 @@ impl parser {
Ok(res) Ok(res)
} }
fn parse_exponent(res: float) -> Result<float, error> { fn parse_exponent(res: float) -> Result<float, Error> {
self.bump(); self.bump();
let mut res = res; let mut res = res;
@ -320,7 +322,7 @@ impl parser {
Ok(res) Ok(res)
} }
fn parse_str() -> Result<@~str, error> { fn parse_str() -> Result<@~str, Error> {
let mut escape = false; let mut escape = false;
let mut res = ~""; let mut res = ~"";
@ -376,7 +378,7 @@ impl parser {
self.error(~"EOF while parsing string") self.error(~"EOF while parsing string")
} }
fn parse_list() -> Result<json, error> { fn parse_list() -> Result<Json, Error> {
self.bump(); self.bump();
self.parse_whitespace(); self.parse_whitespace();
@ -384,7 +386,7 @@ impl parser {
if self.ch == ']' { if self.ch == ']' {
self.bump(); self.bump();
return Ok(list(@values)); return Ok(List(@values));
} }
loop { loop {
@ -400,13 +402,13 @@ impl parser {
match self.ch { match self.ch {
',' => self.bump(), ',' => self.bump(),
']' => { self.bump(); return Ok(list(@values)); } ']' => { self.bump(); return Ok(List(@values)); }
_ => return self.error(~"expected `,` or `]`") _ => return self.error(~"expected `,` or `]`")
} }
}; };
} }
fn parse_object() -> Result<json, error> { fn parse_object() -> Result<Json, Error> {
self.bump(); self.bump();
self.parse_whitespace(); self.parse_whitespace();
@ -414,7 +416,7 @@ impl parser {
if self.ch == '}' { if self.ch == '}' {
self.bump(); self.bump();
return Ok(dict(values)); return Ok(Dict(values));
} }
while !self.eof() { while !self.eof() {
@ -445,7 +447,7 @@ impl parser {
match self.ch { match self.ch {
',' => self.bump(), ',' => self.bump(),
'}' => { self.bump(); return Ok(dict(values)); } '}' => { self.bump(); return Ok(Dict(values)); }
_ => { _ => {
if self.eof() { break; } if self.eof() { break; }
return self.error(~"expected `,` or `}`"); return self.error(~"expected `,` or `}`");
@ -458,8 +460,8 @@ impl parser {
} }
/// Deserializes a json value from an io::reader /// Deserializes a json value from an io::reader
fn from_reader(rdr: io::Reader) -> Result<json, error> { fn from_reader(rdr: io::Reader) -> Result<Json, Error> {
let parser = parser_({ let parser = Parser_({
rdr: rdr, rdr: rdr,
mut ch: rdr.read_char(), mut ch: rdr.read_char(),
mut line: 1u, mut line: 1u,
@ -470,18 +472,18 @@ fn from_reader(rdr: io::Reader) -> Result<json, error> {
} }
/// Deserializes a json value from a string /// Deserializes a json value from a string
fn from_str(s: ~str) -> Result<json, error> { fn from_str(s: ~str) -> Result<Json, Error> {
io::with_str_reader(s, from_reader) io::with_str_reader(s, from_reader)
} }
/// Test if two json values are equal /// Test if two json values are equal
fn eq(value0: json, value1: json) -> bool { fn eq(value0: Json, value1: Json) -> bool {
match (value0, value1) { match (value0, value1) {
(num(f0), num(f1)) => f0 == f1, (Num(f0), Num(f1)) => f0 == f1,
(string(s0), string(s1)) => s0 == s1, (String(s0), String(s1)) => s0 == s1,
(boolean(b0), boolean(b1)) => b0 == b1, (Boolean(b0), Boolean(b1)) => b0 == b1,
(list(l0), list(l1)) => vec::all2(*l0, *l1, eq), (List(l0), List(l1)) => vec::all2(*l0, *l1, eq),
(dict(d0), dict(d1)) => { (Dict(d0), Dict(d1)) => {
if d0.size() == d1.size() { if d0.size() == d1.size() {
let mut equal = true; let mut equal = true;
for d0.each |k, v0| { for d0.each |k, v0| {
@ -495,138 +497,138 @@ fn eq(value0: json, value1: json) -> bool {
false false
} }
} }
(null, null) => true, (Null, Null) => true,
_ => false _ => false
} }
} }
trait to_json { fn to_json() -> json; } trait ToJson { fn to_json() -> Json; }
impl json: to_json { impl Json: ToJson {
fn to_json() -> json { self } fn to_json() -> Json { self }
} }
impl @json: to_json { impl @Json: ToJson {
fn to_json() -> json { *self } fn to_json() -> Json { *self }
} }
impl int: to_json { impl int: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl i8: to_json { impl i8: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl i16: to_json { impl i16: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl i32: to_json { impl i32: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl i64: to_json { impl i64: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl uint: to_json { impl uint: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl u8: to_json { impl u8: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl u16: to_json { impl u16: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl u32: to_json { impl u32: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl u64: to_json { impl u64: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl float: to_json { impl float: ToJson {
fn to_json() -> json { num(self) } fn to_json() -> Json { Num(self) }
} }
impl f32: to_json { impl f32: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl f64: to_json { impl f64: ToJson {
fn to_json() -> json { num(self as float) } fn to_json() -> Json { Num(self as float) }
} }
impl (): to_json { impl (): ToJson {
fn to_json() -> json { null } fn to_json() -> Json { Null }
} }
impl bool: to_json { impl bool: ToJson {
fn to_json() -> json { boolean(self) } fn to_json() -> Json { Boolean(self) }
} }
impl ~str: to_json { impl ~str: ToJson {
fn to_json() -> json { string(@copy self) } fn to_json() -> Json { String(@copy self) }
} }
impl @~str: to_json { impl @~str: ToJson {
fn to_json() -> json { string(self) } fn to_json() -> Json { String(self) }
} }
impl <A: to_json, B: to_json> (A, B): to_json { impl <A: ToJson, B: ToJson> (A, B): ToJson {
fn to_json() -> json { fn to_json() -> Json {
match self { match self {
(a, b) => { (a, b) => {
list(@~[a.to_json(), b.to_json()]) List(@~[a.to_json(), b.to_json()])
} }
} }
} }
} }
impl <A: to_json, B: to_json, C: to_json> (A, B, C): to_json { impl <A: ToJson, B: ToJson, C: ToJson> (A, B, C): ToJson {
fn to_json() -> json { fn to_json() -> Json {
match self { match self {
(a, b, c) => { (a, b, c) => {
list(@~[a.to_json(), b.to_json(), c.to_json()]) List(@~[a.to_json(), b.to_json(), c.to_json()])
} }
} }
} }
} }
impl <A: to_json> ~[A]: to_json { impl <A: ToJson> ~[A]: ToJson {
fn to_json() -> json { list(@self.map(|elt| elt.to_json())) } fn to_json() -> Json { List(@self.map(|elt| elt.to_json())) }
} }
impl <A: to_json copy> hashmap<~str, A>: to_json { impl <A: ToJson copy> hashmap<~str, A>: ToJson {
fn to_json() -> json { fn to_json() -> Json {
let d = map::str_hash(); let d = map::str_hash();
for self.each() |key, value| { for self.each() |key, value| {
d.insert(copy key, value.to_json()); d.insert(copy key, value.to_json());
} }
dict(d) Dict(d)
} }
} }
impl <A: to_json> Option<A>: to_json { impl <A: ToJson> Option<A>: ToJson {
fn to_json() -> json { fn to_json() -> Json {
match self { match self {
None => null, None => Null,
Some(value) => value.to_json() Some(value) => value.to_json()
} }
} }
} }
impl json: to_str::ToStr { impl Json: to_str::ToStr {
fn to_str() -> ~str { to_str(self) } fn to_str() -> ~str { to_str(self) }
} }
impl error: to_str::ToStr { impl Error: to_str::ToStr {
fn to_str() -> ~str { fn to_str() -> ~str {
fmt!("%u:%u: %s", self.line, self.col, *self.msg) fmt!("%u:%u: %s", self.line, self.col, *self.msg)
} }
@ -634,7 +636,7 @@ impl error: to_str::ToStr {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
fn mk_dict(items: ~[(~str, json)]) -> json { fn mk_dict(items: ~[(~str, Json)]) -> Json {
let d = map::str_hash(); let d = map::str_hash();
do vec::iter(items) |item| { do vec::iter(items) |item| {
@ -642,55 +644,55 @@ mod tests {
d.insert(key, value); d.insert(key, value);
}; };
dict(d) Dict(d)
} }
#[test] #[test]
fn test_write_null() { fn test_write_null() {
assert to_str(null) == ~"null"; assert to_str(Null) == ~"null";
} }
#[test] #[test]
fn test_write_num() { fn test_write_num() {
assert to_str(num(3f)) == ~"3"; assert to_str(Num(3f)) == ~"3";
assert to_str(num(3.1f)) == ~"3.1"; assert to_str(Num(3.1f)) == ~"3.1";
assert to_str(num(-1.5f)) == ~"-1.5"; assert to_str(Num(-1.5f)) == ~"-1.5";
assert to_str(num(0.5f)) == ~"0.5"; assert to_str(Num(0.5f)) == ~"0.5";
} }
#[test] #[test]
fn test_write_str() { fn test_write_str() {
assert to_str(string(@~"")) == ~"\"\""; assert to_str(String(@~"")) == ~"\"\"";
assert to_str(string(@~"foo")) == ~"\"foo\""; assert to_str(String(@~"foo")) == ~"\"foo\"";
} }
#[test] #[test]
fn test_write_bool() { fn test_write_bool() {
assert to_str(boolean(true)) == ~"true"; assert to_str(Boolean(true)) == ~"true";
assert to_str(boolean(false)) == ~"false"; assert to_str(Boolean(false)) == ~"false";
} }
#[test] #[test]
fn test_write_list() { fn test_write_list() {
assert to_str(list(@~[])) == ~"[]"; assert to_str(List(@~[])) == ~"[]";
assert to_str(list(@~[boolean(true)])) == ~"[true]"; assert to_str(List(@~[Boolean(true)])) == ~"[true]";
assert to_str(list(@~[ assert to_str(List(@~[
boolean(false), Boolean(false),
null, Null,
list(@~[string(@~"foo\nbar"), num(3.5f)]) List(@~[String(@~"foo\nbar"), Num(3.5f)])
])) == ~"[false, null, [\"foo\\nbar\", 3.5]]"; ])) == ~"[false, null, [\"foo\\nbar\", 3.5]]";
} }
#[test] #[test]
fn test_write_dict() { fn test_write_dict() {
assert to_str(mk_dict(~[])) == ~"{}"; assert to_str(mk_dict(~[])) == ~"{}";
assert to_str(mk_dict(~[(~"a", boolean(true))])) assert to_str(mk_dict(~[(~"a", Boolean(true))]))
== ~"{ \"a\": true }"; == ~"{ \"a\": true }";
assert to_str(mk_dict(~[ assert to_str(mk_dict(~[
(~"a", boolean(true)), (~"a", Boolean(true)),
(~"b", list(@~[ (~"b", List(@~[
mk_dict(~[(~"c", string(@~"\x0c\r"))]), mk_dict(~[(~"c", String(@~"\x0c\r"))]),
mk_dict(~[(~"d", string(@~""))]) mk_dict(~[(~"d", String(@~""))])
])) ]))
])) == ])) ==
~"{ " + ~"{ " +
@ -735,12 +737,12 @@ mod tests {
assert from_str(~"faz") == assert from_str(~"faz") ==
Err({line: 1u, col: 3u, msg: @~"invalid syntax"}); Err({line: 1u, col: 3u, msg: @~"invalid syntax"});
assert from_str(~"null") == Ok(null); assert from_str(~"null") == Ok(Null);
assert from_str(~"true") == Ok(boolean(true)); assert from_str(~"true") == Ok(Boolean(true));
assert from_str(~"false") == Ok(boolean(false)); assert from_str(~"false") == Ok(Boolean(false));
assert from_str(~" null ") == Ok(null); assert from_str(~" null ") == Ok(Null);
assert from_str(~" true ") == Ok(boolean(true)); assert from_str(~" true ") == Ok(Boolean(true));
assert from_str(~" false ") == Ok(boolean(false)); assert from_str(~" false ") == Ok(Boolean(false));
} }
#[test] #[test]
@ -761,14 +763,14 @@ mod tests {
assert from_str(~"1e+") == assert from_str(~"1e+") ==
Err({line: 1u, col: 4u, msg: @~"invalid number"}); Err({line: 1u, col: 4u, msg: @~"invalid number"});
assert from_str(~"3") == Ok(num(3f)); assert from_str(~"3") == Ok(Num(3f));
assert from_str(~"3.1") == Ok(num(3.1f)); assert from_str(~"3.1") == Ok(Num(3.1f));
assert from_str(~"-1.2") == Ok(num(-1.2f)); assert from_str(~"-1.2") == Ok(Num(-1.2f));
assert from_str(~"0.4") == Ok(num(0.4f)); assert from_str(~"0.4") == Ok(Num(0.4f));
assert from_str(~"0.4e5") == Ok(num(0.4e5f)); assert from_str(~"0.4e5") == Ok(Num(0.4e5f));
assert from_str(~"0.4e+15") == Ok(num(0.4e15f)); assert from_str(~"0.4e+15") == Ok(Num(0.4e15f));
assert from_str(~"0.4e-01") == Ok(num(0.4e-01f)); assert from_str(~"0.4e-01") == Ok(Num(0.4e-01f));
assert from_str(~" 3 ") == Ok(num(3f)); assert from_str(~" 3 ") == Ok(Num(3f));
} }
#[test] #[test]
@ -778,14 +780,14 @@ mod tests {
assert from_str(~"\"lol") == assert from_str(~"\"lol") ==
Err({line: 1u, col: 5u, msg: @~"EOF while parsing string"}); Err({line: 1u, col: 5u, msg: @~"EOF while parsing string"});
assert from_str(~"\"\"") == Ok(string(@~"")); assert from_str(~"\"\"") == Ok(String(@~""));
assert from_str(~"\"foo\"") == Ok(string(@~"foo")); assert from_str(~"\"foo\"") == Ok(String(@~"foo"));
assert from_str(~"\"\\\"\"") == Ok(string(@~"\"")); assert from_str(~"\"\\\"\"") == Ok(String(@~"\""));
assert from_str(~"\"\\b\"") == Ok(string(@~"\x08")); assert from_str(~"\"\\b\"") == Ok(String(@~"\x08"));
assert from_str(~"\"\\n\"") == Ok(string(@~"\n")); assert from_str(~"\"\\n\"") == Ok(String(@~"\n"));
assert from_str(~"\"\\r\"") == Ok(string(@~"\r")); assert from_str(~"\"\\r\"") == Ok(String(@~"\r"));
assert from_str(~"\"\\t\"") == Ok(string(@~"\t")); assert from_str(~"\"\\t\"") == Ok(String(@~"\t"));
assert from_str(~" \"foo\" ") == Ok(string(@~"foo")); assert from_str(~" \"foo\" ") == Ok(String(@~"foo"));
} }
#[test] #[test]
@ -801,15 +803,15 @@ mod tests {
assert from_str(~"[6 7]") == assert from_str(~"[6 7]") ==
Err({line: 1u, col: 4u, msg: @~"expected `,` or `]`"}); Err({line: 1u, col: 4u, msg: @~"expected `,` or `]`"});
assert from_str(~"[]") == Ok(list(@~[])); assert from_str(~"[]") == Ok(List(@~[]));
assert from_str(~"[ ]") == Ok(list(@~[])); assert from_str(~"[ ]") == Ok(List(@~[]));
assert from_str(~"[true]") == Ok(list(@~[boolean(true)])); assert from_str(~"[true]") == Ok(List(@~[Boolean(true)]));
assert from_str(~"[ false ]") == Ok(list(@~[boolean(false)])); assert from_str(~"[ false ]") == Ok(List(@~[Boolean(false)]));
assert from_str(~"[null]") == Ok(list(@~[null])); assert from_str(~"[null]") == Ok(List(@~[Null]));
assert from_str(~"[3, 1]") == Ok(list(@~[num(3f), num(1f)])); assert from_str(~"[3, 1]") == Ok(List(@~[Num(3f), Num(1f)]));
assert from_str(~"\n[3, 2]\n") == Ok(list(@~[num(3f), num(2f)])); assert from_str(~"\n[3, 2]\n") == Ok(List(@~[Num(3f), Num(2f)]));
assert from_str(~"[2, [4, 1]]") == assert from_str(~"[2, [4, 1]]") ==
Ok(list(@~[num(2f), list(@~[num(4f), num(1f)])])); Ok(List(@~[Num(2f), List(@~[Num(4f), Num(1f)])]));
} }
#[test] #[test]
@ -840,20 +842,20 @@ mod tests {
assert eq(result::get(from_str(~"{}")), mk_dict(~[])); assert eq(result::get(from_str(~"{}")), mk_dict(~[]));
assert eq(result::get(from_str(~"{\"a\": 3}")), assert eq(result::get(from_str(~"{\"a\": 3}")),
mk_dict(~[(~"a", num(3.0f))])); mk_dict(~[(~"a", Num(3.0f))]));
assert eq(result::get(from_str(~"{ \"a\": null, \"b\" : true }")), assert eq(result::get(from_str(~"{ \"a\": null, \"b\" : true }")),
mk_dict(~[ mk_dict(~[
(~"a", null), (~"a", Null),
(~"b", boolean(true))])); (~"b", Boolean(true))]));
assert eq(result::get(from_str(~"\n{ \"a\": null, \"b\" : true }\n")), assert eq(result::get(from_str(~"\n{ \"a\": null, \"b\" : true }\n")),
mk_dict(~[ mk_dict(~[
(~"a", null), (~"a", Null),
(~"b", boolean(true))])); (~"b", Boolean(true))]));
assert eq(result::get(from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")), assert eq(result::get(from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")),
mk_dict(~[ mk_dict(~[
(~"a", num(1.0)), (~"a", Num(1.0)),
(~"b", list(@~[boolean(true)])) (~"b", List(@~[Boolean(true)]))
])); ]));
assert eq(result::get(from_str( assert eq(result::get(from_str(
~"{" + ~"{" +
@ -865,12 +867,12 @@ mod tests {
~"]" + ~"]" +
~"}")), ~"}")),
mk_dict(~[ mk_dict(~[
(~"a", num(1.0f)), (~"a", Num(1.0f)),
(~"b", list(@~[ (~"b", List(@~[
boolean(true), Boolean(true),
string(@~"foo\nbar"), String(@~"foo\nbar"),
mk_dict(~[ mk_dict(~[
(~"c", mk_dict(~[(~"d", null)])) (~"c", mk_dict(~[(~"d", Null)]))
]) ])
])) ]))
])); ]));

6
src/libsyntax/ext/pipes/liveness.rs
View File

@ -27,7 +27,7 @@ updating the states using rule (2) until there are no changes.
*/ */
import std::bitv::{bitv}; import std::bitv::{Bitv};
import ast_builder::empty_span; import ast_builder::empty_span;
@ -35,7 +35,7 @@ fn analyze(proto: protocol, _cx: ext_ctxt) {
debug!("initializing colive analysis"); debug!("initializing colive analysis");
let num_states = proto.num_states(); let num_states = proto.num_states();
let colive = do (copy proto.states).map_to_vec |state| { let colive = do (copy proto.states).map_to_vec |state| {
let bv = ~bitv(num_states, false); let bv = ~Bitv(num_states, false);
for state.reachable |s| { for state.reachable |s| {
bv.set(s.id, true); bv.set(s.id, true);
} }
@ -88,4 +88,4 @@ fn analyze(proto: protocol, _cx: ext_ctxt) {
debug!("protocol %s is bounded. yay!", proto.name); debug!("protocol %s is bounded. yay!", proto.name);
proto.bounded = Some(true); proto.bounded = Some(true);
} }
} }

4
src/rustc/driver/driver.rs
View File

@ -421,7 +421,7 @@ fn host_triple() -> ~str {
}; };
} }
fn build_session_options(matches: getopts::matches, fn build_session_options(matches: getopts::Matches,
demitter: diagnostic::emitter) -> @session::options { demitter: diagnostic::emitter) -> @session::options {
let crate_type = if opt_present(matches, ~"lib") { let crate_type = if opt_present(matches, ~"lib") {
session::lib_crate session::lib_crate
@ -605,7 +605,7 @@ fn parse_pretty(sess: session, &&name: ~str) -> pp_mode {
} }
} }
fn opts() -> ~[getopts::opt] { fn opts() -> ~[getopts::Opt] {
return ~[optflag(~"h"), optflag(~"help"), return ~[optflag(~"h"), optflag(~"help"),
optflag(~"v"), optflag(~"version"), optflag(~"v"), optflag(~"version"),
optflag(~"emit-llvm"), optflagopt(~"pretty"), optflag(~"emit-llvm"), optflagopt(~"pretty"),

64
src/rustc/metadata/decoder.rs
View File

@ -63,8 +63,8 @@ export translate_def_id;
// what crate that's in and give us a def_id that makes sense for the current // what crate that's in and give us a def_id that makes sense for the current
// build. // build.
fn lookup_hash(d: ebml::doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) -> fn lookup_hash(d: ebml::Doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
Option<ebml::doc> { Option<ebml::Doc> {
let index = ebml::get_doc(d, tag_index); let index = ebml::get_doc(d, tag_index);
let table = ebml::get_doc(index, tag_index_table); let table = ebml::get_doc(index, tag_index_table);
let hash_pos = table.start + hash % 256u * 4u; let hash_pos = table.start + hash % 256u * 4u;
@ -81,7 +81,7 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
None None
} }
fn maybe_find_item(item_id: int, items: ebml::doc) -> Option<ebml::doc> { fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
fn eq_item(bytes: &[u8], item_id: int) -> bool { fn eq_item(bytes: &[u8], item_id: int) -> bool {
return io::u64_from_be_bytes(vec::view(bytes, 0u, 4u), 0u, 4u) as int return io::u64_from_be_bytes(vec::view(bytes, 0u, 4u), 0u, 4u) as int
== item_id; == item_id;
@ -91,13 +91,13 @@ fn maybe_find_item(item_id: int, items: ebml::doc) -> Option<ebml::doc> {
hash_node_id(item_id)) hash_node_id(item_id))
} }
fn find_item(item_id: int, items: ebml::doc) -> ebml::doc { fn find_item(item_id: int, items: ebml::Doc) -> ebml::Doc {
return option::get(maybe_find_item(item_id, items)); return option::get(maybe_find_item(item_id, items));
} }
// Looks up an item in the given metadata and returns an ebml doc pointing // Looks up an item in the given metadata and returns an ebml doc pointing
// to the item data. // to the item data.
fn lookup_item(item_id: int, data: @~[u8]) -> ebml::doc { fn lookup_item(item_id: int, data: @~[u8]) -> ebml::Doc {
let items = ebml::get_doc(ebml::doc(data), tag_items); let items = ebml::get_doc(ebml::doc(data), tag_items);
match maybe_find_item(item_id, items) { match maybe_find_item(item_id, items) {
None => fail(fmt!("lookup_item: id not found: %d", item_id)), None => fail(fmt!("lookup_item: id not found: %d", item_id)),
@ -129,7 +129,7 @@ enum Family {
InheritedField // N InheritedField // N
} }
fn item_family(item: ebml::doc) -> Family { fn item_family(item: ebml::Doc) -> Family {
let fam = ebml::get_doc(item, tag_items_data_item_family); let fam = ebml::get_doc(item, tag_items_data_item_family);
match ebml::doc_as_u8(fam) as char { match ebml::doc_as_u8(fam) as char {
'c' => Const, 'c' => Const,
@ -157,25 +157,25 @@ fn item_family(item: ebml::doc) -> Family {
} }
} }
fn item_symbol(item: ebml::doc) -> ~str { fn item_symbol(item: ebml::Doc) -> ~str {
let sym = ebml::get_doc(item, tag_items_data_item_symbol); let sym = ebml::get_doc(item, tag_items_data_item_symbol);
return str::from_bytes(ebml::doc_data(sym)); return str::from_bytes(ebml::doc_data(sym));
} }
fn item_parent_item(d: ebml::doc) -> Option<ast::def_id> { fn item_parent_item(d: ebml::Doc) -> Option<ast::def_id> {
for ebml::tagged_docs(d, tag_items_data_parent_item) |did| { for ebml::tagged_docs(d, tag_items_data_parent_item) |did| {
return Some(ebml::with_doc_data(did, |d| parse_def_id(d))); return Some(ebml::with_doc_data(did, |d| parse_def_id(d)));
} }
None None
} }
fn item_def_id(d: ebml::doc, cdata: cmd) -> ast::def_id { fn item_def_id(d: ebml::Doc, cdata: cmd) -> ast::def_id {
let tagdoc = ebml::get_doc(d, tag_def_id); let tagdoc = ebml::get_doc(d, tag_def_id);
return translate_def_id(cdata, ebml::with_doc_data(tagdoc, return translate_def_id(cdata, ebml::with_doc_data(tagdoc,
|d| parse_def_id(d))); |d| parse_def_id(d)));
} }
fn each_reexport(d: ebml::doc, f: fn(ebml::doc) -> bool) { fn each_reexport(d: ebml::Doc, f: fn(ebml::Doc) -> bool) {
for ebml::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| { for ebml::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| {
if !f(reexport_doc) { if !f(reexport_doc) {
return; return;
@ -183,7 +183,7 @@ fn each_reexport(d: ebml::doc, f: fn(ebml::doc) -> bool) {
} }
} }
fn field_mutability(d: ebml::doc) -> ast::class_mutability { fn field_mutability(d: ebml::Doc) -> ast::class_mutability {
// Use maybe_get_doc in case it's a method // Use maybe_get_doc in case it's a method
option::map_default( option::map_default(
ebml::maybe_get_doc(d, tag_class_mut), ebml::maybe_get_doc(d, tag_class_mut),
@ -196,20 +196,20 @@ fn field_mutability(d: ebml::doc) -> ast::class_mutability {
}) })
} }
fn variant_disr_val(d: ebml::doc) -> Option<int> { fn variant_disr_val(d: ebml::Doc) -> Option<int> {
do option::chain(ebml::maybe_get_doc(d, tag_disr_val)) |val_doc| { do option::chain(ebml::maybe_get_doc(d, tag_disr_val)) |val_doc| {
int::parse_buf(ebml::doc_data(val_doc), 10u) int::parse_buf(ebml::doc_data(val_doc), 10u)
} }
} }
fn doc_type(doc: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t { fn doc_type(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
let tp = ebml::get_doc(doc, tag_items_data_item_type); let tp = ebml::get_doc(doc, tag_items_data_item_type);
parse_ty_data(tp.data, cdata.cnum, tp.start, tcx, |did| { parse_ty_data(tp.data, cdata.cnum, tp.start, tcx, |did| {
translate_def_id(cdata, did) translate_def_id(cdata, did)
}) })
} }
fn item_type(item_id: ast::def_id, item: ebml::doc, fn item_type(item_id: ast::def_id, item: ebml::Doc,
tcx: ty::ctxt, cdata: cmd) -> ty::t { tcx: ty::ctxt, cdata: cmd) -> ty::t {
let t = doc_type(item, tcx, cdata); let t = doc_type(item, tcx, cdata);
if family_names_type(item_family(item)) { if family_names_type(item_family(item)) {
@ -217,7 +217,7 @@ fn item_type(item_id: ast::def_id, item: ebml::doc,
} else { t } } else { t }
} }
fn item_impl_traits(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] { fn item_impl_traits(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] {
let mut results = ~[]; let mut results = ~[];
for ebml::tagged_docs(item, tag_impl_trait) |ity| { for ebml::tagged_docs(item, tag_impl_trait) |ity| {
vec::push(results, doc_type(ity, tcx, cdata)); vec::push(results, doc_type(ity, tcx, cdata));
@ -225,7 +225,7 @@ fn item_impl_traits(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] {
results results
} }
fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) fn item_ty_param_bounds(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd)
-> @~[ty::param_bounds] { -> @~[ty::param_bounds] {
let mut bounds = ~[]; let mut bounds = ~[];
for ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) |p| { for ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) |p| {
@ -237,21 +237,21 @@ fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
@bounds @bounds
} }
fn item_ty_region_param(item: ebml::doc) -> Option<ty::region_variance> { fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
ebml::maybe_get_doc(item, tag_region_param).map(|doc| { ebml::maybe_get_doc(item, tag_region_param).map(|doc| {
let d = ebml::ebml_deserializer(doc); let d = ebml::ebml_deserializer(doc);
ty::deserialize_region_variance(d) ty::deserialize_region_variance(d)
}) })
} }
fn item_ty_param_count(item: ebml::doc) -> uint { fn item_ty_param_count(item: ebml::Doc) -> uint {
let mut n = 0u; let mut n = 0u;
ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds, ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds,
|_p| { n += 1u; true } ); |_p| { n += 1u; true } );
n n
} }
fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> ~[ast::def_id] { fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] {
let mut ids: ~[ast::def_id] = ~[]; let mut ids: ~[ast::def_id] = ~[];
let v = tag_items_data_item_variant; let v = tag_items_data_item_variant;
for ebml::tagged_docs(item, v) |p| { for ebml::tagged_docs(item, v) |p| {
@ -261,7 +261,7 @@ fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> ~[ast::def_id] {
return ids; return ids;
} }
fn item_path(intr: ident_interner, item_doc: ebml::doc) -> ast_map::path { fn item_path(intr: ident_interner, item_doc: ebml::Doc) -> ast_map::path {
let path_doc = ebml::get_doc(item_doc, tag_path); let path_doc = ebml::get_doc(item_doc, tag_path);
let len_doc = ebml::get_doc(path_doc, tag_path_len); let len_doc = ebml::get_doc(path_doc, tag_path_len);
@ -285,12 +285,12 @@ fn item_path(intr: ident_interner, item_doc: ebml::doc) -> ast_map::path {
return result; return result;
} }
fn item_name(intr: ident_interner, item: ebml::doc) -> ast::ident { fn item_name(intr: ident_interner, item: ebml::Doc) -> ast::ident {
let name = ebml::get_doc(item, tag_paths_data_name); let name = ebml::get_doc(item, tag_paths_data_name);
intr.intern(@str::from_bytes(ebml::doc_data(name))) intr.intern(@str::from_bytes(ebml::doc_data(name)))
} }
fn item_to_def_like(item: ebml::doc, did: ast::def_id, cnum: ast::crate_num) fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
-> def_like { -> def_like {
let fam = item_family(item); let fam = item_family(item);
match fam { match fam {
@ -533,7 +533,7 @@ type decode_inlined_item = fn(
cdata: cstore::crate_metadata, cdata: cstore::crate_metadata,
tcx: ty::ctxt, tcx: ty::ctxt,
path: ast_map::path, path: ast_map::path,
par_doc: ebml::doc) -> Option<ast::inlined_item>; par_doc: ebml::Doc) -> Option<ast::inlined_item>;
fn maybe_get_item_ast(intr: ident_interner, cdata: cmd, tcx: ty::ctxt, fn maybe_get_item_ast(intr: ident_interner, cdata: cmd, tcx: ty::ctxt,
id: ast::node_id, id: ast::node_id,
@ -602,7 +602,7 @@ type method_info = {
type _impl = {did: ast::def_id, ident: ast::ident, methods: ~[@method_info]}; type _impl = {did: ast::def_id, ident: ast::ident, methods: ~[@method_info]};
fn get_self_ty(item: ebml::doc) -> ast::self_ty_ { fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
fn get_mutability(ch: u8) -> ast::mutability { fn get_mutability(ch: u8) -> ast::mutability {
match ch as char { match ch as char {
'i' => { ast::m_imm } 'i' => { ast::m_imm }
@ -631,7 +631,7 @@ fn get_self_ty(item: ebml::doc) -> ast::self_ty_ {
} }
} }
fn item_impl_methods(intr: ident_interner, cdata: cmd, item: ebml::doc, fn item_impl_methods(intr: ident_interner, cdata: cmd, item: ebml::Doc,
base_tps: uint) -> ~[@method_info] { base_tps: uint) -> ~[@method_info] {
let mut rslt = ~[]; let mut rslt = ~[];
for ebml::tagged_docs(item, tag_item_impl_method) |doc| { for ebml::tagged_docs(item, tag_item_impl_method) |doc| {
@ -780,7 +780,7 @@ fn family_names_type(fam: Family) -> bool {
match fam { Type | Mod | Trait => true, _ => false } match fam { Type | Mod | Trait => true, _ => false }
} }
fn read_path(d: ebml::doc) -> {path: ~str, pos: uint} { fn read_path(d: ebml::Doc) -> {path: ~str, pos: uint} {
let desc = ebml::doc_data(d); let desc = ebml::doc_data(d);
let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint; let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc)); let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
@ -788,7 +788,7 @@ fn read_path(d: ebml::doc) -> {path: ~str, pos: uint} {
return {path: path, pos: pos}; return {path: path, pos: pos};
} }
fn describe_def(items: ebml::doc, id: ast::def_id) -> ~str { fn describe_def(items: ebml::Doc, id: ast::def_id) -> ~str {
if id.crate != ast::local_crate { return ~"external"; } if id.crate != ast::local_crate { return ~"external"; }
let it = match maybe_find_item(id.node, items) { let it = match maybe_find_item(id.node, items) {
Some(it) => it, Some(it) => it,
@ -823,7 +823,7 @@ fn item_family_to_str(fam: Family) -> ~str {
} }
} }
fn get_meta_items(md: ebml::doc) -> ~[@ast::meta_item] { fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
let mut items: ~[@ast::meta_item] = ~[]; let mut items: ~[@ast::meta_item] = ~[];
for ebml::tagged_docs(md, tag_meta_item_word) |meta_item_doc| { for ebml::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name); let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
@ -848,7 +848,7 @@ fn get_meta_items(md: ebml::doc) -> ~[@ast::meta_item] {
return items; return items;
} }
fn get_attributes(md: ebml::doc) -> ~[ast::attribute] { fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
let mut attrs: ~[ast::attribute] = ~[]; let mut attrs: ~[ast::attribute] = ~[];
match ebml::maybe_get_doc(md, tag_attributes) { match ebml::maybe_get_doc(md, tag_attributes) {
option::Some(attrs_d) => { option::Some(attrs_d) => {
@ -870,13 +870,13 @@ fn get_attributes(md: ebml::doc) -> ~[ast::attribute] {
} }
fn list_meta_items(intr: ident_interner, fn list_meta_items(intr: ident_interner,
meta_items: ebml::doc, out: io::Writer) { meta_items: ebml::Doc, out: io::Writer) {
for get_meta_items(meta_items).each |mi| { for get_meta_items(meta_items).each |mi| {
out.write_str(fmt!("%s\n", pprust::meta_item_to_str(mi, intr))); out.write_str(fmt!("%s\n", pprust::meta_item_to_str(mi, intr)));
} }
} }
fn list_crate_attributes(intr: ident_interner, md: ebml::doc, hash: ~str, fn list_crate_attributes(intr: ident_interner, md: ebml::Doc, hash: ~str,
out: io::Writer) { out: io::Writer) {
out.write_str(fmt!("=Crate Attributes (%s)=\n", hash)); out.write_str(fmt!("=Crate Attributes (%s)=\n", hash));
@ -899,7 +899,7 @@ fn get_crate_deps(intr: ident_interner, data: @~[u8]) -> ~[crate_dep] {
let cratedoc = ebml::doc(data); let cratedoc = ebml::doc(data);
let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps); let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
let mut crate_num = 1; let mut crate_num = 1;
fn docstr(doc: ebml::doc, tag_: uint) -> ~str { fn docstr(doc: ebml::Doc, tag_: uint) -> ~str {
str::from_bytes(ebml::doc_data(ebml::get_doc(doc, tag_))) str::from_bytes(ebml::doc_data(ebml::get_doc(doc, tag_)))
} }
for ebml::tagged_docs(depsdoc, tag_crate_dep) |depdoc| { for ebml::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {

76
src/rustc/metadata/encoder.rs
View File

@ -5,7 +5,7 @@ import util::ppaux::ty_to_str;
import std::{ebml, map}; import std::{ebml, map};
import std::map::hashmap; import std::map::hashmap;
import io::WriterUtil; import io::WriterUtil;
import ebml::writer; import ebml::Writer;
import syntax::ast::*; import syntax::ast::*;
import syntax::print::pprust; import syntax::print::pprust;
import syntax::{ast_util, visit}; import syntax::{ast_util, visit};
@ -37,7 +37,7 @@ export encode_def_id;
type abbrev_map = map::hashmap<ty::t, tyencode::ty_abbrev>; type abbrev_map = map::hashmap<ty::t, tyencode::ty_abbrev>;
type encode_inlined_item = fn@(ecx: @encode_ctxt, type encode_inlined_item = fn@(ecx: @encode_ctxt,
ebml_w: ebml::writer, ebml_w: ebml::Writer,
path: ast_map::path, path: ast_map::path,
ii: ast::inlined_item); ii: ast::inlined_item);
@ -86,15 +86,15 @@ fn reachable(ecx: @encode_ctxt, id: node_id) -> bool {
ecx.reachable.contains_key(id) ecx.reachable.contains_key(id)
} }
fn encode_name(ecx: @encode_ctxt, ebml_w: ebml::writer, name: ident) { fn encode_name(ecx: @encode_ctxt, ebml_w: ebml::Writer, name: ident) {
ebml_w.wr_tagged_str(tag_paths_data_name, ecx.tcx.sess.str_of(name)); ebml_w.wr_tagged_str(tag_paths_data_name, ecx.tcx.sess.str_of(name));
} }
fn encode_def_id(ebml_w: ebml::writer, id: def_id) { fn encode_def_id(ebml_w: ebml::Writer, id: def_id) {
ebml_w.wr_tagged_str(tag_def_id, def_to_str(id)); ebml_w.wr_tagged_str(tag_def_id, def_to_str(id));
} }
fn encode_region_param(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_region_param(ecx: @encode_ctxt, ebml_w: ebml::Writer,
it: @ast::item) { it: @ast::item) {
let opt_rp = ecx.tcx.region_paramd_items.find(it.id); let opt_rp = ecx.tcx.region_paramd_items.find(it.id);
for opt_rp.each |rp| { for opt_rp.each |rp| {
@ -104,7 +104,7 @@ fn encode_region_param(ecx: @encode_ctxt, ebml_w: ebml::writer,
} }
} }
fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) { fn encode_mutability(ebml_w: ebml::Writer, mt: class_mutability) {
do ebml_w.wr_tag(tag_class_mut) { do ebml_w.wr_tag(tag_class_mut) {
let val = match mt { let val = match mt {
class_immutable => 'a', class_immutable => 'a',
@ -116,7 +116,7 @@ fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) {
type entry<T> = {val: T, pos: uint}; type entry<T> = {val: T, pos: uint};
fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml::writer, path: &[ident], fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml::Writer, path: &[ident],
&index: ~[entry<~str>], name: ident) { &index: ~[entry<~str>], name: ident) {
let mut full_path = ~[]; let mut full_path = ~[];
vec::push_all(full_path, path); vec::push_all(full_path, path);
@ -127,7 +127,7 @@ fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml::writer, path: &[ident],
pos: ebml_w.writer.tell()}); pos: ebml_w.writer.tell()});
} }
fn encode_trait_ref(ebml_w: ebml::writer, ecx: @encode_ctxt, t: @trait_ref) { fn encode_trait_ref(ebml_w: ebml::Writer, ecx: @encode_ctxt, t: @trait_ref) {
ebml_w.start_tag(tag_impl_trait); ebml_w.start_tag(tag_impl_trait);
encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, t.ref_id)); encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, t.ref_id));
ebml_w.end_tag(); ebml_w.end_tag();
@ -135,7 +135,7 @@ fn encode_trait_ref(ebml_w: ebml::writer, ecx: @encode_ctxt, t: @trait_ref) {
// Item info table encoding // Item info table encoding
fn encode_family(ebml_w: ebml::writer, c: char) { fn encode_family(ebml_w: ebml::Writer, c: char) {
ebml_w.start_tag(tag_items_data_item_family); ebml_w.start_tag(tag_items_data_item_family);
ebml_w.writer.write(&[c as u8]); ebml_w.writer.write(&[c as u8]);
ebml_w.end_tag(); ebml_w.end_tag();
@ -143,7 +143,7 @@ fn encode_family(ebml_w: ebml::writer, c: char) {
fn def_to_str(did: def_id) -> ~str { fmt!("%d:%d", did.crate, did.node) } fn def_to_str(did: def_id) -> ~str { fmt!("%d:%d", did.crate, did.node) }
fn encode_ty_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt, fn encode_ty_type_param_bounds(ebml_w: ebml::Writer, ecx: @encode_ctxt,
params: @~[ty::param_bounds]) { params: @~[ty::param_bounds]) {
let ty_str_ctxt = @{diag: ecx.diag, let ty_str_ctxt = @{diag: ecx.diag,
ds: def_to_str, ds: def_to_str,
@ -157,7 +157,7 @@ fn encode_ty_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
} }
} }
fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt, fn encode_type_param_bounds(ebml_w: ebml::Writer, ecx: @encode_ctxt,
params: ~[ty_param]) { params: ~[ty_param]) {
let ty_param_bounds = let ty_param_bounds =
@params.map(|param| ecx.tcx.ty_param_bounds.get(param.id)); @params.map(|param| ecx.tcx.ty_param_bounds.get(param.id));
@ -165,13 +165,13 @@ fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
} }
fn encode_variant_id(ebml_w: ebml::writer, vid: def_id) { fn encode_variant_id(ebml_w: ebml::Writer, vid: def_id) {
ebml_w.start_tag(tag_items_data_item_variant); ebml_w.start_tag(tag_items_data_item_variant);
ebml_w.writer.write(str::to_bytes(def_to_str(vid))); ebml_w.writer.write(str::to_bytes(def_to_str(vid)));
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) { fn write_type(ecx: @encode_ctxt, ebml_w: ebml::Writer, typ: ty::t) {
let ty_str_ctxt = let ty_str_ctxt =
@{diag: ecx.diag, @{diag: ecx.diag,
ds: def_to_str, ds: def_to_str,
@ -181,13 +181,13 @@ fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ); tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
} }
fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) { fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::Writer, typ: ty::t) {
ebml_w.start_tag(tag_items_data_item_type); ebml_w.start_tag(tag_items_data_item_type);
write_type(ecx, ebml_w, typ); write_type(ecx, ebml_w, typ);
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) { fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::Writer, id: node_id) {
ebml_w.start_tag(tag_items_data_item_symbol); ebml_w.start_tag(tag_items_data_item_symbol);
let sym = match ecx.item_symbols.find(id) { let sym = match ecx.item_symbols.find(id) {
Some(x) => x, Some(x) => x,
@ -200,25 +200,25 @@ fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) {
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_discriminant(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) { fn encode_discriminant(ecx: @encode_ctxt, ebml_w: ebml::Writer, id: node_id) {
ebml_w.start_tag(tag_items_data_item_symbol); ebml_w.start_tag(tag_items_data_item_symbol);
ebml_w.writer.write(str::to_bytes(ecx.discrim_symbols.get(id))); ebml_w.writer.write(str::to_bytes(ecx.discrim_symbols.get(id)));
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::writer, disr_val: int) { fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::Writer, disr_val: int) {
ebml_w.start_tag(tag_disr_val); ebml_w.start_tag(tag_disr_val);
ebml_w.writer.write(str::to_bytes(int::to_str(disr_val,10u))); ebml_w.writer.write(str::to_bytes(int::to_str(disr_val,10u)));
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_parent_item(ebml_w: ebml::writer, id: def_id) { fn encode_parent_item(ebml_w: ebml::Writer, id: def_id) {
ebml_w.start_tag(tag_items_data_parent_item); ebml_w.start_tag(tag_items_data_parent_item);
ebml_w.writer.write(str::to_bytes(def_to_str(id))); ebml_w.writer.write(str::to_bytes(def_to_str(id)));
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::Writer,
id: node_id, variants: ~[variant], id: node_id, variants: ~[variant],
path: ast_map::path, index: @mut ~[entry<int>], path: ast_map::path, index: @mut ~[entry<int>],
ty_params: ~[ty_param]) { ty_params: ~[ty_param]) {
@ -255,9 +255,9 @@ fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
} }
} }
fn encode_path(ecx: @encode_ctxt, ebml_w: ebml::writer, path: ast_map::path, fn encode_path(ecx: @encode_ctxt, ebml_w: ebml::Writer, path: ast_map::path,
name: ast_map::path_elt) { name: ast_map::path_elt) {
fn encode_path_elt(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_path_elt(ecx: @encode_ctxt, ebml_w: ebml::Writer,
elt: ast_map::path_elt) { elt: ast_map::path_elt) {
let (tag, name) = match elt { let (tag, name) = match elt {
ast_map::path_mod(name) => (tag_path_elt_mod, name), ast_map::path_mod(name) => (tag_path_elt_mod, name),
@ -274,7 +274,7 @@ fn encode_path(ecx: @encode_ctxt, ebml_w: ebml::writer, path: ast_map::path,
} }
} }
fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod, fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::Writer, md: _mod,
id: node_id, path: ast_map::path, name: ident) { id: node_id, path: ast_map::path, name: ident) {
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(id)); encode_def_id(ebml_w, local_def(id));
@ -332,7 +332,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_visibility(ebml_w: ebml::writer, visibility: visibility) { fn encode_visibility(ebml_w: ebml::Writer, visibility: visibility) {
encode_family(ebml_w, match visibility { encode_family(ebml_w, match visibility {
public => 'g', public => 'g',
private => 'j', private => 'j',
@ -340,7 +340,7 @@ fn encode_visibility(ebml_w: ebml::writer, visibility: visibility) {
}); });
} }
fn encode_self_type(ebml_w: ebml::writer, self_type: ast::self_ty_) { fn encode_self_type(ebml_w: ebml::Writer, self_type: ast::self_ty_) {
ebml_w.start_tag(tag_item_trait_method_self_ty); ebml_w.start_tag(tag_item_trait_method_self_ty);
// Encode the base self type. // Encode the base self type.
@ -373,7 +373,7 @@ fn encode_self_type(ebml_w: ebml::writer, self_type: ast::self_ty_) {
} }
/* Returns an index of items in this class */ /* Returns an index of items in this class */
fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::Writer,
id: node_id, path: ast_map::path, id: node_id, path: ast_map::path,
class_tps: ~[ty_param], class_tps: ~[ty_param],
fields: ~[@struct_field], fields: ~[@struct_field],
@ -429,7 +429,7 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
} }
// This is for encoding info for ctors and dtors // This is for encoding info for ctors and dtors
fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: ebml::Writer,
id: node_id, ident: ident, path: ast_map::path, id: node_id, ident: ident, path: ast_map::path,
item: Option<inlined_item>, tps: ~[ty_param]) { item: Option<inlined_item>, tps: ~[ty_param]) {
ebml_w.start_tag(tag_items_data_item); ebml_w.start_tag(tag_items_data_item);
@ -454,7 +454,7 @@ fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: ebml::writer,
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::Writer,
impl_path: ast_map::path, should_inline: bool, impl_path: ast_map::path, should_inline: bool,
parent_id: node_id, parent_id: node_id,
m: @method, all_tps: ~[ty_param]) { m: @method, all_tps: ~[ty_param]) {
@ -504,7 +504,7 @@ fn should_inline(attrs: ~[attribute]) -> bool {
} }
fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item, fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Writer, item: @item,
index: @mut ~[entry<int>], path: ast_map::path) { index: @mut ~[entry<int>], path: ast_map::path) {
let tcx = ecx.tcx; let tcx = ecx.tcx;
@ -516,7 +516,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
}; };
if !must_write && !reachable(ecx, item.id) { return; } if !must_write && !reachable(ecx, item.id) { return; }
fn add_to_index_(item: @item, ebml_w: ebml::writer, fn add_to_index_(item: @item, ebml_w: ebml::Writer,
index: @mut ~[entry<int>]) { index: @mut ~[entry<int>]) {
vec::push(*index, {val: item.id, pos: ebml_w.writer.tell()}); vec::push(*index, {val: item.id, pos: ebml_w.writer.tell()});
} }
@ -795,7 +795,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
} }
} }
fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::Writer,
nitem: @foreign_item, nitem: @foreign_item,
index: @mut ~[entry<int>], index: @mut ~[entry<int>],
path: ast_map::path, abi: foreign_abi) { path: ast_map::path, abi: foreign_abi) {
@ -829,7 +829,7 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::Writer,
crate: @crate) -> ~[entry<int>] { crate: @crate) -> ~[entry<int>] {
let index = @mut ~[]; let index = @mut ~[];
ebml_w.start_tag(tag_items_data); ebml_w.start_tag(tag_items_data);
@ -884,7 +884,7 @@ fn create_index<T: copy>(index: ~[entry<T>], hash_fn: fn@(T) -> uint) ->
return buckets_frozen; return buckets_frozen;
} }
fn encode_index<T>(ebml_w: ebml::writer, buckets: ~[@~[entry<T>]], fn encode_index<T>(ebml_w: ebml::Writer, buckets: ~[@~[entry<T>]],
write_fn: fn(io::Writer, T)) { write_fn: fn(io::Writer, T)) {
let writer = ebml_w.writer; let writer = ebml_w.writer;
ebml_w.start_tag(tag_index); ebml_w.start_tag(tag_index);
@ -919,7 +919,7 @@ fn write_int(writer: io::Writer, &&n: int) {
writer.write_be_u32(n as u32); writer.write_be_u32(n as u32);
} }
fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) { fn encode_meta_item(ebml_w: ebml::Writer, mi: meta_item) {
match mi.node { match mi.node {
meta_word(name) => { meta_word(name) => {
ebml_w.start_tag(tag_meta_item_word); ebml_w.start_tag(tag_meta_item_word);
@ -956,7 +956,7 @@ fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) {
} }
} }
fn encode_attributes(ebml_w: ebml::writer, attrs: ~[attribute]) { fn encode_attributes(ebml_w: ebml::Writer, attrs: ~[attribute]) {
ebml_w.start_tag(tag_attributes); ebml_w.start_tag(tag_attributes);
for attrs.each |attr| { for attrs.each |attr| {
ebml_w.start_tag(tag_attribute); ebml_w.start_tag(tag_attribute);
@ -1018,7 +1018,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
return attrs; return attrs;
} }
fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml::Writer,
cstore: cstore::cstore) { cstore: cstore::cstore) {
fn get_ordered_deps(ecx: @encode_ctxt, cstore: cstore::cstore) fn get_ordered_deps(ecx: @encode_ctxt, cstore: cstore::cstore)
@ -1064,7 +1064,7 @@ fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml::writer,
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: ebml::writer, fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: ebml::Writer,
dep: decoder::crate_dep) { dep: decoder::crate_dep) {
ebml_w.start_tag(tag_crate_dep); ebml_w.start_tag(tag_crate_dep);
ebml_w.start_tag(tag_crate_dep_name); ebml_w.start_tag(tag_crate_dep_name);
@ -1079,7 +1079,7 @@ fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: ebml::writer,
ebml_w.end_tag(); ebml_w.end_tag();
} }
fn encode_hash(ebml_w: ebml::writer, hash: ~str) { fn encode_hash(ebml_w: ebml::Writer, hash: ~str) {
ebml_w.start_tag(tag_crate_hash); ebml_w.start_tag(tag_crate_hash);
ebml_w.writer.write(str::to_bytes(hash)); ebml_w.writer.write(str::to_bytes(hash));
ebml_w.end_tag(); ebml_w.end_tag();
@ -1113,7 +1113,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
}); });
let buf_w = io::mem_buffer_writer(buf); let buf_w = io::mem_buffer_writer(buf);
let ebml_w = ebml::writer(buf_w); let ebml_w = ebml::Writer(buf_w);
encode_hash(ebml_w, ecx.link_meta.extras_hash); encode_hash(ebml_w, ecx.link_meta.extras_hash);

50
src/rustc/middle/astencode.rs
View File

@ -8,7 +8,7 @@ import syntax::ast_map;
import syntax::ast_util; import syntax::ast_util;
import syntax::codemap::span; import syntax::codemap::span;
import std::ebml; import std::ebml;
import std::ebml::writer; import std::ebml::Writer;
import std::ebml::get_doc; import std::ebml::get_doc;
import std::map::hashmap; import std::map::hashmap;
import std::serialization::serializer; import std::serialization::serializer;
@ -78,7 +78,7 @@ trait tr {
// Top-level methods. // Top-level methods.
fn encode_inlined_item(ecx: @e::encode_ctxt, fn encode_inlined_item(ecx: @e::encode_ctxt,
ebml_w: ebml::writer, ebml_w: ebml::Writer,
path: ast_map::path, path: ast_map::path,
ii: ast::inlined_item, ii: ast::inlined_item,
maps: maps) { maps: maps) {
@ -104,7 +104,7 @@ fn decode_inlined_item(cdata: cstore::crate_metadata,
tcx: ty::ctxt, tcx: ty::ctxt,
maps: maps, maps: maps,
path: ast_map::path, path: ast_map::path,
par_doc: ebml::doc) -> Option<ast::inlined_item> { par_doc: ebml::Doc) -> Option<ast::inlined_item> {
let dcx = @{cdata: cdata, tcx: tcx, maps: maps}; let dcx = @{cdata: cdata, tcx: tcx, maps: maps};
match par_doc.opt_child(c::tag_ast) { match par_doc.opt_child(c::tag_ast) {
None => None, None => None,
@ -222,7 +222,7 @@ impl<D: deserializer> D: def_id_deserializer_helpers {
// We also have to adjust the spans: for now we just insert a dummy span, // We also have to adjust the spans: for now we just insert a dummy span,
// but eventually we should add entries to the local codemap as required. // but eventually we should add entries to the local codemap as required.
fn encode_ast(ebml_w: ebml::writer, item: ast::inlined_item) { fn encode_ast(ebml_w: ebml::Writer, item: ast::inlined_item) {
do ebml_w.wr_tag(c::tag_tree as uint) { do ebml_w.wr_tag(c::tag_tree as uint) {
ast::serialize_inlined_item(ebml_w, item) ast::serialize_inlined_item(ebml_w, item)
} }
@ -282,7 +282,7 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
} }
} }
fn decode_ast(par_doc: ebml::doc) -> ast::inlined_item { fn decode_ast(par_doc: ebml::Doc) -> ast::inlined_item {
let chi_doc = par_doc[c::tag_tree as uint]; let chi_doc = par_doc[c::tag_tree as uint];
let d = ebml::ebml_deserializer(chi_doc); let d = ebml::ebml_deserializer(chi_doc);
ast::deserialize_inlined_item(d) ast::deserialize_inlined_item(d)
@ -336,11 +336,11 @@ fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
// ______________________________________________________________________ // ______________________________________________________________________
// Encoding and decoding of ast::def // Encoding and decoding of ast::def
fn encode_def(ebml_w: ebml::writer, def: ast::def) { fn encode_def(ebml_w: ebml::Writer, def: ast::def) {
ast::serialize_def(ebml_w, def) ast::serialize_def(ebml_w, def)
} }
fn decode_def(xcx: extended_decode_ctxt, doc: ebml::doc) -> ast::def { fn decode_def(xcx: extended_decode_ctxt, doc: ebml::Doc) -> ast::def {
let dsr = ebml::ebml_deserializer(doc); let dsr = ebml::ebml_deserializer(doc);
let def = ast::deserialize_def(dsr); let def = ast::deserialize_def(dsr);
def.tr(xcx) def.tr(xcx)
@ -388,7 +388,7 @@ impl ast::def: tr {
// ______________________________________________________________________ // ______________________________________________________________________
// Encoding and decoding of freevar information // Encoding and decoding of freevar information
fn encode_freevar_entry(ebml_w: ebml::writer, fv: freevar_entry) { fn encode_freevar_entry(ebml_w: ebml::Writer, fv: freevar_entry) {
serialize_freevar_entry(ebml_w, fv) serialize_freevar_entry(ebml_w, fv)
} }
@ -396,7 +396,7 @@ trait ebml_deserializer_helper {
fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry; fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry;
} }
impl ebml::ebml_deserializer: ebml_deserializer_helper { impl ebml::EbmlDeserializer: ebml_deserializer_helper {
fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry { fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry {
let fv = deserialize_freevar_entry(self); let fv = deserialize_freevar_entry(self);
fv.tr(xcx) fv.tr(xcx)
@ -416,7 +416,7 @@ trait read_method_map_entry_helper {
fn read_method_map_entry(xcx: extended_decode_ctxt) -> method_map_entry; fn read_method_map_entry(xcx: extended_decode_ctxt) -> method_map_entry;
} }
impl ebml::ebml_deserializer: read_method_map_entry_helper { impl ebml::EbmlDeserializer: read_method_map_entry_helper {
fn read_method_map_entry(xcx: extended_decode_ctxt) -> method_map_entry { fn read_method_map_entry(xcx: extended_decode_ctxt) -> method_map_entry {
let mme = deserialize_method_map_entry(self); let mme = deserialize_method_map_entry(self);
{derefs: mme.derefs, {derefs: mme.derefs,
@ -445,7 +445,7 @@ impl method_origin: tr {
// Encoding and decoding vtable_res // Encoding and decoding vtable_res
fn encode_vtable_res(ecx: @e::encode_ctxt, fn encode_vtable_res(ecx: @e::encode_ctxt,
ebml_w: ebml::writer, ebml_w: ebml::Writer,
dr: typeck::vtable_res) { dr: typeck::vtable_res) {
// can't autogenerate this code because automatic serialization of // can't autogenerate this code because automatic serialization of
// ty::t doesn't work, and there is no way (atm) to have // ty::t doesn't work, and there is no way (atm) to have
@ -457,7 +457,7 @@ fn encode_vtable_res(ecx: @e::encode_ctxt,
} }
fn encode_vtable_origin(ecx: @e::encode_ctxt, fn encode_vtable_origin(ecx: @e::encode_ctxt,
ebml_w: ebml::writer, ebml_w: ebml::Writer,
vtable_origin: typeck::vtable_origin) { vtable_origin: typeck::vtable_origin) {
do ebml_w.emit_enum(~"vtable_origin") { do ebml_w.emit_enum(~"vtable_origin") {
match vtable_origin { match vtable_origin {
@ -504,7 +504,7 @@ trait vtable_deserialization_helpers {
fn read_vtable_origin(xcx: extended_decode_ctxt) -> typeck::vtable_origin; fn read_vtable_origin(xcx: extended_decode_ctxt) -> typeck::vtable_origin;
} }
impl ebml::ebml_deserializer: vtable_deserialization_helpers { impl ebml::EbmlDeserializer: vtable_deserialization_helpers {
fn read_vtable_res(xcx: extended_decode_ctxt) -> typeck::vtable_res { fn read_vtable_res(xcx: extended_decode_ctxt) -> typeck::vtable_res {
@self.read_to_vec(|| self.read_vtable_origin(xcx) ) @self.read_to_vec(|| self.read_vtable_origin(xcx) )
} }
@ -579,7 +579,7 @@ trait ebml_writer_helpers {
fn emit_tpbt(ecx: @e::encode_ctxt, tpbt: ty::ty_param_bounds_and_ty); fn emit_tpbt(ecx: @e::encode_ctxt, tpbt: ty::ty_param_bounds_and_ty);
} }
impl ebml::writer: ebml_writer_helpers { impl ebml::Writer: ebml_writer_helpers {
fn emit_ty(ecx: @e::encode_ctxt, ty: ty::t) { fn emit_ty(ecx: @e::encode_ctxt, ty: ty::t) {
e::write_type(ecx, self, ty) e::write_type(ecx, self, ty)
} }
@ -618,7 +618,7 @@ trait write_tag_and_id {
fn id(id: ast::node_id); fn id(id: ast::node_id);
} }
impl ebml::writer: write_tag_and_id { impl ebml::Writer: write_tag_and_id {
fn tag(tag_id: c::astencode_tag, f: fn()) { fn tag(tag_id: c::astencode_tag, f: fn()) {
do self.wr_tag(tag_id as uint) { f() } do self.wr_tag(tag_id as uint) { f() }
} }
@ -630,7 +630,7 @@ impl ebml::writer: write_tag_and_id {
fn encode_side_tables_for_ii(ecx: @e::encode_ctxt, fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
maps: maps, maps: maps,
ebml_w: ebml::writer, ebml_w: ebml::Writer,
ii: ast::inlined_item) { ii: ast::inlined_item) {
do ebml_w.wr_tag(c::tag_table as uint) { do ebml_w.wr_tag(c::tag_table as uint) {
ast_util::visit_ids_for_inlined_item( ast_util::visit_ids_for_inlined_item(
@ -646,7 +646,7 @@ fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
fn encode_side_tables_for_id(ecx: @e::encode_ctxt, fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
maps: maps, maps: maps,
ebml_w: ebml::writer, ebml_w: ebml::Writer,
id: ast::node_id) { id: ast::node_id) {
let tcx = ecx.tcx; let tcx = ecx.tcx;
@ -771,12 +771,12 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
trait doc_decoder_helpers { trait doc_decoder_helpers {
fn as_int() -> int; fn as_int() -> int;
fn opt_child(tag: c::astencode_tag) -> Option<ebml::doc>; fn opt_child(tag: c::astencode_tag) -> Option<ebml::Doc>;
} }
impl ebml::doc: doc_decoder_helpers { impl ebml::Doc: doc_decoder_helpers {
fn as_int() -> int { ebml::doc_as_u64(self) as int } fn as_int() -> int { ebml::doc_as_u64(self) as int }
fn opt_child(tag: c::astencode_tag) -> Option<ebml::doc> { fn opt_child(tag: c::astencode_tag) -> Option<ebml::Doc> {
ebml::maybe_get_doc(self, tag as uint) ebml::maybe_get_doc(self, tag as uint)
} }
} }
@ -789,7 +789,7 @@ trait ebml_deserializer_decoder_helpers {
-> ty::ty_param_bounds_and_ty; -> ty::ty_param_bounds_and_ty;
} }
impl ebml::ebml_deserializer: ebml_deserializer_decoder_helpers { impl ebml::EbmlDeserializer: ebml_deserializer_decoder_helpers {
fn read_ty(xcx: extended_decode_ctxt) -> ty::t { fn read_ty(xcx: extended_decode_ctxt) -> ty::t {
// Note: regions types embed local node ids. In principle, we // Note: regions types embed local node ids. In principle, we
@ -831,7 +831,7 @@ impl ebml::ebml_deserializer: ebml_deserializer_decoder_helpers {
} }
fn decode_side_tables(xcx: extended_decode_ctxt, fn decode_side_tables(xcx: extended_decode_ctxt,
ast_doc: ebml::doc) { ast_doc: ebml::Doc) {
let dcx = xcx.dcx; let dcx = xcx.dcx;
let tbl_doc = ast_doc[c::tag_table as uint]; let tbl_doc = ast_doc[c::tag_table as uint];
for ebml::docs(tbl_doc) |tag, entry_doc| { for ebml::docs(tbl_doc) |tag, entry_doc| {
@ -901,14 +901,14 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
// Testing of astencode_gen // Testing of astencode_gen
#[cfg(test)] #[cfg(test)]
fn encode_item_ast(ebml_w: ebml::writer, item: @ast::item) { fn encode_item_ast(ebml_w: ebml::Writer, item: @ast::item) {
do ebml_w.wr_tag(c::tag_tree as uint) { do ebml_w.wr_tag(c::tag_tree as uint) {
ast::serialize_item(ebml_w, *item); ast::serialize_item(ebml_w, *item);
} }
} }
#[cfg(test)] #[cfg(test)]
fn decode_item_ast(par_doc: ebml::doc) -> @ast::item { fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
let chi_doc = par_doc[c::tag_tree as uint]; let chi_doc = par_doc[c::tag_tree as uint];
let d = ebml::ebml_deserializer(chi_doc); let d = ebml::ebml_deserializer(chi_doc);
@ast::deserialize_item(d) @ast::deserialize_item(d)
@ -937,7 +937,7 @@ fn mk_ctxt() -> fake_ext_ctxt {
#[cfg(test)] #[cfg(test)]
fn roundtrip(in_item: @ast::item) { fn roundtrip(in_item: @ast::item) {
let mbuf = io::mem_buffer(); let mbuf = io::mem_buffer();
let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf)); let ebml_w = ebml::Writer(io::mem_buffer_writer(mbuf));
encode_item_ast(ebml_w, in_item); encode_item_ast(ebml_w, in_item);
let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf)); let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
let out_item = decode_item_ast(ebml_doc); let out_item = decode_item_ast(ebml_doc);

4
src/rustdoc/config.rs
View File

@ -41,7 +41,7 @@ fn opt_output_style() -> ~str { ~"output-style" }
fn opt_pandoc_cmd() -> ~str { ~"pandoc-cmd" } fn opt_pandoc_cmd() -> ~str { ~"pandoc-cmd" }
fn opt_help() -> ~str { ~"h" } fn opt_help() -> ~str { ~"h" }
fn opts() -> ~[(getopts::opt, ~str)] { fn opts() -> ~[(getopts::Opt, ~str)] {
~[ ~[
(getopts::optopt(opt_output_dir()), (getopts::optopt(opt_output_dir()),
~"--output-dir <val> put documents here"), ~"--output-dir <val> put documents here"),
@ -119,7 +119,7 @@ fn parse_config_(
fn config_from_opts( fn config_from_opts(
input_crate: &Path, input_crate: &Path,
matches: getopts::matches, matches: getopts::Matches,
program_output: program_output program_output: program_output
) -> Result<config, ~str> { ) -> Result<config, ~str> {

2
src/test/bench/graph500-bfs.rs
View File

@ -11,7 +11,7 @@ import std::map;
import std::map::map; import std::map::map;
import std::map::hashmap; import std::map::hashmap;
import std::deque; import std::deque;
import std::deque::t; import std::deque::Deque;
import std::par; import std::par;
import io::WriterUtil; import io::WriterUtil;
import comm::*; import comm::*;

8
src/test/bench/shootout-binarytrees.rs
View File

@ -1,6 +1,6 @@
use std; use std;
import std::arena; import std::arena;
import methods = std::arena::arena; import methods = std::arena::Arena;
enum tree/& { nil, node(&tree, &tree, int), } enum tree/& { nil, node(&tree, &tree, int), }
@ -13,7 +13,7 @@ fn item_check(t: &tree) -> int {
} }
} }
fn bottom_up_tree(arena: &r/arena::arena, fn bottom_up_tree(arena: &r/arena::Arena,
item: int, item: int,
depth: int) -> &r/tree { depth: int) -> &r/tree {
if depth > 0 { if depth > 0 {
@ -43,7 +43,7 @@ fn main(args: ~[~str]) {
max_depth = n; max_depth = n;
} }
let stretch_arena = arena::arena(); let stretch_arena = arena::Arena();
let stretch_depth = max_depth + 1; let stretch_depth = max_depth + 1;
let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth); let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth);
@ -51,7 +51,7 @@ fn main(args: ~[~str]) {
stretch_depth, stretch_depth,
item_check(stretch_tree))); item_check(stretch_tree)));
let long_lived_arena = arena::arena(); let long_lived_arena = arena::Arena();
let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth); let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);
let mut depth = min_depth; let mut depth = min_depth;
while depth <= max_depth { while depth <= max_depth {

6
src/test/bench/sudoku.rs
View File

@ -50,7 +50,7 @@ fn solve_grid(g: grid_t) {
fn next_color(g: grid, row: u8, col: u8, start_color: u8) -> bool { fn next_color(g: grid, row: u8, col: u8, start_color: u8) -> bool {
if start_color < 10u8 { if start_color < 10u8 {
// colors not yet used // colors not yet used
let avail = bitv::bitv(10u, false); let avail = bitv::Bitv(10u, false);
for u8::range(start_color, 10u8) |color| { for u8::range(start_color, 10u8) |color| {
avail.set(color as uint, true); avail.set(color as uint, true);
} }
@ -71,8 +71,8 @@ fn solve_grid(g: grid_t) {
} }
// find colors available in neighbourhood of (row, col) // find colors available in neighbourhood of (row, col)
fn drop_colors(g: grid, avail: bitv::bitv, row: u8, col: u8) { fn drop_colors(g: grid, avail: bitv::Bitv, row: u8, col: u8) {
fn drop_color(g: grid, colors: bitv::bitv, row: u8, col: u8) { fn drop_color(g: grid, colors: bitv::Bitv, row: u8, col: u8) {
let color = g[row][col]; let color = g[row][col];
if color != 0u8 { colors.set(color as uint, false); } if color != 0u8 { colors.set(color as uint, false); }
} }

2
src/test/compile-fail/for-loop-decl.rs
View File

@ -6,7 +6,7 @@ import std::bitv;
type fn_info = {vars: hashmap<uint, var_info>}; type fn_info = {vars: hashmap<uint, var_info>};
type var_info = {a: uint, b: uint}; type var_info = {a: uint, b: uint};
fn bitv_to_str(enclosing: fn_info, v: ~bitv::bitv) -> str { fn bitv_to_str(enclosing: fn_info, v: ~bitv::Bitv) -> str {
let s = ""; let s = "";
// error is that the value type in the hash map is var_info, not a box // error is that the value type in the hash map is var_info, not a box

6
src/test/run-pass/auto_serialize.rs
View File

@ -9,8 +9,8 @@ import std::serialization::{serialize_uint, deserialize_uint};
fn test_ser_and_deser<A>(a1: A, fn test_ser_and_deser<A>(a1: A,
expected: ~str, expected: ~str,
ebml_ser_fn: fn(ebml::writer, A), ebml_ser_fn: fn(ebml::Writer, A),
ebml_deser_fn: fn(ebml::ebml_deserializer) -> A, ebml_deser_fn: fn(ebml::EbmlDeserializer) -> A,
io_ser_fn: fn(io::Writer, A)) { io_ser_fn: fn(io::Writer, A)) {
// check the pretty printer: // check the pretty printer:
@ -21,7 +21,7 @@ fn test_ser_and_deser<A>(a1: A,
// check the EBML serializer: // check the EBML serializer:
let buf = io::mem_buffer(); let buf = io::mem_buffer();
let w = ebml::writer(buf as io::Writer); let w = ebml::Writer(buf as io::Writer);
ebml_ser_fn(w, a1); ebml_ser_fn(w, a1);
let d = ebml::doc(@io::mem_buffer_buf(buf)); let d = ebml::doc(@io::mem_buffer_buf(buf));
let a2 = ebml_deser_fn(ebml::ebml_deserializer(d)); let a2 = ebml_deser_fn(ebml::ebml_deserializer(d));

6
src/test/run-pass/bitv-perf-test.rs
View File

@ -2,12 +2,12 @@ use std;
import std::bitv::*; import std::bitv::*;
fn bitv_test() -> bool { fn bitv_test() -> bool {
let v1 = ~bitv(31, false); let v1 = ~Bitv(31, false);
let v2 = ~bitv(31, true); let v2 = ~Bitv(31, true);
v1.union(v2); v1.union(v2);
true true
} }
fn main() { fn main() {
do iter::repeat(10000) || {bitv_test()}; do iter::repeat(10000) || {bitv_test()};
} }

6
src/test/run-pass/issue-2101.rs
View File

@ -1,16 +1,16 @@
// xfail-test // xfail-test
use std; use std;
import std::arena; import std::arena;
import std::arena::arena; import std::arena::Arena;
enum hold { s(str) } enum hold { s(str) }
fn init(ar: &a.arena::arena, str: str) -> &a.hold { fn init(ar: &a.arena::Arena, str: str) -> &a.hold {
new(*ar) s(str) new(*ar) s(str)
} }
fn main(args: ~[str]) { fn main(args: ~[str]) {
let ar = arena::arena(); let ar = arena::Arena();
let leak = init(&ar, args[0]); let leak = init(&ar, args[0]);
match *leak { match *leak {
s(astr) { s(astr) {

2
src/test/run-pass/issue-2383.rs
View File

@ -1,6 +1,6 @@
use std; use std;
import std::deque; import std::deque;
import std::deque::t; import std::deque::Deque;
fn main() { fn main() {
let Q = deque::create(); let Q = deque::create();

12
src/test/run-pass/issue-2804.rs
View File

@ -9,11 +9,11 @@ enum object
int_value(i64), int_value(i64),
} }
fn lookup(table: std::map::hashmap<~str, std::json::json>, key: ~str, default: ~str) -> ~str fn lookup(table: std::map::hashmap<~str, std::json::Json>, key: ~str, default: ~str) -> ~str
{ {
match table.find(key) match table.find(key)
{ {
option::Some(std::json::string(s)) => option::Some(std::json::String(s)) =>
{ {
*s *s
} }
@ -29,11 +29,11 @@ fn lookup(table: std::map::hashmap<~str, std::json::json>, key: ~str, default: ~
} }
} }
fn add_interface(store: int, managed_ip: ~str, data: std::json::json) -> (~str, object) fn add_interface(store: int, managed_ip: ~str, data: std::json::Json) -> (~str, object)
{ {
match data match data
{ {
std::json::dict(interface) => std::json::Dict(interface) =>
{ {
let name = lookup(interface, ~"ifDescr", ~""); let name = lookup(interface, ~"ifDescr", ~"");
let label = fmt!("%s-%s", managed_ip, name); let label = fmt!("%s-%s", managed_ip, name);
@ -48,11 +48,11 @@ fn add_interface(store: int, managed_ip: ~str, data: std::json::json) -> (~str,
} }
} }
fn add_interfaces(store: int, managed_ip: ~str, device: std::map::hashmap<~str, std::json::json>) -> ~[(~str, object)] fn add_interfaces(store: int, managed_ip: ~str, device: std::map::hashmap<~str, std::json::Json>) -> ~[(~str, object)]
{ {
match device[~"interfaces"] match device[~"interfaces"]
{ {
std::json::list(interfaces) => std::json::List(interfaces) =>
{ {
do vec::map(*interfaces) |interface| { do vec::map(*interfaces) |interface| {
add_interface(store, managed_ip, interface) add_interface(store, managed_ip, interface)

4
src/test/run-pass/placement-new-arena.rs
View File

@ -1,8 +1,8 @@
use std; use std;
import std::arena::arena; import std::arena;
fn main() { fn main() {
let p = &arena(); let p = &arena::Arena();
let x = p.alloc(|| 4u); let x = p.alloc(|| 4u);
io::print(fmt!("%u", *x)); io::print(fmt!("%u", *x));
assert *x == 4u; assert *x == 4u;

6
src/test/run-pass/regions-mock-trans-impls.rs
View File

@ -1,13 +1,13 @@
use std; use std;
import libc, sys, unsafe; import libc, sys, unsafe;
import std::arena::arena; import std::arena::Arena;
type bcx = { type bcx = {
fcx: &fcx fcx: &fcx
}; };
type fcx = { type fcx = {
arena: &arena, arena: &Arena,
ccx: &ccx ccx: &ccx
}; };
@ -25,7 +25,7 @@ fn g(fcx : &fcx) {
} }
fn f(ccx : &ccx) { fn f(ccx : &ccx) {
let a = arena(); let a = Arena();
let fcx = &{ arena: &a, ccx: ccx }; let fcx = &{ arena: &a, ccx: ccx };
return g(fcx); return g(fcx);
} }