515 lines
15 KiB
Rust
515 lines
15 KiB
Rust
macro_rules! BUFFER_INIT {
|
|
($buffer:expr, $size:expr) => {{
|
|
let start = addr_of_mut!($buffer.start);
|
|
*start = yaml_malloc($size as size_t) as *mut yaml_char_t;
|
|
let pointer = addr_of_mut!($buffer.pointer);
|
|
*pointer = $buffer.start;
|
|
let last = addr_of_mut!($buffer.last);
|
|
*last = *pointer;
|
|
let end = addr_of_mut!($buffer.end);
|
|
*end = $buffer.start.wrapping_add($size as usize);
|
|
}};
|
|
}
|
|
|
|
macro_rules! BUFFER_DEL {
|
|
($buffer:expr) => {{
|
|
yaml_free($buffer.start as *mut libc::c_void);
|
|
let end = addr_of_mut!($buffer.end);
|
|
*end = ptr::null_mut::<yaml_char_t>();
|
|
let pointer = addr_of_mut!($buffer.pointer);
|
|
*pointer = *end;
|
|
let start = addr_of_mut!($buffer.start);
|
|
*start = *pointer;
|
|
}};
|
|
}
|
|
|
|
macro_rules! STRING_ASSIGN {
|
|
($string:expr, $length:expr) => {
|
|
yaml_string_t {
|
|
start: $string,
|
|
end: $string.wrapping_offset($length as isize),
|
|
pointer: $string,
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! STRING_INIT {
|
|
($string:expr) => {{
|
|
$string.start = yaml_malloc(16) as *mut yaml_char_t;
|
|
$string.pointer = $string.start;
|
|
$string.end = $string.start.wrapping_add(16);
|
|
memset($string.start as *mut libc::c_void, 0, 16);
|
|
}};
|
|
}
|
|
|
|
macro_rules! STRING_DEL {
|
|
($string:expr) => {{
|
|
yaml_free($string.start as *mut libc::c_void);
|
|
$string.end = ptr::null_mut::<yaml_char_t>();
|
|
$string.pointer = $string.end;
|
|
$string.start = $string.pointer;
|
|
}};
|
|
}
|
|
|
|
macro_rules! STRING_EXTEND {
|
|
($string:expr) => {
|
|
if $string.pointer.wrapping_add(5) >= $string.end {
|
|
yaml_string_extend(
|
|
addr_of_mut!($string.start),
|
|
addr_of_mut!($string.pointer),
|
|
addr_of_mut!($string.end),
|
|
);
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! CLEAR {
|
|
($string:expr) => {{
|
|
$string.pointer = $string.start;
|
|
memset(
|
|
$string.start as *mut libc::c_void,
|
|
0,
|
|
$string.end.c_offset_from($string.start) as libc::c_ulong,
|
|
);
|
|
}};
|
|
}
|
|
|
|
macro_rules! JOIN {
|
|
($string_a:expr, $string_b:expr) => {{
|
|
yaml_string_join(
|
|
addr_of_mut!($string_a.start),
|
|
addr_of_mut!($string_a.pointer),
|
|
addr_of_mut!($string_a.end),
|
|
addr_of_mut!($string_b.start),
|
|
addr_of_mut!($string_b.pointer),
|
|
addr_of_mut!($string_b.end),
|
|
);
|
|
$string_b.pointer = $string_b.start;
|
|
}};
|
|
}
|
|
|
|
macro_rules! CHECK_AT {
|
|
($string:expr, $octet:expr, $offset:expr) => {
|
|
*$string.pointer.offset($offset as isize) == $octet
|
|
};
|
|
}
|
|
|
|
macro_rules! CHECK {
|
|
($string:expr, $octet:expr) => {
|
|
*$string.pointer == $octet
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_ALPHA {
|
|
($string:expr) => {
|
|
*$string.pointer >= b'0' && *$string.pointer <= b'9'
|
|
|| *$string.pointer >= b'A' && *$string.pointer <= b'Z'
|
|
|| *$string.pointer >= b'a' && *$string.pointer <= b'z'
|
|
|| *$string.pointer == b'_'
|
|
|| *$string.pointer == b'-'
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_DIGIT {
|
|
($string:expr) => {
|
|
*$string.pointer >= b'0' && *$string.pointer <= b'9'
|
|
};
|
|
}
|
|
|
|
macro_rules! AS_DIGIT {
|
|
($string:expr) => {
|
|
(*$string.pointer - b'0') as libc::c_int
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_HEX_AT {
|
|
($string:expr, $offset:expr) => {
|
|
*$string.pointer.wrapping_offset($offset) >= b'0'
|
|
&& *$string.pointer.wrapping_offset($offset) <= b'9'
|
|
|| *$string.pointer.wrapping_offset($offset) >= b'A'
|
|
&& *$string.pointer.wrapping_offset($offset) <= b'F'
|
|
|| *$string.pointer.wrapping_offset($offset) >= b'a'
|
|
&& *$string.pointer.wrapping_offset($offset) <= b'f'
|
|
};
|
|
}
|
|
|
|
macro_rules! AS_HEX_AT {
|
|
($string:expr, $offset:expr) => {
|
|
if *$string.pointer.wrapping_offset($offset) >= b'A'
|
|
&& *$string.pointer.wrapping_offset($offset) <= b'F'
|
|
{
|
|
*$string.pointer.wrapping_offset($offset) - b'A' + 10
|
|
} else if *$string.pointer.wrapping_offset($offset) >= b'a'
|
|
&& *$string.pointer.wrapping_offset($offset) <= b'f'
|
|
{
|
|
*$string.pointer.wrapping_offset($offset) - b'a' + 10
|
|
} else {
|
|
*$string.pointer.wrapping_offset($offset) - b'0'
|
|
} as libc::c_int
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_ASCII {
|
|
($string:expr) => {
|
|
*$string.pointer <= b'\x7F'
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_PRINTABLE {
|
|
($string:expr) => {
|
|
match *$string.pointer {
|
|
// ASCII
|
|
0x0A | 0x20..=0x7E => true,
|
|
// U+A0 ... U+BF
|
|
0xC2 => match *$string.pointer.wrapping_offset(1) {
|
|
0xA0..=0xBF => true,
|
|
_ => false,
|
|
},
|
|
// U+C0 ... U+CFFF
|
|
0xC3..=0xEC => true,
|
|
// U+D000 ... U+D7FF
|
|
0xED => match *$string.pointer.wrapping_offset(1) {
|
|
0x00..=0x9F => true,
|
|
_ => false,
|
|
},
|
|
// U+E000 ... U+EFFF
|
|
0xEE => true,
|
|
// U+F000 ... U+FFFD
|
|
0xEF => match *$string.pointer.wrapping_offset(1) {
|
|
0xBB => match *$string.pointer.wrapping_offset(2) {
|
|
// except U+FEFF
|
|
0xBF => false,
|
|
_ => true,
|
|
},
|
|
0xBF => match *$string.pointer.wrapping_offset(2) {
|
|
0xBE | 0xBF => false,
|
|
_ => true,
|
|
},
|
|
_ => true,
|
|
},
|
|
// U+10000 ... U+10FFFF
|
|
0xF0..=0xF4 => true,
|
|
_ => false,
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_Z_AT {
|
|
($string:expr, $offset:expr) => {
|
|
CHECK_AT!($string, b'\0', $offset)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_Z {
|
|
($string:expr) => {
|
|
IS_Z_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BOM {
|
|
($string:expr) => {
|
|
CHECK_AT!($string, b'\xEF', 0)
|
|
&& CHECK_AT!($string, b'\xBB', 1)
|
|
&& CHECK_AT!($string, b'\xBF', 2)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_SPACE_AT {
|
|
($string:expr, $offset:expr) => {
|
|
CHECK_AT!($string, b' ', $offset)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_SPACE {
|
|
($string:expr) => {
|
|
IS_SPACE_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_TAB_AT {
|
|
($string:expr, $offset:expr) => {
|
|
CHECK_AT!($string, b'\t', $offset)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_TAB {
|
|
($string:expr) => {
|
|
IS_TAB_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BLANK_AT {
|
|
($string:expr, $offset:expr) => {
|
|
IS_SPACE_AT!($string, $offset) || IS_TAB_AT!($string, $offset)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BLANK {
|
|
($string:expr) => {
|
|
IS_BLANK_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BREAK_AT {
|
|
($string:expr, $offset:expr) => {
|
|
CHECK_AT!($string, b'\r', $offset)
|
|
|| CHECK_AT!($string, b'\n', $offset)
|
|
|| CHECK_AT!($string, b'\xC2', $offset) && CHECK_AT!($string, b'\x85', $offset + 1)
|
|
|| CHECK_AT!($string, b'\xE2', $offset)
|
|
&& CHECK_AT!($string, b'\x80', $offset + 1)
|
|
&& CHECK_AT!($string, b'\xA8', $offset + 2)
|
|
|| CHECK_AT!($string, b'\xE2', $offset)
|
|
&& CHECK_AT!($string, b'\x80', $offset + 1)
|
|
&& CHECK_AT!($string, b'\xA9', $offset + 2)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BREAK {
|
|
($string:expr) => {
|
|
IS_BREAK_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_CRLF {
|
|
($string:expr) => {
|
|
CHECK_AT!($string, b'\r', 0) && CHECK_AT!($string, b'\n', 1)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BREAKZ_AT {
|
|
($string:expr, $offset:expr) => {
|
|
IS_BREAK_AT!($string, $offset) || IS_Z_AT!($string, $offset)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BREAKZ {
|
|
($string:expr) => {
|
|
IS_BREAKZ_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BLANKZ_AT {
|
|
($string:expr, $offset:expr) => {
|
|
IS_BLANK_AT!($string, $offset) || IS_BREAKZ_AT!($string, $offset)
|
|
};
|
|
}
|
|
|
|
macro_rules! IS_BLANKZ {
|
|
($string:expr) => {
|
|
IS_BLANKZ_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! WIDTH_AT {
|
|
($string:expr, $offset:expr) => {
|
|
if *$string.pointer.wrapping_offset($offset as isize) & 0x80 == 0x00 {
|
|
1
|
|
} else if *$string.pointer.wrapping_offset($offset as isize) & 0xE0 == 0xC0 {
|
|
2
|
|
} else if *$string.pointer.wrapping_offset($offset as isize) & 0xF0 == 0xE0 {
|
|
3
|
|
} else if *$string.pointer.wrapping_offset($offset as isize) & 0xF8 == 0xF0 {
|
|
4
|
|
} else {
|
|
0
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! WIDTH {
|
|
($string:expr) => {
|
|
WIDTH_AT!($string, 0)
|
|
};
|
|
}
|
|
|
|
macro_rules! MOVE {
|
|
($string:expr) => {
|
|
$string.pointer = $string.pointer.wrapping_offset(WIDTH!($string) as isize)
|
|
};
|
|
}
|
|
|
|
macro_rules! COPY {
|
|
($string_a:expr, $string_b:expr) => {
|
|
if *$string_b.pointer & 0x80 == 0x00 {
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
} else if *$string_b.pointer & 0xE0 == 0xC0 {
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
} else if *$string_b.pointer & 0xF0 == 0xE0 {
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
} else if *$string_b.pointer & 0xF8 == 0xF0 {
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
*$string_a.pointer = *$string_b.pointer;
|
|
$string_a.pointer = $string_a.pointer.wrapping_offset(1);
|
|
$string_b.pointer = $string_b.pointer.wrapping_offset(1);
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! STACK_INIT {
|
|
($stack:expr, $type:ty) => {{
|
|
$stack.start = yaml_malloc(16 * size_of::<$type>() as libc::c_ulong) as *mut $type;
|
|
$stack.top = $stack.start;
|
|
$stack.end = $stack.start.offset(16_isize);
|
|
}};
|
|
}
|
|
|
|
macro_rules! STACK_DEL {
|
|
($stack:expr) => {
|
|
yaml_free($stack.start as *mut libc::c_void);
|
|
$stack.end = ptr::null_mut();
|
|
$stack.top = ptr::null_mut();
|
|
$stack.start = ptr::null_mut();
|
|
};
|
|
}
|
|
|
|
macro_rules! STACK_EMPTY {
|
|
($stack:expr) => {
|
|
$stack.start == $stack.top
|
|
};
|
|
}
|
|
|
|
macro_rules! STACK_LIMIT {
|
|
($context:expr, $stack:expr) => {
|
|
if $stack.top.c_offset_from($stack.start) < libc::c_int::MAX as isize - 1 {
|
|
OK
|
|
} else {
|
|
(*$context).error = YAML_MEMORY_ERROR;
|
|
FAIL
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! PUSH {
|
|
(do $stack:expr, $push:expr) => {{
|
|
if $stack.top == $stack.end {
|
|
yaml_stack_extend(
|
|
addr_of_mut!($stack.start) as *mut *mut libc::c_void,
|
|
addr_of_mut!($stack.top) as *mut *mut libc::c_void,
|
|
addr_of_mut!($stack.end) as *mut *mut libc::c_void,
|
|
);
|
|
}
|
|
$push;
|
|
$stack.top = $stack.top.wrapping_offset(1);
|
|
}};
|
|
($stack:expr, *$value:expr) => {
|
|
PUSH!(do $stack, ptr::copy_nonoverlapping($value, $stack.top, 1))
|
|
};
|
|
($stack:expr, $value:expr) => {
|
|
PUSH!(do $stack, ptr::write($stack.top, $value))
|
|
};
|
|
}
|
|
|
|
macro_rules! POP {
|
|
($stack:expr) => {
|
|
*{
|
|
$stack.top = $stack.top.offset(-1);
|
|
$stack.top
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! QUEUE_INIT {
|
|
($queue:expr, $type:ty) => {{
|
|
$queue.start = yaml_malloc(16 * size_of::<$type>() as libc::c_ulong) as *mut $type;
|
|
$queue.tail = $queue.start;
|
|
$queue.head = $queue.tail;
|
|
$queue.end = $queue.start.offset(16_isize);
|
|
}};
|
|
}
|
|
|
|
macro_rules! QUEUE_DEL {
|
|
($queue:expr) => {
|
|
yaml_free($queue.start as *mut libc::c_void);
|
|
$queue.end = ptr::null_mut();
|
|
$queue.tail = ptr::null_mut();
|
|
$queue.head = ptr::null_mut();
|
|
$queue.start = ptr::null_mut();
|
|
};
|
|
}
|
|
|
|
macro_rules! QUEUE_EMPTY {
|
|
($queue:expr) => {
|
|
$queue.head == $queue.tail
|
|
};
|
|
}
|
|
|
|
macro_rules! ENQUEUE {
|
|
(do $queue:expr, $enqueue:expr) => {{
|
|
if $queue.tail == $queue.end {
|
|
yaml_queue_extend(
|
|
addr_of_mut!($queue.start) as *mut *mut libc::c_void,
|
|
addr_of_mut!($queue.head) as *mut *mut libc::c_void,
|
|
addr_of_mut!($queue.tail) as *mut *mut libc::c_void,
|
|
addr_of_mut!($queue.end) as *mut *mut libc::c_void,
|
|
);
|
|
}
|
|
$enqueue;
|
|
$queue.tail = $queue.tail.wrapping_offset(1);
|
|
}};
|
|
($queue:expr, *$value:expr) => {
|
|
ENQUEUE!(do $queue, ptr::copy_nonoverlapping($value, $queue.tail, 1))
|
|
};
|
|
($queue:expr, $value:expr) => {
|
|
ENQUEUE!(do $queue, ptr::write($queue.tail, $value))
|
|
};
|
|
}
|
|
|
|
macro_rules! DEQUEUE {
|
|
($queue:expr) => {
|
|
*{
|
|
let head = $queue.head;
|
|
$queue.head = $queue.head.wrapping_offset(1);
|
|
head
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! QUEUE_INSERT {
|
|
($queue:expr, $index:expr, $value:expr) => {{
|
|
if $queue.tail == $queue.end {
|
|
yaml_queue_extend(
|
|
addr_of_mut!($queue.start) as *mut *mut libc::c_void,
|
|
addr_of_mut!($queue.head) as *mut *mut libc::c_void,
|
|
addr_of_mut!($queue.tail) as *mut *mut libc::c_void,
|
|
addr_of_mut!($queue.end) as *mut *mut libc::c_void,
|
|
);
|
|
}
|
|
memmove(
|
|
$queue
|
|
.head
|
|
.wrapping_offset($index as isize)
|
|
.wrapping_offset(1_isize) as *mut libc::c_void,
|
|
$queue.head.wrapping_offset($index as isize) as *const libc::c_void,
|
|
($queue.tail.c_offset_from($queue.head) as libc::c_ulong)
|
|
.wrapping_sub($index)
|
|
.wrapping_mul(size_of::<yaml_token_t>() as libc::c_ulong),
|
|
);
|
|
*$queue.head.wrapping_offset($index as isize) = $value;
|
|
let fresh14 = addr_of_mut!($queue.tail);
|
|
*fresh14 = (*fresh14).wrapping_offset(1);
|
|
}};
|
|
}
|