tree_sitter_c2rust/core_wrapper/core/
lexer.rsuse crate::core_transpiled::util::*;
use crate::core_transpiled::*;
use std::os;
pub type __uint8_t = libc::c_uchar;
pub type __uint16_t = libc::c_ushort;
pub type __int32_t = libc::c_int;
pub type __uint32_t = libc::c_uint;
pub type int32_t = __int32_t;
pub type uint8_t = __uint8_t;
pub type uint16_t = __uint16_t;
pub type uint32_t = __uint32_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct Lexer {
pub data: TSLexer,
pub current_position: Length,
pub token_start_position: Length,
pub token_end_position: Length,
pub included_ranges: *mut TSRange,
pub chunk: *const libc::c_char,
pub input: TSInput,
pub logger: TSLogger,
pub included_range_count: uint32_t,
pub current_included_range_index: uint32_t,
pub chunk_start: uint32_t,
pub chunk_size: uint32_t,
pub lookahead_size: uint32_t,
pub did_get_column: bool,
pub debug_buffer: [libc::c_char; 1024],
}
pub type UnicodeDecodeFunction =
Option<unsafe extern "C" fn(*const uint8_t, uint32_t, *mut int32_t) -> uint32_t>;
pub type UChar32 = int32_t;
static mut LENGTH_UNDEFINED: Length = {
let mut init = Length {
bytes: 0 as libc::c_int as uint32_t,
extent: {
let mut init = TSPoint {
row: 0 as libc::c_int as uint32_t,
column: 1 as libc::c_int as uint32_t,
};
init
},
};
init
};
#[inline]
unsafe extern "C" fn length_is_undefined(mut length: Length) -> bool {
return length.bytes == 0 as libc::c_int as libc::c_uint
&& length.extent.column != 0 as libc::c_int as libc::c_uint;
}
#[inline]
unsafe extern "C" fn ts_decode_utf16(
mut string: *const uint8_t,
mut length: uint32_t,
mut code_point: *mut int32_t,
) -> uint32_t {
let mut i: uint32_t = 0 as libc::c_int as uint32_t;
let fresh0 = i;
i = i.wrapping_add(1);
*code_point = *(string as *mut uint16_t).offset(fresh0 as isize) as int32_t;
if *code_point as libc::c_uint & 0xfffffc00 as libc::c_uint
== 0xd800 as libc::c_int as libc::c_uint
{
let mut __c2: uint16_t = 0;
if i != length && {
__c2 = *(string as *mut uint16_t).offset(i as isize);
__c2 as libc::c_uint & 0xfffffc00 as libc::c_uint
== 0xdc00 as libc::c_int as libc::c_uint
} {
i = i.wrapping_add(1);
*code_point = (*code_point << 10 as libc::c_ulong) + __c2 as UChar32
- (((0xd800 as libc::c_int) << 10 as libc::c_ulong) + 0xdc00 as libc::c_int
- 0x10000 as libc::c_int);
}
}
return i.wrapping_mul(2 as libc::c_int as libc::c_uint);
}
#[inline]
unsafe extern "C" fn ts_decode_utf8(
mut string: *const uint8_t,
mut length: uint32_t,
mut code_point: *mut int32_t,
) -> uint32_t {
let mut i: uint32_t = 0 as libc::c_int as uint32_t;
let fresh1 = i;
i = i.wrapping_add(1);
*code_point = *string.offset(fresh1 as isize) as int32_t;
if !(*code_point & 0x80 as libc::c_int == 0 as libc::c_int) {
let mut __t: uint8_t = 0 as libc::c_int as uint8_t;
if !(i != length
&& (if *code_point >= 0xe0 as libc::c_int {
((if *code_point < 0xf0 as libc::c_int {
*code_point &= 0xf as libc::c_int;
__t = *string.offset(i as isize);
((*::core::mem::transmute::<&[u8; 17], &[libc::c_char; 17]>(
b" 000000000000\x1000\0",
))[*code_point as usize] as libc::c_int
& (1 as libc::c_int) << (__t as libc::c_int >> 5 as libc::c_int)
!= 0
&& {
__t = (__t as libc::c_int & 0x3f as libc::c_int) as uint8_t;
1 as libc::c_int != 0
}) as libc::c_int
} else {
*code_point -= 0xf0 as libc::c_int;
(*code_point <= 4 as libc::c_int
&& {
__t = *string.offset(i as isize);
(*::core::mem::transmute::<&[u8; 17], &[libc::c_char; 17]>(
b"\0\0\0\0\0\0\0\0\x1E\x0F\x0F\x0F\0\0\0\0\0",
))[(__t as libc::c_int >> 4 as libc::c_int) as usize]
as libc::c_int
& (1 as libc::c_int) << *code_point
!= 0
}
&& {
*code_point = *code_point << 6 as libc::c_int
| __t as libc::c_int & 0x3f as libc::c_int;
i = i.wrapping_add(1);
i != length
}
&& {
__t = (*string.offset(i as isize) as libc::c_int - 0x80 as libc::c_int)
as uint8_t;
__t as libc::c_int <= 0x3f as libc::c_int
}) as libc::c_int
}) != 0
&& {
*code_point = *code_point << 6 as libc::c_int | __t as libc::c_int;
i = i.wrapping_add(1);
i != length
}) as libc::c_int
} else {
(*code_point >= 0xc2 as libc::c_int && {
*code_point &= 0x1f as libc::c_int;
1 as libc::c_int != 0
}) as libc::c_int
}) != 0
&& {
__t = (*string.offset(i as isize) as libc::c_int - 0x80 as libc::c_int) as uint8_t;
__t as libc::c_int <= 0x3f as libc::c_int
}
&& {
*code_point = *code_point << 6 as libc::c_int | __t as libc::c_int;
i = i.wrapping_add(1);
1 as libc::c_int != 0
})
{
*code_point = -(1 as libc::c_int);
}
}
return i;
}
static mut TS_DECODE_ERROR: int32_t = -(1 as libc::c_int);
static mut BYTE_ORDER_MARK: int32_t = 0xfeff as libc::c_int;
static mut DEFAULT_RANGE: TSRange = {
let mut init = TSRange {
start_point: {
let mut init = TSPoint {
row: 0 as libc::c_int as uint32_t,
column: 0 as libc::c_int as uint32_t,
};
init
},
end_point: {
let mut init = TSPoint {
row: 4294967295 as libc::c_uint,
column: 4294967295 as libc::c_uint,
};
init
},
start_byte: 0 as libc::c_int as uint32_t,
end_byte: 4294967295 as libc::c_uint,
};
init
};
unsafe extern "C" fn ts_lexer__eof(mut _self: *const TSLexer) -> bool {
let mut self_0: *mut Lexer = _self as *mut Lexer;
return (*self_0).current_included_range_index == (*self_0).included_range_count;
}
unsafe extern "C" fn ts_lexer__clear_chunk(mut self_0: *mut Lexer) {
(*self_0).chunk = 0 as *const libc::c_char;
(*self_0).chunk_size = 0 as libc::c_int as uint32_t;
(*self_0).chunk_start = 0 as libc::c_int as uint32_t;
}
unsafe extern "C" fn ts_lexer__get_chunk(mut self_0: *mut Lexer) {
(*self_0).chunk_start = (*self_0).current_position.bytes;
(*self_0).chunk = ((*self_0).input.read).expect("non-null function pointer")(
(*self_0).input.payload,
(*self_0).current_position.bytes,
(*self_0).current_position.extent,
&mut (*self_0).chunk_size,
);
if (*self_0).chunk_size == 0 {
(*self_0).current_included_range_index = (*self_0).included_range_count;
(*self_0).chunk = 0 as *const libc::c_char;
}
}
unsafe extern "C" fn ts_lexer__get_lookahead(mut self_0: *mut Lexer) {
let mut position_in_chunk: uint32_t =
((*self_0).current_position.bytes).wrapping_sub((*self_0).chunk_start);
let mut size: uint32_t = ((*self_0).chunk_size).wrapping_sub(position_in_chunk);
if size == 0 as libc::c_int as libc::c_uint {
(*self_0).lookahead_size = 1 as libc::c_int as uint32_t;
(*self_0).data.lookahead = '\0' as i32;
return;
}
let mut chunk: *const uint8_t =
((*self_0).chunk as *const uint8_t).offset(position_in_chunk as isize);
let mut decode: UnicodeDecodeFunction = if (*self_0).input.encoding as libc::c_uint
== TSInputEncodingUTF8 as libc::c_int as libc::c_uint
{
Some(
ts_decode_utf8
as unsafe extern "C" fn(*const uint8_t, uint32_t, *mut int32_t) -> uint32_t,
)
} else {
Some(
ts_decode_utf16
as unsafe extern "C" fn(*const uint8_t, uint32_t, *mut int32_t) -> uint32_t,
)
};
(*self_0).lookahead_size =
decode.expect("non-null function pointer")(chunk, size, &mut (*self_0).data.lookahead);
if (*self_0).data.lookahead == TS_DECODE_ERROR && size < 4 as libc::c_int as libc::c_uint {
ts_lexer__get_chunk(self_0);
chunk = (*self_0).chunk as *const uint8_t;
size = (*self_0).chunk_size;
(*self_0).lookahead_size =
decode.expect("non-null function pointer")(chunk, size, &mut (*self_0).data.lookahead);
}
if (*self_0).data.lookahead == TS_DECODE_ERROR {
(*self_0).lookahead_size = 1 as libc::c_int as uint32_t;
}
}
unsafe extern "C" fn ts_lexer_goto(mut self_0: *mut Lexer, mut position: Length) {
(*self_0).current_position = position;
let mut found_included_range: bool = 0 as libc::c_int != 0;
let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
while i < (*self_0).included_range_count {
let mut included_range: *mut TSRange =
&mut *((*self_0).included_ranges).offset(i as isize) as *mut TSRange;
if (*included_range).end_byte > (*self_0).current_position.bytes
&& (*included_range).end_byte > (*included_range).start_byte
{
if (*included_range).start_byte >= (*self_0).current_position.bytes {
(*self_0).current_position = {
let mut init = Length {
bytes: (*included_range).start_byte,
extent: (*included_range).start_point,
};
init
};
}
(*self_0).current_included_range_index = i;
found_included_range = 1 as libc::c_int != 0;
break;
} else {
i = i.wrapping_add(1);
}
}
if found_included_range {
if !((*self_0).chunk).is_null()
&& ((*self_0).current_position.bytes < (*self_0).chunk_start
|| (*self_0).current_position.bytes
>= ((*self_0).chunk_start).wrapping_add((*self_0).chunk_size))
{
ts_lexer__clear_chunk(self_0);
}
(*self_0).lookahead_size = 0 as libc::c_int as uint32_t;
(*self_0).data.lookahead = '\0' as i32;
} else {
(*self_0).current_included_range_index = (*self_0).included_range_count;
let mut last_included_range: *mut TSRange = &mut *((*self_0).included_ranges).offset(
((*self_0).included_range_count).wrapping_sub(1 as libc::c_int as libc::c_uint)
as isize,
) as *mut TSRange;
(*self_0).current_position = {
let mut init = Length {
bytes: (*last_included_range).end_byte,
extent: (*last_included_range).end_point,
};
init
};
ts_lexer__clear_chunk(self_0);
(*self_0).lookahead_size = 1 as libc::c_int as uint32_t;
(*self_0).data.lookahead = '\0' as i32;
};
}
unsafe extern "C" fn ts_lexer__do_advance(mut self_0: *mut Lexer, mut skip: bool) {
if (*self_0).lookahead_size != 0 {
(*self_0).current_position.bytes = ((*self_0).current_position.bytes as libc::c_uint)
.wrapping_add((*self_0).lookahead_size)
as uint32_t as uint32_t;
if (*self_0).data.lookahead == '\n' as i32 {
(*self_0).current_position.extent.row =
((*self_0).current_position.extent.row).wrapping_add(1);
(*self_0).current_position.extent.column = 0 as libc::c_int as uint32_t;
} else {
(*self_0).current_position.extent.column =
((*self_0).current_position.extent.column as libc::c_uint)
.wrapping_add((*self_0).lookahead_size) as uint32_t as uint32_t;
}
}
let mut current_range: *const TSRange = &mut *((*self_0).included_ranges)
.offset((*self_0).current_included_range_index as isize)
as *mut TSRange;
while (*self_0).current_position.bytes >= (*current_range).end_byte
|| (*current_range).end_byte == (*current_range).start_byte
{
if (*self_0).current_included_range_index < (*self_0).included_range_count {
(*self_0).current_included_range_index =
((*self_0).current_included_range_index).wrapping_add(1);
}
if (*self_0).current_included_range_index < (*self_0).included_range_count {
current_range = current_range.offset(1);
(*self_0).current_position = {
let mut init = Length {
bytes: (*current_range).start_byte,
extent: (*current_range).start_point,
};
init
};
} else {
current_range = 0 as *const TSRange;
break;
}
}
if skip {
(*self_0).token_start_position = (*self_0).current_position;
}
if !current_range.is_null() {
if (*self_0).current_position.bytes < (*self_0).chunk_start
|| (*self_0).current_position.bytes
>= ((*self_0).chunk_start).wrapping_add((*self_0).chunk_size)
{
ts_lexer__get_chunk(self_0);
}
ts_lexer__get_lookahead(self_0);
} else {
ts_lexer__clear_chunk(self_0);
(*self_0).data.lookahead = '\0' as i32;
(*self_0).lookahead_size = 1 as libc::c_int as uint32_t;
};
}
unsafe extern "C" fn ts_lexer__advance(mut _self: *mut TSLexer, mut skip: bool) {
let mut self_0: *mut Lexer = _self as *mut Lexer;
if ((*self_0).chunk).is_null() {
return;
}
if skip {
if ((*self_0).logger.log).is_some() {
{
if 32 as libc::c_int <= (*self_0).data.lookahead
&& (*self_0).data.lookahead < 127 as libc::c_int
{
snwrite!(
((*self_0).debug_buffer).as_mut_ptr(),
1024 as libc::c_int as libc::c_ulong as usize,
"skip character:'{}'",
(*self_0).data.lookahead as u8 as char
)
.unwrap_or(usize::MAX) as os::raw::c_int
} else {
snwrite!(
((*self_0).debug_buffer).as_mut_ptr(),
1024 as libc::c_int as libc::c_ulong as usize,
"skip character:{}",
(*self_0).data.lookahead
)
.unwrap_or(usize::MAX) as os::raw::c_int
}
};
((*self_0).logger.log).expect("non-null function pointer")(
(*self_0).logger.payload,
TSLogTypeLex,
((*self_0).debug_buffer).as_mut_ptr(),
);
}
} else if ((*self_0).logger.log).is_some() {
{
if 32 as libc::c_int <= (*self_0).data.lookahead
&& (*self_0).data.lookahead < 127 as libc::c_int
{
snwrite!(
((*self_0).debug_buffer).as_mut_ptr(),
1024 as libc::c_int as libc::c_ulong as usize,
"consume character:'{}'",
(*self_0).data.lookahead as u8 as char
)
.unwrap_or(usize::MAX) as os::raw::c_int
} else {
snwrite!(
((*self_0).debug_buffer).as_mut_ptr(),
1024 as libc::c_int as libc::c_ulong as usize,
"consume character:{}",
(*self_0).data.lookahead
)
.unwrap_or(usize::MAX) as os::raw::c_int
}
};
((*self_0).logger.log).expect("non-null function pointer")(
(*self_0).logger.payload,
TSLogTypeLex,
((*self_0).debug_buffer).as_mut_ptr(),
);
}
ts_lexer__do_advance(self_0, skip);
}
unsafe extern "C" fn ts_lexer__mark_end(mut _self: *mut TSLexer) {
let mut self_0: *mut Lexer = _self as *mut Lexer;
if !ts_lexer__eof(&mut (*self_0).data) {
let mut current_included_range: *mut TSRange = &mut *((*self_0).included_ranges)
.offset((*self_0).current_included_range_index as isize)
as *mut TSRange;
if (*self_0).current_included_range_index > 0 as libc::c_int as libc::c_uint
&& (*self_0).current_position.bytes == (*current_included_range).start_byte
{
let mut previous_included_range: *mut TSRange =
current_included_range.offset(-(1 as libc::c_int as isize));
(*self_0).token_end_position = {
let mut init = Length {
bytes: (*previous_included_range).end_byte,
extent: (*previous_included_range).end_point,
};
init
};
return;
}
}
(*self_0).token_end_position = (*self_0).current_position;
}
unsafe extern "C" fn ts_lexer__get_column(mut _self: *mut TSLexer) -> uint32_t {
let mut self_0: *mut Lexer = _self as *mut Lexer;
let mut goal_byte: uint32_t = (*self_0).current_position.bytes;
(*self_0).did_get_column = 1 as libc::c_int != 0;
let mut start_of_col: Length = {
let mut init = Length {
bytes: ((*self_0).current_position.bytes)
.wrapping_sub((*self_0).current_position.extent.column),
extent: {
let mut init = TSPoint {
row: (*self_0).current_position.extent.row,
column: 0 as libc::c_int as uint32_t,
};
init
},
};
init
};
ts_lexer_goto(self_0, start_of_col);
ts_lexer__get_chunk(self_0);
let mut result: uint32_t = 0 as libc::c_int as uint32_t;
if !ts_lexer__eof(_self) {
ts_lexer__get_lookahead(self_0);
while (*self_0).current_position.bytes < goal_byte && !((*self_0).chunk).is_null() {
result = result.wrapping_add(1);
ts_lexer__do_advance(self_0, 0 as libc::c_int != 0);
if ts_lexer__eof(_self) {
break;
}
}
}
return result;
}
unsafe extern "C" fn ts_lexer__is_at_included_range_start(mut _self: *const TSLexer) -> bool {
let mut self_0: *const Lexer = _self as *const Lexer;
if (*self_0).current_included_range_index < (*self_0).included_range_count {
let mut current_range: *mut TSRange = &mut *((*self_0).included_ranges)
.offset((*self_0).current_included_range_index as isize)
as *mut TSRange;
return (*self_0).current_position.bytes == (*current_range).start_byte;
} else {
return 0 as libc::c_int != 0;
};
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_init(mut self_0: *mut Lexer) {
*self_0 = {
let mut init = Lexer {
data: {
let mut init = TSLexer {
lookahead: 0 as libc::c_int,
result_symbol: 0 as libc::c_int as TSSymbol,
advance: Some(
ts_lexer__advance as unsafe extern "C" fn(*mut TSLexer, bool) -> (),
),
mark_end: Some(ts_lexer__mark_end as unsafe extern "C" fn(*mut TSLexer) -> ()),
get_column: Some(
ts_lexer__get_column as unsafe extern "C" fn(*mut TSLexer) -> uint32_t,
),
is_at_included_range_start: Some(
ts_lexer__is_at_included_range_start
as unsafe extern "C" fn(*const TSLexer) -> bool,
),
eof: Some(ts_lexer__eof as unsafe extern "C" fn(*const TSLexer) -> bool),
};
init
},
current_position: {
let mut init = Length {
bytes: 0 as libc::c_int as uint32_t,
extent: {
let mut init = TSPoint {
row: 0 as libc::c_int as uint32_t,
column: 0 as libc::c_int as uint32_t,
};
init
},
};
init
},
token_start_position: Length {
bytes: 0,
extent: TSPoint { row: 0, column: 0 },
},
token_end_position: Length {
bytes: 0,
extent: TSPoint { row: 0, column: 0 },
},
included_ranges: 0 as *mut TSRange,
chunk: 0 as *const libc::c_char,
input: TSInput {
payload: 0 as *mut libc::c_void,
read: None,
encoding: TSInputEncodingUTF8,
},
logger: {
let mut init = TSLogger {
payload: 0 as *mut libc::c_void,
log: None,
};
init
},
included_range_count: 0 as libc::c_int as uint32_t,
current_included_range_index: 0 as libc::c_int as uint32_t,
chunk_start: 0 as libc::c_int as uint32_t,
chunk_size: 0 as libc::c_int as uint32_t,
lookahead_size: 0,
did_get_column: false,
debug_buffer: [0; 1024],
};
init
};
ts_lexer_set_included_ranges(self_0, 0 as *const TSRange, 0 as libc::c_int as uint32_t);
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_delete(mut self_0: *mut Lexer) {
crate::core_transpiled::alloc::ts_free((*self_0).included_ranges as *mut libc::c_void);
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_set_input(mut self_0: *mut Lexer, mut input: TSInput) {
(*self_0).input = input;
ts_lexer__clear_chunk(self_0);
ts_lexer_goto(self_0, (*self_0).current_position);
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_reset(mut self_0: *mut Lexer, mut position: Length) {
if position.bytes != (*self_0).current_position.bytes {
ts_lexer_goto(self_0, position);
}
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_start(mut self_0: *mut Lexer) {
(*self_0).token_start_position = (*self_0).current_position;
(*self_0).token_end_position = LENGTH_UNDEFINED;
(*self_0).data.result_symbol = 0 as libc::c_int as TSSymbol;
(*self_0).did_get_column = 0 as libc::c_int != 0;
if !ts_lexer__eof(&mut (*self_0).data) {
if (*self_0).chunk_size == 0 {
ts_lexer__get_chunk(self_0);
}
if (*self_0).lookahead_size == 0 {
ts_lexer__get_lookahead(self_0);
}
if (*self_0).current_position.bytes == 0 as libc::c_int as libc::c_uint
&& (*self_0).data.lookahead == BYTE_ORDER_MARK
{
ts_lexer__advance(&mut (*self_0).data, 1 as libc::c_int != 0);
}
}
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_finish(
mut self_0: *mut Lexer,
mut lookahead_end_byte: *mut uint32_t,
) {
if length_is_undefined((*self_0).token_end_position) {
ts_lexer__mark_end(&mut (*self_0).data);
}
if (*self_0).token_end_position.bytes < (*self_0).token_start_position.bytes {
(*self_0).token_start_position = (*self_0).token_end_position;
}
let mut current_lookahead_end_byte: uint32_t =
((*self_0).current_position.bytes).wrapping_add(1 as libc::c_int as libc::c_uint);
if (*self_0).data.lookahead == TS_DECODE_ERROR {
current_lookahead_end_byte = (current_lookahead_end_byte as libc::c_uint)
.wrapping_add(4 as libc::c_int as libc::c_uint)
as uint32_t as uint32_t;
}
if current_lookahead_end_byte > *lookahead_end_byte {
*lookahead_end_byte = current_lookahead_end_byte;
}
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_advance_to_end(mut self_0: *mut Lexer) {
while !((*self_0).chunk).is_null() {
ts_lexer__advance(&mut (*self_0).data, 0 as libc::c_int != 0);
}
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_mark_end(mut self_0: *mut Lexer) {
ts_lexer__mark_end(&mut (*self_0).data);
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_set_included_ranges(
mut self_0: *mut Lexer,
mut ranges: *const TSRange,
mut count: uint32_t,
) -> bool {
if count == 0 as libc::c_int as libc::c_uint || ranges.is_null() {
ranges = &DEFAULT_RANGE;
count = 1 as libc::c_int as uint32_t;
} else {
let mut previous_byte: uint32_t = 0 as libc::c_int as uint32_t;
let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
while i < count {
let mut range: *const TSRange = &*ranges.offset(i as isize) as *const TSRange;
if (*range).start_byte < previous_byte || (*range).end_byte < (*range).start_byte {
return 0 as libc::c_int != 0;
}
previous_byte = (*range).end_byte;
i = i.wrapping_add(1);
}
}
let mut size: size_t =
(count as libc::c_ulong).wrapping_mul(::core::mem::size_of::<TSRange>() as libc::c_ulong);
(*self_0).included_ranges = crate::core_transpiled::alloc::ts_realloc(
(*self_0).included_ranges as *mut libc::c_void,
size,
) as *mut TSRange;
std::ptr::copy_nonoverlapping(
ranges as *const libc::c_void,
(*self_0).included_ranges as *mut libc::c_void,
size,
);
(*self_0).included_range_count = count;
ts_lexer_goto(self_0, (*self_0).current_position);
return 1 as libc::c_int != 0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_lexer_included_ranges(
mut self_0: *const Lexer,
mut count: *mut uint32_t,
) -> *mut TSRange {
*count = (*self_0).included_range_count;
return (*self_0).included_ranges;
}