// Extra parameter to run adb on arm-linux-androideabi
pub adb_path: String,
- // Extra parameter to run test sute on arm-linux-androideabi
+ // Extra parameter to run test suite on arm-linux-androideabi
pub adb_test_dir: String,
// status whether android device available or not
let DebuggerCommands { commands, check_lines, .. } = parse_debugger_commands(testfile, "gdb");
let mut cmds = commands.connect("\n");
- // compile test file (it shoud have 'compile-flags:-g' in the header)
+ // compile test file (it should have 'compile-flags:-g' in the header)
let compiler_run_result = compile_test(config, props, testfile);
if !compiler_run_result.status.success() {
fatal_proc_rec("compilation failed!", &compiler_run_result);
let config = &mut config;
- // compile test file (it shoud have 'compile-flags:-g' in the header)
+ // compile test file (it should have 'compile-flags:-g' in the header)
let compile_result = compile_test(config, props, testfile);
if !compile_result.status.success() {
fatal_proc_rec("compilation failed!", &compile_result);
next_idx: uint
}
-/// An iterator combining wo `BitvSet` iterators.
+/// An iterator combining two `BitvSet` iterators.
pub struct TwoBitPositions<'a> {
set: &'a BitvSet,
other: &'a BitvSet,
//! // 10 | |
//! // +---------------+
//! //
-//! // The graph is represented as an adjecency list where each index,
+//! // The graph is represented as an adjacency list where each index,
//! // corresponding to a node value, has a list of outgoing edges.
//! // Chosen for it's efficiency.
//! let graph = vec![
/// Create a `String` from a null-terminated *u8 buffer
///
/// This function is unsafe because we dereference memory until we find the NUL character,
- /// which is not guaranteed to be present. Additionaly, the slice is not checked to see
+ /// which is not guaranteed to be present. Additionally, the slice is not checked to see
/// whether it contains valid UTF-8
pub unsafe fn from_buf(buf: *const u8) -> String {
let mut len = 0;
}
impl<T> UnsafeCell<T> {
- /// Construct a new instance of `UnsafeCell` which will wrapp the specified
+ /// Construct a new instance of `UnsafeCell` which will wrap the specified
/// value.
///
/// All access to the inner value through methods is `unsafe`, and it is
// preserving a handle to the GreenTask down to this point, this
// unfortunately must call `GreenTask::convert`. In order to avoid
// this we could add a `terminate` function to the `Runtime` trait
- // in libstd, but that seems less appropriate since the coversion
+ // in libstd, but that seems less appropriate since the conversion
// method exists.
GreenTask::convert(task).terminate();
}
// It turns out that there's this nifty MSG_DONTWAIT flag which can be passed to
// send/recv, but the niftiness wears off once you realize it only works well on
// linux [1] [2]. This means that it's pretty easy to get a nonblocking
-// operation on linux (no flag fidding, no affecting other objects), but not on
+// operation on linux (no flag fiddling, no affecting other objects), but not on
// other platforms.
//
// To work around this constraint on other platforms, we end up using the
}
}
- // An example I found on microsoft's website used 20
+ // An example I found on Microsoft's website used 20
// seconds, libuv uses 30 seconds, hence we make the
// obvious choice of waiting for 25 seconds.
None => {
//! Finds crate binaries and loads their metadata
//!
//! Might I be the first to welcome you to a world of platform differences,
-//! version requirements, dependency graphs, conficting desires, and fun! This
+//! version requirements, dependency graphs, conflicting desires, and fun! This
//! is the major guts (along with metadata::creader) of the compiler for loading
//! crates and resolving dependencies. Let's take a tour!
//!
//! 5. Does the target in the metadata agree with the current target?
//! 6. Does the SVH match? (more on this later)
//!
-//! If the file answeres `yes` to all these questions, then the file is
+//! If the file answers `yes` to all these questions, then the file is
//! considered as being *candidate* for being accepted. It is illegal to have
//! more than two candidates as the compiler has no method by which to resolve
//! this conflict. Additionally, rlib/dylib candidates are considered
//! ## Loading transitive dependencies
//!
//! Dealing with same-named-but-distinct crates is not just a local problem, but
-//! one that also needs to be dealt with for transitive dependences. Note that
+//! one that also needs to be dealt with for transitive dependencies. Note that
//! in the letter above `--extern` flags only apply to the *local* set of
//! dependencies, not the upstream transitive dependencies. Consider this
//! dependency graph:
false
});
- // Now that we have an itertor of good candidates, make sure there's at
+ // Now that we have an iterator of good candidates, make sure there's at
// most one rlib and at most one dylib.
let mut rlibs = HashSet::new();
let mut dylibs = HashSet::new();
/// Stores the type parameters which were substituted to obtain the type
/// of this node. This only applies to nodes that refer to entities
- /// param<eterized by type parameters, such as generic fns, types, or
+ /// parameterized by type parameters, such as generic fns, types, or
/// other items.
pub item_substs: RefCell<NodeMap<ItemSubsts>>,
Ok(())
}
- /// Non-parellelized version of rendering an item. This will take the input
+ /// Non-parallelized version of rendering an item. This will take the input
/// item, render its contents, and then invoke the specified closure with
/// all sub-items which need to be rendered.
///
}
#[deriving(Encodable, Decodable, PartialEq, Eq)]
-/// A summarized module, which includes total counts and summarized chilcren
+/// A summarized module, which includes total counts and summarized children
/// modules.
pub struct ModuleSummary {
pub name: String,
// Cache the last used uv_write_t so we don't have to allocate a new one on
// every call to uv_write(). Ideally this would be a stack-allocated
// structure, but currently we don't have mappings for all the structures
- // defined in libuv, so we're foced to malloc this.
+ // defined in libuv, so we're forced to malloc this.
last_write_req: Option<Request>,
blocked_writer: Option<BlockedTask>,
/// # Example
///
/// This is a slightly silly example where we define the number's
- /// parity as the equivilance class. It is important that the
+ /// parity as the equivalence class. It is important that the
/// values hash the same, which is why we implement `Hash`.
///
/// ```rust
lookup(Some(host), None, None).map(|a| a.move_iter().map(|i| i.address.ip).collect())
}
-/// Full-fleged resolution. This function will perform a synchronous call to
+/// Full-fledged resolution. This function will perform a synchronous call to
/// getaddrinfo, controlled by the parameters
///
/// # Arguments
///
/// let root = Path::new("/");
/// assert!(os::change_dir(&root));
-/// println!("Succesfully changed working directory to {}!", root.display());
+/// println!("Successfully changed working directory to {}!", root.display());
/// ```
pub fn change_dir(p: &Path) -> bool {
return chdir(p);
pub fn lock<'a>(&'a self) -> MutexGuard<'a, T> {
let guard = self.lock.lock();
- // These two accesses are safe because we're guranteed at this point
+ // These two accesses are safe because we're guaranteed at this point
// that we have exclusive access to this mutex. We are indeed able to
// promote ourselves from &Mutex to `&mut T`
let poison = unsafe { &mut *self.failed.get() };
pub fn write<'a>(&'a self) -> RWLockWriteGuard<'a, T> {
let guard = self.lock.write();
- // These two accesses are safe because we're guranteed at this point
+ // These two accesses are safe because we're guaranteed at this point
// that we have exclusive access to this rwlock. We are indeed able to
// promote ourselves from &RWLock to `&mut T`
let poison = unsafe { &mut *self.failed.get() };
/// not allowed on univariant or zero-variant enums, which have no discriminant.
///
/// If a discriminant type is so specified, then the discriminant will be
-/// present (before fields, if any) with that type; reprensentation
+/// present (before fields, if any) with that type; representation
/// optimizations which would remove it will not be done.
pub fn find_repr_attr(diagnostic: &SpanHandler, attr: &Attribute, acc: ReprAttr)
-> ReprAttr {
//! }
//! ```
//!
-//! Other interesting scenarios are whe the item has type parameters or
+//! Other interesting scenarios are when the item has type parameters or
//! references other non-built-in types. A type definition like:
//!
//! ```ignore
return self.parse_single_struct_field(Inherited, attrs);
}
- /// Parse visiility: PUB, PRIV, or nothing
+ /// Parse visibility: PUB, PRIV, or nothing
fn parse_visibility(&mut self) -> Visibility {
if self.eat_keyword(keywords::Pub) { Public }
else { Inherited }
/// 'right' indices denote the active portion of the ring buffer as well as
/// describing hypothetical points-in-the-infinite-stream at most 3N tokens
/// apart (i.e. "not wrapped to ring-buffer boundaries"). The paper will switch
-/// between using 'left' and 'right' terms to denote the wrapepd-to-ring-buffer
+/// between using 'left' and 'right' terms to denote the wrapped-to-ring-buffer
/// and point-in-infinite-stream senses freely.
///
/// There is a parallel ring buffer, 'size', that holds the calculated size of
/// each token. Why calculated? Because for Begin/End pairs, the "size"
-/// includes everything betwen the pair. That is, the "size" of Begin is
+/// includes everything between the pair. That is, the "size" of Begin is
/// actually the sum of the sizes of everything between Begin and the paired
/// End that follows. Since that is arbitrarily far in the future, 'size' is
/// being rewritten regularly while the printer runs; in fact most of the
left: uint,
/// Index of right side of input stream
right: uint,
- /// Ring-buffr stream goes through
+ /// Ring-buffer stream goes through
token: Vec<Token> ,
/// Ring-buffer of calculated sizes
size: Vec<int> ,
projects / rust.git / commitdiff