unsafe_libyaml/
parser.rs

Help
1use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};
2use crate::externs::{memcpy, memset, strcmp, strlen};
3use crate::ops::ForceAdd as _;
4use crate::scanner::yaml_parser_fetch_more_tokens;
5use crate::success::{Success, FAIL, OK};
6use crate::yaml::{size_t, yaml_char_t};
7use crate::{
8    libc, yaml_event_t, yaml_mark_t, yaml_parser_t, yaml_tag_directive_t, yaml_token_t,
9    yaml_version_directive_t, YAML_ALIAS_EVENT, YAML_ALIAS_TOKEN, YAML_ANCHOR_TOKEN,
10    YAML_BLOCK_END_TOKEN, YAML_BLOCK_ENTRY_TOKEN, YAML_BLOCK_MAPPING_START_TOKEN,
11    YAML_BLOCK_MAPPING_STYLE, YAML_BLOCK_SEQUENCE_START_TOKEN, YAML_BLOCK_SEQUENCE_STYLE,
12    YAML_DOCUMENT_END_EVENT, YAML_DOCUMENT_END_TOKEN, YAML_DOCUMENT_START_EVENT,
13    YAML_DOCUMENT_START_TOKEN, YAML_FLOW_ENTRY_TOKEN, YAML_FLOW_MAPPING_END_TOKEN,
14    YAML_FLOW_MAPPING_START_TOKEN, YAML_FLOW_MAPPING_STYLE, YAML_FLOW_SEQUENCE_END_TOKEN,
15    YAML_FLOW_SEQUENCE_START_TOKEN, YAML_FLOW_SEQUENCE_STYLE, YAML_KEY_TOKEN,
16    YAML_MAPPING_END_EVENT, YAML_MAPPING_START_EVENT, YAML_NO_ERROR, YAML_PARSER_ERROR,
17    YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE, YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
18    YAML_PARSE_BLOCK_MAPPING_VALUE_STATE, YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
19    YAML_PARSE_BLOCK_NODE_STATE, YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
20    YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE, YAML_PARSE_DOCUMENT_CONTENT_STATE,
21    YAML_PARSE_DOCUMENT_END_STATE, YAML_PARSE_DOCUMENT_START_STATE, YAML_PARSE_END_STATE,
22    YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
23    YAML_PARSE_FLOW_MAPPING_KEY_STATE, YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
24    YAML_PARSE_FLOW_NODE_STATE, YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
25    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
26    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE, YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
27    YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE, YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
28    YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE, YAML_PARSE_STREAM_START_STATE,
29    YAML_PLAIN_SCALAR_STYLE, YAML_SCALAR_EVENT, YAML_SCALAR_TOKEN, YAML_SEQUENCE_END_EVENT,
30    YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT, YAML_STREAM_END_TOKEN,
31    YAML_STREAM_START_EVENT, YAML_STREAM_START_TOKEN, YAML_TAG_DIRECTIVE_TOKEN, YAML_TAG_TOKEN,
32    YAML_VALUE_TOKEN, YAML_VERSION_DIRECTIVE_TOKEN,
33};
34use core::mem::size_of;
35use core::ptr::{self, addr_of_mut};
36
37unsafe fn PEEK_TOKEN(parser: *mut yaml_parser_t) -> *mut yaml_token_t {
38    if (*parser).token_available || yaml_parser_fetch_more_tokens(parser).ok {
39        (*parser).tokens.head
40    } else {
41        ptr::null_mut::<yaml_token_t>()
42    }
43}
44
45unsafe fn SKIP_TOKEN(parser: *mut yaml_parser_t) {
46    (*parser).token_available = false;
47    let fresh3 = addr_of_mut!((*parser).tokens_parsed);
48    *fresh3 = (*fresh3).wrapping_add(1);
49    (*parser).stream_end_produced = (*(*parser).tokens.head).type_ == YAML_STREAM_END_TOKEN;
50    let fresh4 = addr_of_mut!((*parser).tokens.head);
51    *fresh4 = (*fresh4).wrapping_offset(1);
52}
53
54/// Parse the input stream and produce the next parsing event.
55///
56/// Call the function subsequently to produce a sequence of events corresponding
57/// to the input stream. The initial event has the type YAML_STREAM_START_EVENT
58/// while the ending event has the type YAML_STREAM_END_EVENT.
59///
60/// An application is responsible for freeing any buffers associated with the
61/// produced event object using the yaml_event_delete() function.
62///
63/// An application must not alternate the calls of yaml_parser_parse() with the
64/// calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the
65/// parser.
66pub unsafe fn yaml_parser_parse(parser: *mut yaml_parser_t, event: *mut yaml_event_t) -> Success {
67    __assert!(!parser.is_null());
68    __assert!(!event.is_null());
69    memset(
70        event as *mut libc::c_void,
71        0,
72        size_of::<yaml_event_t>() as libc::c_ulong,
73    );
74    if (*parser).stream_end_produced
75        || (*parser).error != YAML_NO_ERROR
76        || (*parser).state == YAML_PARSE_END_STATE
77    {
78        return OK;
79    }
80    yaml_parser_state_machine(parser, event)
81}
82
83unsafe fn yaml_parser_set_parser_error(
84    parser: *mut yaml_parser_t,
85    problem: *const libc::c_char,
86    problem_mark: yaml_mark_t,
87) {
88    (*parser).error = YAML_PARSER_ERROR;
89    let fresh0 = addr_of_mut!((*parser).problem);
90    *fresh0 = problem;
91    (*parser).problem_mark = problem_mark;
92}
93
94unsafe fn yaml_parser_set_parser_error_context(
95    parser: *mut yaml_parser_t,
96    context: *const libc::c_char,
97    context_mark: yaml_mark_t,
98    problem: *const libc::c_char,
99    problem_mark: yaml_mark_t,
100) {
101    (*parser).error = YAML_PARSER_ERROR;
102    let fresh1 = addr_of_mut!((*parser).context);
103    *fresh1 = context;
104    (*parser).context_mark = context_mark;
105    let fresh2 = addr_of_mut!((*parser).problem);
106    *fresh2 = problem;
107    (*parser).problem_mark = problem_mark;
108}
109
110unsafe fn yaml_parser_state_machine(
111    parser: *mut yaml_parser_t,
112    event: *mut yaml_event_t,
113) -> Success {
114    match (*parser).state {
115        YAML_PARSE_STREAM_START_STATE => yaml_parser_parse_stream_start(parser, event),
116        YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE => {
117            yaml_parser_parse_document_start(parser, event, true)
118        }
119        YAML_PARSE_DOCUMENT_START_STATE => yaml_parser_parse_document_start(parser, event, false),
120        YAML_PARSE_DOCUMENT_CONTENT_STATE => yaml_parser_parse_document_content(parser, event),
121        YAML_PARSE_DOCUMENT_END_STATE => yaml_parser_parse_document_end(parser, event),
122        YAML_PARSE_BLOCK_NODE_STATE => yaml_parser_parse_node(parser, event, true, false),
123        YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE => {
124            yaml_parser_parse_node(parser, event, true, true)
125        }
126        YAML_PARSE_FLOW_NODE_STATE => yaml_parser_parse_node(parser, event, false, false),
127        YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE => {
128            yaml_parser_parse_block_sequence_entry(parser, event, true)
129        }
130        YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE => {
131            yaml_parser_parse_block_sequence_entry(parser, event, false)
132        }
133        YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE => {
134            yaml_parser_parse_indentless_sequence_entry(parser, event)
135        }
136        YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE => {
137            yaml_parser_parse_block_mapping_key(parser, event, true)
138        }
139        YAML_PARSE_BLOCK_MAPPING_KEY_STATE => {
140            yaml_parser_parse_block_mapping_key(parser, event, false)
141        }
142        YAML_PARSE_BLOCK_MAPPING_VALUE_STATE => {
143            yaml_parser_parse_block_mapping_value(parser, event)
144        }
145        YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE => {
146            yaml_parser_parse_flow_sequence_entry(parser, event, true)
147        }
148        YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE => {
149            yaml_parser_parse_flow_sequence_entry(parser, event, false)
150        }
151        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE => {
152            yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
153        }
154        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE => {
155            yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)
156        }
157        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE => {
158            yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)
159        }
160        YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE => {
161            yaml_parser_parse_flow_mapping_key(parser, event, true)
162        }
163        YAML_PARSE_FLOW_MAPPING_KEY_STATE => {
164            yaml_parser_parse_flow_mapping_key(parser, event, false)
165        }
166        YAML_PARSE_FLOW_MAPPING_VALUE_STATE => {
167            yaml_parser_parse_flow_mapping_value(parser, event, false)
168        }
169        YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE => {
170            yaml_parser_parse_flow_mapping_value(parser, event, true)
171        }
172        _ => FAIL,
173    }
174}
175
176unsafe fn yaml_parser_parse_stream_start(
177    parser: *mut yaml_parser_t,
178    event: *mut yaml_event_t,
179) -> Success {
180    let token: *mut yaml_token_t = PEEK_TOKEN(parser);
181    if token.is_null() {
182        return FAIL;
183    }
184    if (*token).type_ != YAML_STREAM_START_TOKEN {
185        yaml_parser_set_parser_error(
186            parser,
187            b"did not find expected <stream-start>\0" as *const u8 as *const libc::c_char,
188            (*token).start_mark,
189        );
190        return FAIL;
191    }
192    (*parser).state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
193    memset(
194        event as *mut libc::c_void,
195        0,
196        size_of::<yaml_event_t>() as libc::c_ulong,
197    );
198    (*event).type_ = YAML_STREAM_START_EVENT;
199    (*event).start_mark = (*token).start_mark;
200    (*event).end_mark = (*token).start_mark;
201    (*event).data.stream_start.encoding = (*token).data.stream_start.encoding;
202    SKIP_TOKEN(parser);
203    OK
204}
205
206unsafe fn yaml_parser_parse_document_start(
207    parser: *mut yaml_parser_t,
208    event: *mut yaml_event_t,
209    implicit: bool,
210) -> Success {
211    let mut token: *mut yaml_token_t;
212    let mut version_directive: *mut yaml_version_directive_t =
213        ptr::null_mut::<yaml_version_directive_t>();
214    struct TagDirectives {
215        start: *mut yaml_tag_directive_t,
216        end: *mut yaml_tag_directive_t,
217    }
218    let mut tag_directives = TagDirectives {
219        start: ptr::null_mut::<yaml_tag_directive_t>(),
220        end: ptr::null_mut::<yaml_tag_directive_t>(),
221    };
222    token = PEEK_TOKEN(parser);
223    if token.is_null() {
224        return FAIL;
225    }
226    if !implicit {
227        while (*token).type_ == YAML_DOCUMENT_END_TOKEN {
228            SKIP_TOKEN(parser);
229            token = PEEK_TOKEN(parser);
230            if token.is_null() {
231                return FAIL;
232            }
233        }
234    }
235    if implicit
236        && (*token).type_ != YAML_VERSION_DIRECTIVE_TOKEN
237        && (*token).type_ != YAML_TAG_DIRECTIVE_TOKEN
238        && (*token).type_ != YAML_DOCUMENT_START_TOKEN
239        && (*token).type_ != YAML_STREAM_END_TOKEN
240    {
241        if yaml_parser_process_directives(
242            parser,
243            ptr::null_mut::<*mut yaml_version_directive_t>(),
244            ptr::null_mut::<*mut yaml_tag_directive_t>(),
245            ptr::null_mut::<*mut yaml_tag_directive_t>(),
246        )
247        .fail
248        {
249            return FAIL;
250        }
251        PUSH!((*parser).states, YAML_PARSE_DOCUMENT_END_STATE);
252        (*parser).state = YAML_PARSE_BLOCK_NODE_STATE;
253        memset(
254            event as *mut libc::c_void,
255            0,
256            size_of::<yaml_event_t>() as libc::c_ulong,
257        );
258        (*event).type_ = YAML_DOCUMENT_START_EVENT;
259        (*event).start_mark = (*token).start_mark;
260        (*event).end_mark = (*token).start_mark;
261        let fresh9 = addr_of_mut!((*event).data.document_start.version_directive);
262        *fresh9 = ptr::null_mut::<yaml_version_directive_t>();
263        let fresh10 = addr_of_mut!((*event).data.document_start.tag_directives.start);
264        *fresh10 = ptr::null_mut::<yaml_tag_directive_t>();
265        let fresh11 = addr_of_mut!((*event).data.document_start.tag_directives.end);
266        *fresh11 = ptr::null_mut::<yaml_tag_directive_t>();
267        (*event).data.document_start.implicit = true;
268        OK
269    } else if (*token).type_ != YAML_STREAM_END_TOKEN {
270        let end_mark: yaml_mark_t;
271        let start_mark: yaml_mark_t = (*token).start_mark;
272        if yaml_parser_process_directives(
273            parser,
274            addr_of_mut!(version_directive),
275            addr_of_mut!(tag_directives.start),
276            addr_of_mut!(tag_directives.end),
277        )
278        .fail
279        {
280            return FAIL;
281        }
282        token = PEEK_TOKEN(parser);
283        if !token.is_null() {
284            if (*token).type_ != YAML_DOCUMENT_START_TOKEN {
285                yaml_parser_set_parser_error(
286                    parser,
287                    b"did not find expected <document start>\0" as *const u8 as *const libc::c_char,
288                    (*token).start_mark,
289                );
290            } else {
291                PUSH!((*parser).states, YAML_PARSE_DOCUMENT_END_STATE);
292                (*parser).state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
293                end_mark = (*token).end_mark;
294                memset(
295                    event as *mut libc::c_void,
296                    0,
297                    size_of::<yaml_event_t>() as libc::c_ulong,
298                );
299                (*event).type_ = YAML_DOCUMENT_START_EVENT;
300                (*event).start_mark = start_mark;
301                (*event).end_mark = end_mark;
302                let fresh14 = addr_of_mut!((*event).data.document_start.version_directive);
303                *fresh14 = version_directive;
304                let fresh15 = addr_of_mut!((*event).data.document_start.tag_directives.start);
305                *fresh15 = tag_directives.start;
306                let fresh16 = addr_of_mut!((*event).data.document_start.tag_directives.end);
307                *fresh16 = tag_directives.end;
308                (*event).data.document_start.implicit = false;
309                SKIP_TOKEN(parser);
310                tag_directives.end = ptr::null_mut::<yaml_tag_directive_t>();
311                tag_directives.start = tag_directives.end;
312                return OK;
313            }
314        }
315        yaml_free(version_directive as *mut libc::c_void);
316        while tag_directives.start != tag_directives.end {
317            yaml_free((*tag_directives.end.wrapping_offset(-1_isize)).handle as *mut libc::c_void);
318            yaml_free((*tag_directives.end.wrapping_offset(-1_isize)).prefix as *mut libc::c_void);
319            tag_directives.end = tag_directives.end.wrapping_offset(-1);
320        }
321        yaml_free(tag_directives.start as *mut libc::c_void);
322        FAIL
323    } else {
324        (*parser).state = YAML_PARSE_END_STATE;
325        memset(
326            event as *mut libc::c_void,
327            0,
328            size_of::<yaml_event_t>() as libc::c_ulong,
329        );
330        (*event).type_ = YAML_STREAM_END_EVENT;
331        (*event).start_mark = (*token).start_mark;
332        (*event).end_mark = (*token).end_mark;
333        SKIP_TOKEN(parser);
334        OK
335    }
336}
337
338unsafe fn yaml_parser_parse_document_content(
339    parser: *mut yaml_parser_t,
340    event: *mut yaml_event_t,
341) -> Success {
342    let token: *mut yaml_token_t = PEEK_TOKEN(parser);
343    if token.is_null() {
344        return FAIL;
345    }
346    if (*token).type_ == YAML_VERSION_DIRECTIVE_TOKEN
347        || (*token).type_ == YAML_TAG_DIRECTIVE_TOKEN
348        || (*token).type_ == YAML_DOCUMENT_START_TOKEN
349        || (*token).type_ == YAML_DOCUMENT_END_TOKEN
350        || (*token).type_ == YAML_STREAM_END_TOKEN
351    {
352        (*parser).state = POP!((*parser).states);
353        yaml_parser_process_empty_scalar(event, (*token).start_mark)
354    } else {
355        yaml_parser_parse_node(parser, event, true, false)
356    }
357}
358
359unsafe fn yaml_parser_parse_document_end(
360    parser: *mut yaml_parser_t,
361    event: *mut yaml_event_t,
362) -> Success {
363    let mut end_mark: yaml_mark_t;
364    let mut implicit = true;
365    let token: *mut yaml_token_t = PEEK_TOKEN(parser);
366    if token.is_null() {
367        return FAIL;
368    }
369    end_mark = (*token).start_mark;
370    let start_mark: yaml_mark_t = end_mark;
371    if (*token).type_ == YAML_DOCUMENT_END_TOKEN {
372        end_mark = (*token).end_mark;
373        SKIP_TOKEN(parser);
374        implicit = false;
375    }
376    while !STACK_EMPTY!((*parser).tag_directives) {
377        let tag_directive = POP!((*parser).tag_directives);
378        yaml_free(tag_directive.handle as *mut libc::c_void);
379        yaml_free(tag_directive.prefix as *mut libc::c_void);
380    }
381    (*parser).state = YAML_PARSE_DOCUMENT_START_STATE;
382    memset(
383        event as *mut libc::c_void,
384        0,
385        size_of::<yaml_event_t>() as libc::c_ulong,
386    );
387    (*event).type_ = YAML_DOCUMENT_END_EVENT;
388    (*event).start_mark = start_mark;
389    (*event).end_mark = end_mark;
390    (*event).data.document_end.implicit = implicit;
391    OK
392}
393
394unsafe fn yaml_parser_parse_node(
395    parser: *mut yaml_parser_t,
396    event: *mut yaml_event_t,
397    block: bool,
398    indentless_sequence: bool,
399) -> Success {
400    let mut current_block: u64;
401    let mut token: *mut yaml_token_t;
402    let mut anchor: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
403    let mut tag_handle: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
404    let mut tag_suffix: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
405    let mut tag: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
406    let mut start_mark: yaml_mark_t;
407    let mut end_mark: yaml_mark_t;
408    let mut tag_mark = yaml_mark_t {
409        index: 0,
410        line: 0,
411        column: 0,
412    };
413    let implicit;
414    token = PEEK_TOKEN(parser);
415    if token.is_null() {
416        return FAIL;
417    }
418    if (*token).type_ == YAML_ALIAS_TOKEN {
419        (*parser).state = POP!((*parser).states);
420        memset(
421            event as *mut libc::c_void,
422            0,
423            size_of::<yaml_event_t>() as libc::c_ulong,
424        );
425        (*event).type_ = YAML_ALIAS_EVENT;
426        (*event).start_mark = (*token).start_mark;
427        (*event).end_mark = (*token).end_mark;
428        let fresh26 = addr_of_mut!((*event).data.alias.anchor);
429        *fresh26 = (*token).data.alias.value;
430        SKIP_TOKEN(parser);
431        OK
432    } else {
433        end_mark = (*token).start_mark;
434        start_mark = end_mark;
435        if (*token).type_ == YAML_ANCHOR_TOKEN {
436            anchor = (*token).data.anchor.value;
437            start_mark = (*token).start_mark;
438            end_mark = (*token).end_mark;
439            SKIP_TOKEN(parser);
440            token = PEEK_TOKEN(parser);
441            if token.is_null() {
442                current_block = 17786380918591080555;
443            } else if (*token).type_ == YAML_TAG_TOKEN {
444                tag_handle = (*token).data.tag.handle;
445                tag_suffix = (*token).data.tag.suffix;
446                tag_mark = (*token).start_mark;
447                end_mark = (*token).end_mark;
448                SKIP_TOKEN(parser);
449                token = PEEK_TOKEN(parser);
450                if token.is_null() {
451                    current_block = 17786380918591080555;
452                } else {
453                    current_block = 11743904203796629665;
454                }
455            } else {
456                current_block = 11743904203796629665;
457            }
458        } else if (*token).type_ == YAML_TAG_TOKEN {
459            tag_handle = (*token).data.tag.handle;
460            tag_suffix = (*token).data.tag.suffix;
461            tag_mark = (*token).start_mark;
462            start_mark = tag_mark;
463            end_mark = (*token).end_mark;
464            SKIP_TOKEN(parser);
465            token = PEEK_TOKEN(parser);
466            if token.is_null() {
467                current_block = 17786380918591080555;
468            } else if (*token).type_ == YAML_ANCHOR_TOKEN {
469                anchor = (*token).data.anchor.value;
470                end_mark = (*token).end_mark;
471                SKIP_TOKEN(parser);
472                token = PEEK_TOKEN(parser);
473                if token.is_null() {
474                    current_block = 17786380918591080555;
475                } else {
476                    current_block = 11743904203796629665;
477                }
478            } else {
479                current_block = 11743904203796629665;
480            }
481        } else {
482            current_block = 11743904203796629665;
483        }
484        if current_block == 11743904203796629665 {
485            if !tag_handle.is_null() {
486                if *tag_handle == 0 {
487                    tag = tag_suffix;
488                    yaml_free(tag_handle as *mut libc::c_void);
489                    tag_suffix = ptr::null_mut::<yaml_char_t>();
490                    tag_handle = tag_suffix;
491                    current_block = 9437013279121998969;
492                } else {
493                    let mut tag_directive: *mut yaml_tag_directive_t;
494                    tag_directive = (*parser).tag_directives.start;
495                    loop {
496                        if !(tag_directive != (*parser).tag_directives.top) {
497                            current_block = 17728966195399430138;
498                            break;
499                        }
500                        if strcmp(
501                            (*tag_directive).handle as *mut libc::c_char,
502                            tag_handle as *mut libc::c_char,
503                        ) == 0
504                        {
505                            let prefix_len: size_t =
506                                strlen((*tag_directive).prefix as *mut libc::c_char);
507                            let suffix_len: size_t = strlen(tag_suffix as *mut libc::c_char);
508                            tag = yaml_malloc(prefix_len.force_add(suffix_len).force_add(1_u64))
509                                as *mut yaml_char_t;
510                            memcpy(
511                                tag as *mut libc::c_void,
512                                (*tag_directive).prefix as *const libc::c_void,
513                                prefix_len,
514                            );
515                            memcpy(
516                                tag.wrapping_offset(prefix_len as isize) as *mut libc::c_void,
517                                tag_suffix as *const libc::c_void,
518                                suffix_len,
519                            );
520                            *tag.wrapping_offset(prefix_len.force_add(suffix_len) as isize) = b'\0';
521                            yaml_free(tag_handle as *mut libc::c_void);
522                            yaml_free(tag_suffix as *mut libc::c_void);
523                            tag_suffix = ptr::null_mut::<yaml_char_t>();
524                            tag_handle = tag_suffix;
525                            current_block = 17728966195399430138;
526                            break;
527                        } else {
528                            tag_directive = tag_directive.wrapping_offset(1);
529                        }
530                    }
531                    if current_block != 17786380918591080555 {
532                        if tag.is_null() {
533                            yaml_parser_set_parser_error_context(
534                                parser,
535                                b"while parsing a node\0" as *const u8 as *const libc::c_char,
536                                start_mark,
537                                b"found undefined tag handle\0" as *const u8 as *const libc::c_char,
538                                tag_mark,
539                            );
540                            current_block = 17786380918591080555;
541                        } else {
542                            current_block = 9437013279121998969;
543                        }
544                    }
545                }
546            } else {
547                current_block = 9437013279121998969;
548            }
549            if current_block != 17786380918591080555 {
550                implicit = tag.is_null() || *tag == 0;
551                if indentless_sequence && (*token).type_ == YAML_BLOCK_ENTRY_TOKEN {
552                    end_mark = (*token).end_mark;
553                    (*parser).state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
554                    memset(
555                        event as *mut libc::c_void,
556                        0,
557                        size_of::<yaml_event_t>() as libc::c_ulong,
558                    );
559                    (*event).type_ = YAML_SEQUENCE_START_EVENT;
560                    (*event).start_mark = start_mark;
561                    (*event).end_mark = end_mark;
562                    let fresh37 = addr_of_mut!((*event).data.sequence_start.anchor);
563                    *fresh37 = anchor;
564                    let fresh38 = addr_of_mut!((*event).data.sequence_start.tag);
565                    *fresh38 = tag;
566                    (*event).data.sequence_start.implicit = implicit;
567                    (*event).data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;
568                    return OK;
569                } else if (*token).type_ == YAML_SCALAR_TOKEN {
570                    let mut plain_implicit = false;
571                    let mut quoted_implicit = false;
572                    end_mark = (*token).end_mark;
573                    if (*token).data.scalar.style == YAML_PLAIN_SCALAR_STYLE && tag.is_null()
574                        || !tag.is_null()
575                            && strcmp(
576                                tag as *mut libc::c_char,
577                                b"!\0" as *const u8 as *const libc::c_char,
578                            ) == 0
579                    {
580                        plain_implicit = true;
581                    } else if tag.is_null() {
582                        quoted_implicit = true;
583                    }
584                    (*parser).state = POP!((*parser).states);
585                    memset(
586                        event as *mut libc::c_void,
587                        0,
588                        size_of::<yaml_event_t>() as libc::c_ulong,
589                    );
590                    (*event).type_ = YAML_SCALAR_EVENT;
591                    (*event).start_mark = start_mark;
592                    (*event).end_mark = end_mark;
593                    let fresh40 = addr_of_mut!((*event).data.scalar.anchor);
594                    *fresh40 = anchor;
595                    let fresh41 = addr_of_mut!((*event).data.scalar.tag);
596                    *fresh41 = tag;
597                    let fresh42 = addr_of_mut!((*event).data.scalar.value);
598                    *fresh42 = (*token).data.scalar.value;
599                    (*event).data.scalar.length = (*token).data.scalar.length;
600                    (*event).data.scalar.plain_implicit = plain_implicit;
601                    (*event).data.scalar.quoted_implicit = quoted_implicit;
602                    (*event).data.scalar.style = (*token).data.scalar.style;
603                    SKIP_TOKEN(parser);
604                    return OK;
605                } else if (*token).type_ == YAML_FLOW_SEQUENCE_START_TOKEN {
606                    end_mark = (*token).end_mark;
607                    (*parser).state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
608                    memset(
609                        event as *mut libc::c_void,
610                        0,
611                        size_of::<yaml_event_t>() as libc::c_ulong,
612                    );
613                    (*event).type_ = YAML_SEQUENCE_START_EVENT;
614                    (*event).start_mark = start_mark;
615                    (*event).end_mark = end_mark;
616                    let fresh45 = addr_of_mut!((*event).data.sequence_start.anchor);
617                    *fresh45 = anchor;
618                    let fresh46 = addr_of_mut!((*event).data.sequence_start.tag);
619                    *fresh46 = tag;
620                    (*event).data.sequence_start.implicit = implicit;
621                    (*event).data.sequence_start.style = YAML_FLOW_SEQUENCE_STYLE;
622                    return OK;
623                } else if (*token).type_ == YAML_FLOW_MAPPING_START_TOKEN {
624                    end_mark = (*token).end_mark;
625                    (*parser).state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
626                    memset(
627                        event as *mut libc::c_void,
628                        0,
629                        size_of::<yaml_event_t>() as libc::c_ulong,
630                    );
631                    (*event).type_ = YAML_MAPPING_START_EVENT;
632                    (*event).start_mark = start_mark;
633                    (*event).end_mark = end_mark;
634                    let fresh47 = addr_of_mut!((*event).data.mapping_start.anchor);
635                    *fresh47 = anchor;
636                    let fresh48 = addr_of_mut!((*event).data.mapping_start.tag);
637                    *fresh48 = tag;
638                    (*event).data.mapping_start.implicit = implicit;
639                    (*event).data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;
640                    return OK;
641                } else if block && (*token).type_ == YAML_BLOCK_SEQUENCE_START_TOKEN {
642                    end_mark = (*token).end_mark;
643                    (*parser).state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
644                    memset(
645                        event as *mut libc::c_void,
646                        0,
647                        size_of::<yaml_event_t>() as libc::c_ulong,
648                    );
649                    (*event).type_ = YAML_SEQUENCE_START_EVENT;
650                    (*event).start_mark = start_mark;
651                    (*event).end_mark = end_mark;
652                    let fresh49 = addr_of_mut!((*event).data.sequence_start.anchor);
653                    *fresh49 = anchor;
654                    let fresh50 = addr_of_mut!((*event).data.sequence_start.tag);
655                    *fresh50 = tag;
656                    (*event).data.sequence_start.implicit = implicit;
657                    (*event).data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;
658                    return OK;
659                } else if block && (*token).type_ == YAML_BLOCK_MAPPING_START_TOKEN {
660                    end_mark = (*token).end_mark;
661                    (*parser).state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
662                    memset(
663                        event as *mut libc::c_void,
664                        0,
665                        size_of::<yaml_event_t>() as libc::c_ulong,
666                    );
667                    (*event).type_ = YAML_MAPPING_START_EVENT;
668                    (*event).start_mark = start_mark;
669                    (*event).end_mark = end_mark;
670                    let fresh51 = addr_of_mut!((*event).data.mapping_start.anchor);
671                    *fresh51 = anchor;
672                    let fresh52 = addr_of_mut!((*event).data.mapping_start.tag);
673                    *fresh52 = tag;
674                    (*event).data.mapping_start.implicit = implicit;
675                    (*event).data.mapping_start.style = YAML_BLOCK_MAPPING_STYLE;
676                    return OK;
677                } else if !anchor.is_null() || !tag.is_null() {
678                    let value: *mut yaml_char_t = yaml_malloc(1_u64) as *mut yaml_char_t;
679                    *value = b'\0';
680                    (*parser).state = POP!((*parser).states);
681                    memset(
682                        event as *mut libc::c_void,
683                        0,
684                        size_of::<yaml_event_t>() as libc::c_ulong,
685                    );
686                    (*event).type_ = YAML_SCALAR_EVENT;
687                    (*event).start_mark = start_mark;
688                    (*event).end_mark = end_mark;
689                    let fresh54 = addr_of_mut!((*event).data.scalar.anchor);
690                    *fresh54 = anchor;
691                    let fresh55 = addr_of_mut!((*event).data.scalar.tag);
692                    *fresh55 = tag;
693                    let fresh56 = addr_of_mut!((*event).data.scalar.value);
694                    *fresh56 = value;
695                    (*event).data.scalar.length = 0_u64;
696                    (*event).data.scalar.plain_implicit = implicit;
697                    (*event).data.scalar.quoted_implicit = false;
698                    (*event).data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
699                    return OK;
700                } else {
701                    yaml_parser_set_parser_error_context(
702                        parser,
703                        if block {
704                            b"while parsing a block node\0" as *const u8 as *const libc::c_char
705                        } else {
706                            b"while parsing a flow node\0" as *const u8 as *const libc::c_char
707                        },
708                        start_mark,
709                        b"did not find expected node content\0" as *const u8 as *const libc::c_char,
710                        (*token).start_mark,
711                    );
712                }
713            }
714        }
715        yaml_free(anchor as *mut libc::c_void);
716        yaml_free(tag_handle as *mut libc::c_void);
717        yaml_free(tag_suffix as *mut libc::c_void);
718        yaml_free(tag as *mut libc::c_void);
719        FAIL
720    }
721}
722
723unsafe fn yaml_parser_parse_block_sequence_entry(
724    parser: *mut yaml_parser_t,
725    event: *mut yaml_event_t,
726    first: bool,
727) -> Success {
728    let mut token: *mut yaml_token_t;
729    if first {
730        token = PEEK_TOKEN(parser);
731        PUSH!((*parser).marks, (*token).start_mark);
732        SKIP_TOKEN(parser);
733    }
734    token = PEEK_TOKEN(parser);
735    if token.is_null() {
736        return FAIL;
737    }
738    if (*token).type_ == YAML_BLOCK_ENTRY_TOKEN {
739        let mark: yaml_mark_t = (*token).end_mark;
740        SKIP_TOKEN(parser);
741        token = PEEK_TOKEN(parser);
742        if token.is_null() {
743            return FAIL;
744        }
745        if (*token).type_ != YAML_BLOCK_ENTRY_TOKEN && (*token).type_ != YAML_BLOCK_END_TOKEN {
746            PUSH!((*parser).states, YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE);
747            yaml_parser_parse_node(parser, event, true, false)
748        } else {
749            (*parser).state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
750            yaml_parser_process_empty_scalar(event, mark)
751        }
752    } else if (*token).type_ == YAML_BLOCK_END_TOKEN {
753        (*parser).state = POP!((*parser).states);
754        let _ = POP!((*parser).marks);
755        memset(
756            event as *mut libc::c_void,
757            0,
758            size_of::<yaml_event_t>() as libc::c_ulong,
759        );
760        (*event).type_ = YAML_SEQUENCE_END_EVENT;
761        (*event).start_mark = (*token).start_mark;
762        (*event).end_mark = (*token).end_mark;
763        SKIP_TOKEN(parser);
764        OK
765    } else {
766        yaml_parser_set_parser_error_context(
767            parser,
768            b"while parsing a block collection\0" as *const u8 as *const libc::c_char,
769            POP!((*parser).marks),
770            b"did not find expected '-' indicator\0" as *const u8 as *const libc::c_char,
771            (*token).start_mark,
772        );
773        FAIL
774    }
775}
776
777unsafe fn yaml_parser_parse_indentless_sequence_entry(
778    parser: *mut yaml_parser_t,
779    event: *mut yaml_event_t,
780) -> Success {
781    let mut token: *mut yaml_token_t;
782    token = PEEK_TOKEN(parser);
783    if token.is_null() {
784        return FAIL;
785    }
786    if (*token).type_ == YAML_BLOCK_ENTRY_TOKEN {
787        let mark: yaml_mark_t = (*token).end_mark;
788        SKIP_TOKEN(parser);
789        token = PEEK_TOKEN(parser);
790        if token.is_null() {
791            return FAIL;
792        }
793        if (*token).type_ != YAML_BLOCK_ENTRY_TOKEN
794            && (*token).type_ != YAML_KEY_TOKEN
795            && (*token).type_ != YAML_VALUE_TOKEN
796            && (*token).type_ != YAML_BLOCK_END_TOKEN
797        {
798            PUSH!((*parser).states, YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE);
799            yaml_parser_parse_node(parser, event, true, false)
800        } else {
801            (*parser).state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
802            yaml_parser_process_empty_scalar(event, mark)
803        }
804    } else {
805        (*parser).state = POP!((*parser).states);
806        memset(
807            event as *mut libc::c_void,
808            0,
809            size_of::<yaml_event_t>() as libc::c_ulong,
810        );
811        (*event).type_ = YAML_SEQUENCE_END_EVENT;
812        (*event).start_mark = (*token).start_mark;
813        (*event).end_mark = (*token).start_mark;
814        OK
815    }
816}
817
818unsafe fn yaml_parser_parse_block_mapping_key(
819    parser: *mut yaml_parser_t,
820    event: *mut yaml_event_t,
821    first: bool,
822) -> Success {
823    let mut token: *mut yaml_token_t;
824    if first {
825        token = PEEK_TOKEN(parser);
826        PUSH!((*parser).marks, (*token).start_mark);
827        SKIP_TOKEN(parser);
828    }
829    token = PEEK_TOKEN(parser);
830    if token.is_null() {
831        return FAIL;
832    }
833    if (*token).type_ == YAML_KEY_TOKEN {
834        let mark: yaml_mark_t = (*token).end_mark;
835        SKIP_TOKEN(parser);
836        token = PEEK_TOKEN(parser);
837        if token.is_null() {
838            return FAIL;
839        }
840        if (*token).type_ != YAML_KEY_TOKEN
841            && (*token).type_ != YAML_VALUE_TOKEN
842            && (*token).type_ != YAML_BLOCK_END_TOKEN
843        {
844            PUSH!((*parser).states, YAML_PARSE_BLOCK_MAPPING_VALUE_STATE);
845            yaml_parser_parse_node(parser, event, true, true)
846        } else {
847            (*parser).state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
848            yaml_parser_process_empty_scalar(event, mark)
849        }
850    } else if (*token).type_ == YAML_BLOCK_END_TOKEN {
851        (*parser).state = POP!((*parser).states);
852        let _ = POP!((*parser).marks);
853        memset(
854            event as *mut libc::c_void,
855            0,
856            size_of::<yaml_event_t>() as libc::c_ulong,
857        );
858        (*event).type_ = YAML_MAPPING_END_EVENT;
859        (*event).start_mark = (*token).start_mark;
860        (*event).end_mark = (*token).end_mark;
861        SKIP_TOKEN(parser);
862        OK
863    } else {
864        yaml_parser_set_parser_error_context(
865            parser,
866            b"while parsing a block mapping\0" as *const u8 as *const libc::c_char,
867            POP!((*parser).marks),
868            b"did not find expected key\0" as *const u8 as *const libc::c_char,
869            (*token).start_mark,
870        );
871        FAIL
872    }
873}
874
875unsafe fn yaml_parser_parse_block_mapping_value(
876    parser: *mut yaml_parser_t,
877    event: *mut yaml_event_t,
878) -> Success {
879    let mut token: *mut yaml_token_t;
880    token = PEEK_TOKEN(parser);
881    if token.is_null() {
882        return FAIL;
883    }
884    if (*token).type_ == YAML_VALUE_TOKEN {
885        let mark: yaml_mark_t = (*token).end_mark;
886        SKIP_TOKEN(parser);
887        token = PEEK_TOKEN(parser);
888        if token.is_null() {
889            return FAIL;
890        }
891        if (*token).type_ != YAML_KEY_TOKEN
892            && (*token).type_ != YAML_VALUE_TOKEN
893            && (*token).type_ != YAML_BLOCK_END_TOKEN
894        {
895            PUSH!((*parser).states, YAML_PARSE_BLOCK_MAPPING_KEY_STATE);
896            yaml_parser_parse_node(parser, event, true, true)
897        } else {
898            (*parser).state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
899            yaml_parser_process_empty_scalar(event, mark)
900        }
901    } else {
902        (*parser).state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
903        yaml_parser_process_empty_scalar(event, (*token).start_mark)
904    }
905}
906
907unsafe fn yaml_parser_parse_flow_sequence_entry(
908    parser: *mut yaml_parser_t,
909    event: *mut yaml_event_t,
910    first: bool,
911) -> Success {
912    let mut token: *mut yaml_token_t;
913    if first {
914        token = PEEK_TOKEN(parser);
915        PUSH!((*parser).marks, (*token).start_mark);
916        SKIP_TOKEN(parser);
917    }
918    token = PEEK_TOKEN(parser);
919    if token.is_null() {
920        return FAIL;
921    }
922    if (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN {
923        if !first {
924            if (*token).type_ == YAML_FLOW_ENTRY_TOKEN {
925                SKIP_TOKEN(parser);
926                token = PEEK_TOKEN(parser);
927                if token.is_null() {
928                    return FAIL;
929                }
930            } else {
931                yaml_parser_set_parser_error_context(
932                    parser,
933                    b"while parsing a flow sequence\0" as *const u8 as *const libc::c_char,
934                    POP!((*parser).marks),
935                    b"did not find expected ',' or ']'\0" as *const u8 as *const libc::c_char,
936                    (*token).start_mark,
937                );
938                return FAIL;
939            }
940        }
941        if (*token).type_ == YAML_KEY_TOKEN {
942            (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
943            memset(
944                event as *mut libc::c_void,
945                0,
946                size_of::<yaml_event_t>() as libc::c_ulong,
947            );
948            (*event).type_ = YAML_MAPPING_START_EVENT;
949            (*event).start_mark = (*token).start_mark;
950            (*event).end_mark = (*token).end_mark;
951            let fresh99 = addr_of_mut!((*event).data.mapping_start.anchor);
952            *fresh99 = ptr::null_mut::<yaml_char_t>();
953            let fresh100 = addr_of_mut!((*event).data.mapping_start.tag);
954            *fresh100 = ptr::null_mut::<yaml_char_t>();
955            (*event).data.mapping_start.implicit = true;
956            (*event).data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;
957            SKIP_TOKEN(parser);
958            return OK;
959        } else if (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN {
960            PUSH!((*parser).states, YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE);
961            return yaml_parser_parse_node(parser, event, false, false);
962        }
963    }
964    (*parser).state = POP!((*parser).states);
965    let _ = POP!((*parser).marks);
966    memset(
967        event as *mut libc::c_void,
968        0,
969        size_of::<yaml_event_t>() as libc::c_ulong,
970    );
971    (*event).type_ = YAML_SEQUENCE_END_EVENT;
972    (*event).start_mark = (*token).start_mark;
973    (*event).end_mark = (*token).end_mark;
974    SKIP_TOKEN(parser);
975    OK
976}
977
978unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_key(
979    parser: *mut yaml_parser_t,
980    event: *mut yaml_event_t,
981) -> Success {
982    let token: *mut yaml_token_t = PEEK_TOKEN(parser);
983    if token.is_null() {
984        return FAIL;
985    }
986    if (*token).type_ != YAML_VALUE_TOKEN
987        && (*token).type_ != YAML_FLOW_ENTRY_TOKEN
988        && (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN
989    {
990        PUSH!(
991            (*parser).states,
992            YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
993        );
994        yaml_parser_parse_node(parser, event, false, false)
995    } else {
996        let mark: yaml_mark_t = (*token).end_mark;
997        SKIP_TOKEN(parser);
998        (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
999        yaml_parser_process_empty_scalar(event, mark)
1000    }
1001}
1002
1003unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
1004    parser: *mut yaml_parser_t,
1005    event: *mut yaml_event_t,
1006) -> Success {
1007    let mut token: *mut yaml_token_t;
1008    token = PEEK_TOKEN(parser);
1009    if token.is_null() {
1010        return FAIL;
1011    }
1012    if (*token).type_ == YAML_VALUE_TOKEN {
1013        SKIP_TOKEN(parser);
1014        token = PEEK_TOKEN(parser);
1015        if token.is_null() {
1016            return FAIL;
1017        }
1018        if (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN
1019        {
1020            PUSH!(
1021                (*parser).states,
1022                YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
1023            );
1024            return yaml_parser_parse_node(parser, event, false, false);
1025        }
1026    }
1027    (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
1028    yaml_parser_process_empty_scalar(event, (*token).start_mark)
1029}
1030
1031unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_end(
1032    parser: *mut yaml_parser_t,
1033    event: *mut yaml_event_t,
1034) -> Success {
1035    let token: *mut yaml_token_t = PEEK_TOKEN(parser);
1036    if token.is_null() {
1037        return FAIL;
1038    }
1039    (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
1040    memset(
1041        event as *mut libc::c_void,
1042        0,
1043        size_of::<yaml_event_t>() as libc::c_ulong,
1044    );
1045    (*event).type_ = YAML_MAPPING_END_EVENT;
1046    (*event).start_mark = (*token).start_mark;
1047    (*event).end_mark = (*token).start_mark;
1048    OK
1049}
1050
1051unsafe fn yaml_parser_parse_flow_mapping_key(
1052    parser: *mut yaml_parser_t,
1053    event: *mut yaml_event_t,
1054    first: bool,
1055) -> Success {
1056    let mut token: *mut yaml_token_t;
1057    if first {
1058        token = PEEK_TOKEN(parser);
1059        PUSH!((*parser).marks, (*token).start_mark);
1060        SKIP_TOKEN(parser);
1061    }
1062    token = PEEK_TOKEN(parser);
1063    if token.is_null() {
1064        return FAIL;
1065    }
1066    if (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN {
1067        if !first {
1068            if (*token).type_ == YAML_FLOW_ENTRY_TOKEN {
1069                SKIP_TOKEN(parser);
1070                token = PEEK_TOKEN(parser);
1071                if token.is_null() {
1072                    return FAIL;
1073                }
1074            } else {
1075                yaml_parser_set_parser_error_context(
1076                    parser,
1077                    b"while parsing a flow mapping\0" as *const u8 as *const libc::c_char,
1078                    POP!((*parser).marks),
1079                    b"did not find expected ',' or '}'\0" as *const u8 as *const libc::c_char,
1080                    (*token).start_mark,
1081                );
1082                return FAIL;
1083            }
1084        }
1085        if (*token).type_ == YAML_KEY_TOKEN {
1086            SKIP_TOKEN(parser);
1087            token = PEEK_TOKEN(parser);
1088            if token.is_null() {
1089                return FAIL;
1090            }
1091            if (*token).type_ != YAML_VALUE_TOKEN
1092                && (*token).type_ != YAML_FLOW_ENTRY_TOKEN
1093                && (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN
1094            {
1095                PUSH!((*parser).states, YAML_PARSE_FLOW_MAPPING_VALUE_STATE);
1096                return yaml_parser_parse_node(parser, event, false, false);
1097            } else {
1098                (*parser).state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
1099                return yaml_parser_process_empty_scalar(event, (*token).start_mark);
1100            }
1101        } else if (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN {
1102            PUSH!((*parser).states, YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE);
1103            return yaml_parser_parse_node(parser, event, false, false);
1104        }
1105    }
1106    (*parser).state = POP!((*parser).states);
1107    let _ = POP!((*parser).marks);
1108    memset(
1109        event as *mut libc::c_void,
1110        0,
1111        size_of::<yaml_event_t>() as libc::c_ulong,
1112    );
1113    (*event).type_ = YAML_MAPPING_END_EVENT;
1114    (*event).start_mark = (*token).start_mark;
1115    (*event).end_mark = (*token).end_mark;
1116    SKIP_TOKEN(parser);
1117    OK
1118}
1119
1120unsafe fn yaml_parser_parse_flow_mapping_value(
1121    parser: *mut yaml_parser_t,
1122    event: *mut yaml_event_t,
1123    empty: bool,
1124) -> Success {
1125    let mut token: *mut yaml_token_t;
1126    token = PEEK_TOKEN(parser);
1127    if token.is_null() {
1128        return FAIL;
1129    }
1130    if empty {
1131        (*parser).state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1132        return yaml_parser_process_empty_scalar(event, (*token).start_mark);
1133    }
1134    if (*token).type_ == YAML_VALUE_TOKEN {
1135        SKIP_TOKEN(parser);
1136        token = PEEK_TOKEN(parser);
1137        if token.is_null() {
1138            return FAIL;
1139        }
1140        if (*token).type_ != YAML_FLOW_ENTRY_TOKEN && (*token).type_ != YAML_FLOW_MAPPING_END_TOKEN
1141        {
1142            PUSH!((*parser).states, YAML_PARSE_FLOW_MAPPING_KEY_STATE);
1143            return yaml_parser_parse_node(parser, event, false, false);
1144        }
1145    }
1146    (*parser).state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1147    yaml_parser_process_empty_scalar(event, (*token).start_mark)
1148}
1149
1150unsafe fn yaml_parser_process_empty_scalar(event: *mut yaml_event_t, mark: yaml_mark_t) -> Success {
1151    let value: *mut yaml_char_t = yaml_malloc(1_u64) as *mut yaml_char_t;
1152    *value = b'\0';
1153    memset(
1154        event as *mut libc::c_void,
1155        0,
1156        size_of::<yaml_event_t>() as libc::c_ulong,
1157    );
1158    (*event).type_ = YAML_SCALAR_EVENT;
1159    (*event).start_mark = mark;
1160    (*event).end_mark = mark;
1161    let fresh138 = addr_of_mut!((*event).data.scalar.anchor);
1162    *fresh138 = ptr::null_mut::<yaml_char_t>();
1163    let fresh139 = addr_of_mut!((*event).data.scalar.tag);
1164    *fresh139 = ptr::null_mut::<yaml_char_t>();
1165    let fresh140 = addr_of_mut!((*event).data.scalar.value);
1166    *fresh140 = value;
1167    (*event).data.scalar.length = 0_u64;
1168    (*event).data.scalar.plain_implicit = true;
1169    (*event).data.scalar.quoted_implicit = false;
1170    (*event).data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
1171    OK
1172}
1173
1174unsafe fn yaml_parser_process_directives(
1175    parser: *mut yaml_parser_t,
1176    version_directive_ref: *mut *mut yaml_version_directive_t,
1177    tag_directives_start_ref: *mut *mut yaml_tag_directive_t,
1178    tag_directives_end_ref: *mut *mut yaml_tag_directive_t,
1179) -> Success {
1180    let mut current_block: u64;
1181    let mut default_tag_directives: [yaml_tag_directive_t; 3] = [
1182        yaml_tag_directive_t {
1183            handle: b"!\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
1184            prefix: b"!\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
1185        },
1186        yaml_tag_directive_t {
1187            handle: b"!!\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
1188            prefix: b"tag:yaml.org,2002:\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
1189        },
1190        yaml_tag_directive_t {
1191            handle: ptr::null_mut::<yaml_char_t>(),
1192            prefix: ptr::null_mut::<yaml_char_t>(),
1193        },
1194    ];
1195    let mut default_tag_directive: *mut yaml_tag_directive_t;
1196    let mut version_directive: *mut yaml_version_directive_t =
1197        ptr::null_mut::<yaml_version_directive_t>();
1198    struct TagDirectives {
1199        start: *mut yaml_tag_directive_t,
1200        end: *mut yaml_tag_directive_t,
1201        top: *mut yaml_tag_directive_t,
1202    }
1203    let mut tag_directives = TagDirectives {
1204        start: ptr::null_mut::<yaml_tag_directive_t>(),
1205        end: ptr::null_mut::<yaml_tag_directive_t>(),
1206        top: ptr::null_mut::<yaml_tag_directive_t>(),
1207    };
1208    let mut token: *mut yaml_token_t;
1209    STACK_INIT!(tag_directives, yaml_tag_directive_t);
1210    token = PEEK_TOKEN(parser);
1211    if !token.is_null() {
1212        loop {
1213            if !((*token).type_ == YAML_VERSION_DIRECTIVE_TOKEN
1214                || (*token).type_ == YAML_TAG_DIRECTIVE_TOKEN)
1215            {
1216                current_block = 16924917904204750491;
1217                break;
1218            }
1219            if (*token).type_ == YAML_VERSION_DIRECTIVE_TOKEN {
1220                if !version_directive.is_null() {
1221                    yaml_parser_set_parser_error(
1222                        parser,
1223                        b"found duplicate %YAML directive\0" as *const u8 as *const libc::c_char,
1224                        (*token).start_mark,
1225                    );
1226                    current_block = 17143798186130252483;
1227                    break;
1228                } else if (*token).data.version_directive.major != 1
1229                    || (*token).data.version_directive.minor != 1
1230                        && (*token).data.version_directive.minor != 2
1231                {
1232                    yaml_parser_set_parser_error(
1233                        parser,
1234                        b"found incompatible YAML document\0" as *const u8 as *const libc::c_char,
1235                        (*token).start_mark,
1236                    );
1237                    current_block = 17143798186130252483;
1238                    break;
1239                } else {
1240                    version_directive =
1241                        yaml_malloc(size_of::<yaml_version_directive_t>() as libc::c_ulong)
1242                            as *mut yaml_version_directive_t;
1243                    (*version_directive).major = (*token).data.version_directive.major;
1244                    (*version_directive).minor = (*token).data.version_directive.minor;
1245                }
1246            } else if (*token).type_ == YAML_TAG_DIRECTIVE_TOKEN {
1247                let value = yaml_tag_directive_t {
1248                    handle: (*token).data.tag_directive.handle,
1249                    prefix: (*token).data.tag_directive.prefix,
1250                };
1251                if yaml_parser_append_tag_directive(parser, value, false, (*token).start_mark).fail
1252                {
1253                    current_block = 17143798186130252483;
1254                    break;
1255                }
1256                PUSH!(tag_directives, value);
1257            }
1258            SKIP_TOKEN(parser);
1259            token = PEEK_TOKEN(parser);
1260            if token.is_null() {
1261                current_block = 17143798186130252483;
1262                break;
1263            }
1264        }
1265        if current_block != 17143798186130252483 {
1266            default_tag_directive = default_tag_directives.as_mut_ptr();
1267            loop {
1268                if (*default_tag_directive).handle.is_null() {
1269                    current_block = 18377268871191777778;
1270                    break;
1271                }
1272                if yaml_parser_append_tag_directive(
1273                    parser,
1274                    *default_tag_directive,
1275                    true,
1276                    (*token).start_mark,
1277                )
1278                .fail
1279                {
1280                    current_block = 17143798186130252483;
1281                    break;
1282                }
1283                default_tag_directive = default_tag_directive.wrapping_offset(1);
1284            }
1285            if current_block != 17143798186130252483 {
1286                if !version_directive_ref.is_null() {
1287                    *version_directive_ref = version_directive;
1288                }
1289                if !tag_directives_start_ref.is_null() {
1290                    if STACK_EMPTY!(tag_directives) {
1291                        *tag_directives_end_ref = ptr::null_mut::<yaml_tag_directive_t>();
1292                        *tag_directives_start_ref = *tag_directives_end_ref;
1293                        STACK_DEL!(tag_directives);
1294                    } else {
1295                        *tag_directives_start_ref = tag_directives.start;
1296                        *tag_directives_end_ref = tag_directives.top;
1297                    }
1298                } else {
1299                    STACK_DEL!(tag_directives);
1300                }
1301                if version_directive_ref.is_null() {
1302                    yaml_free(version_directive as *mut libc::c_void);
1303                }
1304                return OK;
1305            }
1306        }
1307    }
1308    yaml_free(version_directive as *mut libc::c_void);
1309    while !STACK_EMPTY!(tag_directives) {
1310        let tag_directive = POP!(tag_directives);
1311        yaml_free(tag_directive.handle as *mut libc::c_void);
1312        yaml_free(tag_directive.prefix as *mut libc::c_void);
1313    }
1314    STACK_DEL!(tag_directives);
1315    FAIL
1316}
1317
1318unsafe fn yaml_parser_append_tag_directive(
1319    parser: *mut yaml_parser_t,
1320    value: yaml_tag_directive_t,
1321    allow_duplicates: bool,
1322    mark: yaml_mark_t,
1323) -> Success {
1324    let mut tag_directive: *mut yaml_tag_directive_t;
1325    let mut copy = yaml_tag_directive_t {
1326        handle: ptr::null_mut::<yaml_char_t>(),
1327        prefix: ptr::null_mut::<yaml_char_t>(),
1328    };
1329    tag_directive = (*parser).tag_directives.start;
1330    while tag_directive != (*parser).tag_directives.top {
1331        if strcmp(
1332            value.handle as *mut libc::c_char,
1333            (*tag_directive).handle as *mut libc::c_char,
1334        ) == 0
1335        {
1336            if allow_duplicates {
1337                return OK;
1338            }
1339            yaml_parser_set_parser_error(
1340                parser,
1341                b"found duplicate %TAG directive\0" as *const u8 as *const libc::c_char,
1342                mark,
1343            );
1344            return FAIL;
1345        }
1346        tag_directive = tag_directive.wrapping_offset(1);
1347    }
1348    copy.handle = yaml_strdup(value.handle);
1349    copy.prefix = yaml_strdup(value.prefix);
1350    PUSH!((*parser).tag_directives, copy);
1351    OK
1352}
unsafe_libyaml/parser.rs

unsafe_libyaml/
parser.rs
