glsl_lang_pp/last/
token.rs

1use crate::{
2    parser::SyntaxKind,
3    processor::event::TokenLike,
4    types::{
5        keywords::KeywordAtom,
6        token::ErrorKind,
7        type_names::{TypeNameAtom, TypeNameState},
8        Token, TypeName,
9    },
10};
11
12pub(super) fn token_from_syntax_kind(
13    value: &impl TokenLike,
14    version: u16,
15    target_vulkan: bool,
16    is_type_name: impl Fn(&TypeNameAtom) -> TypeNameState,
17) -> (Token, Option<TypeNameState>) {
18    use Token::*;
19    let kind = value.kind();
20
21    // First, try the tokens that don't require text processing
22    match kind {
23        SyntaxKind::PP_EMPTY
24        | SyntaxKind::PP_INCLUDE
25        | SyntaxKind::PP_INCLUDE_PATH
26        | SyntaxKind::PP_DEFINE
27        | SyntaxKind::PP_DEFINE_ARGS
28        | SyntaxKind::PP_DEFINE_ARG
29        | SyntaxKind::PP_DEFINE_BODY
30        | SyntaxKind::PP_UNDEF
31        | SyntaxKind::PP_IDENT
32        | SyntaxKind::PP_IF
33        | SyntaxKind::PP_IF_EXPR
34        | SyntaxKind::PP_IFDEF
35        | SyntaxKind::PP_IFNDEF
36        | SyntaxKind::PP_ELSE
37        | SyntaxKind::PP_ELIF
38        | SyntaxKind::PP_ENDIF
39        | SyntaxKind::PP_ERROR
40        | SyntaxKind::PP_ERROR_BODY
41        | SyntaxKind::PP_PRAGMA
42        | SyntaxKind::PP_PRAGMA_BODY
43        | SyntaxKind::PP_EXTENSION
44        | SyntaxKind::PP_VERSION
45        | SyntaxKind::PP_VERSION_NUMBER
46        | SyntaxKind::PP_VERSION_PROFILE
47        | SyntaxKind::PP_LINE
48        | SyntaxKind::PP_LINE_BODY
49        | SyntaxKind::ERROR
50        | SyntaxKind::ROOT
51        | SyntaxKind::_LAST
52        | SyntaxKind::QUOTE_STRING
53        | SyntaxKind::ANGLE_STRING
54        | SyntaxKind::BACKSLASH
55        | SyntaxKind::DEFINED
56        | SyntaxKind::PP_CONCAT
57        | SyntaxKind::PP_CONCAT_OP => {
58            return (ERROR(ErrorKind::InvalidToken), None);
59        }
60        // Those need further processing
61        SyntaxKind::IDENT_KW => {}
62        SyntaxKind::DIGITS => {}
63        SyntaxKind::LEFT_OP => {
64            return (LEFT_OP, None);
65        }
66        SyntaxKind::RIGHT_OP => {
67            return (RIGHT_OP, None);
68        }
69        SyntaxKind::INC_OP => {
70            return (INC_OP, None);
71        }
72        SyntaxKind::DEC_OP => {
73            return (DEC_OP, None);
74        }
75        SyntaxKind::LE_OP => {
76            return (LE_OP, None);
77        }
78        SyntaxKind::GE_OP => {
79            return (GE_OP, None);
80        }
81        SyntaxKind::EQ_OP => {
82            return (EQ_OP, None);
83        }
84        SyntaxKind::NE_OP => {
85            return (NE_OP, None);
86        }
87        SyntaxKind::AND_OP => {
88            return (AND_OP, None);
89        }
90        SyntaxKind::OR_OP => {
91            return (OR_OP, None);
92        }
93        SyntaxKind::XOR_OP => {
94            return (XOR_OP, None);
95        }
96        SyntaxKind::MUL_ASSIGN => {
97            return (MUL_ASSIGN, None);
98        }
99        SyntaxKind::DIV_ASSIGN => {
100            return (DIV_ASSIGN, None);
101        }
102        SyntaxKind::ADD_ASSIGN => {
103            return (ADD_ASSIGN, None);
104        }
105        SyntaxKind::MOD_ASSIGN => {
106            return (MOD_ASSIGN, None);
107        }
108        SyntaxKind::LEFT_ASSIGN => {
109            return (LEFT_ASSIGN, None);
110        }
111        SyntaxKind::RIGHT_ASSIGN => {
112            return (RIGHT_ASSIGN, None);
113        }
114        SyntaxKind::AND_ASSIGN => {
115            return (AND_ASSIGN, None);
116        }
117        SyntaxKind::XOR_ASSIGN => {
118            return (XOR_ASSIGN, None);
119        }
120        SyntaxKind::OR_ASSIGN => {
121            return (OR_ASSIGN, None);
122        }
123        SyntaxKind::SUB_ASSIGN => {
124            return (SUB_ASSIGN, None);
125        }
126        SyntaxKind::LPAREN => {
127            return (LPAREN, None);
128        }
129        SyntaxKind::RPAREN => {
130            return (RPAREN, None);
131        }
132        SyntaxKind::LBRACKET => {
133            return (LBRACKET, None);
134        }
135        SyntaxKind::RBRACKET => {
136            return (RBRACKET, None);
137        }
138        SyntaxKind::LBRACE => {
139            return (LBRACE, None);
140        }
141        SyntaxKind::RBRACE => {
142            return (RBRACE, None);
143        }
144        SyntaxKind::PERIOD => {
145            return (PERIOD, None);
146        }
147        SyntaxKind::COMMA => {
148            return (COMMA, None);
149        }
150        SyntaxKind::COLON => {
151            return (COLON, None);
152        }
153        SyntaxKind::EQUAL => {
154            return (EQUAL, None);
155        }
156        SyntaxKind::SEMICOLON => {
157            return (SEMICOLON, None);
158        }
159        SyntaxKind::BANG => {
160            return (BANG, None);
161        }
162        SyntaxKind::DASH => {
163            return (DASH, None);
164        }
165        SyntaxKind::TILDE => {
166            return (TILDE, None);
167        }
168        SyntaxKind::PLUS => {
169            return (PLUS, None);
170        }
171        SyntaxKind::ASTERISK => {
172            return (ASTERISK, None);
173        }
174        SyntaxKind::SLASH => {
175            return (SLASH, None);
176        }
177        SyntaxKind::PERCENT => {
178            return (PERCENT, None);
179        }
180        SyntaxKind::LANGLE => {
181            return (LANGLE, None);
182        }
183        SyntaxKind::RANGLE => {
184            return (RANGLE, None);
185        }
186        SyntaxKind::BAR => {
187            return (BAR, None);
188        }
189        SyntaxKind::CARET => {
190            return (CARET, None);
191        }
192        SyntaxKind::AMPERSAND => {
193            return (AMPERSAND, None);
194        }
195        SyntaxKind::QUESTION => {
196            return (QUESTION, None);
197        }
198        SyntaxKind::HASH => {
199            return (HASH, None);
200        }
201        SyntaxKind::WS | SyntaxKind::NEWLINE => {
202            return (WS, None);
203        }
204        SyntaxKind::COMMENT => {
205            return (COMMENT, None);
206        }
207    }
208
209    // Either IDENT_KW or DIGITS, we need to examine the text to know more
210    let text = value.text().to_string();
211    if kind == SyntaxKind::IDENT_KW {
212        // Is this a keyword?
213        let keyword_atom = KeywordAtom::from(text.as_ref());
214
215        if let Some(keyword) = Token::parse_kw(&keyword_atom) {
216            return (keyword, None);
217        }
218
219        // Else it might be a built-in type name
220        if let Some((type_name, state)) =
221            TypeName::parse(text.as_ref(), version, target_vulkan, is_type_name)
222        {
223            return (TYPE_NAME(type_name), state);
224        }
225
226        // Nothing matched, it's actually an ident
227        (IDENT(text.into()), None)
228    } else if kind == SyntaxKind::DIGITS {
229        (Token::parse_digits(&text), None)
230    } else {
231        unreachable!()
232    }
233}
glsl_lang_pp/last/token.rs

glsl_lang_pp/last/
token.rs
