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);
    }};
}