got pre-linking steps working, removed glob includes

1 files changed, 35 insertions, 27 deletions

diff --git a/src/proto.rs b/src/proto.rs
index 21e8903..2bf13a6 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,6 +1,6 @@
-use std::{mem, fmt};
+use super::Pitch;
 use std::time::Duration;
-use super::*;
+use std::fmt;
 
 use ::byteorder::{ByteOrder, NetworkEndian};
 
@@ -9,7 +9,9 @@ const OBLIGATE_POLYPHONE: u32 = 0xffffffff;
 
 pub enum Command {
     KeepAlive,
-    Ping{data: [u8; 32]},
+    Ping {
+        data: [u8; 32],
+    },
     Quit,
     Play{sec: u32, usec: u32, freq: u32, amp: f32, voice: u32},
     Caps{voices: u32, tp: [u8; 4], ident: [u8; 24]},
@@ -24,14 +26,14 @@ impl Command {
 
     pub fn duration(&self) -> Option<Duration> {
         match *self {
-            Command::Play{sec, usec, ..} => Some(Duration::new(sec as u64, usec * 1000)),
+            Command::Play { sec, usec, .. } => Some(Duration::new(sec as u64, usec * 1000)),
             _ => None,
         }
     }
 
     pub fn pitch(&self) -> Option<Pitch> {
         match *self {
-            Command::Play{freq, ..} => Some(Pitch::Freq(freq as f32)),
+            Command::Play { freq, .. } => Some(Pitch::Freq(freq as f32)),
             _ => None,
         }
     }
@@ -43,22 +45,28 @@ impl Command {
 
         match *self {
             Command::KeepAlive => NetworkEndian::write_u32(&mut ret[..4], 0),
-            Command::Ping{data} => {
+            Command::Ping { data } => {
                 NetworkEndian::write_u32(&mut ret[..4], 1);
                 (&mut ret[4..]).copy_from_slice(&data);
-            },
+            }
             Command::Quit => NetworkEndian::write_u32(&mut ret[..4], 2),
-            Command::Play{sec, usec, freq, amp, voice} => {
+            Command::Play {
+                sec,
+                usec,
+                freq,
+                amp,
+                voice,
+            } => {
                 NetworkEndian::write_u32_into(&[3u32, sec, usec, freq], &mut ret[..16]);
                 NetworkEndian::write_f32(&mut ret[16..20], amp);
                 NetworkEndian::write_u32(&mut ret[20..24], voice);
-            },
-            Command::Caps{voices, tp, ident} => {
+            }
+            Command::Caps { voices, tp, ident } => {
                 NetworkEndian::write_u32_into(&[4u32, voices], &mut ret[..8]);
                 (&mut ret[8..12]).copy_from_slice(&tp);
                 (&mut ret[12..]).copy_from_slice(&ident);
-            },
-            Command::PCM{samples} => {
+            }
+            Command::PCM { samples } => {
                 NetworkEndian::write_u32(&mut ret[..4], 5);
                 NetworkEndian::write_i16_into(&samples, &mut ret[4..]);
             },
@@ -71,7 +79,7 @@ impl Command {
             },
             Command::Unknown{data} => {
                 ret.copy_from_slice(&data);
-            },
+            }
         };
 
         true
@@ -83,7 +91,7 @@ impl fmt::Debug for Command {
         f.write_str("Command::")?;
         match *self {
             Command::KeepAlive => f.write_str("KeepAlive"),
-            Command::Ping{data} => f.debug_struct("Ping").field("data", &data).finish(),
+            Command::Ping { data } => f.debug_struct("Ping").field("data", &data).finish(),
             Command::Quit => f.write_str("Quit"),
             Command::Play{sec, usec, freq, amp, voice} => f.debug_struct("Play").field("sec", &sec).field("usec", &usec).field("freq", &freq).field("amp", &amp).field("voice", &voice).finish(),
             Command::Caps{voices, tp, ident} => f.debug_struct("Caps").field("voices", &voices).field("tp", &tp).field("ident", &ident).finish(),
@@ -97,20 +105,20 @@ impl fmt::Debug for Command {
 
 impl<'a> From<&'a [u8; Command::SIZE]> for Command {
     fn from(packet: &'a [u8; Command::SIZE]) -> Command {
-        let mut fields_u32: [u32; Command::SIZE / 4] = unsafe { mem::uninitialized() };
-        let mut fields_f32: [f32; Command::SIZE / 4] = unsafe { mem::uninitialized() };
+        let mut fields_u32: [u32; Command::SIZE / 4] = [0; Command::SIZE / 4];
+        let mut fields_f32: [f32; Command::SIZE / 4] = [0.0; Command::SIZE / 4];
         NetworkEndian::read_u32_into(packet, &mut fields_u32);
-        unsafe { NetworkEndian::read_f32_into_unchecked(packet, &mut fields_f32); }
+        NetworkEndian::read_f32_into(packet, &mut fields_f32);
 
         match fields_u32[0] {
             0 => Command::KeepAlive,
             1 => {
-                let mut data: [u8; 32] = unsafe { mem::uninitialized() };
+                let mut data: [u8; 32] = [0; 32];
                 data.copy_from_slice(&packet[4..]);
-                Command::Ping{data: data}
+                Command::Ping { data: data }
             }
             2 => Command::Quit,
-            3 => Command::Play{
+            3 => Command::Play {
                 sec: fields_u32[1],
                 usec: fields_u32[2],
                 freq: fields_u32[3],
@@ -118,18 +126,18 @@ impl<'a> From<&'a [u8; Command::SIZE]> for Command {
                 voice: fields_u32[5],
             },
             4 => {
-                let mut tp: [u8; 4] = unsafe { mem::uninitialized() };
-                let mut ident: [u8; 24] = unsafe { mem::uninitialized() };
+                let mut tp: [u8; 4] = [0; 4];
+                let mut ident: [u8; 24] = [0; 24];
                 tp.copy_from_slice(&packet[8..12]);
                 ident.copy_from_slice(&packet[12..]);
-                Command::Caps{
+                Command::Caps {
                     voices: fields_u32[1],
                     tp: tp,
                     ident: ident,
                 }
-            },
+            }
             5 => {
-                let mut samples: [i16; 16] = unsafe { mem::uninitialized() };
+                let mut samples: [i16; 16] = [0; 16];
                 ::byteorder::LittleEndian::read_i16_into(&packet[4..], &mut samples);
                 Command::PCM{samples: samples}
             },
@@ -140,9 +148,9 @@ impl<'a> From<&'a [u8; Command::SIZE]> for Command {
                 value: fields_f32[3],
             },
             _ => {
-                let mut data: [u8; Command::SIZE] = unsafe { mem::uninitialized() };
+                let mut data: [u8; Command::SIZE] = [0; Command::SIZE];
                 data.copy_from_slice(packet);
-                Command::Unknown{data: data}
+                Command::Unknown { data: data }
             }
         }
     }