1 use crate::scanner::*; 2 use std::collections::HashMap; 3 4 #[derive(Clone, Copy, PartialEq, Debug, Eq)] 5 enum State { 6 StreamStart, 7 ImplicitDocumentStart, 8 DocumentStart, 9 DocumentContent, 10 DocumentEnd, 11 BlockNode, 12 // BlockNodeOrIndentlessSequence, 13 // FlowNode, 14 BlockSequenceFirstEntry, 15 BlockSequenceEntry, 16 IndentlessSequenceEntry, 17 BlockMappingFirstKey, 18 BlockMappingKey, 19 BlockMappingValue, 20 FlowSequenceFirstEntry, 21 FlowSequenceEntry, 22 FlowSequenceEntryMappingKey, 23 FlowSequenceEntryMappingValue, 24 FlowSequenceEntryMappingEnd, 25 FlowMappingFirstKey, 26 FlowMappingKey, 27 FlowMappingValue, 28 FlowMappingEmptyValue, 29 End, 30 } 31 32 /// `Event` is used with the low-level event base parsing API, 33 /// see `EventReceiver` trait. 34 #[derive(Clone, PartialEq, Debug, Eq)] 35 pub enum Event { 36 /// Reserved for internal use 37 Nothing, 38 StreamStart, 39 StreamEnd, 40 DocumentStart, 41 DocumentEnd, 42 /// Refer to an anchor ID 43 Alias(usize), 44 /// Value, style, anchor_id, tag 45 Scalar(String, TScalarStyle, usize, Option<TokenType>), 46 /// Anchor ID 47 SequenceStart(usize), 48 SequenceEnd, 49 /// Anchor ID 50 MappingStart(usize), 51 MappingEnd, 52 } 53 54 impl Event { empty_scalar() -> Event55 fn empty_scalar() -> Event { 56 // a null scalar 57 Event::Scalar("~".to_owned(), TScalarStyle::Plain, 0, None) 58 } 59 empty_scalar_with_anchor(anchor: usize, tag: Option<TokenType>) -> Event60 fn empty_scalar_with_anchor(anchor: usize, tag: Option<TokenType>) -> Event { 61 Event::Scalar("".to_owned(), TScalarStyle::Plain, anchor, tag) 62 } 63 } 64 65 #[derive(Debug)] 66 pub struct Parser<T> { 67 scanner: Scanner<T>, 68 states: Vec<State>, 69 state: State, 70 marks: Vec<Marker>, 71 token: Option<Token>, 72 current: Option<(Event, Marker)>, 73 anchors: HashMap<String, usize>, 74 anchor_id: usize, 75 } 76 77 pub trait EventReceiver { on_event(&mut self, ev: Event)78 fn on_event(&mut self, ev: Event); 79 } 80 81 pub trait MarkedEventReceiver { on_event(&mut self, ev: Event, _mark: Marker)82 fn on_event(&mut self, ev: Event, _mark: Marker); 83 } 84 85 impl<R: EventReceiver> MarkedEventReceiver for R { on_event(&mut self, ev: Event, _mark: Marker)86 fn on_event(&mut self, ev: Event, _mark: Marker) { 87 self.on_event(ev) 88 } 89 } 90 91 pub type ParseResult = Result<(Event, Marker), ScanError>; 92 93 impl<T: Iterator<Item = char>> Parser<T> { new(src: T) -> Parser<T>94 pub fn new(src: T) -> Parser<T> { 95 Parser { 96 scanner: Scanner::new(src), 97 states: Vec::new(), 98 state: State::StreamStart, 99 marks: Vec::new(), 100 token: None, 101 current: None, 102 103 anchors: HashMap::new(), 104 // valid anchor_id starts from 1 105 anchor_id: 1, 106 } 107 } 108 peek(&mut self) -> Result<&(Event, Marker), ScanError>109 pub fn peek(&mut self) -> Result<&(Event, Marker), ScanError> { 110 match self.current { 111 Some(ref x) => Ok(x), 112 None => { 113 self.current = Some(self.next()?); 114 self.peek() 115 } 116 } 117 } 118 next(&mut self) -> ParseResult119 pub fn next(&mut self) -> ParseResult { 120 match self.current { 121 None => self.parse(), 122 Some(_) => Ok(self.current.take().unwrap()), 123 } 124 } 125 peek_token(&mut self) -> Result<&Token, ScanError>126 fn peek_token(&mut self) -> Result<&Token, ScanError> { 127 match self.token { 128 None => { 129 self.token = Some(self.scan_next_token()?); 130 Ok(self.token.as_ref().unwrap()) 131 } 132 Some(ref tok) => Ok(tok), 133 } 134 } 135 scan_next_token(&mut self) -> Result<Token, ScanError>136 fn scan_next_token(&mut self) -> Result<Token, ScanError> { 137 let token = self.scanner.next(); 138 match token { 139 None => match self.scanner.get_error() { 140 None => Err(ScanError::new(self.scanner.mark(), "unexpected eof")), 141 Some(e) => Err(e), 142 }, 143 Some(tok) => Ok(tok), 144 } 145 } 146 fetch_token(&mut self) -> Token147 fn fetch_token(&mut self) -> Token { 148 self.token 149 .take() 150 .expect("fetch_token needs to be preceded by peek_token") 151 } 152 skip(&mut self)153 fn skip(&mut self) { 154 self.token = None; 155 //self.peek_token(); 156 } pop_state(&mut self)157 fn pop_state(&mut self) { 158 self.state = self.states.pop().unwrap() 159 } push_state(&mut self, state: State)160 fn push_state(&mut self, state: State) { 161 self.states.push(state); 162 } 163 parse(&mut self) -> ParseResult164 fn parse(&mut self) -> ParseResult { 165 if self.state == State::End { 166 return Ok((Event::StreamEnd, self.scanner.mark())); 167 } 168 let (ev, mark) = self.state_machine()?; 169 // println!("EV {:?}", ev); 170 Ok((ev, mark)) 171 } 172 load<R: MarkedEventReceiver>( &mut self, recv: &mut R, multi: bool, ) -> Result<(), ScanError>173 pub fn load<R: MarkedEventReceiver>( 174 &mut self, 175 recv: &mut R, 176 multi: bool, 177 ) -> Result<(), ScanError> { 178 if !self.scanner.stream_started() { 179 let (ev, mark) = self.next()?; 180 assert_eq!(ev, Event::StreamStart); 181 recv.on_event(ev, mark); 182 } 183 184 if self.scanner.stream_ended() { 185 // XXX has parsed? 186 recv.on_event(Event::StreamEnd, self.scanner.mark()); 187 return Ok(()); 188 } 189 loop { 190 let (ev, mark) = self.next()?; 191 if ev == Event::StreamEnd { 192 recv.on_event(ev, mark); 193 return Ok(()); 194 } 195 // clear anchors before a new document 196 self.anchors.clear(); 197 self.load_document(ev, mark, recv)?; 198 if !multi { 199 break; 200 } 201 } 202 Ok(()) 203 } 204 load_document<R: MarkedEventReceiver>( &mut self, first_ev: Event, mark: Marker, recv: &mut R, ) -> Result<(), ScanError>205 fn load_document<R: MarkedEventReceiver>( 206 &mut self, 207 first_ev: Event, 208 mark: Marker, 209 recv: &mut R, 210 ) -> Result<(), ScanError> { 211 assert_eq!(first_ev, Event::DocumentStart); 212 recv.on_event(first_ev, mark); 213 214 let (ev, mark) = self.next()?; 215 self.load_node(ev, mark, recv)?; 216 217 // DOCUMENT-END is expected. 218 let (ev, mark) = self.next()?; 219 assert_eq!(ev, Event::DocumentEnd); 220 recv.on_event(ev, mark); 221 222 Ok(()) 223 } 224 load_node<R: MarkedEventReceiver>( &mut self, first_ev: Event, mark: Marker, recv: &mut R, ) -> Result<(), ScanError>225 fn load_node<R: MarkedEventReceiver>( 226 &mut self, 227 first_ev: Event, 228 mark: Marker, 229 recv: &mut R, 230 ) -> Result<(), ScanError> { 231 match first_ev { 232 Event::Alias(..) | Event::Scalar(..) => { 233 recv.on_event(first_ev, mark); 234 Ok(()) 235 } 236 Event::SequenceStart(_) => { 237 recv.on_event(first_ev, mark); 238 self.load_sequence(recv) 239 } 240 Event::MappingStart(_) => { 241 recv.on_event(first_ev, mark); 242 self.load_mapping(recv) 243 } 244 _ => { 245 println!("UNREACHABLE EVENT: {:?}", first_ev); 246 unreachable!(); 247 } 248 } 249 } 250 load_mapping<R: MarkedEventReceiver>(&mut self, recv: &mut R) -> Result<(), ScanError>251 fn load_mapping<R: MarkedEventReceiver>(&mut self, recv: &mut R) -> Result<(), ScanError> { 252 let (mut key_ev, mut key_mark) = self.next()?; 253 while key_ev != Event::MappingEnd { 254 // key 255 self.load_node(key_ev, key_mark, recv)?; 256 257 // value 258 let (ev, mark) = self.next()?; 259 self.load_node(ev, mark, recv)?; 260 261 // next event 262 let (ev, mark) = self.next()?; 263 key_ev = ev; 264 key_mark = mark; 265 } 266 recv.on_event(key_ev, key_mark); 267 Ok(()) 268 } 269 load_sequence<R: MarkedEventReceiver>(&mut self, recv: &mut R) -> Result<(), ScanError>270 fn load_sequence<R: MarkedEventReceiver>(&mut self, recv: &mut R) -> Result<(), ScanError> { 271 let (mut ev, mut mark) = self.next()?; 272 while ev != Event::SequenceEnd { 273 self.load_node(ev, mark, recv)?; 274 275 // next event 276 let (next_ev, next_mark) = self.next()?; 277 ev = next_ev; 278 mark = next_mark; 279 } 280 recv.on_event(ev, mark); 281 Ok(()) 282 } 283 state_machine(&mut self) -> ParseResult284 fn state_machine(&mut self) -> ParseResult { 285 // let next_tok = self.peek_token()?; 286 // println!("cur_state {:?}, next tok: {:?}", self.state, next_tok); 287 match self.state { 288 State::StreamStart => self.stream_start(), 289 290 State::ImplicitDocumentStart => self.document_start(true), 291 State::DocumentStart => self.document_start(false), 292 State::DocumentContent => self.document_content(), 293 State::DocumentEnd => self.document_end(), 294 295 State::BlockNode => self.parse_node(true, false), 296 // State::BlockNodeOrIndentlessSequence => self.parse_node(true, true), 297 // State::FlowNode => self.parse_node(false, false), 298 State::BlockMappingFirstKey => self.block_mapping_key(true), 299 State::BlockMappingKey => self.block_mapping_key(false), 300 State::BlockMappingValue => self.block_mapping_value(), 301 302 State::BlockSequenceFirstEntry => self.block_sequence_entry(true), 303 State::BlockSequenceEntry => self.block_sequence_entry(false), 304 305 State::FlowSequenceFirstEntry => self.flow_sequence_entry(true), 306 State::FlowSequenceEntry => self.flow_sequence_entry(false), 307 308 State::FlowMappingFirstKey => self.flow_mapping_key(true), 309 State::FlowMappingKey => self.flow_mapping_key(false), 310 State::FlowMappingValue => self.flow_mapping_value(false), 311 312 State::IndentlessSequenceEntry => self.indentless_sequence_entry(), 313 314 State::FlowSequenceEntryMappingKey => self.flow_sequence_entry_mapping_key(), 315 State::FlowSequenceEntryMappingValue => self.flow_sequence_entry_mapping_value(), 316 State::FlowSequenceEntryMappingEnd => self.flow_sequence_entry_mapping_end(), 317 State::FlowMappingEmptyValue => self.flow_mapping_value(true), 318 319 /* impossible */ 320 State::End => unreachable!(), 321 } 322 } 323 stream_start(&mut self) -> ParseResult324 fn stream_start(&mut self) -> ParseResult { 325 match *self.peek_token()? { 326 Token(mark, TokenType::StreamStart(_)) => { 327 self.state = State::ImplicitDocumentStart; 328 self.skip(); 329 Ok((Event::StreamStart, mark)) 330 } 331 Token(mark, _) => Err(ScanError::new(mark, "did not find expected <stream-start>")), 332 } 333 } 334 document_start(&mut self, implicit: bool) -> ParseResult335 fn document_start(&mut self, implicit: bool) -> ParseResult { 336 if !implicit { 337 while let TokenType::DocumentEnd = self.peek_token()?.1 { 338 self.skip(); 339 } 340 } 341 342 match *self.peek_token()? { 343 Token(mark, TokenType::StreamEnd) => { 344 self.state = State::End; 345 self.skip(); 346 Ok((Event::StreamEnd, mark)) 347 } 348 Token(_, TokenType::VersionDirective(..)) 349 | Token(_, TokenType::TagDirective(..)) 350 | Token(_, TokenType::DocumentStart) => { 351 // explicit document 352 self._explicit_document_start() 353 } 354 Token(mark, _) if implicit => { 355 self.parser_process_directives()?; 356 self.push_state(State::DocumentEnd); 357 self.state = State::BlockNode; 358 Ok((Event::DocumentStart, mark)) 359 } 360 _ => { 361 // explicit document 362 self._explicit_document_start() 363 } 364 } 365 } 366 parser_process_directives(&mut self) -> Result<(), ScanError>367 fn parser_process_directives(&mut self) -> Result<(), ScanError> { 368 loop { 369 match self.peek_token()?.1 { 370 TokenType::VersionDirective(_, _) => { 371 // XXX parsing with warning according to spec 372 //if major != 1 || minor > 2 { 373 // return Err(ScanError::new(tok.0, 374 // "found incompatible YAML document")); 375 //} 376 } 377 TokenType::TagDirective(..) => { 378 // TODO add tag directive 379 } 380 _ => break, 381 } 382 self.skip(); 383 } 384 // TODO tag directive 385 Ok(()) 386 } 387 _explicit_document_start(&mut self) -> ParseResult388 fn _explicit_document_start(&mut self) -> ParseResult { 389 self.parser_process_directives()?; 390 match *self.peek_token()? { 391 Token(mark, TokenType::DocumentStart) => { 392 self.push_state(State::DocumentEnd); 393 self.state = State::DocumentContent; 394 self.skip(); 395 Ok((Event::DocumentStart, mark)) 396 } 397 Token(mark, _) => Err(ScanError::new( 398 mark, 399 "did not find expected <document start>", 400 )), 401 } 402 } 403 document_content(&mut self) -> ParseResult404 fn document_content(&mut self) -> ParseResult { 405 match *self.peek_token()? { 406 Token(mark, TokenType::VersionDirective(..)) 407 | Token(mark, TokenType::TagDirective(..)) 408 | Token(mark, TokenType::DocumentStart) 409 | Token(mark, TokenType::DocumentEnd) 410 | Token(mark, TokenType::StreamEnd) => { 411 self.pop_state(); 412 // empty scalar 413 Ok((Event::empty_scalar(), mark)) 414 } 415 _ => self.parse_node(true, false), 416 } 417 } 418 document_end(&mut self) -> ParseResult419 fn document_end(&mut self) -> ParseResult { 420 let mut _implicit = true; 421 let marker: Marker = match *self.peek_token()? { 422 Token(mark, TokenType::DocumentEnd) => { 423 self.skip(); 424 _implicit = false; 425 mark 426 } 427 Token(mark, _) => mark, 428 }; 429 430 // TODO tag handling 431 self.state = State::DocumentStart; 432 Ok((Event::DocumentEnd, marker)) 433 } 434 register_anchor(&mut self, name: String, _: &Marker) -> Result<usize, ScanError>435 fn register_anchor(&mut self, name: String, _: &Marker) -> Result<usize, ScanError> { 436 // anchors can be overridden/reused 437 // if self.anchors.contains_key(name) { 438 // return Err(ScanError::new(*mark, 439 // "while parsing anchor, found duplicated anchor")); 440 // } 441 let new_id = self.anchor_id; 442 self.anchor_id += 1; 443 self.anchors.insert(name, new_id); 444 Ok(new_id) 445 } 446 parse_node(&mut self, block: bool, indentless_sequence: bool) -> ParseResult447 fn parse_node(&mut self, block: bool, indentless_sequence: bool) -> ParseResult { 448 let mut anchor_id = 0; 449 let mut tag = None; 450 match *self.peek_token()? { 451 Token(_, TokenType::Alias(_)) => { 452 self.pop_state(); 453 if let Token(mark, TokenType::Alias(name)) = self.fetch_token() { 454 match self.anchors.get(&name) { 455 None => { 456 return Err(ScanError::new( 457 mark, 458 "while parsing node, found unknown anchor", 459 )) 460 } 461 Some(id) => return Ok((Event::Alias(*id), mark)), 462 } 463 } else { 464 unreachable!() 465 } 466 } 467 Token(_, TokenType::Anchor(_)) => { 468 if let Token(mark, TokenType::Anchor(name)) = self.fetch_token() { 469 anchor_id = self.register_anchor(name, &mark)?; 470 if let TokenType::Tag(..) = self.peek_token()?.1 { 471 if let tg @ TokenType::Tag(..) = self.fetch_token().1 { 472 tag = Some(tg); 473 } else { 474 unreachable!() 475 } 476 } 477 } else { 478 unreachable!() 479 } 480 } 481 Token(_, TokenType::Tag(..)) => { 482 if let tg @ TokenType::Tag(..) = self.fetch_token().1 { 483 tag = Some(tg); 484 if let TokenType::Anchor(_) = self.peek_token()?.1 { 485 if let Token(mark, TokenType::Anchor(name)) = self.fetch_token() { 486 anchor_id = self.register_anchor(name, &mark)?; 487 } else { 488 unreachable!() 489 } 490 } 491 } else { 492 unreachable!() 493 } 494 } 495 _ => {} 496 } 497 match *self.peek_token()? { 498 Token(mark, TokenType::BlockEntry) if indentless_sequence => { 499 self.state = State::IndentlessSequenceEntry; 500 Ok((Event::SequenceStart(anchor_id), mark)) 501 } 502 Token(_, TokenType::Scalar(..)) => { 503 self.pop_state(); 504 if let Token(mark, TokenType::Scalar(style, v)) = self.fetch_token() { 505 Ok((Event::Scalar(v, style, anchor_id, tag), mark)) 506 } else { 507 unreachable!() 508 } 509 } 510 Token(mark, TokenType::FlowSequenceStart) => { 511 self.state = State::FlowSequenceFirstEntry; 512 Ok((Event::SequenceStart(anchor_id), mark)) 513 } 514 Token(mark, TokenType::FlowMappingStart) => { 515 self.state = State::FlowMappingFirstKey; 516 Ok((Event::MappingStart(anchor_id), mark)) 517 } 518 Token(mark, TokenType::BlockSequenceStart) if block => { 519 self.state = State::BlockSequenceFirstEntry; 520 Ok((Event::SequenceStart(anchor_id), mark)) 521 } 522 Token(mark, TokenType::BlockMappingStart) if block => { 523 self.state = State::BlockMappingFirstKey; 524 Ok((Event::MappingStart(anchor_id), mark)) 525 } 526 // ex 7.2, an empty scalar can follow a secondary tag 527 Token(mark, _) if tag.is_some() || anchor_id > 0 => { 528 self.pop_state(); 529 Ok((Event::empty_scalar_with_anchor(anchor_id, tag), mark)) 530 } 531 Token(mark, _) => Err(ScanError::new( 532 mark, 533 "while parsing a node, did not find expected node content", 534 )), 535 } 536 } 537 block_mapping_key(&mut self, first: bool) -> ParseResult538 fn block_mapping_key(&mut self, first: bool) -> ParseResult { 539 // skip BlockMappingStart 540 if first { 541 let _ = self.peek_token()?; 542 //self.marks.push(tok.0); 543 self.skip(); 544 } 545 match *self.peek_token()? { 546 Token(_, TokenType::Key) => { 547 self.skip(); 548 match *self.peek_token()? { 549 Token(mark, TokenType::Key) 550 | Token(mark, TokenType::Value) 551 | Token(mark, TokenType::BlockEnd) => { 552 self.state = State::BlockMappingValue; 553 // empty scalar 554 Ok((Event::empty_scalar(), mark)) 555 } 556 _ => { 557 self.push_state(State::BlockMappingValue); 558 self.parse_node(true, true) 559 } 560 } 561 } 562 // XXX(chenyh): libyaml failed to parse spec 1.2, ex8.18 563 Token(mark, TokenType::Value) => { 564 self.state = State::BlockMappingValue; 565 Ok((Event::empty_scalar(), mark)) 566 } 567 Token(mark, TokenType::BlockEnd) => { 568 self.pop_state(); 569 self.skip(); 570 Ok((Event::MappingEnd, mark)) 571 } 572 Token(mark, _) => Err(ScanError::new( 573 mark, 574 "while parsing a block mapping, did not find expected key", 575 )), 576 } 577 } 578 block_mapping_value(&mut self) -> ParseResult579 fn block_mapping_value(&mut self) -> ParseResult { 580 match *self.peek_token()? { 581 Token(_, TokenType::Value) => { 582 self.skip(); 583 match *self.peek_token()? { 584 Token(mark, TokenType::Key) 585 | Token(mark, TokenType::Value) 586 | Token(mark, TokenType::BlockEnd) => { 587 self.state = State::BlockMappingKey; 588 // empty scalar 589 Ok((Event::empty_scalar(), mark)) 590 } 591 _ => { 592 self.push_state(State::BlockMappingKey); 593 self.parse_node(true, true) 594 } 595 } 596 } 597 Token(mark, _) => { 598 self.state = State::BlockMappingKey; 599 // empty scalar 600 Ok((Event::empty_scalar(), mark)) 601 } 602 } 603 } 604 flow_mapping_key(&mut self, first: bool) -> ParseResult605 fn flow_mapping_key(&mut self, first: bool) -> ParseResult { 606 if first { 607 let _ = self.peek_token()?; 608 self.skip(); 609 } 610 let marker: Marker = 611 { 612 match *self.peek_token()? { 613 Token(mark, TokenType::FlowMappingEnd) => mark, 614 Token(mark, _) => { 615 if !first { 616 match *self.peek_token()? { 617 Token(_, TokenType::FlowEntry) => self.skip(), 618 Token(mark, _) => return Err(ScanError::new(mark, 619 "while parsing a flow mapping, did not find expected ',' or '}'")) 620 } 621 } 622 623 match *self.peek_token()? { 624 Token(_, TokenType::Key) => { 625 self.skip(); 626 match *self.peek_token()? { 627 Token(mark, TokenType::Value) 628 | Token(mark, TokenType::FlowEntry) 629 | Token(mark, TokenType::FlowMappingEnd) => { 630 self.state = State::FlowMappingValue; 631 return Ok((Event::empty_scalar(), mark)); 632 } 633 _ => { 634 self.push_state(State::FlowMappingValue); 635 return self.parse_node(false, false); 636 } 637 } 638 } 639 Token(marker, TokenType::Value) => { 640 self.state = State::FlowMappingValue; 641 return Ok((Event::empty_scalar(), marker)); 642 } 643 Token(_, TokenType::FlowMappingEnd) => (), 644 _ => { 645 self.push_state(State::FlowMappingEmptyValue); 646 return self.parse_node(false, false); 647 } 648 } 649 650 mark 651 } 652 } 653 }; 654 655 self.pop_state(); 656 self.skip(); 657 Ok((Event::MappingEnd, marker)) 658 } 659 flow_mapping_value(&mut self, empty: bool) -> ParseResult660 fn flow_mapping_value(&mut self, empty: bool) -> ParseResult { 661 let mark: Marker = { 662 if empty { 663 let Token(mark, _) = *self.peek_token()?; 664 self.state = State::FlowMappingKey; 665 return Ok((Event::empty_scalar(), mark)); 666 } else { 667 match *self.peek_token()? { 668 Token(marker, TokenType::Value) => { 669 self.skip(); 670 match self.peek_token()?.1 { 671 TokenType::FlowEntry | TokenType::FlowMappingEnd => {} 672 _ => { 673 self.push_state(State::FlowMappingKey); 674 return self.parse_node(false, false); 675 } 676 } 677 marker 678 } 679 Token(marker, _) => marker, 680 } 681 } 682 }; 683 684 self.state = State::FlowMappingKey; 685 Ok((Event::empty_scalar(), mark)) 686 } 687 flow_sequence_entry(&mut self, first: bool) -> ParseResult688 fn flow_sequence_entry(&mut self, first: bool) -> ParseResult { 689 // skip FlowMappingStart 690 if first { 691 let _ = self.peek_token()?; 692 //self.marks.push(tok.0); 693 self.skip(); 694 } 695 match *self.peek_token()? { 696 Token(mark, TokenType::FlowSequenceEnd) => { 697 self.pop_state(); 698 self.skip(); 699 return Ok((Event::SequenceEnd, mark)); 700 } 701 Token(_, TokenType::FlowEntry) if !first => { 702 self.skip(); 703 } 704 Token(mark, _) if !first => { 705 return Err(ScanError::new( 706 mark, 707 "while parsing a flow sequence, expected ',' or ']'", 708 )); 709 } 710 _ => { /* next */ } 711 } 712 match *self.peek_token()? { 713 Token(mark, TokenType::FlowSequenceEnd) => { 714 self.pop_state(); 715 self.skip(); 716 Ok((Event::SequenceEnd, mark)) 717 } 718 Token(mark, TokenType::Key) => { 719 self.state = State::FlowSequenceEntryMappingKey; 720 self.skip(); 721 Ok((Event::MappingStart(0), mark)) 722 } 723 _ => { 724 self.push_state(State::FlowSequenceEntry); 725 self.parse_node(false, false) 726 } 727 } 728 } 729 indentless_sequence_entry(&mut self) -> ParseResult730 fn indentless_sequence_entry(&mut self) -> ParseResult { 731 match *self.peek_token()? { 732 Token(_, TokenType::BlockEntry) => (), 733 Token(mark, _) => { 734 self.pop_state(); 735 return Ok((Event::SequenceEnd, mark)); 736 } 737 } 738 self.skip(); 739 match *self.peek_token()? { 740 Token(mark, TokenType::BlockEntry) 741 | Token(mark, TokenType::Key) 742 | Token(mark, TokenType::Value) 743 | Token(mark, TokenType::BlockEnd) => { 744 self.state = State::IndentlessSequenceEntry; 745 Ok((Event::empty_scalar(), mark)) 746 } 747 _ => { 748 self.push_state(State::IndentlessSequenceEntry); 749 self.parse_node(true, false) 750 } 751 } 752 } 753 block_sequence_entry(&mut self, first: bool) -> ParseResult754 fn block_sequence_entry(&mut self, first: bool) -> ParseResult { 755 // BLOCK-SEQUENCE-START 756 if first { 757 let _ = self.peek_token()?; 758 //self.marks.push(tok.0); 759 self.skip(); 760 } 761 match *self.peek_token()? { 762 Token(mark, TokenType::BlockEnd) => { 763 self.pop_state(); 764 self.skip(); 765 Ok((Event::SequenceEnd, mark)) 766 } 767 Token(_, TokenType::BlockEntry) => { 768 self.skip(); 769 match *self.peek_token()? { 770 Token(mark, TokenType::BlockEntry) | Token(mark, TokenType::BlockEnd) => { 771 self.state = State::BlockSequenceEntry; 772 Ok((Event::empty_scalar(), mark)) 773 } 774 _ => { 775 self.push_state(State::BlockSequenceEntry); 776 self.parse_node(true, false) 777 } 778 } 779 } 780 Token(mark, _) => Err(ScanError::new( 781 mark, 782 "while parsing a block collection, did not find expected '-' indicator", 783 )), 784 } 785 } 786 flow_sequence_entry_mapping_key(&mut self) -> ParseResult787 fn flow_sequence_entry_mapping_key(&mut self) -> ParseResult { 788 match *self.peek_token()? { 789 Token(mark, TokenType::Value) 790 | Token(mark, TokenType::FlowEntry) 791 | Token(mark, TokenType::FlowSequenceEnd) => { 792 self.skip(); 793 self.state = State::FlowSequenceEntryMappingValue; 794 Ok((Event::empty_scalar(), mark)) 795 } 796 _ => { 797 self.push_state(State::FlowSequenceEntryMappingValue); 798 self.parse_node(false, false) 799 } 800 } 801 } 802 flow_sequence_entry_mapping_value(&mut self) -> ParseResult803 fn flow_sequence_entry_mapping_value(&mut self) -> ParseResult { 804 match *self.peek_token()? { 805 Token(_, TokenType::Value) => { 806 self.skip(); 807 self.state = State::FlowSequenceEntryMappingValue; 808 match *self.peek_token()? { 809 Token(mark, TokenType::FlowEntry) | Token(mark, TokenType::FlowSequenceEnd) => { 810 self.state = State::FlowSequenceEntryMappingEnd; 811 Ok((Event::empty_scalar(), mark)) 812 } 813 _ => { 814 self.push_state(State::FlowSequenceEntryMappingEnd); 815 self.parse_node(false, false) 816 } 817 } 818 } 819 Token(mark, _) => { 820 self.state = State::FlowSequenceEntryMappingEnd; 821 Ok((Event::empty_scalar(), mark)) 822 } 823 } 824 } 825 flow_sequence_entry_mapping_end(&mut self) -> ParseResult826 fn flow_sequence_entry_mapping_end(&mut self) -> ParseResult { 827 self.state = State::FlowSequenceEntry; 828 Ok((Event::MappingEnd, self.scanner.mark())) 829 } 830 } 831 832 #[cfg(test)] 833 mod test { 834 use super::{Event, Parser}; 835 836 #[test] test_peek_eq_parse()837 fn test_peek_eq_parse() { 838 let s = " 839 a0 bb: val 840 a1: &x 841 b1: 4 842 b2: d 843 a2: 4 844 a3: [1, 2, 3] 845 a4: 846 - [a1, a2] 847 - 2 848 a5: *x 849 "; 850 let mut p = Parser::new(s.chars()); 851 while { 852 let event_peek = p.peek().unwrap().clone(); 853 let event = p.next().unwrap(); 854 assert_eq!(event, event_peek); 855 event.0 != Event::StreamEnd 856 } {} 857 } 858 } 859