1use crate::core_transpiled::util::*;
2use crate::core_transpiled::*;
3use std::os;
4pub type __uint8_t = libc::c_uchar;
5pub type __int16_t = libc::c_short;
6pub type __uint16_t = libc::c_ushort;
7pub type __int32_t = libc::c_int;
8pub type __uint32_t = libc::c_uint;
9pub type int16_t = __int16_t;
10pub type int32_t = __int32_t;
11pub type uint8_t = __uint8_t;
12pub type uint16_t = __uint16_t;
13pub type uint32_t = __uint32_t;
14pub type TSStateId = uint16_t;
15pub type TSFieldId = uint16_t;
16#[derive(Copy, Clone)]
17#[repr(C)]
18pub struct TSLanguage {
19 pub version: uint32_t,
20 pub symbol_count: uint32_t,
21 pub alias_count: uint32_t,
22 pub token_count: uint32_t,
23 pub external_token_count: uint32_t,
24 pub state_count: uint32_t,
25 pub large_state_count: uint32_t,
26 pub production_id_count: uint32_t,
27 pub field_count: uint32_t,
28 pub max_alias_sequence_length: uint16_t,
29 pub parse_table: *const uint16_t,
30 pub small_parse_table: *const uint16_t,
31 pub small_parse_table_map: *const uint32_t,
32 pub parse_actions: *const TSParseActionEntry,
33 pub symbol_names: *const *const libc::c_char,
34 pub field_names: *const *const libc::c_char,
35 pub field_map_slices: *const TSFieldMapSlice,
36 pub field_map_entries: *const TSFieldMapEntry,
37 pub symbol_metadata: *const TSSymbolMetadata,
38 pub public_symbol_map: *const TSSymbol,
39 pub alias_map: *const uint16_t,
40 pub alias_sequences: *const TSSymbol,
41 pub lex_modes: *const TSLexMode,
42 pub lex_fn: Option<unsafe extern "C" fn(*mut TSLexer, TSStateId) -> bool>,
43 pub keyword_lex_fn: Option<unsafe extern "C" fn(*mut TSLexer, TSStateId) -> bool>,
44 pub keyword_capture_token: TSSymbol,
45 pub external_scanner: C2RustUnnamed,
46 pub primary_state_ids: *const TSStateId,
47}
48#[derive(Copy, Clone)]
49#[repr(C)]
50pub struct C2RustUnnamed {
51 pub states: *const bool,
52 pub symbol_map: *const TSSymbol,
53 pub create: Option<unsafe extern "C" fn() -> *mut libc::c_void>,
54 pub destroy: Option<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
55 pub scan: Option<unsafe extern "C" fn(*mut libc::c_void, *mut TSLexer, *const bool) -> bool>,
56 pub serialize:
57 Option<unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_char) -> libc::c_uint>,
58 pub deserialize:
59 Option<unsafe extern "C" fn(*mut libc::c_void, *const libc::c_char, libc::c_uint) -> ()>,
60}
61#[derive(Copy, Clone)]
62#[repr(C)]
63pub struct C2RustUnnamed_0 {
64 pub count: uint8_t,
65 pub reusable: bool,
66}
67#[derive(Copy, Clone)]
68#[repr(C)]
69pub struct C2RustUnnamed_1 {
70 pub type_: uint8_t,
71 pub child_count: uint8_t,
72 pub symbol: TSSymbol,
73 pub dynamic_precedence: int16_t,
74 pub production_id: uint16_t,
75}
76#[derive(Copy, Clone)]
77#[repr(C)]
78pub struct C2RustUnnamed_2 {
79 pub type_: uint8_t,
80 pub state: TSStateId,
81 pub extra: bool,
82 pub repetition: bool,
83}
84#[derive(Copy, Clone)]
85#[repr(C)]
86pub struct TableEntry {
87 pub actions: *const TSParseAction,
88 pub action_count: uint32_t,
89 pub is_reusable: bool,
90}
91pub const TSParseActionTypeShift: C2RustUnnamed_3 = 0;
92#[derive(Copy, Clone)]
93#[repr(C)]
94pub struct LookaheadIterator {
95 pub language: *const TSLanguage,
96 pub data: *const uint16_t,
97 pub group_end: *const uint16_t,
98 pub state: TSStateId,
99 pub table_value: uint16_t,
100 pub section_index: uint16_t,
101 pub group_count: uint16_t,
102 pub is_small_state: bool,
103 pub actions: *const TSParseAction,
104 pub symbol: TSSymbol,
105 pub next_state: TSStateId,
106 pub action_count: uint16_t,
107}
108pub type C2RustUnnamed_3 = libc::c_uint;
109pub const TSParseActionTypeRecover: C2RustUnnamed_3 = 3;
110pub const TSParseActionTypeAccept: C2RustUnnamed_3 = 2;
111pub const TSParseActionTypeReduce: C2RustUnnamed_3 = 1;
112#[inline]
113unsafe extern "C" fn ts_language_lookup(
114 mut self_0: *const TSLanguage,
115 mut state: TSStateId,
116 mut symbol: TSSymbol,
117) -> uint16_t {
118 if state as libc::c_uint >= (*self_0).large_state_count {
119 let mut index: uint32_t = *((*self_0).small_parse_table_map)
120 .offset((state as libc::c_uint).wrapping_sub((*self_0).large_state_count) as isize);
121 let mut data: *const uint16_t =
122 &*((*self_0).small_parse_table).offset(index as isize) as *const uint16_t;
123 let fresh0 = data;
124 data = data.offset(1);
125 let mut group_count: uint16_t = *fresh0;
126 let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
127 while i < group_count as libc::c_uint {
128 let fresh1 = data;
129 data = data.offset(1);
130 let mut section_value: uint16_t = *fresh1;
131 let fresh2 = data;
132 data = data.offset(1);
133 let mut symbol_count: uint16_t = *fresh2;
134 let mut j: libc::c_uint = 0 as libc::c_int as libc::c_uint;
135 while j < symbol_count as libc::c_uint {
136 let fresh3 = data;
137 data = data.offset(1);
138 if *fresh3 as libc::c_int == symbol as libc::c_int {
139 return section_value;
140 }
141 j = j.wrapping_add(1);
142 }
143 i = i.wrapping_add(1);
144 }
145 return 0 as libc::c_int as uint16_t;
146 } else {
147 return *((*self_0).parse_table).offset(
148 (state as libc::c_uint)
149 .wrapping_mul((*self_0).symbol_count)
150 .wrapping_add(symbol as libc::c_uint) as isize,
151 );
152 };
153}
154#[inline]
155unsafe extern "C" fn ts_language_actions(
156 mut self_0: *const TSLanguage,
157 mut state: TSStateId,
158 mut symbol: TSSymbol,
159 mut count: *mut uint32_t,
160) -> *const TSParseAction {
161 let mut entry: TableEntry = TableEntry {
162 actions: 0 as *const TSParseAction,
163 action_count: 0,
164 is_reusable: false,
165 };
166 ts_language_table_entry(self_0, state, symbol, &mut entry);
167 *count = entry.action_count;
168 return entry.actions;
169}
170#[inline]
171unsafe extern "C" fn ts_language_lookaheads(
172 mut self_0: *const TSLanguage,
173 mut state: TSStateId,
174) -> LookaheadIterator {
175 let mut is_small_state: bool = state as libc::c_uint >= (*self_0).large_state_count;
176 let mut data: *const uint16_t = 0 as *const uint16_t;
177 let mut group_end: *const uint16_t = 0 as *const uint16_t;
178 let mut group_count: uint16_t = 0 as libc::c_int as uint16_t;
179 if is_small_state {
180 let mut index: uint32_t = *((*self_0).small_parse_table_map)
181 .offset((state as libc::c_uint).wrapping_sub((*self_0).large_state_count) as isize);
182 data = &*((*self_0).small_parse_table).offset(index as isize) as *const uint16_t;
183 group_end = data.offset(1 as libc::c_int as isize);
184 group_count = *data;
185 } else {
186 data = (&*((*self_0).parse_table)
187 .offset((state as libc::c_uint).wrapping_mul((*self_0).symbol_count) as isize)
188 as *const uint16_t)
189 .offset(-(1 as libc::c_int as isize));
190 }
191 return {
192 let mut init = LookaheadIterator {
193 language: self_0,
194 data: data,
195 group_end: group_end,
196 state: 0,
197 table_value: 0,
198 section_index: 0,
199 group_count: group_count,
200 is_small_state: is_small_state,
201 actions: 0 as *const TSParseAction,
202 symbol: 65535 as libc::c_int as TSSymbol,
203 next_state: 0 as libc::c_int as TSStateId,
204 action_count: 0,
205 };
206 init
207 };
208}
209#[inline]
210unsafe extern "C" fn ts_lookahead_iterator__next(mut self_0: *mut LookaheadIterator) -> bool {
211 if (*self_0).is_small_state {
212 (*self_0).data = ((*self_0).data).offset(1);
213 if (*self_0).data == (*self_0).group_end {
214 if (*self_0).group_count as libc::c_int == 0 as libc::c_int {
215 return 0 as libc::c_int != 0;
216 }
217 (*self_0).group_count = ((*self_0).group_count).wrapping_sub(1);
218 let fresh4 = (*self_0).data;
219 (*self_0).data = ((*self_0).data).offset(1);
220 (*self_0).table_value = *fresh4;
221 let fresh5 = (*self_0).data;
222 (*self_0).data = ((*self_0).data).offset(1);
223 let mut symbol_count: libc::c_uint = *fresh5 as libc::c_uint;
224 (*self_0).group_end = ((*self_0).data).offset(symbol_count as isize);
225 (*self_0).symbol = *(*self_0).data;
226 } else {
227 (*self_0).symbol = *(*self_0).data;
228 return 1 as libc::c_int != 0;
229 }
230 } else {
231 loop {
232 (*self_0).data = ((*self_0).data).offset(1);
233 (*self_0).symbol = ((*self_0).symbol).wrapping_add(1);
234 if (*self_0).symbol as libc::c_uint >= (*(*self_0).language).symbol_count {
235 return 0 as libc::c_int != 0;
236 }
237 (*self_0).table_value = *(*self_0).data;
238 if !((*self_0).table_value == 0) {
239 break;
240 }
241 }
242 }
243 if ((*self_0).symbol as libc::c_uint) < (*(*self_0).language).token_count {
244 let mut entry: *const TSParseActionEntry = &*((*(*self_0).language).parse_actions)
245 .offset((*self_0).table_value as isize)
246 as *const TSParseActionEntry;
247 (*self_0).action_count = (*entry).entry.count as uint16_t;
248 (*self_0).actions = entry.offset(1 as libc::c_int as isize) as *const TSParseAction;
249 (*self_0).next_state = 0 as libc::c_int as TSStateId;
250 } else {
251 (*self_0).action_count = 0 as libc::c_int as uint16_t;
252 (*self_0).next_state = (*self_0).table_value;
253 }
254 return 1 as libc::c_int != 0;
255}
256#[no_mangle]
257pub unsafe extern "C" fn ts_language_copy(mut self_0: *const TSLanguage) -> *const TSLanguage {
258 if !self_0.is_null() && ts_language_is_wasm(self_0) as libc::c_int != 0 {
259 ts_wasm_language_retain(self_0);
260 }
261 return self_0;
262}
263#[no_mangle]
264pub unsafe extern "C" fn ts_language_delete(mut self_0: *const TSLanguage) {
265 if !self_0.is_null() && ts_language_is_wasm(self_0) as libc::c_int != 0 {
266 ts_wasm_language_release(self_0);
267 }
268}
269#[no_mangle]
270pub unsafe extern "C" fn ts_language_symbol_count(mut self_0: *const TSLanguage) -> uint32_t {
271 return ((*self_0).symbol_count).wrapping_add((*self_0).alias_count);
272}
273#[no_mangle]
274pub unsafe extern "C" fn ts_language_state_count(mut self_0: *const TSLanguage) -> uint32_t {
275 return (*self_0).state_count;
276}
277#[no_mangle]
278pub unsafe extern "C" fn ts_language_version(mut self_0: *const TSLanguage) -> uint32_t {
279 return (*self_0).version;
280}
281#[no_mangle]
282pub unsafe extern "C" fn ts_language_field_count(mut self_0: *const TSLanguage) -> uint32_t {
283 return (*self_0).field_count;
284}
285#[no_mangle]
286pub unsafe extern "C" fn ts_language_table_entry(
287 mut self_0: *const TSLanguage,
288 mut state: TSStateId,
289 mut symbol: TSSymbol,
290 mut result: *mut TableEntry,
291) {
292 if symbol as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int
293 || symbol as libc::c_int
294 == -(1 as libc::c_int) as TSSymbol as libc::c_int - 1 as libc::c_int
295 {
296 (*result).action_count = 0 as libc::c_int as uint32_t;
297 (*result).is_reusable = 0 as libc::c_int != 0;
298 (*result).actions = 0 as *const TSParseAction;
299 } else {
300 if (symbol as libc::c_uint) < (*self_0).token_count {
301 } else {
302 panic!();
303 }
304 let mut action_index: uint32_t = ts_language_lookup(self_0, state, symbol) as uint32_t;
305 let mut entry: *const TSParseActionEntry =
306 &*((*self_0).parse_actions).offset(action_index as isize) as *const TSParseActionEntry;
307 (*result).action_count = (*entry).entry.count as uint32_t;
308 (*result).is_reusable = (*entry).entry.reusable;
309 (*result).actions = entry.offset(1 as libc::c_int as isize) as *const TSParseAction;
310 };
311}
312#[no_mangle]
313pub unsafe extern "C" fn ts_language_symbol_metadata(
314 mut self_0: *const TSLanguage,
315 mut symbol: TSSymbol,
316) -> TSSymbolMetadata {
317 if symbol as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int {
318 return {
319 let mut init = TSSymbolMetadata {
320 visible: 1 as libc::c_int != 0,
321 named: 1 as libc::c_int != 0,
322 supertype: false,
323 };
324 init
325 };
326 } else if symbol as libc::c_int
327 == -(1 as libc::c_int) as TSSymbol as libc::c_int - 1 as libc::c_int
328 {
329 return {
330 let mut init = TSSymbolMetadata {
331 visible: 0 as libc::c_int != 0,
332 named: 0 as libc::c_int != 0,
333 supertype: false,
334 };
335 init
336 };
337 } else {
338 return *((*self_0).symbol_metadata).offset(symbol as isize);
339 };
340}
341#[no_mangle]
342pub unsafe extern "C" fn ts_language_public_symbol(
343 mut self_0: *const TSLanguage,
344 mut symbol: TSSymbol,
345) -> TSSymbol {
346 if symbol as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int {
347 return symbol;
348 }
349 return *((*self_0).public_symbol_map).offset(symbol as isize);
350}
351#[no_mangle]
352pub unsafe extern "C" fn ts_language_next_state(
353 mut self_0: *const TSLanguage,
354 mut state: TSStateId,
355 mut symbol: TSSymbol,
356) -> TSStateId {
357 if symbol as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int
358 || symbol as libc::c_int
359 == -(1 as libc::c_int) as TSSymbol as libc::c_int - 1 as libc::c_int
360 {
361 return 0 as libc::c_int as TSStateId;
362 } else if (symbol as libc::c_uint) < (*self_0).token_count {
363 let mut count: uint32_t = 0;
364 let mut actions: *const TSParseAction =
365 ts_language_actions(self_0, state, symbol, &mut count);
366 if count > 0 as libc::c_int as libc::c_uint {
367 let mut action: TSParseAction =
368 *actions.offset(count.wrapping_sub(1 as libc::c_int as libc::c_uint) as isize);
369 if action.type_ as libc::c_int == TSParseActionTypeShift as libc::c_int {
370 return (if action.shift.extra as libc::c_int != 0 {
371 state as libc::c_int
372 } else {
373 action.shift.state as libc::c_int
374 }) as TSStateId;
375 }
376 }
377 return 0 as libc::c_int as TSStateId;
378 } else {
379 return ts_language_lookup(self_0, state, symbol);
380 };
381}
382#[no_mangle]
383pub unsafe extern "C" fn ts_language_symbol_name(
384 mut self_0: *const TSLanguage,
385 mut symbol: TSSymbol,
386) -> *const libc::c_char {
387 if symbol as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int {
388 return b"ERROR\0" as *const u8 as *const libc::c_char;
389 } else if symbol as libc::c_int
390 == -(1 as libc::c_int) as TSSymbol as libc::c_int - 1 as libc::c_int
391 {
392 return b"_ERROR\0" as *const u8 as *const libc::c_char;
393 } else if (symbol as libc::c_uint) < ts_language_symbol_count(self_0) {
394 return *((*self_0).symbol_names).offset(symbol as isize);
395 } else {
396 return 0 as *const libc::c_char;
397 };
398}
399#[no_mangle]
400pub unsafe extern "C" fn ts_language_symbol_for_name(
401 mut self_0: *const TSLanguage,
402 mut string: *const libc::c_char,
403 mut length: uint32_t,
404 mut is_named: bool,
405) -> TSSymbol {
406 if strncmp(
407 string,
408 b"ERROR\0" as *const u8 as *const libc::c_char,
409 length as libc::c_ulong,
410 ) == 0
411 {
412 return -(1 as libc::c_int) as TSSymbol;
413 }
414 let mut count: uint16_t = ts_language_symbol_count(self_0) as uint16_t;
415 let mut i: TSSymbol = 0 as libc::c_int as TSSymbol;
416 while (i as libc::c_int) < count as libc::c_int {
417 let mut metadata: TSSymbolMetadata = ts_language_symbol_metadata(self_0, i);
418 if !(!metadata.visible && !metadata.supertype
419 || metadata.named as libc::c_int != is_named as libc::c_int)
420 {
421 let mut symbol_name: *const libc::c_char = *((*self_0).symbol_names).offset(i as isize);
422 if strncmp(symbol_name, string, length as libc::c_ulong) == 0
423 && *symbol_name.offset(length as isize) == 0
424 {
425 return *((*self_0).public_symbol_map).offset(i as isize);
426 }
427 }
428 i = i.wrapping_add(1);
429 }
430 return 0 as libc::c_int as TSSymbol;
431}
432#[no_mangle]
433pub unsafe extern "C" fn ts_language_symbol_type(
434 mut self_0: *const TSLanguage,
435 mut symbol: TSSymbol,
436) -> TSSymbolType {
437 let mut metadata: TSSymbolMetadata = ts_language_symbol_metadata(self_0, symbol);
438 if metadata.named as libc::c_int != 0 && metadata.visible as libc::c_int != 0 {
439 return TSSymbolTypeRegular;
440 } else if metadata.visible {
441 return TSSymbolTypeAnonymous;
442 } else if metadata.supertype {
443 return TSSymbolTypeSupertype;
444 } else {
445 return TSSymbolTypeAuxiliary;
446 };
447}
448#[no_mangle]
449pub unsafe extern "C" fn ts_language_field_name_for_id(
450 mut self_0: *const TSLanguage,
451 mut id: TSFieldId,
452) -> *const libc::c_char {
453 let mut count: uint32_t = ts_language_field_count(self_0);
454 if count != 0 && id as libc::c_uint <= count {
455 return *((*self_0).field_names).offset(id as isize);
456 } else {
457 return 0 as *const libc::c_char;
458 };
459}
460#[no_mangle]
461pub unsafe extern "C" fn ts_language_field_id_for_name(
462 mut self_0: *const TSLanguage,
463 mut name: *const libc::c_char,
464 mut name_length: uint32_t,
465) -> TSFieldId {
466 let mut count: uint16_t = ts_language_field_count(self_0) as uint16_t;
467 let mut i: TSSymbol = 1 as libc::c_int as TSSymbol;
468 while (i as libc::c_int) < count as libc::c_int + 1 as libc::c_int {
469 match strncmp(
470 name,
471 *((*self_0).field_names).offset(i as isize),
472 name_length as libc::c_ulong,
473 ) {
474 0 => {
475 if *(*((*self_0).field_names).offset(i as isize)).offset(name_length as isize)
476 as libc::c_int
477 == 0 as libc::c_int
478 {
479 return i;
480 }
481 }
482 -1 => return 0 as libc::c_int as TSFieldId,
483 _ => {}
484 }
485 i = i.wrapping_add(1);
486 }
487 return 0 as libc::c_int as TSFieldId;
488}
489#[no_mangle]
490pub unsafe extern "C" fn ts_lookahead_iterator_new(
491 mut self_0: *const TSLanguage,
492 mut state: TSStateId,
493) -> *mut TSLookaheadIterator {
494 if state as libc::c_uint >= (*self_0).state_count {
495 return 0 as *mut TSLookaheadIterator;
496 }
497 let mut iterator: *mut LookaheadIterator = crate::core_transpiled::alloc::ts_malloc(
498 ::core::mem::size_of::<LookaheadIterator>() as libc::c_ulong,
499 ) as *mut LookaheadIterator;
500 *iterator = ts_language_lookaheads(self_0, state);
501 return iterator as *mut TSLookaheadIterator;
502}
503#[no_mangle]
504pub unsafe extern "C" fn ts_lookahead_iterator_delete(mut self_0: *mut TSLookaheadIterator) {
505 crate::core_transpiled::alloc::ts_free(self_0 as *mut libc::c_void);
506}
507#[no_mangle]
508pub unsafe extern "C" fn ts_lookahead_iterator_reset_state(
509 mut self_0: *mut TSLookaheadIterator,
510 mut state: TSStateId,
511) -> bool {
512 let mut iterator: *mut LookaheadIterator = self_0 as *mut LookaheadIterator;
513 if state as libc::c_uint >= (*(*iterator).language).state_count {
514 return 0 as libc::c_int != 0;
515 }
516 *iterator = ts_language_lookaheads((*iterator).language, state);
517 return 1 as libc::c_int != 0;
518}
519#[no_mangle]
520pub unsafe extern "C" fn ts_lookahead_iterator_language(
521 mut self_0: *const TSLookaheadIterator,
522) -> *const TSLanguage {
523 let mut iterator: *const LookaheadIterator = self_0 as *const LookaheadIterator;
524 return (*iterator).language;
525}
526#[no_mangle]
527pub unsafe extern "C" fn ts_lookahead_iterator_reset(
528 mut self_0: *mut TSLookaheadIterator,
529 mut language: *const TSLanguage,
530 mut state: TSStateId,
531) -> bool {
532 if state as libc::c_uint >= (*language).state_count {
533 return 0 as libc::c_int != 0;
534 }
535 let mut iterator: *mut LookaheadIterator = self_0 as *mut LookaheadIterator;
536 *iterator = ts_language_lookaheads(language, state);
537 return 1 as libc::c_int != 0;
538}
539#[no_mangle]
540pub unsafe extern "C" fn ts_lookahead_iterator_next(mut self_0: *mut TSLookaheadIterator) -> bool {
541 let mut iterator: *mut LookaheadIterator = self_0 as *mut LookaheadIterator;
542 return ts_lookahead_iterator__next(iterator);
543}
544#[no_mangle]
545pub unsafe extern "C" fn ts_lookahead_iterator_current_symbol(
546 mut self_0: *const TSLookaheadIterator,
547) -> TSSymbol {
548 let mut iterator: *const LookaheadIterator = self_0 as *const LookaheadIterator;
549 return (*iterator).symbol;
550}
551#[no_mangle]
552pub unsafe extern "C" fn ts_lookahead_iterator_current_symbol_name(
553 mut self_0: *const TSLookaheadIterator,
554) -> *const libc::c_char {
555 let mut iterator: *const LookaheadIterator = self_0 as *const LookaheadIterator;
556 return ts_language_symbol_name((*iterator).language, (*iterator).symbol);
557}