enum mode { system_mode, user_mode, local_mode }
-fn opts() -> ~[getopts::opt] {
+fn opts() -> ~[getopts::Opt] {
~[optflag(~"g"), optflag(~"G"), optflag(~"test"),
optflag(~"h"), optflag(~"help")]
}
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) {
fail fmt!("'%s' is an invalid source name", name);
}
match j {
- json::dict(j) => {
+ json::Dict(j) => {
let mut url = match j.find(~"url") {
- Some(json::string(u)) => *u,
+ Some(json::String(u)) => *u,
_ => fail ~"needed 'url' field in source"
};
let method = match j.find(~"method") {
- Some(json::string(u)) => *u,
+ Some(json::String(u)) => *u,
_ => assume_source_method(url)
};
let key = match j.find(~"key") {
- Some(json::string(u)) => Some(*u),
+ Some(json::String(u)) => Some(*u),
_ => None
};
let keyfp = match j.find(~"keyfp") {
- Some(json::string(u)) => Some(*u),
+ Some(json::String(u)) => Some(*u),
_ => None
};
if method == ~"file" {
if !os::path_exists(filename) { return; }
let c = io::read_whole_file_str(filename);
match json::from_str(result::get(c)) {
- Ok(json::dict(j)) => {
+ Ok(json::Dict(j)) => {
for j.each |k, v| {
sources.insert(k, parse_source(k, v));
debug!("source: %s", k);
}
}
-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") {
- Some(json::string(n)) => {
+ Some(json::String(n)) => {
if !valid_pkg_name(*n) {
warn(~"malformed source json: "
+ src.name + ~", '" + *n + ~"'"+
};
let uuid = match p.find(~"uuid") {
- Some(json::string(n)) => {
+ Some(json::String(n)) => {
if !is_uuid(*n) {
warn(~"malformed source json: "
+ src.name + ~", '" + *n + ~"'"+
};
let url = match p.find(~"url") {
- Some(json::string(n)) => *n,
+ Some(json::String(n)) => *n,
_ => {
warn(~"malformed source json: " + src.name + ~" (missing url)");
return;
};
let method = match p.find(~"method") {
- Some(json::string(n)) => *n,
+ Some(json::String(n)) => *n,
_ => {
warn(~"malformed source json: "
+ src.name + ~" (missing method)");
};
let reference = match p.find(~"ref") {
- Some(json::string(n)) => Some(*n),
+ Some(json::String(n)) => Some(*n),
_ => None
};
let mut tags = ~[];
match p.find(~"tags") {
- Some(json::list(js)) => {
+ Some(json::List(js)) => {
for (*js).each |j| {
match j {
- json::string(j) => vec::grow(tags, 1u, *j),
+ json::String(j) => vec::grow(tags, 1u, *j),
_ => ()
}
}
}
let description = match p.find(~"description") {
- Some(json::string(n)) => *n,
+ Some(json::String(n)) => *n,
_ => {
warn(~"malformed source json: " + src.name
+ ~" (missing description)");
if !os::path_exists(&srcfile) { return; }
let srcstr = io::read_whole_file_str(&srcfile);
match json::from_str(result::get(srcstr)) {
- Ok(json::dict(s)) => {
- let o = parse_source(src.name, json::dict(s));
+ Ok(json::Dict(s)) => {
+ let o = parse_source(src.name, json::Dict(s));
src.key = o.key;
src.keyfp = o.keyfp;
if !os::path_exists(&pkgfile) { return; }
let pkgstr = io::read_whole_file_str(&pkgfile);
match json::from_str(result::get(pkgstr)) {
- Ok(json::list(js)) => {
+ Ok(json::List(js)) => {
for (*js).each |j| {
match j {
- json::dict(p) => {
+ json::Dict(p) => {
load_one_source_package(src, p);
}
_ => {
need_dir(&c.root);
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) {
copy_warn(&out, &c.root.push("cache.json.old"));
match io::buffered_file_writer(&out) {
result::Ok(writer) => {
let hash = map::str_hash();
- let root = json::dict(hash);
+ let root = json::Dict(hash);
for c.sources.each |k, v| {
let chash = map::str_hash();
- let child = json::dict(chash);
+ let child = json::Dict(chash);
- chash.insert(~"url", json::string(@v.url));
- chash.insert(~"method", json::string(@v.method));
+ chash.insert(~"url", json::String(@v.url));
+ chash.insert(~"method", json::String(@v.method));
match copy v.key {
Some(key) => {
- chash.insert(~"key", json::string(@key));
+ chash.insert(~"key", json::String(@key));
}
_ => ()
}
match copy v.keyfp {
Some(keyfp) => {
- chash.insert(~"keyfp", json::string(@keyfp));
+ chash.insert(~"keyfp", json::String(@keyfp));
}
_ => ()
}
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))
}
// Dynamic arenas.
+#[warn(non_camel_case_types)];
// Arenas are used to quickly allocate objects that share a
// lifetime. The arena uses ~[u8] vectors as a backing store to
// overhead when initializing plain-old-data and means we don't need
// to waste time running the destructors of POD.
-export arena, arena_with_size;
+export Arena, arena_with_size;
import list;
import list::{list, cons, nil};
// The way arena uses arrays is really deeply awful. The arrays are
// allocated, and have capacities reserved, but the fill for the array
// 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
// microoptimization, to avoid needing to case on the list to
// access the head.
- priv mut head: chunk;
- priv mut pod_head: chunk;
- priv mut chunks: @list<chunk>;
+ priv mut head: Chunk;
+ priv mut pod_head: Chunk;
+ priv mut chunks: @list<Chunk>;
drop {
unsafe {
destroy_chunk(self.head);
}
}
-fn chunk(size: uint, is_pod: bool) -> chunk {
+fn chunk(size: uint, is_pod: bool) -> Chunk {
let mut v = @[];
unsafe { at_vec::unsafe::reserve(v, size); }
{ data: v, mut fill: 0u, is_pod: is_pod }
}
-fn arena_with_size(initial_size: uint) -> arena {
- return arena {mut head: chunk(initial_size, false),
+fn arena_with_size(initial_size: uint) -> Arena {
+ return Arena {mut head: chunk(initial_size, false),
mut pod_head: chunk(initial_size, true),
mut chunks: @nil};
}
-fn arena() -> arena {
+fn Arena() -> Arena {
arena_with_size(32u)
}
// Walk down a chunk, running the destructors for any objects stored
// in it.
-unsafe fn destroy_chunk(chunk: chunk) {
+unsafe fn destroy_chunk(chunk: Chunk) {
let mut idx = 0;
let buf = vec::unsafe::to_ptr_slice(chunk.data);
let fill = chunk.fill;
}
// The duplication between the POD and non-POD functions is annoying.
-impl &arena {
+impl &Arena {
// Functions for the POD part of the arena
fn alloc_pod_grow(n_bytes: uint, align: uint) -> *u8 {
// Allocate a new chunk.
#[test]
fn test_arena_destructors() {
- let arena = arena::arena();
+ let arena = arena::Arena();
for uint::range(0, 10) |i| {
// Arena allocate something with drop glue to make sure it
// doesn't leak.
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_arena_destructors_fail() {
- let arena = arena::arena();
+ let arena = arena::Arena();
// Put some stuff in the arena.
for uint::range(0, 10) |i| {
// Arena allocate something with drop glue to make sure it
+#[deny(non_camel_case_types)];
import io::Reader;
-trait to_base64 {
+trait ToBase64 {
fn to_base64() -> ~str;
}
-impl ~[u8]: to_base64 {
+impl ~[u8]: ToBase64 {
fn to_base64() -> ~str {
let chars = str::chars(
~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
}
}
-impl ~str: to_base64 {
+impl ~str: ToBase64 {
fn to_base64() -> ~str {
str::to_bytes(self).to_base64()
}
}
-trait from_base64 {
+trait FromBase64 {
fn from_base64() -> ~[u8];
}
-impl ~[u8]: from_base64 {
+impl ~[u8]: FromBase64 {
fn from_base64() -> ~[u8] {
if self.len() % 4u != 0u { fail ~"invalid base64 length"; }
}
}
-impl ~str: from_base64 {
+impl ~str: FromBase64 {
fn from_base64() -> ~[u8] {
str::to_bytes(self).from_base64()
}
+#[deny(non_camel_case_types)];
import vec::{to_mut, from_elem};
-export bitv;
+export Bitv;
export union;
+export Union;
export intersect;
+export Intersect;
export assign;
+export Assign;
+export difference;
+export Difference;
export clone;
export get;
export equal;
export clear;
export set_all;
export invert;
-export difference;
export set;
export is_true;
export is_false;
(1 << nbits) - 1
}
-struct small_bitv {
+struct SmallBitv {
/// only the lowest nbits of this value are used. the rest is undefined.
let mut bits: u32;
new(bits: u32) { self.bits = bits; }
}
}
#[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)
}
#[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)
}
#[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)
}
#[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)
}
#[inline(always)]
}
}
#[inline(always)]
- fn equals(b: &small_bitv, nbits: uint) -> bool {
+ fn equals(b: &SmallBitv, nbits: uint) -> bool {
let mask = small_mask(nbits);
mask & self.bits == mask & b.bits
}
}
}
-struct big_bitv {
+struct BigBitv {
// only mut b/c of clone and lack of other constructor
let mut storage: ~[mut uint];
new(-storage: ~[mut uint]) {
}
priv {
#[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 {
let len = b.storage.len();
assert (self.storage.len() == len);
#[inline(always)]
fn invert() { for self.each_storage() |w| { w = !w } }
#[inline(always)]
- fn union(b: &big_bitv, nbits: uint) -> bool {
+ fn union(b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, lor)
}
#[inline(always)]
- fn intersect(b: &big_bitv, nbits: uint) -> bool {
+ fn intersect(b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, land)
}
#[inline(always)]
- fn become(b: &big_bitv, nbits: uint) -> bool {
+ fn become(b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, right)
}
#[inline(always)]
- fn difference(b: &big_bitv, nbits: uint) -> bool {
+ fn difference(b: &BigBitv, nbits: uint) -> bool {
self.invert();
let b = self.intersect(b, nbits);
self.invert();
else { self.storage[w] & !flag };
}
#[inline(always)]
- fn equals(b: &big_bitv, nbits: uint) -> bool {
+ fn equals(b: &BigBitv, nbits: uint) -> bool {
let len = b.storage.len();
for uint::iterate(0, len) |i| {
let mask = big_mask(nbits, i);
}
}
-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
-struct bitv {
- let rep: a_bitv;
+struct Bitv {
+ let rep: BitvVariant;
let nbits: uint;
new(nbits: uint, init: bool) {
self.nbits = nbits;
if nbits <= 32 {
- self.rep = small(~small_bitv(if init {!0} else {0}));
+ self.rep = Small(~SmallBitv(if init {!0} else {0}));
}
else {
let nelems = nbits/uint_bits +
if nbits % uint_bits == 0 {0} else {1};
let elem = if init {!0} else {0};
let s = to_mut(from_elem(nelems, elem));
- self.rep = big(~big_bitv(s));
+ self.rep = Big(~BigBitv(s));
};
}
different sizes";
}
#[inline(always)]
- fn do_op(op: op, other: &bitv) -> bool {
+ fn do_op(op: Op, other: &Bitv) -> bool {
if self.nbits != other.nbits {
self.die();
}
match self.rep {
- small(s) => match other.rep {
- small(s1) => match op {
- union => s.union(s1, self.nbits),
- intersect => s.intersect(s1, self.nbits),
- assign => s.become(s1, self.nbits),
- difference => s.difference(s1, self.nbits)
+ Small(s) => match other.rep {
+ Small(s1) => match op {
+ Union => s.union(s1, self.nbits),
+ Intersect => s.intersect(s1, self.nbits),
+ Assign => s.become(s1, self.nbits),
+ Difference => s.difference(s1, self.nbits)
},
- big(_) => self.die()
+ Big(_) => self.die()
},
- big(s) => match other.rep {
- small(_) => self.die(),
- big(s1) => match op {
- union => s.union(s1, self.nbits),
- intersect => s.intersect(s1, self.nbits),
- assign => s.become(s1, self.nbits),
- difference => s.difference(s1, self.nbits)
+ Big(s) => match other.rep {
+ Small(_) => self.die(),
+ Big(s1) => match op {
+ Union => s.union(s1, self.nbits),
+ Intersect => s.intersect(s1, self.nbits),
+ Assign => s.become(s1, self.nbits),
+ Difference => s.difference(s1, self.nbits)
}
}
}
* the same length. Returns 'true' if `self` changed.
*/
#[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
* the same length. Returns 'true' if `self` changed.
*/
#[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`
* changed
*/
#[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
#[inline(always)]
- fn clone() -> ~bitv {
+ fn clone() -> ~Bitv {
~match self.rep {
- small(b) => {
- bitv{nbits: self.nbits, rep: small(~small_bitv{bits: b.bits})}
+ Small(b) => {
+ 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 len = st.len();
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})}
}
}
}
pure fn get(i: uint) -> bool {
assert (i < self.nbits);
match self.rep {
- big(b) => b.get(i),
- small(s) => s.get(i)
+ Big(b) => b.get(i),
+ Small(s) => s.get(i)
}
}
fn set(i: uint, x: bool) {
assert (i < self.nbits);
match self.rep {
- big(b) => b.set(i, x),
- small(s) => s.set(i, x)
+ Big(b) => b.set(i, x),
+ Small(s) => s.set(i, x)
}
}
* contain identical elements.
*/
#[inline(always)]
- fn equal(v1: bitv) -> bool {
+ fn equal(v1: Bitv) -> bool {
if self.nbits != v1.nbits { return false; }
match self.rep {
- small(b) => match v1.rep {
- small(b1) => b.equals(b1, self.nbits),
+ Small(b) => match v1.rep {
+ Small(b1) => b.equals(b1, self.nbits),
_ => false
},
- big(s) => match v1.rep {
- big(s1) => s.equals(s1, self.nbits),
- small(_) => return false
+ Big(s) => match v1.rep {
+ Big(s1) => s.equals(s1, self.nbits),
+ Small(_) => return false
}
}
}
#[inline(always)]
fn clear() {
match self.rep {
- small(b) => b.clear(),
- big(s) => for s.each_storage() |w| { w = 0u }
+ Small(b) => b.clear(),
+ Big(s) => for s.each_storage() |w| { w = 0u }
}
}
#[inline(always)]
fn set_all() {
match self.rep {
- small(b) => b.set_all(),
- big(s) => for s.each_storage() |w| { w = !0u } }
+ Small(b) => b.set_all(),
+ Big(s) => for s.each_storage() |w| { w = !0u } }
}
/// Invert all bits
#[inline(always)]
fn invert() {
match self.rep {
- small(b) => b.invert(),
- big(s) => for s.each_storage() |w| { w = !w } }
+ Small(b) => b.invert(),
+ Big(s) => for s.each_storage() |w| { w = !w } }
}
/**
* Returns `true` if `v0` was changed.
*/
#[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
#[inline(always)]
fn is_true() -> bool {
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; } }
true
fn is_false() -> bool {
match self.rep {
- small(b) => b.is_false(self.nbits),
- big(_) => {
+ Small(b) => b.is_false(self.nbits),
+ Big(_) => {
for self.each() |i| { if i { return false; } }
true
}
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 {
self.get(i)
}
mod tests {
#[test]
fn test_to_str() {
- let zerolen = bitv(0u, false);
+ let zerolen = Bitv(0u, false);
assert zerolen.to_str() == ~"";
- let eightbits = bitv(8u, false);
+ let eightbits = Bitv(8u, false);
assert eightbits.to_str() == ~"00000000";
}
fn test_0_elements() {
let mut act;
let mut exp;
- act = bitv(0u, false);
+ act = Bitv(0u, false);
exp = vec::from_elem::<uint>(0u, 0u);
assert act.eq_vec(exp);
}
#[test]
fn test_1_element() {
let mut act;
- act = bitv(1u, false);
+ act = Bitv(1u, false);
assert act.eq_vec(~[0u]);
- act = bitv(1u, true);
+ act = Bitv(1u, true);
assert act.eq_vec(~[1u]);
}
#[test]
fn test_2_elements() {
- let b = bitv::bitv(2, false);
+ let b = bitv::Bitv(2, false);
b.set(0, true);
b.set(1, false);
assert b.to_str() == ~"10";
let mut act;
// all 0
- act = bitv(10u, false);
+ act = Bitv(10u, false);
assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
// all 1
- act = bitv(10u, true);
+ act = Bitv(10u, true);
assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
// mixed
- act = bitv(10u, false);
+ act = Bitv(10u, false);
act.set(0u, true);
act.set(1u, true);
act.set(2u, true);
assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]));
// mixed
- act = bitv(10u, false);
+ act = Bitv(10u, false);
act.set(5u, true);
act.set(6u, true);
act.set(7u, true);
assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]));
// mixed
- act = bitv(10u, false);
+ act = Bitv(10u, false);
act.set(0u, true);
act.set(3u, true);
act.set(6u, true);
let mut act;
// all 0
- act = bitv(31u, false);
+ act = Bitv(31u, false);
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]));
// all 1
- act = bitv(31u, true);
+ act = Bitv(31u, true);
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]));
// mixed
- act = bitv(31u, false);
+ act = Bitv(31u, false);
act.set(0u, true);
act.set(1u, true);
act.set(2u, true);
0u, 0u, 0u, 0u, 0u]));
// mixed
- act = bitv(31u, false);
+ act = Bitv(31u, false);
act.set(16u, true);
act.set(17u, true);
act.set(18u, true);
0u, 0u, 0u, 0u, 0u]));
// mixed
- act = bitv(31u, false);
+ act = Bitv(31u, false);
act.set(24u, true);
act.set(25u, true);
act.set(26u, true);
1u, 1u, 1u, 1u, 1u]));
// mixed
- act = bitv(31u, false);
+ act = Bitv(31u, false);
act.set(3u, true);
act.set(17u, true);
act.set(30u, true);
let mut act;
// all 0
- act = bitv(32u, false);
+ act = Bitv(32u, false);
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]));
// all 1
- act = bitv(32u, true);
+ act = Bitv(32u, true);
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]));
// mixed
- act = bitv(32u, false);
+ act = Bitv(32u, false);
act.set(0u, true);
act.set(1u, true);
act.set(2u, true);
0u, 0u, 0u, 0u, 0u, 0u]));
// mixed
- act = bitv(32u, false);
+ act = Bitv(32u, false);
act.set(16u, true);
act.set(17u, true);
act.set(18u, true);
0u, 0u, 0u, 0u, 0u, 0u]));
// mixed
- act = bitv(32u, false);
+ act = Bitv(32u, false);
act.set(24u, true);
act.set(25u, true);
act.set(26u, true);
1u, 1u, 1u, 1u, 1u, 1u]));
// mixed
- act = bitv(32u, false);
+ act = Bitv(32u, false);
act.set(3u, true);
act.set(17u, true);
act.set(30u, true);
let mut act;
// all 0
- act = bitv(33u, false);
+ act = Bitv(33u, false);
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]));
// all 1
- act = bitv(33u, true);
+ act = Bitv(33u, true);
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]));
// mixed
- act = bitv(33u, false);
+ act = Bitv(33u, false);
act.set(0u, true);
act.set(1u, true);
act.set(2u, true);
0u, 0u, 0u, 0u, 0u, 0u, 0u]));
// mixed
- act = bitv(33u, false);
+ act = Bitv(33u, false);
act.set(16u, true);
act.set(17u, true);
act.set(18u, true);
0u, 0u, 0u, 0u, 0u, 0u, 0u]));
// mixed
- act = bitv(33u, false);
+ act = Bitv(33u, false);
act.set(24u, true);
act.set(25u, true);
act.set(26u, true);
1u, 1u, 1u, 1u, 1u, 1u, 0u]));
// mixed
- act = bitv(33u, false);
+ act = Bitv(33u, false);
act.set(3u, true);
act.set(17u, true);
act.set(30u, true);
#[test]
fn test_equal_differing_sizes() {
- let v0 = bitv(10u, false);
- let v1 = bitv(11u, false);
+ let v0 = Bitv(10u, false);
+ let v1 = Bitv(11u, false);
assert !v0.equal(v1);
}
#[test]
fn test_equal_greatly_differing_sizes() {
- let v0 = bitv(10u, false);
- let v1 = bitv(110u, false);
+ let v0 = Bitv(10u, false);
+ let v1 = Bitv(110u, false);
assert !v0.equal(v1);
}
#[test]
fn test_equal_sneaky_small() {
- let a = bitv::bitv(1, false);
+ let a = bitv::Bitv(1, false);
a.set(0, true);
- let b = bitv::bitv(1, true);
+ let b = bitv::Bitv(1, true);
b.set(0, true);
assert a.equal(b);
#[test]
fn test_equal_sneaky_big() {
- let a = bitv::bitv(100, false);
+ let a = bitv::Bitv(100, false);
for uint::range(0, 100) |i| {
a.set(i, true);
}
- let b = bitv::bitv(100, true);
+ let b = bitv::Bitv(100, true);
for uint::range(0, 100) |i| {
b.set(i, true);
}
+#[deny(non_camel_case_types)];
/*!
* Library to interface with chunks of memory allocated in C.
*
* 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.
* 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
* 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
* still held if needed.
*/
-export c_vec;
+export CVec;
export c_vec, c_vec_with_dtor;
export get, set;
export len;
* Wrapped in a enum for opacity; FIXME #818 when it is possible to have
* truly opaque types, this should be revisited.
*/
-enum c_vec<T> {
- c_vec_({ base: *mut T, len: uint, rsrc: @dtor_res})
+enum CVec<T> {
+ CVecCtor({ base: *mut T, len: uint, rsrc: @DtorRes})
}
-struct dtor_res {
+struct DtorRes {
let dtor: Option<fn@()>;
new(dtor: Option<fn@()>) { self.dtor = dtor; }
drop {
*/
/**
- * Create a `c_vec` from a foreign buffer with a given length.
+ * Create a `CVec` from a foreign buffer with a given length.
*
* # Arguments
*
* * base - A foreign pointer to a buffer
* * len - The number of elements in the buffer
*/
-unsafe fn c_vec<T>(base: *mut T, len: uint) -> c_vec<T> {
- return c_vec_({
+unsafe fn c_vec<T>(base: *mut T, len: uint) -> CVec<T> {
+ return CVecCtor({
base: base,
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.
*
* # Arguments
* for freeing the buffer, etc.
*/
unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: fn@())
- -> c_vec<T> {
- return c_vec_({
+ -> CVec<T> {
+ return CVecCtor({
base: base,
len: len,
- rsrc: @dtor_res(option::Some(dtor))
+ rsrc: @DtorRes(option::Some(dtor))
});
}
*
* 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);
return unsafe { *ptr::mut_offset((*t).base, ofs) };
}
*
* 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);
unsafe { *ptr::mut_offset((*t).base, ofs) = v };
}
*/
/// Returns the length of the vector
-fn len<T>(t: c_vec<T>) -> uint {
+fn len<T>(t: CVec<T>) -> uint {
return (*t).len;
}
/// 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;
}
mod tests {
import libc::*;
- fn malloc(n: size_t) -> c_vec<u8> {
+ fn malloc(n: size_t) -> CVec<u8> {
let mem = libc::malloc(n);
assert mem as int != 0;
+#[deny(non_camel_case_types)];
/// Additional general-purpose comparison functionality.
const fuzzy_epsilon: float = 1.0e-6;
-trait fuzzy_eq {
+trait FuzzyEq {
pure fn fuzzy_eq(&&other: self) -> bool;
}
-impl float: fuzzy_eq {
+impl float: FuzzyEq {
pure fn fuzzy_eq(&&other: float) -> bool {
return float::abs(self - other) < fuzzy_epsilon;
}
}
-impl f32: fuzzy_eq {
+impl f32: FuzzyEq {
pure fn fuzzy_eq(&&other: f32) -> bool {
return f32::abs(self - other) < (fuzzy_epsilon as f32);
}
}
-impl f64: fuzzy_eq {
+impl f64: FuzzyEq {
pure fn fuzzy_eq(&&other: f64) -> bool {
return f64::abs(self - other) < (fuzzy_epsilon as f64);
}
+#[deny(non_camel_case_types)];
//! Unsafe debugging functions for inspecting values.
import unsafe::reinterpret_cast;
+#[deny(non_camel_case_types)];
+
//! A deque. Untested as of yet. Likely buggy
import option::{Some, None};
import dvec::DVec;
-trait t<T> {
+trait Deque<T> {
fn size() -> uint;
fn add_front(T);
fn add_back(T);
// FIXME (#2343) eventually, a proper datatype plus an exported impl would
// be preferrable.
-fn create<T: copy>() -> t<T> {
- type cell<T> = Option<T>;
+fn create<T: copy>() -> Deque<T> {
+ type Cell<T> = Option<T>;
let initial_capacity: uint = 32u; // 2^5
/**
* Grow is only called on full elts, so nelts is also len(elts), unlike
* elsewhere.
*/
- fn grow<T: copy>(nelts: uint, lo: uint, -elts: ~[mut cell<T>]) ->
- ~[mut cell<T>] {
+ fn grow<T: copy>(nelts: uint, lo: uint, -elts: ~[mut Cell<T>]) ->
+ ~[mut Cell<T>] {
assert (nelts == vec::len(elts));
let mut rv = ~[mut];
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 }
}
- type repr<T> = {mut nelts: uint,
+ type Repr<T> = {mut nelts: uint,
mut lo: 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 add_front(t: T) {
let oldlo: uint = self.lo;
}
}
- let repr: repr<T> = {
+ let repr: Repr<T> = {
mut nelts: 0u,
mut lo: 0u,
mut hi: 0u,
vec::to_mut(
vec::from_elem(initial_capacity, None)))
};
- repr as t::<T>
+ repr as Deque::<T>
}
#[cfg(test)]
mod tests {
#[test]
fn test_simple() {
- let d: deque::t<int> = deque::create::<int>();
+ let d: deque::Deque<int> = deque::create::<int>();
assert (d.size() == 0u);
d.add_front(17);
d.add_front(42);
}
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);
deq.add_front(a);
deq.add_front(b);
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>(
- 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);
deq.add_front(a);
deq.add_front(b);
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> {
- onepar(int), twopar(int, int), threepar(int, int, int),
+ enum Taggypar<T> {
+ 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]
fn test() {
fn inteq(&&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 {
- one(a1) => match b {
- one(b1) => return a1 == b1,
+ One(a1) => match b {
+ One(b1) => return a1 == b1,
_ => return false
},
- two(a1, a2) => match b {
- two(b1, b2) => return a1 == b1 && a2 == b2,
+ Two(a1, a2) => match b {
+ Two(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
},
- three(a1, a2, a3) => match b {
- three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3,
+ Three(a1, a2, a3) => match b {
+ Three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3,
_ => return false
}
}
}
- fn taggypareq<T>(a: taggypar<T>, b: taggypar<T>) -> bool {
+ fn taggypareq<T>(a: Taggypar<T>, b: Taggypar<T>) -> bool {
match a {
- onepar::<T>(a1) => match b {
- onepar::<T>(b1) => return a1 == b1,
+ Onepar::<T>(a1) => match b {
+ Onepar::<T>(b1) => return a1 == b1,
_ => return false
},
- twopar::<T>(a1, a2) => match b {
- twopar::<T>(b1, b2) => return a1 == b1 && a2 == b2,
+ Twopar::<T>(a1, a2) => match b {
+ Twopar::<T>(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
},
- threepar::<T>(a1, a2, a3) => match b {
- threepar::<T>(b1, b2, b3) => {
+ Threepar::<T>(a1, a2, a3) => match b {
+ Threepar::<T>(b1, b2, b3) => {
return a1 == b1 && a2 == b2 && a3 == b3
}
_ => 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);
}
debug!("*** test boxes");
test_boxes(@5, @72, @64, @175);
debug!("*** end test boxes");
debug!("test parameterized: int");
- let eq1: eqfn<int> = inteq;
+ let eq1: EqFn<int> = inteq;
test_parameterized::<int>(eq1, 5, 72, 64, 175);
debug!("*** test parameterized: @int");
- let eq2: eqfn<@int> = intboxeq;
+ let eq2: EqFn<@int> = intboxeq;
test_parameterized::<@int>(eq2, @5, @72, @64, @175);
debug!("*** end test parameterized @int");
debug!("test parameterized: taggy");
- let eq3: eqfn<taggy> = taggyeq;
- test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
- two(17, 42));
+ let eq3: EqFn<Taggy> = taggyeq;
+ test_parameterized::<Taggy>(eq3, One(1), Two(1, 2), Three(1, 2, 3),
+ Two(17, 42));
debug!("*** test parameterized: taggypar<int>");
- let eq4: eqfn<taggypar<int>> = |x,y| taggypareq::<int>(x, y);
- test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
- twopar::<int>(1, 2),
- threepar::<int>(1, 2, 3),
- twopar::<int>(17, 42));
+ let eq4: EqFn<Taggypar<int>> = |x,y| taggypareq::<int>(x, y);
+ test_parameterized::<Taggypar<int>>(eq4, Onepar::<int>(1),
+ Twopar::<int>(1, 2),
+ Threepar::<int>(1, 2, 3),
+ Twopar::<int>(17, 42));
debug!("*** end test parameterized: taggypar::<int>");
debug!("*** test parameterized: reccy");
- let reccy1: reccy = {x: 1, y: 2, t: one(1)};
- let reccy2: reccy = {x: 345, y: 2, t: two(1, 2)};
- let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)};
- let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)};
- let eq5: eqfn<reccy> = reccyeq;
- test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4);
+ let reccy1: RecCy = {x: 1, y: 2, t: One(1)};
+ let reccy2: RecCy = {x: 345, y: 2, t: Two(1, 2)};
+ let reccy3: RecCy = {x: 1, y: 777, t: Three(1, 2, 3)};
+ let reccy4: RecCy = {x: 19, y: 252, t: Two(17, 42)};
+ let eq5: EqFn<RecCy> = reccyeq;
+ test_parameterized::<RecCy>(eq5, reccy1, reccy2, reccy3, reccy4);
debug!("*** end test parameterized: reccy");
debug!("*** done");
}
-
+#[deny(non_camel_case_types)];
// Simple Extensible Binary Markup Language (ebml) reader and writer on a
// cursor model. See the specification here:
import option::{Some, None};
export doc;
+export Doc;
export doc_at;
export maybe_get_doc;
export get_doc;
export doc_as_i16;
export doc_as_i32;
export doc_as_i64;
-export writer;
+export Writer;
export serializer;
export ebml_deserializer;
+export EbmlDeserializer;
export deserializer;
export with_doc_data;
export get_doc;
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"
// separate modules within this file.
// 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> {
- pure fn index(&&tag: uint) -> doc {
+impl Doc: ops::index<uint,Doc> {
+ pure fn index(&&tag: uint) -> Doc {
unchecked {
get_doc(self, tag)
}
} 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)};
}
-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_size = vuint_at(*data, elt_tag.next);
let end = elt_size.next + elt_size.val;
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;
while pos < d.end {
let elt_tag = vuint_at(*d.data, pos);
let elt_size = vuint_at(*d.data, elt_tag.next);
pos = elt_size.next + elt_size.val;
if elt_tag.val == tg {
- return Some::<doc>({
+ return Some::<Doc>({
data: d.data,
start: elt_size.next,
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) {
Some(d) => return d,
None => {
}
}
-fn docs(d: doc, it: fn(uint, doc) -> bool) {
+fn docs(d: Doc, it: fn(uint, Doc) -> bool) {
let mut pos = d.start;
while pos < d.end {
let elt_tag = vuint_at(*d.data, pos);
}
}
-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;
while pos < d.end {
let elt_tag = vuint_at(*d.data, pos);
}
}
-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));
}
-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;
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;
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;
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;
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_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_i64(d: doc) -> i64 { doc_as_u64(d) as i64 }
+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_i32(d: Doc) -> i32 { doc_as_u32(d) as i32 }
+fn doc_as_i64(d: Doc) -> i64 { doc_as_u64(d) as i64 }
// ebml writing
-type writer_ = {writer: io::Writer, mut size_positions: ~[uint]};
+type Writer_ = {writer: io::Writer, mut size_positions: ~[uint]};
-enum writer {
- writer_(writer_)
+enum Writer {
+ Writer_(Writer_)
}
fn write_sized_vuint(w: io::Writer, n: uint, size: uint) {
fail fmt!("vint to write too big: %?", n);
}
-fn writer(w: io::Writer) -> writer {
+fn Writer(w: io::Writer) -> Writer {
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.
-impl writer {
+impl Writer {
fn start_tag(tag_id: uint) {
debug!("Start tag %u", tag_id);
// Totally lame approach.
const debug: bool = false;
-enum ebml_serializer_tag {
- es_uint, es_u64, es_u32, es_u16, es_u8,
- es_int, es_i64, es_i32, es_i16, es_i8,
- es_bool,
- es_str,
- es_f64, es_f32, es_float,
- es_enum, es_enum_vid, es_enum_body,
- es_vec, es_vec_len, es_vec_elt,
+enum EbmlSerializerTag {
+ EsUint, EsU64, EsU32, EsU16, EsU8,
+ EsInt, EsI64, EsI32, EsI16, EsI8,
+ EsBool,
+ EsStr,
+ EsF64, EsF32, EsFloat,
+ EsEnum, EsEnumVid, EsEnumBody,
+ EsVec, EsVecLen, EsVecElt,
- es_label // Used only when debugging
+ EsLabel // Used only when debugging
}
-trait serializer_priv {
- fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint);
+trait SerializerPriv {
+ fn _emit_tagged_uint(t: EbmlSerializerTag, v: uint);
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
- fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint) {
+ fn _emit_tagged_uint(t: EbmlSerializerTag, v: uint) {
assert v <= 0xFFFF_FFFF_u;
self.wr_tagged_u32(t as uint, v as u32);
}
// efficiency. When debugging, though, we can emit such
// labels and then they will be checked by deserializer to
// 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_uint(v: uint) { self.wr_tagged_u64(es_uint as uint, v as u64); }
- fn emit_u64(v: u64) { self.wr_tagged_u64(es_u64 as uint, v); }
- fn emit_u32(v: u32) { self.wr_tagged_u32(es_u32 as uint, v); }
- fn emit_u16(v: u16) { self.wr_tagged_u16(es_u16 as uint, v); }
- fn emit_u8(v: u8) { self.wr_tagged_u8 (es_u8 as uint, v); }
+ fn emit_uint(v: uint) { self.wr_tagged_u64(EsUint as uint, v as u64); }
+ fn emit_u64(v: u64) { self.wr_tagged_u64(EsU64 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(EsU16 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_i64(v: i64) { self.wr_tagged_i64(es_i64 as uint, v); }
- fn emit_i32(v: i32) { self.wr_tagged_i32(es_i32 as uint, v); }
- fn emit_i16(v: i16) { self.wr_tagged_i16(es_i16 as uint, v); }
- fn emit_i8(v: i8) { self.wr_tagged_i8 (es_i8 as uint, v); }
+ fn emit_int(v: int) { self.wr_tagged_i64(EsInt as uint, v as i64); }
+ fn emit_i64(v: i64) { self.wr_tagged_i64(EsI64 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(EsI16 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
fn emit_f64(_v: f64) { fail ~"Unimplemented: serializing an f64"; }
fn emit_f32(_v: f32) { fail ~"Unimplemented: serializing an f32"; }
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()) {
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()) {
- self._emit_tagged_uint(es_enum_vid, v_id);
- self.wr_tag(es_enum_body as uint, f)
+ self._emit_tagged_uint(EsEnumVid, v_id);
+ self.wr_tag(EsEnumBody as uint, f)
}
fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() }
fn emit_vec(len: uint, f: fn()) {
- do self.wr_tag(es_vec as uint) {
- self._emit_tagged_uint(es_vec_len, len);
+ do self.wr_tag(EsVec as uint) {
+ self._emit_tagged_uint(EsVecLen, len);
f()
}
}
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_tup_elt(_idx: uint, f: fn()) { f() }
}
-type ebml_deserializer_ = {mut parent: ebml::doc,
+type EbmlDeserializer_ = {mut parent: ebml::Doc,
mut pos: uint};
-enum ebml_deserializer {
- ebml_deserializer_(ebml_deserializer_)
+enum EbmlDeserializer {
+ EbmlDeserializer_(EbmlDeserializer_)
}
-fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer {
- ebml_deserializer_({mut parent: d, mut pos: d.start})
+fn ebml_deserializer(d: ebml::Doc) -> EbmlDeserializer {
+ EbmlDeserializer_({mut parent: d, mut pos: d.start})
}
-priv impl ebml_deserializer {
+priv impl EbmlDeserializer {
fn _check_label(lbl: ~str) {
if self.pos < self.parent.end {
let {tag: r_tag, doc: r_doc} =
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;
let str = ebml::doc_as_str(r_doc);
if lbl != str {
}
}
- 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);
if self.pos >= self.parent.end {
fail ~"no more documents in current node!";
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_pos = self.pos;
self.parent = d;
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));
debug!("_next_uint exp_tag=%? result=%?", exp_tag, r);
return r as uint;
}
}
-impl ebml_deserializer: serialization::deserializer {
+impl EbmlDeserializer: serialization::deserializer {
fn read_nil() -> () { () }
- fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(es_u64)) }
- fn read_u32() -> u32 { ebml::doc_as_u32(self.next_doc(es_u32)) }
- fn read_u16() -> u16 { ebml::doc_as_u16(self.next_doc(es_u16)) }
- fn read_u8 () -> u8 { ebml::doc_as_u8 (self.next_doc(es_u8 )) }
+ fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(EsU64)) }
+ fn read_u32() -> u32 { ebml::doc_as_u32(self.next_doc(EsU32)) }
+ fn read_u16() -> u16 { ebml::doc_as_u16(self.next_doc(EsU16)) }
+ fn read_u8 () -> u8 { ebml::doc_as_u8 (self.next_doc(EsU8 )) }
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) {
fail fmt!("uint %? too large for this architecture", v);
}
return v as uint;
}
- fn read_i64() -> i64 { ebml::doc_as_u64(self.next_doc(es_i64)) as i64 }
- fn read_i32() -> i32 { ebml::doc_as_u32(self.next_doc(es_i32)) as i32 }
- fn read_i16() -> i16 { ebml::doc_as_u16(self.next_doc(es_i16)) as i16 }
- fn read_i8 () -> i8 { ebml::doc_as_u8 (self.next_doc(es_i8 )) as i8 }
+ 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(EsI32)) as i32 }
+ 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(EsI8 )) as i8 }
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) {
fail fmt!("int %? out of range for this architecture", v);
}
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_f32() -> f32 { fail ~"read_f32()"; }
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:
fn read_enum<T>(name: ~str, f: fn() -> T) -> T {
debug!("read_enum(%s)", 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 {
debug!("read_enum_variant()");
- let idx = self._next_uint(es_enum_vid);
+ let idx = self._next_uint(EsEnumVid);
debug!(" idx=%u", idx);
- do self.push_doc(self.next_doc(es_enum_body)) {
+ do self.push_doc(self.next_doc(EsEnumBody)) {
f(idx)
}
}
fn read_vec<T>(f: fn(uint) -> T) -> T {
debug!("read_vec()");
- do self.push_doc(self.next_doc(es_vec)) {
- let len = self._next_uint(es_vec_len);
+ do self.push_doc(self.next_doc(EsVec)) {
+ let len = self._next_uint(EsVecLen);
debug!(" len=%u", len);
f(len)
}
fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T {
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 test_v(v: Option<int>) {
debug!("v == %?", v);
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);
let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
let deser = ebml_deserializer(ebml_doc);
+#[deny(non_camel_case_types)];
+
/*!
* A functional key,value store that works on anything.
*
import option::{Some, None};
import option = option;
-export treemap;
+export Treemap;
export init;
export insert;
export find;
export traverse;
-type treemap<K, V> = @tree_node<K, V>;
+type Treemap<K, V> = @TreeNode<K, V>;
-enum tree_node<K, V> {
- empty,
- node(@K, @V, @tree_node<K, V>, @tree_node<K, V>)
+enum TreeNode<K, V> {
+ Empty,
+ Node(@K, @V, @TreeNode<K, V>, @TreeNode<K, V>)
}
/// 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
-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 {
- @empty => node(@k, @v, @empty, @empty),
- @node(@kk, vv, left, right) => {
+ @Empty => Node(@k, @v, @Empty, @Empty),
+ @Node(@kk, vv, left, right) => {
if k < kk {
- node(@kk, vv, insert(left, k, v), right)
+ Node(@kk, vv, insert(left, k, v), right)
} else if k == kk {
- node(@kk, @v, left, right)
- } else { node(@kk, vv, left, insert(right, k, v)) }
+ Node(@kk, @v, left, right)
+ } else { Node(@kk, vv, left, insert(right, k, v)) }
}
}
}
/// 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 {
- empty => None,
- node(@kk, @v, left, right) => {
+ Empty => None,
+ Node(@kk, @v, left, right) => {
if k == kk {
Some(v)
} else if k < kk { find(left, k) } else { find(right, k) }
}
/// 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 {
- empty => (),
+ Empty => (),
/*
Previously, this had what looked like redundant
matches to me, so I changed it. but that may be a
de-optimization -- tjc
*/
- node(@k, @v, left, right) => {
+ Node(@k, @v, left, right) => {
// copy v to make aliases work out
let v1 = v;
traverse(left, f);
+#[deny(non_camel_case_types)];
+
/*!
* Simple getopt alternative.
*
import core::result::{Err, Ok};
import core::option;
import core::option::{Some, None};
-export opt;
+export Opt;
export reqopt;
export optopt;
export optflag;
export optflagopt;
export optmulti;
export getopts;
-export matches;
-export fail_;
+export Matches;
+export Fail_;
export fail_str;
export opt_present;
export opts_present;
export opt_strs;
export opt_maybe_str;
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
-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);
return if str::len(nm) == 1u {
- short(str::char_at(unm, 0u))
- } else { long(unm) };
+ Short(str::char_at(unm, 0u))
+ } else { Long(unm) };
}
/// Create an option that is required and takes an argument
-fn reqopt(name: &str) -> opt {
- return {name: mkname(name), hasarg: yes, occur: req};
+fn reqopt(name: &str) -> Opt {
+ return {name: mkname(name), hasarg: Yes, occur: Req};
}
/// Create an option that is optional and takes an argument
-fn optopt(name: &str) -> opt {
- return {name: mkname(name), hasarg: yes, occur: optional};
+fn optopt(name: &str) -> Opt {
+ return {name: mkname(name), hasarg: Yes, occur: Optional};
}
/// Create an option that is optional and does not take an argument
-fn optflag(name: &str) -> opt {
- return {name: mkname(name), hasarg: no, occur: optional};
+fn optflag(name: &str) -> Opt {
+ return {name: mkname(name), hasarg: No, occur: Optional};
}
/// Create an option that is optional and takes an optional argument
-fn optflagopt(name: &str) -> opt {
- return {name: mkname(name), hasarg: maybe, occur: optional};
+fn optflagopt(name: &str) -> Opt {
+ return {name: mkname(name), hasarg: Maybe, occur: Optional};
}
/**
* Create an option that is optional, takes an argument, and may occur
* multiple times
*/
-fn optmulti(name: &str) -> opt {
- return {name: mkname(name), hasarg: yes, occur: multi};
+fn optmulti(name: &str) -> Opt {
+ 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
* 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 {
return str::len(arg) > 1u && arg[0] == '-' as u8;
}
-fn name_str(nm: &name) -> ~str {
+fn name_str(nm: &Name) -> ~str {
return match *nm {
- short(ch) => str::from_char(ch),
- long(s) => s
+ Short(ch) => str::from_char(ch),
+ 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)
}
* 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.
*/
-enum fail_ {
- argument_missing(~str),
- unrecognized_option(~str),
- option_missing(~str),
- option_duplicated(~str),
- unexpected_argument(~str),
+enum Fail_ {
+ ArgumentMissing(~str),
+ UnrecognizedOption(~str),
+ OptionMissing(~str),
+ OptionDuplicated(~str),
+ UnexpectedArgument(~str),
}
/// Convert a `fail_` enum into an error string
-fn fail_str(+f: fail_) -> ~str {
+fn fail_str(+f: Fail_) -> ~str {
return match f {
- argument_missing(nm) => ~"Argument to option '" + nm + ~"' missing.",
- unrecognized_option(nm) => ~"Unrecognized option: '" + nm + ~"'.",
- option_missing(nm) => ~"Required option '" + nm + ~"' missing.",
- option_duplicated(nm) => ~"Option '" + nm + ~"' given more than once.",
- unexpected_argument(nm) => {
+ ArgumentMissing(nm) => ~"Argument to option '" + nm + ~"' missing.",
+ UnrecognizedOption(nm) => ~"Unrecognized option: '" + nm + ~"'.",
+ OptionMissing(nm) => ~"Required option '" + nm + ~"' missing.",
+ OptionDuplicated(nm) => ~"Option '" + nm + ~"' given more than once.",
+ UnexpectedArgument(nm) => {
~"Option " + nm + ~" does not take an argument."
}
};
/**
* 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
*
- * On success returns `ok(opt)`. Use functions such as `opt_present`
- * `opt_str`, etc. to interrogate results. Returns `err(fail_)` on failure.
+ * On success returns `ok(Opt)`. Use functions such as `opt_present`
+ * `opt_str`, etc. to interrogate results. Returns `err(Fail_)` on failure.
* Use <fail_str> to get an error message.
*/
-fn getopts(args: &[~str], opts: &[opt]) -> result unsafe {
- let n_opts = vec::len::<opt>(opts);
- fn f(_x: uint) -> ~[optval] { return ~[]; }
+fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
+ let n_opts = vec::len::<Opt>(opts);
+ fn f(_x: uint) -> ~[Optval] { return ~[]; }
let vals = vec::to_mut(vec::from_fn(n_opts, f));
let mut free: ~[~str] = ~[];
let l = vec::len(args);
let tail = str::slice(cur, 2u, curlen);
let tail_eq = str::splitn_char(tail, '=', 1u);
if vec::len(tail_eq) <= 1u {
- names = ~[long(tail)];
+ names = ~[Long(tail)];
} else {
names =
- ~[long(tail_eq[0])];
+ ~[Long(tail_eq[0])];
i_arg =
option::Some::<~str>(tail_eq[1]);
}
names = ~[];
while j < curlen {
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
one which takes an argument, we assume all subsequent
match opts[option::get(last_valid_opt_id)]
.hasarg {
- yes | maybe => true,
- no => false
+ Yes | Maybe => true,
+ No => false
};
if arg_follows && j + 1 < curlen {
i_arg = option::Some(str::slice(cur, j, curlen));
name_pos += 1u;
let optid = match find_opt(opts, nm) {
Some(id) => id,
- None => return Err(unrecognized_option(name_str(&nm)))
+ None => return Err(UnrecognizedOption(name_str(&nm)))
};
match opts[optid].hasarg {
- no => {
+ No => {
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) {
- vec::push(vals[optid], val(option::get(i_arg)));
- } else if name_pos < vec::len::<name>(names) ||
+ vec::push(vals[optid], Val(option::get(i_arg)));
+ } else if name_pos < vec::len::<Name>(names) ||
i + 1u == l || is_arg(args[i + 1u]) {
- vec::push(vals[optid], given);
- } else { i += 1u; vec::push(vals[optid], val(args[i])); }
+ vec::push(vals[optid], Given);
+ } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
}
- yes => {
+ Yes => {
if !option::is_none::<~str>(i_arg) {
vec::push(vals[optid],
- val(option::get::<~str>(i_arg)));
+ Val(option::get::<~str>(i_arg)));
} else if i + 1u == l {
- return Err(argument_missing(name_str(&nm)));
- } else { i += 1u; vec::push(vals[optid], val(args[i])); }
+ return Err(ArgumentMissing(name_str(&nm)));
+ } else { i += 1u; vec::push(vals[optid], Val(args[i])); }
}
}
}
}
i = 0u;
while i < n_opts {
- let n = vec::len::<optval>(vals[i]);
+ let n = vec::len::<Optval>(vals[i]);
let occ = opts[i].occur;
- if occ == req {
+ if occ == Req {
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 {
- return Err(option_duplicated(name_str(&(opts[i].name))));
+ return Err(OptionDuplicated(name_str(&(opts[i].name))));
}
}
i += 1u;
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)) {
Some(id) => mm.vals[id],
None => {
};
}
-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
-fn opt_present(+mm: matches, nm: &str) -> bool {
- return vec::len::<optval>(opt_vals(mm, nm)) > 0u;
+fn opt_present(+mm: Matches, nm: &str) -> bool {
+ return vec::len::<Optval>(opt_vals(mm, nm)) > 0u;
}
/// 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| {
match find_opt(mm.opts, mkname(nm)) {
Some(_) => return true,
* Fails if the option was not matched or if the match did not take an
* argument
*/
-fn opt_str(+mm: matches, nm: &str) -> ~str {
- return match opt_val(mm, nm) { val(s) => s, _ => fail };
+fn opt_str(+mm: Matches, nm: &str) -> ~str {
+ return match opt_val(mm, nm) { Val(s) => s, _ => fail };
}
/**
* Fails if the no option was provided from the given list, or if the no such
* 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| {
match opt_val(mm, nm) {
- val(s) => return s,
+ Val(s) => return s,
_ => ()
}
}
*
* 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] = ~[];
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;
}
/// 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);
- if vec::len::<optval>(vals) == 0u { return None::<~str>; }
- return match vals[0] { val(s) => Some::<~str>(s), _ => None::<~str> };
+ if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
+ return match vals[0] { Val(s) => Some::<~str>(s), _ => None::<~str> };
}
* present but no argument was provided, and the argument if the option was
* 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);
- if vec::len::<optval>(vals) == 0u { return None::<~str>; }
- return match vals[0] { val(s) => Some::<~str>(s),
+ if vec::len::<Optval>(vals) == 0u { return None::<~str>; }
+ return match vals[0] { Val(s) => Some::<~str>(s),
_ => Some::<~str>(str::from_slice(def)) }
}
import opt = getopts;
import result::{Err, Ok};
- enum fail_type {
- argument_missing_,
- unrecognized_option_,
- option_missing_,
- option_duplicated_,
- unexpected_argument_,
+ enum FailType {
+ ArgumentMissing_,
+ UnrecognizedOption_,
+ OptionMissing_,
+ OptionDuplicated_,
+ UnexpectedArgument_,
}
- fn check_fail_type(+f: fail_, ft: fail_type) {
+ fn check_fail_type(+f: Fail_, ft: FailType) {
match f {
- argument_missing(_) => assert ft == argument_missing_,
- unrecognized_option(_) => assert ft == unrecognized_option_,
- option_missing(_) => assert ft == option_missing_,
- option_duplicated(_) => assert ft == option_duplicated_,
- unexpected_argument(_) => assert ft == unexpected_argument_
+ ArgumentMissing(_) => assert ft == ArgumentMissing_,
+ UnrecognizedOption(_) => assert ft == UnrecognizedOption_,
+ OptionMissing(_) => assert ft == OptionMissing_,
+ OptionDuplicated(_) => assert ft == OptionDuplicated_,
+ UnexpectedArgument(_) => assert ft == UnexpectedArgument_
}
}
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_missing_),
+ Err(f) => check_fail_type(f, OptionMissing_),
_ => fail
}
}
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, argument_missing_),
+ Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail
}
}
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_duplicated_),
+ Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail
}
}
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_missing_),
+ Err(f) => check_fail_type(f, OptionMissing_),
_ => fail
}
}
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, argument_missing_),
+ Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail
}
}
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_duplicated_),
+ Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail
}
}
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, argument_missing_),
+ Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail
}
}
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_duplicated_),
+ Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail
}
}
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, argument_missing_),
+ Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail
}
}
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_duplicated_),
+ Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail
}
}
match rs {
Err(f) => {
log(error, fail_str(f));
- check_fail_type(f, unexpected_argument_);
+ check_fail_type(f, UnexpectedArgument_);
}
_ => fail
}
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_duplicated_),
+ Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail
}
}
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, option_duplicated_),
+ Err(f) => check_fail_type(f, OptionDuplicated_),
_ => fail
}
}
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, argument_missing_),
+ Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail
}
}
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, argument_missing_),
+ Err(f) => check_fail_type(f, ArgumentMissing_),
_ => fail
}
}
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, unrecognized_option_),
+ Err(f) => check_fail_type(f, UnrecognizedOption_),
_ => fail
}
}
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
match rs {
- Err(f) => check_fail_type(f, unrecognized_option_),
+ Err(f) => check_fail_type(f, UnrecognizedOption_),
_ => fail
}
}
+#[deny(non_camel_case_types)];
+
// Rust JSON serialization library
// Copyright (c) 2011 Google Inc.
import map::hashmap;
import map::map;
-export json;
-export error;
+export Json;
+export Error;
export to_writer;
export to_str;
export from_reader;
export from_str;
export eq;
-export to_json;
+export ToJson;
-export num;
-export string;
-export boolean;
-export list;
-export dict;
-export null;
+export Num;
+export String;
+export Boolean;
+export List;
+export Dict;
+export Null;
/// Represents a json value
-enum json {
- num(float),
- string(@~str),
- boolean(bool),
- list(@~[json]),
- dict(map::hashmap<~str, json>),
- null,
+enum Json {
+ Num(float),
+ String(@~str),
+ Boolean(bool),
+ List(@~[Json]),
+ Dict(map::hashmap<~str, Json>),
+ Null,
}
-type error = {
+type Error = {
line: uint,
col: uint,
msg: @~str,
};
/// 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 {
- num(n) => wr.write_str(float::to_str(n, 6u)),
- string(s) => wr.write_str(escape_str(*s)),
- boolean(b) => wr.write_str(if b { ~"true" } else { ~"false" }),
- list(v) => {
+ Num(n) => wr.write_str(float::to_str(n, 6u)),
+ String(s) => wr.write_str(escape_str(*s)),
+ Boolean(b) => wr.write_str(if b { ~"true" } else { ~"false" }),
+ List(v) => {
wr.write_char('[');
let mut first = true;
for (*v).each |item| {
};
wr.write_char(']');
}
- dict(d) => {
+ Dict(d) => {
if d.size() == 0u {
wr.write_str(~"{}");
return;
};
wr.write_str(~" }");
}
- null => wr.write_str(~"null")
+ Null => wr.write_str(~"null")
}
}
}
/// 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))
}
-type parser_ = {
+type Parser_ = {
rdr: io::Reader,
mut ch: char,
mut line: uint,
mut col: uint,
};
-enum parser {
- parser_(parser_)
+enum Parser {
+ Parser_(Parser_)
}
-impl parser {
+impl Parser {
fn eof() -> bool { self.ch == -1 as char }
fn bump() {
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 })
}
- fn parse() -> Result<json, error> {
+ fn parse() -> Result<Json, Error> {
match self.parse_value() {
Ok(value) => {
// Skip trailing whitespaces.
}
}
- fn parse_value() -> Result<json, error> {
+ fn parse_value() -> Result<Json, Error> {
self.parse_whitespace();
if self.eof() { return self.error(~"EOF while parsing value"); }
match self.ch {
- 'n' => self.parse_ident(~"ull", null),
- 't' => self.parse_ident(~"rue", boolean(true)),
- 'f' => self.parse_ident(~"alse", boolean(false)),
+ 'n' => self.parse_ident(~"ull", Null),
+ 't' => self.parse_ident(~"rue", Boolean(true)),
+ 'f' => self.parse_ident(~"alse", Boolean(false)),
'0' to '9' | '-' => self.parse_number(),
'"' => match self.parse_str() {
- Ok(s) => Ok(string(s)),
+ Ok(s) => Ok(String(s)),
Err(e) => Err(e)
},
'[' => self.parse_list(),
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()) {
self.bump();
Ok(value)
}
}
- fn parse_number() -> Result<json, error> {
+ fn parse_number() -> Result<Json, Error> {
let mut neg = 1f;
if self.ch == '-' {
}
}
- Ok(num(neg * res))
+ Ok(Num(neg * res))
}
- fn parse_integer() -> Result<float, error> {
+ fn parse_integer() -> Result<float, Error> {
let mut res = 0f;
match self.ch {
Ok(res)
}
- fn parse_decimal(res: float) -> Result<float, error> {
+ fn parse_decimal(res: float) -> Result<float, Error> {
self.bump();
// Make sure a digit follows the decimal place.
Ok(res)
}
- fn parse_exponent(res: float) -> Result<float, error> {
+ fn parse_exponent(res: float) -> Result<float, Error> {
self.bump();
let mut res = res;
Ok(res)
}
- fn parse_str() -> Result<@~str, error> {
+ fn parse_str() -> Result<@~str, Error> {
let mut escape = false;
let mut res = ~"";
self.error(~"EOF while parsing string")
}
- fn parse_list() -> Result<json, error> {
+ fn parse_list() -> Result<Json, Error> {
self.bump();
self.parse_whitespace();
if self.ch == ']' {
self.bump();
- return Ok(list(@values));
+ return Ok(List(@values));
}
loop {
match self.ch {
',' => self.bump(),
- ']' => { self.bump(); return Ok(list(@values)); }
+ ']' => { self.bump(); return Ok(List(@values)); }
_ => return self.error(~"expected `,` or `]`")
}
};
}
- fn parse_object() -> Result<json, error> {
+ fn parse_object() -> Result<Json, Error> {
self.bump();
self.parse_whitespace();
if self.ch == '}' {
self.bump();
- return Ok(dict(values));
+ return Ok(Dict(values));
}
while !self.eof() {
match self.ch {
',' => self.bump(),
- '}' => { self.bump(); return Ok(dict(values)); }
+ '}' => { self.bump(); return Ok(Dict(values)); }
_ => {
if self.eof() { break; }
return self.error(~"expected `,` or `}`");
}
/// Deserializes a json value from an io::reader
-fn from_reader(rdr: io::Reader) -> Result<json, error> {
- let parser = parser_({
+fn from_reader(rdr: io::Reader) -> Result<Json, Error> {
+ let parser = Parser_({
rdr: rdr,
mut ch: rdr.read_char(),
mut line: 1u,
}
/// 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)
}
/// Test if two json values are equal
-fn eq(value0: json, value1: json) -> bool {
+fn eq(value0: Json, value1: Json) -> bool {
match (value0, value1) {
- (num(f0), num(f1)) => f0 == f1,
- (string(s0), string(s1)) => s0 == s1,
- (boolean(b0), boolean(b1)) => b0 == b1,
- (list(l0), list(l1)) => vec::all2(*l0, *l1, eq),
- (dict(d0), dict(d1)) => {
+ (Num(f0), Num(f1)) => f0 == f1,
+ (String(s0), String(s1)) => s0 == s1,
+ (Boolean(b0), Boolean(b1)) => b0 == b1,
+ (List(l0), List(l1)) => vec::all2(*l0, *l1, eq),
+ (Dict(d0), Dict(d1)) => {
if d0.size() == d1.size() {
let mut equal = true;
for d0.each |k, v0| {
false
}
}
- (null, null) => true,
+ (Null, Null) => true,
_ => false
}
}
-trait to_json { fn to_json() -> json; }
+trait ToJson { fn to_json() -> Json; }
-impl json: to_json {
- fn to_json() -> json { self }
+impl Json: ToJson {
+ fn to_json() -> Json { self }
}
-impl @json: to_json {
- fn to_json() -> json { *self }
+impl @Json: ToJson {
+ fn to_json() -> Json { *self }
}
-impl int: to_json {
- fn to_json() -> json { num(self as float) }
+impl int: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl i8: to_json {
- fn to_json() -> json { num(self as float) }
+impl i8: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl i16: to_json {
- fn to_json() -> json { num(self as float) }
+impl i16: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl i32: to_json {
- fn to_json() -> json { num(self as float) }
+impl i32: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl i64: to_json {
- fn to_json() -> json { num(self as float) }
+impl i64: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl uint: to_json {
- fn to_json() -> json { num(self as float) }
+impl uint: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl u8: to_json {
- fn to_json() -> json { num(self as float) }
+impl u8: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl u16: to_json {
- fn to_json() -> json { num(self as float) }
+impl u16: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl u32: to_json {
- fn to_json() -> json { num(self as float) }
+impl u32: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl u64: to_json {
- fn to_json() -> json { num(self as float) }
+impl u64: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl float: to_json {
- fn to_json() -> json { num(self) }
+impl float: ToJson {
+ fn to_json() -> Json { Num(self) }
}
-impl f32: to_json {
- fn to_json() -> json { num(self as float) }
+impl f32: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl f64: to_json {
- fn to_json() -> json { num(self as float) }
+impl f64: ToJson {
+ fn to_json() -> Json { Num(self as float) }
}
-impl (): to_json {
- fn to_json() -> json { null }
+impl (): ToJson {
+ fn to_json() -> Json { Null }
}
-impl bool: to_json {
- fn to_json() -> json { boolean(self) }
+impl bool: ToJson {
+ fn to_json() -> Json { Boolean(self) }
}
-impl ~str: to_json {
- fn to_json() -> json { string(@copy self) }
+impl ~str: ToJson {
+ fn to_json() -> Json { String(@copy self) }
}
-impl @~str: to_json {
- fn to_json() -> json { string(self) }
+impl @~str: ToJson {
+ fn to_json() -> Json { String(self) }
}
-impl <A: to_json, B: to_json> (A, B): to_json {
- fn to_json() -> json {
+impl <A: ToJson, B: ToJson> (A, B): ToJson {
+ fn to_json() -> Json {
match self {
(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 {
(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 {
- fn to_json() -> json { list(@self.map(|elt| elt.to_json())) }
+impl <A: ToJson> ~[A]: ToJson {
+ fn to_json() -> Json { List(@self.map(|elt| elt.to_json())) }
}
-impl <A: to_json copy> hashmap<~str, A>: to_json {
- fn to_json() -> json {
+impl <A: ToJson copy> hashmap<~str, A>: ToJson {
+ fn to_json() -> Json {
let d = map::str_hash();
for self.each() |key, value| {
d.insert(copy key, value.to_json());
}
- dict(d)
+ Dict(d)
}
}
-impl <A: to_json> Option<A>: to_json {
- fn to_json() -> json {
+impl <A: ToJson> Option<A>: ToJson {
+ fn to_json() -> Json {
match self {
- None => null,
+ None => Null,
Some(value) => value.to_json()
}
}
}
-impl json: to_str::ToStr {
+impl Json: to_str::ToStr {
fn to_str() -> ~str { to_str(self) }
}
-impl error: to_str::ToStr {
+impl Error: to_str::ToStr {
fn to_str() -> ~str {
fmt!("%u:%u: %s", self.line, self.col, *self.msg)
}
#[cfg(test)]
mod tests {
- fn mk_dict(items: ~[(~str, json)]) -> json {
+ fn mk_dict(items: ~[(~str, Json)]) -> Json {
let d = map::str_hash();
do vec::iter(items) |item| {
d.insert(key, value);
};
- dict(d)
+ Dict(d)
}
#[test]
fn test_write_null() {
- assert to_str(null) == ~"null";
+ assert to_str(Null) == ~"null";
}
#[test]
fn test_write_num() {
- assert to_str(num(3f)) == ~"3";
- assert to_str(num(3.1f)) == ~"3.1";
- assert to_str(num(-1.5f)) == ~"-1.5";
- assert to_str(num(0.5f)) == ~"0.5";
+ assert to_str(Num(3f)) == ~"3";
+ assert to_str(Num(3.1f)) == ~"3.1";
+ assert to_str(Num(-1.5f)) == ~"-1.5";
+ assert to_str(Num(0.5f)) == ~"0.5";
}
#[test]
fn test_write_str() {
- assert to_str(string(@~"")) == ~"\"\"";
- assert to_str(string(@~"foo")) == ~"\"foo\"";
+ assert to_str(String(@~"")) == ~"\"\"";
+ assert to_str(String(@~"foo")) == ~"\"foo\"";
}
#[test]
fn test_write_bool() {
- assert to_str(boolean(true)) == ~"true";
- assert to_str(boolean(false)) == ~"false";
+ assert to_str(Boolean(true)) == ~"true";
+ assert to_str(Boolean(false)) == ~"false";
}
#[test]
fn test_write_list() {
- assert to_str(list(@~[])) == ~"[]";
- assert to_str(list(@~[boolean(true)])) == ~"[true]";
- assert to_str(list(@~[
- boolean(false),
- null,
- list(@~[string(@~"foo\nbar"), num(3.5f)])
+ assert to_str(List(@~[])) == ~"[]";
+ assert to_str(List(@~[Boolean(true)])) == ~"[true]";
+ assert to_str(List(@~[
+ Boolean(false),
+ Null,
+ List(@~[String(@~"foo\nbar"), Num(3.5f)])
])) == ~"[false, null, [\"foo\\nbar\", 3.5]]";
}
#[test]
fn test_write_dict() {
assert to_str(mk_dict(~[])) == ~"{}";
- assert to_str(mk_dict(~[(~"a", boolean(true))]))
+ assert to_str(mk_dict(~[(~"a", Boolean(true))]))
== ~"{ \"a\": true }";
assert to_str(mk_dict(~[
- (~"a", boolean(true)),
- (~"b", list(@~[
- mk_dict(~[(~"c", string(@~"\x0c\r"))]),
- mk_dict(~[(~"d", string(@~""))])
+ (~"a", Boolean(true)),
+ (~"b", List(@~[
+ mk_dict(~[(~"c", String(@~"\x0c\r"))]),
+ mk_dict(~[(~"d", String(@~""))])
]))
])) ==
~"{ " +
assert from_str(~"faz") ==
Err({line: 1u, col: 3u, msg: @~"invalid syntax"});
- assert from_str(~"null") == Ok(null);
- assert from_str(~"true") == Ok(boolean(true));
- assert from_str(~"false") == Ok(boolean(false));
- assert from_str(~" null ") == Ok(null);
- assert from_str(~" true ") == Ok(boolean(true));
- assert from_str(~" false ") == Ok(boolean(false));
+ assert from_str(~"null") == Ok(Null);
+ assert from_str(~"true") == Ok(Boolean(true));
+ assert from_str(~"false") == Ok(Boolean(false));
+ assert from_str(~" null ") == Ok(Null);
+ assert from_str(~" true ") == Ok(Boolean(true));
+ assert from_str(~" false ") == Ok(Boolean(false));
}
#[test]
assert from_str(~"1e+") ==
Err({line: 1u, col: 4u, msg: @~"invalid number"});
- assert from_str(~"3") == Ok(num(3f));
- assert from_str(~"3.1") == Ok(num(3.1f));
- assert from_str(~"-1.2") == Ok(num(-1.2f));
- assert from_str(~"0.4") == Ok(num(0.4f));
- assert from_str(~"0.4e5") == Ok(num(0.4e5f));
- assert from_str(~"0.4e+15") == Ok(num(0.4e15f));
- 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));
+ assert from_str(~"3.1") == Ok(Num(3.1f));
+ assert from_str(~"-1.2") == Ok(Num(-1.2f));
+ assert from_str(~"0.4") == Ok(Num(0.4f));
+ assert from_str(~"0.4e5") == Ok(Num(0.4e5f));
+ assert from_str(~"0.4e+15") == Ok(Num(0.4e15f));
+ assert from_str(~"0.4e-01") == Ok(Num(0.4e-01f));
+ assert from_str(~" 3 ") == Ok(Num(3f));
}
#[test]
assert from_str(~"\"lol") ==
Err({line: 1u, col: 5u, msg: @~"EOF while parsing string"});
- assert from_str(~"\"\"") == Ok(string(@~""));
- assert from_str(~"\"foo\"") == Ok(string(@~"foo"));
- assert from_str(~"\"\\\"\"") == Ok(string(@~"\""));
- assert from_str(~"\"\\b\"") == Ok(string(@~"\x08"));
- assert from_str(~"\"\\n\"") == Ok(string(@~"\n"));
- assert from_str(~"\"\\r\"") == Ok(string(@~"\r"));
- assert from_str(~"\"\\t\"") == Ok(string(@~"\t"));
- assert from_str(~" \"foo\" ") == Ok(string(@~"foo"));
+ assert from_str(~"\"\"") == Ok(String(@~""));
+ assert from_str(~"\"foo\"") == Ok(String(@~"foo"));
+ assert from_str(~"\"\\\"\"") == Ok(String(@~"\""));
+ assert from_str(~"\"\\b\"") == Ok(String(@~"\x08"));
+ assert from_str(~"\"\\n\"") == Ok(String(@~"\n"));
+ assert from_str(~"\"\\r\"") == Ok(String(@~"\r"));
+ assert from_str(~"\"\\t\"") == Ok(String(@~"\t"));
+ assert from_str(~" \"foo\" ") == Ok(String(@~"foo"));
}
#[test]
assert from_str(~"[6 7]") ==
Err({line: 1u, col: 4u, msg: @~"expected `,` or `]`"});
- assert from_str(~"[]") == Ok(list(@~[]));
- assert from_str(~"[ ]") == Ok(list(@~[]));
- assert from_str(~"[true]") == Ok(list(@~[boolean(true)]));
- assert from_str(~"[ false ]") == Ok(list(@~[boolean(false)]));
- assert from_str(~"[null]") == Ok(list(@~[null]));
- 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(~"[]") == Ok(List(@~[]));
+ assert from_str(~"[ ]") == Ok(List(@~[]));
+ assert from_str(~"[true]") == Ok(List(@~[Boolean(true)]));
+ assert from_str(~"[ false ]") == Ok(List(@~[Boolean(false)]));
+ assert from_str(~"[null]") == Ok(List(@~[Null]));
+ 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(~"[2, [4, 1]]") ==
- Ok(list(@~[num(2f), list(@~[num(4f), num(1f)])]));
+ Ok(List(@~[Num(2f), List(@~[Num(4f), Num(1f)])]));
}
#[test]
assert eq(result::get(from_str(~"{}")), mk_dict(~[]));
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 }")),
mk_dict(~[
- (~"a", null),
- (~"b", boolean(true))]));
+ (~"a", Null),
+ (~"b", Boolean(true))]));
assert eq(result::get(from_str(~"\n{ \"a\": null, \"b\" : true }\n")),
mk_dict(~[
- (~"a", null),
- (~"b", boolean(true))]));
+ (~"a", Null),
+ (~"b", Boolean(true))]));
assert eq(result::get(from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")),
mk_dict(~[
- (~"a", num(1.0)),
- (~"b", list(@~[boolean(true)]))
+ (~"a", Num(1.0)),
+ (~"b", List(@~[Boolean(true)]))
]));
assert eq(result::get(from_str(
~"{" +
~"]" +
~"}")),
mk_dict(~[
- (~"a", num(1.0f)),
- (~"b", list(@~[
- boolean(true),
- string(@~"foo\nbar"),
+ (~"a", Num(1.0f)),
+ (~"b", List(@~[
+ Boolean(true),
+ String(@~"foo\nbar"),
mk_dict(~[
- (~"c", mk_dict(~[(~"d", null)]))
+ (~"c", mk_dict(~[(~"d", Null)]))
])
]))
]));
*/
-import std::bitv::{bitv};
+import std::bitv::{Bitv};
import ast_builder::empty_span;
debug!("initializing colive analysis");
let num_states = proto.num_states();
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| {
bv.set(s.id, true);
}
debug!("protocol %s is bounded. yay!", proto.name);
proto.bounded = Some(true);
}
-}
\ No newline at end of file
+}
};
}
-fn build_session_options(matches: getopts::matches,
+fn build_session_options(matches: getopts::Matches,
demitter: diagnostic::emitter) -> @session::options {
let crate_type = if opt_present(matches, ~"lib") {
session::lib_crate
}
}
-fn opts() -> ~[getopts::opt] {
+fn opts() -> ~[getopts::Opt] {
return ~[optflag(~"h"), optflag(~"help"),
optflag(~"v"), optflag(~"version"),
optflag(~"emit-llvm"), optflagopt(~"pretty"),
// what crate that's in and give us a def_id that makes sense for the current
// build.
-fn lookup_hash(d: ebml::doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
- Option<ebml::doc> {
+fn lookup_hash(d: ebml::Doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
+ Option<ebml::Doc> {
let index = ebml::get_doc(d, tag_index);
let table = ebml::get_doc(index, tag_index_table);
let hash_pos = table.start + hash % 256u * 4u;
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 {
return io::u64_from_be_bytes(vec::view(bytes, 0u, 4u), 0u, 4u) as int
== 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));
}
// Looks up an item in the given metadata and returns an ebml doc pointing
// 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);
match maybe_find_item(item_id, items) {
None => fail(fmt!("lookup_item: id not found: %d", item_id)),
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);
match ebml::doc_as_u8(fam) as char {
'c' => Const,
}
}
-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);
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| {
return Some(ebml::with_doc_data(did, |d| parse_def_id(d)));
}
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);
return translate_def_id(cdata, ebml::with_doc_data(tagdoc,
|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| {
if !f(reexport_doc) {
return;
}
}
-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
option::map_default(
ebml::maybe_get_doc(d, tag_class_mut),
})
}
-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| {
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);
parse_ty_data(tp.data, cdata.cnum, tp.start, tcx, |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 {
let t = doc_type(item, tcx, cdata);
if family_names_type(item_family(item)) {
} 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 = ~[];
for ebml::tagged_docs(item, tag_impl_trait) |ity| {
vec::push(results, doc_type(ity, tcx, cdata));
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] {
let mut bounds = ~[];
for ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) |p| {
@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| {
let d = ebml::ebml_deserializer(doc);
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;
ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds,
|_p| { n += 1u; true } );
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 v = tag_items_data_item_variant;
for ebml::tagged_docs(item, v) |p| {
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 len_doc = ebml::get_doc(path_doc, tag_path_len);
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);
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 {
let fam = item_family(item);
match fam {
cdata: cstore::crate_metadata,
tcx: ty::ctxt,
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,
id: ast::node_id,
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 {
match ch as char {
'i' => { ast::m_imm }
}
}
-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] {
let mut rslt = ~[];
for ebml::tagged_docs(item, tag_item_impl_method) |doc| {
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 pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
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"; }
let it = match maybe_find_item(id.node, items) {
Some(it) => it,
}
}
-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] = ~[];
for ebml::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
return items;
}
-fn get_attributes(md: ebml::doc) -> ~[ast::attribute] {
+fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
let mut attrs: ~[ast::attribute] = ~[];
match ebml::maybe_get_doc(md, tag_attributes) {
option::Some(attrs_d) => {
}
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| {
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.write_str(fmt!("=Crate Attributes (%s)=\n", hash));
let cratedoc = ebml::doc(data);
let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
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_)))
}
for ebml::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
import std::{ebml, map};
import std::map::hashmap;
import io::WriterUtil;
-import ebml::writer;
+import ebml::Writer;
import syntax::ast::*;
import syntax::print::pprust;
import syntax::{ast_util, visit};
type abbrev_map = map::hashmap<ty::t, tyencode::ty_abbrev>;
type encode_inlined_item = fn@(ecx: @encode_ctxt,
- ebml_w: ebml::writer,
+ ebml_w: ebml::Writer,
path: ast_map::path,
ii: ast::inlined_item);
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));
}
-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));
}
-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) {
let opt_rp = ecx.tcx.region_paramd_items.find(it.id);
for opt_rp.each |rp| {
}
}
-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) {
let val = match mt {
class_immutable => 'a',
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) {
let mut full_path = ~[];
vec::push_all(full_path, path);
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);
encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, t.ref_id));
ebml_w.end_tag();
// 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.writer.write(&[c as u8]);
ebml_w.end_tag();
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]) {
let ty_str_ctxt = @{diag: ecx.diag,
ds: def_to_str,
}
}
-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]) {
let ty_param_bounds =
@params.map(|param| ecx.tcx.ty_param_bounds.get(param.id));
}
-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.writer.write(str::to_bytes(def_to_str(vid)));
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 =
@{diag: ecx.diag,
ds: def_to_str,
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);
write_type(ecx, ebml_w, typ);
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);
let sym = match ecx.item_symbols.find(id) {
Some(x) => x,
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.writer.write(str::to_bytes(ecx.discrim_symbols.get(id)));
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.writer.write(str::to_bytes(int::to_str(disr_val,10u)));
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.writer.write(str::to_bytes(def_to_str(id)));
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],
path: ast_map::path, index: @mut ~[entry<int>],
ty_params: ~[ty_param]) {
}
}
-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) {
- 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) {
let (tag, name) = match elt {
ast_map::path_mod(name) => (tag_path_elt_mod, name),
}
}
-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) {
ebml_w.start_tag(tag_items_data_item);
encode_def_id(ebml_w, local_def(id));
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 {
public => 'g',
private => 'j',
});
}
-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);
// Encode the base self type.
}
/* 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,
class_tps: ~[ty_param],
fields: ~[@struct_field],
}
// 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,
item: Option<inlined_item>, tps: ~[ty_param]) {
ebml_w.start_tag(tag_items_data_item);
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,
parent_id: node_id,
m: @method, all_tps: ~[ty_param]) {
}
-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) {
let tcx = ecx.tcx;
};
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>]) {
vec::push(*index, {val: item.id, pos: ebml_w.writer.tell()});
}
}
}
-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,
index: @mut ~[entry<int>],
path: ast_map::path, abi: foreign_abi) {
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>] {
let index = @mut ~[];
ebml_w.start_tag(tag_items_data);
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)) {
let writer = ebml_w.writer;
ebml_w.start_tag(tag_index);
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 {
meta_word(name) => {
ebml_w.start_tag(tag_meta_item_word);
}
}
-fn encode_attributes(ebml_w: ebml::writer, attrs: ~[attribute]) {
+fn encode_attributes(ebml_w: ebml::Writer, attrs: ~[attribute]) {
ebml_w.start_tag(tag_attributes);
for attrs.each |attr| {
ebml_w.start_tag(tag_attribute);
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) {
fn get_ordered_deps(ecx: @encode_ctxt, cstore: cstore::cstore)
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) {
ebml_w.start_tag(tag_crate_dep);
ebml_w.start_tag(tag_crate_dep_name);
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.writer.write(str::to_bytes(hash));
ebml_w.end_tag();
});
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);
import syntax::ast_util;
import syntax::codemap::span;
import std::ebml;
-import std::ebml::writer;
+import std::ebml::Writer;
import std::ebml::get_doc;
import std::map::hashmap;
import std::serialization::serializer;
// Top-level methods.
fn encode_inlined_item(ecx: @e::encode_ctxt,
- ebml_w: ebml::writer,
+ ebml_w: ebml::Writer,
path: ast_map::path,
ii: ast::inlined_item,
maps: maps) {
tcx: ty::ctxt,
maps: maps,
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};
match par_doc.opt_child(c::tag_ast) {
None => None,
// 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.
-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) {
ast::serialize_inlined_item(ebml_w, 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 d = ebml::ebml_deserializer(chi_doc);
ast::deserialize_inlined_item(d)
// ______________________________________________________________________
// 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)
}
-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 def = ast::deserialize_def(dsr);
def.tr(xcx)
// ______________________________________________________________________
// 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)
}
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 {
let fv = deserialize_freevar_entry(self);
fv.tr(xcx)
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 {
let mme = deserialize_method_map_entry(self);
{derefs: mme.derefs,
// Encoding and decoding vtable_res
fn encode_vtable_res(ecx: @e::encode_ctxt,
- ebml_w: ebml::writer,
+ ebml_w: ebml::Writer,
dr: typeck::vtable_res) {
// can't autogenerate this code because automatic serialization of
// ty::t doesn't work, and there is no way (atm) to have
}
fn encode_vtable_origin(ecx: @e::encode_ctxt,
- ebml_w: ebml::writer,
+ ebml_w: ebml::Writer,
vtable_origin: typeck::vtable_origin) {
do ebml_w.emit_enum(~"vtable_origin") {
match 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 {
@self.read_to_vec(|| self.read_vtable_origin(xcx) )
}
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) {
e::write_type(ecx, self, ty)
}
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()) {
do self.wr_tag(tag_id as uint) { f() }
}
fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
maps: maps,
- ebml_w: ebml::writer,
+ ebml_w: ebml::Writer,
ii: ast::inlined_item) {
do ebml_w.wr_tag(c::tag_table as uint) {
ast_util::visit_ids_for_inlined_item(
fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
maps: maps,
- ebml_w: ebml::writer,
+ ebml_w: ebml::Writer,
id: ast::node_id) {
let tcx = ecx.tcx;
trait doc_decoder_helpers {
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 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)
}
}
-> 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 {
// Note: regions types embed local node ids. In principle, we
}
fn decode_side_tables(xcx: extended_decode_ctxt,
- ast_doc: ebml::doc) {
+ ast_doc: ebml::Doc) {
let dcx = xcx.dcx;
let tbl_doc = ast_doc[c::tag_table as uint];
for ebml::docs(tbl_doc) |tag, entry_doc| {
// Testing of astencode_gen
#[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) {
ast::serialize_item(ebml_w, *item);
}
}
#[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 d = ebml::ebml_deserializer(chi_doc);
@ast::deserialize_item(d)
#[cfg(test)]
fn roundtrip(in_item: @ast::item) {
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);
let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
let out_item = decode_item_ast(ebml_doc);
fn opt_pandoc_cmd() -> ~str { ~"pandoc-cmd" }
fn opt_help() -> ~str { ~"h" }
-fn opts() -> ~[(getopts::opt, ~str)] {
+fn opts() -> ~[(getopts::Opt, ~str)] {
~[
(getopts::optopt(opt_output_dir()),
~"--output-dir <val> put documents here"),
fn config_from_opts(
input_crate: &Path,
- matches: getopts::matches,
+ matches: getopts::Matches,
program_output: program_output
) -> Result<config, ~str> {
import std::map::map;
import std::map::hashmap;
import std::deque;
-import std::deque::t;
+import std::deque::Deque;
import std::par;
import io::WriterUtil;
import comm::*;
use std;
import std::arena;
-import methods = std::arena::arena;
+import methods = std::arena::Arena;
enum tree/& { nil, node(&tree, &tree, int), }
}
}
-fn bottom_up_tree(arena: &r/arena::arena,
+fn bottom_up_tree(arena: &r/arena::Arena,
item: int,
depth: int) -> &r/tree {
if depth > 0 {
max_depth = n;
}
- let stretch_arena = arena::arena();
+ let stretch_arena = arena::Arena();
let stretch_depth = max_depth + 1;
let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth);
stretch_depth,
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 mut depth = min_depth;
while depth <= max_depth {
fn next_color(g: grid, row: u8, col: u8, start_color: u8) -> bool {
if start_color < 10u8 {
// colors not yet used
- let avail = bitv::bitv(10u, false);
+ let avail = bitv::Bitv(10u, false);
for u8::range(start_color, 10u8) |color| {
avail.set(color as uint, true);
}
}
// find colors available in neighbourhood of (row, col)
- 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_colors(g: grid, avail: bitv::Bitv, row: u8, col: u8) {
+ fn drop_color(g: grid, colors: bitv::Bitv, row: u8, col: u8) {
let color = g[row][col];
if color != 0u8 { colors.set(color as uint, false); }
}
type fn_info = {vars: hashmap<uint, var_info>};
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 = "";
// error is that the value type in the hash map is var_info, not a box
fn test_ser_and_deser<A>(a1: A,
expected: ~str,
- ebml_ser_fn: fn(ebml::writer, A),
- ebml_deser_fn: fn(ebml::ebml_deserializer) -> A,
+ ebml_ser_fn: fn(ebml::Writer, A),
+ ebml_deser_fn: fn(ebml::EbmlDeserializer) -> A,
io_ser_fn: fn(io::Writer, A)) {
// check the pretty printer:
// check the EBML serializer:
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);
let d = ebml::doc(@io::mem_buffer_buf(buf));
let a2 = ebml_deser_fn(ebml::ebml_deserializer(d));
import std::bitv::*;
fn bitv_test() -> bool {
- let v1 = ~bitv(31, false);
- let v2 = ~bitv(31, true);
+ let v1 = ~Bitv(31, false);
+ let v2 = ~Bitv(31, true);
v1.union(v2);
true
}
fn main() {
do iter::repeat(10000) || {bitv_test()};
-}
\ No newline at end of file
+}
// xfail-test
use std;
import std::arena;
-import std::arena::arena;
+import std::arena::Arena;
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)
}
fn main(args: ~[str]) {
- let ar = arena::arena();
+ let ar = arena::Arena();
let leak = init(&ar, args[0]);
match *leak {
s(astr) {
use std;
import std::deque;
-import std::deque::t;
+import std::deque::Deque;
fn main() {
let Q = deque::create();
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)
{
- option::Some(std::json::string(s)) =>
+ option::Some(std::json::String(s)) =>
{
*s
}
}
}
-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
{
- std::json::dict(interface) =>
+ std::json::Dict(interface) =>
{
let name = lookup(interface, ~"ifDescr", ~"");
let label = fmt!("%s-%s", managed_ip, name);
}
}
-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"]
{
- std::json::list(interfaces) =>
+ std::json::List(interfaces) =>
{
do vec::map(*interfaces) |interface| {
add_interface(store, managed_ip, interface)
use std;
-import std::arena::arena;
+import std::arena;
fn main() {
- let p = &arena();
+ let p = &arena::Arena();
let x = p.alloc(|| 4u);
io::print(fmt!("%u", *x));
assert *x == 4u;
use std;
import libc, sys, unsafe;
-import std::arena::arena;
+import std::arena::Arena;
type bcx = {
fcx: &fcx
};
type fcx = {
- arena: &arena,
+ arena: &Arena,
ccx: &ccx
};
}
fn f(ccx : &ccx) {
- let a = arena();
+ let a = Arena();
let fcx = &{ arena: &a, ccx: ccx };
return g(fcx);
}
projects / rust.git / commitdiff