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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
use pyo3::prelude::*;
use std::collections::{HashMap, HashSet};
pub type TokenType = u16;
#[derive(Clone, Debug)]
#[pyclass]
pub struct TokenTypeSettings {
pub bit_string: TokenType,
pub break_: TokenType,
pub dcolon: TokenType,
pub heredoc_string: TokenType,
pub hex_string: TokenType,
pub identifier: TokenType,
pub number: TokenType,
pub parameter: TokenType,
pub semicolon: TokenType,
pub string: TokenType,
pub var: TokenType,
}
#[pymethods]
impl TokenTypeSettings {
#[new]
pub fn new(
bit_string: TokenType,
break_: TokenType,
dcolon: TokenType,
heredoc_string: TokenType,
hex_string: TokenType,
identifier: TokenType,
number: TokenType,
parameter: TokenType,
semicolon: TokenType,
string: TokenType,
var: TokenType,
) -> Self {
TokenTypeSettings {
bit_string,
break_,
dcolon,
heredoc_string,
hex_string,
identifier,
number,
parameter,
semicolon,
string,
var,
}
}
}
#[derive(Clone, Debug)]
#[pyclass]
pub struct TokenizerSettings {
pub white_space: HashMap<char, TokenType>,
pub single_tokens: HashMap<char, TokenType>,
pub keywords: HashMap<String, TokenType>,
pub numeric_literals: HashMap<String, String>,
pub identifiers: HashMap<char, char>,
pub identifier_escapes: HashSet<char>,
pub string_escapes: HashSet<char>,
pub quotes: HashMap<String, String>,
pub format_strings: HashMap<String, (String, TokenType)>,
pub has_bit_strings: bool,
pub has_hex_strings: bool,
pub comments: HashMap<String, Option<String>>,
pub var_single_tokens: HashSet<char>,
pub commands: HashSet<TokenType>,
pub command_prefix_tokens: HashSet<TokenType>,
}
#[pymethods]
impl TokenizerSettings {
#[new]
pub fn new(
white_space: HashMap<String, TokenType>,
single_tokens: HashMap<String, TokenType>,
keywords: HashMap<String, TokenType>,
numeric_literals: HashMap<String, String>,
identifiers: HashMap<String, String>,
identifier_escapes: HashSet<String>,
string_escapes: HashSet<String>,
quotes: HashMap<String, String>,
format_strings: HashMap<String, (String, TokenType)>,
has_bit_strings: bool,
has_hex_strings: bool,
comments: HashMap<String, Option<String>>,
var_single_tokens: HashSet<String>,
commands: HashSet<TokenType>,
command_prefix_tokens: HashSet<TokenType>,
) -> Self {
let to_char = |v: &String| {
if v.len() == 1 {
v.chars().next().unwrap()
} else {
panic!("Invalid char: {}", v)
}
};
let white_space_native: HashMap<char, TokenType> = white_space
.into_iter()
.map(|(k, v)| (to_char(&k), v))
.collect();
let single_tokens_native: HashMap<char, TokenType> = single_tokens
.into_iter()
.map(|(k, v)| (to_char(&k), v))
.collect();
let identifiers_native: HashMap<char, char> = identifiers
.iter()
.map(|(k, v)| (to_char(k), to_char(v)))
.collect();
let identifier_escapes_native: HashSet<char> =
identifier_escapes.iter().map(&to_char).collect();
let string_escapes_native: HashSet<char> = string_escapes.iter().map(&to_char).collect();
let var_single_tokens_native: HashSet<char> =
var_single_tokens.iter().map(&to_char).collect();
TokenizerSettings {
white_space: white_space_native,
single_tokens: single_tokens_native,
keywords,
numeric_literals,
identifiers: identifiers_native,
identifier_escapes: identifier_escapes_native,
string_escapes: string_escapes_native,
quotes,
format_strings,
has_bit_strings,
has_hex_strings,
comments,
var_single_tokens: var_single_tokens_native,
commands,
command_prefix_tokens,
}
}
}
#[derive(Clone, Debug)]
#[pyclass]
pub struct TokenizerDialectSettings {
pub escape_sequences: HashMap<String, String>,
pub identifiers_can_start_with_digit: bool,
}
#[pymethods]
impl TokenizerDialectSettings {
#[new]
pub fn new(
escape_sequences: HashMap<String, String>,
identifiers_can_start_with_digit: bool,
) -> Self {
TokenizerDialectSettings {
escape_sequences,
identifiers_can_start_with_digit,
}
}
}
|
