ps_parser/parser/
token.rs

1use std::{collections::BTreeSet, fmt::Display};
2
3use super::script_result::PsValue;
4
5#[derive(Debug, Clone, PartialEq)]
6pub enum Token {
7    StringExpandable(String, String),
8    String(String),
9    Expression(String, PsValue),
10    Function(String, String, Vec<PsValue>),
11}
12
13impl Display for Token {
14    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15        write!(f, "{:?}", self)
16    }
17}
18
19#[derive(Default, Debug, Clone, PartialEq)]
20pub struct Tokens(Vec<Token>);
21impl Tokens {
22    pub fn new() -> Self {
23        Self(Vec::new())
24    }
25
26    pub fn push(&mut self, token: Token) {
27        self.0.push(token)
28    }
29
30    pub fn all(&self) -> Vec<Token> {
31        self.0.clone()
32    }
33
34    pub fn strings(&self) -> Vec<Token> {
35        self.0
36            .iter()
37            .filter(|token| matches!(token, Token::String(..)))
38            .cloned()
39            .collect()
40    }
41
42    pub fn string_set(&self) -> BTreeSet<String> {
43        let mut string_set = BTreeSet::new();
44        for token in self.0.iter() {
45            match token {
46                Token::String(deobfuscated) | Token::StringExpandable(_, deobfuscated) => {
47                    let _ = string_set.insert(deobfuscated.to_string());
48                }
49                _ => {}
50            }
51        }
52        string_set
53    }
54
55    pub fn lowercased_string_set(&self) -> BTreeSet<String> {
56        let mut string_set = BTreeSet::new();
57        for token in self.0.iter() {
58            match token {
59                Token::String(deobfuscated) | Token::StringExpandable(_, deobfuscated) => {
60                    let _ = string_set.insert(deobfuscated.to_ascii_lowercase());
61                }
62                _ => {}
63            }
64        }
65        string_set
66    }
67
68    pub fn expandable_strings(&self) -> Vec<Token> {
69        self.0
70            .iter()
71            .filter(|token| matches!(token, Token::StringExpandable(..)))
72            .cloned()
73            .collect()
74    }
75
76    pub fn expression(&self) -> Vec<Token> {
77        self.0
78            .iter()
79            .filter(|token| matches!(token, Token::Expression(..)))
80            .cloned()
81            .collect()
82    }
83
84    pub fn function(&self) -> Vec<Token> {
85        self.0
86            .iter()
87            .filter(|token| matches!(token, Token::Function(..)))
88            .cloned()
89            .collect()
90    }
91}