mapfile_parser 2.2.1

Map file parser library focusing decompilation projects
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
117
118
119
120
121
122
123
124
125
126
127

/* SPDX-FileCopyrightText: © 2023 Decompollaborate */
/* SPDX-License-Identifier: MIT */

use std::collections::hash_map::DefaultHasher;

// Required to call the `.hash` and `.finish` methods, which are defined on traits.
use std::hash::{Hash, Hasher};

use pyo3::class::basic::CompareOp;
use pyo3::prelude::*;

#[derive(Debug, Clone)]
#[pyo3::prelude::pyclass(module = "mapfile_parser")]
pub struct Symbol {
    #[pyo3(get)]
    pub name: String,

    #[pyo3(get)]
    pub vram: u64,

    #[pyo3(get, set)]
    pub size: Option<u64>,

    #[pyo3(get, set)]
    pub vrom: Option<u64>,
}

#[pyo3::prelude::pymethods]
impl Symbol {
    #[new]
    pub fn new(name: String, vram: u64, size: Option<u64>, vrom: Option<u64>) -> Self {
        Symbol {
            name,
            vram,
            size,
            vrom,
        }
    }

    #[pyo3(name = "getVramStr")]
    pub fn get_vram_str(&self) -> String {
        format!("0x{0:08X}", self.vram)
    }

    #[pyo3(name = "getSizeStr")]
    pub fn get_size_str(&self) -> String {
        if let Some(size) = self.size {
            //return format!("0x{0:X}", size);
            return format!("{}", size);
        }
        "None".into()
    }

    #[pyo3(name = "getVromStr")]
    pub fn get_vrom_str(&self) -> String {
        if let Some(vrom) = self.vrom {
            return format!("0x{0:06X}", vrom);
        }
        "None".into()
    }

    #[staticmethod]
    #[pyo3(name = "toCsvHeader")]
    pub fn to_csv_header() -> String {
        "Symbol name,VRAM,Size in bytes".to_string()
    }

    #[pyo3(name = "toCsv")]
    pub fn to_csv(&self) -> String {
        format!("{0},{1:08X},{2}", self.name, self.vram, self.get_size_str())
    }

    #[staticmethod]
    #[pyo3(name = "printCsvHeader")]
    pub fn print_csv_header() {
        print!("{}", Self::to_csv_header());
    }

    #[pyo3(name = "printAsCsv")]
    pub fn print_as_csv(&self) {
        print!("{0}", self.to_csv());
    }

    // TODO: implement __eq__ instead when PyO3 0.20 releases
    fn __richcmp__(&self, other: &Self, op: CompareOp, py: Python<'_>) -> PyObject {
        match op {
            pyo3::class::basic::CompareOp::Eq => (self == other).into_py(py),
            pyo3::class::basic::CompareOp::Ne => (self != other).into_py(py),
            _ => py.NotImplemented(),
        }
    }

    fn __hash__(&self) -> isize {
        let mut hasher = DefaultHasher::new();
        self.hash(&mut hasher);
        hasher.finish() as isize
    }

    // TODO: __str__ and __repr__
}

impl Symbol {
    pub fn new_default(name: String, vram: u64) -> Self {
        Symbol {
            name,
            vram,
            size: None,
            vrom: None,
        }
    }
}

// https://doc.rust-lang.org/std/cmp/trait.Eq.html
impl PartialEq for Symbol {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name && self.vram == other.vram
    }
}
impl Eq for Symbol {}

// https://doc.rust-lang.org/std/hash/trait.Hash.html
impl Hash for Symbol {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.name.hash(state);
        self.vram.hash(state);
    }
}