1use crate::util::*;
2use crate::*;
3use c2rust_bitfields;
4use std::os;
5pub type __u8 = os::raw::c_uchar;
6pub type __int16_t = os::raw::c_short;
7pub type __u16 = os::raw::c_ushort;
8pub type __int32_t = os::raw::c_int;
9pub type __u32 = os::raw::c_uint;
10pub type __int64_t = isize;
11pub type __u64 = usize;
12pub type __off_t = isize;
13pub type __off64_t = isize;
14pub type __time_t = isize;
15pub type __clockid_t = os::raw::c_int;
16pub type __syscall_slong_t = isize;
17type _IO_FILE = u8;
18pub type _IO_lock_t = ();
19pub type FILE = _IO_FILE;
20pub type int16_t = __int16_t;
21pub type int32_t = __int32_t;
22pub type int64_t = __int64_t;
23pub type TSSymbol = u16;
24pub type TSFieldId = u16;
25pub type TSStateId = u16;
26#[derive(Copy, Clone)]
27#[repr(C)]
28pub struct C2RustUnnamed {
29 pub states: *const bool,
30 pub symbol_map: *const TSSymbol,
31 pub create: Option<unsafe extern "C" fn() -> *mut os::raw::c_void>,
32 pub destroy: Option<unsafe extern "C" fn(*mut os::raw::c_void) -> ()>,
33 pub scan: Option<unsafe extern "C" fn(*mut os::raw::c_void, *mut TSLexer, *const bool) -> bool>,
34 pub serialize:
35 Option<unsafe extern "C" fn(*mut os::raw::c_void, *mut os::raw::c_char) -> os::raw::c_uint>,
36 pub deserialize: Option<
37 unsafe extern "C" fn(*mut os::raw::c_void, *const os::raw::c_char, os::raw::c_uint) -> (),
38 >,
39}
40#[derive(Copy, Clone)]
41#[repr(C)]
42pub struct C2RustUnnamed_0 {
43 pub count: u8,
44 pub reusable: bool,
45}
46#[derive(Copy, Clone)]
47#[repr(C)]
48pub struct C2RustUnnamed_1 {
49 pub type_: u8,
50 pub child_count: u8,
51 pub symbol: TSSymbol,
52 pub dynamic_precedence: int16_t,
53 pub production_id: u16,
54}
55#[derive(Copy, Clone)]
56#[repr(C)]
57pub struct C2RustUnnamed_2 {
58 pub type_: u8,
59 pub state: TSStateId,
60 pub extra: bool,
61 pub repetition: bool,
62}
63#[derive(Copy, Clone)]
64#[repr(C)]
65pub struct TSRange {
66 pub start_point: TSPoint,
67 pub end_point: TSPoint,
68 pub start_byte: u32,
69 pub end_byte: u32,
70}
71#[derive(Copy, Clone)]
72#[repr(C)]
73pub struct TSPoint {
74 pub row: u32,
75 pub column: u32,
76}
77type C2RustUnnamed_3 = crate::util::ScannerStateWithLookahead;
78type C2RustUnnamed_4 = crate::util::LongShortData;
79type C2RustUnnamed_5 = crate::util::ScannerStateLookaheadMeta;
80type C2RustUnnamed_6 = crate::util::ScannerStateLookaheadFirstLeaf;
81#[derive(Copy, Clone)]
82#[repr(C)]
83pub struct Length {
84 pub bytes: u32,
85 pub extent: TSPoint,
86}
87pub type TSDuration = u64;
88#[derive(Copy, Clone)]
89#[repr(C)]
90pub struct ReusableNode {
91 pub stack: C2RustUnnamed_7,
92 pub last_external_token: Subtree,
93}
94type C2RustUnnamed_7 = crate::util::StackElement<*mut StackEntry>;
95#[derive(Copy, Clone)]
96#[repr(C)]
97pub struct StackEntry {
98 pub tree: Subtree,
99 pub child_index: u32,
100 pub byte_offset: u32,
101}
102#[derive(Copy, Clone)]
103#[repr(C)]
104pub struct TokenCache {
105 pub token: Subtree,
106 pub last_external_token: Subtree,
107 pub byte_index: u32,
108}
109#[derive(Copy, Clone)]
110#[repr(C)]
111pub struct ReduceActionSet {
112 pub contents: *mut ReduceAction,
113 pub size: u32,
114 pub capacity: u32,
115}
116#[derive(Copy, Clone)]
117#[repr(C)]
118pub struct ReduceAction {
119 pub count: u32,
120 pub symbol: TSSymbol,
121 pub dynamic_precedence: os::raw::c_int,
122 pub production_id: os::raw::c_ushort,
123}
124#[derive(Copy, Clone)]
125#[repr(C)]
126pub struct StackNode {
127 pub state: TSStateId,
128 pub position: Length,
129 pub links: [StackLink; 8],
130 pub link_count: os::raw::c_ushort,
131 pub ref_count: u32,
132 pub error_cost: os::raw::c_uint,
133 pub node_count: os::raw::c_uint,
134 pub dynamic_precedence: os::raw::c_int,
135}
136#[derive(Copy, Clone)]
137#[repr(C)]
138pub struct StackLink {
139 pub node: *mut StackNode,
140 pub subtree: Subtree,
141 pub is_pending: bool,
142}
143#[derive(Copy, Clone)]
144#[repr(C)]
145pub struct StackNodeArray {
146 pub contents: *mut *mut StackNode,
147 pub size: u32,
148 pub capacity: u32,
149}
150type C2RustUnnamed_8 = crate::util::StackElement<*mut StackIterator>;
151#[derive(Copy, Clone)]
152#[repr(C)]
153pub struct StackIterator {
154 pub node: *mut StackNode,
155 pub subtrees: SubtreeArray,
156 pub subtree_count: u32,
157 pub is_pending: bool,
158}
159pub type StackVersion = os::raw::c_uint;
160type C2RustUnnamed_9 = crate::util::StackElement<*mut StackHead>;
161#[derive(Copy, Clone)]
162#[repr(C)]
163pub struct StackHead {
164 pub node: *mut StackNode,
165 pub summary: *mut StackSummary,
166 pub node_count_at_last_error: os::raw::c_uint,
167 pub last_external_token: Subtree,
168 pub lookahead_when_paused: Subtree,
169 pub status: StackStatus,
170}
171pub type StackStatus = os::raw::c_uint;
172pub const StackStatusHalted: StackStatus = 2;
173pub const StackStatusPaused: StackStatus = 1;
174pub const StackStatusActive: StackStatus = 0;
175#[derive(Copy, Clone)]
176#[repr(C)]
177pub struct TSLogger {
178 pub payload: *mut os::raw::c_void,
179 pub log:
180 Option<unsafe extern "C" fn(*mut os::raw::c_void, TSLogType, *const os::raw::c_char) -> ()>,
181}
182pub type TSLogType = os::raw::c_uint;
183pub const TSLogTypeLex: TSLogType = 1;
184pub const TSLogTypeParse: TSLogType = 0;
185#[derive(Copy, Clone)]
186#[repr(C)]
187pub struct TSInput {
188 pub payload: *mut os::raw::c_void,
189 pub read: Option<
190 unsafe extern "C" fn(
191 *mut os::raw::c_void,
192 u32,
193 TSPoint,
194 *mut u32,
195 ) -> *const os::raw::c_char,
196 >,
197 pub encoding: TSInputEncoding,
198}
199pub type TSInputEncoding = os::raw::c_uint;
200pub const TSInputEncodingUTF16: TSInputEncoding = 1;
201pub const TSInputEncodingUTF8: TSInputEncoding = 0;
202type C2RustUnnamed_10 = crate::util::StackElement<*mut os::raw::c_char>;
203type C2RustUnnamed_11 = crate::util::StackElement<*mut TSFieldId>;
204type C2RustUnnamed_12 = crate::util::StackElement<*mut StepOffset>;
205#[derive(Copy, Clone)]
206#[repr(C)]
207pub struct StepOffset {
208 pub byte_offset: u32,
209 pub step_index: u16,
210}
211type C2RustUnnamed_13 = crate::util::StackElement<*mut QueryPattern>;
212#[derive(Copy, Clone)]
213#[repr(C)]
214pub struct QueryPattern {
215 pub steps: Slice,
216 pub predicate_steps: Slice,
217 pub start_byte: u32,
218}
219#[derive(Copy, Clone)]
220#[repr(C)]
221pub struct Slice {
222 pub offset: u32,
223 pub length: u32,
224}
225type C2RustUnnamed_14 = crate::util::StackElement<*mut TSQueryPredicateStep>;
226pub type TSQueryPredicateStepType = os::raw::c_uint;
227pub const TSQueryPredicateStepTypeString: TSQueryPredicateStepType = 2;
228pub const TSQueryPredicateStepTypeCapture: TSQueryPredicateStepType = 1;
229pub const TSQueryPredicateStepTypeDone: TSQueryPredicateStepType = 0;
230type C2RustUnnamed_15 = crate::util::StackElement<*mut PatternEntry>;
231#[derive(Copy, Clone)]
232#[repr(C)]
233pub struct PatternEntry {
234 pub step_index: u16,
235 pub pattern_index: u16,
236 pub is_rooted: bool,
237}
238type C2RustUnnamed_16 = crate::util::StackElement<*mut QueryStep>;
239#[derive(Copy, Clone, BitfieldStruct)]
240#[repr(C)]
241pub struct QueryStep {
242 pub symbol: TSSymbol,
243 pub supertype_symbol: TSSymbol,
244 pub field: TSFieldId,
245 pub capture_ids: [u16; 3],
246 pub depth: u16,
247 pub alternative_index: u16,
248 pub negated_field_list_id: u16,
249 #[bitfield(name = "is_named", ty = "bool", bits = "0..=0")]
250 #[bitfield(name = "is_immediate", ty = "bool", bits = "1..=1")]
251 #[bitfield(name = "is_last_child", ty = "bool", bits = "2..=2")]
252 #[bitfield(name = "is_pass_through", ty = "bool", bits = "3..=3")]
253 #[bitfield(name = "is_dead_end", ty = "bool", bits = "4..=4")]
254 #[bitfield(name = "alternative_is_immediate", ty = "bool", bits = "5..=5")]
255 #[bitfield(name = "contains_captures", ty = "bool", bits = "6..=6")]
256 #[bitfield(name = "root_pattern_guaranteed", ty = "bool", bits = "7..=7")]
257 #[bitfield(name = "parent_pattern_guaranteed", ty = "bool", bits = "8..=8")]
258 pub is_named_is_immediate_is_last_child_is_pass_through_is_dead_end_alternative_is_immediate_contains_captures_root_pattern_guaranteed_parent_pattern_guaranteed:
259 [u8; 2],
260}
261#[derive(Copy, Clone)]
262#[repr(C)]
263pub struct SymbolTable {
264 pub characters: C2RustUnnamed_18,
265 pub slices: C2RustUnnamed_17,
266}
267type C2RustUnnamed_17 = crate::util::StackElement<*mut Slice>;
268type C2RustUnnamed_18 = crate::util::StackElement<*mut os::raw::c_char>;
269type C2RustUnnamed_19 = crate::util::StackElement<*mut CaptureQuantifiers>;
270#[derive(Copy, Clone)]
271#[repr(C)]
272pub struct CaptureQuantifiers {
273 pub contents: *mut u8,
274 pub size: u32,
275 pub capacity: u32,
276}
277#[derive(Copy, Clone)]
278#[repr(C)]
279pub struct CaptureListPool {
280 pub list: C2RustUnnamed_20,
281 pub empty_list: CaptureList,
282 pub max_capture_list_count: u32,
283 pub free_capture_list_count: u32,
284}
285#[derive(Copy, Clone)]
286#[repr(C)]
287pub struct CaptureList {
288 pub contents: *mut TSQueryCapture,
289 pub size: u32,
290 pub capacity: u32,
291}
292#[derive(Copy, Clone)]
293#[repr(C)]
294pub struct TSQueryCapture {
295 pub node: TSNode,
296 pub index: u32,
297}
298type C2RustUnnamed_20 = crate::util::StackElement<*mut CaptureList>;
299type C2RustUnnamed_21 = crate::util::StackElement<*mut QueryState>;
300#[derive(Copy, Clone, BitfieldStruct)]
301#[repr(C)]
302pub struct QueryState {
303 pub id: u32,
304 pub capture_list_id: u32,
305 pub start_depth: u16,
306 pub step_index: u16,
307 pub pattern_index: u16,
308 #[bitfield(name = "consumed_capture_count", ty = "u16", bits = "0..=11")]
309 #[bitfield(name = "seeking_immediate_match", ty = "bool", bits = "12..=12")]
310 #[bitfield(name = "has_in_progress_alternatives", ty = "bool", bits = "13..=13")]
311 #[bitfield(name = "dead", ty = "bool", bits = "14..=14")]
312 #[bitfield(name = "needs_parent", ty = "bool", bits = "15..=15")]
313 pub consumed_capture_count_seeking_immediate_match_has_in_progress_alternatives_dead_needs_parent:
314 [u8; 2],
315}
316type C2RustUnnamed_22 = crate::util::StackElement<*mut QueryState>;
317#[derive(Copy, Clone)]
318#[repr(C)]
319pub struct TSTreeCursor {
320 pub tree: *const os::raw::c_void,
321 pub id: *const os::raw::c_void,
322 pub context: [u32; 2],
323}
324pub type TSSymbolType = os::raw::c_uint;
325pub const TSSymbolTypeAuxiliary: TSSymbolType = 2;
326pub const TSSymbolTypeAnonymous: TSSymbolType = 1;
327pub const TSSymbolTypeRegular: TSSymbolType = 0;
328#[derive(Copy, Clone)]
329#[repr(C)]
330pub struct TSInputEdit {
331 pub start_byte: u32,
332 pub old_end_byte: u32,
333 pub new_end_byte: u32,
334 pub start_point: TSPoint,
335 pub old_end_point: TSPoint,
336 pub new_end_point: TSPoint,
337}
338pub type TSQuantifier = os::raw::c_uint;
339pub const TSQuantifierOneOrMore: TSQuantifier = 4;
340pub const TSQuantifierOne: TSQuantifier = 3;
341pub const TSQuantifierZeroOrMore: TSQuantifier = 2;
342pub const TSQuantifierZeroOrOne: TSQuantifier = 1;
343pub const TSQuantifierZero: TSQuantifier = 0;
344pub type TSQueryError = os::raw::c_uint;
345pub const TSQueryErrorLanguage: TSQueryError = 6;
346pub const TSQueryErrorStructure: TSQueryError = 5;
347pub const TSQueryErrorCapture: TSQueryError = 4;
348pub const TSQueryErrorField: TSQueryError = 3;
349pub const TSQueryErrorNodeType: TSQueryError = 2;
350pub const TSQueryErrorSyntax: TSQueryError = 1;
351pub const TSQueryErrorNone: TSQueryError = 0;
352#[derive(Copy, Clone)]
353#[repr(C)]
354pub struct VoidArray {
355 pub contents: *mut os::raw::c_void,
356 pub size: u32,
357 pub capacity: u32,
358}
359pub type UnicodeDecodeFunction = Option<unsafe extern "C" fn(*const u8, u32, *mut int32_t) -> u32>;
360pub type UChar32 = int32_t;
361type C2RustUnnamed_23 = crate::util::StackElement<*mut *mut StackNode>;
362pub type StackAction = os::raw::c_uint;
363pub const StackActionNone: C2RustUnnamed_35 = 0;
364pub const StackActionStop: C2RustUnnamed_35 = 1;
365pub const StackActionPop: C2RustUnnamed_35 = 2;
366pub type StackCallback =
367 Option<unsafe extern "C" fn(*mut os::raw::c_void, *const StackIterator) -> StackAction>;
368pub const TSParseActionTypeShift: C2RustUnnamed_34 = 0;
369pub const ErrorComparisonPreferRight: ErrorComparison = 3;
370pub const ErrorComparisonTakeRight: ErrorComparison = 4;
371pub type ErrorComparison = os::raw::c_uint;
372pub const ErrorComparisonNone: ErrorComparison = 2;
373pub const ErrorComparisonPreferLeft: ErrorComparison = 1;
374pub const ErrorComparisonTakeLeft: ErrorComparison = 0;
375#[derive(Copy, Clone)]
376#[repr(C)]
377pub struct ErrorStatus {
378 pub cost: os::raw::c_uint,
379 pub node_count: os::raw::c_uint,
380 pub dynamic_precedence: os::raw::c_int,
381 pub is_in_error: bool,
382}
383#[derive(Copy, Clone)]
384#[repr(C)]
385pub struct SummarizeStackSession {
386 pub summary: *mut StackSummary,
387 pub max_depth: os::raw::c_uint,
388}
389pub const TSParseActionTypeReduce: C2RustUnnamed_34 = 1;
390pub const TSParseActionTypeRecover: C2RustUnnamed_34 = 3;
391pub const TSParseActionTypeAccept: C2RustUnnamed_34 = 2;
392pub type clockid_t = __clockid_t;
393#[derive(Copy, Clone)]
394#[repr(C)]
395pub struct TSStringInput {
396 pub string: *const os::raw::c_char,
397 pub length: u32,
398}
399type C2RustUnnamed_24 = crate::util::StackElement<*mut StackEntry_0>;
400#[derive(Copy, Clone)]
401#[repr(C)]
402pub struct StackEntry_0 {
403 pub tree: *mut Subtree,
404 pub edit: Edit,
405}
406#[derive(Copy, Clone)]
407#[repr(C)]
408pub struct Edit {
409 pub start: Length,
410 pub old_end: Length,
411 pub new_end: Length,
412}
413type C2RustUnnamed_25 = crate::util::StackElement<*mut TreeCursorEntry>;
414#[derive(Copy, Clone)]
415#[repr(C)]
416pub struct Iterator_0 {
417 pub cursor: TreeCursor,
418 pub language: *const TSLanguage,
419 pub visible_depth: os::raw::c_uint,
420 pub in_padding: bool,
421}
422pub const IteratorDiffers: IteratorComparison = 0;
423pub const IteratorMayDiffer: IteratorComparison = 1;
424pub const IteratorMatches: IteratorComparison = 2;
425pub type IteratorComparison = os::raw::c_uint;
426pub const _ISprint: C2RustUnnamed_36 = 16384;
427#[derive(Copy, Clone)]
428#[repr(C)]
429pub struct NodeChildIterator {
430 pub parent: Subtree,
431 pub tree: *const TSTree,
432 pub position: Length,
433 pub child_index: u32,
434 pub structural_child_index: u32,
435 pub alias_sequence: *const TSSymbol,
436}
437#[derive(Copy, Clone)]
438#[repr(C)]
439pub struct CursorChildIterator {
440 pub parent: Subtree,
441 pub tree: *const TSTree,
442 pub position: Length,
443 pub child_index: u32,
444 pub structural_child_index: u32,
445 pub alias_sequence: *const TSSymbol,
446}
447#[derive(Copy, Clone)]
448#[repr(C)]
449pub struct StatePredecessorMap {
450 pub contents: *mut TSStateId,
451}
452type C2RustUnnamed_26 = crate::util::StackElement<*mut u16>;
453type C2RustUnnamed_27 = crate::util::StackElement<*mut u32>;
454type C2RustUnnamed_28 = crate::util::StackElement<*mut u16>;
455#[derive(Copy, Clone)]
456#[repr(C)]
457pub struct AnalysisStateSet {
458 pub contents: *mut *mut AnalysisState,
459 pub size: u32,
460 pub capacity: u32,
461}
462#[derive(Copy, Clone)]
463#[repr(C)]
464pub struct AnalysisState {
465 pub stack: [AnalysisStateEntry; 8],
466 pub depth: u16,
467 pub step_index: u16,
468}
469#[derive(Copy, Clone, BitfieldStruct)]
470#[repr(C)]
471pub struct AnalysisStateEntry {
472 pub parse_state: TSStateId,
473 pub parent_symbol: TSSymbol,
474 pub child_index: u16,
475 #[bitfield(name = "field_id", ty = "TSFieldId", bits = "0..=14")]
476 #[bitfield(name = "done", ty = "bool", bits = "15..=15")]
477 pub field_id_done: [u8; 2],
478}
479type C2RustUnnamed_29 = crate::util::StackElement<*mut AnalysisSubgraphNode>;
480#[derive(Copy, Clone, BitfieldStruct)]
481#[repr(C)]
482pub struct AnalysisSubgraphNode {
483 pub state: TSStateId,
484 pub production_id: u16,
485 #[bitfield(name = "child_index", ty = "u8", bits = "0..=6")]
486 #[bitfield(name = "done", ty = "bool", bits = "7..=7")]
487 pub child_index_done: [u8; 1],
488 #[bitfield(padding)]
489 pub c2rust_padding: [u8; 1],
490}
491#[derive(Copy, Clone)]
492#[repr(C)]
493pub struct AnalysisStatePool {
494 pub contents: *mut *mut AnalysisState,
495 pub size: u32,
496 pub capacity: u32,
497}
498type C2RustUnnamed_30 = crate::util::StackElement<*mut AnalysisSubgraph>;
499#[derive(Copy, Clone)]
500#[repr(C)]
501pub struct AnalysisSubgraph {
502 pub symbol: TSSymbol,
503 pub start_states: C2RustUnnamed_32,
504 pub nodes: C2RustUnnamed_31,
505}
506type C2RustUnnamed_31 = crate::util::StackElement<*mut AnalysisSubgraphNode>;
507type C2RustUnnamed_32 = crate::util::StackElement<*mut TSStateId>;
508#[derive(Copy, Clone)]
509#[repr(C)]
510pub struct LookaheadIterator {
511 pub language: *const TSLanguage,
512 pub data: *const u16,
513 pub group_end: *const u16,
514 pub state: TSStateId,
515 pub table_value: u16,
516 pub section_index: u16,
517 pub group_count: u16,
518 pub is_small_state: bool,
519 pub actions: *const TSParseAction,
520 pub symbol: TSSymbol,
521 pub next_state: TSStateId,
522 pub action_count: u16,
523}
524#[derive(Copy, Clone)]
525#[repr(C)]
526pub struct Stream {
527 pub input: *const os::raw::c_char,
528 pub start: *const os::raw::c_char,
529 pub end: *const os::raw::c_char,
530 pub next: int32_t,
531 pub next_size: u8,
532}
533pub type wint_t = os::raw::c_uint;
534type C2RustUnnamed_33 = crate::util::StackElement<*mut u32>;
535pub type C2RustUnnamed_34 = os::raw::c_uint;
536pub type C2RustUnnamed_35 = os::raw::c_uint;
537pub type C2RustUnnamed_36 = os::raw::c_uint;
538pub const _ISalnum: C2RustUnnamed_36 = 8;
539pub const _ISpunct: C2RustUnnamed_36 = 4;
540pub const _IScntrl: C2RustUnnamed_36 = 2;
541pub const _ISblank: C2RustUnnamed_36 = 1;
542pub const _ISgraph: C2RustUnnamed_36 = 32768;
543pub const _ISspace: C2RustUnnamed_36 = 8192;
544pub const _ISxdigit: C2RustUnnamed_36 = 4096;
545pub const _ISdigit: C2RustUnnamed_36 = 2048;
546pub const _ISalpha: C2RustUnnamed_36 = 1024;
547pub const _ISlower: C2RustUnnamed_36 = 512;
548pub const _ISupper: C2RustUnnamed_36 = 256;
549static mut LENGTH_MAX: Length = {
550 let mut init = Length {
551 bytes: 4294967295 as os::raw::c_uint,
552 extent: {
553 let mut init = TSPoint {
554 row: 4294967295 as os::raw::c_uint,
555 column: 4294967295 as os::raw::c_uint,
556 };
557 init
558 },
559 };
560 init
561};
562static mut LENGTH_UNDEFINED: Length = {
563 let mut init = Length {
564 bytes: 0 as os::raw::c_int as u32,
565 extent: {
566 let mut init = TSPoint {
567 row: 0 as os::raw::c_int as u32,
568 column: 1 as os::raw::c_int as u32,
569 };
570 init
571 },
572 };
573 init
574};
575static mut BYTE_ORDER_MARK: int32_t = 0xfeff as os::raw::c_int;
576static mut DEFAULT_RANGE: TSRange = {
577 let mut init = TSRange {
578 start_point: {
579 let mut init = TSPoint {
580 row: 0 as os::raw::c_int as u32,
581 column: 0 as os::raw::c_int as u32,
582 };
583 init
584 },
585 end_point: {
586 let mut init = TSPoint {
587 row: 4294967295 as os::raw::c_uint,
588 column: 4294967295 as os::raw::c_uint,
589 };
590 init
591 },
592 start_byte: 0 as os::raw::c_int as u32,
593 end_byte: 4294967295 as os::raw::c_uint,
594 };
595 init
596};
597static mut TS_DECODE_ERROR: int32_t = -(1 as os::raw::c_int);
598static mut MAX_VERSION_COUNT: os::raw::c_uint = 6 as os::raw::c_int as os::raw::c_uint;
599static mut MAX_VERSION_COUNT_OVERFLOW: os::raw::c_uint = 4 as os::raw::c_int as os::raw::c_uint;
600static mut MAX_SUMMARY_DEPTH: os::raw::c_uint = 16 as os::raw::c_int as os::raw::c_uint;
601static mut MAX_COST_DIFFERENCE: os::raw::c_uint =
602 (16 as os::raw::c_int * 100 as os::raw::c_int) as os::raw::c_uint;
603static mut OP_COUNT_PER_TIMEOUT_CHECK: os::raw::c_uint = 100 as os::raw::c_int as os::raw::c_uint;
604static mut NONE: u16 = 65535 as os::raw::c_int as u16;
605static mut PATTERN_DONE_MARKER: u16 = 65535 as os::raw::c_int as u16;
606static mut WILDCARD_SYMBOL: TSSymbol = 0 as os::raw::c_int as TSSymbol;
607static mut PARENT_DONE: TSQueryError = 4294967295 as TSQueryError;
608static mut ROOT_FIELD: *const os::raw::c_char =
609 b"__ROOT__\0" as *const u8 as *const os::raw::c_char;