gnuv2_demangle 0.4.0

GNU V2 C++ symbol demangler
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

/* SPDX-FileCopyrightText: © 2025 Decompollaborate */
/* SPDX-License-Identifier: MIT OR Apache-2.0 */

pub(crate) trait StrCutter<'s> {
    #[must_use]
    fn c_split2(&'s self, pat: &str) -> Option<(&'s str, &'s str)>;
    #[must_use]
    fn c_split2_char(&'s self, pat: char) -> Option<(&'s str, &'s str)>;
    #[must_use]
    fn c_split2_r_starts_with<F>(
        &'s self,
        pat: &str,
        r_cond: F,
    ) -> Option<(&'s str, &'s str, char)>
    where
        F: Fn(char) -> bool;

    #[must_use]
    fn c_cond_and_strip_prefix_and_char(
        &'s self,
        cond: bool,
        prefix: &str,
        c: char,
    ) -> Option<&'s str>;

    #[must_use]
    fn c_maybe_strip_prefix(&'s self, c: char) -> (&'s str, bool);

    #[must_use]
    fn c_strip_prefix_3chars(&'s self, a: char, b: char, c: char) -> Option<&'s str>;
}

impl<'s> StrCutter<'s> for str {
    fn c_split2(&'s self, pat: &str) -> Option<(&'s str, &'s str)> {
        let mut iter = self.splitn(2, pat);

        if let (Some(l), Some(r)) = (iter.next(), iter.next()) {
            if l.is_empty() || r.is_empty() {
                None
            } else {
                Some((l, r))
            }
        } else {
            None
        }
    }

    fn c_split2_char(&'s self, pat: char) -> Option<(&'s str, &'s str)> {
        let mut iter = self.splitn(2, pat);

        if let (Some(l), Some(r)) = (iter.next(), iter.next()) {
            if l.is_empty() || r.is_empty() {
                None
            } else {
                Some((l, r))
            }
        } else {
            None
        }
    }

    fn c_split2_r_starts_with<F>(&'s self, pat: &str, r_cond: F) -> Option<(&'s str, &'s str, char)>
    where
        F: Fn(char) -> bool,
    {
        // This assumes ASCII

        // Start at index 1 to avoid an empty `left`.
        for i in 1..self.len() {
            let current = &self[i..];

            // If current is smaller than the pattern then there's no point
            // in continue looking.
            if current.len() <= pat.len() {
                break;
            }

            // Kinda like an `split`
            if let Some(right) = current.strip_prefix(pat) {
                if right.starts_with(&r_cond) {
                    let left = &self[..i];
                    let first_right_character =
                        right
                            .chars()
                            .next()
                            .expect("Due to the previous start_with we expect this to have at least a single character");

                    return Some((left, right, first_right_character));
                }
            }
        }

        None
    }

    fn c_cond_and_strip_prefix_and_char(
        &'s self,
        cond: bool,
        prefix: &str,
        c: char,
    ) -> Option<&'s str> {
        if cond {
            self.strip_prefix(prefix).and_then(|x| x.strip_prefix(c))
        } else {
            None
        }
    }

    fn c_maybe_strip_prefix(&'s self, c: char) -> (&'s str, bool) {
        if let Some(a) = self.strip_prefix(c) {
            (a, true)
        } else {
            (self, false)
        }
    }

    fn c_strip_prefix_3chars(&'s self, a: char, b: char, c: char) -> Option<&'s str> {
        self.strip_prefix(a)
            .and_then(|x| x.strip_prefix(b).and_then(|y| y.strip_prefix(c)))
    }
}