about summary refs log tree commit diff
path: root/src/libstd
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd')
-rw-r--r--src/libstd/cleanup.rs2
-rw-r--r--src/libstd/fmt/mod.rs8
-rw-r--r--src/libstd/io/extensions.rs4
-rw-r--r--src/libstd/io/mod.rs24
-rw-r--r--src/libstd/io/net/addrinfo.rs2
-rw-r--r--src/libstd/io/net/tcp.rs2
-rw-r--r--src/libstd/rand/distributions/mod.rs2
-rw-r--r--src/libstd/rt/crate_map.rs2
-rw-r--r--src/libstd/rt/local_heap.rs4
-rw-r--r--src/libstd/rt/mod.rs8
-rw-r--r--src/libstd/rt/rtio.rs4
-rw-r--r--src/libstd/rt/task.rs2
-rw-r--r--src/libstd/rt/util.rs2
-rw-r--r--src/libstd/send_str.rs2
-rw-r--r--src/libstd/sync/deque.rs2
-rw-r--r--src/libstd/sync/spsc_queue.rs4
16 files changed, 37 insertions, 37 deletions
diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs
index 40c4ad842ff..82c1ed7440c 100644
--- a/src/libstd/cleanup.rs
+++ b/src/libstd/cleanup.rs
@@ -55,7 +55,7 @@ unsafe fn each_live_alloc(read_next_before: bool,
 
 #[cfg(unix)]
 fn debug_mem() -> bool {
-    // XXX: Need to port the environment struct to newsched
+    // FIXME: Need to port the environment struct to newsched
     false
 }
 
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index 5b2a792a05b..111eb70eb20 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -780,7 +780,7 @@ impl<'a> Formatter<'a> {
                         rt::Keyword(parse::One) => value == 1,
                         rt::Keyword(parse::Two) => value == 2,
 
-                        // XXX: Few/Many should have a user-specified boundary
+                        // FIXME: Few/Many should have a user-specified boundary
                         //      One possible option would be in the function
                         //      pointer of the 'arg: Argument' struct.
                         rt::Keyword(parse::Few) => value < 8,
@@ -1085,7 +1085,7 @@ integer!(i64, u64)
 macro_rules! floating(($ty:ident) => {
     impl Float for $ty {
         fn fmt(f: &$ty, fmt: &mut Formatter) {
-            // XXX: this shouldn't perform an allocation
+            // FIXME: this shouldn't perform an allocation
             let s = match fmt.precision {
                 Some(i) => ::$ty::to_str_exact(f.abs(), i),
                 None => ::$ty::to_str_digits(f.abs(), 6)
@@ -1096,7 +1096,7 @@ macro_rules! floating(($ty:ident) => {
 
     impl LowerExp for $ty {
         fn fmt(f: &$ty, fmt: &mut Formatter) {
-            // XXX: this shouldn't perform an allocation
+            // FIXME: this shouldn't perform an allocation
             let s = match fmt.precision {
                 Some(i) => ::$ty::to_str_exp_exact(f.abs(), i, false),
                 None => ::$ty::to_str_exp_digits(f.abs(), 6, false)
@@ -1107,7 +1107,7 @@ macro_rules! floating(($ty:ident) => {
 
     impl UpperExp for $ty {
         fn fmt(f: &$ty, fmt: &mut Formatter) {
-            // XXX: this shouldn't perform an allocation
+            // FIXME: this shouldn't perform an allocation
             let s = match fmt.precision {
                 Some(i) => ::$ty::to_str_exp_exact(f.abs(), i, true),
                 None => ::$ty::to_str_exp_digits(f.abs(), 6, true)
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 6a9da944f8b..26e0a0d09ad 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -10,8 +10,8 @@
 
 //! Utility mixins that apply to all Readers and Writers
 
-// XXX: Not sure how this should be structured
-// XXX: Iteration should probably be considered separately
+// FIXME: Not sure how this should be structured
+// FIXME: Iteration should probably be considered separately
 
 use container::Container;
 use iter::Iterator;
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 6141faa90da..8531edeb2c6 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -84,7 +84,7 @@ Some examples of obvious things you might want to do
     ```
 
 * Make an simple HTTP request
-  XXX This needs more improvement: TcpStream constructor taking &str,
+  FIXME This needs more improvement: TcpStream constructor taking &str,
   `write_str` and `write_line` methods.
 
     ```rust,should_fail
@@ -101,7 +101,7 @@ Some examples of obvious things you might want to do
 * Connect based on URL? Requires thinking about where the URL type lives
   and how to make protocol handlers extensible, e.g. the "tcp" protocol
   yields a `TcpStream`.
-  XXX this is not implemented now.
+  FIXME this is not implemented now.
 
     ```rust
     // connect("tcp://localhost:8080");
@@ -209,7 +209,7 @@ if error.is_some() {
 # ::std::io::fs::unlink(&Path::new("diary.txt"));
 ```
 
-XXX: Need better condition handling syntax
+FIXME: Need better condition handling syntax
 
 In this case the condition handler will have the opportunity to
 inspect the IoError raised by either the call to `new` or the call to
@@ -232,8 +232,8 @@ to errors similar to null pointer dereferences.
 In particular code written to ignore errors and expect conditions to be unhandled
 will start passing around null or zero objects when wrapped in a condition handler.
 
-* XXX: How should we use condition handlers that return values?
-* XXX: Should EOF raise default conditions when EOF is not an error?
+* FIXME: How should we use condition handlers that return values?
+* FIXME: Should EOF raise default conditions when EOF is not an error?
 
 # Issues with i/o scheduler affinity, work stealing, task pinning
 
@@ -263,7 +263,7 @@ Out of scope
 * Async I/O. We'll probably want it eventually
 
 
-# XXX Questions and issues
+# FIXME Questions and issues
 
 * Should default constructors take `Path` or `&str`? `Path` makes simple cases verbose.
   Overloading would be nice.
@@ -375,7 +375,7 @@ static DEFAULT_BUF_SIZE: uint = 1024 * 64;
 
 /// The type passed to I/O condition handlers to indicate error
 ///
-/// # XXX
+/// # FIXME
 ///
 /// Is something like this sufficient? It's kind of archaic
 pub struct IoError {
@@ -446,7 +446,7 @@ impl ToStr for IoErrorKind {
     }
 }
 
-// XXX: Can't put doc comments on macros
+// FIXME: Can't put doc comments on macros
 // Raised by `I/O` operations on error.
 condition! {
     pub io_error: IoError -> ();
@@ -491,9 +491,9 @@ pub trait Reader {
     /// Raises the `io_error` condition on error. If the condition
     /// is handled then no guarantee is made about the number of bytes
     /// read and the contents of `buf`. If the condition is handled
-    /// returns `None` (XXX see below).
+    /// returns `None` (FIXME see below).
     ///
-    /// # XXX
+    /// # FIXME
     ///
     /// * Should raise_default error on eof?
     /// * If the condition is handled it should still return the bytes read,
@@ -1218,7 +1218,7 @@ pub enum SeekStyle {
     SeekCur,
 }
 
-/// # XXX
+/// # FIXME
 /// * Are `u64` and `i64` the right choices?
 pub trait Seek {
     /// Return position of file cursor in the stream
@@ -1228,7 +1228,7 @@ pub trait Seek {
     ///
     /// A successful seek clears the EOF indicator.
     ///
-    /// # XXX
+    /// # FIXME
     ///
     /// * What is the behavior when seeking past the end of a stream?
     fn seek(&mut self, pos: i64, style: SeekStyle);
diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs
index 4a8529d0a0a..a1650c9a3a3 100644
--- a/src/libstd/io/net/addrinfo.rs
+++ b/src/libstd/io/net/addrinfo.rs
@@ -91,7 +91,7 @@ pub fn get_host_addresses(host: &str) -> Option<~[IpAddr]> {
 ///
 /// On failure, this will raise on the `io_error` condition.
 ///
-/// XXX: this is not public because the `Hint` structure is not ready for public
+/// FIXME: this is not public because the `Hint` structure is not ready for public
 ///      consumption just yet.
 fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>)
           -> Option<~[Info]> {
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index b901ea99cbe..9f0bf84c8d8 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -584,7 +584,7 @@ mod test {
     })
 
     iotest!(fn socket_and_peer_name_ip6() {
-        // XXX: peer name is not consistent
+        // FIXME: peer name is not consistent
         //peer_name(next_test_ip6());
         socket_name(next_test_ip6());
     })
diff --git a/src/libstd/rand/distributions/mod.rs b/src/libstd/rand/distributions/mod.rs
index a996233abe3..140323110df 100644
--- a/src/libstd/rand/distributions/mod.rs
+++ b/src/libstd/rand/distributions/mod.rs
@@ -51,7 +51,7 @@ pub trait Sample<Support> {
 /// Since no state is recorded, each sample is (statistically)
 /// independent of all others, assuming the `Rng` used has this
 /// property.
-// XXX maybe having this separate is overkill (the only reason is to
+// FIXME maybe having this separate is overkill (the only reason is to
 // take &self rather than &mut self)? or maybe this should be the
 // trait called `Sample` and the other should be `DependentSample`.
 pub trait IndependentSample<Support>: Sample<Support> {
diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs
index 6ea12659e77..8567f0e0251 100644
--- a/src/libstd/rt/crate_map.rs
+++ b/src/libstd/rt/crate_map.rs
@@ -108,7 +108,7 @@ fn do_iter_crate_map<'a>(
 
 /// Iterates recursively over `crate_map` and all child crate maps
 pub fn iter_crate_map<'a>(crate_map: &'a CrateMap<'a>, f: |&ModEntry|) {
-    // XXX: use random numbers as keys from the OS-level RNG when there is a nice
+    // FIXME: use random numbers as keys from the OS-level RNG when there is a nice
     //        way to do this
     let mut v: HashSet<*CrateMap<'a>> = HashSet::with_capacity_and_keys(0, 0, 32);
     do_iter_crate_map(crate_map, f, &mut v);
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index 36e3bf858e3..42a7e7867f9 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -293,7 +293,7 @@ impl Drop for MemoryRegion {
 
 #[inline]
 pub unsafe fn local_malloc(td: *u8, size: uint) -> *u8 {
-    // XXX: Unsafe borrow for speed. Lame.
+    // FIXME: Unsafe borrow for speed. Lame.
     let task: Option<*mut Task> = Local::try_unsafe_borrow();
     match task {
         Some(task) => {
@@ -306,7 +306,7 @@ pub unsafe fn local_malloc(td: *u8, size: uint) -> *u8 {
 // A little compatibility function
 #[inline]
 pub unsafe fn local_free(ptr: *u8) {
-    // XXX: Unsafe borrow for speed. Lame.
+    // FIXME: Unsafe borrow for speed. Lame.
     let task_ptr: Option<*mut Task> = Local::try_unsafe_borrow();
     match task_ptr {
         Some(task) => {
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 9088ee6898b..56f6c8f8e6c 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -52,7 +52,7 @@ Several modules in `core` are clients of `rt`:
 
 */
 
-// XXX: this should not be here.
+// FIXME: this should not be here.
 #[allow(missing_doc)];
 
 use any::Any;
@@ -71,7 +71,7 @@ pub use self::util::default_sched_threads;
 // Export unwinding facilities used by the failure macros
 pub use self::unwind::{begin_unwind, begin_unwind_raw};
 
-// XXX: these probably shouldn't be public...
+// FIXME: these probably shouldn't be public...
 #[doc(hidden)]
 pub mod shouldnt_be_public {
     pub use super::local_ptr::native::maybe_tls_key;
@@ -155,7 +155,7 @@ pub trait Runtime {
     /// The (low, high) edges of the current stack.
     fn stack_bounds(&self) -> (uint, uint); // (lo, hi)
 
-    // XXX: This is a serious code smell and this should not exist at all.
+    // FIXME: This is a serious code smell and this should not exist at all.
     fn wrap(~self) -> ~Any;
 }
 
@@ -165,7 +165,7 @@ pub trait Runtime {
 /// the crate's logging flags, registering GC
 /// metadata, and storing the process arguments.
 pub fn init(argc: int, argv: **u8) {
-    // XXX: Derefing these pointers is not safe.
+    // FIXME: Derefing these pointers is not safe.
     // Need to propagate the unsafety to `start`.
     unsafe {
         args::init(argc, argv);
diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs
index 6b3d50a76ac..455a84b4ce3 100644
--- a/src/libstd/rt/rtio.rs
+++ b/src/libstd/rt/rtio.rs
@@ -86,7 +86,7 @@ pub struct LocalIo<'a> {
 #[unsafe_destructor]
 impl<'a> Drop for LocalIo<'a> {
     fn drop(&mut self) {
-        // XXX(pcwalton): Do nothing here for now, but eventually we may want
+        // FIXME(pcwalton): Do nothing here for now, but eventually we may want
         // something. For now this serves to make `LocalIo` noncopyable.
     }
 }
@@ -143,7 +143,7 @@ impl<'a> LocalIo<'a> {
     /// Returns the underlying I/O factory as a trait reference.
     #[inline]
     pub fn get<'a>(&'a mut self) -> &'a mut IoFactory {
-        // XXX(pcwalton): I think this is actually sound? Could borrow check
+        // FIXME(pcwalton): I think this is actually sound? Could borrow check
         // allow this safely?
         unsafe {
             cast::transmute_copy(&self.factory)
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index e63208bcaec..e99e7fa4edd 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -212,7 +212,7 @@ impl Task {
         // pretty sketchy and involves shuffling vtables of trait objects
         // around, but it gets the job done.
         //
-        // XXX: This function is a serious code smell and should be avoided at
+        // FIXME: This function is a serious code smell and should be avoided at
         //      all costs. I have yet to think of a method to avoid this
         //      function, and I would be saddened if more usage of the function
         //      crops up.
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index b482e2fb67f..9c17c624987 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -20,7 +20,7 @@ use unstable::running_on_valgrind;
 use vec::ImmutableVector;
 
 // Indicates whether we should perform expensive sanity checks, including rtassert!
-// XXX: Once the runtime matures remove the `true` below to turn off rtassert, etc.
+// FIXME: Once the runtime matures remove the `true` below to turn off rtassert, etc.
 pub static ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) || cfg!(rtassert);
 
 /// Get the number of cores available
diff --git a/src/libstd/send_str.rs b/src/libstd/send_str.rs
index c8143442d6e..b6c9acd2672 100644
--- a/src/libstd/send_str.rs
+++ b/src/libstd/send_str.rs
@@ -119,7 +119,7 @@ impl Str for SendStr {
     fn as_slice<'r>(&'r self) -> &'r str {
         match *self {
             SendStrOwned(ref s) => s.as_slice(),
-            // XXX: Borrowchecker doesn't recognize lifetime as static unless prompted
+            // FIXME: Borrowchecker doesn't recognize lifetime as static unless prompted
             // SendStrStatic(s) => s.as_slice()
             SendStrStatic(s)    => {let tmp: &'static str = s; tmp}
         }
diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs
index e740862fddf..b65feedb2ae 100644
--- a/src/libstd/sync/deque.rs
+++ b/src/libstd/sync/deque.rs
@@ -45,7 +45,7 @@
 // NB: the "buffer pool" strategy is not done for speed, but rather for
 //     correctness. For more info, see the comment on `swap_buffer`
 
-// XXX: all atomic operations in this module use a SeqCst ordering. That is
+// FIXME: all atomic operations in this module use a SeqCst ordering. That is
 //      probably overkill
 
 use cast;
diff --git a/src/libstd/sync/spsc_queue.rs b/src/libstd/sync/spsc_queue.rs
index 6f1b887c271..b4b327cc9d1 100644
--- a/src/libstd/sync/spsc_queue.rs
+++ b/src/libstd/sync/spsc_queue.rs
@@ -43,7 +43,7 @@ use sync::atomics::{AtomicPtr, Relaxed, AtomicUint, Acquire, Release};
 
 // Node within the linked list queue of messages to send
 struct Node<T> {
-    // XXX: this could be an uninitialized T if we're careful enough, and
+    // FIXME: this could be an uninitialized T if we're careful enough, and
     //      that would reduce memory usage (and be a bit faster).
     //      is it worth it?
     value: Option<T>,           // nullable for re-use of nodes
@@ -225,7 +225,7 @@ impl<T: Send, P: Send> State<T, P> {
         if self.cache_bound == 0 {
             self.tail_prev.store(tail, Release);
         } else {
-            // XXX: this is dubious with overflow.
+            // FIXME: this is dubious with overflow.
             let additions = self.cache_additions.load(Relaxed);
             let subtractions = self.cache_subtractions.load(Relaxed);
             let size = additions - subtractions;
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-01-15 13:42:49 +0000