diff options
Diffstat (limited to 'src/construct')
| -rw-r--r-- | src/construct/definition.rs | 318 | ||||
| -rw-r--r-- | src/construct/mod.rs | 8 | ||||
| -rw-r--r-- | src/construct/partial_destination.rs | 154 | ||||
| -rw-r--r-- | src/construct/partial_label.rs | 100 | ||||
| -rw-r--r-- | src/construct/partial_title.rs | 136 |
5 files changed, 714 insertions, 2 deletions
diff --git a/src/construct/definition.rs b/src/construct/definition.rs new file mode 100644 index 0000000..e540b44 --- /dev/null +++ b/src/construct/definition.rs @@ -0,0 +1,318 @@ +//! Definition is a construct that occurs in the [flow] content type. +//! +//! They’re formed with the following BNF: +//! +//! ```bnf +//! definition ::= label ':' whitespace destination [ whitespace title ] [ space_or_tab ] +//! +//! ; Restriction: maximum `999` codes allowed between brackets. +//! ; Restriction: no blank lines. +//! ; Restriction: at least 1 non-space and non-eol code must exist. +//! label ::= '[' *( label_text | label_escape ) ']' +//! label_text ::= code - '[' - '\\' - ']' +//! label_escape ::= '\\' [ '[' | '\\' | ']' ] +//! +//! destination ::= destination_enclosed | destination_raw +//! destination_enclosed ::= '<' *( destination_enclosed_text | destination_enclosed_escape ) '>' +//! destination_enclosed_text ::= code - '<' - '\\' - eol +//! destination_enclosed_escape ::= '\\' [ '<' | '\\' | '>' ] +//! destination_raw ::= 1*( destination_raw_text | destination_raw_escape ) +//! ; Restriction: unbalanced `)` characters are not allowed. +//! destination_raw_text ::= code - '\\' - ascii_control - space_or_tab - eol +//! destination_raw_escape ::= '\\' [ '(' | ')' | '\\' ] +//! +//! ; Restriction: no blank lines. +//! ; Restriction: markers must match (in case of `(` with `)`). +//! title ::= marker [ *( code - '\\' | '\\' [ marker ] ) ] marker +//! marker ::= '"' | '\'' | '(' +//! +//! whitespace ::= eol *whitespace | 1*space_or_tab [ eol *whitespace ] +//! space_or_tab ::= ' ' | '\t' +//! ``` +//! +//! Definitions in markdown to not, on their own, relate to anything in HTML. +//! When connected with a link (reference), they together relate to the `<a>` +//! element in HTML. +//! The definition forms its `href`, and optionally `title`, attributes. +//! See [*§ 4.5.1 The `a` element*][html] in the HTML spec for more info. +//! +//! The `label`, `destination`, and `title` parts are interpreted as the +//! [string][] content type. +//! That means that character escapes and character reference are allowed. +//! +//! ## References +//! +//! * [`definition.js` in `micromark`](https://github.com/micromark/micromark/blob/main/packages/micromark-core-commonmark/dev/lib/definition.js) +//! * [*§ 4.7 Link reference definitions* in `CommonMark`](https://spec.commonmark.org/0.30/#link-reference-definitions) +//! +//! [flow]: crate::content::flow +//! [string]: crate::content::string +//! [html]: https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-a-element +//! +//! <!-- To do: link link (reference) --> +//! +//! <!-- To do: describe how references and definitions match --> + +use crate::construct::{ + partial_destination::start as destination, partial_label::start as label, + partial_title::start as title, partial_whitespace::start as whitespace, +}; +use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer}; + +/// At the start of a definition. +/// +/// ```markdown +/// |[a]: b "c" +/// ``` +pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + match code { + Code::Char('[') => { + tokenizer.enter(TokenType::Definition); + tokenizer.go(label, label_after)(tokenizer, code) + } + _ => (State::Nok, None), + } +} + +/// After the label of a definition. +/// +/// ```markdown +/// [a]|: b "c" +/// ``` +pub fn label_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + // To do: get the identifier: + // identifier = normalizeIdentifier( + // self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1) + // ) + + match code { + Code::Char(':') => { + tokenizer.enter(TokenType::DefinitionMarker); + tokenizer.consume(code); + tokenizer.exit(TokenType::DefinitionMarker); + (State::Fn(Box::new(marker_after)), None) + } + _ => (State::Nok, None), + } +} + +/// After the marker of a definition. +/// +/// ```markdown +/// [a]:| b "c" +/// +/// [a]:| ␊ +/// b "c" +/// ``` +pub fn marker_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + tokenizer.attempt( + |t, c| whitespace(t, c, TokenType::Whitespace), + |_ok| Box::new(marker_after_optional_whitespace), + )(tokenizer, code) +} + +/// After the marker, after whitespace. +/// +/// ```markdown +/// [a]: |b "c" +/// +/// [a]: |␊ +/// b "c" +/// ``` +pub fn marker_after_optional_whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + match code { + Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => { + tokenizer.enter(TokenType::LineEnding); + tokenizer.consume(code); + tokenizer.exit(TokenType::LineEnding); + (State::Fn(Box::new(marker_after_optional_line_ending)), None) + } + _ => destination_before(tokenizer, code), + } +} + +/// After the marker, after a line ending. +/// +/// ```markdown +/// [a]: +/// | b "c" +/// ``` +pub fn marker_after_optional_line_ending(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + tokenizer.attempt( + |t, c| whitespace(t, c, TokenType::Whitespace), + |_ok| Box::new(destination_before), + )(tokenizer, code) +} + +/// Before a destination. +/// +/// ```markdown +/// [a]: |b "c" +/// +/// [a]: +/// |b "c" +/// ``` +pub fn destination_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + let event = tokenizer.events.last().unwrap(); + // Blank line not ok. + let char_nok = matches!( + code, + Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') + ); + + if !char_nok + && (event.token_type == TokenType::LineEnding || event.token_type == TokenType::Whitespace) + { + tokenizer.go(destination, destination_after)(tokenizer, code) + } else { + (State::Nok, None) + } +} + +/// After a destination. +/// +/// ```markdown +/// [a]: b| "c" +/// +/// [a]: b| ␊ +/// "c" +/// ``` +pub fn destination_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + tokenizer.attempt(title_before, |_ok| Box::new(after))(tokenizer, code) +} + +/// After a definition. +/// +/// ```markdown +/// [a]: b| +/// [a]: b "c"| +/// ``` +pub fn after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + tokenizer.attempt( + |t, c| whitespace(t, c, TokenType::Whitespace), + |_ok| Box::new(after_whitespace), + )(tokenizer, code) +} + +/// After a definition, after optional whitespace. +/// +/// ```markdown +/// [a]: b | +/// [a]: b "c"| +/// ``` +pub fn after_whitespace(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + match code { + Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => { + tokenizer.exit(TokenType::Definition); + (State::Ok, Some(vec![code])) + } + _ => (State::Nok, None), + } +} + +/// After a destination, presumably before a title. +/// +/// ```markdown +/// [a]: b| "c" +/// +/// [a]: b| ␊ +/// "c" +/// ``` +pub fn title_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + tokenizer.attempt( + |t, c| whitespace(t, c, TokenType::Whitespace), + |_ok| Box::new(title_before_after_optional_whitespace), + )(tokenizer, code) +} + +/// Before a title, after optional whitespace. +/// +/// ```markdown +/// [a]: b |"c" +/// +/// [a]: b |␊ +/// "c" +/// ``` +pub fn title_before_after_optional_whitespace( + tokenizer: &mut Tokenizer, + code: Code, +) -> StateFnResult { + match code { + Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => { + tokenizer.enter(TokenType::LineEnding); + tokenizer.consume(code); + tokenizer.exit(TokenType::LineEnding); + ( + State::Fn(Box::new(title_before_after_optional_line_ending)), + None, + ) + } + _ => title_before_marker(tokenizer, code), + } +} + +/// Before a title, after a line ending. +/// +/// ```markdown +/// [a]: b␊ +/// | "c" +/// ``` +pub fn title_before_after_optional_line_ending( + tokenizer: &mut Tokenizer, + code: Code, +) -> StateFnResult { + tokenizer.attempt( + |t, c| whitespace(t, c, TokenType::Whitespace), + |_ok| Box::new(title_before_marker), + )(tokenizer, code) +} + +/// Before a title, after a line ending. +/// +/// ```markdown +/// [a]: b␊ +/// | "c" +/// ``` +pub fn title_before_marker(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + let event = tokenizer.events.last().unwrap(); + + if event.token_type == TokenType::LineEnding || event.token_type == TokenType::Whitespace { + tokenizer.go(title, title_after)(tokenizer, code) + } else { + (State::Nok, None) + } +} + +/// After a title. +/// +/// ```markdown +/// [a]: b "c"| +/// +/// [a]: b␊ +/// "c"| +/// ``` +pub fn title_after(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + tokenizer.attempt( + |t, c| whitespace(t, c, TokenType::Whitespace), + |_ok| Box::new(title_after_after_optional_whitespace), + )(tokenizer, code) +} + +/// After a title, after optional whitespace. +/// +/// ```markdown +/// [a]: b "c"| +/// +/// [a]: b "c" | +/// ``` +pub fn title_after_after_optional_whitespace( + _tokenizer: &mut Tokenizer, + code: Code, +) -> StateFnResult { + match code { + Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => { + (State::Ok, Some(vec![code])) + } + _ => (State::Nok, None), + } +} diff --git a/src/construct/mod.rs b/src/construct/mod.rs index ca1149f..fb79f68 100644 --- a/src/construct/mod.rs +++ b/src/construct/mod.rs @@ -16,7 +16,7 @@ //! The following constructs are found in markdown: //! //! * attention (strong, emphasis) (text) -//! * [autolink][autolink] +//! * [autolink][] //! * [blank line][blank_line] //! * block quote //! * [character escape][character_escape] @@ -25,7 +25,7 @@ //! * [code (indented)][code_indented] //! * [code (text)][code_text] //! * content -//! * definition +//! * [definition][] //! * [hard break (escape)][hard_break_escape] //! * [hard break (trailing)][hard_break_trailing] //! * [heading (atx)][heading_atx] @@ -61,11 +61,15 @@ pub mod character_reference; pub mod code_fenced; pub mod code_indented; pub mod code_text; +pub mod definition; pub mod hard_break_escape; pub mod hard_break_trailing; pub mod heading_atx; pub mod heading_setext; pub mod html_flow; pub mod html_text; +pub mod partial_destination; +pub mod partial_label; +pub mod partial_title; pub mod partial_whitespace; pub mod thematic_break; diff --git a/src/construct/partial_destination.rs b/src/construct/partial_destination.rs new file mode 100644 index 0000000..8cf5b77 --- /dev/null +++ b/src/construct/partial_destination.rs @@ -0,0 +1,154 @@ +// To do: pass token types in. + +use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer}; + +pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + match code { + Code::Char('<') => { + tokenizer.enter(TokenType::DefinitionDestination); + tokenizer.enter(TokenType::DefinitionDestinationLiteral); + tokenizer.enter(TokenType::DefinitionDestinationLiteralMarker); + tokenizer.consume(code); + tokenizer.exit(TokenType::DefinitionDestinationLiteralMarker); + (State::Fn(Box::new(enclosed_before)), None) + } + Code::None | Code::CarriageReturnLineFeed | Code::VirtualSpace | Code::Char(')') => { + (State::Nok, None) + } + Code::Char(char) if char.is_ascii_control() => (State::Nok, None), + Code::Char(_) => { + tokenizer.enter(TokenType::DefinitionDestination); + tokenizer.enter(TokenType::DefinitionDestinationRaw); + tokenizer.enter(TokenType::DefinitionDestinationString); + // To do: link. + tokenizer.enter(TokenType::ChunkString); + raw(tokenizer, code, 0) + } + } +} + +/// To do. +fn enclosed_before(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + if let Code::Char('>') = code { + tokenizer.enter(TokenType::DefinitionDestinationLiteralMarker); + tokenizer.consume(code); + tokenizer.exit(TokenType::DefinitionDestinationLiteralMarker); + tokenizer.exit(TokenType::DefinitionDestinationLiteral); + tokenizer.exit(TokenType::DefinitionDestination); + (State::Ok, None) + } else { + tokenizer.enter(TokenType::DefinitionDestinationString); + // To do: link. + tokenizer.enter(TokenType::ChunkString); + enclosed(tokenizer, code) + } +} + +/// To do. +fn enclosed(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + match code { + Code::Char('>') => { + tokenizer.exit(TokenType::ChunkString); + tokenizer.exit(TokenType::DefinitionDestinationString); + enclosed_before(tokenizer, code) + } + Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n' | '<') => { + (State::Nok, None) + } + Code::Char('\\') => { + tokenizer.consume(code); + (State::Fn(Box::new(enclosed_escape)), None) + } + _ => { + tokenizer.consume(code); + (State::Fn(Box::new(enclosed)), None) + } + } +} + +/// To do. +fn enclosed_escape(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + match code { + Code::Char('<' | '>' | '\\') => { + tokenizer.consume(code); + (State::Fn(Box::new(enclosed)), None) + } + _ => enclosed(tokenizer, code), + } +} + +/// To do. +// To do: these arms can be improved? +fn raw(tokenizer: &mut Tokenizer, code: Code, balance: usize) -> StateFnResult { + // To do: configurable. + let limit = usize::MAX; + + match code { + Code::Char('(') if balance >= limit => (State::Nok, None), + Code::Char('(') => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| raw(t, c, balance + 1))), + None, + ) + } + Code::Char(')') if balance == 0 => { + tokenizer.exit(TokenType::ChunkString); + tokenizer.exit(TokenType::DefinitionDestinationString); + tokenizer.exit(TokenType::DefinitionDestinationRaw); + tokenizer.exit(TokenType::DefinitionDestination); + (State::Ok, Some(vec![code])) + } + Code::Char(')') => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| raw(t, c, balance - 1))), + None, + ) + } + Code::None + | Code::CarriageReturnLineFeed + | Code::VirtualSpace + | Code::Char('\t' | '\r' | '\n' | ' ') + if balance > 0 => + { + (State::Nok, None) + } + Code::None + | Code::CarriageReturnLineFeed + | Code::VirtualSpace + | Code::Char('\t' | '\r' | '\n' | ' ') => { + tokenizer.exit(TokenType::ChunkString); + tokenizer.exit(TokenType::DefinitionDestinationString); + tokenizer.exit(TokenType::DefinitionDestinationRaw); + tokenizer.exit(TokenType::DefinitionDestination); + (State::Ok, Some(vec![code])) + } + Code::Char(char) if char.is_ascii_control() => (State::Nok, None), + Code::Char('\\') => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| raw_escape(t, c, balance))), + None, + ) + } + Code::Char(_) => { + tokenizer.consume(code); + (State::Fn(Box::new(move |t, c| raw(t, c, balance))), None) + } + } +} + +/// To do. +fn raw_escape(tokenizer: &mut Tokenizer, code: Code, balance: usize) -> StateFnResult { + match code { + Code::Char('(' | ')' | '\\') => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| raw(t, c, balance + 1))), + None, + ) + } + _ => raw(tokenizer, code, balance), + } +} diff --git a/src/construct/partial_label.rs b/src/construct/partial_label.rs new file mode 100644 index 0000000..c772c56 --- /dev/null +++ b/src/construct/partial_label.rs @@ -0,0 +1,100 @@ +// To do: pass token types in. + +use crate::constant::LINK_REFERENCE_SIZE_MAX; +use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer}; + +/// To do. +pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + match code { + Code::Char('[') => { + tokenizer.enter(TokenType::DefinitionLabel); + tokenizer.enter(TokenType::DefinitionLabelMarker); + tokenizer.consume(code); + tokenizer.exit(TokenType::DefinitionLabelMarker); + tokenizer.enter(TokenType::DefinitionLabelData); + (State::Fn(Box::new(|t, c| at_break(t, c, false, 0))), None) + } + // To do: allow? + _ => unreachable!("expected `[` at start of label"), + } +} + +/// To do. +fn at_break(tokenizer: &mut Tokenizer, code: Code, data: bool, size: usize) -> StateFnResult { + match code { + Code::None | Code::Char('[') => (State::Nok, None), + Code::Char(']') if !data => (State::Nok, None), + _ if size > LINK_REFERENCE_SIZE_MAX => (State::Nok, None), + Code::Char(']') => { + tokenizer.exit(TokenType::DefinitionLabelData); + tokenizer.enter(TokenType::DefinitionLabelMarker); + tokenizer.consume(code); + tokenizer.exit(TokenType::DefinitionLabelMarker); + tokenizer.exit(TokenType::DefinitionLabel); + (State::Ok, None) + } + Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => { + tokenizer.enter(TokenType::LineEnding); + tokenizer.consume(code); + tokenizer.exit(TokenType::LineEnding); + ( + State::Fn(Box::new(move |t, c| at_break(t, c, data, size))), + None, + ) + } + _ => { + tokenizer.enter(TokenType::ChunkString); + // To do: link. + label(tokenizer, code, data, size) + } + } +} + +/// To do. +fn label(tokenizer: &mut Tokenizer, code: Code, data: bool, size: usize) -> StateFnResult { + match code { + Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n' | '[' | ']') => { + tokenizer.exit(TokenType::ChunkString); + at_break(tokenizer, code, data, size) + } + _ if size > LINK_REFERENCE_SIZE_MAX => { + tokenizer.exit(TokenType::ChunkString); + at_break(tokenizer, code, data, size) + } + Code::VirtualSpace | Code::Char('\t' | ' ') => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| label(t, c, data, size + 1))), + None, + ) + } + Code::Char('/') => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| escape(t, c, true, size + 1))), + None, + ) + } + Code::Char(_) => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| label(t, c, true, size + 1))), + None, + ) + } + } +} + +/// To do. +fn escape(tokenizer: &mut Tokenizer, code: Code, data: bool, size: usize) -> StateFnResult { + match code { + Code::Char('[' | '\\' | ']') => { + tokenizer.consume(code); + ( + State::Fn(Box::new(move |t, c| label(t, c, true, size + 1))), + None, + ) + } + _ => label(tokenizer, code, data, size), + } +} diff --git a/src/construct/partial_title.rs b/src/construct/partial_title.rs new file mode 100644 index 0000000..4c7b527 --- /dev/null +++ b/src/construct/partial_title.rs @@ -0,0 +1,136 @@ +// To do: pass token types in. + +use crate::construct::partial_whitespace::start as whitespace; +use crate::tokenizer::{Code, State, StateFnResult, TokenType, Tokenizer}; + +/// Type of quote, if we’re in an attribure, in complete (condition 7). +#[derive(Debug, Clone, PartialEq)] +enum TitleKind { + /// In a parenthesised (`(` and `)`) title. + Paren, + /// In a double quoted (`"`) title. + Double, + /// In a single quoted (`"`) title. + Single, +} + +fn kind_to_marker(kind: &TitleKind) -> char { + match kind { + TitleKind::Double => '"', + TitleKind::Single => '\'', + TitleKind::Paren => ')', + } +} + +pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult { + let kind = match code { + Code::Char('"') => Some(TitleKind::Double), + Code::Char('\'') => Some(TitleKind::Single), + Code::Char('(') => Some(TitleKind::Paren), + _ => None, + }; + + if let Some(kind) = kind { + tokenizer.enter(TokenType::DefinitionTitle); + tokenizer.enter(TokenType::DefinitionTitleMarker); + tokenizer.consume(code); + tokenizer.exit(TokenType::DefinitionTitleMarker); + (State::Fn(Box::new(|t, c| at_first_break(t, c, kind))), None) + } else { + (State::Nok, None) + } +} + +/// To do. +fn at_first_break(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult { + match code { + Code::Char(char) if char == kind_to_marker(&kind) => { + tokenizer.enter(TokenType::DefinitionTitleMarker); + tokenizer.consume(code); + tokenizer.exit(TokenType::DefinitionTitleMarker); + tokenizer.exit(TokenType::DefinitionTitle); + (State::Ok, None) + } + _ => { + tokenizer.enter(TokenType::DefinitionTitleString); + at_break(tokenizer, code, kind) + } + } +} + +/// To do. +fn at_break(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult { + match code { + Code::Char(char) if char == kind_to_marker(&kind) => { + tokenizer.exit(TokenType::DefinitionTitleString); + at_first_break(tokenizer, code, kind) + } + Code::None => (State::Nok, None), + Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => { + tokenizer.enter(TokenType::LineEnding); + tokenizer.consume(code); + tokenizer.exit(TokenType::LineEnding); + ( + State::Fn(Box::new(|t, c| at_break_line_start(t, c, kind))), + None, + ) + } + _ => { + // To do: link. + tokenizer.enter(TokenType::ChunkString); + title(tokenizer, code, kind) + } + } +} + +fn at_break_line_start(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult { + tokenizer.attempt( + |t, c| whitespace(t, c, TokenType::Whitespace), + |_ok| Box::new(|t, c| at_break_line_begin(t, c, kind)), + )(tokenizer, code) +} + +fn at_break_line_begin(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult { + match code { + // Blank line not allowed. + Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => (State::Nok, None), + _ => at_break(tokenizer, code, kind), + } +} + +/// To do. +fn title(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult { + match code { + Code::Char(char) if char == kind_to_marker(&kind) => { + tokenizer.exit(TokenType::ChunkString); + at_break(tokenizer, code, kind) + } + Code::None | Code::CarriageReturnLineFeed | Code::Char('\r' | '\n') => { + tokenizer.exit(TokenType::ChunkString); + at_break(tokenizer, code, kind) + } + Code::Char('\\') => { + tokenizer.consume(code); + (State::Fn(Box::new(|t, c| escape(t, c, kind))), None) + } + _ => { + tokenizer.consume(code); + (State::Fn(Box::new(|t, c| title(t, c, kind))), None) + } + } +} + +/// To do. +fn escape(tokenizer: &mut Tokenizer, code: Code, kind: TitleKind) -> StateFnResult { + match code { + Code::Char(char) if char == kind_to_marker(&kind) => { + tokenizer.consume(code); + (State::Fn(Box::new(move |t, c| title(t, c, kind))), None) + } + Code::Char('\\') => { + tokenizer.consume(code); + (State::Fn(Box::new(move |t, c| title(t, c, kind))), None) + } + _ => title(tokenizer, code, kind), + } +} |