Mirrors/libyaml-safer
2
0
Fork 0
mirror of https://github.com/simonask/libyaml-safer synced 2024-11-26 05:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

Replace libc integer types with Rust integer types

Browse source
This commit is contained in:
Simon Ask Ulsnes 2024-02-02 11:10:04 +01:00
parent ac00cee574
commit 11c9cd60c9
9 changed files with 215 additions and 239 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
src/api.rs
View file

@ -3,7 +3,7 @@ use alloc::vec::Vec;
use crate::yaml::{YamlEventData, YamlNodeData};
use crate::{
libc, yaml_break_t, yaml_document_t, yaml_emitter_state_t, yaml_emitter_t, yaml_encoding_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_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_UTF8_ENCODING,
@ -172,12 +172,12 @@ pub fn yaml_emitter_set_canonical(emitter: &mut yaml_emitter_t, canonical: bool)
}
/// Set the indentation increment.
pub fn yaml_emitter_set_indent(emitter: &mut yaml_emitter_t, indent: libc::c_int) {
pub fn yaml_emitter_set_indent(emitter: &mut yaml_emitter_t, 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: libc::c_int) {
pub fn yaml_emitter_set_width(emitter: &mut yaml_emitter_t, width: i32) {
emitter.best_width = if width >= 0 { width } else { -1 };
}
@ -408,10 +408,7 @@ pub fn yaml_document_delete(document: &mut yaml_document_t) {
/// modifying the documents are called.
///
/// Returns the node object or NULL if `index` is out of range.
pub fn yaml_document_get_node(
document: &mut yaml_document_t,
index: libc::c_int,
) -> *mut yaml_node_t {
pub fn yaml_document_get_node(document: &mut yaml_document_t, index: i32) -> *mut yaml_node_t {
if index > 0 && index as usize <= document.nodes.len() {
return std::ptr::addr_of_mut!(document.nodes[index as usize - 1]);
}
@ -447,7 +444,7 @@ pub fn yaml_document_add_scalar(
tag: Option<&str>,
value: &str,
style: yaml_scalar_style_t,
) -> libc::c_int {
) -> i32 {
let mark = yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -466,7 +463,7 @@ pub fn yaml_document_add_scalar(
end_mark: mark,
};
document.nodes.push(node);
document.nodes.len() as libc::c_int
document.nodes.len() as i32
}
/// Create a SEQUENCE node and attach it to the document.
@ -479,7 +476,7 @@ pub fn yaml_document_add_sequence(
document: &mut yaml_document_t,
tag: Option<&str>,
style: yaml_sequence_style_t,
) -> libc::c_int {
) -> i32 {
let mark = yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -496,7 +493,7 @@ pub fn yaml_document_add_sequence(
end_mark: mark,
};
document.nodes.push(node);
document.nodes.len() as libc::c_int
document.nodes.len() as i32
}
/// Create a MAPPING node and attach it to the document.
@ -509,7 +506,7 @@ pub fn yaml_document_add_mapping(
document: &mut yaml_document_t,
tag: Option<&str>,
style: yaml_mapping_style_t,
) -> libc::c_int {
) -> i32 {
let mark = yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -527,14 +524,14 @@ pub fn yaml_document_add_mapping(
};
document.nodes.push(node);
document.nodes.len() as libc::c_int
document.nodes.len() as i32
}
/// Add an item to a SEQUENCE node.
pub fn yaml_document_append_sequence_item(
document: &mut yaml_document_t,
sequence: libc::c_int,
item: libc::c_int,
sequence: i32,
item: i32,
) {
__assert!(sequence > 0 && sequence as usize - 1 < document.nodes.len());
__assert!(matches!(
@ -552,9 +549,9 @@ 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,
mapping: libc::c_int,
key: libc::c_int,
value: libc::c_int,
mapping: i32,
key: i32,
value: i32,
) {
__assert!(mapping > 0 && mapping as usize - 1 < document.nodes.len());
__assert!(matches!(

12
src/dumper.rs
View file

@ -5,7 +5,7 @@ use crate::yaml::{
yaml_anchors_t, yaml_document_t, yaml_emitter_t, yaml_event_t, yaml_node_t, YamlEventData,
YamlNodeData, YAML_ANY_ENCODING,
};
use crate::{libc, yaml_document_delete, yaml_emitter_emit, EmitterError};
use crate::{yaml_document_delete, yaml_emitter_emit, EmitterError};
/// Start a YAML stream.
///
@ -112,7 +112,7 @@ fn yaml_emitter_delete_document_and_anchors(
emitter.last_anchor_id = 0;
}
fn yaml_emitter_anchor_node_sub(emitter: &mut yaml_emitter_t, index: libc::c_int) {
fn yaml_emitter_anchor_node_sub(emitter: &mut yaml_emitter_t, index: i32) {
emitter.anchors[index as usize - 1].references += 1;
if emitter.anchors[index as usize - 1].references == 2 {
emitter.last_anchor_id += 1;
@ -123,7 +123,7 @@ fn yaml_emitter_anchor_node_sub(emitter: &mut yaml_emitter_t, index: libc::c_int
fn yaml_emitter_anchor_node(
emitter: &mut yaml_emitter_t,
document: &mut yaml_document_t,
index: libc::c_int,
index: i32,
) {
let node = &document.nodes[index as usize - 1];
emitter.anchors[index as usize - 1].references += 1;
@ -148,17 +148,17 @@ fn yaml_emitter_anchor_node(
}
}
fn yaml_emitter_generate_anchor(_emitter: &mut yaml_emitter_t, anchor_id: libc::c_int) -> String {
fn yaml_emitter_generate_anchor(_emitter: &mut yaml_emitter_t, 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,
index: libc::c_int,
index: i32,
) -> Result<(), EmitterError> {
let node = &mut document.nodes[index as usize - 1];
let anchor_id: libc::c_int = emitter.anchors[index as usize - 1].anchor;
let anchor_id: i32 = emitter.anchors[index as usize - 1].anchor;
let mut anchor: Option<String> = None;
if anchor_id != 0 {
anchor = Some(yaml_emitter_generate_anchor(emitter, anchor_id));

32
src/emitter.rs
View file

@ -7,20 +7,20 @@ use crate::macros::{
use crate::ops::ForceMul as _;
use crate::yaml::YamlEventData;
use crate::{
libc, 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, 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,
};
fn FLUSH(emitter: &mut yaml_emitter_t) -> Result<(), WriterError> {
@ -291,7 +291,7 @@ fn yaml_emitter_emit_stream_start(
emitter.best_width = 80;
}
if emitter.best_width < 0 {
emitter.best_width = libc::c_int::MAX;
emitter.best_width = i32::MAX;
}
if emitter.line_break == YAML_ANY_BREAK {
emitter.line_break = YAML_LN_BREAK;
@ -1264,7 +1264,7 @@ fn yaml_emitter_write_bom(emitter: &mut yaml_emitter_t) -> Result<(), EmitterErr
}
fn yaml_emitter_write_indent(emitter: &mut yaml_emitter_t) -> Result<(), EmitterError> {
let indent: libc::c_int = if emitter.indent >= 0 {
let indent = if emitter.indent >= 0 {
emitter.indent
} else {
0

2
src/error.rs
View file

@ -21,7 +21,7 @@ pub enum ReaderError {
#[error("{problem}")]
Problem {
problem: &'static str,
offset: u64,
offset: usize,
value: i32,
},
#[error(transparent)]

6
src/lib.rs
View file

@ -38,12 +38,6 @@ extern crate alloc;
use core::mem::size_of;
mod libc {
pub use core::primitive::{
i32 as c_int, i64 as c_long, u32 as c_uint, u64 as c_ulong, u8 as c_uchar,
};
}
#[macro_use]
mod externs {
macro_rules! __assert {

34
src/loader.rs
View file

@ -3,7 +3,7 @@ use alloc::{vec, vec::Vec};
use crate::yaml::{YamlEventData, YamlNodeData};
use crate::{
libc, yaml_alias_data_t, yaml_document_new, yaml_document_t, yaml_event_t, yaml_mark_t,
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,
};
@ -118,7 +118,7 @@ fn yaml_parser_load_document(
fn yaml_parser_load_nodes(
parser: &mut yaml_parser_t,
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let end_implicit;
let end_mark;
@ -163,7 +163,7 @@ fn yaml_parser_load_nodes(
fn yaml_parser_register_anchor(
parser: &mut yaml_parser_t,
document: &mut yaml_document_t,
index: libc::c_int,
index: i32,
anchor: Option<String>,
) -> Result<(), ComposerError> {
let Some(anchor) = anchor else {
@ -190,13 +190,13 @@ fn yaml_parser_register_anchor(
fn yaml_parser_load_node_add(
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
index: libc::c_int,
ctx: &mut Vec<i32>,
index: i32,
) -> Result<(), ComposerError> {
if ctx.is_empty() {
return Ok(());
}
let parent_index: libc::c_int = *ctx.last().unwrap();
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, .. } => {
@ -229,7 +229,7 @@ fn yaml_parser_load_alias(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let anchor: &str = if let YamlEventData::Alias { anchor } = &event.data {
anchor
@ -250,7 +250,7 @@ fn yaml_parser_load_scalar(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let YamlEventData::Scalar {
mut tag,
@ -273,7 +273,7 @@ fn yaml_parser_load_scalar(
end_mark: event.end_mark,
};
document.nodes.push(node);
let index: libc::c_int = document.nodes.len() as libc::c_int;
let index: i32 = document.nodes.len() as i32;
yaml_parser_register_anchor(parser, document, index, anchor)?;
yaml_parser_load_node_add(document, ctx, index)
}
@ -282,7 +282,7 @@ fn yaml_parser_load_sequence(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let YamlEventData::SequenceStart {
anchor,
@ -311,7 +311,7 @@ fn yaml_parser_load_sequence(
};
document.nodes.push(node);
let index: libc::c_int = document.nodes.len() as libc::c_int;
let index: i32 = document.nodes.len() as i32;
yaml_parser_register_anchor(parser, document, index, anchor.clone())?;
yaml_parser_load_node_add(document, ctx, index)?;
ctx.push(index);
@ -322,10 +322,10 @@ fn yaml_parser_load_sequence_end(
_parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
__assert!(!ctx.is_empty());
let index: libc::c_int = *ctx.last().unwrap();
let index: i32 = *ctx.last().unwrap();
__assert!(matches!(
document.nodes[index as usize - 1].data,
YamlNodeData::Sequence { .. }
@ -339,7 +339,7 @@ fn yaml_parser_load_mapping(
parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
let YamlEventData::MappingStart {
anchor,
@ -366,7 +366,7 @@ fn yaml_parser_load_mapping(
end_mark: event.end_mark,
};
document.nodes.push(node);
let index: libc::c_int = document.nodes.len() as libc::c_int;
let index: i32 = document.nodes.len() as i32;
yaml_parser_register_anchor(parser, document, index, anchor)?;
yaml_parser_load_node_add(document, ctx, index)?;
ctx.push(index);
@ -377,10 +377,10 @@ fn yaml_parser_load_mapping_end(
_parser: &mut yaml_parser_t,
event: yaml_event_t,
document: &mut yaml_document_t,
ctx: &mut Vec<libc::c_int>,
ctx: &mut Vec<i32>,
) -> Result<(), ComposerError> {
__assert!(!ctx.is_empty());
let index: libc::c_int = *ctx.last().unwrap();
let index: i32 = *ctx.last().unwrap();
__assert!(matches!(
document.nodes[index as usize - 1].data,
YamlNodeData::Mapping { .. }

21
src/reader.rs
View file

@ -2,16 +2,15 @@ use alloc::collections::VecDeque;
use crate::api::INPUT_RAW_BUFFER_SIZE;
use crate::macros::vecdeque_starts_with;
use crate::yaml::size_t;
use crate::{
libc, yaml_parser_t, ReaderError, YAML_ANY_ENCODING, YAML_UTF16BE_ENCODING,
YAML_UTF16LE_ENCODING, YAML_UTF8_ENCODING,
yaml_parser_t, ReaderError, YAML_ANY_ENCODING, YAML_UTF16BE_ENCODING, YAML_UTF16LE_ENCODING,
YAML_UTF8_ENCODING,
};
fn yaml_parser_set_reader_error<T>(
_parser: &mut yaml_parser_t,
problem: &'static str,
offset: u64,
offset: usize,
value: i32,
) -> Result<T, ReaderError> {
Err(ReaderError::Problem {
@ -200,14 +199,14 @@ fn push_char(parser: &mut yaml_parser_t, ch: char) -> Result<(), ReaderError> {
);
}
parser.buffer.push_back(ch);
parser.offset += ch.len_utf8() as u64;
parser.offset += ch.len_utf8();
parser.unread += 1;
Ok(())
}
pub(crate) fn yaml_parser_update_buffer(
parser: &mut yaml_parser_t,
length: size_t,
length: usize,
) -> Result<(), ReaderError> {
let mut first = true;
__assert!((parser.read_handler).is_some());
@ -259,7 +258,7 @@ pub(crate) fn yaml_parser_update_buffer(
return yaml_parser_set_reader_error(
parser,
"invalid trailing UTF-8 octet",
parser.offset + offset as u64,
parser.offset + offset,
parser.raw_buffer[offset] as _,
);
}
@ -310,7 +309,7 @@ pub(crate) fn yaml_parser_update_buffer(
parser,
"unexpected low surrogate area",
parser.offset,
value as libc::c_int,
value as i32,
);
}
// Some(Err(Utf16Error::IncompleteSurrogatePair)) => {
@ -326,7 +325,7 @@ pub(crate) fn yaml_parser_update_buffer(
parser,
"expected low surrogate area",
parser.offset + 2,
value as libc::c_int,
value as i32,
);
}
Some(Err(Utf16Error::InvalidUnicode(value))) => {
@ -334,7 +333,7 @@ pub(crate) fn yaml_parser_update_buffer(
parser,
"invalid Unicode character",
parser.offset,
value as libc::c_int,
value as i32,
);
}
None => (),
@ -346,7 +345,7 @@ pub(crate) fn yaml_parser_update_buffer(
}
}
if parser.offset >= (!0_u64).wrapping_div(2_u64) {
if parser.offset >= (!0_usize).wrapping_div(2_usize) {
return yaml_parser_set_reader_error(parser, "input is too long", parser.offset, -1);
}
Ok(())

253
src/scanner.rs
View file

@ -3,14 +3,14 @@ use alloc::string::String;
use crate::macros::{is_blankz, is_break, vecdeque_starts_with};
use crate::ops::{ForceAdd as _, ForceMul as _};
use crate::reader::yaml_parser_update_buffer;
use crate::yaml::{ptrdiff_t, size_t, YamlTokenData};
use crate::yaml::YamlTokenData;
use crate::{
libc, yaml_mark_t, yaml_parser_t, yaml_simple_key_t, yaml_token_t, ReaderError, ScannerError,
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,
};
fn CACHE(parser: &mut yaml_parser_t, length: size_t) -> Result<(), ReaderError> {
fn CACHE(parser: &mut yaml_parser_t, length: usize) -> Result<(), ReaderError> {
if parser.unread >= length {
Ok(())
} else {
@ -160,15 +160,15 @@ pub(crate) fn yaml_parser_fetch_more_tokens(
}
fn yaml_parser_fetch_next_token(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if !parser.stream_start_produced {
yaml_parser_fetch_stream_start(parser);
return Ok(());
}
yaml_parser_scan_to_next_token(parser)?;
yaml_parser_stale_simple_keys(parser)?;
yaml_parser_unroll_indent(parser, parser.mark.column as ptrdiff_t);
CACHE(parser, 4_u64)?;
yaml_parser_unroll_indent(parser, parser.mark.column as i64);
CACHE(parser, 4)?;
if IS_Z!(parser.buffer) {
return yaml_parser_fetch_stream_end(parser);
}
@ -293,15 +293,12 @@ fn yaml_parser_stale_simple_keys(parser: &mut yaml_parser_t) -> Result<(), Scann
}
fn yaml_parser_save_simple_key(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
let required =
parser.flow_level == 0 && parser.indent as libc::c_long == parser.mark.column as ptrdiff_t;
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 {
possible: true,
required,
token_number: parser
.tokens_parsed
.force_add(parser.tokens.len() as libc::c_ulong),
token_number: parser.tokens_parsed.force_add(parser.tokens.len()),
mark: parser.mark,
};
yaml_parser_remove_simple_key(parser)?;
@ -331,7 +328,7 @@ fn yaml_parser_increase_flow_level(parser: &mut yaml_parser_t) -> Result<(), Sca
let empty_simple_key = yaml_simple_key_t {
possible: false,
required: false,
token_number: 0_u64,
token_number: 0,
mark: yaml_mark_t {
index: 0_u64,
line: 0_u64,
@ -340,7 +337,7 @@ fn yaml_parser_increase_flow_level(parser: &mut yaml_parser_t) -> Result<(), Sca
};
parser.simple_keys.push(empty_simple_key);
assert!(
!(parser.flow_level == libc::c_int::MAX),
!(parser.flow_level == i32::MAX),
"parser.flow_level integer overflow"
);
parser.flow_level += 1;
@ -356,21 +353,18 @@ fn yaml_parser_decrease_flow_level(parser: &mut yaml_parser_t) {
fn yaml_parser_roll_indent(
parser: &mut yaml_parser_t,
column: ptrdiff_t,
number: ptrdiff_t,
column: i64,
number: i64,
data: YamlTokenData,
mark: yaml_mark_t,
) -> Result<(), ScannerError> {
if parser.flow_level != 0 {
return Ok(());
}
if (parser.indent as libc::c_long) < column {
if parser.indent < column as i32 {
parser.indents.push(parser.indent);
assert!(
!(column > ptrdiff_t::from(libc::c_int::MAX)),
"integer overflow"
);
parser.indent = column as libc::c_int;
assert!(!(column > i32::MAX as i64), "integer overflow");
parser.indent = column as i32;
let token = yaml_token_t {
data,
start_mark: mark,
@ -380,7 +374,7 @@ fn yaml_parser_roll_indent(
parser.tokens.push_back(token);
} else {
parser.tokens.insert(
(number as libc::c_ulong).wrapping_sub(parser.tokens_parsed) as usize,
(number as usize).wrapping_sub(parser.tokens_parsed) as usize,
token,
);
}
@ -388,11 +382,11 @@ fn yaml_parser_roll_indent(
Ok(())
}
fn yaml_parser_unroll_indent(parser: &mut yaml_parser_t, column: ptrdiff_t) {
fn yaml_parser_unroll_indent(parser: &mut yaml_parser_t, column: i64) {
if parser.flow_level != 0 {
return;
}
while parser.indent as libc::c_long > column {
while parser.indent as i64 > column {
let token = yaml_token_t {
data: YamlTokenData::BlockEnd,
start_mark: parser.mark,
@ -407,11 +401,11 @@ fn yaml_parser_fetch_stream_start(parser: &mut yaml_parser_t) {
let simple_key = yaml_simple_key_t {
possible: false,
required: false,
token_number: 0_u64,
token_number: 0,
mark: yaml_mark_t {
index: 0_u64,
line: 0_u64,
column: 0_u64,
index: 0,
line: 0,
column: 0,
},
};
parser.indent = -1;
@ -542,7 +536,7 @@ fn yaml_parser_fetch_block_entry(parser: &mut yaml_parser_t) -> Result<(), Scann
}
yaml_parser_roll_indent(
parser,
parser.mark.column as ptrdiff_t,
parser.mark.column as _,
-1_i64,
YamlTokenData::BlockSequenceStart,
parser.mark,
@ -574,7 +568,7 @@ fn yaml_parser_fetch_key(parser: &mut yaml_parser_t) -> Result<(), ScannerError>
}
yaml_parser_roll_indent(
parser,
parser.mark.column as ptrdiff_t,
parser.mark.column as _,
-1_i64,
YamlTokenData::BlockMappingStart,
parser.mark,
@ -606,8 +600,8 @@ fn yaml_parser_fetch_value(parser: &mut yaml_parser_t) -> Result<(), ScannerErro
simple_key.token_number.wrapping_sub(parser.tokens_parsed) as usize,
token,
);
let mark_column = simple_key.mark.column as ptrdiff_t;
let token_number = simple_key.token_number as ptrdiff_t;
let mark_column = simple_key.mark.column as _;
let token_number = simple_key.token_number as _;
let mark = simple_key.mark;
simple_key.possible = false;
yaml_parser_roll_indent(
@ -630,7 +624,7 @@ fn yaml_parser_fetch_value(parser: &mut yaml_parser_t) -> Result<(), ScannerErro
}
yaml_parser_roll_indent(
parser,
parser.mark.column as ptrdiff_t,
parser.mark.column as _,
-1_i64,
YamlTokenData::BlockMappingStart,
parser.mark,
@ -706,27 +700,27 @@ fn yaml_parser_fetch_plain_scalar(parser: &mut yaml_parser_t) -> Result<(), Scan
fn yaml_parser_scan_to_next_token(parser: &mut yaml_parser_t) -> Result<(), ScannerError> {
loop {
CACHE(parser, 1_u64)?;
if parser.mark.column == 0_u64 && IS_BOM!(parser.buffer) {
CACHE(parser, 1)?;
if parser.mark.column == 0 && IS_BOM!(parser.buffer) {
SKIP(parser);
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
while CHECK!(parser.buffer, ' ')
|| (parser.flow_level != 0 || !parser.simple_key_allowed) && CHECK!(parser.buffer, '\t')
{
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if CHECK!(parser.buffer, '#') {
while !IS_BREAKZ!(parser.buffer) {
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
}
if !IS_BREAK!(parser.buffer) {
break;
}
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
SKIP_LINE(parser);
if parser.flow_level == 0 {
parser.simple_key_allowed = true;
@ -740,8 +734,8 @@ fn yaml_parser_scan_directive(
token: &mut yaml_token_t,
) -> Result<(), ScannerError> {
let end_mark: yaml_mark_t;
let mut major: libc::c_int = 0;
let mut minor: libc::c_int = 0;
let mut major: i32 = 0;
let mut minor: i32 = 0;
let start_mark: yaml_mark_t = parser.mark;
SKIP(parser);
let name = yaml_parser_scan_directive_name(parser, start_mark)?;
@ -770,13 +764,13 @@ fn yaml_parser_scan_directive(
"found unknown directive name",
);
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
loop {
if !IS_BLANK!(parser.buffer) {
break;
}
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if CHECK!(parser.buffer, '#') {
@ -785,7 +779,7 @@ fn yaml_parser_scan_directive(
break;
}
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
}
@ -798,7 +792,7 @@ fn yaml_parser_scan_directive(
)
} else {
if IS_BREAK!(parser.buffer) {
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
SKIP_LINE(parser);
}
Ok(())
@ -810,14 +804,14 @@ fn yaml_parser_scan_directive_name(
start_mark: yaml_mark_t,
) -> Result<String, ScannerError> {
let mut string = String::new();
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
loop {
if !IS_ALPHA!(parser.buffer) {
break;
}
READ_STRING(parser, &mut string);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if string.is_empty() {
@ -842,13 +836,13 @@ fn yaml_parser_scan_directive_name(
fn yaml_parser_scan_version_directive_value(
parser: &mut yaml_parser_t,
start_mark: yaml_mark_t,
major: &mut libc::c_int,
minor: &mut libc::c_int,
major: &mut i32,
minor: &mut i32,
) -> Result<(), ScannerError> {
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
while IS_BLANK!(parser.buffer) {
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
yaml_parser_scan_version_directive_number(parser, start_mark, major)?;
if !CHECK!(parser.buffer, '.') {
@ -868,11 +862,11 @@ const MAX_NUMBER_LENGTH: u64 = 9_u64;
fn yaml_parser_scan_version_directive_number(
parser: &mut yaml_parser_t,
start_mark: yaml_mark_t,
number: &mut libc::c_int,
number: &mut i32,
) -> Result<(), ScannerError> {
let mut value: libc::c_int = 0;
let mut length: size_t = 0_u64;
CACHE(parser, 1_u64)?;
let mut value: i32 = 0;
let mut length = 0;
CACHE(parser, 1)?;
while IS_DIGIT!(parser.buffer) {
length = length.force_add(1);
if length > MAX_NUMBER_LENGTH {
@ -887,7 +881,7 @@ fn yaml_parser_scan_version_directive_number(
.force_mul(10)
.force_add(AS_DIGIT!(parser.buffer) as i32);
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if length == 0 {
return yaml_parser_set_scanner_error(
@ -906,16 +900,16 @@ fn yaml_parser_scan_tag_directive_value(
parser: &mut yaml_parser_t,
start_mark: yaml_mark_t,
) -> Result<(String, String), ScannerError> {
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
loop {
if IS_BLANK!(parser.buffer) {
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
} else {
let handle_value = yaml_parser_scan_tag_handle(parser, true, start_mark)?;
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if !IS_BLANK!(parser.buffer) {
return yaml_parser_set_scanner_error(
@ -927,11 +921,11 @@ fn yaml_parser_scan_tag_directive_value(
} else {
while IS_BLANK!(parser.buffer) {
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
let prefix_value = yaml_parser_scan_tag_uri(parser, true, true, None, start_mark)?;
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if !IS_BLANKZ!(parser.buffer) {
return yaml_parser_set_scanner_error(
@ -953,19 +947,19 @@ fn yaml_parser_scan_anchor(
token: &mut yaml_token_t,
scan_alias_instead_of_anchor: bool,
) -> Result<(), ScannerError> {
let mut length: libc::c_int = 0;
let mut length: i32 = 0;
let mut string = String::new();
let start_mark: yaml_mark_t = parser.mark;
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
loop {
if !IS_ALPHA!(parser.buffer) {
break;
}
READ_STRING(parser, &mut string);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
length += 1;
}
let end_mark: yaml_mark_t = parser.mark;
@ -1013,7 +1007,7 @@ fn yaml_parser_scan_tag(
let start_mark: yaml_mark_t = parser.mark;
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
if CHECK_AT!(parser.buffer, '<', 1) {
handle = String::new();
@ -1044,7 +1038,7 @@ fn yaml_parser_scan_tag(
}
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if !IS_BLANKZ!(parser.buffer) {
if parser.flow_level == 0 || !CHECK!(parser.buffer, ',') {
return yaml_parser_set_scanner_error(
@ -1074,7 +1068,7 @@ fn yaml_parser_scan_tag_handle(
start_mark: yaml_mark_t,
) -> Result<String, ScannerError> {
let mut string = String::new();
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if !CHECK!(parser.buffer, '!') {
return yaml_parser_set_scanner_error(
@ -1090,13 +1084,13 @@ fn yaml_parser_scan_tag_handle(
}
READ_STRING(parser, &mut string);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
loop {
if !IS_ALPHA!(parser.buffer) {
break;
}
READ_STRING(parser, &mut string);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if CHECK!(parser.buffer, '!') {
READ_STRING(parser, &mut string);
@ -1125,7 +1119,7 @@ fn yaml_parser_scan_tag_uri(
if length > 1 {
string = String::from(&head[1..]);
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
while IS_ALPHA!(parser.buffer)
|| CHECK!(parser.buffer, ';')
@ -1156,7 +1150,7 @@ fn yaml_parser_scan_tag_uri(
READ_STRING(parser, &mut string);
}
length = length.force_add(1);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if length == 0 {
yaml_parser_set_scanner_error(
@ -1180,9 +1174,9 @@ fn yaml_parser_scan_uri_escapes(
start_mark: yaml_mark_t,
string: &mut String,
) -> Result<(), ScannerError> {
let mut width: libc::c_int = 0;
let mut width: i32 = 0;
loop {
CACHE(parser, 3_u64)?;
CACHE(parser, 3)?;
if !(CHECK!(parser.buffer, '%')
&& IS_HEX_AT!(parser.buffer, 1)
&& IS_HEX_AT!(parser.buffer, 2))
@ -1198,8 +1192,7 @@ fn yaml_parser_scan_uri_escapes(
"did not find URI escaped octet",
);
}
let octet: libc::c_uchar =
((AS_HEX_AT!(parser.buffer, 1) << 4) + AS_HEX_AT!(parser.buffer, 2)) as libc::c_uchar;
let octet = ((AS_HEX_AT!(parser.buffer, 1) << 4) + AS_HEX_AT!(parser.buffer, 2)) as u8;
if width == 0 {
width = if octet & 0x80 == 0 {
1
@ -1258,19 +1251,19 @@ fn yaml_parser_scan_block_scalar(
let mut string = String::new();
let mut leading_break = String::new();
let mut trailing_breaks = String::new();
let mut chomping: libc::c_int = 0;
let mut increment: libc::c_int = 0;
let mut indent: libc::c_int = 0;
let mut leading_blank: libc::c_int = 0;
let mut trailing_blank: libc::c_int;
let mut chomping: i32 = 0;
let mut increment: i32 = 0;
let mut indent: i32 = 0;
let mut leading_blank: i32 = 0;
let mut trailing_blank: i32;
let start_mark: yaml_mark_t = parser.mark;
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if CHECK!(parser.buffer, '+') || CHECK!(parser.buffer, '-') {
chomping = if CHECK!(parser.buffer, '+') { 1 } else { -1 };
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if IS_DIGIT!(parser.buffer) {
if CHECK!(parser.buffer, '0') {
return yaml_parser_set_scanner_error(
@ -1295,7 +1288,7 @@ fn yaml_parser_scan_block_scalar(
} else {
increment = AS_DIGIT!(parser.buffer) as i32;
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if CHECK!(parser.buffer, '+') || CHECK!(parser.buffer, '-') {
chomping = if CHECK!(parser.buffer, '+') { 1 } else { -1 };
SKIP(parser);
@ -1303,13 +1296,13 @@ fn yaml_parser_scan_block_scalar(
}
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
loop {
if !IS_BLANK!(parser.buffer) {
break;
}
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if CHECK!(parser.buffer, '#') {
@ -1318,7 +1311,7 @@ fn yaml_parser_scan_block_scalar(
break;
}
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
}
@ -1332,7 +1325,7 @@ fn yaml_parser_scan_block_scalar(
}
if IS_BREAK!(parser.buffer) {
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
SKIP_LINE(parser);
}
@ -1352,13 +1345,13 @@ fn yaml_parser_scan_block_scalar(
&mut end_mark,
)?;
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
loop {
if !(parser.mark.column as libc::c_int == indent && !IS_Z!(parser.buffer)) {
if !(parser.mark.column as i32 == indent && !IS_Z!(parser.buffer)) {
break;
}
trailing_blank = IS_BLANK!(parser.buffer) as libc::c_int;
trailing_blank = IS_BLANK!(parser.buffer) as i32;
if !literal && leading_break.starts_with('\n') && leading_blank == 0 && trailing_blank == 0
{
if trailing_breaks.is_empty() {
@ -1371,12 +1364,12 @@ fn yaml_parser_scan_block_scalar(
}
string.push_str(&trailing_breaks);
trailing_breaks.clear();
leading_blank = IS_BLANK!(parser.buffer) as libc::c_int;
leading_blank = IS_BLANK!(parser.buffer) as i32;
while !IS_BREAKZ!(parser.buffer) {
READ_STRING(parser, &mut string);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
READ_LINE_STRING(parser, &mut leading_break);
yaml_parser_scan_block_scalar_breaks(
parser,
@ -1413,26 +1406,23 @@ fn yaml_parser_scan_block_scalar(
fn yaml_parser_scan_block_scalar_breaks(
parser: &mut yaml_parser_t,
indent: &mut libc::c_int,
indent: &mut i32,
breaks: &mut String,
start_mark: yaml_mark_t,
end_mark: &mut yaml_mark_t,
) -> Result<(), ScannerError> {
let mut max_indent: libc::c_int = 0;
let mut max_indent: i32 = 0;
*end_mark = parser.mark;
loop {
CACHE(parser, 1_u64)?;
while (*indent == 0 || (parser.mark.column as libc::c_int) < *indent)
&& IS_SPACE!(parser.buffer)
{
CACHE(parser, 1)?;
while (*indent == 0 || (parser.mark.column as i32) < *indent) && IS_SPACE!(parser.buffer) {
SKIP(parser);
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if parser.mark.column as libc::c_int > max_indent {
max_indent = parser.mark.column as libc::c_int;
if parser.mark.column as i32 > max_indent {
max_indent = parser.mark.column as i32;
}
if (*indent == 0 || (parser.mark.column as libc::c_int) < *indent) && IS_TAB!(parser.buffer)
{
if (*indent == 0 || (parser.mark.column as i32) < *indent) && IS_TAB!(parser.buffer) {
return yaml_parser_set_scanner_error(
parser,
"while scanning a block scalar",
@ -1443,7 +1433,7 @@ fn yaml_parser_scan_block_scalar_breaks(
if !IS_BREAK!(parser.buffer) {
break;
}
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
READ_LINE_STRING(parser, breaks);
*end_mark = parser.mark;
}
@ -1473,9 +1463,9 @@ fn yaml_parser_scan_flow_scalar(
let start_mark: yaml_mark_t = parser.mark;
SKIP(parser);
loop {
CACHE(parser, 4_u64)?;
CACHE(parser, 4)?;
if parser.mark.column == 0_u64
if parser.mark.column == 0
&& (CHECK_AT!(parser.buffer, '-', 0)
&& CHECK_AT!(parser.buffer, '-', 1)
&& CHECK_AT!(parser.buffer, '-', 2)
@ -1498,7 +1488,7 @@ fn yaml_parser_scan_flow_scalar(
"found unexpected end of stream",
);
} else {
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
leading_blanks = false;
while !IS_BLANKZ!(parser.buffer) {
if single && CHECK_AT!(parser.buffer, '\'', 0) && CHECK_AT!(parser.buffer, '\'', 1)
@ -1511,13 +1501,13 @@ fn yaml_parser_scan_flow_scalar(
break;
}
if !single && CHECK!(parser.buffer, '\\') && IS_BREAK_AT!(parser.buffer, 1) {
CACHE(parser, 3_u64)?;
CACHE(parser, 3)?;
SKIP(parser);
SKIP_LINE(parser);
leading_blanks = true;
break;
} else if !single && CHECK!(parser.buffer, '\\') {
let mut code_length: size_t = 0_u64;
let mut code_length = 0usize;
match parser.buffer.get(1).copied().unwrap() {
'0' => {
string.push('\0');
@ -1583,13 +1573,13 @@ fn yaml_parser_scan_flow_scalar(
// string.push('\xA9');
}
'x' => {
code_length = 2_u64;
code_length = 2;
}
'u' => {
code_length = 4_u64;
code_length = 4;
}
'U' => {
code_length = 8_u64;
code_length = 8;
}
_ => {
return yaml_parser_set_scanner_error(
@ -1603,10 +1593,9 @@ fn yaml_parser_scan_flow_scalar(
SKIP(parser);
SKIP(parser);
if code_length != 0 {
let mut value: libc::c_uint = 0;
let mut k: size_t;
let mut value: u32 = 0;
let mut k = 0;
CACHE(parser, code_length)?;
k = 0_u64;
while k < code_length {
if !IS_HEX_AT!(parser.buffer, k as usize) {
return yaml_parser_set_scanner_error(
@ -1632,7 +1621,7 @@ fn yaml_parser_scan_flow_scalar(
);
}
k = 0_u64;
k = 0;
while k < code_length {
SKIP(parser);
k = k.force_add(1);
@ -1642,13 +1631,13 @@ fn yaml_parser_scan_flow_scalar(
READ_STRING(parser, &mut string);
}
}
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
if CHECK!(parser.buffer, if single { '\'' } else { '"' }) {
break;
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
while IS_BLANK!(parser.buffer) || IS_BREAK!(parser.buffer) {
if IS_BLANK!(parser.buffer) {
if !leading_blanks {
@ -1657,7 +1646,7 @@ fn yaml_parser_scan_flow_scalar(
SKIP(parser);
}
} else {
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
if !leading_blanks {
whitespaces.clear();
READ_LINE_STRING(parser, &mut leading_break);
@ -1666,7 +1655,7 @@ fn yaml_parser_scan_flow_scalar(
READ_LINE_STRING(parser, &mut trailing_breaks);
}
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if leading_blanks {
if leading_break.starts_with('\n') {
@ -1717,12 +1706,12 @@ fn yaml_parser_scan_plain_scalar(
let mut trailing_breaks = String::new();
let mut whitespaces = String::new();
let mut leading_blanks = false;
let indent: libc::c_int = parser.indent + 1;
let indent: i32 = parser.indent + 1;
end_mark = parser.mark;
let start_mark: yaml_mark_t = end_mark;
loop {
CACHE(parser, 4_u64)?;
if parser.mark.column == 0_u64
CACHE(parser, 4)?;
if parser.mark.column == 0
&& (CHECK_AT!(parser.buffer, '-', 0)
&& CHECK_AT!(parser.buffer, '-', 1)
&& CHECK_AT!(parser.buffer, '-', 2)
@ -1787,19 +1776,17 @@ fn yaml_parser_scan_plain_scalar(
}
READ_STRING(parser, &mut string);
end_mark = parser.mark;
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
}
}
if !(IS_BLANK!(parser.buffer) || IS_BREAK!(parser.buffer)) {
break;
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
while IS_BLANK!(parser.buffer) || IS_BREAK!(parser.buffer) {
if IS_BLANK!(parser.buffer) {
if leading_blanks
&& (parser.mark.column as libc::c_int) < indent
&& IS_TAB!(parser.buffer)
if leading_blanks && (parser.mark.column as i32) < indent && IS_TAB!(parser.buffer)
{
return yaml_parser_set_scanner_error(
parser,
@ -1813,7 +1800,7 @@ fn yaml_parser_scan_plain_scalar(
SKIP(parser);
}
} else {
CACHE(parser, 2_u64)?;
CACHE(parser, 2)?;
if !leading_blanks {
whitespaces.clear();
@ -1823,9 +1810,9 @@ fn yaml_parser_scan_plain_scalar(
READ_LINE_STRING(parser, &mut trailing_breaks);
}
}
CACHE(parser, 1_u64)?;
CACHE(parser, 1)?;
}
if parser.flow_level == 0 && (parser.mark.column as libc::c_int) < indent {
if parser.flow_level == 0 && (parser.mark.column as i32) < indent {
break;
}
}

61
src/yaml.rs
View file

@ -2,10 +2,9 @@ use alloc::collections::VecDeque;
use alloc::string::String;
use alloc::vec::Vec;
use crate::{api::yaml_parser_new, libc, yaml_emitter_new};
use crate::{api::yaml_parser_new, yaml_emitter_new};
pub use self::yaml_encoding_t::*;
pub use core::primitive::{i64 as ptrdiff_t, u64 as size_t};
/// The version directive data.
#[derive(Clone, Copy, Debug)]
@ -13,9 +12,9 @@ pub use core::primitive::{i64 as ptrdiff_t, u64 as size_t};
#[non_exhaustive]
pub struct yaml_version_directive_t {
/// The major version number.
pub major: libc::c_int,
pub major: i32,
/// The minor version number.
pub minor: libc::c_int,
pub minor: i32,
}
/// The tag directive data.
@ -67,11 +66,11 @@ pub enum yaml_break_t {
#[non_exhaustive]
pub struct yaml_mark_t {
/// The position index.
pub index: size_t,
pub index: u64,
/// The position line.
pub line: size_t,
pub line: u64,
/// The position column.
pub column: size_t,
pub column: u64,
}
/// Scalar styles.
@ -199,9 +198,9 @@ pub enum YamlTokenData {
/// A VERSION-DIRECTIVE token.
VersionDirective {
/// The major version number.
major: libc::c_int,
major: i32,
/// The minor version number.
minor: libc::c_int,
minor: i32,
},
/// A TAG-DIRECTIVE token.
TagDirective {
@ -495,16 +494,16 @@ pub enum YamlNodeData {
}
/// An element of a sequence node.
pub type yaml_node_item_t = libc::c_int;
pub type yaml_node_item_t = i32;
/// An element of a mapping node.
#[derive(Copy, Clone, Default)]
#[repr(C)]
#[non_exhaustive]
pub struct yaml_node_pair_t {
/// The key of the element.
pub key: libc::c_int,
pub key: i32,
/// The value of the element.
pub value: libc::c_int,
pub value: i32,
}
/// The document structure.
@ -548,7 +547,7 @@ pub struct yaml_simple_key_t {
/// Is a simple key required?
pub required: bool,
/// The number of the token.
pub token_number: size_t,
pub token_number: usize,
/// The position mark.
pub mark: yaml_mark_t,
}
@ -616,7 +615,7 @@ pub struct yaml_alias_data_t {
/// The anchor.
pub anchor: String,
/// The node id.
pub index: libc::c_int,
pub index: i32,
/// The anchor mark.
pub mark: yaml_mark_t,
}
@ -637,7 +636,7 @@ pub struct yaml_parser_t<'r> {
/// This always contains valid UTF-8.
pub(crate) buffer: VecDeque<char>,
/// The number of unread characters in the buffer.
pub(crate) unread: size_t,
pub(crate) unread: usize,
/// The raw buffer.
///
/// This is the raw unchecked input from the read handler (for example, it
@ -647,7 +646,7 @@ pub struct yaml_parser_t<'r> {
/// The input encoding.
pub(crate) encoding: yaml_encoding_t,
/// The offset of the current position (in bytes).
pub(crate) offset: size_t,
pub(crate) offset: usize,
/// The mark of the current position.
pub(crate) mark: yaml_mark_t,
/// Have we started to scan the input stream?
@ -655,17 +654,17 @@ pub struct yaml_parser_t<'r> {
/// Have we reached the end of the input stream?
pub(crate) stream_end_produced: bool,
/// The number of unclosed '[' and '{' indicators.
pub(crate) flow_level: libc::c_int,
pub(crate) flow_level: i32,
/// The tokens queue.
pub(crate) tokens: VecDeque<yaml_token_t>,
/// The number of tokens fetched from the queue.
pub(crate) tokens_parsed: size_t,
pub(crate) tokens_parsed: usize,
/// Does the tokens queue contain a token ready for dequeueing.
pub(crate) token_available: bool,
/// The indentation levels stack.
pub(crate) indents: Vec<libc::c_int>,
pub(crate) indents: Vec<i32>,
/// The current indentation level.
pub(crate) indent: libc::c_int,
pub(crate) indent: i32,
/// May a simple key occur at the current position?
pub(crate) simple_key_allowed: bool,
/// The stack of simple keys.
@ -736,9 +735,9 @@ pub enum yaml_emitter_state_t {
#[repr(C)]
pub(crate) struct yaml_anchors_t {
/// The number of references.
pub references: libc::c_int,
pub references: i32,
/// The anchor id.
pub anchor: libc::c_int,
pub anchor: i32,
/// If the node has been emitted?
pub serialized: bool,
}
@ -766,9 +765,9 @@ pub struct yaml_emitter_t<'w> {
/// If the output is in the canonical style?
pub(crate) canonical: bool,
/// The number of indentation spaces.
pub(crate) best_indent: libc::c_int,
pub(crate) best_indent: i32,
/// The preferred width of the output lines.
pub(crate) best_width: libc::c_int,
pub(crate) best_width: i32,
/// Allow unescaped non-ASCII characters?
pub(crate) unicode: bool,
/// The preferred line break.
@ -780,13 +779,13 @@ pub struct yaml_emitter_t<'w> {
/// The event queue.
pub(crate) events: VecDeque<yaml_event_t>,
/// The stack of indentation levels.
pub(crate) indents: Vec<libc::c_int>,
pub(crate) indents: Vec<i32>,
/// The list of tag directives.
pub(crate) tag_directives: Vec<yaml_tag_directive_t>,
/// The current indentation level.
pub(crate) indent: libc::c_int,
pub(crate) indent: i32,
/// The current flow level.
pub(crate) flow_level: libc::c_int,
pub(crate) flow_level: i32,
/// Is it the document root context?
pub(crate) root_context: bool,
/// Is it a sequence context?
@ -796,15 +795,15 @@ pub struct yaml_emitter_t<'w> {
/// Is it a simple mapping key context?
pub(crate) simple_key_context: bool,
/// The current line.
pub(crate) line: libc::c_int,
pub(crate) line: i32,
/// The current column.
pub(crate) column: libc::c_int,
pub(crate) column: i32,
/// If the last character was a whitespace?
pub(crate) whitespace: bool,
/// If the last character was an indentation character (' ', '-', '?', ':')?
pub(crate) indention: bool,
/// If an explicit document end is required?
pub(crate) open_ended: libc::c_int,
pub(crate) open_ended: i32,
/// If the stream was already opened?
pub(crate) opened: bool,
/// If the stream was already closed?
@ -813,7 +812,7 @@ pub struct yaml_emitter_t<'w> {
// Note: Same length as `document.nodes`.
pub(crate) anchors: Vec<yaml_anchors_t>,
/// The last assigned anchor id.
pub(crate) last_anchor_id: libc::c_int,
pub(crate) last_anchor_id: i32,
}
impl<'a> Default for yaml_emitter_t<'a> {