use crate::core_transpiled::util::*;
use crate::core_transpiled::*;
use :: c2rust_bitfields;
use std::os;
pub type __uint8_t = libc::c_uchar;
pub type __int16_t = libc::c_short;
pub type __uint16_t = libc::c_ushort;
pub type __int32_t = libc::c_int;
pub type __uint32_t = libc::c_uint;
pub type int16_t = __int16_t;
pub type int32_t = __int32_t;
pub type uint8_t = __uint8_t;
pub type uint16_t = __uint16_t;
pub type uint32_t = __uint32_t;
pub type TSStateId = uint16_t;
pub type TSFieldId = uint16_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed {
pub states: *const bool,
pub symbol_map: *const TSSymbol,
pub create: Option<unsafe extern "C" fn() -> *mut libc::c_void>,
pub destroy: Option<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
pub scan: Option<unsafe extern "C" fn(*mut libc::c_void, *mut TSLexer, *const bool) -> bool>,
pub serialize:
Option<unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_char) -> libc::c_uint>,
pub deserialize:
Option<unsafe extern "C" fn(*mut libc::c_void, *const libc::c_char, libc::c_uint) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_0 {
pub count: uint8_t,
pub reusable: bool,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_1 {
pub type_: uint8_t,
pub child_count: uint8_t,
pub symbol: TSSymbol,
pub dynamic_precedence: int16_t,
pub production_id: uint16_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_2 {
pub type_: uint8_t,
pub state: TSStateId,
pub extra: bool,
pub repetition: bool,
}
type C2RustUnnamed_3 = crate::core_transpiled::util::ScannerStateWithLookahead;
type C2RustUnnamed_4 = crate::core_transpiled::util::LongShortData;
type C2RustUnnamed_5 = crate::core_transpiled::util::ScannerStateLookaheadMeta;
type C2RustUnnamed_6 = crate::core_transpiled::util::ScannerStateLookaheadFirstLeaf;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct TSNode {
pub context: [uint32_t; 4],
pub id: *const libc::c_void,
pub tree: *const TSTree,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct NodeChildIterator {
pub parent: Subtree,
pub tree: *const TSTree,
pub position: Length,
pub child_index: uint32_t,
pub structural_child_index: uint32_t,
pub alias_sequence: *const TSSymbol,
}
#[inline]
unsafe extern "C" fn ts_subtree_symbol(mut self_0: Subtree) -> TSSymbol {
return (if (self_0.data).is_inline() as libc::c_int != 0 {
self_0.data.symbol as libc::c_int
} else {
(*self_0.ptr).symbol as libc::c_int
}) as TSSymbol;
}
#[inline]
unsafe extern "C" fn ts_subtree_size(mut self_0: Subtree) -> Length {
if (self_0.data).is_inline() {
let mut result: Length = {
let mut init = Length {
bytes: self_0.data.size_bytes as uint32_t,
extent: {
let mut init = TSPoint {
row: 0 as libc::c_int as uint32_t,
column: self_0.data.size_bytes as uint32_t,
};
init
},
};
init
};
return result;
} else {
return (*self_0.ptr).size;
};
}
#[inline]
unsafe extern "C" fn point_add(mut a: TSPoint, mut b: TSPoint) -> TSPoint {
if b.row > 0 as libc::c_int as libc::c_uint {
return point__new((a.row).wrapping_add(b.row), b.column);
} else {
return point__new(a.row, (a.column).wrapping_add(b.column));
};
}
#[inline]
unsafe extern "C" fn point__new(mut row: libc::c_uint, mut column: libc::c_uint) -> TSPoint {
let mut result: TSPoint = {
let mut init = TSPoint {
row: row,
column: column,
};
init
};
return result;
}
#[inline]
unsafe extern "C" fn ts_subtree_named(mut self_0: Subtree) -> bool {
return if (self_0.data).is_inline() as libc::c_int != 0 {
(self_0.data).named() as libc::c_int
} else {
(*self_0.ptr).named() as libc::c_int
} != 0;
}
#[inline]
unsafe extern "C" fn ts_subtree_missing(mut self_0: Subtree) -> bool {
return if (self_0.data).is_inline() as libc::c_int != 0 {
(self_0.data).is_missing() as libc::c_int
} else {
(*self_0.ptr).is_missing() as libc::c_int
} != 0;
}
#[inline]
unsafe extern "C" fn ts_subtree_extra(mut self_0: Subtree) -> bool {
return if (self_0.data).is_inline() as libc::c_int != 0 {
(self_0.data).extra() as libc::c_int
} else {
(*self_0.ptr).extra() as libc::c_int
} != 0;
}
#[inline]
unsafe extern "C" fn ts_subtree_has_changes(mut self_0: Subtree) -> bool {
return if (self_0.data).is_inline() as libc::c_int != 0 {
(self_0.data).has_changes() as libc::c_int
} else {
(*self_0.ptr).has_changes() as libc::c_int
} != 0;
}
#[inline]
unsafe extern "C" fn ts_subtree_error_cost(mut self_0: Subtree) -> uint32_t {
if ts_subtree_missing(self_0) {
return (110 as libc::c_int + 500 as libc::c_int) as uint32_t;
} else {
return if (self_0.data).is_inline() as libc::c_int != 0 {
0 as libc::c_int as libc::c_uint
} else {
(*self_0.ptr).error_cost
};
};
}
#[inline]
unsafe extern "C" fn ts_subtree_parse_state(mut self_0: Subtree) -> TSStateId {
return (if (self_0.data).is_inline() as libc::c_int != 0 {
self_0.data.parse_state as libc::c_int
} else {
(*self_0.ptr).parse_state as libc::c_int
}) as TSStateId;
}
#[inline]
unsafe extern "C" fn ts_subtree_visible(mut self_0: Subtree) -> bool {
return if (self_0.data).is_inline() as libc::c_int != 0 {
(self_0.data).visible() as libc::c_int
} else {
(*self_0.ptr).visible() as libc::c_int
} != 0;
}
#[inline]
unsafe extern "C" fn ts_subtree_child_count(mut self_0: Subtree) -> uint32_t {
return if (self_0.data).is_inline() as libc::c_int != 0 {
0 as libc::c_int as libc::c_uint
} else {
(*self_0.ptr).child_count
};
}
#[inline]
unsafe extern "C" fn length_zero() -> Length {
let mut result: 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: 0 as libc::c_int as uint32_t,
};
init
},
};
init
};
return result;
}
#[inline]
unsafe extern "C" fn length_add(mut len1: Length, mut len2: Length) -> Length {
let mut result: Length = Length {
bytes: 0,
extent: TSPoint { row: 0, column: 0 },
};
result.bytes = (len1.bytes).wrapping_add(len2.bytes);
result.extent = point_add(len1.extent, len2.extent);
return result;
}
#[inline]
unsafe extern "C" fn ts_subtree_padding(mut self_0: Subtree) -> Length {
if (self_0.data).is_inline() {
let mut result: Length = {
let mut init = Length {
bytes: self_0.data.padding_bytes as uint32_t,
extent: {
let mut init = TSPoint {
row: (self_0.data).padding_rows() as uint32_t,
column: self_0.data.padding_columns as uint32_t,
};
init
},
};
init
};
return result;
} else {
return (*self_0.ptr).padding;
};
}
#[inline]
unsafe extern "C" fn ts_subtree_total_bytes(mut self_0: Subtree) -> uint32_t {
return (ts_subtree_total_size(self_0)).bytes;
}
#[inline]
unsafe extern "C" fn ts_subtree_total_size(mut self_0: Subtree) -> Length {
return length_add(ts_subtree_padding(self_0), ts_subtree_size(self_0));
}
#[inline]
unsafe extern "C" fn ts_subtree_visible_descendant_count(mut self_0: Subtree) -> uint32_t {
return if (self_0.data).is_inline() as libc::c_int != 0
|| (*self_0.ptr).child_count == 0 as libc::c_int as libc::c_uint
{
0 as libc::c_int as libc::c_uint
} else {
(*self_0.ptr)
.c2rust_unnamed
.c2rust_unnamed
.visible_descendant_count
};
}
#[inline]
unsafe extern "C" fn point_lt(mut a: TSPoint, mut b: TSPoint) -> bool {
return a.row < b.row || a.row == b.row && a.column < b.column;
}
#[inline]
unsafe extern "C" fn point_lte(mut a: TSPoint, mut b: TSPoint) -> bool {
return a.row < b.row || a.row == b.row && a.column <= b.column;
}
#[inline]
unsafe extern "C" fn point_eq(mut a: TSPoint, mut b: TSPoint) -> bool {
return a.row == b.row && a.column == b.column;
}
#[inline]
unsafe extern "C" fn point_sub(mut a: TSPoint, mut b: TSPoint) -> TSPoint {
if a.row > b.row {
return point__new((a.row).wrapping_sub(b.row), a.column);
} else {
return point__new(
0 as libc::c_int as libc::c_uint,
(a.column).wrapping_sub(b.column),
);
};
}
#[inline]
unsafe extern "C" fn ts_language_alias_sequence(
mut self_0: *const TSLanguage,
mut production_id: uint32_t,
) -> *const TSSymbol {
return if production_id != 0 {
&*((*self_0).alias_sequences).offset(
production_id.wrapping_mul((*self_0).max_alias_sequence_length as libc::c_uint)
as isize,
) as *const TSSymbol
} else {
0 as *const TSSymbol
};
}
#[inline]
unsafe extern "C" fn ts_language_field_map(
mut self_0: *const TSLanguage,
mut production_id: uint32_t,
mut start: *mut *const TSFieldMapEntry,
mut end: *mut *const TSFieldMapEntry,
) {
if (*self_0).field_count == 0 as libc::c_int as libc::c_uint {
*start = 0 as *const TSFieldMapEntry;
*end = 0 as *const TSFieldMapEntry;
return;
}
let mut slice: TSFieldMapSlice = *((*self_0).field_map_slices).offset(production_id as isize);
*start = &*((*self_0).field_map_entries).offset(slice.index as isize) as *const TSFieldMapEntry;
*end = (&*((*self_0).field_map_entries).offset(slice.index as isize) as *const TSFieldMapEntry)
.offset(slice.length as libc::c_int as isize);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_new(
mut tree: *const TSTree,
mut subtree: *const Subtree,
mut position: Length,
mut alias: TSSymbol,
) -> TSNode {
return {
let mut init = TSNode {
context: [
position.bytes,
position.extent.row,
position.extent.column,
alias as uint32_t,
],
id: subtree as *const libc::c_void,
tree: tree,
};
init
};
}
#[inline]
unsafe extern "C" fn ts_node__null() -> TSNode {
return ts_node_new(
0 as *const TSTree,
0 as *const Subtree,
length_zero(),
0 as libc::c_int as TSSymbol,
);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_start_byte(mut self_0: TSNode) -> uint32_t {
return self_0.context[0 as libc::c_int as usize];
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_start_point(mut self_0: TSNode) -> TSPoint {
return {
let mut init = TSPoint {
row: self_0.context[1 as libc::c_int as usize],
column: self_0.context[2 as libc::c_int as usize],
};
init
};
}
#[inline]
unsafe extern "C" fn ts_node__alias(mut self_0: *const TSNode) -> uint32_t {
return (*self_0).context[3 as libc::c_int as usize];
}
#[inline]
unsafe extern "C" fn ts_node__subtree(mut self_0: TSNode) -> Subtree {
return *(self_0.id as *const Subtree);
}
#[inline]
unsafe extern "C" fn ts_node_iterate_children(mut node: *const TSNode) -> NodeChildIterator {
let mut subtree: Subtree = ts_node__subtree(*node);
if ts_subtree_child_count(subtree) == 0 as libc::c_int as libc::c_uint {
return {
let mut init = NodeChildIterator {
parent: Subtree {
ptr: 0 as *const SubtreeHeapData,
},
tree: (*node).tree,
position: length_zero(),
child_index: 0 as libc::c_int as uint32_t,
structural_child_index: 0 as libc::c_int as uint32_t,
alias_sequence: 0 as *const TSSymbol,
};
init
};
}
let mut alias_sequence: *const TSSymbol = ts_language_alias_sequence(
(*(*node).tree).language,
(*subtree.ptr).c2rust_unnamed.c2rust_unnamed.production_id as uint32_t,
);
return {
let mut init = NodeChildIterator {
parent: subtree,
tree: (*node).tree,
position: {
let mut init = Length {
bytes: ts_node_start_byte(*node),
extent: ts_node_start_point(*node),
};
init
},
child_index: 0 as libc::c_int as uint32_t,
structural_child_index: 0 as libc::c_int as uint32_t,
alias_sequence: alias_sequence,
};
init
};
}
#[inline]
unsafe extern "C" fn ts_node_child_iterator_done(mut self_0: *mut NodeChildIterator) -> bool {
return (*self_0).child_index == (*(*self_0).parent.ptr).child_count;
}
#[inline]
unsafe extern "C" fn ts_node_child_iterator_next(
mut self_0: *mut NodeChildIterator,
mut result: *mut TSNode,
) -> bool {
if ((*self_0).parent.ptr).is_null() || ts_node_child_iterator_done(self_0) as libc::c_int != 0 {
return 0 as libc::c_int != 0;
}
let mut child: *const Subtree = &mut *if ((*self_0).parent.data).is_inline() as libc::c_int != 0
{
0 as *mut Subtree
} else {
((*self_0).parent.ptr as *mut Subtree)
.offset(-((*(*self_0).parent.ptr).child_count as isize))
}
.offset((*self_0).child_index as isize) as *mut Subtree;
let mut alias_symbol: TSSymbol = 0 as libc::c_int as TSSymbol;
if !ts_subtree_extra(*child) {
if !((*self_0).alias_sequence).is_null() {
alias_symbol =
*((*self_0).alias_sequence).offset((*self_0).structural_child_index as isize);
}
(*self_0).structural_child_index = ((*self_0).structural_child_index).wrapping_add(1);
}
if (*self_0).child_index > 0 as libc::c_int as libc::c_uint {
(*self_0).position = length_add((*self_0).position, ts_subtree_padding(*child));
}
*result = ts_node_new((*self_0).tree, child, (*self_0).position, alias_symbol);
(*self_0).position = length_add((*self_0).position, ts_subtree_size(*child));
(*self_0).child_index = ((*self_0).child_index).wrapping_add(1);
return 1 as libc::c_int != 0;
}
#[inline]
unsafe extern "C" fn ts_node_child_iterator_next_sibling_is_empty_adjacent(
mut self_0: *mut NodeChildIterator,
mut previous: TSNode,
) -> bool {
if ((*self_0).parent.ptr).is_null() || ts_node_child_iterator_done(self_0) as libc::c_int != 0 {
return 0 as libc::c_int != 0;
}
if (*self_0).child_index == 0 as libc::c_int as libc::c_uint {
return 0 as libc::c_int != 0;
}
let mut child: *const Subtree = &mut *if ((*self_0).parent.data).is_inline() as libc::c_int != 0
{
0 as *mut Subtree
} else {
((*self_0).parent.ptr as *mut Subtree)
.offset(-((*(*self_0).parent.ptr).child_count as isize))
}
.offset((*self_0).child_index as isize) as *mut Subtree;
let mut alias: TSSymbol = 0 as libc::c_int as TSSymbol;
if !ts_subtree_extra(*child) {
if !((*self_0).alias_sequence).is_null() {
alias = *((*self_0).alias_sequence).offset((*self_0).structural_child_index as isize);
}
}
let mut next: TSNode = ts_node_new((*self_0).tree, child, (*self_0).position, alias);
return ts_node_end_byte(previous) == ts_node_end_byte(next)
&& ts_node__is_relevant(next, 1 as libc::c_int != 0) as libc::c_int != 0;
}
#[inline]
unsafe extern "C" fn ts_node__is_relevant(mut self_0: TSNode, mut include_anonymous: bool) -> bool {
let mut tree: Subtree = ts_node__subtree(self_0);
if include_anonymous {
return ts_subtree_visible(tree) as libc::c_int != 0 || ts_node__alias(&mut self_0) != 0;
} else {
let mut alias: TSSymbol = ts_node__alias(&mut self_0) as TSSymbol;
if alias != 0 {
return (ts_language_symbol_metadata((*self_0.tree).language, alias)).named;
} else {
return ts_subtree_visible(tree) as libc::c_int != 0
&& ts_subtree_named(tree) as libc::c_int != 0;
}
};
}
#[inline]
unsafe extern "C" fn ts_node__relevant_child_count(
mut self_0: TSNode,
mut include_anonymous: bool,
) -> uint32_t {
let mut tree: Subtree = ts_node__subtree(self_0);
if ts_subtree_child_count(tree) > 0 as libc::c_int as libc::c_uint {
if include_anonymous {
return (*tree.ptr)
.c2rust_unnamed
.c2rust_unnamed
.visible_child_count;
} else {
return (*tree.ptr).c2rust_unnamed.c2rust_unnamed.named_child_count;
}
} else {
return 0 as libc::c_int as uint32_t;
};
}
#[inline]
unsafe extern "C" fn ts_node__child(
mut self_0: TSNode,
mut child_index: uint32_t,
mut include_anonymous: bool,
) -> TSNode {
let mut result: TSNode = self_0;
let mut did_descend: bool = 1 as libc::c_int != 0;
while did_descend {
did_descend = 0 as libc::c_int != 0;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut index: uint32_t = 0 as libc::c_int as uint32_t;
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut result);
while ts_node_child_iterator_next(&mut iterator, &mut child) {
if ts_node__is_relevant(child, include_anonymous) {
if index == child_index {
return child;
}
index = index.wrapping_add(1);
} else {
let mut grandchild_index: uint32_t = child_index.wrapping_sub(index);
let mut grandchild_count: uint32_t =
ts_node__relevant_child_count(child, include_anonymous);
if grandchild_index < grandchild_count {
did_descend = 1 as libc::c_int != 0;
result = child;
child_index = grandchild_index;
break;
} else {
index = (index as libc::c_uint).wrapping_add(grandchild_count) as uint32_t
as uint32_t;
}
}
}
}
return ts_node__null();
}
unsafe extern "C" fn ts_subtree_has_trailing_empty_descendant(
mut self_0: Subtree,
mut other: Subtree,
) -> bool {
let mut i: libc::c_uint =
(ts_subtree_child_count(self_0)).wrapping_sub(1 as libc::c_int as libc::c_uint);
while i.wrapping_add(1 as libc::c_int as libc::c_uint) > 0 as libc::c_int as libc::c_uint {
let mut child: Subtree = *if (self_0.data).is_inline() as libc::c_int != 0 {
0 as *mut Subtree
} else {
(self_0.ptr as *mut Subtree).offset(-((*self_0.ptr).child_count as isize))
}
.offset(i as isize);
if ts_subtree_total_bytes(child) > 0 as libc::c_int as libc::c_uint {
break;
}
if child.ptr == other.ptr
|| ts_subtree_has_trailing_empty_descendant(child, other) as libc::c_int != 0
{
return 1 as libc::c_int != 0;
}
i = i.wrapping_sub(1);
}
return 0 as libc::c_int != 0;
}
#[inline]
unsafe extern "C" fn ts_node__prev_sibling(
mut self_0: TSNode,
mut include_anonymous: bool,
) -> TSNode {
let mut self_subtree: Subtree = ts_node__subtree(self_0);
let mut self_is_empty: bool =
ts_subtree_total_bytes(self_subtree) == 0 as libc::c_int as libc::c_uint;
let mut target_end_byte: uint32_t = ts_node_end_byte(self_0);
let mut node: TSNode = ts_node_parent(self_0);
let mut earlier_node: TSNode = ts_node__null();
let mut earlier_node_is_relevant: bool = 0 as libc::c_int != 0;
while !ts_node_is_null(node) {
let mut earlier_child: TSNode = ts_node__null();
let mut earlier_child_is_relevant: bool = 0 as libc::c_int != 0;
let mut found_child_containing_target: bool = 0 as libc::c_int != 0;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut node);
while ts_node_child_iterator_next(&mut iterator, &mut child) {
if child.id == self_0.id {
break;
}
if iterator.position.bytes > target_end_byte {
found_child_containing_target = 1 as libc::c_int != 0;
break;
} else if iterator.position.bytes == target_end_byte
&& (!self_is_empty
|| ts_subtree_has_trailing_empty_descendant(
ts_node__subtree(child),
self_subtree,
) as libc::c_int
!= 0)
{
found_child_containing_target = 1 as libc::c_int != 0;
break;
} else if ts_node__is_relevant(child, include_anonymous) {
earlier_child = child;
earlier_child_is_relevant = 1 as libc::c_int != 0;
} else if ts_node__relevant_child_count(child, include_anonymous)
> 0 as libc::c_int as libc::c_uint
{
earlier_child = child;
earlier_child_is_relevant = 0 as libc::c_int != 0;
}
}
if found_child_containing_target {
if !ts_node_is_null(earlier_child) {
earlier_node = earlier_child;
earlier_node_is_relevant = earlier_child_is_relevant;
}
node = child;
} else if earlier_child_is_relevant {
return earlier_child;
} else {
if !ts_node_is_null(earlier_child) {
node = earlier_child;
} else if earlier_node_is_relevant {
return earlier_node;
} else {
node = earlier_node;
earlier_node = ts_node__null();
earlier_node_is_relevant = 0 as libc::c_int != 0;
}
}
}
return ts_node__null();
}
#[inline]
unsafe extern "C" fn ts_node__next_sibling(
mut self_0: TSNode,
mut include_anonymous: bool,
) -> TSNode {
let mut target_end_byte: uint32_t = ts_node_end_byte(self_0);
let mut node: TSNode = ts_node_parent(self_0);
let mut later_node: TSNode = ts_node__null();
let mut later_node_is_relevant: bool = 0 as libc::c_int != 0;
while !ts_node_is_null(node) {
let mut later_child: TSNode = ts_node__null();
let mut later_child_is_relevant: bool = 0 as libc::c_int != 0;
let mut child_containing_target: TSNode = ts_node__null();
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut node);
while ts_node_child_iterator_next(&mut iterator, &mut child) {
if iterator.position.bytes < target_end_byte {
continue;
}
if ts_node_start_byte(child) <= ts_node_start_byte(self_0) {
if (ts_node__subtree(child)).ptr != (ts_node__subtree(self_0)).ptr {
child_containing_target = child;
}
} else if ts_node__is_relevant(child, include_anonymous) {
later_child = child;
later_child_is_relevant = 1 as libc::c_int != 0;
break;
} else {
if !(ts_node__relevant_child_count(child, include_anonymous)
> 0 as libc::c_int as libc::c_uint)
{
continue;
}
later_child = child;
later_child_is_relevant = 0 as libc::c_int != 0;
break;
}
}
if !ts_node_is_null(child_containing_target) {
if !ts_node_is_null(later_child) {
later_node = later_child;
later_node_is_relevant = later_child_is_relevant;
}
node = child_containing_target;
} else if later_child_is_relevant {
return later_child;
} else {
if !ts_node_is_null(later_child) {
node = later_child;
} else if later_node_is_relevant {
return later_node;
} else {
node = later_node;
}
}
}
return ts_node__null();
}
#[inline]
unsafe extern "C" fn ts_node__first_child_for_byte(
mut self_0: TSNode,
mut goal: uint32_t,
mut include_anonymous: bool,
) -> TSNode {
let mut node: TSNode = self_0;
let mut did_descend: bool = 1 as libc::c_int != 0;
let mut last_iterator: NodeChildIterator = NodeChildIterator {
parent: Subtree {
data: SubtreeInlineData {
is_inline_visible_named_extra_has_changes_is_missing_is_keyword: [0; 1],
symbol: 0,
parse_state: 0,
padding_columns: 0,
padding_rows_lookahead_bytes: [0; 1],
padding_bytes: 0,
size_bytes: 0,
},
},
tree: 0 as *const TSTree,
position: Length {
bytes: 0,
extent: TSPoint { row: 0, column: 0 },
},
child_index: 0,
structural_child_index: 0,
alias_sequence: 0 as *const TSSymbol,
};
let mut has_last_iterator: bool = 0 as libc::c_int != 0;
while did_descend {
did_descend = 0 as libc::c_int != 0;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut node);
loop {
while ts_node_child_iterator_next(&mut iterator, &mut child) {
if !(ts_node_end_byte(child) > goal) {
continue;
}
if ts_node__is_relevant(child, include_anonymous) {
return child;
} else {
if !(ts_node_child_count(child) > 0 as libc::c_int as libc::c_uint) {
continue;
}
if iterator.child_index < ts_subtree_child_count(ts_node__subtree(child)) {
last_iterator = iterator;
has_last_iterator = 1 as libc::c_int != 0;
}
did_descend = 1 as libc::c_int != 0;
node = child;
break;
}
}
if !(!did_descend && has_last_iterator as libc::c_int != 0) {
break;
}
iterator = last_iterator;
has_last_iterator = 0 as libc::c_int != 0;
}
}
return ts_node__null();
}
#[inline]
unsafe extern "C" fn ts_node__descendant_for_byte_range(
mut self_0: TSNode,
mut range_start: uint32_t,
mut range_end: uint32_t,
mut include_anonymous: bool,
) -> TSNode {
let mut node: TSNode = self_0;
let mut last_visible_node: TSNode = self_0;
let mut did_descend: bool = 1 as libc::c_int != 0;
while did_descend {
did_descend = 0 as libc::c_int != 0;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut node);
while ts_node_child_iterator_next(&mut iterator, &mut child) {
let mut node_end: uint32_t = iterator.position.bytes;
if node_end < range_end {
continue;
}
let mut is_empty: bool = ts_node_start_byte(child) == node_end;
if if is_empty as libc::c_int != 0 {
(node_end < range_start) as libc::c_int
} else {
(node_end <= range_start) as libc::c_int
} != 0
{
continue;
}
if range_start < ts_node_start_byte(child) {
break;
}
node = child;
if ts_node__is_relevant(node, include_anonymous) {
last_visible_node = node;
}
did_descend = 1 as libc::c_int != 0;
break;
}
}
return last_visible_node;
}
#[inline]
unsafe extern "C" fn ts_node__descendant_for_point_range(
mut self_0: TSNode,
mut range_start: TSPoint,
mut range_end: TSPoint,
mut include_anonymous: bool,
) -> TSNode {
let mut node: TSNode = self_0;
let mut last_visible_node: TSNode = self_0;
let mut did_descend: bool = 1 as libc::c_int != 0;
while did_descend {
did_descend = 0 as libc::c_int != 0;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut node);
while ts_node_child_iterator_next(&mut iterator, &mut child) {
let mut node_end: TSPoint = iterator.position.extent;
if point_lt(node_end, range_end) {
continue;
}
let mut is_empty: bool = point_eq(ts_node_start_point(child), node_end);
if if is_empty as libc::c_int != 0 {
point_lt(node_end, range_start) as libc::c_int
} else {
point_lte(node_end, range_start) as libc::c_int
} != 0
{
continue;
}
if point_lt(range_start, ts_node_start_point(child)) {
break;
}
node = child;
if ts_node__is_relevant(node, include_anonymous) {
last_visible_node = node;
}
did_descend = 1 as libc::c_int != 0;
break;
}
}
return last_visible_node;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_end_byte(mut self_0: TSNode) -> uint32_t {
return (ts_node_start_byte(self_0))
.wrapping_add((ts_subtree_size(ts_node__subtree(self_0))).bytes);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_end_point(mut self_0: TSNode) -> TSPoint {
return point_add(
ts_node_start_point(self_0),
(ts_subtree_size(ts_node__subtree(self_0))).extent,
);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_symbol(mut self_0: TSNode) -> TSSymbol {
let mut symbol: TSSymbol = ts_node__alias(&mut self_0) as TSSymbol;
if symbol == 0 {
symbol = ts_subtree_symbol(ts_node__subtree(self_0));
}
return ts_language_public_symbol((*self_0.tree).language, symbol);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_type(mut self_0: TSNode) -> *const libc::c_char {
let mut symbol: TSSymbol = ts_node__alias(&mut self_0) as TSSymbol;
if symbol == 0 {
symbol = ts_subtree_symbol(ts_node__subtree(self_0));
}
return ts_language_symbol_name((*self_0.tree).language, symbol);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_language(mut self_0: TSNode) -> *const TSLanguage {
return (*self_0.tree).language;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_grammar_symbol(mut self_0: TSNode) -> TSSymbol {
return ts_subtree_symbol(ts_node__subtree(self_0));
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_grammar_type(mut self_0: TSNode) -> *const libc::c_char {
let mut symbol: TSSymbol = ts_subtree_symbol(ts_node__subtree(self_0));
return ts_language_symbol_name((*self_0.tree).language, symbol);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_string(mut self_0: TSNode) -> *mut libc::c_char {
let mut alias_symbol: TSSymbol = ts_node__alias(&mut self_0) as TSSymbol;
return ts_subtree_string(
ts_node__subtree(self_0),
alias_symbol,
(ts_language_symbol_metadata((*self_0.tree).language, alias_symbol)).visible,
(*self_0.tree).language,
0 as libc::c_int != 0,
);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_eq(mut self_0: TSNode, mut other: TSNode) -> bool {
return self_0.tree == other.tree && self_0.id == other.id;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_is_null(mut self_0: TSNode) -> bool {
return (self_0.id).is_null();
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_is_extra(mut self_0: TSNode) -> bool {
return ts_subtree_extra(ts_node__subtree(self_0));
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_is_named(mut self_0: TSNode) -> bool {
let mut alias: TSSymbol = ts_node__alias(&mut self_0) as TSSymbol;
return if alias as libc::c_int != 0 {
(ts_language_symbol_metadata((*self_0.tree).language, alias)).named as libc::c_int
} else {
ts_subtree_named(ts_node__subtree(self_0)) as libc::c_int
} != 0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_is_missing(mut self_0: TSNode) -> bool {
return ts_subtree_missing(ts_node__subtree(self_0));
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_has_changes(mut self_0: TSNode) -> bool {
return ts_subtree_has_changes(ts_node__subtree(self_0));
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_has_error(mut self_0: TSNode) -> bool {
return ts_subtree_error_cost(ts_node__subtree(self_0)) > 0 as libc::c_int as libc::c_uint;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_is_error(mut self_0: TSNode) -> bool {
let mut symbol: TSSymbol = ts_node_symbol(self_0);
return symbol as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_descendant_count(mut self_0: TSNode) -> uint32_t {
return (ts_subtree_visible_descendant_count(ts_node__subtree(self_0)))
.wrapping_add(1 as libc::c_int as libc::c_uint);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_parse_state(mut self_0: TSNode) -> TSStateId {
return ts_subtree_parse_state(ts_node__subtree(self_0));
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_next_parse_state(mut self_0: TSNode) -> TSStateId {
let mut language: *const TSLanguage = (*self_0.tree).language;
let mut state: uint16_t = ts_node_parse_state(self_0);
if state as libc::c_int == 32767 as libc::c_int * 2 as libc::c_int + 1 as libc::c_int {
return (32767 as libc::c_int * 2 as libc::c_int + 1 as libc::c_int) as TSStateId;
}
let mut symbol: uint16_t = ts_node_grammar_symbol(self_0);
return ts_language_next_state(language, state, symbol);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_parent(mut self_0: TSNode) -> TSNode {
let mut node: TSNode = ts_tree_root_node(self_0.tree);
if node.id == self_0.id {
return ts_node__null();
}
loop {
let mut next_node: TSNode = ts_node_child_containing_descendant(node, self_0);
if ts_node_is_null(next_node) {
break;
}
node = next_node;
}
return node;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_child_containing_descendant(
mut self_0: TSNode,
mut descendant: TSNode,
) -> TSNode {
let mut start_byte: uint32_t = ts_node_start_byte(descendant);
let mut end_byte: uint32_t = ts_node_end_byte(descendant);
loop {
let mut iter: NodeChildIterator = ts_node_iterate_children(&mut self_0);
loop {
if !ts_node_child_iterator_next(&mut iter, &mut self_0)
|| ts_node_start_byte(self_0) > start_byte
|| self_0.id == descendant.id
{
return ts_node__null();
}
let mut old: TSNode = self_0;
while ts_node_child_iterator_next_sibling_is_empty_adjacent(&mut iter, self_0) {
let mut current_node: TSNode =
ts_node_child_containing_descendant(self_0, descendant);
if !ts_node_is_null(current_node) {
return current_node;
}
ts_node_child_iterator_next(&mut iter, &mut self_0);
if self_0.id == descendant.id {
return ts_node__null();
}
}
self_0 = old;
if !(iter.position.bytes < end_byte
|| ts_node_child_count(self_0) == 0 as libc::c_int as libc::c_uint)
{
break;
}
}
if ts_node__is_relevant(self_0, 1 as libc::c_int != 0) {
break;
}
}
return self_0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_child_with_descendant(
mut self_0: TSNode,
mut descendant: TSNode,
) -> TSNode {
let mut start_byte: uint32_t = ts_node_start_byte(descendant);
let mut end_byte: uint32_t = ts_node_end_byte(descendant);
loop {
let mut iter: NodeChildIterator = ts_node_iterate_children(&mut self_0);
loop {
if !ts_node_child_iterator_next(&mut iter, &mut self_0)
|| ts_node_start_byte(self_0) > start_byte
{
return ts_node__null();
}
if self_0.id == descendant.id {
return self_0;
}
let mut old: TSNode = self_0;
while ts_node_child_iterator_next_sibling_is_empty_adjacent(&mut iter, self_0) {
let mut current_node: TSNode = ts_node_child_with_descendant(self_0, descendant);
if !ts_node_is_null(current_node) {
return current_node;
}
ts_node_child_iterator_next(&mut iter, &mut self_0);
if self_0.id == descendant.id {
return self_0;
}
}
self_0 = old;
if !(iter.position.bytes < end_byte
|| ts_node_child_count(self_0) == 0 as libc::c_int as libc::c_uint)
{
break;
}
}
if ts_node__is_relevant(self_0, 1 as libc::c_int != 0) {
break;
}
}
return self_0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_child(mut self_0: TSNode, mut child_index: uint32_t) -> TSNode {
return ts_node__child(self_0, child_index, 1 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_named_child(
mut self_0: TSNode,
mut child_index: uint32_t,
) -> TSNode {
return ts_node__child(self_0, child_index, 0 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_child_by_field_id(
mut self_0: TSNode,
mut field_id: TSFieldId,
) -> TSNode {
let mut field_map: *const TSFieldMapEntry = 0 as *const TSFieldMapEntry;
let mut field_map_end: *const TSFieldMapEntry = 0 as *const TSFieldMapEntry;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut iterator: NodeChildIterator = NodeChildIterator {
parent: Subtree {
data: SubtreeInlineData {
is_inline_visible_named_extra_has_changes_is_missing_is_keyword: [0; 1],
symbol: 0,
parse_state: 0,
padding_columns: 0,
padding_rows_lookahead_bytes: [0; 1],
padding_bytes: 0,
size_bytes: 0,
},
},
tree: 0 as *const TSTree,
position: Length {
bytes: 0,
extent: TSPoint { row: 0, column: 0 },
},
child_index: 0,
structural_child_index: 0,
alias_sequence: 0 as *const TSSymbol,
};
'_recur: loop {
if field_id == 0 || ts_node_child_count(self_0) == 0 as libc::c_int as libc::c_uint {
return ts_node__null();
}
field_map = 0 as *const TSFieldMapEntry;
field_map_end = 0 as *const TSFieldMapEntry;
ts_language_field_map(
(*self_0.tree).language,
(*(ts_node__subtree(self_0)).ptr)
.c2rust_unnamed
.c2rust_unnamed
.production_id as uint32_t,
&mut field_map,
&mut field_map_end,
);
if field_map == field_map_end {
return ts_node__null();
}
while ((*field_map).field_id as libc::c_int) < field_id as libc::c_int {
field_map = field_map.offset(1);
if field_map == field_map_end {
return ts_node__null();
}
}
while (*field_map_end.offset(-(1 as libc::c_int) as isize)).field_id as libc::c_int
> field_id as libc::c_int
{
field_map_end = field_map_end.offset(-1);
if field_map == field_map_end {
return ts_node__null();
}
}
child = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
iterator = ts_node_iterate_children(&mut self_0);
loop {
if !ts_node_child_iterator_next(&mut iterator, &mut child) {
break '_recur;
}
if ts_subtree_extra(ts_node__subtree(child)) {
continue;
}
let mut index: uint32_t =
(iterator.structural_child_index).wrapping_sub(1 as libc::c_int as libc::c_uint);
if index < (*field_map).child_index as libc::c_uint {
continue;
}
if (*field_map).inherited {
if field_map.offset(1 as libc::c_int as isize) == field_map_end {
self_0 = child;
break;
} else {
let mut result: TSNode = ts_node_child_by_field_id(child, field_id);
if !(result.id).is_null() {
return result;
}
field_map = field_map.offset(1);
if field_map == field_map_end {
return ts_node__null();
}
}
} else if ts_node__is_relevant(child, 1 as libc::c_int != 0) {
return child;
} else {
if ts_node_child_count(child) > 0 as libc::c_int as libc::c_uint {
return ts_node_child(child, 0 as libc::c_int as uint32_t);
} else {
field_map = field_map.offset(1);
if field_map == field_map_end {
return ts_node__null();
}
}
}
}
}
return ts_node__null();
}
#[inline]
unsafe extern "C" fn ts_node__field_name_from_language(
mut self_0: TSNode,
mut structural_child_index: uint32_t,
) -> *const libc::c_char {
let mut field_map: *const TSFieldMapEntry = 0 as *const TSFieldMapEntry;
let mut field_map_end: *const TSFieldMapEntry = 0 as *const TSFieldMapEntry;
ts_language_field_map(
(*self_0.tree).language,
(*(ts_node__subtree(self_0)).ptr)
.c2rust_unnamed
.c2rust_unnamed
.production_id as uint32_t,
&mut field_map,
&mut field_map_end,
);
while field_map != field_map_end {
if !(*field_map).inherited
&& (*field_map).child_index as libc::c_uint == structural_child_index
{
return *((*(*self_0.tree).language).field_names)
.offset((*field_map).field_id as isize);
}
field_map = field_map.offset(1);
}
return 0 as *const libc::c_char;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_field_name_for_child(
mut self_0: TSNode,
mut child_index: uint32_t,
) -> *const libc::c_char {
let mut result: TSNode = self_0;
let mut did_descend: bool = 1 as libc::c_int != 0;
let mut inherited_field_name: *const libc::c_char = 0 as *const libc::c_char;
while did_descend {
did_descend = 0 as libc::c_int != 0;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut index: uint32_t = 0 as libc::c_int as uint32_t;
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut result);
while ts_node_child_iterator_next(&mut iterator, &mut child) {
if ts_node__is_relevant(child, 1 as libc::c_int != 0) {
if index == child_index {
if ts_node_is_extra(child) {
return 0 as *const libc::c_char;
}
let mut field_name: *const libc::c_char = ts_node__field_name_from_language(
result,
(iterator.structural_child_index)
.wrapping_sub(1 as libc::c_int as libc::c_uint),
);
if !field_name.is_null() {
return field_name;
}
return inherited_field_name;
}
index = index.wrapping_add(1);
} else {
let mut grandchild_index: uint32_t = child_index.wrapping_sub(index);
let mut grandchild_count: uint32_t =
ts_node__relevant_child_count(child, 1 as libc::c_int != 0);
if grandchild_index < grandchild_count {
let mut field_name_0: *const libc::c_char = ts_node__field_name_from_language(
result,
(iterator.structural_child_index)
.wrapping_sub(1 as libc::c_int as libc::c_uint),
);
if !field_name_0.is_null() {
inherited_field_name = field_name_0;
}
did_descend = 1 as libc::c_int != 0;
result = child;
child_index = grandchild_index;
break;
} else {
index = (index as libc::c_uint).wrapping_add(grandchild_count) as uint32_t
as uint32_t;
}
}
}
}
return 0 as *const libc::c_char;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_field_name_for_named_child(
mut self_0: TSNode,
mut named_child_index: uint32_t,
) -> *const libc::c_char {
let mut result: TSNode = self_0;
let mut did_descend: bool = 1 as libc::c_int != 0;
let mut inherited_field_name: *const libc::c_char = 0 as *const libc::c_char;
while did_descend {
did_descend = 0 as libc::c_int != 0;
let mut child: TSNode = TSNode {
context: [0; 4],
id: 0 as *const libc::c_void,
tree: 0 as *const TSTree,
};
let mut index: uint32_t = 0 as libc::c_int as uint32_t;
let mut iterator: NodeChildIterator = ts_node_iterate_children(&mut result);
while ts_node_child_iterator_next(&mut iterator, &mut child) {
if ts_node__is_relevant(child, 0 as libc::c_int != 0) {
if index == named_child_index {
if ts_node_is_extra(child) {
return 0 as *const libc::c_char;
}
let mut field_name: *const libc::c_char = ts_node__field_name_from_language(
result,
(iterator.structural_child_index)
.wrapping_sub(1 as libc::c_int as libc::c_uint),
);
if !field_name.is_null() {
return field_name;
}
return inherited_field_name;
}
index = index.wrapping_add(1);
} else {
let mut named_grandchild_index: uint32_t = named_child_index.wrapping_sub(index);
let mut grandchild_count: uint32_t =
ts_node__relevant_child_count(child, 0 as libc::c_int != 0);
if named_grandchild_index < grandchild_count {
let mut field_name_0: *const libc::c_char = ts_node__field_name_from_language(
result,
(iterator.structural_child_index)
.wrapping_sub(1 as libc::c_int as libc::c_uint),
);
if !field_name_0.is_null() {
inherited_field_name = field_name_0;
}
did_descend = 1 as libc::c_int != 0;
result = child;
named_child_index = named_grandchild_index;
break;
} else {
index = (index as libc::c_uint).wrapping_add(grandchild_count) as uint32_t
as uint32_t;
}
}
}
}
return 0 as *const libc::c_char;
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_child_by_field_name(
mut self_0: TSNode,
mut name: *const libc::c_char,
mut name_length: uint32_t,
) -> TSNode {
let mut field_id: TSFieldId =
ts_language_field_id_for_name((*self_0.tree).language, name, name_length);
return ts_node_child_by_field_id(self_0, field_id);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_child_count(mut self_0: TSNode) -> uint32_t {
let mut tree: Subtree = ts_node__subtree(self_0);
if ts_subtree_child_count(tree) > 0 as libc::c_int as libc::c_uint {
return (*tree.ptr)
.c2rust_unnamed
.c2rust_unnamed
.visible_child_count;
} else {
return 0 as libc::c_int as uint32_t;
};
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_named_child_count(mut self_0: TSNode) -> uint32_t {
let mut tree: Subtree = ts_node__subtree(self_0);
if ts_subtree_child_count(tree) > 0 as libc::c_int as libc::c_uint {
return (*tree.ptr).c2rust_unnamed.c2rust_unnamed.named_child_count;
} else {
return 0 as libc::c_int as uint32_t;
};
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_next_sibling(mut self_0: TSNode) -> TSNode {
return ts_node__next_sibling(self_0, 1 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_next_named_sibling(mut self_0: TSNode) -> TSNode {
return ts_node__next_sibling(self_0, 0 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_prev_sibling(mut self_0: TSNode) -> TSNode {
return ts_node__prev_sibling(self_0, 1 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_prev_named_sibling(mut self_0: TSNode) -> TSNode {
return ts_node__prev_sibling(self_0, 0 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_first_child_for_byte(
mut self_0: TSNode,
mut byte: uint32_t,
) -> TSNode {
return ts_node__first_child_for_byte(self_0, byte, 1 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_first_named_child_for_byte(
mut self_0: TSNode,
mut byte: uint32_t,
) -> TSNode {
return ts_node__first_child_for_byte(self_0, byte, 0 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_descendant_for_byte_range(
mut self_0: TSNode,
mut start: uint32_t,
mut end: uint32_t,
) -> TSNode {
return ts_node__descendant_for_byte_range(self_0, start, end, 1 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_named_descendant_for_byte_range(
mut self_0: TSNode,
mut start: uint32_t,
mut end: uint32_t,
) -> TSNode {
return ts_node__descendant_for_byte_range(self_0, start, end, 0 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_descendant_for_point_range(
mut self_0: TSNode,
mut start: TSPoint,
mut end: TSPoint,
) -> TSNode {
return ts_node__descendant_for_point_range(self_0, start, end, 1 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_named_descendant_for_point_range(
mut self_0: TSNode,
mut start: TSPoint,
mut end: TSPoint,
) -> TSNode {
return ts_node__descendant_for_point_range(self_0, start, end, 0 as libc::c_int != 0);
}
#[no_mangle]
pub unsafe extern "C" fn ts_node_edit(mut self_0: *mut TSNode, mut edit: *const TSInputEdit) {
let mut start_byte: uint32_t = ts_node_start_byte(*self_0);
let mut start_point: TSPoint = ts_node_start_point(*self_0);
if start_byte >= (*edit).old_end_byte {
start_byte =
((*edit).new_end_byte).wrapping_add(start_byte.wrapping_sub((*edit).old_end_byte));
start_point = point_add(
(*edit).new_end_point,
point_sub(start_point, (*edit).old_end_point),
);
} else if start_byte > (*edit).start_byte {
start_byte = (*edit).new_end_byte;
start_point = (*edit).new_end_point;
}
(*self_0).context[0 as libc::c_int as usize] = start_byte;
(*self_0).context[1 as libc::c_int as usize] = start_point.row;
(*self_0).context[2 as libc::c_int as usize] = start_point.column;
}