/// 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>
****************************************************************************/
/// An atomically reference counted wrapper for shared immutable state.
+// all were already priv
pub struct Arc<T> { priv x: UnsafeArc<T> }
/// An Arc with mutable data protected by a blocking mutex.
#[no_freeze]
+//All were already priv
pub struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
*/
#[no_freeze]
pub struct RWArc<T> {
+ // all were already priv
priv x: UnsafeArc<RWArcInner<T>>,
}
/// 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> {
// 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<Chunk>,
/// 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<uint>
+ priv line_length: Option<uint>
}
/// Configuration for RFC 4648 standard base64 encoding
/// 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() -> ! {
/// An iterator for `Bitv`.
pub struct BitvIterator<'self> {
+ /// all were already priv
priv bitv: &'self Bitv,
priv next_idx: uint,
priv end_idx: uint,
/// 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
}
pub struct BitvSetIterator<'self> {
+ // all were already priv
priv set: &'self BitvSet,
priv next_idx: uint
}
* The type representing a foreign chunk of memory
*/
pub struct CVec<T> {
+ /// No change all were allready priv!!
priv base: *mut T,
priv len: uint,
priv rsrc: @DtorRes,
/// An extension of `pipes::stream` that allows both sending and receiving.
pub struct DuplexStream<T, U> {
+// all were already priv
priv chan: Chan<T>,
priv port: Port<U>,
}
}
/// An extension of `pipes::stream` that provides synchronous message sending.
+// all were already priv
pub struct SyncChan<T> { priv duplex_stream: DuplexStream<T, ()> }
/// An extension of `pipes::stream` that acknowledges each message received.
+// all were already priv
pub struct SyncPort<T> { priv duplex_stream: DuplexStream<(), T> }
impl<T: Send> GenericChan<T> for SyncChan<T> {
/// A fixed size buffer of 64 bytes useful for cryptographic operations.
pub struct FixedBuffer64 {
+ // already priv
priv buffer: [u8, ..64],
priv buffer_idx: uint,
}
/// A fixed size buffer of 128 bytes useful for cryptographic operations.
pub struct FixedBuffer128 {
+ // already priv
priv buffer: [u8, ..128],
priv buffer_idx: uint,
}
/// The MD5 Digest algorithm
pub struct Md5 {
+ // already priv
priv length_bytes: u64,
priv buffer: FixedBuffer64,
priv state: Md5State,
/// 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,
/// The SHA-512 hash algorithm
pub struct Sha512 {
+ // already priv
priv engine: Engine512
}
/// The SHA-384 hash algorithm
pub struct Sha384 {
+ // already priv
priv engine: Engine512
}
/// The SHA-512 hash algorithm with digest truncated to 256 bits
pub struct Sha512Trunc256 {
+ // already priv
priv engine: Engine512
}
/// The SHA-512 hash algorithm with digest truncated to 224 bits
pub struct Sha512Trunc224 {
+ // already priv
priv engine: Engine512
}
/// The SHA-256 hash algorithm
pub struct Sha256 {
+ // already priv
priv engine: Engine256
}
/// The SHA-224 hash algorithm
pub struct Sha224 {
+ // already priv
priv engine: Engine256
}
/// A doubly-linked list.
pub struct DList<T> {
+ // all were already priv
priv length: uint,
priv list_head: Link<T>,
priv list_tail: Rawlink<Node<T>>,
/// Double-ended DList iterator
#[deriving(Clone)]
pub struct DListIterator<'self, T> {
+ // all were already priv
priv head: &'self Link<T>,
priv tail: Rawlink<Node<T>>,
priv nelem: uint,
/// Double-ended mutable DList iterator
pub struct MutDListIterator<'self, T> {
+ // all were already priv
priv list: &'self mut DList<T>,
priv head: Rawlink<Node<T>>,
priv tail: Rawlink<Node<T>>,
/// DList consuming iterator
#[deriving(Clone)]
pub struct MoveIterator<T> {
+ // all were already priv
priv list: DList<T>
}
#[deriving(Clone)]
pub struct Doc {
+ // all these should be public
data: @~[u8],
start: uint,
end: uint,
}
pub struct TaggedDoc {
- tag: uint,
+ // was made privv by reedlepee
+ priv tag: uint,
+ // should be public
doc: Doc,
}
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,
}
// 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 {
pub struct EnumSet<E> {
// We must maintain the invariant that no bits are set
// for which no variant exists
+ // all were already priv
priv bits: uint
}
/// An iterator over an EnumSet
pub struct EnumSetIterator<E> {
+ // all were already priv
priv index: uint,
priv bits: uint,
}
*/
#[deriving(Clone)]
pub struct FileInputState {
- current_path: Option<Path>,
- line_num: uint,
- line_num_file: uint
+ // all were priv made by reedlepee
+ priv current_path: Option<Path>,
+ priv line_num: uint,
+ priv line_num_file: uint
}
impl FileInputState {
// "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 {
/// A type encapsulating the result of a computation which may not be complete
pub struct Future<A> {
+ // all were already privv!!
priv state: FutureState<A>,
}
/// 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.
/// 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]
}
* 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,
*/
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)]
pub struct Pattern {
+ // already priv
priv tokens: ~[PatternToken]
}
*/
#[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
* 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 {
/// 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 {
/// 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 {
/// A structure for implementing serialization to JSON.
pub struct Encoder {
+ // all were already priv
priv wr: @io::Writer,
}
/// 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,
}
}
pub struct Parser<T> {
+ // all were already priv
priv rdr: ~T,
priv ch: char,
priv line: uint,
/// A structure to decode JSON to values in rust.
pub struct Decoder {
+ // all were already priv
priv stack: ~[Json],
}
*/
#[deriving(Clone)]
pub struct BigUint {
+ // already priv
priv data: ~[BigDigit]
}
/// A big signed integer type.
#[deriving(Clone)]
pub struct BigInt {
+ // already priv
priv sign: Sign,
priv data: BigUint
}
/// A complex number in Cartesian form.
#[deriving(Eq,Clone)]
pub struct Cmplx<T> {
+ // 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<f32>;
#[deriving(Clone)]
#[allow(missing_doc)]
pub struct Ratio<T> {
- numer: T,
- denom: T
+ // made priv by reedlepee
+ priv numer: T,
+ priv denom: T
}
/// Alias for a `Ratio` of machine-sized integers.
/// A priority queue implemented with a binary heap
#[deriving(Clone)]
pub struct PriorityQueue<T> {
+ // all were already priv
priv data: ~[T],
}
/// PriorityQueue iterator
pub struct PriorityQueueIterator <'self, T> {
+ // all were already priv
priv iter: vec::VecIterator<'self, T>,
}
/// RingBuf is a circular buffer that implements Deque.
#[deriving(Clone)]
pub struct RingBuf<T> {
+ // all were already priv
priv nelts: uint,
priv lo: uint,
priv elts: ~[Option<T>]
/// RingBuf iterator
pub struct RingBufIterator<'self, T> {
+ // all were already priv
priv lo: uint,
priv index: uint,
priv rindex: uint,
/// RingBuf mutable iterator
pub struct RingBufMutIterator<'self, T> {
+ // all were already priv
priv lo: uint,
priv index: uint,
priv rindex: uint,
/// 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 {
#[allow(missing_doc)]
pub struct SmallIntMap<T> {
+ /// all were already priv!!
priv v: ~[Option<T>],
}
}
pub struct SmallIntMapIterator<'self, T> {
+ /// all were already priv!!
priv front: uint,
priv back: uint,
priv iter: VecIterator<'self, Option<T>>
pub type SmallIntMapRevIterator<'self, T> = Invert<SmallIntMapIterator<'self, T>>;
pub struct SmallIntMapMutIterator<'self, T> {
+ /// all were already priv!!
priv front: uint,
priv back: uint,
priv iter: VecMutIterator<'self, Option<T>>
#[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 {
/// 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]>,
* 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()) } }
* unwinds.
*/
pub struct RWLock {
+ // reedlepee did not change they were already priv!!
priv order_lock: Semaphore,
priv access_lock: Sem<~[WaitQueue]>,
priv state: UnsafeArc<RWLockInner>,
}
/// 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 }
}
pub struct TaskPool<T> {
- channels: ~[Chan<Msg<T>>],
- next_index: uint,
+ /// all were made priv by reedlepee
+ priv channels: ~[Chan<Msg<T>>],
+ priv next_index: uint,
}
#[unsafe_destructor]
/// A wrapper for a path to temporary directory implementing automatic
/// scope-pased deletion.
pub struct TempDir {
+ // all were already priv!!
priv path: Option<Path>
}
#[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,
}
/// 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 {
/// 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
// 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
}
// 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 {
}
pub struct TestOpts {
+ /// priv added in all by reedlepee!!
filter: Option<~str>,
run_ignored: bool,
run_tests: bool,
#[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)]
}
/// 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-
#[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 {
#[allow(missing_doc)]
#[deriving(Clone)]
pub struct TreeMap<K, V> {
+ /// all were already priv!!
priv root: Option<~TreeNode<K, V>>,
priv length: uint
}
/// Lazy forward iterator over a map
pub struct TreeMapIterator<'self, K, V> {
+ // all were already priv
priv stack: ~[&'self ~TreeNode<K, V>],
priv node: &'self Option<~TreeNode<K, V>>,
priv remaining_min: uint,
/// Lazy backward iterator over a map
pub struct TreeMapRevIterator<'self, K, V> {
+ // all were already priv
priv iter: TreeMapIterator<'self, K, V>,
}
/// Lazy forward iterator over a map that consumes the map while iterating
pub struct TreeMapMoveIterator<K, V> {
+ // all were laready priv!!
priv stack: ~[TreeNode<K, V>],
priv remaining: uint
}
/// only requirement is that the type of the elements contained ascribes to the
/// `TotalOrd` trait.
pub struct TreeSet<T> {
+ //all were already priv
priv map: TreeMap<T, ()>
}
/// 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>>,
}
#[deriving(Clone, Eq)]
pub struct Url {
- scheme: ~str,
- user: Option<UserInfo>,
- host: ~str,
- port: Option<~str>,
- path: ~str,
- query: Query,
- fragment: Option<~str>
+ // all were made privv bt reedlepee
+ priv scheme: ~str,
+ priv user: Option<UserInfo>,
+ 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)];
/// A Universally Unique Identifier (UUID)
pub struct Uuid {
/// The 128-bit number stored in 16 bytes
+ /// should be public
bytes: UuidBytes
}
}
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
}
pub struct Logger {
// FIXME #4432: Fill in
- a: ()
+ /// alll were made priv reeldepee
+ priv a: ()
}
impl Logger {
#[deriving(Clone)]
pub struct Context {
+//// all were made priv by reedlepee
db: RWArc<Database>,
- logger: RWArc<Logger>,
- cfg: Arc<json::Object>,
+ priv logger: RWArc<Logger>,
+ priv cfg: Arc<json::Object>,
/// 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<FreshnessMap>
+ priv freshness: Arc<FreshnessMap>
}
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> {
/// 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,
}
///
/// 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
}
#[deriving(Clone, DeepClone, Eq)]
#[allow(missing_doc)]
pub struct Cell<T> {
+ // already priv
priv value: Option<T>
}
#[doc(hidden)]
pub struct Handler<T, U> {
+ //already priv
priv handle: Closure,
priv prev: Option<@Handler<T, U>>,
}
/// This struct should never be created directly, but rather only through the
/// `condition!` macro provided to all libraries using libstd.
pub struct Condition<T, U> {
+ // all made priv by reedlepee
/// Name of the condition handler
name: &'static str,
/// TLS key used to insert/remove values in TLS.
/// 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
/// Optionally specified integer width that the output should be
width: Option<uint>,
/// Optionally specified precision for numeric types
- precision: Option<uint>,
+ precision: Option<uint>,
/// Output buffer.
buf: &'self mut io::Writer,
+ // already priv
priv curarg: vec::VecIterator<'self, Argument<'self>>,
priv args: &'self [Argument<'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,
}
/// 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>],
}
/// 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<char>,
/// Optionally specified alignment
/// 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<PluralKeyword, uint>,
/// 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
/// 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,
}
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,
}
}
pub struct PluralArm<'self> {
+ /// made by redlepee
selector: Either<parse::PluralKeyword, uint>,
result: &'self [Piece<'self>],
}
pub struct SelectArm<'self> {
+ /// made by redlepee
selector: &'self str,
result: &'self [Piece<'self>],
}
/// `IterBytes` traits as `Hash` is automatically implemented for types that
/// implement `IterBytes`.
pub struct HashMap<K,V> {
+ // already priv
priv k0: u64,
priv k1: u64,
priv resize_at: uint,
/// HashMap iterator
#[deriving(Clone)]
pub struct HashMapIterator<'self, K, V> {
+ // already priv
priv iter: vec::VecIterator<'self, Option<Bucket<K, V>>>,
}
/// HashMap mutable values iterator
pub struct HashMapMutIterator<'self, K, V> {
+ // already priv
priv iter: vec::VecMutIterator<'self, Option<Bucket<K, V>>>,
}
/// HashMap move iterator
pub struct HashMapMoveIterator<K, V> {
+ // already priv
priv iter: vec::MoveRevIterator<Option<Bucket<K, V>>>,
}
/// HashSet iterator
#[deriving(Clone)]
pub struct HashSetIterator<'self, K> {
+ // already priv
priv iter: vec::VecIterator<'self, Option<Bucket<K, ()>>>,
}
/// HashSet move iterator
pub struct HashSetMoveIterator<K> {
+ // already priv
priv iter: vec::MoveRevIterator<Option<Bucket<K, ()>>>,
}
/// 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<T> {
+ // already priv
priv map: HashMap<T, ()>
}
}
pub struct FILERes {
- f: *libc::FILE,
+ // all by reedlepee
+ priv f: *libc::FILE,
}
impl FILERes {
// 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],
}
pub struct FdRes {
- fd: fd_t,
+ // all by reedlepee
+ priv fd: fd_t,
}
impl FdRes {
}
pub struct BytesWriter {
+ // all by reedlepee
bytes: @mut ~[u8],
pos: @mut uint,
}
// Artifacts that need to fsync on destruction
pub struct Res<t> {
- arg: Arg<t>,
+ // all by reedlepee
+ priv arg: Arg<t>,
}
impl <t> Res<t> {
}
pub struct Arg<t> {
- val: t,
- opt_level: Option<Level>,
- fsync_fn: extern "Rust" fn(f: &t, Level) -> int,
+ // all by reedlepee
+ priv val: t,
+ priv opt_level: Option<Level>,
+ priv fsync_fn: extern "Rust" fn(f: &t, Level) -> int,
}
// fsync file after executing blk
/// An double-ended iterator with the direction inverted
#[deriving(Clone)]
pub struct Invert<T> {
+ // already priv
+ // already priv
priv iter: T
}
/// A mutable reference to an iterator
pub struct ByRef<'self, T> {
+ // already priv
priv iter: &'self mut T
}
/// An iterator that repeats endlessly
#[deriving(Clone)]
pub struct Cycle<T> {
+ // already priv
priv orig: T,
priv iter: T,
}
/// An iterator which strings two iterators together
#[deriving(Clone)]
pub struct Chain<T, U> {
+ // already priv
priv a: T,
priv b: U,
priv flag: bool
/// An iterator which iterates two other iterators simultaneously
#[deriving(Clone)]
pub struct Zip<T, U> {
+ // already priv
priv a: T,
priv b: U
}
/// 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
}
/// 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
}
/// 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<B>
}
/// An iterator which yields the current count and the element during iteration
#[deriving(Clone)]
pub struct Enumerate<T> {
+ // already priv
priv iter: T,
priv count: uint
}
/// An iterator with a `peek()` that returns an optional reference to the next element.
pub struct Peekable<A, T> {
+ // already priv
priv iter: T,
priv peeked: Option<A>,
}
/// 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
/// 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
/// An iterator which skips over `n` elements of `iter`.
#[deriving(Clone)]
pub struct Skip<T> {
+ // already priv
priv iter: T,
priv n: uint
}
/// An iterator which only iterates over the first `n` iterations of `iter`.
#[deriving(Clone)]
pub struct Take<T> {
+ // already priv
priv iter: T,
priv n: uint
}
/// 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<B>,
/// 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<A>, St> Iterator<B> 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<U>,
/// yields `None` once.
#[deriving(Clone, DeepClone)]
pub struct Fuse<T> {
+ // already priv
priv iter: T,
priv done: bool
}
/// 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)
}
/// 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<A>,
/// Internal state that will be yielded on the next iteration
+ /// priv reedlepee
state: St
}
/// iteration
#[deriving(Clone)]
pub struct Counter<A> {
+ // 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
/// An iterator over the range [start, stop)
#[deriving(Clone, DeepClone)]
pub struct Range<A> {
+ // already priv
priv state: A,
priv stop: A,
priv one: A
/// An iterator over the range [start, stop]
#[deriving(Clone, DeepClone)]
pub struct RangeInclusive<A> {
+ // already priv
priv range: Range<A>,
priv done: bool
}
/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
#[deriving(Clone, DeepClone)]
pub struct RangeStep<A> {
+ // already priv
priv state: A,
priv stop: A,
priv step: A,
/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
#[deriving(Clone, DeepClone)]
pub struct RangeStepInclusive<A> {
+ // already priv
priv state: A,
priv stop: A,
priv step: A,
/// An iterator that repeats an element endlessly
#[deriving(Clone, DeepClone)]
pub struct Repeat<A> {
+ // already priv
priv element: A
}
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,
}
}
}
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,
st_ctime: time_t,
st_ctime_nsec: c_long,
__unused4: c_long,
- __unused5: c_long,
+ __unused5: c_long,
}
}
#[cfg(target_arch = "arm")]
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,
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
}
}
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,
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 {}
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 {
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,
}
}
}
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,
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 {
// 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,
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;
}
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;
}
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;
}
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;
}
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,
}
}
}
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 {
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 {
/// An iterator that yields either one or zero elements
#[deriving(Clone, DeepClone)]
pub struct OptionIterator<A> {
+ // already priv
priv opt: Option<A>
}
}
pub struct Pipe {
+ // made priv by reedlepee
input: c_int,
out: c_int
}
}
pub struct MemoryMap {
+ // made priv by reedlepee
data: *mut u8,
len: size_t,
kind: MemoryMapKind
/// Helper struct for printing paths with format!()
pub struct Display<'self, P> {
+ /// already priv
priv path: &'self P,
priv filename: bool
}
/// 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<uint> // index of the final separator in repr
}
// 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<PathPrefix>,
priv sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr
///
/// 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],
///
/// 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],
/// A value with a particular weight compared to other values
pub struct Weighted<T> {
+ /// 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
/// 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 {
/// 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,
/// This does not block.
#[cfg(unix)]
pub struct OSRng {
+ // already priv
priv inner: ReaderRng<file::FileStream>
}
/// A random number generator that retrieves randomness straight from
/// This does not block.
#[cfg(windows)]
pub struct OSRng {
+ // already priv
priv hcryptprov: HCRYPTPROV
}
/// }
/// ```
pub struct ReaderRng<R> {
+ // already priv
priv reader: R
}
/// A wrapper around any RNG which reseeds the underlying RNG after it
/// has generated a certain number of random bytes.
pub struct ReseedingRng<R, Rsdr> {
+ // 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<R: Rng, Rsdr: Reseeder<R>> ReseedingRng<R, Rsdr> {
#[unsafe_no_drop_flag]
#[no_send]
pub struct Rc<T> {
+ // already priv
priv ptr: *mut RcBox<T>
}
#[no_freeze]
#[unsafe_no_drop_flag]
pub struct RcMut<T> {
+ // already priv
priv ptr: *mut RcMutBox<T>,
}
/// Adaptor to wrap around visitors implementing MovePtr.
pub struct MovePtrAdaptor<V> {
- inner: V
+ // all by reedlepee
+ priv inner: V
}
pub fn MovePtrAdaptor<V:TyVisitor + MovePtr>(v: V) -> MovePtrAdaptor<V> {
MovePtrAdaptor { inner: v }
}
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,
#[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]> {
// A one-shot channel.
pub struct ChanOne<T> {
- 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<T> {
- void_packet: *mut Void,
- suppress_finalize: bool
+ // all made priv by reeldepee
+ priv void_packet: *mut Void,
+ priv suppress_finalize: bool
}
pub fn oneshot<T: Send>() -> (PortOne<T>, ChanOne<T>) {
/// A channel with unbounded size.
pub struct Chan<T> {
+ // all made priv by reeldepee
// FIXME #5372. Using Cell because we don't take &mut self
next: Cell<StreamChanOne<T>>
}
/// An port with unbounded size.
pub struct Port<T> {
+ // all made priv by reeldepee
// FIXME #5372. Using Cell because we don't take &mut self
next: Cell<StreamPortOne<T>>
}
impl<'self, T> SelectPort<T> for &'self Port<T> { }
pub struct SharedChan<T> {
+ // already priv
// Just like Chan, but a shared AtomicOption instead of Cell
priv next: UnsafeArc<AtomicOption<StreamChanOne<T>>>
}
}
pub struct SharedPort<T> {
+ // already priv
// The next port on which we will receive the next port on which we will receive T
priv next_link: UnsafeArc<AtomicOption<PortOne<StreamPortOne<T>>>>
}
// 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 {
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))]
/// Wraps a Reader and buffers input from it
pub struct BufferedReader<R> {
+ // all already priv
priv inner: R,
priv buf: ~[u8],
priv pos: uint,
///
/// Note that `BufferedWriter` will NOT flush its buffer when dropped.
pub struct BufferedWriter<W> {
+ // all already priv
priv inner: W,
priv buf: ~[u8],
priv pos: uint
///
/// Note that `BufferedStream` will NOT flush its output buffer when dropped.
pub struct BufferedStream<S> {
+ // all already priv
priv inner: BufferedReader<InternalBufferedWriter<S>>
}
/// each call to its `.next()` method.
/// Yields `None` if the condition is handled.
pub struct ByteIterator<T> {
+ // all already priv
priv reader: T,
}
/// 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.
/// 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.
/// 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.
/// A Writer decorator that compresses using the 'deflate' scheme
pub struct DeflateWriter<W> {
- inner_writer: W
+ // all made by reedlepee
+ priv inner_writer: W
}
impl<W: Writer> DeflateWriter<W> {
/// A Reader decorator that decompresses using the 'deflate' scheme
pub struct InflateReader<R> {
- inner_reader: R
+ // all made by reedlepee
+ priv inner_reader: R
}
impl<R: Reader> InflateReader<R> {
/// Writes to an owned, growable byte vector
pub struct MemWriter {
+ // already priv
priv buf: ~[u8]
}
/// Reads from an owned byte vector
pub struct MemReader {
+ // already priv
priv buf: ~[u8],
priv pos: uint
}
/// Writes to a fixed-size byte slice
pub struct BufWriter<'self> {
+ // already priv
priv buf: &'self mut [u8],
priv pos: uint
}
/// Reads from a fixed-size byte slice
pub struct BufReader<'self> {
+ // already priv
priv buf: &'self [u8],
priv pos: uint
}
use rt::io::{Reader, Writer};
pub struct MockReader {
+ // all made by reedlepee
read: ~fn(buf: &mut [u8]) -> Option<uint>,
- eof: ~fn() -> bool
+ priv eof: ~fn() -> bool
}
impl MockReader {
}
pub struct MockWriter {
- write: ~fn(buf: &[u8]),
- flush: ~fn()
+ priv write: ~fn(buf: &[u8]),
+ priv flush: ~fn()
}
impl MockWriter {
///
/// 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>
}
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
pub type fd_t = libc::c_int;
pub struct FileDesc {
+ // aleady priv
priv fd: fd_t,
}
}
pub struct CFile {
+ // aleady priv
priv file: *libc::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,
}
pub struct StdIn {
+ // aleady priv
priv fd: file::FileDesc
}
}
pub struct StdOut {
+ // aleady priv
priv fd: file::FileDesc
}
#[deriving(Eq, TotalEq, Clone)]
pub struct SocketAddr {
+ // all made by reedlpee
ip: IpAddr,
port: Port,
}
use rt::local::Local;
pub struct TcpStream {
+ // aleady priv
priv obj: ~RtioTcpStreamObject
}
}
pub struct TcpListener {
+ // aleady priv
priv obj: ~RtioTcpListenerObject
}
}
pub struct TcpAcceptor {
+ // aleady priv
priv obj: ~RtioTcpAcceptorObject
}
use rt::local::Local;
pub struct UdpSocket {
+ // aleady priv
priv obj: ~RtioUdpSocketObject
}
}
pub struct UdpStream {
+ // aleady priv
priv socket: UdpSocket,
priv connectedTo: SocketAddr
}
use rt::rtio::RtioUnboundPipeObject;
pub struct PipeStream {
+ // already priv
priv obj: RtioPipeObject
}
#[cfg(not(windows))] pub static MustDieSignal: int = libc::SIGKILL as int;
pub struct Process {
+ // already priv
priv handle: ~RtioProcessObject,
+ // made by reedlepee
io: ~[Option<io::PipeStream>],
}
/// 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,
/// Representation of a reader of a standard input stream
pub struct StdReader {
+ // aleady priv
priv inner: ~RtioFileStream
}
/// Representation of a writer to a standard output stream
pub struct StdWriter {
+ // aleady priv
priv inner: ~RtioFileStream
}
use rt::local::Local;
pub struct Timer {
+ // aleady priv
priv obj: ~RtioTimerObject
}
/// 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<KillHandle>,
+ kill_handle: Option<KillHandle>,
// Handle to a watching parent, if we have one, for exit code propagation.
- watching_parent: Option<KillHandle>,
+ priv watching_parent: Option<KillHandle>,
// 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<KillFlagHandle>,
+ priv spare_kill_flag: Option<KillFlagHandle>,
}
impl Drop for KillFlag {
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 {
use clone::Clone;
pub struct MessageQueue<T> {
+ // already priv
priv state: UnsafeArc<State<T>>
}
use cast;
pub struct RC<T> {
- p: *c_void // ~(uint, T)
+ // all made priv by reedlepe
+ priv p: *c_void // ~(uint, T)
}
impl<T> RC<T> {
/// 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 {
/// 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<SchedMessage>,
/// A shared list of sleeping schedulers. We'll use this to wake
/// up schedulers when pushing work onto the work queue.
/// 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.
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<CleanupJob>,
+ priv cleanup_job: Option<CleanupJob>,
/// 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<SchedHandle>,
+ priv friend_handle: Option<SchedHandle>,
/// 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
}
pub struct SchedHandle {
+ //already priv
priv remote: ~RemoteCallbackObject,
priv queue: MessageQueue<SchedMessage>,
+ // made by reedlepee
sched_id: uint
}
use clone::Clone;
pub struct SleeperList {
+ // already priv
priv state: UnsafeArc<State>
}
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 {
// the type-specific state.
pub struct Task {
- heap: LocalHeap,
- gc: GarbageCollector,
- storage: LocalStorage,
- logger: StdErrLogger,
- unwinder: Unwinder,
- taskgroup: Option<Taskgroup>,
- death: Death,
- destroyed: bool,
- name: Option<SendStr>,
- coroutine: Option<Coroutine>,
- sched: Option<~Scheduler>,
- task_type: TaskType,
+ //all priv made br reedlepe
+ heap: LocalHeap,
+ priv gc: GarbageCollector,
+ storage: LocalStorage,
+ logger: StdErrLogger,
+ unwinder: Unwinder,
+ taskgroup: Option<Taskgroup>,
+ death: Death,
+ destroyed: bool,
+ name: Option<SendStr>,
+ coroutine: Option<Coroutine>,
+ sched: Option<~Scheduler>,
+ task_type: TaskType,
// Dynamic borrowck debugging info
- borrow_list: Option<~[BorrowRecord]>
+ // should be public
+ borrow_list: Option<~[BorrowRecord]>
}
pub enum TaskType {
/// 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
}
pub struct LocalStorage(Option<local_data::Map>);
pub struct Unwinder {
+ //all priv made br reedlepe
unwinding: bool,
}
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 {
}
pub struct Tube<T> {
- p: RC<TubeState<T>>
+ //all priv made br reedlepe
+ priv p: RC<TubeState<T>>
}
impl<T> Tube<T> {
pub struct GetAddrInfoRequest(*uvll::uv_getaddrinfo_t);
pub struct RequestData {
- getaddrinfo_cb: Option<GetAddrInfoCallback>,
+ // all made by reedlepee
+ priv getaddrinfo_cb: Option<GetAddrInfoCallback>,
}
impl GetAddrInfoRequest {
impl Request for FsRequest {}
pub struct RequestData {
- complete_cb: Option<FsCallback>
+ // all made by reedlepee
+ priv complete_cb: Option<FsCallback>
}
impl FsRequest {
/// 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
// Obviously an Event Loop is always home.
pub struct UvEventLoop {
- uvio: UvIoFactory
+ // all made by reedlepee
+ priv uvio: UvIoFactory
}
impl 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 {
// 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<bool>
+ priv exit_flag: Exclusive<bool>
}
impl UvRemoteCallback {
}
pub struct UvTcpListener {
- watcher : TcpWatcher,
- home: SchedHandle,
+ // all made by reedlepee
+ priv watcher : TcpWatcher,
+ priv home: SchedHandle,
}
impl HomingIO for UvTcpListener {
}
pub struct UvTcpAcceptor {
- listener: UvTcpListener,
- incoming: Tube<Result<~RtioTcpStreamObject, IoError>>,
+ // all made by reedlepee
+ priv listener: UvTcpListener,
+ priv incoming: Tube<Result<~RtioTcpStreamObject, IoError>>,
}
impl HomingIO for UvTcpAcceptor {
}
pub struct UvUnboundPipe {
+ // all made by reedlepee
pipe: Pipe,
- home: SchedHandle,
+ priv home: SchedHandle,
}
impl HomingIO for UvUnboundPipe {
}
pub struct UvPipeStream {
+ // already
priv inner: ~UvUnboundPipe,
}
}
pub struct UvTcpStream {
- watcher: TcpWatcher,
- home: SchedHandle,
+ // all made by reedlepee
+ priv watcher: TcpWatcher,
+ priv home: SchedHandle,
}
impl HomingIO for UvTcpStream {
}
pub struct UvUdpSocket {
- watcher: UdpWatcher,
- home: SchedHandle,
+ // all made by reedelpee
+ priv watcher: UdpWatcher,
+ priv home: SchedHandle,
}
impl HomingIO 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 {
}
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 {
}
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<SchedHandle>,
+ priv home: Option<SchedHandle>,
// All None until the process exits (exit_error may stay None)
+ // Rest were already priv
priv exit_status: Option<int>,
priv term_signal: Option<int>,
priv exit_error: Option<UvError>,
// see libuv/include/uv-unix.h
#[cfg(unix)]
pub struct uv_buf_t {
+ // all made by reedelpee
base: *u8,
len: libc::size_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,
}
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 {
#[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;
}
pub struct uv_err_data {
- err_name: ~str,
- err_msg: ~str,
+ // all made by reedelpee
+ priv err_name: ~str,
+ priv err_msg: ~str,
}
extern {
use clone::Clone;
pub struct WorkQueue<T> {
+ // already priv
// XXX: Another mystery bug fixed by boxing this lock
priv queue: ~Exclusive<~[T]>
}
* 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.
/// The output of a finished process.
pub struct ProcessOutput {
-
+ /// made priv by reedlepee
/// The status (exit code) of the process.
status: int,
/// Use with the `std::iterator` module.
#[deriving(Clone)]
pub struct CharIterator<'self> {
+ // already priv
/// The slice remaining to be iterated
priv string: &'self str,
}
/// 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>,
/// 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,
/// 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,
/// substring within a larger string
#[deriving(Clone)]
pub struct MatchesIndexIterator<'self> {
+ // already priv
priv haystack: &'self str,
priv needle: &'self str,
priv position: uint,
/// search string
#[deriving(Clone)]
pub struct StrSplitIterator<'self> {
+ // already priv
priv it: MatchesIndexIterator<'self>,
priv last_end: uint,
priv finished: bool
/// 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
}
/// 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 {
*
*/
pub struct SchedOpts {
- mode: SchedMode,
+ // all made by reedelpee
+ priv mode: SchedMode,
}
/**
* scheduler other tasks will be impeded or even blocked indefinitely.
*/
pub struct TaskOpts {
- linked: bool,
- supervised: bool,
- watched: bool,
- indestructible: bool,
- notify_chan: Option<Chan<TaskResult>>,
- name: Option<SendStr>,
- sched: SchedOpts,
- stack_size: Option<uint>
+ // all made by reedelpee
+ priv linked: bool,
+ priv supervised: bool,
+ priv watched: bool,
+ priv indestructible: bool,
+ priv notify_chan: Option<Chan<TaskResult>>,
+ name: Option<SendStr>,
+ sched: SchedOpts,
+ stack_size: Option<uint>
}
/**
// 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<util::NonCopyable>,
- consumed: bool,
+ priv gen_body: Option<~fn(v: ~fn()) -> ~fn()>,
+ priv can_not_copy: Option<util::NonCopyable>,
+ priv consumed: bool,
}
/**
// 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<AutoNotify>,
+ priv ancestors: AncestorList,
+
priv notifier: Option<AutoNotify>,
}
impl Drop for Taskgroup {
#[allow(missing_doc)]
pub struct TrieMap<T> {
+ // already priv
priv root: TrieNode<T>,
priv length: uint
}
#[allow(missing_doc)]
pub struct TrieSet {
+ // already priv
priv map: TrieMap<()>
}
/// Forward iterator over a map
pub struct TrieMapIterator<'self, T> {
+ // already priv
priv stack: ~[vec::VecIterator<'self, Child<T>>],
priv remaining_min: uint,
priv remaining_max: uint
/// Forward iterator over a set
pub struct TrieSetIterator<'self> {
+ // already priv
priv iter: TrieMapIterator<'self, ()>
}
* A simple atomic flag, that can be set and cleared. The most basic atomic type.
*/
pub struct AtomicFlag {
+ // already
priv v: int
}
* An atomic boolean type.
*/
pub struct AtomicBool {
+ // already
priv v: uint
}
* A signed atomic integer type, supporting basic atomic arithmetic operations
*/
pub struct AtomicInt {
+ // already
priv v: int
}
* An unsigned atomic integer type, supporting basic atomic arithmetic operations
*/
pub struct AtomicUint {
+ // already
priv v: uint
}
* An unsafe atomic pointer. Only supports basic atomic operations
*/
pub struct AtomicPtr<T> {
+ // already
priv p: *mut T
}
*/
#[unsafe_no_drop_flag]
pub struct AtomicOption<T> {
+ // already
priv p: *mut c_void
}
use option::*;
use result::*;
+// already
pub struct DynamicLibrary { priv handle: *libc::c_void }
impl Drop for DynamicLibrary {
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! 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<T> {
+ val: T,
+ next: uint
+ }
+
+ impl<T> Parsed<T> {
+ pub fn new(val: T, next: uint) -> Parsed<T> {
+ 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<uint>,
+ 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<Parsed<uint>> {
+ 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<Piece> {
+ 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<Option<uint>> {
+ 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<Count> {
+ 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<Count> {
+ 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<Ty> {
+ 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<uint>, 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<T>(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<T>(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<char>, 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);
+ }
+}
#[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
/// The representation of a Rust managed box
pub struct Box<T> {
+ // all ade by reedlepee
ref_count: uint,
type_desc: *TyDesc,
- prev: *Box<T>,
+ priv prev: *Box<T>,
next: *Box<T>,
data: T
}
/// The representation of a Rust vector
pub struct Vec<T> {
+ // all ade by reedlepee
fill: uint,
alloc: uint,
data: T
/// The representation of a Rust slice
pub struct Slice<T> {
+ // all ade by reedlepee
data: *T,
len: uint
}
/// The representation of a Rust closure
pub struct Closure {
+ // all ade by reedlepee
code: *(),
env: *(),
}
/// Enforces no shared-memory safety.
//#[unsafe_no_drop_flag] FIXME: #9758
pub struct UnsafeArc<T> {
+ // all ade by reedlepee
data: *mut ArcData<T>,
}
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 {
* need to block or deschedule while accessing shared state, use extra::sync::RWArc.
*/
pub struct Exclusive<T> {
- x: UnsafeArc<ExData<T>>
+ // all ade by reedlepee
+ priv x: UnsafeArc<ExData<T>>
}
impl<T:Send> Clone for Exclusive<T> {
/// 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,
/// 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,
/// 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,
///
/// Generates even and odd permutations alternatingly.
pub struct Permutations<T> {
+ // already priv
priv swaps: ElementSwaps,
priv v: ~[T],
}
/// a vector.
#[deriving(Clone)]
pub struct WindowIter<'self, T> {
+ // already priv
priv v: &'self [T],
priv size: uint
}
/// 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
}
//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
//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
/// An iterator that moves out of a vector.
#[deriving(Clone)]
pub struct MoveIterator<T> {
+ // already priv
priv v: ~[T],
priv idx: uint,
}
/// An iterator that moves out of a vector in reverse order.
#[deriving(Clone)]
pub struct MoveRevIterator<T> {
+ // already priv
priv v: ~[T]
}
projects / rust.git / commitdiff