From 0ada7c7ffe453b9df849996f8dca0b8d0f2d9e62 Mon Sep 17 00:00:00 2001 From: reedlepee Date: Sun, 20 Oct 2013 06:03:09 +0530 Subject: [PATCH] Making fields in std and extra : private #4386 --- src/libextra/arc.rs | 17 +- src/libextra/arena.rs | 1 + src/libextra/base64.rs | 7 +- src/libextra/bitv.rs | 8 +- src/libextra/c_vec.rs | 1 + src/libextra/comm.rs | 3 + src/libextra/crypto/cryptoutil.rs | 2 + src/libextra/crypto/md5.rs | 1 + src/libextra/crypto/sha1.rs | 1 + src/libextra/crypto/sha2.rs | 6 + src/libextra/dlist.rs | 4 + src/libextra/ebml.rs | 12 +- src/libextra/enum_set.rs | 2 + src/libextra/fileinput.rs | 10 +- src/libextra/future.rs | 1 + src/libextra/getopts.rs | 15 +- src/libextra/glob.rs | 9 +- src/libextra/io_util.rs | 5 +- src/libextra/json.rs | 11 +- src/libextra/num/bigint.rs | 2 + src/libextra/num/complex.rs | 5 +- src/libextra/num/rational.rs | 5 +- src/libextra/priority_queue.rs | 2 + src/libextra/ringbuf.rs | 3 + src/libextra/semver.rs | 11 +- src/libextra/smallintmap.rs | 3 + src/libextra/stats.rs | 20 +- src/libextra/sync.rs | 10 +- src/libextra/task_pool.rs | 5 +- src/libextra/tempfile.rs | 1 + src/libextra/term.rs | 9 +- src/libextra/terminfo/parm.rs | 5 +- src/libextra/terminfo/terminfo.rs | 5 +- src/libextra/test.rs | 22 +- src/libextra/time.rs | 31 +- src/libextra/treemap.rs | 11 + src/libextra/url.rs | 20 +- src/libextra/uuid.rs | 1 + src/libextra/workcache.rs | 27 +- src/libstd/c_str.rs | 2 + src/libstd/cell.rs | 1 + src/libstd/condition.rs | 2 + src/libstd/fmt/mod.rs | 8 +- src/libstd/fmt/parse.rs | 8 +- src/libstd/fmt/rt.rs | 6 +- src/libstd/hashmap.rs | 7 + src/libstd/io.rs | 18 +- src/libstd/iter.rs | 34 +- src/libstd/libc.rs | 376 +++++++-------- src/libstd/option.rs | 1 + src/libstd/os.rs | 2 + src/libstd/path/mod.rs | 1 + src/libstd/path/posix.rs | 1 + src/libstd/path/windows.rs | 1 + src/libstd/rand/isaac.rs | 2 + src/libstd/rand/mod.rs | 8 +- src/libstd/rand/os.rs | 2 + src/libstd/rand/reader.rs | 1 + src/libstd/rand/reseeding.rs | 4 +- src/libstd/rc.rs | 2 + src/libstd/reflect.rs | 3 +- src/libstd/repr.rs | 9 +- src/libstd/rt/borrowck.rs | 5 +- src/libstd/rt/comm.rs | 14 +- src/libstd/rt/context.rs | 6 +- src/libstd/rt/crate_map.rs | 8 +- src/libstd/rt/io/buffered.rs | 3 + src/libstd/rt/io/extensions.rs | 1 + src/libstd/rt/io/file.rs | 7 +- src/libstd/rt/io/flate.rs | 6 +- src/libstd/rt/io/mem.rs | 4 + src/libstd/rt/io/mock.rs | 7 +- src/libstd/rt/io/mod.rs | 2 + src/libstd/rt/io/native/file.rs | 2 + src/libstd/rt/io/native/process.rs | 1 + src/libstd/rt/io/native/stdio.rs | 2 + src/libstd/rt/io/net/ip.rs | 1 + src/libstd/rt/io/net/tcp.rs | 3 + src/libstd/rt/io/net/udp.rs | 2 + src/libstd/rt/io/pipe.rs | 1 + src/libstd/rt/io/process.rs | 3 + src/libstd/rt/io/stdio.rs | 2 + src/libstd/rt/io/timer.rs | 1 + src/libstd/rt/kill.rs | 13 +- src/libstd/rt/local_heap.rs | 5 +- src/libstd/rt/message_queue.rs | 1 + src/libstd/rt/rc.rs | 3 +- src/libstd/rt/rtio.rs | 3 +- src/libstd/rt/sched.rs | 19 +- src/libstd/rt/sleeper_list.rs | 1 + src/libstd/rt/stack.rs | 5 +- src/libstd/rt/task.rs | 32 +- src/libstd/rt/thread.rs | 6 +- src/libstd/rt/tube.rs | 3 +- src/libstd/rt/uv/addrinfo.rs | 3 +- src/libstd/rt/uv/file.rs | 3 +- src/libstd/rt/uv/mod.rs | 3 +- src/libstd/rt/uv/uvio.rs | 59 ++- src/libstd/rt/uv/uvll.rs | 100 ++-- src/libstd/rt/work_queue.rs | 1 + src/libstd/run.rs | 5 +- src/libstd/str.rs | 10 +- src/libstd/str/ascii.rs | 1 + src/libstd/task/mod.rs | 27 +- src/libstd/task/spawn.rs | 7 +- src/libstd/trie.rs | 4 + src/libstd/unstable/atomics.rs | 6 + src/libstd/unstable/dynamic_lib.rs | 1 + src/libstd/unstable/extfmt.rs | 705 +++++++++++++++++++++++++++++ src/libstd/unstable/intrinsics.rs | 11 +- src/libstd/unstable/raw.rs | 6 +- src/libstd/unstable/sync.rs | 7 +- src/libstd/vec.rs | 10 + 113 files changed, 1504 insertions(+), 450 deletions(-) create mode 100644 src/libstd/unstable/extfmt.rs diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs index 66dad4721aa98..932dac4195c3c 100644 --- a/src/libextra/arc.rs +++ b/src/libextra/arc.rs @@ -50,6 +50,7 @@ use std::borrow; /// As sync::condvar, a mechanism for unlock-and-descheduling and signaling. pub struct Condvar<'self> { + // all were already priv priv is_mutex: bool, priv failed: &'self mut bool, priv cond: &'self sync::Condvar<'self> @@ -108,6 +109,7 @@ impl<'self> Condvar<'self> { ****************************************************************************/ /// An atomically reference counted wrapper for shared immutable state. +// all were already priv pub struct Arc { priv x: UnsafeArc } @@ -162,6 +164,7 @@ struct MutexArcInner { priv lock: Mutex, priv failed: bool, priv data: T } /// An Arc with mutable data protected by a blocking mutex. #[no_freeze] +//All were already priv pub struct MutexArc { priv x: UnsafeArc> } @@ -344,6 +347,7 @@ struct RWArcInner { priv lock: RWLock, priv failed: bool, priv data: T } */ #[no_freeze] pub struct RWArc { + // all were already priv priv x: UnsafeArc>, } @@ -521,15 +525,18 @@ fn borrow_rwlock(state: *mut RWArcInner) -> *RWLock { /// The "write permission" token used for RWArc.write_downgrade(). pub struct RWWriteMode<'self, T> { - data: &'self mut T, - token: sync::RWLockWriteMode<'self>, - poison: PoisonOnFail, + +/// reedlepee added priv in all the feilds below + priv data: &'self mut T, + priv token: sync::RWLockWriteMode<'self>, + priv poison: PoisonOnFail, } /// The "read permission" token used for RWArc.write_downgrade(). pub struct RWReadMode<'self, T> { - data: &'self T, - token: sync::RWLockReadMode<'self>, +/// reedlepee added priv in all the feilds below + priv data: &'self T, + priv token: sync::RWLockReadMode<'self>, } impl<'self, T:Freeze + Send> RWWriteMode<'self, T> { diff --git a/src/libextra/arena.rs b/src/libextra/arena.rs index b684e0d429e31..934217f581b13 100644 --- a/src/libextra/arena.rs +++ b/src/libextra/arena.rs @@ -62,6 +62,7 @@ pub struct Arena { // The head is separated out from the list as a unbenchmarked // microoptimization, to avoid needing to case on the list to // access the head. +/// no change by reedlepee all were already priv priv head: Chunk, priv pod_head: Chunk, priv chunks: @mut MutList, diff --git a/src/libextra/base64.rs b/src/libextra/base64.rs index 3960be4668698..212525508c17b 100644 --- a/src/libextra/base64.rs +++ b/src/libextra/base64.rs @@ -21,12 +21,13 @@ pub enum CharacterSet { /// Contains configuration parameters for `to_base64`. pub struct Config { + /// all were made priv by reedlepee /// Character set to use - char_set: CharacterSet, + priv char_set: CharacterSet, /// True to pad output with `=` characters - pad: bool, + priv pad: bool, /// `Some(len)` to wrap lines at `len`, `None` to disable line wrapping - line_length: Option + priv line_length: Option } /// Configuration for RFC 4648 standard base64 encoding diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs index bf0fde807d3f4..39a5f1d7a6626 100644 --- a/src/libextra/bitv.rs +++ b/src/libextra/bitv.rs @@ -225,10 +225,11 @@ enum Op {Union, Intersect, Assign, Difference} /// The bitvector type #[deriving(Clone)] pub struct Bitv { + /// all were made priv by reedlepee /// Internal representation of the bit vector (small or large) - rep: BitvVariant, + priv rep: BitvVariant, /// The number of valid bits in the internal representation - nbits: uint + priv nbits: uint } fn die() -> ! { @@ -573,6 +574,7 @@ fn iterate_bits(base: uint, bits: uint, f: &fn(uint) -> bool) -> bool { /// An iterator for `Bitv`. pub struct BitvIterator<'self> { + /// all were already priv priv bitv: &'self Bitv, priv next_idx: uint, priv end_idx: uint, @@ -634,6 +636,7 @@ impl<'self> RandomAccessIterator for BitvIterator<'self> { /// as a `uint`. #[deriving(Clone)] pub struct BitvSet { + // all were already priv!! priv size: uint, // In theory this is a `Bitv` instead of always a `BigBitv`, but knowing that @@ -900,6 +903,7 @@ impl BitvSet { } pub struct BitvSetIterator<'self> { + // all were already priv priv set: &'self BitvSet, priv next_idx: uint } diff --git a/src/libextra/c_vec.rs b/src/libextra/c_vec.rs index bd3ce20742ed1..501a71fca1518 100644 --- a/src/libextra/c_vec.rs +++ b/src/libextra/c_vec.rs @@ -44,6 +44,7 @@ use std::util; * The type representing a foreign chunk of memory */ pub struct CVec { + /// No change all were allready priv!! priv base: *mut T, priv len: uint, priv rsrc: @DtorRes, diff --git a/src/libextra/comm.rs b/src/libextra/comm.rs index 4a3801827a211..d96925bce6941 100644 --- a/src/libextra/comm.rs +++ b/src/libextra/comm.rs @@ -23,6 +23,7 @@ use std::comm; /// An extension of `pipes::stream` that allows both sending and receiving. pub struct DuplexStream { +// all were already priv priv chan: Chan, priv port: Port, } @@ -91,8 +92,10 @@ pub fn DuplexStream() } /// An extension of `pipes::stream` that provides synchronous message sending. +// all were already priv pub struct SyncChan { priv duplex_stream: DuplexStream } /// An extension of `pipes::stream` that acknowledges each message received. +// all were already priv pub struct SyncPort { priv duplex_stream: DuplexStream<(), T> } impl GenericChan for SyncChan { diff --git a/src/libextra/crypto/cryptoutil.rs b/src/libextra/crypto/cryptoutil.rs index 97b82383d8432..d6189e33911fd 100644 --- a/src/libextra/crypto/cryptoutil.rs +++ b/src/libextra/crypto/cryptoutil.rs @@ -284,6 +284,7 @@ macro_rules! impl_fixed_buffer( ($name:ident, $size:expr) => ( /// A fixed size buffer of 64 bytes useful for cryptographic operations. pub struct FixedBuffer64 { + // already priv priv buffer: [u8, ..64], priv buffer_idx: uint, } @@ -302,6 +303,7 @@ impl_fixed_buffer!(FixedBuffer64, 64) /// A fixed size buffer of 128 bytes useful for cryptographic operations. pub struct FixedBuffer128 { + // already priv priv buffer: [u8, ..128], priv buffer_idx: uint, } diff --git a/src/libextra/crypto/md5.rs b/src/libextra/crypto/md5.rs index 864fc64f82bec..63ee2ccf79020 100644 --- a/src/libextra/crypto/md5.rs +++ b/src/libextra/crypto/md5.rs @@ -159,6 +159,7 @@ static C4: [u32, ..16] = [ /// The MD5 Digest algorithm pub struct Md5 { + // already priv priv length_bytes: u64, priv buffer: FixedBuffer64, priv state: Md5State, diff --git a/src/libextra/crypto/sha1.rs b/src/libextra/crypto/sha1.rs index 4d4d47feee817..9343124e83df1 100644 --- a/src/libextra/crypto/sha1.rs +++ b/src/libextra/crypto/sha1.rs @@ -43,6 +43,7 @@ static K3: u32 = 0xCA62C1D6u32; /// Structure representing the state of a Sha1 computation pub struct Sha1 { + // already priv priv h: [u32, ..DIGEST_BUF_LEN], priv length_bits: u64, priv buffer: FixedBuffer64, diff --git a/src/libextra/crypto/sha2.rs b/src/libextra/crypto/sha2.rs index fb9a6df50e48c..529cab9133703 100644 --- a/src/libextra/crypto/sha2.rs +++ b/src/libextra/crypto/sha2.rs @@ -234,6 +234,7 @@ impl Engine512 { /// The SHA-512 hash algorithm pub struct Sha512 { + // already priv priv engine: Engine512 } @@ -287,6 +288,7 @@ static H512: [u64, ..8] = [ /// The SHA-384 hash algorithm pub struct Sha384 { + // already priv priv engine: Engine512 } @@ -338,6 +340,7 @@ static H384: [u64, ..8] = [ /// The SHA-512 hash algorithm with digest truncated to 256 bits pub struct Sha512Trunc256 { + // already priv priv engine: Engine512 } @@ -387,6 +390,7 @@ static H512_TRUNC_256: [u64, ..8] = [ /// The SHA-512 hash algorithm with digest truncated to 224 bits pub struct Sha512Trunc224 { + // already priv priv engine: Engine512 } @@ -643,6 +647,7 @@ impl Engine256 { /// The SHA-256 hash algorithm pub struct Sha256 { + // already priv priv engine: Engine256 } @@ -696,6 +701,7 @@ static H256: [u32, ..8] = [ /// The SHA-224 hash algorithm pub struct Sha224 { + // already priv priv engine: Engine256 } diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs index f29cbd6ee5294..102f0eac85336 100644 --- a/src/libextra/dlist.rs +++ b/src/libextra/dlist.rs @@ -32,6 +32,7 @@ use container::Deque; /// A doubly-linked list. pub struct DList { + // all were already priv priv length: uint, priv list_head: Link, priv list_tail: Rawlink>, @@ -49,6 +50,7 @@ struct Node { /// Double-ended DList iterator #[deriving(Clone)] pub struct DListIterator<'self, T> { + // all were already priv priv head: &'self Link, priv tail: Rawlink>, priv nelem: uint, @@ -56,6 +58,7 @@ pub struct DListIterator<'self, T> { /// Double-ended mutable DList iterator pub struct MutDListIterator<'self, T> { + // all were already priv priv list: &'self mut DList, priv head: Rawlink>, priv tail: Rawlink>, @@ -65,6 +68,7 @@ pub struct MutDListIterator<'self, T> { /// DList consuming iterator #[deriving(Clone)] pub struct MoveIterator { + // all were already priv priv list: DList } diff --git a/src/libextra/ebml.rs b/src/libextra/ebml.rs index 006ae3520c60b..ac1edd3f116e5 100644 --- a/src/libextra/ebml.rs +++ b/src/libextra/ebml.rs @@ -30,6 +30,7 @@ struct EbmlState { #[deriving(Clone)] pub struct Doc { + // all these should be public data: @~[u8], start: uint, end: uint, @@ -50,7 +51,9 @@ impl Doc { } pub struct TaggedDoc { - tag: uint, + // was made privv by reedlepee + priv tag: uint, + // should be public doc: Doc, } @@ -284,6 +287,7 @@ pub mod reader { pub fn doc_as_i64(d: Doc) -> i64 { doc_as_u64(d) as i64 } pub struct Decoder { + // all were already priv priv parent: Doc, priv pos: uint, } @@ -618,8 +622,10 @@ pub mod writer { // ebml writing pub struct Encoder { - writer: @io::Writer, - priv size_positions: ~[uint], + /// should be public!! + writer: @io::Writer, + /// this was already privv!! + priv size_positions: ~[uint], } impl Clone for Encoder { diff --git a/src/libextra/enum_set.rs b/src/libextra/enum_set.rs index da9e0a225ba1b..7908f73453ac9 100644 --- a/src/libextra/enum_set.rs +++ b/src/libextra/enum_set.rs @@ -18,6 +18,7 @@ pub struct EnumSet { // We must maintain the invariant that no bits are set // for which no variant exists + // all were already priv priv bits: uint } @@ -100,6 +101,7 @@ impl BitAnd, EnumSet> for EnumSet { /// An iterator over an EnumSet pub struct EnumSetIterator { + // all were already priv priv index: uint, priv bits: uint, } diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs index fda88c583ce0f..abc3f4b98f11d 100644 --- a/src/libextra/fileinput.rs +++ b/src/libextra/fileinput.rs @@ -109,9 +109,10 @@ file is `stdin`. */ #[deriving(Clone)] pub struct FileInputState { - current_path: Option, - line_num: uint, - line_num_file: uint + // all were priv made by reedlepee + priv current_path: Option, + priv line_num: uint, + priv line_num_file: uint } impl FileInputState { @@ -155,7 +156,8 @@ struct FileInput_ { // "self.fi" -> "self." and renaming FileInput_. Documentation above // will likely have to be updated to use `let mut in = ...`. pub struct FileInput { - fi: @mut FileInput_ +/// all were made priv by reedlepee + priv fi: @mut FileInput_ } impl FileInput { diff --git a/src/libextra/future.rs b/src/libextra/future.rs index fdb296e5f403b..f2bedd9bc7a24 100644 --- a/src/libextra/future.rs +++ b/src/libextra/future.rs @@ -32,6 +32,7 @@ use std::util::replace; /// A type encapsulating the result of a computation which may not be complete pub struct Future { + // all were already privv!! priv state: FutureState, } diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs index a0ce29cd1b644..255c3fef24d7c 100644 --- a/src/libextra/getopts.rs +++ b/src/libextra/getopts.rs @@ -112,14 +112,16 @@ pub enum Occur { /// A description of a possible option. #[deriving(Clone, Eq)] pub struct Opt { + + /// reedlepee added priv infront of them!! /// Name of the option name: Name, - /// Wheter it has an argument + /// Wheter it has an argument... should be public!! hasarg: HasArg, - /// How often it can occur + /// How often it can occur... should be private !! occur: Occur, /// Which options it aliases - aliases: ~[Opt], + priv aliases: ~[Opt], } /// Describes wether an option is given at all or has a value. @@ -133,11 +135,14 @@ enum Optval { /// of matches and a vector of free strings. #[deriving(Clone, Eq)] pub struct Matches { + +/// reedlepee added priv infront of all /// Options that matched - opts: ~[Opt], + priv opts: ~[Opt], /// Values of the Options that matched - vals: ~[~[Optval]], + priv vals: ~[~[Optval]], /// Free string fragments + // public free: ~[~str] } diff --git a/src/libextra/glob.rs b/src/libextra/glob.rs index cdcb730e8bed5..a094df4e75603 100644 --- a/src/libextra/glob.rs +++ b/src/libextra/glob.rs @@ -33,6 +33,7 @@ use sort; * pattern - see the `glob` function for more details. */ pub struct GlobIterator { + /// no change by reedlepee all were priv already!! priv root: Path, priv dir_patterns: ~[Pattern], priv options: MatchOptions, @@ -156,6 +157,7 @@ fn list_dir_sorted(path: &Path) -> ~[Path] { */ #[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)] pub struct Pattern { + // already priv priv tokens: ~[PatternToken] } @@ -474,19 +476,20 @@ fn chars_eq(a: char, b: char, case_sensitive: bool) -> bool { */ #[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)] pub struct MatchOptions { +/// all were made priv by reedlepee /** * Whether or not patterns should be matched in a case-sensitive manner. This * currently only considers upper/lower case relationships between ASCII characters, * but in future this might be extended to work with Unicode. */ - case_sensitive: bool, + priv case_sensitive: bool, /** * If this is true then path-component separator characters (e.g. `/` on Posix) * must be matched by a literal `/`, rather than by `*` or `?` or `[...]` */ - require_literal_separator: bool, + priv require_literal_separator: bool, /** * If this is true then paths that contain components that start with a `.` will @@ -494,7 +497,7 @@ pub struct MatchOptions { * will not match. This is useful because such files are conventionally considered * hidden on Unix systems and it might be desirable to skip them when listing files. */ - require_literal_leading_dot: bool + priv require_literal_leading_dot: bool } impl MatchOptions { diff --git a/src/libextra/io_util.rs b/src/libextra/io_util.rs index 904ed13eabbcc..415fa590d4c76 100644 --- a/src/libextra/io_util.rs +++ b/src/libextra/io_util.rs @@ -16,10 +16,11 @@ use std::cast; /// An implementation of the io::Reader interface which reads a buffer of bytes pub struct BufReader { + // all were made priv by reedlepee /// The buffer of bytes to read - buf: ~[u8], + priv buf: ~[u8], /// The current position in the buffer of bytes - pos: @mut uint + priv pos: @mut uint } impl BufReader { diff --git a/src/libextra/json.rs b/src/libextra/json.rs index e151568ad7f81..2ddb389398df0 100644 --- a/src/libextra/json.rs +++ b/src/libextra/json.rs @@ -48,12 +48,13 @@ pub type Object = TreeMap<~str, Json>; /// If an error occurs while parsing some JSON, this is the structure which is /// returned pub struct Error { + // all were made privv by reedlepee /// The line number at which the error occurred - line: uint, + priv line: uint, /// The column number at which the error occurred - col: uint, + priv col: uint, /// A message describing the type of the error - msg: @~str, + priv msg: @~str, } fn escape_str(s: &str) -> ~str { @@ -86,6 +87,7 @@ fn spaces(n: uint) -> ~str { /// A structure for implementing serialization to JSON. pub struct Encoder { + // all were already priv priv wr: @io::Writer, } @@ -243,6 +245,7 @@ impl serialize::Encoder for Encoder { /// Another encoder for JSON, but prints out human-readable JSON instead of /// compact data pub struct PrettyEncoder { + // all were already priv priv wr: @io::Writer, priv indent: uint, } @@ -479,6 +482,7 @@ impl Json{ } pub struct Parser { + // all were already priv priv rdr: ~T, priv ch: char, priv line: uint, @@ -868,6 +872,7 @@ pub fn from_str(s: &str) -> Result { /// A structure to decode JSON to values in rust. pub struct Decoder { + // all were already priv priv stack: ~[Json], } diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs index cd5ccc14cafb1..33803cb5ff3ea 100644 --- a/src/libextra/num/bigint.rs +++ b/src/libextra/num/bigint.rs @@ -86,6 +86,7 @@ A `BigUint`-typed value `BigUint { data: @[a, b, c] }` represents a number */ #[deriving(Clone)] pub struct BigUint { + // already priv priv data: ~[BigDigit] } @@ -893,6 +894,7 @@ impl Neg for Sign { /// A big signed integer type. #[deriving(Clone)] pub struct BigInt { + // already priv priv sign: Sign, priv data: BigUint } diff --git a/src/libextra/num/complex.rs b/src/libextra/num/complex.rs index 58af80fefb787..a59a09c84e272 100644 --- a/src/libextra/num/complex.rs +++ b/src/libextra/num/complex.rs @@ -24,10 +24,11 @@ use std::num::{Zero,One,ToStrRadix}; /// A complex number in Cartesian form. #[deriving(Eq,Clone)] pub struct Cmplx { + // all made real by reedlepee /// Real portion of the complex number - re: T, + priv re: T, /// Imaginary portion of the complex number - im: T + priv im: T } pub type Complex32 = Cmplx; diff --git a/src/libextra/num/rational.rs b/src/libextra/num/rational.rs index abb802c06f3b2..01176f7150f23 100644 --- a/src/libextra/num/rational.rs +++ b/src/libextra/num/rational.rs @@ -20,8 +20,9 @@ use super::bigint::BigInt; #[deriving(Clone)] #[allow(missing_doc)] pub struct Ratio { - numer: T, - denom: T + // made priv by reedlepee + priv numer: T, + priv denom: T } /// Alias for a `Ratio` of machine-sized integers. diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs index 587f83720877d..a5851778ab3f7 100644 --- a/src/libextra/priority_queue.rs +++ b/src/libextra/priority_queue.rs @@ -20,6 +20,7 @@ use std::vec; /// A priority queue implemented with a binary heap #[deriving(Clone)] pub struct PriorityQueue { + // all were already priv priv data: ~[T], } @@ -178,6 +179,7 @@ impl PriorityQueue { /// PriorityQueue iterator pub struct PriorityQueueIterator <'self, T> { + // all were already priv priv iter: vec::VecIterator<'self, T>, } diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs index e7032db5a9195..2946046485231 100644 --- a/src/libextra/ringbuf.rs +++ b/src/libextra/ringbuf.rs @@ -25,6 +25,7 @@ static MINIMUM_CAPACITY: uint = 2u; /// RingBuf is a circular buffer that implements Deque. #[deriving(Clone)] pub struct RingBuf { + // all were already priv priv nelts: uint, priv lo: uint, priv elts: ~[Option] @@ -248,6 +249,7 @@ macro_rules! iterator_rev { /// RingBuf iterator pub struct RingBufIterator<'self, T> { + // all were already priv priv lo: uint, priv index: uint, priv rindex: uint, @@ -275,6 +277,7 @@ impl<'self, T> RandomAccessIterator<&'self T> for RingBufIterator<'self, T> { /// RingBuf mutable iterator pub struct RingBufMutIterator<'self, T> { + // all were already priv priv lo: uint, priv index: uint, priv rindex: uint, diff --git a/src/libextra/semver.rs b/src/libextra/semver.rs index e5ef9ee12d5a4..b9225e66399d1 100644 --- a/src/libextra/semver.rs +++ b/src/libextra/semver.rs @@ -70,18 +70,19 @@ impl ToStr for Identifier { /// Represents a version number conforming to the semantic versioning scheme. #[deriving(Clone, Eq)] pub struct Version { + /// reedlepee added priv in all /// The major version, to be incremented on incompatible changes. - major: uint, + priv major: uint, /// The minor version, to be incremented when functionality is added in a /// backwards-compatible manner. - minor: uint, + priv minor: uint, /// The patch version, to be incremented when backwards-compatible bug /// fixes are made. - patch: uint, + priv patch: uint, /// The pre-release version identifier, if one exists. - pre: ~[Identifier], + priv pre: ~[Identifier], /// The build metadata, ignored when determining version precedence. - build: ~[Identifier], + priv build: ~[Identifier], } impl ToStr for Version { diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs index 0ca0ff66039d8..c0d40514c4cca 100644 --- a/src/libextra/smallintmap.rs +++ b/src/libextra/smallintmap.rs @@ -22,6 +22,7 @@ use std::vec; #[allow(missing_doc)] pub struct SmallIntMap { + /// all were already priv!! priv v: ~[Option], } @@ -233,6 +234,7 @@ macro_rules! double_ended_iterator { } pub struct SmallIntMapIterator<'self, T> { + /// all were already priv!! priv front: uint, priv back: uint, priv iter: VecIterator<'self, Option> @@ -243,6 +245,7 @@ double_ended_iterator!(impl SmallIntMapIterator -> (uint, &'self T), get_ref) pub type SmallIntMapRevIterator<'self, T> = Invert>; pub struct SmallIntMapMutIterator<'self, T> { + /// all were already priv!! priv front: uint, priv back: uint, priv iter: VecMutIterator<'self, Option> diff --git a/src/libextra/stats.rs b/src/libextra/stats.rs index cc6ce715ad331..3e252e30842db 100644 --- a/src/libextra/stats.rs +++ b/src/libextra/stats.rs @@ -105,18 +105,24 @@ pub trait Stats { #[deriving(Clone, Eq)] #[allow(missing_doc)] pub struct Summary { - sum: f64, + /// all were made privv by reedlepee + priv sum: f64, + // public min: f64, + // public max: f64, - mean: f64, + priv mean: f64, + // public median: f64, - var: f64, - std_dev: f64, - std_dev_pct: f64, + priv var: f64, + priv std_dev: f64, + priv std_dev_pct: f64, + // public median_abs_dev: f64, + // public median_abs_dev_pct: f64, - quartiles: (f64,f64,f64), - iqr: f64, + priv quartiles: (f64,f64,f64), + priv iqr: f64, } impl Summary { diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs index 5a2c1e0998ca7..cda912857d739 100644 --- a/src/libextra/sync.rs +++ b/src/libextra/sync.rs @@ -167,6 +167,9 @@ enum ReacquireOrderLock<'self> { /// A mechanism for atomic-unlock-and-deschedule blocking and signalling. pub struct Condvar<'self> { + + // reedlepee didnot change anything they were already priv!!! + // The 'Sem' object associated with this condvar. This is the one that's // atomically-unlocked-and-descheduled upon and reacquired during wakeup. priv sem: &'self Sem<~[WaitQueue]>, @@ -376,8 +379,9 @@ impl Semaphore { * A task which fails while holding a mutex will unlock the mutex as it * unwinds. */ -pub struct Mutex { priv sem: Sem<~[WaitQueue]> } +// reedlepee did not change !! +pub struct Mutex { priv sem: Sem<~[WaitQueue]> } impl Clone for Mutex { /// Create a new handle to the mutex. fn clone(&self) -> Mutex { Mutex { sem: Sem((*self.sem).clone()) } } @@ -444,6 +448,7 @@ struct RWLockInner { * unwinds. */ pub struct RWLock { + // reedlepee did not change they were already priv!! priv order_lock: Semaphore, priv access_lock: Sem<~[WaitQueue]>, priv state: UnsafeArc, @@ -663,9 +668,12 @@ impl RWLock { } /// The "write permission" token used for rwlock.write_downgrade(). + +// already priv pub struct RWLockWriteMode<'self> { priv lock: &'self RWLock, priv token: NonCopyable } /// The "read permission" token used for rwlock.write_downgrade(). +// already priv pub struct RWLockReadMode<'self> { priv lock: &'self RWLock, priv token: NonCopyable } diff --git a/src/libextra/task_pool.rs b/src/libextra/task_pool.rs index 804ccd2a9fde3..50ddac3f84b2d 100644 --- a/src/libextra/task_pool.rs +++ b/src/libextra/task_pool.rs @@ -28,8 +28,9 @@ enum Msg { } pub struct TaskPool { - channels: ~[Chan>], - next_index: uint, + /// all were made priv by reedlepee + priv channels: ~[Chan>], + priv next_index: uint, } #[unsafe_destructor] diff --git a/src/libextra/tempfile.rs b/src/libextra/tempfile.rs index d8fa130916a46..f2a022de233c9 100644 --- a/src/libextra/tempfile.rs +++ b/src/libextra/tempfile.rs @@ -18,6 +18,7 @@ use std::rand; /// A wrapper for a path to temporary directory implementing automatic /// scope-pased deletion. pub struct TempDir { + // all were already priv!! priv path: Option } diff --git a/src/libextra/term.rs b/src/libextra/term.rs index cebe0ba9aa659..095afe7f77ea6 100644 --- a/src/libextra/term.rs +++ b/src/libextra/term.rs @@ -95,14 +95,19 @@ fn cap_for_attr(attr: attr::Attr) -> &'static str { #[cfg(not(target_os = "win32"))] pub struct Terminal { - num_colors: u16, + +// this was made priv by reedlepee + priv num_colors: u16, + // These were already priv priv out: @io::Writer, priv ti: ~TermInfo } #[cfg(target_os = "win32")] pub struct Terminal { - num_colors: u16, + // this was made priv by reedlepee + priv num_colors: u16, + // These were already priv priv out: @io::Writer, } diff --git a/src/libextra/terminfo/parm.rs b/src/libextra/terminfo/parm.rs index d1a0a86334af4..618067efb326d 100644 --- a/src/libextra/terminfo/parm.rs +++ b/src/libextra/terminfo/parm.rs @@ -47,10 +47,11 @@ pub enum Param { /// Container for static and dynamic variable arrays pub struct Variables { + // made priv by redlpee /// Static variables A-Z - sta: [Param, ..26], + priv sta: [Param, ..26], /// Dynamic variables a-z - dyn: [Param, ..26] + priv dyn: [Param, ..26] } impl Variables { diff --git a/src/libextra/terminfo/terminfo.rs b/src/libextra/terminfo/terminfo.rs index 57e00885b2fb1..691f5420dc85c 100644 --- a/src/libextra/terminfo/terminfo.rs +++ b/src/libextra/terminfo/terminfo.rs @@ -14,10 +14,11 @@ use std::hashmap::HashMap; /// A parsed terminfo entry. pub struct TermInfo { + // made priv by redlpee /// Names for the terminal - names: ~[~str], + priv names: ~[~str], /// Map of capability name to boolean value - bools: HashMap<~str, bool>, + priv bools: HashMap<~str, bool>, /// Map of capability name to numeric value numbers: HashMap<~str, u16>, /// Map of capability name to raw (unexpanded) string diff --git a/src/libextra/test.rs b/src/libextra/test.rs index 1f8405dca9498..78ee0db399e73 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -102,9 +102,11 @@ impl TestFn { // Structure passed to BenchFns pub struct BenchHarness { - iterations: u64, - ns_start: u64, - ns_end: u64, + // all changed to priv by reedlepee + priv iterations: u64, + priv ns_start: u64, + priv ns_end: u64, + // should be public bytes: u64 } @@ -112,23 +114,27 @@ pub struct BenchHarness { // these. #[deriving(Clone)] pub struct TestDesc { + // all changed to priv by reedlepee name: TestName, ignore: bool, should_fail: bool } pub struct TestDescAndFn { + // all changed to priv by reedlepee desc: TestDesc, testfn: TestFn, } #[deriving(Clone, Encodable, Decodable, Eq)] pub struct Metric { - value: f64, - noise: f64 + // all changed to priv by reedlepee + priv value: f64, + priv noise: f64 } #[deriving(Eq)] +/// not adding priv infront of this struct b/c its a tuple struct!! - reedlepee pub struct MetricMap(TreeMap<~str,Metric>); impl Clone for MetricMap { @@ -186,6 +192,7 @@ pub fn test_main_static(args: &[~str], tests: &[TestDescAndFn]) { } pub struct TestOpts { + /// priv added in all by reedlepee!! filter: Option<~str>, run_ignored: bool, run_tests: bool, @@ -322,8 +329,9 @@ pub fn opt_shard(maybestr: Option<~str>) -> Option<(uint,uint)> { #[deriving(Clone, Eq)] pub struct BenchSamples { - ns_iter_summ: stats::Summary, - mb_s: uint + /// priv added in all by reedlepee + priv ns_iter_summ: stats::Summary, + priv mb_s: uint } #[deriving(Clone, Eq)] diff --git a/src/libextra/time.rs b/src/libextra/time.rs index ab701f1f982c8..5b1754e7243f6 100644 --- a/src/libextra/time.rs +++ b/src/libextra/time.rs @@ -31,9 +31,11 @@ pub mod rustrt { } /// A record specifying a time value in seconds and nanoseconds. -#[deriving(Clone, DeepClone, Eq, Encodable, Decodable)] -pub struct Timespec { sec: i64, nsec: i32 } +/// all were made priv reedlepee + +#[deriving(Clone, DeepClone, Eq, Encodable, Decodable)] +pub struct Timespec { priv sec: i64, priv nsec: i32 } /* * Timespec assumes that pre-epoch Timespecs have negative sec and positive * nsec fields. Darwin's and Linux's struct timespec functions handle pre- @@ -105,18 +107,19 @@ pub fn tzset() { #[deriving(Clone, DeepClone, Eq, Encodable, Decodable)] pub struct Tm { - tm_sec: i32, // seconds after the minute ~[0-60] - tm_min: i32, // minutes after the hour ~[0-59] - tm_hour: i32, // hours after midnight ~[0-23] - tm_mday: i32, // days of the month ~[1-31] - tm_mon: i32, // months since January ~[0-11] - tm_year: i32, // years since 1900 - tm_wday: i32, // days since Sunday ~[0-6] - tm_yday: i32, // days since January 1 ~[0-365] - tm_isdst: i32, // Daylight Savings Time flag - tm_gmtoff: i32, // offset from UTC in seconds - tm_zone: ~str, // timezone abbreviation - tm_nsec: i32, // nanoseconds + /// all were made priv by reedlepee + priv tm_sec: i32, // seconds after the minute ~[0-60] + priv tm_min: i32, // minutes after the hour ~[0-59] + priv tm_hour: i32, // hours after midnight ~[0-23] + priv tm_mday: i32, // days of the month ~[1-31] + priv tm_mon: i32, // months since January ~[0-11] + priv tm_year: i32, // years since 1900 + priv tm_wday: i32, // days since Sunday ~[0-6] + priv tm_yday: i32, // days since January 1 ~[0-365] + priv tm_isdst: i32, // Daylight Savings Time flag + priv tm_gmtoff: i32, // offset from UTC in seconds + priv tm_zone: ~str, // timezone abbreviation + priv tm_nsec: i32, // nanoseconds } pub fn empty_tm() -> Tm { diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs index ad196b32fb2ca..ebb3494b5ebb0 100644 --- a/src/libextra/treemap.rs +++ b/src/libextra/treemap.rs @@ -36,6 +36,7 @@ use std::cmp::Ordering; #[allow(missing_doc)] #[deriving(Clone)] pub struct TreeMap { + /// all were already priv!! priv root: Option<~TreeNode>, priv length: uint } @@ -229,6 +230,7 @@ impl TreeMap { /// Lazy forward iterator over a map pub struct TreeMapIterator<'self, K, V> { + // all were already priv priv stack: ~[&'self ~TreeNode], priv node: &'self Option<~TreeNode>, priv remaining_min: uint, @@ -275,6 +277,7 @@ impl<'self, K, V> Iterator<(&'self K, &'self V)> for TreeMapIterator<'self, K, V /// Lazy backward iterator over a map pub struct TreeMapRevIterator<'self, K, V> { + // all were already priv priv iter: TreeMapIterator<'self, K, V>, } @@ -333,6 +336,7 @@ fn iter_traverse_complete<'a, K, V>(it: &mut TreeMapIterator<'a, K, V>) { /// Lazy forward iterator over a map that consumes the map while iterating pub struct TreeMapMoveIterator { + // all were laready priv!! priv stack: ~[TreeNode], priv remaining: uint } @@ -401,6 +405,7 @@ impl<'self, T> Iterator<&'self T> for TreeSetRevIterator<'self, T> { /// only requirement is that the type of the elements contained ascribes to the /// `TotalOrd` trait. pub struct TreeSet { + //all were already priv priv map: TreeMap } @@ -553,34 +558,40 @@ impl TreeSet { /// Lazy forward iterator over a set pub struct TreeSetIterator<'self, T> { + // all were already priv priv iter: TreeMapIterator<'self, T, ()> } /// Lazy backward iterator over a set pub struct TreeSetRevIterator<'self, T> { + // all were already priv priv iter: TreeMapRevIterator<'self, T, ()> } /// Lazy iterator producing elements in the set difference (in-order) pub struct Difference<'self, T> { + // all were already priv priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, } /// Lazy iterator producing elements in the set symmetric difference (in-order) pub struct SymDifference<'self, T> { + // all were already priv priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, } /// Lazy iterator producing elements in the set intersection (in-order) pub struct Intersection<'self, T> { + // all were already priv priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, } /// Lazy iterator producing elements in the set intersection (in-order) pub struct Union<'self, T> { + // all were already priv priv a: Peekable<&'self T, TreeSetIterator<'self, T>>, priv b: Peekable<&'self T, TreeSetIterator<'self, T>>, } diff --git a/src/libextra/url.rs b/src/libextra/url.rs index e836d3b52709c..103d185aa1eac 100644 --- a/src/libextra/url.rs +++ b/src/libextra/url.rs @@ -22,19 +22,21 @@ use std::uint; #[deriving(Clone, Eq)] pub struct Url { - scheme: ~str, - user: Option, - host: ~str, - port: Option<~str>, - path: ~str, - query: Query, - fragment: Option<~str> + // all were made privv bt reedlepee + priv scheme: ~str, + priv user: Option, + priv host: ~str, + priv port: Option<~str>, + priv path: ~str, + priv query: Query, + priv fragment: Option<~str> } #[deriving(Clone, Eq)] pub struct UserInfo { - user: ~str, - pass: Option<~str> + // all were made privv bt reedlepee + priv user: ~str, + priv pass: Option<~str> } pub type Query = ~[(~str, ~str)]; diff --git a/src/libextra/uuid.rs b/src/libextra/uuid.rs index 345cf64f1281a..fa5c302faeec7 100644 --- a/src/libextra/uuid.rs +++ b/src/libextra/uuid.rs @@ -102,6 +102,7 @@ pub enum UuidVariant { /// A Universally Unique Identifier (UUID) pub struct Uuid { /// The 128-bit number stored in 16 bytes + /// should be public bytes: UuidBytes } diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs index 3ee1025132315..f30fa3362c511 100644 --- a/src/libextra/workcache.rs +++ b/src/libextra/workcache.rs @@ -128,8 +128,9 @@ impl WorkMap { } pub struct Database { - db_filename: Path, - db_cache: TreeMap<~str, ~str>, + /// all were made by reedlepee + priv db_filename: Path, + priv db_cache: TreeMap<~str, ~str>, db_dirty: bool } @@ -209,7 +210,8 @@ impl Drop for Database { pub struct Logger { // FIXME #4432: Fill in - a: () + /// alll were made priv reeldepee + priv a: () } impl Logger { @@ -227,27 +229,30 @@ pub type FreshnessMap = TreeMap<~str,extern fn(&str,&str)->bool>; #[deriving(Clone)] pub struct Context { +//// all were made priv by reedlepee db: RWArc, - logger: RWArc, - cfg: Arc, + priv logger: RWArc, + priv cfg: Arc, /// Map from kinds (source, exe, url, etc.) to a freshness function. /// The freshness function takes a name (e.g. file path) and value /// (e.g. hash of file contents) and determines whether it's up-to-date. /// For example, in the file case, this would read the file off disk, /// hash it, and return the result of comparing the given hash and the /// read hash for equality. - freshness: Arc + priv freshness: Arc } pub struct Prep<'self> { - ctxt: &'self Context, - fn_name: &'self str, - declared_inputs: WorkMap, +//// all were made priv by reedlepee + priv ctxt: &'self Context, + priv fn_name: &'self str, + priv declared_inputs: WorkMap, } pub struct Exec { - discovered_inputs: WorkMap, - discovered_outputs: WorkMap +//// all were made priv by reedlepee + priv discovered_inputs: WorkMap, + priv discovered_outputs: WorkMap } enum Work<'self, T> { diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index acfa02a4defd5..2f1ac2c6b6b58 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -92,6 +92,7 @@ condition! { /// This structure wraps a `*libc::c_char`, and will automatically free the /// memory it is pointing to when it goes out of scope. pub struct CString { + // already priv priv buf: *libc::c_char, priv owns_buffer_: bool, } @@ -332,6 +333,7 @@ fn check_for_null(v: &[u8], buf: *mut libc::c_char) { /// /// Use with the `std::iterator` module. pub struct CStringIterator<'self> { + // already priv priv ptr: *libc::c_char, priv lifetime: &'self libc::c_char, // FIXME: #5922 } diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs index a1459b780dfb3..e1ba46e8f2750 100644 --- a/src/libstd/cell.rs +++ b/src/libstd/cell.rs @@ -26,6 +26,7 @@ Similar to a mutable option type, but friendlier. #[deriving(Clone, DeepClone, Eq)] #[allow(missing_doc)] pub struct Cell { + // already priv priv value: Option } diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs index cb9552b189ce5..346e8a51322a1 100644 --- a/src/libstd/condition.rs +++ b/src/libstd/condition.rs @@ -72,6 +72,7 @@ use unstable::raw::Closure; #[doc(hidden)] pub struct Handler { + //already priv priv handle: Closure, priv prev: Option<@Handler>, } @@ -83,6 +84,7 @@ pub struct Handler { /// This struct should never be created directly, but rather only through the /// `condition!` macro provided to all libraries using libstd. pub struct Condition { + // all made priv by reedlepee /// Name of the condition handler name: &'static str, /// TLS key used to insert/remove values in TLS. diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs index e7fa81fc87ac9..b47559b6055f5 100644 --- a/src/libstd/fmt/mod.rs +++ b/src/libstd/fmt/mod.rs @@ -477,8 +477,9 @@ pub mod rt; /// should be formatted. A mutable version of this is passed to all formatting /// traits. pub struct Formatter<'self> { + // made by reedlepee /// Flags for formatting (packed version of rt::Flag) - flags: uint, + flags: uint, /// Character used as 'fill' whenever there is alignment fill: char, /// Boolean indication of whether the output should be left-aligned @@ -486,11 +487,12 @@ pub struct Formatter<'self> { /// Optionally specified integer width that the output should be width: Option, /// Optionally specified precision for numeric types - precision: Option, + precision: Option, /// Output buffer. buf: &'self mut io::Writer, + // already priv priv curarg: vec::VecIterator<'self, Argument<'self>>, priv args: &'self [Argument<'self>], } @@ -500,6 +502,7 @@ pub struct Formatter<'self> { /// compile time it is ensured that the function and the value have the correct /// types, and then this struct is used to canonicalize arguments to one type. pub struct Argument<'self> { + // already priv priv formatter: extern "Rust" fn(&util::Void, &mut Formatter), priv value: &'self util::Void, } @@ -526,6 +529,7 @@ impl<'self> Arguments<'self> { /// string at compile-time so usage of the `write` and `format` functions can /// be safely performed. pub struct Arguments<'self> { + // already priv priv fmt: &'self [rt::Piece<'self>], priv args: &'self [Argument<'self>], } diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs index 504050f9a771a..fea512c08b4a5 100644 --- a/src/libstd/fmt/parse.rs +++ b/src/libstd/fmt/parse.rs @@ -38,17 +38,20 @@ pub enum Piece<'self> { /// Representation of an argument specification. #[deriving(Eq)] pub struct Argument<'self> { + // made by reedlepee /// Where to find this argument position: Position<'self>, - /// How to format the argument + /// How to format the argument format: FormatSpec<'self>, /// If not `None`, what method to invoke on the argument + // should be public method: Option<~Method<'self>> } /// Specification for the formatting of an argument in the format string. #[deriving(Eq)] pub struct FormatSpec<'self> { + // made by reedlepee /// Optionally specified character to fill alignment with fill: Option, /// Optionally specified alignment @@ -125,6 +128,7 @@ pub enum Method<'self> { /// Structure representing one "arm" of the `plural` function. #[deriving(Eq)] pub struct PluralArm<'self> { + // made by reedlepee /// A selector can either be specified by a keyword or with an integer /// literal. selector: Either, @@ -145,6 +149,7 @@ pub enum PluralKeyword { /// Structure representing one "arm" of the `select` function. #[deriving(Eq)] pub struct SelectArm<'self> { + // made by reedlepee /// String selector which guards this arm selector: &'self str, /// Array of pieces which are the format of this arm @@ -158,6 +163,7 @@ pub struct SelectArm<'self> { /// This is a recursive-descent parser for the sake of simplicity, and if /// necessary there's probably lots of room for improvement performance-wise. pub struct Parser<'self> { + // already priv priv input: &'self str, priv cur: str::CharOffsetIterator<'self>, priv depth: uint, diff --git a/src/libstd/fmt/rt.rs b/src/libstd/fmt/rt.rs index b20af1a35b8c7..a623695c8a1b5 100644 --- a/src/libstd/fmt/rt.rs +++ b/src/libstd/fmt/rt.rs @@ -29,16 +29,18 @@ pub enum Piece<'self> { } pub struct Argument<'self> { + /// should be public position: Position, format: FormatSpec, method: Option<&'self Method<'self>> } pub struct FormatSpec { + /// made by redlepee fill: char, align: parse::Alignment, flags: uint, - precision: Count, + precision: Count, width: Count, } @@ -56,11 +58,13 @@ pub enum Method<'self> { } pub struct PluralArm<'self> { + /// made by redlepee selector: Either, result: &'self [Piece<'self>], } pub struct SelectArm<'self> { + /// made by redlepee selector: &'self str, result: &'self [Piece<'self>], } diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs index edefd39ebb4d1..ec792510271a5 100644 --- a/src/libstd/hashmap.rs +++ b/src/libstd/hashmap.rs @@ -48,6 +48,7 @@ struct Bucket { /// `IterBytes` traits as `Hash` is automatically implemented for types that /// implement `IterBytes`. pub struct HashMap { + // already priv priv k0: u64, priv k1: u64, priv resize_at: uint, @@ -517,27 +518,32 @@ impl Clone for HashMap { /// HashMap iterator #[deriving(Clone)] pub struct HashMapIterator<'self, K, V> { + // already priv priv iter: vec::VecIterator<'self, Option>>, } /// HashMap mutable values iterator pub struct HashMapMutIterator<'self, K, V> { + // already priv priv iter: vec::VecMutIterator<'self, Option>>, } /// HashMap move iterator pub struct HashMapMoveIterator { + // already priv priv iter: vec::MoveRevIterator>>, } /// HashSet iterator #[deriving(Clone)] pub struct HashSetIterator<'self, K> { + // already priv priv iter: vec::VecIterator<'self, Option>>, } /// HashSet move iterator pub struct HashSetMoveIterator { + // already priv priv iter: vec::MoveRevIterator>>, } @@ -631,6 +637,7 @@ impl Default for HashMap { /// HashMap where the value is (). As with the `HashMap` type, a `HashSet` /// requires that the elements implement the `Eq` and `Hash` traits. pub struct HashSet { + // already priv priv map: HashMap } diff --git a/src/libstd/io.rs b/src/libstd/io.rs index 94a6b7cfea8dd..297ba84fbf9fb 100644 --- a/src/libstd/io.rs +++ b/src/libstd/io.rs @@ -1009,7 +1009,8 @@ impl Reader for Wrapper { } pub struct FILERes { - f: *libc::FILE, + // all by reedlepee + priv f: *libc::FILE, } impl FILERes { @@ -1080,6 +1081,7 @@ pub fn file_reader(path: &Path) -> Result<@Reader, ~str> { // Byte readers pub struct BytesReader { + // all by reedlepee // FIXME(#5723) see other FIXME below // FIXME(#7268) this should also be parameterized over <'self> bytes: &'static [u8], @@ -1282,7 +1284,8 @@ impl Writer for fd_t { } pub struct FdRes { - fd: fd_t, + // all by reedlepee + priv fd: fd_t, } impl FdRes { @@ -1674,6 +1677,7 @@ pub fn println(s: &str) { } pub struct BytesWriter { + // all by reedlepee bytes: @mut ~[u8], pos: @mut uint, } @@ -1792,7 +1796,8 @@ pub mod fsync { // Artifacts that need to fsync on destruction pub struct Res { - arg: Arg, + // all by reedlepee + priv arg: Arg, } impl Res { @@ -1815,9 +1820,10 @@ pub mod fsync { } pub struct Arg { - val: t, - opt_level: Option, - fsync_fn: extern "Rust" fn(f: &t, Level) -> int, + // all by reedlepee + priv val: t, + priv opt_level: Option, + priv fsync_fn: extern "Rust" fn(f: &t, Level) -> int, } // fsync file after executing blk diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs index 01af3d931573c..4985557dff787 100644 --- a/src/libstd/iter.rs +++ b/src/libstd/iter.rs @@ -765,6 +765,8 @@ impl, U: ExactSize> ExactSize<(A, B)> for Zip {} /// An double-ended iterator with the direction inverted #[deriving(Clone)] pub struct Invert { + // already priv + // already priv priv iter: T } @@ -792,6 +794,7 @@ impl + RandomAccessIterator> RandomAccessIterato /// A mutable reference to an iterator pub struct ByRef<'self, T> { + // already priv priv iter: &'self mut T } @@ -927,6 +930,7 @@ impl> ClonableIterator for T { /// An iterator that repeats endlessly #[deriving(Clone)] pub struct Cycle { + // already priv priv orig: T, priv iter: T, } @@ -978,6 +982,7 @@ impl> RandomAccessIterator for Cycle /// An iterator which strings two iterators together #[deriving(Clone)] pub struct Chain { + // already priv priv a: T, priv b: U, priv flag: bool @@ -1047,6 +1052,7 @@ for Chain { /// An iterator which iterates two other iterators simultaneously #[deriving(Clone)] pub struct Zip { + // already priv priv a: T, priv b: U } @@ -1125,6 +1131,7 @@ RandomAccessIterator<(A, B)> for Zip { /// An iterator which maps the values of `iter` with `f` pub struct Map<'self, A, B, T> { + // already priv priv iter: T, priv f: &'self fn(A) -> B } @@ -1174,6 +1181,7 @@ impl<'self, A, B, T: RandomAccessIterator> RandomAccessIterator for Map<'s /// An iterator which filters the elements of `iter` with `predicate` pub struct Filter<'self, A, T> { + // already priv priv iter: T, priv predicate: &'self fn(&A) -> bool } @@ -1218,6 +1226,7 @@ impl<'self, A, T: DoubleEndedIterator> DoubleEndedIterator for Filter<'sel /// An iterator which uses `f` to both filter and map elements from `iter` pub struct FilterMap<'self, A, B, T> { + // already priv priv iter: T, priv f: &'self fn(A) -> Option } @@ -1262,6 +1271,7 @@ for FilterMap<'self, A, B, T> { /// An iterator which yields the current count and the element during iteration #[deriving(Clone)] pub struct Enumerate { + // already priv priv iter: T, priv count: uint } @@ -1316,6 +1326,7 @@ impl> RandomAccessIterator<(uint, A)> for Enumerat /// An iterator with a `peek()` that returns an optional reference to the next element. pub struct Peekable { + // already priv priv iter: T, priv peeked: Option, } @@ -1360,6 +1371,7 @@ impl<'self, A, T: Iterator> Peekable { /// An iterator which rejects elements while `predicate` is true pub struct SkipWhile<'self, A, T> { + // already priv priv iter: T, priv flag: bool, priv predicate: &'self fn(&A) -> bool @@ -1398,6 +1410,7 @@ impl<'self, A, T: Iterator> Iterator for SkipWhile<'self, A, T> { /// An iterator which only accepts elements while `predicate` is true pub struct TakeWhile<'self, A, T> { + // already priv priv iter: T, priv flag: bool, priv predicate: &'self fn(&A) -> bool @@ -1433,6 +1446,7 @@ impl<'self, A, T: Iterator> Iterator for TakeWhile<'self, A, T> { /// An iterator which skips over `n` elements of `iter`. #[deriving(Clone)] pub struct Skip { + // already priv priv iter: T, priv n: uint } @@ -1497,6 +1511,7 @@ impl> RandomAccessIterator for Skip { /// An iterator which only iterates over the first `n` iterations of `iter`. #[deriving(Clone)] pub struct Take { + // already priv priv iter: T, priv n: uint } @@ -1546,11 +1561,13 @@ impl> RandomAccessIterator for Take { /// An iterator to maintain state while iterating another iterator pub struct Scan<'self, A, B, T, St> { + // already priv priv iter: T, priv f: &'self fn(&mut St, A) -> Option, /// The current internal state to be passed to the closure next. - state: St + // priv by reedlepee + priv state: St } impl<'self, A, B, T: Iterator, St> Iterator for Scan<'self, A, B, T, St> { @@ -1570,6 +1587,7 @@ impl<'self, A, B, T: Iterator, St> Iterator for Scan<'self, A, B, T, St> { /// and yields the elements of the produced iterators /// pub struct FlatMap<'self, A, T, U> { + // already priv priv iter: T, priv f: &'self fn(A) -> U, priv frontiter: Option, @@ -1629,6 +1647,7 @@ impl<'self, /// yields `None` once. #[deriving(Clone, DeepClone)] pub struct Fuse { + // already priv priv iter: T, priv done: bool } @@ -1701,6 +1720,7 @@ impl Fuse { /// An iterator that calls a function with a reference to each /// element before yielding it. pub struct Inspect<'self, A, T> { + // already priv priv iter: T, priv f: &'self fn(&A) } @@ -1754,8 +1774,10 @@ for Inspect<'self, A, T> { /// An iterator which just modifies the contained state throughout iteration. pub struct Unfold<'self, A, St> { + // already priv priv f: &'self fn(&mut St) -> Option, /// Internal state that will be yielded on the next iteration + /// priv reedlepee state: St } @@ -1789,10 +1811,11 @@ impl<'self, A, St> Iterator for Unfold<'self, A, St> { /// iteration #[deriving(Clone)] pub struct Counter { + // by reedlepee /// The current state the counter is at (next value to be yielded) - state: A, + priv state: A, /// The amount that this iterator is stepping by - step: A + priv step: A } /// Creates a new counter with the specified start/step @@ -1818,6 +1841,7 @@ impl + Clone> Iterator for Counter { /// An iterator over the range [start, stop) #[deriving(Clone, DeepClone)] pub struct Range { + // already priv priv state: A, priv stop: A, priv one: A @@ -1862,6 +1886,7 @@ impl DoubleEndedIterator for Range { /// An iterator over the range [start, stop] #[deriving(Clone, DeepClone)] pub struct RangeInclusive { + // already priv priv range: Range, priv done: bool } @@ -1923,6 +1948,7 @@ impl + Integer + Ord + Clone> DoubleEndedIterator for RangeInclu /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[deriving(Clone, DeepClone)] pub struct RangeStep { + // already priv priv state: A, priv stop: A, priv step: A, @@ -1955,6 +1981,7 @@ impl Iterator for RangeStep { /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[deriving(Clone, DeepClone)] pub struct RangeStepInclusive { + // already priv priv state: A, priv stop: A, priv step: A, @@ -1990,6 +2017,7 @@ impl Iterator for RangeStepInclusive { /// An iterator that repeats an element endlessly #[deriving(Clone, DeepClone)] pub struct Repeat { + // already priv priv element: A } diff --git a/src/libstd/libc.rs b/src/libstd/libc.rs index d4df0e826f604..67d64596460f4 100644 --- a/src/libstd/libc.rs +++ b/src/libstd/libc.rs @@ -226,15 +226,16 @@ pub mod types { use libc::types::common::c95::{c_void}; use libc::types::os::arch::c95::{c_char, size_t}; pub struct glob_t { - gl_pathc: size_t, - gl_pathv: **c_char, - gl_offs: size_t, - - __unused1: *c_void, - __unused2: *c_void, - __unused3: *c_void, - __unused4: *c_void, - __unused5: *c_void, + // all made by reedlepee + priv gl_pathc: size_t, + priv gl_pathv: **c_char, + priv gl_offs: size_t, + + priv __unused1: *c_void, + priv __unused2: *c_void, + priv __unused3: *c_void, + __unused4: *c_void, + __unused5: *c_void, } } } @@ -304,15 +305,16 @@ pub mod types { pub type blkcnt_t = i32; pub struct stat { + // all made by reedlepee st_dev: dev_t, - __pad1: c_short, + __pad1: c_short, st_ino: ino_t, st_mode: mode_t, st_nlink: nlink_t, - st_uid: uid_t, + st_uid: uid_t, st_gid: gid_t, - st_rdev: dev_t, - __pad2: c_short, + st_rdev: dev_t, + __pad2: c_short, st_size: off_t, st_blksize: blksize_t, st_blocks: blkcnt_t, @@ -323,7 +325,7 @@ pub mod types { st_ctime: time_t, st_ctime_nsec: c_long, __unused4: c_long, - __unused5: c_long, + __unused5: c_long, } } #[cfg(target_arch = "arm")] @@ -337,15 +339,16 @@ pub mod types { pub type blkcnt_t = u32; pub struct stat { + // all made priv by reedlepee st_dev: c_ulonglong, - __pad0: [c_uchar, ..4], - __st_ino: ino_t, + priv __pad0: [c_uchar, ..4], + priv __st_ino: ino_t, st_mode: c_uint, st_nlink: c_uint, - st_uid: uid_t, - st_gid: gid_t, - st_rdev: c_ulonglong, - __pad3: [c_uchar, ..4], + st_uid: uid_t, + st_gid: gid_t, + st_rdev: c_ulonglong, + priv __pad3: [c_uchar, ..4], st_size: c_longlong, st_blksize: blksize_t, st_blocks: c_ulonglong, @@ -353,8 +356,8 @@ pub mod types { st_atime_nsec: c_ulong, st_mtime: time_t, st_mtime_nsec: c_ulong, - st_ctime: time_t, - st_ctime_nsec: c_ulong, + st_ctime: time_t, + st_ctime_nsec: c_ulong, st_ino: c_ulonglong } } @@ -370,17 +373,18 @@ pub mod types { pub type blkcnt_t = i32; pub struct stat { + /// all made priv by reedlepee st_dev: c_ulong, - st_pad1: [c_long, ..3], + priv st_pad1: [c_long, ..3], st_ino: ino_t, st_mode: mode_t, st_nlink: nlink_t, st_uid: uid_t, st_gid: gid_t, st_rdev: c_ulong, - st_pad2: [c_long, ..2], + priv st_pad2: [c_long, ..2], st_size: off_t, - st_pad3: c_long, + priv st_pad3: c_long, st_atime: time_t, st_atime_nsec: c_long, st_mtime: time_t, @@ -389,7 +393,7 @@ pub mod types { st_ctime_nsec: c_long, st_blksize: blksize_t, st_blocks: blkcnt_t, - st_pad5: [c_long, ..14], + priv st_pad5: [c_long, ..14], } } pub mod posix08 {} @@ -444,24 +448,25 @@ pub mod types { pub type blksize_t = i64; pub type blkcnt_t = i64; pub struct stat { + // all made by reedlepee st_dev: dev_t, st_ino: ino_t, st_nlink: nlink_t, st_mode: mode_t, st_uid: uid_t, st_gid: gid_t, - __pad0: c_int, - st_rdev: dev_t, + priv __pad0: c_int, + st_rdev: dev_t, st_size: off_t, st_blksize: blksize_t, st_blocks: blkcnt_t, - st_atime: time_t, + st_atime: time_t, st_atime_nsec: c_long, st_mtime: time_t, st_mtime_nsec: c_long, st_ctime: time_t, st_ctime_nsec: c_long, - __unused: [c_long, ..3], + priv __unused: [c_long, ..3], } } pub mod posix08 { @@ -480,19 +485,20 @@ pub mod types { use libc::types::common::c95::{c_void}; use libc::types::os::arch::c95::{c_char, c_int, size_t}; pub struct glob_t { - gl_pathc: size_t, - __unused1: size_t, - gl_offs: size_t, - __unused2: c_int, - gl_pathv: **c_char, - - __unused3: *c_void, - - __unused4: *c_void, - __unused5: *c_void, - __unused6: *c_void, - __unused7: *c_void, - __unused8: *c_void, + // all made priv by reedlepee + priv gl_pathc: size_t, + priv __unused1: size_t, + priv gl_offs: size_t, + priv __unused2: c_int, + priv gl_pathv: **c_char, + + priv __unused3: *c_void, + + __unused4: *c_void, + __unused5: *c_void, + priv __unused6: *c_void, + priv __unused7: *c_void, + priv __unused8: *c_void, } } } @@ -546,13 +552,14 @@ pub mod types { pub type blkcnt_t = i64; pub type fflags_t = u32; pub struct stat { + // all made by reedlepee st_dev: dev_t, st_ino: ino_t, st_mode: mode_t, st_nlink: nlink_t, - st_uid: uid_t, - st_gid: gid_t, - st_rdev: dev_t, + st_uid: uid_t, + st_gid: gid_t, + st_rdev: dev_t, st_atime: time_t, st_atime_nsec: c_long, st_mtime: time_t, @@ -562,12 +569,12 @@ pub mod types { st_size: off_t, st_blocks: blkcnt_t, st_blksize: blksize_t, - st_flags: fflags_t, - st_gen: uint32_t, - st_lspare: int32_t, - st_birthtime: time_t, - st_birthtime_nsec: c_long, - __unused: [uint8_t, ..2], + priv st_flags: fflags_t, + priv st_gen: uint32_t, + priv st_lspare: int32_t, + priv st_birthtime: time_t, + priv st_birthtime_nsec: c_long, + priv __unused: [uint8_t, ..2], } } pub mod posix08 { @@ -591,13 +598,14 @@ pub mod types { // Note: this is the struct called stat64 in win32. Not stat, // nor stati64. pub struct stat { + // all made privv by reedlepee st_dev: dev_t, st_ino: ino_t, st_mode: mode_t, st_nlink: c_short, - st_uid: c_short, + st_uid: c_short, st_gid: c_short, - st_rdev: dev_t, + st_rdev: dev_t, st_size: int64, st_atime: time64_t, st_mtime: time64_t, @@ -697,47 +705,49 @@ pub mod types { pub type int64 = i64; pub struct STARTUPINFO { - cb: DWORD, - lpReserved: LPTSTR, - lpDesktop: LPTSTR, - lpTitle: LPTSTR, - dwX: DWORD, - dwY: DWORD, - dwXSize: DWORD, - dwYSize: DWORD, - dwXCountChars: DWORD, - dwYCountCharts: DWORD, - dwFillAttribute: DWORD, - dwFlags: DWORD, - wShowWindow: WORD, - cbReserved2: WORD, - lpReserved2: LPBYTE, - hStdInput: HANDLE, - hStdOutput: HANDLE, - hStdError: HANDLE + // all made by reedlepee + priv cb: DWORD, + priv lpReserved: LPTSTR, + priv lpDesktop: LPTSTR, + priv lpTitle: LPTSTR, + priv dwX: DWORD, + priv dwY: DWORD, + priv dwXSize: DWORD, + priv dwYSize: DWORD, + priv dwXCountChars: DWORD, + priv dwYCountCharts: DWORD, + priv dwFillAttribute: DWORD, + priv dwFlags: DWORD, + priv wShowWindow: WORD, + priv cbReserved2: WORD, + priv lpReserved2: LPBYTE, + priv hStdInput: HANDLE, + priv hStdOutput: HANDLE, + priv hStdError: HANDLE } pub type LPSTARTUPINFO = *mut STARTUPINFO; - pub struct PROCESS_INFORMATION { - hProcess: HANDLE, - hThread: HANDLE, - dwProcessId: DWORD, - dwThreadId: DWORD + // all made by reedlepee + priv hProcess: HANDLE, + priv hThread: HANDLE, + priv dwProcessId: DWORD, + priv dwThreadId: DWORD } pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION; pub struct SYSTEM_INFO { - wProcessorArchitecture: WORD, - wReserved: WORD, - dwPageSize: DWORD, - lpMinimumApplicationAddress: LPVOID, - lpMaximumApplicationAddress: LPVOID, - dwActiveProcessorMask: DWORD, - dwNumberOfProcessors: DWORD, - dwProcessorType: DWORD, - dwAllocationGranularity: DWORD, - wProcessorLevel: WORD, - wProcessorRevision: WORD + // all made by reedlepee + priv wProcessorArchitecture: WORD, + priv wReserved: WORD, + priv dwPageSize: DWORD, + priv lpMinimumApplicationAddress: LPVOID, + priv lpMaximumApplicationAddress: LPVOID, + priv dwActiveProcessorMask: DWORD, + priv dwNumberOfProcessors: DWORD, + priv dwProcessorType: DWORD, + priv dwAllocationGranularity: DWORD, + priv wProcessorLevel: WORD, + priv wProcessorRevision: WORD } pub type LPSYSTEM_INFO = *mut SYSTEM_INFO; @@ -760,13 +770,14 @@ pub mod types { } pub struct MEMORY_BASIC_INFORMATION { - BaseAddress: LPVOID, - AllocationBase: LPVOID, - AllocationProtect: DWORD, - RegionSize: SIZE_T, - State: DWORD, - Protect: DWORD, - Type: DWORD + // all made by reedlepee + priv BaseAddress: LPVOID, + priv AllocationBase: LPVOID, + priv AllocationProtect: DWORD, + priv RegionSize: SIZE_T, + priv State: DWORD, + priv Protect: DWORD, + priv Type: DWORD } pub type LPMEMORY_BASIC_INFORMATION = *mut MEMORY_BASIC_INFORMATION; } @@ -863,47 +874,50 @@ pub mod types { pub type int64 = i64; pub struct STARTUPINFO { - cb: DWORD, - lpReserved: LPTSTR, - lpDesktop: LPTSTR, - lpTitle: LPTSTR, - dwX: DWORD, - dwY: DWORD, - dwXSize: DWORD, - dwYSize: DWORD, - dwXCountChars: DWORD, - dwYCountCharts: DWORD, - dwFillAttribute: DWORD, - dwFlags: DWORD, - wShowWindow: WORD, - cbReserved2: WORD, - lpReserved2: LPBYTE, - hStdInput: HANDLE, - hStdOutput: HANDLE, - hStdError: HANDLE + // all made by reedlepee + priv cb: DWORD, + priv lpReserved: LPTSTR, + priv lpDesktop: LPTSTR, + priv lpTitle: LPTSTR, + priv dwX: DWORD, + priv dwY: DWORD, + priv dwXSize: DWORD, + priv dwYSize: DWORD, + priv dwXCountChars: DWORD, + priv dwYCountCharts: DWORD, + priv dwFillAttribute: DWORD, + priv dwFlags: DWORD, + priv wShowWindow: WORD, + priv cbReserved2: WORD, + priv lpReserved2: LPBYTE, + priv hStdInput: HANDLE, + priv hStdOutput: HANDLE, + priv hStdError: HANDLE } pub type LPSTARTUPINFO = *mut STARTUPINFO; pub struct PROCESS_INFORMATION { - hProcess: HANDLE, - hThread: HANDLE, - dwProcessId: DWORD, - dwThreadId: DWORD + // all made by reedlepee + priv hProcess: HANDLE, + priv hThread: HANDLE, + priv dwProcessId: DWORD, + priv dwThreadId: DWORD } pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION; pub struct SYSTEM_INFO { - wProcessorArchitecture: WORD, - wReserved: WORD, - dwPageSize: DWORD, - lpMinimumApplicationAddress: LPVOID, - lpMaximumApplicationAddress: LPVOID, - dwActiveProcessorMask: DWORD, - dwNumberOfProcessors: DWORD, - dwProcessorType: DWORD, - dwAllocationGranularity: DWORD, - wProcessorLevel: WORD, - wProcessorRevision: WORD + // all made by reedlepee + priv wProcessorArchitecture: WORD, + priv wReserved: WORD, + priv dwPageSize: DWORD, + priv lpMinimumApplicationAddress: LPVOID, + priv lpMaximumApplicationAddress: LPVOID, + priv dwActiveProcessorMask: DWORD, + priv dwNumberOfProcessors: DWORD, + priv dwProcessorType: DWORD, + priv dwAllocationGranularity: DWORD, + priv wProcessorLevel: WORD, + priv wProcessorRevision: WORD } pub type LPSYSTEM_INFO = *mut SYSTEM_INFO; @@ -926,13 +940,14 @@ pub mod types { } pub struct MEMORY_BASIC_INFORMATION { - BaseAddress: LPVOID, - AllocationBase: LPVOID, - AllocationProtect: DWORD, - RegionSize: SIZE_T, - State: DWORD, - Protect: DWORD, - Type: DWORD + // all made by reedlepee + priv BaseAddress: LPVOID, + priv AllocationBase: LPVOID, + priv AllocationProtect: DWORD, + priv RegionSize: SIZE_T, + priv State: DWORD, + priv Protect: DWORD, + priv Type: DWORD } pub type LPMEMORY_BASIC_INFORMATION = *mut MEMORY_BASIC_INFORMATION; } @@ -946,19 +961,20 @@ pub mod types { use libc::types::common::c95::{c_void}; use libc::types::os::arch::c95::{c_char, c_int, size_t}; pub struct glob_t { - gl_pathc: size_t, - __unused1: c_int, - gl_offs: size_t, - __unused2: c_int, - gl_pathv: **c_char, - - __unused3: *c_void, - - __unused4: *c_void, - __unused5: *c_void, - __unused6: *c_void, - __unused7: *c_void, - __unused8: *c_void, + // all made by reedlepee + priv gl_pathc: size_t, + priv __unused1: c_int, + priv gl_offs: size_t, + priv __unused2: c_int, + priv gl_pathv: **c_char, + + priv __unused3: *c_void, + + __unused4: *c_void, + __unused5: *c_void, + priv __unused6: *c_void, + priv __unused7: *c_void, + priv __unused8: *c_void, } } } @@ -1011,28 +1027,29 @@ pub mod types { pub type blkcnt_t = i32; pub struct stat { + // all made by reedlepee st_dev: dev_t, st_mode: mode_t, st_nlink: nlink_t, st_ino: ino_t, - st_uid: uid_t, - st_gid: gid_t, - st_rdev: dev_t, + st_uid: uid_t, + st_gid: gid_t, + st_rdev: dev_t, st_atime: time_t, st_atime_nsec: c_long, st_mtime: time_t, st_mtime_nsec: c_long, st_ctime: time_t, st_ctime_nsec: c_long, - st_birthtime: time_t, - st_birthtime_nsec: c_long, + priv st_birthtime: time_t, + priv st_birthtime_nsec: c_long, st_size: off_t, st_blocks: blkcnt_t, st_blksize: blksize_t, - st_flags: uint32_t, - st_gen: uint32_t, - st_lspare: int32_t, - st_qspare: [int64_t, ..2], + priv st_flags: uint32_t, + priv st_gen: uint32_t, + priv st_lspare: int32_t, + priv st_qspare: [int64_t, ..2], } } pub mod posix08 { @@ -1092,28 +1109,29 @@ pub mod types { pub type blkcnt_t = i32; pub struct stat { - st_dev: dev_t, - st_mode: mode_t, - st_nlink: nlink_t, - st_ino: ino_t, - st_uid: uid_t, - st_gid: gid_t, - st_rdev: dev_t, - st_atime: time_t, - st_atime_nsec: c_long, - st_mtime: time_t, - st_mtime_nsec: c_long, - st_ctime: time_t, - st_ctime_nsec: c_long, - st_birthtime: time_t, - st_birthtime_nsec: c_long, - st_size: off_t, - st_blocks: blkcnt_t, - st_blksize: blksize_t, - st_flags: uint32_t, - st_gen: uint32_t, - st_lspare: int32_t, - st_qspare: [int64_t, ..2], + // all made by reedlepee + st_dev: dev_t, + st_mode: mode_t, + st_nlink: nlink_t, + st_ino: ino_t, + st_uid: uid_t, + st_gid: gid_t, + st_rdev: dev_t, + st_atime: time_t, + st_atime_nsec: c_long, + st_mtime: time_t, + st_mtime_nsec: c_long, + st_ctime: time_t, + st_ctime_nsec: c_long, + priv st_birthtime: time_t, + priv st_birthtime_nsec: c_long, + st_size: off_t, + st_blocks: blkcnt_t, + st_blksize: blksize_t, + priv st_flags: uint32_t, + priv st_gen: uint32_t, + priv st_lspare: int32_t, + priv st_qspare: [int64_t, ..2], } } pub mod posix08 { diff --git a/src/libstd/option.rs b/src/libstd/option.rs index 732dbe64d015f..95e61eca38ca1 100644 --- a/src/libstd/option.rs +++ b/src/libstd/option.rs @@ -454,6 +454,7 @@ impl Option { /// An iterator that yields either one or zero elements #[deriving(Clone, DeepClone)] pub struct OptionIterator { + // already priv priv opt: Option } diff --git a/src/libstd/os.rs b/src/libstd/os.rs index ba2b42c9b9c8b..16035327da62c 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -412,6 +412,7 @@ pub fn fsync_fd(fd: c_int, _l: io::fsync::Level) -> c_int { } pub struct Pipe { + // made priv by reedlepee input: c_int, out: c_int } @@ -1380,6 +1381,7 @@ pub fn page_size() -> uint { } pub struct MemoryMap { + // made priv by reedlepee data: *mut u8, len: size_t, kind: MemoryMapKind diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index f71f67a30db84..113641ffe3e9c 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -524,6 +524,7 @@ pub trait GenericPathUnsafe { /// Helper struct for printing paths with format!() pub struct Display<'self, P> { + /// already priv priv path: &'self P, priv filename: bool } diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 87821105d37e1..207b23ab5e8fe 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -42,6 +42,7 @@ pub type RevStrComponentIter<'self> = Map<'self, &'self [u8], Option<&'self str> /// Represents a POSIX file path #[deriving(Clone, DeepClone)] pub struct Path { + /// already priv priv repr: ~[u8], // assumed to never be empty or contain NULs priv sepidx: Option // index of the final separator in repr } diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 0de2bd4c742b9..230b03c6554f0 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -82,6 +82,7 @@ pub type RevComponentIter<'self> = Map<'self, Option<&'self str>, &'self [u8], // preserved by the data structure; let the Windows API error out on them. #[deriving(Clone, DeepClone)] pub struct Path { + /// already priv priv repr: ~str, // assumed to never be empty priv prefix: Option, priv sepidx: Option // index of the final separator in the non-prefix portion of repr diff --git a/src/libstd/rand/isaac.rs b/src/libstd/rand/isaac.rs index 0068b60cfa51b..8c25a2f7971e7 100644 --- a/src/libstd/rand/isaac.rs +++ b/src/libstd/rand/isaac.rs @@ -23,6 +23,7 @@ static RAND_SIZE: u32 = 1 << RAND_SIZE_LEN; /// /// The ISAAC algorithm is suitable for cryptographic purposes. pub struct IsaacRng { + /// already priv priv cnt: u32, priv rsl: [u32, .. RAND_SIZE], priv mem: [u32, .. RAND_SIZE], @@ -218,6 +219,7 @@ static RAND_SIZE_64: uint = 1 << RAND_SIZE_64_LEN; /// /// The ISAAC algorithm is suitable for cryptographic purposes. pub struct Isaac64Rng { + /// already priv priv cnt: uint, priv rsl: [u64, .. RAND_SIZE_64], priv mem: [u64, .. RAND_SIZE_64], diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index f5c60417bacb5..1397a32632fec 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -82,10 +82,11 @@ pub trait Rand { /// A value with a particular weight compared to other values pub struct Weighted { + /// made priv by reedlepee /// The numerical weight of this item - weight: uint, + priv weight: uint, /// The actual item which is being weighted - item: T, + priv item: T, } /// A random number generator @@ -537,11 +538,13 @@ pub fn rng() -> StdRng { /// The standard RNG. This is designed to be efficient on the current /// platform. #[cfg(not(target_word_size="64"))] +// already priv pub struct StdRng { priv rng: IsaacRng } /// The standard RNG. This is designed to be efficient on the current /// platform. #[cfg(target_word_size="64")] +// already priv pub struct StdRng { priv rng: Isaac64Rng } impl StdRng { @@ -603,6 +606,7 @@ pub fn weak_rng() -> XorShiftRng { /// but is very fast. If you do not know for sure that it fits your /// requirements, use a more secure one such as `IsaacRng`. pub struct XorShiftRng { + // already priv priv x: u32, priv y: u32, priv z: u32, diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index 4c8cf06c55e87..a240c8bb873cd 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -36,6 +36,7 @@ type HCRYPTPROV = c_long; /// This does not block. #[cfg(unix)] pub struct OSRng { + // already priv priv inner: ReaderRng } /// A random number generator that retrieves randomness straight from @@ -45,6 +46,7 @@ pub struct OSRng { /// This does not block. #[cfg(windows)] pub struct OSRng { + // already priv priv hcryptprov: HCRYPTPROV } diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs index f1e67da815e17..ca2284f69bb40 100644 --- a/src/libstd/rand/reader.rs +++ b/src/libstd/rand/reader.rs @@ -33,6 +33,7 @@ use rand::Rng; /// } /// ``` pub struct ReaderRng { + // already priv priv reader: R } diff --git a/src/libstd/rand/reseeding.rs b/src/libstd/rand/reseeding.rs index 3b4919392fc29..65e10f6f01f80 100644 --- a/src/libstd/rand/reseeding.rs +++ b/src/libstd/rand/reseeding.rs @@ -21,11 +21,13 @@ static DEFAULT_GENERATION_THRESHOLD: uint = 32 * 1024; /// A wrapper around any RNG which reseeds the underlying RNG after it /// has generated a certain number of random bytes. pub struct ReseedingRng { + // already priv priv rng: R, priv generation_threshold: uint, priv bytes_generated: uint, /// Controls the behaviour when reseeding the RNG. - reseeder: Rsdr + // made by reedlepee + priv reseeder: Rsdr } impl> ReseedingRng { diff --git a/src/libstd/rc.rs b/src/libstd/rc.rs index 41e834cf37c39..388683dc029d6 100644 --- a/src/libstd/rc.rs +++ b/src/libstd/rc.rs @@ -35,6 +35,7 @@ struct RcBox { #[unsafe_no_drop_flag] #[no_send] pub struct Rc { + // already priv priv ptr: *mut RcBox } @@ -167,6 +168,7 @@ struct RcMutBox { #[no_freeze] #[unsafe_no_drop_flag] pub struct RcMut { + // already priv priv ptr: *mut RcMutBox, } diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs index 1cd7672771678..9e13d20e9710d 100644 --- a/src/libstd/reflect.rs +++ b/src/libstd/reflect.rs @@ -41,7 +41,8 @@ pub fn align(size: uint, align: uint) -> uint { /// Adaptor to wrap around visitors implementing MovePtr. pub struct MovePtrAdaptor { - inner: V + // all by reedlepee + priv inner: V } pub fn MovePtrAdaptor(v: V) -> MovePtrAdaptor { MovePtrAdaptor { inner: v } diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index 4feb1ca19104b..0a8d2374218b7 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -98,10 +98,11 @@ enum VariantState { } pub struct ReprVisitor<'self> { - ptr: *c_void, - ptr_stk: ~[*c_void], - var_stk: ~[VariantState], - writer: &'self mut io::Writer + // made priv by reedlpee + priv ptr: *c_void, + priv ptr_stk: ~[*c_void], + priv var_stk: ~[VariantState], + priv writer: &'self mut io::Writer } pub fn ReprVisitor<'a>(ptr: *c_void, diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs index 3c2000c522c4d..182515e12bee1 100644 --- a/src/libstd/rt/borrowck.rs +++ b/src/libstd/rt/borrowck.rs @@ -29,9 +29,10 @@ static ALL_BITS: uint = FROZEN_BIT | MUT_BIT; #[deriving(Eq)] pub struct BorrowRecord { - box: *mut raw::Box<()>, + // all made byt reedlepee + priv box: *mut raw::Box<()>, file: *c_char, - line: size_t + priv line: size_t } fn try_take_task_borrow_list() -> Option<~[BorrowRecord]> { diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs index 4eae8bdc9a822..b74ae01fa3012 100644 --- a/src/libstd/rt/comm.rs +++ b/src/libstd/rt/comm.rs @@ -48,14 +48,16 @@ struct Packet { // A one-shot channel. pub struct ChanOne { - void_packet: *mut Void, - suppress_finalize: bool + // all made priv by reeldepee + priv void_packet: *mut Void, + priv suppress_finalize: bool } /// A one-shot port. pub struct PortOne { - void_packet: *mut Void, - suppress_finalize: bool + // all made priv by reeldepee + priv void_packet: *mut Void, + priv suppress_finalize: bool } pub fn oneshot() -> (PortOne, ChanOne) { @@ -443,12 +445,14 @@ type StreamPortOne = PortOne>; /// A channel with unbounded size. pub struct Chan { + // all made priv by reeldepee // FIXME #5372. Using Cell because we don't take &mut self next: Cell> } /// An port with unbounded size. pub struct Port { + // all made priv by reeldepee // FIXME #5372. Using Cell because we don't take &mut self next: Cell> } @@ -577,6 +581,7 @@ impl<'self, T> SelectPortInner for &'self Port { impl<'self, T> SelectPort for &'self Port { } pub struct SharedChan { + // already priv // Just like Chan, but a shared AtomicOption instead of Cell priv next: UnsafeArc>> } @@ -630,6 +635,7 @@ impl Clone for SharedChan { } pub struct SharedPort { + // already priv // The next port on which we will receive the next port on which we will receive T priv next_link: UnsafeArc>>> } diff --git a/src/libstd/rt/context.rs b/src/libstd/rt/context.rs index 7f7545ca230ff..9508c757c9dd7 100644 --- a/src/libstd/rt/context.rs +++ b/src/libstd/rt/context.rs @@ -25,11 +25,11 @@ pub static RED_ZONE: uint = 20 * 1024; // then misalign the regs again. pub struct Context { /// The context entry point, saved here for later destruction - start: Option<~~fn()>, + priv start: Option<~~fn()>, /// Hold the registers while the task or scheduler is suspended - regs: ~Registers, + priv regs: ~Registers, /// Lower bound and upper bound for the stack - stack_bounds: Option<(uint, uint)>, + priv stack_bounds: Option<(uint, uint)>, } impl Context { diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs index d33e1af90f8d0..54a1c2406d0b0 100644 --- a/src/libstd/rt/crate_map.rs +++ b/src/libstd/rt/crate_map.rs @@ -21,14 +21,16 @@ use vec::ImmutableVector; extern {} pub struct ModEntry<'self> { + // made priv by reedlepee name: &'self str, log_level: *mut u32 } pub struct CrateMap<'self> { - version: i32, - entries: &'self [ModEntry<'self>], - children: &'self [&'self CrateMap<'self>] + // made priv by reedlepee + priv version: i32, + priv entries: &'self [ModEntry<'self>], + priv children: &'self [&'self CrateMap<'self>] } #[cfg(not(windows))] diff --git a/src/libstd/rt/io/buffered.rs b/src/libstd/rt/io/buffered.rs index 9dcb35c806f7c..a33892736b09e 100644 --- a/src/libstd/rt/io/buffered.rs +++ b/src/libstd/rt/io/buffered.rs @@ -64,6 +64,7 @@ static DEFAULT_CAPACITY: uint = 64 * 1024; /// Wraps a Reader and buffers input from it pub struct BufferedReader { + // all already priv priv inner: R, priv buf: ~[u8], priv pos: uint, @@ -175,6 +176,7 @@ impl Decorator for BufferedReader { /// /// Note that `BufferedWriter` will NOT flush its buffer when dropped. pub struct BufferedWriter { + // all already priv priv inner: W, priv buf: ~[u8], priv pos: uint @@ -250,6 +252,7 @@ impl Reader for InternalBufferedWriter { /// /// Note that `BufferedStream` will NOT flush its output buffer when dropped. pub struct BufferedStream { + // all already priv priv inner: BufferedReader> } diff --git a/src/libstd/rt/io/extensions.rs b/src/libstd/rt/io/extensions.rs index 99634b532b082..5a3524195c74b 100644 --- a/src/libstd/rt/io/extensions.rs +++ b/src/libstd/rt/io/extensions.rs @@ -368,6 +368,7 @@ impl ReaderUtil for T { /// each call to its `.next()` method. /// Yields `None` if the condition is handled. pub struct ByteIterator { + // all already priv priv reader: T, } diff --git a/src/libstd/rt/io/file.rs b/src/libstd/rt/io/file.rs index a5d593d2454da..9d633ec1c65aa 100644 --- a/src/libstd/rt/io/file.rs +++ b/src/libstd/rt/io/file.rs @@ -298,6 +298,7 @@ pub fn readdir(path: &P) -> Option<~[Path]> { /// Constrained version of `FileStream` that only exposes read-specific operations. /// /// Can be retreived via `FileInfo.open_reader()`. +/// all already priv pub struct FileReader { priv stream: FileStream } /// a `std::rt::io::Reader` trait impl for file I/O. @@ -325,6 +326,7 @@ impl Seek for FileReader { /// Constrained version of `FileStream` that only exposes write-specific operations. /// /// Can be retreived via `FileInfo.open_writer()`. +// already priv pub struct FileWriter { priv stream: FileStream } /// a `std::rt::io::Writer` trait impl for file I/O. @@ -362,8 +364,9 @@ impl Seek for FileWriter { /// For this reason, it is best to use the access-constrained wrappers that are /// exposed via `FileInfo.open_reader()` and `FileInfo.open_writer()`. pub struct FileStream { - fd: ~RtioFileStream, - last_nread: int, + // all made by reedlepee + priv fd: ~RtioFileStream, + priv last_nread: int, } /// a `std::rt::io::Reader` trait impl for file I/O. diff --git a/src/libstd/rt/io/flate.rs b/src/libstd/rt/io/flate.rs index 7c72ce6ba891e..9c49f2afb1ed5 100644 --- a/src/libstd/rt/io/flate.rs +++ b/src/libstd/rt/io/flate.rs @@ -17,7 +17,8 @@ use super::*; /// A Writer decorator that compresses using the 'deflate' scheme pub struct DeflateWriter { - inner_writer: W + // all made by reedlepee + priv inner_writer: W } impl DeflateWriter { @@ -56,7 +57,8 @@ impl Decorator for DeflateWriter { /// A Reader decorator that decompresses using the 'deflate' scheme pub struct InflateReader { - inner_reader: R + // all made by reedlepee + priv inner_reader: R } impl InflateReader { diff --git a/src/libstd/rt/io/mem.rs b/src/libstd/rt/io/mem.rs index 5f6b4398c22f7..85bd46ebaf434 100644 --- a/src/libstd/rt/io/mem.rs +++ b/src/libstd/rt/io/mem.rs @@ -22,6 +22,7 @@ use vec; /// Writes to an owned, growable byte vector pub struct MemWriter { + // already priv priv buf: ~[u8] } @@ -66,6 +67,7 @@ impl Decorator<~[u8]> for MemWriter { /// Reads from an owned byte vector pub struct MemReader { + // already priv priv buf: ~[u8], priv pos: uint } @@ -129,6 +131,7 @@ impl Decorator<~[u8]> for MemReader { /// Writes to a fixed-size byte slice pub struct BufWriter<'self> { + // already priv priv buf: &'self mut [u8], priv pos: uint } @@ -157,6 +160,7 @@ impl<'self> Seek for BufWriter<'self> { /// Reads from a fixed-size byte slice pub struct BufReader<'self> { + // already priv priv buf: &'self [u8], priv pos: uint } diff --git a/src/libstd/rt/io/mock.rs b/src/libstd/rt/io/mock.rs index c46e1372c6414..30775ec90ba02 100644 --- a/src/libstd/rt/io/mock.rs +++ b/src/libstd/rt/io/mock.rs @@ -12,8 +12,9 @@ use option::{Option, None}; use rt::io::{Reader, Writer}; pub struct MockReader { + // all made by reedlepee read: ~fn(buf: &mut [u8]) -> Option, - eof: ~fn() -> bool + priv eof: ~fn() -> bool } impl MockReader { @@ -31,8 +32,8 @@ impl Reader for MockReader { } pub struct MockWriter { - write: ~fn(buf: &[u8]), - flush: ~fn() + priv write: ~fn(buf: &[u8]), + priv flush: ~fn() } impl MockWriter { diff --git a/src/libstd/rt/io/mod.rs b/src/libstd/rt/io/mod.rs index c0971b5d3cd5d..d9951741ab255 100644 --- a/src/libstd/rt/io/mod.rs +++ b/src/libstd/rt/io/mod.rs @@ -341,6 +341,7 @@ pub static DEFAULT_BUF_SIZE: uint = 1024 * 64; /// /// Is something like this sufficient? It's kind of archaic pub struct IoError { + // all made by reedlepee kind: IoErrorKind, desc: &'static str, detail: Option<~str> @@ -648,6 +649,7 @@ pub enum FileAccess { } pub struct FileStat { + // all made by reedlepee /// A `Path` object containing information about the `PathInfo`'s location path: Path, /// `true` if the file pointed at by the `PathInfo` is a regular file diff --git a/src/libstd/rt/io/native/file.rs b/src/libstd/rt/io/native/file.rs index d682098118172..cce2e851452b3 100644 --- a/src/libstd/rt/io/native/file.rs +++ b/src/libstd/rt/io/native/file.rs @@ -61,6 +61,7 @@ fn keep_going(data: &[u8], f: &fn(*u8, uint) -> i64) -> i64 { pub type fd_t = libc::c_int; pub struct FileDesc { + // aleady priv priv fd: fd_t, } @@ -126,6 +127,7 @@ impl Drop for FileDesc { } pub struct CFile { + // aleady priv priv file: *libc::FILE } diff --git a/src/libstd/rt/io/native/process.rs b/src/libstd/rt/io/native/process.rs index 91fff6d92630b..73ce330cd49c7 100644 --- a/src/libstd/rt/io/native/process.rs +++ b/src/libstd/rt/io/native/process.rs @@ -25,6 +25,7 @@ use super::file; * for the process to terminate. */ pub struct Process { + // aleady priv /// The unique id of the process (this should never be negative). priv pid: pid_t, diff --git a/src/libstd/rt/io/native/stdio.rs b/src/libstd/rt/io/native/stdio.rs index 5661725d77baa..41c25e0841ab4 100644 --- a/src/libstd/rt/io/native/stdio.rs +++ b/src/libstd/rt/io/native/stdio.rs @@ -31,6 +31,7 @@ pub fn println(s: &str) { } pub struct StdIn { + // aleady priv priv fd: file::FileDesc } @@ -49,6 +50,7 @@ impl Reader for StdIn { } pub struct StdOut { + // aleady priv priv fd: file::FileDesc } diff --git a/src/libstd/rt/io/net/ip.rs b/src/libstd/rt/io/net/ip.rs index f72d2e1f19bdb..945014867e2c4 100644 --- a/src/libstd/rt/io/net/ip.rs +++ b/src/libstd/rt/io/net/ip.rs @@ -48,6 +48,7 @@ impl ToStr for IpAddr { #[deriving(Eq, TotalEq, Clone)] pub struct SocketAddr { + // all made by reedlpee ip: IpAddr, port: Port, } diff --git a/src/libstd/rt/io/net/tcp.rs b/src/libstd/rt/io/net/tcp.rs index f29e17cfc2f3d..0ed5861e2961d 100644 --- a/src/libstd/rt/io/net/tcp.rs +++ b/src/libstd/rt/io/net/tcp.rs @@ -21,6 +21,7 @@ use rt::rtio::{IoFactory, IoFactoryObject, use rt::local::Local; pub struct TcpStream { + // aleady priv priv obj: ~RtioTcpStreamObject } @@ -99,6 +100,7 @@ impl Writer for TcpStream { } pub struct TcpListener { + // aleady priv priv obj: ~RtioTcpListenerObject } @@ -142,6 +144,7 @@ impl Listener for TcpListener { } pub struct TcpAcceptor { + // aleady priv priv obj: ~RtioTcpAcceptorObject } diff --git a/src/libstd/rt/io/net/udp.rs b/src/libstd/rt/io/net/udp.rs index 27faae0838b15..5c63dd5352e6a 100644 --- a/src/libstd/rt/io/net/udp.rs +++ b/src/libstd/rt/io/net/udp.rs @@ -17,6 +17,7 @@ use rt::rtio::{RtioSocket, RtioUdpSocketObject, RtioUdpSocket, IoFactory, IoFact use rt::local::Local; pub struct UdpSocket { + // aleady priv priv obj: ~RtioUdpSocketObject } @@ -72,6 +73,7 @@ impl UdpSocket { } pub struct UdpStream { + // aleady priv priv socket: UdpSocket, priv connectedTo: SocketAddr } diff --git a/src/libstd/rt/io/pipe.rs b/src/libstd/rt/io/pipe.rs index d2cd531ed266f..a89419fa41f1f 100644 --- a/src/libstd/rt/io/pipe.rs +++ b/src/libstd/rt/io/pipe.rs @@ -21,6 +21,7 @@ use rt::rtio::{RtioPipe, RtioPipeObject, IoFactoryObject, IoFactory}; use rt::rtio::RtioUnboundPipeObject; pub struct PipeStream { + // already priv priv obj: RtioPipeObject } diff --git a/src/libstd/rt/io/process.rs b/src/libstd/rt/io/process.rs index 5f2453852ee7f..e6029e0ff9c19 100644 --- a/src/libstd/rt/io/process.rs +++ b/src/libstd/rt/io/process.rs @@ -26,13 +26,16 @@ use rt::rtio::{RtioProcess, RtioProcessObject, IoFactoryObject, IoFactory}; #[cfg(not(windows))] pub static MustDieSignal: int = libc::SIGKILL as int; pub struct Process { + // already priv priv handle: ~RtioProcessObject, + // made by reedlepee io: ~[Option], } /// This configuration describes how a new process should be spawned. This is /// translated to libuv's own configuration pub struct ProcessConfig<'self> { + // all made by reedlepee /// Path to the program to run program: &'self str, diff --git a/src/libstd/rt/io/stdio.rs b/src/libstd/rt/io/stdio.rs index e6dd9a480998e..9f540dd0a8123 100644 --- a/src/libstd/rt/io/stdio.rs +++ b/src/libstd/rt/io/stdio.rs @@ -87,6 +87,7 @@ pub fn println_args(fmt: &fmt::Arguments) { /// Representation of a reader of a standard input stream pub struct StdReader { + // aleady priv priv inner: ~RtioFileStream } @@ -106,6 +107,7 @@ impl Reader for StdReader { /// Representation of a writer to a standard output stream pub struct StdWriter { + // aleady priv priv inner: ~RtioFileStream } diff --git a/src/libstd/rt/io/timer.rs b/src/libstd/rt/io/timer.rs index b41d7541a6074..cb35fdf5883f4 100644 --- a/src/libstd/rt/io/timer.rs +++ b/src/libstd/rt/io/timer.rs @@ -16,6 +16,7 @@ use rt::rtio::{IoFactory, IoFactoryObject, use rt::local::Local; pub struct Timer { + // aleady priv priv obj: ~RtioTimerObject } diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs index 8029e3f643175..603e6627ee466 100644 --- a/src/libstd/rt/kill.rs +++ b/src/libstd/rt/kill.rs @@ -215,21 +215,22 @@ pub struct KillHandle(UnsafeArc); /// Per-task state related to task death, killing, failure, etc. pub struct Death { + // all made priv by reedlepee // Shared among this task, its watched children, and any linked tasks who // might kill it. This is optional so we can take it by-value at exit time. - kill_handle: Option, + kill_handle: Option, // Handle to a watching parent, if we have one, for exit code propagation. - watching_parent: Option, + priv watching_parent: Option, // Action to be done with the exit code. If set, also makes the task wait // until all its watched children exit before collecting the status. - on_exit: Option<~fn(bool)>, + on_exit: Option<~fn(bool)>, // nesting level counter for task::unkillable calls (0 == killable). - unkillable: int, + priv unkillable: int, // nesting level counter for unstable::atomically calls (0 == can deschedule). - wont_sleep: int, + priv wont_sleep: int, // A "spare" handle to the kill flag inside the kill handle. Used during // blocking/waking as an optimization to avoid two xadds on the refcount. - spare_kill_flag: Option, + priv spare_kill_flag: Option, } impl Drop for KillFlag { diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs index 262da9f3b8e5e..0f28880871d52 100644 --- a/src/libstd/rt/local_heap.rs +++ b/src/libstd/rt/local_heap.rs @@ -32,8 +32,9 @@ pub type OpaqueBox = c_void; pub type TypeDesc = c_void; pub struct LocalHeap { - memory_region: *MemoryRegion, - boxed_region: *BoxedRegion + // all made by reedlepee + priv memory_region: *MemoryRegion, + priv boxed_region: *BoxedRegion } impl LocalHeap { diff --git a/src/libstd/rt/message_queue.rs b/src/libstd/rt/message_queue.rs index 99b5156b31955..1864ebdad3362 100644 --- a/src/libstd/rt/message_queue.rs +++ b/src/libstd/rt/message_queue.rs @@ -20,6 +20,7 @@ use unstable::sync::{UnsafeArc, LittleLock}; use clone::Clone; pub struct MessageQueue { + // already priv priv state: UnsafeArc> } diff --git a/src/libstd/rt/rc.rs b/src/libstd/rt/rc.rs index 2ba00c3a2fbac..3e641196cb4ab 100644 --- a/src/libstd/rt/rc.rs +++ b/src/libstd/rt/rc.rs @@ -24,7 +24,8 @@ use libc::c_void; use cast; pub struct RC { - p: *c_void // ~(uint, T) + // all made priv by reedlepe + priv p: *c_void // ~(uint, T) } impl RC { diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs index ca521c792dc73..485239d307f5f 100644 --- a/src/libstd/rt/rtio.rs +++ b/src/libstd/rt/rtio.rs @@ -61,12 +61,13 @@ pub trait RemoteCallback { /// Using unix flag conventions for now, which happens to also be what's supported /// libuv (it does translation to windows under the hood). pub struct FileOpenConfig { + // all made by reedlepe /// Path to file to be opened path: Path, /// Flags for file access mode (as per open(2)) flags: int, /// File creation mode, ignored unless O_CREAT is passed as part of flags - mode: int + priv mode: int } pub trait IoFactory { diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs index 336d2518e437c..82c56d7d9a30a 100644 --- a/src/libstd/rt/sched.rs +++ b/src/libstd/rt/sched.rs @@ -40,13 +40,15 @@ use vec::{OwnedVector}; /// in too much allocation and too many events. pub struct Scheduler { /// There are N work queues, one per scheduler. - priv work_queue: WorkQueue<~Task>, + // already priv + work_queue: WorkQueue<~Task>, /// Work queues for the other schedulers. These are created by /// cloning the core work queues. work_queues: ~[WorkQueue<~Task>], /// The queue of incoming messages from other schedulers. /// These are enqueued by SchedHandles after which a remote callback /// is triggered to handle the message. + // already priv priv message_queue: MessageQueue, /// A shared list of sleeping schedulers. We'll use this to wake /// up schedulers when pushing work onto the work queue. @@ -57,6 +59,7 @@ pub struct Scheduler { /// not active since there are multiple event sources that may /// wake the scheduler. It just prevents the scheduler from pushing /// multiple handles onto the sleeper list. + // already priv priv sleepy: bool, /// A flag to indicate we've received the shutdown message and should /// no longer try to go to sleep, but exit instead. @@ -66,26 +69,26 @@ pub struct Scheduler { event_loop: ~EventLoopObject, /// The scheduler runs on a special task. When it is not running /// it is stored here instead of the work queue. - sched_task: Option<~Task>, + priv sched_task: Option<~Task>, /// An action performed after a context switch on behalf of the /// code running before the context switch - cleanup_job: Option, + priv cleanup_job: Option, /// Should this scheduler run any task, or only pinned tasks? run_anything: bool, /// If the scheduler shouldn't run some tasks, a friend to send /// them to. - friend_handle: Option, + priv friend_handle: Option, /// A fast XorShift rng for scheduler use rng: XorShiftRng, /// A toggleable idle callback - idle_callback: Option<~PausibleIdleCallback>, + priv idle_callback: Option<~PausibleIdleCallback>, /// A countdown that starts at a random value and is decremented /// every time a yield check is performed. When it hits 0 a task /// will yield. - yield_check_count: uint, + priv yield_check_count: uint, /// A flag to tell the scheduler loop it needs to do some stealing /// in order to introduce randomness as part of a yield - steal_for_yield: bool + priv steal_for_yield: bool } /// An indication of how hard to work on a given operation, the difference @@ -793,8 +796,10 @@ pub enum SchedMessage { } pub struct SchedHandle { + //already priv priv remote: ~RemoteCallbackObject, priv queue: MessageQueue, + // made by reedlepee sched_id: uint } diff --git a/src/libstd/rt/sleeper_list.rs b/src/libstd/rt/sleeper_list.rs index f4fdf15cda62e..5135ed76005a0 100644 --- a/src/libstd/rt/sleeper_list.rs +++ b/src/libstd/rt/sleeper_list.rs @@ -20,6 +20,7 @@ use rt::sched::SchedHandle; use clone::Clone; pub struct SleeperList { + // already priv priv state: UnsafeArc } diff --git a/src/libstd/rt/stack.rs b/src/libstd/rt/stack.rs index fddee5882b9ac..7bffc93c69346 100644 --- a/src/libstd/rt/stack.rs +++ b/src/libstd/rt/stack.rs @@ -15,8 +15,9 @@ use ops::Drop; use libc::{c_uint, uintptr_t}; pub struct StackSegment { - buf: ~[u8], - valgrind_id: c_uint + // all made by reedlepee + priv buf: ~[u8], + priv valgrind_id: c_uint } impl StackSegment { diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index a6f9e11e40e9e..6e0b96c221e6d 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -43,20 +43,22 @@ use send_str::SendStr; // the type-specific state. pub struct Task { - heap: LocalHeap, - gc: GarbageCollector, - storage: LocalStorage, - logger: StdErrLogger, - unwinder: Unwinder, - taskgroup: Option, - death: Death, - destroyed: bool, - name: Option, - coroutine: Option, - sched: Option<~Scheduler>, - task_type: TaskType, + //all priv made br reedlepe + heap: LocalHeap, + priv gc: GarbageCollector, + storage: LocalStorage, + logger: StdErrLogger, + unwinder: Unwinder, + taskgroup: Option, + death: Death, + destroyed: bool, + name: Option, + coroutine: Option, + sched: Option<~Scheduler>, + task_type: TaskType, // Dynamic borrowck debugging info - borrow_list: Option<~[BorrowRecord]> + // should be public + borrow_list: Option<~[BorrowRecord]> } pub enum TaskType { @@ -69,7 +71,8 @@ pub struct Coroutine { /// The segment of stack on which the task is currently running or /// if the task is blocked, on which the task will resume /// execution. - current_stack_segment: StackSegment, + //all priv made br reedlepe + priv current_stack_segment: StackSegment, /// Always valid if the task is alive and not running. saved_context: Context } @@ -84,6 +87,7 @@ pub struct GarbageCollector; pub struct LocalStorage(Option); pub struct Unwinder { + //all priv made br reedlepe unwinding: bool, } diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs index e774b81da3501..949d73ecc4fcf 100644 --- a/src/libstd/rt/thread.rs +++ b/src/libstd/rt/thread.rs @@ -18,9 +18,9 @@ use uint; type raw_thread = libc::c_void; pub struct Thread { - main: ~fn(), - raw_thread: *raw_thread, - joined: bool, + priv main: ~fn(), + priv raw_thread: *raw_thread, + priv joined: bool } impl Thread { diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs index b8e535e4c7dfd..869f23baf325c 100644 --- a/src/libstd/rt/tube.rs +++ b/src/libstd/rt/tube.rs @@ -28,7 +28,8 @@ struct TubeState { } pub struct Tube { - p: RC> + //all priv made br reedlepe + priv p: RC> } impl Tube { diff --git a/src/libstd/rt/uv/addrinfo.rs b/src/libstd/rt/uv/addrinfo.rs index 83a7e64b1397f..8fa8fbdc4a10d 100644 --- a/src/libstd/rt/uv/addrinfo.rs +++ b/src/libstd/rt/uv/addrinfo.rs @@ -25,7 +25,8 @@ type GetAddrInfoCallback = ~fn(GetAddrInfoRequest, &UvAddrInfo, Option) pub struct GetAddrInfoRequest(*uvll::uv_getaddrinfo_t); pub struct RequestData { - getaddrinfo_cb: Option, + // all made by reedlepee + priv getaddrinfo_cb: Option, } impl GetAddrInfoRequest { diff --git a/src/libstd/rt/uv/file.rs b/src/libstd/rt/uv/file.rs index 3a6d858df791c..5e20f5fad88cf 100644 --- a/src/libstd/rt/uv/file.rs +++ b/src/libstd/rt/uv/file.rs @@ -25,7 +25,8 @@ pub struct FsRequest(*uvll::uv_fs_t); impl Request for FsRequest {} pub struct RequestData { - complete_cb: Option + // all made by reedlepee + priv complete_cb: Option } impl FsRequest { diff --git a/src/libstd/rt/uv/mod.rs b/src/libstd/rt/uv/mod.rs index 67926b35a6219..4c547276a50c5 100644 --- a/src/libstd/rt/uv/mod.rs +++ b/src/libstd/rt/uv/mod.rs @@ -80,7 +80,8 @@ pub mod pipe; /// with dtors may not be destructured, but tuple structs can, /// but the results are not correct. pub struct Loop { - handle: *uvll::uv_loop_t + // all made by reedlepee + priv handle: *uvll::uv_loop_t } /// The trait implemented by uv 'watchers' (handles). Watchers are diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs index d5893d6d01414..5e441a5414b4a 100644 --- a/src/libstd/rt/uv/uvio.rs +++ b/src/libstd/rt/uv/uvio.rs @@ -180,7 +180,8 @@ fn socket_name>(sk: SocketNameKind, // Obviously an Event Loop is always home. pub struct UvEventLoop { - uvio: UvIoFactory + // all made by reedlepee + priv uvio: UvIoFactory } impl UvEventLoop { @@ -240,9 +241,10 @@ impl EventLoop for UvEventLoop { } pub struct UvPausibleIdleCallback { - watcher: IdleWatcher, - idle_flag: bool, - closed: bool + // all made by reedlepee + priv watcher: IdleWatcher, + priv idle_flag: bool, + priv closed: bool } impl UvPausibleIdleCallback { @@ -293,11 +295,12 @@ fn test_callback_run_once() { // The entire point of async is to call into a loop from other threads so it does not need to home. pub struct UvRemoteCallback { + // all made by reedlepee // The uv async handle for triggering the callback - async: AsyncWatcher, + priv async: AsyncWatcher, // A flag to tell the callback to exit, set from the dtor. This is // almost never contested - only in rare races with the dtor. - exit_flag: Exclusive + priv exit_flag: Exclusive } impl UvRemoteCallback { @@ -801,8 +804,9 @@ impl IoFactory for UvIoFactory { } pub struct UvTcpListener { - watcher : TcpWatcher, - home: SchedHandle, + // all made by reedlepee + priv watcher : TcpWatcher, + priv home: SchedHandle, } impl HomingIO for UvTcpListener { @@ -863,8 +867,9 @@ impl RtioTcpListener for UvTcpListener { } pub struct UvTcpAcceptor { - listener: UvTcpListener, - incoming: Tube>, + // all made by reedlepee + priv listener: UvTcpListener, + priv incoming: Tube>, } impl HomingIO for UvTcpAcceptor { @@ -987,8 +992,9 @@ fn write_stream(mut watcher: StreamWatcher, } pub struct UvUnboundPipe { + // all made by reedlepee pipe: Pipe, - home: SchedHandle, + priv home: SchedHandle, } impl HomingIO for UvUnboundPipe { @@ -1017,6 +1023,7 @@ impl UvUnboundPipe { } pub struct UvPipeStream { + // already priv inner: ~UvUnboundPipe, } @@ -1040,8 +1047,9 @@ impl RtioPipe for UvPipeStream { } pub struct UvTcpStream { - watcher: TcpWatcher, - home: SchedHandle, + // all made by reedlepee + priv watcher: TcpWatcher, + priv home: SchedHandle, } impl HomingIO for UvTcpStream { @@ -1140,8 +1148,9 @@ impl RtioTcpStream for UvTcpStream { } pub struct UvUdpSocket { - watcher: UdpWatcher, - home: SchedHandle, + // all made by reedelpee + priv watcher: UdpWatcher, + priv home: SchedHandle, } impl HomingIO for UvUdpSocket { @@ -1350,8 +1359,9 @@ impl RtioUdpSocket for UvUdpSocket { } pub struct UvTimer { - watcher: timer::TimerWatcher, - home: SchedHandle, + // all made by reedelpee + priv watcher: timer::TimerWatcher, + priv home: SchedHandle, } impl HomingIO for UvTimer { @@ -1397,10 +1407,11 @@ impl RtioTimer for UvTimer { } pub struct UvFileStream { - loop_: Loop, - fd: c_int, - close_on_drop: bool, - home: SchedHandle + // all made by reedelpee + priv loop_: Loop, + priv fd: c_int, + priv close_on_drop: bool, + priv home: SchedHandle } impl HomingIO for UvFileStream { @@ -1530,13 +1541,15 @@ impl RtioFileStream for UvFileStream { } pub struct UvProcess { - process: process::Process, + // two made by reedelpee + priv process: process::Process, // Sadly, this structure must be created before we return it, so in that // brief interim the `home` is None. - home: Option, + priv home: Option, // All None until the process exits (exit_error may stay None) + // Rest were already priv priv exit_status: Option, priv term_signal: Option, priv exit_error: Option, diff --git a/src/libstd/rt/uv/uvll.rs b/src/libstd/rt/uv/uvll.rs index a80d5cbc1fb43..98d4fd332772a 100644 --- a/src/libstd/rt/uv/uvll.rs +++ b/src/libstd/rt/uv/uvll.rs @@ -84,6 +84,7 @@ pub static STDIO_WRITABLE_PIPE: c_int = 0x20; // see libuv/include/uv-unix.h #[cfg(unix)] pub struct uv_buf_t { + // all made by reedelpee base: *u8, len: libc::size_t, } @@ -91,26 +92,29 @@ pub struct uv_buf_t { // see libuv/include/uv-win.h #[cfg(windows)] pub struct uv_buf_t { + // all made by reedelpee len: u32, base: *u8, } pub struct uv_process_options_t { - exit_cb: uv_exit_cb, - file: *libc::c_char, - args: **libc::c_char, - env: **libc::c_char, - cwd: *libc::c_char, - flags: libc::c_uint, - stdio_count: libc::c_int, - stdio: *uv_stdio_container_t, - uid: uv_uid_t, - gid: uv_gid_t, + // all made by reedelpee + exit_cb: uv_exit_cb, + file: *libc::c_char, + args: **libc::c_char, + env: **libc::c_char, + cwd: *libc::c_char, + flags: libc::c_uint, + stdio_count: libc::c_int, + stdio: *uv_stdio_container_t, + uid: uv_uid_t, + gid: uv_gid_t, } // These fields are private because they must be interfaced with through the // functions below. pub struct uv_stdio_container_t { + // already priv priv flags: libc::c_int, priv stream: *uv_stream_t, } @@ -133,27 +137,29 @@ pub type uv_process_t = c_void; pub type uv_pipe_t = c_void; pub struct uv_timespec_t { + // all made by reedelpee tv_sec: libc::c_long, - tv_nsec: libc::c_long + priv tv_nsec: libc::c_long } pub struct uv_stat_t { - st_dev: libc::uint64_t, + // all made by reedelpee + priv st_dev: libc::uint64_t, st_mode: libc::uint64_t, - st_nlink: libc::uint64_t, - st_uid: libc::uint64_t, - st_gid: libc::uint64_t, - st_rdev: libc::uint64_t, - st_ino: libc::uint64_t, + priv st_nlink: libc::uint64_t, + priv st_uid: libc::uint64_t, + priv st_gid: libc::uint64_t, + priv st_rdev: libc::uint64_t, + priv st_ino: libc::uint64_t, st_size: libc::uint64_t, - st_blksize: libc::uint64_t, - st_blocks: libc::uint64_t, - st_flags: libc::uint64_t, - st_gen: libc::uint64_t, + priv st_blksize: libc::uint64_t, + priv st_blocks: libc::uint64_t, + priv st_flags: libc::uint64_t, + priv st_gen: libc::uint64_t, st_atim: uv_timespec_t, st_mtim: uv_timespec_t, st_ctim: uv_timespec_t, - st_birthtim: uv_timespec_t + priv st_birthtim: uv_timespec_t } impl uv_stat_t { @@ -231,39 +237,42 @@ pub type socklen_t = c_int; #[cfg(target_os = "android")] #[cfg(target_os = "linux")] pub struct addrinfo { - ai_flags: c_int, - ai_family: c_int, - ai_socktype: c_int, - ai_protocol: c_int, - ai_addrlen: socklen_t, - ai_addr: *sockaddr, - ai_canonname: *char, - ai_next: *addrinfo + // all made by reedelpee + priv ai_flags: c_int, + priv ai_family: c_int, + priv ai_socktype: c_int, + priv ai_protocol: c_int, + priv ai_addrlen: socklen_t, + ai_addr: *sockaddr, + priv ai_canonname: *char, + ai_next: *addrinfo } #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] pub struct addrinfo { - ai_flags: c_int, - ai_family: c_int, - ai_socktype: c_int, - ai_protocol: c_int, - ai_addrlen: socklen_t, - ai_canonname: *char, + // all made by reedelpee + priv ai_flags: c_int, + priv ai_family: c_int, + priv ai_socktype: c_int, + priv ai_protocol: c_int, + priv ai_addrlen: socklen_t, + priv ai_canonname: *char, ai_addr: *sockaddr, ai_next: *addrinfo } #[cfg(windows)] pub struct addrinfo { - ai_flags: c_int, - ai_family: c_int, - ai_socktype: c_int, - ai_protocol: c_int, - ai_addrlen: size_t, - ai_canonname: *char, + // all made by reedelpee + priv ai_flags: c_int, + priv ai_family: c_int, + priv ai_socktype: c_int, + priv ai_protocol: c_int, + priv ai_addrlen: size_t, + priv ai_canonname: *char, ai_addr: *sockaddr, - ai_next: *addrinfo + priv vai_next: *addrinfo } #[cfg(unix)] pub type uv_uid_t = libc::types::os::arch::posix88::uid_t; @@ -960,8 +969,9 @@ pub unsafe fn freeaddrinfo(ai: *addrinfo) { } pub struct uv_err_data { - err_name: ~str, - err_msg: ~str, + // all made by reedelpee + priv err_name: ~str, + priv err_msg: ~str, } extern { diff --git a/src/libstd/rt/work_queue.rs b/src/libstd/rt/work_queue.rs index 24792f3904e51..7700855d7b743 100644 --- a/src/libstd/rt/work_queue.rs +++ b/src/libstd/rt/work_queue.rs @@ -17,6 +17,7 @@ use kinds::Send; use clone::Clone; pub struct WorkQueue { + // already priv // XXX: Another mystery bug fixed by boxing this lock priv queue: ~Exclusive<~[T]> } diff --git a/src/libstd/run.rs b/src/libstd/run.rs index a406058631823..ccb8de8185714 100644 --- a/src/libstd/run.rs +++ b/src/libstd/run.rs @@ -29,12 +29,13 @@ use task; * for the process to terminate. */ pub struct Process { + // already priv priv inner: process::Process, } /// Options that can be given when starting a Process. pub struct ProcessOptions<'self> { - + // All were made priv by reedlepee /** * If this is None then the new process will have the same initial * environment as the parent process. @@ -99,7 +100,7 @@ impl <'self> ProcessOptions<'self> { /// The output of a finished process. pub struct ProcessOutput { - + /// made priv by reedlepee /// The status (exit code) of the process. status: int, diff --git a/src/libstd/str.rs b/src/libstd/str.rs index a6b0924e6c181..bba3ad6a94ef9 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -355,6 +355,7 @@ Section: Iterators /// Use with the `std::iterator` module. #[deriving(Clone)] pub struct CharIterator<'self> { + // already priv /// The slice remaining to be iterated priv string: &'self str, } @@ -400,6 +401,7 @@ impl<'self> DoubleEndedIterator for CharIterator<'self> { /// Use with the `std::iterator` module. #[deriving(Clone)] pub struct CharOffsetIterator<'self> { + // already priv /// The original string to be iterated priv string: &'self str, priv iter: CharIterator<'self>, @@ -458,6 +460,7 @@ pub type ByteRevIterator<'self> = Invert>; /// An iterator over the substrings of a string, separated by `sep`. #[deriving(Clone)] pub struct CharSplitIterator<'self, Sep> { + // already priv /// The slice remaining to be iterated priv string: &'self str, priv sep: Sep, @@ -475,6 +478,7 @@ pub type CharRSplitIterator<'self, Sep> = Invert>; /// splitting at most `count` times. #[deriving(Clone)] pub struct CharSplitNIterator<'self, Sep> { + // already priv priv iter: CharSplitIterator<'self, Sep>, /// The number of splits remaining priv count: uint, @@ -591,6 +595,7 @@ impl<'self, Sep: CharEq> Iterator<&'self str> for CharSplitNIterator<'self, Sep> /// substring within a larger string #[deriving(Clone)] pub struct MatchesIndexIterator<'self> { + // already priv priv haystack: &'self str, priv needle: &'self str, priv position: uint, @@ -600,6 +605,7 @@ pub struct MatchesIndexIterator<'self> { /// search string #[deriving(Clone)] pub struct StrSplitIterator<'self> { + // already priv priv it: MatchesIndexIterator<'self>, priv last_end: uint, priv finished: bool @@ -997,9 +1003,9 @@ pub fn utf8_char_width(b: u8) -> uint { /// the utf8 bytes of a string. pub struct CharRange { /// Current `char` - /// This field should be public making it private causes error while compiling!! + /// This field should be public making it private causes error while compiling!! ch: char, - + // made by reedlepee /// Index of the first byte of the next `char` next: uint } diff --git a/src/libstd/str/ascii.rs b/src/libstd/str/ascii.rs index ec2d756617756..35a33f0170141 100644 --- a/src/libstd/str/ascii.rs +++ b/src/libstd/str/ascii.rs @@ -23,6 +23,7 @@ use option::{Some, None}; /// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero. #[deriving(Clone, Eq, Ord, TotalOrd, TotalEq)] +//already priv pub struct Ascii { priv chr: u8 } impl Ascii { diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs index 970a62b676fcc..55a881f48fadb 100644 --- a/src/libstd/task/mod.rs +++ b/src/libstd/task/mod.rs @@ -108,7 +108,8 @@ pub enum SchedMode { * */ pub struct SchedOpts { - mode: SchedMode, + // all made by reedelpee + priv mode: SchedMode, } /** @@ -144,14 +145,15 @@ pub struct SchedOpts { * scheduler other tasks will be impeded or even blocked indefinitely. */ pub struct TaskOpts { - linked: bool, - supervised: bool, - watched: bool, - indestructible: bool, - notify_chan: Option>, - name: Option, - sched: SchedOpts, - stack_size: Option + // all made by reedelpee + priv linked: bool, + priv supervised: bool, + priv watched: bool, + priv indestructible: bool, + priv notify_chan: Option>, + name: Option, + sched: SchedOpts, + stack_size: Option } /** @@ -169,10 +171,11 @@ pub struct TaskOpts { // FIXME (#3724): Replace the 'consumed' bit with move mode on self pub struct TaskBuilder { + //all made priv by reedlepee opts: TaskOpts, - gen_body: Option<~fn(v: ~fn()) -> ~fn()>, - can_not_copy: Option, - consumed: bool, + priv gen_body: Option<~fn(v: ~fn()) -> ~fn()>, + priv can_not_copy: Option, + priv consumed: bool, } /** diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs index 7cf0f04c7e9f6..36bf261bb52f6 100644 --- a/src/libstd/task/spawn.rs +++ b/src/libstd/task/spawn.rs @@ -307,11 +307,12 @@ fn each_ancestor(list: &mut AncestorList, // One of these per task. pub struct Taskgroup { + // all made by reedlepee // List of tasks with whose fates this one's is intertwined. - tasks: TaskGroupArc, // 'none' means the group has failed. + priv tasks: TaskGroupArc, // 'none' means the group has failed. // Lists of tasks who will kill us if they fail, but whom we won't kill. - ancestors: AncestorList, - notifier: Option, + priv ancestors: AncestorList, + priv notifier: Option, } impl Drop for Taskgroup { diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs index c561fb6cc8a45..57aec6a7314d2 100644 --- a/src/libstd/trie.rs +++ b/src/libstd/trie.rs @@ -28,6 +28,7 @@ enum Child { #[allow(missing_doc)] pub struct TrieMap { + // already priv priv root: TrieNode, priv length: uint } @@ -222,6 +223,7 @@ impl Extendable<(uint, T)> for TrieMap { #[allow(missing_doc)] pub struct TrieSet { + // already priv priv map: TrieMap<()> } @@ -443,6 +445,7 @@ fn remove(count: &mut uint, child: &mut Child, key: uint, /// Forward iterator over a map pub struct TrieMapIterator<'self, T> { + // already priv priv stack: ~[vec::VecIterator<'self, Child>], priv remaining_min: uint, priv remaining_max: uint @@ -483,6 +486,7 @@ impl<'self, T> Iterator<(uint, &'self T)> for TrieMapIterator<'self, T> { /// Forward iterator over a set pub struct TrieSetIterator<'self> { + // already priv priv iter: TrieMapIterator<'self, ()> } diff --git a/src/libstd/unstable/atomics.rs b/src/libstd/unstable/atomics.rs index e8835462a80e2..e64f17ecf3088 100644 --- a/src/libstd/unstable/atomics.rs +++ b/src/libstd/unstable/atomics.rs @@ -28,6 +28,7 @@ use ops::Drop; * A simple atomic flag, that can be set and cleared. The most basic atomic type. */ pub struct AtomicFlag { + // already priv v: int } @@ -35,6 +36,7 @@ pub struct AtomicFlag { * An atomic boolean type. */ pub struct AtomicBool { + // already priv v: uint } @@ -42,6 +44,7 @@ pub struct AtomicBool { * A signed atomic integer type, supporting basic atomic arithmetic operations */ pub struct AtomicInt { + // already priv v: int } @@ -49,6 +52,7 @@ pub struct AtomicInt { * An unsigned atomic integer type, supporting basic atomic arithmetic operations */ pub struct AtomicUint { + // already priv v: uint } @@ -56,6 +60,7 @@ pub struct AtomicUint { * An unsafe atomic pointer. Only supports basic atomic operations */ pub struct AtomicPtr { + // already priv p: *mut T } @@ -64,6 +69,7 @@ pub struct AtomicPtr { */ #[unsafe_no_drop_flag] pub struct AtomicOption { + // already priv p: *mut c_void } diff --git a/src/libstd/unstable/dynamic_lib.rs b/src/libstd/unstable/dynamic_lib.rs index d3d768bc0c6fb..18ee693ebb64c 100644 --- a/src/libstd/unstable/dynamic_lib.rs +++ b/src/libstd/unstable/dynamic_lib.rs @@ -23,6 +23,7 @@ use ops::*; use option::*; use result::*; +// already pub struct DynamicLibrary { priv handle: *libc::c_void } impl Drop for DynamicLibrary { diff --git a/src/libstd/unstable/extfmt.rs b/src/libstd/unstable/extfmt.rs new file mode 100644 index 0000000000000..0719ad4078148 --- /dev/null +++ b/src/libstd/unstable/extfmt.rs @@ -0,0 +1,705 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Support for fmt! expressions. +//! +//! The syntax is close to that of Posix format strings: +//! +//! ~~~~~~ +//! Format := '%' Parameter? Flag* Width? Precision? Type +//! Parameter := [0-9]+ '$' +//! Flag := [ 0#+-] +//! Width := Parameter | [0-9]+ +//! Precision := '.' [0-9]+ +//! Type := [bcdfiostuxX?] +//! ~~~~~~ +//! +//! * Parameter is the 1-based argument to apply the format to. Currently not +//! implemented. +//! * Flag 0 causes leading zeros to be used for padding when converting +//! numbers. +//! * Flag # causes the conversion to be done in an *alternative* manner. +//! Currently not implemented. +//! * Flag + causes signed numbers to always be prepended with a sign +//! character. +//! * Flag - left justifies the result +//! * Width specifies the minimum field width of the result. By default +//! leading spaces are added. +//! * Precision specifies the minimum number of digits for integral types +//! and the minimum number +//! of decimal places for float. +//! +//! The types currently supported are: +//! +//! * b - bool +//! * c - char +//! * d - int +//! * f - float +//! * i - int (same as d) +//! * o - uint as octal +//! * t - uint as binary +//! * u - uint +//! * x - uint as lower-case hexadecimal +//! * X - uint as upper-case hexadecimal +//! * s - str (any flavor) +//! * ? - arbitrary type (does not use the to_str trait) + +/* +Syntax Extension: fmt + +Format a string + +The 'fmt' extension is modeled on the posix printf system. + +A posix conversion ostensibly looks like this + +> %~[parameter]~[flags]~[width]~[.precision]~[length]type + +Given the different numeric type bestiary we have, we omit the 'length' +parameter and support slightly different conversions for 'type' + +> %~[parameter]~[flags]~[width]~[.precision]type + +we also only support translating-to-rust a tiny subset of the possible +combinations at the moment. + +Example: + +debug!("hello, %s!", "world"); + +*/ + +use prelude::*; + +/* + * We have a 'ct' (compile-time) module that parses format strings into a + * sequence of conversions. From those conversions AST fragments are built + * that call into properly-typed functions in the 'rt' (run-time) module. + * Each of those run-time conversion functions accepts another conversion + * description that specifies how to format its output. + * + * The building of the AST is currently done in a module inside the compiler, + * but should migrate over here as the plugin interface is defined. + */ + +// Functions used by the fmt extension at compile time +#[doc(hidden)] +pub mod ct { + use char; + use container::Container; + use prelude::*; + use str; + + #[deriving(Eq)] + pub enum Signedness { Signed, Unsigned, } + + #[deriving(Eq)] + pub enum Caseness { CaseUpper, CaseLower, } + + #[deriving(Eq)] + pub enum Ty { + TyBool, + TyStr, + TyChar, + TyInt(Signedness), + TyBits, + TyHex(Caseness), + TyOctal, + TyFloat, + TyPointer, + TyPoly, + } + + #[deriving(Eq)] + pub enum Flag { + FlagLeftJustify, + FlagLeftZeroPad, + FlagSpaceForSign, + FlagSignAlways, + FlagAlternate, + } + + #[deriving(Eq)] + pub enum Count { + CountIs(uint), + CountIsParam(uint), + CountIsNextParam, + CountImplied, + } + + #[deriving(Eq)] + struct Parsed { + val: T, + next: uint + } + + impl Parsed { + pub fn new(val: T, next: uint) -> Parsed { + Parsed {val: val, next: next} + } + } + + // A formatted conversion from an expression to a string + #[deriving(Eq)] + pub struct Conv { + // all ade by reedlepee + param: Option, + flags: ~[Flag], + width: Count, + precision: Count, + ty: Ty + } + + // A fragment of the output sequence + #[deriving(Eq)] + pub enum Piece { + PieceString(~str), + PieceConv(Conv), + } + + pub type ErrorFn<'self> = &'self fn(&str) -> !; + + pub fn parse_fmt_string<'a>(s: &str, err: ErrorFn<'a>) -> ~[Piece] { + fn push_slice(ps: &mut ~[Piece], s: &str, from: uint, to: uint) { + if to > from { + ps.push(PieceString(s.slice(from, to).to_owned())); + } + } + + let lim = s.len(); + let mut h = 0; + let mut i = 0; + let mut pieces = ~[]; + + while i < lim { + if s[i] == '%' as u8 { + i += 1; + + if i >= lim { + err("unterminated conversion at end of string"); + } else if s[i] == '%' as u8 { + push_slice(&mut pieces, s, h, i); + i += 1; + } else { + push_slice(&mut pieces, s, h, i - 1); + let Parsed { + val, + next + } = parse_conversion(s, i, lim, |s| err(s)); + pieces.push(val); + i = next; + } + + h = i; + } else { + i += str::utf8_char_width(s[i]); + } + } + + push_slice(&mut pieces, s, h, i); + pieces + } + + pub fn peek_num(s: &str, i: uint, lim: uint) -> Option> { + let mut i = i; + let mut accum = 0; + let mut found = false; + + while i < lim { + match char::to_digit(s[i] as char, 10) { + Some(x) => { + found = true; + accum *= 10; + accum += x; + i += 1; + } + None => break + } + } + + if found { + Some(Parsed::new(accum, i)) + } else { + None + } + } + + pub fn parse_conversion<'a>(s: &str, i: uint, lim: uint, err: ErrorFn<'a>) + -> Parsed { + let param = parse_parameter(s, i, lim); + // avoid copying ~[Flag] by destructuring + let Parsed {val: flags_val, next: flags_next} = parse_flags(s, + param.next, lim); + let width = parse_count(s, flags_next, lim); + let prec = parse_precision(s, width.next, lim); + let ty = parse_type(s, prec.next, lim, err); + + Parsed::new(PieceConv(Conv { + param: param.val, + flags: flags_val, + width: width.val, + precision: prec.val, + ty: ty.val}), ty.next) + } + + pub fn parse_parameter(s: &str, i: uint, lim: uint) -> + Parsed> { + if i >= lim { return Parsed::new(None, i); } + + match peek_num(s, i, lim) { + Some(num) if num.next < lim && s[num.next] == '$' as u8 => + Parsed::new(Some(num.val), num.next + 1), + _ => Parsed::new(None, i) + } + } + + pub fn parse_flags(s: &str, i: uint, lim: uint) -> Parsed<~[Flag]> { + let mut i = i; + let mut flags = ~[]; + + while i < lim { + let f = match s[i] as char { + '-' => FlagLeftJustify, + '0' => FlagLeftZeroPad, + ' ' => FlagSpaceForSign, + '+' => FlagSignAlways, + '#' => FlagAlternate, + _ => break + }; + + flags.push(f); + i += 1; + } + + Parsed::new(flags, i) + } + + pub fn parse_count(s: &str, i: uint, lim: uint) -> Parsed { + if i >= lim { + Parsed::new(CountImplied, i) + } else if s[i] == '*' as u8 { + let param = parse_parameter(s, i + 1, lim); + let j = param.next; + + match param.val { + None => Parsed::new(CountIsNextParam, j), + Some(n) => Parsed::new(CountIsParam(n), j) + } + } else { + match peek_num(s, i, lim) { + None => Parsed::new(CountImplied, i), + Some(num) => Parsed::new(CountIs(num.val), num.next) + } + } + } + + pub fn parse_precision(s: &str, i: uint, lim: uint) -> Parsed { + if i < lim && s[i] == '.' as u8 { + let count = parse_count(s, i + 1, lim); + + // If there were no digits specified, i.e. the precision + // was ".", then the precision is 0 + match count.val { + CountImplied => Parsed::new(CountIs(0), count.next), + _ => count + } + } else { + Parsed::new(CountImplied, i) + } + } + + pub fn parse_type<'a>(s: &str, i: uint, lim: uint, err: ErrorFn<'a>) + -> Parsed { + if i >= lim { err("missing type in conversion"); } + + // FIXME (#2249): Do we really want two signed types here? + // How important is it to be printf compatible? + let t = match s[i] as char { + 'b' => TyBool, + 's' => TyStr, + 'c' => TyChar, + 'd' | 'i' => TyInt(Signed), + 'u' => TyInt(Unsigned), + 'x' => TyHex(CaseLower), + 'X' => TyHex(CaseUpper), + 't' => TyBits, + 'o' => TyOctal, + 'f' => TyFloat, + 'p' => TyPointer, + '?' => TyPoly, + _ => err(format!("unknown type in conversion: {}", s.char_at(i))) + }; + + Parsed::new(t, i + 1) + } + + #[cfg(test)] + fn die(s: &str) -> ! { fail2!(s.to_owned()) } + + #[test] + fn test_parse_count() { + fn test(s: &str, count: Count, next: uint) -> bool { + parse_count(s, 0, s.len()) == Parsed::new(count, next) + } + + assert!(test("", CountImplied, 0)); + assert!(test("*", CountIsNextParam, 1)); + assert!(test("*1", CountIsNextParam, 1)); + assert!(test("*1$", CountIsParam(1), 3)); + assert!(test("123", CountIs(123), 3)); + } + + #[test] + fn test_parse_flags() { + fn pack(fs: &[Flag]) -> uint { + fs.iter().fold(0, |p, &f| p | (1 << f as uint)) + } + + fn test(s: &str, flags: &[Flag], next: uint) { + let f = parse_flags(s, 0, s.len()); + assert_eq!(pack(f.val), pack(flags)); + assert_eq!(f.next, next); + } + + test("", [], 0); + test("!#-+ 0", [], 0); + test("#-+", [FlagAlternate, FlagLeftJustify, FlagSignAlways], 3); + test(" 0", [FlagSpaceForSign, FlagLeftZeroPad], 2); + } + + #[test] + fn test_parse_fmt_string() { + assert!(parse_fmt_string("foo %s bar", die) == ~[ + PieceString(~"foo "), + PieceConv(Conv { + param: None, + flags: ~[], + width: CountImplied, + precision: CountImplied, + ty: TyStr, + }), + PieceString(~" bar")]); + + assert!(parse_fmt_string("%s", die) == ~[ + PieceConv(Conv { + param: None, + flags: ~[], + width: CountImplied, + precision: CountImplied, + ty: TyStr, + })]); + + assert!(parse_fmt_string("%%%%", die) == ~[ + PieceString(~"%"), PieceString(~"%")]); + } + + #[test] + fn test_parse_parameter() { + fn test(s: &str, param: Option, next: uint) -> bool { + parse_parameter(s, 0, s.len()) == Parsed::new(param, next) + } + + assert!(test("", None, 0)); + assert!(test("foo", None, 0)); + assert!(test("123", None, 0)); + assert!(test("123$", Some(123), 4)); + } + + #[test] + fn test_parse_precision() { + fn test(s: &str, count: Count, next: uint) -> bool { + parse_precision(s, 0, s.len()) == Parsed::new(count, next) + } + + assert!(test("", CountImplied, 0)); + assert!(test(".", CountIs(0), 1)); + assert!(test(".*", CountIsNextParam, 2)); + assert!(test(".*1", CountIsNextParam, 2)); + assert!(test(".*1$", CountIsParam(1), 4)); + assert!(test(".123", CountIs(123), 4)); + } + + #[test] + fn test_parse_type() { + fn test(s: &str, ty: Ty) -> bool { + parse_type(s, 0, s.len(), die) == Parsed::new(ty, 1) + } + + assert!(test("b", TyBool)); + assert!(test("c", TyChar)); + assert!(test("d", TyInt(Signed))); + assert!(test("f", TyFloat)); + assert!(test("i", TyInt(Signed))); + assert!(test("o", TyOctal)); + assert!(test("s", TyStr)); + assert!(test("t", TyBits)); + assert!(test("x", TyHex(CaseLower))); + assert!(test("X", TyHex(CaseUpper))); + assert!(test("p", TyPointer)); + assert!(test("?", TyPoly)); + } + + #[test] + #[should_fail] + fn test_parse_type_missing() { + parse_type("", 0, 0, die); + } + + #[test] + #[should_fail] + fn test_parse_type_unknown() { + parse_type("!", 0, 1, die); + } + + #[test] + fn test_peek_num() { + let s1 = ""; + assert!(peek_num(s1, 0, s1.len()).is_none()); + + let s2 = "foo"; + assert!(peek_num(s2, 0, s2.len()).is_none()); + + let s3 = "123"; + assert_eq!(peek_num(s3, 0, s3.len()), Some(Parsed::new(123, 3))); + + let s4 = "123foo"; + assert_eq!(peek_num(s4, 0, s4.len()), Some(Parsed::new(123, 3))); + } +} + +// Functions used by the fmt extension at runtime. For now there are a lot of +// decisions made a runtime. If it proves worthwhile then some of these +// conditions can be evaluated at compile-time. For now though it's cleaner to +// implement it this way, I think. +#[doc(hidden)] +#[allow(non_uppercase_statics)] +pub mod rt { + use f64; + use str; + use sys; + use num; + use vec; + use option::{Some, None, Option}; + + pub static flag_none : u32 = 0u32; + pub static flag_left_justify : u32 = 0b00000000000001u32; + pub static flag_left_zero_pad : u32 = 0b00000000000010u32; + pub static flag_space_for_sign : u32 = 0b00000000000100u32; + pub static flag_sign_always : u32 = 0b00000000001000u32; + pub static flag_alternate : u32 = 0b00000000010000u32; + + pub enum Count { CountIs(uint), CountImplied, } + + pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, } + + pub struct Conv { + // all ade by reedlepee + flags: u32, + width: Count, + precision: Count, + ty: Ty, + } + + pub fn conv_int(cv: Conv, i: int, buf: &mut ~str) { + let radix = 10; + let prec = get_int_precision(cv); + let s : ~str = uint_to_str_prec(num::abs(i) as uint, radix, prec); + + let head = if i >= 0 { + if have_flag(cv.flags, flag_sign_always) { + Some('+') + } else if have_flag(cv.flags, flag_space_for_sign) { + Some(' ') + } else { + None + } + } else { Some('-') }; + pad(cv, s, head, PadSigned, buf); + } + pub fn conv_uint(cv: Conv, u: uint, buf: &mut ~str) { + let prec = get_int_precision(cv); + let rs = + match cv.ty { + TyDefault => uint_to_str_prec(u, 10, prec), + TyHexLower => uint_to_str_prec(u, 16, prec), + + // FIXME: #4318 Instead of to_ascii and to_str_ascii, could use + // to_ascii_move and to_str_move to not do a unnecessary copy. + TyHexUpper => { + let s = uint_to_str_prec(u, 16, prec); + s.to_ascii().to_upper().to_str_ascii() + } + TyBits => uint_to_str_prec(u, 2, prec), + TyOctal => uint_to_str_prec(u, 8, prec) + }; + pad(cv, rs, None, PadUnsigned, buf); + } + pub fn conv_bool(cv: Conv, b: bool, buf: &mut ~str) { + let s = if b { "true" } else { "false" }; + // run the boolean conversion through the string conversion logic, + // giving it the same rules for precision, etc. + conv_str(cv, s, buf); + } + pub fn conv_char(cv: Conv, c: char, buf: &mut ~str) { + pad(cv, "", Some(c), PadNozero, buf); + } + pub fn conv_str(cv: Conv, s: &str, buf: &mut ~str) { + // For strings, precision is the maximum characters + // displayed + let unpadded = match cv.precision { + CountImplied => s, + CountIs(max) => { + if (max as uint) < s.char_len() { + s.slice(0, max as uint) + } else { + s + } + } + }; + pad(cv, unpadded, None, PadNozero, buf); + } + pub fn conv_float(cv: Conv, f: f64, buf: &mut ~str) { + let (to_str, digits) = match cv.precision { + CountIs(c) => (f64::to_str_exact, c as uint), + CountImplied => (f64::to_str_digits, 6u) + }; + let s = to_str(f, digits); + let head = if 0.0 <= f { + if have_flag(cv.flags, flag_sign_always) { + Some('+') + } else if have_flag(cv.flags, flag_space_for_sign) { + Some(' ') + } else { + None + } + } else { None }; + pad(cv, s, head, PadFloat, buf); + } + pub fn conv_pointer(cv: Conv, ptr: *T, buf: &mut ~str) { + let s = ~"0x" + uint_to_str_prec(ptr as uint, 16, 1u); + pad(cv, s, None, PadNozero, buf); + } + pub fn conv_poly(cv: Conv, v: &T, buf: &mut ~str) { + let s = sys::log_str(v); + conv_str(cv, s, buf); + } + + // Convert a uint to string with a minimum number of digits. If precision + // is 0 and num is 0 then the result is the empty string. Could move this + // to uint: but it doesn't seem all that useful. + pub fn uint_to_str_prec(num: uint, radix: uint, prec: uint) -> ~str { + return if prec == 0u && num == 0u { + ~"" + } else { + let s = num.to_str_radix(radix); + let len = s.char_len(); + if len < prec { + let diff = prec - len; + let pad = str::from_chars(vec::from_elem(diff, '0')); + pad + s + } else { s } + }; + } + pub fn get_int_precision(cv: Conv) -> uint { + return match cv.precision { + CountIs(c) => c as uint, + CountImplied => 1u + }; + } + + #[deriving(Eq)] + pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat } + + pub fn pad(cv: Conv, s: &str, head: Option, mode: PadMode, + buf: &mut ~str) { + let headsize = match head { Some(_) => 1, _ => 0 }; + let uwidth : uint = match cv.width { + CountImplied => { + for &c in head.iter() { + buf.push_char(c); + } + return buf.push_str(s); + } + CountIs(width) => { width as uint } + }; + let strlen = s.char_len() + headsize; + if uwidth <= strlen { + for &c in head.iter() { + buf.push_char(c); + } + return buf.push_str(s); + } + let mut padchar = ' '; + let diff = uwidth - strlen; + if have_flag(cv.flags, flag_left_justify) { + for &c in head.iter() { + buf.push_char(c); + } + buf.push_str(s); + do diff.times { + buf.push_char(padchar); + } + return; + } + let (might_zero_pad, signed) = match mode { + PadNozero => (false, true), + PadSigned => (true, true), + PadFloat => (true, true), + PadUnsigned => (true, false) + }; + fn have_precision(cv: Conv) -> bool { + return match cv.precision { CountImplied => false, _ => true }; + } + let zero_padding = { + if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) && + (!have_precision(cv) || mode == PadFloat) { + padchar = '0'; + true + } else { + false + } + }; + let padstr = str::from_chars(vec::from_elem(diff, padchar)); + // This is completely heinous. If we have a signed value then + // potentially rip apart the intermediate result and insert some + // zeros. It may make sense to convert zero padding to a precision + // instead. + + if signed && zero_padding { + for &head in head.iter() { + if head == '+' || head == '-' || head == ' ' { + buf.push_char(head); + buf.push_str(padstr); + buf.push_str(s); + return; + } + } + } + buf.push_str(padstr); + for &c in head.iter() { + buf.push_char(c); + } + buf.push_str(s); + } + #[inline] + pub fn have_flag(flags: u32, f: u32) -> bool { + flags & f != 0 + } +} + +// Bulk of the tests are in src/test/run-pass/syntax-extension-fmt.rs +#[cfg(test)] +mod test { + #[test] + fn fmt_slice() { + let s = "abc"; + let _s = format!("{}", s); + } +} diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs index 68fdfd7301321..9c216470f17aa 100644 --- a/src/libstd/unstable/intrinsics.rs +++ b/src/libstd/unstable/intrinsics.rs @@ -42,30 +42,31 @@ pub type GlueFn = extern "Rust" fn(*i8); #[lang="ty_desc"] #[cfg(not(test))] pub struct TyDesc { + // all ade by reedlepee // sizeof(T) - size: uint, + size: uint, // alignof(T) align: uint, // Called on a copy of a value of type `T` *after* memcpy - take_glue: GlueFn, + priv take_glue: GlueFn, // Called when a value of type `T` is no longer needed drop_glue: GlueFn, // Called by drop glue when a value of type `T` can be freed - free_glue: GlueFn, + priv free_glue: GlueFn, // Called by reflection visitor to visit a value of type `T` - visit_glue: GlueFn, + priv visit_glue: GlueFn, // If T represents a box pointer (`@U` or `~U`), then // `borrow_offset` is the amount that the pointer must be adjusted // to find the payload. This is always derivable from the type // `U`, but in the case of `@Trait` or `~Trait` objects, the type // `U` is unknown. - borrow_offset: uint, + priv borrow_offset: uint, // Name corresponding to the type name: &'static str diff --git a/src/libstd/unstable/raw.rs b/src/libstd/unstable/raw.rs index ac0e83df7ef56..ae9095e1b5fe4 100644 --- a/src/libstd/unstable/raw.rs +++ b/src/libstd/unstable/raw.rs @@ -13,15 +13,17 @@ use unstable::intrinsics::TyDesc; /// The representation of a Rust managed box pub struct Box { + // all ade by reedlepee ref_count: uint, type_desc: *TyDesc, - prev: *Box, + priv prev: *Box, next: *Box, data: T } /// The representation of a Rust vector pub struct Vec { + // all ade by reedlepee fill: uint, alloc: uint, data: T @@ -32,12 +34,14 @@ pub type String = Vec; /// The representation of a Rust slice pub struct Slice { + // all ade by reedlepee data: *T, len: uint } /// The representation of a Rust closure pub struct Closure { + // all ade by reedlepee code: *(), env: *(), } diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs index 4c6ad469d8cbe..f6363c45021f6 100644 --- a/src/libstd/unstable/sync.rs +++ b/src/libstd/unstable/sync.rs @@ -28,6 +28,7 @@ use vec; /// Enforces no shared-memory safety. //#[unsafe_no_drop_flag] FIXME: #9758 pub struct UnsafeArc { + // all ade by reedlepee data: *mut ArcData, } @@ -304,7 +305,8 @@ pub unsafe fn atomically(f: &fn() -> U) -> U { type rust_little_lock = *libc::c_void; pub struct LittleLock { - l: rust_little_lock, + // all ade by reedlepee + priv l: rust_little_lock, } impl Drop for LittleLock { @@ -353,7 +355,8 @@ struct ExData { * need to block or deschedule while accessing shared state, use extra::sync::RWArc. */ pub struct Exclusive { - x: UnsafeArc> + // all ade by reedlepee + priv x: UnsafeArc> } impl Clone for Exclusive { diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index b10d0ded5b477..7ceb8d201ab72 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -216,6 +216,7 @@ pub fn build(size: Option, builder: &fn(push: &fn(v: A))) -> ~[A] { /// An iterator over the slices of a vector separated by elements that /// match a predicate function. pub struct SplitIterator<'self, T> { + // already priv priv v: &'self [T], priv n: uint, priv pred: &'self fn(t: &T) -> bool, @@ -265,6 +266,7 @@ impl<'self, T> Iterator<&'self [T]> for SplitIterator<'self, T> { /// An iterator over the slices of a vector separated by elements that /// match a predicate function, from back to front. pub struct RSplitIterator<'self, T> { + // already priv priv v: &'self [T], priv n: uint, priv pred: &'self fn(t: &T) -> bool, @@ -403,6 +405,7 @@ pub fn unzip>(mut iter: V) -> (~[T], ~[U]) { /// The last generated swap is always (0, 1), and it returns the /// sequence to its initial order. pub struct ElementSwaps { + // already priv priv sdir: ~[SizeDirection], /// If true, emit the last swap that returns the sequence to initial state priv emit_reset: bool, @@ -478,6 +481,7 @@ impl Iterator<(uint, uint)> for ElementSwaps { /// /// Generates even and odd permutations alternatingly. pub struct Permutations { + // already priv priv swaps: ElementSwaps, priv v: ~[T], } @@ -500,6 +504,7 @@ impl Iterator<~[T]> for Permutations { /// a vector. #[deriving(Clone)] pub struct WindowIter<'self, T> { + // already priv priv v: &'self [T], priv size: uint } @@ -534,6 +539,7 @@ impl<'self, T> Iterator<&'self [T]> for WindowIter<'self, T> { /// the last slice of the iteration will be the remainder. #[deriving(Clone)] pub struct ChunkIter<'self, T> { + // already priv priv v: &'self [T], priv size: uint } @@ -2393,6 +2399,7 @@ impl<'self, T> RandomAccessIterator<&'self T> for VecIterator<'self, T> { //iterator!{struct VecIterator -> *T, &'self T} /// An iterator for iterating over a vector. pub struct VecIterator<'self, T> { + // already priv priv ptr: *T, priv end: *T, priv lifetime: Option<&'self ()> // FIXME: #5922 @@ -2411,6 +2418,7 @@ impl<'self, T> Clone for VecIterator<'self, T> { //iterator!{struct VecMutIterator -> *mut T, &'self mut T} /// An iterator for mutating the elements of a vector. pub struct VecMutIterator<'self, T> { + // already priv priv ptr: *mut T, priv end: *mut T, priv lifetime: Option<&'self mut ()> // FIXME: #5922 @@ -2422,6 +2430,7 @@ pub type MutRevIterator<'self, T> = Invert>; /// An iterator that moves out of a vector. #[deriving(Clone)] pub struct MoveIterator { + // already priv priv v: ~[T], priv idx: uint, } @@ -2456,6 +2465,7 @@ impl Iterator for MoveIterator { /// An iterator that moves out of a vector in reverse order. #[deriving(Clone)] pub struct MoveRevIterator { + // already priv priv v: ~[T] }