diff options
Diffstat (limited to '')
| -rw-r--r-- | src/construct/html_flow.rs | 419 |
1 files changed, 210 insertions, 209 deletions
diff --git a/src/construct/html_flow.rs b/src/construct/html_flow.rs index 064da35..aaa803d 100644 --- a/src/construct/html_flow.rs +++ b/src/construct/html_flow.rs @@ -1,4 +1,4 @@ -//! HTML (flow) is a construct that occurs in the [flow][] content type. +//! HTML (flow) is a construct that occurs in the [flow][] cont&ent type. //! //! It forms with the following BNF: //! @@ -110,37 +110,20 @@ use crate::token::Token; use crate::tokenizer::{State, Tokenizer}; use crate::util::slice::Slice; -/// Kind of HTML (flow). -#[derive(Debug, PartialEq)] -enum Kind { - /// Symbol for `<script>` (condition 1). - Raw, - /// Symbol for `<!---->` (condition 2). - Comment, - /// Symbol for `<?php?>` (condition 3). - Instruction, - /// Symbol for `<!doctype>` (condition 4). - Declaration, - /// Symbol for `<![CDATA[]]>` (condition 5). - Cdata, - /// Symbol for `<div` (condition 6). - Basic, - /// Symbol for `<x>` (condition 7). - Complete, -} - -/// State needed to parse HTML (flow). -#[derive(Debug)] -struct Info { - /// Kind of HTML (flow). - kind: Kind, - /// Whether this is a start tag (`<` not followed by `/`). - start_tag: bool, - /// Start index of a tag name or cdata prefix. - start: usize, - /// Current quote, when in a double or single quoted attribute value. - quote: u8, -} +/// Symbol for `<script>` (condition 1). +const RAW: u8 = 1; +/// Symbol for `<!---->` (condition 2). +const COMMENT: u8 = 2; +/// Symbol for `<?php?>` (condition 3). +const INSTRUCTION: u8 = 3; +/// Symbol for `<!doctype>` (condition 4). +const DECLARATION: u8 = 4; +/// Symbol for `<![CDATA[]]>` (condition 5). +const CDATA: u8 = 5; +/// Symbol for `<div` (condition 6). +const BASIC: u8 = 6; +/// Symbol for `<x>` (condition 7). +const COMPLETE: u8 = 7; /// Start of HTML (flow), before optional whitespace. /// @@ -197,39 +180,30 @@ fn before(tokenizer: &mut Tokenizer) -> State { /// ^ /// ``` fn open(tokenizer: &mut Tokenizer) -> State { - let mut info = Info { - // Assume basic. - kind: Kind::Basic, - // Assume closing tag (or no tag). - start_tag: false, - start: 0, - quote: 0, - }; - match tokenizer.current { Some(b'!') => { tokenizer.consume(); - State::Fn(Box::new(|t| declaration_open(t, info))) + State::Fn(Box::new(declaration_open)) } Some(b'/') => { tokenizer.consume(); - info.start = tokenizer.point.index; - State::Fn(Box::new(|t| tag_close_start(t, info))) + tokenizer.tokenize_state.seen = true; + tokenizer.tokenize_state.start = tokenizer.point.index; + State::Fn(Box::new(tag_close_start)) } Some(b'?') => { - info.kind = Kind::Instruction; + tokenizer.tokenize_state.marker = INSTRUCTION; tokenizer.consume(); // Do not form containers. tokenizer.concrete = true; // While we’re in an instruction instead of a declaration, we’re on a `?` // right now, so we do need to search for `>`, similar to declarations. - State::Fn(Box::new(|t| continuation_declaration_inside(t, info))) + State::Fn(Box::new(continuation_declaration_inside)) } // ASCII alphabetical. Some(b'A'..=b'Z' | b'a'..=b'z') => { - info.start_tag = true; - info.start = tokenizer.point.index; - tag_name(tokenizer, info) + tokenizer.tokenize_state.start = tokenizer.point.index; + tag_name(tokenizer) } _ => State::Nok, } @@ -245,25 +219,24 @@ fn open(tokenizer: &mut Tokenizer) -> State { /// > | <![CDATA[>&<]]> /// ^ /// ``` -fn declaration_open(tokenizer: &mut Tokenizer, mut info: Info) -> State { +fn declaration_open(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'-') => { tokenizer.consume(); - info.kind = Kind::Comment; - State::Fn(Box::new(|t| comment_open_inside(t, info))) + tokenizer.tokenize_state.marker = COMMENT; + State::Fn(Box::new(comment_open_inside)) } Some(b'A'..=b'Z' | b'a'..=b'z') => { tokenizer.consume(); - info.kind = Kind::Declaration; + tokenizer.tokenize_state.marker = DECLARATION; // Do not form containers. tokenizer.concrete = true; - State::Fn(Box::new(|t| continuation_declaration_inside(t, info))) + State::Fn(Box::new(continuation_declaration_inside)) } Some(b'[') => { tokenizer.consume(); - info.kind = Kind::Cdata; - info.start = tokenizer.point.index; - State::Fn(Box::new(|t| cdata_open_inside(t, info))) + tokenizer.tokenize_state.marker = CDATA; + State::Fn(Box::new(cdata_open_inside)) } _ => State::Nok, } @@ -275,15 +248,15 @@ fn declaration_open(tokenizer: &mut Tokenizer, mut info: Info) -> State { /// > | <!--xxx--> /// ^ /// ``` -fn comment_open_inside(tokenizer: &mut Tokenizer, info: Info) -> State { - match tokenizer.current { - Some(b'-') => { - tokenizer.consume(); - // Do not form containers. - tokenizer.concrete = true; - State::Fn(Box::new(|t| continuation_declaration_inside(t, info))) - } - _ => State::Nok, +fn comment_open_inside(tokenizer: &mut Tokenizer) -> State { + if let Some(b'-') = tokenizer.current { + tokenizer.consume(); + // Do not form containers. + tokenizer.concrete = true; + State::Fn(Box::new(continuation_declaration_inside)) + } else { + tokenizer.tokenize_state.marker = 0; + State::Nok } } @@ -293,21 +266,23 @@ fn comment_open_inside(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <![CDATA[>&<]]> /// ^^^^^^ /// ``` -fn cdata_open_inside(tokenizer: &mut Tokenizer, mut info: Info) -> State { - match tokenizer.current { - Some(byte) if byte == HTML_CDATA_PREFIX[tokenizer.point.index - info.start] => { - tokenizer.consume(); +fn cdata_open_inside(tokenizer: &mut Tokenizer) -> State { + if tokenizer.current == Some(HTML_CDATA_PREFIX[tokenizer.tokenize_state.size]) { + tokenizer.tokenize_state.size += 1; + tokenizer.consume(); - if tokenizer.point.index - info.start == HTML_CDATA_PREFIX.len() { - info.start = 0; - // Do not form containers. - tokenizer.concrete = true; - State::Fn(Box::new(|t| continuation(t, info))) - } else { - State::Fn(Box::new(|t| cdata_open_inside(t, info))) - } + if tokenizer.tokenize_state.size == HTML_CDATA_PREFIX.len() { + tokenizer.tokenize_state.size = 0; + // Do not form containers. + tokenizer.concrete = true; + State::Fn(Box::new(continuation)) + } else { + State::Fn(Box::new(cdata_open_inside)) } - _ => State::Nok, + } else { + tokenizer.tokenize_state.marker = 0; + tokenizer.tokenize_state.size = 0; + State::Nok } } @@ -317,14 +292,14 @@ fn cdata_open_inside(tokenizer: &mut Tokenizer, mut info: Info) -> State { /// > | </x> /// ^ /// ``` -fn tag_close_start(tokenizer: &mut Tokenizer, info: Info) -> State { - match tokenizer.current { - // ASCII alphabetical. - Some(b'A'..=b'Z' | b'a'..=b'z') => { - tokenizer.consume(); - State::Fn(Box::new(|t| tag_name(t, info))) - } - _ => State::Nok, +fn tag_close_start(tokenizer: &mut Tokenizer) -> State { + if let Some(b'A'..=b'Z' | b'a'..=b'z') = tokenizer.current { + tokenizer.consume(); + State::Fn(Box::new(tag_name)) + } else { + tokenizer.tokenize_state.seen = false; + tokenizer.tokenize_state.start = 0; + State::Nok } } @@ -336,14 +311,15 @@ fn tag_close_start(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | </ab> /// ^^ /// ``` -fn tag_name(tokenizer: &mut Tokenizer, mut info: Info) -> State { +fn tag_name(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { None | Some(b'\t' | b'\n' | b' ' | b'/' | b'>') => { + let closing_tag = tokenizer.tokenize_state.seen; let slash = matches!(tokenizer.current, Some(b'/')); // Guaranteed to be valid ASCII bytes. let slice = Slice::from_indices( tokenizer.parse_state.bytes, - info.start, + tokenizer.tokenize_state.start, tokenizer.point.index, ); let name = slice @@ -351,42 +327,48 @@ fn tag_name(tokenizer: &mut Tokenizer, mut info: Info) -> State { // The line ending case might result in a `\r` that is already accounted for. .trim() .to_ascii_lowercase(); - info.start = 0; + tokenizer.tokenize_state.seen = false; + tokenizer.tokenize_state.start = 0; - if !slash && info.start_tag && HTML_RAW_NAMES.contains(&name.as_str()) { - info.kind = Kind::Raw; + if !slash && !closing_tag && HTML_RAW_NAMES.contains(&name.as_str()) { + tokenizer.tokenize_state.marker = RAW; // Do not form containers. tokenizer.concrete = true; - continuation(tokenizer, info) + continuation(tokenizer) } else if HTML_BLOCK_NAMES.contains(&name.as_str()) { - // Basic is assumed, no need to set `kind`. + tokenizer.tokenize_state.marker = BASIC; + if slash { tokenizer.consume(); - State::Fn(Box::new(|t| basic_self_closing(t, info))) + State::Fn(Box::new(basic_self_closing)) } else { // Do not form containers. tokenizer.concrete = true; - continuation(tokenizer, info) + continuation(tokenizer) } } else { - info.kind = Kind::Complete; + tokenizer.tokenize_state.marker = COMPLETE; // Do not support complete HTML when interrupting. if tokenizer.interrupt && !tokenizer.lazy { + tokenizer.tokenize_state.marker = 0; State::Nok - } else if info.start_tag { - complete_attribute_name_before(tokenizer, info) + } else if closing_tag { + complete_closing_tag_after(tokenizer) } else { - complete_closing_tag_after(tokenizer, info) + complete_attribute_name_before(tokenizer) } } } // ASCII alphanumerical and `-`. Some(b'-' | b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z') => { tokenizer.consume(); - State::Fn(Box::new(|t| tag_name(t, info))) + State::Fn(Box::new(tag_name)) + } + Some(_) => { + tokenizer.tokenize_state.seen = false; + State::Nok } - Some(_) => State::Nok, } } @@ -396,15 +378,15 @@ fn tag_name(tokenizer: &mut Tokenizer, mut info: Info) -> State { /// > | <div/> /// ^ /// ``` -fn basic_self_closing(tokenizer: &mut Tokenizer, info: Info) -> State { - match tokenizer.current { - Some(b'>') => { - tokenizer.consume(); - // Do not form containers. - tokenizer.concrete = true; - State::Fn(Box::new(|t| continuation(t, info))) - } - _ => State::Nok, +fn basic_self_closing(tokenizer: &mut Tokenizer) -> State { + if let Some(b'>') = tokenizer.current { + tokenizer.consume(); + // Do not form containers. + tokenizer.concrete = true; + State::Fn(Box::new(continuation)) + } else { + tokenizer.tokenize_state.marker = 0; + State::Nok } } @@ -414,13 +396,13 @@ fn basic_self_closing(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <x/> /// ^ /// ``` -fn complete_closing_tag_after(tokenizer: &mut Tokenizer, info: Info) -> State { +fn complete_closing_tag_after(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'\t' | b' ') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_closing_tag_after(t, info))) + State::Fn(Box::new(complete_closing_tag_after)) } - _ => complete_end(tokenizer, info), + _ => complete_end(tokenizer), } } @@ -443,22 +425,22 @@ fn complete_closing_tag_after(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <a > /// ^ /// ``` -fn complete_attribute_name_before(tokenizer: &mut Tokenizer, info: Info) -> State { +fn complete_attribute_name_before(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'\t' | b' ') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_name_before(t, info))) + State::Fn(Box::new(complete_attribute_name_before)) } Some(b'/') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_end(t, info))) + State::Fn(Box::new(complete_end)) } // ASCII alphanumerical and `:` and `_`. Some(b'0'..=b'9' | b':' | b'A'..=b'Z' | b'_' | b'a'..=b'z') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_name(t, info))) + State::Fn(Box::new(complete_attribute_name)) } - _ => complete_end(tokenizer, info), + _ => complete_end(tokenizer), } } @@ -472,14 +454,14 @@ fn complete_attribute_name_before(tokenizer: &mut Tokenizer, info: Info) -> Stat /// > | <a b> /// ^ /// ``` -fn complete_attribute_name(tokenizer: &mut Tokenizer, info: Info) -> State { +fn complete_attribute_name(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { // ASCII alphanumerical and `-`, `.`, `:`, and `_`. Some(b'-' | b'.' | b'0'..=b'9' | b':' | b'A'..=b'Z' | b'_' | b'a'..=b'z') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_name(t, info))) + State::Fn(Box::new(complete_attribute_name)) } - _ => complete_attribute_name_after(tokenizer, info), + _ => complete_attribute_name_after(tokenizer), } } @@ -492,17 +474,17 @@ fn complete_attribute_name(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <a b=c> /// ^ /// ``` -fn complete_attribute_name_after(tokenizer: &mut Tokenizer, info: Info) -> State { +fn complete_attribute_name_after(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'\t' | b' ') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_name_after(t, info))) + State::Fn(Box::new(complete_attribute_name_after)) } Some(b'=') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_value_before(t, info))) + State::Fn(Box::new(complete_attribute_value_before)) } - _ => complete_attribute_name_before(tokenizer, info), + _ => complete_attribute_name_before(tokenizer), } } @@ -515,19 +497,22 @@ fn complete_attribute_name_after(tokenizer: &mut Tokenizer, info: Info) -> State /// > | <a b="c"> /// ^ /// ``` -fn complete_attribute_value_before(tokenizer: &mut Tokenizer, mut info: Info) -> State { +fn complete_attribute_value_before(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { - None | Some(b'<' | b'=' | b'>' | b'`') => State::Nok, + None | Some(b'<' | b'=' | b'>' | b'`') => { + tokenizer.tokenize_state.marker = 0; + State::Nok + } Some(b'\t' | b' ') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_value_before(t, info))) + State::Fn(Box::new(complete_attribute_value_before)) } Some(b'"' | b'\'') => { - info.quote = tokenizer.current.unwrap(); + tokenizer.tokenize_state.marker_other = tokenizer.current.unwrap(); tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_value_quoted(t, info))) + State::Fn(Box::new(complete_attribute_value_quoted)) } - _ => complete_attribute_value_unquoted(tokenizer, info), + _ => complete_attribute_value_unquoted(tokenizer), } } @@ -539,16 +524,23 @@ fn complete_attribute_value_before(tokenizer: &mut Tokenizer, mut info: Info) -> /// > | <a b='c'> /// ^ /// ``` -fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer, info: Info) -> State { +fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { - None | Some(b'\n') => State::Nok, - Some(b'"' | b'\'') if tokenizer.current.unwrap() == info.quote => { + None | Some(b'\n') => { + tokenizer.tokenize_state.marker = 0; + tokenizer.tokenize_state.marker_other = 0; + State::Nok + } + Some(b'"' | b'\'') + if tokenizer.current.unwrap() == tokenizer.tokenize_state.marker_other => + { + tokenizer.tokenize_state.marker_other = 0; tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_value_quoted_after(t, info))) + State::Fn(Box::new(complete_attribute_value_quoted_after)) } _ => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_value_quoted(t, info))) + State::Fn(Box::new(complete_attribute_value_quoted)) } } } @@ -559,14 +551,14 @@ fn complete_attribute_value_quoted(tokenizer: &mut Tokenizer, info: Info) -> Sta /// > | <a b=c> /// ^ /// ``` -fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer, info: Info) -> State { +fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { None | Some(b'\t' | b'\n' | b' ' | b'"' | b'\'' | b'/' | b'<' | b'=' | b'>' | b'`') => { - complete_attribute_name_after(tokenizer, info) + complete_attribute_name_after(tokenizer) } Some(_) => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_attribute_value_unquoted(t, info))) + State::Fn(Box::new(complete_attribute_value_unquoted)) } } } @@ -578,10 +570,12 @@ fn complete_attribute_value_unquoted(tokenizer: &mut Tokenizer, info: Info) -> S /// > | <a b="c"> /// ^ /// ``` -fn complete_attribute_value_quoted_after(tokenizer: &mut Tokenizer, info: Info) -> State { - match tokenizer.current { - Some(b'\t' | b' ' | b'/' | b'>') => complete_attribute_name_before(tokenizer, info), - _ => State::Nok, +fn complete_attribute_value_quoted_after(tokenizer: &mut Tokenizer) -> State { + if let Some(b'\t' | b' ' | b'/' | b'>') = tokenizer.current { + complete_attribute_name_before(tokenizer) + } else { + tokenizer.tokenize_state.marker = 0; + State::Nok } } @@ -591,13 +585,13 @@ fn complete_attribute_value_quoted_after(tokenizer: &mut Tokenizer, info: Info) /// > | <a b="c"> /// ^ /// ``` -fn complete_end(tokenizer: &mut Tokenizer, info: Info) -> State { - match tokenizer.current { - Some(b'>') => { - tokenizer.consume(); - State::Fn(Box::new(|t| complete_after(t, info))) - } - _ => State::Nok, +fn complete_end(tokenizer: &mut Tokenizer) -> State { + if let Some(b'>') = tokenizer.current { + tokenizer.consume(); + State::Fn(Box::new(complete_after)) + } else { + tokenizer.tokenize_state.marker = 0; + State::Nok } } @@ -607,18 +601,21 @@ fn complete_end(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <x> /// ^ /// ``` -fn complete_after(tokenizer: &mut Tokenizer, info: Info) -> State { +fn complete_after(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { None | Some(b'\n') => { // Do not form containers. tokenizer.concrete = true; - continuation(tokenizer, info) + continuation(tokenizer) } Some(b'\t' | b' ') => { tokenizer.consume(); - State::Fn(Box::new(|t| complete_after(t, info))) + State::Fn(Box::new(complete_after)) + } + Some(_) => { + tokenizer.tokenize_state.marker = 0; + State::Nok } - Some(_) => State::Nok, } } @@ -628,46 +625,49 @@ fn complete_after(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <!--xxx--> /// ^ /// ``` -fn continuation(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { - Some(b'\n') if info.kind == Kind::Basic || info.kind == Kind::Complete => { + Some(b'\n') + if tokenizer.tokenize_state.marker == BASIC + || tokenizer.tokenize_state.marker == COMPLETE => + { tokenizer.exit(Token::HtmlFlowData); tokenizer.check(blank_line_before, |ok| { - if ok { - Box::new(continuation_after) + Box::new(if ok { + continuation_after } else { - Box::new(move |t| continuation_start(t, info)) - } + continuation_start + }) })(tokenizer) } // Note: important that this is after the basic/complete case. None | Some(b'\n') => { tokenizer.exit(Token::HtmlFlowData); - continuation_start(tokenizer, info) + continuation_start(tokenizer) } - Some(b'-') if info.kind == Kind::Comment => { + Some(b'-') if tokenizer.tokenize_state.marker == COMMENT => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_comment_inside(t, info))) + State::Fn(Box::new(continuation_comment_inside)) } - Some(b'<') if info.kind == Kind::Raw => { + Some(b'<') if tokenizer.tokenize_state.marker == RAW => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_raw_tag_open(t, info))) + State::Fn(Box::new(continuation_raw_tag_open)) } - Some(b'>') if info.kind == Kind::Declaration => { + Some(b'>') if tokenizer.tokenize_state.marker == DECLARATION => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_close(t, info))) + State::Fn(Box::new(continuation_close)) } - Some(b'?') if info.kind == Kind::Instruction => { + Some(b'?') if tokenizer.tokenize_state.marker == INSTRUCTION => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_declaration_inside(t, info))) + State::Fn(Box::new(continuation_declaration_inside)) } - Some(b']') if info.kind == Kind::Cdata => { + Some(b']') if tokenizer.tokenize_state.marker == CDATA => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_character_data_inside(t, info))) + State::Fn(Box::new(continuation_character_data_inside)) } _ => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation(t, info))) + State::Fn(Box::new(continuation)) } } } @@ -679,13 +679,13 @@ fn continuation(tokenizer: &mut Tokenizer, info: Info) -> State { /// ^ /// | asd /// ``` -fn continuation_start(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation_start(tokenizer: &mut Tokenizer) -> State { tokenizer.check(partial_non_lazy_continuation, |ok| { - if ok { - Box::new(move |t| continuation_start_non_lazy(t, info)) + Box::new(if ok { + continuation_start_non_lazy } else { - Box::new(continuation_after) - } + continuation_after + }) })(tokenizer) } @@ -696,13 +696,13 @@ fn continuation_start(tokenizer: &mut Tokenizer, info: Info) -> State { /// ^ /// | asd /// ``` -fn continuation_start_non_lazy(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation_start_non_lazy(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'\n') => { tokenizer.enter(Token::LineEnding); tokenizer.consume(); tokenizer.exit(Token::LineEnding); - State::Fn(Box::new(|t| continuation_before(t, info))) + State::Fn(Box::new(continuation_before)) } _ => unreachable!("expected eol"), } @@ -715,12 +715,12 @@ fn continuation_start_non_lazy(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | asd /// ^ /// ``` -fn continuation_before(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation_before(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { - None | Some(b'\n') => continuation_start(tokenizer, info), + None | Some(b'\n') => continuation_start(tokenizer), _ => { tokenizer.enter(Token::HtmlFlowData); - continuation(tokenizer, info) + continuation(tokenizer) } } } @@ -731,13 +731,13 @@ fn continuation_before(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <!--xxx--> /// ^ /// ``` -fn continuation_comment_inside(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation_comment_inside(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'-') => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_declaration_inside(t, info))) + State::Fn(Box::new(continuation_declaration_inside)) } - _ => continuation(tokenizer, info), + _ => continuation(tokenizer), } } @@ -747,14 +747,14 @@ fn continuation_comment_inside(tokenizer: &mut Tokenizer, info: Info) -> State { /// > | <script>console.log(1)</script> /// ^ /// ``` -fn continuation_raw_tag_open(tokenizer: &mut Tokenizer, mut info: Info) -> State { +fn continuation_raw_tag_open(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'/') => { tokenizer.consume(); - info.start = tokenizer.point.index; - State::Fn(Box::new(|t| continuation_raw_end_tag(t, info))) + tokenizer.tokenize_state.start = tokenizer.point.index; + State::Fn(Box::new(continuation_raw_end_tag)) } - _ => continuation(tokenizer, info), + _ => continuation(tokenizer), } } @@ -764,35 +764,35 @@ fn continuation_raw_tag_open(tokenizer: &mut Tokenizer, mut info: Info) -> State /// > | <script>console.log(1)</script> /// ^^^^^^ /// ``` -fn continuation_raw_end_tag(tokenizer: &mut Tokenizer, mut info: Info) -> State { +fn continuation_raw_end_tag(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'>') => { // Guaranteed to be valid ASCII bytes. let slice = Slice::from_indices( tokenizer.parse_state.bytes, - info.start, + tokenizer.tokenize_state.start, tokenizer.point.index, ); let name = slice.as_str().to_ascii_lowercase(); - info.start = 0; + tokenizer.tokenize_state.start = 0; if HTML_RAW_NAMES.contains(&name.as_str()) { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_close(t, info))) + State::Fn(Box::new(continuation_close)) } else { - continuation(tokenizer, info) + continuation(tokenizer) } } Some(b'A'..=b'Z' | b'a'..=b'z') - if tokenizer.point.index - info.start < HTML_RAW_SIZE_MAX => + if tokenizer.point.index - tokenizer.tokenize_state.start < HTML_RAW_SIZE_MAX => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_raw_end_tag(t, info))) + State::Fn(Box::new(continuation_raw_end_tag)) } _ => { - info.start = 0; - continuation(tokenizer, info) + tokenizer.tokenize_state.start = 0; + continuation(tokenizer) } } } @@ -803,13 +803,13 @@ fn continuation_raw_end_tag(tokenizer: &mut Tokenizer, mut info: Info) -> State /// > | <![CDATA[>&<]]> /// ^ /// ``` -fn continuation_character_data_inside(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation_character_data_inside(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b']') => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_declaration_inside(t, info))) + State::Fn(Box::new(continuation_declaration_inside)) } - _ => continuation(tokenizer, info), + _ => continuation(tokenizer), } } @@ -827,17 +827,17 @@ fn continuation_character_data_inside(tokenizer: &mut Tokenizer, info: Info) -> /// > | <![CDATA[>&<]]> /// ^ /// ``` -fn continuation_declaration_inside(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation_declaration_inside(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'>') => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_close(t, info))) + State::Fn(Box::new(continuation_close)) } - Some(b'-') if info.kind == Kind::Comment => { + Some(b'-') if tokenizer.tokenize_state.marker == COMMENT => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_declaration_inside(t, info))) + State::Fn(Box::new(continuation_declaration_inside)) } - _ => continuation(tokenizer, info), + _ => continuation(tokenizer), } } @@ -847,7 +847,7 @@ fn continuation_declaration_inside(tokenizer: &mut Tokenizer, info: Info) -> Sta /// > | <!doctype> /// ^ /// ``` -fn continuation_close(tokenizer: &mut Tokenizer, info: Info) -> State { +fn continuation_close(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { None | Some(b'\n') => { tokenizer.exit(Token::HtmlFlowData); @@ -855,7 +855,7 @@ fn continuation_close(tokenizer: &mut Tokenizer, info: Info) -> State { } _ => { tokenizer.consume(); - State::Fn(Box::new(|t| continuation_close(t, info))) + State::Fn(Box::new(continuation_close)) } } } @@ -868,6 +868,7 @@ fn continuation_close(tokenizer: &mut Tokenizer, info: Info) -> State { /// ``` fn continuation_after(tokenizer: &mut Tokenizer) -> State { tokenizer.exit(Token::HtmlFlow); + tokenizer.tokenize_state.marker = 0; // Feel free to interrupt. tokenizer.interrupt = false; // No longer concrete. |