diff options
Diffstat (limited to 'src/construct/list.rs')
| -rw-r--r-- | src/construct/list.rs | 108 |
1 files changed, 56 insertions, 52 deletions
diff --git a/src/construct/list.rs b/src/construct/list.rs index 516cec7..ded77d0 100644 --- a/src/construct/list.rs +++ b/src/construct/list.rs @@ -46,9 +46,9 @@ use crate::constant::{LIST_ITEM_VALUE_SIZE_MAX, TAB_SIZE}; use crate::construct::partial_space_or_tab::space_or_tab_min_max; -use crate::state::{Name, State}; -use crate::token::Token; -use crate::tokenizer::{EventType, Tokenizer}; +use crate::event::{Kind, Name}; +use crate::state::{Name as StateName, State}; +use crate::tokenizer::Tokenizer; use crate::util::{ skip, slice::{Position, Slice}, @@ -62,7 +62,7 @@ use crate::util::{ /// ``` pub fn start(tokenizer: &mut Tokenizer) -> State { if tokenizer.parse_state.constructs.list { - tokenizer.enter(Token::ListItem); + tokenizer.enter(Name::ListItem); let name = space_or_tab_min_max( tokenizer, 0, @@ -72,7 +72,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State { usize::MAX }, ); - tokenizer.attempt(name, State::Next(Name::ListBefore), State::Nok) + tokenizer.attempt(name, State::Next(StateName::ListBefore), State::Nok) } else { State::Nok } @@ -88,14 +88,14 @@ pub fn before(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { // Unordered. Some(b'*' | b'-') => tokenizer.check( - Name::ThematicBreakStart, - State::Next(Name::ListNok), - State::Next(Name::ListBeforeUnordered), + StateName::ThematicBreakStart, + State::Next(StateName::ListNok), + State::Next(StateName::ListBeforeUnordered), ), - Some(b'+') => State::Retry(Name::ListBeforeUnordered), + Some(b'+') => State::Retry(StateName::ListBeforeUnordered), // Ordered. - Some(b'0'..=b'9') if !tokenizer.interrupt => State::Retry(Name::ListBeforeOrdered), - Some(b'1') => State::Retry(Name::ListBeforeOrdered), + Some(b'0'..=b'9') if !tokenizer.interrupt => State::Retry(StateName::ListBeforeOrdered), + Some(b'1') => State::Retry(StateName::ListBeforeOrdered), _ => State::Nok, } } @@ -109,8 +109,8 @@ pub fn before(tokenizer: &mut Tokenizer) -> State { /// ^ /// ``` pub fn before_unordered(tokenizer: &mut Tokenizer) -> State { - tokenizer.enter(Token::ListItemPrefix); - State::Retry(Name::ListMarker) + tokenizer.enter(Name::ListItemPrefix); + State::Retry(StateName::ListMarker) } /// Start of an ordered list item. @@ -120,9 +120,9 @@ pub fn before_unordered(tokenizer: &mut Tokenizer) -> State { /// ^ /// ``` pub fn before_ordered(tokenizer: &mut Tokenizer) -> State { - tokenizer.enter(Token::ListItemPrefix); - tokenizer.enter(Token::ListItemValue); - State::Retry(Name::ListValue) + tokenizer.enter(Name::ListItemPrefix); + tokenizer.enter(Name::ListItemValue); + State::Retry(StateName::ListValue) } /// In an ordered list item value. @@ -134,13 +134,13 @@ pub fn before_ordered(tokenizer: &mut Tokenizer) -> State { pub fn value(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'.' | b')') if !tokenizer.interrupt || tokenizer.tokenize_state.size < 2 => { - tokenizer.exit(Token::ListItemValue); - State::Retry(Name::ListMarker) + tokenizer.exit(Name::ListItemValue); + State::Retry(StateName::ListMarker) } Some(b'0'..=b'9') if tokenizer.tokenize_state.size + 1 < LIST_ITEM_VALUE_SIZE_MAX => { tokenizer.tokenize_state.size += 1; tokenizer.consume(); - State::Next(Name::ListValue) + State::Next(StateName::ListValue) } _ => { tokenizer.tokenize_state.size = 0; @@ -158,10 +158,10 @@ pub fn value(tokenizer: &mut Tokenizer) -> State { /// ^ /// ``` pub fn marker(tokenizer: &mut Tokenizer) -> State { - tokenizer.enter(Token::ListItemMarker); + tokenizer.enter(Name::ListItemMarker); tokenizer.consume(); - tokenizer.exit(Token::ListItemMarker); - State::Next(Name::ListMarkerAfter) + tokenizer.exit(Name::ListItemMarker); + State::Next(StateName::ListMarkerAfter) } /// After a list item marker. @@ -175,9 +175,9 @@ pub fn marker(tokenizer: &mut Tokenizer) -> State { pub fn marker_after(tokenizer: &mut Tokenizer) -> State { tokenizer.tokenize_state.size = 1; tokenizer.check( - Name::BlankLineStart, - State::Next(Name::ListAfter), - State::Next(Name::ListMarkerAfterFilled), + StateName::BlankLineStart, + State::Next(StateName::ListAfter), + State::Next(StateName::ListMarkerAfterFilled), ) } @@ -192,9 +192,9 @@ pub fn marker_after_filled(tokenizer: &mut Tokenizer) -> State { // Attempt to parse up to the largest allowed indent, `nok` if there is more whitespace. tokenizer.attempt( - Name::ListWhitespace, - State::Next(Name::ListAfter), - State::Next(Name::ListPrefixOther), + StateName::ListWhitespace, + State::Next(StateName::ListAfter), + State::Next(StateName::ListPrefixOther), ) } @@ -206,7 +206,11 @@ pub fn marker_after_filled(tokenizer: &mut Tokenizer) -> State { /// ``` pub fn whitespace(tokenizer: &mut Tokenizer) -> State { let name = space_or_tab_min_max(tokenizer, 1, TAB_SIZE); - tokenizer.attempt(name, State::Next(Name::ListWhitespaceAfter), State::Nok) + tokenizer.attempt( + name, + State::Next(StateName::ListWhitespaceAfter), + State::Nok, + ) } /// After acceptable whitespace. @@ -232,10 +236,10 @@ pub fn whitespace_after(tokenizer: &mut Tokenizer) -> State { pub fn prefix_other(tokenizer: &mut Tokenizer) -> State { match tokenizer.current { Some(b'\t' | b' ') => { - tokenizer.enter(Token::SpaceOrTab); + tokenizer.enter(Name::SpaceOrTab); tokenizer.consume(); - tokenizer.exit(Token::SpaceOrTab); - State::Next(Name::ListAfter) + tokenizer.exit(Name::SpaceOrTab); + State::Next(StateName::ListAfter) } _ => State::Nok, } @@ -257,7 +261,7 @@ pub fn after(tokenizer: &mut Tokenizer) -> State { let start = skip::to_back( &tokenizer.events, tokenizer.events.len() - 1, - &[Token::ListItem], + &[Name::ListItem], ); let mut prefix = Slice::from_position( tokenizer.parse_state.bytes, @@ -278,7 +282,7 @@ pub fn after(tokenizer: &mut Tokenizer) -> State { container.blank_initial = blank; container.size = prefix; - tokenizer.exit(Token::ListItemPrefix); + tokenizer.exit(Name::ListItemPrefix); tokenizer.register_resolver_before("list_item".to_string(), Box::new(resolve_list_item)); State::Ok } @@ -293,9 +297,9 @@ pub fn after(tokenizer: &mut Tokenizer) -> State { /// ``` pub fn cont_start(tokenizer: &mut Tokenizer) -> State { tokenizer.check( - Name::BlankLineStart, - State::Next(Name::ListContBlank), - State::Next(Name::ListContFilled), + StateName::BlankLineStart, + State::Next(StateName::ListContBlank), + State::Next(StateName::ListContFilled), ) } @@ -317,7 +321,7 @@ pub fn cont_blank(tokenizer: &mut Tokenizer) -> State { } else { let name = space_or_tab_min_max(tokenizer, 0, size); // Consume, optionally, at most `size`. - tokenizer.attempt(name, State::Next(Name::ListOk), State::Nok) + tokenizer.attempt(name, State::Next(StateName::ListOk), State::Nok) } } @@ -337,7 +341,7 @@ pub fn cont_filled(tokenizer: &mut Tokenizer) -> State { // Consume exactly `size`. let name = space_or_tab_min_max(tokenizer, size, size); - tokenizer.attempt(name, State::Next(Name::ListOk), State::Nok) + tokenizer.attempt(name, State::Next(StateName::ListOk), State::Nok) } /// A state fn to yield [`State::Ok`]. @@ -361,10 +365,10 @@ pub fn resolve_list_item(tokenizer: &mut Tokenizer) { while index < tokenizer.events.len() { let event = &tokenizer.events[index]; - if event.token_type == Token::ListItem { - if event.event_type == EventType::Enter { - let end = skip::opt(&tokenizer.events, index, &[Token::ListItem]) - 1; - let marker = skip::to(&tokenizer.events, index, &[Token::ListItemMarker]); + if event.name == Name::ListItem { + if event.kind == Kind::Enter { + let end = skip::opt(&tokenizer.events, index, &[Name::ListItem]) - 1; + let marker = skip::to(&tokenizer.events, index, &[Name::ListItemMarker]); // Guaranteed to be a valid ASCII byte. let marker = Slice::from_index( tokenizer.parse_state.bytes, @@ -384,10 +388,10 @@ pub fn resolve_list_item(tokenizer: &mut Tokenizer) { &tokenizer.events, previous.3 + 1, &[ - Token::SpaceOrTab, - Token::LineEnding, - Token::BlankLineEnding, - Token::BlockQuotePrefix, + Name::SpaceOrTab, + Name::LineEnding, + Name::BlankLineEnding, + Name::BlockQuotePrefix, ], ); @@ -441,12 +445,12 @@ pub fn resolve_list_item(tokenizer: &mut Tokenizer) { let list_item = &lists[index]; let mut list_start = tokenizer.events[list_item.2].clone(); let mut list_end = tokenizer.events[list_item.3].clone(); - let token_type = match list_item.0 { - b'.' | b')' => Token::ListOrdered, - _ => Token::ListUnordered, + let name = match list_item.0 { + b'.' | b')' => Name::ListOrdered, + _ => Name::ListUnordered, }; - list_start.token_type = token_type.clone(); - list_end.token_type = token_type; + list_start.name = name.clone(); + list_end.name = name; tokenizer.map.add(list_item.2, 0, vec![list_start]); tokenizer.map.add(list_item.3 + 1, 0, vec![list_end]); |