1 use crate::api::{
2 yaml_free, yaml_malloc, yaml_queue_extend, yaml_stack_extend, yaml_string_extend,
3 yaml_string_join,
4 };
5 use crate::externs::{memcpy, memmove, memset, strcmp, strlen};
6 use crate::ops::{ForceAdd as _, ForceMul as _};
7 use crate::reader::yaml_parser_update_buffer;
8 use crate::success::{Success, FAIL, OK};
9 use crate::yaml::{ptrdiff_t, size_t, yaml_char_t, yaml_string_t, NULL_STRING};
10 use crate::{
11 libc, yaml_mark_t, yaml_parser_t, yaml_simple_key_t, yaml_token_t, yaml_token_type_t,
12 PointerExt, YAML_ALIAS_TOKEN, YAML_ANCHOR_TOKEN, YAML_BLOCK_END_TOKEN, YAML_BLOCK_ENTRY_TOKEN,
13 YAML_BLOCK_MAPPING_START_TOKEN, YAML_BLOCK_SEQUENCE_START_TOKEN, YAML_DOCUMENT_END_TOKEN,
14 YAML_DOCUMENT_START_TOKEN, YAML_DOUBLE_QUOTED_SCALAR_STYLE, YAML_FLOW_ENTRY_TOKEN,
15 YAML_FLOW_MAPPING_END_TOKEN, YAML_FLOW_MAPPING_START_TOKEN, YAML_FLOW_SEQUENCE_END_TOKEN,
16 YAML_FLOW_SEQUENCE_START_TOKEN, YAML_FOLDED_SCALAR_STYLE, YAML_KEY_TOKEN,
17 YAML_LITERAL_SCALAR_STYLE, YAML_MEMORY_ERROR, YAML_NO_ERROR, YAML_PLAIN_SCALAR_STYLE,
18 YAML_SCALAR_TOKEN, YAML_SCANNER_ERROR, YAML_SINGLE_QUOTED_SCALAR_STYLE, YAML_STREAM_END_TOKEN,
19 YAML_STREAM_START_TOKEN, YAML_TAG_DIRECTIVE_TOKEN, YAML_TAG_TOKEN, YAML_VALUE_TOKEN,
20 YAML_VERSION_DIRECTIVE_TOKEN,
21 };
22 use core::mem::{size_of, MaybeUninit};
23 use core::ptr::{self, addr_of_mut};
24
CACHE(parser: *mut yaml_parser_t, length: size_t) -> Success25 unsafe fn CACHE(parser: *mut yaml_parser_t, length: size_t) -> Success {
26 if (*parser).unread >= length {
27 OK
28 } else {
29 yaml_parser_update_buffer(parser, length)
30 }
31 }
32
SKIP(parser: *mut yaml_parser_t)33 unsafe fn SKIP(parser: *mut yaml_parser_t) {
34 let width = WIDTH!((*parser).buffer);
35 (*parser).mark.index = (*parser).mark.index.force_add(width as u64);
36 (*parser).mark.column = (*parser).mark.column.force_add(1);
37 (*parser).unread = (*parser).unread.wrapping_sub(1);
38 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(width as isize);
39 }
40
SKIP_LINE(parser: *mut yaml_parser_t)41 unsafe fn SKIP_LINE(parser: *mut yaml_parser_t) {
42 if IS_CRLF!((*parser).buffer) {
43 (*parser).mark.index = (*parser).mark.index.force_add(2);
44 (*parser).mark.column = 0;
45 (*parser).mark.line = (*parser).mark.line.force_add(1);
46 (*parser).unread = (*parser).unread.wrapping_sub(2);
47 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(2);
48 } else if IS_BREAK!((*parser).buffer) {
49 let width = WIDTH!((*parser).buffer);
50 (*parser).mark.index = (*parser).mark.index.force_add(width as u64);
51 (*parser).mark.column = 0;
52 (*parser).mark.line = (*parser).mark.line.force_add(1);
53 (*parser).unread = (*parser).unread.wrapping_sub(1);
54 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(width as isize);
55 };
56 }
57
READ(parser: *mut yaml_parser_t, string: *mut yaml_string_t)58 unsafe fn READ(parser: *mut yaml_parser_t, string: *mut yaml_string_t) {
59 STRING_EXTEND!(*string);
60 let width = WIDTH!((*parser).buffer);
61 COPY!(*string, (*parser).buffer);
62 (*parser).mark.index = (*parser).mark.index.force_add(width as u64);
63 (*parser).mark.column = (*parser).mark.column.force_add(1);
64 (*parser).unread = (*parser).unread.wrapping_sub(1);
65 }
66
READ_LINE(parser: *mut yaml_parser_t, string: *mut yaml_string_t)67 unsafe fn READ_LINE(parser: *mut yaml_parser_t, string: *mut yaml_string_t) {
68 STRING_EXTEND!(*string);
69 if CHECK_AT!((*parser).buffer, b'\r', 0) && CHECK_AT!((*parser).buffer, b'\n', 1) {
70 *(*string).pointer = b'\n';
71 (*string).pointer = (*string).pointer.wrapping_offset(1);
72 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(2);
73 (*parser).mark.index = (*parser).mark.index.force_add(2);
74 (*parser).mark.column = 0;
75 (*parser).mark.line = (*parser).mark.line.force_add(1);
76 (*parser).unread = (*parser).unread.wrapping_sub(2);
77 } else if CHECK_AT!((*parser).buffer, b'\r', 0) || CHECK_AT!((*parser).buffer, b'\n', 0) {
78 *(*string).pointer = b'\n';
79 (*string).pointer = (*string).pointer.wrapping_offset(1);
80 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(1);
81 (*parser).mark.index = (*parser).mark.index.force_add(1);
82 (*parser).mark.column = 0;
83 (*parser).mark.line = (*parser).mark.line.force_add(1);
84 (*parser).unread = (*parser).unread.wrapping_sub(1);
85 } else if CHECK_AT!((*parser).buffer, b'\xC2', 0) && CHECK_AT!((*parser).buffer, b'\x85', 1) {
86 *(*string).pointer = b'\n';
87 (*string).pointer = (*string).pointer.wrapping_offset(1);
88 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(2);
89 (*parser).mark.index = (*parser).mark.index.force_add(2);
90 (*parser).mark.column = 0;
91 (*parser).mark.line = (*parser).mark.line.force_add(1);
92 (*parser).unread = (*parser).unread.wrapping_sub(1);
93 } else if CHECK_AT!((*parser).buffer, b'\xE2', 0)
94 && CHECK_AT!((*parser).buffer, b'\x80', 1)
95 && (CHECK_AT!((*parser).buffer, b'\xA8', 2) || CHECK_AT!((*parser).buffer, b'\xA9', 2))
96 {
97 *(*string).pointer = *(*parser).buffer.pointer;
98 (*string).pointer = (*string).pointer.wrapping_offset(1);
99 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(1);
100 *(*string).pointer = *(*parser).buffer.pointer;
101 (*string).pointer = (*string).pointer.wrapping_offset(1);
102 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(1);
103 *(*string).pointer = *(*parser).buffer.pointer;
104 (*string).pointer = (*string).pointer.wrapping_offset(1);
105 (*parser).buffer.pointer = (*parser).buffer.pointer.wrapping_offset(1);
106 (*parser).mark.index = (*parser).mark.index.force_add(3);
107 (*parser).mark.column = 0;
108 (*parser).mark.line = (*parser).mark.line.force_add(1);
109 (*parser).unread = (*parser).unread.wrapping_sub(1);
110 };
111 }
112
113 macro_rules! READ {
114 ($parser:expr, $string:expr) => {
115 READ($parser, addr_of_mut!($string))
116 };
117 }
118
119 macro_rules! READ_LINE {
120 ($parser:expr, $string:expr) => {
121 READ_LINE($parser, addr_of_mut!($string))
122 };
123 }
124
125 /// Scan the input stream and produce the next token.
126 ///
127 /// Call the function subsequently to produce a sequence of tokens corresponding
128 /// to the input stream. The initial token has the type YAML_STREAM_START_TOKEN
129 /// while the ending token has the type YAML_STREAM_END_TOKEN.
130 ///
131 /// An application is responsible for freeing any buffers associated with the
132 /// produced token object using the yaml_token_delete function.
133 ///
134 /// An application must not alternate the calls of yaml_parser_scan() with the
135 /// calls of yaml_parser_parse() or yaml_parser_load(). Doing this will break
136 /// the parser.
yaml_parser_scan(parser: *mut yaml_parser_t, token: *mut yaml_token_t) -> Success137 pub unsafe fn yaml_parser_scan(parser: *mut yaml_parser_t, token: *mut yaml_token_t) -> Success {
138 __assert!(!parser.is_null());
139 __assert!(!token.is_null());
140 memset(
141 token as *mut libc::c_void,
142 0,
143 size_of::<yaml_token_t>() as libc::c_ulong,
144 );
145 if (*parser).stream_end_produced || (*parser).error != YAML_NO_ERROR {
146 return OK;
147 }
148 if !(*parser).token_available {
149 if yaml_parser_fetch_more_tokens(parser).fail {
150 return FAIL;
151 }
152 }
153 *token = DEQUEUE!((*parser).tokens);
154 (*parser).token_available = false;
155 let fresh2 = addr_of_mut!((*parser).tokens_parsed);
156 *fresh2 = (*fresh2).force_add(1);
157 if (*token).type_ == YAML_STREAM_END_TOKEN {
158 (*parser).stream_end_produced = true;
159 }
160 OK
161 }
162
yaml_parser_set_scanner_error( parser: *mut yaml_parser_t, context: *const libc::c_char, context_mark: yaml_mark_t, problem: *const libc::c_char, )163 unsafe fn yaml_parser_set_scanner_error(
164 parser: *mut yaml_parser_t,
165 context: *const libc::c_char,
166 context_mark: yaml_mark_t,
167 problem: *const libc::c_char,
168 ) {
169 (*parser).error = YAML_SCANNER_ERROR;
170 let fresh3 = addr_of_mut!((*parser).context);
171 *fresh3 = context;
172 (*parser).context_mark = context_mark;
173 let fresh4 = addr_of_mut!((*parser).problem);
174 *fresh4 = problem;
175 (*parser).problem_mark = (*parser).mark;
176 }
177
yaml_parser_fetch_more_tokens(parser: *mut yaml_parser_t) -> Success178 pub(crate) unsafe fn yaml_parser_fetch_more_tokens(parser: *mut yaml_parser_t) -> Success {
179 let mut need_more_tokens;
180 loop {
181 need_more_tokens = false;
182 if (*parser).tokens.head == (*parser).tokens.tail {
183 need_more_tokens = true;
184 } else {
185 let mut simple_key: *mut yaml_simple_key_t;
186 if yaml_parser_stale_simple_keys(parser).fail {
187 return FAIL;
188 }
189 simple_key = (*parser).simple_keys.start;
190 while simple_key != (*parser).simple_keys.top {
191 if (*simple_key).possible && (*simple_key).token_number == (*parser).tokens_parsed {
192 need_more_tokens = true;
193 break;
194 } else {
195 simple_key = simple_key.wrapping_offset(1);
196 }
197 }
198 }
199 if !need_more_tokens {
200 break;
201 }
202 if yaml_parser_fetch_next_token(parser).fail {
203 return FAIL;
204 }
205 }
206 (*parser).token_available = true;
207 OK
208 }
209
yaml_parser_fetch_next_token(parser: *mut yaml_parser_t) -> Success210 unsafe fn yaml_parser_fetch_next_token(parser: *mut yaml_parser_t) -> Success {
211 if CACHE(parser, 1_u64).fail {
212 return FAIL;
213 }
214 if !(*parser).stream_start_produced {
215 yaml_parser_fetch_stream_start(parser);
216 return OK;
217 }
218 if yaml_parser_scan_to_next_token(parser).fail {
219 return FAIL;
220 }
221 if yaml_parser_stale_simple_keys(parser).fail {
222 return FAIL;
223 }
224 yaml_parser_unroll_indent(parser, (*parser).mark.column as ptrdiff_t);
225 if CACHE(parser, 4_u64).fail {
226 return FAIL;
227 }
228 if IS_Z!((*parser).buffer) {
229 return yaml_parser_fetch_stream_end(parser);
230 }
231 if (*parser).mark.column == 0_u64 && CHECK!((*parser).buffer, b'%') {
232 return yaml_parser_fetch_directive(parser);
233 }
234 if (*parser).mark.column == 0_u64
235 && CHECK_AT!((*parser).buffer, b'-', 0)
236 && CHECK_AT!((*parser).buffer, b'-', 1)
237 && CHECK_AT!((*parser).buffer, b'-', 2)
238 && IS_BLANKZ_AT!((*parser).buffer, 3)
239 {
240 return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_START_TOKEN);
241 }
242 if (*parser).mark.column == 0_u64
243 && CHECK_AT!((*parser).buffer, b'.', 0)
244 && CHECK_AT!((*parser).buffer, b'.', 1)
245 && CHECK_AT!((*parser).buffer, b'.', 2)
246 && IS_BLANKZ_AT!((*parser).buffer, 3)
247 {
248 return yaml_parser_fetch_document_indicator(parser, YAML_DOCUMENT_END_TOKEN);
249 }
250 if CHECK!((*parser).buffer, b'[') {
251 return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_SEQUENCE_START_TOKEN);
252 }
253 if CHECK!((*parser).buffer, b'{') {
254 return yaml_parser_fetch_flow_collection_start(parser, YAML_FLOW_MAPPING_START_TOKEN);
255 }
256 if CHECK!((*parser).buffer, b']') {
257 return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_SEQUENCE_END_TOKEN);
258 }
259 if CHECK!((*parser).buffer, b'}') {
260 return yaml_parser_fetch_flow_collection_end(parser, YAML_FLOW_MAPPING_END_TOKEN);
261 }
262 if CHECK!((*parser).buffer, b',') {
263 return yaml_parser_fetch_flow_entry(parser);
264 }
265 if CHECK!((*parser).buffer, b'-') && IS_BLANKZ_AT!((*parser).buffer, 1) {
266 return yaml_parser_fetch_block_entry(parser);
267 }
268 if CHECK!((*parser).buffer, b'?')
269 && ((*parser).flow_level != 0 || IS_BLANKZ_AT!((*parser).buffer, 1))
270 {
271 return yaml_parser_fetch_key(parser);
272 }
273 if CHECK!((*parser).buffer, b':')
274 && ((*parser).flow_level != 0 || IS_BLANKZ_AT!((*parser).buffer, 1))
275 {
276 return yaml_parser_fetch_value(parser);
277 }
278 if CHECK!((*parser).buffer, b'*') {
279 return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN);
280 }
281 if CHECK!((*parser).buffer, b'&') {
282 return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN);
283 }
284 if CHECK!((*parser).buffer, b'!') {
285 return yaml_parser_fetch_tag(parser);
286 }
287 if CHECK!((*parser).buffer, b'|') && (*parser).flow_level == 0 {
288 return yaml_parser_fetch_block_scalar(parser, true);
289 }
290 if CHECK!((*parser).buffer, b'>') && (*parser).flow_level == 0 {
291 return yaml_parser_fetch_block_scalar(parser, false);
292 }
293 if CHECK!((*parser).buffer, b'\'') {
294 return yaml_parser_fetch_flow_scalar(parser, true);
295 }
296 if CHECK!((*parser).buffer, b'"') {
297 return yaml_parser_fetch_flow_scalar(parser, false);
298 }
299 if !(IS_BLANKZ!((*parser).buffer)
300 || CHECK!((*parser).buffer, b'-')
301 || CHECK!((*parser).buffer, b'?')
302 || CHECK!((*parser).buffer, b':')
303 || CHECK!((*parser).buffer, b',')
304 || CHECK!((*parser).buffer, b'[')
305 || CHECK!((*parser).buffer, b']')
306 || CHECK!((*parser).buffer, b'{')
307 || CHECK!((*parser).buffer, b'}')
308 || CHECK!((*parser).buffer, b'#')
309 || CHECK!((*parser).buffer, b'&')
310 || CHECK!((*parser).buffer, b'*')
311 || CHECK!((*parser).buffer, b'!')
312 || CHECK!((*parser).buffer, b'|')
313 || CHECK!((*parser).buffer, b'>')
314 || CHECK!((*parser).buffer, b'\'')
315 || CHECK!((*parser).buffer, b'"')
316 || CHECK!((*parser).buffer, b'%')
317 || CHECK!((*parser).buffer, b'@')
318 || CHECK!((*parser).buffer, b'`'))
319 || CHECK!((*parser).buffer, b'-') && !IS_BLANK_AT!((*parser).buffer, 1)
320 || (*parser).flow_level == 0
321 && (CHECK!((*parser).buffer, b'?') || CHECK!((*parser).buffer, b':'))
322 && !IS_BLANKZ_AT!((*parser).buffer, 1)
323 {
324 return yaml_parser_fetch_plain_scalar(parser);
325 }
326 yaml_parser_set_scanner_error(
327 parser,
328 b"while scanning for the next token\0" as *const u8 as *const libc::c_char,
329 (*parser).mark,
330 b"found character that cannot start any token\0" as *const u8 as *const libc::c_char,
331 );
332 FAIL
333 }
334
yaml_parser_stale_simple_keys(parser: *mut yaml_parser_t) -> Success335 unsafe fn yaml_parser_stale_simple_keys(parser: *mut yaml_parser_t) -> Success {
336 let mut simple_key: *mut yaml_simple_key_t;
337 simple_key = (*parser).simple_keys.start;
338 while simple_key != (*parser).simple_keys.top {
339 if (*simple_key).possible
340 && ((*simple_key).mark.line < (*parser).mark.line
341 || (*simple_key).mark.index.force_add(1024_u64) < (*parser).mark.index)
342 {
343 if (*simple_key).required {
344 yaml_parser_set_scanner_error(
345 parser,
346 b"while scanning a simple key\0" as *const u8 as *const libc::c_char,
347 (*simple_key).mark,
348 b"could not find expected ':'\0" as *const u8 as *const libc::c_char,
349 );
350 return FAIL;
351 }
352 (*simple_key).possible = false;
353 }
354 simple_key = simple_key.wrapping_offset(1);
355 }
356 OK
357 }
358
yaml_parser_save_simple_key(parser: *mut yaml_parser_t) -> Success359 unsafe fn yaml_parser_save_simple_key(parser: *mut yaml_parser_t) -> Success {
360 let required = (*parser).flow_level == 0
361 && (*parser).indent as libc::c_long == (*parser).mark.column as ptrdiff_t;
362 if (*parser).simple_key_allowed {
363 let simple_key = yaml_simple_key_t {
364 possible: true,
365 required,
366 token_number: (*parser).tokens_parsed.force_add(
367 (*parser).tokens.tail.c_offset_from((*parser).tokens.head) as libc::c_ulong,
368 ),
369 mark: (*parser).mark,
370 };
371 if yaml_parser_remove_simple_key(parser).fail {
372 return FAIL;
373 }
374 *(*parser).simple_keys.top.wrapping_offset(-1_isize) = simple_key;
375 }
376 OK
377 }
378
yaml_parser_remove_simple_key(parser: *mut yaml_parser_t) -> Success379 unsafe fn yaml_parser_remove_simple_key(parser: *mut yaml_parser_t) -> Success {
380 let simple_key: *mut yaml_simple_key_t = (*parser).simple_keys.top.wrapping_offset(-1_isize);
381 if (*simple_key).possible {
382 if (*simple_key).required {
383 yaml_parser_set_scanner_error(
384 parser,
385 b"while scanning a simple key\0" as *const u8 as *const libc::c_char,
386 (*simple_key).mark,
387 b"could not find expected ':'\0" as *const u8 as *const libc::c_char,
388 );
389 return FAIL;
390 }
391 }
392 (*simple_key).possible = false;
393 OK
394 }
395
yaml_parser_increase_flow_level(parser: *mut yaml_parser_t) -> Success396 unsafe fn yaml_parser_increase_flow_level(parser: *mut yaml_parser_t) -> Success {
397 let empty_simple_key = yaml_simple_key_t {
398 possible: false,
399 required: false,
400 token_number: 0_u64,
401 mark: yaml_mark_t {
402 index: 0_u64,
403 line: 0_u64,
404 column: 0_u64,
405 },
406 };
407 PUSH!((*parser).simple_keys, empty_simple_key);
408 if (*parser).flow_level == libc::c_int::MAX {
409 (*parser).error = YAML_MEMORY_ERROR;
410 return FAIL;
411 }
412 let fresh7 = addr_of_mut!((*parser).flow_level);
413 *fresh7 += 1;
414 OK
415 }
416
yaml_parser_decrease_flow_level(parser: *mut yaml_parser_t)417 unsafe fn yaml_parser_decrease_flow_level(parser: *mut yaml_parser_t) {
418 if (*parser).flow_level != 0 {
419 let fresh8 = addr_of_mut!((*parser).flow_level);
420 *fresh8 -= 1;
421 let _ = POP!((*parser).simple_keys);
422 }
423 }
424
yaml_parser_roll_indent( parser: *mut yaml_parser_t, column: ptrdiff_t, number: ptrdiff_t, type_: yaml_token_type_t, mark: yaml_mark_t, ) -> Success425 unsafe fn yaml_parser_roll_indent(
426 parser: *mut yaml_parser_t,
427 column: ptrdiff_t,
428 number: ptrdiff_t,
429 type_: yaml_token_type_t,
430 mark: yaml_mark_t,
431 ) -> Success {
432 let mut token = MaybeUninit::<yaml_token_t>::uninit();
433 let token = token.as_mut_ptr();
434 if (*parser).flow_level != 0 {
435 return OK;
436 }
437 if ((*parser).indent as libc::c_long) < column {
438 PUSH!((*parser).indents, (*parser).indent);
439 if column > ptrdiff_t::from(libc::c_int::MAX) {
440 (*parser).error = YAML_MEMORY_ERROR;
441 return FAIL;
442 }
443 (*parser).indent = column as libc::c_int;
444 memset(
445 token as *mut libc::c_void,
446 0,
447 size_of::<yaml_token_t>() as libc::c_ulong,
448 );
449 (*token).type_ = type_;
450 (*token).start_mark = mark;
451 (*token).end_mark = mark;
452 if number == -1_i64 {
453 ENQUEUE!((*parser).tokens, *token);
454 } else {
455 QUEUE_INSERT!(
456 (*parser).tokens,
457 (number as libc::c_ulong).wrapping_sub((*parser).tokens_parsed),
458 *token
459 );
460 }
461 }
462 OK
463 }
464
yaml_parser_unroll_indent(parser: *mut yaml_parser_t, column: ptrdiff_t)465 unsafe fn yaml_parser_unroll_indent(parser: *mut yaml_parser_t, column: ptrdiff_t) {
466 let mut token = MaybeUninit::<yaml_token_t>::uninit();
467 let token = token.as_mut_ptr();
468 if (*parser).flow_level != 0 {
469 return;
470 }
471 while (*parser).indent as libc::c_long > column {
472 memset(
473 token as *mut libc::c_void,
474 0,
475 size_of::<yaml_token_t>() as libc::c_ulong,
476 );
477 (*token).type_ = YAML_BLOCK_END_TOKEN;
478 (*token).start_mark = (*parser).mark;
479 (*token).end_mark = (*parser).mark;
480 ENQUEUE!((*parser).tokens, *token);
481 (*parser).indent = POP!((*parser).indents);
482 }
483 }
484
yaml_parser_fetch_stream_start(parser: *mut yaml_parser_t)485 unsafe fn yaml_parser_fetch_stream_start(parser: *mut yaml_parser_t) {
486 let simple_key = yaml_simple_key_t {
487 possible: false,
488 required: false,
489 token_number: 0_u64,
490 mark: yaml_mark_t {
491 index: 0_u64,
492 line: 0_u64,
493 column: 0_u64,
494 },
495 };
496 let mut token = MaybeUninit::<yaml_token_t>::uninit();
497 let token = token.as_mut_ptr();
498 (*parser).indent = -1;
499 PUSH!((*parser).simple_keys, simple_key);
500 (*parser).simple_key_allowed = true;
501 (*parser).stream_start_produced = true;
502 memset(
503 token as *mut libc::c_void,
504 0,
505 size_of::<yaml_token_t>() as libc::c_ulong,
506 );
507 (*token).type_ = YAML_STREAM_START_TOKEN;
508 (*token).start_mark = (*parser).mark;
509 (*token).end_mark = (*parser).mark;
510 (*token).data.stream_start.encoding = (*parser).encoding;
511 ENQUEUE!((*parser).tokens, *token);
512 }
513
yaml_parser_fetch_stream_end(parser: *mut yaml_parser_t) -> Success514 unsafe fn yaml_parser_fetch_stream_end(parser: *mut yaml_parser_t) -> Success {
515 let mut token = MaybeUninit::<yaml_token_t>::uninit();
516 let token = token.as_mut_ptr();
517 if (*parser).mark.column != 0_u64 {
518 (*parser).mark.column = 0_u64;
519 let fresh22 = addr_of_mut!((*parser).mark.line);
520 *fresh22 = (*fresh22).force_add(1);
521 }
522 yaml_parser_unroll_indent(parser, -1_i64);
523 if yaml_parser_remove_simple_key(parser).fail {
524 return FAIL;
525 }
526 (*parser).simple_key_allowed = false;
527 memset(
528 token as *mut libc::c_void,
529 0,
530 size_of::<yaml_token_t>() as libc::c_ulong,
531 );
532 (*token).type_ = YAML_STREAM_END_TOKEN;
533 (*token).start_mark = (*parser).mark;
534 (*token).end_mark = (*parser).mark;
535 ENQUEUE!((*parser).tokens, *token);
536 OK
537 }
538
yaml_parser_fetch_directive(parser: *mut yaml_parser_t) -> Success539 unsafe fn yaml_parser_fetch_directive(parser: *mut yaml_parser_t) -> Success {
540 let mut token = MaybeUninit::<yaml_token_t>::uninit();
541 let token = token.as_mut_ptr();
542 yaml_parser_unroll_indent(parser, -1_i64);
543 if yaml_parser_remove_simple_key(parser).fail {
544 return FAIL;
545 }
546 (*parser).simple_key_allowed = false;
547 if yaml_parser_scan_directive(parser, token).fail {
548 return FAIL;
549 }
550 ENQUEUE!((*parser).tokens, *token);
551 OK
552 }
553
yaml_parser_fetch_document_indicator( parser: *mut yaml_parser_t, type_: yaml_token_type_t, ) -> Success554 unsafe fn yaml_parser_fetch_document_indicator(
555 parser: *mut yaml_parser_t,
556 type_: yaml_token_type_t,
557 ) -> Success {
558 let mut token = MaybeUninit::<yaml_token_t>::uninit();
559 let token = token.as_mut_ptr();
560 yaml_parser_unroll_indent(parser, -1_i64);
561 if yaml_parser_remove_simple_key(parser).fail {
562 return FAIL;
563 }
564 (*parser).simple_key_allowed = false;
565 let start_mark: yaml_mark_t = (*parser).mark;
566 SKIP(parser);
567 SKIP(parser);
568 SKIP(parser);
569 let end_mark: yaml_mark_t = (*parser).mark;
570 memset(
571 token as *mut libc::c_void,
572 0,
573 size_of::<yaml_token_t>() as libc::c_ulong,
574 );
575 (*token).type_ = type_;
576 (*token).start_mark = start_mark;
577 (*token).end_mark = end_mark;
578 ENQUEUE!((*parser).tokens, *token);
579 OK
580 }
581
yaml_parser_fetch_flow_collection_start( parser: *mut yaml_parser_t, type_: yaml_token_type_t, ) -> Success582 unsafe fn yaml_parser_fetch_flow_collection_start(
583 parser: *mut yaml_parser_t,
584 type_: yaml_token_type_t,
585 ) -> Success {
586 let mut token = MaybeUninit::<yaml_token_t>::uninit();
587 let token = token.as_mut_ptr();
588 if yaml_parser_save_simple_key(parser).fail {
589 return FAIL;
590 }
591 if yaml_parser_increase_flow_level(parser).fail {
592 return FAIL;
593 }
594 (*parser).simple_key_allowed = true;
595 let start_mark: yaml_mark_t = (*parser).mark;
596 SKIP(parser);
597 let end_mark: yaml_mark_t = (*parser).mark;
598 memset(
599 token as *mut libc::c_void,
600 0,
601 size_of::<yaml_token_t>() as libc::c_ulong,
602 );
603 (*token).type_ = type_;
604 (*token).start_mark = start_mark;
605 (*token).end_mark = end_mark;
606 ENQUEUE!((*parser).tokens, *token);
607 OK
608 }
609
yaml_parser_fetch_flow_collection_end( parser: *mut yaml_parser_t, type_: yaml_token_type_t, ) -> Success610 unsafe fn yaml_parser_fetch_flow_collection_end(
611 parser: *mut yaml_parser_t,
612 type_: yaml_token_type_t,
613 ) -> Success {
614 let mut token = MaybeUninit::<yaml_token_t>::uninit();
615 let token = token.as_mut_ptr();
616 if yaml_parser_remove_simple_key(parser).fail {
617 return FAIL;
618 }
619 yaml_parser_decrease_flow_level(parser);
620 (*parser).simple_key_allowed = false;
621 let start_mark: yaml_mark_t = (*parser).mark;
622 SKIP(parser);
623 let end_mark: yaml_mark_t = (*parser).mark;
624 memset(
625 token as *mut libc::c_void,
626 0,
627 size_of::<yaml_token_t>() as libc::c_ulong,
628 );
629 (*token).type_ = type_;
630 (*token).start_mark = start_mark;
631 (*token).end_mark = end_mark;
632 ENQUEUE!((*parser).tokens, *token);
633 OK
634 }
635
yaml_parser_fetch_flow_entry(parser: *mut yaml_parser_t) -> Success636 unsafe fn yaml_parser_fetch_flow_entry(parser: *mut yaml_parser_t) -> Success {
637 let mut token = MaybeUninit::<yaml_token_t>::uninit();
638 let token = token.as_mut_ptr();
639 if yaml_parser_remove_simple_key(parser).fail {
640 return FAIL;
641 }
642 (*parser).simple_key_allowed = true;
643 let start_mark: yaml_mark_t = (*parser).mark;
644 SKIP(parser);
645 let end_mark: yaml_mark_t = (*parser).mark;
646 memset(
647 token as *mut libc::c_void,
648 0,
649 size_of::<yaml_token_t>() as libc::c_ulong,
650 );
651 (*token).type_ = YAML_FLOW_ENTRY_TOKEN;
652 (*token).start_mark = start_mark;
653 (*token).end_mark = end_mark;
654 ENQUEUE!((*parser).tokens, *token);
655 OK
656 }
657
yaml_parser_fetch_block_entry(parser: *mut yaml_parser_t) -> Success658 unsafe fn yaml_parser_fetch_block_entry(parser: *mut yaml_parser_t) -> Success {
659 let mut token = MaybeUninit::<yaml_token_t>::uninit();
660 let token = token.as_mut_ptr();
661 if (*parser).flow_level == 0 {
662 if !(*parser).simple_key_allowed {
663 yaml_parser_set_scanner_error(
664 parser,
665 ptr::null::<libc::c_char>(),
666 (*parser).mark,
667 b"block sequence entries are not allowed in this context\0" as *const u8
668 as *const libc::c_char,
669 );
670 return FAIL;
671 }
672 if yaml_parser_roll_indent(
673 parser,
674 (*parser).mark.column as ptrdiff_t,
675 -1_i64,
676 YAML_BLOCK_SEQUENCE_START_TOKEN,
677 (*parser).mark,
678 )
679 .fail
680 {
681 return FAIL;
682 }
683 }
684 if yaml_parser_remove_simple_key(parser).fail {
685 return FAIL;
686 }
687 (*parser).simple_key_allowed = true;
688 let start_mark: yaml_mark_t = (*parser).mark;
689 SKIP(parser);
690 let end_mark: yaml_mark_t = (*parser).mark;
691 memset(
692 token as *mut libc::c_void,
693 0,
694 size_of::<yaml_token_t>() as libc::c_ulong,
695 );
696 (*token).type_ = YAML_BLOCK_ENTRY_TOKEN;
697 (*token).start_mark = start_mark;
698 (*token).end_mark = end_mark;
699 ENQUEUE!((*parser).tokens, *token);
700 OK
701 }
702
yaml_parser_fetch_key(parser: *mut yaml_parser_t) -> Success703 unsafe fn yaml_parser_fetch_key(parser: *mut yaml_parser_t) -> Success {
704 let mut token = MaybeUninit::<yaml_token_t>::uninit();
705 let token = token.as_mut_ptr();
706 if (*parser).flow_level == 0 {
707 if !(*parser).simple_key_allowed {
708 yaml_parser_set_scanner_error(
709 parser,
710 ptr::null::<libc::c_char>(),
711 (*parser).mark,
712 b"mapping keys are not allowed in this context\0" as *const u8
713 as *const libc::c_char,
714 );
715 return FAIL;
716 }
717 if yaml_parser_roll_indent(
718 parser,
719 (*parser).mark.column as ptrdiff_t,
720 -1_i64,
721 YAML_BLOCK_MAPPING_START_TOKEN,
722 (*parser).mark,
723 )
724 .fail
725 {
726 return FAIL;
727 }
728 }
729 if yaml_parser_remove_simple_key(parser).fail {
730 return FAIL;
731 }
732 (*parser).simple_key_allowed = (*parser).flow_level == 0;
733 let start_mark: yaml_mark_t = (*parser).mark;
734 SKIP(parser);
735 let end_mark: yaml_mark_t = (*parser).mark;
736 memset(
737 token as *mut libc::c_void,
738 0,
739 size_of::<yaml_token_t>() as libc::c_ulong,
740 );
741 (*token).type_ = YAML_KEY_TOKEN;
742 (*token).start_mark = start_mark;
743 (*token).end_mark = end_mark;
744 ENQUEUE!((*parser).tokens, *token);
745 OK
746 }
747
yaml_parser_fetch_value(parser: *mut yaml_parser_t) -> Success748 unsafe fn yaml_parser_fetch_value(parser: *mut yaml_parser_t) -> Success {
749 let mut token = MaybeUninit::<yaml_token_t>::uninit();
750 let token = token.as_mut_ptr();
751 let simple_key: *mut yaml_simple_key_t = (*parser).simple_keys.top.wrapping_offset(-1_isize);
752 if (*simple_key).possible {
753 memset(
754 token as *mut libc::c_void,
755 0,
756 size_of::<yaml_token_t>() as libc::c_ulong,
757 );
758 (*token).type_ = YAML_KEY_TOKEN;
759 (*token).start_mark = (*simple_key).mark;
760 (*token).end_mark = (*simple_key).mark;
761 QUEUE_INSERT!(
762 (*parser).tokens,
763 ((*simple_key).token_number).wrapping_sub((*parser).tokens_parsed),
764 *token
765 );
766 if yaml_parser_roll_indent(
767 parser,
768 (*simple_key).mark.column as ptrdiff_t,
769 (*simple_key).token_number as ptrdiff_t,
770 YAML_BLOCK_MAPPING_START_TOKEN,
771 (*simple_key).mark,
772 )
773 .fail
774 {
775 return FAIL;
776 }
777 (*simple_key).possible = false;
778 (*parser).simple_key_allowed = false;
779 } else {
780 if (*parser).flow_level == 0 {
781 if !(*parser).simple_key_allowed {
782 yaml_parser_set_scanner_error(
783 parser,
784 ptr::null::<libc::c_char>(),
785 (*parser).mark,
786 b"mapping values are not allowed in this context\0" as *const u8
787 as *const libc::c_char,
788 );
789 return FAIL;
790 }
791 if yaml_parser_roll_indent(
792 parser,
793 (*parser).mark.column as ptrdiff_t,
794 -1_i64,
795 YAML_BLOCK_MAPPING_START_TOKEN,
796 (*parser).mark,
797 )
798 .fail
799 {
800 return FAIL;
801 }
802 }
803 (*parser).simple_key_allowed = (*parser).flow_level == 0;
804 }
805 let start_mark: yaml_mark_t = (*parser).mark;
806 SKIP(parser);
807 let end_mark: yaml_mark_t = (*parser).mark;
808 memset(
809 token as *mut libc::c_void,
810 0,
811 size_of::<yaml_token_t>() as libc::c_ulong,
812 );
813 (*token).type_ = YAML_VALUE_TOKEN;
814 (*token).start_mark = start_mark;
815 (*token).end_mark = end_mark;
816 ENQUEUE!((*parser).tokens, *token);
817 OK
818 }
819
yaml_parser_fetch_anchor( parser: *mut yaml_parser_t, type_: yaml_token_type_t, ) -> Success820 unsafe fn yaml_parser_fetch_anchor(
821 parser: *mut yaml_parser_t,
822 type_: yaml_token_type_t,
823 ) -> Success {
824 let mut token = MaybeUninit::<yaml_token_t>::uninit();
825 let token = token.as_mut_ptr();
826 if yaml_parser_save_simple_key(parser).fail {
827 return FAIL;
828 }
829 (*parser).simple_key_allowed = false;
830 if yaml_parser_scan_anchor(parser, token, type_).fail {
831 return FAIL;
832 }
833 ENQUEUE!((*parser).tokens, *token);
834 OK
835 }
836
yaml_parser_fetch_tag(parser: *mut yaml_parser_t) -> Success837 unsafe fn yaml_parser_fetch_tag(parser: *mut yaml_parser_t) -> Success {
838 let mut token = MaybeUninit::<yaml_token_t>::uninit();
839 let token = token.as_mut_ptr();
840 if yaml_parser_save_simple_key(parser).fail {
841 return FAIL;
842 }
843 (*parser).simple_key_allowed = false;
844 if yaml_parser_scan_tag(parser, token).fail {
845 return FAIL;
846 }
847 ENQUEUE!((*parser).tokens, *token);
848 OK
849 }
850
yaml_parser_fetch_block_scalar(parser: *mut yaml_parser_t, literal: bool) -> Success851 unsafe fn yaml_parser_fetch_block_scalar(parser: *mut yaml_parser_t, literal: bool) -> Success {
852 let mut token = MaybeUninit::<yaml_token_t>::uninit();
853 let token = token.as_mut_ptr();
854 if yaml_parser_remove_simple_key(parser).fail {
855 return FAIL;
856 }
857 (*parser).simple_key_allowed = true;
858 if yaml_parser_scan_block_scalar(parser, token, literal).fail {
859 return FAIL;
860 }
861 ENQUEUE!((*parser).tokens, *token);
862 OK
863 }
864
yaml_parser_fetch_flow_scalar(parser: *mut yaml_parser_t, single: bool) -> Success865 unsafe fn yaml_parser_fetch_flow_scalar(parser: *mut yaml_parser_t, single: bool) -> Success {
866 let mut token = MaybeUninit::<yaml_token_t>::uninit();
867 let token = token.as_mut_ptr();
868 if yaml_parser_save_simple_key(parser).fail {
869 return FAIL;
870 }
871 (*parser).simple_key_allowed = false;
872 if yaml_parser_scan_flow_scalar(parser, token, single).fail {
873 return FAIL;
874 }
875 ENQUEUE!((*parser).tokens, *token);
876 OK
877 }
878
yaml_parser_fetch_plain_scalar(parser: *mut yaml_parser_t) -> Success879 unsafe fn yaml_parser_fetch_plain_scalar(parser: *mut yaml_parser_t) -> Success {
880 let mut token = MaybeUninit::<yaml_token_t>::uninit();
881 let token = token.as_mut_ptr();
882 if yaml_parser_save_simple_key(parser).fail {
883 return FAIL;
884 }
885 (*parser).simple_key_allowed = false;
886 if yaml_parser_scan_plain_scalar(parser, token).fail {
887 return FAIL;
888 }
889 ENQUEUE!((*parser).tokens, *token);
890 OK
891 }
892
yaml_parser_scan_to_next_token(parser: *mut yaml_parser_t) -> Success893 unsafe fn yaml_parser_scan_to_next_token(parser: *mut yaml_parser_t) -> Success {
894 loop {
895 if CACHE(parser, 1_u64).fail {
896 return FAIL;
897 }
898 if (*parser).mark.column == 0_u64 && IS_BOM!((*parser).buffer) {
899 SKIP(parser);
900 }
901 if CACHE(parser, 1_u64).fail {
902 return FAIL;
903 }
904 while CHECK!((*parser).buffer, b' ')
905 || ((*parser).flow_level != 0 || !(*parser).simple_key_allowed)
906 && CHECK!((*parser).buffer, b'\t')
907 {
908 SKIP(parser);
909 if CACHE(parser, 1_u64).fail {
910 return FAIL;
911 }
912 }
913 if CHECK!((*parser).buffer, b'#') {
914 while !IS_BREAKZ!((*parser).buffer) {
915 SKIP(parser);
916 if CACHE(parser, 1_u64).fail {
917 return FAIL;
918 }
919 }
920 }
921 if !IS_BREAK!((*parser).buffer) {
922 break;
923 }
924 if CACHE(parser, 2_u64).fail {
925 return FAIL;
926 }
927 SKIP_LINE(parser);
928 if (*parser).flow_level == 0 {
929 (*parser).simple_key_allowed = true;
930 }
931 }
932 OK
933 }
934
yaml_parser_scan_directive( parser: *mut yaml_parser_t, token: *mut yaml_token_t, ) -> Success935 unsafe fn yaml_parser_scan_directive(
936 parser: *mut yaml_parser_t,
937 token: *mut yaml_token_t,
938 ) -> Success {
939 let mut current_block: u64;
940 let end_mark: yaml_mark_t;
941 let mut name: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
942 let mut major: libc::c_int = 0;
943 let mut minor: libc::c_int = 0;
944 let mut handle: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
945 let mut prefix: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
946 let start_mark: yaml_mark_t = (*parser).mark;
947 SKIP(parser);
948 if yaml_parser_scan_directive_name(parser, start_mark, addr_of_mut!(name)).ok {
949 if strcmp(
950 name as *mut libc::c_char,
951 b"YAML\0" as *const u8 as *const libc::c_char,
952 ) == 0
953 {
954 if yaml_parser_scan_version_directive_value(
955 parser,
956 start_mark,
957 addr_of_mut!(major),
958 addr_of_mut!(minor),
959 )
960 .fail
961 {
962 current_block = 11397968426844348457;
963 } else {
964 end_mark = (*parser).mark;
965 memset(
966 token as *mut libc::c_void,
967 0,
968 size_of::<yaml_token_t>() as libc::c_ulong,
969 );
970 (*token).type_ = YAML_VERSION_DIRECTIVE_TOKEN;
971 (*token).start_mark = start_mark;
972 (*token).end_mark = end_mark;
973 (*token).data.version_directive.major = major;
974 (*token).data.version_directive.minor = minor;
975 current_block = 17407779659766490442;
976 }
977 } else if strcmp(
978 name as *mut libc::c_char,
979 b"TAG\0" as *const u8 as *const libc::c_char,
980 ) == 0
981 {
982 if yaml_parser_scan_tag_directive_value(
983 parser,
984 start_mark,
985 addr_of_mut!(handle),
986 addr_of_mut!(prefix),
987 )
988 .fail
989 {
990 current_block = 11397968426844348457;
991 } else {
992 end_mark = (*parser).mark;
993 memset(
994 token as *mut libc::c_void,
995 0,
996 size_of::<yaml_token_t>() as libc::c_ulong,
997 );
998 (*token).type_ = YAML_TAG_DIRECTIVE_TOKEN;
999 (*token).start_mark = start_mark;
1000 (*token).end_mark = end_mark;
1001 let fresh112 = addr_of_mut!((*token).data.tag_directive.handle);
1002 *fresh112 = handle;
1003 let fresh113 = addr_of_mut!((*token).data.tag_directive.prefix);
1004 *fresh113 = prefix;
1005 current_block = 17407779659766490442;
1006 }
1007 } else {
1008 yaml_parser_set_scanner_error(
1009 parser,
1010 b"while scanning a directive\0" as *const u8 as *const libc::c_char,
1011 start_mark,
1012 b"found unknown directive name\0" as *const u8 as *const libc::c_char,
1013 );
1014 current_block = 11397968426844348457;
1015 }
1016 if current_block != 11397968426844348457 {
1017 if CACHE(parser, 1_u64).ok {
1018 loop {
1019 if !IS_BLANK!((*parser).buffer) {
1020 current_block = 11584701595673473500;
1021 break;
1022 }
1023 SKIP(parser);
1024 if CACHE(parser, 1_u64).fail {
1025 current_block = 11397968426844348457;
1026 break;
1027 }
1028 }
1029 if current_block != 11397968426844348457 {
1030 if CHECK!((*parser).buffer, b'#') {
1031 loop {
1032 if IS_BREAKZ!((*parser).buffer) {
1033 current_block = 6669252993407410313;
1034 break;
1035 }
1036 SKIP(parser);
1037 if CACHE(parser, 1_u64).fail {
1038 current_block = 11397968426844348457;
1039 break;
1040 }
1041 }
1042 } else {
1043 current_block = 6669252993407410313;
1044 }
1045 if current_block != 11397968426844348457 {
1046 if !IS_BREAKZ!((*parser).buffer) {
1047 yaml_parser_set_scanner_error(
1048 parser,
1049 b"while scanning a directive\0" as *const u8 as *const libc::c_char,
1050 start_mark,
1051 b"did not find expected comment or line break\0" as *const u8
1052 as *const libc::c_char,
1053 );
1054 } else {
1055 if IS_BREAK!((*parser).buffer) {
1056 if CACHE(parser, 2_u64).fail {
1057 current_block = 11397968426844348457;
1058 } else {
1059 SKIP_LINE(parser);
1060 current_block = 652864300344834934;
1061 }
1062 } else {
1063 current_block = 652864300344834934;
1064 }
1065 if current_block != 11397968426844348457 {
1066 yaml_free(name as *mut libc::c_void);
1067 return OK;
1068 }
1069 }
1070 }
1071 }
1072 }
1073 }
1074 }
1075 yaml_free(prefix as *mut libc::c_void);
1076 yaml_free(handle as *mut libc::c_void);
1077 yaml_free(name as *mut libc::c_void);
1078 FAIL
1079 }
1080
yaml_parser_scan_directive_name( parser: *mut yaml_parser_t, start_mark: yaml_mark_t, name: *mut *mut yaml_char_t, ) -> Success1081 unsafe fn yaml_parser_scan_directive_name(
1082 parser: *mut yaml_parser_t,
1083 start_mark: yaml_mark_t,
1084 name: *mut *mut yaml_char_t,
1085 ) -> Success {
1086 let current_block: u64;
1087 let mut string = NULL_STRING;
1088 STRING_INIT!(string);
1089 if CACHE(parser, 1_u64).ok {
1090 loop {
1091 if !IS_ALPHA!((*parser).buffer) {
1092 current_block = 10879442775620481940;
1093 break;
1094 }
1095 READ!(parser, string);
1096 if CACHE(parser, 1_u64).fail {
1097 current_block = 8318012024179131575;
1098 break;
1099 }
1100 }
1101 if current_block != 8318012024179131575 {
1102 if string.start == string.pointer {
1103 yaml_parser_set_scanner_error(
1104 parser,
1105 b"while scanning a directive\0" as *const u8 as *const libc::c_char,
1106 start_mark,
1107 b"could not find expected directive name\0" as *const u8 as *const libc::c_char,
1108 );
1109 } else if !IS_BLANKZ!((*parser).buffer) {
1110 yaml_parser_set_scanner_error(
1111 parser,
1112 b"while scanning a directive\0" as *const u8 as *const libc::c_char,
1113 start_mark,
1114 b"found unexpected non-alphabetical character\0" as *const u8
1115 as *const libc::c_char,
1116 );
1117 } else {
1118 *name = string.start;
1119 return OK;
1120 }
1121 }
1122 }
1123 STRING_DEL!(string);
1124 FAIL
1125 }
1126
yaml_parser_scan_version_directive_value( parser: *mut yaml_parser_t, start_mark: yaml_mark_t, major: *mut libc::c_int, minor: *mut libc::c_int, ) -> Success1127 unsafe fn yaml_parser_scan_version_directive_value(
1128 parser: *mut yaml_parser_t,
1129 start_mark: yaml_mark_t,
1130 major: *mut libc::c_int,
1131 minor: *mut libc::c_int,
1132 ) -> Success {
1133 if CACHE(parser, 1_u64).fail {
1134 return FAIL;
1135 }
1136 while IS_BLANK!((*parser).buffer) {
1137 SKIP(parser);
1138 if CACHE(parser, 1_u64).fail {
1139 return FAIL;
1140 }
1141 }
1142 if yaml_parser_scan_version_directive_number(parser, start_mark, major).fail {
1143 return FAIL;
1144 }
1145 if !CHECK!((*parser).buffer, b'.') {
1146 yaml_parser_set_scanner_error(
1147 parser,
1148 b"while scanning a %YAML directive\0" as *const u8 as *const libc::c_char,
1149 start_mark,
1150 b"did not find expected digit or '.' character\0" as *const u8 as *const libc::c_char,
1151 );
1152 return FAIL;
1153 }
1154 SKIP(parser);
1155 yaml_parser_scan_version_directive_number(parser, start_mark, minor)
1156 }
1157
1158 const MAX_NUMBER_LENGTH: u64 = 9_u64;
1159
yaml_parser_scan_version_directive_number( parser: *mut yaml_parser_t, start_mark: yaml_mark_t, number: *mut libc::c_int, ) -> Success1160 unsafe fn yaml_parser_scan_version_directive_number(
1161 parser: *mut yaml_parser_t,
1162 start_mark: yaml_mark_t,
1163 number: *mut libc::c_int,
1164 ) -> Success {
1165 let mut value: libc::c_int = 0;
1166 let mut length: size_t = 0_u64;
1167 if CACHE(parser, 1_u64).fail {
1168 return FAIL;
1169 }
1170 while IS_DIGIT!((*parser).buffer) {
1171 length = length.force_add(1);
1172 if length > MAX_NUMBER_LENGTH {
1173 yaml_parser_set_scanner_error(
1174 parser,
1175 b"while scanning a %YAML directive\0" as *const u8 as *const libc::c_char,
1176 start_mark,
1177 b"found extremely long version number\0" as *const u8 as *const libc::c_char,
1178 );
1179 return FAIL;
1180 }
1181 value = value.force_mul(10).force_add(AS_DIGIT!((*parser).buffer));
1182 SKIP(parser);
1183 if CACHE(parser, 1_u64).fail {
1184 return FAIL;
1185 }
1186 }
1187 if length == 0 {
1188 yaml_parser_set_scanner_error(
1189 parser,
1190 b"while scanning a %YAML directive\0" as *const u8 as *const libc::c_char,
1191 start_mark,
1192 b"did not find expected version number\0" as *const u8 as *const libc::c_char,
1193 );
1194 return FAIL;
1195 }
1196 *number = value;
1197 OK
1198 }
1199
yaml_parser_scan_tag_directive_value( parser: *mut yaml_parser_t, start_mark: yaml_mark_t, handle: *mut *mut yaml_char_t, prefix: *mut *mut yaml_char_t, ) -> Success1200 unsafe fn yaml_parser_scan_tag_directive_value(
1201 parser: *mut yaml_parser_t,
1202 start_mark: yaml_mark_t,
1203 handle: *mut *mut yaml_char_t,
1204 prefix: *mut *mut yaml_char_t,
1205 ) -> Success {
1206 let mut current_block: u64;
1207 let mut handle_value: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
1208 let mut prefix_value: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
1209 if CACHE(parser, 1_u64).fail {
1210 current_block = 5231181710497607163;
1211 } else {
1212 current_block = 14916268686031723178;
1213 }
1214 'c_34337: loop {
1215 match current_block {
1216 5231181710497607163 => {
1217 yaml_free(handle_value as *mut libc::c_void);
1218 yaml_free(prefix_value as *mut libc::c_void);
1219 return FAIL;
1220 }
1221 _ => {
1222 if IS_BLANK!((*parser).buffer) {
1223 SKIP(parser);
1224 if CACHE(parser, 1_u64).fail {
1225 current_block = 5231181710497607163;
1226 } else {
1227 current_block = 14916268686031723178;
1228 }
1229 } else {
1230 if yaml_parser_scan_tag_handle(
1231 parser,
1232 true,
1233 start_mark,
1234 addr_of_mut!(handle_value),
1235 )
1236 .fail
1237 {
1238 current_block = 5231181710497607163;
1239 continue;
1240 }
1241 if CACHE(parser, 1_u64).fail {
1242 current_block = 5231181710497607163;
1243 continue;
1244 }
1245 if !IS_BLANK!((*parser).buffer) {
1246 yaml_parser_set_scanner_error(
1247 parser,
1248 b"while scanning a %TAG directive\0" as *const u8
1249 as *const libc::c_char,
1250 start_mark,
1251 b"did not find expected whitespace\0" as *const u8
1252 as *const libc::c_char,
1253 );
1254 current_block = 5231181710497607163;
1255 } else {
1256 while IS_BLANK!((*parser).buffer) {
1257 SKIP(parser);
1258 if CACHE(parser, 1_u64).fail {
1259 current_block = 5231181710497607163;
1260 continue 'c_34337;
1261 }
1262 }
1263 if yaml_parser_scan_tag_uri(
1264 parser,
1265 true,
1266 true,
1267 ptr::null_mut::<yaml_char_t>(),
1268 start_mark,
1269 addr_of_mut!(prefix_value),
1270 )
1271 .fail
1272 {
1273 current_block = 5231181710497607163;
1274 continue;
1275 }
1276 if CACHE(parser, 1_u64).fail {
1277 current_block = 5231181710497607163;
1278 continue;
1279 }
1280 if !IS_BLANKZ!((*parser).buffer) {
1281 yaml_parser_set_scanner_error(
1282 parser,
1283 b"while scanning a %TAG directive\0" as *const u8
1284 as *const libc::c_char,
1285 start_mark,
1286 b"did not find expected whitespace or line break\0" as *const u8
1287 as *const libc::c_char,
1288 );
1289 current_block = 5231181710497607163;
1290 } else {
1291 *handle = handle_value;
1292 *prefix = prefix_value;
1293 return OK;
1294 }
1295 }
1296 }
1297 }
1298 }
1299 }
1300 }
1301
yaml_parser_scan_anchor( parser: *mut yaml_parser_t, token: *mut yaml_token_t, type_: yaml_token_type_t, ) -> Success1302 unsafe fn yaml_parser_scan_anchor(
1303 parser: *mut yaml_parser_t,
1304 token: *mut yaml_token_t,
1305 type_: yaml_token_type_t,
1306 ) -> Success {
1307 let current_block: u64;
1308 let mut length: libc::c_int = 0;
1309 let end_mark: yaml_mark_t;
1310 let mut string = NULL_STRING;
1311 STRING_INIT!(string);
1312 let start_mark: yaml_mark_t = (*parser).mark;
1313 SKIP(parser);
1314 if CACHE(parser, 1_u64).ok {
1315 loop {
1316 if !IS_ALPHA!((*parser).buffer) {
1317 current_block = 2868539653012386629;
1318 break;
1319 }
1320 READ!(parser, string);
1321 if CACHE(parser, 1_u64).fail {
1322 current_block = 5883759901342942623;
1323 break;
1324 }
1325 length += 1;
1326 }
1327 if current_block != 5883759901342942623 {
1328 end_mark = (*parser).mark;
1329 if length == 0
1330 || !(IS_BLANKZ!((*parser).buffer)
1331 || CHECK!((*parser).buffer, b'?')
1332 || CHECK!((*parser).buffer, b':')
1333 || CHECK!((*parser).buffer, b',')
1334 || CHECK!((*parser).buffer, b']')
1335 || CHECK!((*parser).buffer, b'}')
1336 || CHECK!((*parser).buffer, b'%')
1337 || CHECK!((*parser).buffer, b'@')
1338 || CHECK!((*parser).buffer, b'`'))
1339 {
1340 yaml_parser_set_scanner_error(
1341 parser,
1342 if type_ == YAML_ANCHOR_TOKEN {
1343 b"while scanning an anchor\0" as *const u8 as *const libc::c_char
1344 } else {
1345 b"while scanning an alias\0" as *const u8 as *const libc::c_char
1346 },
1347 start_mark,
1348 b"did not find expected alphabetic or numeric character\0" as *const u8
1349 as *const libc::c_char,
1350 );
1351 } else {
1352 if type_ == YAML_ANCHOR_TOKEN {
1353 memset(
1354 token as *mut libc::c_void,
1355 0,
1356 size_of::<yaml_token_t>() as libc::c_ulong,
1357 );
1358 (*token).type_ = YAML_ANCHOR_TOKEN;
1359 (*token).start_mark = start_mark;
1360 (*token).end_mark = end_mark;
1361 let fresh220 = addr_of_mut!((*token).data.anchor.value);
1362 *fresh220 = string.start;
1363 } else {
1364 memset(
1365 token as *mut libc::c_void,
1366 0,
1367 size_of::<yaml_token_t>() as libc::c_ulong,
1368 );
1369 (*token).type_ = YAML_ALIAS_TOKEN;
1370 (*token).start_mark = start_mark;
1371 (*token).end_mark = end_mark;
1372 let fresh221 = addr_of_mut!((*token).data.alias.value);
1373 *fresh221 = string.start;
1374 }
1375 return OK;
1376 }
1377 }
1378 }
1379 STRING_DEL!(string);
1380 FAIL
1381 }
1382
yaml_parser_scan_tag(parser: *mut yaml_parser_t, token: *mut yaml_token_t) -> Success1383 unsafe fn yaml_parser_scan_tag(parser: *mut yaml_parser_t, token: *mut yaml_token_t) -> Success {
1384 let mut current_block: u64;
1385 let mut handle: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
1386 let mut suffix: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
1387 let end_mark: yaml_mark_t;
1388 let start_mark: yaml_mark_t = (*parser).mark;
1389 if CACHE(parser, 2_u64).ok {
1390 if CHECK_AT!((*parser).buffer, b'<', 1) {
1391 handle = yaml_malloc(1_u64) as *mut yaml_char_t;
1392 *handle = b'\0';
1393 SKIP(parser);
1394 SKIP(parser);
1395 if yaml_parser_scan_tag_uri(
1396 parser,
1397 true,
1398 false,
1399 ptr::null_mut::<yaml_char_t>(),
1400 start_mark,
1401 addr_of_mut!(suffix),
1402 )
1403 .fail
1404 {
1405 current_block = 17708497480799081542;
1406 } else if !CHECK!((*parser).buffer, b'>') {
1407 yaml_parser_set_scanner_error(
1408 parser,
1409 b"while scanning a tag\0" as *const u8 as *const libc::c_char,
1410 start_mark,
1411 b"did not find the expected '>'\0" as *const u8 as *const libc::c_char,
1412 );
1413 current_block = 17708497480799081542;
1414 } else {
1415 SKIP(parser);
1416 current_block = 4488286894823169796;
1417 }
1418 } else if yaml_parser_scan_tag_handle(parser, false, start_mark, addr_of_mut!(handle)).fail
1419 {
1420 current_block = 17708497480799081542;
1421 } else if *handle == b'!'
1422 && *handle.wrapping_offset(1_isize) != b'\0'
1423 && *handle
1424 .wrapping_offset(strlen(handle as *mut libc::c_char).wrapping_sub(1_u64) as isize)
1425 == b'!'
1426 {
1427 if yaml_parser_scan_tag_uri(
1428 parser,
1429 false,
1430 false,
1431 ptr::null_mut::<yaml_char_t>(),
1432 start_mark,
1433 addr_of_mut!(suffix),
1434 )
1435 .fail
1436 {
1437 current_block = 17708497480799081542;
1438 } else {
1439 current_block = 4488286894823169796;
1440 }
1441 } else if yaml_parser_scan_tag_uri(
1442 parser,
1443 false,
1444 false,
1445 handle,
1446 start_mark,
1447 addr_of_mut!(suffix),
1448 )
1449 .fail
1450 {
1451 current_block = 17708497480799081542;
1452 } else {
1453 yaml_free(handle as *mut libc::c_void);
1454 handle = yaml_malloc(2_u64) as *mut yaml_char_t;
1455 *handle = b'!';
1456 *handle.wrapping_offset(1_isize) = b'\0';
1457 if *suffix == b'\0' {
1458 let tmp: *mut yaml_char_t = handle;
1459 handle = suffix;
1460 suffix = tmp;
1461 }
1462 current_block = 4488286894823169796;
1463 }
1464 if current_block != 17708497480799081542 {
1465 if CACHE(parser, 1_u64).ok {
1466 if !IS_BLANKZ!((*parser).buffer) {
1467 if (*parser).flow_level == 0 || !CHECK!((*parser).buffer, b',') {
1468 yaml_parser_set_scanner_error(
1469 parser,
1470 b"while scanning a tag\0" as *const u8 as *const libc::c_char,
1471 start_mark,
1472 b"did not find expected whitespace or line break\0" as *const u8
1473 as *const libc::c_char,
1474 );
1475 current_block = 17708497480799081542;
1476 } else {
1477 current_block = 7333393191927787629;
1478 }
1479 } else {
1480 current_block = 7333393191927787629;
1481 }
1482 if current_block != 17708497480799081542 {
1483 end_mark = (*parser).mark;
1484 memset(
1485 token as *mut libc::c_void,
1486 0,
1487 size_of::<yaml_token_t>() as libc::c_ulong,
1488 );
1489 (*token).type_ = YAML_TAG_TOKEN;
1490 (*token).start_mark = start_mark;
1491 (*token).end_mark = end_mark;
1492 let fresh234 = addr_of_mut!((*token).data.tag.handle);
1493 *fresh234 = handle;
1494 let fresh235 = addr_of_mut!((*token).data.tag.suffix);
1495 *fresh235 = suffix;
1496 return OK;
1497 }
1498 }
1499 }
1500 }
1501 yaml_free(handle as *mut libc::c_void);
1502 yaml_free(suffix as *mut libc::c_void);
1503 FAIL
1504 }
1505
yaml_parser_scan_tag_handle( parser: *mut yaml_parser_t, directive: bool, start_mark: yaml_mark_t, handle: *mut *mut yaml_char_t, ) -> Success1506 unsafe fn yaml_parser_scan_tag_handle(
1507 parser: *mut yaml_parser_t,
1508 directive: bool,
1509 start_mark: yaml_mark_t,
1510 handle: *mut *mut yaml_char_t,
1511 ) -> Success {
1512 let mut current_block: u64;
1513 let mut string = NULL_STRING;
1514 STRING_INIT!(string);
1515 if CACHE(parser, 1_u64).ok {
1516 if !CHECK!((*parser).buffer, b'!') {
1517 yaml_parser_set_scanner_error(
1518 parser,
1519 if directive {
1520 b"while scanning a tag directive\0" as *const u8 as *const libc::c_char
1521 } else {
1522 b"while scanning a tag\0" as *const u8 as *const libc::c_char
1523 },
1524 start_mark,
1525 b"did not find expected '!'\0" as *const u8 as *const libc::c_char,
1526 );
1527 } else {
1528 READ!(parser, string);
1529 if CACHE(parser, 1_u64).ok {
1530 loop {
1531 if !IS_ALPHA!((*parser).buffer) {
1532 current_block = 7651349459974463963;
1533 break;
1534 }
1535 READ!(parser, string);
1536 if CACHE(parser, 1_u64).fail {
1537 current_block = 1771849829115608806;
1538 break;
1539 }
1540 }
1541 if current_block != 1771849829115608806 {
1542 if CHECK!((*parser).buffer, b'!') {
1543 READ!(parser, string);
1544 current_block = 5689001924483802034;
1545 } else if directive
1546 && !(*string.start == b'!'
1547 && *string.start.wrapping_offset(1_isize) == b'\0')
1548 {
1549 yaml_parser_set_scanner_error(
1550 parser,
1551 b"while parsing a tag directive\0" as *const u8 as *const libc::c_char,
1552 start_mark,
1553 b"did not find expected '!'\0" as *const u8 as *const libc::c_char,
1554 );
1555 current_block = 1771849829115608806;
1556 } else {
1557 current_block = 5689001924483802034;
1558 }
1559 if current_block != 1771849829115608806 {
1560 *handle = string.start;
1561 return OK;
1562 }
1563 }
1564 }
1565 }
1566 }
1567 STRING_DEL!(string);
1568 FAIL
1569 }
1570
yaml_parser_scan_tag_uri( parser: *mut yaml_parser_t, uri_char: bool, directive: bool, head: *mut yaml_char_t, start_mark: yaml_mark_t, uri: *mut *mut yaml_char_t, ) -> Success1571 unsafe fn yaml_parser_scan_tag_uri(
1572 parser: *mut yaml_parser_t,
1573 uri_char: bool,
1574 directive: bool,
1575 head: *mut yaml_char_t,
1576 start_mark: yaml_mark_t,
1577 uri: *mut *mut yaml_char_t,
1578 ) -> Success {
1579 let mut current_block: u64;
1580 let mut length: size_t = if !head.is_null() {
1581 strlen(head as *mut libc::c_char)
1582 } else {
1583 0_u64
1584 };
1585 let mut string = NULL_STRING;
1586 STRING_INIT!(string);
1587 current_block = 14916268686031723178;
1588 'c_21953: loop {
1589 match current_block {
1590 15265153392498847348 => {
1591 STRING_DEL!(string);
1592 return FAIL;
1593 }
1594 _ => {
1595 if string.end.c_offset_from(string.start) as size_t <= length {
1596 yaml_string_extend(
1597 addr_of_mut!(string.start),
1598 addr_of_mut!(string.pointer),
1599 addr_of_mut!(string.end),
1600 );
1601 current_block = 14916268686031723178;
1602 continue;
1603 } else {
1604 if length > 1_u64 {
1605 memcpy(
1606 string.start as *mut libc::c_void,
1607 head.wrapping_offset(1_isize) as *const libc::c_void,
1608 length.wrapping_sub(1_u64),
1609 );
1610 string.pointer = string
1611 .pointer
1612 .wrapping_offset(length.wrapping_sub(1_u64) as isize);
1613 }
1614 if CACHE(parser, 1_u64).fail {
1615 current_block = 15265153392498847348;
1616 continue;
1617 }
1618 while IS_ALPHA!((*parser).buffer)
1619 || CHECK!((*parser).buffer, b';')
1620 || CHECK!((*parser).buffer, b'/')
1621 || CHECK!((*parser).buffer, b'?')
1622 || CHECK!((*parser).buffer, b':')
1623 || CHECK!((*parser).buffer, b'@')
1624 || CHECK!((*parser).buffer, b'&')
1625 || CHECK!((*parser).buffer, b'=')
1626 || CHECK!((*parser).buffer, b'+')
1627 || CHECK!((*parser).buffer, b'$')
1628 || CHECK!((*parser).buffer, b'.')
1629 || CHECK!((*parser).buffer, b'%')
1630 || CHECK!((*parser).buffer, b'!')
1631 || CHECK!((*parser).buffer, b'~')
1632 || CHECK!((*parser).buffer, b'*')
1633 || CHECK!((*parser).buffer, b'\'')
1634 || CHECK!((*parser).buffer, b'(')
1635 || CHECK!((*parser).buffer, b')')
1636 || uri_char
1637 && (CHECK!((*parser).buffer, b',')
1638 || CHECK!((*parser).buffer, b'[')
1639 || CHECK!((*parser).buffer, b']'))
1640 {
1641 if CHECK!((*parser).buffer, b'%') {
1642 STRING_EXTEND!(string);
1643 if yaml_parser_scan_uri_escapes(
1644 parser,
1645 directive,
1646 start_mark,
1647 addr_of_mut!(string),
1648 )
1649 .fail
1650 {
1651 current_block = 15265153392498847348;
1652 continue 'c_21953;
1653 }
1654 } else {
1655 READ!(parser, string);
1656 }
1657 length = length.force_add(1);
1658 if CACHE(parser, 1_u64).fail {
1659 current_block = 15265153392498847348;
1660 continue 'c_21953;
1661 }
1662 }
1663 if length == 0 {
1664 STRING_EXTEND!(string);
1665 yaml_parser_set_scanner_error(
1666 parser,
1667 if directive {
1668 b"while parsing a %TAG directive\0" as *const u8
1669 as *const libc::c_char
1670 } else {
1671 b"while parsing a tag\0" as *const u8 as *const libc::c_char
1672 },
1673 start_mark,
1674 b"did not find expected tag URI\0" as *const u8 as *const libc::c_char,
1675 );
1676 current_block = 15265153392498847348;
1677 } else {
1678 *uri = string.start;
1679 return OK;
1680 }
1681 }
1682 }
1683 }
1684 }
1685 }
1686
yaml_parser_scan_uri_escapes( parser: *mut yaml_parser_t, directive: bool, start_mark: yaml_mark_t, string: *mut yaml_string_t, ) -> Success1687 unsafe fn yaml_parser_scan_uri_escapes(
1688 parser: *mut yaml_parser_t,
1689 directive: bool,
1690 start_mark: yaml_mark_t,
1691 string: *mut yaml_string_t,
1692 ) -> Success {
1693 let mut width: libc::c_int = 0;
1694 loop {
1695 if CACHE(parser, 3_u64).fail {
1696 return FAIL;
1697 }
1698 if !(CHECK!((*parser).buffer, b'%')
1699 && IS_HEX_AT!((*parser).buffer, 1)
1700 && IS_HEX_AT!((*parser).buffer, 2))
1701 {
1702 yaml_parser_set_scanner_error(
1703 parser,
1704 if directive {
1705 b"while parsing a %TAG directive\0" as *const u8 as *const libc::c_char
1706 } else {
1707 b"while parsing a tag\0" as *const u8 as *const libc::c_char
1708 },
1709 start_mark,
1710 b"did not find URI escaped octet\0" as *const u8 as *const libc::c_char,
1711 );
1712 return FAIL;
1713 }
1714 let octet: libc::c_uchar = ((AS_HEX_AT!((*parser).buffer, 1) << 4)
1715 + AS_HEX_AT!((*parser).buffer, 2)) as libc::c_uchar;
1716 if width == 0 {
1717 width = if octet & 0x80 == 0 {
1718 1
1719 } else if octet & 0xE0 == 0xC0 {
1720 2
1721 } else if octet & 0xF0 == 0xE0 {
1722 3
1723 } else if octet & 0xF8 == 0xF0 {
1724 4
1725 } else {
1726 0
1727 };
1728 if width == 0 {
1729 yaml_parser_set_scanner_error(
1730 parser,
1731 if directive {
1732 b"while parsing a %TAG directive\0" as *const u8 as *const libc::c_char
1733 } else {
1734 b"while parsing a tag\0" as *const u8 as *const libc::c_char
1735 },
1736 start_mark,
1737 b"found an incorrect leading UTF-8 octet\0" as *const u8 as *const libc::c_char,
1738 );
1739 return FAIL;
1740 }
1741 } else if octet & 0xC0 != 0x80 {
1742 yaml_parser_set_scanner_error(
1743 parser,
1744 if directive {
1745 b"while parsing a %TAG directive\0" as *const u8 as *const libc::c_char
1746 } else {
1747 b"while parsing a tag\0" as *const u8 as *const libc::c_char
1748 },
1749 start_mark,
1750 b"found an incorrect trailing UTF-8 octet\0" as *const u8 as *const libc::c_char,
1751 );
1752 return FAIL;
1753 }
1754 let fresh368 = addr_of_mut!((*string).pointer);
1755 let fresh369 = *fresh368;
1756 *fresh368 = (*fresh368).wrapping_offset(1);
1757 *fresh369 = octet;
1758 SKIP(parser);
1759 SKIP(parser);
1760 SKIP(parser);
1761 width -= 1;
1762 if !(width != 0) {
1763 break;
1764 }
1765 }
1766 OK
1767 }
1768
yaml_parser_scan_block_scalar( parser: *mut yaml_parser_t, token: *mut yaml_token_t, literal: bool, ) -> Success1769 unsafe fn yaml_parser_scan_block_scalar(
1770 parser: *mut yaml_parser_t,
1771 token: *mut yaml_token_t,
1772 literal: bool,
1773 ) -> Success {
1774 let mut current_block: u64;
1775 let mut end_mark: yaml_mark_t;
1776 let mut string = NULL_STRING;
1777 let mut leading_break = NULL_STRING;
1778 let mut trailing_breaks = NULL_STRING;
1779 let mut chomping: libc::c_int = 0;
1780 let mut increment: libc::c_int = 0;
1781 let mut indent: libc::c_int = 0;
1782 let mut leading_blank: libc::c_int = 0;
1783 let mut trailing_blank: libc::c_int;
1784 STRING_INIT!(string);
1785 STRING_INIT!(leading_break);
1786 STRING_INIT!(trailing_breaks);
1787 let start_mark: yaml_mark_t = (*parser).mark;
1788 SKIP(parser);
1789 if CACHE(parser, 1_u64).ok {
1790 if CHECK!((*parser).buffer, b'+') || CHECK!((*parser).buffer, b'-') {
1791 chomping = if CHECK!((*parser).buffer, b'+') {
1792 1
1793 } else {
1794 -1
1795 };
1796 SKIP(parser);
1797 if CACHE(parser, 1_u64).fail {
1798 current_block = 14984465786483313892;
1799 } else if IS_DIGIT!((*parser).buffer) {
1800 if CHECK!((*parser).buffer, b'0') {
1801 yaml_parser_set_scanner_error(
1802 parser,
1803 b"while scanning a block scalar\0" as *const u8 as *const libc::c_char,
1804 start_mark,
1805 b"found an indentation indicator equal to 0\0" as *const u8
1806 as *const libc::c_char,
1807 );
1808 current_block = 14984465786483313892;
1809 } else {
1810 increment = AS_DIGIT!((*parser).buffer);
1811 SKIP(parser);
1812 current_block = 11913429853522160501;
1813 }
1814 } else {
1815 current_block = 11913429853522160501;
1816 }
1817 } else if IS_DIGIT!((*parser).buffer) {
1818 if CHECK!((*parser).buffer, b'0') {
1819 yaml_parser_set_scanner_error(
1820 parser,
1821 b"while scanning a block scalar\0" as *const u8 as *const libc::c_char,
1822 start_mark,
1823 b"found an indentation indicator equal to 0\0" as *const u8
1824 as *const libc::c_char,
1825 );
1826 current_block = 14984465786483313892;
1827 } else {
1828 increment = AS_DIGIT!((*parser).buffer);
1829 SKIP(parser);
1830 if CACHE(parser, 1_u64).fail {
1831 current_block = 14984465786483313892;
1832 } else {
1833 if CHECK!((*parser).buffer, b'+') || CHECK!((*parser).buffer, b'-') {
1834 chomping = if CHECK!((*parser).buffer, b'+') {
1835 1
1836 } else {
1837 -1
1838 };
1839 SKIP(parser);
1840 }
1841 current_block = 11913429853522160501;
1842 }
1843 }
1844 } else {
1845 current_block = 11913429853522160501;
1846 }
1847 if current_block != 14984465786483313892 {
1848 if CACHE(parser, 1_u64).ok {
1849 loop {
1850 if !IS_BLANK!((*parser).buffer) {
1851 current_block = 4090602189656566074;
1852 break;
1853 }
1854 SKIP(parser);
1855 if CACHE(parser, 1_u64).fail {
1856 current_block = 14984465786483313892;
1857 break;
1858 }
1859 }
1860 if current_block != 14984465786483313892 {
1861 if CHECK!((*parser).buffer, b'#') {
1862 loop {
1863 if IS_BREAKZ!((*parser).buffer) {
1864 current_block = 12997042908615822766;
1865 break;
1866 }
1867 SKIP(parser);
1868 if CACHE(parser, 1_u64).fail {
1869 current_block = 14984465786483313892;
1870 break;
1871 }
1872 }
1873 } else {
1874 current_block = 12997042908615822766;
1875 }
1876 if current_block != 14984465786483313892 {
1877 if !IS_BREAKZ!((*parser).buffer) {
1878 yaml_parser_set_scanner_error(
1879 parser,
1880 b"while scanning a block scalar\0" as *const u8
1881 as *const libc::c_char,
1882 start_mark,
1883 b"did not find expected comment or line break\0" as *const u8
1884 as *const libc::c_char,
1885 );
1886 } else {
1887 if IS_BREAK!((*parser).buffer) {
1888 if CACHE(parser, 2_u64).fail {
1889 current_block = 14984465786483313892;
1890 } else {
1891 SKIP_LINE(parser);
1892 current_block = 13619784596304402172;
1893 }
1894 } else {
1895 current_block = 13619784596304402172;
1896 }
1897 if current_block != 14984465786483313892 {
1898 end_mark = (*parser).mark;
1899 if increment != 0 {
1900 indent = if (*parser).indent >= 0 {
1901 (*parser).indent + increment
1902 } else {
1903 increment
1904 };
1905 }
1906 if yaml_parser_scan_block_scalar_breaks(
1907 parser,
1908 addr_of_mut!(indent),
1909 addr_of_mut!(trailing_breaks),
1910 start_mark,
1911 addr_of_mut!(end_mark),
1912 )
1913 .ok
1914 {
1915 if CACHE(parser, 1_u64).ok {
1916 's_281: loop {
1917 if !((*parser).mark.column as libc::c_int == indent
1918 && !IS_Z!((*parser).buffer))
1919 {
1920 current_block = 5793491756164225964;
1921 break;
1922 }
1923 trailing_blank =
1924 IS_BLANK!((*parser).buffer) as libc::c_int;
1925 if !literal
1926 && *leading_break.start == b'\n'
1927 && leading_blank == 0
1928 && trailing_blank == 0
1929 {
1930 if *trailing_breaks.start == b'\0' {
1931 STRING_EXTEND!(string);
1932 let fresh418 = string.pointer;
1933 string.pointer =
1934 string.pointer.wrapping_offset(1);
1935 *fresh418 = b' ';
1936 }
1937 CLEAR!(leading_break);
1938 } else {
1939 JOIN!(string, leading_break);
1940 CLEAR!(leading_break);
1941 }
1942 JOIN!(string, trailing_breaks);
1943 CLEAR!(trailing_breaks);
1944 leading_blank =
1945 IS_BLANK!((*parser).buffer) as libc::c_int;
1946 while !IS_BREAKZ!((*parser).buffer) {
1947 READ!(parser, string);
1948 if CACHE(parser, 1_u64).fail {
1949 current_block = 14984465786483313892;
1950 break 's_281;
1951 }
1952 }
1953 if CACHE(parser, 2_u64).fail {
1954 current_block = 14984465786483313892;
1955 break;
1956 }
1957 READ_LINE!(parser, leading_break);
1958 if yaml_parser_scan_block_scalar_breaks(
1959 parser,
1960 addr_of_mut!(indent),
1961 addr_of_mut!(trailing_breaks),
1962 start_mark,
1963 addr_of_mut!(end_mark),
1964 )
1965 .fail
1966 {
1967 current_block = 14984465786483313892;
1968 break;
1969 }
1970 }
1971 if current_block != 14984465786483313892 {
1972 if chomping != -1 {
1973 JOIN!(string, leading_break);
1974 current_block = 17787701279558130514;
1975 } else {
1976 current_block = 17787701279558130514;
1977 }
1978 if current_block != 14984465786483313892 {
1979 if chomping == 1 {
1980 JOIN!(string, trailing_breaks);
1981 }
1982 memset(
1983 token as *mut libc::c_void,
1984 0,
1985 size_of::<yaml_token_t>() as libc::c_ulong,
1986 );
1987 (*token).type_ = YAML_SCALAR_TOKEN;
1988 (*token).start_mark = start_mark;
1989 (*token).end_mark = end_mark;
1990 let fresh479 =
1991 addr_of_mut!((*token).data.scalar.value);
1992 *fresh479 = string.start;
1993 (*token).data.scalar.length =
1994 string.pointer.c_offset_from(string.start)
1995 as size_t;
1996 (*token).data.scalar.style = if literal {
1997 YAML_LITERAL_SCALAR_STYLE
1998 } else {
1999 YAML_FOLDED_SCALAR_STYLE
2000 };
2001 STRING_DEL!(leading_break);
2002 STRING_DEL!(trailing_breaks);
2003 return OK;
2004 }
2005 }
2006 }
2007 }
2008 }
2009 }
2010 }
2011 }
2012 }
2013 }
2014 }
2015 STRING_DEL!(string);
2016 STRING_DEL!(leading_break);
2017 STRING_DEL!(trailing_breaks);
2018 FAIL
2019 }
2020
yaml_parser_scan_block_scalar_breaks( parser: *mut yaml_parser_t, indent: *mut libc::c_int, breaks: *mut yaml_string_t, start_mark: yaml_mark_t, end_mark: *mut yaml_mark_t, ) -> Success2021 unsafe fn yaml_parser_scan_block_scalar_breaks(
2022 parser: *mut yaml_parser_t,
2023 indent: *mut libc::c_int,
2024 breaks: *mut yaml_string_t,
2025 start_mark: yaml_mark_t,
2026 end_mark: *mut yaml_mark_t,
2027 ) -> Success {
2028 let mut max_indent: libc::c_int = 0;
2029 *end_mark = (*parser).mark;
2030 loop {
2031 if CACHE(parser, 1_u64).fail {
2032 return FAIL;
2033 }
2034 while (*indent == 0 || ((*parser).mark.column as libc::c_int) < *indent)
2035 && IS_SPACE!((*parser).buffer)
2036 {
2037 SKIP(parser);
2038 if CACHE(parser, 1_u64).fail {
2039 return FAIL;
2040 }
2041 }
2042 if (*parser).mark.column as libc::c_int > max_indent {
2043 max_indent = (*parser).mark.column as libc::c_int;
2044 }
2045 if (*indent == 0 || ((*parser).mark.column as libc::c_int) < *indent)
2046 && IS_TAB!((*parser).buffer)
2047 {
2048 yaml_parser_set_scanner_error(
2049 parser,
2050 b"while scanning a block scalar\0" as *const u8 as *const libc::c_char,
2051 start_mark,
2052 b"found a tab character where an indentation space is expected\0" as *const u8
2053 as *const libc::c_char,
2054 );
2055 return FAIL;
2056 }
2057 if !IS_BREAK!((*parser).buffer) {
2058 break;
2059 }
2060 if CACHE(parser, 2_u64).fail {
2061 return FAIL;
2062 }
2063 READ_LINE!(parser, *breaks);
2064 *end_mark = (*parser).mark;
2065 }
2066 if *indent == 0 {
2067 *indent = max_indent;
2068 if *indent < (*parser).indent + 1 {
2069 *indent = (*parser).indent + 1;
2070 }
2071 if *indent < 1 {
2072 *indent = 1;
2073 }
2074 }
2075 OK
2076 }
2077
yaml_parser_scan_flow_scalar( parser: *mut yaml_parser_t, token: *mut yaml_token_t, single: bool, ) -> Success2078 unsafe fn yaml_parser_scan_flow_scalar(
2079 parser: *mut yaml_parser_t,
2080 token: *mut yaml_token_t,
2081 single: bool,
2082 ) -> Success {
2083 let current_block: u64;
2084 let end_mark: yaml_mark_t;
2085 let mut string = NULL_STRING;
2086 let mut leading_break = NULL_STRING;
2087 let mut trailing_breaks = NULL_STRING;
2088 let mut whitespaces = NULL_STRING;
2089 let mut leading_blanks;
2090 STRING_INIT!(string);
2091 STRING_INIT!(leading_break);
2092 STRING_INIT!(trailing_breaks);
2093 STRING_INIT!(whitespaces);
2094 let start_mark: yaml_mark_t = (*parser).mark;
2095 SKIP(parser);
2096 's_58: loop {
2097 if CACHE(parser, 4_u64).fail {
2098 current_block = 8114179180390253173;
2099 break;
2100 }
2101 if (*parser).mark.column == 0_u64
2102 && (CHECK_AT!((*parser).buffer, b'-', 0)
2103 && CHECK_AT!((*parser).buffer, b'-', 1)
2104 && CHECK_AT!((*parser).buffer, b'-', 2)
2105 || CHECK_AT!((*parser).buffer, b'.', 0)
2106 && CHECK_AT!((*parser).buffer, b'.', 1)
2107 && CHECK_AT!((*parser).buffer, b'.', 2))
2108 && IS_BLANKZ_AT!((*parser).buffer, 3)
2109 {
2110 yaml_parser_set_scanner_error(
2111 parser,
2112 b"while scanning a quoted scalar\0" as *const u8 as *const libc::c_char,
2113 start_mark,
2114 b"found unexpected document indicator\0" as *const u8 as *const libc::c_char,
2115 );
2116 current_block = 8114179180390253173;
2117 break;
2118 } else if IS_Z!((*parser).buffer) {
2119 yaml_parser_set_scanner_error(
2120 parser,
2121 b"while scanning a quoted scalar\0" as *const u8 as *const libc::c_char,
2122 start_mark,
2123 b"found unexpected end of stream\0" as *const u8 as *const libc::c_char,
2124 );
2125 current_block = 8114179180390253173;
2126 break;
2127 } else {
2128 if CACHE(parser, 2_u64).fail {
2129 current_block = 8114179180390253173;
2130 break;
2131 }
2132 leading_blanks = false;
2133 while !IS_BLANKZ!((*parser).buffer) {
2134 if single
2135 && CHECK_AT!((*parser).buffer, b'\'', 0)
2136 && CHECK_AT!((*parser).buffer, b'\'', 1)
2137 {
2138 STRING_EXTEND!(string);
2139 let fresh521 = string.pointer;
2140 string.pointer = string.pointer.wrapping_offset(1);
2141 *fresh521 = b'\'';
2142 SKIP(parser);
2143 SKIP(parser);
2144 } else {
2145 if CHECK!((*parser).buffer, if single { b'\'' } else { b'"' }) {
2146 break;
2147 }
2148 if !single
2149 && CHECK!((*parser).buffer, b'\\')
2150 && IS_BREAK_AT!((*parser).buffer, 1)
2151 {
2152 if CACHE(parser, 3_u64).fail {
2153 current_block = 8114179180390253173;
2154 break 's_58;
2155 }
2156 SKIP(parser);
2157 SKIP_LINE(parser);
2158 leading_blanks = true;
2159 break;
2160 } else if !single && CHECK!((*parser).buffer, b'\\') {
2161 let mut code_length: size_t = 0_u64;
2162 STRING_EXTEND!(string);
2163 match *(*parser).buffer.pointer.wrapping_offset(1_isize) {
2164 b'0' => {
2165 let fresh542 = string.pointer;
2166 string.pointer = string.pointer.wrapping_offset(1);
2167 *fresh542 = b'\0';
2168 }
2169 b'a' => {
2170 let fresh543 = string.pointer;
2171 string.pointer = string.pointer.wrapping_offset(1);
2172 *fresh543 = b'\x07';
2173 }
2174 b'b' => {
2175 let fresh544 = string.pointer;
2176 string.pointer = string.pointer.wrapping_offset(1);
2177 *fresh544 = b'\x08';
2178 }
2179 b't' | b'\t' => {
2180 let fresh545 = string.pointer;
2181 string.pointer = string.pointer.wrapping_offset(1);
2182 *fresh545 = b'\t';
2183 }
2184 b'n' => {
2185 let fresh546 = string.pointer;
2186 string.pointer = string.pointer.wrapping_offset(1);
2187 *fresh546 = b'\n';
2188 }
2189 b'v' => {
2190 let fresh547 = string.pointer;
2191 string.pointer = string.pointer.wrapping_offset(1);
2192 *fresh547 = b'\x0B';
2193 }
2194 b'f' => {
2195 let fresh548 = string.pointer;
2196 string.pointer = string.pointer.wrapping_offset(1);
2197 *fresh548 = b'\x0C';
2198 }
2199 b'r' => {
2200 let fresh549 = string.pointer;
2201 string.pointer = string.pointer.wrapping_offset(1);
2202 *fresh549 = b'\r';
2203 }
2204 b'e' => {
2205 let fresh550 = string.pointer;
2206 string.pointer = string.pointer.wrapping_offset(1);
2207 *fresh550 = b'\x1B';
2208 }
2209 b' ' => {
2210 let fresh551 = string.pointer;
2211 string.pointer = string.pointer.wrapping_offset(1);
2212 *fresh551 = b' ';
2213 }
2214 b'"' => {
2215 let fresh552 = string.pointer;
2216 string.pointer = string.pointer.wrapping_offset(1);
2217 *fresh552 = b'"';
2218 }
2219 b'/' => {
2220 let fresh553 = string.pointer;
2221 string.pointer = string.pointer.wrapping_offset(1);
2222 *fresh553 = b'/';
2223 }
2224 b'\\' => {
2225 let fresh554 = string.pointer;
2226 string.pointer = string.pointer.wrapping_offset(1);
2227 *fresh554 = b'\\';
2228 }
2229 // NEL (#x85)
2230 b'N' => {
2231 let fresh555 = string.pointer;
2232 string.pointer = string.pointer.wrapping_offset(1);
2233 *fresh555 = b'\xC2';
2234 let fresh556 = string.pointer;
2235 string.pointer = string.pointer.wrapping_offset(1);
2236 *fresh556 = b'\x85';
2237 }
2238 // #xA0
2239 b'_' => {
2240 let fresh557 = string.pointer;
2241 string.pointer = string.pointer.wrapping_offset(1);
2242 *fresh557 = b'\xC2';
2243 let fresh558 = string.pointer;
2244 string.pointer = string.pointer.wrapping_offset(1);
2245 *fresh558 = b'\xA0';
2246 }
2247 // LS (#x2028)
2248 b'L' => {
2249 let fresh559 = string.pointer;
2250 string.pointer = string.pointer.wrapping_offset(1);
2251 *fresh559 = b'\xE2';
2252 let fresh560 = string.pointer;
2253 string.pointer = string.pointer.wrapping_offset(1);
2254 *fresh560 = b'\x80';
2255 let fresh561 = string.pointer;
2256 string.pointer = string.pointer.wrapping_offset(1);
2257 *fresh561 = b'\xA8';
2258 }
2259 // PS (#x2029)
2260 b'P' => {
2261 let fresh562 = string.pointer;
2262 string.pointer = string.pointer.wrapping_offset(1);
2263 *fresh562 = b'\xE2';
2264 let fresh563 = string.pointer;
2265 string.pointer = string.pointer.wrapping_offset(1);
2266 *fresh563 = b'\x80';
2267 let fresh564 = string.pointer;
2268 string.pointer = string.pointer.wrapping_offset(1);
2269 *fresh564 = b'\xA9';
2270 }
2271 b'x' => {
2272 code_length = 2_u64;
2273 }
2274 b'u' => {
2275 code_length = 4_u64;
2276 }
2277 b'U' => {
2278 code_length = 8_u64;
2279 }
2280 _ => {
2281 yaml_parser_set_scanner_error(
2282 parser,
2283 b"while parsing a quoted scalar\0" as *const u8
2284 as *const libc::c_char,
2285 start_mark,
2286 b"found unknown escape character\0" as *const u8
2287 as *const libc::c_char,
2288 );
2289 current_block = 8114179180390253173;
2290 break 's_58;
2291 }
2292 }
2293 SKIP(parser);
2294 SKIP(parser);
2295 if code_length != 0 {
2296 let mut value: libc::c_uint = 0;
2297 let mut k: size_t;
2298 if CACHE(parser, code_length).fail {
2299 current_block = 8114179180390253173;
2300 break 's_58;
2301 }
2302 k = 0_u64;
2303 while k < code_length {
2304 if !IS_HEX_AT!((*parser).buffer, k as isize) {
2305 yaml_parser_set_scanner_error(
2306 parser,
2307 b"while parsing a quoted scalar\0" as *const u8
2308 as *const libc::c_char,
2309 start_mark,
2310 b"did not find expected hexdecimal number\0" as *const u8
2311 as *const libc::c_char,
2312 );
2313 current_block = 8114179180390253173;
2314 break 's_58;
2315 } else {
2316 value = (value << 4).force_add(AS_HEX_AT!(
2317 (*parser).buffer,
2318 k as isize
2319 )
2320 as libc::c_uint);
2321 k = k.force_add(1);
2322 }
2323 }
2324 if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
2325 yaml_parser_set_scanner_error(
2326 parser,
2327 b"while parsing a quoted scalar\0" as *const u8
2328 as *const libc::c_char,
2329 start_mark,
2330 b"found invalid Unicode character escape code\0" as *const u8
2331 as *const libc::c_char,
2332 );
2333 current_block = 8114179180390253173;
2334 break 's_58;
2335 } else {
2336 if value <= 0x7F {
2337 let fresh573 = string.pointer;
2338 string.pointer = string.pointer.wrapping_offset(1);
2339 *fresh573 = value as yaml_char_t;
2340 } else if value <= 0x7FF {
2341 let fresh574 = string.pointer;
2342 string.pointer = string.pointer.wrapping_offset(1);
2343 *fresh574 = 0xC0_u32.force_add(value >> 6) as yaml_char_t;
2344 let fresh575 = string.pointer;
2345 string.pointer = string.pointer.wrapping_offset(1);
2346 *fresh575 = 0x80_u32.force_add(value & 0x3F) as yaml_char_t;
2347 } else if value <= 0xFFFF {
2348 let fresh576 = string.pointer;
2349 string.pointer = string.pointer.wrapping_offset(1);
2350 *fresh576 = 0xE0_u32.force_add(value >> 12) as yaml_char_t;
2351 let fresh577 = string.pointer;
2352 string.pointer = string.pointer.wrapping_offset(1);
2353 *fresh577 =
2354 0x80_u32.force_add(value >> 6 & 0x3F) as yaml_char_t;
2355 let fresh578 = string.pointer;
2356 string.pointer = string.pointer.wrapping_offset(1);
2357 *fresh578 = 0x80_u32.force_add(value & 0x3F) as yaml_char_t;
2358 } else {
2359 let fresh579 = string.pointer;
2360 string.pointer = string.pointer.wrapping_offset(1);
2361 *fresh579 = 0xF0_u32.force_add(value >> 18) as yaml_char_t;
2362 let fresh580 = string.pointer;
2363 string.pointer = string.pointer.wrapping_offset(1);
2364 *fresh580 =
2365 0x80_u32.force_add(value >> 12 & 0x3F) as yaml_char_t;
2366 let fresh581 = string.pointer;
2367 string.pointer = string.pointer.wrapping_offset(1);
2368 *fresh581 =
2369 0x80_u32.force_add(value >> 6 & 0x3F) as yaml_char_t;
2370 let fresh582 = string.pointer;
2371 string.pointer = string.pointer.wrapping_offset(1);
2372 *fresh582 = 0x80_u32.force_add(value & 0x3F) as yaml_char_t;
2373 }
2374 k = 0_u64;
2375 while k < code_length {
2376 SKIP(parser);
2377 k = k.force_add(1);
2378 }
2379 }
2380 }
2381 } else {
2382 READ!(parser, string);
2383 }
2384 }
2385 if CACHE(parser, 2_u64).fail {
2386 current_block = 8114179180390253173;
2387 break 's_58;
2388 }
2389 }
2390 if CACHE(parser, 1_u64).fail {
2391 current_block = 8114179180390253173;
2392 break;
2393 }
2394 if CHECK!((*parser).buffer, if single { b'\'' } else { b'"' }) {
2395 current_block = 7468767852762055642;
2396 break;
2397 }
2398 if CACHE(parser, 1_u64).fail {
2399 current_block = 8114179180390253173;
2400 break;
2401 }
2402 while IS_BLANK!((*parser).buffer) || IS_BREAK!((*parser).buffer) {
2403 if IS_BLANK!((*parser).buffer) {
2404 if !leading_blanks {
2405 READ!(parser, whitespaces);
2406 } else {
2407 SKIP(parser);
2408 }
2409 } else {
2410 if CACHE(parser, 2_u64).fail {
2411 current_block = 8114179180390253173;
2412 break 's_58;
2413 }
2414 if !leading_blanks {
2415 CLEAR!(whitespaces);
2416 READ_LINE!(parser, leading_break);
2417 leading_blanks = true;
2418 } else {
2419 READ_LINE!(parser, trailing_breaks);
2420 }
2421 }
2422 if CACHE(parser, 1_u64).fail {
2423 current_block = 8114179180390253173;
2424 break 's_58;
2425 }
2426 }
2427 if leading_blanks {
2428 if *leading_break.start == b'\n' {
2429 if *trailing_breaks.start == b'\0' {
2430 STRING_EXTEND!(string);
2431 let fresh711 = string.pointer;
2432 string.pointer = string.pointer.wrapping_offset(1);
2433 *fresh711 = b' ';
2434 } else {
2435 JOIN!(string, trailing_breaks);
2436 CLEAR!(trailing_breaks);
2437 }
2438 CLEAR!(leading_break);
2439 } else {
2440 JOIN!(string, leading_break);
2441 JOIN!(string, trailing_breaks);
2442 CLEAR!(leading_break);
2443 CLEAR!(trailing_breaks);
2444 }
2445 } else {
2446 JOIN!(string, whitespaces);
2447 CLEAR!(whitespaces);
2448 }
2449 }
2450 }
2451 if current_block != 8114179180390253173 {
2452 SKIP(parser);
2453 end_mark = (*parser).mark;
2454 memset(
2455 token as *mut libc::c_void,
2456 0,
2457 size_of::<yaml_token_t>() as libc::c_ulong,
2458 );
2459 (*token).type_ = YAML_SCALAR_TOKEN;
2460 (*token).start_mark = start_mark;
2461 (*token).end_mark = end_mark;
2462 let fresh716 = addr_of_mut!((*token).data.scalar.value);
2463 *fresh716 = string.start;
2464 (*token).data.scalar.length = string.pointer.c_offset_from(string.start) as size_t;
2465 (*token).data.scalar.style = if single {
2466 YAML_SINGLE_QUOTED_SCALAR_STYLE
2467 } else {
2468 YAML_DOUBLE_QUOTED_SCALAR_STYLE
2469 };
2470 STRING_DEL!(leading_break);
2471 STRING_DEL!(trailing_breaks);
2472 STRING_DEL!(whitespaces);
2473 return OK;
2474 }
2475 STRING_DEL!(string);
2476 STRING_DEL!(leading_break);
2477 STRING_DEL!(trailing_breaks);
2478 STRING_DEL!(whitespaces);
2479 FAIL
2480 }
2481
yaml_parser_scan_plain_scalar( parser: *mut yaml_parser_t, token: *mut yaml_token_t, ) -> Success2482 unsafe fn yaml_parser_scan_plain_scalar(
2483 parser: *mut yaml_parser_t,
2484 token: *mut yaml_token_t,
2485 ) -> Success {
2486 let current_block: u64;
2487 let mut end_mark: yaml_mark_t;
2488 let mut string = NULL_STRING;
2489 let mut leading_break = NULL_STRING;
2490 let mut trailing_breaks = NULL_STRING;
2491 let mut whitespaces = NULL_STRING;
2492 let mut leading_blanks = false;
2493 let indent: libc::c_int = (*parser).indent + 1;
2494 STRING_INIT!(string);
2495 STRING_INIT!(leading_break);
2496 STRING_INIT!(trailing_breaks);
2497 STRING_INIT!(whitespaces);
2498 end_mark = (*parser).mark;
2499 let start_mark: yaml_mark_t = end_mark;
2500 's_57: loop {
2501 if CACHE(parser, 4_u64).fail {
2502 current_block = 16642808987012640029;
2503 break;
2504 }
2505 if (*parser).mark.column == 0_u64
2506 && (CHECK_AT!((*parser).buffer, b'-', 0)
2507 && CHECK_AT!((*parser).buffer, b'-', 1)
2508 && CHECK_AT!((*parser).buffer, b'-', 2)
2509 || CHECK_AT!((*parser).buffer, b'.', 0)
2510 && CHECK_AT!((*parser).buffer, b'.', 1)
2511 && CHECK_AT!((*parser).buffer, b'.', 2))
2512 && IS_BLANKZ_AT!((*parser).buffer, 3)
2513 {
2514 current_block = 6281126495347172768;
2515 break;
2516 }
2517 if CHECK!((*parser).buffer, b'#') {
2518 current_block = 6281126495347172768;
2519 break;
2520 }
2521 while !IS_BLANKZ!((*parser).buffer) {
2522 if (*parser).flow_level != 0
2523 && CHECK!((*parser).buffer, b':')
2524 && (CHECK_AT!((*parser).buffer, b',', 1)
2525 || CHECK_AT!((*parser).buffer, b'?', 1)
2526 || CHECK_AT!((*parser).buffer, b'[', 1)
2527 || CHECK_AT!((*parser).buffer, b']', 1)
2528 || CHECK_AT!((*parser).buffer, b'{', 1)
2529 || CHECK_AT!((*parser).buffer, b'}', 1))
2530 {
2531 yaml_parser_set_scanner_error(
2532 parser,
2533 b"while scanning a plain scalar\0" as *const u8 as *const libc::c_char,
2534 start_mark,
2535 b"found unexpected ':'\0" as *const u8 as *const libc::c_char,
2536 );
2537 current_block = 16642808987012640029;
2538 break 's_57;
2539 } else {
2540 if CHECK!((*parser).buffer, b':') && IS_BLANKZ_AT!((*parser).buffer, 1)
2541 || (*parser).flow_level != 0
2542 && (CHECK!((*parser).buffer, b',')
2543 || CHECK!((*parser).buffer, b'[')
2544 || CHECK!((*parser).buffer, b']')
2545 || CHECK!((*parser).buffer, b'{')
2546 || CHECK!((*parser).buffer, b'}'))
2547 {
2548 break;
2549 }
2550 if leading_blanks || whitespaces.start != whitespaces.pointer {
2551 if leading_blanks {
2552 if *leading_break.start == b'\n' {
2553 if *trailing_breaks.start == b'\0' {
2554 STRING_EXTEND!(string);
2555 let fresh717 = string.pointer;
2556 string.pointer = string.pointer.wrapping_offset(1);
2557 *fresh717 = b' ';
2558 } else {
2559 JOIN!(string, trailing_breaks);
2560 CLEAR!(trailing_breaks);
2561 }
2562 CLEAR!(leading_break);
2563 } else {
2564 JOIN!(string, leading_break);
2565 JOIN!(string, trailing_breaks);
2566 CLEAR!(leading_break);
2567 CLEAR!(trailing_breaks);
2568 }
2569 leading_blanks = false;
2570 } else {
2571 JOIN!(string, whitespaces);
2572 CLEAR!(whitespaces);
2573 }
2574 }
2575 READ!(parser, string);
2576 end_mark = (*parser).mark;
2577 if CACHE(parser, 2_u64).fail {
2578 current_block = 16642808987012640029;
2579 break 's_57;
2580 }
2581 }
2582 }
2583 if !(IS_BLANK!((*parser).buffer) || IS_BREAK!((*parser).buffer)) {
2584 current_block = 6281126495347172768;
2585 break;
2586 }
2587 if CACHE(parser, 1_u64).fail {
2588 current_block = 16642808987012640029;
2589 break;
2590 }
2591 while IS_BLANK!((*parser).buffer) || IS_BREAK!((*parser).buffer) {
2592 if IS_BLANK!((*parser).buffer) {
2593 if leading_blanks
2594 && ((*parser).mark.column as libc::c_int) < indent
2595 && IS_TAB!((*parser).buffer)
2596 {
2597 yaml_parser_set_scanner_error(
2598 parser,
2599 b"while scanning a plain scalar\0" as *const u8 as *const libc::c_char,
2600 start_mark,
2601 b"found a tab character that violates indentation\0" as *const u8
2602 as *const libc::c_char,
2603 );
2604 current_block = 16642808987012640029;
2605 break 's_57;
2606 } else if !leading_blanks {
2607 READ!(parser, whitespaces);
2608 } else {
2609 SKIP(parser);
2610 }
2611 } else {
2612 if CACHE(parser, 2_u64).fail {
2613 current_block = 16642808987012640029;
2614 break 's_57;
2615 }
2616 if !leading_blanks {
2617 CLEAR!(whitespaces);
2618 READ_LINE!(parser, leading_break);
2619 leading_blanks = true;
2620 } else {
2621 READ_LINE!(parser, trailing_breaks);
2622 }
2623 }
2624 if CACHE(parser, 1_u64).fail {
2625 current_block = 16642808987012640029;
2626 break 's_57;
2627 }
2628 }
2629 if (*parser).flow_level == 0 && ((*parser).mark.column as libc::c_int) < indent {
2630 current_block = 6281126495347172768;
2631 break;
2632 }
2633 }
2634 if current_block != 16642808987012640029 {
2635 memset(
2636 token as *mut libc::c_void,
2637 0,
2638 size_of::<yaml_token_t>() as libc::c_ulong,
2639 );
2640 (*token).type_ = YAML_SCALAR_TOKEN;
2641 (*token).start_mark = start_mark;
2642 (*token).end_mark = end_mark;
2643 let fresh842 = addr_of_mut!((*token).data.scalar.value);
2644 *fresh842 = string.start;
2645 (*token).data.scalar.length = string.pointer.c_offset_from(string.start) as size_t;
2646 (*token).data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
2647 if leading_blanks {
2648 (*parser).simple_key_allowed = true;
2649 }
2650 STRING_DEL!(leading_break);
2651 STRING_DEL!(trailing_breaks);
2652 STRING_DEL!(whitespaces);
2653 return OK;
2654 }
2655 STRING_DEL!(string);
2656 STRING_DEL!(leading_break);
2657 STRING_DEL!(trailing_breaks);
2658 STRING_DEL!(whitespaces);
2659 FAIL
2660 }
2661