Load hexdump of ELF

1 files changed, 70 insertions, 9 deletions

diff --git a/src/binary.rs b/src/binary.rs
index 2564637..e1e6d45 100644
--- a/src/binary.rs
+++ b/src/binary.rs
@@ -1,15 +1,76 @@
-pub struct Binary<'a> {
-    words: &'a [u32],
+use std::error::Error;
+use std::fmt;
+use std::fs::File;
+use std::io::{self, BufRead};
+use std::num;
+use std::path::Path;
+use std::str;
+
+pub struct Binary {
+    words: Vec<u32>,
 }
 
-impl<'a> Binary<'a> {
-    pub fn new(words: &'a [u32]) -> Binary<'a> {
-        Binary {
-            words: words,
+#[derive(Debug)]
+pub enum BinaryError {
+    Io(io::Error),
+    Utf8(str::Utf8Error),
+    ParseInt(num::ParseIntError),
+}
+
+impl fmt::Display for BinaryError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            BinaryError::Io(ref err) => err.fmt(f),
+            BinaryError::Utf8(ref err) => err.fmt(f),
+            BinaryError::ParseInt(ref err) => err.fmt(f),
+        }
+    }
+}
+
+impl Error for BinaryError {
+    fn description(&self) -> &str {
+        match *self {
+            BinaryError::Io(ref err) => err.description(),
+            BinaryError::Utf8(ref err) => err.description(),
+            BinaryError::ParseInt(ref err) => err.description(),
         }
     }
+}
+
+impl From<io::Error> for BinaryError {
+    fn from(err: io::Error) -> BinaryError {
+        BinaryError::Io(err)
+    }
+}
 
-    // pub fn new_from_hex_file() -> Binary<'a> {
-        
-    // }
+impl From<str::Utf8Error> for BinaryError {
+    fn from(err: str::Utf8Error) -> BinaryError {
+        BinaryError::Utf8(err)
+    }
+}
+
+impl From<num::ParseIntError> for BinaryError {
+    fn from(err: num::ParseIntError) -> BinaryError {
+        BinaryError::ParseInt(err)
+    }
+}
+
+impl Binary {
+    pub fn new_from_hex_file(path: &Path) -> Result<Binary, BinaryError> {
+        let file = try!(File::open(path));
+        let file = io::BufReader::new(file);
+
+        let mut words: Vec<u32> = Vec::new();
+        for line in file.lines() {
+            let line = try!(line);
+            for bytes in line.as_bytes().chunks(8).rev() {
+                let word = try!(str::from_utf8(bytes));
+                words.push(try!(u32::from_str_radix(word, 16)));
+            }
+        }
+
+        Ok(Binary {
+            words: words,
+        })
+    }
 }