1use std::borrow::Cow;
21
22use crate::parser::{
23 AtRule, Block, ComponentValue, Declaration, ErrorKind, Item, ParseError, QualifiedRule, Rule,
24 Seen, Stylesheet, Values, Watch, looks_like_custom_property, take_tail, unicode_range_tokens,
25 value_plan,
26};
27use crate::tokenizer::{Span, Token, Tokenizer};
28
29enum Head<'a> {
31 At {
32 name: Cow<'a, str>,
33 prelude: Vec<ComponentValue<'a>>,
34 start: usize,
35 },
36 Qualified {
37 prelude: Vec<ComponentValue<'a>>,
38 start: usize,
39 },
40}
41
42struct Open<'a> {
43 head: Head<'a>,
44 start: usize,
46 at: usize,
48}
49
50struct Deep<'a> {
51 src: &'a str,
52 values: Values<'a>,
53 open: Vec<Open<'a>>,
54 items: Vec<Item<'a, Block<'a>>>,
55 rules: Vec<Rule<'a, Block<'a>>>,
56 scratch: Vec<ComponentValue<'a>>,
58 errors: Vec<ParseError>,
59}
60
61impl<'a> Deep<'a> {
62 fn next_token(&mut self) -> Option<(Token<'a>, Span)> {
63 self.values.tokens.next_token()
64 }
65
66 fn back_to(&mut self, position: usize) {
68 self.values.tokens.reset(position);
69 }
70
71 fn error(&mut self, kind: ErrorKind, start: usize, end: usize) {
72 self.errors.push(ParseError {
73 kind,
74 span: Span::new(start, end.max(start)),
75 });
76 }
77
78 fn place(&mut self, rule: Rule<'a, Block<'a>>) {
79 if self.open.is_empty() {
80 self.rules.push(rule);
81 } else {
82 self.items.push(Item::Rule(rule));
83 }
84 }
85
86 fn run(mut self) -> Stylesheet<'a, Block<'a>> {
87 while let Some((token, span)) = self.next_token() {
88 if self.open.is_empty() {
89 match token {
91 Token::Whitespace | Token::Cdo | Token::Cdc => {}
92 Token::AtKeyword(name) => self.at_rule(name, span, false),
93 token => self.qualified_rule(token, span, false),
94 }
95 continue;
96 }
97 match token {
99 Token::Whitespace | Token::Semicolon => {}
100 Token::RightBrace => self.close(span.end),
101 Token::AtKeyword(name) => self.at_rule(name, span, true),
102 Token::Ident(name) => {
103 if !self.declaration(name, span) {
104 self.back_to(span.start);
105 let (token, span) = self.next_token().unwrap();
106 self.qualified_rule(token, span, true);
107 }
108 }
109 token => self.qualified_rule(token, span, true),
110 }
111 }
112 while !self.open.is_empty() {
114 self.close(self.src.len());
115 }
116 Stylesheet {
117 rules: self.rules,
118 errors: self.errors,
119 }
120 }
121
122 fn close(&mut self, end: usize) {
124 let open = self.open.pop().unwrap();
125 self.values.limit += 1;
126 let block = Block {
127 items: take_tail(&mut self.items, open.at),
128 span: Span::new(open.start, end),
129 };
130 let rule = match open.head {
131 Head::At {
132 name,
133 prelude,
134 start,
135 } => Rule::At(AtRule {
136 name,
137 prelude,
138 block: Some(block),
139 span: Span::new(start, end),
140 }),
141 Head::Qualified { prelude, start } => Rule::Qualified(QualifiedRule {
142 prelude,
143 block,
144 span: Span::new(start, end),
145 }),
146 };
147 self.place(rule);
148 }
149
150 fn open_block(&mut self, head: Head<'a>, brace: Span) {
151 if self.values.limit <= 1 {
152 let start = match head {
154 Head::At { start, .. } | Head::Qualified { start, .. } => start,
155 };
156 let end = self.values.whole(Token::LeftBrace, brace).span().end;
157 return self.error(ErrorKind::InvalidRule, start, end);
158 }
159 self.values.limit -= 1;
160 self.open.push(Open {
161 head,
162 start: brace.start,
163 at: self.items.len(),
164 });
165 }
166
167 fn at_rule(&mut self, name: Cow<'a, str>, keyword: Span, nested: bool) {
169 let mut end = keyword.end;
170 self.scratch.clear();
171 while let Some((token, span)) = self.next_token() {
172 match token {
173 Token::Semicolon => break,
174 Token::RightBrace if nested => {
175 self.back_to(span.start);
176 break;
177 }
178 Token::LeftBrace => {
179 let prelude = take_tail(&mut self.scratch, 0);
180 let head = Head::At {
181 name,
182 prelude,
183 start: keyword.start,
184 };
185 return self.open_block(head, span);
186 }
187 token => {
188 let value = self.values.whole(token, span);
189 end = value.span().end;
190 self.scratch.push(value);
191 }
192 }
193 }
194 let rule = Rule::At(AtRule {
195 name,
196 prelude: take_tail(&mut self.scratch, 0),
197 block: None,
198 span: Span::new(keyword.start, end),
199 });
200 self.place(rule);
201 }
202
203 fn qualified_rule(&mut self, token: Token<'a>, span: Span, nested: bool) {
206 let start = span.start;
207 let mut end = start;
208 self.scratch.clear();
209 let mut next = Some((token, span));
210 loop {
211 let Some((token, span)) = next.take().or_else(|| self.next_token()) else {
212 self.scratch.clear();
213 return self.error(ErrorKind::InvalidRule, start, end);
214 };
215 match token {
216 Token::Semicolon if nested => {
217 self.scratch.clear();
218 return self.error(ErrorKind::InvalidRule, start, end);
219 }
220 Token::RightBrace if nested => {
221 self.back_to(span.start);
222 self.scratch.clear();
223 return self.error(ErrorKind::InvalidRule, start, end);
224 }
225 Token::LeftBrace => {
226 let prelude = take_tail(&mut self.scratch, 0);
227 if looks_like_custom_property(&prelude) {
228 let end = self.values.whole(Token::LeftBrace, span).span().end;
231 if nested {
232 self.bad_declaration_remnants();
233 }
234 return self.error(ErrorKind::InvalidRule, start, end);
235 }
236 return self.open_block(Head::Qualified { prelude, start }, span);
237 }
238 token => {
239 let value = self.values.whole(token, span);
240 end = value.span().end;
241 self.scratch.push(value);
242 }
243 }
244 }
245 }
246
247 fn bad_declaration_remnants(&mut self) {
249 while let Some((token, span)) = self.next_token() {
250 match token {
251 Token::Semicolon => return,
252 Token::RightBrace => return self.back_to(span.start),
253 token => drop(self.values.whole(token, span)),
254 }
255 }
256 }
257
258 fn declaration(&mut self, name: Cow<'a, str>, ident: Span) -> bool {
261 let colon_end = loop {
262 match self.next_token() {
263 Some((Token::Whitespace, _)) => {}
264 Some((Token::Colon, span)) => break span.end,
265 _ => return false,
266 }
267 };
268 self.scratch.clear();
269 let mut watch = match name.starts_with("--") {
270 true => Watch::Custom,
271 false => Watch::Value(Seen::Nothing),
272 };
273 while let Some((token, span)) = self.next_token() {
274 match token {
275 Token::Semicolon => break,
276 Token::RightBrace => {
277 self.back_to(span.start);
278 break;
279 }
280 token => {
281 let value = self.values.whole(token, span);
282 if !watch.see(&value) {
283 self.scratch.clear();
284 return false;
285 }
286 self.scratch.push(value);
287 }
288 }
289 }
290 let Some(plan) = value_plan(&name, &self.scratch) else {
291 self.scratch.clear();
292 return false;
293 };
294 let mut value: Vec<_> = self.scratch.drain(plan.start..plan.end).collect();
295 self.scratch.clear();
296 if name.eq_ignore_ascii_case("unicode-range") && !value.is_empty() {
297 let from = value[0].span().start;
299 let to = value[value.len() - 1].span().end;
300 value = Values::new(unicode_range_tokens(self.src, from, to)).collect();
301 }
302 self.items.push(Item::Declaration(Declaration {
303 name,
304 value,
305 important: plan.important,
306 span: Span::new(ident.start, plan.last_end.unwrap_or(colon_end)),
307 }));
308 true
309 }
310}
311
312pub fn parse_stylesheet_deep(css: &str) -> Stylesheet<'_, Block<'_>> {
332 Deep {
333 src: css,
334 values: Values::new(Tokenizer::new(css)),
335 open: Vec::new(),
336 items: Vec::new(),
337 rules: Vec::new(),
338 scratch: Vec::new(),
339 errors: Vec::new(),
340 }
341 .run()
342}
343
344#[cfg(test)]
345mod tests {
346 use super::*;
347
348 #[test]
349 fn deep_nesting_parses_writes_and_drops() {
350 let css = format!("{}color: red", "a{".repeat(300_000));
351 let sheet = parse_stylesheet_deep(&css);
352 assert_eq!(sheet.rules.len(), 1);
353 let mut depth = 0;
355 let mut rule = &sheet.rules[0];
356 while let Rule::Qualified(q) = rule {
357 depth += 1;
358 match q.block.items.first() {
359 Some(Item::Rule(r)) => rule = r,
360 _ => break,
361 }
362 }
363 assert_eq!(depth, crate::MAX_NESTING - 1);
364 assert_eq!(sheet.errors.len(), 1);
365 let written = sheet.to_string();
366 assert!(written.ends_with(&"}".repeat(crate::MAX_NESTING - 1)));
367 assert!(!written.contains("color"));
368 assert!(sheet.clone() == sheet);
370 drop(sheet);
371 }
372
373 #[test]
374 fn an_ident_that_starts_a_rule_is_read_again_as_one() {
375 let css = "a { b:hover { c: d } e: f; --x:y { g } h }";
376 let sheet = parse_stylesheet_deep(css);
377 let Rule::Qualified(a) = &sheet.rules[0] else {
378 panic!()
379 };
380 let kinds: Vec<_> = a
381 .block
382 .items
383 .iter()
384 .map(|i| match i {
385 Item::Declaration(d) => d.span.text(css),
386 Item::Rule(r) => r.span().text(css),
387 })
388 .collect();
389 assert_eq!(kinds, ["b:hover { c: d }", "e: f", "--x:y { g } h"]);
390 }
391}