hermes_rs 0.1.0

A dependency-free disassembler and assembler for the Hermes bytecode
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::io;

use crate::hermes::Serializable;
use crate::hermes::decode::decode_u32;
use crate::hermes::encode::encode_u32;

#[derive(Debug)]
pub struct DebugInfoOffsets {
    pub src: u32,
    pub scope_desc: u32,
    pub callee: u32,
}

impl Serializable for DebugInfoOffsets {
    fn size(&self) -> usize {
        12
    }

    fn deserialize<R>(r: &mut R) -> Self
    where
        R: io::Read + io::BufRead + io::Seek,
    {
        DebugInfoOffsets {
            src: decode_u32(r),
            scope_desc: decode_u32(r),
            callee: decode_u32(r),
        }
    }

    fn serialize<W>(&self, _w: &mut W)
    where
        W: io::Write,
    {
        // encode_u32(w, self.string_data_off);
    }
}

#[derive(Debug)]
pub struct DebugInfoHeader {
    pub filename_count: u32,
    pub filename_storage_size: u32,
    pub file_region_count: u32,
    pub scope_desc_data_offset: u32,
    pub textified_callee_offset: u32,
    pub string_table_offset: u32,
    pub debug_data_size: u32,
}

impl Serializable for DebugInfoHeader {
    fn size(&self) -> usize {
        28
    }

    fn deserialize<R>(r: &mut R) -> Self
    where
        R: io::Read + io::BufRead + io::Seek,
    {
        DebugInfoHeader {
            filename_count: decode_u32(r),
            filename_storage_size: decode_u32(r),
            file_region_count: decode_u32(r),
            scope_desc_data_offset: decode_u32(r),
            textified_callee_offset: decode_u32(r),
            string_table_offset: decode_u32(r),
            debug_data_size: decode_u32(r),
        }
    }

    fn serialize<W>(&self, w: &mut W)
    where
        W: io::Write,
    {
        // encode_u32(w, self.string_data_off);
        encode_u32(w, self.filename_count);
        encode_u32(w, self.filename_storage_size);
        encode_u32(w, self.file_region_count);
        encode_u32(w, self.scope_desc_data_offset);
        encode_u32(w, self.textified_callee_offset);
        encode_u32(w, self.string_table_offset);
        encode_u32(w, self.debug_data_size);
    }
}

#[derive(Debug)]
pub struct DebugFileRegion {
    pub from_address: u32,
    pub filename_id: u32,
    pub source_mapping_url_id: u32,
}

impl Serializable for DebugFileRegion {
    fn size(&self) -> usize {
        12
    }

    fn deserialize<R>(r: &mut R) -> Self
    where
        R: io::Read + io::BufRead + io::Seek,
    {
        DebugFileRegion {
            from_address: decode_u32(r),
            filename_id: decode_u32(r),
            source_mapping_url_id: decode_u32(r)
        }
    }

    fn serialize<W>(&self, w: &mut W)
    where
        W: io::Write,
    {
        // encode_u32(w, self.string_data_off);
        encode_u32(w, self.from_address);
        encode_u32(w, self.filename_id);
        encode_u32(w, self.source_mapping_url_id);
    }
}