"libstd/sync/spsc_queue.rs", # BSD
"libstd/sync/mpmc_bounded_queue.rs", # BSD
"libsync/mpsc_intrusive.rs", # BSD
+ "test/bench/shootout-fannkuch-redux.rs", # BSD
"test/bench/shootout-meteor.rs", # BSD
+ "test/bench/shootout-regex-dna.rs", # BSD
]
def check_license(name, contents):
use core::ops;
use core::slice;
use core::uint;
+use std::hash;
use vec::Vec;
}
impl SmallBitv {
- pub fn new(bits: uint) -> SmallBitv {
+ fn new(bits: uint) -> SmallBitv {
SmallBitv {bits: bits}
}
#[inline]
- pub fn bits_op(&mut self,
+ fn bits_op(&mut self,
right_bits: uint,
nbits: uint,
f: |uint, uint| -> uint)
}
#[inline]
- pub fn union(&mut self, s: &SmallBitv, nbits: uint) -> bool {
+ fn union(&mut self, s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |u1, u2| u1 | u2)
}
#[inline]
- pub fn intersect(&mut self, s: &SmallBitv, nbits: uint) -> bool {
+ fn intersect(&mut self, s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |u1, u2| u1 & u2)
}
#[inline]
- pub fn become(&mut self, s: &SmallBitv, nbits: uint) -> bool {
+ fn become(&mut self, s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |_u1, u2| u2)
}
#[inline]
- pub fn difference(&mut self, s: &SmallBitv, nbits: uint) -> bool {
+ fn difference(&mut self, s: &SmallBitv, nbits: uint) -> bool {
self.bits_op(s.bits, nbits, |u1, u2| u1 & !u2)
}
#[inline]
- pub fn get(&self, i: uint) -> bool {
+ fn get(&self, i: uint) -> bool {
(self.bits & (1 << i)) != 0
}
#[inline]
- pub fn set(&mut self, i: uint, x: bool) {
+ fn set(&mut self, i: uint, x: bool) {
if x {
self.bits |= 1<<i;
}
}
#[inline]
- pub fn equals(&self, b: &SmallBitv, nbits: uint) -> bool {
+ fn equals(&self, b: &SmallBitv, nbits: uint) -> bool {
let mask = small_mask(nbits);
mask & self.bits == mask & b.bits
}
#[inline]
- pub fn clear(&mut self) { self.bits = 0; }
+ fn clear(&mut self) { self.bits = 0; }
#[inline]
- pub fn set_all(&mut self) { self.bits = !0; }
+ fn set_all(&mut self) { self.bits = !0; }
#[inline]
- pub fn all(&self, nbits: uint) -> bool {
+ fn all(&self, nbits: uint) -> bool {
small_mask(nbits) & !self.bits == 0
}
#[inline]
- pub fn none(&self, nbits: uint) -> bool {
+ fn none(&self, nbits: uint) -> bool {
small_mask(nbits) & self.bits == 0
}
#[inline]
- pub fn negate(&mut self) { self.bits = !self.bits; }
+ fn negate(&mut self) { self.bits = !self.bits; }
}
#[deriving(Clone)]
}
impl BigBitv {
- pub fn new(storage: Vec<uint>) -> BigBitv {
+ fn new(storage: Vec<uint>) -> BigBitv {
BigBitv {storage: storage}
}
#[inline]
- pub fn process(&mut self,
+ fn process(&mut self,
b: &BigBitv,
nbits: uint,
op: |uint, uint| -> uint)
}
#[inline]
- pub fn each_storage(&mut self, op: |v: &mut uint| -> bool) -> bool {
+ fn each_storage(&mut self, op: |v: &mut uint| -> bool) -> bool {
self.storage.mut_iter().advance(|elt| op(elt))
}
#[inline]
- pub fn negate(&mut self) {
+ fn negate(&mut self) {
self.each_storage(|w| { *w = !*w; true });
}
#[inline]
- pub fn union(&mut self, b: &BigBitv, nbits: uint) -> bool {
+ fn union(&mut self, b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, |w1, w2| w1 | w2)
}
#[inline]
- pub fn intersect(&mut self, b: &BigBitv, nbits: uint) -> bool {
+ fn intersect(&mut self, b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, |w1, w2| w1 & w2)
}
#[inline]
- pub fn become(&mut self, b: &BigBitv, nbits: uint) -> bool {
+ fn become(&mut self, b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, |_, w| w)
}
#[inline]
- pub fn difference(&mut self, b: &BigBitv, nbits: uint) -> bool {
+ fn difference(&mut self, b: &BigBitv, nbits: uint) -> bool {
self.process(b, nbits, |w1, w2| w1 & !w2)
}
#[inline]
- pub fn get(&self, i: uint) -> bool {
+ fn get(&self, i: uint) -> bool {
let w = i / uint::BITS;
let b = i % uint::BITS;
let x = 1 & self.storage.get(w) >> b;
}
#[inline]
- pub fn set(&mut self, i: uint, x: bool) {
+ fn set(&mut self, i: uint, x: bool) {
let w = i / uint::BITS;
let b = i % uint::BITS;
let flag = 1 << b;
}
#[inline]
- pub fn equals(&self, b: &BigBitv, nbits: uint) -> bool {
+ fn equals(&self, b: &BigBitv, nbits: uint) -> bool {
for (i, elt) in b.storage.iter().enumerate() {
let mask = big_mask(nbits, i);
if mask & *self.storage.get(i) != mask & *elt {
}
}
+impl<S: hash::Writer> hash::Hash<S> for Bitv {
+ fn hash(&self, state: &mut S) {
+ self.nbits.hash(state);
+ match self.rep {
+ Small(ref s) => (s.bits & small_mask(self.nbits)).hash(state),
+ Big(ref b) => {
+ for (i, ele) in b.storage.iter().enumerate() {
+ (ele & big_mask(self.nbits, i)).hash(state);
+ }
+ }
+ }
+ }
+}
+
#[inline]
fn iterate_bits(base: uint, bits: uint, f: |uint| -> bool) -> bool {
if bits == 0 {
}
}
+impl<S: hash::Writer> hash::Hash<S> for BitvSet {
+ fn hash(&self, state: &mut S) {
+ for pos in self.iter() {
+ pos.hash(state);
+ }
+ }
+}
+
impl Container for BitvSet {
#[inline]
fn len(&self) -> uint { self.size }
use core::prelude::*;
use alloc::owned::Box;
+use core::fmt;
use core::iter;
use core::mem;
use core::ptr;
}
}
+impl<A: fmt::Show> fmt::Show for DList<A> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ try!(write!(f, "["));
+
+ for (i, e) in self.iter().enumerate() {
+ if i != 0 { try!(write!(f, ", ")); }
+ try!(write!(f, "{}", *e));
+ }
+
+ write!(f, "]")
+ }
+}
+
#[cfg(test)]
mod tests {
use std::prelude::*;
}
}
+ #[test]
+ fn test_show() {
+ let list: DList<int> = range(0, 10).collect();
+ assert!(list.to_str().as_slice() == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+
+ let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
+ .map(|&s| s)
+ .collect();
+ assert!(list.to_str().as_slice() == "[just, one, test, more]");
+ }
+
#[cfg(test)]
fn fuzz_test(sz: int) {
let mut m: DList<int> = DList::new();
use core::prelude::*;
+use core::fmt;
use core::iter::{Enumerate, FilterMap};
use core::mem::replace;
}
}
+impl<V: fmt::Show> fmt::Show for SmallIntMap<V> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ try!(write!(f, r"\{"));
+
+ for (i, (k, v)) in self.iter().enumerate() {
+ if i != 0 { try!(write!(f, ", ")); }
+ try!(write!(f, "{}: {}", k, *v));
+ }
+
+ write!(f, r"\}")
+ }
+}
macro_rules! iterator {
(impl $name:ident -> $elem:ty, $getter:ident) => {
assert!(called);
m.insert(2, box 1);
}
+
+ #[test]
+ fn test_show() {
+ let mut map = SmallIntMap::new();
+ let empty = SmallIntMap::<int>::new();
+
+ map.insert(1, 2);
+ map.insert(3, 4);
+
+ let map_str = map.to_str();
+ let map_str = map_str.as_slice();
+ assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}");
+ assert_eq!(format!("{}", empty), "{}".to_string());
+ }
}
#[cfg(test)]
// In a post-DST world, we can attempt to reuse the Vec allocation by calling
// shrink_to_fit() on it. That may involve a reallocation+memcpy, but that's no
- // diffrent than what we're doing manually here.
+ // different than what we're doing manually here.
let vp = v.as_mut_ptr();
/// Trait for values that can be compared for equality and inequality.
///
-/// This trait allows partial equality, where types can be unordered instead of
-/// strictly equal or unequal. For example, with the built-in floating-point
-/// types `a == b` and `a != b` will both evaluate to false if either `a` or
-/// `b` is NaN (cf. IEEE 754-2008 section 5.11).
+/// This trait allows for partial equality, for types that do not have an
+/// equivalence relation. For example, in floating point numbers `NaN != NaN`,
+/// so floating point types implement `PartialEq` but not `Eq`.
///
-/// PartialEq only requires the `eq` method to be implemented; `ne` is its negation by
-/// default.
+/// PartialEq only requires the `eq` method to be implemented; `ne` is defined
+/// in terms of it by default. Any manual implementation of `ne` *must* respect
+/// the rule that `eq` is a strict inverse of `ne`; that is, `!(a == b)` if and
+/// only if `a != b`.
///
/// Eventually, this will be implemented by default for types that implement
/// `Eq`.
/// PartialOrd only requires implementation of the `lt` method,
/// with the others generated from default implementations.
///
-/// However it remains possible to implement the others separately,
-/// for compatibility with floating-point NaN semantics
-/// (cf. IEEE 754-2008 section 5.11).
+/// However it remains possible to implement the others separately for types
+/// which do not have a total order. For example, for floating point numbers,
+/// `NaN < 0 == false` and `NaN >= 0 == false` (cf. IEEE 754-2008 section
+/// 5.11).
#[lang="ord"]
pub trait PartialOrd: PartialEq {
/// This method tests less than (for `self` and `other`) and is used by the `<` operator.
//!
//! ## Stability Note
//!
-//! These are all experimental. The inferface may change entirely, without
+//! These are all experimental. The interface may change entirely, without
//! warning.
#![allow(non_camel_case_types)]
}
/// The internal state of an iterator that searches for matches of a substring
-/// within a larger string using a dynamically chosed search algorithm
+/// within a larger string using a dynamically chosen search algorithm
#[deriving(Clone)]
enum Searcher {
Naive(NaiveSearcher),
///
/// That is, each returned value `(start, end)` satisfies
/// `self.slice(start, end) == sep`. For matches of `sep` within
- /// `self` that overlap, only the indicies corresponding to the
+ /// `self` that overlap, only the indices corresponding to the
/// first match are returned.
///
/// # Example
pub fn extract(attrs: &[ast::Attribute]) -> Option<InternedString> {
for attribute in attrs.iter() {
- match attribute.name_str_pair() {
- Some((ref key, ref value)) if key.equiv(&("lang")) => {
- return Some((*value).clone());
+ match attribute.value_str() {
+ Some(ref value) if attribute.check_name("lang") => {
+ return Some(value.clone());
}
- Some(..) | None => {}
+ _ => {}
}
}
TypeOverflow,
UnusedUnsafe,
UnsafeBlock,
- AttributeUsage,
UnusedAttribute,
UnknownFeatures,
UnknownCrateType,
default: Allow
}),
- ("attribute_usage",
- LintSpec {
- lint: AttributeUsage,
- desc: "detects bad use of attributes",
- default: Warn
- }),
-
("unused_attribute",
LintSpec {
lint: UnusedAttribute,
}
}
-static crate_attrs: &'static [&'static str] = &[
- "crate_type", "feature", "no_start", "no_main", "no_std", "crate_id",
- "desc", "comment", "license", "copyright", // not used in rustc now
- "no_builtins",
-];
-
-
-static obsolete_attrs: &'static [(&'static str, &'static str)] = &[
- ("abi", "Use `extern \"abi\" fn` instead"),
- ("auto_encode", "Use `#[deriving(Encodable)]` instead"),
- ("auto_decode", "Use `#[deriving(Decodable)]` instead"),
- ("fast_ffi", "Remove it"),
- ("fixed_stack_segment", "Remove it"),
- ("rust_stack", "Remove it"),
-];
-
-static other_attrs: &'static [&'static str] = &[
- // item-level
- "address_insignificant", // can be crate-level too
- "thread_local", // for statics
- "allow", "deny", "forbid", "warn", // lint options
- "deprecated", "experimental", "unstable", "stable", "locked", "frozen", //item stability
- "cfg", "doc", "export_name", "link_section",
- "no_mangle", "static_assert", "unsafe_no_drop_flag", "packed",
- "simd", "repr", "deriving", "unsafe_destructor", "link", "phase",
- "macro_export", "must_use", "automatically_derived",
-
- //mod-level
- "path", "link_name", "link_args", "macro_escape", "no_implicit_prelude",
-
- // fn-level
- "test", "bench", "should_fail", "ignore", "inline", "lang", "main", "start",
- "no_split_stack", "cold", "macro_registrar", "linkage",
-
- // internal attribute: bypass privacy inside items
- "!resolve_unexported",
-];
-
-fn check_crate_attrs_usage(cx: &Context, attrs: &[ast::Attribute]) {
-
- for attr in attrs.iter() {
- let name = attr.node.value.name();
- let mut iter = crate_attrs.iter().chain(other_attrs.iter());
- if !iter.any(|other_attr| { name.equiv(other_attr) }) {
- cx.span_lint(AttributeUsage, attr.span, "unknown crate attribute");
- }
- if name.equiv(&("link")) {
- cx.tcx.sess.span_err(attr.span,
- "obsolete crate `link` attribute");
- cx.tcx.sess.note("the link attribute has been superceded by the crate_id \
- attribute, which has the format `#[crate_id = \"name#version\"]`");
- }
- }
-}
-
-fn check_attrs_usage(cx: &Context, attrs: &[ast::Attribute]) {
- // check if element has crate-level, obsolete, or any unknown attributes.
-
- for attr in attrs.iter() {
- let name = attr.node.value.name();
- for crate_attr in crate_attrs.iter() {
- if name.equiv(crate_attr) {
- let msg = match attr.node.style {
- ast::AttrOuter => "crate-level attribute should be an inner attribute: \
- add an exclamation mark: #![foo]",
- ast::AttrInner => "crate-level attribute should be in the root module",
- };
- cx.span_lint(AttributeUsage, attr.span, msg);
- return;
- }
- }
-
- for &(obs_attr, obs_alter) in obsolete_attrs.iter() {
- if name.equiv(&obs_attr) {
- cx.span_lint(AttributeUsage, attr.span,
- format!("obsolete attribute: {:s}",
- obs_alter).as_slice());
- return;
- }
- }
-
- if !other_attrs.iter().any(|other_attr| { name.equiv(other_attr) }) {
- cx.span_lint(AttributeUsage, attr.span, "unknown attribute");
- }
- }
-}
-
-fn check_unused_attribute(cx: &Context, attrs: &[ast::Attribute]) {
+fn check_unused_attribute(cx: &Context, attr: &ast::Attribute) {
static ATTRIBUTE_WHITELIST: &'static [&'static str] = &'static [
// FIXME: #14408 whitelist docs since rustdoc looks at them
"doc",
"stable",
"unstable",
];
- for attr in attrs.iter() {
- for &name in ATTRIBUTE_WHITELIST.iter() {
- if attr.check_name(name) {
- break;
- }
+
+ static CRATE_ATTRS: &'static [&'static str] = &'static [
+ "crate_type",
+ "feature",
+ "no_start",
+ "no_main",
+ "no_std",
+ "crate_id",
+ "desc",
+ "comment",
+ "license",
+ "copyright",
+ "no_builtins",
+ ];
+
+ for &name in ATTRIBUTE_WHITELIST.iter() {
+ if attr.check_name(name) {
+ break;
}
+ }
- if !attr::is_used(attr) {
- cx.span_lint(UnusedAttribute, attr.span, "unused attribute");
+ if !attr::is_used(attr) {
+ cx.span_lint(UnusedAttribute, attr.span, "unused attribute");
+ if CRATE_ATTRS.contains(&attr.name().get()) {
+ let msg = match attr.node.style {
+ ast::AttrOuter => "crate-level attribute should be an inner \
+ attribute: add an exclamation mark: #![foo]",
+ ast::AttrInner => "crate-level attribute should be in the \
+ root module",
+ };
+ cx.span_lint(UnusedAttribute, attr.span, msg);
}
}
}
check_item_non_uppercase_statics(cx, it);
check_heap_item(cx, it);
check_missing_doc_item(cx, it);
- check_attrs_usage(cx, it.attrs.as_slice());
- check_unused_attribute(cx, it.attrs.as_slice());
check_raw_ptr_deriving(cx, it);
cx.visit_ids(|v| v.visit_item(it, ()));
fn visit_foreign_item(&mut self, it: &ast::ForeignItem, _: ()) {
self.with_lint_attrs(it.attrs.as_slice(), |cx| {
- check_attrs_usage(cx, it.attrs.as_slice());
visit::walk_foreign_item(cx, it, ());
})
}
fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) {
self.with_lint_attrs(i.attrs.as_slice(), |cx| {
- check_attrs_usage(cx, i.attrs.as_slice());
-
cx.visit_ids(|v| v.visit_view_item(i, ()));
visit::walk_view_item(cx, i, ());
visit::FkMethod(ident, _, m) => {
self.with_lint_attrs(m.attrs.as_slice(), |cx| {
check_missing_doc_method(cx, m);
- check_attrs_usage(cx, m.attrs.as_slice());
match method_context(cx, m) {
PlainImpl => check_snake_case(cx, "method", ident, span),
fn visit_ty_method(&mut self, t: &ast::TypeMethod, _: ()) {
self.with_lint_attrs(t.attrs.as_slice(), |cx| {
check_missing_doc_ty_method(cx, t);
- check_attrs_usage(cx, t.attrs.as_slice());
check_snake_case(cx, "trait method", t.ident, t.span);
visit::walk_ty_method(cx, t, ());
fn visit_struct_field(&mut self, s: &ast::StructField, _: ()) {
self.with_lint_attrs(s.node.attrs.as_slice(), |cx| {
check_missing_doc_struct_field(cx, s);
- check_attrs_usage(cx, s.node.attrs.as_slice());
visit::walk_struct_field(cx, s, ());
})
fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics, _: ()) {
self.with_lint_attrs(v.node.attrs.as_slice(), |cx| {
check_missing_doc_variant(cx, v);
- check_attrs_usage(cx, v.node.attrs.as_slice());
visit::walk_variant(cx, v, g, ());
})
// FIXME(#10894) should continue recursing
fn visit_ty(&mut self, _t: &ast::Ty, _: ()) {}
+
+ fn visit_attribute(&mut self, attr: &ast::Attribute, _: ()) {
+ check_unused_attribute(self, attr);
+ }
}
impl<'a> IdVisitingOperation for Context<'a> {
visit::walk_crate(v, krate, ());
});
- check_crate_attrs_usage(cx, krate.attrs.as_slice());
// since the root module isn't visited as an item (because it isn't an item), warn for it
// here.
- check_unused_attribute(cx, krate.attrs.as_slice());
check_missing_doc_attrs(cx,
None,
krate.attrs.as_slice(),
{
// no-op
} else if !ty::type_is_numeric(b_ty) && !ty::type_is_char(b_ty) {
- tcx.sess.span_err(pat.span, "non-numeric type used in range");
+ tcx.sess.span_err(pat.span,
+ "only char and numeric types are allowed in range");
} else {
match valid_range_bounds(fcx.ccx, begin, end) {
Some(false) => {
}
}
fn meta_item_list<'a>(&'a self) -> Option<&'a [@ast::MetaItem]> { None }
- fn name_str_pair(&self) -> Option<(InternedString, InternedString)> {
- None
- }
}
impl<'a> attr::AttrMetaMethods for &'a Attribute {
fn name(&self) -> InternedString { (**self).name() }
fn value_str(&self) -> Option<InternedString> { (**self).value_str() }
fn meta_item_list<'a>(&'a self) -> Option<&'a [@ast::MetaItem]> { None }
- fn name_str_pair(&self) -> Option<(InternedString, InternedString)> {
- None
- }
}
#[deriving(Clone, Encodable, Decodable)]
if lints {
prog.push_str(r"
#![deny(warnings)]
-#![allow(unused_variable, dead_assignment, unused_mut, attribute_usage, dead_code)]
+#![allow(unused_variable, dead_assignment, unused_mut, unused_attribute, dead_code)]
");
}
ParseObject(bool),
// Parse ',' or ']' after an element in an object.
ParseObjectComma,
- // Initialial state.
+ // Initial state.
ParseStart,
// Expecting the stream to end.
ParseBeforeFinish,
// We maintain a stack representing where we are in the logical structure
// of the JSON stream.
stack: Stack,
- // A state machine is kept to make it possible to interupt and resume parsing.
+ // A state machine is kept to make it possible to interrupt and resume parsing.
state: ParserState,
}
// information to return a JsonEvent.
// Manages an internal state so that parsing can be interrupted and resumed.
// Also keeps track of the position in the logical structure of the json
- // stream int the form of a stack that can be queried by the user usng the
+ // stream int the form of a stack that can be queried by the user using the
// stack() method.
fn parse(&mut self) -> JsonEvent {
loop {
use result::{Ok, Err};
use super::{Reader, Writer, IoResult};
use str::StrSlice;
-use slice::{bytes, CloneableVector, MutableVector, ImmutableVector};
+use slice::{bytes, MutableVector, ImmutableVector};
+use vec::Vec;
/// Allows reading from a rx.
///
/// # drop(tx);
/// let mut reader = ChanReader::new(rx);
///
-/// let mut buf = ~[0u8, ..100];
+/// let mut buf = [0u8, ..100];
/// match reader.read(buf) {
/// Ok(nread) => println!("Read {} bytes", nread),
/// Err(e) => println!("read error: {}", e),
/// }
/// ```
pub struct ChanReader {
- buf: Option<~[u8]>, // A buffer of bytes received but not consumed.
- pos: uint, // How many of the buffered bytes have already be consumed.
- rx: Receiver<~[u8]>, // The rx to pull data from.
- closed: bool, // Whether the pipe this rx connects to has been closed.
+ buf: Option<Vec<u8>>, // A buffer of bytes received but not consumed.
+ pos: uint, // How many of the buffered bytes have already be consumed.
+ rx: Receiver<Vec<u8>>, // The Receiver to pull data from.
+ closed: bool, // Whether the channel this Receiver connects to has been closed.
}
impl ChanReader {
/// Wraps a `Port` in a `ChanReader` structure
- pub fn new(rx: Receiver<~[u8]>) -> ChanReader {
+ pub fn new(rx: Receiver<Vec<u8>>) -> ChanReader {
ChanReader {
buf: None,
pos: 0,
/// writer.write("hello, world".as_bytes());
/// ```
pub struct ChanWriter {
- tx: Sender<~[u8]>,
+ tx: Sender<Vec<u8>>,
}
impl ChanWriter {
/// Wraps a channel in a `ChanWriter` structure
- pub fn new(tx: Sender<~[u8]>) -> ChanWriter {
+ pub fn new(tx: Sender<Vec<u8>>) -> ChanWriter {
ChanWriter { tx: tx }
}
}
impl Writer for ChanWriter {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
- self.tx.send_opt(buf.to_owned()).map_err(|_| {
+ self.tx.send_opt(Vec::from_slice(buf)).map_err(|_| {
io::IoError {
kind: io::BrokenPipe,
desc: "Pipe closed",
fn test_rx_reader() {
let (tx, rx) = channel();
task::spawn(proc() {
- tx.send(box [1u8, 2u8]);
- tx.send(box []);
- tx.send(box [3u8, 4u8]);
- tx.send(box [5u8, 6u8]);
- tx.send(box [7u8, 8u8]);
+ tx.send(vec![1u8, 2u8]);
+ tx.send(vec![]);
+ tx.send(vec![3u8, 4u8]);
+ tx.send(vec![5u8, 6u8]);
+ tx.send(vec![7u8, 8u8]);
});
let mut reader = ChanReader::new(rx);
- let mut buf = box [0u8, ..3];
+ let mut buf = [0u8, ..3];
assert_eq!(Ok(0), reader.read([]));
assert_eq!(Ok(3), reader.read(buf));
- assert_eq!(box [1,2,3], buf);
+ assert_eq!(&[1,2,3], buf.as_slice());
assert_eq!(Ok(3), reader.read(buf));
- assert_eq!(box [4,5,6], buf);
+ assert_eq!(&[4,5,6], buf.as_slice());
assert_eq!(Ok(2), reader.read(buf));
- assert_eq!(box [7,8,6], buf);
+ assert_eq!(&[7,8,6], buf.as_slice());
match reader.read(buf) {
Ok(..) => fail!(),
Err(e) => assert_eq!(e.kind, io::EndOfFile),
}
- assert_eq!(box [7,8,6], buf);
+ assert_eq!(&[7,8,6], buf.as_slice());
// Ensure it continues to fail in the same way.
match reader.read(buf) {
Ok(..) => fail!(),
Err(e) => assert_eq!(e.kind, io::EndOfFile),
}
- assert_eq!(box [7,8,6], buf);
+ assert_eq!(&[7,8,6], buf.as_slice());
}
#[test]
let mut writer = ChanWriter::new(tx);
writer.write_be_u32(42).unwrap();
- let wanted = box [0u8, 0u8, 0u8, 42u8];
+ let wanted = vec![0u8, 0u8, 0u8, 42u8];
let got = task::try(proc() { rx.recv() }).unwrap();
assert_eq!(wanted, got);
/// Returns a slice of `v` between `start` and `end`.
///
-/// Similar to `slice()` except this function only bounds the sclie on the
+/// Similar to `slice()` except this function only bounds the slice on the
/// capacity of `v`, not the length.
///
/// # Failure
pub fn sleeper() -> Process {
// There's a `timeout` command on windows, but it doesn't like having
// its output piped, so instead just ping ourselves a few times with
- // gaps inbetweeen so we're sure this process is alive for awhile
+ // gaps in between so we're sure this process is alive for awhile
Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().unwrap()
}
pub fn stdin() -> BufferedReader<StdReader> {
// The default buffer capacity is 64k, but apparently windows doesn't like
// 64k reads on stdin. See #13304 for details, but the idea is that on
- // windows we use a slighly smaller buffer that's been seen to be
+ // windows we use a slightly smaller buffer that's been seen to be
// acceptable.
if cfg!(windows) {
BufferedReader::with_capacity(8 * 1024, stdin_raw())
}
/// Creates a oneshot receiver which will have a notification sent when
- /// `msecs` milliseconds has elapsed. This does *not* block the current
- /// task, but instead returns immediately.
+ /// `msecs` milliseconds has elapsed.
+ ///
+ /// This does *not* block the current task, but instead returns immediately.
///
/// Note that this invalidates any previous receiver which has been created
/// by this timer, and that the returned receiver will be invalidated once
- /// the timer is destroyed (when it falls out of scope).
+ /// the timer is destroyed (when it falls out of scope). In particular, if
+ /// this is called in method-chaining style, the receiver will be
+ /// invalidated at the end of that statement, and all `recv` calls will
+ /// fail.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// use std::io::timer::Timer;
+ ///
+ /// let mut timer = Timer::new().unwrap();
+ /// let ten_milliseconds = timer.oneshot(10);
+ ///
+ /// for _ in range(0, 100) { /* do work */ }
+ ///
+ /// // blocks until 10 ms after the `oneshot` call
+ /// ten_milliseconds.recv();
+ /// ```
+ ///
+ /// ```rust
+ /// use std::io::timer::Timer;
+ ///
+ /// // Incorrect, method chaining-style:
+ /// let mut five_ms = Timer::new().unwrap().oneshot(5);
+ /// // The timer object was destroyed, so this will always fail:
+ /// // five_ms.recv()
+ /// ```
pub fn oneshot(&mut self, msecs: u64) -> Receiver<()> {
let (tx, rx) = channel();
self.obj.oneshot(msecs, box TimerCallback { tx: tx });
}
/// Creates a receiver which will have a continuous stream of notifications
- /// being sent every `msecs` milliseconds. This does *not* block the
- /// current task, but instead returns immediately. The first notification
- /// will not be received immediately, but rather after `msec` milliseconds
- /// have passed.
+ /// being sent every `msecs` milliseconds.
+ ///
+ /// This does *not* block the current task, but instead returns
+ /// immediately. The first notification will not be received immediately,
+ /// but rather after `msec` milliseconds have passed.
///
/// Note that this invalidates any previous receiver which has been created
/// by this timer, and that the returned receiver will be invalidated once
- /// the timer is destroyed (when it falls out of scope).
+ /// the timer is destroyed (when it falls out of scope). In particular, if
+ /// this is called in method-chaining style, the receiver will be
+ /// invalidated at the end of that statement, and all `recv` calls will
+ /// fail.
+ ///
+ /// # Example
+ ///
+ /// ```rust
+ /// use std::io::timer::Timer;
+ ///
+ /// let mut timer = Timer::new().unwrap();
+ /// let ten_milliseconds = timer.periodic(10);
+ ///
+ /// for _ in range(0, 100) { /* do work */ }
+ ///
+ /// // blocks until 10 ms after the `periodic` call
+ /// ten_milliseconds.recv();
+ ///
+ /// for _ in range(0, 100) { /* do work */ }
+ ///
+ /// // blocks until 20 ms after the `periodic` call (*not* 10ms after the
+ /// // previous `recv`)
+ /// ten_milliseconds.recv();
+ /// ```
+ ///
+ /// ```rust
+ /// use std::io::timer::Timer;
+ ///
+ /// // Incorrect, method chaining-style.
+ /// let mut five_ms = Timer::new().unwrap().periodic(5);
+ /// // The timer object was destroyed, so this will always fail:
+ /// // five_ms.recv()
+ /// ```
pub fn periodic(&mut self, msecs: u64) -> Receiver<()> {
let (tx, rx) = channel();
self.obj.period(msecs, box TimerCallback { tx: tx });
iotest!(fn test_io_timer_oneshot_then_sleep() {
let mut timer = Timer::new().unwrap();
let rx = timer.oneshot(100000000000);
- timer.sleep(1); // this should inalidate rx
+ timer.sleep(1); // this should invalidate rx
assert_eq!(rx.recv_opt(), Err(()));
})
let mut timer1 = Timer::new().unwrap();
timer1.oneshot(1);
let mut timer2 = Timer::new().unwrap();
- // while sleeping, the prevous timer should fire and not have its
+ // while sleeping, the previous timer should fire and not have its
// callback do something terrible.
timer2.sleep(2);
})
let mut timer1 = Timer::new().unwrap();
timer1.periodic(1);
let mut timer2 = Timer::new().unwrap();
- // while sleeping, the prevous timer should fire and not have its
+ // while sleeping, the previous timer should fire and not have its
// callback do something terrible.
timer2.sleep(2);
})
if accum_positive && accum <= last_accum { return NumStrConv::inf(); }
if !accum_positive && accum >= last_accum { return NumStrConv::neg_inf(); }
- // Detect overflow by reversing the shift-and-add proccess
+ // Detect overflow by reversing the shift-and-add process
if accum_positive &&
(last_accum != ((accum - cast(digit as int).unwrap())/radix_gen.clone())) {
return NumStrConv::inf();
/// let key = "HOME";
/// match std::os::getenv(key) {
/// Some(val) => println!("{}: {}", key, val),
-/// None => println!("{} is not defined in the environnement.", key)
+/// None => println!("{} is not defined in the environment.", key)
/// }
/// ```
pub fn getenv(n: &str) -> Option<String> {
ret
}
- /// See `GenericPathUnsafe::set_filename_unchecekd`.
+ /// See `GenericPathUnsafe::set_filename_unchecked`.
///
/// # Failure
///
// EINVAL means |stack_size| is either too small or not a
// multiple of the system page size. Because it's definitely
// >= PTHREAD_STACK_MIN, it must be an alignment issue.
- // Round up to the neareast page and try again.
+ // Round up to the nearest page and try again.
let page_size = os::page_size();
let stack_size = (stack_size + page_size - 1) & (-(page_size - 1) - 1);
assert_eq!(pthread_attr_setstacksize(&mut attr, stack_size as libc::size_t), 0);
fn value_str(&self) -> Option<InternedString>;
/// Gets a list of inner meta items from a list MetaItem type.
fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]>;
-
- /**
- * If the meta item is a name-value type with a string value then returns
- * a tuple containing the name and string value, otherwise `None`
- */
- fn name_str_pair(&self) -> Option<(InternedString,InternedString)>;
}
impl AttrMetaMethods for Attribute {
fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]> {
self.node.value.meta_item_list()
}
- fn name_str_pair(&self) -> Option<(InternedString,InternedString)> {
- self.meta().name_str_pair()
- }
}
impl AttrMetaMethods for MetaItem {
_ => None
}
}
-
- fn name_str_pair(&self) -> Option<(InternedString,InternedString)> {
- self.value_str().map(|s| (self.name(), s))
- }
}
// Annoying, but required to get test_cfg to work
fn meta_item_list<'a>(&'a self) -> Option<&'a [@MetaItem]> {
(**self).meta_item_list()
}
- fn name_str_pair(&self) -> Option<(InternedString,InternedString)> {
- (**self).name_str_pair()
- }
}
fn visit_path(&mut self, path: &Path, _id: ast::NodeId, e: E) {
walk_path(self, path, e)
}
+ fn visit_attribute(&mut self, _attr: &Attribute, _e: E) {}
}
pub fn walk_inlined_item<E: Clone, V: Visitor<E>>(visitor: &mut V,
pub fn walk_crate<E: Clone, V: Visitor<E>>(visitor: &mut V, krate: &Crate, env: E) {
- visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID, env)
+ visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID, env.clone());
+ for attr in krate.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
+ }
}
pub fn walk_mod<E: Clone, V: Visitor<E>>(visitor: &mut V, module: &Mod, env: E) {
pub fn walk_view_item<E: Clone, V: Visitor<E>>(visitor: &mut V, vi: &ViewItem, env: E) {
match vi.node {
ViewItemExternCrate(name, _, _) => {
- visitor.visit_ident(vi.span, name, env)
+ visitor.visit_ident(vi.span, name, env.clone())
}
ViewItemUse(ref vp) => {
match vp.node {
}
}
}
+ for attr in vi.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
+ }
}
pub fn walk_local<E: Clone, V: Visitor<E>>(visitor: &mut V, local: &Local, env: E) {
match item.node {
ItemStatic(typ, _, expr) => {
visitor.visit_ty(typ, env.clone());
- visitor.visit_expr(expr, env);
+ visitor.visit_expr(expr, env.clone());
}
ItemFn(declaration, fn_style, abi, ref generics, body) => {
visitor.visit_fn(&FkItemFn(item.ident, generics, fn_style, abi),
body,
item.span,
item.id,
- env)
+ env.clone())
}
ItemMod(ref module) => {
- visitor.visit_mod(module, item.span, item.id, env)
+ visitor.visit_mod(module, item.span, item.id, env.clone())
}
ItemForeignMod(ref foreign_module) => {
for view_item in foreign_module.view_items.iter() {
}
ItemTy(typ, ref type_parameters) => {
visitor.visit_ty(typ, env.clone());
- visitor.visit_generics(type_parameters, env)
+ visitor.visit_generics(type_parameters, env.clone())
}
ItemEnum(ref enum_definition, ref type_parameters) => {
visitor.visit_generics(type_parameters, env.clone());
- walk_enum_def(visitor, enum_definition, type_parameters, env)
+ walk_enum_def(visitor, enum_definition, type_parameters, env.clone())
}
ItemImpl(ref type_parameters,
ref trait_reference,
item.ident,
generics,
item.id,
- env)
+ env.clone())
}
ItemTrait(ref generics, _, ref trait_paths, ref methods) => {
visitor.visit_generics(generics, env.clone());
visitor.visit_trait_method(method, env.clone())
}
}
- ItemMac(ref macro) => visitor.visit_mac(macro, env),
+ ItemMac(ref macro) => visitor.visit_mac(macro, env.clone()),
+ }
+ for attr in item.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
}
}
}
}
match variant.node.disr_expr {
- Some(expr) => visitor.visit_expr(expr, env),
+ Some(expr) => visitor.visit_expr(expr, env.clone()),
None => ()
}
+ for attr in variant.node.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
+ }
}
pub fn skip_ty<E, V: Visitor<E>>(_: &mut V, _: &Ty, _: E) {
match foreign_item.node {
ForeignItemFn(function_declaration, ref generics) => {
walk_fn_decl(visitor, function_declaration, env.clone());
- visitor.visit_generics(generics, env)
+ visitor.visit_generics(generics, env.clone())
}
- ForeignItemStatic(typ, _) => visitor.visit_ty(typ, env),
+ ForeignItemStatic(typ, _) => visitor.visit_ty(typ, env.clone()),
+ }
+
+ for attr in foreign_item.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
}
}
method.body,
method.span,
method.id,
- env)
+ env.clone());
+ for attr in method.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
+ }
}
pub fn walk_fn<E: Clone, V: Visitor<E>>(visitor: &mut V,
visitor.visit_ty(argument_type.ty, env.clone())
}
visitor.visit_generics(&method_type.generics, env.clone());
- visitor.visit_ty(method_type.decl.output, env);
+ visitor.visit_ty(method_type.decl.output, env.clone());
+ for attr in method_type.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
+ }
}
pub fn walk_trait_method<E: Clone, V: Visitor<E>>(visitor: &mut V,
_ => {}
}
- visitor.visit_ty(struct_field.node.ty, env)
+ visitor.visit_ty(struct_field.node.ty, env.clone());
+
+ for attr in struct_field.node.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
+ }
}
pub fn walk_block<E: Clone, V: Visitor<E>>(visitor: &mut V, block: &Block, env: E) {
visitor.visit_pat(*pattern, env.clone())
}
walk_expr_opt(visitor, arm.guard, env.clone());
- visitor.visit_expr(arm.body, env)
+ visitor.visit_expr(arm.body, env.clone());
+ for attr in arm.attrs.iter() {
+ visitor.visit_attribute(attr, env.clone());
+ }
}
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
//
-// 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.
+// contributed by the Rust Project Developers
+
+// Copyright (c) 2014 The Rust Project Developers
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// - Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of "The Computer Language Benchmarks Game" nor
+// the name of "The Computer Language Shootout Benchmarks" nor the
+// names of its contributors may be used to endorse or promote
+// products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
use std::cmp::max;
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
+// The Computer Language Benchmarks Game
+// http://benchmarksgame.alioth.debian.org/
//
-// 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.
+// contributed by the Rust Project Developers
+
+// Copyright (c) 2014 The Rust Project Developers
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+// - Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// - Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the
+// distribution.
+//
+// - Neither the name of "The Computer Language Benchmarks Game" nor
+// the name of "The Computer Language Shootout Benchmarks" nor the
+// names of its contributors may be used to endorse or promote
+// products derived from this software without specific prior
+// written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
// FIXME(#13725) windows needs fixing.
// ignore-win32
// When denying at the crate level, be sure to not get random warnings from the
// injected intrinsics by the compiler.
-#![deny(attribute_usage)]
#![deny(unused_attribute)]
mod a {
- #![crate_type = "bin"] //~ ERROR: crate-level attribute
- //~^ ERROR: unused attribute
+ #![crate_type = "bin"] //~ ERROR unused attribute
+ //~^ ERROR should be in the root module
}
-#[crate_type = "bin"] fn main() {} //~ ERROR: crate-level attribute
- //~^ ERROR: unused attribute
+#[crate_type = "bin"] fn main() {} //~ ERROR unused attribute
+ //~^ ERROR should be an inner
// When denying at the crate level, be sure to not get random warnings from the
// injected intrinsics by the compiler.
-#![deny(attribute_usage)]
#![deny(unused_attribute)]
#![allow(dead_code)]
-#[abi="stdcall"] extern {} //~ ERROR: obsolete attribute
- //~^ ERROR: unused attribute
+#[abi="stdcall"] extern {} //~ ERROR unused attribute
-#[fixed_stack_segment] fn f() {} //~ ERROR: obsolete attribute
- //~^ ERROR: unused attribute
+#[fixed_stack_segment] fn f() {} //~ ERROR unused attribute
fn main() {}
// When denying at the crate level, be sure to not get random warnings from the
// injected intrinsics by the compiler.
-#![deny(attribute_usage)]
#![deny(unused_attribute)]
-#![mutable_doc] //~ ERROR: unknown crate attribute
- //~^ ERROR: unused attribute
+#![mutable_doc] //~ ERROR unused attribute
-#[dance] mod a {} //~ ERROR: unknown attribute
- //~^ ERROR: unused attribute
+#[dance] mod a {} //~ ERROR unused attribute
-#[dance] fn main() {} //~ ERROR: unknown attribute
- //~^ ERROR: unused attribute
+#[dance] fn main() {} //~ ERROR unused attribute
// except according to those terms.
//error-pattern: lower range bound
-//error-pattern: non-numeric
+//error-pattern: only char and numeric types
//error-pattern: mismatched types
fn main() {
--- /dev/null
+// Copyright 2014 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.
+#![deny(unused_attribute)]
+#![allow(dead_code, unused_imports)]
+
+#![foo] //~ ERROR unused attribute
+
+#[foo] //~ ERROR unused attribute
+extern crate std;
+
+#[foo] //~ ERROR unused attribute
+use std::collections;
+
+#[foo] //~ ERROR unused attribute
+extern "C" {
+ #[foo] //~ ERROR unused attribute
+ fn foo();
+}
+
+#[foo] //~ ERROR unused attribute
+mod foo {
+ #[foo] //~ ERROR unused attribute
+ pub enum Foo {
+ #[foo] //~ ERROR unused attribute
+ Bar,
+ }
+}
+
+#[foo] //~ ERROR unused attribute
+fn bar(f: foo::Foo) {
+ match f {
+ #[foo] //~ ERROR unused attribute
+ foo::Bar => {}
+ }
+}
+
+#[foo] //~ ERROR unused attribute
+struct Foo {
+ #[foo] //~ ERROR unused attribute
+ a: int
+}
+
+#[foo] //~ ERROR unused attribute
+trait Baz {
+ #[foo] //~ ERROR unused attribute
+ fn blah();
+ #[foo] //~ ERROR unused attribute
+ fn blah2() {}
+}
+
+fn main() {}
projects / rust.git / commitdiff