atom-macho 0.1.0

MachO file format primitives
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use byteorder::{BigEndian, LittleEndian, NativeEndian, ReadBytesExt, WriteBytesExt};
use std::io::{Read, Write};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Endian {
    Little,
    Big,
}

#[cfg(target_endian = "little")]
impl Endian {
    pub const NATIVE: Endian = Endian::Little;
    pub const REVERSE: Endian = Endian::Big;
}

#[cfg(target_endian = "big")]
impl Endian {
    pub const NATIVE: Endian = Endian::Big;
    pub const REVERSE: Endian = Endian::Little;
}

macro_rules! read_in {
    ($func:ident, $endian:expr) => {
        match $endian {
            Endian::Little => ReadBytesExt::$func::<LittleEndian>,
            Endian::Big => ReadBytesExt::$func::<BigEndian>,
        }
    };
}

pub trait ReadExt: Read + ReadBytesExt {
    fn read_u8(&mut self) -> u8 {
        ReadBytesExt::read_u8(self).unwrap()
    }

    fn read_u16_in(&mut self, endian: Endian) -> u16 {
        read_in!(read_u16, endian)(self).unwrap()
    }

    fn read_i32_in(&mut self, endian: Endian) -> i32 {
        read_in!(read_i32, endian)(self).unwrap()
    }

    fn read_u32_in(&mut self, endian: Endian) -> u32 {
        read_in!(read_u32, endian)(self).unwrap()
    }

    fn read_u64_in(&mut self, endian: Endian) -> u64 {
        read_in!(read_u64, endian)(self).unwrap()
    }

    fn read_fixed_size_string(&mut self, size: usize) -> String {
        let mut buf = vec![0u8; size];
        self.read_exact(&mut buf).unwrap();

        let valid_len = buf.split(|&b| b == 0).next().unwrap().len();
        buf.truncate(valid_len);
        String::from_utf8(buf).unwrap()
    }
}

impl<T> ReadExt for T where T: Read {}

pub trait WriteExt: Write + WriteBytesExt {
    fn write_u8(&mut self, n: u8) {
        WriteBytesExt::write_u8(self, n).unwrap()
    }

    fn write_u16_native(&mut self, n: u16) {
        self.write_u16::<NativeEndian>(n).unwrap()
    }

    fn write_i32_native(&mut self, n: i32) {
        self.write_i32::<NativeEndian>(n).unwrap()
    }

    fn write_u32_native(&mut self, n: u32) {
        self.write_u32::<NativeEndian>(n).unwrap()
    }

    fn write_u64_native(&mut self, n: u64) {
        self.write_u64::<NativeEndian>(n).unwrap()
    }

    fn write_fixed_size_string(&mut self, s: &str, size: usize) {
        assert!(s.is_ascii());
        assert!(s.len() <= size);

        let mut buf = vec![0u8; size];

        for (i, c) in s.chars().enumerate() {
            buf[i] = c as u8;
        }

        self.write_all(&buf).unwrap();
    }
}

impl<T> WriteExt for T where T: Write {}