Mirrors/libyaml-safer
2
0
Fork 0
mirror of https://github.com/simonask/libyaml-safer synced 2025-02-16 20:38:30 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rustify type names

Browse source
This commit is contained in:
Simon Ask Ulsnes 2024-02-03 09:28:18 +01:00
parent a35a2cd14b
commit 4f8f997d8f
13 changed files with 740 additions and 862 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

204
src/api.rs
View file

@ -1,13 +1,12 @@
use alloc::string::String;
use alloc::vec::Vec;
use crate::yaml::{YamlEventData, YamlNodeData};
use crate::yaml::{EventData, NodeData};
use crate::{
yaml_break_t, yaml_document_t, yaml_emitter_state_t, yaml_emitter_t, yaml_encoding_t,
yaml_event_t, yaml_mapping_style_t, yaml_mark_t, yaml_node_pair_t, yaml_node_t,
yaml_parser_state_t, yaml_parser_t, yaml_scalar_style_t, yaml_sequence_style_t,
yaml_tag_directive_t, yaml_version_directive_t, YAML_ANY_ENCODING, YAML_DEFAULT_MAPPING_TAG,
YAML_DEFAULT_SCALAR_TAG, YAML_DEFAULT_SEQUENCE_TAG, YAML_UTF8_ENCODING,
Break, Document, Emitter, EmitterState, Encoding, Event, MappingStyle, Mark, Node, NodePair,
Parser, ParserState, ScalarStyle, SequenceStyle, TagDirective, VersionDirective,
YAML_ANY_ENCODING, YAML_DEFAULT_MAPPING_TAG, YAML_DEFAULT_SCALAR_TAG,
YAML_DEFAULT_SEQUENCE_TAG, YAML_UTF8_ENCODING,
};
use std::collections::VecDeque;
@ -19,15 +18,15 @@ pub(crate) const OUTPUT_BUFFER_SIZE: usize = 16384;
///
/// This function creates a new parser object. An application is responsible
/// for destroying the object using the yaml_parser_delete() function.
pub fn yaml_parser_new<'r>() -> yaml_parser_t<'r> {
yaml_parser_t {
pub fn yaml_parser_new<'r>() -> Parser<'r> {
Parser {
read_handler: None,
eof: false,
buffer: VecDeque::with_capacity(INPUT_BUFFER_SIZE),
unread: 0,
encoding: YAML_ANY_ENCODING,
offset: 0,
mark: yaml_mark_t::default(),
mark: Mark::default(),
stream_start_produced: false,
stream_end_produced: false,
flow_level: 0,
@ -39,7 +38,7 @@ pub fn yaml_parser_new<'r>() -> yaml_parser_t<'r> {
simple_key_allowed: false,
simple_keys: Vec::with_capacity(16),
states: Vec::with_capacity(16),
state: yaml_parser_state_t::default(),
state: ParserState::default(),
marks: Vec::with_capacity(16),
tag_directives: Vec::with_capacity(16),
aliases: Vec::new(),
@ -47,34 +46,31 @@ pub fn yaml_parser_new<'r>() -> yaml_parser_t<'r> {
}
/// Reset the parser state.
pub fn yaml_parser_reset(parser: &mut yaml_parser_t) {
pub fn yaml_parser_reset(parser: &mut Parser) {
*parser = yaml_parser_new();
}
/// Set a string input.
pub fn yaml_parser_set_input_string<'r>(parser: &mut yaml_parser_t<'r>, input: &'r mut &[u8]) {
pub fn yaml_parser_set_input_string<'r>(parser: &mut Parser<'r>, input: &'r mut &[u8]) {
assert!((parser.read_handler).is_none());
parser.read_handler = Some(input);
}
/// Set a generic input handler.
pub fn yaml_parser_set_input<'r>(
parser: &mut yaml_parser_t<'r>,
input: &'r mut dyn std::io::BufRead,
) {
pub fn yaml_parser_set_input<'r>(parser: &mut Parser<'r>, input: &'r mut dyn std::io::BufRead) {
assert!((parser.read_handler).is_none());
parser.read_handler = Some(input);
}
/// Set the source encoding.
pub fn yaml_parser_set_encoding(parser: &mut yaml_parser_t, encoding: yaml_encoding_t) {
pub fn yaml_parser_set_encoding(parser: &mut Parser, encoding: Encoding) {
assert!(parser.encoding == YAML_ANY_ENCODING);
parser.encoding = encoding;
}
/// Create an emitter.
pub fn yaml_emitter_new<'w>() -> yaml_emitter_t<'w> {
yaml_emitter_t {
pub fn yaml_emitter_new<'w>() -> Emitter<'w> {
Emitter {
write_handler: None,
buffer: String::with_capacity(OUTPUT_BUFFER_SIZE),
raw_buffer: Vec::with_capacity(OUTPUT_BUFFER_SIZE),
@ -83,9 +79,9 @@ pub fn yaml_emitter_new<'w>() -> yaml_emitter_t<'w> {
best_indent: 0,
best_width: 0,
unicode: false,
line_break: yaml_break_t::default(),
line_break: Break::default(),
states: Vec::with_capacity(16),
state: yaml_emitter_state_t::default(),
state: EmitterState::default(),
events: VecDeque::with_capacity(16),
indents: Vec::with_capacity(16),
tag_directives: Vec::with_capacity(16),
@ -108,17 +104,14 @@ pub fn yaml_emitter_new<'w>() -> yaml_emitter_t<'w> {
}
/// Reset the emitter state.
pub fn yaml_emitter_reset(emitter: &mut yaml_emitter_t) {
pub fn yaml_emitter_reset(emitter: &mut Emitter) {
*emitter = yaml_emitter_new();
}
/// Set a string output.
///
/// The emitter will write the output characters to the `output` buffer.
pub fn yaml_emitter_set_output_string<'w>(
emitter: &mut yaml_emitter_t<'w>,
output: &'w mut Vec<u8>,
) {
pub fn yaml_emitter_set_output_string<'w>(emitter: &mut Emitter<'w>, output: &'w mut Vec<u8>) {
assert!(emitter.write_handler.is_none());
if emitter.encoding == YAML_ANY_ENCODING {
yaml_emitter_set_encoding(emitter, YAML_UTF8_ENCODING);
@ -130,58 +123,55 @@ pub fn yaml_emitter_set_output_string<'w>(
}
/// Set a generic output handler.
pub fn yaml_emitter_set_output<'w>(
emitter: &mut yaml_emitter_t<'w>,
handler: &'w mut dyn std::io::Write,
) {
pub fn yaml_emitter_set_output<'w>(emitter: &mut Emitter<'w>, handler: &'w mut dyn std::io::Write) {
assert!(emitter.write_handler.is_none());
emitter.write_handler = Some(handler);
}
/// Set the output encoding.
pub fn yaml_emitter_set_encoding(emitter: &mut yaml_emitter_t, encoding: yaml_encoding_t) {
pub fn yaml_emitter_set_encoding(emitter: &mut Emitter, encoding: Encoding) {
assert_eq!(emitter.encoding, YAML_ANY_ENCODING);
emitter.encoding = encoding;
}
/// Set if the output should be in the "canonical" format as in the YAML
/// specification.
pub fn yaml_emitter_set_canonical(emitter: &mut yaml_emitter_t, canonical: bool) {
pub fn yaml_emitter_set_canonical(emitter: &mut Emitter, canonical: bool) {
emitter.canonical = canonical;
}
/// Set the indentation increment.
pub fn yaml_emitter_set_indent(emitter: &mut yaml_emitter_t, indent: i32) {
pub fn yaml_emitter_set_indent(emitter: &mut Emitter, indent: i32) {
emitter.best_indent = if 1 < indent && indent < 10 { indent } else { 2 };
}
/// Set the preferred line width. -1 means unlimited.
pub fn yaml_emitter_set_width(emitter: &mut yaml_emitter_t, width: i32) {
pub fn yaml_emitter_set_width(emitter: &mut Emitter, width: i32) {
emitter.best_width = if width >= 0 { width } else { -1 };
}
/// Set if unescaped non-ASCII characters are allowed.
pub fn yaml_emitter_set_unicode(emitter: &mut yaml_emitter_t, unicode: bool) {
pub fn yaml_emitter_set_unicode(emitter: &mut Emitter, unicode: bool) {
emitter.unicode = unicode;
}
/// Set the preferred line break.
pub fn yaml_emitter_set_break(emitter: &mut yaml_emitter_t, line_break: yaml_break_t) {
pub fn yaml_emitter_set_break(emitter: &mut Emitter, line_break: Break) {
emitter.line_break = line_break;
}
/// Create the STREAM-START event.
pub fn yaml_stream_start_event_new(encoding: yaml_encoding_t) -> yaml_event_t {
yaml_event_t {
data: YamlEventData::StreamStart { encoding },
pub fn yaml_stream_start_event_new(encoding: Encoding) -> Event {
Event {
data: EventData::StreamStart { encoding },
..Default::default()
}
}
/// Create the STREAM-END event.
pub fn yaml_stream_end_event_new() -> yaml_event_t {
yaml_event_t {
data: YamlEventData::StreamEnd,
pub fn yaml_stream_end_event_new() -> Event {
Event {
data: EventData::StreamEnd,
..Default::default()
}
}
@ -191,14 +181,14 @@ pub fn yaml_stream_end_event_new() -> yaml_event_t {
/// The `implicit` argument is considered as a stylistic parameter and may be
/// ignored by the emitter.
pub fn yaml_document_start_event_new(
version_directive: Option<yaml_version_directive_t>,
tag_directives_in: &[yaml_tag_directive_t],
version_directive: Option<VersionDirective>,
tag_directives_in: &[TagDirective],
implicit: bool,
) -> yaml_event_t {
) -> Event {
let tag_directives = Vec::from_iter(tag_directives_in.iter().cloned());
yaml_event_t {
data: YamlEventData::DocumentStart {
Event {
data: EventData::DocumentStart {
version_directive,
tag_directives,
implicit,
@ -211,17 +201,17 @@ pub fn yaml_document_start_event_new(
///
/// The `implicit` argument is considered as a stylistic parameter and may be
/// ignored by the emitter.
pub fn yaml_document_end_event_new(implicit: bool) -> yaml_event_t {
yaml_event_t {
data: YamlEventData::DocumentEnd { implicit },
pub fn yaml_document_end_event_new(implicit: bool) -> Event {
Event {
data: EventData::DocumentEnd { implicit },
..Default::default()
}
}
/// Create an ALIAS event.
pub fn yaml_alias_event_new(anchor: &str) -> yaml_event_t {
yaml_event_t {
data: YamlEventData::Alias {
pub fn yaml_alias_event_new(anchor: &str) -> Event {
Event {
data: EventData::Alias {
anchor: String::from(anchor),
},
..Default::default()
@ -241,9 +231,9 @@ pub fn yaml_scalar_event_new(
value: &str,
plain_implicit: bool,
quoted_implicit: bool,
style: yaml_scalar_style_t,
) -> yaml_event_t {
let mark = yaml_mark_t {
style: ScalarStyle,
) -> Event {
let mark = Mark {
index: 0_u64,
line: 0_u64,
column: 0_u64,
@ -258,8 +248,8 @@ pub fn yaml_scalar_event_new(
tag_copy = Some(String::from(tag));
}
yaml_event_t {
data: YamlEventData::Scalar {
Event {
data: EventData::Scalar {
anchor: anchor_copy,
tag: tag_copy,
value: String::from(value),
@ -281,8 +271,8 @@ pub fn yaml_sequence_start_event_new(
anchor: Option<&str>,
tag: Option<&str>,
implicit: bool,
style: yaml_sequence_style_t,
) -> yaml_event_t {
style: SequenceStyle,
) -> Event {
let mut anchor_copy: Option<String> = None;
let mut tag_copy: Option<String> = None;
@ -293,8 +283,8 @@ pub fn yaml_sequence_start_event_new(
tag_copy = Some(String::from(tag));
}
yaml_event_t {
data: YamlEventData::SequenceStart {
Event {
data: EventData::SequenceStart {
anchor: anchor_copy,
tag: tag_copy,
implicit,
@ -305,9 +295,9 @@ pub fn yaml_sequence_start_event_new(
}
/// Create a SEQUENCE-END event.
pub fn yaml_sequence_end_event_new() -> yaml_event_t {
yaml_event_t {
data: YamlEventData::SequenceEnd,
pub fn yaml_sequence_end_event_new() -> Event {
Event {
data: EventData::SequenceEnd,
..Default::default()
}
}
@ -321,8 +311,8 @@ pub fn yaml_mapping_start_event_new(
anchor: Option<&str>,
tag: Option<&str>,
implicit: bool,
style: yaml_mapping_style_t,
) -> yaml_event_t {
style: MappingStyle,
) -> Event {
let mut anchor_copy: Option<String> = None;
let mut tag_copy: Option<String> = None;
@ -334,8 +324,8 @@ pub fn yaml_mapping_start_event_new(
tag_copy = Some(String::from(tag));
}
yaml_event_t {
data: YamlEventData::MappingStart {
Event {
data: EventData::MappingStart {
anchor: anchor_copy,
tag: tag_copy,
implicit,
@ -346,36 +336,36 @@ pub fn yaml_mapping_start_event_new(
}
/// Create a MAPPING-END event.
pub fn yaml_mapping_end_event_new() -> yaml_event_t {
yaml_event_t {
data: YamlEventData::MappingEnd,
pub fn yaml_mapping_end_event_new() -> Event {
Event {
data: EventData::MappingEnd,
..Default::default()
}
}
/// Create a YAML document.
pub fn yaml_document_new(
version_directive: Option<yaml_version_directive_t>,
tag_directives_in: &[yaml_tag_directive_t],
version_directive: Option<VersionDirective>,
tag_directives_in: &[TagDirective],
start_implicit: bool,
end_implicit: bool,
) -> yaml_document_t {
) -> Document {
let nodes = Vec::with_capacity(16);
let tag_directives = Vec::from_iter(tag_directives_in.iter().cloned());
yaml_document_t {
Document {
nodes,
version_directive,
tag_directives,
start_implicit,
end_implicit,
start_mark: yaml_mark_t::default(),
end_mark: yaml_mark_t::default(),
start_mark: Mark::default(),
end_mark: Mark::default(),
}
}
/// Delete a YAML document and all its nodes.
pub fn yaml_document_delete(document: &mut yaml_document_t) {
pub fn yaml_document_delete(document: &mut Document) {
document.nodes.clear();
document.version_directive = None;
document.tag_directives.clear();
@ -384,10 +374,7 @@ pub fn yaml_document_delete(document: &mut yaml_document_t) {
/// Get a node of a YAML document.
///
/// Returns the node object or `None` if `index` is out of range.
pub fn yaml_document_get_node(
document: &mut yaml_document_t,
index: i32,
) -> Option<&mut yaml_node_t> {
pub fn yaml_document_get_node(document: &mut Document, index: i32) -> Option<&mut Node> {
document.nodes.get_mut(index as usize - 1)
}
@ -398,7 +385,7 @@ pub fn yaml_document_get_node(
/// An empty document produced by the parser signifies the end of a YAML stream.
///
/// Returns the node object or `None` if the document is empty.
pub fn yaml_document_get_root_node(document: &mut yaml_document_t) -> Option<&mut yaml_node_t> {
pub fn yaml_document_get_root_node(document: &mut Document) -> Option<&mut Node> {
document.nodes.get_mut(0)
}
@ -409,12 +396,12 @@ pub fn yaml_document_get_root_node(document: &mut yaml_document_t) -> Option<&mu
/// Returns the node id or 0 on error.
#[must_use]
pub fn yaml_document_add_scalar(
document: &mut yaml_document_t,
document: &mut Document,
tag: Option<&str>,
value: &str,
style: yaml_scalar_style_t,
style: ScalarStyle,
) -> i32 {
let mark = yaml_mark_t {
let mark = Mark {
index: 0_u64,
line: 0_u64,
column: 0_u64,
@ -422,8 +409,8 @@ pub fn yaml_document_add_scalar(
let tag = tag.unwrap_or(YAML_DEFAULT_SCALAR_TAG);
let tag_copy = String::from(tag);
let value_copy = String::from(value);
let node = yaml_node_t {
data: YamlNodeData::Scalar {
let node = Node {
data: NodeData::Scalar {
value: value_copy,
style,
},
@ -442,11 +429,11 @@ pub fn yaml_document_add_scalar(
/// Returns the node id, which is a nonzero integer.
#[must_use]
pub fn yaml_document_add_sequence(
document: &mut yaml_document_t,
document: &mut Document,
tag: Option<&str>,
style: yaml_sequence_style_t,
style: SequenceStyle,
) -> i32 {
let mark = yaml_mark_t {
let mark = Mark {
index: 0_u64,
line: 0_u64,
column: 0_u64,
@ -455,8 +442,8 @@ pub fn yaml_document_add_sequence(
let items = Vec::with_capacity(16);
let tag = tag.unwrap_or(YAML_DEFAULT_SEQUENCE_TAG);
let tag_copy = String::from(tag);
let node = yaml_node_t {
data: YamlNodeData::Sequence { items, style },
let node = Node {
data: NodeData::Sequence { items, style },
tag: Some(tag_copy),
start_mark: mark,
end_mark: mark,
@ -472,11 +459,11 @@ pub fn yaml_document_add_sequence(
/// Returns the node id, which is a nonzero integer.
#[must_use]
pub fn yaml_document_add_mapping(
document: &mut yaml_document_t,
document: &mut Document,
tag: Option<&str>,
style: yaml_mapping_style_t,
style: MappingStyle,
) -> i32 {
let mark = yaml_mark_t {
let mark = Mark {
index: 0_u64,
line: 0_u64,
column: 0_u64,
@ -485,8 +472,8 @@ pub fn yaml_document_add_mapping(
let tag = tag.unwrap_or(YAML_DEFAULT_MAPPING_TAG);
let tag_copy = String::from(tag);
let node = yaml_node_t {
data: YamlNodeData::Mapping { pairs, style },
let node = Node {
data: NodeData::Mapping { pairs, style },
tag: Some(tag_copy),
start_mark: mark,
end_mark: mark,
@ -497,18 +484,14 @@ pub fn yaml_document_add_mapping(
}
/// Add an item to a SEQUENCE node.
pub fn yaml_document_append_sequence_item(
document: &mut yaml_document_t,
sequence: i32,
item: i32,
) {
pub fn yaml_document_append_sequence_item(document: &mut Document, sequence: i32, item: i32) {
assert!(sequence > 0 && sequence as usize - 1 < document.nodes.len());
assert!(matches!(
&document.nodes[sequence as usize - 1].data,
YamlNodeData::Sequence { .. }
NodeData::Sequence { .. }
));
assert!(item > 0 && item as usize - 1 < document.nodes.len());
if let YamlNodeData::Sequence { ref mut items, .. } =
if let NodeData::Sequence { ref mut items, .. } =
&mut document.nodes[sequence as usize - 1].data
{
items.push(item);
@ -517,7 +500,7 @@ pub fn yaml_document_append_sequence_item(
/// Add a pair of a key and a value to a MAPPING node.
pub fn yaml_document_append_mapping_pair(
document: &mut yaml_document_t,
document: &mut Document,
mapping: i32,
key: i32,
value: i32,
@ -525,13 +508,12 @@ pub fn yaml_document_append_mapping_pair(
assert!(mapping > 0 && mapping as usize - 1 < document.nodes.len());
assert!(matches!(
&document.nodes[mapping as usize - 1].data,
YamlNodeData::Mapping { .. }
NodeData::Mapping { .. }
));
assert!(key > 0 && key as usize - 1 < document.nodes.len());
assert!(value > 0 && value as usize - 1 < document.nodes.len());
let pair = yaml_node_pair_t { key, value };
if let YamlNodeData::Mapping { ref mut pairs, .. } =
&mut document.nodes[mapping as usize - 1].data
let pair = NodePair { key, value };
if let NodeData::Mapping { ref mut pairs, .. } = &mut document.nodes[mapping as usize - 1].data
{
pairs.push(pair);
}

13
src/bin/run-emitter-test-suite.rs
View file

@ -18,12 +18,11 @@ use libyaml_safer::{
yaml_alias_event_new, yaml_document_end_event_new, yaml_document_start_event_new,
yaml_emitter_emit, yaml_emitter_new, yaml_emitter_reset, yaml_emitter_set_canonical,
yaml_emitter_set_output, yaml_emitter_set_unicode, yaml_mapping_end_event_new,
yaml_mapping_start_event_new, yaml_scalar_event_new, yaml_scalar_style_t,
yaml_sequence_end_event_new, yaml_sequence_start_event_new, yaml_stream_end_event_new,
yaml_stream_start_event_new, YAML_ANY_SCALAR_STYLE, YAML_BLOCK_MAPPING_STYLE,
YAML_BLOCK_SEQUENCE_STYLE, YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_FOLDED_SCALAR_STYLE,
YAML_LITERAL_SCALAR_STYLE, YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE,
YAML_UTF8_ENCODING,
yaml_mapping_start_event_new, yaml_scalar_event_new, yaml_sequence_end_event_new,
yaml_sequence_start_event_new, yaml_stream_end_event_new, yaml_stream_start_event_new,
ScalarStyle, YAML_ANY_SCALAR_STYLE, YAML_BLOCK_MAPPING_STYLE, YAML_BLOCK_SEQUENCE_STYLE,
YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE,
YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE, YAML_UTF8_ENCODING,
};
use std::env;
use std::error::Error;
@ -125,7 +124,7 @@ fn get_tag(line: &str) -> Option<&str> {
Some(until_angle_close)
}
fn get_value<'a>(line: &str, buffer: &'a mut String, style: &mut yaml_scalar_style_t) -> &'a str {
fn get_value<'a>(line: &str, buffer: &'a mut String, style: &mut ScalarStyle) -> &'a str {
let mut remainder = line;
let value = loop {
let Some((_before, tail)) = remainder.split_once(' ') else {

24
src/bin/run-parser-test-suite.rs
View file

@ -12,7 +12,7 @@
)]
use libyaml_safer::{
yaml_parser_new, yaml_parser_parse, yaml_parser_reset, yaml_parser_set_input, YamlEventData,
yaml_parser_new, yaml_parser_parse, yaml_parser_reset, yaml_parser_set_input, EventData,
YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE,
YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE,
};
@ -45,34 +45,34 @@ pub(crate) fn test_main(
let mut is_end = false;
match &event.data {
YamlEventData::NoEvent => {
EventData::NoEvent => {
_ = writeln!(stdout, "???");
}
YamlEventData::StreamStart { .. } => {
EventData::StreamStart { .. } => {
_ = writeln!(stdout, "+STR");
}
YamlEventData::StreamEnd => {
EventData::StreamEnd => {
is_end = true;
_ = writeln!(stdout, "-STR");
}
YamlEventData::DocumentStart { implicit, .. } => {
EventData::DocumentStart { implicit, .. } => {
_ = write!(stdout, "+DOC");
if !*implicit {
_ = write!(stdout, " ---");
}
_ = writeln!(stdout);
}
YamlEventData::DocumentEnd { implicit } => {
EventData::DocumentEnd { implicit } => {
_ = write!(stdout, "-DOC");
if !*implicit {
_ = write!(stdout, " ...");
}
_ = writeln!(stdout);
}
YamlEventData::Alias { anchor } => {
EventData::Alias { anchor } => {
_ = writeln!(stdout, "=ALI *{anchor}");
}
YamlEventData::Scalar {
EventData::Scalar {
anchor,
tag,
value,
@ -97,7 +97,7 @@ pub(crate) fn test_main(
print_escaped(stdout, value);
_ = writeln!(stdout);
}
YamlEventData::SequenceStart { anchor, tag, .. } => {
EventData::SequenceStart { anchor, tag, .. } => {
let _ = write!(stdout, "+SEQ");
if let Some(anchor) = anchor {
_ = write!(stdout, " &{anchor}");
@ -107,10 +107,10 @@ pub(crate) fn test_main(
}
_ = writeln!(stdout);
}
YamlEventData::SequenceEnd => {
EventData::SequenceEnd => {
_ = writeln!(stdout, "-SEQ");
}
YamlEventData::MappingStart { anchor, tag, .. } => {
EventData::MappingStart { anchor, tag, .. } => {
let _ = write!(stdout, "+MAP");
if let Some(anchor) = anchor {
_ = write!(stdout, " &{anchor}");
@ -120,7 +120,7 @@ pub(crate) fn test_main(
}
_ = writeln!(stdout);
}
YamlEventData::MappingEnd => {
EventData::MappingEnd => {
_ = writeln!(stdout, "-MAP");
}
}

104
src/dumper.rs
View file

@ -4,8 +4,7 @@ use alloc::string::String;
use alloc::vec;
use crate::yaml::{
yaml_anchors_t, yaml_document_t, yaml_emitter_t, yaml_event_t, yaml_node_t, YamlEventData,
YamlNodeData, YAML_ANY_ENCODING,
Anchors, Document, Emitter, Event, EventData, Node, NodeData, YAML_ANY_ENCODING,
};
use crate::{
yaml_emitter_emit, EmitterError, YAML_DEFAULT_MAPPING_TAG, YAML_DEFAULT_SCALAR_TAG,
@ -15,10 +14,10 @@ use crate::{
/// Start a YAML stream.
///
/// This function should be used before yaml_emitter_dump() is called.
pub fn yaml_emitter_open(emitter: &mut yaml_emitter_t) -> Result<(), EmitterError> {
pub fn yaml_emitter_open(emitter: &mut Emitter) -> Result<(), EmitterError> {
assert!(!emitter.opened);
let event = yaml_event_t {
data: YamlEventData::StreamStart {
let event = Event {
data: EventData::StreamStart {
encoding: YAML_ANY_ENCODING,
},
..Default::default()
@ -31,13 +30,13 @@ pub fn yaml_emitter_open(emitter: &mut yaml_emitter_t) -> Result<(), EmitterErro
/// Finish a YAML stream.
///
/// This function should be used after yaml_emitter_dump() is called.
pub fn yaml_emitter_close(emitter: &mut yaml_emitter_t) -> Result<(), EmitterError> {
pub fn yaml_emitter_close(emitter: &mut Emitter) -> Result<(), EmitterError> {
assert!(emitter.opened);
if emitter.closed {
return Ok(());
}
let event = yaml_event_t {
data: YamlEventData::StreamEnd,
let event = Event {
data: EventData::StreamEnd,
..Default::default()
};
yaml_emitter_emit(emitter, event)?;
@ -50,8 +49,8 @@ pub fn yaml_emitter_close(emitter: &mut yaml_emitter_t) -> Result<(), EmitterErr
/// The document object may be generated using the yaml_parser_load() function
/// or the yaml_document_new() function.
pub fn yaml_emitter_dump(
emitter: &mut yaml_emitter_t,
mut document: yaml_document_t,
emitter: &mut Emitter,
mut document: Document,
) -> Result<(), EmitterError> {
if !emitter.opened {
if let Err(err) = yaml_emitter_open(emitter) {
@ -63,9 +62,9 @@ pub fn yaml_emitter_dump(
yaml_emitter_close(emitter)?;
} else {
assert!(emitter.opened);
emitter.anchors = vec![yaml_anchors_t::default(); document.nodes.len()];
let event = yaml_event_t {
data: YamlEventData::DocumentStart {
emitter.anchors = vec![Anchors::default(); document.nodes.len()];
let event = Event {
data: EventData::DocumentStart {
version_directive: document.version_directive,
tag_directives: take(&mut document.tag_directives),
implicit: document.start_implicit,
@ -75,8 +74,8 @@ pub fn yaml_emitter_dump(
yaml_emitter_emit(emitter, event)?;
yaml_emitter_anchor_node(emitter, &document, 1);
yaml_emitter_dump_node(emitter, &mut document, 1)?;
let event = yaml_event_t {
data: YamlEventData::DocumentEnd {
let event = Event {
data: EventData::DocumentEnd {
implicit: document.end_implicit,
},
..Default::default()
@ -88,12 +87,12 @@ pub fn yaml_emitter_dump(
Ok(())
}
fn yaml_emitter_reset_anchors(emitter: &mut yaml_emitter_t) {
fn yaml_emitter_reset_anchors(emitter: &mut Emitter) {
emitter.anchors.clear();
emitter.last_anchor_id = 0;
}
fn yaml_emitter_anchor_node_sub(emitter: &mut yaml_emitter_t, index: i32) {
fn yaml_emitter_anchor_node_sub(emitter: &mut Emitter, index: i32) {
emitter.anchors[index as usize - 1].references += 1;
if emitter.anchors[index as usize - 1].references == 2 {
emitter.last_anchor_id += 1;
@ -101,17 +100,17 @@ fn yaml_emitter_anchor_node_sub(emitter: &mut yaml_emitter_t, index: i32) {
}
}
fn yaml_emitter_anchor_node(emitter: &mut yaml_emitter_t, document: &yaml_document_t, index: i32) {
fn yaml_emitter_anchor_node(emitter: &mut Emitter, document: &Document, index: i32) {
let node = &document.nodes[index as usize - 1];
emitter.anchors[index as usize - 1].references += 1;
if emitter.anchors[index as usize - 1].references == 1 {
match &node.data {
YamlNodeData::Sequence { items, .. } => {
NodeData::Sequence { items, .. } => {
for item in items {
yaml_emitter_anchor_node_sub(emitter, *item);
}
}
YamlNodeData::Mapping { pairs, .. } => {
NodeData::Mapping { pairs, .. } => {
for pair in pairs {
yaml_emitter_anchor_node_sub(emitter, pair.key);
yaml_emitter_anchor_node_sub(emitter, pair.value);
@ -125,13 +124,13 @@ fn yaml_emitter_anchor_node(emitter: &mut yaml_emitter_t, document: &yaml_docume
}
}
fn yaml_emitter_generate_anchor(_emitter: &mut yaml_emitter_t, anchor_id: i32) -> String {
fn yaml_emitter_generate_anchor(_emitter: &mut Emitter, anchor_id: i32) -> String {
alloc::format!("id{anchor_id:03}")
}
fn yaml_emitter_dump_node(
emitter: &mut yaml_emitter_t,
document: &mut yaml_document_t,
emitter: &mut Emitter,
document: &mut Document,
index: i32,
) -> Result<(), EmitterError> {
let node = &mut document.nodes[index as usize - 1];
@ -147,37 +146,32 @@ fn yaml_emitter_dump_node(
let node = take(node);
match node.data {
YamlNodeData::Scalar { .. } => yaml_emitter_dump_scalar(emitter, node, anchor),
YamlNodeData::Sequence { .. } => {
yaml_emitter_dump_sequence(emitter, document, node, anchor)
}
YamlNodeData::Mapping { .. } => yaml_emitter_dump_mapping(emitter, document, node, anchor),
NodeData::Scalar { .. } => yaml_emitter_dump_scalar(emitter, node, anchor),
NodeData::Sequence { .. } => yaml_emitter_dump_sequence(emitter, document, node, anchor),
NodeData::Mapping { .. } => yaml_emitter_dump_mapping(emitter, document, node, anchor),
_ => unreachable!("document node is neither a scalar, sequence, or a mapping"),
}
}
fn yaml_emitter_dump_alias(
emitter: &mut yaml_emitter_t,
anchor: String,
) -> Result<(), EmitterError> {
let event = yaml_event_t {
data: YamlEventData::Alias { anchor },
fn yaml_emitter_dump_alias(emitter: &mut Emitter, anchor: String) -> Result<(), EmitterError> {
let event = Event {
data: EventData::Alias { anchor },
..Default::default()
};
yaml_emitter_emit(emitter, event)
}
fn yaml_emitter_dump_scalar(
emitter: &mut yaml_emitter_t,
node: yaml_node_t,
emitter: &mut Emitter,
node: Node,
anchor: Option<String>,
) -> Result<(), EmitterError> {
let plain_implicit = node.tag.as_deref() == Some(YAML_DEFAULT_SCALAR_TAG);
let quoted_implicit = node.tag.as_deref() == Some(YAML_DEFAULT_SCALAR_TAG); // TODO: Why compare twice?! (even the C code does this)
if let YamlNodeData::Scalar { value, style } = node.data {
let event = yaml_event_t {
data: YamlEventData::Scalar {
if let NodeData::Scalar { value, style } = node.data {
let event = Event {
data: EventData::Scalar {
anchor,
tag: node.tag,
value,
@ -194,16 +188,16 @@ fn yaml_emitter_dump_scalar(
}
fn yaml_emitter_dump_sequence(
emitter: &mut yaml_emitter_t,
document: &mut yaml_document_t,
node: yaml_node_t,
emitter: &mut Emitter,
document: &mut Document,
node: Node,
anchor: Option<String>,
) -> Result<(), EmitterError> {
let implicit = node.tag.as_deref() == Some(YAML_DEFAULT_SEQUENCE_TAG);
if let YamlNodeData::Sequence { items, style } = node.data {
let event = yaml_event_t {
data: YamlEventData::SequenceStart {
if let NodeData::Sequence { items, style } = node.data {
let event = Event {
data: EventData::SequenceStart {
anchor,
tag: node.tag,
implicit,
@ -216,8 +210,8 @@ fn yaml_emitter_dump_sequence(
for item in items {
yaml_emitter_dump_node(emitter, document, item)?;
}
let event = yaml_event_t {
data: YamlEventData::SequenceEnd,
let event = Event {
data: EventData::SequenceEnd,
..Default::default()
};
yaml_emitter_emit(emitter, event)
@ -227,16 +221,16 @@ fn yaml_emitter_dump_sequence(
}
fn yaml_emitter_dump_mapping(
emitter: &mut yaml_emitter_t,
document: &mut yaml_document_t,
node: yaml_node_t,
emitter: &mut Emitter,
document: &mut Document,
node: Node,
anchor: Option<String>,
) -> Result<(), EmitterError> {
let implicit = node.tag.as_deref() == Some(YAML_DEFAULT_MAPPING_TAG);
if let YamlNodeData::Mapping { pairs, style } = node.data {
let event = yaml_event_t {
data: YamlEventData::MappingStart {
if let NodeData::Mapping { pairs, style } = node.data {
let event = Event {
data: EventData::MappingStart {
anchor,
tag: node.tag,
implicit,
@ -250,8 +244,8 @@ fn yaml_emitter_dump_mapping(
yaml_emitter_dump_node(emitter, document, pair.key)?;
yaml_emitter_dump_node(emitter, document, pair.value)?;
}
let event = yaml_event_t {
data: YamlEventData::MappingEnd,
let event = Event {
data: EventData::MappingEnd,
..Default::default()
};
yaml_emitter_emit(emitter, event)

282
src/emitter.rs
View file

@ -4,25 +4,24 @@ use crate::api::OUTPUT_BUFFER_SIZE;
use crate::macros::{
is_alpha, is_ascii, is_blank, is_blankz, is_bom, is_break, is_breakz, is_printable, is_space,
};
use crate::yaml::YamlEventData;
use crate::yaml::EventData;
use crate::{
yaml_emitter_flush, yaml_emitter_t, yaml_event_t, yaml_scalar_style_t, yaml_tag_directive_t,
yaml_version_directive_t, EmitterError, WriterError, YAML_ANY_BREAK, YAML_ANY_ENCODING,
YAML_ANY_SCALAR_STYLE, YAML_CRLN_BREAK, YAML_CR_BREAK, YAML_DOUBLE_QUOTED_SCALAR_STYLE,
YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE, YAML_EMIT_BLOCK_MAPPING_KEY_STATE,
YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE, YAML_EMIT_BLOCK_MAPPING_VALUE_STATE,
YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE, YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
YAML_EMIT_DOCUMENT_CONTENT_STATE, YAML_EMIT_DOCUMENT_END_STATE, YAML_EMIT_DOCUMENT_START_STATE,
YAML_EMIT_END_STATE, YAML_EMIT_FIRST_DOCUMENT_START_STATE,
YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE, YAML_EMIT_FLOW_MAPPING_KEY_STATE,
YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE, YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
YAML_EMIT_STREAM_START_STATE, YAML_FLOW_MAPPING_STYLE, YAML_FLOW_SEQUENCE_STYLE,
YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE, YAML_LN_BREAK, YAML_PLAIN_SCALAR_STYLE,
YAML_SINGLE_QUOTED_SCALAR_STYLE, YAML_UTF8_ENCODING,
yaml_emitter_flush, Emitter, EmitterError, Event, ScalarStyle, TagDirective, VersionDirective,
WriterError, YAML_ANY_BREAK, YAML_ANY_ENCODING, YAML_ANY_SCALAR_STYLE, YAML_CRLN_BREAK,
YAML_CR_BREAK, YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
YAML_EMIT_BLOCK_MAPPING_KEY_STATE, YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
YAML_EMIT_BLOCK_MAPPING_VALUE_STATE, YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE, YAML_EMIT_DOCUMENT_CONTENT_STATE,
YAML_EMIT_DOCUMENT_END_STATE, YAML_EMIT_DOCUMENT_START_STATE, YAML_EMIT_END_STATE,
YAML_EMIT_FIRST_DOCUMENT_START_STATE, YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
YAML_EMIT_FLOW_MAPPING_KEY_STATE, YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,
YAML_EMIT_FLOW_MAPPING_VALUE_STATE, YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE, YAML_EMIT_STREAM_START_STATE, YAML_FLOW_MAPPING_STYLE,
YAML_FLOW_SEQUENCE_STYLE, YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE, YAML_LN_BREAK,
YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE, YAML_UTF8_ENCODING,
};
fn FLUSH(emitter: &mut yaml_emitter_t) -> Result<(), WriterError> {
fn FLUSH(emitter: &mut Emitter) -> Result<(), WriterError> {
if emitter.buffer.len() < OUTPUT_BUFFER_SIZE - 5 {
Ok(())
} else {
@ -30,7 +29,7 @@ fn FLUSH(emitter: &mut yaml_emitter_t) -> Result<(), WriterError> {
}
}
fn PUT(emitter: &mut yaml_emitter_t, value: u8) -> Result<(), WriterError> {
fn PUT(emitter: &mut Emitter, value: u8) -> Result<(), WriterError> {
FLUSH(emitter)?;
let ch = char::try_from(value).expect("invalid char");
emitter.buffer.push(ch);
@ -38,7 +37,7 @@ fn PUT(emitter: &mut yaml_emitter_t, value: u8) -> Result<(), WriterError> {
Ok(())
}
fn PUT_BREAK(emitter: &mut yaml_emitter_t) -> Result<(), WriterError> {
fn PUT_BREAK(emitter: &mut Emitter) -> Result<(), WriterError> {
FLUSH(emitter)?;
if emitter.line_break == YAML_CR_BREAK {
emitter.buffer.push('\r');
@ -54,21 +53,21 @@ fn PUT_BREAK(emitter: &mut yaml_emitter_t) -> Result<(), WriterError> {
/// Write UTF-8 charanters from `string` to `emitter` and increment
/// `emitter.column` the appropriate number of times.
fn WRITE_STR(emitter: &mut yaml_emitter_t, string: &str) -> Result<(), WriterError> {
fn WRITE_STR(emitter: &mut Emitter, string: &str) -> Result<(), WriterError> {
for ch in string.chars() {
WRITE_CHAR(emitter, ch)?;
}
Ok(())
}
fn WRITE_CHAR(emitter: &mut yaml_emitter_t, ch: char) -> Result<(), WriterError> {
fn WRITE_CHAR(emitter: &mut Emitter, ch: char) -> Result<(), WriterError> {
FLUSH(emitter)?;
emitter.buffer.push(ch);
emitter.column += 1;
Ok(())
}
fn WRITE_BREAK_CHAR(emitter: &mut yaml_emitter_t, ch: char) -> Result<(), WriterError> {
fn WRITE_BREAK_CHAR(emitter: &mut Emitter, ch: char) -> Result<(), WriterError> {
FLUSH(emitter)?;
if ch == '\n' {
_ = PUT_BREAK(emitter);
@ -111,11 +110,11 @@ struct ScalarAnalysis<'a> {
/// Can the scalar be expressed in the literal or folded styles?
pub block_allowed: bool,
/// The output style.
pub style: yaml_scalar_style_t,
pub style: ScalarStyle,
}
fn yaml_emitter_set_emitter_error<T>(
_emitter: &mut yaml_emitter_t,
_emitter: &mut Emitter,
problem: &'static str,
) -> Result<T, EmitterError> {
Err(EmitterError::Problem(problem))
@ -127,10 +126,7 @@ fn yaml_emitter_set_emitter_error<T>(
/// The emitter takes the responsibility for the event object and destroys its
/// content after it is emitted. The event object is destroyed even if the
/// function fails.
pub fn yaml_emitter_emit(
emitter: &mut yaml_emitter_t,
event: yaml_event_t,
) -> Result<(), EmitterError> {
pub fn yaml_emitter_emit(emitter: &mut Emitter, event: Event) -> Result<(), EmitterError> {
emitter.events.push_back(event);
while let Some(event) = yaml_emitter_needs_mode_events(emitter) {
let tag_directives = core::mem::take(&mut emitter.tag_directives);
@ -147,13 +143,13 @@ pub fn yaml_emitter_emit(
Ok(())
}
fn yaml_emitter_needs_mode_events(emitter: &mut yaml_emitter_t) -> Option<yaml_event_t> {
fn yaml_emitter_needs_mode_events(emitter: &mut Emitter) -> Option<Event> {
let first = emitter.events.front()?;
let accummulate = match &first.data {
YamlEventData::DocumentStart { .. } => 1,
YamlEventData::SequenceStart { .. } => 2,
YamlEventData::MappingStart { .. } => 3,
EventData::DocumentStart { .. } => 1,
EventData::SequenceStart { .. } => 2,
EventData::MappingStart { .. } => 3,
_ => return emitter.events.pop_front(),
};
@ -164,17 +160,17 @@ fn yaml_emitter_needs_mode_events(emitter: &mut yaml_emitter_t) -> Option<yaml_e
let mut level = 0;
for event in &emitter.events {
match event.data {
YamlEventData::StreamStart { .. }
| YamlEventData::DocumentStart { .. }
| YamlEventData::SequenceStart { .. }
| YamlEventData::MappingStart { .. } => {
EventData::StreamStart { .. }
| EventData::DocumentStart { .. }
| EventData::SequenceStart { .. }
| EventData::MappingStart { .. } => {
level += 1;
}
YamlEventData::StreamEnd
| YamlEventData::DocumentEnd { .. }
| YamlEventData::SequenceEnd
| YamlEventData::MappingEnd => {
EventData::StreamEnd
| EventData::DocumentEnd { .. }
| EventData::SequenceEnd
| EventData::MappingEnd => {
level -= 1;
}
_ => {}
@ -189,8 +185,8 @@ fn yaml_emitter_needs_mode_events(emitter: &mut yaml_emitter_t) -> Option<yaml_e
}
fn yaml_emitter_append_tag_directive(
emitter: &mut yaml_emitter_t,
value: &yaml_tag_directive_t,
emitter: &mut Emitter,
value: &TagDirective,
allow_duplicates: bool,
) -> Result<(), EmitterError> {
for tag_directive in &emitter.tag_directives {
@ -205,7 +201,7 @@ fn yaml_emitter_append_tag_directive(
Ok(())
}
fn yaml_emitter_increase_indent(emitter: &mut yaml_emitter_t, flow: bool, indentless: bool) {
fn yaml_emitter_increase_indent(emitter: &mut Emitter, flow: bool, indentless: bool) {
emitter.indents.push(emitter.indent);
if emitter.indent < 0 {
emitter.indent = if flow { emitter.best_indent } else { 0 };
@ -215,8 +211,8 @@ fn yaml_emitter_increase_indent(emitter: &mut yaml_emitter_t, flow: bool, indent
}
fn yaml_emitter_state_machine(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
match emitter.state {
@ -272,11 +268,11 @@ fn yaml_emitter_state_machine(
}
fn yaml_emitter_emit_stream_start(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
) -> Result<(), EmitterError> {
emitter.open_ended = 0;
if let YamlEventData::StreamStart { ref encoding } = event.data {
if let EventData::StreamStart { ref encoding } = event.data {
if emitter.encoding == YAML_ANY_ENCODING {
emitter.encoding = *encoding;
}
@ -310,11 +306,11 @@ fn yaml_emitter_emit_stream_start(
}
fn yaml_emitter_emit_document_start(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
first: bool,
) -> Result<(), EmitterError> {
if let YamlEventData::DocumentStart {
if let EventData::DocumentStart {
version_directive,
tag_directives,
implicit,
@ -323,13 +319,13 @@ fn yaml_emitter_emit_document_start(
let (version_directive, tag_directives, implicit) =
(*version_directive, tag_directives, *implicit);
let default_tag_directives: [yaml_tag_directive_t; 2] = [
let default_tag_directives: [TagDirective; 2] = [
// TODO: Avoid these heap allocations.
yaml_tag_directive_t {
TagDirective {
handle: String::from("!"),
prefix: String::from("!"),
},
yaml_tag_directive_t {
TagDirective {
handle: String::from("!!"),
prefix: String::from("tag:yaml.org,2002:"),
},
@ -385,7 +381,7 @@ fn yaml_emitter_emit_document_start(
emitter.state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
emitter.open_ended = 0;
return Ok(());
} else if let YamlEventData::StreamEnd = &event.data {
} else if let EventData::StreamEnd = &event.data {
if emitter.open_ended == 2 {
yaml_emitter_write_indicator(emitter, "...", true, false, false)?;
emitter.open_ended = 0;
@ -400,8 +396,8 @@ fn yaml_emitter_emit_document_start(
}
fn yaml_emitter_emit_document_content(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
emitter.states.push(YAML_EMIT_DOCUMENT_END_STATE);
@ -409,10 +405,10 @@ fn yaml_emitter_emit_document_content(
}
fn yaml_emitter_emit_document_end(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
) -> Result<(), EmitterError> {
if let YamlEventData::DocumentEnd { implicit } = &event.data {
if let EventData::DocumentEnd { implicit } = &event.data {
let implicit = *implicit;
yaml_emitter_write_indent(emitter)?;
if !implicit {
@ -432,8 +428,8 @@ fn yaml_emitter_emit_document_end(
}
fn yaml_emitter_emit_flow_sequence_item(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
first: bool,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
@ -442,7 +438,7 @@ fn yaml_emitter_emit_flow_sequence_item(
yaml_emitter_increase_indent(emitter, true, false);
emitter.flow_level += 1;
}
if let YamlEventData::SequenceEnd = &event.data {
if let EventData::SequenceEnd = &event.data {
emitter.flow_level -= 1;
emitter.indent = emitter.indents.pop().unwrap();
if emitter.canonical && !first {
@ -464,8 +460,8 @@ fn yaml_emitter_emit_flow_sequence_item(
}
fn yaml_emitter_emit_flow_mapping_key(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
first: bool,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
@ -474,7 +470,7 @@ fn yaml_emitter_emit_flow_mapping_key(
yaml_emitter_increase_indent(emitter, true, false);
emitter.flow_level += 1;
}
if let YamlEventData::MappingEnd = &event.data {
if let EventData::MappingEnd = &event.data {
assert!(
!emitter.indents.is_empty(),
"emitter.indents should not be empty"
@ -508,8 +504,8 @@ fn yaml_emitter_emit_flow_mapping_key(
}
fn yaml_emitter_emit_flow_mapping_value(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
simple: bool,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
@ -526,8 +522,8 @@ fn yaml_emitter_emit_flow_mapping_value(
}
fn yaml_emitter_emit_block_sequence_item(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
first: bool,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
@ -538,7 +534,7 @@ fn yaml_emitter_emit_block_sequence_item(
emitter.mapping_context && !emitter.indention,
);
}
if let YamlEventData::SequenceEnd = &event.data {
if let EventData::SequenceEnd = &event.data {
emitter.indent = emitter.indents.pop().unwrap();
emitter.state = emitter.states.pop().unwrap();
return Ok(());
@ -550,15 +546,15 @@ fn yaml_emitter_emit_block_sequence_item(
}
fn yaml_emitter_emit_block_mapping_key(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
first: bool,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
if first {
yaml_emitter_increase_indent(emitter, false, false);
}
if let YamlEventData::MappingEnd = &event.data {
if let EventData::MappingEnd = &event.data {
emitter.indent = emitter.indents.pop().unwrap();
emitter.state = emitter.states.pop().unwrap();
return Ok(());
@ -577,8 +573,8 @@ fn yaml_emitter_emit_block_mapping_key(
}
fn yaml_emitter_emit_block_mapping_value(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
simple: bool,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
@ -593,8 +589,8 @@ fn yaml_emitter_emit_block_mapping_value(
}
fn yaml_emitter_emit_node(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
root: bool,
sequence: bool,
mapping: bool,
@ -607,14 +603,12 @@ fn yaml_emitter_emit_node(
emitter.simple_key_context = simple_key;
match event.data {
YamlEventData::Alias { .. } => yaml_emitter_emit_alias(emitter, event, &analysis.anchor),
YamlEventData::Scalar { .. } => yaml_emitter_emit_scalar(emitter, event, analysis),
YamlEventData::SequenceStart { .. } => {
EventData::Alias { .. } => yaml_emitter_emit_alias(emitter, event, &analysis.anchor),
EventData::Scalar { .. } => yaml_emitter_emit_scalar(emitter, event, analysis),
EventData::SequenceStart { .. } => {
yaml_emitter_emit_sequence_start(emitter, event, analysis)
}
YamlEventData::MappingStart { .. } => {
yaml_emitter_emit_mapping_start(emitter, event, analysis)
}
EventData::MappingStart { .. } => yaml_emitter_emit_mapping_start(emitter, event, analysis),
_ => yaml_emitter_set_emitter_error(
emitter,
"expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS",
@ -623,8 +617,8 @@ fn yaml_emitter_emit_node(
}
fn yaml_emitter_emit_alias(
emitter: &mut yaml_emitter_t,
_event: &yaml_event_t,
emitter: &mut Emitter,
_event: &Event,
analysis: &Option<AnchorAnalysis>,
) -> Result<(), EmitterError> {
yaml_emitter_process_anchor(emitter, analysis)?;
@ -636,8 +630,8 @@ fn yaml_emitter_emit_alias(
}
fn yaml_emitter_emit_scalar(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
analysis: &mut Analysis,
) -> Result<(), EmitterError> {
let Analysis {
@ -660,15 +654,15 @@ fn yaml_emitter_emit_scalar(
}
fn yaml_emitter_emit_sequence_start(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
analysis: &Analysis,
) -> Result<(), EmitterError> {
let Analysis { anchor, tag, .. } = analysis;
yaml_emitter_process_anchor(emitter, anchor)?;
yaml_emitter_process_tag(emitter, tag)?;
let style = if let YamlEventData::SequenceStart { style, .. } = &event.data {
let style = if let EventData::SequenceStart { style, .. } = &event.data {
*style
} else {
unreachable!()
@ -687,15 +681,15 @@ fn yaml_emitter_emit_sequence_start(
}
fn yaml_emitter_emit_mapping_start(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
analysis: &Analysis,
) -> Result<(), EmitterError> {
let Analysis { anchor, tag, .. } = analysis;
yaml_emitter_process_anchor(emitter, anchor)?;
yaml_emitter_process_tag(emitter, tag)?;
let style = if let YamlEventData::MappingStart { style, .. } = &event.data {
let style = if let EventData::MappingStart { style, .. } = &event.data {
*style
} else {
unreachable!()
@ -713,33 +707,29 @@ fn yaml_emitter_emit_mapping_start(
Ok(())
}
fn yaml_emitter_check_empty_document(_emitter: &yaml_emitter_t) -> bool {
fn yaml_emitter_check_empty_document(_emitter: &Emitter) -> bool {
false
}
fn yaml_emitter_check_empty_sequence(emitter: &yaml_emitter_t, event: &yaml_event_t) -> bool {
fn yaml_emitter_check_empty_sequence(emitter: &Emitter, event: &Event) -> bool {
if emitter.events.is_empty() {
return false;
}
let start = matches!(event.data, YamlEventData::SequenceStart { .. });
let end = matches!(emitter.events[0].data, YamlEventData::SequenceEnd);
let start = matches!(event.data, EventData::SequenceStart { .. });
let end = matches!(emitter.events[0].data, EventData::SequenceEnd);
start && end
}
fn yaml_emitter_check_empty_mapping(emitter: &yaml_emitter_t, event: &yaml_event_t) -> bool {
fn yaml_emitter_check_empty_mapping(emitter: &Emitter, event: &Event) -> bool {
if emitter.events.is_empty() {
return false;
}
let start = matches!(event.data, YamlEventData::MappingStart { .. });
let end = matches!(emitter.events[0].data, YamlEventData::MappingEnd);
let start = matches!(event.data, EventData::MappingStart { .. });
let end = matches!(emitter.events[0].data, EventData::MappingEnd);
start && end
}
fn yaml_emitter_check_simple_key(
emitter: &yaml_emitter_t,
event: &yaml_event_t,
analysis: &Analysis,
) -> bool {
fn yaml_emitter_check_simple_key(emitter: &Emitter, event: &Event, analysis: &Analysis) -> bool {
let Analysis {
tag,
anchor,
@ -750,10 +740,10 @@ fn yaml_emitter_check_simple_key(
+ tag.as_ref().map_or(0, |t| t.handle.len() + t.suffix.len());
match event.data {
YamlEventData::Alias { .. } => {
EventData::Alias { .. } => {
length = analysis.anchor.as_ref().map_or(0, |a| a.anchor.len());
}
YamlEventData::Scalar { .. } => {
EventData::Scalar { .. } => {
let Some(scalar) = scalar else {
panic!("no analysis for scalar")
};
@ -763,12 +753,12 @@ fn yaml_emitter_check_simple_key(
}
length += scalar.value.len();
}
YamlEventData::SequenceStart { .. } => {
EventData::SequenceStart { .. } => {
if !yaml_emitter_check_empty_sequence(emitter, event) {
return false;
}
}
YamlEventData::MappingStart { .. } => {
EventData::MappingStart { .. } => {
if !yaml_emitter_check_empty_mapping(emitter, event) {
return false;
}
@ -784,19 +774,19 @@ fn yaml_emitter_check_simple_key(
}
fn yaml_emitter_select_scalar_style(
emitter: &mut yaml_emitter_t,
event: &yaml_event_t,
emitter: &mut Emitter,
event: &Event,
scalar_analysis: &mut ScalarAnalysis,
tag_analysis: &mut Option<TagAnalysis>,
) -> Result<(), EmitterError> {
if let YamlEventData::Scalar {
if let EventData::Scalar {
plain_implicit,
quoted_implicit,
style,
..
} = &event.data
{
let mut style: yaml_scalar_style_t = *style;
let mut style: ScalarStyle = *style;
let no_tag = tag_analysis.is_none();
if no_tag && !*plain_implicit && !*quoted_implicit {
yaml_emitter_set_emitter_error(
@ -855,7 +845,7 @@ fn yaml_emitter_select_scalar_style(
}
fn yaml_emitter_process_anchor(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
analysis: &Option<AnchorAnalysis>,
) -> Result<(), EmitterError> {
let Some(analysis) = analysis.as_ref() else {
@ -872,7 +862,7 @@ fn yaml_emitter_process_anchor(
}
fn yaml_emitter_process_tag(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
analysis: &Option<TagAnalysis>,
) -> Result<(), EmitterError> {
let Some(analysis) = analysis.as_ref() else {
@ -896,7 +886,7 @@ fn yaml_emitter_process_tag(
}
fn yaml_emitter_process_scalar(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
analysis: &ScalarAnalysis,
) -> Result<(), EmitterError> {
match analysis.style {
@ -920,8 +910,8 @@ fn yaml_emitter_process_scalar(
}
fn yaml_emitter_analyze_version_directive(
emitter: &mut yaml_emitter_t,
version_directive: yaml_version_directive_t,
emitter: &mut Emitter,
version_directive: VersionDirective,
) -> Result<(), EmitterError> {
if version_directive.major != 1 || version_directive.minor != 1 && version_directive.minor != 2
{
@ -931,8 +921,8 @@ fn yaml_emitter_analyze_version_directive(
}
fn yaml_emitter_analyze_tag_directive(
emitter: &mut yaml_emitter_t,
tag_directive: &yaml_tag_directive_t,
emitter: &mut Emitter,
tag_directive: &TagDirective,
) -> Result<(), EmitterError> {
if tag_directive.handle.is_empty() {
return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty");
@ -963,7 +953,7 @@ fn yaml_emitter_analyze_tag_directive(
}
fn yaml_emitter_analyze_anchor<'a>(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
anchor: &'a str,
alias: bool,
) -> Result<AnchorAnalysis<'a>, EmitterError> {
@ -995,9 +985,9 @@ fn yaml_emitter_analyze_anchor<'a>(
}
fn yaml_emitter_analyze_tag<'a>(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
tag: &'a str,
tag_directives: &'a [yaml_tag_directive_t],
tag_directives: &'a [TagDirective],
) -> Result<TagAnalysis<'a>, EmitterError> {
if tag.is_empty() {
yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")?;
@ -1019,7 +1009,7 @@ fn yaml_emitter_analyze_tag<'a>(
}
fn yaml_emitter_analyze_scalar<'a>(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
value: &'a str,
) -> Result<ScalarAnalysis<'a>, EmitterError> {
let mut block_indicators = false;
@ -1185,17 +1175,17 @@ fn yaml_emitter_analyze_scalar<'a>(
}
fn yaml_emitter_analyze_event<'a>(
emitter: &mut yaml_emitter_t,
event: &'a yaml_event_t,
tag_directives: &'a [yaml_tag_directive_t],
emitter: &mut Emitter,
event: &'a Event,
tag_directives: &'a [TagDirective],
) -> Result<Analysis<'a>, EmitterError> {
let mut analysis = Analysis::default();
match &event.data {
YamlEventData::Alias { anchor } => {
EventData::Alias { anchor } => {
analysis.anchor = Some(yaml_emitter_analyze_anchor(emitter, anchor, true)?);
}
YamlEventData::Scalar {
EventData::Scalar {
anchor,
tag,
value,
@ -1216,7 +1206,7 @@ fn yaml_emitter_analyze_event<'a>(
}
analysis.scalar = Some(yaml_emitter_analyze_scalar(emitter, value)?);
}
YamlEventData::SequenceStart {
EventData::SequenceStart {
anchor,
tag,
implicit,
@ -1233,7 +1223,7 @@ fn yaml_emitter_analyze_event<'a>(
)?);
}
}
YamlEventData::MappingStart {
EventData::MappingStart {
anchor,
tag,
implicit,
@ -1256,13 +1246,13 @@ fn yaml_emitter_analyze_event<'a>(
Ok(analysis)
}
fn yaml_emitter_write_bom(emitter: &mut yaml_emitter_t) -> Result<(), EmitterError> {
fn yaml_emitter_write_bom(emitter: &mut Emitter) -> Result<(), EmitterError> {
FLUSH(emitter)?;
emitter.buffer.push('\u{feff}');
Ok(())
}
fn yaml_emitter_write_indent(emitter: &mut yaml_emitter_t) -> Result<(), EmitterError> {
fn yaml_emitter_write_indent(emitter: &mut Emitter) -> Result<(), EmitterError> {
let indent = if emitter.indent >= 0 {
emitter.indent
} else {
@ -1283,7 +1273,7 @@ fn yaml_emitter_write_indent(emitter: &mut yaml_emitter_t) -> Result<(), Emitter
}
fn yaml_emitter_write_indicator(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
indicator: &str,
need_whitespace: bool,
is_whitespace: bool,
@ -1298,20 +1288,14 @@ fn yaml_emitter_write_indicator(
Ok(())
}
fn yaml_emitter_write_anchor(
emitter: &mut yaml_emitter_t,
value: &str,
) -> Result<(), EmitterError> {
fn yaml_emitter_write_anchor(emitter: &mut Emitter, value: &str) -> Result<(), EmitterError> {
WRITE_STR(emitter, value)?;
emitter.whitespace = false;
emitter.indention = false;
Ok(())
}
fn yaml_emitter_write_tag_handle(
emitter: &mut yaml_emitter_t,
value: &str,
) -> Result<(), EmitterError> {
fn yaml_emitter_write_tag_handle(emitter: &mut Emitter, value: &str) -> Result<(), EmitterError> {
if !emitter.whitespace {
PUT(emitter, b' ')?;
}
@ -1322,7 +1306,7 @@ fn yaml_emitter_write_tag_handle(
}
fn yaml_emitter_write_tag_content(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
value: &str,
need_whitespace: bool,
) -> Result<(), EmitterError> {
@ -1363,7 +1347,7 @@ fn yaml_emitter_write_tag_content(
}
fn yaml_emitter_write_plain_scalar(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
value: &str,
allow_breaks: bool,
) -> Result<(), EmitterError> {
@ -1407,7 +1391,7 @@ fn yaml_emitter_write_plain_scalar(
}
fn yaml_emitter_write_single_quoted_scalar(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
value: &str,
allow_breaks: bool,
) -> Result<(), EmitterError> {
@ -1465,7 +1449,7 @@ fn yaml_emitter_write_single_quoted_scalar(
}
fn yaml_emitter_write_double_quoted_scalar(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
value: &str,
allow_breaks: bool,
) -> Result<(), EmitterError> {
@ -1583,7 +1567,7 @@ fn yaml_emitter_write_double_quoted_scalar(
}
fn yaml_emitter_write_block_scalar_hints(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
string: &str,
) -> Result<(), EmitterError> {
let mut chomp_hint: Option<&str> = None;
@ -1621,7 +1605,7 @@ fn yaml_emitter_write_block_scalar_hints(
}
fn yaml_emitter_write_literal_scalar(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
value: &str,
) -> Result<(), EmitterError> {
let mut breaks = true;
@ -1649,7 +1633,7 @@ fn yaml_emitter_write_literal_scalar(
}
fn yaml_emitter_write_folded_scalar(
emitter: &mut yaml_emitter_t,
emitter: &mut Emitter,
value: &str,
) -> Result<(), EmitterError> {
let mut breaks = true;

24
src/error.rs
View file

@ -1,4 +1,4 @@
use crate::yaml_mark_t;
use crate::Mark;
#[derive(Debug, thiserror::Error)]
pub enum EmitterError {
@ -37,9 +37,9 @@ pub enum ScannerError {
#[error("{}:{}: {} {} ({}:{})", problem_mark.line, problem_mark.column, problem, context, context_mark.line, context_mark.column)]
Problem {
context: &'static str,
context_mark: yaml_mark_t,
context_mark: Mark,
problem: &'static str,
problem_mark: yaml_mark_t,
problem_mark: Mark,
},
#[error(transparent)]
Reader(#[from] ReaderError),
@ -50,16 +50,13 @@ pub enum ParserError {
#[error("no more tokens")]
UnexpectedEof,
#[error("{}:{}: {}", mark.line, mark.column, problem)]
Problem {
problem: &'static str,
mark: yaml_mark_t,
},
Problem { problem: &'static str, mark: Mark },
#[error("{}:{}: {} {} ({}:{})", mark.line, mark.column, problem, context, context_mark.line, context_mark.column)]
ProblemWithContext {
context: &'static str,
context_mark: yaml_mark_t,
context_mark: Mark,
problem: &'static str,
mark: yaml_mark_t,
mark: Mark,
},
#[error(transparent)]
Scanner(#[from] ScannerError),
@ -68,16 +65,13 @@ pub enum ParserError {
#[derive(Debug, thiserror::Error)]
pub enum ComposerError {
#[error("{}:{}: {}", mark.line, mark.column, problem)]
Problem {
problem: &'static str,
mark: yaml_mark_t,
},
Problem { problem: &'static str, mark: Mark },
#[error("{}:{}: {} {} ({}:{})", mark.line, mark.column, problem, context, context_mark.line, context_mark.column)]
ProblemWithContext {
context: &'static str,
context_mark: yaml_mark_t,
context_mark: Mark,
problem: &'static str,
mark: yaml_mark_t,
mark: Mark,
},
#[error(transparent)]
Parser(#[from] ParserError),

17
src/lib.rs
View file

@ -71,19 +71,16 @@ pub use crate::parser::yaml_parser_parse;
pub use crate::scanner::yaml_parser_scan;
pub use crate::writer::yaml_emitter_flush;
pub use crate::yaml::{
yaml_alias_data_t, yaml_break_t, yaml_document_t, yaml_emitter_state_t, yaml_emitter_t,
yaml_encoding_t, yaml_event_t, yaml_mapping_style_t, yaml_mark_t, yaml_node_item_t,
yaml_node_pair_t, yaml_node_t, yaml_parser_state_t, yaml_parser_t, yaml_scalar_style_t,
yaml_sequence_style_t, yaml_simple_key_t, yaml_tag_directive_t, yaml_token_t,
yaml_token_type_t, yaml_version_directive_t, YamlEventData,
AliasData, Break, Document, Emitter, EmitterState, Encoding, Event, EventData, MappingStyle,
Mark, Node, NodeItem, NodePair, Parser, ParserState, ScalarStyle, SequenceStyle, SimpleKey,
TagDirective, Token, VersionDirective,
};
#[doc(hidden)]
pub use crate::yaml::{
yaml_break_t::*, yaml_emitter_state_t::*, yaml_encoding_t::*, yaml_mapping_style_t::*,
yaml_parser_state_t::*, yaml_scalar_style_t::*, yaml_sequence_style_t::*, yaml_token_type_t::*,
YAML_BOOL_TAG, YAML_DEFAULT_MAPPING_TAG, YAML_DEFAULT_SCALAR_TAG, YAML_DEFAULT_SEQUENCE_TAG,
YAML_FLOAT_TAG, YAML_INT_TAG, YAML_MAP_TAG, YAML_NULL_TAG, YAML_SEQ_TAG, YAML_STR_TAG,
YAML_TIMESTAMP_TAG,
Break::*, EmitterState::*, Encoding::*, MappingStyle::*, ParserState::*, ScalarStyle::*,
SequenceStyle::*, YAML_BOOL_TAG, YAML_DEFAULT_MAPPING_TAG, YAML_DEFAULT_SCALAR_TAG,
YAML_DEFAULT_SEQUENCE_TAG, YAML_FLOAT_TAG, YAML_INT_TAG, YAML_MAP_TAG, YAML_NULL_TAG,
YAML_SEQ_TAG, YAML_STR_TAG, YAML_TIMESTAMP_TAG,
};
#[cfg(test)]

133
src/loader.rs
View file

@ -1,11 +1,10 @@
use alloc::string::String;
use alloc::{vec, vec::Vec};
use crate::yaml::{YamlEventData, YamlNodeData};
use crate::yaml::{EventData, NodeData};
use crate::{
yaml_alias_data_t, yaml_document_new, yaml_document_t, yaml_event_t, yaml_mark_t,
yaml_node_pair_t, yaml_node_t, yaml_parser_parse, yaml_parser_t, ComposerError,
YAML_DEFAULT_MAPPING_TAG, YAML_DEFAULT_SCALAR_TAG, YAML_DEFAULT_SEQUENCE_TAG,
yaml_document_new, yaml_parser_parse, AliasData, ComposerError, Document, Event, Mark, Node,
NodePair, Parser, YAML_DEFAULT_MAPPING_TAG, YAML_DEFAULT_SCALAR_TAG, YAML_DEFAULT_SEQUENCE_TAG,
};
/// Parse the input stream and produce the next YAML document.
@ -19,14 +18,14 @@ use crate::{
/// An application must not alternate the calls of yaml_parser_load() with the
/// calls of yaml_parser_scan() or yaml_parser_parse(). Doing this will break
/// the parser.
pub fn yaml_parser_load(parser: &mut yaml_parser_t) -> Result<yaml_document_t, ComposerError> {
pub fn yaml_parser_load(parser: &mut Parser) -> Result<Document, ComposerError> {
let mut document = yaml_document_new(None, &[], false, false);
document.nodes.reserve(16);
if !parser.stream_start_produced {
match yaml_parser_parse(parser) {
Ok(yaml_event_t {
data: YamlEventData::StreamStart { .. },
Ok(Event {
data: EventData::StreamStart { .. },
..
}) => (),
Ok(_) => panic!("expected stream start"),
@ -42,7 +41,7 @@ pub fn yaml_parser_load(parser: &mut yaml_parser_t) -> Result<yaml_document_t, C
let err: ComposerError;
match yaml_parser_parse(parser) {
Ok(event) => {
if let YamlEventData::StreamEnd = &event.data {
if let EventData::StreamEnd = &event.data {
return Ok(document);
}
parser.aliases.reserve(16);
@ -62,7 +61,7 @@ pub fn yaml_parser_load(parser: &mut yaml_parser_t) -> Result<yaml_document_t, C
fn yaml_parser_set_composer_error<T>(
problem: &'static str,
problem_mark: yaml_mark_t,
problem_mark: Mark,
) -> Result<T, ComposerError> {
Err(ComposerError::Problem {
problem,
@ -72,9 +71,9 @@ fn yaml_parser_set_composer_error<T>(
fn yaml_parser_set_composer_error_context<T>(
context: &'static str,
context_mark: yaml_mark_t,
context_mark: Mark,
problem: &'static str,
problem_mark: yaml_mark_t,
problem_mark: Mark,
) -> Result<T, ComposerError> {
Err(ComposerError::ProblemWithContext {
context,
@ -84,17 +83,17 @@ fn yaml_parser_set_composer_error_context<T>(
})
}
fn yaml_parser_delete_aliases(parser: &mut yaml_parser_t) {
fn yaml_parser_delete_aliases(parser: &mut Parser) {
parser.aliases.clear();
}
fn yaml_parser_load_document(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
parser: &mut Parser,
event: Event,
document: &mut Document,
) -> Result<(), ComposerError> {
let mut ctx = vec![];
if let YamlEventData::DocumentStart {
if let EventData::DocumentStart {
version_directive,
tag_directives,
implicit,
@ -117,8 +116,8 @@ fn yaml_parser_load_document(
}
fn yaml_parser_load_nodes(
parser: &mut yaml_parser_t,
document: &mut yaml_document_t,
parser: &mut Parser,
document: &mut Document,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let end_implicit;
@ -127,31 +126,31 @@ fn yaml_parser_load_nodes(
loop {
let event = yaml_parser_parse(parser)?;
match event.data {
YamlEventData::NoEvent => panic!("empty event"),
YamlEventData::StreamStart { .. } => panic!("unexpected stream start event"),
YamlEventData::StreamEnd => panic!("unexpected stream end event"),
YamlEventData::DocumentStart { .. } => panic!("unexpected document start event"),
YamlEventData::DocumentEnd { implicit } => {
EventData::NoEvent => panic!("empty event"),
EventData::StreamStart { .. } => panic!("unexpected stream start event"),
EventData::StreamEnd => panic!("unexpected stream end event"),
EventData::DocumentStart { .. } => panic!("unexpected document start event"),
EventData::DocumentEnd { implicit } => {
end_implicit = implicit;
end_mark = event.end_mark;
break;
}
YamlEventData::Alias { .. } => {
EventData::Alias { .. } => {
yaml_parser_load_alias(parser, event, document, ctx)?;
}
YamlEventData::Scalar { .. } => {
EventData::Scalar { .. } => {
yaml_parser_load_scalar(parser, event, document, ctx)?;
}
YamlEventData::SequenceStart { .. } => {
EventData::SequenceStart { .. } => {
yaml_parser_load_sequence(parser, event, document, ctx)?;
}
YamlEventData::SequenceEnd => {
EventData::SequenceEnd => {
yaml_parser_load_sequence_end(parser, event, document, ctx)?;
}
YamlEventData::MappingStart { .. } => {
EventData::MappingStart { .. } => {
yaml_parser_load_mapping(parser, event, document, ctx)?;
}
YamlEventData::MappingEnd => {
EventData::MappingEnd => {
yaml_parser_load_mapping_end(parser, event, document, ctx)?;
}
}
@ -162,15 +161,15 @@ fn yaml_parser_load_nodes(
}
fn yaml_parser_register_anchor(
parser: &mut yaml_parser_t,
document: &mut yaml_document_t,
parser: &mut Parser,
document: &mut Document,
index: i32,
anchor: Option<String>,
) -> Result<(), ComposerError> {
let Some(anchor) = anchor else {
return Ok(());
};
let data = yaml_alias_data_t {
let data = AliasData {
anchor,
index,
mark: document.nodes[index as usize - 1].start_mark,
@ -190,7 +189,7 @@ fn yaml_parser_register_anchor(
}
fn yaml_parser_load_node_add(
document: &mut yaml_document_t,
document: &mut Document,
ctx: &mut Vec<i32>,
index: i32,
) -> Result<(), ComposerError> {
@ -200,14 +199,14 @@ fn yaml_parser_load_node_add(
let parent_index: i32 = *ctx.last().unwrap();
let parent = &mut document.nodes[parent_index as usize - 1];
match parent.data {
YamlNodeData::Sequence { ref mut items, .. } => {
NodeData::Sequence { ref mut items, .. } => {
items.push(index);
}
YamlNodeData::Mapping { ref mut pairs, .. } => {
let mut pair = yaml_node_pair_t::default();
NodeData::Mapping { ref mut pairs, .. } => {
let mut pair = NodePair::default();
let mut do_push = true;
if !pairs.is_empty() {
let p: &mut yaml_node_pair_t = pairs.last_mut().unwrap();
let p: &mut NodePair = pairs.last_mut().unwrap();
if p.key != 0 && p.value == 0 {
p.value = index;
do_push = false;
@ -227,12 +226,12 @@ fn yaml_parser_load_node_add(
}
fn yaml_parser_load_alias(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
parser: &mut Parser,
event: Event,
document: &mut Document,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let anchor: &str = if let YamlEventData::Alias { anchor } = &event.data {
let anchor: &str = if let EventData::Alias { anchor } = &event.data {
anchor
} else {
unreachable!()
@ -248,12 +247,12 @@ fn yaml_parser_load_alias(
}
fn yaml_parser_load_scalar(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
parser: &mut Parser,
event: Event,
document: &mut Document,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let YamlEventData::Scalar {
let EventData::Scalar {
mut tag,
value,
style,
@ -267,8 +266,8 @@ fn yaml_parser_load_scalar(
if tag.is_none() || tag.as_deref() == Some("!") {
tag = Some(String::from(YAML_DEFAULT_SCALAR_TAG));
}
let node = yaml_node_t {
data: YamlNodeData::Scalar { value, style },
let node = Node {
data: NodeData::Scalar { value, style },
tag,
start_mark: event.start_mark,
end_mark: event.end_mark,
@ -280,12 +279,12 @@ fn yaml_parser_load_scalar(
}
fn yaml_parser_load_sequence(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
parser: &mut Parser,
event: Event,
document: &mut Document,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let YamlEventData::SequenceStart {
let EventData::SequenceStart {
anchor,
mut tag,
style,
@ -301,8 +300,8 @@ fn yaml_parser_load_sequence(
tag = Some(String::from(YAML_DEFAULT_SEQUENCE_TAG));
}
let node = yaml_node_t {
data: YamlNodeData::Sequence {
let node = Node {
data: NodeData::Sequence {
items: core::mem::take(&mut items),
style,
},
@ -320,16 +319,16 @@ fn yaml_parser_load_sequence(
}
fn yaml_parser_load_sequence_end(
_parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
_parser: &mut Parser,
event: Event,
document: &mut Document,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
assert!(!ctx.is_empty());
let index: i32 = *ctx.last().unwrap();
assert!(matches!(
document.nodes[index as usize - 1].data,
YamlNodeData::Sequence { .. }
NodeData::Sequence { .. }
));
document.nodes[index as usize - 1].end_mark = event.end_mark;
_ = ctx.pop();
@ -337,12 +336,12 @@ fn yaml_parser_load_sequence_end(
}
fn yaml_parser_load_mapping(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
parser: &mut Parser,
event: Event,
document: &mut Document,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let YamlEventData::MappingStart {
let EventData::MappingStart {
anchor,
mut tag,
style,
@ -357,8 +356,8 @@ fn yaml_parser_load_mapping(
if tag.is_none() || tag.as_deref() == Some("!") {
tag = Some(String::from(YAML_DEFAULT_MAPPING_TAG));
}
let node = yaml_node_t {
data: YamlNodeData::Mapping {
let node = Node {
data: NodeData::Mapping {
pairs: core::mem::take(&mut pairs),
style,
},
@ -375,16 +374,16 @@ fn yaml_parser_load_mapping(
}
fn yaml_parser_load_mapping_end(
_parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
_parser: &mut Parser,
event: Event,
document: &mut Document,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
assert!(!ctx.is_empty());
let index: i32 = *ctx.last().unwrap();
assert!(matches!(
document.nodes[index as usize - 1].data,
YamlNodeData::Mapping { .. }
NodeData::Mapping { .. }
));
document.nodes[index as usize - 1].end_mark = event.end_mark;
_ = ctx.pop();

262
src/parser.rs
View file

@ -2,11 +2,11 @@ use alloc::string::String;
use alloc::{vec, vec::Vec};
use crate::scanner::yaml_parser_fetch_more_tokens;
use crate::yaml::{YamlEventData, YamlTokenData};
use crate::yaml::{EventData, TokenData};
use crate::{
yaml_event_t, yaml_mark_t, yaml_parser_t, yaml_tag_directive_t, yaml_token_t,
yaml_version_directive_t, ParserError, YAML_BLOCK_MAPPING_STYLE, YAML_BLOCK_SEQUENCE_STYLE,
YAML_FLOW_MAPPING_STYLE, YAML_FLOW_SEQUENCE_STYLE, YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
Event, Mark, Parser, ParserError, TagDirective, Token, VersionDirective,
YAML_BLOCK_MAPPING_STYLE, YAML_BLOCK_SEQUENCE_STYLE, YAML_FLOW_MAPPING_STYLE,
YAML_FLOW_SEQUENCE_STYLE, YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
YAML_PARSE_BLOCK_MAPPING_KEY_STATE, YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE, YAML_PARSE_BLOCK_NODE_STATE,
YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE, YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
@ -22,7 +22,7 @@ use crate::{
YAML_PLAIN_SCALAR_STYLE,
};
fn PEEK_TOKEN<'a>(parser: &'a mut yaml_parser_t) -> Result<&'a yaml_token_t, ParserError> {
fn PEEK_TOKEN<'a>(parser: &'a mut Parser) -> Result<&'a Token, ParserError> {
if parser.token_available {
return Ok(parser
.tokens
@ -39,7 +39,7 @@ fn PEEK_TOKEN<'a>(parser: &'a mut yaml_parser_t) -> Result<&'a yaml_token_t, Par
.expect("token_available is true, but token queue is empty"))
}
fn PEEK_TOKEN_MUT<'a>(parser: &'a mut yaml_parser_t) -> Result<&'a mut yaml_token_t, ParserError> {
fn PEEK_TOKEN_MUT<'a>(parser: &'a mut Parser) -> Result<&'a mut Token, ParserError> {
if parser.token_available {
return Ok(parser
.tokens
@ -56,14 +56,14 @@ fn PEEK_TOKEN_MUT<'a>(parser: &'a mut yaml_parser_t) -> Result<&'a mut yaml_toke
.expect("token_available is true, but token queue is empty"))
}
fn SKIP_TOKEN(parser: &mut yaml_parser_t) {
fn SKIP_TOKEN(parser: &mut Parser) {
parser.token_available = false;
parser.tokens_parsed = parser.tokens_parsed.wrapping_add(1);
let skipped = parser.tokens.pop_front().expect("SKIP_TOKEN but EOF");
parser.stream_end_produced = matches!(
skipped,
yaml_token_t {
data: YamlTokenData::StreamEnd,
Token {
data: TokenData::StreamEnd,
..
}
);
@ -78,10 +78,10 @@ fn SKIP_TOKEN(parser: &mut yaml_parser_t) {
/// An application must not alternate the calls of yaml_parser_parse() with the
/// calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the
/// parser.
pub fn yaml_parser_parse(parser: &mut yaml_parser_t) -> Result<yaml_event_t, ParserError> {
pub fn yaml_parser_parse(parser: &mut Parser) -> Result<Event, ParserError> {
if parser.stream_end_produced || parser.state == YAML_PARSE_END_STATE {
return Ok(yaml_event_t {
data: YamlEventData::StreamEnd,
return Ok(Event {
data: EventData::StreamEnd,
..Default::default()
});
}
@ -90,7 +90,7 @@ pub fn yaml_parser_parse(parser: &mut yaml_parser_t) -> Result<yaml_event_t, Par
fn yaml_parser_set_parser_error<T>(
problem: &'static str,
problem_mark: yaml_mark_t,
problem_mark: Mark,
) -> Result<T, ParserError> {
Err(ParserError::Problem {
problem,
@ -100,9 +100,9 @@ fn yaml_parser_set_parser_error<T>(
fn yaml_parser_set_parser_error_context<T>(
context: &'static str,
context_mark: yaml_mark_t,
context_mark: Mark,
problem: &'static str,
problem_mark: yaml_mark_t,
problem_mark: Mark,
) -> Result<T, ParserError> {
Err(ParserError::ProblemWithContext {
context,
@ -112,7 +112,7 @@ fn yaml_parser_set_parser_error_context<T>(
})
}
fn yaml_parser_state_machine(parser: &mut yaml_parser_t) -> Result<yaml_event_t, ParserError> {
fn yaml_parser_state_machine(parser: &mut Parser) -> Result<Event, ParserError> {
match parser.state {
YAML_PARSE_STREAM_START_STATE => yaml_parser_parse_stream_start(parser),
YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE => yaml_parser_parse_document_start(parser, true),
@ -163,12 +163,12 @@ fn yaml_parser_state_machine(parser: &mut yaml_parser_t) -> Result<yaml_event_t,
}
}
fn yaml_parser_parse_stream_start(parser: &mut yaml_parser_t) -> Result<yaml_event_t, ParserError> {
fn yaml_parser_parse_stream_start(parser: &mut Parser) -> Result<Event, ParserError> {
let token = PEEK_TOKEN(parser)?;
if let YamlTokenData::StreamStart { encoding } = &token.data {
let event = yaml_event_t {
data: YamlEventData::StreamStart {
if let TokenData::StreamStart { encoding } = &token.data {
let event = Event {
data: EventData::StreamStart {
encoding: *encoding,
},
start_mark: token.start_mark,
@ -184,15 +184,15 @@ fn yaml_parser_parse_stream_start(parser: &mut yaml_parser_t) -> Result<yaml_eve
}
fn yaml_parser_parse_document_start(
parser: &mut yaml_parser_t,
parser: &mut Parser,
implicit: bool,
) -> Result<yaml_event_t, ParserError> {
let mut version_directive: Option<yaml_version_directive_t> = None;
) -> Result<Event, ParserError> {
let mut version_directive: Option<VersionDirective> = None;
let mut tag_directives = vec![];
let mut token = PEEK_TOKEN(parser)?;
if !implicit {
while let YamlTokenData::DocumentEnd = &token.data {
while let TokenData::DocumentEnd = &token.data {
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser)?;
}
@ -203,8 +203,8 @@ fn yaml_parser_parse_document_start(
&& !token.data.is_document_start()
&& !token.data.is_stream_end()
{
let event = yaml_event_t {
data: YamlEventData::DocumentStart {
let event = Event {
data: EventData::DocumentStart {
version_directive: None,
tag_directives: vec![],
implicit: true,
@ -217,8 +217,8 @@ fn yaml_parser_parse_document_start(
parser.state = YAML_PARSE_BLOCK_NODE_STATE;
Ok(event)
} else if !token.data.is_stream_end() {
let end_mark: yaml_mark_t;
let start_mark: yaml_mark_t = token.start_mark;
let end_mark: Mark;
let start_mark: Mark = token.start_mark;
yaml_parser_process_directives(
parser,
Some(&mut version_directive),
@ -232,8 +232,8 @@ fn yaml_parser_parse_document_start(
);
} else {
end_mark = token.end_mark;
let event = yaml_event_t {
data: YamlEventData::DocumentStart {
let event = Event {
data: EventData::DocumentStart {
version_directive,
tag_directives: core::mem::take(&mut tag_directives),
implicit: false,
@ -247,8 +247,8 @@ fn yaml_parser_parse_document_start(
return Ok(event);
}
} else {
let event = yaml_event_t {
data: YamlEventData::StreamEnd,
let event = Event {
data: EventData::StreamEnd,
start_mark: token.start_mark,
end_mark: token.end_mark,
};
@ -258,15 +258,13 @@ fn yaml_parser_parse_document_start(
}
}
fn yaml_parser_parse_document_content(
parser: &mut yaml_parser_t,
) -> Result<yaml_event_t, ParserError> {
fn yaml_parser_parse_document_content(parser: &mut Parser) -> Result<Event, ParserError> {
let token = PEEK_TOKEN(parser)?;
if let YamlTokenData::VersionDirective { .. }
| YamlTokenData::TagDirective { .. }
| YamlTokenData::DocumentStart
| YamlTokenData::DocumentEnd
| YamlTokenData::StreamEnd = &token.data
if let TokenData::VersionDirective { .. }
| TokenData::TagDirective { .. }
| TokenData::DocumentStart
| TokenData::DocumentEnd
| TokenData::StreamEnd = &token.data
{
let mark = token.start_mark;
parser.state = parser.states.pop().unwrap();
@ -276,38 +274,38 @@ fn yaml_parser_parse_document_content(
}
}
fn yaml_parser_parse_document_end(parser: &mut yaml_parser_t) -> Result<yaml_event_t, ParserError> {
let mut end_mark: yaml_mark_t;
fn yaml_parser_parse_document_end(parser: &mut Parser) -> Result<Event, ParserError> {
let mut end_mark: Mark;
let mut implicit = true;
let token = PEEK_TOKEN(parser)?;
end_mark = token.start_mark;
let start_mark: yaml_mark_t = end_mark;
if let YamlTokenData::DocumentEnd = &token.data {
let start_mark: Mark = end_mark;
if let TokenData::DocumentEnd = &token.data {
end_mark = token.end_mark;
SKIP_TOKEN(parser);
implicit = false;
}
parser.tag_directives.clear();
parser.state = YAML_PARSE_DOCUMENT_START_STATE;
Ok(yaml_event_t {
data: YamlEventData::DocumentEnd { implicit },
Ok(Event {
data: EventData::DocumentEnd { implicit },
start_mark,
end_mark,
})
}
fn yaml_parser_parse_node(
parser: &mut yaml_parser_t,
parser: &mut Parser,
block: bool,
indentless_sequence: bool,
) -> Result<yaml_event_t, ParserError> {
) -> Result<Event, ParserError> {
let mut anchor: Option<String> = None;
let mut tag_handle: Option<String> = None;
let mut tag_suffix: Option<String> = None;
let mut tag: Option<String> = None;
let mut start_mark: yaml_mark_t;
let mut end_mark: yaml_mark_t;
let mut tag_mark = yaml_mark_t {
let mut start_mark: Mark;
let mut end_mark: Mark;
let mut tag_mark = Mark {
index: 0,
line: 0,
column: 0,
@ -315,9 +313,9 @@ fn yaml_parser_parse_node(
let mut token = PEEK_TOKEN_MUT(parser)?;
if let YamlTokenData::Alias { value } = &mut token.data {
let event = yaml_event_t {
data: YamlEventData::Alias {
if let TokenData::Alias { value } = &mut token.data {
let event = Event {
data: EventData::Alias {
anchor: core::mem::take(value),
},
start_mark: token.start_mark,
@ -330,20 +328,20 @@ fn yaml_parser_parse_node(
end_mark = token.start_mark;
start_mark = end_mark;
if let YamlTokenData::Anchor { value } = &mut token.data {
if let TokenData::Anchor { value } = &mut token.data {
anchor = Some(core::mem::take(value));
start_mark = token.start_mark;
end_mark = token.end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN_MUT(parser)?;
if let YamlTokenData::Tag { handle, suffix } = &mut token.data {
if let TokenData::Tag { handle, suffix } = &mut token.data {
tag_handle = Some(core::mem::take(handle));
tag_suffix = Some(core::mem::take(suffix));
tag_mark = token.start_mark;
end_mark = token.end_mark;
SKIP_TOKEN(parser);
}
} else if let YamlTokenData::Tag { handle, suffix } = &mut token.data {
} else if let TokenData::Tag { handle, suffix } = &mut token.data {
tag_handle = Some(core::mem::take(handle));
tag_suffix = Some(core::mem::take(suffix));
tag_mark = token.start_mark;
@ -351,7 +349,7 @@ fn yaml_parser_parse_node(
end_mark = token.end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN_MUT(parser)?;
if let YamlTokenData::Anchor { value } = &mut token.data {
if let TokenData::Anchor { value } = &mut token.data {
anchor = Some(core::mem::take(value));
end_mark = token.end_mark;
SKIP_TOKEN(parser);
@ -387,8 +385,8 @@ fn yaml_parser_parse_node(
if indentless_sequence && token.data.is_block_entry() {
end_mark = token.end_mark;
parser.state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
let event = yaml_event_t {
data: YamlEventData::SequenceStart {
let event = Event {
data: EventData::SequenceStart {
anchor,
tag,
implicit,
@ -398,7 +396,7 @@ fn yaml_parser_parse_node(
end_mark,
};
Ok(event)
} else if let YamlTokenData::Scalar { value, style } = &mut token.data {
} else if let TokenData::Scalar { value, style } = &mut token.data {
let mut plain_implicit = false;
let mut quoted_implicit = false;
end_mark = token.end_mark;
@ -407,8 +405,8 @@ fn yaml_parser_parse_node(
} else if tag.is_none() {
quoted_implicit = true;
}
let event = yaml_event_t {
data: YamlEventData::Scalar {
let event = Event {
data: EventData::Scalar {
anchor,
tag,
value: core::mem::take(value),
@ -422,11 +420,11 @@ fn yaml_parser_parse_node(
parser.state = parser.states.pop().unwrap();
SKIP_TOKEN(parser);
return Ok(event);
} else if let YamlTokenData::FlowSequenceStart = &token.data {
} else if let TokenData::FlowSequenceStart = &token.data {
end_mark = token.end_mark;
parser.state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
let event = yaml_event_t {
data: YamlEventData::SequenceStart {
let event = Event {
data: EventData::SequenceStart {
anchor,
tag,
implicit,
@ -436,11 +434,11 @@ fn yaml_parser_parse_node(
end_mark,
};
return Ok(event);
} else if let YamlTokenData::FlowMappingStart = &token.data {
} else if let TokenData::FlowMappingStart = &token.data {
end_mark = token.end_mark;
parser.state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
let event = yaml_event_t {
data: YamlEventData::MappingStart {
let event = Event {
data: EventData::MappingStart {
anchor,
tag,
implicit,
@ -453,8 +451,8 @@ fn yaml_parser_parse_node(
} else if block && token.data.is_block_sequence_start() {
end_mark = token.end_mark;
parser.state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
let event = yaml_event_t {
data: YamlEventData::SequenceStart {
let event = Event {
data: EventData::SequenceStart {
anchor,
tag,
implicit,
@ -467,8 +465,8 @@ fn yaml_parser_parse_node(
} else if block && token.data.is_block_mapping_start() {
end_mark = token.end_mark;
parser.state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
let event = yaml_event_t {
data: YamlEventData::MappingStart {
let event = Event {
data: EventData::MappingStart {
anchor,
tag,
implicit,
@ -480,8 +478,8 @@ fn yaml_parser_parse_node(
return Ok(event);
} else if anchor.is_some() || tag.is_some() {
parser.state = parser.states.pop().unwrap();
let event = yaml_event_t {
data: YamlEventData::Scalar {
let event = Event {
data: EventData::Scalar {
anchor,
tag,
value: String::new(),
@ -508,9 +506,9 @@ fn yaml_parser_parse_node(
}
fn yaml_parser_parse_block_sequence_entry(
parser: &mut yaml_parser_t,
parser: &mut Parser,
first: bool,
) -> Result<yaml_event_t, ParserError> {
) -> Result<Event, ParserError> {
if first {
let token = PEEK_TOKEN(parser)?;
let mark = token.start_mark;
@ -520,8 +518,8 @@ fn yaml_parser_parse_block_sequence_entry(
let mut token = PEEK_TOKEN(parser)?;
if let YamlTokenData::BlockEntry = &token.data {
let mark: yaml_mark_t = token.end_mark;
if let TokenData::BlockEntry = &token.data {
let mark: Mark = token.end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser)?;
if !token.data.is_block_entry() && !token.data.is_block_end() {
@ -532,8 +530,8 @@ fn yaml_parser_parse_block_sequence_entry(
yaml_parser_process_empty_scalar(mark)
}
} else if token.data.is_block_end() {
let event = yaml_event_t {
data: YamlEventData::SequenceEnd,
let event = Event {
data: EventData::SequenceEnd,
start_mark: token.start_mark,
end_mark: token.end_mark,
};
@ -553,12 +551,10 @@ fn yaml_parser_parse_block_sequence_entry(
}
}
fn yaml_parser_parse_indentless_sequence_entry(
parser: &mut yaml_parser_t,
) -> Result<yaml_event_t, ParserError> {
fn yaml_parser_parse_indentless_sequence_entry(parser: &mut Parser) -> Result<Event, ParserError> {
let mut token = PEEK_TOKEN(parser)?;
if token.data.is_block_entry() {
let mark: yaml_mark_t = token.end_mark;
let mark: Mark = token.end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser)?;
if !token.data.is_block_entry()
@ -575,8 +571,8 @@ fn yaml_parser_parse_indentless_sequence_entry(
yaml_parser_process_empty_scalar(mark)
}
} else {
let event = yaml_event_t {
data: YamlEventData::SequenceEnd,
let event = Event {
data: EventData::SequenceEnd,
start_mark: token.start_mark,
end_mark: token.end_mark,
};
@ -586,9 +582,9 @@ fn yaml_parser_parse_indentless_sequence_entry(
}
fn yaml_parser_parse_block_mapping_key(
parser: &mut yaml_parser_t,
parser: &mut Parser,
first: bool,
) -> Result<yaml_event_t, ParserError> {
) -> Result<Event, ParserError> {
if first {
let token = PEEK_TOKEN(parser)?;
let mark = token.start_mark;
@ -598,7 +594,7 @@ fn yaml_parser_parse_block_mapping_key(
let mut token = PEEK_TOKEN(parser)?;
if token.data.is_key() {
let mark: yaml_mark_t = token.end_mark;
let mark: Mark = token.end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser)?;
if !token.data.is_key() && !token.data.is_value() && !token.data.is_block_end() {
@ -609,8 +605,8 @@ fn yaml_parser_parse_block_mapping_key(
yaml_parser_process_empty_scalar(mark)
}
} else if token.data.is_block_end() {
let event = yaml_event_t {
data: YamlEventData::MappingEnd,
let event = Event {
data: EventData::MappingEnd,
start_mark: token.start_mark,
end_mark: token.end_mark,
};
@ -630,12 +626,10 @@ fn yaml_parser_parse_block_mapping_key(
}
}
fn yaml_parser_parse_block_mapping_value(
parser: &mut yaml_parser_t,
) -> Result<yaml_event_t, ParserError> {
fn yaml_parser_parse_block_mapping_value(parser: &mut Parser) -> Result<Event, ParserError> {
let mut token = PEEK_TOKEN(parser)?;
if token.data.is_value() {
let mark: yaml_mark_t = token.end_mark;
let mark: Mark = token.end_mark;
SKIP_TOKEN(parser);
token = PEEK_TOKEN(parser)?;
if !token.data.is_key() && !token.data.is_value() && !token.data.is_block_end() {
@ -653,9 +647,9 @@ fn yaml_parser_parse_block_mapping_value(
}
fn yaml_parser_parse_flow_sequence_entry(
parser: &mut yaml_parser_t,
parser: &mut Parser,
first: bool,
) -> Result<yaml_event_t, ParserError> {
) -> Result<Event, ParserError> {
if first {
let token = PEEK_TOKEN(parser)?;
let mark = token.start_mark;
@ -681,8 +675,8 @@ fn yaml_parser_parse_flow_sequence_entry(
}
}
if token.data.is_key() {
let event = yaml_event_t {
data: YamlEventData::MappingStart {
let event = Event {
data: EventData::MappingStart {
anchor: None,
tag: None,
implicit: true,
@ -699,8 +693,8 @@ fn yaml_parser_parse_flow_sequence_entry(
return yaml_parser_parse_node(parser, false, false);
}
}
let event = yaml_event_t {
data: YamlEventData::SequenceEnd,
let event = Event {
data: EventData::SequenceEnd,
start_mark: token.start_mark,
end_mark: token.end_mark,
};
@ -711,8 +705,8 @@ fn yaml_parser_parse_flow_sequence_entry(
}
fn yaml_parser_parse_flow_sequence_entry_mapping_key(
parser: &mut yaml_parser_t,
) -> Result<yaml_event_t, ParserError> {
parser: &mut Parser,
) -> Result<Event, ParserError> {
let token = PEEK_TOKEN(parser)?;
if !token.data.is_value() && !token.data.is_flow_entry() && !token.data.is_flow_sequence_end() {
parser
@ -720,7 +714,7 @@ fn yaml_parser_parse_flow_sequence_entry_mapping_key(
.push(YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE);
yaml_parser_parse_node(parser, false, false)
} else {
let mark: yaml_mark_t = token.end_mark;
let mark: Mark = token.end_mark;
SKIP_TOKEN(parser);
parser.state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
yaml_parser_process_empty_scalar(mark)
@ -728,8 +722,8 @@ fn yaml_parser_parse_flow_sequence_entry_mapping_key(
}
fn yaml_parser_parse_flow_sequence_entry_mapping_value(
parser: &mut yaml_parser_t,
) -> Result<yaml_event_t, ParserError> {
parser: &mut Parser,
) -> Result<Event, ParserError> {
let mut token = PEEK_TOKEN(parser)?;
if token.data.is_value() {
SKIP_TOKEN(parser);
@ -747,23 +741,23 @@ fn yaml_parser_parse_flow_sequence_entry_mapping_value(
}
fn yaml_parser_parse_flow_sequence_entry_mapping_end(
parser: &mut yaml_parser_t,
) -> Result<yaml_event_t, ParserError> {
parser: &mut Parser,
) -> Result<Event, ParserError> {
let token = PEEK_TOKEN(parser)?;
let start_mark = token.start_mark;
let end_mark = token.end_mark;
parser.state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
Ok(yaml_event_t {
data: YamlEventData::MappingEnd,
Ok(Event {
data: EventData::MappingEnd,
start_mark,
end_mark,
})
}
fn yaml_parser_parse_flow_mapping_key(
parser: &mut yaml_parser_t,
parser: &mut Parser,
first: bool,
) -> Result<yaml_event_t, ParserError> {
) -> Result<Event, ParserError> {
if first {
let token = PEEK_TOKEN(parser)?;
let mark = token.start_mark;
@ -809,8 +803,8 @@ fn yaml_parser_parse_flow_mapping_key(
return yaml_parser_parse_node(parser, false, false);
}
}
let event = yaml_event_t {
data: YamlEventData::MappingEnd,
let event = Event {
data: EventData::MappingEnd,
start_mark: token.start_mark,
end_mark: token.end_mark,
};
@ -821,9 +815,9 @@ fn yaml_parser_parse_flow_mapping_key(
}
fn yaml_parser_parse_flow_mapping_value(
parser: &mut yaml_parser_t,
parser: &mut Parser,
empty: bool,
) -> Result<yaml_event_t, ParserError> {
) -> Result<Event, ParserError> {
let mut token = PEEK_TOKEN(parser)?;
if empty {
let mark = token.start_mark;
@ -843,9 +837,9 @@ fn yaml_parser_parse_flow_mapping_value(
yaml_parser_process_empty_scalar(mark)
}
fn yaml_parser_process_empty_scalar(mark: yaml_mark_t) -> Result<yaml_event_t, ParserError> {
Ok(yaml_event_t {
data: YamlEventData::Scalar {
fn yaml_parser_process_empty_scalar(mark: Mark) -> Result<Event, ParserError> {
Ok(Event {
data: EventData::Scalar {
anchor: None,
tag: None,
value: String::new(),
@ -859,22 +853,22 @@ fn yaml_parser_process_empty_scalar(mark: yaml_mark_t) -> Result<yaml_event_t, P
}
fn yaml_parser_process_directives(
parser: &mut yaml_parser_t,
version_directive_ref: Option<&mut Option<yaml_version_directive_t>>,
tag_directives_ref: Option<&mut Vec<yaml_tag_directive_t>>,
parser: &mut Parser,
version_directive_ref: Option<&mut Option<VersionDirective>>,
tag_directives_ref: Option<&mut Vec<TagDirective>>,
) -> Result<(), ParserError> {
let default_tag_directives: [yaml_tag_directive_t; 2] = [
let default_tag_directives: [TagDirective; 2] = [
// TODO: Get rid of these heap allocations.
yaml_tag_directive_t {
TagDirective {
handle: String::from("!"),
prefix: String::from("!"),
},
yaml_tag_directive_t {
TagDirective {
handle: String::from("!!"),
prefix: String::from("tag:yaml.org,2002:"),
},
];
let mut version_directive: Option<yaml_version_directive_t> = None;
let mut version_directive: Option<VersionDirective> = None;
let mut tag_directives = Vec::with_capacity(16);
@ -885,20 +879,20 @@ fn yaml_parser_process_directives(
break;
}
if let YamlTokenData::VersionDirective { major, minor } = &token.data {
if let TokenData::VersionDirective { major, minor } = &token.data {
let mark = token.start_mark;
if version_directive.is_some() {
return yaml_parser_set_parser_error("found duplicate %YAML directive", mark);
} else if *major != 1 || *minor != 1 && *minor != 2 {
return yaml_parser_set_parser_error("found incompatible YAML document", mark);
} else {
version_directive = Some(yaml_version_directive_t {
version_directive = Some(VersionDirective {
major: *major,
minor: *minor,
});
}
} else if let YamlTokenData::TagDirective { handle, prefix } = &token.data {
let value = yaml_tag_directive_t {
} else if let TokenData::TagDirective { handle, prefix } = &token.data {
let value = TagDirective {
// TODO: Get rid of these clones by consuming tokens by value.
handle: handle.clone(),
prefix: prefix.clone(),
@ -936,10 +930,10 @@ fn yaml_parser_process_directives(
}
fn yaml_parser_append_tag_directive(
parser: &mut yaml_parser_t,
value: &yaml_tag_directive_t,
parser: &mut Parser,
value: &TagDirective,
allow_duplicates: bool,
mark: yaml_mark_t,
mark: Mark,
) -> Result<(), ParserError> {
for tag_directive in &parser.tag_directives {
if value.handle == tag_directive.handle {

8
src/reader.rs
View file

@ -3,8 +3,8 @@ use std::io::BufRead;
use alloc::collections::VecDeque;
use crate::{
yaml_encoding_t, yaml_parser_t, ReaderError, YAML_ANY_ENCODING, YAML_UTF16BE_ENCODING,
YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
Encoding, Parser, ReaderError, YAML_ANY_ENCODING, YAML_UTF16BE_ENCODING, YAML_UTF16LE_ENCODING,
YAML_UTF8_ENCODING,
};
fn yaml_parser_set_reader_error<T>(
@ -25,7 +25,7 @@ const BOM_UTF16BE: [u8; 2] = [0xfe, 0xff];
fn yaml_parser_determine_encoding(
reader: &mut dyn BufRead,
) -> Result<Option<yaml_encoding_t>, ReaderError> {
) -> Result<Option<Encoding>, ReaderError> {
let initial_bytes = reader.fill_buf()?;
if initial_bytes.is_empty() {
return Ok(None);
@ -283,7 +283,7 @@ fn push_char(out: &mut VecDeque<char>, ch: char, offset: usize) -> Result<(), Re
}
pub(crate) fn yaml_parser_update_buffer(
parser: &mut yaml_parser_t,
parser: &mut Parser,
length: usize,
) -> Result<(), ReaderError> {
let reader = parser.read_handler.as_deref_mut().expect("no read handler");

326
src/scanner.rs
View file

@ -2,14 +2,14 @@ use alloc::string::String;
use crate::macros::{is_blankz, is_break, vecdeque_starts_with};
use crate::reader::yaml_parser_update_buffer;
use crate::yaml::YamlTokenData;
use crate::yaml::TokenData;
use crate::{
yaml_mark_t, yaml_parser_t, yaml_simple_key_t, yaml_token_t, ReaderError, ScannerError,
YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE,
YAML_PLAIN_SCALAR_STYLE, YAML_SINGLE_QUOTED_SCALAR_STYLE,
Mark, Parser, ReaderError, ScannerError, SimpleKey, Token, YAML_DOUBLE_QUOTED_SCALAR_STYLE,
YAML_FOLDED_SCALAR_STYLE, YAML_LITERAL_SCALAR_STYLE, YAML_PLAIN_SCALAR_STYLE,
YAML_SINGLE_QUOTED_SCALAR_STYLE,
};
fn CACHE(parser: &mut yaml_parser_t, length: usize) -> Result<(), ReaderError> {
fn CACHE(parser: &mut Parser, length: usize) -> Result<(), ReaderError> {
if parser.unread >= length {
Ok(())
} else {
@ -17,7 +17,7 @@ fn CACHE(parser: &mut yaml_parser_t, length: usize) -> Result<(), ReaderError> {
}
}
fn SKIP(parser: &mut yaml_parser_t) {
fn SKIP(parser: &mut Parser) {
let popped = parser.buffer.pop_front().expect("unexpected end of tokens");
let width = popped.len_utf8();
parser.mark.index += width as u64;
@ -25,7 +25,7 @@ fn SKIP(parser: &mut yaml_parser_t) {
parser.unread -= 1;
}
fn SKIP_LINE(parser: &mut yaml_parser_t) {
fn SKIP_LINE(parser: &mut Parser) {
if vecdeque_starts_with(&parser.buffer, &['\r', '\n']) {
parser.mark.index += 2;
parser.mark.column = 0;
@ -44,7 +44,7 @@ fn SKIP_LINE(parser: &mut yaml_parser_t) {
}
}
fn READ_STRING(parser: &mut yaml_parser_t, string: &mut String) {
fn READ_STRING(parser: &mut Parser, string: &mut String) {
if let Some(popped) = parser.buffer.pop_front() {
string.push(popped);
parser.mark.index = popped.len_utf8() as u64;
@ -55,7 +55,7 @@ fn READ_STRING(parser: &mut yaml_parser_t, string: &mut String) {
}
}
fn READ_LINE_STRING(parser: &mut yaml_parser_t, string: &mut String) {
fn READ_LINE_STRING(parser: &mut Parser, string: &mut String) {
if vecdeque_starts_with(&parser.buffer, &['\r', '\n']) {
string.push('\n');
parser.buffer.drain(0..2);
@ -93,10 +93,10 @@ fn READ_LINE_STRING(parser: &mut yaml_parser_t, string: &mut String) {
/// An application must not alternate the calls of yaml_parser_scan() with the
/// calls of yaml_parser_parse() or yaml_parser_load(). Doing this will break
/// the parser.
pub fn yaml_parser_scan(parser: &mut yaml_parser_t) -> Result<yaml_token_t, ScannerError> {
pub fn yaml_parser_scan(parser: &mut Parser) -> Result<Token, ScannerError> {
if parser.stream_end_produced {
return Ok(yaml_token_t {
data: YamlTokenData::StreamEnd,
return Ok(Token {
data: TokenData::StreamEnd,
..Default::default()
});
}
@ -106,7 +106,7 @@ pub fn yaml_parser_scan(parser: &mut yaml_parser_t) -> Result<yaml_token_t, Scan
if let Some(token) = parser.tokens.pop_front() {
parser.token_available = false;
parser.tokens_parsed += 1;
if let YamlTokenData::StreamEnd = &token.data {
if let TokenData::StreamEnd = &token.data {
parser.stream_end_produced = true;
}
Ok(token)
@ -116,9 +116,9 @@ pub fn yaml_parser_scan(parser: &mut yaml_parser_t) -> Result<yaml_token_t, Scan
}
fn yaml_parser_set_scanner_error<T>(
parser: &mut yaml_parser_t,
parser: &mut Parser,
context: &'static str,
context_mark: yaml_mark_t,
context_mark: Mark,
problem: &'static str,
) -> Result<T, ScannerError> {
Err(ScannerError::Problem {
@ -129,9 +129,7 @@ fn yaml_parser_set_scanner_error<T>(
})
}
pub(crate) fn yaml_parser_fetch_more_tokens(
parser: &mut yaml_parser_t,
) -> Result<(), ScannerError> {
pub(crate) fn yaml_parser_fetch_more_tokens(parser: &mut Parser) -> Result<(), ScannerError> {
let mut need_more_tokens;
loop {
need_more_tokens = false;
@ -155,7 +153,7 @@ pub(crate) fn yaml_parser_fetch_more_tokens(
Ok(())
}
fn yaml_parser_fetch_next_token(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_fetch_next_token(parser: &mut Parser) -> Result<(), ScannerError> {
CACHE(parser, 1)?;
if !parser.stream_start_produced {
yaml_parser_fetch_stream_start(parser);
@ -177,7 +175,7 @@ fn yaml_parser_fetch_next_token(parser: &mut yaml_parser_t) -> Result<(), Scanne
&& CHECK_AT!(parser.buffer, '-', 2)
&& is_blankz(parser.buffer.get(3).copied())
{
return yaml_parser_fetch_document_indicator(parser, YamlTokenData::DocumentStart);
return yaml_parser_fetch_document_indicator(parser, TokenData::DocumentStart);
}
if parser.mark.column == 0_u64
&& CHECK_AT!(parser.buffer, '.', 0)
@ -185,19 +183,19 @@ fn yaml_parser_fetch_next_token(parser: &mut yaml_parser_t) -> Result<(), Scanne
&& CHECK_AT!(parser.buffer, '.', 2)
&& is_blankz(parser.buffer.get(3).copied())
{
return yaml_parser_fetch_document_indicator(parser, YamlTokenData::DocumentEnd);
return yaml_parser_fetch_document_indicator(parser, TokenData::DocumentEnd);
}
if CHECK!(parser.buffer, '[') {
return yaml_parser_fetch_flow_collection_start(parser, YamlTokenData::FlowSequenceStart);
return yaml_parser_fetch_flow_collection_start(parser, TokenData::FlowSequenceStart);
}
if CHECK!(parser.buffer, '{') {
return yaml_parser_fetch_flow_collection_start(parser, YamlTokenData::FlowMappingStart);
return yaml_parser_fetch_flow_collection_start(parser, TokenData::FlowMappingStart);
}
if CHECK!(parser.buffer, ']') {
return yaml_parser_fetch_flow_collection_end(parser, YamlTokenData::FlowSequenceEnd);
return yaml_parser_fetch_flow_collection_end(parser, TokenData::FlowSequenceEnd);
}
if CHECK!(parser.buffer, '}') {
return yaml_parser_fetch_flow_collection_end(parser, YamlTokenData::FlowMappingEnd);
return yaml_parser_fetch_flow_collection_end(parser, TokenData::FlowMappingEnd);
}
if CHECK!(parser.buffer, ',') {
return yaml_parser_fetch_flow_entry(parser);
@ -267,7 +265,7 @@ fn yaml_parser_fetch_next_token(parser: &mut yaml_parser_t) -> Result<(), Scanne
)
}
fn yaml_parser_stale_simple_keys(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_stale_simple_keys(parser: &mut Parser) -> Result<(), ScannerError> {
for simple_key in &mut parser.simple_keys {
let mark = simple_key.mark;
if simple_key.possible
@ -288,10 +286,10 @@ fn yaml_parser_stale_simple_keys(parser: &mut yaml_parser_t) -> Result<(), Scann
Ok(())
}
fn yaml_parser_save_simple_key(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_save_simple_key(parser: &mut Parser) -> Result<(), ScannerError> {
let required = parser.flow_level == 0 && parser.indent as u64 == parser.mark.column as u64;
if parser.simple_key_allowed {
let simple_key = yaml_simple_key_t {
let simple_key = SimpleKey {
possible: true,
required,
token_number: parser.tokens_parsed + parser.tokens.len(),
@ -303,8 +301,8 @@ fn yaml_parser_save_simple_key(parser: &mut yaml_parser_t) -> Result<(), Scanner
Ok(())
}
fn yaml_parser_remove_simple_key(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
let simple_key: &mut yaml_simple_key_t = parser.simple_keys.last_mut().unwrap();
fn yaml_parser_remove_simple_key(parser: &mut Parser) -> Result<(), ScannerError> {
let simple_key: &mut SimpleKey = parser.simple_keys.last_mut().unwrap();
if simple_key.possible {
let mark = simple_key.mark;
if simple_key.required {
@ -320,12 +318,12 @@ fn yaml_parser_remove_simple_key(parser: &mut yaml_parser_t) -> Result<(), Scann
Ok(())
}
fn yaml_parser_increase_flow_level(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
let empty_simple_key = yaml_simple_key_t {
fn yaml_parser_increase_flow_level(parser: &mut Parser) -> Result<(), ScannerError> {
let empty_simple_key = SimpleKey {
possible: false,
required: false,
token_number: 0,
mark: yaml_mark_t {
mark: Mark {
index: 0_u64,
line: 0_u64,
column: 0_u64,
@ -340,7 +338,7 @@ fn yaml_parser_increase_flow_level(parser: &mut yaml_parser_t) -> Result<(), Sca
Ok(())
}
fn yaml_parser_decrease_flow_level(parser: &mut yaml_parser_t) {
fn yaml_parser_decrease_flow_level(parser: &mut Parser) {
if parser.flow_level != 0 {
parser.flow_level -= 1;
let _ = parser.simple_keys.pop();
@ -348,11 +346,11 @@ fn yaml_parser_decrease_flow_level(parser: &mut yaml_parser_t) {
}
fn yaml_parser_roll_indent(
parser: &mut yaml_parser_t,
parser: &mut Parser,
column: i64,
number: i64,
data: YamlTokenData,
mark: yaml_mark_t,
data: TokenData,
mark: Mark,
) -> Result<(), ScannerError> {
if parser.flow_level != 0 {
return Ok(());
@ -361,7 +359,7 @@ fn yaml_parser_roll_indent(
parser.indents.push(parser.indent);
assert!(!(column > i32::MAX as i64), "integer overflow");
parser.indent = column as i32;
let token = yaml_token_t {
let token = Token {
data,
start_mark: mark,
end_mark: mark,
@ -378,13 +376,13 @@ fn yaml_parser_roll_indent(
Ok(())
}
fn yaml_parser_unroll_indent(parser: &mut yaml_parser_t, column: i64) {
fn yaml_parser_unroll_indent(parser: &mut Parser, column: i64) {
if parser.flow_level != 0 {
return;
}
while parser.indent as i64 > column {
let token = yaml_token_t {
data: YamlTokenData::BlockEnd,
let token = Token {
data: TokenData::BlockEnd,
start_mark: parser.mark,
end_mark: parser.mark,
};
@ -393,12 +391,12 @@ fn yaml_parser_unroll_indent(parser: &mut yaml_parser_t, column: i64) {
}
}
fn yaml_parser_fetch_stream_start(parser: &mut yaml_parser_t) {
let simple_key = yaml_simple_key_t {
fn yaml_parser_fetch_stream_start(parser: &mut Parser) {
let simple_key = SimpleKey {
possible: false,
required: false,
token_number: 0,
mark: yaml_mark_t {
mark: Mark {
index: 0,
line: 0,
column: 0,
@ -408,8 +406,8 @@ fn yaml_parser_fetch_stream_start(parser: &mut yaml_parser_t) {
parser.simple_keys.push(simple_key);
parser.simple_key_allowed = true;
parser.stream_start_produced = true;
let token = yaml_token_t {
data: YamlTokenData::StreamStart {
let token = Token {
data: TokenData::StreamStart {
encoding: parser.encoding,
},
start_mark: parser.mark,
@ -418,7 +416,7 @@ fn yaml_parser_fetch_stream_start(parser: &mut yaml_parser_t) {
parser.tokens.push_back(token);
}
fn yaml_parser_fetch_stream_end(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_fetch_stream_end(parser: &mut Parser) -> Result<(), ScannerError> {
if parser.mark.column != 0_u64 {
parser.mark.column = 0_u64;
parser.mark.line += 1;
@ -426,8 +424,8 @@ fn yaml_parser_fetch_stream_end(parser: &mut yaml_parser_t) -> Result<(), Scanne
yaml_parser_unroll_indent(parser, -1_i64);
yaml_parser_remove_simple_key(parser)?;
parser.simple_key_allowed = false;
let token = yaml_token_t {
data: YamlTokenData::StreamEnd,
let token = Token {
data: TokenData::StreamEnd,
start_mark: parser.mark,
end_mark: parser.mark,
};
@ -435,8 +433,8 @@ fn yaml_parser_fetch_stream_end(parser: &mut yaml_parser_t) -> Result<(), Scanne
Ok(())
}
fn yaml_parser_fetch_directive(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
let mut token = yaml_token_t::default();
fn yaml_parser_fetch_directive(parser: &mut Parser) -> Result<(), ScannerError> {
let mut token = Token::default();
yaml_parser_unroll_indent(parser, -1_i64);
yaml_parser_remove_simple_key(parser)?;
parser.simple_key_allowed = false;
@ -446,19 +444,19 @@ fn yaml_parser_fetch_directive(parser: &mut yaml_parser_t) -> Result<(), Scanner
}
fn yaml_parser_fetch_document_indicator(
parser: &mut yaml_parser_t,
data: YamlTokenData,
parser: &mut Parser,
data: TokenData,
) -> Result<(), ScannerError> {
yaml_parser_unroll_indent(parser, -1_i64);
yaml_parser_remove_simple_key(parser)?;
parser.simple_key_allowed = false;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
SKIP(parser);
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
let end_mark: Mark = parser.mark;
let token = yaml_token_t {
let token = Token {
data,
start_mark,
end_mark,
@ -468,16 +466,16 @@ fn yaml_parser_fetch_document_indicator(
}
fn yaml_parser_fetch_flow_collection_start(
parser: &mut yaml_parser_t,
data: YamlTokenData,
parser: &mut Parser,
data: TokenData,
) -> Result<(), ScannerError> {
yaml_parser_save_simple_key(parser)?;
yaml_parser_increase_flow_level(parser)?;
parser.simple_key_allowed = true;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
let token = yaml_token_t {
let end_mark: Mark = parser.mark;
let token = Token {
data,
start_mark,
end_mark,
@ -487,16 +485,16 @@ fn yaml_parser_fetch_flow_collection_start(
}
fn yaml_parser_fetch_flow_collection_end(
parser: &mut yaml_parser_t,
data: YamlTokenData,
parser: &mut Parser,
data: TokenData,
) -> Result<(), ScannerError> {
yaml_parser_remove_simple_key(parser)?;
yaml_parser_decrease_flow_level(parser);
parser.simple_key_allowed = false;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
let token = yaml_token_t {
let end_mark: Mark = parser.mark;
let token = Token {
data,
start_mark,
end_mark,
@ -505,14 +503,14 @@ fn yaml_parser_fetch_flow_collection_end(
Ok(())
}
fn yaml_parser_fetch_flow_entry(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_fetch_flow_entry(parser: &mut Parser) -> Result<(), ScannerError> {
yaml_parser_remove_simple_key(parser)?;
parser.simple_key_allowed = true;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
let token = yaml_token_t {
data: YamlTokenData::FlowEntry,
let end_mark: Mark = parser.mark;
let token = Token {
data: TokenData::FlowEntry,
start_mark,
end_mark,
};
@ -520,7 +518,7 @@ fn yaml_parser_fetch_flow_entry(parser: &mut yaml_parser_t) -> Result<(), Scanne
Ok(())
}
fn yaml_parser_fetch_block_entry(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_fetch_block_entry(parser: &mut Parser) -> Result<(), ScannerError> {
if parser.flow_level == 0 {
if !parser.simple_key_allowed {
return yaml_parser_set_scanner_error(
@ -534,17 +532,17 @@ fn yaml_parser_fetch_block_entry(parser: &mut yaml_parser_t) -> Result<(), Scann
parser,
parser.mark.column as _,
-1_i64,
YamlTokenData::BlockSequenceStart,
TokenData::BlockSequenceStart,
parser.mark,
)?;
}
yaml_parser_remove_simple_key(parser)?;
parser.simple_key_allowed = true;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
let token = yaml_token_t {
data: YamlTokenData::BlockEntry,
let end_mark: Mark = parser.mark;
let token = Token {
data: TokenData::BlockEntry,
start_mark,
end_mark,
};
@ -552,7 +550,7 @@ fn yaml_parser_fetch_block_entry(parser: &mut yaml_parser_t) -> Result<(), Scann
Ok(())
}
fn yaml_parser_fetch_key(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_fetch_key(parser: &mut Parser) -> Result<(), ScannerError> {
if parser.flow_level == 0 {
if !parser.simple_key_allowed {
return yaml_parser_set_scanner_error(
@ -566,17 +564,17 @@ fn yaml_parser_fetch_key(parser: &mut yaml_parser_t) -> Result<(), ScannerError>
parser,
parser.mark.column as _,
-1_i64,
YamlTokenData::BlockMappingStart,
TokenData::BlockMappingStart,
parser.mark,
)?;
}
yaml_parser_remove_simple_key(parser)?;
parser.simple_key_allowed = parser.flow_level == 0;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
let token = yaml_token_t {
data: YamlTokenData::Key,
let end_mark: Mark = parser.mark;
let token = Token {
data: TokenData::Key,
start_mark,
end_mark,
};
@ -584,11 +582,11 @@ fn yaml_parser_fetch_key(parser: &mut yaml_parser_t) -> Result<(), ScannerError>
Ok(())
}
fn yaml_parser_fetch_value(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
let simple_key: &mut yaml_simple_key_t = parser.simple_keys.last_mut().unwrap();
fn yaml_parser_fetch_value(parser: &mut Parser) -> Result<(), ScannerError> {
let simple_key: &mut SimpleKey = parser.simple_keys.last_mut().unwrap();
if simple_key.possible {
let token = yaml_token_t {
data: YamlTokenData::Key,
let token = Token {
data: TokenData::Key,
start_mark: simple_key.mark,
end_mark: simple_key.mark,
};
@ -604,7 +602,7 @@ fn yaml_parser_fetch_value(parser: &mut yaml_parser_t) -> Result<(), ScannerErro
parser,
mark_column,
token_number,
YamlTokenData::BlockMappingStart,
TokenData::BlockMappingStart,
mark,
)?;
parser.simple_key_allowed = false;
@ -622,17 +620,17 @@ fn yaml_parser_fetch_value(parser: &mut yaml_parser_t) -> Result<(), ScannerErro
parser,
parser.mark.column as _,
-1_i64,
YamlTokenData::BlockMappingStart,
TokenData::BlockMappingStart,
parser.mark,
)?;
}
parser.simple_key_allowed = parser.flow_level == 0;
}
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
let token = yaml_token_t {
data: YamlTokenData::Value,
let end_mark: Mark = parser.mark;
let token = Token {
data: TokenData::Value,
start_mark,
end_mark,
};
@ -641,10 +639,10 @@ fn yaml_parser_fetch_value(parser: &mut yaml_parser_t) -> Result<(), ScannerErro
}
fn yaml_parser_fetch_anchor(
parser: &mut yaml_parser_t,
parser: &mut Parser,
fetch_alias_instead_of_anchor: bool,
) -> Result<(), ScannerError> {
let mut token = yaml_token_t::default();
let mut token = Token::default();
yaml_parser_save_simple_key(parser)?;
parser.simple_key_allowed = false;
yaml_parser_scan_anchor(parser, &mut token, fetch_alias_instead_of_anchor)?;
@ -652,8 +650,8 @@ fn yaml_parser_fetch_anchor(
Ok(())
}
fn yaml_parser_fetch_tag(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
let mut token = yaml_token_t::default();
fn yaml_parser_fetch_tag(parser: &mut Parser) -> Result<(), ScannerError> {
let mut token = Token::default();
yaml_parser_save_simple_key(parser)?;
parser.simple_key_allowed = false;
yaml_parser_scan_tag(parser, &mut token)?;
@ -661,11 +659,8 @@ fn yaml_parser_fetch_tag(parser: &mut yaml_parser_t) -> Result<(), ScannerError>
Ok(())
}
fn yaml_parser_fetch_block_scalar(
parser: &mut yaml_parser_t,
literal: bool,
) -> Result<(), ScannerError> {
let mut token = yaml_token_t::default();
fn yaml_parser_fetch_block_scalar(parser: &mut Parser, literal: bool) -> Result<(), ScannerError> {
let mut token = Token::default();
yaml_parser_remove_simple_key(parser)?;
parser.simple_key_allowed = true;
yaml_parser_scan_block_scalar(parser, &mut token, literal)?;
@ -673,11 +668,8 @@ fn yaml_parser_fetch_block_scalar(
Ok(())
}
fn yaml_parser_fetch_flow_scalar(
parser: &mut yaml_parser_t,
single: bool,
) -> Result<(), ScannerError> {
let mut token = yaml_token_t::default();
fn yaml_parser_fetch_flow_scalar(parser: &mut Parser, single: bool) -> Result<(), ScannerError> {
let mut token = Token::default();
yaml_parser_save_simple_key(parser)?;
parser.simple_key_allowed = false;
yaml_parser_scan_flow_scalar(parser, &mut token, single)?;
@ -685,8 +677,8 @@ fn yaml_parser_fetch_flow_scalar(
Ok(())
}
fn yaml_parser_fetch_plain_scalar(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
let mut token = yaml_token_t::default();
fn yaml_parser_fetch_plain_scalar(parser: &mut Parser) -> Result<(), ScannerError> {
let mut token = Token::default();
yaml_parser_save_simple_key(parser)?;
parser.simple_key_allowed = false;
yaml_parser_scan_plain_scalar(parser, &mut token)?;
@ -694,7 +686,7 @@ fn yaml_parser_fetch_plain_scalar(parser: &mut yaml_parser_t) -> Result<(), Scan
Ok(())
}
fn yaml_parser_scan_to_next_token(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
fn yaml_parser_scan_to_next_token(parser: &mut Parser) -> Result<(), ScannerError> {
loop {
CACHE(parser, 1)?;
if parser.mark.column == 0 && IS_BOM!(parser.buffer) {
@ -725,30 +717,27 @@ fn yaml_parser_scan_to_next_token(parser: &mut yaml_parser_t) -> Result<(), Scan
Ok(())
}
fn yaml_parser_scan_directive(
parser: &mut yaml_parser_t,
token: &mut yaml_token_t,
) -> Result<(), ScannerError> {
let end_mark: yaml_mark_t;
fn yaml_parser_scan_directive(parser: &mut Parser, token: &mut Token) -> Result<(), ScannerError> {
let end_mark: Mark;
let mut major: i32 = 0;
let mut minor: i32 = 0;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
let name = yaml_parser_scan_directive_name(parser, start_mark)?;
if name == "YAML" {
yaml_parser_scan_version_directive_value(parser, start_mark, &mut major, &mut minor)?;
end_mark = parser.mark;
*token = yaml_token_t {
data: YamlTokenData::VersionDirective { major, minor },
*token = Token {
data: TokenData::VersionDirective { major, minor },
start_mark,
end_mark,
};
} else if name == "TAG" {
let (handle, prefix) = yaml_parser_scan_tag_directive_value(parser, start_mark)?;
end_mark = parser.mark;
*token = yaml_token_t {
data: YamlTokenData::TagDirective { handle, prefix },
*token = Token {
data: TokenData::TagDirective { handle, prefix },
start_mark,
end_mark,
};
@ -796,8 +785,8 @@ fn yaml_parser_scan_directive(
}
fn yaml_parser_scan_directive_name(
parser: &mut yaml_parser_t,
start_mark: yaml_mark_t,
parser: &mut Parser,
start_mark: Mark,
) -> Result<String, ScannerError> {
let mut string = String::new();
CACHE(parser, 1)?;
@ -830,8 +819,8 @@ fn yaml_parser_scan_directive_name(
}
fn yaml_parser_scan_version_directive_value(
parser: &mut yaml_parser_t,
start_mark: yaml_mark_t,
parser: &mut Parser,
start_mark: Mark,
major: &mut i32,
minor: &mut i32,
) -> Result<(), ScannerError> {
@ -856,8 +845,8 @@ fn yaml_parser_scan_version_directive_value(
const MAX_NUMBER_LENGTH: u64 = 9_u64;
fn yaml_parser_scan_version_directive_number(
parser: &mut yaml_parser_t,
start_mark: yaml_mark_t,
parser: &mut Parser,
start_mark: Mark,
number: &mut i32,
) -> Result<(), ScannerError> {
let mut value: i32 = 0;
@ -891,8 +880,8 @@ fn yaml_parser_scan_version_directive_number(
// Returns (handle, prefix)
fn yaml_parser_scan_tag_directive_value(
parser: &mut yaml_parser_t,
start_mark: yaml_mark_t,
parser: &mut Parser,
start_mark: Mark,
) -> Result<(String, String), ScannerError> {
CACHE(parser, 1)?;
@ -937,14 +926,14 @@ fn yaml_parser_scan_tag_directive_value(
}
fn yaml_parser_scan_anchor(
parser: &mut yaml_parser_t,
token: &mut yaml_token_t,
parser: &mut Parser,
token: &mut Token,
scan_alias_instead_of_anchor: bool,
) -> Result<(), ScannerError> {
let mut length: i32 = 0;
let mut string = String::new();
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
CACHE(parser, 1)?;
@ -956,7 +945,7 @@ fn yaml_parser_scan_anchor(
CACHE(parser, 1)?;
length += 1;
}
let end_mark: yaml_mark_t = parser.mark;
let end_mark: Mark = parser.mark;
if length == 0
|| !(IS_BLANKZ!(parser.buffer)
|| CHECK!(parser.buffer, '?')
@ -979,11 +968,11 @@ fn yaml_parser_scan_anchor(
"did not find expected alphabetic or numeric character",
)
} else {
*token = yaml_token_t {
*token = Token {
data: if scan_alias_instead_of_anchor {
YamlTokenData::Alias { value: string }
TokenData::Alias { value: string }
} else {
YamlTokenData::Anchor { value: string }
TokenData::Anchor { value: string }
},
start_mark,
end_mark,
@ -992,14 +981,11 @@ fn yaml_parser_scan_anchor(
}
}
fn yaml_parser_scan_tag(
parser: &mut yaml_parser_t,
token: &mut yaml_token_t,
) -> Result<(), ScannerError> {
fn yaml_parser_scan_tag(parser: &mut Parser, token: &mut Token) -> Result<(), ScannerError> {
let mut handle;
let mut suffix;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
CACHE(parser, 2)?;
@ -1046,9 +1032,9 @@ fn yaml_parser_scan_tag(
}
}
let end_mark: yaml_mark_t = parser.mark;
*token = yaml_token_t {
data: YamlTokenData::Tag { handle, suffix },
let end_mark: Mark = parser.mark;
*token = Token {
data: TokenData::Tag { handle, suffix },
start_mark,
end_mark,
};
@ -1057,9 +1043,9 @@ fn yaml_parser_scan_tag(
}
fn yaml_parser_scan_tag_handle(
parser: &mut yaml_parser_t,
parser: &mut Parser,
directive: bool,
start_mark: yaml_mark_t,
start_mark: Mark,
) -> Result<String, ScannerError> {
let mut string = String::new();
CACHE(parser, 1)?;
@ -1100,11 +1086,11 @@ fn yaml_parser_scan_tag_handle(
}
fn yaml_parser_scan_tag_uri(
parser: &mut yaml_parser_t,
parser: &mut Parser,
uri_char: bool,
directive: bool,
head: Option<&str>,
start_mark: yaml_mark_t,
start_mark: Mark,
) -> Result<String, ScannerError> {
let head = head.unwrap_or("");
let mut length = head.len();
@ -1163,9 +1149,9 @@ fn yaml_parser_scan_tag_uri(
}
fn yaml_parser_scan_uri_escapes(
parser: &mut yaml_parser_t,
parser: &mut Parser,
directive: bool,
start_mark: yaml_mark_t,
start_mark: Mark,
string: &mut String,
) -> Result<(), ScannerError> {
let mut width: i32 = 0;
@ -1237,11 +1223,11 @@ fn yaml_parser_scan_uri_escapes(
}
fn yaml_parser_scan_block_scalar(
parser: &mut yaml_parser_t,
token: &mut yaml_token_t,
parser: &mut Parser,
token: &mut Token,
literal: bool,
) -> Result<(), ScannerError> {
let mut end_mark: yaml_mark_t;
let mut end_mark: Mark;
let mut string = String::new();
let mut leading_break = String::new();
let mut trailing_breaks = String::new();
@ -1250,7 +1236,7 @@ fn yaml_parser_scan_block_scalar(
let mut indent: i32 = 0;
let mut leading_blank: i32 = 0;
let mut trailing_blank: i32;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
CACHE(parser, 1)?;
@ -1382,8 +1368,8 @@ fn yaml_parser_scan_block_scalar(
string.push_str(&trailing_breaks);
}
*token = yaml_token_t {
data: YamlTokenData::Scalar {
*token = Token {
data: TokenData::Scalar {
value: string,
style: if literal {
YAML_LITERAL_SCALAR_STYLE
@ -1399,11 +1385,11 @@ fn yaml_parser_scan_block_scalar(
}
fn yaml_parser_scan_block_scalar_breaks(
parser: &mut yaml_parser_t,
parser: &mut Parser,
indent: &mut i32,
breaks: &mut String,
start_mark: yaml_mark_t,
end_mark: &mut yaml_mark_t,
start_mark: Mark,
end_mark: &mut Mark,
) -> Result<(), ScannerError> {
let mut max_indent: i32 = 0;
*end_mark = parser.mark;
@ -1444,8 +1430,8 @@ fn yaml_parser_scan_block_scalar_breaks(
}
fn yaml_parser_scan_flow_scalar(
parser: &mut yaml_parser_t,
token: &mut yaml_token_t,
parser: &mut Parser,
token: &mut Token,
single: bool,
) -> Result<(), ScannerError> {
let mut string = String::new();
@ -1454,7 +1440,7 @@ fn yaml_parser_scan_flow_scalar(
let mut whitespaces = String::new();
let mut leading_blanks;
let start_mark: yaml_mark_t = parser.mark;
let start_mark: Mark = parser.mark;
SKIP(parser);
loop {
CACHE(parser, 4)?;
@ -1673,9 +1659,9 @@ fn yaml_parser_scan_flow_scalar(
}
SKIP(parser);
let end_mark: yaml_mark_t = parser.mark;
*token = yaml_token_t {
data: YamlTokenData::Scalar {
let end_mark: Mark = parser.mark;
*token = Token {
data: TokenData::Scalar {
value: string,
style: if single {
YAML_SINGLE_QUOTED_SCALAR_STYLE
@ -1690,10 +1676,10 @@ fn yaml_parser_scan_flow_scalar(
}
fn yaml_parser_scan_plain_scalar(
parser: &mut yaml_parser_t,
token: &mut yaml_token_t,
parser: &mut Parser,
token: &mut Token,
) -> Result<(), ScannerError> {
let mut end_mark: yaml_mark_t;
let mut end_mark: Mark;
let mut string = String::new();
let mut leading_break = String::new();
let mut trailing_breaks = String::new();
@ -1701,7 +1687,7 @@ fn yaml_parser_scan_plain_scalar(
let mut leading_blanks = false;
let indent: i32 = parser.indent + 1;
end_mark = parser.mark;
let start_mark: yaml_mark_t = end_mark;
let start_mark: Mark = end_mark;
loop {
CACHE(parser, 4)?;
if parser.mark.column == 0
@ -1810,8 +1796,8 @@ fn yaml_parser_scan_plain_scalar(
}
}
*token = yaml_token_t {
data: YamlTokenData::Scalar {
*token = Token {
data: TokenData::Scalar {
value: string,
style: YAML_PLAIN_SCALAR_STYLE,
},

8
src/writer.rs
View file

@ -1,10 +1,8 @@
use crate::yaml_encoding_t::YAML_UTF16BE_ENCODING;
use crate::{
yaml_emitter_t, WriterError, YAML_ANY_ENCODING, YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
};
use crate::Encoding::YAML_UTF16BE_ENCODING;
use crate::{Emitter, WriterError, YAML_ANY_ENCODING, YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING};
/// Flush the accumulated characters to the output.
pub fn yaml_emitter_flush(emitter: &mut yaml_emitter_t) -> Result<(), WriterError> {
pub fn yaml_emitter_flush(emitter: &mut Emitter) -> Result<(), WriterError> {
assert!((emitter.write_handler).is_some());
assert_ne!(emitter.encoding, YAML_ANY_ENCODING);

197
src/yaml.rs
View file

@ -4,7 +4,7 @@ use alloc::vec::Vec;
use crate::{api::yaml_parser_new, yaml_emitter_new};
pub use self::yaml_encoding_t::*;
pub use self::Encoding::*;
/// The tag @c !!null with the only possible value: @c null.
pub const YAML_NULL_TAG: &str = "tag:yaml.org,2002:null";
@ -34,7 +34,7 @@ pub const YAML_DEFAULT_MAPPING_TAG: &str = YAML_MAP_TAG;
/// The version directive data.
#[derive(Clone, Copy, Debug)]
#[non_exhaustive]
pub struct yaml_version_directive_t {
pub struct VersionDirective {
/// The major version number.
pub major: i32,
/// The minor version number.
@ -44,7 +44,7 @@ pub struct yaml_version_directive_t {
/// The tag directive data.
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct yaml_tag_directive_t {
pub struct TagDirective {
/// The tag handle.
pub handle: String,
/// The tag prefix.
@ -54,7 +54,7 @@ pub struct yaml_tag_directive_t {
/// The stream encoding.
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_encoding_t {
pub enum Encoding {
/// Let the parser choose the encoding.
#[default]
YAML_ANY_ENCODING = 0,
@ -69,7 +69,7 @@ pub enum yaml_encoding_t {
/// Line break type.
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_break_t {
pub enum Break {
/// Let the parser choose the break type.
#[default]
YAML_ANY_BREAK = 0,
@ -84,7 +84,7 @@ pub enum yaml_break_t {
/// The pointer position.
#[derive(Copy, Clone, Default, Debug)]
#[non_exhaustive]
pub struct yaml_mark_t {
pub struct Mark {
/// The position index.
pub index: u64,
/// The position line.
@ -96,7 +96,7 @@ pub struct yaml_mark_t {
/// Scalar styles.
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_scalar_style_t {
pub enum ScalarStyle {
/// Let the emitter choose the style.
#[default]
YAML_ANY_SCALAR_STYLE = 0,
@ -115,7 +115,7 @@ pub enum yaml_scalar_style_t {
/// Sequence styles.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_sequence_style_t {
pub enum SequenceStyle {
/// Let the emitter choose the style.
YAML_ANY_SEQUENCE_STYLE = 0,
/// The block sequence style.
@ -127,7 +127,7 @@ pub enum yaml_sequence_style_t {
/// Mapping styles.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_mapping_style_t {
pub enum MappingStyle {
/// Let the emitter choose the style.
YAML_ANY_MAPPING_STYLE = 0,
/// The block mapping style.
@ -136,77 +136,27 @@ pub enum yaml_mapping_style_t {
YAML_FLOW_MAPPING_STYLE = 2,
}
/// Token types.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_token_type_t {
/// An empty token.
YAML_NO_TOKEN = 0,
/// A STREAM-START token.
YAML_STREAM_START_TOKEN = 1,
/// A STREAM-END token.
YAML_STREAM_END_TOKEN = 2,
/// A VERSION-DIRECTIVE token.
YAML_VERSION_DIRECTIVE_TOKEN = 3,
/// A TAG-DIRECTIVE token.
YAML_TAG_DIRECTIVE_TOKEN = 4,
/// A DOCUMENT-START token.
YAML_DOCUMENT_START_TOKEN = 5,
/// A DOCUMENT-END token.
YAML_DOCUMENT_END_TOKEN = 6,
/// A BLOCK-SEQUENCE-START token.
YAML_BLOCK_SEQUENCE_START_TOKEN = 7,
/// A BLOCK-MAPPING-START token.
YAML_BLOCK_MAPPING_START_TOKEN = 8,
/// A BLOCK-END token.
YAML_BLOCK_END_TOKEN = 9,
/// A FLOW-SEQUENCE-START token.
YAML_FLOW_SEQUENCE_START_TOKEN = 10,
/// A FLOW-SEQUENCE-END token.
YAML_FLOW_SEQUENCE_END_TOKEN = 11,
/// A FLOW-MAPPING-START token.
YAML_FLOW_MAPPING_START_TOKEN = 12,
/// A FLOW-MAPPING-END token.
YAML_FLOW_MAPPING_END_TOKEN = 13,
/// A BLOCK-ENTRY token.
YAML_BLOCK_ENTRY_TOKEN = 14,
/// A FLOW-ENTRY token.
YAML_FLOW_ENTRY_TOKEN = 15,
/// A KEY token.
YAML_KEY_TOKEN = 16,
/// A VALUE token.
YAML_VALUE_TOKEN = 17,
/// An ALIAS token.
YAML_ALIAS_TOKEN = 18,
/// An ANCHOR token.
YAML_ANCHOR_TOKEN = 19,
/// A TAG token.
YAML_TAG_TOKEN = 20,
/// A SCALAR token.
YAML_SCALAR_TOKEN = 21,
}
/// The token structure.
#[derive(Default)]
#[non_exhaustive]
pub struct yaml_token_t {
pub struct Token {
/// The token type.
pub data: YamlTokenData,
pub data: TokenData,
/// The beginning of the token.
pub start_mark: yaml_mark_t,
pub start_mark: Mark,
/// The end of the token.
pub end_mark: yaml_mark_t,
pub end_mark: Mark,
}
#[derive(Default)]
pub enum YamlTokenData {
pub enum TokenData {
/// An empty token.
#[default]
NoToken,
/// A STREAM-START token.
StreamStart {
/// The stream encoding.
encoding: yaml_encoding_t,
encoding: Encoding,
},
/// A STREAM-END token.
StreamEnd,
@ -272,11 +222,11 @@ pub enum YamlTokenData {
/// The scalar value.
value: String,
/// The scalar style.
style: yaml_scalar_style_t,
style: ScalarStyle,
},
}
impl YamlTokenData {
impl TokenData {
/// Returns `true` if the yaml token data is [`VersionDirective`].
///
/// [`VersionDirective`]: YamlTokenData::VersionDirective
@ -385,31 +335,31 @@ impl YamlTokenData {
/// The event structure.
#[derive(Default, Debug)]
#[non_exhaustive]
pub struct yaml_event_t {
pub struct Event {
/// The event data.
pub data: YamlEventData,
pub data: EventData,
/// The beginning of the event.
pub start_mark: yaml_mark_t,
pub start_mark: Mark,
/// The end of the event.
pub end_mark: yaml_mark_t,
pub end_mark: Mark,
}
#[derive(Default, Debug)]
pub enum YamlEventData {
pub enum EventData {
#[default]
NoEvent,
/// The stream parameters (for YAML_STREAM_START_EVENT).
StreamStart {
/// The document encoding.
encoding: yaml_encoding_t,
encoding: Encoding,
},
StreamEnd,
/// The document parameters (for YAML_DOCUMENT_START_EVENT).
DocumentStart {
/// The version directive.
version_directive: Option<yaml_version_directive_t>,
version_directive: Option<VersionDirective>,
/// The tag directives list.
tag_directives: Vec<yaml_tag_directive_t>,
tag_directives: Vec<TagDirective>,
/// Is the document indicator implicit?
implicit: bool,
},
@ -435,7 +385,7 @@ pub enum YamlEventData {
/// Is the tag optional for any non-plain style?
quoted_implicit: bool,
/// The scalar style.
style: yaml_scalar_style_t,
style: ScalarStyle,
},
/// The sequence parameters (for YAML_SEQUENCE_START_EVENT).
SequenceStart {
@ -446,7 +396,7 @@ pub enum YamlEventData {
/// Is the tag optional?
implicit: bool,
/// The sequence style.
style: yaml_sequence_style_t,
style: SequenceStyle,
},
SequenceEnd,
/// The mapping parameters (for YAML_MAPPING_START_EVENT).
@ -458,7 +408,7 @@ pub enum YamlEventData {
/// Is the tag optional?
implicit: bool,
/// The mapping style.
style: yaml_mapping_style_t,
style: MappingStyle,
},
MappingEnd,
}
@ -466,20 +416,20 @@ pub enum YamlEventData {
/// The node structure.
#[derive(Clone, Default, Debug)]
#[non_exhaustive]
pub struct yaml_node_t {
pub struct Node {
/// The node type.
pub data: YamlNodeData,
pub data: NodeData,
/// The node tag.
pub tag: Option<String>,
/// The beginning of the node.
pub start_mark: yaml_mark_t,
pub start_mark: Mark,
/// The end of the node.
pub end_mark: yaml_mark_t,
pub end_mark: Mark,
}
/// Node types.
#[derive(Clone, Default, Debug)]
pub enum YamlNodeData {
pub enum NodeData {
/// An empty node.
#[default]
NoNode,
@ -488,30 +438,31 @@ pub enum YamlNodeData {
/// The scalar value.
value: String,
/// The scalar style.
style: yaml_scalar_style_t,
style: ScalarStyle,
},
/// A sequence node.
Sequence {
/// The stack of sequence items.
items: Vec<yaml_node_item_t>,
items: Vec<NodeItem>,
/// The sequence style.
style: yaml_sequence_style_t,
style: SequenceStyle,
},
/// A mapping node.
Mapping {
/// The stack of mapping pairs (key, value).
pairs: Vec<yaml_node_pair_t>,
pairs: Vec<NodePair>,
/// The mapping style.
style: yaml_mapping_style_t,
style: MappingStyle,
},
}
/// An element of a sequence node.
pub type yaml_node_item_t = i32;
pub type NodeItem = i32;
/// An element of a mapping node.
#[derive(Copy, Clone, Default, Debug)]
#[non_exhaustive]
pub struct yaml_node_pair_t {
pub struct NodePair {
/// The key of the element.
pub key: i32,
/// The value of the element.
@ -521,11 +472,11 @@ pub struct yaml_node_pair_t {
/// The document structure.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct yaml_document_t {
pub struct Document {
/// The document nodes.
pub nodes: Vec<yaml_node_t>,
pub nodes: Vec<Node>,
/// The version directive.
pub version_directive: Option<yaml_version_directive_t>,
pub version_directive: Option<VersionDirective>,
/// The list of tag directives.
///
/// ```
@ -538,21 +489,21 @@ pub struct yaml_document_t {
/// }
/// # };
/// ```
pub tag_directives: Vec<yaml_tag_directive_t>,
pub tag_directives: Vec<TagDirective>,
/// Is the document start indicator implicit?
pub start_implicit: bool,
/// Is the document end indicator implicit?
pub end_implicit: bool,
/// The beginning of the document.
pub start_mark: yaml_mark_t,
pub start_mark: Mark,
/// The end of the document.
pub end_mark: yaml_mark_t,
pub end_mark: Mark,
}
/// This structure holds information about a potential simple key.
#[derive(Copy, Clone)]
#[non_exhaustive]
pub struct yaml_simple_key_t {
pub struct SimpleKey {
/// Is a simple key possible?
pub possible: bool,
/// Is a simple key required?
@ -560,13 +511,13 @@ pub struct yaml_simple_key_t {
/// The number of the token.
pub token_number: usize,
/// The position mark.
pub mark: yaml_mark_t,
pub mark: Mark,
}
/// The states of the parser.
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_parser_state_t {
pub enum ParserState {
/// Expect STREAM-START.
#[default]
YAML_PARSE_STREAM_START_STATE = 0,
@ -620,13 +571,13 @@ pub enum yaml_parser_state_t {
/// This structure holds aliases data.
#[non_exhaustive]
pub struct yaml_alias_data_t {
pub struct AliasData {
/// The anchor.
pub anchor: String,
/// The node id.
pub index: i32,
/// The anchor mark.
pub mark: yaml_mark_t,
pub mark: Mark,
}
/// The parser structure.
@ -634,7 +585,7 @@ pub struct yaml_alias_data_t {
/// All members are internal. Manage the structure using the `yaml_parser_`
/// family of functions.
#[non_exhaustive]
pub struct yaml_parser_t<'r> {
pub struct Parser<'r> {
/// Read handler.
pub(crate) read_handler: Option<&'r mut dyn std::io::BufRead>,
/// EOF flag
@ -646,11 +597,11 @@ pub struct yaml_parser_t<'r> {
/// The number of unread characters in the buffer.
pub(crate) unread: usize,
/// The input encoding.
pub(crate) encoding: yaml_encoding_t,
pub(crate) encoding: Encoding,
/// The offset of the current position (in bytes).
pub(crate) offset: usize,
/// The mark of the current position.
pub(crate) mark: yaml_mark_t,
pub(crate) mark: Mark,
/// Have we started to scan the input stream?
pub(crate) stream_start_produced: bool,
/// Have we reached the end of the input stream?
@ -658,7 +609,7 @@ pub struct yaml_parser_t<'r> {
/// The number of unclosed '[' and '{' indicators.
pub(crate) flow_level: i32,
/// The tokens queue.
pub(crate) tokens: VecDeque<yaml_token_t>,
pub(crate) tokens: VecDeque<Token>,
/// The number of tokens fetched from the queue.
pub(crate) tokens_parsed: usize,
/// Does the tokens queue contain a token ready for dequeueing.
@ -670,20 +621,20 @@ pub struct yaml_parser_t<'r> {
/// May a simple key occur at the current position?
pub(crate) simple_key_allowed: bool,
/// The stack of simple keys.
pub(crate) simple_keys: Vec<yaml_simple_key_t>,
pub(crate) simple_keys: Vec<SimpleKey>,
/// The parser states stack.
pub(crate) states: Vec<yaml_parser_state_t>,
pub(crate) states: Vec<ParserState>,
/// The current parser state.
pub(crate) state: yaml_parser_state_t,
pub(crate) state: ParserState,
/// The stack of marks.
pub(crate) marks: Vec<yaml_mark_t>,
pub(crate) marks: Vec<Mark>,
/// The list of TAG directives.
pub(crate) tag_directives: Vec<yaml_tag_directive_t>,
pub(crate) tag_directives: Vec<TagDirective>,
/// The alias data.
pub(crate) aliases: Vec<yaml_alias_data_t>,
pub(crate) aliases: Vec<AliasData>,
}
impl<'r> Default for yaml_parser_t<'r> {
impl<'r> Default for Parser<'r> {
fn default() -> Self {
yaml_parser_new()
}
@ -692,7 +643,7 @@ impl<'r> Default for yaml_parser_t<'r> {
/// The emitter states.
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[non_exhaustive]
pub enum yaml_emitter_state_t {
pub enum EmitterState {
/// Expect STREAM-START.
#[default]
YAML_EMIT_STREAM_START_STATE = 0,
@ -733,7 +684,7 @@ pub enum yaml_emitter_state_t {
}
#[derive(Copy, Clone, Default)]
pub(crate) struct yaml_anchors_t {
pub(crate) struct Anchors {
/// The number of references.
pub references: i32,
/// The anchor id.
@ -747,7 +698,7 @@ pub(crate) struct yaml_anchors_t {
/// All members are internal. Manage the structure using the `yaml_emitter_`
/// family of functions.
#[non_exhaustive]
pub struct yaml_emitter_t<'w> {
pub struct Emitter<'w> {
/// Write handler.
pub(crate) write_handler: Option<&'w mut dyn std::io::Write>,
/// The working buffer.
@ -760,7 +711,7 @@ pub struct yaml_emitter_t<'w> {
/// UTF-16 encoded.
pub(crate) raw_buffer: Vec<u8>,
/// The stream encoding.
pub(crate) encoding: yaml_encoding_t,
pub(crate) encoding: Encoding,
/// If the output is in the canonical style?
pub(crate) canonical: bool,
/// The number of indentation spaces.
@ -770,17 +721,17 @@ pub struct yaml_emitter_t<'w> {
/// Allow unescaped non-ASCII characters?
pub(crate) unicode: bool,
/// The preferred line break.
pub(crate) line_break: yaml_break_t,
pub(crate) line_break: Break,
/// The stack of states.
pub(crate) states: Vec<yaml_emitter_state_t>,
pub(crate) states: Vec<EmitterState>,
/// The current emitter state.
pub(crate) state: yaml_emitter_state_t,
pub(crate) state: EmitterState,
/// The event queue.
pub(crate) events: VecDeque<yaml_event_t>,
pub(crate) events: VecDeque<Event>,
/// The stack of indentation levels.
pub(crate) indents: Vec<i32>,
/// The list of tag directives.
pub(crate) tag_directives: Vec<yaml_tag_directive_t>,
pub(crate) tag_directives: Vec<TagDirective>,
/// The current indentation level.
pub(crate) indent: i32,
/// The current flow level.
@ -809,12 +760,12 @@ pub struct yaml_emitter_t<'w> {
pub(crate) closed: bool,
/// The information associated with the document nodes.
// Note: Same length as `document.nodes`.
pub(crate) anchors: Vec<yaml_anchors_t>,
pub(crate) anchors: Vec<Anchors>,
/// The last assigned anchor id.
pub(crate) last_anchor_id: i32,
}
impl<'a> Default for yaml_emitter_t<'a> {
impl<'a> Default for Emitter<'a> {
fn default() -> Self {
yaml_emitter_new()
}