1use crate::util::*;
2use crate::*;
3use std::os;
4pub type __u8 = os::raw::c_uchar;
5pub type __int16_t = os::raw::c_short;
6pub type __u16 = os::raw::c_ushort;
7pub type __int32_t = os::raw::c_int;
8pub type __u32 = os::raw::c_uint;
9pub type int16_t = __int16_t;
10pub type int32_t = __int32_t;
11pub type TSSymbol = u16;
12pub type TSFieldId = u16;
13#[derive(Copy, Clone)]
14#[repr(C)]
15pub struct TSLanguage {
16 pub version: u32,
17 pub symbol_count: u32,
18 pub alias_count: u32,
19 pub token_count: u32,
20 pub external_token_count: u32,
21 pub state_count: u32,
22 pub large_state_count: u32,
23 pub production_id_count: u32,
24 pub field_count: u32,
25 pub max_alias_sequence_length: u16,
26 pub parse_table: *const u16,
27 pub small_parse_table: *const u16,
28 pub small_parse_table_map: *const u32,
29 pub parse_actions: *const TSParseActionEntry,
30 pub symbol_names: *const *const os::raw::c_char,
31 pub field_names: *const *const os::raw::c_char,
32 pub field_map_slices: *const TSFieldMapSlice,
33 pub field_map_entries: *const TSFieldMapEntry,
34 pub symbol_metadata: *const TSSymbolMetadata,
35 pub public_symbol_map: *const TSSymbol,
36 pub alias_map: *const u16,
37 pub alias_sequences: *const TSSymbol,
38 pub lex_modes: *const TSLexMode,
39 pub lex_fn: Option<unsafe extern "C" fn(*mut TSLexer, TSStateId) -> bool>,
40 pub keyword_lex_fn: Option<unsafe extern "C" fn(*mut TSLexer, TSStateId) -> bool>,
41 pub keyword_capture_token: TSSymbol,
42 pub external_scanner: C2RustUnnamed,
43 pub primary_state_ids: *const TSStateId,
44}
45pub type TSStateId = u16;
46#[derive(Copy, Clone)]
47#[repr(C)]
48pub struct C2RustUnnamed {
49 pub states: *const bool,
50 pub symbol_map: *const TSSymbol,
51 pub create: Option<unsafe extern "C" fn() -> *mut os::raw::c_void>,
52 pub destroy: Option<unsafe extern "C" fn(*mut os::raw::c_void) -> ()>,
53 pub scan: Option<unsafe extern "C" fn(*mut os::raw::c_void, *mut TSLexer, *const bool) -> bool>,
54 pub serialize:
55 Option<unsafe extern "C" fn(*mut os::raw::c_void, *mut os::raw::c_char) -> os::raw::c_uint>,
56 pub deserialize: Option<
57 unsafe extern "C" fn(*mut os::raw::c_void, *const os::raw::c_char, os::raw::c_uint) -> (),
58 >,
59}
60#[derive(Copy, Clone)]
61#[repr(C)]
62pub struct C2RustUnnamed_0 {
63 pub count: u8,
64 pub reusable: bool,
65}
66#[derive(Copy, Clone)]
67#[repr(C)]
68pub struct C2RustUnnamed_1 {
69 pub type_: u8,
70 pub child_count: u8,
71 pub symbol: TSSymbol,
72 pub dynamic_precedence: int16_t,
73 pub production_id: u16,
74}
75#[derive(Copy, Clone)]
76#[repr(C)]
77pub struct C2RustUnnamed_2 {
78 pub type_: u8,
79 pub state: TSStateId,
80 pub extra: bool,
81 pub repetition: bool,
82}
83pub const TSSymbolTypeAuxiliary: TSSymbolType = 2;
84pub const TSSymbolTypeAnonymous: TSSymbolType = 1;
85pub const TSSymbolTypeRegular: TSSymbolType = 0;
86#[derive(Copy, Clone)]
87#[repr(C)]
88pub struct TableEntry {
89 pub actions: *const TSParseAction,
90 pub action_count: u32,
91 pub is_reusable: bool,
92}
93#[inline]
94unsafe extern "C" fn ts_language_lookup(
95 mut self_0: *const TSLanguage,
96 mut state: TSStateId,
97 mut symbol: TSSymbol,
98) -> u16 {
99 if state as os::raw::c_uint >= (*self_0).large_state_count {
100 let mut index: u32 = *((*self_0).small_parse_table_map)
101 .offset((state as os::raw::c_uint).wrapping_sub((*self_0).large_state_count) as isize);
102 let mut data: *const u16 =
103 &*((*self_0).small_parse_table).offset(index as isize) as *const u16;
104 let fresh0 = data;
105 data = data.offset(1);
106 let mut group_count: u16 = *fresh0;
107 let mut i: os::raw::c_uint = 0 as os::raw::c_int as os::raw::c_uint;
108 while i < group_count as os::raw::c_uint {
109 let fresh1 = data;
110 data = data.offset(1);
111 let mut section_value: u16 = *fresh1;
112 let fresh2 = data;
113 data = data.offset(1);
114 let mut symbol_count: u16 = *fresh2;
115 let mut i_0: os::raw::c_uint = 0 as os::raw::c_int as os::raw::c_uint;
116 while i_0 < symbol_count as os::raw::c_uint {
117 let fresh3 = data;
118 data = data.offset(1);
119 if *fresh3 as os::raw::c_int == symbol as os::raw::c_int {
120 return section_value;
121 }
122 i_0 = i_0.wrapping_add(1);
123 }
124 i = i.wrapping_add(1);
125 }
126 return 0 as os::raw::c_int as u16;
127 } else {
128 return *((*self_0).parse_table).offset(
129 (state as os::raw::c_uint)
130 .wrapping_mul((*self_0).symbol_count)
131 .wrapping_add(symbol as os::raw::c_uint) as isize,
132 );
133 };
134}
135#[no_mangle]
136pub unsafe extern "C" fn ts_language_symbol_count(mut self_0: *const TSLanguage) -> u32 {
137 return ((*self_0).symbol_count).wrapping_add((*self_0).alias_count);
138}
139#[no_mangle]
140pub unsafe extern "C" fn ts_language_version(mut self_0: *const TSLanguage) -> u32 {
141 return (*self_0).version;
142}
143#[no_mangle]
144pub unsafe extern "C" fn ts_language_field_count(mut self_0: *const TSLanguage) -> u32 {
145 return (*self_0).field_count;
146}
147#[no_mangle]
148pub unsafe extern "C" fn ts_language_table_entry(
149 mut self_0: *const TSLanguage,
150 mut state: TSStateId,
151 mut symbol: TSSymbol,
152 mut result: *mut TableEntry,
153) {
154 if symbol as os::raw::c_int == -(1 as os::raw::c_int) as TSSymbol as os::raw::c_int
155 || symbol as os::raw::c_int
156 == -(1 as os::raw::c_int) as TSSymbol as os::raw::c_int - 1 as os::raw::c_int
157 {
158 (*result).action_count = 0 as os::raw::c_int as u32;
159 (*result).is_reusable = false;
160 let ref mut fresh4 = (*result).actions;
161 *fresh4 = 0 as *const TSParseAction;
162 } else {
163 if (symbol as os::raw::c_uint) < (*self_0).token_count {
164 } else {
165 panic!();
166 }
167 let mut action_index: u32 = ts_language_lookup(self_0, state, symbol) as u32;
168 let mut entry: *const TSParseActionEntry =
169 &*((*self_0).parse_actions).offset(action_index as isize) as *const TSParseActionEntry;
170 (*result).action_count = (*entry).entry.count as u32;
171 (*result).is_reusable = (*entry).entry.reusable;
172 let ref mut fresh5 = (*result).actions;
173 *fresh5 = entry.offset(1 as os::raw::c_int as isize) as *const TSParseAction;
174 };
175}
176#[no_mangle]
177pub unsafe extern "C" fn ts_language_symbol_metadata(
178 mut self_0: *const TSLanguage,
179 mut symbol: TSSymbol,
180) -> TSSymbolMetadata {
181 if symbol as os::raw::c_int == -(1 as os::raw::c_int) as TSSymbol as os::raw::c_int {
182 return {
183 let mut init = TSSymbolMetadata {
184 visible: true,
185 named: true,
186 supertype: false,
187 };
188 init
189 };
190 } else if symbol as os::raw::c_int
191 == -(1 as os::raw::c_int) as TSSymbol as os::raw::c_int - 1 as os::raw::c_int
192 {
193 return {
194 let mut init = TSSymbolMetadata {
195 visible: false,
196 named: false,
197 supertype: false,
198 };
199 init
200 };
201 } else {
202 return *((*self_0).symbol_metadata).offset(symbol as isize);
203 };
204}
205#[no_mangle]
206pub unsafe extern "C" fn ts_language_public_symbol(
207 mut self_0: *const TSLanguage,
208 mut symbol: TSSymbol,
209) -> TSSymbol {
210 if symbol as os::raw::c_int == -(1 as os::raw::c_int) as TSSymbol as os::raw::c_int {
211 return symbol;
212 }
213 return *((*self_0).public_symbol_map).offset(symbol as isize);
214}
215#[no_mangle]
216pub unsafe extern "C" fn ts_language_symbol_name(
217 mut self_0: *const TSLanguage,
218 mut symbol: TSSymbol,
219) -> *const os::raw::c_char {
220 if symbol as os::raw::c_int == -(1 as os::raw::c_int) as TSSymbol as os::raw::c_int {
221 return b"ERROR\0" as *const u8 as *const os::raw::c_char;
222 } else if symbol as os::raw::c_int
223 == -(1 as os::raw::c_int) as TSSymbol as os::raw::c_int - 1 as os::raw::c_int
224 {
225 return b"_ERROR\0" as *const u8 as *const os::raw::c_char;
226 } else if (symbol as os::raw::c_uint) < ts_language_symbol_count(self_0) {
227 return *((*self_0).symbol_names).offset(symbol as isize);
228 } else {
229 return 0 as *const os::raw::c_char;
230 };
231}
232#[no_mangle]
233pub unsafe extern "C" fn ts_language_symbol_for_name(
234 mut self_0: *const TSLanguage,
235 mut string: *const os::raw::c_char,
236 mut length: u32,
237 mut is_named: bool,
238) -> TSSymbol {
239 if strncmp(
240 string,
241 b"ERROR\0" as *const u8 as *const os::raw::c_char,
242 length as usize,
243 ) == 0
244 {
245 return -(1 as os::raw::c_int) as TSSymbol;
246 }
247 let mut count: u32 = ts_language_symbol_count(self_0);
248 let mut i: TSSymbol = 0 as os::raw::c_int as TSSymbol;
249 while (i as os::raw::c_uint) < count {
250 let mut metadata: TSSymbolMetadata = ts_language_symbol_metadata(self_0, i);
251 if !(!metadata.visible && !metadata.supertype
252 || metadata.named as os::raw::c_int != is_named as os::raw::c_int)
253 {
254 let mut symbol_name: *const os::raw::c_char =
255 *((*self_0).symbol_names).offset(i as isize);
256 if strncmp(symbol_name, string, length as usize) == 0
257 && *symbol_name.offset(length as isize) == 0
258 {
259 return *((*self_0).public_symbol_map).offset(i as isize);
260 }
261 }
262 i = i.wrapping_add(1);
263 }
264 return 0 as os::raw::c_int as TSSymbol;
265}
266#[no_mangle]
267pub unsafe extern "C" fn ts_language_symbol_type(
268 mut self_0: *const TSLanguage,
269 mut symbol: TSSymbol,
270) -> TSSymbolType {
271 let mut metadata: TSSymbolMetadata = ts_language_symbol_metadata(self_0, symbol);
272 if metadata.named as os::raw::c_int != 0 && metadata.visible as os::raw::c_int != 0 {
273 return TSSymbolTypeRegular;
274 } else if metadata.visible {
275 return TSSymbolTypeAnonymous;
276 } else {
277 return TSSymbolTypeAuxiliary;
278 };
279}
280#[no_mangle]
281pub unsafe extern "C" fn ts_language_field_name_for_id(
282 mut self_0: *const TSLanguage,
283 mut id: TSFieldId,
284) -> *const os::raw::c_char {
285 let mut count: u32 = ts_language_field_count(self_0);
286 if count != 0 && id as os::raw::c_uint <= count {
287 return *((*self_0).field_names).offset(id as isize);
288 } else {
289 return 0 as *const os::raw::c_char;
290 };
291}
292#[no_mangle]
293pub unsafe extern "C" fn ts_language_field_id_for_name(
294 mut self_0: *const TSLanguage,
295 mut name: *const os::raw::c_char,
296 mut name_length: u32,
297) -> TSFieldId {
298 let mut count: u32 = ts_language_field_count(self_0);
299 let mut i: TSSymbol = 1 as os::raw::c_int as TSSymbol;
300 while (i as os::raw::c_uint) < count.wrapping_add(1 as os::raw::c_int as os::raw::c_uint) {
301 match strncmp(
302 name,
303 *((*self_0).field_names).offset(i as isize),
304 name_length as usize,
305 ) {
306 0 => {
307 if *(*((*self_0).field_names).offset(i as isize)).offset(name_length as isize)
308 as os::raw::c_int
309 == 0 as os::raw::c_int
310 {
311 return i;
312 }
313 }
314 -1 => return 0 as os::raw::c_int as TSFieldId,
315 _ => {}
316 }
317 i = i.wrapping_add(1);
318 }
319 return 0 as os::raw::c_int as TSFieldId;
320}