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