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

Remove yaml_char_t conversion from CHECK args

Browse source
This commit is contained in:
David Tolnay 2022-07-22 22:14:24 -07:00
parent c52336a746
commit e245fc53a8
No known key found for this signature in database
GPG key ID: F9BA143B95FF6D82
3 changed files with 189 additions and 187 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

110
src/emitter.rs
View file

@ -93,7 +93,7 @@ macro_rules! WRITE {
macro_rules! WRITE_BREAK { macro_rules! WRITE_BREAK {
($emitter:expr, $string:expr) => { ($emitter:expr, $string:expr) => {
FLUSH!($emitter) FLUSH!($emitter)
&& if CHECK!($string, '\n') { && if CHECK!($string, b'\n') {
let _ = PUT_BREAK!($emitter); let _ = PUT_BREAK!($emitter);
$string.pointer = $string.pointer.wrapping_offset(1); $string.pointer = $string.pointer.wrapping_offset(1);
1_i32 1_i32
@ -1511,8 +1511,8 @@ unsafe fn yaml_emitter_analyze_scalar(
(*emitter).scalar_data.block_allowed = 0_i32; (*emitter).scalar_data.block_allowed = 0_i32;
return 1_i32; return 1_i32;
} }
if CHECK_AT!(string, '-', 0) && CHECK_AT!(string, '-', 1) && CHECK_AT!(string, '-', 2) if CHECK_AT!(string, b'-', 0) && CHECK_AT!(string, b'-', 1) && CHECK_AT!(string, b'-', 2)
|| CHECK_AT!(string, '.', 0) && CHECK_AT!(string, '.', 1) && CHECK_AT!(string, '.', 2) || CHECK_AT!(string, b'.', 0) && CHECK_AT!(string, b'.', 1) && CHECK_AT!(string, b'.', 2)
{ {
block_indicators = 1_i32; block_indicators = 1_i32;
flow_indicators = 1_i32; flow_indicators = 1_i32;
@ -1521,53 +1521,53 @@ unsafe fn yaml_emitter_analyze_scalar(
followed_by_whitespace = IS_BLANKZ_AT!(string, WIDTH!(string)) as libc::c_int; followed_by_whitespace = IS_BLANKZ_AT!(string, WIDTH!(string)) as libc::c_int;
while string.pointer != string.end { while string.pointer != string.end {
if string.start == string.pointer { if string.start == string.pointer {
if CHECK!(string, '#') if CHECK!(string, b'#')
|| CHECK!(string, ',') || CHECK!(string, b',')
|| CHECK!(string, '[') || CHECK!(string, b'[')
|| CHECK!(string, ']') || CHECK!(string, b']')
|| CHECK!(string, '{') || CHECK!(string, b'{')
|| CHECK!(string, '}') || CHECK!(string, b'}')
|| CHECK!(string, '&') || CHECK!(string, b'&')
|| CHECK!(string, '*') || CHECK!(string, b'*')
|| CHECK!(string, '!') || CHECK!(string, b'!')
|| CHECK!(string, '|') || CHECK!(string, b'|')
|| CHECK!(string, '>') || CHECK!(string, b'>')
|| CHECK!(string, '\'') || CHECK!(string, b'\'')
|| CHECK!(string, '"') || CHECK!(string, b'"')
|| CHECK!(string, '%') || CHECK!(string, b'%')
|| CHECK!(string, '@') || CHECK!(string, b'@')
|| CHECK!(string, '`') || CHECK!(string, b'`')
{ {
flow_indicators = 1_i32; flow_indicators = 1_i32;
block_indicators = 1_i32; block_indicators = 1_i32;
} }
if CHECK!(string, '?') || CHECK!(string, ':') { if CHECK!(string, b'?') || CHECK!(string, b':') {
flow_indicators = 1_i32; flow_indicators = 1_i32;
if followed_by_whitespace != 0 { if followed_by_whitespace != 0 {
block_indicators = 1_i32; block_indicators = 1_i32;
} }
} }
if CHECK!(string, '-') && followed_by_whitespace != 0 { if CHECK!(string, b'-') && followed_by_whitespace != 0 {
flow_indicators = 1_i32; flow_indicators = 1_i32;
block_indicators = 1_i32; block_indicators = 1_i32;
} }
} else { } else {
if CHECK!(string, ',') if CHECK!(string, b',')
|| CHECK!(string, '?') || CHECK!(string, b'?')
|| CHECK!(string, '[') || CHECK!(string, b'[')
|| CHECK!(string, ']') || CHECK!(string, b']')
|| CHECK!(string, '{') || CHECK!(string, b'{')
|| CHECK!(string, '}') || CHECK!(string, b'}')
{ {
flow_indicators = 1_i32; flow_indicators = 1_i32;
} }
if CHECK!(string, ':') { if CHECK!(string, b':') {
flow_indicators = 1_i32; flow_indicators = 1_i32;
if followed_by_whitespace != 0 { if followed_by_whitespace != 0 {
block_indicators = 1_i32; block_indicators = 1_i32;
} }
} }
if CHECK!(string, '#') && preceded_by_whitespace != 0 { if CHECK!(string, b'#') && preceded_by_whitespace != 0 {
flow_indicators = 1_i32; flow_indicators = 1_i32;
block_indicators = 1_i32; block_indicators = 1_i32;
} }
@ -1852,25 +1852,25 @@ unsafe fn yaml_emitter_write_tag_content(
} }
while string.pointer != string.end { while string.pointer != string.end {
if IS_ALPHA!(string) if IS_ALPHA!(string)
|| CHECK!(string, ';') || CHECK!(string, b';')
|| CHECK!(string, '/') || CHECK!(string, b'/')
|| CHECK!(string, '?') || CHECK!(string, b'?')
|| CHECK!(string, ':') || CHECK!(string, b':')
|| CHECK!(string, '@') || CHECK!(string, b'@')
|| CHECK!(string, '&') || CHECK!(string, b'&')
|| CHECK!(string, '=') || CHECK!(string, b'=')
|| CHECK!(string, '+') || CHECK!(string, b'+')
|| CHECK!(string, '$') || CHECK!(string, b'$')
|| CHECK!(string, ',') || CHECK!(string, b',')
|| CHECK!(string, '_') || CHECK!(string, b'_')
|| CHECK!(string, '.') || CHECK!(string, b'.')
|| CHECK!(string, '~') || CHECK!(string, b'~')
|| CHECK!(string, '*') || CHECK!(string, b'*')
|| CHECK!(string, '\'') || CHECK!(string, b'\'')
|| CHECK!(string, '(') || CHECK!(string, b'(')
|| CHECK!(string, ')') || CHECK!(string, b')')
|| CHECK!(string, '[') || CHECK!(string, b'[')
|| CHECK!(string, ']') || CHECK!(string, b']')
{ {
if !(WRITE!(emitter, string)) { if !(WRITE!(emitter, string)) {
return 0_i32; return 0_i32;
@ -1952,7 +1952,7 @@ unsafe fn yaml_emitter_write_plain_scalar(
} }
spaces = 1_i32; spaces = 1_i32;
} else if IS_BREAK!(string) { } else if IS_BREAK!(string) {
if breaks == 0 && CHECK!(string, '\n') { if breaks == 0 && CHECK!(string, b'\n') {
if !(PUT_BREAK!(emitter)) { if !(PUT_BREAK!(emitter)) {
return 0_i32; return 0_i32;
} }
@ -2018,7 +2018,7 @@ unsafe fn yaml_emitter_write_single_quoted_scalar(
} }
spaces = 1_i32; spaces = 1_i32;
} else if IS_BREAK!(string) { } else if IS_BREAK!(string) {
if breaks == 0 && CHECK!(string, '\n') { if breaks == 0 && CHECK!(string, b'\n') {
if !(PUT_BREAK!(emitter)) { if !(PUT_BREAK!(emitter)) {
return 0_i32; return 0_i32;
} }
@ -2034,8 +2034,8 @@ unsafe fn yaml_emitter_write_single_quoted_scalar(
return 0_i32; return 0_i32;
} }
} }
if CHECK!(string, '\'') { if CHECK!(string, b'\'') {
if !(PUT!(emitter, '\'')) { if !(PUT!(emitter, b'\'')) {
return 0_i32; return 0_i32;
} }
} }
@ -2090,8 +2090,8 @@ unsafe fn yaml_emitter_write_double_quoted_scalar(
|| (*emitter).unicode == 0 && !IS_ASCII!(string) || (*emitter).unicode == 0 && !IS_ASCII!(string)
|| IS_BOM!(string) || IS_BOM!(string)
|| IS_BREAK!(string) || IS_BREAK!(string)
|| CHECK!(string, '"') || CHECK!(string, b'"')
|| CHECK!(string, '\\') || CHECK!(string, b'\\')
{ {
let mut octet: libc::c_uchar; let mut octet: libc::c_uchar;
let mut width: libc::c_uint; let mut width: libc::c_uint;
@ -2414,7 +2414,7 @@ unsafe fn yaml_emitter_write_folded_scalar(
(*emitter).whitespace = 1_i32; (*emitter).whitespace = 1_i32;
while string.pointer != string.end { while string.pointer != string.end {
if IS_BREAK!(string) { if IS_BREAK!(string) {
if breaks == 0 && leading_spaces == 0 && CHECK!(string, '\n') { if breaks == 0 && leading_spaces == 0 && CHECK!(string, b'\n') {
let mut k: libc::c_int = 0_i32; let mut k: libc::c_int = 0_i32;
while IS_BREAK_AT!(string, k as isize) { while IS_BREAK_AT!(string, k as isize) {
k += WIDTH_AT!(string, k as isize); k += WIDTH_AT!(string, k as isize);

16
src/macros.rs
View file

@ -123,13 +123,13 @@ macro_rules! JOIN {
macro_rules! CHECK_AT { macro_rules! CHECK_AT {
($string:expr, $octet:expr, $offset:expr) => { ($string:expr, $octet:expr, $offset:expr) => {
*$string.pointer.offset($offset as isize) == $octet as yaml_char_t *$string.pointer.offset($offset as isize) == $octet
}; };
} }
macro_rules! CHECK { macro_rules! CHECK {
($string:expr, $octet:expr) => { ($string:expr, $octet:expr) => {
*$string.pointer == $octet as yaml_char_t *$string.pointer == $octet
}; };
} }
@ -209,7 +209,7 @@ macro_rules! IS_PRINTABLE {
macro_rules! IS_Z_AT { macro_rules! IS_Z_AT {
($string:expr, $offset:expr) => { ($string:expr, $offset:expr) => {
CHECK_AT!($string, '\0', $offset) CHECK_AT!($string, b'\0', $offset)
}; };
} }
@ -229,7 +229,7 @@ macro_rules! IS_BOM {
macro_rules! IS_SPACE_AT { macro_rules! IS_SPACE_AT {
($string:expr, $offset:expr) => { ($string:expr, $offset:expr) => {
CHECK_AT!($string, ' ', $offset) CHECK_AT!($string, b' ', $offset)
}; };
} }
@ -241,7 +241,7 @@ macro_rules! IS_SPACE {
macro_rules! IS_TAB_AT { macro_rules! IS_TAB_AT {
($string:expr, $offset:expr) => { ($string:expr, $offset:expr) => {
CHECK_AT!($string, '\t', $offset) CHECK_AT!($string, b'\t', $offset)
}; };
} }
@ -265,8 +265,8 @@ macro_rules! IS_BLANK {
macro_rules! IS_BREAK_AT { macro_rules! IS_BREAK_AT {
($string:expr, $offset:expr) => { ($string:expr, $offset:expr) => {
CHECK_AT!($string, '\r', $offset) CHECK_AT!($string, b'\r', $offset)
|| CHECK_AT!($string, '\n', $offset) || CHECK_AT!($string, b'\n', $offset)
|| CHECK_AT!($string, b'\xC2', $offset) && CHECK_AT!($string, b'\x85', $offset + 1) || CHECK_AT!($string, b'\xC2', $offset) && CHECK_AT!($string, b'\x85', $offset + 1)
|| CHECK_AT!($string, b'\xE2', $offset) || CHECK_AT!($string, b'\xE2', $offset)
&& CHECK_AT!($string, b'\x80', $offset + 1) && CHECK_AT!($string, b'\x80', $offset + 1)
@ -285,7 +285,7 @@ macro_rules! IS_BREAK {
macro_rules! IS_CRLF { macro_rules! IS_CRLF {
($string:expr) => { ($string:expr) => {
CHECK_AT!($string, '\r', 0) && CHECK_AT!($string, '\n', 1) CHECK_AT!($string, b'\r', 0) && CHECK_AT!($string, b'\n', 1)
}; };
} }

250
src/scanner.rs
View file

@ -89,7 +89,7 @@ macro_rules! READ {
macro_rules! READ_LINE { macro_rules! READ_LINE {
($parser:expr, $string:expr) => { ($parser:expr, $string:expr) => {
if STRING_EXTEND!($parser, $string) != 0 { if STRING_EXTEND!($parser, $string) != 0 {
if CHECK_AT!((*$parser).buffer, '\r', 0) && CHECK_AT!((*$parser).buffer, '\n', 1) { if CHECK_AT!((*$parser).buffer, b'\r', 0) && CHECK_AT!((*$parser).buffer, b'\n', 1) {
let fresh484 = addr_of_mut!($string.pointer); let fresh484 = addr_of_mut!($string.pointer);
let fresh485 = *fresh484; let fresh485 = *fresh484;
*fresh484 = (*fresh484).wrapping_offset(1); *fresh484 = (*fresh484).wrapping_offset(1);
@ -103,7 +103,8 @@ macro_rules! READ_LINE {
*fresh488 = (*fresh488).wrapping_add(1); *fresh488 = (*fresh488).wrapping_add(1);
let fresh489 = addr_of_mut!((*$parser).unread); let fresh489 = addr_of_mut!((*$parser).unread);
*fresh489 = (*fresh489 as libc::c_ulong).wrapping_sub(2_u64) as size_t as size_t; *fresh489 = (*fresh489 as libc::c_ulong).wrapping_sub(2_u64) as size_t as size_t;
} else if CHECK_AT!((*$parser).buffer, '\r', 0) || CHECK_AT!((*$parser).buffer, '\n', 0) } else if CHECK_AT!((*$parser).buffer, b'\r', 0)
|| CHECK_AT!((*$parser).buffer, b'\n', 0)
{ {
let fresh490 = addr_of_mut!($string.pointer); let fresh490 = addr_of_mut!($string.pointer);
let fresh491 = *fresh490; let fresh491 = *fresh490;
@ -291,97 +292,97 @@ unsafe fn yaml_parser_fetch_next_token(parser: *mut yaml_parser_t) -> libc::c_in
if IS_Z!((*parser).buffer) { if IS_Z!((*parser).buffer) {
return yaml_parser_fetch_stream_end(parser); return yaml_parser_fetch_stream_end(parser);
} }
if (*parser).mark.column == 0_u64 && CHECK!((*parser).buffer, '%') { if (*parser).mark.column == 0_u64 && CHECK!((*parser).buffer, b'%') {
return yaml_parser_fetch_directive(parser); return yaml_parser_fetch_directive(parser);
} }
if (*parser).mark.column == 0_u64 if (*parser).mark.column == 0_u64
&& CHECK_AT!((*parser).buffer, '-', 0) && CHECK_AT!((*parser).buffer, b'-', 0)
&& CHECK_AT!((*parser).buffer, '-', 1) && CHECK_AT!((*parser).buffer, b'-', 1)
&& CHECK_AT!((*parser).buffer, '-', 2) && CHECK_AT!((*parser).buffer, b'-', 2)
&& IS_BLANKZ_AT!((*parser).buffer, 3) && IS_BLANKZ_AT!((*parser).buffer, 3)
{ {
return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_START_TOKEN); return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_START_TOKEN);
} }
if (*parser).mark.column == 0_u64 if (*parser).mark.column == 0_u64
&& CHECK_AT!((*parser).buffer, '.', 0) && CHECK_AT!((*parser).buffer, b'.', 0)
&& CHECK_AT!((*parser).buffer, '.', 1) && CHECK_AT!((*parser).buffer, b'.', 1)
&& CHECK_AT!((*parser).buffer, '.', 2) && CHECK_AT!((*parser).buffer, b'.', 2)
&& IS_BLANKZ_AT!((*parser).buffer, 3) && IS_BLANKZ_AT!((*parser).buffer, 3)
{ {
return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_END_TOKEN); return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_END_TOKEN);
} }
if CHECK!((*parser).buffer, '[') { if CHECK!((*parser).buffer, b'[') {
return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_SEQUENCE_START_TOKEN); return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_SEQUENCE_START_TOKEN);
} }
if CHECK!((*parser).buffer, '{') { if CHECK!((*parser).buffer, b'{') {
return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_MAPPING_START_TOKEN); return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_MAPPING_START_TOKEN);
} }
if CHECK!((*parser).buffer, ']') { if CHECK!((*parser).buffer, b']') {
return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_SEQUENCE_END_TOKEN); return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_SEQUENCE_END_TOKEN);
} }
if CHECK!((*parser).buffer, '}') { if CHECK!((*parser).buffer, b'}') {
return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_MAPPING_END_TOKEN); return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_MAPPING_END_TOKEN);
} }
if CHECK!((*parser).buffer, ',') { if CHECK!((*parser).buffer, b',') {
return yaml_parser_fetch_flow_entry(parser); return yaml_parser_fetch_flow_entry(parser);
} }
if CHECK!((*parser).buffer, '-') && IS_BLANKZ_AT!((*parser).buffer, 1) { if CHECK!((*parser).buffer, b'-') && IS_BLANKZ_AT!((*parser).buffer, 1) {
return yaml_parser_fetch_block_entry(parser); return yaml_parser_fetch_block_entry(parser);
} }
if CHECK!((*parser).buffer, '?') if CHECK!((*parser).buffer, b'?')
&& ((*parser).flow_level != 0 || IS_BLANKZ_AT!((*parser).buffer, 1)) && ((*parser).flow_level != 0 || IS_BLANKZ_AT!((*parser).buffer, 1))
{ {
return yaml_parser_fetch_key(parser); return yaml_parser_fetch_key(parser);
} }
if CHECK!((*parser).buffer, ':') if CHECK!((*parser).buffer, b':')
&& ((*parser).flow_level != 0 || IS_BLANKZ_AT!((*parser).buffer, 1)) && ((*parser).flow_level != 0 || IS_BLANKZ_AT!((*parser).buffer, 1))
{ {
return yaml_parser_fetch_value(parser); return yaml_parser_fetch_value(parser);
} }
if CHECK!((*parser).buffer, '*') { if CHECK!((*parser).buffer, b'*') {
return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN); return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN);
} }
if CHECK!((*parser).buffer, '&') { if CHECK!((*parser).buffer, b'&') {
return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN); return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN);
} }
if CHECK!((*parser).buffer, '!') { if CHECK!((*parser).buffer, b'!') {
return yaml_parser_fetch_tag(parser); return yaml_parser_fetch_tag(parser);
} }
if CHECK!((*parser).buffer, '|') && (*parser).flow_level == 0 { if CHECK!((*parser).buffer, b'|') && (*parser).flow_level == 0 {
return yaml_parser_fetch_block_scalar(parser, 1_i32); return yaml_parser_fetch_block_scalar(parser, 1_i32);
} }
if CHECK!((*parser).buffer, '>') && (*parser).flow_level == 0 { if CHECK!((*parser).buffer, b'>') && (*parser).flow_level == 0 {
return yaml_parser_fetch_block_scalar(parser, 0_i32); return yaml_parser_fetch_block_scalar(parser, 0_i32);
} }
if CHECK!((*parser).buffer, '\'') { if CHECK!((*parser).buffer, b'\'') {
return yaml_parser_fetch_flow_scalar(parser, 1_i32); return yaml_parser_fetch_flow_scalar(parser, 1_i32);
} }
if CHECK!((*parser).buffer, '"') { if CHECK!((*parser).buffer, b'"') {
return yaml_parser_fetch_flow_scalar(parser, 0_i32); return yaml_parser_fetch_flow_scalar(parser, 0_i32);
} }
if !(IS_BLANKZ!((*parser).buffer) if !(IS_BLANKZ!((*parser).buffer)
|| CHECK!((*parser).buffer, '-') || CHECK!((*parser).buffer, b'-')
|| CHECK!((*parser).buffer, '?') || CHECK!((*parser).buffer, b'?')
|| CHECK!((*parser).buffer, ':') || CHECK!((*parser).buffer, b':')
|| CHECK!((*parser).buffer, ',') || CHECK!((*parser).buffer, b',')
|| CHECK!((*parser).buffer, '[') || CHECK!((*parser).buffer, b'[')
|| CHECK!((*parser).buffer, ']') || CHECK!((*parser).buffer, b']')
|| CHECK!((*parser).buffer, '{') || CHECK!((*parser).buffer, b'{')
|| CHECK!((*parser).buffer, '}') || CHECK!((*parser).buffer, b'}')
|| CHECK!((*parser).buffer, '#') || CHECK!((*parser).buffer, b'#')
|| CHECK!((*parser).buffer, '&') || CHECK!((*parser).buffer, b'&')
|| CHECK!((*parser).buffer, '*') || CHECK!((*parser).buffer, b'*')
|| CHECK!((*parser).buffer, '!') || CHECK!((*parser).buffer, b'!')
|| CHECK!((*parser).buffer, '|') || CHECK!((*parser).buffer, b'|')
|| CHECK!((*parser).buffer, '>') || CHECK!((*parser).buffer, b'>')
|| CHECK!((*parser).buffer, '\'') || CHECK!((*parser).buffer, b'\'')
|| CHECK!((*parser).buffer, '"') || CHECK!((*parser).buffer, b'"')
|| CHECK!((*parser).buffer, '%') || CHECK!((*parser).buffer, b'%')
|| CHECK!((*parser).buffer, '@') || CHECK!((*parser).buffer, b'@')
|| CHECK!((*parser).buffer, '`')) || CHECK!((*parser).buffer, b'`'))
|| CHECK!((*parser).buffer, '-') && !IS_BLANK_AT!((*parser).buffer, 1) || CHECK!((*parser).buffer, b'-') && !IS_BLANK_AT!((*parser).buffer, 1)
|| (*parser).flow_level == 0 || (*parser).flow_level == 0
&& (CHECK!((*parser).buffer, '?') || CHECK!((*parser).buffer, ':')) && (CHECK!((*parser).buffer, b'?') || CHECK!((*parser).buffer, b':'))
&& !IS_BLANKZ_AT!((*parser).buffer, 1) && !IS_BLANKZ_AT!((*parser).buffer, 1)
{ {
return yaml_parser_fetch_plain_scalar(parser); return yaml_parser_fetch_plain_scalar(parser);
@ -1029,16 +1030,16 @@ unsafe fn yaml_parser_scan_to_next_token(mut parser: *mut yaml_parser_t) -> libc
if CACHE!(parser, 1_u64) == 0 { if CACHE!(parser, 1_u64) == 0 {
return 0_i32; return 0_i32;
} }
while CHECK!((*parser).buffer, ' ') while CHECK!((*parser).buffer, b' ')
|| ((*parser).flow_level != 0 || (*parser).simple_key_allowed == 0) || ((*parser).flow_level != 0 || (*parser).simple_key_allowed == 0)
&& CHECK!((*parser).buffer, '\t') && CHECK!((*parser).buffer, b'\t')
{ {
SKIP!(parser); SKIP!(parser);
if CACHE!(parser, 1_u64) == 0 { if CACHE!(parser, 1_u64) == 0 {
return 0_i32; return 0_i32;
} }
} }
if CHECK!((*parser).buffer, '#') { if CHECK!((*parser).buffer, b'#') {
while !IS_BREAKZ!((*parser).buffer) { while !IS_BREAKZ!((*parser).buffer) {
SKIP!(parser); SKIP!(parser);
if CACHE!(parser, 1_u64) == 0 { if CACHE!(parser, 1_u64) == 0 {
@ -1157,7 +1158,7 @@ unsafe fn yaml_parser_scan_directive(
match current_block { match current_block {
11397968426844348457 => {} 11397968426844348457 => {}
_ => { _ => {
if CHECK!((*parser).buffer, '#') { if CHECK!((*parser).buffer, b'#') {
loop { loop {
if IS_BREAKZ!((*parser).buffer) { if IS_BREAKZ!((*parser).buffer) {
current_block = 6669252993407410313; current_block = 6669252993407410313;
@ -1290,7 +1291,7 @@ unsafe fn yaml_parser_scan_version_directive_value(
if yaml_parser_scan_version_directive_number(parser, start_mark, major) == 0 { if yaml_parser_scan_version_directive_number(parser, start_mark, major) == 0 {
return 0_i32; return 0_i32;
} }
if !CHECK!((*parser).buffer, '.') { if !CHECK!((*parser).buffer, b'.') {
return yaml_parser_set_scanner_error( return yaml_parser_set_scanner_error(
parser, parser,
b"while scanning a %YAML directive\0" as *const u8 as *const libc::c_char, b"while scanning a %YAML directive\0" as *const u8 as *const libc::c_char,
@ -1480,14 +1481,14 @@ unsafe fn yaml_parser_scan_anchor(
end_mark = (*parser).mark; end_mark = (*parser).mark;
if length == 0 if length == 0
|| !(IS_BLANKZ!((*parser).buffer) || !(IS_BLANKZ!((*parser).buffer)
|| CHECK!((*parser).buffer, '?') || CHECK!((*parser).buffer, b'?')
|| CHECK!((*parser).buffer, ':') || CHECK!((*parser).buffer, b':')
|| CHECK!((*parser).buffer, ',') || CHECK!((*parser).buffer, b',')
|| CHECK!((*parser).buffer, ']') || CHECK!((*parser).buffer, b']')
|| CHECK!((*parser).buffer, '}') || CHECK!((*parser).buffer, b'}')
|| CHECK!((*parser).buffer, '%') || CHECK!((*parser).buffer, b'%')
|| CHECK!((*parser).buffer, '@') || CHECK!((*parser).buffer, b'@')
|| CHECK!((*parser).buffer, '`')) || CHECK!((*parser).buffer, b'`'))
{ {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
parser, parser,
@ -1547,7 +1548,7 @@ unsafe fn yaml_parser_scan_tag(
let end_mark: yaml_mark_t; let end_mark: yaml_mark_t;
let start_mark: yaml_mark_t = (*parser).mark; let start_mark: yaml_mark_t = (*parser).mark;
if !(CACHE!(parser, 2_u64) == 0) { if !(CACHE!(parser, 2_u64) == 0) {
if CHECK_AT!((*parser).buffer, '<', 1) { if CHECK_AT!((*parser).buffer, b'<', 1) {
handle = yaml_malloc(1_u64) as *mut yaml_char_t; handle = yaml_malloc(1_u64) as *mut yaml_char_t;
if handle.is_null() { if handle.is_null() {
current_block = 17708497480799081542; current_block = 17708497480799081542;
@ -1565,7 +1566,7 @@ unsafe fn yaml_parser_scan_tag(
) == 0 ) == 0
{ {
current_block = 17708497480799081542; current_block = 17708497480799081542;
} else if !CHECK!((*parser).buffer, '>') { } else if !CHECK!((*parser).buffer, b'>') {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
parser, parser,
b"while scanning a tag\0" as *const u8 as *const libc::c_char, b"while scanning a tag\0" as *const u8 as *const libc::c_char,
@ -1632,7 +1633,7 @@ unsafe fn yaml_parser_scan_tag(
_ => { _ => {
if !(CACHE!(parser, 1_u64) == 0) { if !(CACHE!(parser, 1_u64) == 0) {
if !IS_BLANKZ!((*parser).buffer) { if !IS_BLANKZ!((*parser).buffer) {
if (*parser).flow_level == 0 || !CHECK!((*parser).buffer, ',') { if (*parser).flow_level == 0 || !CHECK!((*parser).buffer, b',') {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
parser, parser,
b"while scanning a tag\0" as *const u8 as *const libc::c_char, b"while scanning a tag\0" as *const u8 as *const libc::c_char,
@ -1685,7 +1686,7 @@ unsafe fn yaml_parser_scan_tag_handle(
let mut string = NULL_STRING!(); let mut string = NULL_STRING!();
if !(STRING_INIT!(parser, string) == 0) { if !(STRING_INIT!(parser, string) == 0) {
if !(CACHE!(parser, 1_u64) == 0) { if !(CACHE!(parser, 1_u64) == 0) {
if !CHECK!((*parser).buffer, '!') { if !CHECK!((*parser).buffer, b'!') {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
parser, parser,
if directive != 0 { if directive != 0 {
@ -1715,7 +1716,7 @@ unsafe fn yaml_parser_scan_tag_handle(
match current_block { match current_block {
1771849829115608806 => {} 1771849829115608806 => {}
_ => { _ => {
if CHECK!((*parser).buffer, '!') { if CHECK!((*parser).buffer, b'!') {
if READ!(parser, string) == 0 { if READ!(parser, string) == 0 {
current_block = 1771849829115608806; current_block = 1771849829115608806;
} else { } else {
@ -1810,29 +1811,29 @@ unsafe fn yaml_parser_scan_tag_uri(
continue; continue;
} }
while IS_ALPHA!((*parser).buffer) while IS_ALPHA!((*parser).buffer)
|| CHECK!((*parser).buffer, ';') || CHECK!((*parser).buffer, b';')
|| CHECK!((*parser).buffer, '/') || CHECK!((*parser).buffer, b'/')
|| CHECK!((*parser).buffer, '?') || CHECK!((*parser).buffer, b'?')
|| CHECK!((*parser).buffer, ':') || CHECK!((*parser).buffer, b':')
|| CHECK!((*parser).buffer, '@') || CHECK!((*parser).buffer, b'@')
|| CHECK!((*parser).buffer, '&') || CHECK!((*parser).buffer, b'&')
|| CHECK!((*parser).buffer, '=') || CHECK!((*parser).buffer, b'=')
|| CHECK!((*parser).buffer, '+') || CHECK!((*parser).buffer, b'+')
|| CHECK!((*parser).buffer, '$') || CHECK!((*parser).buffer, b'$')
|| CHECK!((*parser).buffer, '.') || CHECK!((*parser).buffer, b'.')
|| CHECK!((*parser).buffer, '%') || CHECK!((*parser).buffer, b'%')
|| CHECK!((*parser).buffer, '!') || CHECK!((*parser).buffer, b'!')
|| CHECK!((*parser).buffer, '~') || CHECK!((*parser).buffer, b'~')
|| CHECK!((*parser).buffer, '*') || CHECK!((*parser).buffer, b'*')
|| CHECK!((*parser).buffer, '\'') || CHECK!((*parser).buffer, b'\'')
|| CHECK!((*parser).buffer, '(') || CHECK!((*parser).buffer, b'(')
|| CHECK!((*parser).buffer, ')') || CHECK!((*parser).buffer, b')')
|| uri_char != 0 || uri_char != 0
&& (CHECK!((*parser).buffer, ',') && (CHECK!((*parser).buffer, b',')
|| CHECK!((*parser).buffer, '[') || CHECK!((*parser).buffer, b'[')
|| CHECK!((*parser).buffer, ']')) || CHECK!((*parser).buffer, b']'))
{ {
if CHECK!((*parser).buffer, '%') { if CHECK!((*parser).buffer, b'%') {
if STRING_EXTEND!(parser, string) == 0 { if STRING_EXTEND!(parser, string) == 0 {
current_block = 15265153392498847348; current_block = 15265153392498847348;
continue 'c_21953; continue 'c_21953;
@ -1895,7 +1896,7 @@ unsafe fn yaml_parser_scan_uri_escapes(
if CACHE!(parser, 3_u64) == 0 { if CACHE!(parser, 3_u64) == 0 {
return 0_i32; return 0_i32;
} }
if !(CHECK!((*parser).buffer, '%') if !(CHECK!((*parser).buffer, b'%')
&& IS_HEX_AT!((*parser).buffer, 1) && IS_HEX_AT!((*parser).buffer, 1)
&& IS_HEX_AT!((*parser).buffer, 2)) && IS_HEX_AT!((*parser).buffer, 2))
{ {
@ -1985,8 +1986,8 @@ unsafe fn yaml_parser_scan_block_scalar(
start_mark = (*parser).mark; start_mark = (*parser).mark;
SKIP!(parser); SKIP!(parser);
if !(CACHE!(parser, 1_u64) == 0) { if !(CACHE!(parser, 1_u64) == 0) {
if CHECK!((*parser).buffer, '+') || CHECK!((*parser).buffer, '-') { if CHECK!((*parser).buffer, b'+') || CHECK!((*parser).buffer, b'-') {
chomping = if CHECK!((*parser).buffer, '+') { chomping = if CHECK!((*parser).buffer, b'+') {
1_i32 1_i32
} else { } else {
-1_i32 -1_i32
@ -1995,7 +1996,7 @@ unsafe fn yaml_parser_scan_block_scalar(
if CACHE!(parser, 1_u64) == 0 { if CACHE!(parser, 1_u64) == 0 {
current_block = 14984465786483313892; current_block = 14984465786483313892;
} else if IS_DIGIT!((*parser).buffer) { } else if IS_DIGIT!((*parser).buffer) {
if CHECK!((*parser).buffer, '0') { if CHECK!((*parser).buffer, b'0') {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
parser, parser,
b"while scanning a block scalar\0" as *const u8 b"while scanning a block scalar\0" as *const u8
@ -2014,7 +2015,7 @@ unsafe fn yaml_parser_scan_block_scalar(
current_block = 11913429853522160501; current_block = 11913429853522160501;
} }
} else if IS_DIGIT!((*parser).buffer) { } else if IS_DIGIT!((*parser).buffer) {
if CHECK!((*parser).buffer, '0') { if CHECK!((*parser).buffer, b'0') {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
parser, parser,
b"while scanning a block scalar\0" as *const u8 b"while scanning a block scalar\0" as *const u8
@ -2030,8 +2031,9 @@ unsafe fn yaml_parser_scan_block_scalar(
if CACHE!(parser, 1_u64) == 0 { if CACHE!(parser, 1_u64) == 0 {
current_block = 14984465786483313892; current_block = 14984465786483313892;
} else { } else {
if CHECK!((*parser).buffer, '+') || CHECK!((*parser).buffer, '-') { if CHECK!((*parser).buffer, b'+') || CHECK!((*parser).buffer, b'-')
chomping = if CHECK!((*parser).buffer, '+') { {
chomping = if CHECK!((*parser).buffer, b'+') {
1_i32 1_i32
} else { } else {
-1_i32 -1_i32
@ -2062,7 +2064,7 @@ unsafe fn yaml_parser_scan_block_scalar(
match current_block { match current_block {
14984465786483313892 => {} 14984465786483313892 => {}
_ => { _ => {
if CHECK!((*parser).buffer, '#') { if CHECK!((*parser).buffer, b'#') {
loop { loop {
if IS_BREAKZ!((*parser).buffer) { if IS_BREAKZ!((*parser).buffer) {
current_block = 12997042908615822766; current_block = 12997042908615822766;
@ -2350,12 +2352,12 @@ unsafe fn yaml_parser_scan_flow_scalar(
break; break;
} }
if (*parser).mark.column == 0_u64 if (*parser).mark.column == 0_u64
&& (CHECK_AT!((*parser).buffer, '-', 0) && (CHECK_AT!((*parser).buffer, b'-', 0)
&& CHECK_AT!((*parser).buffer, '-', 1) && CHECK_AT!((*parser).buffer, b'-', 1)
&& CHECK_AT!((*parser).buffer, '-', 2) && CHECK_AT!((*parser).buffer, b'-', 2)
|| CHECK_AT!((*parser).buffer, '.', 0) || CHECK_AT!((*parser).buffer, b'.', 0)
&& CHECK_AT!((*parser).buffer, '.', 1) && CHECK_AT!((*parser).buffer, b'.', 1)
&& CHECK_AT!((*parser).buffer, '.', 2)) && CHECK_AT!((*parser).buffer, b'.', 2))
&& IS_BLANKZ_AT!((*parser).buffer, 3) && IS_BLANKZ_AT!((*parser).buffer, 3)
{ {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
@ -2387,8 +2389,8 @@ unsafe fn yaml_parser_scan_flow_scalar(
leading_blanks = 0_i32; leading_blanks = 0_i32;
while !IS_BLANKZ!((*parser).buffer) { while !IS_BLANKZ!((*parser).buffer) {
if single != 0 if single != 0
&& CHECK_AT!((*parser).buffer, '\'', 0) && CHECK_AT!((*parser).buffer, b'\'', 0)
&& CHECK_AT!((*parser).buffer, '\'', 1) && CHECK_AT!((*parser).buffer, b'\'', 1)
{ {
if STRING_EXTEND!(parser, string) == 0 { if STRING_EXTEND!(parser, string) == 0 {
current_block = 8114179180390253173; current_block = 8114179180390253173;
@ -2402,12 +2404,12 @@ unsafe fn yaml_parser_scan_flow_scalar(
} else { } else {
if CHECK!( if CHECK!(
(*parser).buffer, (*parser).buffer,
if single != 0 { '\'' } else { '"' } if single != 0 { b'\'' } else { b'"' }
) { ) {
break; break;
} }
if single == 0 if single == 0
&& CHECK!((*parser).buffer, '\\') && CHECK!((*parser).buffer, b'\\')
&& IS_BREAK_AT!((*parser).buffer, 1) && IS_BREAK_AT!((*parser).buffer, 1)
{ {
if CACHE!(parser, 3_u64) == 0 { if CACHE!(parser, 3_u64) == 0 {
@ -2418,7 +2420,7 @@ unsafe fn yaml_parser_scan_flow_scalar(
SKIP_LINE!(parser); SKIP_LINE!(parser);
leading_blanks = 1_i32; leading_blanks = 1_i32;
break; break;
} else if single == 0 && CHECK!((*parser).buffer, '\\') { } else if single == 0 && CHECK!((*parser).buffer, b'\\') {
let mut code_length: size_t = 0_u64; let mut code_length: size_t = 0_u64;
if STRING_EXTEND!(parser, string) == 0 { if STRING_EXTEND!(parser, string) == 0 {
current_block = 8114179180390253173; current_block = 8114179180390253173;
@ -2699,7 +2701,7 @@ unsafe fn yaml_parser_scan_flow_scalar(
current_block = 8114179180390253173; current_block = 8114179180390253173;
break; break;
} }
if CHECK!((*parser).buffer, if single != 0 { '\'' } else { '"' }) { if CHECK!((*parser).buffer, if single != 0 { b'\'' } else { b'"' }) {
current_block = 7468767852762055642; current_block = 7468767852762055642;
break; break;
} }
@ -2843,30 +2845,30 @@ unsafe fn yaml_parser_scan_plain_scalar(
break; break;
} }
if (*parser).mark.column == 0_u64 if (*parser).mark.column == 0_u64
&& (CHECK_AT!((*parser).buffer, '-', 0) && (CHECK_AT!((*parser).buffer, b'-', 0)
&& CHECK_AT!((*parser).buffer, '-', 1) && CHECK_AT!((*parser).buffer, b'-', 1)
&& CHECK_AT!((*parser).buffer, '-', 2) && CHECK_AT!((*parser).buffer, b'-', 2)
|| CHECK_AT!((*parser).buffer, '.', 0) || CHECK_AT!((*parser).buffer, b'.', 0)
&& CHECK_AT!((*parser).buffer, '.', 1) && CHECK_AT!((*parser).buffer, b'.', 1)
&& CHECK_AT!((*parser).buffer, '.', 2)) && CHECK_AT!((*parser).buffer, b'.', 2))
&& IS_BLANKZ_AT!((*parser).buffer, 3) && IS_BLANKZ_AT!((*parser).buffer, 3)
{ {
current_block = 6281126495347172768; current_block = 6281126495347172768;
break; break;
} }
if CHECK!((*parser).buffer, '#') { if CHECK!((*parser).buffer, b'#') {
current_block = 6281126495347172768; current_block = 6281126495347172768;
break; break;
} }
while !IS_BLANKZ!((*parser).buffer) { while !IS_BLANKZ!((*parser).buffer) {
if (*parser).flow_level != 0 if (*parser).flow_level != 0
&& CHECK!((*parser).buffer, ':') && CHECK!((*parser).buffer, b':')
&& (CHECK_AT!((*parser).buffer, ',', 1) && (CHECK_AT!((*parser).buffer, b',', 1)
|| CHECK_AT!((*parser).buffer, '?', 1) || CHECK_AT!((*parser).buffer, b'?', 1)
|| CHECK_AT!((*parser).buffer, '[', 1) || CHECK_AT!((*parser).buffer, b'[', 1)
|| CHECK_AT!((*parser).buffer, ']', 1) || CHECK_AT!((*parser).buffer, b']', 1)
|| CHECK_AT!((*parser).buffer, '{', 1) || CHECK_AT!((*parser).buffer, b'{', 1)
|| CHECK_AT!((*parser).buffer, '}', 1)) || CHECK_AT!((*parser).buffer, b'}', 1))
{ {
yaml_parser_set_scanner_error( yaml_parser_set_scanner_error(
parser, parser,
@ -2878,14 +2880,14 @@ unsafe fn yaml_parser_scan_plain_scalar(
current_block = 16642808987012640029; current_block = 16642808987012640029;
break 's_57; break 's_57;
} else { } else {
if CHECK!((*parser).buffer, ':') if CHECK!((*parser).buffer, b':')
&& IS_BLANKZ_AT!((*parser).buffer, 1) && IS_BLANKZ_AT!((*parser).buffer, 1)
|| (*parser).flow_level != 0 || (*parser).flow_level != 0
&& (CHECK!((*parser).buffer, ',') && (CHECK!((*parser).buffer, b',')
|| CHECK!((*parser).buffer, '[') || CHECK!((*parser).buffer, b'[')
|| CHECK!((*parser).buffer, ']') || CHECK!((*parser).buffer, b']')
|| CHECK!((*parser).buffer, '{') || CHECK!((*parser).buffer, b'{')
|| CHECK!((*parser).buffer, '}')) || CHECK!((*parser).buffer, b'}'))
{ {
break; break;
} }