1 use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};
2 use crate::externs::{memcpy, memset, strcmp, strlen};
3 use crate::ops::ForceAdd as _;
4 use crate::scanner::yaml_parser_fetch_more_tokens;
5 use crate::success::{Success, FAIL, OK};
6 use crate::yaml::{size_t, yaml_char_t};
7 use 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 };
34 use core::mem::size_of;
35 use core::ptr::{self, addr_of_mut};
36
PEEK_TOKEN(parser: *mut yaml_parser_t) -> *mut yaml_token_t37 unsafe 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
SKIP_TOKEN(parser: *mut yaml_parser_t)45 unsafe 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.
yaml_parser_parse(parser: *mut yaml_parser_t, event: *mut yaml_event_t) -> Success66 pub 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
yaml_parser_set_parser_error( parser: *mut yaml_parser_t, problem: *const libc::c_char, problem_mark: yaml_mark_t, )83 unsafe 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
yaml_parser_set_parser_error_context( parser: *mut yaml_parser_t, context: *const libc::c_char, context_mark: yaml_mark_t, problem: *const libc::c_char, problem_mark: yaml_mark_t, )94 unsafe 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
yaml_parser_state_machine( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success110 unsafe 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
yaml_parser_parse_stream_start( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success176 unsafe 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
yaml_parser_parse_document_start( parser: *mut yaml_parser_t, event: *mut yaml_event_t, implicit: bool, ) -> Success206 unsafe 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
yaml_parser_parse_document_content( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success338 unsafe 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
yaml_parser_parse_document_end( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success359 unsafe 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
yaml_parser_parse_node( parser: *mut yaml_parser_t, event: *mut yaml_event_t, block: bool, indentless_sequence: bool, ) -> Success394 unsafe 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
yaml_parser_parse_block_sequence_entry( parser: *mut yaml_parser_t, event: *mut yaml_event_t, first: bool, ) -> Success723 unsafe 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
yaml_parser_parse_indentless_sequence_entry( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success777 unsafe 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
yaml_parser_parse_block_mapping_key( parser: *mut yaml_parser_t, event: *mut yaml_event_t, first: bool, ) -> Success818 unsafe 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
yaml_parser_parse_block_mapping_value( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success875 unsafe 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
yaml_parser_parse_flow_sequence_entry( parser: *mut yaml_parser_t, event: *mut yaml_event_t, first: bool, ) -> Success907 unsafe 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
yaml_parser_parse_flow_sequence_entry_mapping_key( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success978 unsafe 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
yaml_parser_parse_flow_sequence_entry_mapping_value( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success1003 unsafe 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
yaml_parser_parse_flow_sequence_entry_mapping_end( parser: *mut yaml_parser_t, event: *mut yaml_event_t, ) -> Success1031 unsafe 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
yaml_parser_parse_flow_mapping_key( parser: *mut yaml_parser_t, event: *mut yaml_event_t, first: bool, ) -> Success1051 unsafe 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
yaml_parser_parse_flow_mapping_value( parser: *mut yaml_parser_t, event: *mut yaml_event_t, empty: bool, ) -> Success1120 unsafe 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
yaml_parser_process_empty_scalar(event: *mut yaml_event_t, mark: yaml_mark_t) -> Success1150 unsafe 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
yaml_parser_process_directives( parser: *mut yaml_parser_t, version_directive_ref: *mut *mut yaml_version_directive_t, tag_directives_start_ref: *mut *mut yaml_tag_directive_t, tag_directives_end_ref: *mut *mut yaml_tag_directive_t, ) -> Success1174 unsafe 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
yaml_parser_append_tag_directive( parser: *mut yaml_parser_t, value: yaml_tag_directive_t, allow_duplicates: bool, mark: yaml_mark_t, ) -> Success1318 unsafe 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 }
1353