Convert field terminators to commas. Stop parsing semis.

Author: brson

src/libcore/future.rs

@@ -33,7 +33,7 @@ export future_pipe;
 
 #[doc = "The future type"]
 struct Future<A> {
-    /*priv*/ mut state: FutureState<A>;
+    /*priv*/ mut state: FutureState<A>,
 }
 
 priv enum FutureState<A> {

src/libcore/hash.rs

@@ -176,15 +176,15 @@ fn default_state() -> State {
 }
 
 struct SipState {
-    k0: u64;
-    k1: u64;
-    mut length: uint; // how many bytes we've processed
-    mut v0: u64;      // hash state
-    mut v1: u64;
-    mut v2: u64;
-    mut v3: u64;
-    tail: [mut u8]/8; // unprocessed bytes
-    mut ntail: uint;  // how many bytes in tail are valid
+    k0: u64,
+    k1: u64,
+    mut length: uint, // how many bytes we've processed
+    mut v0: u64,      // hash state
+    mut v1: u64,
+    mut v2: u64,
+    mut v3: u64,
+    tail: [mut u8]/8, // unprocessed bytes
+    mut ntail: uint,  // how many bytes in tail are valid
 }
 
 #[inline(always)]

src/libcore/managed.rs

@@ -20,8 +20,8 @@ export Managed;
 enum Mode { ReadOnly, Mutable, Immutable }
 
 struct Data<T> {
-    priv mut value: T;
-    priv mut mode: Mode;
+    priv mut value: T,
+    priv mut mode: Mode
 }
 
 type Managed<T> = @Data<T>;

src/libcore/path.rs

@@ -5,15 +5,15 @@
 use cmp::Eq;
 
 struct WindowsPath {
-    host: Option<~str>;
-    device: Option<~str>;
-    is_absolute: bool;
-    components: ~[~str];
+    host: Option<~str>,
+    device: Option<~str>,
+    is_absolute: bool,
+    components: ~[~str],
 }
 
 struct PosixPath {
-    is_absolute: bool;
-    components: ~[~str];
+    is_absolute: bool,
+    components: ~[~str],
 }
 
 trait GenericPath {

src/libcore/pipes.rs

@@ -465,7 +465,7 @@ fn try_recv<T: send, Tbuffer: send>(+p: RecvPacketBuffered<T, Tbuffer>)
     let p = unsafe { &*p_ };
 
     struct DropState {
-        p: &PacketHeader;
+        p: &PacketHeader,
 
         drop {
             if task::failing() {

src/libcore/send_map.rs

@@ -30,16 +30,16 @@ mod linear {
 
     const initial_capacity: uint = 32u; // 2^5
     struct Bucket<K:Eq Hash,V> {
-        hash: uint;
-        key: K;
-        value: V;
+        hash: uint,
+        key: K,
+        value: V,
     }
     struct LinearMap<K:Eq Hash,V> {
-        k0: u64;
-        k1: u64;
-        resize_at: uint;
-        size: uint;
-        buckets: ~[Option<Bucket<K,V>>];
+        k0: u64,
+        k1: u64,
+        resize_at: uint,
+        size: uint,
+        buckets: ~[Option<Bucket<K,V>>],
     }
 
     // FIXME(#3148) -- we could rewrite found_entry

src/libcore/sys.rs

@@ -28,8 +28,8 @@ enum TypeDesc = {
 
 /// The representation of a Rust closure
 struct Closure {
-    code: *();
-    env: *();
+    code: *(),
+    env: *(),
 }
 
 #[abi = "cdecl"]

src/libcore/unsafe.rs

@@ -86,15 +86,15 @@ unsafe fn copy_lifetime<S,T>(_ptr: &a/S, ptr: &T) -> &a/T {
 type UnwrapProto = ~mut Option<(pipes::ChanOne<()>, pipes::PortOne<bool>)>;
 
 struct ArcData<T> {
-    mut count:     libc::intptr_t;
-    mut unwrapper: libc::uintptr_t; // either a UnwrapProto or 0
+    mut count:     libc::intptr_t,
+    mut unwrapper: libc::uintptr_t, // either a UnwrapProto or 0
     // FIXME(#3224) should be able to make this non-option to save memory, and
     // in unwrap() use "let ~ArcData { data: result, _ } = thing" to unwrap it
-    mut data:      Option<T>;
+    mut data:      Option<T>,
 }
 
 struct ArcDestruct<T> {
-    mut data: *libc::c_void;
+    mut data: *libc::c_void,
     drop unsafe {
         if self.data.is_null() {
             return; // Happens when destructing an unwrapper's handle.
@@ -140,8 +140,8 @@ fn ArcDestruct<T>(data: *libc::c_void) -> ArcDestruct<T> {
 unsafe fn unwrap_shared_mutable_state<T: send>(+rc: SharedMutableState<T>)
         -> T {
     struct DeathThroes<T> {
-        mut ptr:      Option<~ArcData<T>>;
-        mut response: Option<pipes::ChanOne<bool>>;
+        mut ptr:      Option<~ArcData<T>>,
+        mut response: Option<pipes::ChanOne<bool>>,
         drop unsafe {
             let response = option::swap_unwrap(&mut self.response);
             // In case we get killed early, we need to tell the person who
@@ -312,11 +312,11 @@ impl LittleLock {
     }
 }
 
-struct ExData<T: send> { lock: LittleLock; mut failed: bool; mut data: T; }
+struct ExData<T: send> { lock: LittleLock, mut failed: bool, mut data: T, }
 /**
  * An arc over mutable data that is protected by a lock. For library use only.
  */
-struct Exclusive<T: send> { x: SharedMutableState<ExData<T>>; }
+struct Exclusive<T: send> { x: SharedMutableState<ExData<T>> }
 
 fn exclusive<T:send >(+user_data: T) -> Exclusive<T> {
     let data = ExData {

src/libcore/util.rs

@@ -54,7 +54,7 @@ fn replace<T>(dest: &mut T, +src: T) -> T {
 
 /// A non-copyable dummy type.
 struct NonCopyable {
-    i: ();
+    i: (),
     drop { }
 }
 

src/libstd/arc.rs

@@ -19,7 +19,7 @@ export RWARC, rw_arc_with_condvars, RWWriteMode, RWReadMode;
 export unwrap_rw_arc;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signalling.
-struct Condvar { is_mutex: bool; failed: &mut bool; cond: &sync::Condvar; }
+struct Condvar { is_mutex: bool, failed: &mut bool, cond: &sync::Condvar }
 
 impl &Condvar {
     /// Atomically exit the associated ARC and block until a signal is sent.
@@ -69,7 +69,7 @@ impl &Condvar {
  ****************************************************************************/
 
 /// An atomically reference counted wrapper for shared immutable state.
-struct ARC<T: const send> { x: SharedMutableState<T>; }
+struct ARC<T: const send> { x: SharedMutableState<T> }
 
 /// Create an atomically reference counted wrapper.
 fn ARC<T: const send>(+data: T) -> ARC<T> {
@@ -114,9 +114,9 @@ fn unwrap<T: const send>(+rc: ARC<T>) -> T {
  ****************************************************************************/
 
 #[doc(hidden)]
-struct MutexARCInner<T: send> { lock: Mutex; failed: bool; data: T; }
+struct MutexARCInner<T: send> { lock: Mutex, failed: bool, data: T }
 /// An ARC with mutable data protected by a blocking mutex.
-struct MutexARC<T: send> { x: SharedMutableState<MutexARCInner<T>>; }
+struct MutexARC<T: send> { x: SharedMutableState<MutexARCInner<T>> }
 
 /// Create a mutex-protected ARC with the supplied data.
 fn MutexARC<T: send>(+user_data: T) -> MutexARC<T> {
@@ -222,7 +222,7 @@ fn check_poison(is_mutex: bool, failed: bool) {
 
 #[doc(hidden)]
 struct PoisonOnFail {
-    failed: &mut bool;
+    failed: &mut bool,
     drop {
         /* assert !*self.failed; -- might be false in case of cond.wait() */
         if task::failing() { *self.failed = true; }
@@ -240,16 +240,16 @@ fn PoisonOnFail(failed: &r/mut bool) -> PoisonOnFail/&r {
  ****************************************************************************/
 
 #[doc(hidden)]
-struct RWARCInner<T: const send> { lock: RWlock; failed: bool; data: T; }
+struct RWARCInner<T: const send> { lock: RWlock, failed: bool, data: T }
 /**
  * A dual-mode ARC protected by a reader-writer lock. The data can be accessed
  * mutably or immutably, and immutably-accessing tasks may run concurrently.
  *
  * Unlike mutex_arcs, rw_arcs are safe, because they cannot be nested.
  */
 struct RWARC<T: const send> {
-    x: SharedMutableState<RWARCInner<T>>;
-    mut cant_nest: ();
+    x: SharedMutableState<RWARCInner<T>>,
+    mut cant_nest: ()
 }
 
 /// Create a reader/writer ARC with the supplied data.

src/libstd/arena.rs

@@ -51,9 +51,9 @@ struct Arena {
     // The head is seperated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to
     // access the head.
-    priv mut head: Chunk;
-    priv mut pod_head: Chunk;
-    priv mut chunks: @List<Chunk>;
+    priv mut head: Chunk,
+    priv mut pod_head: Chunk,
+    priv mut chunks: @List<Chunk>,
     drop {
         unsafe {
             destroy_chunk(self.head);

src/libstd/cell.rs

@@ -5,7 +5,7 @@
 /// Similar to a mutable option type, but friendlier.
 
 struct Cell<T> {
-    mut value: Option<T>;
+    mut value: Option<T>
 }
 
 /// Creates a new full cell with the given value.

src/libstd/comm.rs

@@ -14,8 +14,8 @@ export DuplexStream;
 
 /// An extension of `pipes::stream` that allows both sending and receiving.
 struct DuplexStream<T: send, U: send> : Channel<T>, Recv<U>, Selectable {
-    priv chan: Chan<T>;
-    priv port: Port <U>;
+    priv chan: Chan<T>,
+    priv port: Port <U>,
 
     fn send(+x: T) {
         self.chan.send(x)

src/libstd/map.rs

@@ -113,17 +113,17 @@ mod chained {
     const initial_capacity: uint = 32u; // 2^5
 
     struct entry<K, V> {
-        hash: uint;
-        key: K;
-        value: V;
-        mut next: Option<@entry<K, V>>;
+        hash: uint,
+        key: K,
+        value: V,
+        mut next: Option<@entry<K, V>>
     }
 
     struct hashmap_<K, V> {
-        mut count: uint;
-        mut chains: ~[mut Option<@entry<K,V>>];
-        hasher: hashfn<K>;
-        eqer: eqfn<K>;
+        mut count: uint,
+        mut chains: ~[mut Option<@entry<K,V>>],
+        hasher: hashfn<K>,
+        eqer: eqfn<K>
     }
 
     type t<K, V> = @hashmap_<K, V>;