spimdisasm 2.0.0-alpha.1

MIPS disassembler
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

/* SPDX-FileCopyrightText: © 2024-2025 Decompollaborate */
/* SPDX-License-Identifier: MIT */

use crate::{sections::processed::DataSectionProcessed, symbols::processed::DataSymProcessed};

use super::FuncRodataPairing;

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RodataIterator<'pairing, 'rodata> {
    pairing: &'pairing FuncRodataPairing,
    rodata_section: Option<&'rodata DataSectionProcessed>,
    rodata_index: usize,
    late_rodata_index: usize,
}

impl<'pairing, 'rodata> RodataIterator<'pairing, 'rodata> {
    pub(super) fn new(
        pairing: &'pairing FuncRodataPairing,
        rodata_section: Option<&'rodata DataSectionProcessed>,
    ) -> Self {
        Self {
            pairing,
            rodata_section,
            rodata_index: 0,
            late_rodata_index: 0,
        }
    }
}

impl<'rodata> Iterator for RodataIterator<'_, 'rodata> {
    type Item = &'rodata DataSymProcessed;

    fn next(&mut self) -> Option<Self::Item> {
        match &self.pairing {
            FuncRodataPairing::SingleRodata { rodata_index } => {
                if let Some(rodata_section) = self.rodata_section {
                    if self.rodata_index == 0 {
                        self.rodata_index += 1;
                        rodata_section.data_symbols().get(*rodata_index)
                    } else {
                        None
                    }
                } else {
                    None
                }
            }
            FuncRodataPairing::Pairing {
                rodata_indices,
                late_rodata_indices,
                ..
            } => {
                if let Some(rodata_section) = self.rodata_section {
                    let (rodata_index, index) = if self.rodata_index < rodata_indices.len() {
                        (&rodata_indices[self.rodata_index], &mut self.rodata_index)
                    } else if self.late_rodata_index < late_rodata_indices.len() {
                        (
                            &late_rodata_indices[self.late_rodata_index],
                            &mut self.late_rodata_index,
                        )
                    } else {
                        return None;
                    };

                    *index += 1;
                    rodata_section.data_symbols().get(*rodata_index)
                } else {
                    None
                }
            }
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        match &self.pairing {
            FuncRodataPairing::SingleRodata { .. } => {
                let remaining = 1 - self.rodata_index;

                (remaining, Some(remaining))
            }
            FuncRodataPairing::Pairing {
                rodata_indices,
                late_rodata_indices,
                ..
            } => {
                let remaining = (rodata_indices.len() - self.rodata_index)
                    + (late_rodata_indices.len() - self.late_rodata_index);

                (remaining, Some(remaining))
            }
        }
    }
}