libyaml_safer/
parser.rs

1use std::io::BufRead;
2
3use crate::scanner::Scanner;
4use crate::{
5    Encoding, Error, Event, EventData, MappingStyle, Mark, Result, ScalarStyle, SequenceStyle,
6    TagDirective, TokenData, VersionDirective,
7};
8
9/// The parser structure.
10#[non_exhaustive]
11pub struct Parser<R> {
12    pub(crate) scanner: Scanner<R>,
13    pub(crate) inner: ParserInner,
14}
15
16/// The non-generic parts of `Parser`.
17#[derive(Default)]
18pub(crate) struct ParserInner {
19    /// The parser states stack.
20    pub(crate) states: Vec<ParserState>,
21    /// The current parser state.
22    pub(crate) state: ParserState,
23    /// The stack of marks.
24    pub(crate) marks: Vec<Mark>,
25    /// The list of TAG directives.
26    pub(crate) tag_directives: Vec<TagDirective>,
27    /// The alias data.
28    pub(crate) aliases: Vec<AliasData>,
29}
30
31impl<R> Default for Parser<R> {
32    fn default() -> Self {
33        Self::new()
34    }
35}
36
37/// This structure holds information about a potential simple key.
38#[derive(Copy, Clone)]
39#[non_exhaustive]
40pub struct SimpleKey {
41    /// Is a simple key possible?
42    pub possible: bool,
43    /// Is a simple key required?
44    pub required: bool,
45    /// The number of the token.
46    pub token_number: usize,
47    /// The position mark.
48    pub mark: Mark,
49}
50
51/// The states of the parser.
52#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
53#[non_exhaustive]
54pub enum ParserState {
55    /// Expect STREAM-START.
56    #[default]
57    StreamStart = 0,
58    /// Expect the beginning of an implicit document.
59    ImplicitDocumentStart = 1,
60    /// Expect DOCUMENT-START.
61    DocumentStart = 2,
62    /// Expect the content of a document.
63    DocumentContent = 3,
64    /// Expect DOCUMENT-END.
65    DocumentEnd = 4,
66    /// Expect a block node.
67    BlockNode = 5,
68    /// Expect a block node or indentless sequence.
69    BlockNodeOrIndentlessSequence = 6,
70    /// Expect a flow node.
71    FlowNode = 7,
72    /// Expect the first entry of a block sequence.
73    BlockSequenceFirstEntry = 8,
74    /// Expect an entry of a block sequence.
75    BlockSequenceEntry = 9,
76    /// Expect an entry of an indentless sequence.
77    IndentlessSequenceEntry = 10,
78    /// Expect the first key of a block mapping.
79    BlockMappingFirstKey = 11,
80    /// Expect a block mapping key.
81    BlockMappingKey = 12,
82    /// Expect a block mapping value.
83    BlockMappingValue = 13,
84    /// Expect the first entry of a flow sequence.
85    FlowSequenceFirstEntry = 14,
86    /// Expect an entry of a flow sequence.
87    FlowSequenceEntry = 15,
88    /// Expect a key of an ordered mapping.
89    FlowSequenceEntryMappingKey = 16,
90    /// Expect a value of an ordered mapping.
91    FlowSequenceEntryMappingValue = 17,
92    /// Expect the and of an ordered mapping entry.
93    FlowSequenceEntryMappingEnd = 18,
94    /// Expect the first key of a flow mapping.
95    FlowMappingFirstKey = 19,
96    /// Expect a key of a flow mapping.
97    FlowMappingKey = 20,
98    /// Expect a value of a flow mapping.
99    FlowMappingValue = 21,
100    /// Expect an empty value of a flow mapping.
101    FlowMappingEmptyValue = 22,
102    /// Expect nothing.
103    End = 23,
104}
105
106/// This structure holds aliases data.
107#[non_exhaustive]
108pub struct AliasData {
109    /// The anchor.
110    pub anchor: String,
111    /// The node id.
112    pub index: i32,
113    /// The anchor mark.
114    pub mark: Mark,
115}
116
117impl<R: BufRead> Iterator for Parser<R> {
118    type Item = Result<Event>;
119
120    fn next(&mut self) -> Option<Self::Item> {
121        if self.scanner.stream_end_produced || self.inner.state == ParserState::End {
122            None
123        } else {
124            Some(self.parse())
125        }
126    }
127}
128
129impl<R: BufRead> core::iter::FusedIterator for Parser<R> {}
130
131impl<R> Parser<R> {
132    /// Create a parser.
133    pub fn new() -> Parser<R> {
134        Parser {
135            scanner: Scanner::new(),
136            inner: ParserInner {
137                states: Vec::with_capacity(16),
138                state: ParserState::default(),
139                marks: Vec::with_capacity(16),
140                tag_directives: Vec::with_capacity(16),
141                aliases: Vec::new(),
142            },
143        }
144    }
145
146    /// Reset the parser state.
147    pub fn reset(&mut self) {
148        self.scanner.reset();
149
150        // Preserve allocations.
151        self.inner.states.clear();
152        self.inner.state = ParserState::default();
153        self.inner.marks.clear();
154        self.inner.tag_directives.clear();
155        self.inner.aliases.clear();
156    }
157}
158
159impl<'r, 'b> Parser<&'b mut &'r [u8]> {
160    /// Set a string input.
161    pub fn set_input_string(&mut self, input: &'r mut &'b [u8]) {
162        self.scanner.set_input_string(input);
163    }
164}
165
166impl<R: BufRead> Parser<R> {
167    /// Set a generic input handler.
168    pub fn set_input(&mut self, input: R) {
169        self.scanner.set_input(input);
170    }
171
172    /// Set the source encoding.
173    pub fn set_encoding(&mut self, encoding: Encoding) {
174        self.scanner.set_encoding(encoding);
175    }
176
177    /// Parse the input stream and produce the next parsing event.
178    ///
179    /// Call the function subsequently to produce a sequence of events
180    /// corresponding to the input stream. The initial event has the type
181    /// [`EventData::StreamStart`](crate::EventData::StreamStart) while the
182    /// ending event has the type
183    /// [`EventData::StreamEnd`](crate::EventData::StreamEnd).
184    ///
185    /// An application must not alternate the calls of [`Parser::parse()`] with
186    /// the calls of [`Document::load()`](crate::Document::load). Doing this
187    /// will break the parser.
188    pub fn parse(&mut self) -> Result<Event> {
189        if self.scanner.stream_end_produced || self.inner.state == ParserState::End {
190            return Ok(Event::stream_end());
191        }
192        self.state_machine()
193    }
194
195    fn state_machine(&mut self) -> Result<Event> {
196        match self.inner.state {
197            ParserState::StreamStart => self.parse_stream_start(),
198            ParserState::ImplicitDocumentStart => self.parse_document_start(true),
199            ParserState::DocumentStart => self.parse_document_start(false),
200            ParserState::DocumentContent => self.parse_document_content(),
201            ParserState::DocumentEnd => self.parse_document_end(),
202            ParserState::BlockNode => self.parse_node(true, false),
203            ParserState::BlockNodeOrIndentlessSequence => self.parse_node(true, true),
204            ParserState::FlowNode => self.parse_node(false, false),
205            ParserState::BlockSequenceFirstEntry => self.parse_block_sequence_entry(true),
206            ParserState::BlockSequenceEntry => self.parse_block_sequence_entry(false),
207            ParserState::IndentlessSequenceEntry => self.parse_indentless_sequence_entry(),
208            ParserState::BlockMappingFirstKey => self.parse_block_mapping_key(true),
209            ParserState::BlockMappingKey => self.parse_block_mapping_key(false),
210            ParserState::BlockMappingValue => self.parse_block_mapping_value(),
211            ParserState::FlowSequenceFirstEntry => self.parse_flow_sequence_entry(true),
212            ParserState::FlowSequenceEntry => self.parse_flow_sequence_entry(false),
213            ParserState::FlowSequenceEntryMappingKey => {
214                self.parse_flow_sequence_entry_mapping_key()
215            }
216            ParserState::FlowSequenceEntryMappingValue => {
217                self.parse_flow_sequence_entry_mapping_value()
218            }
219            ParserState::FlowSequenceEntryMappingEnd => {
220                self.parse_flow_sequence_entry_mapping_end()
221            }
222            ParserState::FlowMappingFirstKey => self.parse_flow_mapping_key(true),
223            ParserState::FlowMappingKey => self.parse_flow_mapping_key(false),
224            ParserState::FlowMappingValue => self.parse_flow_mapping_value(false),
225            ParserState::FlowMappingEmptyValue => self.parse_flow_mapping_value(true),
226            ParserState::End => panic!("parser end state reached unexpectedly"),
227        }
228    }
229
230    fn parse_stream_start(&mut self) -> Result<Event> {
231        let token = self.scanner.peek()?;
232
233        if let TokenData::StreamStart { encoding } = &token.data {
234            let event = Event {
235                data: EventData::StreamStart {
236                    encoding: *encoding,
237                },
238                start_mark: token.start_mark,
239                end_mark: token.end_mark,
240            };
241            self.inner.state = ParserState::ImplicitDocumentStart;
242            self.scanner.skip_token();
243            Ok(event)
244        } else {
245            let mark = token.start_mark;
246            Err(Error::parser(
247                "",
248                Mark::default(),
249                "did not find expected <stream-start>",
250                mark,
251            ))
252        }
253    }
254
255    fn parse_document_start(&mut self, implicit: bool) -> Result<Event> {
256        let mut version_directive: Option<VersionDirective> = None;
257
258        let mut tag_directives = vec![];
259        let mut token = self.scanner.peek()?;
260        if !implicit {
261            while let TokenData::DocumentEnd = &token.data {
262                self.scanner.skip_token();
263                token = self.scanner.peek()?;
264            }
265        }
266        if implicit
267            && !matches!(
268                token.data,
269                TokenData::VersionDirective { .. }
270                    | TokenData::TagDirective { .. }
271                    | TokenData::DocumentStart
272                    | TokenData::StreamEnd
273            )
274        {
275            let event = Event {
276                data: EventData::DocumentStart {
277                    version_directive: None,
278                    tag_directives: vec![],
279                    implicit: true,
280                },
281                start_mark: token.start_mark,
282                end_mark: token.end_mark,
283            };
284            self.process_directives(None, None)?;
285            self.inner.states.push(ParserState::DocumentEnd);
286            self.inner.state = ParserState::BlockNode;
287            Ok(event)
288        } else if !matches!(token.data, TokenData::StreamEnd) {
289            let end_mark: Mark;
290            let start_mark: Mark = token.start_mark;
291            self.process_directives(Some(&mut version_directive), Some(&mut tag_directives))?;
292            token = self.scanner.peek()?;
293            if let TokenData::DocumentStart = token.data {
294                end_mark = token.end_mark;
295                let event = Event {
296                    data: EventData::DocumentStart {
297                        version_directive,
298                        tag_directives: core::mem::take(&mut tag_directives),
299                        implicit: false,
300                    },
301                    start_mark,
302                    end_mark,
303                };
304                self.inner.states.push(ParserState::DocumentEnd);
305                self.inner.state = ParserState::DocumentContent;
306                self.scanner.skip_token();
307                Ok(event)
308            } else {
309                Err(Error::parser(
310                    "",
311                    Mark::default(),
312                    "did not find expected <document start>",
313                    token.start_mark,
314                ))
315            }
316        } else {
317            let event = Event {
318                data: EventData::StreamEnd,
319                start_mark: token.start_mark,
320                end_mark: token.end_mark,
321            };
322            self.inner.state = ParserState::End;
323            self.scanner.skip_token();
324            Ok(event)
325        }
326    }
327
328    fn parse_document_content(&mut self) -> Result<Event> {
329        let token = self.scanner.peek()?;
330        if let TokenData::VersionDirective { .. }
331        | TokenData::TagDirective { .. }
332        | TokenData::DocumentStart
333        | TokenData::DocumentEnd
334        | TokenData::StreamEnd = &token.data
335        {
336            let mark = token.start_mark;
337            self.inner.state = self.inner.states.pop().unwrap();
338            Self::process_empty_scalar(mark)
339        } else {
340            self.parse_node(true, false)
341        }
342    }
343
344    fn parse_document_end(&mut self) -> Result<Event> {
345        let mut end_mark: Mark;
346        let mut implicit = true;
347        let token = self.scanner.peek()?;
348        end_mark = token.start_mark;
349        let start_mark: Mark = end_mark;
350        if let TokenData::DocumentEnd = &token.data {
351            end_mark = token.end_mark;
352            self.scanner.skip_token();
353            implicit = false;
354        }
355        self.inner.tag_directives.clear();
356        self.inner.state = ParserState::DocumentStart;
357        Ok(Event {
358            data: EventData::DocumentEnd { implicit },
359            start_mark,
360            end_mark,
361        })
362    }
363
364    fn parse_node(&mut self, block: bool, indentless_sequence: bool) -> Result<Event> {
365        let mut anchor: Option<String> = None;
366        let mut tag_handle: Option<String> = None;
367        let mut tag_suffix: Option<String> = None;
368        let mut tag: Option<String> = None;
369        let mut start_mark: Mark;
370        let mut end_mark: Mark;
371        let mut tag_mark = Mark {
372            index: 0,
373            line: 0,
374            column: 0,
375        };
376
377        let mut token = self.scanner.peek_mut()?;
378
379        if let TokenData::Alias { value } = &mut token.data {
380            let event = Event {
381                data: EventData::Alias {
382                    anchor: core::mem::take(value),
383                },
384                start_mark: token.start_mark,
385                end_mark: token.end_mark,
386            };
387            self.inner.state = self.inner.states.pop().unwrap();
388            self.scanner.skip_token();
389            return Ok(event);
390        }
391
392        end_mark = token.start_mark;
393        start_mark = end_mark;
394        if let TokenData::Anchor { value } = &mut token.data {
395            anchor = Some(core::mem::take(value));
396            start_mark = token.start_mark;
397            end_mark = token.end_mark;
398            self.scanner.skip_token();
399            token = self.scanner.peek_mut()?;
400            if let TokenData::Tag { handle, suffix } = &mut token.data {
401                tag_handle = Some(core::mem::take(handle));
402                tag_suffix = Some(core::mem::take(suffix));
403                tag_mark = token.start_mark;
404                end_mark = token.end_mark;
405                self.scanner.skip_token();
406            }
407        } else if let TokenData::Tag { handle, suffix } = &mut token.data {
408            tag_handle = Some(core::mem::take(handle));
409            tag_suffix = Some(core::mem::take(suffix));
410            tag_mark = token.start_mark;
411            start_mark = tag_mark;
412            end_mark = token.end_mark;
413            self.scanner.skip_token();
414            token = self.scanner.peek_mut()?;
415            if let TokenData::Anchor { value } = &mut token.data {
416                anchor = Some(core::mem::take(value));
417                end_mark = token.end_mark;
418                self.scanner.skip_token();
419            }
420        }
421
422        if let Some(ref tag_handle_value) = tag_handle {
423            if tag_handle_value.is_empty() {
424                tag = tag_suffix;
425            } else {
426                for tag_directive in &self.inner.tag_directives {
427                    if tag_directive.handle == *tag_handle_value {
428                        let suffix = tag_suffix.as_deref().unwrap_or("");
429                        tag = Some(alloc::format!("{}{}", tag_directive.prefix, suffix));
430                        break;
431                    }
432                }
433                if tag.is_none() {
434                    return Err(Error::parser(
435                        "while parsing a node",
436                        start_mark,
437                        "found undefined tag handle",
438                        tag_mark,
439                    ));
440                }
441            }
442        }
443
444        let token = self.scanner.peek_mut()?;
445
446        let implicit = tag.is_none() || tag.as_deref() == Some("");
447
448        if indentless_sequence && matches!(token.data, TokenData::BlockEntry) {
449            end_mark = token.end_mark;
450            self.inner.state = ParserState::IndentlessSequenceEntry;
451            let event = Event {
452                data: EventData::SequenceStart {
453                    anchor,
454                    tag,
455                    implicit,
456                    style: SequenceStyle::Block,
457                },
458                start_mark,
459                end_mark,
460            };
461            Ok(event)
462        } else if let TokenData::Scalar { value, style } = &mut token.data {
463            let mut plain_implicit = false;
464            let mut quoted_implicit = false;
465            end_mark = token.end_mark;
466            if *style == ScalarStyle::Plain && tag.is_none() || tag.as_deref() == Some("!") {
467                plain_implicit = true;
468            } else if tag.is_none() {
469                quoted_implicit = true;
470            }
471            let event = Event {
472                data: EventData::Scalar {
473                    anchor,
474                    tag,
475                    value: core::mem::take(value),
476                    plain_implicit,
477                    quoted_implicit,
478                    style: *style,
479                },
480                start_mark,
481                end_mark,
482            };
483            self.inner.state = self.inner.states.pop().unwrap();
484            self.scanner.skip_token();
485            Ok(event)
486        } else if let TokenData::FlowSequenceStart = &token.data {
487            end_mark = token.end_mark;
488            self.inner.state = ParserState::FlowSequenceFirstEntry;
489            let event = Event {
490                data: EventData::SequenceStart {
491                    anchor,
492                    tag,
493                    implicit,
494                    style: SequenceStyle::Flow,
495                },
496                start_mark,
497                end_mark,
498            };
499            Ok(event)
500        } else if let TokenData::FlowMappingStart = &token.data {
501            end_mark = token.end_mark;
502            self.inner.state = ParserState::FlowMappingFirstKey;
503            let event = Event {
504                data: EventData::MappingStart {
505                    anchor,
506                    tag,
507                    implicit,
508                    style: MappingStyle::Flow,
509                },
510                start_mark,
511                end_mark,
512            };
513            Ok(event)
514        } else if block && matches!(token.data, TokenData::BlockSequenceStart) {
515            end_mark = token.end_mark;
516            self.inner.state = ParserState::BlockSequenceFirstEntry;
517            let event = Event {
518                data: EventData::SequenceStart {
519                    anchor,
520                    tag,
521                    implicit,
522                    style: SequenceStyle::Block,
523                },
524                start_mark,
525                end_mark,
526            };
527            Ok(event)
528        } else if block && matches!(token.data, TokenData::BlockMappingStart) {
529            end_mark = token.end_mark;
530            self.inner.state = ParserState::BlockMappingFirstKey;
531            let event = Event {
532                data: EventData::MappingStart {
533                    anchor,
534                    tag,
535                    implicit,
536                    style: MappingStyle::Block,
537                },
538                start_mark,
539                end_mark,
540            };
541            Ok(event)
542        } else if anchor.is_some() || tag.is_some() {
543            self.inner.state = self.inner.states.pop().unwrap();
544            let event = Event {
545                data: EventData::Scalar {
546                    anchor,
547                    tag,
548                    value: String::new(),
549                    plain_implicit: implicit,
550                    quoted_implicit: false,
551                    style: ScalarStyle::Plain,
552                },
553                start_mark,
554                end_mark,
555            };
556            Ok(event)
557        } else {
558            Err(Error::parser(
559                if block {
560                    "while parsing a block node"
561                } else {
562                    "while parsing a flow node"
563                },
564                start_mark,
565                "did not find expected node content",
566                token.start_mark,
567            ))
568        }
569    }
570
571    fn parse_block_sequence_entry(&mut self, first: bool) -> Result<Event> {
572        if first {
573            let token = self.scanner.peek()?;
574            let mark = token.start_mark;
575            self.inner.marks.push(mark);
576            self.scanner.skip_token();
577        }
578
579        let mut token = self.scanner.peek()?;
580
581        if let TokenData::BlockEntry = &token.data {
582            let mark: Mark = token.end_mark;
583            self.scanner.skip_token();
584            token = self.scanner.peek()?;
585            if matches!(token.data, TokenData::BlockEntry | TokenData::BlockEnd) {
586                self.inner.state = ParserState::BlockSequenceEntry;
587                Self::process_empty_scalar(mark)
588            } else {
589                self.inner.states.push(ParserState::BlockSequenceEntry);
590                self.parse_node(true, false)
591            }
592        } else if let TokenData::BlockEnd = token.data {
593            let event = Event {
594                data: EventData::SequenceEnd,
595                start_mark: token.start_mark,
596                end_mark: token.end_mark,
597            };
598            self.inner.state = self.inner.states.pop().unwrap();
599            let _ = self.inner.marks.pop();
600            self.scanner.skip_token();
601            Ok(event)
602        } else {
603            let token_mark = token.start_mark;
604            let mark = self.inner.marks.pop().unwrap();
605            Err(Error::parser(
606                "while parsing a block collection",
607                mark,
608                "did not find expected '-' indicator",
609                token_mark,
610            ))
611        }
612    }
613
614    fn parse_indentless_sequence_entry(&mut self) -> Result<Event> {
615        let mut token = self.scanner.peek()?;
616        if let TokenData::BlockEntry = token.data {
617            let mark: Mark = token.end_mark;
618            self.scanner.skip_token();
619            token = self.scanner.peek()?;
620
621            if matches!(
622                token.data,
623                TokenData::BlockEntry | TokenData::Key | TokenData::Value | TokenData::BlockEnd
624            ) {
625                self.inner.state = ParserState::IndentlessSequenceEntry;
626                Self::process_empty_scalar(mark)
627            } else {
628                self.inner.states.push(ParserState::IndentlessSequenceEntry);
629                self.parse_node(true, false)
630            }
631        } else {
632            let event = Event {
633                data: EventData::SequenceEnd,
634                start_mark: token.start_mark,
635                end_mark: token.end_mark,
636            };
637            self.inner.state = self.inner.states.pop().unwrap();
638            Ok(event)
639        }
640    }
641
642    fn parse_block_mapping_key(&mut self, first: bool) -> Result<Event> {
643        if first {
644            let token = self.scanner.peek()?;
645            let mark = token.start_mark;
646            self.inner.marks.push(mark);
647            self.scanner.skip_token();
648        }
649
650        let mut token = self.scanner.peek()?;
651        if let TokenData::Key = token.data {
652            let mark: Mark = token.end_mark;
653            self.scanner.skip_token();
654            token = self.scanner.peek()?;
655            if matches!(
656                token.data,
657                TokenData::Key | TokenData::Value | TokenData::BlockEnd
658            ) {
659                self.inner.state = ParserState::BlockMappingValue;
660                Self::process_empty_scalar(mark)
661            } else {
662                self.inner.states.push(ParserState::BlockMappingValue);
663                self.parse_node(true, true)
664            }
665        } else if let TokenData::BlockEnd = token.data {
666            let event = Event {
667                data: EventData::MappingEnd,
668                start_mark: token.start_mark,
669                end_mark: token.end_mark,
670            };
671            self.inner.state = self.inner.states.pop().unwrap();
672            _ = self.inner.marks.pop();
673            self.scanner.skip_token();
674            Ok(event)
675        } else {
676            let token_mark = token.start_mark;
677            let mark = self.inner.marks.pop().unwrap();
678            Err(Error::parser(
679                "while parsing a block mapping",
680                mark,
681                "did not find expected key",
682                token_mark,
683            ))
684        }
685    }
686
687    fn parse_block_mapping_value(&mut self) -> Result<Event> {
688        let mut token = self.scanner.peek()?;
689        if let TokenData::Value = token.data {
690            let mark: Mark = token.end_mark;
691            self.scanner.skip_token();
692            token = self.scanner.peek()?;
693            if matches!(
694                token.data,
695                TokenData::Key | TokenData::Value | TokenData::BlockEnd
696            ) {
697                self.inner.state = ParserState::BlockMappingKey;
698                Self::process_empty_scalar(mark)
699            } else {
700                self.inner.states.push(ParserState::BlockMappingKey);
701                self.parse_node(true, true)
702            }
703        } else {
704            let mark = token.start_mark;
705            self.inner.state = ParserState::BlockMappingKey;
706            Self::process_empty_scalar(mark)
707        }
708    }
709
710    fn parse_flow_sequence_entry(&mut self, first: bool) -> Result<Event> {
711        if first {
712            let token = self.scanner.peek()?;
713            let mark = token.start_mark;
714            self.inner.marks.push(mark);
715            self.scanner.skip_token();
716        }
717
718        let mut token = self.scanner.peek()?;
719        if !matches!(token.data, TokenData::FlowSequenceEnd) {
720            if !first {
721                if let TokenData::FlowEntry = token.data {
722                    self.scanner.skip_token();
723                    token = self.scanner.peek()?;
724                } else {
725                    let token_mark = token.start_mark;
726                    let mark = self.inner.marks.pop().unwrap();
727                    return Err(Error::parser(
728                        "while parsing a flow sequence",
729                        mark,
730                        "did not find expected ',' or ']'",
731                        token_mark,
732                    ));
733                }
734            }
735            if let TokenData::Key = token.data {
736                let event = Event {
737                    data: EventData::MappingStart {
738                        anchor: None,
739                        tag: None,
740                        implicit: true,
741                        style: MappingStyle::Flow,
742                    },
743                    start_mark: token.start_mark,
744                    end_mark: token.end_mark,
745                };
746                self.inner.state = ParserState::FlowSequenceEntryMappingKey;
747                self.scanner.skip_token();
748                return Ok(event);
749            } else if !matches!(token.data, TokenData::FlowSequenceEnd) {
750                self.inner.states.push(ParserState::FlowSequenceEntry);
751                return self.parse_node(false, false);
752            }
753        }
754        let event = Event {
755            data: EventData::SequenceEnd,
756            start_mark: token.start_mark,
757            end_mark: token.end_mark,
758        };
759        self.inner.state = self.inner.states.pop().unwrap();
760        _ = self.inner.marks.pop();
761        self.scanner.skip_token();
762        Ok(event)
763    }
764
765    fn parse_flow_sequence_entry_mapping_key(&mut self) -> Result<Event> {
766        let token = self.scanner.peek()?;
767        if matches!(
768            token.data,
769            TokenData::Value | TokenData::FlowEntry | TokenData::FlowSequenceEnd
770        ) {
771            let mark: Mark = token.end_mark;
772            self.scanner.skip_token();
773            self.inner.state = ParserState::FlowSequenceEntryMappingValue;
774            Self::process_empty_scalar(mark)
775        } else {
776            self.inner
777                .states
778                .push(ParserState::FlowSequenceEntryMappingValue);
779            self.parse_node(false, false)
780        }
781    }
782
783    fn parse_flow_sequence_entry_mapping_value(&mut self) -> Result<Event> {
784        let mut token = self.scanner.peek()?;
785        if let TokenData::Value = token.data {
786            self.scanner.skip_token();
787            token = self.scanner.peek()?;
788            if !matches!(
789                token.data,
790                TokenData::FlowEntry | TokenData::FlowSequenceEnd
791            ) {
792                self.inner
793                    .states
794                    .push(ParserState::FlowSequenceEntryMappingEnd);
795                return self.parse_node(false, false);
796            }
797        }
798        let mark = token.start_mark;
799        self.inner.state = ParserState::FlowSequenceEntryMappingEnd;
800        Self::process_empty_scalar(mark)
801    }
802
803    fn parse_flow_sequence_entry_mapping_end(&mut self) -> Result<Event> {
804        let token = self.scanner.peek()?;
805        let start_mark = token.start_mark;
806        let end_mark = token.end_mark;
807        self.inner.state = ParserState::FlowSequenceEntry;
808        Ok(Event {
809            data: EventData::MappingEnd,
810            start_mark,
811            end_mark,
812        })
813    }
814
815    fn parse_flow_mapping_key(&mut self, first: bool) -> Result<Event> {
816        if first {
817            let token = self.scanner.peek()?;
818            let mark = token.start_mark;
819            self.inner.marks.push(mark);
820            self.scanner.skip_token();
821        }
822
823        let mut token = self.scanner.peek()?;
824        if !matches!(token.data, TokenData::FlowMappingEnd) {
825            if !first {
826                if let TokenData::FlowEntry = token.data {
827                    self.scanner.skip_token();
828                    token = self.scanner.peek()?;
829                } else {
830                    let token_mark = token.start_mark;
831                    let mark = self.inner.marks.pop().unwrap();
832                    return Err(Error::parser(
833                        "while parsing a flow mapping",
834                        mark,
835                        "did not find expected ',' or '}'",
836                        token_mark,
837                    ));
838                }
839            }
840            if let TokenData::Key = token.data {
841                self.scanner.skip_token();
842                token = self.scanner.peek()?;
843                if !matches!(
844                    token.data,
845                    TokenData::Value | TokenData::FlowEntry | TokenData::FlowMappingEnd
846                ) {
847                    self.inner.states.push(ParserState::FlowMappingValue);
848                    return self.parse_node(false, false);
849                }
850                let mark = token.start_mark;
851                self.inner.state = ParserState::FlowMappingValue;
852                return Self::process_empty_scalar(mark);
853            } else if !matches!(token.data, TokenData::FlowMappingEnd) {
854                self.inner.states.push(ParserState::FlowMappingEmptyValue);
855                return self.parse_node(false, false);
856            }
857        }
858        let event = Event {
859            data: EventData::MappingEnd,
860            start_mark: token.start_mark,
861            end_mark: token.end_mark,
862        };
863        self.inner.state = self.inner.states.pop().unwrap();
864        _ = self.inner.marks.pop();
865        self.scanner.skip_token();
866        Ok(event)
867    }
868
869    fn parse_flow_mapping_value(&mut self, empty: bool) -> Result<Event> {
870        let mut token = self.scanner.peek()?;
871        if empty {
872            let mark = token.start_mark;
873            self.inner.state = ParserState::FlowMappingKey;
874            return Self::process_empty_scalar(mark);
875        }
876        if let TokenData::Value = token.data {
877            self.scanner.skip_token();
878            token = self.scanner.peek()?;
879            if !matches!(token.data, TokenData::FlowEntry | TokenData::FlowMappingEnd) {
880                self.inner.states.push(ParserState::FlowMappingKey);
881                return self.parse_node(false, false);
882            }
883        }
884        let mark = token.start_mark;
885        self.inner.state = ParserState::FlowMappingKey;
886        Self::process_empty_scalar(mark)
887    }
888
889    fn process_empty_scalar(mark: Mark) -> Result<Event> {
890        Ok(Event {
891            data: EventData::Scalar {
892                anchor: None,
893                tag: None,
894                value: String::new(),
895                plain_implicit: true,
896                quoted_implicit: false,
897                style: ScalarStyle::Plain,
898            },
899            start_mark: mark,
900            end_mark: mark,
901        })
902    }
903
904    fn process_directives(
905        &mut self,
906        version_directive_ref: Option<&mut Option<VersionDirective>>,
907        tag_directives_ref: Option<&mut Vec<TagDirective>>,
908    ) -> Result<()> {
909        let default_tag_directives: [TagDirective; 2] = [
910            // TODO: Get rid of these heap allocations.
911            TagDirective {
912                handle: String::from("!"),
913                prefix: String::from("!"),
914            },
915            TagDirective {
916                handle: String::from("!!"),
917                prefix: String::from("tag:yaml.org,2002:"),
918            },
919        ];
920        let mut version_directive: Option<VersionDirective> = None;
921
922        let mut tag_directives = Vec::with_capacity(16);
923
924        let mut token = self.scanner.peek_mut()?;
925
926        loop {
927            if !matches!(
928                token.data,
929                TokenData::VersionDirective { .. } | TokenData::TagDirective { .. }
930            ) {
931                break;
932            }
933
934            if let TokenData::VersionDirective { major, minor } = &token.data {
935                let mark = token.start_mark;
936                if version_directive.is_some() {
937                    return Err(Error::parser(
938                        "",
939                        Mark::default(),
940                        "found duplicate %YAML directive",
941                        mark,
942                    ));
943                } else if *major != 1 || *minor != 1 && *minor != 2 {
944                    return Err(Error::parser(
945                        "",
946                        Mark::default(),
947                        "found incompatible YAML document",
948                        mark,
949                    ));
950                }
951                version_directive = Some(VersionDirective {
952                    major: *major,
953                    minor: *minor,
954                });
955            } else if let TokenData::TagDirective { handle, prefix } = &mut token.data {
956                let value = TagDirective {
957                    handle: core::mem::take(handle),
958                    prefix: core::mem::take(prefix),
959                };
960                let mark = token.start_mark;
961                self.inner
962                    .append_tag_directive(value.clone(), false, mark)?;
963
964                tag_directives.push(value);
965            }
966
967            self.scanner.skip_token();
968            token = self.scanner.peek_mut()?;
969        }
970
971        let start_mark = token.start_mark;
972        for default_tag_directive in default_tag_directives {
973            self.inner
974                .append_tag_directive(default_tag_directive, true, start_mark)?;
975        }
976
977        if let Some(version_directive_ref) = version_directive_ref {
978            *version_directive_ref = version_directive;
979        }
980        if let Some(tag_directives_ref) = tag_directives_ref {
981            if tag_directives.is_empty() {
982                tag_directives_ref.clear();
983                tag_directives.clear();
984            } else {
985                *tag_directives_ref = tag_directives;
986            }
987        } else {
988            tag_directives.clear();
989        }
990
991        Ok(())
992    }
993}
994
995impl ParserInner {
996    fn append_tag_directive(
997        &mut self,
998        value: TagDirective,
999        allow_duplicates: bool,
1000        mark: Mark,
1001    ) -> Result<()> {
1002        for tag_directive in &self.tag_directives {
1003            if value.handle == tag_directive.handle {
1004                if allow_duplicates {
1005                    return Ok(());
1006                }
1007                return Err(Error::parser(
1008                    "",
1009                    Mark::default(),
1010                    "found duplicate %TAG directive",
1011                    mark,
1012                ));
1013            }
1014        }
1015        self.tag_directives.push(value);
1016        Ok(())
1017    }
1018
1019    pub(crate) fn delete_aliases(&mut self) {
1020        self.aliases.clear();
1021    }
1022}
libyaml_safer/parser.rs

libyaml_safer/
parser.rs
