yaml_malloc: 32| 22.7M|{ 33| 22.7M| return malloc(size ? size : 1); ------------------ | Branch (33:19): [True: 22.7M, False: 0] ------------------ 34| 22.7M|} yaml_realloc: 42| 288k|{ 43| 288k| return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1); ------------------ | Branch (43:12): [True: 288k, False: 0] | Branch (43:31): [True: 288k, False: 0] | Branch (43:57): [True: 0, False: 0] ------------------ 44| 288k|} yaml_free: 52| 50.9M|{ 53| 50.9M| if (ptr) free(ptr); ------------------ | Branch (53:9): [True: 34.2M, False: 16.6M] ------------------ 54| 50.9M|} yaml_strdup: 62| 11.5M|{ 63| 11.5M| if (!str) ------------------ | Branch (63:9): [True: 0, False: 11.5M] ------------------ 64| 0| return NULL; 65| | 66| 11.5M| return (yaml_char_t *)strdup((char *)str); 67| 11.5M|} yaml_string_extend: 76| 144k|{ 77| 144k| yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2); 78| | 79| 144k| if (!new_start) return 0; ------------------ | Branch (79:9): [True: 0, False: 144k] ------------------ 80| | 81| 144k| memset(new_start + (*end - *start), 0, *end - *start); 82| | 83| 144k| *pointer = new_start + (*pointer - *start); 84| 144k| *end = new_start + (*end - *start)*2; 85| 144k| *start = new_start; 86| | 87| 144k| return 1; 88| 144k|} yaml_string_join: 98| 4.44M|{ 99| 4.44M| UNUSED_PARAM(b_end) ------------------ | | 678| 4.44M|# define UNUSED_PARAM(a) (void)(a); ------------------ 100| 4.44M| if (*b_start == *b_pointer) ------------------ | Branch (100:9): [True: 680k, False: 3.76M] ------------------ 101| 680k| return 1; 102| | 103| 3.77M| while (*a_end - *a_pointer <= *b_pointer - *b_start) { ------------------ | Branch (103:12): [True: 9.69k, False: 3.76M] ------------------ 104| 9.69k| if (!yaml_string_extend(a_start, a_pointer, a_end)) ------------------ | Branch (104:13): [True: 0, False: 9.69k] ------------------ 105| 0| return 0; 106| 9.69k| } 107| | 108| 3.76M| memcpy(*a_pointer, *b_start, *b_pointer - *b_start); 109| 3.76M| *a_pointer += *b_pointer - *b_start; 110| | 111| 3.76M| return 1; 112| 3.76M|} yaml_stack_extend: 120| 138k|{ 121| 138k| void *new_start; 122| | 123| 138k| if ((char *)*end - (char *)*start >= INT_MAX / 2) ------------------ | Branch (123:9): [True: 0, False: 138k] ------------------ 124| 0| return 0; 125| | 126| 138k| new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2); 127| | 128| 138k| if (!new_start) return 0; ------------------ | Branch (128:9): [True: 0, False: 138k] ------------------ 129| | 130| 138k| *top = (char *)new_start + ((char *)*top - (char *)*start); 131| 138k| *end = (char *)new_start + ((char *)*end - (char *)*start)*2; 132| 138k| *start = new_start; 133| | 134| 138k| return 1; 135| 138k|} yaml_queue_extend: 143| 969k|{ 144| | /* Check if we need to resize the queue. */ 145| | 146| 969k| if (*start == *head && *tail == *end) { ------------------ | Branch (146:9): [True: 5.12k, False: 964k] | Branch (146:28): [True: 5.12k, False: 0] ------------------ 147| 5.12k| void *new_start = yaml_realloc(*start, 148| 5.12k| ((char *)*end - (char *)*start)*2); 149| | 150| 5.12k| if (!new_start) return 0; ------------------ | Branch (150:13): [True: 0, False: 5.12k] ------------------ 151| | 152| 5.12k| *head = (char *)new_start + ((char *)*head - (char *)*start); 153| 5.12k| *tail = (char *)new_start + ((char *)*tail - (char *)*start); 154| 5.12k| *end = (char *)new_start + ((char *)*end - (char *)*start)*2; 155| 5.12k| *start = new_start; 156| 5.12k| } 157| | 158| | /* Check if we need to move the queue at the beginning of the buffer. */ 159| | 160| 969k| if (*tail == *end) { ------------------ | Branch (160:9): [True: 964k, False: 5.12k] ------------------ 161| 964k| if (*head != *tail) { ------------------ | Branch (161:13): [True: 351k, False: 612k] ------------------ 162| 351k| memmove(*start, *head, (char *)*tail - (char *)*head); 163| 351k| } 164| 964k| *tail = (char *)*tail - (char *)*head + (char *)*start; 165| 964k| *head = *start; 166| 964k| } 167| | 168| 969k| return 1; 169| 969k|} yaml_parser_initialize: 178| 10.9k|{ 179| 10.9k| assert(parser); /* Non-NULL parser object expected. */ ------------------ | Branch (179:5): [True: 0, False: 10.9k] | Branch (179:5): [True: 10.9k, False: 0] ------------------ 180| | 181| 10.9k| memset(parser, 0, sizeof(yaml_parser_t)); 182| 10.9k| if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE)) ------------------ | | 93| 10.9k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 10.9k, False: 0] | | ------------------ | | 94| 10.9k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 10.9k| (buffer).end = (buffer).start+(size), \ | | 96| 10.9k| 1) : \ | | 97| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (182:9): [True: 0, False: 10.9k] ------------------ 183| 0| goto error; 184| 10.9k| if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE)) ------------------ | | 93| 10.9k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 10.9k, False: 0] | | ------------------ | | 94| 10.9k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 10.9k| (buffer).end = (buffer).start+(size), \ | | 96| 10.9k| 1) : \ | | 97| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (184:9): [True: 0, False: 10.9k] ------------------ 185| 0| goto error; 186| 10.9k| if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*)) ------------------ | | 457| 10.9k| (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \ | | ------------------ | | | Branch (457:4): [True: 10.9k, False: 0] | | ------------------ | | 458| 10.9k| ((queue).head = (queue).tail = (queue).start, \ | | 459| 10.9k| (queue).end = (queue).start+(size), \ | | 460| 10.9k| 1) : \ | | 461| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 462| 0| 0)) ------------------ | Branch (186:9): [True: 0, False: 10.9k] ------------------ 187| 0| goto error; 188| 10.9k| if (!STACK_INIT(parser, parser->indents, int*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (188:9): [True: 0, False: 10.9k] ------------------ 189| 0| goto error; 190| 10.9k| if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (190:9): [True: 0, False: 10.9k] ------------------ 191| 0| goto error; 192| 10.9k| if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (192:9): [True: 0, False: 10.9k] ------------------ 193| 0| goto error; 194| 10.9k| if (!STACK_INIT(parser, parser->marks, yaml_mark_t*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (194:9): [True: 0, False: 10.9k] ------------------ 195| 0| goto error; 196| 10.9k| if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (196:9): [True: 0, False: 10.9k] ------------------ 197| 0| goto error; 198| | 199| 10.9k| return 1; 200| | 201| 0|error: 202| | 203| 0| BUFFER_DEL(parser, parser->raw_buffer); ------------------ | | 101| 0| (yaml_free((buffer).start), \ | | 102| 0| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 204| 0| BUFFER_DEL(parser, parser->buffer); ------------------ | | 101| 0| (yaml_free((buffer).start), \ | | 102| 0| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 205| 0| QUEUE_DEL(parser, parser->tokens); ------------------ | | 465| 0| (yaml_free((queue).start), \ | | 466| 0| (queue).start = (queue).head = (queue).tail = (queue).end = 0) ------------------ 206| 0| STACK_DEL(parser, parser->indents); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 207| 0| STACK_DEL(parser, parser->simple_keys); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 208| 0| STACK_DEL(parser, parser->states); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 209| 0| STACK_DEL(parser, parser->marks); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 210| 0| STACK_DEL(parser, parser->tag_directives); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 211| | 212| 0| return 0; 213| 10.9k|} yaml_parser_delete: 221| 10.9k|{ 222| 10.9k| assert(parser); /* Non-NULL parser object expected. */ ------------------ | Branch (222:5): [True: 0, False: 10.9k] | Branch (222:5): [True: 10.9k, False: 0] ------------------ 223| | 224| 10.9k| BUFFER_DEL(parser, parser->raw_buffer); ------------------ | | 101| 10.9k| (yaml_free((buffer).start), \ | | 102| 10.9k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 225| 10.9k| BUFFER_DEL(parser, parser->buffer); ------------------ | | 101| 10.9k| (yaml_free((buffer).start), \ | | 102| 10.9k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 226| 56.8k| while (!QUEUE_EMPTY(parser, parser->tokens)) { ------------------ | | 469| 56.8k| ((queue).head == (queue).tail) ------------------ | Branch (226:12): [True: 45.8k, False: 10.9k] ------------------ 227| 45.8k| yaml_token_delete(&DEQUEUE(parser, parser->tokens)); ------------------ | | 481| 45.8k| (*((queue).head++)) ------------------ 228| 45.8k| } 229| 10.9k| QUEUE_DEL(parser, parser->tokens); ------------------ | | 465| 10.9k| (yaml_free((queue).start), \ | | 466| 10.9k| (queue).start = (queue).head = (queue).tail = (queue).end = 0) ------------------ 230| 10.9k| STACK_DEL(parser, parser->indents); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 231| 10.9k| STACK_DEL(parser, parser->simple_keys); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 232| 10.9k| STACK_DEL(parser, parser->states); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 233| 10.9k| STACK_DEL(parser, parser->marks); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 234| 16.5k| while (!STACK_EMPTY(parser, parser->tag_directives)) { ------------------ | | 436| 16.5k| ((stack).start == (stack).top) ------------------ | Branch (234:12): [True: 5.56k, False: 10.9k] ------------------ 235| 5.56k| yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); ------------------ | | 454| 5.56k| (*(--(stack).top)) ------------------ 236| 5.56k| yaml_free(tag_directive.handle); 237| 5.56k| yaml_free(tag_directive.prefix); 238| 5.56k| } 239| 10.9k| STACK_DEL(parser, parser->tag_directives); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 240| | 241| 10.9k| memset(parser, 0, sizeof(yaml_parser_t)); 242| 10.9k|} yaml_parser_set_input_string: 291| 10.9k|{ 292| 10.9k| assert(parser); /* Non-NULL parser object expected. */ ------------------ | Branch (292:5): [True: 0, False: 10.9k] | Branch (292:5): [True: 10.9k, False: 0] ------------------ 293| 10.9k| assert(!parser->read_handler); /* You can set the source only once. */ ------------------ | Branch (293:5): [True: 0, False: 10.9k] | Branch (293:5): [True: 10.9k, False: 0] ------------------ 294| 10.9k| assert(input); /* Non-NULL input string expected. */ ------------------ | Branch (294:5): [True: 0, False: 10.9k] | Branch (294:5): [True: 10.9k, False: 0] ------------------ 295| | 296| 10.9k| parser->read_handler = yaml_string_read_handler; 297| 10.9k| parser->read_handler_data = parser; 298| | 299| 10.9k| parser->input.string.start = input; 300| 10.9k| parser->input.string.current = input; 301| 10.9k| parser->input.string.end = input+size; 302| 10.9k|} yaml_emitter_initialize: 356| 10.9k|{ 357| 10.9k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (357:5): [True: 0, False: 10.9k] | Branch (357:5): [True: 10.9k, False: 0] ------------------ 358| | 359| 10.9k| memset(emitter, 0, sizeof(yaml_emitter_t)); 360| 10.9k| if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE)) ------------------ | | 93| 10.9k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 10.9k, False: 0] | | ------------------ | | 94| 10.9k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 10.9k| (buffer).end = (buffer).start+(size), \ | | 96| 10.9k| 1) : \ | | 97| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (360:9): [True: 0, False: 10.9k] ------------------ 361| 0| goto error; 362| 10.9k| if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE)) ------------------ | | 93| 10.9k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 10.9k, False: 0] | | ------------------ | | 94| 10.9k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 10.9k| (buffer).end = (buffer).start+(size), \ | | 96| 10.9k| 1) : \ | | 97| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (362:9): [True: 0, False: 10.9k] ------------------ 363| 0| goto error; 364| 10.9k| if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (364:9): [True: 0, False: 10.9k] ------------------ 365| 0| goto error; 366| 10.9k| if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*)) ------------------ | | 457| 10.9k| (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \ | | ------------------ | | | Branch (457:4): [True: 10.9k, False: 0] | | ------------------ | | 458| 10.9k| ((queue).head = (queue).tail = (queue).start, \ | | 459| 10.9k| (queue).end = (queue).start+(size), \ | | 460| 10.9k| 1) : \ | | 461| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 462| 0| 0)) ------------------ | Branch (366:9): [True: 0, False: 10.9k] ------------------ 367| 0| goto error; 368| 10.9k| if (!STACK_INIT(emitter, emitter->indents, int*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (368:9): [True: 0, False: 10.9k] ------------------ 369| 0| goto error; 370| 10.9k| if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*)) ------------------ | | 424| 10.9k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 10.9k, False: 0] | | ------------------ | | 425| 10.9k| ((stack).top = (stack).start, \ | | 426| 10.9k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 10.9k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 10.9k| 1) : \ | | 428| 10.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (370:9): [True: 0, False: 10.9k] ------------------ 371| 0| goto error; 372| | 373| 10.9k| return 1; 374| | 375| 0|error: 376| | 377| 0| BUFFER_DEL(emitter, emitter->buffer); ------------------ | | 101| 0| (yaml_free((buffer).start), \ | | 102| 0| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 378| 0| BUFFER_DEL(emitter, emitter->raw_buffer); ------------------ | | 101| 0| (yaml_free((buffer).start), \ | | 102| 0| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 379| 0| STACK_DEL(emitter, emitter->states); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 380| 0| QUEUE_DEL(emitter, emitter->events); ------------------ | | 465| 0| (yaml_free((queue).start), \ | | 466| 0| (queue).start = (queue).head = (queue).tail = (queue).end = 0) ------------------ 381| 0| STACK_DEL(emitter, emitter->indents); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 382| 0| STACK_DEL(emitter, emitter->tag_directives); ------------------ | | 432| 0| (yaml_free((stack).start), \ | | 433| 0| (stack).start = (stack).top = (stack).end = 0) ------------------ 383| | 384| 0| return 0; 385| 10.9k|} yaml_emitter_delete: 393| 10.9k|{ 394| 10.9k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (394:5): [True: 0, False: 10.9k] | Branch (394:5): [True: 10.9k, False: 0] ------------------ 395| | 396| 10.9k| BUFFER_DEL(emitter, emitter->buffer); ------------------ | | 101| 10.9k| (yaml_free((buffer).start), \ | | 102| 10.9k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 397| 10.9k| BUFFER_DEL(emitter, emitter->raw_buffer); ------------------ | | 101| 10.9k| (yaml_free((buffer).start), \ | | 102| 10.9k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 398| 10.9k| STACK_DEL(emitter, emitter->states); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 399| 15.9k| while (!QUEUE_EMPTY(emitter, emitter->events)) { ------------------ | | 469| 15.9k| ((queue).head == (queue).tail) ------------------ | Branch (399:12): [True: 4.99k, False: 10.9k] ------------------ 400| 4.99k| yaml_event_delete(&DEQUEUE(emitter, emitter->events)); ------------------ | | 481| 4.99k| (*((queue).head++)) ------------------ 401| 4.99k| } 402| 10.9k| QUEUE_DEL(emitter, emitter->events); ------------------ | | 465| 10.9k| (yaml_free((queue).start), \ | | 466| 10.9k| (queue).start = (queue).head = (queue).tail = (queue).end = 0) ------------------ 403| 10.9k| STACK_DEL(emitter, emitter->indents); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 404| 21.2k| while (!STACK_EMPTY(empty, emitter->tag_directives)) { ------------------ | | 436| 21.2k| ((stack).start == (stack).top) ------------------ | Branch (404:12): [True: 10.3k, False: 10.9k] ------------------ 405| 10.3k| yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives); ------------------ | | 454| 10.3k| (*(--(stack).top)) ------------------ 406| 10.3k| yaml_free(tag_directive.handle); 407| 10.3k| yaml_free(tag_directive.prefix); 408| 10.3k| } 409| 10.9k| STACK_DEL(emitter, emitter->tag_directives); ------------------ | | 432| 10.9k| (yaml_free((stack).start), \ | | 433| 10.9k| (stack).start = (stack).top = (stack).end = 0) ------------------ 410| 10.9k| yaml_free(emitter->anchors); 411| | 412| 10.9k| memset(emitter, 0, sizeof(yaml_emitter_t)); 413| 10.9k|} yaml_emitter_set_output: 497| 10.9k|{ 498| 10.9k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (498:5): [True: 0, False: 10.9k] | Branch (498:5): [True: 10.9k, False: 0] ------------------ 499| 10.9k| assert(!emitter->write_handler); /* You can set the output only once. */ ------------------ | Branch (499:5): [True: 0, False: 10.9k] | Branch (499:5): [True: 10.9k, False: 0] ------------------ 500| 10.9k| assert(handler); /* Non-NULL handler object expected. */ ------------------ | Branch (500:5): [True: 0, False: 10.9k] | Branch (500:5): [True: 10.9k, False: 0] ------------------ 501| | 502| 10.9k| emitter->write_handler = handler; 503| 10.9k| emitter->write_handler_data = data; 504| 10.9k|} yaml_emitter_set_canonical: 525| 10.9k|{ 526| 10.9k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (526:5): [True: 0, False: 10.9k] | Branch (526:5): [True: 10.9k, False: 0] ------------------ 527| | 528| 10.9k| emitter->canonical = (canonical != 0); 529| 10.9k|} yaml_emitter_set_unicode: 561| 10.9k|{ 562| 10.9k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (562:5): [True: 0, False: 10.9k] | Branch (562:5): [True: 10.9k, False: 0] ------------------ 563| | 564| 10.9k| emitter->unicode = (unicode != 0); 565| 10.9k|} yaml_token_delete: 585| 45.8k|{ 586| 45.8k| assert(token); /* Non-NULL token object expected. */ ------------------ | Branch (586:5): [True: 0, False: 45.8k] | Branch (586:5): [True: 45.8k, False: 0] ------------------ 587| | 588| 45.8k| switch (token->type) 589| 45.8k| { 590| 72| case YAML_TAG_DIRECTIVE_TOKEN: ------------------ | Branch (590:9): [True: 72, False: 45.7k] ------------------ 591| 72| yaml_free(token->data.tag_directive.handle); 592| 72| yaml_free(token->data.tag_directive.prefix); 593| 72| break; 594| | 595| 718| case YAML_ALIAS_TOKEN: ------------------ | Branch (595:9): [True: 718, False: 45.1k] ------------------ 596| 718| yaml_free(token->data.alias.value); 597| 718| break; 598| | 599| 1.61k| case YAML_ANCHOR_TOKEN: ------------------ | Branch (599:9): [True: 1.61k, False: 44.2k] ------------------ 600| 1.61k| yaml_free(token->data.anchor.value); 601| 1.61k| break; 602| | 603| 2.46k| case YAML_TAG_TOKEN: ------------------ | Branch (603:9): [True: 2.46k, False: 43.4k] ------------------ 604| 2.46k| yaml_free(token->data.tag.handle); 605| 2.46k| yaml_free(token->data.tag.suffix); 606| 2.46k| break; 607| | 608| 5.76k| case YAML_SCALAR_TOKEN: ------------------ | Branch (608:9): [True: 5.76k, False: 40.1k] ------------------ 609| 5.76k| yaml_free(token->data.scalar.value); 610| 5.76k| break; 611| | 612| 35.2k| default: ------------------ | Branch (612:9): [True: 35.2k, False: 10.6k] ------------------ 613| 35.2k| break; 614| 45.8k| } 615| | 616| 45.8k| memset(token, 0, sizeof(yaml_token_t)); 617| 45.8k|} yaml_event_delete: 986| 8.50M|{ 987| 8.50M| yaml_tag_directive_t *tag_directive; 988| | 989| 8.50M| assert(event); /* Non-NULL event object expected. */ ------------------ | Branch (989:5): [True: 0, False: 8.50M] | Branch (989:5): [True: 8.50M, False: 0] ------------------ 990| | 991| 8.50M| switch (event->type) 992| 8.50M| { 993| 62.3k| case YAML_DOCUMENT_START_EVENT: ------------------ | Branch (993:9): [True: 62.3k, False: 8.44M] ------------------ 994| 62.3k| yaml_free(event->data.document_start.version_directive); 995| 62.3k| for (tag_directive = event->data.document_start.tag_directives.start; 996| 166k| tag_directive != event->data.document_start.tag_directives.end; ------------------ | Branch (996:21): [True: 104k, False: 62.3k] ------------------ 997| 104k| tag_directive++) { 998| 104k| yaml_free(tag_directive->handle); 999| 104k| yaml_free(tag_directive->prefix); 1000| 104k| } 1001| 62.3k| yaml_free(event->data.document_start.tag_directives.start); 1002| 62.3k| break; 1003| | 1004| 130k| case YAML_ALIAS_EVENT: ------------------ | Branch (1004:9): [True: 130k, False: 8.37M] ------------------ 1005| 130k| yaml_free(event->data.alias.anchor); 1006| 130k| break; 1007| | 1008| 3.53M| case YAML_SCALAR_EVENT: ------------------ | Branch (1008:9): [True: 3.53M, False: 4.96M] ------------------ 1009| 3.53M| yaml_free(event->data.scalar.anchor); 1010| 3.53M| yaml_free(event->data.scalar.tag); 1011| 3.53M| yaml_free(event->data.scalar.value); 1012| 3.53M| break; 1013| | 1014| 115k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1014:9): [True: 115k, False: 8.39M] ------------------ 1015| 115k| yaml_free(event->data.sequence_start.anchor); 1016| 115k| yaml_free(event->data.sequence_start.tag); 1017| 115k| break; 1018| | 1019| 2.23M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1019:9): [True: 2.23M, False: 6.27M] ------------------ 1020| 2.23M| yaml_free(event->data.mapping_start.anchor); 1021| 2.23M| yaml_free(event->data.mapping_start.tag); 1022| 2.23M| break; 1023| | 1024| 2.42M| default: ------------------ | Branch (1024:9): [True: 2.42M, False: 6.08M] ------------------ 1025| 2.42M| break; 1026| 8.50M| } 1027| | 1028| 8.50M| memset(event, 0, sizeof(yaml_event_t)); 1029| 8.50M|} yaml_document_delete: 1124| 6.03k|{ 1125| 6.03k| yaml_tag_directive_t *tag_directive; 1126| | 1127| 6.03k| assert(document); /* Non-NULL document object is expected. */ ------------------ | Branch (1127:5): [True: 0, False: 6.03k] | Branch (1127:5): [True: 6.03k, False: 0] ------------------ 1128| | 1129| 4.78M| while (!STACK_EMPTY(&context, document->nodes)) { ------------------ | | 436| 4.78M| ((stack).start == (stack).top) ------------------ | Branch (1129:12): [True: 4.77M, False: 6.03k] ------------------ 1130| 4.77M| yaml_node_t node = POP(&context, document->nodes); ------------------ | | 454| 4.77M| (*(--(stack).top)) ------------------ 1131| 4.77M| yaml_free(node.tag); 1132| 4.77M| switch (node.type) { 1133| 4.65M| case YAML_SCALAR_NODE: ------------------ | Branch (1133:13): [True: 4.65M, False: 126k] ------------------ 1134| 4.65M| yaml_free(node.data.scalar.value); 1135| 4.65M| break; 1136| 25.3k| case YAML_SEQUENCE_NODE: ------------------ | Branch (1136:13): [True: 25.3k, False: 4.75M] ------------------ 1137| 25.3k| STACK_DEL(&context, node.data.sequence.items); ------------------ | | 432| 25.3k| (yaml_free((stack).start), \ | | 433| 25.3k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1138| 25.3k| break; 1139| 101k| case YAML_MAPPING_NODE: ------------------ | Branch (1139:13): [True: 101k, False: 4.67M] ------------------ 1140| 101k| STACK_DEL(&context, node.data.mapping.pairs); ------------------ | | 432| 101k| (yaml_free((stack).start), \ | | 433| 101k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1141| 101k| break; 1142| 0| default: ------------------ | Branch (1142:13): [True: 0, False: 4.77M] ------------------ 1143| 0| assert(0); /* Should not happen. */ ------------------ | Branch (1143:17): [Folded, False: 0] | Branch (1143:17): [Folded, False: 0] ------------------ 1144| 4.77M| } 1145| 4.77M| } 1146| 6.03k| STACK_DEL(&context, document->nodes); ------------------ | | 432| 6.03k| (yaml_free((stack).start), \ | | 433| 6.03k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1147| | 1148| 6.03k| yaml_free(document->version_directive); 1149| 6.03k| for (tag_directive = document->tag_directives.start; 1150| 6.34k| tag_directive != document->tag_directives.end; ------------------ | Branch (1150:13): [True: 305, False: 6.03k] ------------------ 1151| 6.03k| tag_directive++) { 1152| 305| yaml_free(tag_directive->handle); 1153| 305| yaml_free(tag_directive->prefix); 1154| 305| } 1155| 6.03k| yaml_free(document->tag_directives.start); 1156| | 1157| 6.03k| memset(document, 0, sizeof(yaml_document_t)); 1158| 6.03k|} yaml_document_get_root_node: 1181| 63.9k|{ 1182| 63.9k| assert(document); /* Non-NULL document object is expected. */ ------------------ | Branch (1182:5): [True: 0, False: 63.9k] | Branch (1182:5): [True: 63.9k, False: 0] ------------------ 1183| | 1184| 63.9k| if (document->nodes.top != document->nodes.start) { ------------------ | Branch (1184:9): [True: 62.3k, False: 1.64k] ------------------ 1185| 62.3k| return document->nodes.start; 1186| 62.3k| } 1187| 1.64k| return NULL; 1188| 63.9k|} api.c:yaml_string_read_handler: 251| 30.0k|{ 252| 30.0k| yaml_parser_t *parser = (yaml_parser_t *)data; 253| | 254| 30.0k| if (parser->input.string.current == parser->input.string.end) { ------------------ | Branch (254:9): [True: 10.3k, False: 19.6k] ------------------ 255| 10.3k| *size_read = 0; 256| 10.3k| return 1; 257| 10.3k| } 258| | 259| 19.6k| if (size > (size_t)(parser->input.string.end ------------------ | Branch (259:9): [True: 10.8k, False: 8.78k] ------------------ 260| 19.6k| - parser->input.string.current)) { 261| 10.8k| size = parser->input.string.end - parser->input.string.current; 262| 10.8k| } 263| | 264| 19.6k| memcpy(buffer, parser->input.string.current, size); 265| 19.6k| parser->input.string.current += size; 266| 19.6k| *size_read = size; 267| 19.6k| return 1; 268| 30.0k|} yaml_emitter_open: 63| 6.96k|{ 64| 6.96k| yaml_event_t event; 65| 6.96k| yaml_mark_t mark = { 0, 0, 0 }; 66| | 67| 6.96k| assert(emitter); /* Non-NULL emitter object is required. */ ------------------ | Branch (67:5): [True: 0, False: 6.96k] | Branch (67:5): [True: 6.96k, False: 0] ------------------ 68| 6.96k| assert(!emitter->opened); /* Emitter should not be opened yet. */ ------------------ | Branch (68:5): [True: 0, False: 6.96k] | Branch (68:5): [True: 6.96k, False: 0] ------------------ 69| | 70| 6.96k| STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark); ------------------ | | 552| 6.96k| (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 6.96k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 6.96k| (event).type = (event_type), \ | | | | 548| 6.96k| (event).start_mark = (event_start_mark), \ | | | | 549| 6.96k| (event).end_mark = (event_end_mark)) | | ------------------ | | 553| 6.96k| (event).data.stream_start.encoding = (event_encoding)) ------------------ 71| | 72| 6.96k| if (!yaml_emitter_emit(emitter, &event)) { ------------------ | Branch (72:9): [True: 0, False: 6.96k] ------------------ 73| 0| return 0; 74| 0| } 75| | 76| 6.96k| emitter->opened = 1; 77| | 78| 6.96k| return 1; 79| 6.96k|} yaml_emitter_close: 87| 1.64k|{ 88| 1.64k| yaml_event_t event; 89| 1.64k| yaml_mark_t mark = { 0, 0, 0 }; 90| | 91| 1.64k| assert(emitter); /* Non-NULL emitter object is required. */ ------------------ | Branch (91:5): [True: 0, False: 1.64k] | Branch (91:5): [True: 1.64k, False: 0] ------------------ 92| 1.64k| assert(emitter->opened); /* Emitter should be opened. */ ------------------ | Branch (92:5): [True: 0, False: 1.64k] | Branch (92:5): [True: 1.64k, False: 0] ------------------ 93| | 94| 1.64k| if (emitter->closed) return 1; ------------------ | Branch (94:9): [True: 0, False: 1.64k] ------------------ 95| | 96| 1.64k| STREAM_END_EVENT_INIT(event, mark, mark); ------------------ | | 556| 1.64k| (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 1.64k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 1.64k| (event).type = (event_type), \ | | | | 548| 1.64k| (event).start_mark = (event_start_mark), \ | | | | 549| 1.64k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 97| | 98| 1.64k| if (!yaml_emitter_emit(emitter, &event)) { ------------------ | Branch (98:9): [True: 0, False: 1.64k] ------------------ 99| 0| return 0; 100| 0| } 101| | 102| 1.64k| emitter->closed = 1; 103| | 104| 1.64k| return 1; 105| 1.64k|} yaml_emitter_dump: 113| 63.9k|{ 114| 63.9k| yaml_event_t event; 115| 63.9k| yaml_mark_t mark = { 0, 0, 0 }; 116| | 117| 63.9k| assert(emitter); /* Non-NULL emitter object is required. */ ------------------ | Branch (117:5): [True: 0, False: 63.9k] | Branch (117:5): [True: 63.9k, False: 0] ------------------ 118| 63.9k| assert(document); /* Non-NULL emitter object is expected. */ ------------------ | Branch (118:5): [True: 0, False: 63.9k] | Branch (118:5): [True: 63.9k, False: 0] ------------------ 119| | 120| 63.9k| emitter->document = document; 121| | 122| 63.9k| if (!emitter->opened) { ------------------ | Branch (122:9): [True: 6.96k, False: 57.0k] ------------------ 123| 6.96k| if (!yaml_emitter_open(emitter)) goto error; ------------------ | Branch (123:13): [True: 0, False: 6.96k] ------------------ 124| 6.96k| } 125| | 126| 63.9k| if (STACK_EMPTY(emitter, document->nodes)) { ------------------ | | 436| 63.9k| ((stack).start == (stack).top) | | ------------------ | | | Branch (436:5): [True: 1.64k, False: 62.3k] | | ------------------ ------------------ 127| 1.64k| if (!yaml_emitter_close(emitter)) goto error; ------------------ | Branch (127:13): [True: 0, False: 1.64k] ------------------ 128| 1.64k| yaml_emitter_delete_document_and_anchors(emitter); 129| 1.64k| return 1; 130| 1.64k| } 131| | 132| 63.9k| assert(emitter->opened); /* Emitter should be opened. */ ------------------ | Branch (132:5): [True: 0, False: 62.3k] | Branch (132:5): [True: 62.3k, False: 0] ------------------ 133| | 134| 62.3k| emitter->anchors = (yaml_anchors_t*)yaml_malloc(sizeof(*(emitter->anchors)) 135| 62.3k| * (document->nodes.top - document->nodes.start)); 136| 62.3k| if (!emitter->anchors) goto error; ------------------ | Branch (136:9): [True: 0, False: 62.3k] ------------------ 137| 62.3k| memset(emitter->anchors, 0, sizeof(*(emitter->anchors)) 138| 62.3k| * (document->nodes.top - document->nodes.start)); 139| | 140| 62.3k| DOCUMENT_START_EVENT_INIT(event, document->version_directive, ------------------ | | 560| 62.3k| (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 62.3k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 62.3k| (event).type = (event_type), \ | | | | 548| 62.3k| (event).start_mark = (event_start_mark), \ | | | | 549| 62.3k| (event).end_mark = (event_end_mark)) | | ------------------ | | 561| 62.3k| (event).data.document_start.version_directive = (event_version_directive), \ | | 562| 62.3k| (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ | | 563| 62.3k| (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ | | 564| 62.3k| (event).data.document_start.implicit = (event_implicit)) ------------------ 141| 62.3k| document->tag_directives.start, document->tag_directives.end, 142| 62.3k| document->start_implicit, mark, mark); 143| 62.3k| if (!yaml_emitter_emit(emitter, &event)) goto error; ------------------ | Branch (143:9): [True: 0, False: 62.3k] ------------------ 144| | 145| 62.3k| yaml_emitter_anchor_node(emitter, 1); 146| 62.3k| if (!yaml_emitter_dump_node(emitter, 1)) goto error; ------------------ | Branch (146:9): [True: 50, False: 62.2k] ------------------ 147| | 148| 62.2k| DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark); ------------------ | | 567| 62.2k| (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 62.2k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 62.2k| (event).type = (event_type), \ | | | | 548| 62.2k| (event).start_mark = (event_start_mark), \ | | | | 549| 62.2k| (event).end_mark = (event_end_mark)) | | ------------------ | | 568| 62.2k| (event).data.document_end.implicit = (event_implicit)) ------------------ 149| 62.2k| if (!yaml_emitter_emit(emitter, &event)) goto error; ------------------ | Branch (149:9): [True: 4.86k, False: 57.4k] ------------------ 150| | 151| 57.4k| yaml_emitter_delete_document_and_anchors(emitter); 152| | 153| 57.4k| return 1; 154| | 155| 4.91k|error: 156| | 157| 4.91k| yaml_emitter_delete_document_and_anchors(emitter); 158| | 159| 4.91k| return 0; 160| 62.2k|} dumper.c:yaml_emitter_delete_document_and_anchors: 168| 63.9k|{ 169| 63.9k| int index; 170| | 171| 63.9k| if (!emitter->anchors) { ------------------ | Branch (171:9): [True: 1.64k, False: 62.3k] ------------------ 172| 1.64k| yaml_document_delete(emitter->document); 173| 1.64k| emitter->document = NULL; 174| 1.64k| return; 175| 1.64k| } 176| | 177| 5.96M| for (index = 0; emitter->document->nodes.start + index ------------------ | Branch (177:21): [True: 5.89M, False: 62.3k] ------------------ 178| 5.96M| < emitter->document->nodes.top; index ++) { 179| 5.89M| yaml_node_t node = emitter->document->nodes.start[index]; 180| 5.89M| if (!emitter->anchors[index].serialized) { ------------------ | Branch (180:13): [True: 6.74k, False: 5.89M] ------------------ 181| 6.74k| yaml_free(node.tag); 182| 6.74k| if (node.type == YAML_SCALAR_NODE) { ------------------ | Branch (182:17): [True: 4.31k, False: 2.43k] ------------------ 183| 4.31k| yaml_free(node.data.scalar.value); 184| 4.31k| } 185| 6.74k| } 186| 5.89M| if (node.type == YAML_SEQUENCE_NODE) { ------------------ | Branch (186:13): [True: 116k, False: 5.78M] ------------------ 187| 116k| STACK_DEL(emitter, node.data.sequence.items); ------------------ | | 432| 116k| (yaml_free((stack).start), \ | | 433| 116k| (stack).start = (stack).top = (stack).end = 0) ------------------ 188| 116k| } 189| 5.89M| if (node.type == YAML_MAPPING_NODE) { ------------------ | Branch (189:13): [True: 2.23M, False: 3.65M] ------------------ 190| 2.23M| STACK_DEL(emitter, node.data.mapping.pairs); ------------------ | | 432| 2.23M| (yaml_free((stack).start), \ | | 433| 2.23M| (stack).start = (stack).top = (stack).end = 0) ------------------ 191| 2.23M| } 192| 5.89M| } 193| | 194| 62.3k| STACK_DEL(emitter, emitter->document->nodes); ------------------ | | 432| 62.3k| (yaml_free((stack).start), \ | | 433| 62.3k| (stack).start = (stack).top = (stack).end = 0) ------------------ 195| 62.3k| yaml_free(emitter->anchors); 196| | 197| 62.3k| emitter->anchors = NULL; 198| 62.3k| emitter->last_anchor_id = 0; 199| | emitter->document = NULL; 200| 62.3k|} dumper.c:yaml_emitter_anchor_node: 208| 6.02M|{ 209| 6.02M| yaml_node_t *node = emitter->document->nodes.start + index - 1; 210| 6.02M| yaml_node_item_t *item; 211| 6.02M| yaml_node_pair_t *pair; 212| | 213| 6.02M| emitter->anchors[index-1].references ++; 214| | 215| 6.02M| if (emitter->anchors[index-1].references == 1) { ------------------ | Branch (215:9): [True: 5.89M, False: 130k] ------------------ 216| 5.89M| switch (node->type) { 217| 116k| case YAML_SEQUENCE_NODE: ------------------ | Branch (217:13): [True: 116k, False: 5.78M] ------------------ 218| 116k| for (item = node->data.sequence.items.start; 219| 721k| item < node->data.sequence.items.top; item ++) { ------------------ | Branch (219:25): [True: 605k, False: 116k] ------------------ 220| 605k| yaml_emitter_anchor_node(emitter, *item); 221| 605k| } 222| 116k| break; 223| 2.23M| case YAML_MAPPING_NODE: ------------------ | Branch (223:13): [True: 2.23M, False: 3.65M] ------------------ 224| 2.23M| for (pair = node->data.mapping.pairs.start; 225| 4.91M| pair < node->data.mapping.pairs.top; pair ++) { ------------------ | Branch (225:25): [True: 2.68M, False: 2.23M] ------------------ 226| 2.68M| yaml_emitter_anchor_node(emitter, pair->key); 227| 2.68M| yaml_emitter_anchor_node(emitter, pair->value); 228| 2.68M| } 229| 2.23M| break; 230| 3.54M| default: ------------------ | Branch (230:13): [True: 3.54M, False: 2.35M] ------------------ 231| 3.54M| break; 232| 5.89M| } 233| 5.89M| } 234| | 235| 130k| else if (emitter->anchors[index-1].references == 2) { ------------------ | Branch (235:14): [True: 3.81k, False: 126k] ------------------ 236| 3.81k| emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id); 237| 3.81k| } 238| 6.02M|} dumper.c:yaml_emitter_dump_node: 265| 6.02M|{ 266| 6.02M| yaml_node_t *node = emitter->document->nodes.start + index - 1; 267| 6.02M| int anchor_id = emitter->anchors[index-1].anchor; 268| 6.02M| yaml_char_t *anchor = NULL; 269| | 270| 6.02M| if (anchor_id) { ------------------ | Branch (270:9): [True: 134k, False: 5.88M] ------------------ 271| 134k| anchor = yaml_emitter_generate_anchor(emitter, anchor_id); 272| 134k| if (!anchor) return 0; ------------------ | Branch (272:13): [True: 0, False: 134k] ------------------ 273| 134k| } 274| | 275| 6.02M| if (emitter->anchors[index-1].serialized) { ------------------ | Branch (275:9): [True: 130k, False: 5.89M] ------------------ 276| 130k| return yaml_emitter_dump_alias(emitter, anchor); 277| 130k| } 278| | 279| 5.89M| emitter->anchors[index-1].serialized = 1; 280| | 281| 5.89M| switch (node->type) { 282| 3.53M| case YAML_SCALAR_NODE: ------------------ | Branch (282:9): [True: 3.53M, False: 2.35M] ------------------ 283| 3.53M| return yaml_emitter_dump_scalar(emitter, node, anchor); 284| 115k| case YAML_SEQUENCE_NODE: ------------------ | Branch (284:9): [True: 115k, False: 5.77M] ------------------ 285| 115k| return yaml_emitter_dump_sequence(emitter, node, anchor); 286| 2.23M| case YAML_MAPPING_NODE: ------------------ | Branch (286:9): [True: 2.23M, False: 3.65M] ------------------ 287| 2.23M| return yaml_emitter_dump_mapping(emitter, node, anchor); 288| 0| default: ------------------ | Branch (288:9): [True: 0, False: 5.89M] ------------------ 289| 0| assert(0); /* Could not happen. */ ------------------ | Branch (289:13): [Folded, False: 0] | Branch (289:13): [Folded, False: 0] ------------------ 290| 0| break; 291| 5.89M| } 292| | 293| 0| return 0; /* Could not happen. */ 294| 5.89M|} dumper.c:yaml_emitter_generate_anchor: 249| 134k|{ 250| 134k| yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH); ------------------ | | 684| 134k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 251| | 252| 134k| if (!anchor) return NULL; ------------------ | Branch (252:9): [True: 0, False: 134k] ------------------ 253| | 254| 134k| sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id); ------------------ | | 244| 134k|#define ANCHOR_TEMPLATE "id%03d" ------------------ 255| | 256| 134k| return anchor; 257| 134k|} dumper.c:yaml_emitter_dump_alias: 302| 130k|{ 303| 130k| yaml_event_t event; 304| 130k| yaml_mark_t mark = { 0, 0, 0 }; 305| | 306| 130k| ALIAS_EVENT_INIT(event, anchor, mark, mark); ------------------ | | 571| 130k| (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 130k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 130k| (event).type = (event_type), \ | | | | 548| 130k| (event).start_mark = (event_start_mark), \ | | | | 549| 130k| (event).end_mark = (event_end_mark)) | | ------------------ | | 572| 130k| (event).data.alias.anchor = (event_anchor)) ------------------ 307| | 308| 130k| return yaml_emitter_emit(emitter, &event); 309| 130k|} dumper.c:yaml_emitter_dump_scalar: 318| 3.53M|{ 319| 3.53M| yaml_event_t event; 320| 3.53M| yaml_mark_t mark = { 0, 0, 0 }; 321| | 322| 3.53M| int plain_implicit = (strcmp((char *)node->tag, 323| 3.53M| YAML_DEFAULT_SCALAR_TAG) == 0); ------------------ | | 685| 3.53M|#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG | | ------------------ | | | | 671| 3.53M|#define YAML_STR_TAG "tag:yaml.org,2002:str" | | ------------------ ------------------ 324| 3.53M| int quoted_implicit = (strcmp((char *)node->tag, 325| 3.53M| YAML_DEFAULT_SCALAR_TAG) == 0); ------------------ | | 685| 3.53M|#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG | | ------------------ | | | | 671| 3.53M|#define YAML_STR_TAG "tag:yaml.org,2002:str" | | ------------------ ------------------ 326| | 327| 3.53M| SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value, ------------------ | | 576| 3.53M| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 3.53M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 3.53M| (event).type = (event_type), \ | | | | 548| 3.53M| (event).start_mark = (event_start_mark), \ | | | | 549| 3.53M| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 3.53M| (event).data.scalar.anchor = (event_anchor), \ | | 578| 3.53M| (event).data.scalar.tag = (event_tag), \ | | 579| 3.53M| (event).data.scalar.value = (event_value), \ | | 580| 3.53M| (event).data.scalar.length = (event_length), \ | | 581| 3.53M| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 3.53M| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 3.53M| (event).data.scalar.style = (event_style)) ------------------ 328| 3.53M| node->data.scalar.length, plain_implicit, quoted_implicit, 329| 3.53M| node->data.scalar.style, mark, mark); 330| | 331| 3.53M| return yaml_emitter_emit(emitter, &event); 332| 3.53M|} dumper.c:yaml_emitter_dump_sequence: 341| 115k|{ 342| 115k| yaml_event_t event; 343| 115k| yaml_mark_t mark = { 0, 0, 0 }; 344| | 345| 115k| int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0); ------------------ | | 687| 115k|#define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG | | ------------------ | | | | 680| 115k|#define YAML_SEQ_TAG "tag:yaml.org,2002:seq" | | ------------------ ------------------ 346| | 347| 115k| yaml_node_item_t *item; 348| | 349| 115k| SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit, ------------------ | | 587| 115k| (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 115k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 115k| (event).type = (event_type), \ | | | | 548| 115k| (event).start_mark = (event_start_mark), \ | | | | 549| 115k| (event).end_mark = (event_end_mark)) | | ------------------ | | 588| 115k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 115k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 115k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 115k| (event).data.sequence_start.style = (event_style)) ------------------ 350| 115k| node->data.sequence.style, mark, mark); 351| 115k| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (351:9): [True: 4, False: 115k] ------------------ 352| | 353| 115k| for (item = node->data.sequence.items.start; 354| 719k| item < node->data.sequence.items.top; item ++) { ------------------ | Branch (354:13): [True: 604k, False: 115k] ------------------ 355| 604k| if (!yaml_emitter_dump_node(emitter, *item)) return 0; ------------------ | Branch (355:13): [True: 236, False: 603k] ------------------ 356| 604k| } 357| | 358| 115k| SEQUENCE_END_EVENT_INIT(event, mark, mark); ------------------ | | 594| 115k| (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 115k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 115k| (event).type = (event_type), \ | | | | 548| 115k| (event).start_mark = (event_start_mark), \ | | | | 549| 115k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 359| 115k| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (359:9): [True: 10, False: 115k] ------------------ 360| | 361| 115k| return 1; 362| 115k|} dumper.c:yaml_emitter_dump_mapping: 371| 2.23M|{ 372| 2.23M| yaml_event_t event; 373| 2.23M| yaml_mark_t mark = { 0, 0, 0 }; 374| | 375| 2.23M| int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0); ------------------ | | 689| 2.23M|#define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG | | ------------------ | | | | 682| 2.23M|#define YAML_MAP_TAG "tag:yaml.org,2002:map" | | ------------------ ------------------ 376| | 377| 2.23M| yaml_node_pair_t *pair; 378| | 379| 2.23M| MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit, ------------------ | | 598| 2.23M| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 2.23M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.23M| (event).type = (event_type), \ | | | | 548| 2.23M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.23M| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 2.23M| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 2.23M| (event).data.mapping_start.tag = (event_tag), \ | | 601| 2.23M| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 2.23M| (event).data.mapping_start.style = (event_style)) ------------------ 380| 2.23M| node->data.mapping.style, mark, mark); 381| 2.23M| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (381:9): [True: 6, False: 2.23M] ------------------ 382| | 383| 2.23M| for (pair = node->data.mapping.pairs.start; 384| 4.91M| pair < node->data.mapping.pairs.top; pair ++) { ------------------ | Branch (384:13): [True: 2.67M, False: 2.23M] ------------------ 385| 2.67M| if (!yaml_emitter_dump_node(emitter, pair->key)) return 0; ------------------ | Branch (385:13): [True: 214, False: 2.67M] ------------------ 386| 2.67M| if (!yaml_emitter_dump_node(emitter, pair->value)) return 0; ------------------ | Branch (386:13): [True: 36, False: 2.67M] ------------------ 387| 2.67M| } 388| | 389| 2.23M| MAPPING_END_EVENT_INIT(event, mark, mark); ------------------ | | 605| 2.23M| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 2.23M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.23M| (event).type = (event_type), \ | | | | 548| 2.23M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.23M| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 390| 2.23M| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (390:9): [True: 8, False: 2.23M] ------------------ 391| | 392| 2.23M| return 1; 393| 2.23M|} yaml_emitter_emit: 282| 8.50M|{ 283| 8.50M| if (!ENQUEUE(emitter, emitter->events, *event)) { ------------------ | | 472| 8.50M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 7.94M, False: 561k] | | ------------------ | | 473| 8.50M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 561k, False: 0] | | ------------------ | | 474| 561k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 8.50M| (*((queue).tail++) = value, \ | | 476| 8.50M| 1) : \ | | 477| 8.50M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (283:9): [True: 0, False: 8.50M] ------------------ 284| 0| yaml_event_delete(event); 285| 0| return 0; 286| 0| } 287| | 288| 17.0M| while (!yaml_emitter_need_more_events(emitter)) { ------------------ | Branch (288:12): [True: 8.50M, False: 8.50M] ------------------ 289| 8.50M| if (!yaml_emitter_analyze_event(emitter, emitter->events.head)) ------------------ | Branch (289:13): [True: 48, False: 8.50M] ------------------ 290| 48| return 0; 291| 8.50M| if (!yaml_emitter_state_machine(emitter, emitter->events.head)) ------------------ | Branch (291:13): [True: 4.86k, False: 8.50M] ------------------ 292| 4.86k| return 0; 293| 8.50M| yaml_event_delete(&DEQUEUE(emitter, emitter->events)); ------------------ | | 481| 8.50M| (*((queue).head++)) ------------------ 294| 8.50M| } 295| | 296| 8.50M| return 1; 297| 8.50M|} emitter.c:yaml_emitter_need_more_events: 310| 17.0M|{ 311| 17.0M| int level = 0; 312| 17.0M| int accumulate = 0; 313| 17.0M| yaml_event_t *event; 314| | 315| 17.0M| if (QUEUE_EMPTY(emitter, emitter->events)) ------------------ | | 469| 17.0M| ((queue).head == (queue).tail) | | ------------------ | | | Branch (469:5): [True: 4.74M, False: 12.2M] | | ------------------ ------------------ 316| 4.74M| return 1; 317| | 318| 12.2M| switch (emitter->events.head->type) { 319| 124k| case YAML_DOCUMENT_START_EVENT: ------------------ | Branch (319:9): [True: 124k, False: 12.1M] ------------------ 320| 124k| accumulate = 1; 321| 124k| break; 322| 253k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (322:9): [True: 253k, False: 12.0M] ------------------ 323| 253k| accumulate = 2; 324| 253k| break; 325| 5.79M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (325:9): [True: 5.79M, False: 6.47M] ------------------ 326| 5.79M| accumulate = 3; 327| 5.79M| break; 328| 6.09M| default: ------------------ | Branch (328:9): [True: 6.09M, False: 6.17M] ------------------ 329| 6.09M| return 0; 330| 12.2M| } 331| | 332| 6.17M| if (emitter->events.tail - emitter->events.head > accumulate) ------------------ | Branch (332:9): [True: 2.41M, False: 3.76M] ------------------ 333| 2.41M| return 0; 334| | 335| 12.7M| for (event = emitter->events.head; event != emitter->events.tail; event ++) { ------------------ | Branch (335:40): [True: 9.02M, False: 3.76M] ------------------ 336| 9.02M| switch (event->type) { 337| 0| case YAML_STREAM_START_EVENT: ------------------ | Branch (337:13): [True: 0, False: 9.02M] ------------------ 338| 62.3k| case YAML_DOCUMENT_START_EVENT: ------------------ | Branch (338:13): [True: 62.3k, False: 8.96M] ------------------ 339| 293k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (339:13): [True: 231k, False: 8.79M] ------------------ 340| 7.00M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (340:13): [True: 6.70M, False: 2.31M] ------------------ 341| 7.00M| level += 1; 342| 7.00M| break; 343| 0| case YAML_STREAM_END_EVENT: ------------------ | Branch (343:13): [True: 0, False: 9.02M] ------------------ 344| 0| case YAML_DOCUMENT_END_EVENT: ------------------ | Branch (344:13): [True: 0, False: 9.02M] ------------------ 345| 685| case YAML_SEQUENCE_END_EVENT: ------------------ | Branch (345:13): [True: 685, False: 9.02M] ------------------ 346| 1.42k| case YAML_MAPPING_END_EVENT: ------------------ | Branch (346:13): [True: 736, False: 9.02M] ------------------ 347| 1.42k| level -= 1; 348| 1.42k| break; 349| 2.02M| default: ------------------ | Branch (349:13): [True: 2.02M, False: 7.00M] ------------------ 350| 2.02M| break; 351| 9.02M| } 352| 9.02M| if (!level) ------------------ | Branch (352:13): [True: 1.13k, False: 9.02M] ------------------ 353| 1.13k| return 0; 354| 9.02M| } 355| | 356| 3.76M| return 1; 357| 3.76M|} emitter.c:yaml_emitter_state_machine: 425| 8.50M|{ 426| 8.50M| switch (emitter->state) 427| 8.50M| { 428| 6.96k| case YAML_EMIT_STREAM_START_STATE: ------------------ | Branch (428:9): [True: 6.96k, False: 8.50M] ------------------ 429| 6.96k| return yaml_emitter_emit_stream_start(emitter, event); 430| | 431| 6.96k| case YAML_EMIT_FIRST_DOCUMENT_START_STATE: ------------------ | Branch (431:9): [True: 6.96k, False: 8.50M] ------------------ 432| 6.96k| return yaml_emitter_emit_document_start(emitter, event, 1); 433| | 434| 57.0k| case YAML_EMIT_DOCUMENT_START_STATE: ------------------ | Branch (434:9): [True: 57.0k, False: 8.45M] ------------------ 435| 57.0k| return yaml_emitter_emit_document_start(emitter, event, 0); 436| | 437| 62.3k| case YAML_EMIT_DOCUMENT_CONTENT_STATE: ------------------ | Branch (437:9): [True: 62.3k, False: 8.44M] ------------------ 438| 62.3k| return yaml_emitter_emit_document_content(emitter, event); 439| | 440| 62.2k| case YAML_EMIT_DOCUMENT_END_STATE: ------------------ | Branch (440:9): [True: 62.2k, False: 8.44M] ------------------ 441| 62.2k| return yaml_emitter_emit_document_end(emitter, event); 442| | 443| 83.1k| case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE: ------------------ | Branch (443:9): [True: 83.1k, False: 8.42M] ------------------ 444| 83.1k| return yaml_emitter_emit_flow_sequence_item(emitter, event, 1); 445| | 446| 410k| case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE: ------------------ | Branch (446:9): [True: 410k, False: 8.09M] ------------------ 447| 410k| return yaml_emitter_emit_flow_sequence_item(emitter, event, 0); 448| | 449| 1.50M| case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (449:9): [True: 1.50M, False: 7.00M] ------------------ 450| 1.50M| return yaml_emitter_emit_flow_mapping_key(emitter, event, 1); 451| | 452| 1.85M| case YAML_EMIT_FLOW_MAPPING_KEY_STATE: ------------------ | Branch (452:9): [True: 1.85M, False: 6.65M] ------------------ 453| 1.85M| return yaml_emitter_emit_flow_mapping_key(emitter, event, 0); 454| | 455| 208k| case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE: ------------------ | Branch (455:9): [True: 208k, False: 8.29M] ------------------ 456| 208k| return yaml_emitter_emit_flow_mapping_value(emitter, event, 1); 457| | 458| 1.64M| case YAML_EMIT_FLOW_MAPPING_VALUE_STATE: ------------------ | Branch (458:9): [True: 1.64M, False: 6.85M] ------------------ 459| 1.64M| return yaml_emitter_emit_flow_mapping_value(emitter, event, 0); 460| | 461| 32.5k| case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE: ------------------ | Branch (461:9): [True: 32.5k, False: 8.47M] ------------------ 462| 32.5k| return yaml_emitter_emit_block_sequence_item(emitter, event, 1); 463| | 464| 193k| case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE: ------------------ | Branch (464:9): [True: 193k, False: 8.31M] ------------------ 465| 193k| return yaml_emitter_emit_block_sequence_item(emitter, event, 0); 466| | 467| 732k| case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (467:9): [True: 732k, False: 7.77M] ------------------ 468| 732k| return yaml_emitter_emit_block_mapping_key(emitter, event, 1); 469| | 470| 820k| case YAML_EMIT_BLOCK_MAPPING_KEY_STATE: ------------------ | Branch (470:9): [True: 820k, False: 7.68M] ------------------ 471| 820k| return yaml_emitter_emit_block_mapping_key(emitter, event, 0); 472| | 473| 258k| case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE: ------------------ | Branch (473:9): [True: 258k, False: 8.24M] ------------------ 474| 258k| return yaml_emitter_emit_block_mapping_value(emitter, event, 1); 475| | 476| 561k| case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE: ------------------ | Branch (476:9): [True: 561k, False: 7.94M] ------------------ 477| 561k| return yaml_emitter_emit_block_mapping_value(emitter, event, 0); 478| | 479| 0| case YAML_EMIT_END_STATE: ------------------ | Branch (479:9): [True: 0, False: 8.50M] ------------------ 480| 0| return yaml_emitter_set_emitter_error(emitter, 481| 0| "expected nothing after STREAM-END"); 482| | 483| 0| default: ------------------ | Branch (483:9): [True: 0, False: 8.50M] ------------------ 484| 0| assert(1); /* Invalid state. */ ------------------ | Branch (484:13): [True: 0, Folded] | Branch (484:13): [True: 0, Folded] ------------------ 485| 8.50M| } 486| | 487| 0| return 0; 488| 8.50M|} emitter.c:yaml_emitter_emit_stream_start: 497| 6.96k|{ 498| 6.96k| emitter->open_ended = 0; 499| 6.96k| if (event->type == YAML_STREAM_START_EVENT) ------------------ | Branch (499:9): [True: 6.96k, False: 0] ------------------ 500| 6.96k| { 501| 6.96k| if (!emitter->encoding) { ------------------ | Branch (501:13): [True: 6.96k, False: 0] ------------------ 502| 6.96k| emitter->encoding = event->data.stream_start.encoding; 503| 6.96k| } 504| | 505| 6.96k| if (!emitter->encoding) { ------------------ | Branch (505:13): [True: 6.96k, False: 0] ------------------ 506| 6.96k| emitter->encoding = YAML_UTF8_ENCODING; 507| 6.96k| } 508| | 509| 6.96k| if (emitter->best_indent < 2 || emitter->best_indent > 9) { ------------------ | Branch (509:13): [True: 6.96k, False: 0] | Branch (509:41): [True: 0, False: 0] ------------------ 510| 6.96k| emitter->best_indent = 2; 511| 6.96k| } 512| | 513| 6.96k| if (emitter->best_width >= 0 ------------------ | Branch (513:13): [True: 6.96k, False: 0] ------------------ 514| 6.96k| && emitter->best_width <= emitter->best_indent*2) { ------------------ | Branch (514:20): [True: 6.96k, False: 0] ------------------ 515| 6.96k| emitter->best_width = 80; 516| 6.96k| } 517| | 518| 6.96k| if (emitter->best_width < 0) { ------------------ | Branch (518:13): [True: 0, False: 6.96k] ------------------ 519| 0| emitter->best_width = INT_MAX; 520| 0| } 521| | 522| 6.96k| if (!emitter->line_break) { ------------------ | Branch (522:13): [True: 6.96k, False: 0] ------------------ 523| 6.96k| emitter->line_break = YAML_LN_BREAK; 524| 6.96k| } 525| | 526| 6.96k| emitter->indent = -1; 527| | 528| 6.96k| emitter->line = 0; 529| 6.96k| emitter->column = 0; 530| 6.96k| emitter->whitespace = 1; 531| 6.96k| emitter->indention = 1; 532| | 533| 6.96k| if (emitter->encoding != YAML_UTF8_ENCODING) { ------------------ | Branch (533:13): [True: 0, False: 6.96k] ------------------ 534| 0| if (!yaml_emitter_write_bom(emitter)) ------------------ | Branch (534:17): [True: 0, False: 0] ------------------ 535| 0| return 0; 536| 0| } 537| | 538| 6.96k| emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE; 539| | 540| 6.96k| return 1; 541| 6.96k| } 542| | 543| 0| return yaml_emitter_set_emitter_error(emitter, 544| 0| "expected STREAM-START"); 545| 6.96k|} emitter.c:yaml_emitter_emit_document_start: 554| 63.9k|{ 555| 63.9k| if (event->type == YAML_DOCUMENT_START_EVENT) ------------------ | Branch (555:9): [True: 62.3k, False: 1.64k] ------------------ 556| 62.3k| { 557| 62.3k| yaml_tag_directive_t default_tag_directives[] = { 558| 62.3k| {(yaml_char_t *)"!", (yaml_char_t *)"!"}, 559| 62.3k| {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, 560| 62.3k| {NULL, NULL} 561| 62.3k| }; 562| 62.3k| yaml_tag_directive_t *tag_directive; 563| 62.3k| int implicit; 564| | 565| 62.3k| if (event->data.document_start.version_directive) { ------------------ | Branch (565:13): [True: 9.08k, False: 53.2k] ------------------ 566| 9.08k| if (!yaml_emitter_analyze_version_directive(emitter, ------------------ | Branch (566:17): [True: 0, False: 9.08k] ------------------ 567| 9.08k| *event->data.document_start.version_directive)) 568| 0| return 0; 569| 9.08k| } 570| | 571| 62.3k| for (tag_directive = event->data.document_start.tag_directives.start; 572| 166k| tag_directive != event->data.document_start.tag_directives.end; ------------------ | Branch (572:17): [True: 104k, False: 62.3k] ------------------ 573| 104k| tag_directive ++) { 574| 104k| if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive)) ------------------ | Branch (574:17): [True: 2, False: 104k] ------------------ 575| 2| return 0; 576| 104k| if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0)) ------------------ | Branch (576:17): [True: 0, False: 104k] ------------------ 577| 0| return 0; 578| 104k| } 579| | 580| 62.3k| for (tag_directive = default_tag_directives; 581| 186k| tag_directive->handle; tag_directive ++) { ------------------ | Branch (581:17): [True: 124k, False: 62.3k] ------------------ 582| 124k| if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1)) ------------------ | Branch (582:17): [True: 0, False: 124k] ------------------ 583| 0| return 0; 584| 124k| } 585| | 586| 62.3k| implicit = event->data.document_start.implicit; 587| 62.3k| if (!first || emitter->canonical) { ------------------ | Branch (587:13): [True: 55.5k, False: 6.77k] | Branch (587:23): [True: 2.90k, False: 3.86k] ------------------ 588| 58.4k| implicit = 0; 589| 58.4k| } 590| | 591| 62.3k| if ((event->data.document_start.version_directive || ------------------ | Branch (591:14): [True: 9.08k, False: 53.2k] ------------------ 592| 53.2k| (event->data.document_start.tag_directives.start ------------------ | Branch (592:21): [True: 14.4k, False: 38.7k] ------------------ 593| 53.2k| != event->data.document_start.tag_directives.end)) && 594| 23.5k| emitter->open_ended) ------------------ | Branch (594:17): [True: 22.8k, False: 697] ------------------ 595| 22.8k| { 596| 22.8k| if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) ------------------ | Branch (596:17): [True: 0, False: 22.8k] ------------------ 597| 0| return 0; 598| 22.8k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (598:17): [True: 0, False: 22.8k] ------------------ 599| 0| return 0; 600| 22.8k| } 601| 62.3k| emitter->open_ended = 0; 602| | 603| 62.3k| if (event->data.document_start.version_directive) { ------------------ | Branch (603:13): [True: 9.08k, False: 53.2k] ------------------ 604| 9.08k| implicit = 0; 605| 9.08k| if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0)) ------------------ | Branch (605:17): [True: 0, False: 9.08k] ------------------ 606| 0| return 0; 607| 9.08k| if (event->data.document_start.version_directive->minor == 1) { ------------------ | Branch (607:17): [True: 5.57k, False: 3.50k] ------------------ 608| 5.57k| if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0)) ------------------ | Branch (608:21): [True: 0, False: 5.57k] ------------------ 609| 0| return 0; 610| 5.57k| } 611| 3.50k| else { 612| 3.50k| if (!yaml_emitter_write_indicator(emitter, "1.2", 1, 0, 0)) ------------------ | Branch (612:21): [True: 0, False: 3.50k] ------------------ 613| 0| return 0; 614| 3.50k| } 615| 9.08k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (615:17): [True: 0, False: 9.08k] ------------------ 616| 0| return 0; 617| 9.08k| } 618| | 619| 62.3k| if (event->data.document_start.tag_directives.start ------------------ | Branch (619:13): [True: 14.5k, False: 47.8k] ------------------ 620| 62.3k| != event->data.document_start.tag_directives.end) { 621| 14.5k| implicit = 0; 622| 14.5k| for (tag_directive = event->data.document_start.tag_directives.start; 623| 119k| tag_directive != event->data.document_start.tag_directives.end; ------------------ | Branch (623:21): [True: 104k, False: 14.5k] ------------------ 624| 104k| tag_directive ++) { 625| 104k| if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0)) ------------------ | Branch (625:21): [True: 0, False: 104k] ------------------ 626| 0| return 0; 627| 104k| if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle, ------------------ | Branch (627:21): [True: 0, False: 104k] ------------------ 628| 104k| strlen((char *)tag_directive->handle))) 629| 0| return 0; 630| 104k| if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix, ------------------ | Branch (630:21): [True: 0, False: 104k] ------------------ 631| 104k| strlen((char *)tag_directive->prefix), 1)) 632| 0| return 0; 633| 104k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (633:21): [True: 0, False: 104k] ------------------ 634| 0| return 0; 635| 104k| } 636| 14.5k| } 637| | 638| 62.3k| if (yaml_emitter_check_empty_document(emitter)) { ------------------ | Branch (638:13): [True: 0, False: 62.3k] ------------------ 639| 0| implicit = 0; 640| 0| } 641| | 642| 62.3k| if (!implicit) { ------------------ | Branch (642:13): [True: 58.5k, False: 3.80k] ------------------ 643| 58.5k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (643:17): [True: 0, False: 58.5k] ------------------ 644| 0| return 0; 645| 58.5k| if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0)) ------------------ | Branch (645:17): [True: 0, False: 58.5k] ------------------ 646| 0| return 0; 647| 58.5k| if (emitter->canonical) { ------------------ | Branch (647:17): [True: 37.2k, False: 21.2k] ------------------ 648| 37.2k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (648:21): [True: 0, False: 37.2k] ------------------ 649| 0| return 0; 650| 37.2k| } 651| 58.5k| } 652| | 653| 62.3k| emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE; 654| | 655| 62.3k| emitter->open_ended = 0; 656| 62.3k| return 1; 657| 62.3k| } 658| | 659| 1.64k| else if (event->type == YAML_STREAM_END_EVENT) ------------------ | Branch (659:14): [True: 1.64k, False: 0] ------------------ 660| 1.64k| { 661| | 662| | /** 663| | * This can happen if a block scalar with trailing empty lines 664| | * is at the end of the stream 665| | */ 666| 1.64k| if (emitter->open_ended == 2) ------------------ | Branch (666:13): [True: 31, False: 1.61k] ------------------ 667| 31| { 668| 31| if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) ------------------ | Branch (668:17): [True: 0, False: 31] ------------------ 669| 0| return 0; 670| 31| emitter->open_ended = 0; 671| 31| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (671:17): [True: 0, False: 31] ------------------ 672| 0| return 0; 673| 31| } 674| 1.64k| if (!yaml_emitter_flush(emitter)) ------------------ | Branch (674:13): [True: 0, False: 1.64k] ------------------ 675| 0| return 0; 676| | 677| 1.64k| emitter->state = YAML_EMIT_END_STATE; 678| | 679| 1.64k| return 1; 680| 1.64k| } 681| | 682| 0| return yaml_emitter_set_emitter_error(emitter, 683| 0| "expected DOCUMENT-START or STREAM-END"); 684| 63.9k|} emitter.c:yaml_emitter_analyze_version_directive: 1354| 9.08k|{ 1355| 9.08k| if (version_directive.major != 1 || ( ------------------ | Branch (1355:9): [True: 0, False: 9.08k] ------------------ 1356| 9.08k| version_directive.minor != 1 ------------------ | Branch (1356:9): [True: 3.50k, False: 5.57k] ------------------ 1357| 3.50k| && version_directive.minor != 2 ------------------ | Branch (1357:12): [True: 0, False: 3.50k] ------------------ 1358| 9.08k| )) { 1359| 0| return yaml_emitter_set_emitter_error(emitter, 1360| 0| "incompatible %YAML directive"); 1361| 0| } 1362| | 1363| 9.08k| return 1; 1364| 9.08k|} emitter.c:yaml_emitter_analyze_tag_directive: 1373| 104k|{ 1374| 104k| yaml_string_t handle; 1375| 104k| yaml_string_t prefix; 1376| 104k| size_t handle_length; 1377| 104k| size_t prefix_length; 1378| | 1379| 104k| handle_length = strlen((char *)tag_directive.handle); 1380| 104k| prefix_length = strlen((char *)tag_directive.prefix); 1381| 104k| STRING_ASSIGN(handle, tag_directive.handle, handle_length); ------------------ | | 128| 104k| ((value).start = (string), \ | | 129| 104k| (value).end = (string)+(length), \ | | 130| 104k| (value).pointer = (string)) ------------------ 1382| 104k| STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length); ------------------ | | 128| 104k| ((value).start = (string), \ | | 129| 104k| (value).end = (string)+(length), \ | | 130| 104k| (value).pointer = (string)) ------------------ 1383| | 1384| 104k| if (handle.start == handle.end) { ------------------ | Branch (1384:9): [True: 0, False: 104k] ------------------ 1385| 0| return yaml_emitter_set_emitter_error(emitter, 1386| 0| "tag handle must not be empty"); 1387| 0| } 1388| | 1389| 104k| if (handle.start[0] != '!') { ------------------ | Branch (1389:9): [True: 0, False: 104k] ------------------ 1390| 0| return yaml_emitter_set_emitter_error(emitter, 1391| 0| "tag handle must start with '!'"); 1392| 0| } 1393| | 1394| 104k| if (handle.end[-1] != '!') { ------------------ | Branch (1394:9): [True: 0, False: 104k] ------------------ 1395| 0| return yaml_emitter_set_emitter_error(emitter, 1396| 0| "tag handle must end with '!'"); 1397| 0| } 1398| | 1399| 104k| handle.pointer ++; 1400| | 1401| 2.25M| while (handle.pointer < handle.end-1) { ------------------ | Branch (1401:12): [True: 2.15M, False: 104k] ------------------ 1402| 2.15M| if (!IS_ALPHA(handle)) { ------------------ | | 198| 2.15M|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 2.15M| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 2.15M, False: 3.93k] | | | | ------------------ | | | | 190| 2.15M| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 55.7k, False: 2.09M] | | | | ------------------ | | | | 191| 2.15M| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 2.09M, False: 3.93k] | | | | ------------------ | | | | 192| 2.09M| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 230k, False: 1.86M] | | | | ------------------ | | | | 193| 2.15M| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 1.84M, False: 27.0k] | | | | ------------------ | | | | 194| 1.86M| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 1.84M, False: 0] | | | | ------------------ | | | | 195| 2.15M| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 23.1k, False: 3.93k] | | | | ------------------ | | | | 196| 2.15M| (string).pointer[offset] == '-') | | | | ------------------ | | | | | Branch (196:7): [True: 3.93k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1403| 0| return yaml_emitter_set_emitter_error(emitter, 1404| 0| "tag handle must contain alphanumerical characters only"); 1405| 0| } 1406| 2.15M| MOVE(handle); ------------------ | | 391| 2.15M|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 2.15M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.15M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.15M, False: 0] | | | | | | ------------------ | | | | | | 381| 2.15M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1407| 2.15M| } 1408| | 1409| 104k| if (prefix.start == prefix.end) { ------------------ | Branch (1409:9): [True: 2, False: 104k] ------------------ 1410| 2| return yaml_emitter_set_emitter_error(emitter, 1411| 2| "tag prefix must not be empty"); 1412| 2| } 1413| | 1414| 104k| return 1; 1415| 104k|} emitter.c:yaml_emitter_append_tag_directive: 366| 229k|{ 367| 229k| yaml_tag_directive_t *tag_directive; 368| 229k| yaml_tag_directive_t copy = { NULL, NULL }; 369| | 370| 229k| for (tag_directive = emitter->tag_directives.start; 371| 1.04M| tag_directive != emitter->tag_directives.top; tag_directive ++) { ------------------ | Branch (371:13): [True: 837k, False: 209k] ------------------ 372| 837k| if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { ------------------ | Branch (372:13): [True: 19.3k, False: 818k] ------------------ 373| 19.3k| if (allow_duplicates) ------------------ | Branch (373:17): [True: 19.3k, False: 0] ------------------ 374| 19.3k| return 1; 375| 0| return yaml_emitter_set_emitter_error(emitter, 376| 0| "duplicate %TAG directive"); 377| 19.3k| } 378| 837k| } 379| | 380| 209k| copy.handle = yaml_strdup(value.handle); 381| 209k| copy.prefix = yaml_strdup(value.prefix); 382| 209k| if (!copy.handle || !copy.prefix) { ------------------ | Branch (382:9): [True: 0, False: 209k] | Branch (382:25): [True: 0, False: 209k] ------------------ 383| 0| emitter->error = YAML_MEMORY_ERROR; 384| 0| goto error; 385| 0| } 386| | 387| 209k| if (!PUSH(emitter, emitter->tag_directives, copy)) ------------------ | | 445| 209k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 209k, False: 40] | | ------------------ | | 446| 209k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 40, False: 0] | | ------------------ | | 447| 40| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 209k| (*((stack).top++) = value, \ | | 449| 209k| 1) : \ | | 450| 209k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (387:9): [True: 0, False: 209k] ------------------ 388| 0| goto error; 389| | 390| 209k| return 1; 391| | 392| 0|error: 393| 0| yaml_free(copy.handle); 394| 0| yaml_free(copy.prefix); 395| 0| return 0; 396| 209k|} emitter.c:yaml_emitter_write_indicator: 1811| 16.4M|{ 1812| 16.4M| size_t indicator_length; 1813| 16.4M| yaml_string_t string; 1814| | 1815| 16.4M| indicator_length = strlen(indicator); 1816| 16.4M| STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length); ------------------ | | 128| 16.4M| ((value).start = (string), \ | | 129| 16.4M| (value).end = (string)+(length), \ | | 130| 16.4M| (value).pointer = (string)) ------------------ 1817| | 1818| 16.4M| if (need_whitespace && !emitter->whitespace) { ------------------ | Branch (1818:9): [True: 9.32M, False: 7.10M] | Branch (1818:28): [True: 4.35M, False: 4.96M] ------------------ 1819| 4.35M| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 4.35M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 8.71M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 4.35M, False: 341] | | | | ------------------ | | | | 10| 8.71M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 341, False: 0] | | | | ------------------ | | ------------------ | | 18| 4.35M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 4.35M, False: 0] | | ------------------ | | 19| 4.35M| emitter->column++, \ | | 20| 4.35M| 1)) ------------------ 1820| 4.35M| } 1821| | 1822| 33.6M| while (string.pointer != string.end) { ------------------ | Branch (1822:12): [True: 17.2M, False: 16.4M] ------------------ 1823| 17.2M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 17.2M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 34.4M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 17.2M, False: 1.16k] | | | | ------------------ | | | | 10| 34.4M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1.16k, False: 0] | | | | ------------------ | | ------------------ | | 45| 17.2M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 17.2M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 17.2M, False: 0] | | | | ------------------ | | | | 399| 17.2M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 17.2M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 17.2M, False: 0] | | ------------------ | | 46| 17.2M| emitter->column ++, \ | | 47| 17.2M| 1)) ------------------ 1824| 17.2M| } 1825| | 1826| 16.4M| emitter->whitespace = is_whitespace; 1827| 16.4M| emitter->indention = (emitter->indention && is_indention); ------------------ | Branch (1827:27): [True: 6.56M, False: 9.85M] | Branch (1827:49): [True: 1.31M, False: 5.25M] ------------------ 1828| | 1829| 16.4M| return 1; 1830| 16.4M|} emitter.c:yaml_emitter_write_indent: 1789| 9.09M|{ 1790| 9.09M| int indent = (emitter->indent >= 0) ? emitter->indent : 0; ------------------ | Branch (1790:18): [True: 8.77M, False: 320k] ------------------ 1791| | 1792| 9.09M| if (!emitter->indention || emitter->column > indent ------------------ | Branch (1792:9): [True: 6.98M, False: 2.10M] | Branch (1792:32): [True: 1.27M, False: 831k] ------------------ 1793| 8.26M| || (emitter->column == indent && !emitter->whitespace)) { ------------------ | Branch (1793:17): [True: 74.0k, False: 756k] | Branch (1793:46): [True: 0, False: 74.0k] ------------------ 1794| 8.26M| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 8.26M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 16.5M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 8.26M, False: 827] | | | | ------------------ | | | | 10| 16.5M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 827, False: 0] | | | | ------------------ | | ------------------ | | 28| 8.26M| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 8.26M, False: 0] | | | Branch (28:11): [True: 0, False: 8.26M] | | ------------------ | | 29| 8.26M| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 8.26M| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 8.26M, False: 0] | | ------------------ | | 31| 8.26M| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 8.26M| emitter->line_break == YAML_CRLN_BREAK ? \ | | ------------------ | | | Branch (32:11): [True: 0, False: 0] | | ------------------ | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | 35| 8.26M| emitter->column = 0, \ | | 36| 8.26M| emitter->line ++, \ | | 37| 8.26M| 1)) ------------------ 1795| 8.26M| } 1796| | 1797| 2.43G| while (emitter->column < indent) { ------------------ | Branch (1797:12): [True: 2.42G, False: 9.09M] ------------------ 1798| 2.42G| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 2.42G| (FLUSH(emitter) \ | | ------------------ | | | | 9| 4.84G| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 2.42G, False: 136k] | | | | ------------------ | | | | 10| 4.84G| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 136k, False: 0] | | | | ------------------ | | ------------------ | | 18| 2.42G| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 2.42G, False: 0] | | ------------------ | | 19| 2.42G| emitter->column++, \ | | 20| 2.42G| 1)) ------------------ 1799| 2.42G| } 1800| | 1801| 9.09M| emitter->whitespace = 1; 1802| 9.09M| emitter->indention = 1; 1803| | 1804| 9.09M| return 1; 1805| 9.09M|} emitter.c:yaml_emitter_write_tag_handle: 1852| 3.54M|{ 1853| 3.54M| yaml_string_t string; 1854| 3.54M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 3.54M| ((value).start = (string), \ | | 129| 3.54M| (value).end = (string)+(length), \ | | 130| 3.54M| (value).pointer = (string)) ------------------ 1855| | 1856| 3.54M| if (!emitter->whitespace) { ------------------ | Branch (1856:9): [True: 3.11M, False: 432k] ------------------ 1857| 3.11M| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 3.11M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 6.22M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.11M, False: 344] | | | | ------------------ | | | | 10| 6.22M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 344, False: 0] | | | | ------------------ | | ------------------ | | 18| 3.11M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 3.11M, False: 0] | | ------------------ | | 19| 3.11M| emitter->column++, \ | | 20| 3.11M| 1)) ------------------ 1858| 3.11M| } 1859| | 1860| 13.5M| while (string.pointer != string.end) { ------------------ | Branch (1860:12): [True: 9.96M, False: 3.54M] ------------------ 1861| 9.96M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 9.96M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 19.9M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 9.95M, False: 601] | | | | ------------------ | | | | 10| 19.9M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 601, False: 0] | | | | ------------------ | | ------------------ | | 45| 9.96M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 9.96M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 9.96M, False: 0] | | | | ------------------ | | | | 399| 9.96M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 9.96M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 9.96M, False: 0] | | ------------------ | | 46| 9.96M| emitter->column ++, \ | | 47| 9.96M| 1)) ------------------ 1862| 9.96M| } 1863| | 1864| 3.54M| emitter->whitespace = 0; 1865| 3.54M| emitter->indention = 0; 1866| | 1867| 3.54M| return 1; 1868| 3.54M|} emitter.c:yaml_emitter_write_tag_content: 1874| 3.81M|{ 1875| 3.81M| yaml_string_t string; 1876| 3.81M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 3.81M| ((value).start = (string), \ | | 129| 3.81M| (value).end = (string)+(length), \ | | 130| 3.81M| (value).pointer = (string)) ------------------ 1877| | 1878| 3.81M| if (need_whitespace && !emitter->whitespace) { ------------------ | Branch (1878:9): [True: 104k, False: 3.71M] | Branch (1878:28): [True: 104k, False: 0] ------------------ 1879| 104k| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 104k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 209k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 104k, False: 1] | | | | ------------------ | | | | 10| 209k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 18| 104k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 104k, False: 0] | | ------------------ | | 19| 104k| emitter->column++, \ | | 20| 104k| 1)) ------------------ 1880| 104k| } 1881| | 1882| 42.3M| while (string.pointer != string.end) { ------------------ | Branch (1882:12): [True: 38.5M, False: 3.81M] ------------------ 1883| 38.5M| if (IS_ALPHA(string) ------------------ | | 198| 38.5M|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 77.1M| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 24.5M, False: 14.0M] | | | | ------------------ | | | | 190| 38.5M| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 1.79M, False: 22.7M] | | | | ------------------ | | | | 191| 38.5M| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 22.0M, False: 14.7M] | | | | ------------------ | | | | 192| 36.7M| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 175k, False: 21.8M] | | | | ------------------ | | | | 193| 38.5M| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 21.8M, False: 14.7M] | | | | ------------------ | | | | 194| 36.6M| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 21.8M, False: 1.18k] | | | | ------------------ | | | | 195| 38.5M| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 15.5k, False: 14.7M] | | | | ------------------ | | | | 196| 77.1M| (string).pointer[offset] == '-') | | | | ------------------ | | | | | Branch (196:7): [True: 50.0k, False: 14.6M] | | | | ------------------ | | ------------------ ------------------ 1884| 14.6M| || CHECK(string, ';') || CHECK(string, '/') ------------------ | | 181| 53.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.34k, False: 14.6M] | | ------------------ ------------------ || CHECK(string, ';') || CHECK(string, '/') ------------------ | | 181| 53.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 17.0k, False: 14.6M] | | ------------------ ------------------ 1885| 14.6M| || CHECK(string, '?') || CHECK(string, ':') ------------------ | | 181| 53.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 15.1k, False: 14.6M] | | ------------------ ------------------ || CHECK(string, '?') || CHECK(string, ':') ------------------ | | 181| 53.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 626k, False: 14.0M] | | ------------------ ------------------ 1886| 14.0M| || CHECK(string, '@') || CHECK(string, '&') ------------------ | | 181| 52.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.4k, False: 14.0M] | | ------------------ ------------------ || CHECK(string, '@') || CHECK(string, '&') ------------------ | | 181| 52.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.27k, False: 13.9M] | | ------------------ ------------------ 1887| 13.9M| || CHECK(string, '=') || CHECK(string, '+') ------------------ | | 181| 52.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.83k, False: 13.9M] | | ------------------ ------------------ || CHECK(string, '=') || CHECK(string, '+') ------------------ | | 181| 52.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.94k, False: 13.9M] | | ------------------ ------------------ 1888| 13.9M| || CHECK(string, '$') || CHECK(string, ',') ------------------ | | 181| 52.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10.4k, False: 13.9M] | | ------------------ ------------------ || CHECK(string, '$') || CHECK(string, ',') ------------------ | | 181| 52.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 304k, False: 13.6M] | | ------------------ ------------------ 1889| 13.6M| || CHECK(string, '_') || CHECK(string, '.') ------------------ | | 181| 52.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 13.6M] | | ------------------ ------------------ || CHECK(string, '_') || CHECK(string, '.') ------------------ | | 181| 52.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 307k, False: 13.3M] | | ------------------ ------------------ 1890| 13.3M| || CHECK(string, '~') || CHECK(string, '*') ------------------ | | 181| 51.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 451, False: 13.3M] | | ------------------ ------------------ || CHECK(string, '~') || CHECK(string, '*') ------------------ | | 181| 51.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 13.6k, False: 13.3M] | | ------------------ ------------------ 1891| 13.3M| || CHECK(string, '\'') || CHECK(string, '(') ------------------ | | 181| 51.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.10k, False: 13.3M] | | ------------------ ------------------ || CHECK(string, '\'') || CHECK(string, '(') ------------------ | | 181| 51.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 4.33k, False: 13.3M] | | ------------------ ------------------ 1892| 13.3M| || CHECK(string, ')') || CHECK(string, '[') ------------------ | | 181| 51.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 4.40k, False: 13.3M] | | ------------------ ------------------ || CHECK(string, ')') || CHECK(string, '[') ------------------ | | 181| 51.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.63k, False: 13.3M] | | ------------------ ------------------ 1893| 25.2M| || CHECK(string, ']')) { ------------------ | | 181| 13.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.62k, False: 13.3M] | | ------------------ ------------------ 1894| 25.2M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 25.2M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 50.5M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 25.2M, False: 1.76k] | | | | ------------------ | | | | 10| 50.5M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1.76k, False: 0] | | | | ------------------ | | ------------------ | | 45| 25.2M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 25.2M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 25.2M, False: 0] | | | | ------------------ | | | | 399| 25.2M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 25.2M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 25.2M, False: 0] | | ------------------ | | 46| 25.2M| emitter->column ++, \ | | 47| 25.2M| 1)) ------------------ 1895| 25.2M| } 1896| 13.3M| else { 1897| 13.3M| int width = WIDTH(string); ------------------ | | 385| 13.3M|#define WIDTH(string) WIDTH_AT((string),0) | | ------------------ | | | | 380| 13.3M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | ------------------ | | | | | Branch (380:7): [True: 13.3M, False: 733] | | | | ------------------ | | | | 381| 13.3M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | ------------------ | | | | | Branch (381:7): [True: 317, False: 416] | | | | ------------------ | | | | 382| 733| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | ------------------ | | | | | Branch (382:7): [True: 197, False: 219] | | | | ------------------ | | | | 383| 416| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | ------------------ | | | | | Branch (383:7): [True: 219, False: 0] | | | | ------------------ | | ------------------ ------------------ 1898| 13.3M| unsigned int value; 1899| 26.6M| while (width --) { ------------------ | Branch (1899:20): [True: 13.3M, False: 13.3M] ------------------ 1900| 13.3M| value = *(string.pointer++); 1901| 13.3M| if (!PUT(emitter, '%')) return 0; ------------------ | | 17| 13.3M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 26.6M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 13.3M, False: 974] | | | | ------------------ | | | | 10| 26.6M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 974, False: 0] | | | | ------------------ | | ------------------ | | 18| 13.3M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 13.3M, False: 0] | | ------------------ | | 19| 13.3M| emitter->column++, \ | | 20| 13.3M| 1)) ------------------ 1902| 13.3M| if (!PUT(emitter, (value >> 4) ------------------ | | 17| 13.3M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 26.6M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 13.3M, False: 1.06k] | | | | ------------------ | | | | 10| 26.6M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1.06k, False: 0] | | | | ------------------ | | ------------------ | | 18| 26.6M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 13.3M, False: 0] | | | Branch (18:55): [True: 13.3M, False: 2.08k] | | ------------------ | | 19| 13.3M| emitter->column++, \ | | 20| 13.3M| 1)) ------------------ 1903| 13.3M| + ((value >> 4) < 10 ? '0' : 'A' - 10))) 1904| 0| return 0; 1905| 13.3M| if (!PUT(emitter, (value & 0x0F) ------------------ | | 17| 13.3M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 26.6M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 13.3M, False: 962] | | | | ------------------ | | | | 10| 26.6M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 962, False: 0] | | | | ------------------ | | ------------------ | | 18| 26.6M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 13.3M, False: 0] | | | Branch (18:55): [True: 13.3M, False: 1.99k] | | ------------------ | | 19| 13.3M| emitter->column++, \ | | 20| 13.3M| 1)) ------------------ 1906| 13.3M| + ((value & 0x0F) < 10 ? '0' : 'A' - 10))) 1907| 0| return 0; 1908| 13.3M| } 1909| 13.3M| } 1910| 38.5M| } 1911| | 1912| 3.81M| emitter->whitespace = 0; 1913| 3.81M| emitter->indention = 0; 1914| | 1915| 3.81M| return 1; 1916| 3.81M|} emitter.c:yaml_emitter_check_empty_document: 1110| 62.3k|{ 1111| 62.3k| return 0; 1112| 62.3k|} emitter.c:yaml_emitter_emit_document_content: 693| 62.3k|{ 694| 62.3k| if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE)) ------------------ | | 445| 62.3k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 62.3k, False: 0] | | ------------------ | | 446| 62.3k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 62.3k| (*((stack).top++) = value, \ | | 449| 62.3k| 1) : \ | | 450| 62.3k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (694:9): [True: 0, False: 62.3k] ------------------ 695| 0| return 0; 696| | 697| 62.3k| return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0); 698| 62.3k|} emitter.c:yaml_emitter_emit_node: 989| 6.02M|{ 990| 6.02M| emitter->root_context = root; 991| 6.02M| emitter->sequence_context = sequence; 992| 6.02M| emitter->mapping_context = mapping; 993| 6.02M| emitter->simple_key_context = simple_key; 994| | 995| 6.02M| switch (event->type) 996| 6.02M| { 997| 130k| case YAML_ALIAS_EVENT: ------------------ | Branch (997:9): [True: 130k, False: 5.89M] ------------------ 998| 130k| return yaml_emitter_emit_alias(emitter, event); 999| | 1000| 3.53M| case YAML_SCALAR_EVENT: ------------------ | Branch (1000:9): [True: 3.53M, False: 2.48M] ------------------ 1001| 3.53M| return yaml_emitter_emit_scalar(emitter, event); 1002| | 1003| 115k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1003:9): [True: 115k, False: 5.90M] ------------------ 1004| 115k| return yaml_emitter_emit_sequence_start(emitter, event); 1005| | 1006| 2.23M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1006:9): [True: 2.23M, False: 3.78M] ------------------ 1007| 2.23M| return yaml_emitter_emit_mapping_start(emitter, event); 1008| | 1009| 0| default: ------------------ | Branch (1009:9): [True: 0, False: 6.02M] ------------------ 1010| 0| return yaml_emitter_set_emitter_error(emitter, 1011| 0| "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS"); 1012| 6.02M| } 1013| | 1014| 0| return 0; 1015| 6.02M|} emitter.c:yaml_emitter_emit_alias: 1023| 130k|{ 1024| 130k| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1024:9): [True: 0, False: 130k] ------------------ 1025| 0| return 0; 1026| 130k| if (emitter->simple_key_context) ------------------ | Branch (1026:9): [True: 117k, False: 12.8k] ------------------ 1027| 117k| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 117k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 235k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 117k, False: 201] | | | | ------------------ | | | | 10| 235k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 201, False: 0] | | | | ------------------ | | ------------------ | | 18| 117k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 117k, False: 0] | | ------------------ | | 19| 117k| emitter->column++, \ | | 20| 117k| 1)) ------------------ 1028| 130k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 130k| (*(--(stack).top)) ------------------ 1029| | 1030| 130k| return 1; 1031| 130k|} emitter.c:yaml_emitter_process_anchor: 1261| 6.02M|{ 1262| 6.02M| if (!emitter->anchor_data.anchor) ------------------ | Branch (1262:9): [True: 5.88M, False: 134k] ------------------ 1263| 5.88M| return 1; 1264| | 1265| 134k| if (!yaml_emitter_write_indicator(emitter, ------------------ | Branch (1265:9): [True: 0, False: 134k] ------------------ 1266| 134k| (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0)) ------------------ | Branch (1266:18): [True: 130k, False: 3.81k] ------------------ 1267| 0| return 0; 1268| | 1269| 134k| return yaml_emitter_write_anchor(emitter, 1270| 134k| emitter->anchor_data.anchor, emitter->anchor_data.anchor_length); 1271| 134k|} emitter.c:yaml_emitter_write_anchor: 1835| 134k|{ 1836| 134k| yaml_string_t string; 1837| 134k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 134k| ((value).start = (string), \ | | 129| 134k| (value).end = (string)+(length), \ | | 130| 134k| (value).pointer = (string)) ------------------ 1838| | 1839| 806k| while (string.pointer != string.end) { ------------------ | Branch (1839:12): [True: 672k, False: 134k] ------------------ 1840| 672k| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 672k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 1.34M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 671k, False: 241] | | | | ------------------ | | | | 10| 1.34M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 241, False: 0] | | | | ------------------ | | ------------------ | | 45| 672k| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 672k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 672k, False: 0] | | | | ------------------ | | | | 399| 672k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 672k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 672k, False: 0] | | ------------------ | | 46| 672k| emitter->column ++, \ | | 47| 672k| 1)) ------------------ 1841| 672k| } 1842| | 1843| 134k| emitter->whitespace = 0; 1844| 134k| emitter->indention = 0; 1845| | 1846| 134k| return 1; 1847| 134k|} emitter.c:yaml_emitter_emit_scalar: 1039| 3.53M|{ 1040| 3.53M| if (!yaml_emitter_select_scalar_style(emitter, event)) ------------------ | Branch (1040:9): [True: 0, False: 3.53M] ------------------ 1041| 0| return 0; 1042| 3.53M| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1042:9): [True: 0, False: 3.53M] ------------------ 1043| 0| return 0; 1044| 3.53M| if (!yaml_emitter_process_tag(emitter)) ------------------ | Branch (1044:9): [True: 0, False: 3.53M] ------------------ 1045| 0| return 0; 1046| 3.53M| if (!yaml_emitter_increase_indent(emitter, 1, 0)) ------------------ | Branch (1046:9): [True: 0, False: 3.53M] ------------------ 1047| 0| return 0; 1048| 3.53M| if (!yaml_emitter_process_scalar(emitter)) ------------------ | Branch (1048:9): [True: 0, False: 3.53M] ------------------ 1049| 0| return 0; 1050| 3.53M| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 3.53M| (*(--(stack).top)) ------------------ 1051| 3.53M| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 3.53M| (*(--(stack).top)) ------------------ 1052| | 1053| 3.53M| return 1; 1054| 3.53M|} emitter.c:yaml_emitter_select_scalar_style: 1199| 3.53M|{ 1200| 3.53M| yaml_scalar_style_t style = event->data.scalar.style; 1201| 3.53M| int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix); ------------------ | Branch (1201:19): [True: 1.53M, False: 2.00M] | Branch (1201:48): [True: 1.40M, False: 137k] ------------------ 1202| | 1203| 3.53M| if (no_tag && !event->data.scalar.plain_implicit ------------------ | Branch (1203:9): [True: 1.40M, False: 2.13M] | Branch (1203:19): [True: 0, False: 1.40M] ------------------ 1204| 0| && !event->data.scalar.quoted_implicit) { ------------------ | Branch (1204:16): [True: 0, False: 0] ------------------ 1205| 0| return yaml_emitter_set_emitter_error(emitter, 1206| 0| "neither tag nor implicit flags are specified"); 1207| 0| } 1208| | 1209| 3.53M| if (style == YAML_ANY_SCALAR_STYLE) ------------------ | Branch (1209:9): [True: 0, False: 3.53M] ------------------ 1210| 0| style = YAML_PLAIN_SCALAR_STYLE; 1211| | 1212| 3.53M| if (emitter->canonical) ------------------ | Branch (1212:9): [True: 2.13M, False: 1.40M] ------------------ 1213| 2.13M| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1214| | 1215| 3.53M| if (emitter->simple_key_context && emitter->scalar_data.multiline) ------------------ | Branch (1215:9): [True: 348k, False: 3.19M] | Branch (1215:40): [True: 0, False: 348k] ------------------ 1216| 0| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1217| | 1218| 3.53M| if (style == YAML_PLAIN_SCALAR_STYLE) ------------------ | Branch (1218:9): [True: 1.37M, False: 2.16M] ------------------ 1219| 1.37M| { 1220| 1.37M| if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed) ------------------ | Branch (1220:14): [True: 305k, False: 1.06M] | Branch (1220:37): [True: 217k, False: 87.4k] ------------------ 1221| 1.15M| || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed)) ------------------ | Branch (1221:21): [True: 1.06M, False: 87.4k] | Branch (1221:45): [True: 117k, False: 951k] ------------------ 1222| 335k| style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1223| 1.37M| if (!emitter->scalar_data.length ------------------ | Branch (1223:13): [True: 1.02M, False: 348k] ------------------ 1224| 1.02M| && (emitter->flow_level || emitter->simple_key_context)) ------------------ | Branch (1224:21): [True: 216k, False: 809k] | Branch (1224:44): [True: 11.4k, False: 798k] ------------------ 1225| 227k| style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1226| 1.37M| if (no_tag && !event->data.scalar.plain_implicit) ------------------ | Branch (1226:13): [True: 1.37M, False: 1.20k] | Branch (1226:23): [True: 0, False: 1.37M] ------------------ 1227| 0| style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1228| 1.37M| } 1229| | 1230| 3.53M| if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE) ------------------ | Branch (1230:9): [True: 351k, False: 3.18M] ------------------ 1231| 351k| { 1232| 351k| if (!emitter->scalar_data.single_quoted_allowed) ------------------ | Branch (1232:13): [True: 7.12k, False: 344k] ------------------ 1233| 7.12k| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1234| 351k| } 1235| | 1236| 3.53M| if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE) ------------------ | Branch (1236:9): [True: 15.5k, False: 3.52M] | Branch (1236:47): [True: 6.97k, False: 3.51M] ------------------ 1237| 22.4k| { 1238| 22.4k| if (!emitter->scalar_data.block_allowed ------------------ | Branch (1238:13): [True: 3.75k, False: 18.7k] ------------------ 1239| 18.7k| || emitter->flow_level || emitter->simple_key_context) ------------------ | Branch (1239:20): [True: 0, False: 18.7k] | Branch (1239:43): [True: 201, False: 18.5k] ------------------ 1240| 3.95k| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1241| 22.4k| } 1242| | 1243| 3.53M| if (no_tag && !event->data.scalar.quoted_implicit ------------------ | Branch (1243:9): [True: 1.40M, False: 2.13M] | Branch (1243:19): [True: 0, False: 1.40M] ------------------ 1244| 0| && style != YAML_PLAIN_SCALAR_STYLE) ------------------ | Branch (1244:16): [True: 0, False: 0] ------------------ 1245| 0| { 1246| 0| emitter->tag_data.handle = (yaml_char_t *)"!"; 1247| 0| emitter->tag_data.handle_length = 1; 1248| 0| } 1249| | 1250| 3.53M| emitter->scalar_data.style = style; 1251| | 1252| 3.53M| return 1; 1253| 3.53M|} emitter.c:yaml_emitter_process_tag: 1279| 5.89M|{ 1280| 5.89M| if (!emitter->tag_data.handle && !emitter->tag_data.suffix) ------------------ | Branch (1280:9): [True: 2.45M, False: 3.44M] | Branch (1280:38): [True: 2.17M, False: 271k] ------------------ 1281| 2.17M| return 1; 1282| | 1283| 3.71M| if (emitter->tag_data.handle) ------------------ | Branch (1283:9): [True: 3.44M, False: 271k] ------------------ 1284| 3.44M| { 1285| 3.44M| if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle, ------------------ | Branch (1285:13): [True: 0, False: 3.44M] ------------------ 1286| 3.44M| emitter->tag_data.handle_length)) 1287| 0| return 0; 1288| 3.44M| if (emitter->tag_data.suffix) { ------------------ | Branch (1288:13): [True: 3.44M, False: 0] ------------------ 1289| 3.44M| if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, ------------------ | Branch (1289:17): [True: 0, False: 3.44M] ------------------ 1290| 3.44M| emitter->tag_data.suffix_length, 0)) 1291| 0| return 0; 1292| 3.44M| } 1293| 3.44M| } 1294| 271k| else 1295| 271k| { 1296| 271k| if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0)) ------------------ | Branch (1296:13): [True: 0, False: 271k] ------------------ 1297| 0| return 0; 1298| 271k| if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, ------------------ | Branch (1298:13): [True: 0, False: 271k] ------------------ 1299| 271k| emitter->tag_data.suffix_length, 0)) 1300| 0| return 0; 1301| 271k| if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0)) ------------------ | Branch (1301:13): [True: 0, False: 271k] ------------------ 1302| 0| return 0; 1303| 271k| } 1304| | 1305| 3.71M| return 1; 1306| 3.71M|} emitter.c:yaml_emitter_increase_indent: 405| 5.89M|{ 406| 5.89M| if (!PUSH(emitter, emitter->indents, emitter->indent)) ------------------ | | 445| 5.89M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 5.88M, False: 2.56k] | | ------------------ | | 446| 5.89M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 2.56k, False: 0] | | ------------------ | | 447| 2.56k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 5.89M| (*((stack).top++) = value, \ | | 449| 5.89M| 1) : \ | | 450| 5.89M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (406:9): [True: 0, False: 5.89M] ------------------ 407| 0| return 0; 408| | 409| 5.89M| if (emitter->indent < 0) { ------------------ | Branch (409:9): [True: 62.3k, False: 5.82M] ------------------ 410| 62.3k| emitter->indent = flow ? emitter->best_indent : 0; ------------------ | Branch (410:27): [True: 40.9k, False: 21.3k] ------------------ 411| 62.3k| } 412| 5.82M| else if (!indentless) { ------------------ | Branch (412:14): [True: 5.81M, False: 18.1k] ------------------ 413| 5.81M| emitter->indent += emitter->best_indent; 414| 5.81M| } 415| | 416| 5.89M| return 1; 417| 5.89M|} emitter.c:yaml_emitter_process_scalar: 1314| 3.53M|{ 1315| 3.53M| switch (emitter->scalar_data.style) 1316| 3.53M| { 1317| 1.02M| case YAML_PLAIN_SCALAR_STYLE: ------------------ | Branch (1317:9): [True: 1.02M, False: 2.51M] ------------------ 1318| 1.02M| return yaml_emitter_write_plain_scalar(emitter, 1319| 1.02M| emitter->scalar_data.value, emitter->scalar_data.length, 1320| 1.02M| !emitter->simple_key_context); 1321| | 1322| 344k| case YAML_SINGLE_QUOTED_SCALAR_STYLE: ------------------ | Branch (1322:9): [True: 344k, False: 3.19M] ------------------ 1323| 344k| return yaml_emitter_write_single_quoted_scalar(emitter, 1324| 344k| emitter->scalar_data.value, emitter->scalar_data.length, 1325| 344k| !emitter->simple_key_context); 1326| | 1327| 2.14M| case YAML_DOUBLE_QUOTED_SCALAR_STYLE: ------------------ | Branch (1327:9): [True: 2.14M, False: 1.39M] ------------------ 1328| 2.14M| return yaml_emitter_write_double_quoted_scalar(emitter, 1329| 2.14M| emitter->scalar_data.value, emitter->scalar_data.length, 1330| 2.14M| !emitter->simple_key_context); 1331| | 1332| 14.0k| case YAML_LITERAL_SCALAR_STYLE: ------------------ | Branch (1332:9): [True: 14.0k, False: 3.52M] ------------------ 1333| 14.0k| return yaml_emitter_write_literal_scalar(emitter, 1334| 14.0k| emitter->scalar_data.value, emitter->scalar_data.length); 1335| | 1336| 4.44k| case YAML_FOLDED_SCALAR_STYLE: ------------------ | Branch (1336:9): [True: 4.44k, False: 3.53M] ------------------ 1337| 4.44k| return yaml_emitter_write_folded_scalar(emitter, 1338| 4.44k| emitter->scalar_data.value, emitter->scalar_data.length); 1339| | 1340| 0| default: ------------------ | Branch (1340:9): [True: 0, False: 3.53M] ------------------ 1341| 0| assert(1); /* Impossible. */ ------------------ | Branch (1341:13): [True: 0, Folded] | Branch (1341:13): [True: 0, Folded] ------------------ 1342| 3.53M| } 1343| | 1344| 0| return 0; 1345| 3.53M|} emitter.c:yaml_emitter_write_plain_scalar: 1921| 1.02M|{ 1922| 1.02M| yaml_string_t string; 1923| 1.02M| int spaces = 0; 1924| 1.02M| int breaks = 0; 1925| | 1926| 1.02M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 1.02M| ((value).start = (string), \ | | 129| 1.02M| (value).end = (string)+(length), \ | | 130| 1.02M| (value).pointer = (string)) ------------------ 1927| | 1928| | /** 1929| | * Avoid trailing spaces for empty values in block mode. 1930| | * In flow mode, we still want the space to prevent ambiguous things 1931| | * like {a:}. 1932| | * Currently, the emitter forbids any plain empty scalar in flow mode 1933| | * (e.g. it outputs {a: ''} instead), so emitter->flow_level will 1934| | * never be true here. 1935| | * But if the emitter is ever changed to allow emitting empty values, 1936| | * the check for flow_level is already here. 1937| | */ 1938| 1.02M| if (!emitter->whitespace && (length || emitter->flow_level)) { ------------------ | Branch (1938:9): [True: 888k, False: 138k] | Branch (1938:34): [True: 90.3k, False: 798k] | Branch (1938:44): [True: 0, False: 798k] ------------------ 1939| 90.3k| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 90.3k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 180k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 90.1k, False: 196] | | | | ------------------ | | | | 10| 180k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 196, False: 0] | | | | ------------------ | | ------------------ | | 18| 90.3k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 90.3k, False: 0] | | ------------------ | | 19| 90.3k| emitter->column++, \ | | 20| 90.3k| 1)) ------------------ 1940| 90.3k| } 1941| | 1942| 9.58M| while (string.pointer != string.end) ------------------ | Branch (1942:12): [True: 8.56M, False: 1.02M] ------------------ 1943| 8.56M| { 1944| 8.56M| if (IS_SPACE(string)) ------------------ | | 306| 8.56M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 8.56M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 8.56M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.53M, False: 6.02M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1945| 2.53M| { 1946| 2.53M| if (allow_breaks && !spaces ------------------ | Branch (1946:17): [True: 2.48M, False: 54.5k] | Branch (1946:33): [True: 687k, False: 1.79M] ------------------ 1947| 687k| && emitter->column > emitter->best_width ------------------ | Branch (1947:24): [True: 629k, False: 58.0k] ------------------ 1948| 629k| && !IS_SPACE_AT(string, 1)) { ------------------ | | 304| 629k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 629k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (1948:24): [True: 596k, False: 33.0k] ------------------ 1949| 596k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (1949:21): [True: 0, False: 596k] ------------------ 1950| 596k| MOVE(string); ------------------ | | 391| 596k|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 596k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 596k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 596k, False: 0] | | | | | | ------------------ | | | | | | 381| 596k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1951| 596k| } 1952| 1.93M| else { 1953| 1.93M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 1.93M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 3.87M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.93M, False: 294] | | | | ------------------ | | | | 10| 3.87M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 294, False: 0] | | | | ------------------ | | ------------------ | | 45| 1.93M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.93M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 1.93M, False: 0] | | | | ------------------ | | | | 399| 1.93M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.93M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 1.93M, False: 0] | | ------------------ | | 46| 1.93M| emitter->column ++, \ | | 47| 1.93M| 1)) ------------------ 1954| 1.93M| } 1955| 2.53M| spaces = 1; 1956| 2.53M| } 1957| 6.02M| else if (IS_BREAK(string)) ------------------ | | 341| 6.02M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 6.02M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 12.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 6.02M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 6.02M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 12.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 6.02M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 6.02M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 12.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.31k, False: 6.02M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 6.02M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 1.31k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 1.31k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 6.02M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 12.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 741k, False: 5.28M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 6.02M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 6.76M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 716k, False: 24.8k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 6.02M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 716k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 716k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 6.02M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 12.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 741k, False: 5.28M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 6.02M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 6.76M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 716k, False: 24.8k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 6.02M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 716k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 716k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1958| 0| { 1959| 0| if (!breaks && CHECK(string, '\n')) { ------------------ | | 181| 0|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 0| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1959:17): [True: 0, False: 0] ------------------ 1960| 0| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 0| (FLUSH(emitter) \ | | ------------------ | | | | 9| 0| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 0, False: 0] | | | | ------------------ | | | | 10| 0| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 28| 0| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 0, False: 0] | | | Branch (28:11): [True: 0, False: 0] | | ------------------ | | 29| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 0| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 0, False: 0] | | ------------------ | | 31| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 0| emitter->line_break == YAML_CRLN_BREAK ? \ | | ------------------ | | | Branch (32:11): [True: 0, False: 0] | | ------------------ | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | 35| 0| emitter->column = 0, \ | | 36| 0| emitter->line ++, \ | | 37| 0| 1)) ------------------ 1961| 0| } 1962| 0| if (!WRITE_BREAK(emitter, string)) return 0; ------------------ | | 54| 0| (FLUSH(emitter) \ | | ------------------ | | | | 9| 0| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 0, False: 0] | | | | ------------------ | | | | 10| 0| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 55| 0| && (CHECK(string,'\n') ? \ | | ------------------ | | | | 181| 0|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | | | ------------------ | | | | | | 175| 0| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (181:29): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (55:9): [True: 0, False: 0] | | ------------------ | | 56| 0| (PUT_BREAK(emitter), \ | | ------------------ | | | | 27| 0| (FLUSH(emitter) \ | | | | ------------------ | | | | | | 9| 0| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | | | ------------------ | | | | | | | Branch (9:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 10| 0| || yaml_emitter_flush(emitter)) | | | | | | ------------------ | | | | | | | Branch (10:9): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 28| 0| && ((emitter->line_break == YAML_CR_BREAK ? \ | | | | ------------------ | | | | | Branch (28:9): [True: 0, False: 0] | | | | | Branch (28:11): [True: 0, False: 0] | | | | ------------------ | | | | 29| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | | | 30| 0| emitter->line_break == YAML_LN_BREAK ? \ | | | | ------------------ | | | | | Branch (30:11): [True: 0, False: 0] | | | | ------------------ | | | | 31| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | | | 32| 0| emitter->line_break == YAML_CRLN_BREAK ? \ | | | | ------------------ | | | | | Branch (32:11): [True: 0, False: 0] | | | | ------------------ | | | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | | | 35| 0| emitter->column = 0, \ | | | | 36| 0| emitter->line ++, \ | | | | 37| 0| 1)) | | ------------------ | | 57| 0| string.pointer ++, \ | | 58| 0| 1) : \ | | 59| 0| (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 0| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 0, False: 0] | | | | ------------------ | | | | 399| 0| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 0| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 60| 0| emitter->column = 0, \ | | 61| 0| emitter->line ++, \ | | 62| 0| 1))) ------------------ 1963| 0| emitter->indention = 1; 1964| 0| breaks = 1; 1965| 0| } 1966| 6.02M| else 1967| 6.02M| { 1968| 6.02M| if (breaks) { ------------------ | Branch (1968:17): [True: 0, False: 6.02M] ------------------ 1969| 0| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (1969:21): [True: 0, False: 0] ------------------ 1970| 0| } 1971| 6.02M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 6.02M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 12.0M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 6.02M, False: 492] | | | | ------------------ | | | | 10| 12.0M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 492, False: 0] | | | | ------------------ | | ------------------ | | 45| 6.02M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 6.02M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 5.19M, False: 830k] | | | | ------------------ | | | | 399| 6.02M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 6.02M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 5.66k, False: 824k] | | | | ------------------ | | | | 401| 830k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 5.66k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 830k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 824k, False: 0] | | | | ------------------ | | | | 404| 824k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 824k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 824k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 824k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 6.02M, False: 0] | | ------------------ | | 46| 6.02M| emitter->column ++, \ | | 47| 6.02M| 1)) ------------------ 1972| 6.02M| emitter->indention = 0; 1973| 6.02M| spaces = 0; 1974| 6.02M| breaks = 0; 1975| 6.02M| } 1976| 8.56M| } 1977| | 1978| 1.02M| emitter->whitespace = 0; 1979| 1.02M| emitter->indention = 0; 1980| | 1981| 1.02M| return 1; 1982| 1.02M|} emitter.c:yaml_emitter_write_single_quoted_scalar: 1987| 344k|{ 1988| 344k| yaml_string_t string; 1989| 344k| int spaces = 0; 1990| 344k| int breaks = 0; 1991| | 1992| 344k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 344k| ((value).start = (string), \ | | 129| 344k| (value).end = (string)+(length), \ | | 130| 344k| (value).pointer = (string)) ------------------ 1993| | 1994| 344k| if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0)) ------------------ | Branch (1994:9): [True: 0, False: 344k] ------------------ 1995| 0| return 0; 1996| | 1997| 2.61M| while (string.pointer != string.end) ------------------ | Branch (1997:12): [True: 2.26M, False: 344k] ------------------ 1998| 2.26M| { 1999| 2.26M| if (IS_SPACE(string)) ------------------ | | 306| 2.26M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 2.26M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 2.26M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 95.7k, False: 2.17M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2000| 95.7k| { 2001| 95.7k| if (allow_breaks && !spaces ------------------ | Branch (2001:17): [True: 94.3k, False: 1.39k] | Branch (2001:33): [True: 34.1k, False: 60.2k] ------------------ 2002| 34.1k| && emitter->column > emitter->best_width ------------------ | Branch (2002:24): [True: 2.97k, False: 31.1k] ------------------ 2003| 2.97k| && string.pointer != string.start ------------------ | Branch (2003:24): [True: 2.74k, False: 231] ------------------ 2004| 2.74k| && string.pointer != string.end - 1 ------------------ | Branch (2004:24): [True: 2.54k, False: 205] ------------------ 2005| 2.54k| && !IS_SPACE_AT(string, 1)) { ------------------ | | 304| 2.54k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 2.54k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2005:24): [True: 1.99k, False: 545] ------------------ 2006| 1.99k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2006:21): [True: 0, False: 1.99k] ------------------ 2007| 1.99k| MOVE(string); ------------------ | | 391| 1.99k|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 1.99k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.99k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.99k, False: 0] | | | | | | ------------------ | | | | | | 381| 1.99k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2008| 1.99k| } 2009| 93.7k| else { 2010| 93.7k| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 93.7k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 187k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 93.5k, False: 201] | | | | ------------------ | | | | 10| 187k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 201, False: 0] | | | | ------------------ | | ------------------ | | 45| 93.7k| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 93.7k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 93.7k, False: 0] | | | | ------------------ | | | | 399| 93.7k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 93.7k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 93.7k, False: 0] | | ------------------ | | 46| 93.7k| emitter->column ++, \ | | 47| 93.7k| 1)) ------------------ 2011| 93.7k| } 2012| 95.7k| spaces = 1; 2013| 95.7k| } 2014| 2.17M| else if (IS_BREAK(string)) ------------------ | | 341| 2.17M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 2.17M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 4.34M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 2.17M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 2.17M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 4.34M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 25.3k, False: 2.14M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 2.17M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 4.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 346, False: 2.14M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 2.14M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 346| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 346] | | | | | | ------------------ | | | | ------------------ | | | | 334| 2.17M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 4.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 746k, False: 1.40M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 2.14M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 2.89M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 741k, False: 4.31k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 2.14M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 741k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 540, False: 741k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 2.17M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 4.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 745k, False: 1.40M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.14M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 2.89M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 741k, False: 4.31k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.14M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 741k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 849, False: 740k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2015| 26.7k| { 2016| 26.7k| if (!breaks && CHECK(string, '\n')) { ------------------ | | 181| 19.4k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 19.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 18.8k, False: 635] | | ------------------ ------------------ | Branch (2016:17): [True: 19.4k, False: 7.26k] ------------------ 2017| 18.8k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 18.8k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 37.6k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 18.6k, False: 200] | | | | ------------------ | | | | 10| 37.6k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 200, False: 0] | | | | ------------------ | | ------------------ | | 28| 18.8k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 18.8k, False: 0] | | | Branch (28:11): [True: 0, False: 18.8k] | | ------------------ | | 29| 18.8k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 18.8k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 18.8k, False: 0] | | ------------------ | | 31| 18.8k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 18.8k| emitter->line_break == YAML_CRLN_BREAK ? \ | | ------------------ | | | Branch (32:11): [True: 0, False: 0] | | ------------------ | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | 35| 18.8k| emitter->column = 0, \ | | 36| 18.8k| emitter->line ++, \ | | 37| 18.8k| 1)) ------------------ 2018| 18.8k| } 2019| 26.7k| if (!WRITE_BREAK(emitter, string)) return 0; ------------------ | | 54| 26.7k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 53.4k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 26.5k, False: 196] | | | | ------------------ | | | | 10| 53.4k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 196, False: 0] | | | | ------------------ | | ------------------ | | 55| 26.7k| && (CHECK(string,'\n') ? \ | | ------------------ | | | | 181| 26.7k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | | | ------------------ | | | | | | 175| 26.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (181:29): [True: 25.3k, False: 1.38k] | | | | ------------------ | | ------------------ | | | Branch (55:9): [True: 26.7k, False: 0] | | ------------------ | | 56| 26.7k| (PUT_BREAK(emitter), \ | | ------------------ | | | | 27| 25.3k| (FLUSH(emitter) \ | | | | ------------------ | | | | | | 9| 50.7k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | | | ------------------ | | | | | | | Branch (9:6): [True: 25.3k, False: 0] | | | | | | ------------------ | | | | | | 10| 50.7k| || yaml_emitter_flush(emitter)) | | | | | | ------------------ | | | | | | | Branch (10:9): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 28| 25.3k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | | | ------------------ | | | | | Branch (28:9): [True: 25.3k, False: 0] | | | | | Branch (28:11): [True: 0, False: 25.3k] | | | | ------------------ | | | | 29| 25.3k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | | | 30| 25.3k| emitter->line_break == YAML_LN_BREAK ? \ | | | | ------------------ | | | | | Branch (30:11): [True: 25.3k, False: 0] | | | | ------------------ | | | | 31| 25.3k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | | | 32| 25.3k| emitter->line_break == YAML_CRLN_BREAK ? \ | | | | ------------------ | | | | | Branch (32:11): [True: 0, False: 0] | | | | ------------------ | | | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | | | 35| 25.3k| emitter->column = 0, \ | | | | 36| 25.3k| emitter->line ++, \ | | | | 37| 25.3k| 1)) | | ------------------ | | 57| 25.3k| string.pointer ++, \ | | 58| 25.3k| 1) : \ | | 59| 26.7k| (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.38k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 0, False: 1.38k] | | | | ------------------ | | | | 399| 1.38k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.38k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 1.38k] | | | | ------------------ | | | | 401| 1.38k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 1.38k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 1.38k, False: 0] | | | | ------------------ | | | | 404| 1.38k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 1.38k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 1.38k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 1.38k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 60| 1.38k| emitter->column = 0, \ | | 61| 1.38k| emitter->line ++, \ | | 62| 1.38k| 1))) ------------------ 2020| 26.7k| emitter->indention = 1; 2021| 26.7k| breaks = 1; 2022| 26.7k| } 2023| 2.14M| else 2024| 2.14M| { 2025| 2.14M| if (breaks) { ------------------ | Branch (2025:17): [True: 19.2k, False: 2.12M] ------------------ 2026| 19.2k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2026:21): [True: 0, False: 19.2k] ------------------ 2027| 19.2k| } 2028| 2.14M| if (CHECK(string, '\'')) { ------------------ | | 181| 2.14M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.14M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.79k, False: 2.14M] | | ------------------ ------------------ 2029| 3.79k| if (!PUT(emitter, '\'')) return 0; ------------------ | | 17| 3.79k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 7.59k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.60k, False: 194] | | | | ------------------ | | | | 10| 7.59k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 18| 3.79k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 3.79k, False: 0] | | ------------------ | | 19| 3.79k| emitter->column++, \ | | 20| 3.79k| 1)) ------------------ 2030| 3.79k| } 2031| 2.14M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 2.14M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 4.29M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 2.14M, False: 418] | | | | ------------------ | | | | 10| 4.29M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 418, False: 0] | | | | ------------------ | | ------------------ | | 45| 2.14M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 2.14M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 1.30M, False: 838k] | | | | ------------------ | | | | 399| 2.14M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 2.14M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 437, False: 837k] | | | | ------------------ | | | | 401| 838k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 437| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 838k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 837k, False: 0] | | | | ------------------ | | | | 404| 837k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 837k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 837k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 837k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 2.14M, False: 0] | | ------------------ | | 46| 2.14M| emitter->column ++, \ | | 47| 2.14M| 1)) ------------------ 2032| 2.14M| emitter->indention = 0; 2033| 2.14M| spaces = 0; 2034| 2.14M| breaks = 0; 2035| 2.14M| } 2036| 2.26M| } 2037| | 2038| 344k| if (breaks) ------------------ | Branch (2038:9): [True: 195, False: 344k] ------------------ 2039| 195| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2039:13): [True: 0, False: 195] ------------------ 2040| | 2041| 344k| if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0)) ------------------ | Branch (2041:9): [True: 0, False: 344k] ------------------ 2042| 0| return 0; 2043| | 2044| 344k| emitter->whitespace = 0; 2045| 344k| emitter->indention = 0; 2046| | 2047| 344k| return 1; 2048| 344k|} emitter.c:yaml_emitter_write_double_quoted_scalar: 2053| 2.14M|{ 2054| 2.14M| yaml_string_t string; 2055| 2.14M| int spaces = 0; 2056| | 2057| 2.14M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 2.14M| ((value).start = (string), \ | | 129| 2.14M| (value).end = (string)+(length), \ | | 130| 2.14M| (value).pointer = (string)) ------------------ 2058| | 2059| 2.14M| if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0)) ------------------ | Branch (2059:9): [True: 0, False: 2.14M] ------------------ 2060| 0| return 0; 2061| | 2062| 23.9M| while (string.pointer != string.end) ------------------ | Branch (2062:12): [True: 21.7M, False: 2.14M] ------------------ 2063| 21.7M| { 2064| 21.7M| if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string)) ------------------ | | 279| 21.7M|#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) | | ------------------ | | | | 262| 43.5M| (((string).pointer[offset] == 0x0A) /* . == #x0A */ \ | | | | ------------------ | | | | | Branch (262:6): [True: 1.16M, False: 20.6M] | | | | ------------------ | | | | 263| 21.7M| || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \ | | | | ------------------ | | | | | Branch (263:10): [True: 18.1M, False: 2.48M] | | | | ------------------ | | | | 264| 20.6M| && (string).pointer[offset] <= 0x7E) \ | | | | ------------------ | | | | | Branch (264:13): [True: 12.2M, False: 5.92M] | | | | ------------------ | | | | 265| 21.7M| || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ | | | | ------------------ | | | | | Branch (265:10): [True: 204k, False: 8.20M] | | | | ------------------ | | | | 266| 8.40M| && (string).pointer[offset+1] >= 0xA0) \ | | | | ------------------ | | | | | Branch (266:13): [True: 26.5k, False: 178k] | | | | ------------------ | | | | 267| 21.7M| || ((string).pointer[offset] > 0xC2 \ | | | | ------------------ | | | | | Branch (267:10): [True: 5.72M, False: 2.66M] | | | | ------------------ | | | | 268| 8.38M| && (string).pointer[offset] < 0xED) \ | | | | ------------------ | | | | | Branch (268:13): [True: 5.63M, False: 85.4k] | | | | ------------------ | | | | 269| 21.7M| || ((string).pointer[offset] == 0xED \ | | | | ------------------ | | | | | Branch (269:10): [True: 16.8k, False: 2.72M] | | | | ------------------ | | | | 270| 2.74M| && (string).pointer[offset+1] < 0xA0) \ | | | | ------------------ | | | | | Branch (270:13): [True: 16.8k, False: 0] | | | | ------------------ | | | | 271| 21.7M| || ((string).pointer[offset] == 0xEE) \ | | | | ------------------ | | | | | Branch (271:9): [True: 1.73k, False: 2.72M] | | | | ------------------ | | | | 272| 43.5M| || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \ | | | | ------------------ | | | | | Branch (272:10): [True: 9.35k, False: 2.71M] | | | | ------------------ | | | | 273| 2.72M| && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \ | | | | ------------------ | | | | | Branch (273:15): [True: 2.92k, False: 6.43k] | | | | ------------------ | | | | 274| 9.35k| && (string).pointer[offset+2] == 0xBF) \ | | | | ------------------ | | | | | Branch (274:17): [True: 1.77k, False: 1.15k] | | | | ------------------ | | | | 275| 2.72M| && !((string).pointer[offset+1] == 0xBF \ | | | | ------------------ | | | | | Branch (275:15): [True: 1.31k, False: 6.26k] | | | | ------------------ | | | | 276| 7.58k| && ((string).pointer[offset+2] == 0xBE \ | | | | ------------------ | | | | | Branch (276:18): [True: 274, False: 1.04k] | | | | ------------------ | | | | 277| 1.31k| || (string).pointer[offset+2] == 0xBF)))) | | | | ------------------ | | | | | Branch (277:21): [True: 199, False: 844] | | | | ------------------ | | ------------------ ------------------ if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string)) ------------------ | | 255| 9.29M|#define IS_ASCII(string) IS_ASCII_AT((string),0) | | ------------------ | | | | 253| 9.29M| ((string).pointer[offset] <= (yaml_char_t) '\x7F') | | ------------------ ------------------ | Branch (2064:39): [True: 9.29M, False: 9.77M] | Branch (2064:60): [True: 4.17M, False: 5.12M] ------------------ 2065| 21.7M| || IS_BOM(string) || IS_BREAK(string) ------------------ | | 298| 14.8M|#define IS_BOM(string) IS_BOM_AT(string,0) | | ------------------ | | | | 294| 36.6M| (CHECK_AT((string),'\xEF',(offset)) \ | | | | ------------------ | | | | | | 175| 29.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.96k, False: 14.8M] | | | | | | ------------------ | | | | ------------------ | | | | 295| 14.8M| && CHECK_AT((string),'\xBB',(offset)+1) \ | | | | ------------------ | | | | | | 175| 14.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 595, False: 2.37k] | | | | | | ------------------ | | | | ------------------ | | | | 296| 36.6M| && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */ | | | | ------------------ | | | | | | 175| 595| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 595] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ || IS_BOM(string) || IS_BREAK(string) ------------------ | | 341| 14.8M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 36.6M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 29.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 14.8M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 14.8M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 29.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.16M, False: 13.7M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 14.8M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 27.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 4.45k, False: 13.7M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 13.7M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 4.45k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 4.45k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 14.8M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 27.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.10M, False: 12.6M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 13.7M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 14.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.01M, False: 89.2k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 13.7M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 1.01M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.89k, False: 1.01M] | | | | | | ------------------ | | | | ------------------ | | | | 337| 36.6M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 27.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.10M, False: 12.6M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 13.7M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 14.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.01M, False: 89.2k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 13.7M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 1.01M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 68.1k, False: 947k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2066| 13.6M| || CHECK(string, '"') || CHECK(string, '\\')) ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 41.8k, False: 13.6M] | | ------------------ ------------------ || CHECK(string, '"') || CHECK(string, '\\')) ------------------ | | 181| 13.6M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 196k, False: 13.4M] | | ------------------ ------------------ 2067| 8.36M| { 2068| 8.36M| unsigned char octet; 2069| 8.36M| unsigned int width; 2070| 8.36M| unsigned int value; 2071| 8.36M| int k; 2072| | 2073| 8.36M| octet = string.pointer[0]; 2074| 8.36M| width = (octet & 0x80) == 0x00 ? 1 : ------------------ | Branch (2074:21): [True: 3.88M, False: 4.47M] ------------------ 2075| 8.36M| (octet & 0xE0) == 0xC0 ? 2 : ------------------ | Branch (2075:21): [True: 215k, False: 4.26M] ------------------ 2076| 4.47M| (octet & 0xF0) == 0xE0 ? 3 : ------------------ | Branch (2076:21): [True: 4.20M, False: 57.5k] ------------------ 2077| 4.26M| (octet & 0xF8) == 0xF0 ? 4 : 0; ------------------ | Branch (2077:21): [True: 57.5k, False: 0] ------------------ 2078| 8.36M| value = (octet & 0x80) == 0x00 ? octet & 0x7F : ------------------ | Branch (2078:21): [True: 3.88M, False: 4.47M] ------------------ 2079| 8.36M| (octet & 0xE0) == 0xC0 ? octet & 0x1F : ------------------ | Branch (2079:21): [True: 215k, False: 4.26M] ------------------ 2080| 4.47M| (octet & 0xF0) == 0xE0 ? octet & 0x0F : ------------------ | Branch (2080:21): [True: 4.20M, False: 57.5k] ------------------ 2081| 4.26M| (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; ------------------ | Branch (2081:21): [True: 57.5k, False: 0] ------------------ 2082| 17.1M| for (k = 1; k < (int)width; k ++) { ------------------ | Branch (2082:25): [True: 8.80M, False: 8.36M] ------------------ 2083| 8.80M| octet = string.pointer[k]; 2084| 8.80M| value = (value << 6) + (octet & 0x3F); 2085| 8.80M| } 2086| 8.36M| string.pointer += width; 2087| | 2088| 8.36M| if (!PUT(emitter, '\\')) return 0; ------------------ | | 17| 8.36M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 16.7M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 8.36M, False: 700] | | | | ------------------ | | | | 10| 16.7M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 700, False: 0] | | | | ------------------ | | ------------------ | | 18| 8.36M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 8.36M, False: 0] | | ------------------ | | 19| 8.36M| emitter->column++, \ | | 20| 8.36M| 1)) ------------------ 2089| | 2090| 8.36M| switch (value) 2091| 8.36M| { 2092| 4.49k| case 0x00: ------------------ | Branch (2092:17): [True: 4.49k, False: 8.36M] ------------------ 2093| 4.49k| if (!PUT(emitter, '0')) return 0; ------------------ | | 17| 4.49k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 8.99k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 4.49k, False: 6] | | | | ------------------ | | | | 10| 8.99k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 6, False: 0] | | | | ------------------ | | ------------------ | | 18| 4.49k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 4.49k, False: 0] | | ------------------ | | 19| 4.49k| emitter->column++, \ | | 20| 4.49k| 1)) ------------------ 2094| 4.49k| break; 2095| | 2096| 763k| case 0x07: ------------------ | Branch (2096:17): [True: 763k, False: 7.60M] ------------------ 2097| 763k| if (!PUT(emitter, 'a')) return 0; ------------------ | | 17| 763k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 1.52M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 763k, False: 75] | | | | ------------------ | | | | 10| 1.52M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 75, False: 0] | | | | ------------------ | | ------------------ | | 18| 763k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 763k, False: 0] | | ------------------ | | 19| 763k| emitter->column++, \ | | 20| 763k| 1)) ------------------ 2098| 763k| break; 2099| | 2100| 763k| case 0x08: ------------------ | Branch (2100:17): [True: 1.85k, False: 8.36M] ------------------ 2101| 1.85k| if (!PUT(emitter, 'b')) return 0; ------------------ | | 17| 1.85k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 3.71k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.84k, False: 10] | | | | ------------------ | | | | 10| 3.71k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 10, False: 0] | | | | ------------------ | | ------------------ | | 18| 1.85k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 1.85k, False: 0] | | ------------------ | | 19| 1.85k| emitter->column++, \ | | 20| 1.85k| 1)) ------------------ 2102| 1.85k| break; 2103| | 2104| 545k| case 0x09: ------------------ | Branch (2104:17): [True: 545k, False: 7.82M] ------------------ 2105| 545k| if (!PUT(emitter, 't')) return 0; ------------------ | | 17| 545k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 1.09M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 545k, False: 211] | | | | ------------------ | | | | 10| 1.09M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 211, False: 0] | | | | ------------------ | | ------------------ | | 18| 545k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 545k, False: 0] | | ------------------ | | 19| 545k| emitter->column++, \ | | 20| 545k| 1)) ------------------ 2106| 545k| break; 2107| | 2108| 1.16M| case 0x0A: ------------------ | Branch (2108:17): [True: 1.16M, False: 7.19M] ------------------ 2109| 1.16M| if (!PUT(emitter, 'n')) return 0; ------------------ | | 17| 1.16M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 2.33M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.16M, False: 252] | | | | ------------------ | | | | 10| 2.33M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 252, False: 0] | | | | ------------------ | | ------------------ | | 18| 1.16M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 1.16M, False: 0] | | ------------------ | | 19| 1.16M| emitter->column++, \ | | 20| 1.16M| 1)) ------------------ 2110| 1.16M| break; 2111| | 2112| 1.16M| case 0x0B: ------------------ | Branch (2112:17): [True: 36.6k, False: 8.32M] ------------------ 2113| 36.6k| if (!PUT(emitter, 'v')) return 0; ------------------ | | 17| 36.6k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 73.3k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 36.6k, False: 18] | | | | ------------------ | | | | 10| 73.3k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 18, False: 0] | | | | ------------------ | | ------------------ | | 18| 36.6k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 36.6k, False: 0] | | ------------------ | | 19| 36.6k| emitter->column++, \ | | 20| 36.6k| 1)) ------------------ 2114| 36.6k| break; 2115| | 2116| 105k| case 0x0C: ------------------ | Branch (2116:17): [True: 105k, False: 8.26M] ------------------ 2117| 105k| if (!PUT(emitter, 'f')) return 0; ------------------ | | 17| 105k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 211k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 105k, False: 19] | | | | ------------------ | | | | 10| 211k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 19, False: 0] | | | | ------------------ | | ------------------ | | 18| 105k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 105k, False: 0] | | ------------------ | | 19| 105k| emitter->column++, \ | | 20| 105k| 1)) ------------------ 2118| 105k| break; 2119| | 2120| 614k| case 0x0D: ------------------ | Branch (2120:17): [True: 614k, False: 7.75M] ------------------ 2121| 614k| if (!PUT(emitter, 'r')) return 0; ------------------ | | 17| 614k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 1.22M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 614k, False: 66] | | | | ------------------ | | | | 10| 1.22M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 66, False: 0] | | | | ------------------ | | ------------------ | | 18| 614k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 614k, False: 0] | | ------------------ | | 19| 614k| emitter->column++, \ | | 20| 614k| 1)) ------------------ 2122| 614k| break; 2123| | 2124| 614k| case 0x1B: ------------------ | Branch (2124:17): [True: 409k, False: 7.95M] ------------------ 2125| 409k| if (!PUT(emitter, 'e')) return 0; ------------------ | | 17| 409k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 818k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 409k, False: 44] | | | | ------------------ | | | | 10| 818k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 44, False: 0] | | | | ------------------ | | ------------------ | | 18| 409k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 409k, False: 0] | | ------------------ | | 19| 409k| emitter->column++, \ | | 20| 409k| 1)) ------------------ 2126| 409k| break; 2127| | 2128| 409k| case 0x22: ------------------ | Branch (2128:17): [True: 41.8k, False: 8.32M] ------------------ 2129| 41.8k| if (!PUT(emitter, '\"')) return 0; ------------------ | | 17| 41.8k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 83.6k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 41.6k, False: 200] | | | | ------------------ | | | | 10| 83.6k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 200, False: 0] | | | | ------------------ | | ------------------ | | 18| 41.8k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 41.8k, False: 0] | | ------------------ | | 19| 41.8k| emitter->column++, \ | | 20| 41.8k| 1)) ------------------ 2130| 41.8k| break; 2131| | 2132| 196k| case 0x5C: ------------------ | Branch (2132:17): [True: 196k, False: 8.16M] ------------------ 2133| 196k| if (!PUT(emitter, '\\')) return 0; ------------------ | | 17| 196k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 392k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 195k, False: 207] | | | | ------------------ | | | | 10| 392k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 207, False: 0] | | | | ------------------ | | ------------------ | | 18| 196k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 196k, False: 0] | | ------------------ | | 19| 196k| emitter->column++, \ | | 20| 196k| 1)) ------------------ 2134| 196k| break; 2135| | 2136| 196k| case 0x85: ------------------ | Branch (2136:17): [True: 178k, False: 8.18M] ------------------ 2137| 178k| if (!PUT(emitter, 'N')) return 0; ------------------ | | 17| 178k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 356k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 178k, False: 34] | | | | ------------------ | | | | 10| 356k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 34, False: 0] | | | | ------------------ | | ------------------ | | 18| 178k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 178k, False: 0] | | ------------------ | | 19| 178k| emitter->column++, \ | | 20| 178k| 1)) ------------------ 2138| 178k| break; 2139| | 2140| 178k| case 0xA0: ------------------ | Branch (2140:17): [True: 15.6k, False: 8.35M] ------------------ 2141| 15.6k| if (!PUT(emitter, '_')) return 0; ------------------ | | 17| 15.6k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 31.2k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 15.4k, False: 201] | | | | ------------------ | | | | 10| 31.2k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 201, False: 0] | | | | ------------------ | | ------------------ | | 18| 15.6k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 15.6k, False: 0] | | ------------------ | | 19| 15.6k| emitter->column++, \ | | 20| 15.6k| 1)) ------------------ 2142| 15.6k| break; 2143| | 2144| 15.6k| case 0x2028: ------------------ | Branch (2144:17): [True: 7.87k, False: 8.35M] ------------------ 2145| 7.87k| if (!PUT(emitter, 'L')) return 0; ------------------ | | 17| 7.87k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 15.7k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 7.68k, False: 194] | | | | ------------------ | | | | 10| 15.7k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 18| 7.87k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 7.87k, False: 0] | | ------------------ | | 19| 7.87k| emitter->column++, \ | | 20| 7.87k| 1)) ------------------ 2146| 7.87k| break; 2147| | 2148| 69.3k| case 0x2029: ------------------ | Branch (2148:17): [True: 69.3k, False: 8.29M] ------------------ 2149| 69.3k| if (!PUT(emitter, 'P')) return 0; ------------------ | | 17| 69.3k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 138k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 69.1k, False: 219] | | | | ------------------ | | | | 10| 138k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 219, False: 0] | | | | ------------------ | | ------------------ | | 18| 69.3k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 69.3k, False: 0] | | ------------------ | | 19| 69.3k| emitter->column++, \ | | 20| 69.3k| 1)) ------------------ 2150| 69.3k| break; 2151| | 2152| 4.20M| default: ------------------ | Branch (2152:17): [True: 4.20M, False: 4.15M] ------------------ 2153| 4.20M| if (value <= 0xFF) { ------------------ | Branch (2153:25): [True: 7.16k, False: 4.20M] ------------------ 2154| 7.16k| if (!PUT(emitter, 'x')) return 0; ------------------ | | 17| 7.16k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 14.3k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 6.96k, False: 194] | | | | ------------------ | | | | 10| 14.3k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 18| 7.16k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 7.16k, False: 0] | | ------------------ | | 19| 7.16k| emitter->column++, \ | | 20| 7.16k| 1)) ------------------ 2155| 7.16k| width = 2; 2156| 7.16k| } 2157| 4.20M| else if (value <= 0xFFFF) { ------------------ | Branch (2157:30): [True: 4.14M, False: 57.5k] ------------------ 2158| 4.14M| if (!PUT(emitter, 'u')) return 0; ------------------ | | 17| 4.14M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 8.28M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 4.14M, False: 427] | | | | ------------------ | | | | 10| 8.28M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 427, False: 0] | | | | ------------------ | | ------------------ | | 18| 4.14M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 4.14M, False: 0] | | ------------------ | | 19| 4.14M| emitter->column++, \ | | 20| 4.14M| 1)) ------------------ 2159| 4.14M| width = 4; 2160| 4.14M| } 2161| 57.5k| else { 2162| 57.5k| if (!PUT(emitter, 'U')) return 0; ------------------ | | 17| 57.5k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 115k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 57.3k, False: 194] | | | | ------------------ | | | | 10| 115k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 18| 57.5k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 57.5k, False: 0] | | ------------------ | | 19| 57.5k| emitter->column++, \ | | 20| 57.5k| 1)) ------------------ 2163| 57.5k| width = 8; 2164| 57.5k| } 2165| 21.2M| for (k = (width-1)*4; k >= 0; k -= 4) { ------------------ | Branch (2165:43): [True: 17.0M, False: 4.20M] ------------------ 2166| 17.0M| int digit = (value >> k) & 0x0F; 2167| 17.0M| if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10))) ------------------ | | 17| 17.0M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 34.0M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 17.0M, False: 1.22k] | | | | ------------------ | | | | 10| 34.0M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1.22k, False: 0] | | | | ------------------ | | ------------------ | | 18| 34.0M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 17.0M, False: 0] | | | Branch (18:55): [True: 14.4M, False: 2.57M] | | ------------------ | | 19| 17.0M| emitter->column++, \ | | 20| 17.0M| 1)) ------------------ 2168| 0| return 0; 2169| 17.0M| } 2170| 8.36M| } 2171| 8.36M| spaces = 0; 2172| 8.36M| } 2173| 13.4M| else if (IS_SPACE(string)) ------------------ | | 306| 13.4M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 13.4M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 13.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.62M, False: 9.79M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2174| 3.62M| { 2175| 3.62M| if (allow_breaks && !spaces ------------------ | Branch (2175:17): [True: 3.62M, False: 3.42k] | Branch (2175:33): [True: 1.76M, False: 1.85M] ------------------ 2176| 1.76M| && emitter->column > emitter->best_width ------------------ | Branch (2176:24): [True: 1.28M, False: 479k] ------------------ 2177| 1.28M| && string.pointer != string.start ------------------ | Branch (2177:24): [True: 1.28M, False: 198] ------------------ 2178| 1.28M| && string.pointer != string.end - 1) { ------------------ | Branch (2178:24): [True: 1.28M, False: 231] ------------------ 2179| 1.28M| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2179:21): [True: 0, False: 1.28M] ------------------ 2180| 1.28M| if (IS_SPACE_AT(string, 1)) { ------------------ | | 304| 1.28M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 1.28M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 40.5k, False: 1.24M] | | | | ------------------ | | ------------------ ------------------ 2181| 40.5k| if (!PUT(emitter, '\\')) return 0; ------------------ | | 17| 40.5k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 81.0k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 40.2k, False: 252] | | | | ------------------ | | | | 10| 81.0k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 252, False: 0] | | | | ------------------ | | ------------------ | | 18| 40.5k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 40.5k, False: 0] | | ------------------ | | 19| 40.5k| emitter->column++, \ | | 20| 40.5k| 1)) ------------------ 2182| 40.5k| } 2183| 1.28M| MOVE(string); ------------------ | | 391| 1.28M|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 1.28M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.28M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.28M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.28M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2184| 1.28M| } 2185| 2.33M| else { 2186| 2.33M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 2.33M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 4.67M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 2.33M, False: 338] | | | | ------------------ | | | | 10| 4.67M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 338, False: 0] | | | | ------------------ | | ------------------ | | 45| 2.33M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 2.33M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 2.33M, False: 0] | | | | ------------------ | | | | 399| 2.33M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 2.33M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 2.33M, False: 0] | | ------------------ | | 46| 2.33M| emitter->column ++, \ | | 47| 2.33M| 1)) ------------------ 2187| 2.33M| } 2188| 3.62M| spaces = 1; 2189| 3.62M| } 2190| 9.79M| else 2191| 9.79M| { 2192| 9.79M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 9.79M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 19.5M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 9.79M, False: 885] | | | | ------------------ | | | | 10| 19.5M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 885, False: 0] | | | | ------------------ | | ------------------ | | 45| 9.79M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 9.79M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 8.34M, False: 1.44M] | | | | ------------------ | | | | 399| 9.79M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 9.79M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 4.93k, False: 1.44M] | | | | ------------------ | | | | 401| 1.44M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 4.93k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 1.44M| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 1.44M, False: 0] | | | | ------------------ | | | | 404| 1.44M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 1.44M| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 1.44M| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 1.44M| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 9.79M, False: 0] | | ------------------ | | 46| 9.79M| emitter->column ++, \ | | 47| 9.79M| 1)) ------------------ 2193| 9.79M| spaces = 0; 2194| 9.79M| } 2195| 21.7M| } 2196| | 2197| 2.14M| if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0)) ------------------ | Branch (2197:9): [True: 0, False: 2.14M] ------------------ 2198| 0| return 0; 2199| | 2200| 2.14M| emitter->whitespace = 0; 2201| 2.14M| emitter->indention = 0; 2202| | 2203| 2.14M| return 1; 2204| 2.14M|} emitter.c:yaml_emitter_write_literal_scalar: 2267| 14.0k|{ 2268| 14.0k| yaml_string_t string; 2269| 14.0k| int breaks = 1; 2270| | 2271| 14.0k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 14.0k| ((value).start = (string), \ | | 129| 14.0k| (value).end = (string)+(length), \ | | 130| 14.0k| (value).pointer = (string)) ------------------ 2272| | 2273| 14.0k| if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0)) ------------------ | Branch (2273:9): [True: 0, False: 14.0k] ------------------ 2274| 0| return 0; 2275| 14.0k| if (!yaml_emitter_write_block_scalar_hints(emitter, string)) ------------------ | Branch (2275:9): [True: 0, False: 14.0k] ------------------ 2276| 0| return 0; 2277| 14.0k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 14.0k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 28.1k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 13.8k, False: 199] | | | | ------------------ | | | | 10| 28.1k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 199, False: 0] | | | | ------------------ | | ------------------ | | 28| 14.0k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 14.0k, False: 0] | | | Branch (28:11): [True: 0, False: 14.0k] | | ------------------ | | 29| 14.0k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 14.0k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 14.0k, False: 0] | | ------------------ | | 31| 14.0k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 14.0k| emitter->line_break == YAML_CRLN_BREAK ? \ | | ------------------ | | | Branch (32:11): [True: 0, False: 0] | | ------------------ | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | 35| 14.0k| emitter->column = 0, \ | | 36| 14.0k| emitter->line ++, \ | | 37| 14.0k| 1)) ------------------ 2278| 14.0k| emitter->indention = 1; 2279| 14.0k| emitter->whitespace = 1; 2280| | 2281| 509k| while (string.pointer != string.end) ------------------ | Branch (2281:12): [True: 495k, False: 14.0k] ------------------ 2282| 495k| { 2283| 495k| if (IS_BREAK(string)) ------------------ | | 341| 495k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 495k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 991k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 495k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 495k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 991k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 14.7k, False: 480k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 495k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 961k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 199, False: 480k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 480k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 199| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 199] | | | | | | ------------------ | | | | ------------------ | | | | 334| 495k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 961k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 102k, False: 378k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 480k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 583k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 30.4k, False: 71.9k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 480k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 30.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 836, False: 29.6k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 495k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 959k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 101k, False: 378k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 479k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 581k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 29.6k, False: 71.9k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 479k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 29.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 231, False: 29.3k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2284| 15.8k| { 2285| 15.8k| if (!WRITE_BREAK(emitter, string)) return 0; ------------------ | | 54| 15.8k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 31.6k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 15.6k, False: 194] | | | | ------------------ | | | | 10| 31.6k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 55| 15.8k| && (CHECK(string,'\n') ? \ | | ------------------ | | | | 181| 15.8k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | | | ------------------ | | | | | | 175| 15.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (181:29): [True: 14.7k, False: 1.06k] | | | | ------------------ | | ------------------ | | | Branch (55:9): [True: 15.8k, False: 0] | | ------------------ | | 56| 15.8k| (PUT_BREAK(emitter), \ | | ------------------ | | | | 27| 14.7k| (FLUSH(emitter) \ | | | | ------------------ | | | | | | 9| 29.5k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | | | ------------------ | | | | | | | Branch (9:6): [True: 14.7k, False: 0] | | | | | | ------------------ | | | | | | 10| 29.5k| || yaml_emitter_flush(emitter)) | | | | | | ------------------ | | | | | | | Branch (10:9): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 28| 14.7k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | | | ------------------ | | | | | Branch (28:9): [True: 14.7k, False: 0] | | | | | Branch (28:11): [True: 0, False: 14.7k] | | | | ------------------ | | | | 29| 14.7k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | | | 30| 14.7k| emitter->line_break == YAML_LN_BREAK ? \ | | | | ------------------ | | | | | Branch (30:11): [True: 14.7k, False: 0] | | | | ------------------ | | | | 31| 14.7k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | | | 32| 14.7k| emitter->line_break == YAML_CRLN_BREAK ? \ | | | | ------------------ | | | | | Branch (32:11): [True: 0, False: 0] | | | | ------------------ | | | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | | | 35| 14.7k| emitter->column = 0, \ | | | | 36| 14.7k| emitter->line ++, \ | | | | 37| 14.7k| 1)) | | ------------------ | | 57| 14.7k| string.pointer ++, \ | | 58| 14.7k| 1) : \ | | 59| 15.8k| (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.06k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 0, False: 1.06k] | | | | ------------------ | | | | 399| 1.06k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.06k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 1.06k] | | | | ------------------ | | | | 401| 1.06k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 1.06k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 1.06k, False: 0] | | | | ------------------ | | | | 404| 1.06k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 1.06k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 1.06k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 1.06k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 60| 1.06k| emitter->column = 0, \ | | 61| 1.06k| emitter->line ++, \ | | 62| 1.06k| 1))) ------------------ 2286| 15.8k| emitter->indention = 1; 2287| 15.8k| breaks = 1; 2288| 15.8k| } 2289| 479k| else 2290| 479k| { 2291| 479k| if (breaks) { ------------------ | Branch (2291:17): [True: 2.17k, False: 477k] ------------------ 2292| 2.17k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2292:21): [True: 0, False: 2.17k] ------------------ 2293| 2.17k| } 2294| 479k| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 479k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 959k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 479k, False: 237] | | | | ------------------ | | | | 10| 959k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 237, False: 0] | | | | ------------------ | | ------------------ | | 45| 479k| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 479k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 363k, False: 116k] | | | | ------------------ | | | | 399| 479k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 479k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 214, False: 116k] | | | | ------------------ | | | | 401| 116k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 214| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 116k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 116k, False: 0] | | | | ------------------ | | | | 404| 116k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 116k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 116k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 116k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 479k, False: 0] | | ------------------ | | 46| 479k| emitter->column ++, \ | | 47| 479k| 1)) ------------------ 2295| 479k| emitter->indention = 0; 2296| 479k| breaks = 0; 2297| 479k| } 2298| 495k| } 2299| | 2300| 14.0k| return 1; 2301| 14.0k|} emitter.c:yaml_emitter_write_block_scalar_hints: 2209| 18.5k|{ 2210| 18.5k| char indent_hint[2]; 2211| 18.5k| const char *chomp_hint = NULL; 2212| | 2213| 18.5k| if (IS_SPACE(string) || IS_BREAK(string)) ------------------ | | 306| 18.5k|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 18.5k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 37.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 211, False: 18.3k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (IS_SPACE(string) || IS_BREAK(string)) ------------------ | | 341| 18.3k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 18.3k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 36.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 18.3k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 18.3k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 36.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 12.3k, False: 5.94k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 18.3k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 11.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 588, False: 5.35k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 5.94k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 588| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 588] | | | | | | ------------------ | | | | ------------------ | | | | 334| 18.3k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 11.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.08k, False: 2.85k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 5.94k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 9.02k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.64k, False: 437] | | | | | | ------------------ | | | | ------------------ | | | | 336| 5.94k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 2.64k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 654, False: 1.99k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 18.3k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 10.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.43k, False: 2.85k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 5.28k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 7.71k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.99k, False: 437] | | | | | | ------------------ | | | | ------------------ | | | | 339| 5.28k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 1.99k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 434, False: 1.56k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2214| 13.6k| { 2215| 13.6k| indent_hint[0] = '0' + (char)emitter->best_indent; 2216| 13.6k| indent_hint[1] = '\0'; 2217| 13.6k| if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0)) ------------------ | Branch (2217:13): [True: 0, False: 13.6k] ------------------ 2218| 0| return 0; 2219| 13.6k| } 2220| | 2221| 18.5k| emitter->open_ended = 0; 2222| | 2223| 18.5k| string.pointer = string.end; 2224| 18.5k| if (string.start == string.pointer) ------------------ | Branch (2224:9): [True: 0, False: 18.5k] ------------------ 2225| 0| { 2226| 0| chomp_hint = "-"; 2227| 0| } 2228| 18.5k| else 2229| 18.5k| { 2230| 21.0k| do { 2231| 21.0k| string.pointer --; 2232| 21.0k| } while ((*string.pointer & 0xC0) == 0x80); ------------------ | Branch (2232:18): [True: 2.47k, False: 18.5k] ------------------ 2233| 18.5k| if (!IS_BREAK(string)) ------------------ | | 341| 18.5k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 18.5k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 37.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 18.5k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 18.5k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 37.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 15.5k, False: 3.00k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 18.5k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 224, False: 2.77k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 3.00k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 224| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 224] | | | | | | ------------------ | | | | ------------------ | | | | 334| 18.5k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.10k, False: 1.90k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 3.00k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 4.10k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 862, False: 240] | | | | | | ------------------ | | | | ------------------ | | | | 336| 3.00k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 862| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 422, False: 440] | | | | | | ------------------ | | | | ------------------ | | | | 337| 18.5k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.16k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 680, False: 1.90k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.58k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.26k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 440, False: 240] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.58k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 440| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 91, False: 349] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2234| 2.49k| { 2235| 2.49k| chomp_hint = "-"; 2236| 2.49k| } 2237| 16.0k| else if (string.start == string.pointer) ------------------ | Branch (2237:18): [True: 12.0k, False: 4.02k] ------------------ 2238| 12.0k| { 2239| 12.0k| chomp_hint = "+"; 2240| 12.0k| emitter->open_ended = 2; 2241| 12.0k| } 2242| 4.02k| else 2243| 4.02k| { 2244| 6.66k| do { 2245| 6.66k| string.pointer --; 2246| 6.66k| } while ((*string.pointer & 0xC0) == 0x80); ------------------ | Branch (2246:22): [True: 2.64k, False: 4.02k] ------------------ 2247| 4.02k| if (IS_BREAK(string)) ------------------ | | 341| 4.02k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 4.02k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 8.04k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 4.02k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 4.02k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 8.04k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.07k, False: 2.95k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 4.02k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.90k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 399, False: 2.55k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 2.95k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 399| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 399] | | | | | | ------------------ | | | | ------------------ | | | | 334| 4.02k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.90k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.11k, False: 1.83k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 2.95k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 4.06k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 904, False: 213] | | | | | | ------------------ | | | | ------------------ | | | | 336| 2.95k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 904| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 281, False: 623] | | | | | | ------------------ | | | | ------------------ | | | | 337| 4.02k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.33k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 836, False: 1.83k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.66k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.50k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 623, False: 213] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.66k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 623| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 308, False: 315] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2248| 1.66k| { 2249| 1.66k| chomp_hint = "+"; 2250| 1.66k| emitter->open_ended = 2; 2251| 1.66k| } 2252| 4.02k| } 2253| 18.5k| } 2254| | 2255| 18.5k| if (chomp_hint) ------------------ | Branch (2255:9): [True: 16.1k, False: 2.36k] ------------------ 2256| 16.1k| { 2257| 16.1k| if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0)) ------------------ | Branch (2257:13): [True: 0, False: 16.1k] ------------------ 2258| 0| return 0; 2259| 16.1k| } 2260| | 2261| 18.5k| return 1; 2262| 18.5k|} emitter.c:yaml_emitter_write_folded_scalar: 2306| 4.44k|{ 2307| 4.44k| yaml_string_t string; 2308| 4.44k| int breaks = 1; 2309| 4.44k| int leading_spaces = 1; 2310| | 2311| 4.44k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 4.44k| ((value).start = (string), \ | | 129| 4.44k| (value).end = (string)+(length), \ | | 130| 4.44k| (value).pointer = (string)) ------------------ 2312| | 2313| 4.44k| if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0)) ------------------ | Branch (2313:9): [True: 0, False: 4.44k] ------------------ 2314| 0| return 0; 2315| 4.44k| if (!yaml_emitter_write_block_scalar_hints(emitter, string)) ------------------ | Branch (2315:9): [True: 0, False: 4.44k] ------------------ 2316| 0| return 0; 2317| 4.44k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 4.44k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 8.88k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 4.23k, False: 207] | | | | ------------------ | | | | 10| 8.88k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 207, False: 0] | | | | ------------------ | | ------------------ | | 28| 4.44k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 4.44k, False: 0] | | | Branch (28:11): [True: 0, False: 4.44k] | | ------------------ | | 29| 4.44k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 4.44k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 4.44k, False: 0] | | ------------------ | | 31| 4.44k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 4.44k| emitter->line_break == YAML_CRLN_BREAK ? \ | | ------------------ | | | Branch (32:11): [True: 0, False: 0] | | ------------------ | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | 35| 4.44k| emitter->column = 0, \ | | 36| 4.44k| emitter->line ++, \ | | 37| 4.44k| 1)) ------------------ 2318| 4.44k| emitter->indention = 1; 2319| 4.44k| emitter->whitespace = 1; 2320| | 2321| 3.35M| while (string.pointer != string.end) ------------------ | Branch (2321:12): [True: 3.34M, False: 4.44k] ------------------ 2322| 3.34M| { 2323| 3.34M| if (IS_BREAK(string)) ------------------ | | 341| 3.34M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 3.34M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 6.69M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 3.34M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 3.34M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 6.69M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 360k, False: 2.98M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 3.34M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.53k, False: 2.98M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 2.98M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 3.53k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 3.53k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 3.34M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 17.0k, False: 2.96M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 2.98M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.00M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 14.8k, False: 2.15k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 2.98M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 14.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.03k, False: 13.8k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 3.34M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 15.9k, False: 2.96M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.98M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.00M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 13.8k, False: 2.15k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.98M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 13.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.24k, False: 12.5k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2324| 362k| { 2325| 362k| if (!breaks && !leading_spaces && CHECK(string, '\n')) { ------------------ | | 181| 13.1k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.6k, False: 418] | | ------------------ ------------------ | Branch (2325:17): [True: 13.9k, False: 348k] | Branch (2325:28): [True: 13.1k, False: 807] ------------------ 2326| 12.6k| int k = 0; 2327| 292k| while (IS_BREAK_AT(string, k)) { ------------------ | | 330| 292k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | ------------------ | | | | 175| 584k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 0, False: 292k] | | | | ------------------ | | ------------------ | | 331| 292k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | ------------------ | | | | 175| 584k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 278k, False: 13.6k] | | | | ------------------ | | ------------------ | | 332| 292k| || (CHECK_AT((string),'\xC2',(offset)) \ | | ------------------ | | | | 175| 27.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 335, False: 13.3k] | | | | ------------------ | | ------------------ | | 333| 13.6k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | ------------------ | | | | 175| 335| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 0, False: 335] | | | | ------------------ | | ------------------ | | 334| 292k| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 27.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 10.3k, False: 3.38k] | | | | ------------------ | | ------------------ | | 335| 13.6k| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 23.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 9.76k, False: 541] | | | | ------------------ | | ------------------ | | 336| 13.6k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | ------------------ | | | | 175| 9.76k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 491, False: 9.27k] | | | | ------------------ | | ------------------ | | 337| 292k| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 26.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 9.81k, False: 3.38k] | | | | ------------------ | | ------------------ | | 338| 13.2k| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 23.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 9.27k, False: 541] | | | | ------------------ | | ------------------ | | 339| 13.2k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | ------------------ | | | | 175| 9.27k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 512, False: 8.75k] | | | | ------------------ | | ------------------ ------------------ 2328| 279k| k += WIDTH_AT(string, k); ------------------ | | 380| 279k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | ------------------ | | | Branch (380:7): [True: 278k, False: 1.00k] | | ------------------ | | 381| 279k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | ------------------ | | | Branch (381:7): [True: 0, False: 1.00k] | | ------------------ | | 382| 1.00k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | ------------------ | | | Branch (382:7): [True: 1.00k, False: 0] | | ------------------ | | 383| 1.00k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | ------------------ | | | Branch (383:7): [True: 0, False: 0] | | ------------------ ------------------ 2329| 279k| } 2330| 12.6k| if (!IS_BLANKZ_AT(string, k)) { ------------------ | | 371| 12.6k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 25.3k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 12.6k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 25.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 657, False: 12.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 12.0k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 12.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 12.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 12.0k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 24.0k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 24.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 12.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 12.0k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 24.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 12.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 12.0k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 24.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 335, False: 11.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 12.0k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 335| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 335] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 12.0k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 24.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 9.29k, False: 2.73k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 12.0k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 21.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.75k, False: 541] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 12.0k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 8.75k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 8.75k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 24.0k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 24.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 9.29k, False: 2.73k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 12.0k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 21.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.75k, False: 541] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 12.0k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 8.75k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 8.75k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 12.0k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 12.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.63k, False: 10.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2331| 10.3k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 10.3k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 20.7k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 10.2k, False: 194] | | | | ------------------ | | | | 10| 20.7k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 28| 10.3k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 10.3k, False: 0] | | | Branch (28:11): [True: 0, False: 10.3k] | | ------------------ | | 29| 10.3k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 10.3k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 10.3k, False: 0] | | ------------------ | | 31| 10.3k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 10.3k| emitter->line_break == YAML_CRLN_BREAK ? \ | | ------------------ | | | Branch (32:11): [True: 0, False: 0] | | ------------------ | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | 35| 10.3k| emitter->column = 0, \ | | 36| 10.3k| emitter->line ++, \ | | 37| 10.3k| 1)) ------------------ 2332| 10.3k| } 2333| 12.6k| } 2334| 362k| if (!WRITE_BREAK(emitter, string)) return 0; ------------------ | | 54| 362k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 725k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 362k, False: 214] | | | | ------------------ | | | | 10| 725k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 214, False: 0] | | | | ------------------ | | ------------------ | | 55| 362k| && (CHECK(string,'\n') ? \ | | ------------------ | | | | 181| 362k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | | | ------------------ | | | | | | 175| 362k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (181:29): [True: 360k, False: 2.27k] | | | | ------------------ | | ------------------ | | | Branch (55:9): [True: 362k, False: 0] | | ------------------ | | 56| 362k| (PUT_BREAK(emitter), \ | | ------------------ | | | | 27| 360k| (FLUSH(emitter) \ | | | | ------------------ | | | | | | 9| 720k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | | | ------------------ | | | | | | | Branch (9:6): [True: 360k, False: 0] | | | | | | ------------------ | | | | | | 10| 720k| || yaml_emitter_flush(emitter)) | | | | | | ------------------ | | | | | | | Branch (10:9): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 28| 360k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | | | ------------------ | | | | | Branch (28:9): [True: 360k, False: 0] | | | | | Branch (28:11): [True: 0, False: 360k] | | | | ------------------ | | | | 29| 360k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | | | 30| 360k| emitter->line_break == YAML_LN_BREAK ? \ | | | | ------------------ | | | | | Branch (30:11): [True: 360k, False: 0] | | | | ------------------ | | | | 31| 360k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | | | 32| 360k| emitter->line_break == YAML_CRLN_BREAK ? \ | | | | ------------------ | | | | | Branch (32:11): [True: 0, False: 0] | | | | ------------------ | | | | 33| 0| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \ | | | | 34| 0| *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \ | | | | 35| 360k| emitter->column = 0, \ | | | | 36| 360k| emitter->line ++, \ | | | | 37| 360k| 1)) | | ------------------ | | 57| 360k| string.pointer ++, \ | | 58| 360k| 1) : \ | | 59| 362k| (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 2.27k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 0, False: 2.27k] | | | | ------------------ | | | | 399| 2.27k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 2.27k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 2.27k] | | | | ------------------ | | | | 401| 2.27k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 2.27k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 2.27k, False: 0] | | | | ------------------ | | | | 404| 2.27k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 2.27k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 2.27k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 2.27k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 60| 2.27k| emitter->column = 0, \ | | 61| 2.27k| emitter->line ++, \ | | 62| 2.27k| 1))) ------------------ 2335| 362k| emitter->indention = 1; 2336| 362k| breaks = 1; 2337| 362k| } 2338| 2.98M| else 2339| 2.98M| { 2340| 2.98M| if (breaks) { ------------------ | Branch (2340:17): [True: 15.9k, False: 2.96M] ------------------ 2341| 15.9k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2341:21): [True: 0, False: 15.9k] ------------------ 2342| 15.9k| leading_spaces = IS_BLANK(string); ------------------ | | 323| 15.9k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 15.9k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 15.9k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 31.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 897, False: 15.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 15.1k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 15.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 15.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2343| 15.9k| } 2344| 2.98M| if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1) ------------------ | | 306| 2.98M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 2.96M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 5.95M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 578k, False: 2.38M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1) ------------------ | | 304| 578k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 3.56M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2344:17): [True: 2.96M, False: 15.9k] | Branch (2344:48): [True: 78.8k, False: 499k] ------------------ 2345| 78.8k| && emitter->column > emitter->best_width) { ------------------ | Branch (2345:24): [True: 2.76k, False: 76.1k] ------------------ 2346| 2.76k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2346:21): [True: 0, False: 2.76k] ------------------ 2347| 2.76k| MOVE(string); ------------------ | | 391| 2.76k|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 2.76k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.76k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.76k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.76k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2348| 2.76k| } 2349| 2.98M| else { 2350| 2.98M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 2.98M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 5.96M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 2.98M, False: 386] | | | | ------------------ | | | | 10| 5.96M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 386, False: 0] | | | | ------------------ | | ------------------ | | 45| 2.98M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 2.98M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 2.82M, False: 155k] | | | | ------------------ | | | | 399| 2.98M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 2.98M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 3.73k, False: 152k] | | | | ------------------ | | | | 401| 155k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 3.73k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 155k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 152k, False: 0] | | | | ------------------ | | | | 404| 152k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 152k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 152k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 152k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | | Branch (45:9): [True: 2.98M, False: 0] | | ------------------ | | 46| 2.98M| emitter->column ++, \ | | 47| 2.98M| 1)) ------------------ 2351| 2.98M| } 2352| 2.98M| emitter->indention = 0; 2353| 2.98M| breaks = 0; 2354| 2.98M| } 2355| 3.34M| } 2356| | 2357| 4.44k| return 1; 2358| 4.44k|} emitter.c:yaml_emitter_emit_sequence_start: 1062| 115k|{ 1063| 115k| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1063:9): [True: 0, False: 115k] ------------------ 1064| 0| return 0; 1065| 115k| if (!yaml_emitter_process_tag(emitter)) ------------------ | Branch (1065:9): [True: 0, False: 115k] ------------------ 1066| 0| return 0; 1067| | 1068| 115k| if (emitter->flow_level || emitter->canonical ------------------ | Branch (1068:9): [True: 79.8k, False: 35.7k] | Branch (1068:32): [True: 2.70k, False: 33.0k] ------------------ 1069| 33.0k| || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE ------------------ | Branch (1069:16): [True: 541, False: 32.5k] ------------------ 1070| 83.1k| || yaml_emitter_check_empty_sequence(emitter)) { ------------------ | Branch (1070:16): [True: 0, False: 32.5k] ------------------ 1071| 83.1k| emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE; 1072| 83.1k| } 1073| 32.5k| else { 1074| 32.5k| emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE; 1075| 32.5k| } 1076| | 1077| 115k| return 1; 1078| 115k|} emitter.c:yaml_emitter_check_empty_sequence: 1120| 39.9k|{ 1121| 39.9k| if (emitter->events.tail - emitter->events.head < 2) ------------------ | Branch (1121:9): [True: 0, False: 39.9k] ------------------ 1122| 0| return 0; 1123| | 1124| 39.9k| return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT ------------------ | Branch (1124:13): [True: 39.9k, False: 0] ------------------ 1125| 39.9k| && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT); ------------------ | Branch (1125:16): [True: 367, False: 39.6k] ------------------ 1126| 39.9k|} emitter.c:yaml_emitter_emit_mapping_start: 1086| 2.23M|{ 1087| 2.23M| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1087:9): [True: 0, False: 2.23M] ------------------ 1088| 0| return 0; 1089| 2.23M| if (!yaml_emitter_process_tag(emitter)) ------------------ | Branch (1089:9): [True: 0, False: 2.23M] ------------------ 1090| 0| return 0; 1091| | 1092| 2.23M| if (emitter->flow_level || emitter->canonical ------------------ | Branch (1092:9): [True: 1.48M, False: 754k] | Branch (1092:32): [True: 21.9k, False: 732k] ------------------ 1093| 732k| || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE ------------------ | Branch (1093:16): [True: 541, False: 732k] ------------------ 1094| 1.50M| || yaml_emitter_check_empty_mapping(emitter)) { ------------------ | Branch (1094:16): [True: 0, False: 732k] ------------------ 1095| 1.50M| emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE; 1096| 1.50M| } 1097| 732k| else { 1098| 732k| emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE; 1099| 732k| } 1100| | 1101| 2.23M| return 1; 1102| 2.23M|} emitter.c:yaml_emitter_check_empty_mapping: 1134| 1.27M|{ 1135| 1.27M| if (emitter->events.tail - emitter->events.head < 2) ------------------ | Branch (1135:9): [True: 0, False: 1.27M] ------------------ 1136| 0| return 0; 1137| | 1138| 1.27M| return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT ------------------ | Branch (1138:13): [True: 1.27M, False: 0] ------------------ 1139| 1.27M| && emitter->events.head[1].type == YAML_MAPPING_END_EVENT); ------------------ | Branch (1139:16): [True: 377, False: 1.27M] ------------------ 1140| 1.27M|} emitter.c:yaml_emitter_emit_document_end: 707| 62.2k|{ 708| 62.2k| if (event->type == YAML_DOCUMENT_END_EVENT) ------------------ | Branch (708:9): [True: 62.2k, False: 0] ------------------ 709| 62.2k| { 710| 62.2k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (710:13): [True: 0, False: 62.2k] ------------------ 711| 0| return 0; 712| 62.2k| if (!event->data.document_end.implicit) { ------------------ | Branch (712:13): [True: 986, False: 61.2k] ------------------ 713| 986| if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) ------------------ | Branch (713:17): [True: 0, False: 986] ------------------ 714| 0| return 0; 715| 986| emitter->open_ended = 0; 716| 986| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (716:17): [True: 0, False: 986] ------------------ 717| 0| return 0; 718| 986| } 719| 61.2k| else if (!emitter->open_ended) ------------------ | Branch (719:18): [True: 57.8k, False: 3.47k] ------------------ 720| 57.8k| emitter->open_ended = 1; 721| 62.2k| if (!yaml_emitter_flush(emitter)) ------------------ | Branch (721:13): [True: 4.86k, False: 57.4k] ------------------ 722| 4.86k| return 0; 723| | 724| 57.4k| emitter->state = YAML_EMIT_DOCUMENT_START_STATE; 725| | 726| 257k| while (!STACK_EMPTY(emitter, emitter->tag_directives)) { ------------------ | | 436| 257k| ((stack).start == (stack).top) ------------------ | Branch (726:16): [True: 199k, False: 57.4k] ------------------ 727| 199k| yaml_tag_directive_t tag_directive = POP(emitter, ------------------ | | 454| 199k| (*(--(stack).top)) ------------------ 728| 199k| emitter->tag_directives); 729| 199k| yaml_free(tag_directive.handle); 730| 199k| yaml_free(tag_directive.prefix); 731| 199k| } 732| | 733| 57.4k| return 1; 734| 62.2k| } 735| | 736| 0| return yaml_emitter_set_emitter_error(emitter, 737| 0| "expected DOCUMENT-END"); 738| 62.2k|} emitter.c:yaml_emitter_emit_flow_sequence_item: 748| 493k|{ 749| 493k| if (first) ------------------ | Branch (749:9): [True: 83.1k, False: 410k] ------------------ 750| 83.1k| { 751| 83.1k| if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0)) ------------------ | Branch (751:13): [True: 0, False: 83.1k] ------------------ 752| 0| return 0; 753| 83.1k| if (!yaml_emitter_increase_indent(emitter, 1, 0)) ------------------ | Branch (753:13): [True: 0, False: 83.1k] ------------------ 754| 0| return 0; 755| 83.1k| emitter->flow_level ++; 756| 83.1k| } 757| | 758| 493k| if (event->type == YAML_SEQUENCE_END_EVENT) ------------------ | Branch (758:9): [True: 83.0k, False: 410k] ------------------ 759| 83.0k| { 760| 83.0k| emitter->flow_level --; 761| 83.0k| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 83.0k| (*(--(stack).top)) ------------------ 762| 83.0k| if (emitter->canonical && !first) { ------------------ | Branch (762:13): [True: 75.8k, False: 7.18k] | Branch (762:35): [True: 75.6k, False: 246] ------------------ 763| 75.6k| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (763:17): [True: 0, False: 75.6k] ------------------ 764| 0| return 0; 765| 75.6k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (765:17): [True: 0, False: 75.6k] ------------------ 766| 0| return 0; 767| 75.6k| } 768| 83.0k| if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0)) ------------------ | Branch (768:13): [True: 0, False: 83.0k] ------------------ 769| 0| return 0; 770| 83.0k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 83.0k| (*(--(stack).top)) ------------------ 771| | 772| 83.0k| return 1; 773| 83.0k| } 774| | 775| 410k| if (!first) { ------------------ | Branch (775:9): [True: 328k, False: 82.4k] ------------------ 776| 328k| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (776:13): [True: 0, False: 328k] ------------------ 777| 0| return 0; 778| 328k| } 779| | 780| 410k| if (emitter->canonical || emitter->column > emitter->best_width) { ------------------ | Branch (780:9): [True: 399k, False: 11.0k] | Branch (780:31): [True: 4.84k, False: 6.20k] ------------------ 781| 404k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (781:13): [True: 0, False: 404k] ------------------ 782| 0| return 0; 783| 404k| } 784| 410k| if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE)) ------------------ | | 445| 410k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 410k, False: 426] | | ------------------ | | 446| 410k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 426, False: 0] | | ------------------ | | 447| 426| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 410k| (*((stack).top++) = value, \ | | 449| 410k| 1) : \ | | 450| 410k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (784:9): [True: 0, False: 410k] ------------------ 785| 0| return 0; 786| | 787| 410k| return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); 788| 410k|} emitter.c:yaml_emitter_emit_flow_mapping_key: 797| 3.36M|{ 798| 3.36M| if (first) ------------------ | Branch (798:9): [True: 1.50M, False: 1.85M] ------------------ 799| 1.50M| { 800| 1.50M| if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0)) ------------------ | Branch (800:13): [True: 0, False: 1.50M] ------------------ 801| 0| return 0; 802| 1.50M| if (!yaml_emitter_increase_indent(emitter, 1, 0)) ------------------ | Branch (802:13): [True: 0, False: 1.50M] ------------------ 803| 0| return 0; 804| 1.50M| emitter->flow_level ++; 805| 1.50M| } 806| | 807| 3.36M| if (event->type == YAML_MAPPING_END_EVENT) ------------------ | Branch (807:9): [True: 1.50M, False: 1.85M] ------------------ 808| 1.50M| { 809| 1.50M| emitter->flow_level --; 810| 1.50M| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 1.50M| (*(--(stack).top)) ------------------ 811| 1.50M| if (emitter->canonical && !first) { ------------------ | Branch (811:13): [True: 1.49M, False: 8.58k] | Branch (811:35): [True: 1.49M, False: 232] ------------------ 812| 1.49M| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (812:17): [True: 0, False: 1.49M] ------------------ 813| 0| return 0; 814| 1.49M| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (814:17): [True: 0, False: 1.49M] ------------------ 815| 0| return 0; 816| 1.49M| } 817| 1.50M| if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0)) ------------------ | Branch (817:13): [True: 0, False: 1.50M] ------------------ 818| 0| return 0; 819| 1.50M| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 1.50M| (*(--(stack).top)) ------------------ 820| | 821| 1.50M| return 1; 822| 1.50M| } 823| | 824| 1.85M| if (!first) { ------------------ | Branch (824:9): [True: 353k, False: 1.50M] ------------------ 825| 353k| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (825:13): [True: 0, False: 353k] ------------------ 826| 0| return 0; 827| 353k| } 828| 1.85M| if (emitter->canonical || emitter->column > emitter->best_width) { ------------------ | Branch (828:9): [True: 1.64M, False: 215k] | Branch (828:31): [True: 29.0k, False: 185k] ------------------ 829| 1.67M| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (829:13): [True: 0, False: 1.67M] ------------------ 830| 0| return 0; 831| 1.67M| } 832| | 833| 1.85M| if (!emitter->canonical && yaml_emitter_check_simple_key(emitter)) ------------------ | Branch (833:9): [True: 215k, False: 1.64M] | Branch (833:32): [True: 208k, False: 6.98k] ------------------ 834| 208k| { 835| 208k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 208k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 208k, False: 37] | | ------------------ | | 446| 208k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 37, False: 0] | | ------------------ | | 447| 37| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 208k| (*((stack).top++) = value, \ | | 449| 208k| 1) : \ | | 450| 208k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (835:13): [True: 0, False: 208k] ------------------ 836| 208k| YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)) 837| 0| return 0; 838| | 839| 208k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); 840| 208k| } 841| 1.64M| else 842| 1.64M| { 843| 1.64M| if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0)) ------------------ | Branch (843:13): [True: 0, False: 1.64M] ------------------ 844| 0| return 0; 845| 1.64M| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 1.64M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.64M, False: 1.27k] | | ------------------ | | 446| 1.64M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.27k, False: 0] | | ------------------ | | 447| 1.27k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.64M| (*((stack).top++) = value, \ | | 449| 1.64M| 1) : \ | | 450| 1.64M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (845:13): [True: 0, False: 1.64M] ------------------ 846| 1.64M| YAML_EMIT_FLOW_MAPPING_VALUE_STATE)) 847| 0| return 0; 848| | 849| 1.64M| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 850| 1.64M| } 851| 1.85M|} emitter.c:yaml_emitter_check_simple_key: 1148| 1.03M|{ 1149| 1.03M| yaml_event_t *event = emitter->events.head; 1150| 1.03M| size_t length = 0; 1151| | 1152| 1.03M| switch (event->type) 1153| 1.03M| { 1154| 117k| case YAML_ALIAS_EVENT: ------------------ | Branch (1154:9): [True: 117k, False: 918k] ------------------ 1155| 117k| length += emitter->anchor_data.anchor_length; 1156| 117k| break; 1157| | 1158| 368k| case YAML_SCALAR_EVENT: ------------------ | Branch (1158:9): [True: 368k, False: 667k] ------------------ 1159| 368k| if (emitter->scalar_data.multiline) ------------------ | Branch (1159:17): [True: 15.1k, False: 353k] ------------------ 1160| 15.1k| return 0; 1161| 353k| length += emitter->anchor_data.anchor_length 1162| 353k| + emitter->tag_data.handle_length 1163| 353k| + emitter->tag_data.suffix_length 1164| 353k| + emitter->scalar_data.length; 1165| 353k| break; 1166| | 1167| 7.41k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1167:9): [True: 7.41k, False: 1.02M] ------------------ 1168| 7.41k| if (!yaml_emitter_check_empty_sequence(emitter)) ------------------ | Branch (1168:17): [True: 7.05k, False: 367] ------------------ 1169| 7.05k| return 0; 1170| 367| length += emitter->anchor_data.anchor_length 1171| 367| + emitter->tag_data.handle_length 1172| 367| + emitter->tag_data.suffix_length; 1173| 367| break; 1174| | 1175| 542k| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1175:9): [True: 542k, False: 493k] ------------------ 1176| 542k| if (!yaml_emitter_check_empty_mapping(emitter)) ------------------ | Branch (1176:17): [True: 541k, False: 377] ------------------ 1177| 541k| return 0; 1178| 377| length += emitter->anchor_data.anchor_length 1179| 377| + emitter->tag_data.handle_length 1180| 377| + emitter->tag_data.suffix_length; 1181| 377| break; 1182| | 1183| 0| default: ------------------ | Branch (1183:9): [True: 0, False: 1.03M] ------------------ 1184| 0| return 0; 1185| 1.03M| } 1186| | 1187| 471k| if (length > 128) ------------------ | Branch (1187:9): [True: 4.91k, False: 466k] ------------------ 1188| 4.91k| return 0; 1189| | 1190| 466k| return 1; 1191| 471k|} emitter.c:yaml_emitter_emit_flow_mapping_value: 860| 1.85M|{ 861| 1.85M| if (simple) { ------------------ | Branch (861:9): [True: 208k, False: 1.64M] ------------------ 862| 208k| if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) ------------------ | Branch (862:13): [True: 0, False: 208k] ------------------ 863| 0| return 0; 864| 208k| } 865| 1.64M| else { 866| 1.64M| if (emitter->canonical || emitter->column > emitter->best_width) { ------------------ | Branch (866:13): [True: 1.64M, False: 6.98k] | Branch (866:35): [True: 4.63k, False: 2.35k] ------------------ 867| 1.64M| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (867:17): [True: 0, False: 1.64M] ------------------ 868| 0| return 0; 869| 1.64M| } 870| 1.64M| if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0)) ------------------ | Branch (870:13): [True: 0, False: 1.64M] ------------------ 871| 0| return 0; 872| 1.64M| } 873| 1.85M| if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE)) ------------------ | | 445| 1.85M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.85M, False: 0] | | ------------------ | | 446| 1.85M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.85M| (*((stack).top++) = value, \ | | 449| 1.85M| 1) : \ | | 450| 1.85M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (873:9): [True: 0, False: 1.85M] ------------------ 874| 0| return 0; 875| 1.85M| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 876| 1.85M|} emitter.c:yaml_emitter_emit_block_sequence_item: 885| 225k|{ 886| 225k| if (first) ------------------ | Branch (886:9): [True: 32.5k, False: 193k] ------------------ 887| 32.5k| { 888| 32.5k| if (!yaml_emitter_increase_indent(emitter, 0, ------------------ | Branch (888:13): [True: 0, False: 32.5k] ------------------ 889| 32.5k| (emitter->mapping_context && !emitter->indention))) ------------------ | Branch (889:22): [True: 20.1k, False: 12.3k] | Branch (889:50): [True: 18.1k, False: 2.03k] ------------------ 890| 0| return 0; 891| 32.5k| } 892| | 893| 225k| if (event->type == YAML_SEQUENCE_END_EVENT) ------------------ | Branch (893:9): [True: 32.4k, False: 193k] ------------------ 894| 32.4k| { 895| 32.4k| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 32.4k| (*(--(stack).top)) ------------------ 896| 32.4k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 32.4k| (*(--(stack).top)) ------------------ 897| | 898| 32.4k| return 1; 899| 32.4k| } 900| | 901| 193k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (901:9): [True: 0, False: 193k] ------------------ 902| 0| return 0; 903| 193k| if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1)) ------------------ | Branch (903:9): [True: 0, False: 193k] ------------------ 904| 0| return 0; 905| 193k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 193k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 193k, False: 196] | | ------------------ | | 446| 193k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 196, False: 0] | | ------------------ | | 447| 196| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 193k| (*((stack).top++) = value, \ | | 449| 193k| 1) : \ | | 450| 193k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (905:9): [True: 0, False: 193k] ------------------ 906| 193k| YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE)) 907| 0| return 0; 908| | 909| 193k| return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); 910| 193k|} emitter.c:yaml_emitter_emit_block_mapping_key: 919| 1.55M|{ 920| 1.55M| if (first) ------------------ | Branch (920:9): [True: 732k, False: 820k] ------------------ 921| 732k| { 922| 732k| if (!yaml_emitter_increase_indent(emitter, 0, 0)) ------------------ | Branch (922:13): [True: 0, False: 732k] ------------------ 923| 0| return 0; 924| 732k| } 925| | 926| 1.55M| if (event->type == YAML_MAPPING_END_EVENT) ------------------ | Branch (926:9): [True: 731k, False: 820k] ------------------ 927| 731k| { 928| 731k| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 731k| (*(--(stack).top)) ------------------ 929| 731k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 731k| (*(--(stack).top)) ------------------ 930| | 931| 731k| return 1; 932| 731k| } 933| | 934| 820k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (934:9): [True: 0, False: 820k] ------------------ 935| 0| return 0; 936| | 937| 820k| if (yaml_emitter_check_simple_key(emitter)) ------------------ | Branch (937:9): [True: 258k, False: 561k] ------------------ 938| 258k| { 939| 258k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 258k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 258k, False: 58] | | ------------------ | | 446| 258k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 58, False: 0] | | ------------------ | | 447| 58| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 258k| (*((stack).top++) = value, \ | | 449| 258k| 1) : \ | | 450| 258k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (939:13): [True: 0, False: 258k] ------------------ 940| 258k| YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)) 941| 0| return 0; 942| | 943| 258k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); 944| 258k| } 945| 561k| else 946| 561k| { 947| 561k| if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1)) ------------------ | Branch (947:13): [True: 0, False: 561k] ------------------ 948| 0| return 0; 949| 561k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 561k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 561k, False: 573] | | ------------------ | | 446| 561k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 573, False: 0] | | ------------------ | | 447| 573| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 561k| (*((stack).top++) = value, \ | | 449| 561k| 1) : \ | | 450| 561k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (949:13): [True: 0, False: 561k] ------------------ 950| 561k| YAML_EMIT_BLOCK_MAPPING_VALUE_STATE)) 951| 0| return 0; 952| | 953| 561k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 954| 561k| } 955| 820k|} emitter.c:yaml_emitter_emit_block_mapping_value: 964| 820k|{ 965| 820k| if (simple) { ------------------ | Branch (965:9): [True: 258k, False: 561k] ------------------ 966| 258k| if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) ------------------ | Branch (966:13): [True: 0, False: 258k] ------------------ 967| 0| return 0; 968| 258k| } 969| 561k| else { 970| 561k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (970:13): [True: 0, False: 561k] ------------------ 971| 0| return 0; 972| 561k| if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1)) ------------------ | Branch (972:13): [True: 0, False: 561k] ------------------ 973| 0| return 0; 974| 561k| } 975| 820k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 820k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 820k, False: 0] | | ------------------ | | 446| 820k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 820k| (*((stack).top++) = value, \ | | 449| 820k| 1) : \ | | 450| 820k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (975:9): [True: 0, False: 820k] ------------------ 976| 820k| YAML_EMIT_BLOCK_MAPPING_KEY_STATE)) 977| 0| return 0; 978| | 979| 820k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 980| 820k|} emitter.c:yaml_emitter_set_emitter_error: 269| 50|{ 270| 50| emitter->error = YAML_EMITTER_ERROR; 271| 50| emitter->problem = problem; 272| | 273| 50| return 0; 274| 50|} emitter.c:yaml_emitter_analyze_event: 1703| 8.50M|{ 1704| 8.50M| emitter->anchor_data.anchor = NULL; 1705| 8.50M| emitter->anchor_data.anchor_length = 0; 1706| 8.50M| emitter->tag_data.handle = NULL; 1707| 8.50M| emitter->tag_data.handle_length = 0; 1708| 8.50M| emitter->tag_data.suffix = NULL; 1709| 8.50M| emitter->tag_data.suffix_length = 0; 1710| 8.50M| emitter->scalar_data.value = NULL; 1711| 8.50M| emitter->scalar_data.length = 0; 1712| | 1713| 8.50M| switch (event->type) 1714| 8.50M| { 1715| 130k| case YAML_ALIAS_EVENT: ------------------ | Branch (1715:9): [True: 130k, False: 8.37M] ------------------ 1716| 130k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1716:17): [True: 0, False: 130k] ------------------ 1717| 130k| event->data.alias.anchor, 1)) 1718| 0| return 0; 1719| 130k| return 1; 1720| | 1721| 3.53M| case YAML_SCALAR_EVENT: ------------------ | Branch (1721:9): [True: 3.53M, False: 4.96M] ------------------ 1722| 3.53M| if (event->data.scalar.anchor) { ------------------ | Branch (1722:17): [True: 1.67k, False: 3.53M] ------------------ 1723| 1.67k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1723:21): [True: 0, False: 1.67k] ------------------ 1724| 1.67k| event->data.scalar.anchor, 0)) 1725| 0| return 0; 1726| 1.67k| } 1727| 3.53M| if (event->data.scalar.tag && (emitter->canonical || ------------------ | Branch (1727:17): [True: 3.53M, False: 0] | Branch (1727:44): [True: 2.13M, False: 1.40M] ------------------ 1728| 1.40M| (!event->data.scalar.plain_implicit ------------------ | Branch (1728:26): [True: 1.27k, False: 1.40M] ------------------ 1729| 2.13M| && !event->data.scalar.quoted_implicit))) { ------------------ | Branch (1729:29): [True: 1.27k, False: 0] ------------------ 1730| 2.13M| if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag)) ------------------ | Branch (1730:21): [True: 28, False: 2.13M] ------------------ 1731| 28| return 0; 1732| 2.13M| } 1733| 3.53M| if (!yaml_emitter_analyze_scalar(emitter, ------------------ | Branch (1733:17): [True: 0, False: 3.53M] ------------------ 1734| 3.53M| event->data.scalar.value, event->data.scalar.length)) 1735| 0| return 0; 1736| 3.53M| return 1; 1737| | 1738| 115k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1738:9): [True: 115k, False: 8.39M] ------------------ 1739| 115k| if (event->data.sequence_start.anchor) { ------------------ | Branch (1739:17): [True: 1.06k, False: 114k] ------------------ 1740| 1.06k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1740:21): [True: 0, False: 1.06k] ------------------ 1741| 1.06k| event->data.sequence_start.anchor, 0)) 1742| 0| return 0; 1743| 1.06k| } 1744| 115k| if (event->data.sequence_start.tag && (emitter->canonical || ------------------ | Branch (1744:17): [True: 115k, False: 0] | Branch (1744:52): [True: 75.9k, False: 39.7k] ------------------ 1745| 78.1k| !event->data.sequence_start.implicit)) { ------------------ | Branch (1745:25): [True: 2.21k, False: 37.5k] ------------------ 1746| 78.1k| if (!yaml_emitter_analyze_tag(emitter, ------------------ | Branch (1746:21): [True: 9, False: 78.1k] ------------------ 1747| 78.1k| event->data.sequence_start.tag)) 1748| 9| return 0; 1749| 78.1k| } 1750| 115k| return 1; 1751| | 1752| 2.23M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1752:9): [True: 2.23M, False: 6.27M] ------------------ 1753| 2.23M| if (event->data.mapping_start.anchor) { ------------------ | Branch (1753:17): [True: 1.07k, False: 2.23M] ------------------ 1754| 1.07k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1754:21): [True: 0, False: 1.07k] ------------------ 1755| 1.07k| event->data.mapping_start.anchor, 0)) 1756| 0| return 0; 1757| 1.07k| } 1758| 2.23M| if (event->data.mapping_start.tag && (emitter->canonical || ------------------ | Branch (1758:17): [True: 2.23M, False: 0] | Branch (1758:51): [True: 1.49M, False: 740k] ------------------ 1759| 1.49M| !event->data.mapping_start.implicit)) { ------------------ | Branch (1759:25): [True: 307, False: 740k] ------------------ 1760| 1.49M| if (!yaml_emitter_analyze_tag(emitter, ------------------ | Branch (1760:21): [True: 11, False: 1.49M] ------------------ 1761| 1.49M| event->data.mapping_start.tag)) 1762| 11| return 0; 1763| 1.49M| } 1764| 2.23M| return 1; 1765| | 1766| 2.48M| default: ------------------ | Branch (1766:9): [True: 2.48M, False: 6.02M] ------------------ 1767| 2.48M| return 1; 1768| 8.50M| } 1769| 8.50M|} emitter.c:yaml_emitter_analyze_anchor: 1424| 134k|{ 1425| 134k| size_t anchor_length; 1426| 134k| yaml_string_t string; 1427| | 1428| 134k| anchor_length = strlen((char *)anchor); 1429| 134k| STRING_ASSIGN(string, anchor, anchor_length); ------------------ | | 128| 134k| ((value).start = (string), \ | | 129| 134k| (value).end = (string)+(length), \ | | 130| 134k| (value).pointer = (string)) ------------------ 1430| | 1431| 134k| if (string.start == string.end) { ------------------ | Branch (1431:9): [True: 0, False: 134k] ------------------ 1432| 0| return yaml_emitter_set_emitter_error(emitter, alias ? ------------------ | Branch (1432:56): [True: 0, False: 0] ------------------ 1433| 0| "alias value must not be empty" : 1434| 0| "anchor value must not be empty"); 1435| 0| } 1436| | 1437| 806k| while (string.pointer != string.end) { ------------------ | Branch (1437:12): [True: 672k, False: 134k] ------------------ 1438| 672k| if (!IS_ALPHA(string)) { ------------------ | | 198| 672k|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 672k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 672k, False: 0] | | | | ------------------ | | | | 190| 672k| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 403k, False: 268k] | | | | ------------------ | | | | 191| 672k| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 268k, False: 0] | | | | ------------------ | | | | 192| 268k| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 0, False: 268k] | | | | ------------------ | | | | 193| 672k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 268k, False: 0] | | | | ------------------ | | | | 194| 268k| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 268k, False: 0] | | | | ------------------ | | | | 195| 672k| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 0, False: 0] | | | | ------------------ | | | | 196| 672k| (string).pointer[offset] == '-') | | | | ------------------ | | | | | Branch (196:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1439| 0| return yaml_emitter_set_emitter_error(emitter, alias ? ------------------ | Branch (1439:60): [True: 0, False: 0] ------------------ 1440| 0| "alias value must contain alphanumerical characters only" : 1441| 0| "anchor value must contain alphanumerical characters only"); 1442| 0| } 1443| 672k| MOVE(string); ------------------ | | 391| 672k|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 672k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 672k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 672k, False: 0] | | | | | | ------------------ | | | | | | 381| 672k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1444| 672k| } 1445| | 1446| 134k| emitter->anchor_data.anchor = string.start; 1447| 134k| emitter->anchor_data.anchor_length = string.end - string.start; 1448| 134k| emitter->anchor_data.alias = alias; 1449| | 1450| 134k| return 1; 1451| 134k|} emitter.c:yaml_emitter_analyze_tag: 1460| 3.71M|{ 1461| 3.71M| size_t tag_length; 1462| 3.71M| yaml_string_t string; 1463| 3.71M| yaml_tag_directive_t *tag_directive; 1464| | 1465| 3.71M| tag_length = strlen((char *)tag); 1466| 3.71M| STRING_ASSIGN(string, tag, tag_length); ------------------ | | 128| 3.71M| ((value).start = (string), \ | | 129| 3.71M| (value).end = (string)+(length), \ | | 130| 3.71M| (value).pointer = (string)) ------------------ 1467| | 1468| 3.71M| if (string.start == string.end) { ------------------ | Branch (1468:9): [True: 48, False: 3.71M] ------------------ 1469| 48| return yaml_emitter_set_emitter_error(emitter, 1470| 48| "tag value must not be empty"); 1471| 48| } 1472| | 1473| 3.71M| for (tag_directive = emitter->tag_directives.start; 1474| 7.76M| tag_directive != emitter->tag_directives.top; tag_directive ++) { ------------------ | Branch (1474:13): [True: 7.49M, False: 271k] ------------------ 1475| 7.49M| size_t prefix_length = strlen((char *)tag_directive->prefix); 1476| 7.49M| if (prefix_length < (size_t)(string.end - string.start) ------------------ | Branch (1476:13): [True: 7.49M, False: 4.54k] ------------------ 1477| 7.49M| && strncmp((char *)tag_directive->prefix, (char *)string.start, ------------------ | Branch (1477:20): [True: 3.44M, False: 4.04M] ------------------ 1478| 7.49M| prefix_length) == 0) 1479| 3.44M| { 1480| 3.44M| emitter->tag_data.handle = tag_directive->handle; 1481| 3.44M| emitter->tag_data.handle_length = 1482| 3.44M| strlen((char *)tag_directive->handle); 1483| 3.44M| emitter->tag_data.suffix = string.start + prefix_length; 1484| 3.44M| emitter->tag_data.suffix_length = 1485| 3.44M| (string.end - string.start) - prefix_length; 1486| 3.44M| return 1; 1487| 3.44M| } 1488| 7.49M| } 1489| | 1490| 271k| emitter->tag_data.suffix = string.start; 1491| 271k| emitter->tag_data.suffix_length = string.end - string.start; 1492| | 1493| 271k| return 1; 1494| 3.71M|} emitter.c:yaml_emitter_analyze_scalar: 1503| 3.53M|{ 1504| 3.53M| yaml_string_t string; 1505| | 1506| 3.53M| int block_indicators = 0; 1507| 3.53M| int flow_indicators = 0; 1508| 3.53M| int line_breaks = 0; 1509| 3.53M| int special_characters = 0; 1510| | 1511| 3.53M| int leading_space = 0; 1512| 3.53M| int leading_break = 0; 1513| 3.53M| int trailing_space = 0; 1514| 3.53M| int trailing_break = 0; 1515| 3.53M| int break_space = 0; 1516| 3.53M| int space_break = 0; 1517| | 1518| 3.53M| int preceded_by_whitespace = 0; 1519| 3.53M| int followed_by_whitespace = 0; 1520| 3.53M| int previous_space = 0; 1521| 3.53M| int previous_break = 0; 1522| | 1523| 3.53M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 3.53M| ((value).start = (string), \ | | 129| 3.53M| (value).end = (string)+(length), \ | | 130| 3.53M| (value).pointer = (string)) ------------------ 1524| | 1525| 3.53M| emitter->scalar_data.value = value; 1526| 3.53M| emitter->scalar_data.length = length; 1527| | 1528| 3.53M| if (string.start == string.end) ------------------ | Branch (1528:9): [True: 2.73M, False: 799k] ------------------ 1529| 2.73M| { 1530| 2.73M| emitter->scalar_data.multiline = 0; 1531| 2.73M| emitter->scalar_data.flow_plain_allowed = 0; 1532| 2.73M| emitter->scalar_data.block_plain_allowed = 1; 1533| 2.73M| emitter->scalar_data.single_quoted_allowed = 1; 1534| 2.73M| emitter->scalar_data.block_allowed = 0; 1535| | 1536| 2.73M| return 1; 1537| 2.73M| } 1538| | 1539| 799k| if ((CHECK_AT(string, '-', 0) ------------------ | | 175| 1.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 101k, False: 697k] | | ------------------ ------------------ 1540| 101k| && CHECK_AT(string, '-', 1) ------------------ | | 175| 900k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 20.7k, False: 80.6k] | | ------------------ ------------------ 1541| 20.7k| && CHECK_AT(string, '-', 2)) ------------------ | | 175| 20.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 3.16k, False: 17.6k] | | ------------------ ------------------ 1542| 796k| || (CHECK_AT(string, '.', 0) ------------------ | | 175| 1.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.75k, False: 793k] | | ------------------ ------------------ 1543| 2.75k| && CHECK_AT(string, '.', 1) ------------------ | | 175| 799k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 902, False: 1.85k] | | ------------------ ------------------ 1544| 3.79k| && CHECK_AT(string, '.', 2))) { ------------------ | | 175| 902| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 630, False: 272] | | ------------------ ------------------ 1545| 3.79k| block_indicators = 1; 1546| 3.79k| flow_indicators = 1; 1547| 3.79k| } 1548| | 1549| 799k| preceded_by_whitespace = 1; 1550| 799k| followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); ------------------ | | 371| 799k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 1.59M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 799k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.62M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 9.96k, False: 789k] | | | | | | | | | Branch (175:23): [True: 706, False: 0] | | | | | | | | | Branch (175:23): [True: 5.74k, False: 706] | | | | | | | | | Branch (175:23): [True: 1.68k, False: 6.45k] | | | | | | | | | Branch (175:23): [True: 791k, False: 8.13k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 789k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.60M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 231, False: 789k] | | | | | | | | | Branch (175:23): [True: 703, False: 0] | | | | | | | | | Branch (175:23): [True: 5.54k, False: 703] | | | | | | | | | Branch (175:23): [True: 1.65k, False: 6.25k] | | | | | | | | | Branch (175:23): [True: 781k, False: 7.90k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 789k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 1.57M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 1.60M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 206, False: 789k] | | | | | | | | | Branch (175:23): [True: 703, False: 0] | | | | | | | | | Branch (175:23): [True: 5.54k, False: 703] | | | | | | | | | Branch (175:23): [True: 1.65k, False: 6.25k] | | | | | | | | | Branch (175:23): [True: 781k, False: 7.90k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 789k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.60M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.63k, False: 785k] | | | | | | | | | Branch (175:23): [True: 703, False: 0] | | | | | | | | | Branch (175:23): [True: 5.54k, False: 703] | | | | | | | | | Branch (175:23): [True: 1.65k, False: 6.25k] | | | | | | | | | Branch (175:23): [True: 781k, False: 7.90k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 789k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.23k, False: 782k] | | | | | | | | | Branch (175:23): [True: 703, False: 0] | | | | | | | | | Branch (175:23): [True: 3.77k, False: 703] | | | | | | | | | Branch (175:23): [True: 1.26k, False: 4.47k] | | | | | | | | | Branch (175:23): [True: 779k, False: 5.74k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 785k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 14.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 226, False: 3.00k] | | | | | | | | | Branch (175:23): [True: 235, False: 0] | | | | | | | | | Branch (175:23): [True: 1.61k, False: 235] | | | | | | | | | Branch (175:23): [True: 248, False: 1.85k] | | | | | | | | | Branch (175:23): [True: 1.13k, False: 2.09k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 789k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.00k, False: 783k] | | | | | | | | | Branch (175:23): [True: 703, False: 0] | | | | | | | | | Branch (175:23): [True: 3.77k, False: 703] | | | | | | | | | Branch (175:23): [True: 1.26k, False: 4.47k] | | | | | | | | | Branch (175:23): [True: 779k, False: 5.73k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 785k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 787k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.55k, False: 453] | | | | | | | | | Branch (175:23): [True: 202, False: 0] | | | | | | | | | Branch (175:23): [True: 440, False: 202] | | | | | | | | | Branch (175:23): [True: 242, False: 642] | | | | | | | | | Branch (175:23): [True: 1.12k, False: 884] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 785k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 6.14k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 284, False: 1.26k] | | | | | | | | | Branch (175:23): [True: 201, False: 0] | | | | | | | | | Branch (175:23): [True: 342, False: 201] | | | | | | | | | Branch (175:23): [True: 235, False: 543] | | | | | | | | | Branch (175:23): [True: 773, False: 778] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 1.57M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.72k, False: 783k] | | | | | | | | | Branch (175:23): [True: 703, False: 0] | | | | | | | | | Branch (175:23): [True: 3.73k, False: 703] | | | | | | | | | Branch (175:23): [True: 1.26k, False: 4.43k] | | | | | | | | | Branch (175:23): [True: 779k, False: 5.69k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 784k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 786k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.26k, False: 453] | | | | | | | | | Branch (175:23): [True: 202, False: 0] | | | | | | | | | Branch (175:23): [True: 403, False: 202] | | | | | | | | | Branch (175:23): [True: 240, False: 605] | | | | | | | | | Branch (175:23): [True: 875, False: 845] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 784k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 5.42k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 467, False: 800] | | | | | | | | | Branch (175:23): [True: 201, False: 0] | | | | | | | | | Branch (175:23): [True: 305, False: 201] | | | | | | | | | Branch (175:23): [True: 233, False: 506] | | | | | | | | | Branch (175:23): [True: 528, False: 739] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 784k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.58M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 625k, False: 158k] | | | | | | | | | Branch (175:23): [True: 620, False: 0] | | | | | | | | | Branch (175:23): [True: 3.50k, False: 620] | | | | | | | | | Branch (175:23): [True: 1.25k, False: 4.12k] | | | | | | | | | Branch (175:23): [True: 779k, False: 5.38k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1551| | 1552| 37.2M| while (string.pointer != string.end) ------------------ | Branch (1552:12): [True: 36.4M, False: 799k] ------------------ 1553| 36.4M| { 1554| 36.4M| if (string.start == string.pointer) ------------------ | Branch (1554:13): [True: 799k, False: 35.6M] ------------------ 1555| 799k| { 1556| 799k| if (CHECK(string, '#') || CHECK(string, ',') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 799k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 267, False: 799k] | | ------------------ ------------------ if (CHECK(string, '#') || CHECK(string, ',') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 799k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 236, False: 798k] | | ------------------ ------------------ 1557| 798k| || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 798k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 202, False: 798k] | | ------------------ ------------------ || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 798k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 315, False: 798k] | | ------------------ ------------------ 1558| 798k| || CHECK(string, '{') || CHECK(string, '}') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 798k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 221, False: 798k] | | ------------------ ------------------ || CHECK(string, '{') || CHECK(string, '}') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 798k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 247, False: 797k] | | ------------------ ------------------ 1559| 797k| || CHECK(string, '&') || CHECK(string, '*') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 797k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 255, False: 797k] | | ------------------ ------------------ || CHECK(string, '&') || CHECK(string, '*') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 797k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 303, False: 797k] | | ------------------ ------------------ 1560| 797k| || CHECK(string, '!') || CHECK(string, '|') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 797k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 535, False: 796k] | | ------------------ ------------------ || CHECK(string, '!') || CHECK(string, '|') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 796k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.05k, False: 794k] | | ------------------ ------------------ 1561| 794k| || CHECK(string, '>') || CHECK(string, '\'') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 794k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 377, False: 794k] | | ------------------ ------------------ || CHECK(string, '>') || CHECK(string, '\'') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 794k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 218, False: 794k] | | ------------------ ------------------ 1562| 794k| || CHECK(string, '"') || CHECK(string, '%') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 794k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 293, False: 793k] | | ------------------ ------------------ || CHECK(string, '"') || CHECK(string, '%') ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 793k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 307, False: 793k] | | ------------------ ------------------ 1563| 793k| || CHECK(string, '@') || CHECK(string, '`')) { ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 793k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 258, False: 793k] | | ------------------ ------------------ || CHECK(string, '@') || CHECK(string, '`')) { ------------------ | | 181| 793k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 793k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 274, False: 793k] | | ------------------ ------------------ 1564| 6.36k| flow_indicators = 1; 1565| 6.36k| block_indicators = 1; 1566| 6.36k| } 1567| | 1568| 799k| if (CHECK(string, '?') || CHECK(string, ':')) { ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 799k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 60.2k, False: 739k] | | ------------------ ------------------ if (CHECK(string, '?') || CHECK(string, ':')) { ------------------ | | 181| 739k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 739k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 219k, False: 520k] | | ------------------ ------------------ 1569| 279k| flow_indicators = 1; 1570| 279k| if (followed_by_whitespace) { ------------------ | Branch (1570:21): [True: 224k, False: 55.0k] ------------------ 1571| 224k| block_indicators = 1; 1572| 224k| } 1573| 279k| } 1574| | 1575| 799k| if (CHECK(string, '-') && followed_by_whitespace) { ------------------ | | 181| 1.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 799k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 101k, False: 697k] | | ------------------ ------------------ | Branch (1575:39): [True: 54.1k, False: 47.2k] ------------------ 1576| 54.1k| flow_indicators = 1; 1577| 54.1k| block_indicators = 1; 1578| 54.1k| } 1579| 799k| } 1580| 35.6M| else 1581| 35.6M| { 1582| 35.6M| if (CHECK(string, ',') || CHECK(string, '?') ------------------ | | 181| 71.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 35.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 152k, False: 35.5M] | | ------------------ ------------------ if (CHECK(string, ',') || CHECK(string, '?') ------------------ | | 181| 71.1M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 35.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.29M, False: 33.2M] | | ------------------ ------------------ 1583| 33.2M| || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 68.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 37.9k, False: 33.1M] | | ------------------ ------------------ || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 68.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10.4k, False: 33.1M] | | ------------------ ------------------ 1584| 33.1M| || CHECK(string, '{') || CHECK(string, '}')) { ------------------ | | 181| 68.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 29.6k, False: 33.1M] | | ------------------ ------------------ || CHECK(string, '{') || CHECK(string, '}')) { ------------------ | | 181| 33.1M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 32.9k, False: 33.0M] | | ------------------ ------------------ 1585| 2.56M| flow_indicators = 1; 1586| 2.56M| } 1587| | 1588| 35.6M| if (CHECK(string, ':')) { ------------------ | | 181| 35.6M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 35.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 268k, False: 35.3M] | | ------------------ ------------------ 1589| 268k| flow_indicators = 1; 1590| 268k| if (followed_by_whitespace) { ------------------ | Branch (1590:21): [True: 29.9k, False: 238k] ------------------ 1591| 29.9k| block_indicators = 1; 1592| 29.9k| } 1593| 268k| } 1594| | 1595| 35.6M| if (CHECK(string, '#') && preceded_by_whitespace) { ------------------ | | 181| 71.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 35.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.63k, False: 35.6M] | | ------------------ ------------------ | Branch (1595:39): [True: 1.19k, False: 2.44k] ------------------ 1596| 1.19k| flow_indicators = 1; 1597| 1.19k| block_indicators = 1; 1598| 1.19k| } 1599| 35.6M| } 1600| | 1601| 36.4M| if (!IS_PRINTABLE(string) ------------------ | | 279| 36.4M|#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) | | ------------------ | | | | 262| 72.9M| (((string).pointer[offset] == 0x0A) /* . == #x0A */ \ | | | | ------------------ | | | | | Branch (262:6): [True: 1.56M, False: 34.8M] | | | | ------------------ | | | | 263| 36.4M| || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \ | | | | ------------------ | | | | | Branch (263:10): [True: 32.4M, False: 2.48M] | | | | ------------------ | | | | 264| 34.8M| && (string).pointer[offset] <= 0x7E) \ | | | | ------------------ | | | | | Branch (264:13): [True: 24.5M, False: 7.87M] | | | | ------------------ | | | | 265| 36.4M| || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ | | | | ------------------ | | | | | Branch (265:10): [True: 210k, False: 10.1M] | | | | ------------------ | | | | 266| 10.3M| && (string).pointer[offset+1] >= 0xA0) \ | | | | ------------------ | | | | | Branch (266:13): [True: 31.9k, False: 178k] | | | | ------------------ | | | | 267| 36.4M| || ((string).pointer[offset] > 0xC2 \ | | | | ------------------ | | | | | Branch (267:10): [True: 7.66M, False: 2.66M] | | | | ------------------ | | | | 268| 10.3M| && (string).pointer[offset] < 0xED) \ | | | | ------------------ | | | | | Branch (268:13): [True: 7.56M, False: 94.3k] | | | | ------------------ | | | | 269| 36.4M| || ((string).pointer[offset] == 0xED \ | | | | ------------------ | | | | | Branch (269:10): [True: 16.9k, False: 2.73M] | | | | ------------------ | | | | 270| 2.75M| && (string).pointer[offset+1] < 0xA0) \ | | | | ------------------ | | | | | Branch (270:13): [True: 16.9k, False: 0] | | | | ------------------ | | | | 271| 36.4M| || ((string).pointer[offset] == 0xEE) \ | | | | ------------------ | | | | | Branch (271:9): [True: 3.14k, False: 2.73M] | | | | ------------------ | | | | 272| 72.9M| || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \ | | | | ------------------ | | | | | Branch (272:10): [True: 16.6k, False: 2.71M] | | | | ------------------ | | | | 273| 2.73M| && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \ | | | | ------------------ | | | | | Branch (273:15): [True: 2.93k, False: 13.7k] | | | | ------------------ | | | | 274| 16.6k| && (string).pointer[offset+2] == 0xBF) \ | | | | ------------------ | | | | | Branch (274:17): [True: 1.77k, False: 1.16k] | | | | ------------------ | | | | 275| 2.73M| && !((string).pointer[offset+1] == 0xBF \ | | | | ------------------ | | | | | Branch (275:15): [True: 1.32k, False: 13.5k] | | | | ------------------ | | | | 276| 14.9k| && ((string).pointer[offset+2] == 0xBE \ | | | | ------------------ | | | | | Branch (276:18): [True: 274, False: 1.04k] | | | | ------------------ | | | | 277| 1.32k| || (string).pointer[offset+2] == 0xBF)))) | | | | ------------------ | | | | | Branch (277:21): [True: 199, False: 848] | | | | ------------------ | | ------------------ ------------------ 1602| 33.7M| || (!IS_ASCII(string) && !emitter->unicode)) { ------------------ | | 255| 33.7M|#define IS_ASCII(string) IS_ASCII_AT((string),0) | | ------------------ | | | | 253| 67.4M| ((string).pointer[offset] <= (yaml_char_t) '\x7F') | | ------------------ ------------------ | Branch (1602:21): [True: 7.63M, False: 26.1M] | Branch (1602:42): [True: 4.17M, False: 3.46M] ------------------ 1603| 6.89M| special_characters = 1; 1604| 6.89M| } 1605| | 1606| 36.4M| if (IS_BREAK(string)) { ------------------ | | 341| 36.4M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 36.4M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 72.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 614k, False: 35.8M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 36.4M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 72.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.56M, False: 34.2M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 36.4M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 68.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 210k, False: 34.0M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 34.2M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 210k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 178k, False: 31.9k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 36.4M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 68.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.71M, False: 30.3M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 34.0M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 37.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.47M, False: 239k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 34.0M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 3.47M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 10.2k, False: 3.46M] | | | | | | ------------------ | | | | ------------------ | | | | 337| 36.4M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 68.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.70M, False: 30.3M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 34.0M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 37.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.46M, False: 239k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 34.0M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 71.6k, False: 3.39M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1607| 2.44M| line_breaks = 1; 1608| 2.44M| } 1609| | 1610| 36.4M| if (IS_SPACE(string)) ------------------ | | 306| 36.4M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 36.4M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 36.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 6.87M, False: 29.5M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1611| 6.87M| { 1612| 6.87M| if (string.start == string.pointer) { ------------------ | Branch (1612:17): [True: 1.33k, False: 6.86M] ------------------ 1613| 1.33k| leading_space = 1; 1614| 1.33k| } 1615| 6.87M| if (string.pointer+WIDTH(string) == string.end) { ------------------ | | 385| 6.87M|#define WIDTH(string) WIDTH_AT((string),0) | | ------------------ | | | | 380| 6.87M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | ------------------ | | | | | Branch (380:7): [True: 6.87M, False: 0] | | | | ------------------ | | | | 381| 6.87M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | ------------------ | | | | | Branch (381:7): [True: 0, False: 0] | | | | ------------------ | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | ------------------ | | | | | Branch (382:7): [True: 0, False: 0] | | | | ------------------ | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | ------------------ | | | | | Branch (383:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (1615:17): [True: 3.51k, False: 6.86M] ------------------ 1616| 3.51k| trailing_space = 1; 1617| 3.51k| } 1618| 6.87M| if (previous_break) { ------------------ | Branch (1618:17): [True: 6.91k, False: 6.86M] ------------------ 1619| 6.91k| break_space = 1; 1620| 6.91k| } 1621| 6.87M| previous_space = 1; 1622| 6.87M| previous_break = 0; 1623| 6.87M| } 1624| 29.5M| else if (IS_BREAK(string)) ------------------ | | 341| 29.5M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 29.5M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 59.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 614k, False: 28.9M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 29.5M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 58.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.56M, False: 27.4M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 29.5M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 54.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 210k, False: 27.1M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 27.4M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 210k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 178k, False: 31.9k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 29.5M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 54.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.71M, False: 23.5M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 27.2M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 30.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.47M, False: 239k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 27.2M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 3.47M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 10.2k, False: 3.46M] | | | | | | ------------------ | | | | ------------------ | | | | 337| 29.5M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 54.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.70M, False: 23.5M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 27.2M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 30.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.46M, False: 239k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 27.2M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 71.6k, False: 3.39M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1625| 2.44M| { 1626| 2.44M| if (string.start == string.pointer) { ------------------ | Branch (1626:17): [True: 14.8k, False: 2.42M] ------------------ 1627| 14.8k| leading_break = 1; 1628| 14.8k| } 1629| 2.44M| if (string.pointer+WIDTH(string) == string.end) { ------------------ | | 385| 2.44M|#define WIDTH(string) WIDTH_AT((string),0) | | ------------------ | | | | 380| 2.44M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | ------------------ | | | | | Branch (380:7): [True: 2.18M, False: 260k] | | | | ------------------ | | | | 381| 2.44M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | ------------------ | | | | | Branch (381:7): [True: 178k, False: 81.9k] | | | | ------------------ | | | | 382| 260k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | ------------------ | | | | | Branch (382:7): [True: 81.9k, False: 0] | | | | ------------------ | | | | 383| 81.9k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | ------------------ | | | | | Branch (383:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (1629:17): [True: 17.9k, False: 2.42M] ------------------ 1630| 17.9k| trailing_break = 1; 1631| 17.9k| } 1632| 2.44M| if (previous_space) { ------------------ | Branch (1632:17): [True: 2.11k, False: 2.43M] ------------------ 1633| 2.11k| space_break = 1; 1634| 2.11k| } 1635| 2.44M| previous_space = 0; 1636| 2.44M| previous_break = 1; 1637| 2.44M| } 1638| 27.1M| else 1639| 27.1M| { 1640| 27.1M| previous_space = 0; 1641| 27.1M| previous_break = 0; 1642| 27.1M| } 1643| | 1644| 36.4M| preceded_by_whitespace = IS_BLANKZ(string); ------------------ | | 373| 36.4M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 36.4M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 72.9M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 36.4M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 72.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 6.87M, False: 29.5M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 29.5M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 29.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 545k, False: 29.0M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 29.0M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 58.0M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 58.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 614k, False: 28.4M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 29.0M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 57.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.56M, False: 26.8M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 29.0M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 53.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 210k, False: 26.6M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 26.8M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 210k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 178k, False: 31.9k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 29.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 53.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.71M, False: 22.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 26.6M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 30.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.47M, False: 239k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 26.6M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.47M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 10.2k, False: 3.46M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 58.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 53.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.70M, False: 22.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 26.6M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 30.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.46M, False: 239k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 26.6M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 71.6k, False: 3.39M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 26.6M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 26.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 4.49k, False: 26.5M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1645| 36.4M| MOVE(string); ------------------ | | 391| 36.4M|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 36.4M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 36.4M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 28.5M, False: 7.87M] | | | | | | ------------------ | | | | | | 381| 36.4M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 230k, False: 7.64M] | | | | | | ------------------ | | | | | | 382| 7.87M| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 7.58M, False: 57.5k] | | | | | | ------------------ | | | | | | 383| 7.64M| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 57.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1646| 36.4M| if (string.pointer != string.end) { ------------------ | Branch (1646:13): [True: 35.6M, False: 799k] ------------------ 1647| 35.6M| followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); ------------------ | | 371| 35.6M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 71.3M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 35.6M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 102M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 6.85M, False: 28.8M] | | | | | | | | | Branch (175:23): [True: 56.8k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.57M, False: 56.8k] | | | | | | | | | Branch (175:23): [True: 228k, False: 7.63M] | | | | | | | | | Branch (175:23): [True: 27.7M, False: 7.86M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 28.8M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 88.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 545k, False: 28.2M] | | | | | | | | | Branch (175:23): [True: 56.5k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.57M, False: 56.5k] | | | | | | | | | Branch (175:23): [True: 227k, False: 7.63M] | | | | | | | | | Branch (175:23): [True: 20.9M, False: 7.86M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 28.2M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 56.5M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 87.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 614k, False: 27.6M] | | | | | | | | | Branch (175:23): [True: 56.5k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.57M, False: 56.5k] | | | | | | | | | Branch (175:23): [True: 227k, False: 7.63M] | | | | | | | | | Branch (175:23): [True: 20.3M, False: 7.85M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 28.2M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 86.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.55M, False: 26.0M] | | | | | | | | | Branch (175:23): [True: 56.5k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.57M, False: 56.5k] | | | | | | | | | Branch (175:23): [True: 227k, False: 7.63M] | | | | | | | | | Branch (175:23): [True: 19.7M, False: 7.85M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 28.2M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 83.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 205k, False: 25.8M] | | | | | | | | | Branch (175:23): [True: 56.5k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.56M, False: 56.5k] | | | | | | | | | Branch (175:23): [True: 226k, False: 7.62M] | | | | | | | | | Branch (175:23): [True: 18.2M, False: 7.84M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 26.0M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 786k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 177k, False: 27.6k] | | | | | | | | | Branch (175:23): [True: 199, False: 0] | | | | | | | | | Branch (175:23): [True: 550, False: 199] | | | | | | | | | Branch (175:23): [True: 186k, False: 749] | | | | | | | | | Branch (175:23): [True: 18.7k, False: 186k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 28.2M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 82.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.71M, False: 22.2M] | | | | | | | | | Branch (175:23): [True: 56.5k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.56M, False: 56.5k] | | | | | | | | | Branch (175:23): [True: 60.4k, False: 7.62M] | | | | | | | | | Branch (175:23): [True: 18.2M, False: 7.68M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 25.9M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 29.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.47M, False: 238k] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 3.68M, False: 200] | | | | | | | | | Branch (175:23): [True: 972, False: 3.68M] | | | | | | | | | Branch (175:23): [True: 20.3k, False: 3.69M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 25.9M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 20.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.86k, False: 3.46M] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 3.45M, False: 200] | | | | | | | | | Branch (175:23): [True: 798, False: 3.45M] | | | | | | | | | Branch (175:23): [True: 17.5k, False: 3.45M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 56.5M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 82.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.70M, False: 22.2M] | | | | | | | | | Branch (175:23): [True: 56.5k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.55M, False: 56.5k] | | | | | | | | | Branch (175:23): [True: 60.1k, False: 7.61M] | | | | | | | | | Branch (175:23): [True: 18.2M, False: 7.67M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 25.9M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 29.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.46M, False: 238k] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 3.68M, False: 200] | | | | | | | | | Branch (175:23): [True: 605, False: 3.68M] | | | | | | | | | Branch (175:23): [True: 17.7k, False: 3.68M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 25.9M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 20.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 70.1k, False: 3.39M] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 3.44M, False: 200] | | | | | | | | | Branch (175:23): [True: 431, False: 3.44M] | | | | | | | | | Branch (175:23): [True: 14.9k, False: 3.44M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 25.8M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 82.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 178k, False: 25.6M] | | | | | | | | | Branch (175:23): [True: 56.5k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.48M, False: 56.5k] | | | | | | | | | Branch (175:23): [True: 59.8k, False: 7.54M] | | | | | | | | | Branch (175:23): [True: 18.2M, False: 7.60M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1648| 35.6M| } 1649| 36.4M| } 1650| | 1651| 799k| emitter->scalar_data.multiline = line_breaks; 1652| | 1653| 799k| emitter->scalar_data.flow_plain_allowed = 1; 1654| 799k| emitter->scalar_data.block_plain_allowed = 1; 1655| 799k| emitter->scalar_data.single_quoted_allowed = 1; 1656| 799k| emitter->scalar_data.block_allowed = 1; 1657| | 1658| 799k| if (leading_space || leading_break || trailing_space || trailing_break) { ------------------ | Branch (1658:9): [True: 1.33k, False: 798k] | Branch (1658:26): [True: 14.8k, False: 783k] | Branch (1658:43): [True: 2.50k, False: 780k] | Branch (1658:61): [True: 2.86k, False: 777k] ------------------ 1659| 21.5k| emitter->scalar_data.flow_plain_allowed = 0; 1660| 21.5k| emitter->scalar_data.block_plain_allowed = 0; 1661| 21.5k| } 1662| | 1663| 799k| if (trailing_space) { ------------------ | Branch (1663:9): [True: 3.51k, False: 795k] ------------------ 1664| 3.51k| emitter->scalar_data.block_allowed = 0; 1665| 3.51k| } 1666| | 1667| 799k| if (break_space) { ------------------ | Branch (1667:9): [True: 641, False: 798k] ------------------ 1668| 641| emitter->scalar_data.flow_plain_allowed = 0; 1669| 641| emitter->scalar_data.block_plain_allowed = 0; 1670| 641| emitter->scalar_data.single_quoted_allowed = 0; 1671| 641| } 1672| | 1673| 799k| if (space_break || special_characters) { ------------------ | Branch (1673:9): [True: 363, False: 799k] | Branch (1673:24): [True: 11.6k, False: 787k] ------------------ 1674| 11.9k| emitter->scalar_data.flow_plain_allowed = 0; 1675| 11.9k| emitter->scalar_data.block_plain_allowed = 0; 1676| 11.9k| emitter->scalar_data.single_quoted_allowed = 0; 1677| 11.9k| emitter->scalar_data.block_allowed = 0; 1678| 11.9k| } 1679| | 1680| 799k| if (line_breaks) { ------------------ | Branch (1680:9): [True: 21.1k, False: 778k] ------------------ 1681| 21.1k| emitter->scalar_data.flow_plain_allowed = 0; 1682| 21.1k| emitter->scalar_data.block_plain_allowed = 0; 1683| 21.1k| } 1684| | 1685| 799k| if (flow_indicators) { ------------------ | Branch (1685:9): [True: 403k, False: 396k] ------------------ 1686| 403k| emitter->scalar_data.flow_plain_allowed = 0; 1687| 403k| } 1688| | 1689| 799k| if (block_indicators) { ------------------ | Branch (1689:9): [True: 308k, False: 490k] ------------------ 1690| 308k| emitter->scalar_data.block_plain_allowed = 0; 1691| 308k| } 1692| | 1693| 799k| return 1; 1694| 3.53M|} yaml_parser_load: 88| 68.3k|{ 89| 68.3k| yaml_event_t event; 90| | 91| 68.3k| assert(parser); /* Non-NULL parser object is expected. */ ------------------ | Branch (91:5): [True: 0, False: 68.3k] | Branch (91:5): [True: 68.3k, False: 0] ------------------ 92| 68.3k| assert(document); /* Non-NULL document object is expected. */ ------------------ | Branch (92:5): [True: 0, False: 68.3k] | Branch (92:5): [True: 68.3k, False: 0] ------------------ 93| | 94| 68.3k| memset(document, 0, sizeof(yaml_document_t)); 95| 68.3k| if (!STACK_INIT(parser, document->nodes, yaml_node_t*)) ------------------ | | 424| 68.3k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 68.3k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 68.3k, False: 0] | | ------------------ | | 425| 68.3k| ((stack).top = (stack).start, \ | | 426| 68.3k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 68.3k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 68.3k| 1) : \ | | 428| 68.3k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (95:9): [True: 0, False: 68.3k] ------------------ 96| 0| goto error; 97| | 98| 68.3k| if (!parser->stream_start_produced) { ------------------ | Branch (98:9): [True: 10.9k, False: 57.4k] ------------------ 99| 10.9k| if (!yaml_parser_parse(parser, &event)) goto error; ------------------ | Branch (99:13): [True: 144, False: 10.8k] ------------------ 100| 10.9k| assert(event.type == YAML_STREAM_START_EVENT); ------------------ | Branch (100:9): [True: 0, False: 10.8k] | Branch (100:9): [True: 10.8k, False: 0] ------------------ 101| | /* STREAM-START is expected. */ 102| 10.8k| } 103| | 104| 68.2k| if (parser->stream_end_produced) { ------------------ | Branch (104:9): [True: 0, False: 68.2k] ------------------ 105| 0| return 1; 106| 0| } 107| | 108| 68.2k| if (!yaml_parser_parse(parser, &event)) goto error; ------------------ | Branch (108:9): [True: 2.32k, False: 65.8k] ------------------ 109| 65.8k| if (event.type == YAML_STREAM_END_EVENT) { ------------------ | Branch (109:9): [True: 1.64k, False: 64.2k] ------------------ 110| 1.64k| return 1; 111| 1.64k| } 112| | 113| 64.2k| if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*)) ------------------ | | 424| 64.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 64.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 64.2k, False: 0] | | ------------------ | | 425| 64.2k| ((stack).top = (stack).start, \ | | 426| 64.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 64.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 64.2k| 1) : \ | | 428| 64.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (113:9): [True: 0, False: 64.2k] ------------------ 114| 0| goto error; 115| | 116| 64.2k| parser->document = document; 117| | 118| 64.2k| if (!yaml_parser_load_document(parser, &event)) goto error; ------------------ | Branch (118:9): [True: 1.92k, False: 62.3k] ------------------ 119| | 120| 62.3k| yaml_parser_delete_aliases(parser); 121| 62.3k| parser->document = NULL; 122| | 123| 62.3k| return 1; 124| | 125| 4.39k|error: 126| | 127| 4.39k| yaml_parser_delete_aliases(parser); 128| 4.39k| yaml_document_delete(document); 129| 4.39k| parser->document = NULL; 130| | 131| 4.39k| return 0; 132| 64.2k|} loader.c:yaml_parser_delete_aliases: 173| 66.7k|{ 174| 73.4k| while (!STACK_EMPTY(parser, parser->aliases)) { ------------------ | | 436| 73.4k| ((stack).start == (stack).top) ------------------ | Branch (174:12): [True: 6.68k, False: 66.7k] ------------------ 175| 6.68k| yaml_free(POP(parser, parser->aliases).anchor); ------------------ | | 454| 6.68k| (*(--(stack).top)) ------------------ 176| 6.68k| } 177| 66.7k| STACK_DEL(parser, parser->aliases); ------------------ | | 432| 66.7k| (yaml_free((stack).start), \ | | 433| 66.7k| (stack).start = (stack).top = (stack).end = 0) ------------------ 178| 66.7k|} loader.c:yaml_parser_load_document: 186| 64.2k|{ 187| 64.2k| struct loader_ctx ctx = { NULL, NULL, NULL }; 188| | 189| 64.2k| assert(event->type == YAML_DOCUMENT_START_EVENT); ------------------ | Branch (189:5): [True: 0, False: 64.2k] | Branch (189:5): [True: 64.2k, False: 0] ------------------ 190| | /* DOCUMENT-START is expected. */ 191| | 192| 64.2k| parser->document->version_directive 193| 64.2k| = event->data.document_start.version_directive; 194| 64.2k| parser->document->tag_directives.start 195| 64.2k| = event->data.document_start.tag_directives.start; 196| 64.2k| parser->document->tag_directives.end 197| 64.2k| = event->data.document_start.tag_directives.end; 198| 64.2k| parser->document->start_implicit 199| 64.2k| = event->data.document_start.implicit; 200| 64.2k| parser->document->start_mark = event->start_mark; 201| | 202| 64.2k| if (!STACK_INIT(parser, ctx, int*)) return 0; ------------------ | | 424| 64.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 64.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 64.2k, False: 0] | | ------------------ | | 425| 64.2k| ((stack).top = (stack).start, \ | | 426| 64.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 64.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 64.2k| 1) : \ | | 428| 64.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (202:9): [True: 0, False: 64.2k] ------------------ 203| 64.2k| if (!yaml_parser_load_nodes(parser, &ctx)) { ------------------ | Branch (203:9): [True: 1.92k, False: 62.3k] ------------------ 204| 1.92k| STACK_DEL(parser, ctx); ------------------ | | 432| 1.92k| (yaml_free((stack).start), \ | | 433| 1.92k| (stack).start = (stack).top = (stack).end = 0) ------------------ 205| 1.92k| return 0; 206| 1.92k| } 207| 62.3k| STACK_DEL(parser, ctx); ------------------ | | 432| 62.3k| (yaml_free((stack).start), \ | | 433| 62.3k| (stack).start = (stack).top = (stack).end = 0) ------------------ 208| | 209| 62.3k| return 1; 210| 64.2k|} loader.c:yaml_parser_load_nodes: 218| 64.2k|{ 219| 64.2k| yaml_event_t event; 220| | 221| 13.3M| do { 222| 13.3M| if (!yaml_parser_parse(parser, &event)) return 0; ------------------ | Branch (222:13): [True: 1.71k, False: 13.3M] ------------------ 223| | 224| 13.3M| switch (event.type) { 225| 143k| case YAML_ALIAS_EVENT: ------------------ | Branch (225:13): [True: 143k, False: 13.1M] ------------------ 226| 143k| if (!yaml_parser_load_alias(parser, &event, ctx)) return 0; ------------------ | Branch (226:21): [True: 188, False: 143k] ------------------ 227| 143k| break; 228| 8.19M| case YAML_SCALAR_EVENT: ------------------ | Branch (228:13): [True: 8.19M, False: 5.12M] ------------------ 229| 8.19M| if (!yaml_parser_load_scalar(parser, &event, ctx)) return 0; ------------------ | Branch (229:21): [True: 14, False: 8.19M] ------------------ 230| 8.19M| break; 231| 8.19M| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (231:13): [True: 141k, False: 13.1M] ------------------ 232| 141k| if (!yaml_parser_load_sequence(parser, &event, ctx)) return 0; ------------------ | Branch (232:21): [True: 1, False: 141k] ------------------ 233| 141k| break; 234| 141k| case YAML_SEQUENCE_END_EVENT: ------------------ | Branch (234:13): [True: 124k, False: 13.1M] ------------------ 235| 124k| if (!yaml_parser_load_sequence_end(parser, &event, ctx)) ------------------ | Branch (235:21): [True: 0, False: 124k] ------------------ 236| 0| return 0; 237| 124k| break; 238| 2.33M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (238:13): [True: 2.33M, False: 10.9M] ------------------ 239| 2.33M| if (!yaml_parser_load_mapping(parser, &event, ctx)) return 0; ------------------ | Branch (239:21): [True: 1, False: 2.33M] ------------------ 240| 2.33M| break; 241| 2.33M| case YAML_MAPPING_END_EVENT: ------------------ | Branch (241:13): [True: 2.31M, False: 11.0M] ------------------ 242| 2.31M| if (!yaml_parser_load_mapping_end(parser, &event, ctx)) ------------------ | Branch (242:21): [True: 0, False: 2.31M] ------------------ 243| 0| return 0; 244| 2.31M| break; 245| 2.31M| default: ------------------ | Branch (245:13): [True: 0, False: 13.3M] ------------------ 246| 0| assert(0); /* Could not happen. */ ------------------ | Branch (246:17): [Folded, False: 0] | Branch (246:17): [Folded, False: 0] ------------------ 247| 0| return 0; 248| 62.3k| case YAML_DOCUMENT_END_EVENT: ------------------ | Branch (248:13): [True: 62.3k, False: 13.2M] ------------------ 249| 62.3k| break; 250| 13.3M| } 251| 13.3M| } while (event.type != YAML_DOCUMENT_END_EVENT); ------------------ | Branch (251:14): [True: 13.2M, False: 62.3k] ------------------ 252| | 253| 62.3k| parser->document->end_implicit = event.data.document_end.implicit; 254| 62.3k| parser->document->end_mark = event.end_mark; 255| | 256| 62.3k| return 1; 257| 64.2k|} loader.c:yaml_parser_load_alias: 353| 143k|{ 354| 143k| yaml_char_t *anchor = event->data.alias.anchor; 355| 143k| yaml_alias_data_t *alias_data; 356| | 357| 143k| for (alias_data = parser->aliases.start; 358| 143k| alias_data != parser->aliases.top; alias_data ++) { ------------------ | Branch (358:13): [True: 143k, False: 188] ------------------ 359| 143k| if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) { ------------------ | Branch (359:13): [True: 143k, False: 445] ------------------ 360| 143k| yaml_free(anchor); 361| 143k| return yaml_parser_load_node_add(parser, ctx, alias_data->index); 362| 143k| } 363| 143k| } 364| | 365| 188| yaml_free(anchor); 366| 188| return yaml_parser_set_composer_error(parser, "found undefined alias", 367| 188| event->start_mark); 368| 143k|} loader.c:yaml_parser_load_node_add: 301| 10.8M|{ 302| 10.8M| struct yaml_node_s *parent; 303| 10.8M| int parent_index; 304| | 305| 10.8M| if (STACK_EMPTY(parser, *ctx)) { ------------------ | | 436| 10.8M| ((stack).start == (stack).top) | | ------------------ | | | Branch (436:5): [True: 64.0k, False: 10.7M] | | ------------------ ------------------ 306| | /* This is the root node, there's no tree to add it to. */ 307| 64.0k| return 1; 308| 64.0k| } 309| | 310| 10.7M| parent_index = *((*ctx).top - 1); 311| 10.7M| parent = &parser->document->nodes.start[parent_index-1]; 312| | 313| 10.7M| switch (parent->type) { 314| 1.76M| case YAML_SEQUENCE_NODE: ------------------ | Branch (314:9): [True: 1.76M, False: 8.99M] ------------------ 315| 1.76M| if (!STACK_LIMIT(parser, parent->data.sequence.items, INT_MAX-1)) ------------------ | | 439| 1.76M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 1.76M, False: 0] | | ------------------ | | 440| 1.76M| 1 : \ | | 441| 1.76M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (315:17): [True: 0, False: 1.76M] ------------------ 316| 0| return 0; 317| 1.76M| if (!PUSH(parser, parent->data.sequence.items, index)) ------------------ | | 445| 1.76M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.74M, False: 17.3k] | | ------------------ | | 446| 1.76M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 17.3k, False: 0] | | ------------------ | | 447| 17.3k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.76M| (*((stack).top++) = value, \ | | 449| 1.76M| 1) : \ | | 450| 1.76M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (317:17): [True: 0, False: 1.76M] ------------------ 318| 0| return 0; 319| 1.76M| break; 320| 8.99M| case YAML_MAPPING_NODE: { ------------------ | Branch (320:9): [True: 8.99M, False: 1.76M] ------------------ 321| 8.99M| yaml_node_pair_t pair; 322| 8.99M| if (!STACK_EMPTY(parser, parent->data.mapping.pairs)) { ------------------ | | 436| 8.99M| ((stack).start == (stack).top) ------------------ | Branch (322:17): [True: 6.65M, False: 2.33M] ------------------ 323| 6.65M| yaml_node_pair_t *p = parent->data.mapping.pairs.top - 1; 324| 6.65M| if (p->key != 0 && p->value == 0) { ------------------ | Branch (324:21): [True: 6.65M, False: 0] | Branch (324:36): [True: 4.48M, False: 2.16M] ------------------ 325| 4.48M| p->value = index; 326| 4.48M| break; 327| 4.48M| } 328| 6.65M| } 329| | 330| 4.50M| pair.key = index; 331| 4.50M| pair.value = 0; 332| 4.50M| if (!STACK_LIMIT(parser, parent->data.mapping.pairs, INT_MAX-1)) ------------------ | | 439| 4.50M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 4.50M, False: 0] | | ------------------ | | 440| 4.50M| 1 : \ | | 441| 4.50M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (332:17): [True: 0, False: 4.50M] ------------------ 333| 0| return 0; 334| 4.50M| if (!PUSH(parser, parent->data.mapping.pairs, pair)) ------------------ | | 445| 4.50M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 4.50M, False: 1.72k] | | ------------------ | | 446| 4.50M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.72k, False: 0] | | ------------------ | | 447| 1.72k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 4.50M| (*((stack).top++) = value, \ | | 449| 4.50M| 1) : \ | | 450| 4.50M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (334:17): [True: 0, False: 4.50M] ------------------ 335| 0| return 0; 336| | 337| 4.50M| break; 338| 4.50M| } 339| 4.50M| default: ------------------ | Branch (339:9): [True: 0, False: 10.7M] ------------------ 340| 0| assert(0); /* Could not happen. */ ------------------ | Branch (340:13): [Folded, False: 0] | Branch (340:13): [Folded, False: 0] ------------------ 341| 0| return 0; 342| 10.7M| } 343| 10.7M| return 1; 344| 10.7M|} loader.c:yaml_parser_set_composer_error: 141| 188|{ 142| 188| parser->error = YAML_COMPOSER_ERROR; 143| 188| parser->problem = problem; 144| 188| parser->problem_mark = problem_mark; 145| | 146| 188| return 0; 147| 188|} loader.c:yaml_parser_load_scalar: 377| 8.19M|{ 378| 8.19M| yaml_node_t node; 379| 8.19M| int index; 380| 8.19M| yaml_char_t *tag = event->data.scalar.tag; 381| | 382| 8.19M| if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; ------------------ | | 439| 8.19M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 8.19M, False: 0] | | ------------------ | | 440| 8.19M| 1 : \ | | 441| 8.19M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (382:9): [True: 0, False: 8.19M] ------------------ 383| | 384| 8.19M| if (!tag || strcmp((char *)tag, "!") == 0) { ------------------ | Branch (384:9): [True: 8.18M, False: 6.87k] | Branch (384:17): [True: 2.27k, False: 4.59k] ------------------ 385| 8.18M| yaml_free(tag); 386| 8.18M| tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG); ------------------ | | 685| 8.18M|#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG | | ------------------ | | | | 671| 8.18M|#define YAML_STR_TAG "tag:yaml.org,2002:str" | | ------------------ ------------------ 387| 8.18M| if (!tag) goto error; ------------------ | Branch (387:13): [True: 0, False: 8.18M] ------------------ 388| 8.18M| } 389| | 390| 8.19M| SCALAR_NODE_INIT(node, tag, event->data.scalar.value, ------------------ | | 640| 8.19M| (NODE_INIT((node),YAML_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \ | | ------------------ | | | | 632| 8.19M| (memset(&(node), 0, sizeof(yaml_node_t)), \ | | | | 633| 8.19M| (node).type = (node_type), \ | | | | 634| 8.19M| (node).tag = (node_tag), \ | | | | 635| 8.19M| (node).start_mark = (node_start_mark), \ | | | | 636| 8.19M| (node).end_mark = (node_end_mark)) | | ------------------ | | 641| 8.19M| (node).data.scalar.value = (node_value), \ | | 642| 8.19M| (node).data.scalar.length = (node_length), \ | | 643| 8.19M| (node).data.scalar.style = (node_style)) ------------------ 391| 8.19M| event->data.scalar.length, event->data.scalar.style, 392| 8.19M| event->start_mark, event->end_mark); 393| | 394| 8.19M| if (!PUSH(parser, parser->document->nodes, node)) goto error; ------------------ | | 445| 8.19M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 8.16M, False: 26.0k] | | ------------------ | | 446| 8.19M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 26.0k, False: 0] | | ------------------ | | 447| 26.0k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 8.19M| (*((stack).top++) = value, \ | | 449| 8.19M| 1) : \ | | 450| 8.19M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (394:9): [True: 0, False: 8.19M] ------------------ 395| | 396| 8.19M| index = parser->document->nodes.top - parser->document->nodes.start; 397| | 398| 8.19M| if (!yaml_parser_register_anchor(parser, index, ------------------ | Branch (398:9): [True: 14, False: 8.19M] ------------------ 399| 8.19M| event->data.scalar.anchor)) return 0; 400| | 401| 8.19M| return yaml_parser_load_node_add(parser, ctx, index); 402| | 403| 0|error: 404| 0| yaml_free(tag); 405| 0| yaml_free(event->data.scalar.anchor); 406| 0| yaml_free(event->data.scalar.value); 407| 0| return 0; 408| 8.19M|} loader.c:yaml_parser_register_anchor: 266| 10.6M|{ 267| 10.6M| yaml_alias_data_t data; 268| 10.6M| yaml_alias_data_t *alias_data; 269| | 270| 10.6M| if (!anchor) return 1; ------------------ | Branch (270:9): [True: 10.6M, False: 6.69k] ------------------ 271| | 272| 6.69k| data.anchor = anchor; 273| 6.69k| data.index = index; 274| 6.69k| data.mark = parser->document->nodes.start[index-1].start_mark; 275| | 276| 6.69k| for (alias_data = parser->aliases.start; 277| 7.99k| alias_data != parser->aliases.top; alias_data ++) { ------------------ | Branch (277:13): [True: 1.30k, False: 6.68k] ------------------ 278| 1.30k| if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) { ------------------ | Branch (278:13): [True: 16, False: 1.29k] ------------------ 279| 16| yaml_free(anchor); 280| 16| return yaml_parser_set_composer_error_context(parser, 281| 16| "found duplicate anchor; first occurrence", 282| 16| alias_data->mark, "second occurrence", data.mark); 283| 16| } 284| 1.30k| } 285| | 286| 6.68k| if (!PUSH(parser, parser->aliases, data)) { ------------------ | | 445| 6.68k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 6.68k, False: 3] | | ------------------ | | 446| 6.68k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 3, False: 0] | | ------------------ | | 447| 3| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 6.68k| (*((stack).top++) = value, \ | | 449| 6.68k| 1) : \ | | 450| 6.68k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (286:9): [True: 0, False: 6.68k] ------------------ 287| 0| yaml_free(anchor); 288| 0| return 0; 289| 0| } 290| | 291| 6.68k| return 1; 292| 6.68k|} loader.c:yaml_parser_set_composer_error_context: 157| 16|{ 158| 16| parser->error = YAML_COMPOSER_ERROR; 159| 16| parser->context = context; 160| 16| parser->context_mark = context_mark; 161| 16| parser->problem = problem; 162| 16| parser->problem_mark = problem_mark; 163| | 164| 16| return 0; 165| 16|} loader.c:yaml_parser_load_sequence: 417| 141k|{ 418| 141k| yaml_node_t node; 419| 141k| struct { 420| 141k| yaml_node_item_t *start; 421| 141k| yaml_node_item_t *end; 422| 141k| yaml_node_item_t *top; 423| 141k| } items = { NULL, NULL, NULL }; 424| 141k| int index; 425| 141k| yaml_char_t *tag = event->data.sequence_start.tag; 426| | 427| 141k| if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; ------------------ | | 439| 141k| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 141k, False: 0] | | ------------------ | | 440| 141k| 1 : \ | | 441| 141k| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (427:9): [True: 0, False: 141k] ------------------ 428| | 429| 141k| if (!tag || strcmp((char *)tag, "!") == 0) { ------------------ | Branch (429:9): [True: 138k, False: 3.00k] | Branch (429:17): [True: 450, False: 2.55k] ------------------ 430| 138k| yaml_free(tag); 431| 138k| tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG); ------------------ | | 687| 138k|#define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG | | ------------------ | | | | 680| 138k|#define YAML_SEQ_TAG "tag:yaml.org,2002:seq" | | ------------------ ------------------ 432| 138k| if (!tag) goto error; ------------------ | Branch (432:13): [True: 0, False: 138k] ------------------ 433| 138k| } 434| | 435| 141k| if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error; ------------------ | | 424| 141k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 141k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 141k, False: 0] | | ------------------ | | 425| 141k| ((stack).top = (stack).start, \ | | 426| 141k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 141k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 141k| 1) : \ | | 428| 141k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (435:9): [True: 0, False: 141k] ------------------ 436| | 437| 141k| SEQUENCE_NODE_INIT(node, tag, items.start, items.end, ------------------ | | 647| 141k| (NODE_INIT((node),YAML_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \ | | ------------------ | | | | 632| 141k| (memset(&(node), 0, sizeof(yaml_node_t)), \ | | | | 633| 141k| (node).type = (node_type), \ | | | | 634| 141k| (node).tag = (node_tag), \ | | | | 635| 141k| (node).start_mark = (node_start_mark), \ | | | | 636| 141k| (node).end_mark = (node_end_mark)) | | ------------------ | | 648| 141k| (node).data.sequence.items.start = (node_items_start), \ | | 649| 141k| (node).data.sequence.items.end = (node_items_end), \ | | 650| 141k| (node).data.sequence.items.top = (node_items_start), \ | | 651| 141k| (node).data.sequence.style = (node_style)) ------------------ 438| 141k| event->data.sequence_start.style, 439| 141k| event->start_mark, event->end_mark); 440| | 441| 141k| if (!PUSH(parser, parser->document->nodes, node)) goto error; ------------------ | | 445| 141k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 139k, False: 1.98k] | | ------------------ | | 446| 141k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.98k, False: 0] | | ------------------ | | 447| 1.98k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 141k| (*((stack).top++) = value, \ | | 449| 141k| 1) : \ | | 450| 141k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (441:9): [True: 0, False: 141k] ------------------ 442| | 443| 141k| index = parser->document->nodes.top - parser->document->nodes.start; 444| | 445| 141k| if (!yaml_parser_register_anchor(parser, index, ------------------ | Branch (445:9): [True: 1, False: 141k] ------------------ 446| 141k| event->data.sequence_start.anchor)) return 0; 447| | 448| 141k| if (!yaml_parser_load_node_add(parser, ctx, index)) return 0; ------------------ | Branch (448:9): [True: 0, False: 141k] ------------------ 449| | 450| 141k| if (!STACK_LIMIT(parser, *ctx, INT_MAX-1)) return 0; ------------------ | | 439| 141k| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 141k, False: 0] | | ------------------ | | 440| 141k| 1 : \ | | 441| 141k| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (450:9): [True: 0, False: 141k] ------------------ 451| 141k| if (!PUSH(parser, *ctx, index)) return 0; ------------------ | | 445| 141k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 139k, False: 1.93k] | | ------------------ | | 446| 141k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.93k, False: 0] | | ------------------ | | 447| 1.93k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 141k| (*((stack).top++) = value, \ | | 449| 141k| 1) : \ | | 450| 141k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (451:9): [True: 0, False: 141k] ------------------ 452| | 453| 141k| return 1; 454| | 455| 0|error: 456| 0| yaml_free(tag); 457| 0| yaml_free(event->data.sequence_start.anchor); 458| 0| return 0; 459| 141k|} loader.c:yaml_parser_load_sequence_end: 464| 124k|{ 465| 124k| int index; 466| | 467| 124k| assert(((*ctx).top - (*ctx).start) > 0); ------------------ | Branch (467:5): [True: 0, False: 124k] | Branch (467:5): [True: 124k, False: 0] ------------------ 468| | 469| 124k| index = *((*ctx).top - 1); 470| 124k| assert(parser->document->nodes.start[index-1].type == YAML_SEQUENCE_NODE); ------------------ | Branch (470:5): [True: 0, False: 124k] | Branch (470:5): [True: 124k, False: 0] ------------------ 471| 124k| parser->document->nodes.start[index-1].end_mark = event->end_mark; 472| | 473| 124k| (void)POP(parser, *ctx); ------------------ | | 454| 124k| (*(--(stack).top)) ------------------ 474| | 475| 124k| return 1; 476| 124k|} loader.c:yaml_parser_load_mapping: 485| 2.33M|{ 486| 2.33M| yaml_node_t node; 487| 2.33M| struct { 488| 2.33M| yaml_node_pair_t *start; 489| 2.33M| yaml_node_pair_t *end; 490| 2.33M| yaml_node_pair_t *top; 491| 2.33M| } pairs = { NULL, NULL, NULL }; 492| 2.33M| int index; 493| 2.33M| yaml_char_t *tag = event->data.mapping_start.tag; 494| | 495| 2.33M| if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; ------------------ | | 439| 2.33M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 2.33M, False: 0] | | ------------------ | | 440| 2.33M| 1 : \ | | 441| 2.33M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (495:9): [True: 0, False: 2.33M] ------------------ 496| | 497| 2.33M| if (!tag || strcmp((char *)tag, "!") == 0) { ------------------ | Branch (497:9): [True: 2.33M, False: 1.42k] | Branch (497:17): [True: 637, False: 792] ------------------ 498| 2.33M| yaml_free(tag); 499| 2.33M| tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG); ------------------ | | 689| 2.33M|#define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG | | ------------------ | | | | 682| 2.33M|#define YAML_MAP_TAG "tag:yaml.org,2002:map" | | ------------------ ------------------ 500| 2.33M| if (!tag) goto error; ------------------ | Branch (500:13): [True: 0, False: 2.33M] ------------------ 501| 2.33M| } 502| | 503| 2.33M| if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error; ------------------ | | 424| 2.33M| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 2.33M|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 2.33M, False: 0] | | ------------------ | | 425| 2.33M| ((stack).top = (stack).start, \ | | 426| 2.33M| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 2.33M|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 2.33M| 1) : \ | | 428| 2.33M| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (503:9): [True: 0, False: 2.33M] ------------------ 504| | 505| 2.33M| MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end, ------------------ | | 655| 2.33M| (NODE_INIT((node),YAML_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \ | | ------------------ | | | | 632| 2.33M| (memset(&(node), 0, sizeof(yaml_node_t)), \ | | | | 633| 2.33M| (node).type = (node_type), \ | | | | 634| 2.33M| (node).tag = (node_tag), \ | | | | 635| 2.33M| (node).start_mark = (node_start_mark), \ | | | | 636| 2.33M| (node).end_mark = (node_end_mark)) | | ------------------ | | 656| 2.33M| (node).data.mapping.pairs.start = (node_pairs_start), \ | | 657| 2.33M| (node).data.mapping.pairs.end = (node_pairs_end), \ | | 658| 2.33M| (node).data.mapping.pairs.top = (node_pairs_start), \ | | 659| 2.33M| (node).data.mapping.style = (node_style)) ------------------ 506| 2.33M| event->data.mapping_start.style, 507| 2.33M| event->start_mark, event->end_mark); 508| | 509| 2.33M| if (!PUSH(parser, parser->document->nodes, node)) goto error; ------------------ | | 445| 2.33M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.30M, False: 38.1k] | | ------------------ | | 446| 2.33M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 38.1k, False: 0] | | ------------------ | | 447| 38.1k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.33M| (*((stack).top++) = value, \ | | 449| 2.33M| 1) : \ | | 450| 2.33M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (509:9): [True: 0, False: 2.33M] ------------------ 510| | 511| 2.33M| index = parser->document->nodes.top - parser->document->nodes.start; 512| | 513| 2.33M| if (!yaml_parser_register_anchor(parser, index, ------------------ | Branch (513:9): [True: 1, False: 2.33M] ------------------ 514| 2.33M| event->data.mapping_start.anchor)) return 0; 515| | 516| 2.33M| if (!yaml_parser_load_node_add(parser, ctx, index)) return 0; ------------------ | Branch (516:9): [True: 0, False: 2.33M] ------------------ 517| | 518| 2.33M| if (!STACK_LIMIT(parser, *ctx, INT_MAX-1)) return 0; ------------------ | | 439| 2.33M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 2.33M, False: 0] | | ------------------ | | 440| 2.33M| 1 : \ | | 441| 2.33M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (518:9): [True: 0, False: 2.33M] ------------------ 519| 2.33M| if (!PUSH(parser, *ctx, index)) return 0; ------------------ | | 445| 2.33M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.30M, False: 34.1k] | | ------------------ | | 446| 2.33M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 34.1k, False: 0] | | ------------------ | | 447| 34.1k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.33M| (*((stack).top++) = value, \ | | 449| 2.33M| 1) : \ | | 450| 2.33M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (519:9): [True: 0, False: 2.33M] ------------------ 520| | 521| 2.33M| return 1; 522| | 523| 0|error: 524| 0| yaml_free(tag); 525| 0| yaml_free(event->data.mapping_start.anchor); 526| 0| return 0; 527| 2.33M|} loader.c:yaml_parser_load_mapping_end: 532| 2.31M|{ 533| 2.31M| int index; 534| | 535| 2.31M| assert(((*ctx).top - (*ctx).start) > 0); ------------------ | Branch (535:5): [True: 0, False: 2.31M] | Branch (535:5): [True: 2.31M, False: 0] ------------------ 536| | 537| 2.31M| index = *((*ctx).top - 1); 538| 2.31M| assert(parser->document->nodes.start[index-1].type == YAML_MAPPING_NODE); ------------------ | Branch (538:5): [True: 0, False: 2.31M] | Branch (538:5): [True: 2.31M, False: 0] ------------------ 539| 2.31M| parser->document->nodes.start[index-1].end_mark = event->end_mark; 540| | 541| 2.31M| (void)POP(parser, *ctx); ------------------ | | 454| 2.31M| (*(--(stack).top)) ------------------ 542| | 543| 2.31M| return 1; 544| 2.31M|} yaml_parser_parse: 179| 13.4M|{ 180| 13.4M| assert(parser); /* Non-NULL parser object is expected. */ ------------------ | Branch (180:5): [True: 0, False: 13.4M] | Branch (180:5): [True: 13.4M, False: 0] ------------------ 181| 13.4M| assert(event); /* Non-NULL event object is expected. */ ------------------ | Branch (181:5): [True: 0, False: 13.4M] | Branch (181:5): [True: 13.4M, False: 0] ------------------ 182| | 183| | /* Erase the event object. */ 184| | 185| 13.4M| memset(event, 0, sizeof(yaml_event_t)); 186| | 187| | /* No events after the end of the stream or error. */ 188| | 189| 13.4M| if (parser->stream_end_produced || parser->error || ------------------ | Branch (189:9): [True: 0, False: 13.4M] | Branch (189:40): [True: 0, False: 13.4M] ------------------ 190| 13.4M| parser->state == YAML_PARSE_END_STATE) { ------------------ | Branch (190:13): [True: 0, False: 13.4M] ------------------ 191| 0| return 1; 192| 0| } 193| | 194| | /* Generate the next event. */ 195| | 196| 13.4M| return yaml_parser_state_machine(parser, event); 197| 13.4M|} parser.c:yaml_parser_state_machine: 234| 13.4M|{ 235| 13.4M| switch (parser->state) 236| 13.4M| { 237| 10.9k| case YAML_PARSE_STREAM_START_STATE: ------------------ | Branch (237:9): [True: 10.9k, False: 13.3M] ------------------ 238| 10.9k| return yaml_parser_parse_stream_start(parser, event); 239| | 240| 10.8k| case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE: ------------------ | Branch (240:9): [True: 10.8k, False: 13.3M] ------------------ 241| 10.8k| return yaml_parser_parse_document_start(parser, event, 1); 242| | 243| 57.4k| case YAML_PARSE_DOCUMENT_START_STATE: ------------------ | Branch (243:9): [True: 57.4k, False: 13.3M] ------------------ 244| 57.4k| return yaml_parser_parse_document_start(parser, event, 0); 245| | 246| 56.1k| case YAML_PARSE_DOCUMENT_CONTENT_STATE: ------------------ | Branch (246:9): [True: 56.1k, False: 13.3M] ------------------ 247| 56.1k| return yaml_parser_parse_document_content(parser, event); 248| | 249| 62.3k| case YAML_PARSE_DOCUMENT_END_STATE: ------------------ | Branch (249:9): [True: 62.3k, False: 13.3M] ------------------ 250| 62.3k| return yaml_parser_parse_document_end(parser, event); 251| | 252| 8.13k| case YAML_PARSE_BLOCK_NODE_STATE: ------------------ | Branch (252:9): [True: 8.13k, False: 13.3M] ------------------ 253| 8.13k| return yaml_parser_parse_node(parser, event, 1, 0); 254| | 255| 0| case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: ------------------ | Branch (255:9): [True: 0, False: 13.4M] ------------------ 256| 0| return yaml_parser_parse_node(parser, event, 1, 1); 257| | 258| 0| case YAML_PARSE_FLOW_NODE_STATE: ------------------ | Branch (258:9): [True: 0, False: 13.4M] ------------------ 259| 0| return yaml_parser_parse_node(parser, event, 0, 0); 260| | 261| 45.2k| case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: ------------------ | Branch (261:9): [True: 45.2k, False: 13.3M] ------------------ 262| 45.2k| return yaml_parser_parse_block_sequence_entry(parser, event, 1); 263| | 264| 48.3k| case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: ------------------ | Branch (264:9): [True: 48.3k, False: 13.3M] ------------------ 265| 48.3k| return yaml_parser_parse_block_sequence_entry(parser, event, 0); 266| | 267| 577k| case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: ------------------ | Branch (267:9): [True: 577k, False: 12.8M] ------------------ 268| 577k| return yaml_parser_parse_indentless_sequence_entry(parser, event); 269| | 270| 2.28M| case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (270:9): [True: 2.28M, False: 11.1M] ------------------ 271| 2.28M| return yaml_parser_parse_block_mapping_key(parser, event, 1); 272| | 273| 2.53M| case YAML_PARSE_BLOCK_MAPPING_KEY_STATE: ------------------ | Branch (273:9): [True: 2.53M, False: 10.8M] ------------------ 274| 2.53M| return yaml_parser_parse_block_mapping_key(parser, event, 0); 275| | 276| 2.53M| case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE: ------------------ | Branch (276:9): [True: 2.53M, False: 10.8M] ------------------ 277| 2.53M| return yaml_parser_parse_block_mapping_value(parser, event); 278| | 279| 47.2k| case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: ------------------ | Branch (279:9): [True: 47.2k, False: 13.3M] ------------------ 280| 47.2k| return yaml_parser_parse_flow_sequence_entry(parser, event, 1); 281| | 282| 1.16M| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE: ------------------ | Branch (282:9): [True: 1.16M, False: 12.2M] ------------------ 283| 1.16M| return yaml_parser_parse_flow_sequence_entry(parser, event, 0); 284| | 285| 36.1k| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: ------------------ | Branch (285:9): [True: 36.1k, False: 13.3M] ------------------ 286| 36.1k| return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event); 287| | 288| 34.6k| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: ------------------ | Branch (288:9): [True: 34.6k, False: 13.3M] ------------------ 289| 34.6k| return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event); 290| | 291| 33.0k| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: ------------------ | Branch (291:9): [True: 33.0k, False: 13.3M] ------------------ 292| 33.0k| return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event); 293| | 294| 14.5k| case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (294:9): [True: 14.5k, False: 13.3M] ------------------ 295| 14.5k| return yaml_parser_parse_flow_mapping_key(parser, event, 1); 296| | 297| 1.91M| case YAML_PARSE_FLOW_MAPPING_KEY_STATE: ------------------ | Branch (297:9): [True: 1.91M, False: 11.4M] ------------------ 298| 1.91M| return yaml_parser_parse_flow_mapping_key(parser, event, 0); 299| | 300| 2.07k| case YAML_PARSE_FLOW_MAPPING_VALUE_STATE: ------------------ | Branch (300:9): [True: 2.07k, False: 13.4M] ------------------ 301| 2.07k| return yaml_parser_parse_flow_mapping_value(parser, event, 0); 302| | 303| 1.91M| case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: ------------------ | Branch (303:9): [True: 1.91M, False: 11.4M] ------------------ 304| 1.91M| return yaml_parser_parse_flow_mapping_value(parser, event, 1); 305| | 306| 0| default: ------------------ | Branch (306:9): [True: 0, False: 13.4M] ------------------ 307| 0| assert(1); /* Invalid state. */ ------------------ | Branch (307:13): [True: 0, Folded] | Branch (307:13): [True: 0, Folded] ------------------ 308| 13.4M| } 309| | 310| 0| return 0; 311| 13.4M|} parser.c:yaml_parser_parse_stream_start: 321| 10.9k|{ 322| 10.9k| yaml_token_t *token; 323| | 324| 10.9k| token = PEEK_TOKEN(parser); ------------------ | | 49| 10.9k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 10.9k] | | | Branch (49:34): [True: 10.8k, False: 144] | | ------------------ | | 50| 10.9k| parser->tokens.head : NULL) ------------------ 325| 10.9k| if (!token) return 0; ------------------ | Branch (325:9): [True: 144, False: 10.8k] ------------------ 326| | 327| 10.8k| if (token->type != YAML_STREAM_START_TOKEN) { ------------------ | Branch (327:9): [True: 0, False: 10.8k] ------------------ 328| 0| return yaml_parser_set_parser_error(parser, 329| 0| "did not find expected ", token->start_mark); 330| 0| } 331| | 332| 10.8k| parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE; 333| 10.8k| STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding, ------------------ | | 552| 10.8k| (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 10.8k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 10.8k| (event).type = (event_type), \ | | | | 548| 10.8k| (event).start_mark = (event_start_mark), \ | | | | 549| 10.8k| (event).end_mark = (event_end_mark)) | | ------------------ | | 553| 10.8k| (event).data.stream_start.encoding = (event_encoding)) ------------------ 334| 10.8k| token->start_mark, token->start_mark); 335| 10.8k| SKIP_TOKEN(parser); ------------------ | | 57| 10.8k| (parser->token_available = 0, \ | | 58| 10.8k| parser->tokens_parsed ++, \ | | 59| 10.8k| parser->stream_end_produced = \ | | 60| 10.8k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 10.8k| parser->tokens.head ++) ------------------ 336| | 337| 10.8k| return 1; 338| 10.8k|} parser.c:yaml_parser_set_parser_error: 206| 535|{ 207| 535| parser->error = YAML_PARSER_ERROR; 208| 535| parser->problem = problem; 209| 535| parser->problem_mark = problem_mark; 210| | 211| 535| return 0; 212| 535|} parser.c:yaml_parser_parse_document_start: 351| 68.2k|{ 352| 68.2k| yaml_token_t *token; 353| 68.2k| yaml_version_directive_t *version_directive = NULL; 354| 68.2k| struct { 355| 68.2k| yaml_tag_directive_t *start; 356| 68.2k| yaml_tag_directive_t *end; 357| 68.2k| } tag_directives = { NULL, NULL }; 358| | 359| 68.2k| token = PEEK_TOKEN(parser); ------------------ | | 49| 68.2k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 56.4k, False: 11.7k] | | | Branch (49:34): [True: 10.0k, False: 1.71k] | | ------------------ | | 50| 68.2k| parser->tokens.head : NULL) ------------------ 360| 68.2k| if (!token) return 0; ------------------ | Branch (360:9): [True: 1.71k, False: 66.5k] ------------------ 361| | 362| | /* Parse extra document end indicators. */ 363| | 364| 66.5k| if (!implicit) ------------------ | Branch (364:9): [True: 57.4k, False: 9.08k] ------------------ 365| 57.4k| { 366| 58.3k| while (token->type == YAML_DOCUMENT_END_TOKEN) { ------------------ | Branch (366:16): [True: 922, False: 57.4k] ------------------ 367| 922| SKIP_TOKEN(parser); ------------------ | | 57| 922| (parser->token_available = 0, \ | | 58| 922| parser->tokens_parsed ++, \ | | 59| 922| parser->stream_end_produced = \ | | 60| 922| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 922| parser->tokens.head ++) ------------------ 368| 922| token = PEEK_TOKEN(parser); ------------------ | | 49| 922| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 922] | | | Branch (49:34): [True: 919, False: 3] | | ------------------ | | 50| 922| parser->tokens.head : NULL) ------------------ 369| 922| if (!token) return 0; ------------------ | Branch (369:17): [True: 3, False: 919] ------------------ 370| 922| } 371| 57.4k| } 372| | 373| | /* Parse an implicit document. */ 374| | 375| 66.5k| if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN && ------------------ | Branch (375:9): [True: 9.08k, False: 57.4k] | Branch (375:21): [True: 8.98k, False: 104] ------------------ 376| 8.98k| token->type != YAML_TAG_DIRECTIVE_TOKEN && ------------------ | Branch (376:13): [True: 8.35k, False: 628] ------------------ 377| 8.35k| token->type != YAML_DOCUMENT_START_TOKEN && ------------------ | Branch (377:13): [True: 8.32k, False: 26] ------------------ 378| 8.32k| token->type != YAML_STREAM_END_TOKEN) ------------------ | Branch (378:13): [True: 8.13k, False: 188] ------------------ 379| 8.13k| { 380| 8.13k| if (!yaml_parser_process_directives(parser, NULL, NULL, NULL)) ------------------ | Branch (380:13): [True: 0, False: 8.13k] ------------------ 381| 0| return 0; 382| 8.13k| if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) ------------------ | | 445| 8.13k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 8.13k, False: 0] | | ------------------ | | 446| 8.13k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 8.13k| (*((stack).top++) = value, \ | | 449| 8.13k| 1) : \ | | 450| 8.13k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (382:13): [True: 0, False: 8.13k] ------------------ 383| 0| return 0; 384| 8.13k| parser->state = YAML_PARSE_BLOCK_NODE_STATE; 385| 8.13k| DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1, ------------------ | | 560| 8.13k| (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 8.13k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 8.13k| (event).type = (event_type), \ | | | | 548| 8.13k| (event).start_mark = (event_start_mark), \ | | | | 549| 8.13k| (event).end_mark = (event_end_mark)) | | ------------------ | | 561| 8.13k| (event).data.document_start.version_directive = (event_version_directive), \ | | 562| 8.13k| (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ | | 563| 8.13k| (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ | | 564| 8.13k| (event).data.document_start.implicit = (event_implicit)) ------------------ 386| 8.13k| token->start_mark, token->start_mark); 387| 8.13k| return 1; 388| 8.13k| } 389| | 390| | /* Parse an explicit document. */ 391| | 392| 58.3k| else if (token->type != YAML_STREAM_END_TOKEN) ------------------ | Branch (392:14): [True: 56.7k, False: 1.64k] ------------------ 393| 56.7k| { 394| 56.7k| yaml_mark_t start_mark, end_mark; 395| 56.7k| start_mark = token->start_mark; 396| 56.7k| if (!yaml_parser_process_directives(parser, &version_directive, ------------------ | Branch (396:13): [True: 228, False: 56.4k] ------------------ 397| 56.7k| &tag_directives.start, &tag_directives.end)) 398| 228| return 0; 399| 56.4k| token = PEEK_TOKEN(parser); ------------------ | | 49| 56.4k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 56.4k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 56.4k| parser->tokens.head : NULL) ------------------ 400| 56.4k| if (!token) goto error; ------------------ | Branch (400:13): [True: 0, False: 56.4k] ------------------ 401| 56.4k| if (token->type != YAML_DOCUMENT_START_TOKEN) { ------------------ | Branch (401:13): [True: 380, False: 56.1k] ------------------ 402| 380| yaml_parser_set_parser_error(parser, 403| 380| "did not find expected ", token->start_mark); 404| 380| goto error; 405| 380| } 406| 56.1k| if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) ------------------ | | 445| 56.1k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 56.1k, False: 0] | | ------------------ | | 446| 56.1k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 56.1k| (*((stack).top++) = value, \ | | 449| 56.1k| 1) : \ | | 450| 56.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (406:13): [True: 0, False: 56.1k] ------------------ 407| 0| goto error; 408| 56.1k| parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE; 409| 56.1k| end_mark = token->end_mark; 410| 56.1k| DOCUMENT_START_EVENT_INIT(*event, version_directive, ------------------ | | 560| 56.1k| (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 56.1k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 56.1k| (event).type = (event_type), \ | | | | 548| 56.1k| (event).start_mark = (event_start_mark), \ | | | | 549| 56.1k| (event).end_mark = (event_end_mark)) | | ------------------ | | 561| 56.1k| (event).data.document_start.version_directive = (event_version_directive), \ | | 562| 56.1k| (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ | | 563| 56.1k| (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ | | 564| 56.1k| (event).data.document_start.implicit = (event_implicit)) ------------------ 411| 56.1k| tag_directives.start, tag_directives.end, 0, 412| 56.1k| start_mark, end_mark); 413| 56.1k| SKIP_TOKEN(parser); ------------------ | | 57| 56.1k| (parser->token_available = 0, \ | | 58| 56.1k| parser->tokens_parsed ++, \ | | 59| 56.1k| parser->stream_end_produced = \ | | 60| 56.1k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 56.1k| parser->tokens.head ++) ------------------ 414| 56.1k| version_directive = NULL; 415| 56.1k| tag_directives.start = tag_directives.end = NULL; 416| 56.1k| return 1; 417| 56.1k| } 418| | 419| | /* Parse the stream end. */ 420| | 421| 1.64k| else 422| 1.64k| { 423| 1.64k| parser->state = YAML_PARSE_END_STATE; 424| 1.64k| STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 556| 1.64k| (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 1.64k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 1.64k| (event).type = (event_type), \ | | | | 548| 1.64k| (event).start_mark = (event_start_mark), \ | | | | 549| 1.64k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 425| 1.64k| SKIP_TOKEN(parser); ------------------ | | 57| 1.64k| (parser->token_available = 0, \ | | 58| 1.64k| parser->tokens_parsed ++, \ | | 59| 1.64k| parser->stream_end_produced = \ | | 60| 1.64k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 1.64k| parser->tokens.head ++) ------------------ 426| 1.64k| return 1; 427| 1.64k| } 428| | 429| 380|error: 430| 380| yaml_free(version_directive); 431| 774| while (tag_directives.start != tag_directives.end) { ------------------ | Branch (431:12): [True: 394, False: 380] ------------------ 432| 394| yaml_free(tag_directives.end[-1].handle); 433| 394| yaml_free(tag_directives.end[-1].prefix); 434| 394| tag_directives.end --; 435| 394| } 436| 380| yaml_free(tag_directives.start); 437| 380| return 0; 438| 66.5k|} parser.c:yaml_parser_process_directives: 1245| 64.8k|{ 1246| 64.8k| yaml_tag_directive_t default_tag_directives[] = { 1247| 64.8k| {(yaml_char_t *)"!", (yaml_char_t *)"!"}, 1248| 64.8k| {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, 1249| 64.8k| {NULL, NULL} 1250| 64.8k| }; 1251| 64.8k| yaml_tag_directive_t *default_tag_directive; 1252| 64.8k| yaml_version_directive_t *version_directive = NULL; 1253| 64.8k| struct { 1254| 64.8k| yaml_tag_directive_t *start; 1255| 64.8k| yaml_tag_directive_t *end; 1256| 64.8k| yaml_tag_directive_t *top; 1257| 64.8k| } tag_directives = { NULL, NULL, NULL }; 1258| 64.8k| yaml_token_t *token; 1259| | 1260| 64.8k| if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*)) ------------------ | | 424| 64.8k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 64.8k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 64.8k, False: 0] | | ------------------ | | 425| 64.8k| ((stack).top = (stack).start, \ | | 426| 64.8k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 64.8k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 64.8k| 1) : \ | | 428| 64.8k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (1260:9): [True: 0, False: 64.8k] ------------------ 1261| 0| goto error; 1262| | 1263| 64.8k| token = PEEK_TOKEN(parser); ------------------ | | 49| 64.8k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 64.8k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 64.8k| parser->tokens.head : NULL) ------------------ 1264| 64.8k| if (!token) goto error; ------------------ | Branch (1264:9): [True: 0, False: 64.8k] ------------------ 1265| | 1266| 179k| while (token->type == YAML_VERSION_DIRECTIVE_TOKEN || ------------------ | Branch (1266:12): [True: 9.22k, False: 170k] ------------------ 1267| 170k| token->type == YAML_TAG_DIRECTIVE_TOKEN) ------------------ | Branch (1267:13): [True: 105k, False: 64.6k] ------------------ 1268| 115k| { 1269| 115k| if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) { ------------------ | Branch (1269:13): [True: 9.22k, False: 105k] ------------------ 1270| 9.22k| if (version_directive) { ------------------ | Branch (1270:17): [True: 4, False: 9.22k] ------------------ 1271| 4| yaml_parser_set_parser_error(parser, 1272| 4| "found duplicate %YAML directive", token->start_mark); 1273| 4| goto error; 1274| 4| } 1275| 9.22k| if (token->data.version_directive.major != 1 ------------------ | Branch (1275:17): [True: 50, False: 9.17k] ------------------ 1276| 9.17k| || ( 1277| 9.17k| token->data.version_directive.minor != 1 ------------------ | Branch (1277:25): [True: 3.56k, False: 5.61k] ------------------ 1278| 3.56k| && token->data.version_directive.minor != 2 ------------------ | Branch (1278:28): [True: 33, False: 3.52k] ------------------ 1279| 9.17k| )) { 1280| 83| yaml_parser_set_parser_error(parser, 1281| 83| "found incompatible YAML document", token->start_mark); 1282| 83| goto error; 1283| 83| } 1284| 9.13k| version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t); ------------------ | | 683| 9.13k|#define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type)) ------------------ 1285| 9.13k| if (!version_directive) { ------------------ | Branch (1285:17): [True: 0, False: 9.13k] ------------------ 1286| 0| parser->error = YAML_MEMORY_ERROR; 1287| 0| goto error; 1288| 0| } 1289| 9.13k| version_directive->major = token->data.version_directive.major; 1290| 9.13k| version_directive->minor = token->data.version_directive.minor; 1291| 9.13k| } 1292| | 1293| 105k| else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) { ------------------ | Branch (1293:18): [True: 105k, False: 0] ------------------ 1294| 105k| yaml_tag_directive_t value; 1295| 105k| value.handle = token->data.tag_directive.handle; 1296| 105k| value.prefix = token->data.tag_directive.prefix; 1297| | 1298| 105k| if (!yaml_parser_append_tag_directive(parser, value, 0, ------------------ | Branch (1298:17): [True: 68, False: 105k] ------------------ 1299| 105k| token->start_mark)) 1300| 68| goto error; 1301| 105k| if (!PUSH(parser, tag_directives, value)) ------------------ | | 445| 105k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 102k, False: 3.15k] | | ------------------ | | 446| 105k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 3.15k, False: 0] | | ------------------ | | 447| 3.15k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 105k| (*((stack).top++) = value, \ | | 449| 105k| 1) : \ | | 450| 105k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1301:17): [True: 0, False: 105k] ------------------ 1302| 0| goto error; 1303| 105k| } 1304| | 1305| 114k| SKIP_TOKEN(parser); ------------------ | | 57| 114k| (parser->token_available = 0, \ | | 58| 114k| parser->tokens_parsed ++, \ | | 59| 114k| parser->stream_end_produced = \ | | 60| 114k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 114k| parser->tokens.head ++) ------------------ 1306| 114k| token = PEEK_TOKEN(parser); ------------------ | | 49| 114k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 114k] | | | Branch (49:34): [True: 114k, False: 73] | | ------------------ | | 50| 114k| parser->tokens.head : NULL) ------------------ 1307| 114k| if (!token) goto error; ------------------ | Branch (1307:13): [True: 73, False: 114k] ------------------ 1308| 114k| } 1309| | 1310| 64.6k| for (default_tag_directive = default_tag_directives; 1311| 193k| default_tag_directive->handle; default_tag_directive++) { ------------------ | Branch (1311:13): [True: 129k, False: 64.6k] ------------------ 1312| 129k| if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1, ------------------ | Branch (1312:13): [True: 0, False: 129k] ------------------ 1313| 129k| token->start_mark)) 1314| 0| goto error; 1315| 129k| } 1316| | 1317| 64.6k| if (version_directive_ref) { ------------------ | Branch (1317:9): [True: 56.4k, False: 8.13k] ------------------ 1318| 56.4k| *version_directive_ref = version_directive; 1319| 56.4k| } 1320| 64.6k| if (tag_directives_start_ref) { ------------------ | Branch (1320:9): [True: 56.4k, False: 8.13k] ------------------ 1321| 56.4k| if (STACK_EMPTY(parser, tag_directives)) { ------------------ | | 436| 56.4k| ((stack).start == (stack).top) | | ------------------ | | | Branch (436:5): [True: 41.6k, False: 14.7k] | | ------------------ ------------------ 1322| 41.6k| *tag_directives_start_ref = *tag_directives_end_ref = NULL; 1323| 41.6k| STACK_DEL(parser, tag_directives); ------------------ | | 432| 41.6k| (yaml_free((stack).start), \ | | 433| 41.6k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1324| 41.6k| } 1325| 14.7k| else { 1326| 14.7k| *tag_directives_start_ref = tag_directives.start; 1327| 14.7k| *tag_directives_end_ref = tag_directives.top; 1328| 14.7k| } 1329| 56.4k| } 1330| 8.13k| else { 1331| 8.13k| STACK_DEL(parser, tag_directives); ------------------ | | 432| 8.13k| (yaml_free((stack).start), \ | | 433| 8.13k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1332| 8.13k| } 1333| | 1334| 64.6k| if (!version_directive_ref) ------------------ | Branch (1334:9): [True: 8.13k, False: 56.4k] ------------------ 1335| 8.13k| yaml_free(version_directive); 1336| 64.6k| return 1; 1337| | 1338| 228|error: 1339| 228| yaml_free(version_directive); 1340| 693| while (!STACK_EMPTY(parser, tag_directives)) { ------------------ | | 436| 693| ((stack).start == (stack).top) ------------------ | Branch (1340:12): [True: 465, False: 228] ------------------ 1341| 465| yaml_tag_directive_t tag_directive = POP(parser, tag_directives); ------------------ | | 454| 465| (*(--(stack).top)) ------------------ 1342| 465| yaml_free(tag_directive.handle); 1343| 465| yaml_free(tag_directive.prefix); 1344| 465| } 1345| 228| STACK_DEL(parser, tag_directives); ------------------ | | 432| 228| (yaml_free((stack).start), \ | | 433| 228| (stack).start = (stack).top = (stack).end = 0) ------------------ 1346| 228| return 0; 1347| 64.6k|} parser.c:yaml_parser_append_tag_directive: 1356| 235k|{ 1357| 235k| yaml_tag_directive_t *tag_directive; 1358| 235k| yaml_tag_directive_t copy = { NULL, NULL }; 1359| | 1360| 235k| for (tag_directive = parser->tag_directives.start; 1361| 1.06M| tag_directive != parser->tag_directives.top; tag_directive ++) { ------------------ | Branch (1361:13): [True: 847k, False: 215k] ------------------ 1362| 847k| if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { ------------------ | Branch (1362:13): [True: 19.6k, False: 827k] ------------------ 1363| 19.6k| if (allow_duplicates) ------------------ | Branch (1363:17): [True: 19.5k, False: 68] ------------------ 1364| 19.5k| return 1; 1365| 68| return yaml_parser_set_parser_error(parser, 1366| 68| "found duplicate %TAG directive", mark); 1367| 19.6k| } 1368| 847k| } 1369| | 1370| 215k| copy.handle = yaml_strdup(value.handle); 1371| 215k| copy.prefix = yaml_strdup(value.prefix); 1372| 215k| if (!copy.handle || !copy.prefix) { ------------------ | Branch (1372:9): [True: 0, False: 215k] | Branch (1372:25): [True: 0, False: 215k] ------------------ 1373| 0| parser->error = YAML_MEMORY_ERROR; 1374| 0| goto error; 1375| 0| } 1376| | 1377| 215k| if (!PUSH(parser, parser->tag_directives, copy)) ------------------ | | 445| 215k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 215k, False: 54] | | ------------------ | | 446| 215k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 54, False: 0] | | ------------------ | | 447| 54| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 215k| (*((stack).top++) = value, \ | | 449| 215k| 1) : \ | | 450| 215k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1377:9): [True: 0, False: 215k] ------------------ 1378| 0| goto error; 1379| | 1380| 215k| return 1; 1381| | 1382| 0|error: 1383| 0| yaml_free(copy.handle); 1384| 0| yaml_free(copy.prefix); 1385| 0| return 0; 1386| 215k|} parser.c:yaml_parser_parse_document_content: 448| 56.1k|{ 449| 56.1k| yaml_token_t *token; 450| | 451| 56.1k| token = PEEK_TOKEN(parser); ------------------ | | 49| 56.1k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 56.1k] | | | Branch (49:34): [True: 56.0k, False: 26] | | ------------------ | | 50| 56.1k| parser->tokens.head : NULL) ------------------ 452| 56.1k| if (!token) return 0; ------------------ | Branch (452:9): [True: 26, False: 56.0k] ------------------ 453| | 454| 56.0k| if (token->type == YAML_VERSION_DIRECTIVE_TOKEN || ------------------ | Branch (454:9): [True: 2.46k, False: 53.6k] ------------------ 455| 53.6k| token->type == YAML_TAG_DIRECTIVE_TOKEN || ------------------ | Branch (455:13): [True: 1.01k, False: 52.6k] ------------------ 456| 52.6k| token->type == YAML_DOCUMENT_START_TOKEN || ------------------ | Branch (456:13): [True: 2.67k, False: 49.9k] ------------------ 457| 49.9k| token->type == YAML_DOCUMENT_END_TOKEN || ------------------ | Branch (457:13): [True: 637, False: 49.2k] ------------------ 458| 49.2k| token->type == YAML_STREAM_END_TOKEN) { ------------------ | Branch (458:13): [True: 390, False: 48.9k] ------------------ 459| 7.18k| parser->state = POP(parser, parser->states); ------------------ | | 454| 7.18k| (*(--(stack).top)) ------------------ 460| 7.18k| return yaml_parser_process_empty_scalar(parser, event, 461| 7.18k| token->start_mark); 462| 7.18k| } 463| 48.9k| else { 464| 48.9k| return yaml_parser_parse_node(parser, event, 1, 0); 465| 48.9k| } 466| 56.0k|} parser.c:yaml_parser_process_empty_scalar: 1220| 4.55M|{ 1221| 4.55M| yaml_char_t *value; 1222| | 1223| 4.55M| value = YAML_MALLOC(1); ------------------ | | 684| 4.55M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 1224| 4.55M| if (!value) { ------------------ | Branch (1224:9): [True: 0, False: 4.55M] ------------------ 1225| 0| parser->error = YAML_MEMORY_ERROR; 1226| 0| return 0; 1227| 0| } 1228| 4.55M| value[0] = '\0'; 1229| | 1230| 4.55M| SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0, ------------------ | | 576| 4.55M| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 4.55M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 4.55M| (event).type = (event_type), \ | | | | 548| 4.55M| (event).start_mark = (event_start_mark), \ | | | | 549| 4.55M| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 4.55M| (event).data.scalar.anchor = (event_anchor), \ | | 578| 4.55M| (event).data.scalar.tag = (event_tag), \ | | 579| 4.55M| (event).data.scalar.value = (event_value), \ | | 580| 4.55M| (event).data.scalar.length = (event_length), \ | | 581| 4.55M| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 4.55M| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 4.55M| (event).data.scalar.style = (event_style)) ------------------ 1231| 4.55M| 1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark); 1232| | 1233| 4.55M| return 1; 1234| 4.55M|} parser.c:yaml_parser_parse_document_end: 478| 62.3k|{ 479| 62.3k| yaml_token_t *token; 480| 62.3k| yaml_mark_t start_mark, end_mark; 481| 62.3k| int implicit = 1; 482| | 483| 62.3k| token = PEEK_TOKEN(parser); ------------------ | | 49| 62.3k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 8.90k, False: 53.4k] | | | Branch (49:34): [True: 53.4k, False: 45] | | ------------------ | | 50| 62.3k| parser->tokens.head : NULL) ------------------ 484| 62.3k| if (!token) return 0; ------------------ | Branch (484:9): [True: 45, False: 62.3k] ------------------ 485| | 486| 62.3k| start_mark = end_mark = token->start_mark; 487| | 488| 62.3k| if (token->type == YAML_DOCUMENT_END_TOKEN) { ------------------ | Branch (488:9): [True: 986, False: 61.3k] ------------------ 489| 986| end_mark = token->end_mark; 490| 986| SKIP_TOKEN(parser); ------------------ | | 57| 986| (parser->token_available = 0, \ | | 58| 986| parser->tokens_parsed ++, \ | | 59| 986| parser->stream_end_produced = \ | | 60| 986| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 986| parser->tokens.head ++) ------------------ 491| 986| implicit = 0; 492| 986| } 493| | 494| 272k| while (!STACK_EMPTY(parser, parser->tag_directives)) { ------------------ | | 436| 272k| ((stack).start == (stack).top) ------------------ | Branch (494:12): [True: 209k, False: 62.3k] ------------------ 495| 209k| yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); ------------------ | | 454| 209k| (*(--(stack).top)) ------------------ 496| 209k| yaml_free(tag_directive.handle); 497| 209k| yaml_free(tag_directive.prefix); 498| 209k| } 499| | 500| 62.3k| parser->state = YAML_PARSE_DOCUMENT_START_STATE; 501| 62.3k| DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark); ------------------ | | 567| 62.3k| (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 62.3k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 62.3k| (event).type = (event_type), \ | | | | 548| 62.3k| (event).start_mark = (event_start_mark), \ | | | | 549| 62.3k| (event).end_mark = (event_end_mark)) | | ------------------ | | 568| 62.3k| (event).data.document_end.implicit = (event_implicit)) ------------------ 502| | 503| 62.3k| return 1; 504| 62.3k|} parser.c:yaml_parser_parse_node: 538| 6.23M|{ 539| 6.23M| yaml_token_t *token; 540| 6.23M| yaml_char_t *anchor = NULL; 541| 6.23M| yaml_char_t *tag_handle = NULL; 542| 6.23M| yaml_char_t *tag_suffix = NULL; 543| 6.23M| yaml_char_t *tag = NULL; 544| 6.23M| yaml_mark_t start_mark, end_mark, tag_mark; 545| 6.23M| int implicit; 546| | 547| 6.23M| token = PEEK_TOKEN(parser); ------------------ | | 49| 6.23M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 6.23M, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 6.23M| parser->tokens.head : NULL) ------------------ 548| 6.23M| if (!token) return 0; ------------------ | Branch (548:9): [True: 0, False: 6.23M] ------------------ 549| | 550| 6.23M| if (token->type == YAML_ALIAS_TOKEN) ------------------ | Branch (550:9): [True: 143k, False: 6.08M] ------------------ 551| 143k| { 552| 143k| parser->state = POP(parser, parser->states); ------------------ | | 454| 143k| (*(--(stack).top)) ------------------ 553| 143k| ALIAS_EVENT_INIT(*event, token->data.alias.value, ------------------ | | 571| 143k| (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 143k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 143k| (event).type = (event_type), \ | | | | 548| 143k| (event).start_mark = (event_start_mark), \ | | | | 549| 143k| (event).end_mark = (event_end_mark)) | | ------------------ | | 572| 143k| (event).data.alias.anchor = (event_anchor)) ------------------ 554| 143k| token->start_mark, token->end_mark); 555| 143k| SKIP_TOKEN(parser); ------------------ | | 57| 143k| (parser->token_available = 0, \ | | 58| 143k| parser->tokens_parsed ++, \ | | 59| 143k| parser->stream_end_produced = \ | | 60| 143k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 143k| parser->tokens.head ++) ------------------ 556| 143k| return 1; 557| 143k| } 558| | 559| 6.08M| else 560| 6.08M| { 561| 6.08M| start_mark = end_mark = token->start_mark; 562| | 563| 6.08M| if (token->type == YAML_ANCHOR_TOKEN) ------------------ | Branch (563:13): [True: 6.47k, False: 6.08M] ------------------ 564| 6.47k| { 565| 6.47k| anchor = token->data.anchor.value; 566| 6.47k| start_mark = token->start_mark; 567| 6.47k| end_mark = token->end_mark; 568| 6.47k| SKIP_TOKEN(parser); ------------------ | | 57| 6.47k| (parser->token_available = 0, \ | | 58| 6.47k| parser->tokens_parsed ++, \ | | 59| 6.47k| parser->stream_end_produced = \ | | 60| 6.47k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 6.47k| parser->tokens.head ++) ------------------ 569| 6.47k| token = PEEK_TOKEN(parser); ------------------ | | 49| 6.47k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 6.47k] | | | Branch (49:34): [True: 6.46k, False: 4] | | ------------------ | | 50| 6.47k| parser->tokens.head : NULL) ------------------ 570| 6.47k| if (!token) goto error; ------------------ | Branch (570:17): [True: 4, False: 6.46k] ------------------ 571| 6.46k| if (token->type == YAML_TAG_TOKEN) ------------------ | Branch (571:17): [True: 208, False: 6.25k] ------------------ 572| 208| { 573| 208| tag_handle = token->data.tag.handle; 574| 208| tag_suffix = token->data.tag.suffix; 575| 208| tag_mark = token->start_mark; 576| 208| end_mark = token->end_mark; 577| 208| SKIP_TOKEN(parser); ------------------ | | 57| 208| (parser->token_available = 0, \ | | 58| 208| parser->tokens_parsed ++, \ | | 59| 208| parser->stream_end_produced = \ | | 60| 208| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 208| parser->tokens.head ++) ------------------ 578| 208| token = PEEK_TOKEN(parser); ------------------ | | 49| 208| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 208] | | | Branch (49:34): [True: 207, False: 1] | | ------------------ | | 50| 208| parser->tokens.head : NULL) ------------------ 579| 208| if (!token) goto error; ------------------ | Branch (579:21): [True: 1, False: 207] ------------------ 580| 208| } 581| 6.46k| } 582| 6.08M| else if (token->type == YAML_TAG_TOKEN) ------------------ | Branch (582:18): [True: 11.2k, False: 6.06M] ------------------ 583| 11.2k| { 584| 11.2k| tag_handle = token->data.tag.handle; 585| 11.2k| tag_suffix = token->data.tag.suffix; 586| 11.2k| start_mark = tag_mark = token->start_mark; 587| 11.2k| end_mark = token->end_mark; 588| 11.2k| SKIP_TOKEN(parser); ------------------ | | 57| 11.2k| (parser->token_available = 0, \ | | 58| 11.2k| parser->tokens_parsed ++, \ | | 59| 11.2k| parser->stream_end_produced = \ | | 60| 11.2k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 11.2k| parser->tokens.head ++) ------------------ 589| 11.2k| token = PEEK_TOKEN(parser); ------------------ | | 49| 11.2k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 11.2k] | | | Branch (49:34): [True: 11.2k, False: 9] | | ------------------ | | 50| 11.2k| parser->tokens.head : NULL) ------------------ 590| 11.2k| if (!token) goto error; ------------------ | Branch (590:17): [True: 9, False: 11.2k] ------------------ 591| 11.2k| if (token->type == YAML_ANCHOR_TOKEN) ------------------ | Branch (591:17): [True: 238, False: 10.9k] ------------------ 592| 238| { 593| 238| anchor = token->data.anchor.value; 594| 238| end_mark = token->end_mark; 595| 238| SKIP_TOKEN(parser); ------------------ | | 57| 238| (parser->token_available = 0, \ | | 58| 238| parser->tokens_parsed ++, \ | | 59| 238| parser->stream_end_produced = \ | | 60| 238| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 238| parser->tokens.head ++) ------------------ 596| 238| token = PEEK_TOKEN(parser); ------------------ | | 49| 238| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 238] | | | Branch (49:34): [True: 237, False: 1] | | ------------------ | | 50| 238| parser->tokens.head : NULL) ------------------ 597| 238| if (!token) goto error; ------------------ | Branch (597:21): [True: 1, False: 237] ------------------ 598| 238| } 599| 11.2k| } 600| | 601| 6.08M| if (tag_handle) { ------------------ | Branch (601:13): [True: 11.4k, False: 6.07M] ------------------ 602| 11.4k| if (!*tag_handle) { ------------------ | Branch (602:17): [True: 6.22k, False: 5.18k] ------------------ 603| 6.22k| tag = tag_suffix; 604| 6.22k| yaml_free(tag_handle); 605| 6.22k| tag_handle = tag_suffix = NULL; 606| 6.22k| } 607| 5.18k| else { 608| 5.18k| yaml_tag_directive_t *tag_directive; 609| 5.18k| for (tag_directive = parser->tag_directives.start; 610| 6.09k| tag_directive != parser->tag_directives.top; ------------------ | Branch (610:25): [True: 5.99k, False: 101] ------------------ 611| 5.99k| tag_directive ++) { 612| 5.99k| if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) { ------------------ | Branch (612:25): [True: 5.07k, False: 915] ------------------ 613| 5.07k| size_t prefix_len = strlen((char *)tag_directive->prefix); 614| 5.07k| size_t suffix_len = strlen((char *)tag_suffix); 615| 5.07k| tag = YAML_MALLOC(prefix_len+suffix_len+1); ------------------ | | 684| 5.07k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 616| 5.07k| if (!tag) { ------------------ | Branch (616:29): [True: 0, False: 5.07k] ------------------ 617| 0| parser->error = YAML_MEMORY_ERROR; 618| 0| goto error; 619| 0| } 620| 5.07k| memcpy(tag, tag_directive->prefix, prefix_len); 621| 5.07k| memcpy(tag+prefix_len, tag_suffix, suffix_len); 622| 5.07k| tag[prefix_len+suffix_len] = '\0'; 623| 5.07k| yaml_free(tag_handle); 624| 5.07k| yaml_free(tag_suffix); 625| 5.07k| tag_handle = tag_suffix = NULL; 626| 5.07k| break; 627| 5.07k| } 628| 5.99k| } 629| 5.18k| if (!tag) { ------------------ | Branch (629:21): [True: 101, False: 5.07k] ------------------ 630| 101| yaml_parser_set_parser_error_context(parser, 631| 101| "while parsing a node", start_mark, 632| 101| "found undefined tag handle", tag_mark); 633| 101| goto error; 634| 101| } 635| 5.18k| } 636| 11.4k| } 637| | 638| 6.08M| implicit = (!tag || !*tag); ------------------ | Branch (638:21): [True: 6.07M, False: 11.3k] | Branch (638:29): [True: 175, False: 11.1k] ------------------ 639| 6.08M| if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) { ------------------ | Branch (639:13): [True: 2.49M, False: 3.59M] | Branch (639:36): [True: 48.9k, False: 2.44M] ------------------ 640| 48.9k| end_mark = token->end_mark; 641| 48.9k| parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; 642| 48.9k| SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 587| 48.9k| (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 48.9k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 48.9k| (event).type = (event_type), \ | | | | 548| 48.9k| (event).start_mark = (event_start_mark), \ | | | | 549| 48.9k| (event).end_mark = (event_end_mark)) | | ------------------ | | 588| 48.9k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 48.9k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 48.9k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 48.9k| (event).data.sequence_start.style = (event_style)) ------------------ 643| 48.9k| YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); 644| 48.9k| return 1; 645| 48.9k| } 646| 6.03M| else { 647| 6.03M| if (token->type == YAML_SCALAR_TOKEN) { ------------------ | Branch (647:17): [True: 3.63M, False: 2.40M] ------------------ 648| 3.63M| int plain_implicit = 0; 649| 3.63M| int quoted_implicit = 0; 650| 3.63M| end_mark = token->end_mark; 651| 3.63M| if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag) ------------------ | Branch (651:22): [True: 3.58M, False: 50.4k] | Branch (651:77): [True: 3.58M, False: 1.23k] ------------------ 652| 3.58M| || (tag && strcmp((char *)tag, "!") == 0)) { ------------------ | Branch (652:29): [True: 2.22k, False: 49.4k] | Branch (652:36): [True: 437, False: 1.78k] ------------------ 653| 3.58M| plain_implicit = 1; 654| 3.58M| } 655| 51.2k| else if (!tag) { ------------------ | Branch (655:26): [True: 49.4k, False: 1.78k] ------------------ 656| 49.4k| quoted_implicit = 1; 657| 49.4k| } 658| 3.63M| parser->state = POP(parser, parser->states); ------------------ | | 454| 3.63M| (*(--(stack).top)) ------------------ 659| 3.63M| SCALAR_EVENT_INIT(*event, anchor, tag, ------------------ | | 576| 3.63M| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 3.63M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 3.63M| (event).type = (event_type), \ | | | | 548| 3.63M| (event).start_mark = (event_start_mark), \ | | | | 549| 3.63M| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 3.63M| (event).data.scalar.anchor = (event_anchor), \ | | 578| 3.63M| (event).data.scalar.tag = (event_tag), \ | | 579| 3.63M| (event).data.scalar.value = (event_value), \ | | 580| 3.63M| (event).data.scalar.length = (event_length), \ | | 581| 3.63M| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 3.63M| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 3.63M| (event).data.scalar.style = (event_style)) ------------------ 660| 3.63M| token->data.scalar.value, token->data.scalar.length, 661| 3.63M| plain_implicit, quoted_implicit, 662| 3.63M| token->data.scalar.style, start_mark, end_mark); 663| 3.63M| SKIP_TOKEN(parser); ------------------ | | 57| 3.63M| (parser->token_available = 0, \ | | 58| 3.63M| parser->tokens_parsed ++, \ | | 59| 3.63M| parser->stream_end_produced = \ | | 60| 3.63M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 3.63M| parser->tokens.head ++) ------------------ 664| 3.63M| return 1; 665| 3.63M| } 666| 2.40M| else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) { ------------------ | Branch (666:22): [True: 47.2k, False: 2.35M] ------------------ 667| 47.2k| end_mark = token->end_mark; 668| 47.2k| parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE; 669| 47.2k| SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 587| 47.2k| (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 47.2k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 47.2k| (event).type = (event_type), \ | | | | 548| 47.2k| (event).start_mark = (event_start_mark), \ | | | | 549| 47.2k| (event).end_mark = (event_end_mark)) | | ------------------ | | 588| 47.2k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 47.2k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 47.2k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 47.2k| (event).data.sequence_start.style = (event_style)) ------------------ 670| 47.2k| YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark); 671| 47.2k| return 1; 672| 47.2k| } 673| 2.35M| else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) { ------------------ | Branch (673:22): [True: 14.5k, False: 2.34M] ------------------ 674| 14.5k| end_mark = token->end_mark; 675| 14.5k| parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE; 676| 14.5k| MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 598| 14.5k| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 14.5k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 14.5k| (event).type = (event_type), \ | | | | 548| 14.5k| (event).start_mark = (event_start_mark), \ | | | | 549| 14.5k| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 14.5k| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 14.5k| (event).data.mapping_start.tag = (event_tag), \ | | 601| 14.5k| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 14.5k| (event).data.mapping_start.style = (event_style)) ------------------ 677| 14.5k| YAML_FLOW_MAPPING_STYLE, start_mark, end_mark); 678| 14.5k| return 1; 679| 14.5k| } 680| 2.34M| else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) { ------------------ | Branch (680:22): [True: 2.33M, False: 3.19k] | Branch (680:31): [True: 45.2k, False: 2.29M] ------------------ 681| 45.2k| end_mark = token->end_mark; 682| 45.2k| parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE; 683| 45.2k| SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 587| 45.2k| (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 45.2k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 45.2k| (event).type = (event_type), \ | | | | 548| 45.2k| (event).start_mark = (event_start_mark), \ | | | | 549| 45.2k| (event).end_mark = (event_end_mark)) | | ------------------ | | 588| 45.2k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 45.2k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 45.2k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 45.2k| (event).data.sequence_start.style = (event_style)) ------------------ 684| 45.2k| YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); 685| 45.2k| return 1; 686| 45.2k| } 687| 2.29M| else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) { ------------------ | Branch (687:22): [True: 2.29M, False: 3.19k] | Branch (687:31): [True: 2.28M, False: 4.96k] ------------------ 688| 2.28M| end_mark = token->end_mark; 689| 2.28M| parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE; 690| 2.28M| MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 598| 2.28M| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 2.28M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.28M| (event).type = (event_type), \ | | | | 548| 2.28M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.28M| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 2.28M| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 2.28M| (event).data.mapping_start.tag = (event_tag), \ | | 601| 2.28M| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 2.28M| (event).data.mapping_start.style = (event_style)) ------------------ 691| 2.28M| YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark); 692| 2.28M| return 1; 693| 2.28M| } 694| 8.15k| else if (anchor || tag) { ------------------ | Branch (694:22): [True: 3.40k, False: 4.75k] | Branch (694:32): [True: 4.32k, False: 424] ------------------ 695| 7.72k| yaml_char_t *value = YAML_MALLOC(1); ------------------ | | 684| 7.72k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 696| 7.72k| if (!value) { ------------------ | Branch (696:21): [True: 0, False: 7.72k] ------------------ 697| 0| parser->error = YAML_MEMORY_ERROR; 698| 0| goto error; 699| 0| } 700| 7.72k| value[0] = '\0'; 701| 7.72k| parser->state = POP(parser, parser->states); ------------------ | | 454| 7.72k| (*(--(stack).top)) ------------------ 702| 7.72k| SCALAR_EVENT_INIT(*event, anchor, tag, value, 0, ------------------ | | 576| 7.72k| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 7.72k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 7.72k| (event).type = (event_type), \ | | | | 548| 7.72k| (event).start_mark = (event_start_mark), \ | | | | 549| 7.72k| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 7.72k| (event).data.scalar.anchor = (event_anchor), \ | | 578| 7.72k| (event).data.scalar.tag = (event_tag), \ | | 579| 7.72k| (event).data.scalar.value = (event_value), \ | | 580| 7.72k| (event).data.scalar.length = (event_length), \ | | 581| 7.72k| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 7.72k| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 7.72k| (event).data.scalar.style = (event_style)) ------------------ 703| 7.72k| implicit, 0, YAML_PLAIN_SCALAR_STYLE, 704| 7.72k| start_mark, end_mark); 705| 7.72k| return 1; 706| 7.72k| } 707| 424| else { 708| 424| yaml_parser_set_parser_error_context(parser, 709| 424| (block ? "while parsing a block node" ------------------ | Branch (709:26): [True: 22, False: 402] ------------------ 710| 424| : "while parsing a flow node"), start_mark, 711| 424| "did not find expected node content", token->start_mark); 712| 424| goto error; 713| 424| } 714| 6.03M| } 715| 6.08M| } 716| | 717| 540|error: 718| 540| yaml_free(anchor); 719| 540| yaml_free(tag_handle); 720| 540| yaml_free(tag_suffix); 721| 540| yaml_free(tag); 722| | 723| 540| return 0; 724| 6.23M|} parser.c:yaml_parser_set_parser_error_context: 218| 1.27k|{ 219| 1.27k| parser->error = YAML_PARSER_ERROR; 220| 1.27k| parser->context = context; 221| 1.27k| parser->context_mark = context_mark; 222| 1.27k| parser->problem = problem; 223| 1.27k| parser->problem_mark = problem_mark; 224| | 225| 1.27k| return 0; 226| 1.27k|} parser.c:yaml_parser_parse_block_sequence_entry: 735| 93.5k|{ 736| 93.5k| yaml_token_t *token; 737| | 738| 93.5k| if (first) { ------------------ | Branch (738:9): [True: 45.2k, False: 48.3k] ------------------ 739| 45.2k| token = PEEK_TOKEN(parser); ------------------ | | 49| 45.2k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 45.2k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 45.2k| parser->tokens.head : NULL) ------------------ 740| 45.2k| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 45.2k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 44.8k, False: 339] | | ------------------ | | 446| 45.2k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 339, False: 0] | | ------------------ | | 447| 339| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 45.2k| (*((stack).top++) = value, \ | | 449| 45.2k| 1) : \ | | 450| 45.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (740:13): [True: 0, False: 45.2k] ------------------ 741| 0| return 0; 742| 45.2k| SKIP_TOKEN(parser); ------------------ | | 57| 45.2k| (parser->token_available = 0, \ | | 58| 45.2k| parser->tokens_parsed ++, \ | | 59| 45.2k| parser->stream_end_produced = \ | | 60| 45.2k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 45.2k| parser->tokens.head ++) ------------------ 743| 45.2k| } 744| | 745| 93.5k| token = PEEK_TOKEN(parser); ------------------ | | 49| 93.5k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 5.89k, False: 87.6k] | | | Branch (49:34): [True: 87.6k, False: 19] | | ------------------ | | 50| 93.5k| parser->tokens.head : NULL) ------------------ 746| 93.5k| if (!token) return 0; ------------------ | Branch (746:9): [True: 19, False: 93.5k] ------------------ 747| | 748| 93.5k| if (token->type == YAML_BLOCK_ENTRY_TOKEN) ------------------ | Branch (748:9): [True: 54.0k, False: 39.4k] ------------------ 749| 54.0k| { 750| 54.0k| yaml_mark_t mark = token->end_mark; 751| 54.0k| SKIP_TOKEN(parser); ------------------ | | 57| 54.0k| (parser->token_available = 0, \ | | 58| 54.0k| parser->tokens_parsed ++, \ | | 59| 54.0k| parser->stream_end_produced = \ | | 60| 54.0k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 54.0k| parser->tokens.head ++) ------------------ 752| 54.0k| token = PEEK_TOKEN(parser); ------------------ | | 49| 54.0k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 54.0k] | | | Branch (49:34): [True: 54.0k, False: 35] | | ------------------ | | 50| 54.0k| parser->tokens.head : NULL) ------------------ 753| 54.0k| if (!token) return 0; ------------------ | Branch (753:13): [True: 35, False: 54.0k] ------------------ 754| 54.0k| if (token->type != YAML_BLOCK_ENTRY_TOKEN && ------------------ | Branch (754:13): [True: 52.0k, False: 2.01k] ------------------ 755| 52.0k| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (755:17): [True: 48.1k, False: 3.85k] ------------------ 756| 48.1k| if (!PUSH(parser, parser->states, ------------------ | | 445| 48.1k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 47.8k, False: 354] | | ------------------ | | 446| 48.1k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 354, False: 0] | | ------------------ | | 447| 354| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 48.1k| (*((stack).top++) = value, \ | | 449| 48.1k| 1) : \ | | 450| 48.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (756:17): [True: 0, False: 48.1k] ------------------ 757| 48.1k| YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)) 758| 0| return 0; 759| 48.1k| return yaml_parser_parse_node(parser, event, 1, 0); 760| 48.1k| } 761| 5.87k| else { 762| 5.87k| parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE; 763| 5.87k| return yaml_parser_process_empty_scalar(parser, event, mark); 764| 5.87k| } 765| 54.0k| } 766| | 767| 39.4k| else if (token->type == YAML_BLOCK_END_TOKEN) ------------------ | Branch (767:14): [True: 39.3k, False: 65] ------------------ 768| 39.3k| { 769| 39.3k| parser->state = POP(parser, parser->states); ------------------ | | 454| 39.3k| (*(--(stack).top)) ------------------ 770| 39.3k| (void)POP(parser, parser->marks); ------------------ | | 454| 39.3k| (*(--(stack).top)) ------------------ 771| 39.3k| SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 594| 39.3k| (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 39.3k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 39.3k| (event).type = (event_type), \ | | | | 548| 39.3k| (event).start_mark = (event_start_mark), \ | | | | 549| 39.3k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 772| 39.3k| SKIP_TOKEN(parser); ------------------ | | 57| 39.3k| (parser->token_available = 0, \ | | 58| 39.3k| parser->tokens_parsed ++, \ | | 59| 39.3k| parser->stream_end_produced = \ | | 60| 39.3k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 39.3k| parser->tokens.head ++) ------------------ 773| 39.3k| return 1; 774| 39.3k| } 775| | 776| 65| else 777| 65| { 778| 65| return yaml_parser_set_parser_error_context(parser, 779| 65| "while parsing a block collection", POP(parser, parser->marks), ------------------ | | 454| 65| (*(--(stack).top)) ------------------ 780| 65| "did not find expected '-' indicator", token->start_mark); 781| 65| } 782| 93.5k|} parser.c:yaml_parser_parse_indentless_sequence_entry: 793| 577k|{ 794| 577k| yaml_token_t *token; 795| | 796| 577k| token = PEEK_TOKEN(parser); ------------------ | | 49| 577k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 52.3k, False: 525k] | | | Branch (49:34): [True: 525k, False: 3] | | ------------------ | | 50| 577k| parser->tokens.head : NULL) ------------------ 797| 577k| if (!token) return 0; ------------------ | Branch (797:9): [True: 3, False: 577k] ------------------ 798| | 799| 577k| if (token->type == YAML_BLOCK_ENTRY_TOKEN) ------------------ | Branch (799:9): [True: 528k, False: 48.9k] ------------------ 800| 528k| { 801| 528k| yaml_mark_t mark = token->end_mark; 802| 528k| SKIP_TOKEN(parser); ------------------ | | 57| 528k| (parser->token_available = 0, \ | | 58| 528k| parser->tokens_parsed ++, \ | | 59| 528k| parser->stream_end_produced = \ | | 60| 528k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 528k| parser->tokens.head ++) ------------------ 803| 528k| token = PEEK_TOKEN(parser); ------------------ | | 49| 528k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 528k] | | | Branch (49:34): [True: 528k, False: 4] | | ------------------ | | 50| 528k| parser->tokens.head : NULL) ------------------ 804| 528k| if (!token) return 0; ------------------ | Branch (804:13): [True: 4, False: 528k] ------------------ 805| 528k| if (token->type != YAML_BLOCK_ENTRY_TOKEN && ------------------ | Branch (805:13): [True: 527k, False: 828] ------------------ 806| 527k| token->type != YAML_KEY_TOKEN && ------------------ | Branch (806:17): [True: 526k, False: 1.01k] ------------------ 807| 526k| token->type != YAML_VALUE_TOKEN && ------------------ | Branch (807:17): [True: 526k, False: 215] ------------------ 808| 526k| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (808:17): [True: 526k, False: 267] ------------------ 809| 526k| if (!PUSH(parser, parser->states, ------------------ | | 445| 526k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 526k, False: 1] | | ------------------ | | 446| 526k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1, False: 0] | | ------------------ | | 447| 1| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 526k| (*((stack).top++) = value, \ | | 449| 526k| 1) : \ | | 450| 526k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (809:17): [True: 0, False: 526k] ------------------ 810| 526k| YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)) 811| 0| return 0; 812| 526k| return yaml_parser_parse_node(parser, event, 1, 0); 813| 526k| } 814| 2.32k| else { 815| 2.32k| parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; 816| 2.32k| return yaml_parser_process_empty_scalar(parser, event, mark); 817| 2.32k| } 818| 528k| } 819| | 820| 48.9k| else 821| 48.9k| { 822| 48.9k| parser->state = POP(parser, parser->states); ------------------ | | 454| 48.9k| (*(--(stack).top)) ------------------ 823| 48.9k| SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark); ------------------ | | 594| 48.9k| (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 48.9k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 48.9k| (event).type = (event_type), \ | | | | 548| 48.9k| (event).start_mark = (event_start_mark), \ | | | | 549| 48.9k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 824| 48.9k| return 1; 825| 48.9k| } 826| 577k|} parser.c:yaml_parser_parse_block_mapping_key: 843| 4.82M|{ 844| 4.82M| yaml_token_t *token; 845| | 846| 4.82M| if (first) { ------------------ | Branch (846:9): [True: 2.28M, False: 2.53M] ------------------ 847| 2.28M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.28M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 2.28M, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 2.28M| parser->tokens.head : NULL) ------------------ 848| 2.28M| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 2.28M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.28M, False: 1.59k] | | ------------------ | | 446| 2.28M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.59k, False: 0] | | ------------------ | | 447| 1.59k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.28M| (*((stack).top++) = value, \ | | 449| 2.28M| 1) : \ | | 450| 2.28M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (848:13): [True: 0, False: 2.28M] ------------------ 849| 0| return 0; 850| 2.28M| SKIP_TOKEN(parser); ------------------ | | 57| 2.28M| (parser->token_available = 0, \ | | 58| 2.28M| parser->tokens_parsed ++, \ | | 59| 2.28M| parser->stream_end_produced = \ | | 60| 2.28M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.28M| parser->tokens.head ++) ------------------ 851| 2.28M| } 852| | 853| 4.82M| token = PEEK_TOKEN(parser); ------------------ | | 49| 4.82M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 2.51M, False: 2.30M] | | | Branch (49:34): [True: 2.30M, False: 21] | | ------------------ | | 50| 4.82M| parser->tokens.head : NULL) ------------------ 854| 4.82M| if (!token) return 0; ------------------ | Branch (854:9): [True: 21, False: 4.82M] ------------------ 855| | 856| 4.82M| if (token->type == YAML_KEY_TOKEN) ------------------ | Branch (856:9): [True: 2.54M, False: 2.28M] ------------------ 857| 2.54M| { 858| 2.54M| yaml_mark_t mark = token->end_mark; 859| 2.54M| SKIP_TOKEN(parser); ------------------ | | 57| 2.54M| (parser->token_available = 0, \ | | 58| 2.54M| parser->tokens_parsed ++, \ | | 59| 2.54M| parser->stream_end_produced = \ | | 60| 2.54M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.54M| parser->tokens.head ++) ------------------ 860| 2.54M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.54M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 2.54M] | | | Branch (49:34): [True: 2.54M, False: 47] | | ------------------ | | 50| 2.54M| parser->tokens.head : NULL) ------------------ 861| 2.54M| if (!token) return 0; ------------------ | Branch (861:13): [True: 47, False: 2.54M] ------------------ 862| 2.54M| if (token->type != YAML_KEY_TOKEN && ------------------ | Branch (862:13): [True: 2.53M, False: 5.06k] ------------------ 863| 2.53M| token->type != YAML_VALUE_TOKEN && ------------------ | Branch (863:17): [True: 2.53M, False: 219] ------------------ 864| 2.53M| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (864:17): [True: 2.43M, False: 103k] ------------------ 865| 2.43M| if (!PUSH(parser, parser->states, ------------------ | | 445| 2.43M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.43M, False: 1.59k] | | ------------------ | | 446| 2.43M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.59k, False: 0] | | ------------------ | | 447| 1.59k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.43M| (*((stack).top++) = value, \ | | 449| 2.43M| 1) : \ | | 450| 2.43M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (865:17): [True: 0, False: 2.43M] ------------------ 866| 2.43M| YAML_PARSE_BLOCK_MAPPING_VALUE_STATE)) 867| 0| return 0; 868| 2.43M| return yaml_parser_parse_node(parser, event, 1, 1); 869| 2.43M| } 870| 108k| else { 871| 108k| parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE; 872| 108k| return yaml_parser_process_empty_scalar(parser, event, mark); 873| 108k| } 874| 2.54M| } 875| | 876| 2.28M| else if (token->type == YAML_BLOCK_END_TOKEN) ------------------ | Branch (876:14): [True: 2.27M, False: 114] ------------------ 877| 2.27M| { 878| 2.27M| parser->state = POP(parser, parser->states); ------------------ | | 454| 2.27M| (*(--(stack).top)) ------------------ 879| 2.27M| (void)POP(parser, parser->marks); ------------------ | | 454| 2.27M| (*(--(stack).top)) ------------------ 880| 2.27M| MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 605| 2.27M| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 2.27M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.27M| (event).type = (event_type), \ | | | | 548| 2.27M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.27M| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 881| 2.27M| SKIP_TOKEN(parser); ------------------ | | 57| 2.27M| (parser->token_available = 0, \ | | 58| 2.27M| parser->tokens_parsed ++, \ | | 59| 2.27M| parser->stream_end_produced = \ | | 60| 2.27M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.27M| parser->tokens.head ++) ------------------ 882| 2.27M| return 1; 883| 2.27M| } 884| | 885| 114| else 886| 114| { 887| 114| return yaml_parser_set_parser_error_context(parser, 888| 114| "while parsing a block mapping", POP(parser, parser->marks), ------------------ | | 454| 114| (*(--(stack).top)) ------------------ 889| 114| "did not find expected key", token->start_mark); 890| 114| } 891| 4.82M|} parser.c:yaml_parser_parse_block_mapping_value: 908| 2.53M|{ 909| 2.53M| yaml_token_t *token; 910| | 911| 2.53M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.53M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 111k, False: 2.42M] | | | Branch (49:34): [True: 2.42M, False: 33] | | ------------------ | | 50| 2.53M| parser->tokens.head : NULL) ------------------ 912| 2.53M| if (!token) return 0; ------------------ | Branch (912:9): [True: 33, False: 2.53M] ------------------ 913| | 914| 2.53M| if (token->type == YAML_VALUE_TOKEN) ------------------ | Branch (914:9): [True: 620k, False: 1.91M] ------------------ 915| 620k| { 916| 620k| yaml_mark_t mark = token->end_mark; 917| 620k| SKIP_TOKEN(parser); ------------------ | | 57| 620k| (parser->token_available = 0, \ | | 58| 620k| parser->tokens_parsed ++, \ | | 59| 620k| parser->stream_end_produced = \ | | 60| 620k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 620k| parser->tokens.head ++) ------------------ 918| 620k| token = PEEK_TOKEN(parser); ------------------ | | 49| 620k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 620k] | | | Branch (49:34): [True: 620k, False: 151] | | ------------------ | | 50| 620k| parser->tokens.head : NULL) ------------------ 919| 620k| if (!token) return 0; ------------------ | Branch (919:13): [True: 151, False: 620k] ------------------ 920| 620k| if (token->type != YAML_KEY_TOKEN && ------------------ | Branch (920:13): [True: 581k, False: 38.8k] ------------------ 921| 581k| token->type != YAML_VALUE_TOKEN && ------------------ | Branch (921:17): [True: 581k, False: 23] ------------------ 922| 581k| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (922:17): [True: 62.6k, False: 518k] ------------------ 923| 62.6k| if (!PUSH(parser, parser->states, ------------------ | | 445| 62.6k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 62.6k, False: 1] | | ------------------ | | 446| 62.6k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1, False: 0] | | ------------------ | | 447| 1| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 62.6k| (*((stack).top++) = value, \ | | 449| 62.6k| 1) : \ | | 450| 62.6k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (923:17): [True: 0, False: 62.6k] ------------------ 924| 62.6k| YAML_PARSE_BLOCK_MAPPING_KEY_STATE)) 925| 0| return 0; 926| 62.6k| return yaml_parser_parse_node(parser, event, 1, 1); 927| 62.6k| } 928| 557k| else { 929| 557k| parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; 930| 557k| return yaml_parser_process_empty_scalar(parser, event, mark); 931| 557k| } 932| 620k| } 933| | 934| 1.91M| else 935| 1.91M| { 936| 1.91M| parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; 937| 1.91M| return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 938| 1.91M| } 939| 2.53M|} parser.c:yaml_parser_parse_flow_sequence_entry: 958| 1.21M|{ 959| 1.21M| yaml_token_t *token; 960| | 961| 1.21M| if (first) { ------------------ | Branch (961:9): [True: 47.2k, False: 1.16M] ------------------ 962| 47.2k| token = PEEK_TOKEN(parser); ------------------ | | 49| 47.2k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 47.2k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 47.2k| parser->tokens.head : NULL) ------------------ 963| 47.2k| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 47.2k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 46.5k, False: 663] | | ------------------ | | 446| 47.2k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 663, False: 0] | | ------------------ | | 447| 663| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 47.2k| (*((stack).top++) = value, \ | | 449| 47.2k| 1) : \ | | 450| 47.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (963:13): [True: 0, False: 47.2k] ------------------ 964| 0| return 0; 965| 47.2k| SKIP_TOKEN(parser); ------------------ | | 57| 47.2k| (parser->token_available = 0, \ | | 58| 47.2k| parser->tokens_parsed ++, \ | | 59| 47.2k| parser->stream_end_produced = \ | | 60| 47.2k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 47.2k| parser->tokens.head ++) ------------------ 966| 47.2k| } 967| | 968| 1.21M| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.21M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 34.6k, False: 1.17M] | | | Branch (49:34): [True: 1.17M, False: 9] | | ------------------ | | 50| 1.21M| parser->tokens.head : NULL) ------------------ 969| 1.21M| if (!token) return 0; ------------------ | Branch (969:9): [True: 9, False: 1.21M] ------------------ 970| | 971| 1.21M| if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) ------------------ | Branch (971:9): [True: 1.17M, False: 35.0k] ------------------ 972| 1.17M| { 973| 1.17M| if (!first) { ------------------ | Branch (973:13): [True: 1.13M, False: 46.3k] ------------------ 974| 1.13M| if (token->type == YAML_FLOW_ENTRY_TOKEN) { ------------------ | Branch (974:17): [True: 1.13M, False: 327] ------------------ 975| 1.13M| SKIP_TOKEN(parser); ------------------ | | 57| 1.13M| (parser->token_available = 0, \ | | 58| 1.13M| parser->tokens_parsed ++, \ | | 59| 1.13M| parser->stream_end_produced = \ | | 60| 1.13M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 1.13M| parser->tokens.head ++) ------------------ 976| 1.13M| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.13M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 1.13M] | | | Branch (49:34): [True: 1.13M, False: 11] | | ------------------ | | 50| 1.13M| parser->tokens.head : NULL) ------------------ 977| 1.13M| if (!token) return 0; ------------------ | Branch (977:21): [True: 11, False: 1.13M] ------------------ 978| 1.13M| } 979| 327| else { 980| 327| return yaml_parser_set_parser_error_context(parser, 981| 327| "while parsing a flow sequence", POP(parser, parser->marks), ------------------ | | 454| 327| (*(--(stack).top)) ------------------ 982| 327| "did not find expected ',' or ']'", token->start_mark); 983| 327| } 984| 1.13M| } 985| | 986| 1.17M| if (token->type == YAML_KEY_TOKEN) { ------------------ | Branch (986:13): [True: 36.1k, False: 1.14M] ------------------ 987| 36.1k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE; 988| 36.1k| MAPPING_START_EVENT_INIT(*event, NULL, NULL, ------------------ | | 598| 36.1k| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 36.1k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 36.1k| (event).type = (event_type), \ | | | | 548| 36.1k| (event).start_mark = (event_start_mark), \ | | | | 549| 36.1k| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 36.1k| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 36.1k| (event).data.mapping_start.tag = (event_tag), \ | | 601| 36.1k| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 36.1k| (event).data.mapping_start.style = (event_style)) ------------------ 989| 36.1k| 1, YAML_FLOW_MAPPING_STYLE, 990| 36.1k| token->start_mark, token->end_mark); 991| 36.1k| SKIP_TOKEN(parser); ------------------ | | 57| 36.1k| (parser->token_available = 0, \ | | 58| 36.1k| parser->tokens_parsed ++, \ | | 59| 36.1k| parser->stream_end_produced = \ | | 60| 36.1k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 36.1k| parser->tokens.head ++) ------------------ 992| 36.1k| return 1; 993| 36.1k| } 994| | 995| 1.14M| else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (995:18): [True: 1.14M, False: 672] ------------------ 996| 1.14M| if (!PUSH(parser, parser->states, ------------------ | | 445| 1.14M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.14M, False: 234] | | ------------------ | | 446| 1.14M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 234, False: 0] | | ------------------ | | 447| 234| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.14M| (*((stack).top++) = value, \ | | 449| 1.14M| 1) : \ | | 450| 1.14M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (996:17): [True: 0, False: 1.14M] ------------------ 997| 1.14M| YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE)) 998| 0| return 0; 999| 1.14M| return yaml_parser_parse_node(parser, event, 0, 0); 1000| 1.14M| } 1001| 1.17M| } 1002| | 1003| 35.7k| parser->state = POP(parser, parser->states); ------------------ | | 454| 35.7k| (*(--(stack).top)) ------------------ 1004| 35.7k| (void)POP(parser, parser->marks); ------------------ | | 454| 35.7k| (*(--(stack).top)) ------------------ 1005| 35.7k| SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 594| 35.7k| (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 35.7k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 35.7k| (event).type = (event_type), \ | | | | 548| 35.7k| (event).start_mark = (event_start_mark), \ | | | | 549| 35.7k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 1006| 35.7k| SKIP_TOKEN(parser); ------------------ | | 57| 35.7k| (parser->token_available = 0, \ | | 58| 35.7k| parser->tokens_parsed ++, \ | | 59| 35.7k| parser->stream_end_produced = \ | | 60| 35.7k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 35.7k| parser->tokens.head ++) ------------------ 1007| 35.7k| return 1; 1008| 1.21M|} parser.c:yaml_parser_parse_flow_sequence_entry_mapping_key: 1019| 36.1k|{ 1020| 36.1k| yaml_token_t *token; 1021| | 1022| 36.1k| token = PEEK_TOKEN(parser); ------------------ | | 49| 36.1k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 36.1k] | | | Branch (49:34): [True: 36.1k, False: 3] | | ------------------ | | 50| 36.1k| parser->tokens.head : NULL) ------------------ 1023| 36.1k| if (!token) return 0; ------------------ | Branch (1023:9): [True: 3, False: 36.1k] ------------------ 1024| | 1025| 36.1k| if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1025:9): [True: 35.7k, False: 377] | Branch (1025:44): [True: 35.5k, False: 208] ------------------ 1026| 35.5k| && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (1026:16): [True: 29.7k, False: 5.76k] ------------------ 1027| 29.7k| if (!PUSH(parser, parser->states, ------------------ | | 445| 29.7k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 29.3k, False: 441] | | ------------------ | | 446| 29.7k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 441, False: 0] | | ------------------ | | 447| 441| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 29.7k| (*((stack).top++) = value, \ | | 449| 29.7k| 1) : \ | | 450| 29.7k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1027:13): [True: 0, False: 29.7k] ------------------ 1028| 29.7k| YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)) 1029| 0| return 0; 1030| 29.7k| return yaml_parser_parse_node(parser, event, 0, 0); 1031| 29.7k| } 1032| 6.35k| else if (token->type == YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (1032:14): [True: 5.76k, False: 585] ------------------ 1033| 5.76k| yaml_mark_t mark = token->start_mark; 1034| 5.76k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; 1035| 5.76k| return yaml_parser_process_empty_scalar(parser, event, mark); 1036| 5.76k| } 1037| 585| else { 1038| 585| yaml_mark_t mark = token->end_mark; 1039| 585| SKIP_TOKEN(parser); ------------------ | | 57| 585| (parser->token_available = 0, \ | | 58| 585| parser->tokens_parsed ++, \ | | 59| 585| parser->stream_end_produced = \ | | 60| 585| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 585| parser->tokens.head ++) ------------------ 1040| 585| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; 1041| 585| return yaml_parser_process_empty_scalar(parser, event, mark); 1042| 585| } 1043| 36.1k|} parser.c:yaml_parser_parse_flow_sequence_entry_mapping_value: 1054| 34.6k|{ 1055| 34.6k| yaml_token_t *token; 1056| | 1057| 34.6k| token = PEEK_TOKEN(parser); ------------------ | | 49| 34.6k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 5.82k, False: 28.7k] | | | Branch (49:34): [True: 28.7k, False: 1] | | ------------------ | | 50| 34.6k| parser->tokens.head : NULL) ------------------ 1058| 34.6k| if (!token) return 0; ------------------ | Branch (1058:9): [True: 1, False: 34.6k] ------------------ 1059| | 1060| 34.6k| if (token->type == YAML_VALUE_TOKEN) { ------------------ | Branch (1060:9): [True: 10.1k, False: 24.4k] ------------------ 1061| 10.1k| SKIP_TOKEN(parser); ------------------ | | 57| 10.1k| (parser->token_available = 0, \ | | 58| 10.1k| parser->tokens_parsed ++, \ | | 59| 10.1k| parser->stream_end_produced = \ | | 60| 10.1k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 10.1k| parser->tokens.head ++) ------------------ 1062| 10.1k| token = PEEK_TOKEN(parser); ------------------ | | 49| 10.1k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 10.1k] | | | Branch (49:34): [True: 10.1k, False: 1] | | ------------------ | | 50| 10.1k| parser->tokens.head : NULL) ------------------ 1063| 10.1k| if (!token) return 0; ------------------ | Branch (1063:13): [True: 1, False: 10.1k] ------------------ 1064| 10.1k| if (token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1064:13): [True: 8.92k, False: 1.20k] ------------------ 1065| 8.92k| && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (1065:20): [True: 2.41k, False: 6.51k] ------------------ 1066| 2.41k| if (!PUSH(parser, parser->states, ------------------ | | 445| 2.41k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.39k, False: 13] | | ------------------ | | 446| 2.41k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 13, False: 0] | | ------------------ | | 447| 13| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.41k| (*((stack).top++) = value, \ | | 449| 2.41k| 1) : \ | | 450| 2.41k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1066:17): [True: 0, False: 2.41k] ------------------ 1067| 2.41k| YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)) 1068| 0| return 0; 1069| 2.41k| return yaml_parser_parse_node(parser, event, 0, 0); 1070| 2.41k| } 1071| 10.1k| } 1072| 32.2k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE; 1073| 32.2k| return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 1074| 34.6k|} parser.c:yaml_parser_parse_flow_sequence_entry_mapping_end: 1085| 33.0k|{ 1086| 33.0k| yaml_token_t *token; 1087| | 1088| 33.0k| token = PEEK_TOKEN(parser); ------------------ | | 49| 33.0k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 32.2k, False: 814] | | | Branch (49:34): [True: 812, False: 2] | | ------------------ | | 50| 33.0k| parser->tokens.head : NULL) ------------------ 1089| 33.0k| if (!token) return 0; ------------------ | Branch (1089:9): [True: 2, False: 33.0k] ------------------ 1090| | 1091| 33.0k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE; 1092| | 1093| 33.0k| MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark); ------------------ | | 605| 33.0k| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 33.0k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 33.0k| (event).type = (event_type), \ | | | | 548| 33.0k| (event).start_mark = (event_start_mark), \ | | | | 549| 33.0k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 1094| 33.0k| return 1; 1095| 33.0k|} parser.c:yaml_parser_parse_flow_mapping_key: 1114| 1.93M|{ 1115| 1.93M| yaml_token_t *token; 1116| | 1117| 1.93M| if (first) { ------------------ | Branch (1117:9): [True: 14.5k, False: 1.91M] ------------------ 1118| 14.5k| token = PEEK_TOKEN(parser); ------------------ | | 49| 14.5k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 14.5k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 14.5k| parser->tokens.head : NULL) ------------------ 1119| 14.5k| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 14.5k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 14.3k, False: 264] | | ------------------ | | 446| 14.5k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 264, False: 0] | | ------------------ | | 447| 264| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 14.5k| (*((stack).top++) = value, \ | | 449| 14.5k| 1) : \ | | 450| 14.5k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1119:13): [True: 0, False: 14.5k] ------------------ 1120| 0| return 0; 1121| 14.5k| SKIP_TOKEN(parser); ------------------ | | 57| 14.5k| (parser->token_available = 0, \ | | 58| 14.5k| parser->tokens_parsed ++, \ | | 59| 14.5k| parser->stream_end_produced = \ | | 60| 14.5k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 14.5k| parser->tokens.head ++) ------------------ 1122| 14.5k| } 1123| | 1124| 1.93M| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.93M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 1.91M, False: 14.6k] | | | Branch (49:34): [True: 14.6k, False: 2] | | ------------------ | | 50| 1.93M| parser->tokens.head : NULL) ------------------ 1125| 1.93M| if (!token) return 0; ------------------ | Branch (1125:9): [True: 2, False: 1.93M] ------------------ 1126| | 1127| 1.93M| if (token->type != YAML_FLOW_MAPPING_END_TOKEN) ------------------ | Branch (1127:9): [True: 1.92M, False: 3.56k] ------------------ 1128| 1.92M| { 1129| 1.92M| if (!first) { ------------------ | Branch (1129:13): [True: 1.91M, False: 13.6k] ------------------ 1130| 1.91M| if (token->type == YAML_FLOW_ENTRY_TOKEN) { ------------------ | Branch (1130:17): [True: 1.91M, False: 246] ------------------ 1131| 1.91M| SKIP_TOKEN(parser); ------------------ | | 57| 1.91M| (parser->token_available = 0, \ | | 58| 1.91M| parser->tokens_parsed ++, \ | | 59| 1.91M| parser->stream_end_produced = \ | | 60| 1.91M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 1.91M| parser->tokens.head ++) ------------------ 1132| 1.91M| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.91M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 1.91M] | | | Branch (49:34): [True: 1.91M, False: 7] | | ------------------ | | 50| 1.91M| parser->tokens.head : NULL) ------------------ 1133| 1.91M| if (!token) return 0; ------------------ | Branch (1133:21): [True: 7, False: 1.91M] ------------------ 1134| 1.91M| } 1135| 246| else { 1136| 246| return yaml_parser_set_parser_error_context(parser, 1137| 246| "while parsing a flow mapping", POP(parser, parser->marks), ------------------ | | 454| 246| (*(--(stack).top)) ------------------ 1138| 246| "did not find expected ',' or '}'", token->start_mark); 1139| 246| } 1140| 1.91M| } 1141| | 1142| 1.92M| if (token->type == YAML_KEY_TOKEN) { ------------------ | Branch (1142:13): [True: 2.35k, False: 1.92M] ------------------ 1143| 2.35k| SKIP_TOKEN(parser); ------------------ | | 57| 2.35k| (parser->token_available = 0, \ | | 58| 2.35k| parser->tokens_parsed ++, \ | | 59| 2.35k| parser->stream_end_produced = \ | | 60| 2.35k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.35k| parser->tokens.head ++) ------------------ 1144| 2.35k| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.35k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 2.35k] | | | Branch (49:34): [True: 2.34k, False: 2] | | ------------------ | | 50| 2.35k| parser->tokens.head : NULL) ------------------ 1145| 2.35k| if (!token) return 0; ------------------ | Branch (1145:17): [True: 2, False: 2.34k] ------------------ 1146| 2.34k| if (token->type != YAML_VALUE_TOKEN ------------------ | Branch (1146:17): [True: 1.75k, False: 589] ------------------ 1147| 1.75k| && token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1147:24): [True: 1.37k, False: 380] ------------------ 1148| 1.37k| && token->type != YAML_FLOW_MAPPING_END_TOKEN) { ------------------ | Branch (1148:24): [True: 984, False: 395] ------------------ 1149| 984| if (!PUSH(parser, parser->states, ------------------ | | 445| 984| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 961, False: 23] | | ------------------ | | 446| 984| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 23, False: 0] | | ------------------ | | 447| 23| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 984| (*((stack).top++) = value, \ | | 449| 984| 1) : \ | | 450| 984| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1149:21): [True: 0, False: 984] ------------------ 1150| 984| YAML_PARSE_FLOW_MAPPING_VALUE_STATE)) 1151| 0| return 0; 1152| 984| return yaml_parser_parse_node(parser, event, 0, 0); 1153| 984| } 1154| 1.36k| else { 1155| 1.36k| parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE; 1156| 1.36k| return yaml_parser_process_empty_scalar(parser, event, 1157| 1.36k| token->start_mark); 1158| 1.36k| } 1159| 2.34k| } 1160| 1.92M| else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) { ------------------ | Branch (1160:18): [True: 1.92M, False: 208] ------------------ 1161| 1.92M| if (!PUSH(parser, parser->states, ------------------ | | 445| 1.92M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.92M, False: 259] | | ------------------ | | 446| 1.92M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 259, False: 0] | | ------------------ | | 447| 259| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.92M| (*((stack).top++) = value, \ | | 449| 1.92M| 1) : \ | | 450| 1.92M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1161:17): [True: 0, False: 1.92M] ------------------ 1162| 1.92M| YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)) 1163| 0| return 0; 1164| 1.92M| return yaml_parser_parse_node(parser, event, 0, 0); 1165| 1.92M| } 1166| 1.92M| } 1167| | 1168| 3.77k| parser->state = POP(parser, parser->states); ------------------ | | 454| 3.77k| (*(--(stack).top)) ------------------ 1169| 3.77k| (void)POP(parser, parser->marks); ------------------ | | 454| 3.77k| (*(--(stack).top)) ------------------ 1170| 3.77k| MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 605| 3.77k| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 3.77k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 3.77k| (event).type = (event_type), \ | | | | 548| 3.77k| (event).start_mark = (event_start_mark), \ | | | | 549| 3.77k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 1171| 3.77k| SKIP_TOKEN(parser); ------------------ | | 57| 3.77k| (parser->token_available = 0, \ | | 58| 3.77k| parser->tokens_parsed ++, \ | | 59| 3.77k| parser->stream_end_produced = \ | | 60| 3.77k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 3.77k| parser->tokens.head ++) ------------------ 1172| 3.77k| return 1; 1173| 1.93M|} parser.c:yaml_parser_parse_flow_mapping_value: 1184| 1.91M|{ 1185| 1.91M| yaml_token_t *token; 1186| | 1187| 1.91M| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.91M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 2.45k, False: 1.91M] | | | Branch (49:34): [True: 1.91M, False: 3] | | ------------------ | | 50| 1.91M| parser->tokens.head : NULL) ------------------ 1188| 1.91M| if (!token) return 0; ------------------ | Branch (1188:9): [True: 3, False: 1.91M] ------------------ 1189| | 1190| 1.91M| if (empty) { ------------------ | Branch (1190:9): [True: 1.91M, False: 2.07k] ------------------ 1191| 1.91M| parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 1192| 1.91M| return yaml_parser_process_empty_scalar(parser, event, 1193| 1.91M| token->start_mark); 1194| 1.91M| } 1195| | 1196| 2.07k| if (token->type == YAML_VALUE_TOKEN) { ------------------ | Branch (1196:9): [True: 1.07k, False: 1.00k] ------------------ 1197| 1.07k| SKIP_TOKEN(parser); ------------------ | | 57| 1.07k| (parser->token_available = 0, \ | | 58| 1.07k| parser->tokens_parsed ++, \ | | 59| 1.07k| parser->stream_end_produced = \ | | 60| 1.07k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 1.07k| parser->tokens.head ++) ------------------ 1198| 1.07k| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.07k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 1.07k] | | | Branch (49:34): [True: 1.07k, False: 1] | | ------------------ | | 50| 1.07k| parser->tokens.head : NULL) ------------------ 1199| 1.07k| if (!token) return 0; ------------------ | Branch (1199:13): [True: 1, False: 1.07k] ------------------ 1200| 1.07k| if (token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1200:13): [True: 704, False: 367] ------------------ 1201| 704| && token->type != YAML_FLOW_MAPPING_END_TOKEN) { ------------------ | Branch (1201:20): [True: 366, False: 338] ------------------ 1202| 366| if (!PUSH(parser, parser->states, ------------------ | | 445| 366| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 351, False: 15] | | ------------------ | | 446| 366| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 15, False: 0] | | ------------------ | | 447| 15| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 366| (*((stack).top++) = value, \ | | 449| 366| 1) : \ | | 450| 366| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1202:17): [True: 0, False: 366] ------------------ 1203| 366| YAML_PARSE_FLOW_MAPPING_KEY_STATE)) 1204| 0| return 0; 1205| 366| return yaml_parser_parse_node(parser, event, 0, 0); 1206| 366| } 1207| 1.07k| } 1208| | 1209| 1.70k| parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 1210| 1.70k| return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 1211| 2.07k|} yaml_parser_update_buffer: 143| 46.4k|{ 144| 46.4k| int first = 1; 145| | 146| 46.4k| assert(parser->read_handler); /* Read handler must be set. */ ------------------ | Branch (146:5): [True: 0, False: 46.4k] | Branch (146:5): [True: 46.4k, False: 0] ------------------ 147| | 148| | /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 149| | 150| 46.4k| if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last) ------------------ | Branch (150:9): [True: 16.9k, False: 29.5k] | Branch (150:24): [True: 16.9k, False: 0] ------------------ 151| 16.9k| return 1; 152| | 153| | /* Return if the buffer contains enough characters. */ 154| | 155| 29.5k| if (parser->unread >= length) ------------------ | Branch (155:9): [True: 0, False: 29.5k] ------------------ 156| 0| return 1; 157| | 158| | /* Determine the input encoding if it is not known yet. */ 159| | 160| 29.5k| if (!parser->encoding) { ------------------ | Branch (160:9): [True: 10.9k, False: 18.6k] ------------------ 161| 10.9k| if (!yaml_parser_determine_encoding(parser)) ------------------ | Branch (161:13): [True: 0, False: 10.9k] ------------------ 162| 0| return 0; 163| 10.9k| } 164| | 165| | /* Move the unread characters to the beginning of the buffer. */ 166| | 167| 29.5k| if (parser->buffer.start < parser->buffer.pointer ------------------ | Branch (167:9): [True: 17.7k, False: 11.7k] ------------------ 168| 17.7k| && parser->buffer.pointer < parser->buffer.last) { ------------------ | Branch (168:16): [True: 10.1k, False: 7.61k] ------------------ 169| 10.1k| size_t size = parser->buffer.last - parser->buffer.pointer; 170| 10.1k| memmove(parser->buffer.start, parser->buffer.pointer, size); 171| 10.1k| parser->buffer.pointer = parser->buffer.start; 172| 10.1k| parser->buffer.last = parser->buffer.start + size; 173| 10.1k| } 174| 19.3k| else if (parser->buffer.pointer == parser->buffer.last) { ------------------ | Branch (174:14): [True: 18.5k, False: 823] ------------------ 175| 18.5k| parser->buffer.pointer = parser->buffer.start; 176| 18.5k| parser->buffer.last = parser->buffer.start; 177| 18.5k| } 178| | 179| | /* Fill the buffer until it has enough characters. */ 180| | 181| 49.0k| while (parser->unread < length) ------------------ | Branch (181:12): [True: 29.9k, False: 19.1k] ------------------ 182| 29.9k| { 183| | /* Fill the raw buffer if necessary. */ 184| | 185| 29.9k| if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) { ------------------ | Branch (185:13): [True: 385, False: 29.5k] | Branch (185:23): [True: 18.2k, False: 11.3k] ------------------ 186| 18.6k| if (!yaml_parser_update_raw_buffer(parser)) return 0; ------------------ | Branch (186:17): [True: 0, False: 18.6k] ------------------ 187| 18.6k| } 188| 29.9k| first = 0; 189| | 190| | /* Decode the raw buffer. */ 191| | 192| 140M| while (parser->raw_buffer.pointer != parser->raw_buffer.last) ------------------ | Branch (192:16): [True: 140M, False: 28.9k] ------------------ 193| 140M| { 194| 140M| unsigned int value = 0, value2 = 0; 195| 140M| int incomplete = 0; 196| 140M| unsigned char octet; 197| 140M| unsigned int width = 0; 198| 140M| int low, high; 199| 140M| size_t k; 200| 140M| size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer; 201| | 202| | /* Decode the next character. */ 203| | 204| 140M| switch (parser->encoding) 205| 140M| { 206| 132M| case YAML_UTF8_ENCODING: ------------------ | Branch (206:17): [True: 132M, False: 8.65M] ------------------ 207| | 208| | /* 209| | * Decode a UTF-8 character. Check RFC 3629 210| | * (http://www.ietf.org/rfc/rfc3629.txt) for more details. 211| | * 212| | * The following table (taken from the RFC) is used for 213| | * decoding. 214| | * 215| | * Char. number range | UTF-8 octet sequence 216| | * (hexadecimal) | (binary) 217| | * --------------------+------------------------------------ 218| | * 0000 0000-0000 007F | 0xxxxxxx 219| | * 0000 0080-0000 07FF | 110xxxxx 10xxxxxx 220| | * 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx 221| | * 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 222| | * 223| | * Additionally, the characters in the range 0xD800-0xDFFF 224| | * are prohibited as they are reserved for use with UTF-16 225| | * surrogate pairs. 226| | */ 227| | 228| | /* Determine the length of the UTF-8 sequence. */ 229| | 230| 132M| octet = parser->raw_buffer.pointer[0]; 231| 132M| width = (octet & 0x80) == 0x00 ? 1 : ------------------ | Branch (231:29): [True: 131M, False: 839k] ------------------ 232| 132M| (octet & 0xE0) == 0xC0 ? 2 : ------------------ | Branch (232:29): [True: 66.8k, False: 772k] ------------------ 233| 839k| (octet & 0xF0) == 0xE0 ? 3 : ------------------ | Branch (233:29): [True: 332k, False: 439k] ------------------ 234| 772k| (octet & 0xF8) == 0xF0 ? 4 : 0; ------------------ | Branch (234:29): [True: 439k, False: 38] ------------------ 235| | 236| | /* Check if the leading octet is valid. */ 237| | 238| 132M| if (!width) ------------------ | Branch (238:25): [True: 38, False: 132M] ------------------ 239| 38| return yaml_parser_set_reader_error(parser, 240| 38| "invalid leading UTF-8 octet", 241| 38| parser->offset, octet); 242| | 243| | /* Check if the raw buffer contains an incomplete character. */ 244| | 245| 132M| if (width > raw_unread) { ------------------ | Branch (245:25): [True: 773, False: 132M] ------------------ 246| 773| if (parser->eof) { ------------------ | Branch (246:29): [True: 90, False: 683] ------------------ 247| 90| return yaml_parser_set_reader_error(parser, 248| 90| "incomplete UTF-8 octet sequence", 249| 90| parser->offset, -1); 250| 90| } 251| 683| incomplete = 1; 252| 683| break; 253| 773| } 254| | 255| | /* Decode the leading octet. */ 256| | 257| 132M| value = (octet & 0x80) == 0x00 ? octet & 0x7F : ------------------ | Branch (257:29): [True: 131M, False: 838k] ------------------ 258| 132M| (octet & 0xE0) == 0xC0 ? octet & 0x1F : ------------------ | Branch (258:29): [True: 66.7k, False: 771k] ------------------ 259| 838k| (octet & 0xF0) == 0xE0 ? octet & 0x0F : ------------------ | Branch (259:29): [True: 332k, False: 439k] ------------------ 260| 771k| (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; ------------------ | Branch (260:29): [True: 439k, False: 0] ------------------ 261| | 262| | /* Check and decode the trailing octets. */ 263| | 264| 134M| for (k = 1; k < width; k ++) ------------------ | Branch (264:33): [True: 2.04M, False: 132M] ------------------ 265| 2.04M| { 266| 2.04M| octet = parser->raw_buffer.pointer[k]; 267| | 268| | /* Check if the octet is valid. */ 269| | 270| 2.04M| if ((octet & 0xC0) != 0x80) ------------------ | Branch (270:29): [True: 17, False: 2.04M] ------------------ 271| 17| return yaml_parser_set_reader_error(parser, 272| 17| "invalid trailing UTF-8 octet", 273| 17| parser->offset+k, octet); 274| | 275| | /* Decode the octet. */ 276| | 277| 2.04M| value = (value << 6) + (octet & 0x3F); 278| 2.04M| } 279| | 280| | /* Check the length of the sequence against the value. */ 281| | 282| 132M| if (!((width == 1) || ------------------ | Branch (282:27): [True: 131M, False: 838k] ------------------ 283| 838k| (width == 2 && value >= 0x80) || ------------------ | Branch (283:30): [True: 66.7k, False: 771k] | Branch (283:44): [True: 66.7k, False: 11] ------------------ 284| 771k| (width == 3 && value >= 0x800) || ------------------ | Branch (284:30): [True: 332k, False: 439k] | Branch (284:44): [True: 332k, False: 7] ------------------ 285| 439k| (width == 4 && value >= 0x10000))) ------------------ | Branch (285:30): [True: 439k, False: 18] | Branch (285:44): [True: 439k, False: 15] ------------------ 286| 33| return yaml_parser_set_reader_error(parser, 287| 33| "invalid length of a UTF-8 sequence", 288| 33| parser->offset, -1); 289| | 290| | /* Check the range of the value. */ 291| | 292| 132M| if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) ------------------ | Branch (292:26): [True: 441k, False: 131M] | Branch (292:45): [True: 12, False: 441k] | Branch (292:65): [True: 4, False: 132M] ------------------ 293| 16| return yaml_parser_set_reader_error(parser, 294| 16| "invalid Unicode character", 295| 16| parser->offset, value); 296| | 297| 132M| break; 298| | 299| 132M| case YAML_UTF16LE_ENCODING: ------------------ | Branch (299:17): [True: 3.59M, False: 137M] ------------------ 300| 8.65M| case YAML_UTF16BE_ENCODING: ------------------ | Branch (300:17): [True: 5.06M, False: 135M] ------------------ 301| | 302| 8.65M| low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1); ------------------ | Branch (302:28): [True: 3.59M, False: 5.06M] ------------------ 303| 8.65M| high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0); ------------------ | Branch (303:29): [True: 3.59M, False: 5.06M] ------------------ 304| | 305| | /* 306| | * The UTF-16 encoding is not as simple as one might 307| | * naively think. Check RFC 2781 308| | * (http://www.ietf.org/rfc/rfc2781.txt). 309| | * 310| | * Normally, two subsequent bytes describe a Unicode 311| | * character. However a special technique (called a 312| | * surrogate pair) is used for specifying character 313| | * values larger than 0xFFFF. 314| | * 315| | * A surrogate pair consists of two pseudo-characters: 316| | * high surrogate area (0xD800-0xDBFF) 317| | * low surrogate area (0xDC00-0xDFFF) 318| | * 319| | * The following formulas are used for decoding 320| | * and encoding characters using surrogate pairs: 321| | * 322| | * U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF) 323| | * U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF) 324| | * W1 = 110110yyyyyyyyyy 325| | * W2 = 110111xxxxxxxxxx 326| | * 327| | * where U is the character value, W1 is the high surrogate 328| | * area, W2 is the low surrogate area. 329| | */ 330| | 331| | /* Check for incomplete UTF-16 character. */ 332| | 333| 8.65M| if (raw_unread < 2) { ------------------ | Branch (333:25): [True: 91, False: 8.65M] ------------------ 334| 91| if (parser->eof) { ------------------ | Branch (334:29): [True: 31, False: 60] ------------------ 335| 31| return yaml_parser_set_reader_error(parser, 336| 31| "incomplete UTF-16 character", 337| 31| parser->offset, -1); 338| 31| } 339| 60| incomplete = 1; 340| 60| break; 341| 91| } 342| | 343| | /* Get the character. */ 344| | 345| 8.65M| value = parser->raw_buffer.pointer[low] 346| 8.65M| + (parser->raw_buffer.pointer[high] << 8); 347| | 348| | /* Check for unexpected low surrogate area. */ 349| | 350| 8.65M| if ((value & 0xFC00) == 0xDC00) ------------------ | Branch (350:25): [True: 2, False: 8.65M] ------------------ 351| 2| return yaml_parser_set_reader_error(parser, 352| 2| "unexpected low surrogate area", 353| 2| parser->offset, value); 354| | 355| | /* Check for a high surrogate area. */ 356| | 357| 8.65M| if ((value & 0xFC00) == 0xD800) { ------------------ | Branch (357:25): [True: 1.30k, False: 8.65M] ------------------ 358| | 359| 1.30k| width = 4; 360| | 361| | /* Check for incomplete surrogate pair. */ 362| | 363| 1.30k| if (raw_unread < 4) { ------------------ | Branch (363:29): [True: 23, False: 1.28k] ------------------ 364| 23| if (parser->eof) { ------------------ | Branch (364:33): [True: 5, False: 18] ------------------ 365| 5| return yaml_parser_set_reader_error(parser, 366| 5| "incomplete UTF-16 surrogate pair", 367| 5| parser->offset, -1); 368| 5| } 369| 18| incomplete = 1; 370| 18| break; 371| 23| } 372| | 373| | /* Get the next character. */ 374| | 375| 1.28k| value2 = parser->raw_buffer.pointer[low+2] 376| 1.28k| + (parser->raw_buffer.pointer[high+2] << 8); 377| | 378| | /* Check for a low surrogate area. */ 379| | 380| 1.28k| if ((value2 & 0xFC00) != 0xDC00) ------------------ | Branch (380:29): [True: 5, False: 1.27k] ------------------ 381| 5| return yaml_parser_set_reader_error(parser, 382| 5| "expected low surrogate area", 383| 5| parser->offset+2, value2); 384| | 385| | /* Generate the value of the surrogate pair. */ 386| | 387| 1.27k| value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF); 388| 1.27k| } 389| | 390| 8.65M| else { 391| 8.65M| width = 2; 392| 8.65M| } 393| | 394| 8.65M| break; 395| | 396| 8.65M| default: ------------------ | Branch (396:17): [True: 0, False: 140M] ------------------ 397| 0| assert(1); /* Impossible. */ ------------------ | Branch (397:21): [True: 0, Folded] | Branch (397:21): [True: 0, Folded] ------------------ 398| 140M| } 399| | 400| | /* Check if the raw buffer contains enough bytes to form a character. */ 401| | 402| 140M| if (incomplete) break; ------------------ | Branch (402:17): [True: 761, False: 140M] ------------------ 403| | 404| | /* 405| | * Check if the character is in the allowed range: 406| | * #x9 | #xA | #xD | [#x20-#x7E] (8 bit) 407| | * | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit) 408| | * | [#x10000-#x10FFFF] (32 bit) 409| | */ 410| | 411| 140M| if (! (value == 0x09 || value == 0x0A || value == 0x0D ------------------ | Branch (411:20): [True: 730k, False: 139M] | Branch (411:37): [True: 5.40M, False: 134M] | Branch (411:54): [True: 5.60M, False: 128M] ------------------ 412| 128M| || (value >= 0x20 && value <= 0x7E) ------------------ | Branch (412:29): [True: 128M, False: 24] | Branch (412:46): [True: 119M, False: 9.49M] ------------------ 413| 9.49M| || (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF) ------------------ | Branch (413:28): [True: 15.4k, False: 9.47M] | Branch (413:48): [True: 9.47M, False: 31] | Branch (413:65): [True: 9.01M, False: 468k] ------------------ 414| 468k| || (value >= 0xE000 && value <= 0xFFFD) ------------------ | Branch (414:29): [True: 468k, False: 31] | Branch (414:48): [True: 27.4k, False: 440k] ------------------ 415| 440k| || (value >= 0x10000 && value <= 0x10FFFF))) ------------------ | Branch (415:29): [True: 440k, False: 35] | Branch (415:49): [True: 440k, False: 0] ------------------ 416| 35| return yaml_parser_set_reader_error(parser, 417| 35| "control characters are not allowed", 418| 35| parser->offset, value); 419| | 420| | /* Move the raw pointers. */ 421| | 422| 140M| parser->raw_buffer.pointer += width; 423| 140M| parser->offset += width; 424| | 425| | /* Finally put the character into the buffer. */ 426| | 427| | /* 0000 0000-0000 007F -> 0xxxxxxx */ 428| 140M| if (value <= 0x7F) { ------------------ | Branch (428:17): [True: 131M, False: 9.49M] ------------------ 429| 131M| *(parser->buffer.last++) = value; 430| 131M| } 431| | /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */ 432| 9.49M| else if (value <= 0x7FF) { ------------------ | Branch (432:22): [True: 72.4k, False: 9.42M] ------------------ 433| 72.4k| *(parser->buffer.last++) = 0xC0 + (value >> 6); 434| 72.4k| *(parser->buffer.last++) = 0x80 + (value & 0x3F); 435| 72.4k| } 436| | /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */ 437| 9.42M| else if (value <= 0xFFFF) { ------------------ | Branch (437:22): [True: 8.98M, False: 440k] ------------------ 438| 8.98M| *(parser->buffer.last++) = 0xE0 + (value >> 12); 439| 8.98M| *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 440| 8.98M| *(parser->buffer.last++) = 0x80 + (value & 0x3F); 441| 8.98M| } 442| | /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 443| 440k| else { 444| 440k| *(parser->buffer.last++) = 0xF0 + (value >> 18); 445| 440k| *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F); 446| 440k| *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 447| 440k| *(parser->buffer.last++) = 0x80 + (value & 0x3F); 448| 440k| } 449| | 450| 140M| parser->unread ++; 451| 140M| } 452| | 453| | /* On EOF, put NUL into the buffer and return. */ 454| | 455| 29.6k| if (parser->eof) { ------------------ | Branch (455:13): [True: 10.1k, False: 19.4k] ------------------ 456| 10.1k| *(parser->buffer.last++) = '\0'; 457| 10.1k| parser->unread ++; 458| 10.1k| return 1; 459| 10.1k| } 460| | 461| 29.6k| } 462| | 463| 19.1k| if (parser->offset >= MAX_FILE_SIZE) { ------------------ | | 77| 19.1k|#define MAX_FILE_SIZE (~(size_t)0 / 2) ------------------ | Branch (463:9): [True: 0, False: 19.1k] ------------------ 464| 0| return yaml_parser_set_reader_error(parser, "input is too long", 465| 0| parser->offset, -1); 466| 0| } 467| | 468| 19.1k| return 1; 469| 19.1k|} reader.c:yaml_parser_determine_encoding: 52| 10.9k|{ 53| | /* Ensure that we had enough bytes in the raw buffer. */ 54| | 55| 22.3k| while (!parser->eof ------------------ | Branch (55:12): [True: 21.8k, False: 471] ------------------ 56| 21.8k| && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) { ------------------ | Branch (56:16): [True: 11.4k, False: 10.4k] ------------------ 57| 11.4k| if (!yaml_parser_update_raw_buffer(parser)) { ------------------ | Branch (57:13): [True: 0, False: 11.4k] ------------------ 58| 0| return 0; 59| 0| } 60| 11.4k| } 61| | 62| | /* Determine the encoding. */ 63| | 64| 10.9k| if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 ------------------ | Branch (64:9): [True: 10.8k, False: 89] ------------------ 65| 10.8k| && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) { ------------------ | | 42| 10.8k|#define BOM_UTF16LE "\xff\xfe" ------------------ | Branch (65:16): [True: 164, False: 10.6k] ------------------ 66| 164| parser->encoding = YAML_UTF16LE_ENCODING; 67| 164| parser->raw_buffer.pointer += 2; 68| 164| parser->offset += 2; 69| 164| } 70| 10.7k| else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 ------------------ | Branch (70:14): [True: 10.6k, False: 89] ------------------ 71| 10.6k| && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) { ------------------ | | 43| 10.6k|#define BOM_UTF16BE "\xfe\xff" ------------------ | Branch (71:16): [True: 364, False: 10.3k] ------------------ 72| 364| parser->encoding = YAML_UTF16BE_ENCODING; 73| 364| parser->raw_buffer.pointer += 2; 74| 364| parser->offset += 2; 75| 364| } 76| 10.4k| else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3 ------------------ | Branch (76:14): [True: 9.94k, False: 469] ------------------ 77| 9.94k| && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) { ------------------ | | 41| 9.94k|#define BOM_UTF8 "\xef\xbb\xbf" ------------------ | Branch (77:16): [True: 21, False: 9.92k] ------------------ 78| 21| parser->encoding = YAML_UTF8_ENCODING; 79| 21| parser->raw_buffer.pointer += 3; 80| 21| parser->offset += 3; 81| 21| } 82| 10.3k| else { 83| 10.3k| parser->encoding = YAML_UTF8_ENCODING; 84| 10.3k| } 85| | 86| 10.9k| return 1; 87| 10.9k|} reader.c:yaml_parser_update_raw_buffer: 95| 30.0k|{ 96| 30.0k| size_t size_read = 0; 97| | 98| | /* Return if the raw buffer is full. */ 99| | 100| 30.0k| if (parser->raw_buffer.start == parser->raw_buffer.pointer ------------------ | Branch (100:9): [True: 11.4k, False: 18.6k] ------------------ 101| 11.4k| && parser->raw_buffer.last == parser->raw_buffer.end) ------------------ | Branch (101:16): [True: 0, False: 11.4k] ------------------ 102| 0| return 1; 103| | 104| | /* Return on EOF. */ 105| | 106| 30.0k| if (parser->eof) return 1; ------------------ | Branch (106:9): [True: 4, False: 30.0k] ------------------ 107| | 108| | /* Move the remaining bytes in the raw buffer to the beginning. */ 109| | 110| 30.0k| if (parser->raw_buffer.start < parser->raw_buffer.pointer ------------------ | Branch (110:9): [True: 18.6k, False: 11.4k] ------------------ 111| 18.6k| && parser->raw_buffer.pointer < parser->raw_buffer.last) { ------------------ | Branch (111:16): [True: 377, False: 18.2k] ------------------ 112| 377| memmove(parser->raw_buffer.start, parser->raw_buffer.pointer, 113| 377| parser->raw_buffer.last - parser->raw_buffer.pointer); 114| 377| } 115| 30.0k| parser->raw_buffer.last -= 116| 30.0k| parser->raw_buffer.pointer - parser->raw_buffer.start; 117| 30.0k| parser->raw_buffer.pointer = parser->raw_buffer.start; 118| | 119| | /* Call the read handler to fill the buffer. */ 120| | 121| 30.0k| if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last, ------------------ | Branch (121:9): [True: 0, False: 30.0k] ------------------ 122| 30.0k| parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) { 123| 0| return yaml_parser_set_reader_error(parser, "input error", 124| 0| parser->offset, -1); 125| 0| } 126| 30.0k| parser->raw_buffer.last += size_read; 127| 30.0k| if (!size_read) { ------------------ | Branch (127:9): [True: 10.3k, False: 19.6k] ------------------ 128| 10.3k| parser->eof = 1; 129| 10.3k| } 130| | 131| 30.0k| return 1; 132| 30.0k|} reader.c:yaml_parser_set_reader_error: 28| 272|{ 29| 272| parser->error = YAML_READER_ERROR; 30| 272| parser->problem = problem; 31| 272| parser->problem_offset = offset; 32| 272| parser->problem_value = value; 33| | 34| 272| return 0; 35| 272|} yaml_parser_fetch_more_tokens: 808| 15.5M|{ 809| 15.5M| int need_more_tokens; 810| | 811| | /* While we need more tokens to fetch, do it. */ 812| | 813| 25.9M| while (1) ------------------ | Branch (813:12): [True: 25.9M, Folded] ------------------ 814| 25.9M| { 815| | /* 816| | * Check if we really need to fetch more tokens. 817| | */ 818| | 819| 25.9M| need_more_tokens = 0; 820| | 821| 25.9M| if (parser->tokens.head == parser->tokens.tail) ------------------ | Branch (821:13): [True: 6.48M, False: 19.4M] ------------------ 822| 6.48M| { 823| | /* Queue is empty. */ 824| | 825| 6.48M| need_more_tokens = 1; 826| 6.48M| } 827| 19.4M| else 828| 19.4M| { 829| 19.4M| yaml_simple_key_t *simple_key; 830| | 831| | /* Check if any potential simple key may occupy the head position. */ 832| | 833| 19.4M| if (!yaml_parser_stale_simple_keys(parser)) ------------------ | Branch (833:17): [True: 32, False: 19.4M] ------------------ 834| 32| return 0; 835| | 836| 19.4M| for (simple_key = parser->simple_keys.start; 837| 106M| simple_key != parser->simple_keys.top; simple_key++) { ------------------ | Branch (837:21): [True: 90.9M, False: 15.5M] ------------------ 838| 90.9M| if (simple_key->possible ------------------ | Branch (838:21): [True: 6.82M, False: 84.1M] ------------------ 839| 6.82M| && simple_key->token_number == parser->tokens_parsed) { ------------------ | Branch (839:28): [True: 3.86M, False: 2.96M] ------------------ 840| 3.86M| need_more_tokens = 1; 841| 3.86M| break; 842| 3.86M| } 843| 90.9M| } 844| 19.4M| } 845| | 846| | /* We are finished. */ 847| | 848| 25.9M| if (!need_more_tokens) ------------------ | Branch (848:13): [True: 15.5M, False: 10.3M] ------------------ 849| 15.5M| break; 850| | 851| | /* Fetch the next token. */ 852| | 853| 10.3M| if (!yaml_parser_fetch_next_token(parser)) ------------------ | Branch (853:13): [True: 2.34k, False: 10.3M] ------------------ 854| 2.34k| return 0; 855| 10.3M| } 856| | 857| 15.5M| parser->token_available = 1; 858| | 859| 15.5M| return 1; 860| 15.5M|} scanner.c:yaml_parser_fetch_next_token: 868| 10.3M|{ 869| | /* Ensure that the buffer is initialized. */ 870| | 871| 10.3M| if (!CACHE(parser, 1)) ------------------ | | 493| 10.3M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 10.3M, False: 10.9k] | | ------------------ | | 494| 10.3M| ? 1 \ | | 495| 10.3M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (871:9): [True: 144, False: 10.3M] ------------------ 872| 144| return 0; 873| | 874| | /* Check if we just started scanning. Fetch STREAM-START then. */ 875| | 876| 10.3M| if (!parser->stream_start_produced) ------------------ | Branch (876:9): [True: 10.8k, False: 10.3M] ------------------ 877| 10.8k| return yaml_parser_fetch_stream_start(parser); 878| | 879| | /* Eat whitespaces and comments until we reach the next token. */ 880| | 881| 10.3M| if (!yaml_parser_scan_to_next_token(parser)) ------------------ | Branch (881:9): [True: 11, False: 10.3M] ------------------ 882| 11| return 0; 883| | 884| | /* Remove obsolete potential simple keys. */ 885| | 886| 10.3M| if (!yaml_parser_stale_simple_keys(parser)) ------------------ | Branch (886:9): [True: 6, False: 10.3M] ------------------ 887| 6| return 0; 888| | 889| | /* Check the indentation level against the current column. */ 890| | 891| 10.3M| if (!yaml_parser_unroll_indent(parser, parser->mark.column)) ------------------ | Branch (891:9): [True: 0, False: 10.3M] ------------------ 892| 0| return 0; 893| | 894| | /* 895| | * Ensure that the buffer contains at least 4 characters. 4 is the length 896| | * of the longest indicators ('--- ' and '... '). 897| | */ 898| | 899| 10.3M| if (!CACHE(parser, 4)) ------------------ | | 493| 10.3M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 10.3M, False: 16.7k] | | ------------------ | | 494| 10.3M| ? 1 \ | | 495| 10.3M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (899:9): [True: 13, False: 10.3M] ------------------ 900| 13| return 0; 901| | 902| | /* Is it the end of the stream? */ 903| | 904| 10.3M| if (IS_Z(parser->buffer)) ------------------ | | 287| 10.3M|#define IS_Z(string) IS_Z_AT((string),0) | | ------------------ | | | | 285| 10.3M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | ------------------ | | | | | | 175| 10.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 7.86k, False: 10.3M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 905| 7.86k| return yaml_parser_fetch_stream_end(parser); 906| | 907| | /* Is it a directive? */ 908| | 909| 10.3M| if (parser->mark.column == 0 && CHECK(parser->buffer, '%')) ------------------ | | 181| 1.01M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.01M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 115k, False: 904k] | | ------------------ ------------------ | Branch (909:9): [True: 1.01M, False: 9.30M] ------------------ 910| 115k| return yaml_parser_fetch_directive(parser); 911| | 912| | /* Is it the document start indicator? */ 913| | 914| 10.2M| if (parser->mark.column == 0 ------------------ | Branch (914:9): [True: 904k, False: 9.30M] ------------------ 915| 904k| && CHECK_AT(parser->buffer, '-', 0) ------------------ | | 175| 11.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 652k, False: 251k] | | ------------------ ------------------ 916| 652k| && CHECK_AT(parser->buffer, '-', 1) ------------------ | | 175| 10.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 74.6k, False: 577k] | | ------------------ ------------------ 917| 74.6k| && CHECK_AT(parser->buffer, '-', 2) ------------------ | | 175| 10.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 57.9k, False: 16.7k] | | ------------------ ------------------ 918| 57.9k| && IS_BLANKZ_AT(parser->buffer, 3)) ------------------ | | 371| 57.9k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 115k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 57.9k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 115k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.57k, False: 56.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 56.3k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 56.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 481, False: 55.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 55.9k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 111k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 111k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 28.1k, False: 27.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 55.9k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 83.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 18.9k, False: 8.74k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 55.9k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 17.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.79k, False: 2.95k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 8.74k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 5.79k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.58k, False: 201] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 55.9k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 6.30k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.16k, False: 985] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 3.15k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 5.31k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.23k, False: 934] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 3.15k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.23k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 596, False: 636] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 111k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.11k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.57k, False: 985] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 2.55k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 4.12k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 636, False: 934] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 2.55k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 636| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 434, False: 202] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 2.12k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.12k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 311, False: 1.81k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 919| 56.1k| return yaml_parser_fetch_document_indicator(parser, 920| 56.1k| YAML_DOCUMENT_START_TOKEN); 921| | 922| | /* Is it the document end indicator? */ 923| | 924| 10.1M| if (parser->mark.column == 0 ------------------ | Branch (924:9): [True: 848k, False: 9.30M] ------------------ 925| 848k| && CHECK_AT(parser->buffer, '.', 0) ------------------ | | 175| 10.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 5.51k, False: 842k] | | ------------------ ------------------ 926| 5.51k| && CHECK_AT(parser->buffer, '.', 1) ------------------ | | 175| 10.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 3.10k, False: 2.41k] | | ------------------ ------------------ 927| 3.10k| && CHECK_AT(parser->buffer, '.', 2) ------------------ | | 175| 10.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.84k, False: 257] | | ------------------ ------------------ 928| 2.84k| && IS_BLANKZ_AT(parser->buffer, 3)) ------------------ | | 371| 2.84k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 5.69k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 2.84k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 5.69k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 67, False: 2.77k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 2.77k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.77k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 194, False: 2.58k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 2.58k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 5.16k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 5.16k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 710, False: 1.87k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 2.58k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 4.45k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 359, False: 1.51k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 2.58k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 3.03k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 260, False: 1.25k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.51k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 260| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 66, False: 194] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 2.58k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.89k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 955, False: 494] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 1.44k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 2.40k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 692, False: 263] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 1.44k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 692| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 263, False: 429] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 5.16k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.37k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 692, False: 494] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 1.18k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.87k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 429, False: 263] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 1.18k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 429| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 228, False: 201] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 958|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 958| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 33, False: 925] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 929| 1.92k| return yaml_parser_fetch_document_indicator(parser, 930| 1.92k| YAML_DOCUMENT_END_TOKEN); 931| | 932| | /* Is it the flow sequence start indicator? */ 933| | 934| 10.1M| if (CHECK(parser->buffer, '[')) ------------------ | | 181| 10.1M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 10.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 55.4k, False: 10.0M] | | ------------------ ------------------ 935| 55.4k| return yaml_parser_fetch_flow_collection_start(parser, 936| 55.4k| YAML_FLOW_SEQUENCE_START_TOKEN); 937| | 938| | /* Is it the flow mapping start indicator? */ 939| | 940| 10.0M| if (CHECK(parser->buffer, '{')) ------------------ | | 181| 10.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 10.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 23.6k, False: 10.0M] | | ------------------ ------------------ 941| 23.6k| return yaml_parser_fetch_flow_collection_start(parser, 942| 23.6k| YAML_FLOW_MAPPING_START_TOKEN); 943| | 944| | /* Is it the flow sequence end indicator? */ 945| | 946| 10.0M| if (CHECK(parser->buffer, ']')) ------------------ | | 181| 10.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 10.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 37.4k, False: 10.0M] | | ------------------ ------------------ 947| 37.4k| return yaml_parser_fetch_flow_collection_end(parser, 948| 37.4k| YAML_FLOW_SEQUENCE_END_TOKEN); 949| | 950| | /* Is it the flow mapping end indicator? */ 951| | 952| 10.0M| if (CHECK(parser->buffer, '}')) ------------------ | | 181| 10.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 10.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.53k, False: 10.0M] | | ------------------ ------------------ 953| 6.53k| return yaml_parser_fetch_flow_collection_end(parser, 954| 6.53k| YAML_FLOW_MAPPING_END_TOKEN); 955| | 956| | /* Is it the flow entry indicator? */ 957| | 958| 10.0M| if (CHECK(parser->buffer, ',')) ------------------ | | 181| 10.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 10.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.04M, False: 6.97M] | | ------------------ ------------------ 959| 3.04M| return yaml_parser_fetch_flow_entry(parser); 960| | 961| | /* Is it the block entry indicator? */ 962| | 963| 6.97M| if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1)) ------------------ | | 181| 13.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 6.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 687k, False: 6.29M] | | ------------------ ------------------ if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1)) ------------------ | | 371| 687k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 1.37M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 687k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.37M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 562k, False: 125k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 125k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 125k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 378, False: 124k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 124k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 249k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 249k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.02k, False: 119k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 124k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 244k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.6k, False: 105k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 124k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 210k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 630, False: 104k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 105k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 630| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 430, False: 200] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 124k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 209k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 764, False: 103k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 104k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 105k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 564, False: 200] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 104k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 564| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 134, False: 430] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 249k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 209k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 630, False: 103k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 104k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 105k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 430, False: 200] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 104k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 430| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 231, False: 199] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 104k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 104k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 326, False: 103k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 964| 583k| return yaml_parser_fetch_block_entry(parser); 965| | 966| | /* Is it the key indicator? */ 967| | 968| 6.39M| if (CHECK(parser->buffer, '?') ------------------ | | 181| 12.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 6.39M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.01M, False: 4.37M] | | ------------------ ------------------ 969| 2.01M| && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) ------------------ | | 371| 1.98M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 3.97M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 1.98M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 3.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.81M, False: 170k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 170k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 170k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 170k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 170k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 340k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 340k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 84.9k, False: 85.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 170k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 255k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 20.0k, False: 65.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 170k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 130k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 874, False: 64.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 65.4k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 874| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 217, False: 657] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 170k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 130k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.23k, False: 64.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 65.2k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 66.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.03k, False: 195] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 65.2k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.03k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 565, False: 474] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 340k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 129k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 669, False: 64.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 64.6k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 65.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 474, False: 195] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 64.6k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 474| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 268, False: 206] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 64.4k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 64.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 318, False: 64.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (969:17): [True: 29.3k, False: 1.98M] ------------------ 970| 1.95M| return yaml_parser_fetch_key(parser); 971| | 972| | /* Is it the value indicator? */ 973| | 974| 4.44M| if (CHECK(parser->buffer, ':') ------------------ | | 181| 8.88M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 4.44M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 854k, False: 3.58M] | | ------------------ ------------------ 975| 854k| && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) ------------------ | | 371| 841k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 1.68M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 841k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.68M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 4.67k, False: 836k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 836k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 836k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 224, False: 836k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 836k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 1.67M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 1.67M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 39.8k, False: 796k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 836k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.63M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 574k, False: 222k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 836k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 444k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 411, False: 222k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 222k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 411| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 204, False: 207] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 836k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 444k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.49k, False: 220k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 222k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 223k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.28k, False: 209] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 222k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.28k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 567, False: 720] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 1.67M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 443k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 929, False: 220k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 221k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 222k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 720, False: 209] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 221k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 720| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 419, False: 301] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 221k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 221k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 284, False: 221k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (975:17): [True: 13.3k, False: 841k] ------------------ 976| 633k| return yaml_parser_fetch_value(parser); 977| | 978| | /* Is it an alias? */ 979| | 980| 3.80M| if (CHECK(parser->buffer, '*')) ------------------ | | 181| 3.80M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.80M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 144k, False: 3.66M] | | ------------------ ------------------ 981| 144k| return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN); 982| | 983| | /* Is it an anchor? */ 984| | 985| 3.66M| if (CHECK(parser->buffer, '&')) ------------------ | | 181| 3.66M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.66M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.39k, False: 3.65M] | | ------------------ ------------------ 986| 8.39k| return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN); 987| | 988| | /* Is it a tag? */ 989| | 990| 3.65M| if (CHECK(parser->buffer, '!')) ------------------ | | 181| 3.65M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.65M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 14.1k, False: 3.64M] | | ------------------ ------------------ 991| 14.1k| return yaml_parser_fetch_tag(parser); 992| | 993| | /* Is it a literal scalar? */ 994| | 995| 3.64M| if (CHECK(parser->buffer, '|') && !parser->flow_level) ------------------ | | 181| 7.28M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.64M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 22.2k, False: 3.61M] | | ------------------ ------------------ | Branch (995:39): [True: 22.2k, False: 10] ------------------ 996| 22.2k| return yaml_parser_fetch_block_scalar(parser, 1); 997| | 998| | /* Is it a folded scalar? */ 999| | 1000| 3.61M| if (CHECK(parser->buffer, '>') && !parser->flow_level) ------------------ | | 181| 7.23M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.61M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 13.2k, False: 3.60M] | | ------------------ ------------------ | Branch (1000:39): [True: 13.2k, False: 6] ------------------ 1001| 13.2k| return yaml_parser_fetch_block_scalar(parser, 0); 1002| | 1003| | /* Is it a single-quoted scalar? */ 1004| | 1005| 3.60M| if (CHECK(parser->buffer, '\'')) ------------------ | | 181| 3.60M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.60M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.78k, False: 3.59M] | | ------------------ ------------------ 1006| 8.78k| return yaml_parser_fetch_flow_scalar(parser, 1); 1007| | 1008| | /* Is it a double-quoted scalar? */ 1009| | 1010| 3.59M| if (CHECK(parser->buffer, '"')) ------------------ | | 181| 3.59M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.28k, False: 3.58M] | | ------------------ ------------------ 1011| 9.28k| return yaml_parser_fetch_flow_scalar(parser, 0); 1012| | 1013| | /* 1014| | * Is it a plain scalar? 1015| | * 1016| | * A plain scalar may start with any non-blank characters except 1017| | * 1018| | * '-', '?', ':', ',', '[', ']', '{', '}', 1019| | * '#', '&', '*', '!', '|', '>', '\'', '\"', 1020| | * '%', '@', '`'. 1021| | * 1022| | * In the block context (and, for the '-' indicator, in the flow context 1023| | * too), it may also start with the characters 1024| | * 1025| | * '-', '?', ':' 1026| | * 1027| | * if it is followed by a non-space character. 1028| | * 1029| | * The last rule is more restrictive than the specification requires. 1030| | */ 1031| | 1032| 3.58M| if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-') ------------------ | | 373| 3.58M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 7.17M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 7.17M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 3.58M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 7.17M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 3.58M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 3.58M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 12, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 3.58M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 7.17M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.17M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 3.58M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.17M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 3.58M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.17M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 906, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 3.58M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 906| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 906] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 3.58M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.17M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.19k, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 3.58M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.58M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 495, False: 704] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 3.58M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 495| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 495] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 7.17M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.17M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.19k, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 3.58M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.58M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 495, False: 704] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 3.58M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 495| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 495] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 3.58M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 3.58M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.58M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-') ------------------ | | 181| 7.17M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.58M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 103k, False: 3.48M] | | ------------------ ------------------ 1033| 3.48M| || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') ------------------ | | 181| 7.06M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.48M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 64.1k, False: 3.41M] | | ------------------ ------------------ || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') ------------------ | | 181| 7.00M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 221k, False: 3.19M] | | ------------------ ------------------ 1034| 3.19M| || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ 1035| 3.19M| || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ 1036| 3.19M| || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ 1037| 3.19M| || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ 1038| 3.19M| || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10, False: 3.19M] | | ------------------ ------------------ 1039| 3.19M| || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ 1040| 3.19M| || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%') ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 11, False: 3.19M] | | ------------------ ------------------ 1041| 3.19M| || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) || ------------------ | | 181| 6.78M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9, False: 3.19M] | | ------------------ ------------------ || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) || ------------------ | | 181| 3.19M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.19M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10, False: 3.19M] | | ------------------ ------------------ 1042| 389k| (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) || ------------------ | | 181| 778k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 389k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 103k, False: 285k] | | ------------------ ------------------ (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) || ------------------ | | 321| 103k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | ------------------ | | | | 304| 103k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 207k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 103k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | ------------------ | | | | 312| 103k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | ------------------ | | | | | | 175| 103k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 103k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1043| 285k| (!parser->flow_level && ------------------ | Branch (1043:14): [True: 285k, False: 24] ------------------ 1044| 285k| (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')) ------------------ | | 181| 570k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 285k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 64.1k, False: 221k] | | ------------------ ------------------ (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')) ------------------ | | 181| 221k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 221k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 221k, False: 34] | | ------------------ ------------------ 1045| 285k| && !IS_BLANKZ_AT(parser->buffer, 1))) ------------------ | | 371| 285k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 570k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 285k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 570k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 285k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 285k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 285k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 285k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 285k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 570k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 570k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 285k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 285k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 570k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 285k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 285k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 570k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 864, False: 284k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 285k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 864| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 864] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 285k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 570k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 911, False: 284k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 285k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 286k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 507, False: 404] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 285k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 507| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 507] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 570k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 570k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 911, False: 284k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 285k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 286k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 507, False: 404] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 285k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 507| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 507] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 285k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 285k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 285k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1046| 3.58M| return yaml_parser_fetch_plain_scalar(parser); 1047| | 1048| | /* 1049| | * If we don't determine the token type so far, it is an error. 1050| | */ 1051| | 1052| 58| return yaml_parser_set_scanner_error(parser, 1053| 58| "while scanning for the next token", parser->mark, 1054| 58| "found character that cannot start any token"); 1055| 3.58M|} scanner.c:yaml_parser_fetch_stream_start: 1311| 10.8k|{ 1312| 10.8k| yaml_simple_key_t simple_key = { 0, 0, 0, { 0, 0, 0 } }; 1313| 10.8k| yaml_token_t token; 1314| | 1315| | /* Set the initial indentation. */ 1316| | 1317| 10.8k| parser->indent = -1; 1318| | 1319| | /* Initialize the simple key stack. */ 1320| | 1321| 10.8k| if (!PUSH(parser, parser->simple_keys, simple_key)) ------------------ | | 445| 10.8k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 10.8k, False: 0] | | ------------------ | | 446| 10.8k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 10.8k| (*((stack).top++) = value, \ | | 449| 10.8k| 1) : \ | | 450| 10.8k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1321:9): [True: 0, False: 10.8k] ------------------ 1322| 0| return 0; 1323| | 1324| | /* A simple key is allowed at the beginning of the stream. */ 1325| | 1326| 10.8k| parser->simple_key_allowed = 1; 1327| | 1328| | /* We have started. */ 1329| | 1330| 10.8k| parser->stream_start_produced = 1; 1331| | 1332| | /* Create the STREAM-START token and append it to the queue. */ 1333| | 1334| 10.8k| STREAM_START_TOKEN_INIT(token, parser->encoding, ------------------ | | 506| 10.8k| (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 10.8k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 10.8k| (token).type = (token_type), \ | | | | 502| 10.8k| (token).start_mark = (token_start_mark), \ | | | | 503| 10.8k| (token).end_mark = (token_end_mark)) | | ------------------ | | 507| 10.8k| (token).data.stream_start.encoding = (token_encoding)) ------------------ 1335| 10.8k| parser->mark, parser->mark); 1336| | 1337| 10.8k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 10.8k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 10.8k, False: 0] | | ------------------ | | 473| 10.8k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 0, False: 0] | | ------------------ | | 474| 0| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 10.8k| (*((queue).tail++) = value, \ | | 476| 10.8k| 1) : \ | | 477| 10.8k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1337:9): [True: 0, False: 10.8k] ------------------ 1338| 0| return 0; 1339| | 1340| 10.8k| return 1; 1341| 10.8k|} scanner.c:yaml_parser_scan_to_next_token: 1939| 10.3M|{ 1940| | /* Until the next token is not found. */ 1941| | 1942| 13.9M| while (1) ------------------ | Branch (1942:12): [True: 13.9M, Folded] ------------------ 1943| 13.9M| { 1944| | /* Allow the BOM mark to start a line. */ 1945| | 1946| 13.9M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 13.9M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 13.9M, False: 133] | | ------------------ | | 494| 13.9M| ? 1 \ | | 495| 13.9M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1946:13): [True: 1, False: 13.9M] ------------------ 1947| | 1948| 13.9M| if (parser->mark.column == 0 && IS_BOM(parser->buffer)) ------------------ | | 298| 3.84M|#define IS_BOM(string) IS_BOM_AT(string,0) | | ------------------ | | | | 294| 3.84M| (CHECK_AT((string),'\xEF',(offset)) \ | | | | ------------------ | | | | | | 175| 7.68M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.51k, False: 3.84M] | | | | | | ------------------ | | | | ------------------ | | | | 295| 3.84M| && CHECK_AT((string),'\xBB',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.00k, False: 507] | | | | | | ------------------ | | | | ------------------ | | | | 296| 3.84M| && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */ | | | | ------------------ | | | | | | 175| 1.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 516, False: 492] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1948:13): [True: 3.84M, False: 10.0M] ------------------ 1949| 516| SKIP(parser); ------------------ | | 502| 516| (parser->mark.index ++, \ | | 503| 516| parser->mark.column ++, \ | | 504| 516| parser->unread --, \ | | 505| 516| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 516|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 516| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 0, False: 516] | | | | | | ------------------ | | | | | | 381| 516| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 516] | | | | | | ------------------ | | | | | | 382| 516| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 516, False: 0] | | | | | | ------------------ | | | | | | 383| 516| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1950| | 1951| | /* 1952| | * Eat whitespaces. 1953| | * 1954| | * Tabs are allowed: 1955| | * 1956| | * - in the flow context; 1957| | * - in the block context, but not at the beginning of the line or 1958| | * after '-', '?', or ':' (complex value). 1959| | */ 1960| | 1961| 13.9M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 13.9M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 13.9M, False: 18] | | ------------------ | | 494| 13.9M| ? 1 \ | | 495| 13.9M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1961:13): [True: 2, False: 13.9M] ------------------ 1962| | 1963| 31.8M| while (CHECK(parser->buffer,' ') || ------------------ | | 181| 63.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 31.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 17.9M, False: 13.9M] | | ------------------ ------------------ 1964| 13.9M| ((parser->flow_level || !parser->simple_key_allowed) && ------------------ | Branch (1964:19): [True: 7.38M, False: 6.55M] | Branch (1964:41): [True: 1.43M, False: 5.11M] ------------------ 1965| 17.9M| CHECK(parser->buffer, '\t'))) { ------------------ | | 181| 8.81M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 8.81M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.77k, False: 8.81M] | | ------------------ ------------------ 1966| 17.9M| SKIP(parser); ------------------ | | 502| 17.9M| (parser->mark.index ++, \ | | 503| 17.9M| parser->mark.column ++, \ | | 504| 17.9M| parser->unread --, \ | | 505| 17.9M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 17.9M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 17.9M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 17.9M, False: 0] | | | | | | ------------------ | | | | | | 381| 17.9M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1967| 17.9M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 17.9M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 17.9M, False: 937] | | ------------------ | | 494| 17.9M| ? 1 \ | | 495| 17.9M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1967:17): [True: 2, False: 17.9M] ------------------ 1968| 17.9M| } 1969| | 1970| | /* Eat a comment until a line break. */ 1971| | 1972| 13.9M| if (CHECK(parser->buffer, '#')) { ------------------ | | 181| 13.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.31k, False: 13.9M] | | ------------------ ------------------ 1973| 2.42M| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 2.42M|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 2.42M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 4.84M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 4.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 680, False: 2.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 2.42M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 4.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 370, False: 2.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 2.42M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 4.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.04k, False: 2.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 2.42M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.04k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 510, False: 531] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 2.42M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 4.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 195k, False: 2.22M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 2.42M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 2.61M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 187k, False: 8.10k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 2.42M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 187k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 286, False: 187k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 4.84M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 4.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 195k, False: 2.22M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 2.42M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 2.61M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 187k, False: 8.10k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 2.42M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 187k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 363, False: 186k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 2.42M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.42M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 99, False: 2.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1974| 2.42M| SKIP(parser); ------------------ | | 502| 2.42M| (parser->mark.index ++, \ | | 503| 2.42M| parser->mark.column ++, \ | | 504| 2.42M| parser->unread --, \ | | 505| 2.42M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.42M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.42M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.20M, False: 221k] | | | | | | ------------------ | | | | | | 381| 2.42M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 538, False: 221k] | | | | | | ------------------ | | | | | | 382| 221k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 221k, False: 194] | | | | | | ------------------ | | | | | | 383| 221k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 194, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1975| 2.42M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 2.42M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.42M, False: 251] | | ------------------ | | 494| 2.42M| ? 1 \ | | 495| 2.42M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1975:21): [True: 3, False: 2.42M] ------------------ 1976| 2.42M| } 1977| 2.31k| } 1978| | 1979| | /* If it is a line break, eat it. */ 1980| | 1981| 13.9M| if (IS_BREAK(parser->buffer)) ------------------ | | 341| 13.9M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 13.9M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 27.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.93M, False: 11.9M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 13.9M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 25.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.65M, False: 10.3M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 13.9M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 20.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.98k, False: 10.3M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 10.3M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 8.98k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.08k, False: 906] | | | | | | ------------------ | | | | ------------------ | | | | 334| 13.9M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 20.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 7.09k, False: 10.3M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 10.3M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 10.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 6.39k, False: 704] | | | | | | ------------------ | | | | ------------------ | | | | 336| 10.3M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 6.39k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.29k, False: 3.09k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 13.9M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 20.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.80k, False: 10.3M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 10.3M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 10.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.09k, False: 704] | | | | | | ------------------ | | | | ------------------ | | | | 339| 10.3M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 3.09k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.60k, False: 495] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1982| 3.60M| { 1983| 3.60M| if (!CACHE(parser, 2)) return 0; ------------------ | | 493| 3.60M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 3.60M, False: 363] | | ------------------ | | 494| 3.60M| ? 1 \ | | 495| 3.60M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1983:17): [True: 3, False: 3.60M] ------------------ 1984| 3.60M| SKIP_LINE(parser); ------------------ | | 508| 3.60M| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 3.60M|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 3.60M| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 7.20M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.93M, False: 1.66M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 1.93M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.62M, False: 312k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 3.60M| (parser->mark.index += 2, \ | | 510| 1.62M| parser->mark.column = 0, \ | | 511| 1.62M| parser->mark.line ++, \ | | 512| 1.62M| parser->unread -= 2, \ | | 513| 1.62M| parser->buffer.pointer += 2) : \ | | 514| 3.60M| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 1.98M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 3.96M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 3.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 312k, False: 1.66M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 1.98M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 3.64M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.65M, False: 13.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 1.98M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 27.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.07k, False: 5.89k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 13.9k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 8.07k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.07k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 1.98M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 11.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.89k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 5.89k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 11.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.89k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 5.89k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 5.89k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.29k, False: 2.60k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 3.96M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.20k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.60k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 2.60k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 5.20k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.60k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 2.60k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 2.60k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.60k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 515| 1.98M| (parser->mark.index ++, \ | | 516| 1.98M| parser->mark.column = 0, \ | | 517| 1.98M| parser->mark.line ++, \ | | 518| 1.98M| parser->unread --, \ | | 519| 1.98M| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 1.98M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.98M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.96M, False: 13.9k] | | | | | | ------------------ | | | | | | 381| 1.98M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 8.07k, False: 5.89k] | | | | | | ------------------ | | | | | | 382| 13.9k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 5.89k, False: 0] | | | | | | ------------------ | | | | | | 383| 5.89k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1985| | 1986| | /* In the block context, a new line may start a simple key. */ 1987| | 1988| 3.60M| if (!parser->flow_level) { ------------------ | Branch (1988:17): [True: 2.48M, False: 1.11M] ------------------ 1989| 2.48M| parser->simple_key_allowed = 1; 1990| 2.48M| } 1991| 3.60M| } 1992| 10.3M| else 1993| 10.3M| { 1994| | /* We have found a token. */ 1995| | 1996| 10.3M| break; 1997| 10.3M| } 1998| 13.9M| } 1999| | 2000| 10.3M| return 1; 2001| 10.3M|} scanner.c:yaml_parser_unroll_indent: 1278| 10.5M|{ 1279| 10.5M| yaml_token_t token; 1280| | 1281| | /* In the flow context, do nothing. */ 1282| | 1283| 10.5M| if (parser->flow_level) ------------------ | Branch (1283:9): [True: 6.26M, False: 4.24M] ------------------ 1284| 6.26M| return 1; 1285| | 1286| | /* Loop through the indentation levels in the stack. */ 1287| | 1288| 6.56M| while (parser->indent > column) ------------------ | Branch (1288:12): [True: 2.32M, False: 4.24M] ------------------ 1289| 2.32M| { 1290| | /* Create a token and append it to the queue. */ 1291| | 1292| 2.32M| TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark); ------------------ | | 500| 2.32M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 2.32M| (token).type = (token_type), \ | | 502| 2.32M| (token).start_mark = (token_start_mark), \ | | 503| 2.32M| (token).end_mark = (token_end_mark)) ------------------ 1293| | 1294| 2.32M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 2.32M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 2.21M, False: 102k] | | ------------------ | | 473| 2.32M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 102k, False: 0] | | ------------------ | | 474| 102k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 2.32M| (*((queue).tail++) = value, \ | | 476| 2.32M| 1) : \ | | 477| 2.32M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1294:13): [True: 0, False: 2.32M] ------------------ 1295| 0| return 0; 1296| | 1297| | /* Pop the indentation level. */ 1298| | 1299| 2.32M| parser->indent = POP(parser, parser->indents); ------------------ | | 454| 2.32M| (*(--(stack).top)) ------------------ 1300| 2.32M| } 1301| | 1302| 4.24M| return 1; 1303| 4.24M|} scanner.c:yaml_parser_fetch_stream_end: 1349| 7.86k|{ 1350| 7.86k| yaml_token_t token; 1351| | 1352| | /* Force new line. */ 1353| | 1354| 7.86k| if (parser->mark.column != 0) { ------------------ | Branch (1354:9): [True: 6.87k, False: 993] ------------------ 1355| 6.87k| parser->mark.column = 0; 1356| 6.87k| parser->mark.line ++; 1357| 6.87k| } 1358| | 1359| | /* Reset the indentation level. */ 1360| | 1361| 7.86k| if (!yaml_parser_unroll_indent(parser, -1)) ------------------ | Branch (1361:9): [True: 0, False: 7.86k] ------------------ 1362| 0| return 0; 1363| | 1364| | /* Reset simple keys. */ 1365| | 1366| 7.86k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1366:9): [True: 130, False: 7.73k] ------------------ 1367| 130| return 0; 1368| | 1369| 7.73k| parser->simple_key_allowed = 0; 1370| | 1371| | /* Create the STREAM-END token and append it to the queue. */ 1372| | 1373| 7.73k| STREAM_END_TOKEN_INIT(token, parser->mark, parser->mark); ------------------ | | 510| 7.73k| (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) | | ------------------ | | | | 500| 7.73k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 7.73k| (token).type = (token_type), \ | | | | 502| 7.73k| (token).start_mark = (token_start_mark), \ | | | | 503| 7.73k| (token).end_mark = (token_end_mark)) | | ------------------ ------------------ 1374| | 1375| 7.73k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 7.73k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 7.49k, False: 244] | | ------------------ | | 473| 7.73k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 244, False: 0] | | ------------------ | | 474| 244| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 7.73k| (*((queue).tail++) = value, \ | | 476| 7.73k| 1) : \ | | 477| 7.73k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1375:9): [True: 0, False: 7.73k] ------------------ 1376| 0| return 0; 1377| | 1378| 7.73k| return 1; 1379| 7.73k|} scanner.c:yaml_parser_remove_simple_key: 1142| 9.65M|{ 1143| 9.65M| yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 1144| | 1145| 9.65M| if (simple_key->possible) ------------------ | Branch (1145:9): [True: 3.04M, False: 6.61M] ------------------ 1146| 3.04M| { 1147| | /* If the key is required, it is an error. */ 1148| | 1149| 3.04M| if (simple_key->required) { ------------------ | Branch (1149:13): [True: 133, False: 3.04M] ------------------ 1150| 133| return yaml_parser_set_scanner_error(parser, 1151| 133| "while scanning a simple key", simple_key->mark, 1152| 133| "could not find expected ':'"); 1153| 133| } 1154| 3.04M| } 1155| | 1156| | /* Remove the key from the stack. */ 1157| | 1158| 9.65M| simple_key->possible = 0; 1159| | 1160| 9.65M| return 1; 1161| 9.65M|} scanner.c:yaml_parser_fetch_directive: 1387| 115k|{ 1388| 115k| yaml_token_t token; 1389| | 1390| | /* Reset the indentation level. */ 1391| | 1392| 115k| if (!yaml_parser_unroll_indent(parser, -1)) ------------------ | Branch (1392:9): [True: 0, False: 115k] ------------------ 1393| 0| return 0; 1394| | 1395| | /* Reset simple keys. */ 1396| | 1397| 115k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1397:9): [True: 0, False: 115k] ------------------ 1398| 0| return 0; 1399| | 1400| 115k| parser->simple_key_allowed = 0; 1401| | 1402| | /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */ 1403| | 1404| 115k| if (!yaml_parser_scan_directive(parser, &token)) ------------------ | Branch (1404:9): [True: 425, False: 115k] ------------------ 1405| 425| return 0; 1406| | 1407| | /* Append the token to the queue. */ 1408| | 1409| 115k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 115k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 108k, False: 6.81k] | | ------------------ | | 473| 115k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 6.81k, False: 0] | | ------------------ | | 474| 6.81k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 115k| (*((queue).tail++) = value, \ | | 476| 115k| 1) : \ | | 477| 115k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1409:9): [True: 0, False: 115k] ------------------ 1410| 0| yaml_token_delete(&token); 1411| 0| return 0; 1412| 0| } 1413| | 1414| 115k| return 1; 1415| 115k|} scanner.c:yaml_parser_scan_directive: 2015| 115k|{ 2016| 115k| yaml_mark_t start_mark, end_mark; 2017| 115k| yaml_char_t *name = NULL; 2018| 115k| int major, minor; 2019| 115k| yaml_char_t *handle = NULL, *prefix = NULL; 2020| | 2021| | /* Eat '%'. */ 2022| | 2023| 115k| start_mark = parser->mark; 2024| | 2025| 115k| SKIP(parser); ------------------ | | 502| 115k| (parser->mark.index ++, \ | | 503| 115k| parser->mark.column ++, \ | | 504| 115k| parser->unread --, \ | | 505| 115k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 115k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 115k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 115k, False: 0] | | | | | | ------------------ | | | | | | 381| 115k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2026| | 2027| | /* Scan the directive name. */ 2028| | 2029| 115k| if (!yaml_parser_scan_directive_name(parser, start_mark, &name)) ------------------ | Branch (2029:9): [True: 83, False: 115k] ------------------ 2030| 83| goto error; 2031| | 2032| | /* Is it a YAML directive? */ 2033| | 2034| 115k| if (strcmp((char *)name, "YAML") == 0) ------------------ | Branch (2034:9): [True: 9.30k, False: 106k] ------------------ 2035| 9.30k| { 2036| | /* Scan the VERSION directive value. */ 2037| | 2038| 9.30k| if (!yaml_parser_scan_version_directive_value(parser, start_mark, ------------------ | Branch (2038:13): [True: 70, False: 9.23k] ------------------ 2039| 9.30k| &major, &minor)) 2040| 70| goto error; 2041| | 2042| 9.23k| end_mark = parser->mark; 2043| | 2044| | /* Create a VERSION-DIRECTIVE token. */ 2045| | 2046| 9.23k| VERSION_DIRECTIVE_TOKEN_INIT(*token, major, minor, ------------------ | | 532| 9.23k| (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 9.23k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 9.23k| (token).type = (token_type), \ | | | | 502| 9.23k| (token).start_mark = (token_start_mark), \ | | | | 503| 9.23k| (token).end_mark = (token_end_mark)) | | ------------------ | | 533| 9.23k| (token).data.version_directive.major = (token_major), \ | | 534| 9.23k| (token).data.version_directive.minor = (token_minor)) ------------------ 2047| 9.23k| start_mark, end_mark); 2048| 9.23k| } 2049| | 2050| | /* Is it a TAG directive? */ 2051| | 2052| 106k| else if (strcmp((char *)name, "TAG") == 0) ------------------ | Branch (2052:14): [True: 105k, False: 123] ------------------ 2053| 105k| { 2054| | /* Scan the TAG directive value. */ 2055| | 2056| 105k| if (!yaml_parser_scan_tag_directive_value(parser, start_mark, ------------------ | Branch (2056:13): [True: 114, False: 105k] ------------------ 2057| 105k| &handle, &prefix)) 2058| 114| goto error; 2059| | 2060| 105k| end_mark = parser->mark; 2061| | 2062| | /* Create a TAG-DIRECTIVE token. */ 2063| | 2064| 105k| TAG_DIRECTIVE_TOKEN_INIT(*token, handle, prefix, ------------------ | | 537| 105k| (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 105k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 105k| (token).type = (token_type), \ | | | | 502| 105k| (token).start_mark = (token_start_mark), \ | | | | 503| 105k| (token).end_mark = (token_end_mark)) | | ------------------ | | 538| 105k| (token).data.tag_directive.handle = (token_handle), \ | | 539| 105k| (token).data.tag_directive.prefix = (token_prefix)) ------------------ 2065| 105k| start_mark, end_mark); 2066| 105k| } 2067| | 2068| | /* Unknown directive. */ 2069| | 2070| 123| else 2071| 123| { 2072| 123| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2073| 123| start_mark, "found unknown directive name"); 2074| 123| goto error; 2075| 123| } 2076| | 2077| | /* Eat the rest of the line including any comments. */ 2078| | 2079| 115k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 115k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 115k, False: 0] | | ------------------ | | 494| 115k| ? 1 \ | | 495| 115k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2079:9): [True: 0, False: 115k] ------------------ 2080| | 2081| 926k| while (IS_BLANK(parser->buffer)) { 2082| 926k| SKIP(parser); ------------------ | | 502| 926k| (parser->mark.index ++, \ | | 503| 926k| parser->mark.column ++, \ | | 504| 926k| parser->unread --, \ | | 505| 926k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 926k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 926k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 926k, False: 0] | | | | | | ------------------ | | | | | | 381| 926k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2083| 926k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 926k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 926k, False: 94] | | ------------------ | | 494| 926k| ? 1 \ | | 495| 926k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2083:13): [True: 1, False: 926k] ------------------ 2084| 926k| } 2085| | 2086| 115k| if (CHECK(parser->buffer, '#')) { ------------------ | | 181| 115k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 115k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 11.7k, False: 103k] | | ------------------ ------------------ 2087| 994k| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 994k|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 994k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 1.98M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 1.98M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 10.6k, False: 983k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 994k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 399, False: 983k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 994k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 704, False: 982k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 983k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 704| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 220, False: 484] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 994k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 914, False: 982k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 982k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 983k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 715, False: 199] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 982k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 715| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 279, False: 436] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 1.98M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 635, False: 982k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 982k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 983k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 436, False: 199] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 982k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 436| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 194, False: 242] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 982k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 982k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 82, False: 982k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2088| 982k| SKIP(parser); ------------------ | | 502| 982k| (parser->mark.index ++, \ | | 503| 982k| parser->mark.column ++, \ | | 504| 982k| parser->unread --, \ | | 505| 982k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 982k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 982k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 981k, False: 1.20k] | | | | | | ------------------ | | | | | | 381| 982k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 559, False: 641] | | | | | | ------------------ | | | | | | 382| 1.20k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 444, False: 197] | | | | | | ------------------ | | | | | | 383| 641| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 197, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2089| 982k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 982k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 982k, False: 144] | | ------------------ | | 494| 982k| ? 1 \ | | 495| 982k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2089:17): [True: 2, False: 982k] ------------------ 2090| 982k| } 2091| 11.7k| } 2092| | 2093| | /* Check if we are at the end of the line. */ 2094| | 2095| 115k| if (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 115k|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 115k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 230k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 230k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.7k, False: 100k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 115k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 215k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 98.9k, False: 1.48k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 115k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.97k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 423, False: 1.06k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.48k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 423| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 417, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 115k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.14k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 801, False: 269] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 1.07k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.87k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 800, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 1.07k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 800| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 538, False: 262] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 230k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.06k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 263, False: 269] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 532| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 795| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 262, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 532| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 262| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 261, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 271|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 271| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 240, False: 31] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2096| 31| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2097| 31| start_mark, "did not find expected comment or line break"); 2098| 31| goto error; 2099| 31| } 2100| | 2101| | /* Eat a line break. */ 2102| | 2103| 115k| if (IS_BREAK(parser->buffer)) { ------------------ | | 341| 115k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 115k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 230k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 14.7k, False: 100k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 115k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 215k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 98.9k, False: 1.45k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 115k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.91k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 417, False: 1.03k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 1.45k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 417| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 417, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 334| 115k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.07k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 799, False: 240] | | | | | | ------------------ | | | | ------------------ | | | | 335| 1.03k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 1.83k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 799, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 336| 1.03k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 799| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 538, False: 261] | | | | | | ------------------ | | | | ------------------ | | | | 337| 115k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 1.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 261, False: 240] | | | | | | ------------------ | | | | ------------------ | | | | 338| 501| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 762| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 261, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 339| 501| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 261| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 261, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2104| 114k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 114k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 114k, False: 74] | | ------------------ | | 494| 114k| ? 1 \ | | 495| 114k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2104:13): [True: 1, False: 114k] ------------------ 2105| 114k| SKIP_LINE(parser); ------------------ | | 508| 114k| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 114k|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 114k| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 229k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.7k, False: 100k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 14.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 305, False: 14.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 114k| (parser->mark.index += 2, \ | | 510| 305| parser->mark.column = 0, \ | | 511| 305| parser->mark.line ++, \ | | 512| 305| parser->unread -= 2, \ | | 513| 305| parser->buffer.pointer += 2) : \ | | 514| 114k| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 114k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 229k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 229k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.4k, False: 100k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 114k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 214k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 98.9k, False: 1.21k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 114k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.43k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 417, False: 799] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.21k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 417| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 417, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 114k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.59k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 799, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 799| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.59k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 799, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 799| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 799| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 538, False: 261] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 229k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 522| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 261, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 261| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 522| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 261, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 261| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 261| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 261, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 515| 114k| (parser->mark.index ++, \ | | 516| 114k| parser->mark.column = 0, \ | | 517| 114k| parser->mark.line ++, \ | | 518| 114k| parser->unread --, \ | | 519| 114k| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 114k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 114k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 113k, False: 1.21k] | | | | | | ------------------ | | | | | | 381| 114k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 417, False: 799] | | | | | | ------------------ | | | | | | 382| 1.21k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 799, False: 0] | | | | | | ------------------ | | | | | | 383| 799| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2106| 114k| } 2107| | 2108| 115k| yaml_free(name); 2109| | 2110| 115k| return 1; 2111| | 2112| 425|error: 2113| 425| yaml_free(prefix); 2114| 425| yaml_free(handle); 2115| 425| yaml_free(name); 2116| 425| return 0; 2117| 115k|} scanner.c:yaml_parser_scan_directive_name: 2132| 115k|{ 2133| 115k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 115k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2134| | 2135| 115k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 115k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 115k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 115k, False: 0] | | ------------------ | | 134| 115k| ((string).pointer = (string).start, \ | | 135| 115k| (string).end = (string).start+(size), \ | | 136| 115k| memset((string).start, 0, (size)), \ | | 137| 115k| 1) : \ | | 138| 115k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2135:9): [True: 0, False: 115k] ------------------ 2136| | 2137| | /* Consume the directive name. */ 2138| | 2139| 115k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 115k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 115k, False: 0] | | ------------------ | | 494| 115k| ? 1 \ | | 495| 115k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2139:9): [True: 0, False: 115k] ------------------ 2140| | 2141| 115k| while (IS_ALPHA(parser->buffer)) 2142| 2.34M| { 2143| 2.34M| if (!READ(parser, string)) goto error; ------------------ | | 526| 2.34M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 2.34M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 2.34M, False: 0] | | | | | Branch (146:7): [True: 2.34M, False: 171] | | | | ------------------ | | | | 147| 2.34M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 171, False: 0] | | | | ------------------ | | | | 148| 171| &(string).pointer, &(string).end)) ? \ | | | | 149| 2.34M| 1 : \ | | | | 150| 2.34M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 2.34M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 2.34M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 2.34M, False: 0] | | | | ------------------ | | | | 399| 2.34M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 2.34M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 2.34M| parser->mark.index ++, \ | | 529| 2.34M| parser->mark.column ++, \ | | 530| 2.34M| parser->unread --, \ | | 531| 2.34M| 1) : 0) ------------------ | Branch (2143:13): [True: 0, False: 2.34M] ------------------ 2144| 2.34M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 2.34M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.34M, False: 205] | | ------------------ | | 494| 2.34M| ? 1 \ | | 495| 2.34M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2144:13): [True: 1, False: 2.34M] ------------------ 2145| 2.34M| } 2146| | 2147| | /* Check if the name is empty. */ 2148| | 2149| 115k| if (string.start == string.pointer) { ------------------ | Branch (2149:9): [True: 43, False: 115k] ------------------ 2150| 43| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2151| 43| start_mark, "could not find expected directive name"); 2152| 43| goto error; 2153| 43| } 2154| | 2155| | /* Check for an blank character after the name. */ 2156| | 2157| 115k| if (!IS_BLANKZ(parser->buffer)) { ------------------ | | 373| 115k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 115k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 230k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 115k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 230k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 114k, False: 1.22k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 1.22k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 1.22k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.06k, False: 158] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 158| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 316| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 316| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2, False: 156] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 158| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 314| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3, False: 153] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 158| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 306| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 6, False: 147] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 153| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1, False: 5] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 158| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 304| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 10, False: 142] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 152| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 162| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 4, False: 6] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 152| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 4| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1, False: 3] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 316| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 302| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 9, False: 142] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 151| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 160| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3, False: 6] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 151| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 3| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 149|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 149| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 110, False: 39] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2158| 39| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2159| 39| start_mark, "found unexpected non-alphabetical character"); 2160| 39| goto error; 2161| 39| } 2162| | 2163| 115k| *name = string.start; 2164| | 2165| 115k| return 1; 2166| | 2167| 83|error: 2168| 83| STRING_DEL(parser, string); ------------------ | | 142| 83| (yaml_free((string).start), \ | | 143| 83| (string).start = (string).pointer = (string).end = 0) ------------------ 2169| 83| return 0; 2170| 115k|} scanner.c:yaml_parser_scan_version_directive_value: 2183| 9.30k|{ 2184| | /* Eat whitespaces. */ 2185| | 2186| 9.30k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 9.30k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 9.30k, False: 0] | | ------------------ | | 494| 9.30k| ? 1 \ | | 495| 9.30k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2186:9): [True: 0, False: 9.30k] ------------------ 2187| | 2188| 996k| while (IS_BLANK(parser->buffer)) { 2189| 996k| SKIP(parser); ------------------ | | 502| 996k| (parser->mark.index ++, \ | | 503| 996k| parser->mark.column ++, \ | | 504| 996k| parser->unread --, \ | | 505| 996k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 996k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 996k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 996k, False: 0] | | | | | | ------------------ | | | | | | 381| 996k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2190| 996k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 996k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 996k, False: 84] | | ------------------ | | 494| 996k| ? 1 \ | | 495| 996k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2190:13): [True: 1, False: 996k] ------------------ 2191| 996k| } 2192| | 2193| | /* Consume the major version number. */ 2194| | 2195| 9.30k| if (!yaml_parser_scan_version_directive_number(parser, start_mark, major)) ------------------ | Branch (2195:9): [True: 38, False: 9.26k] ------------------ 2196| 38| return 0; 2197| | 2198| | /* Eat '.'. */ 2199| | 2200| 9.26k| if (!CHECK(parser->buffer, '.')) { ------------------ | | 181| 9.26k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 9.26k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2200:9): [True: 21, False: 9.24k] ------------------ 2201| 21| return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 2202| 21| start_mark, "did not find expected digit or '.' character"); 2203| 21| } 2204| | 2205| 9.24k| SKIP(parser); ------------------ | | 502| 9.24k| (parser->mark.index ++, \ | | 503| 9.24k| parser->mark.column ++, \ | | 504| 9.24k| parser->unread --, \ | | 505| 9.24k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 9.24k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 9.24k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 9.24k, False: 0] | | | | | | ------------------ | | | | | | 381| 9.24k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2206| | 2207| | /* Consume the minor version number. */ 2208| | 2209| 9.24k| if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor)) ------------------ | Branch (2209:9): [True: 10, False: 9.23k] ------------------ 2210| 10| return 0; 2211| | 2212| 9.23k| return 1; 2213| 9.24k|} scanner.c:yaml_parser_scan_version_directive_number: 2230| 18.5k|{ 2231| 18.5k| int value = 0; 2232| 18.5k| size_t length = 0; 2233| | 2234| | /* Repeat while the next character is digit. */ 2235| | 2236| 18.5k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 18.5k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 18.5k, False: 15] | | ------------------ | | 494| 18.5k| ? 1 \ | | 495| 18.5k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2236:9): [True: 1, False: 18.5k] ------------------ 2237| | 2238| 18.5k| while (IS_DIGIT(parser->buffer)) 2239| 18.8k| { 2240| | /* Check if the number is too long. */ 2241| | 2242| 18.8k| if (++length > MAX_NUMBER_LENGTH) { ------------------ | | 2215| 18.8k|#define MAX_NUMBER_LENGTH 9 ------------------ | Branch (2242:13): [True: 2, False: 18.8k] ------------------ 2243| 2| return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 2244| 2| start_mark, "found extremely long version number"); 2245| 2| } 2246| | 2247| 18.8k| value = value*10 + AS_DIGIT(parser->buffer); ------------------ | | 217| 18.8k|#define AS_DIGIT(string) AS_DIGIT_AT((string),0) | | ------------------ | | | | 215| 18.8k| ((string).pointer[offset] - (yaml_char_t) '0') | | ------------------ ------------------ 2248| | 2249| 18.8k| SKIP(parser); ------------------ | | 502| 18.8k| (parser->mark.index ++, \ | | 503| 18.8k| parser->mark.column ++, \ | | 504| 18.8k| parser->unread --, \ | | 505| 18.8k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 18.8k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 18.8k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 18.8k, False: 0] | | | | | | ------------------ | | | | | | 381| 18.8k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2250| | 2251| 18.8k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 18.8k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 18.7k, False: 85] | | ------------------ | | 494| 18.8k| ? 1 \ | | 495| 18.8k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2251:13): [True: 1, False: 18.8k] ------------------ 2252| 18.8k| } 2253| | 2254| | /* Check if the number was present. */ 2255| | 2256| 18.5k| if (!length) { ------------------ | Branch (2256:9): [True: 44, False: 18.4k] ------------------ 2257| 44| return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 2258| 44| start_mark, "did not find expected version number"); 2259| 44| } 2260| | 2261| 18.4k| *number = value; 2262| | 2263| 18.4k| return 1; 2264| 18.5k|} scanner.c:yaml_parser_scan_tag_directive_value: 2277| 105k|{ 2278| 105k| yaml_char_t *handle_value = NULL; 2279| 105k| yaml_char_t *prefix_value = NULL; 2280| | 2281| | /* Eat whitespaces. */ 2282| | 2283| 105k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 105k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 105k, False: 0] | | ------------------ | | 494| 105k| ? 1 \ | | 495| 105k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2283:9): [True: 0, False: 105k] ------------------ 2284| | 2285| 1.14M| while (IS_BLANK(parser->buffer)) { 2286| 1.14M| SKIP(parser); ------------------ | | 502| 1.14M| (parser->mark.index ++, \ | | 503| 1.14M| parser->mark.column ++, \ | | 504| 1.14M| parser->unread --, \ | | 505| 1.14M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.14M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.14M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.14M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.14M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2287| 1.14M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.14M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.14M, False: 86] | | ------------------ | | 494| 1.14M| ? 1 \ | | 495| 1.14M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2287:13): [True: 1, False: 1.14M] ------------------ 2288| 1.14M| } 2289| | 2290| | /* Scan a handle. */ 2291| | 2292| 105k| if (!yaml_parser_scan_tag_handle(parser, 1, start_mark, &handle_value)) ------------------ | Branch (2292:9): [True: 41, False: 105k] ------------------ 2293| 41| goto error; 2294| | 2295| | /* Expect a whitespace. */ 2296| | 2297| 105k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 105k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 105k, False: 36] | | ------------------ | | 494| 105k| ? 1 \ | | 495| 105k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2297:9): [True: 1, False: 105k] ------------------ 2298| | 2299| 105k| if (!IS_BLANK(parser->buffer)) { ------------------ | | 323| 105k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 105k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 105k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 211k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 105k, False: 804] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 804|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 804| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 789, False: 15] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2300| 15| yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 2301| 15| start_mark, "did not find expected whitespace"); 2302| 15| goto error; 2303| 15| } 2304| | 2305| | /* Eat whitespaces. */ 2306| | 2307| 1.07M| while (IS_BLANK(parser->buffer)) { 2308| 1.07M| SKIP(parser); ------------------ | | 502| 1.07M| (parser->mark.index ++, \ | | 503| 1.07M| parser->mark.column ++, \ | | 504| 1.07M| parser->unread --, \ | | 505| 1.07M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.07M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.07M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.07M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.07M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2309| 1.07M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.07M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.07M, False: 91] | | ------------------ | | 494| 1.07M| ? 1 \ | | 495| 1.07M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2309:13): [True: 1, False: 1.07M] ------------------ 2310| 1.07M| } 2311| | 2312| | /* Scan a prefix. */ 2313| | 2314| 105k| if (!yaml_parser_scan_tag_uri(parser, 1, 1, NULL, start_mark, &prefix_value)) ------------------ | Branch (2314:9): [True: 34, False: 105k] ------------------ 2315| 34| goto error; 2316| | 2317| | /* Expect a whitespace or line break. */ 2318| | 2319| 105k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 105k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 105k, False: 0] | | ------------------ | | 494| 105k| ? 1 \ | | 495| 105k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2319:9): [True: 0, False: 105k] ------------------ 2320| | 2321| 105k| if (!IS_BLANKZ(parser->buffer)) { ------------------ | | 373| 105k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 105k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 211k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 105k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 211k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 10.0k, False: 95.8k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 95.8k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 95.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 211, False: 95.6k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 95.6k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 191k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 191k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.31k, False: 94.3k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 95.6k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 189k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 93.7k, False: 581] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 95.6k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 1.16k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 385] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 581| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 196| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 195, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 95.6k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 772| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 313, False: 73] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 386| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 699| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 307, False: 6] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 386| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 307| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 237, False: 70] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 191k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 298| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 76, False: 73] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 149| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 225| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 70, False: 6] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 149| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 70| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 67, False: 3] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 82|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 82| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 61, False: 21] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2322| 21| yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 2323| 21| start_mark, "did not find expected whitespace or line break"); 2324| 21| goto error; 2325| 21| } 2326| | 2327| 105k| *handle = handle_value; 2328| 105k| *prefix = prefix_value; 2329| | 2330| 105k| return 1; 2331| | 2332| 114|error: 2333| 114| yaml_free(handle_value); 2334| 114| yaml_free(prefix_value); 2335| 114| return 0; 2336| 105k|} scanner.c:yaml_parser_scan_tag_handle: 2524| 117k|{ 2525| 117k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 117k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2526| | 2527| 117k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 117k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 117k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 117k, False: 0] | | ------------------ | | 134| 117k| ((string).pointer = (string).start, \ | | 135| 117k| (string).end = (string).start+(size), \ | | 136| 117k| memset((string).start, 0, (size)), \ | | 137| 117k| 1) : \ | | 138| 117k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2527:9): [True: 0, False: 117k] ------------------ 2528| | 2529| | /* Check the initial '!' character. */ 2530| | 2531| 117k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 117k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 117k, False: 0] | | ------------------ | | 494| 117k| ? 1 \ | | 495| 117k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2531:9): [True: 0, False: 117k] ------------------ 2532| | 2533| 117k| if (!CHECK(parser->buffer, '!')) { ------------------ | | 181| 117k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 117k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2533:9): [True: 37, False: 117k] ------------------ 2534| 37| yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2534:47): [True: 37, False: 0] ------------------ 2535| 37| "while scanning a tag directive" : "while scanning a tag", 2536| 37| start_mark, "did not find expected '!'"); 2537| 37| goto error; 2538| 37| } 2539| | 2540| | /* Copy the '!' character. */ 2541| | 2542| 117k| if (!READ(parser, string)) goto error; ------------------ | | 526| 117k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 117k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 117k, False: 0] | | | | | Branch (146:7): [True: 117k, False: 0] | | | | ------------------ | | | | 147| 117k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 117k| 1 : \ | | | | 150| 117k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 117k| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 117k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 117k, False: 0] | | | | ------------------ | | | | 399| 117k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 117k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 117k| parser->mark.index ++, \ | | 529| 117k| parser->mark.column ++, \ | | 530| 117k| parser->unread --, \ | | 531| 117k| 1) : 0) ------------------ | Branch (2542:9): [True: 0, False: 117k] ------------------ 2543| | 2544| | /* Copy all subsequent alphabetical and numerical characters. */ 2545| | 2546| 117k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 117k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 117k, False: 41] | | ------------------ | | 494| 117k| ? 1 \ | | 495| 117k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2546:9): [True: 1, False: 117k] ------------------ 2547| | 2548| 117k| while (IS_ALPHA(parser->buffer)) 2549| 8.28M| { 2550| 8.28M| if (!READ(parser, string)) goto error; ------------------ | | 526| 8.28M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 8.28M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 8.28M, False: 0] | | | | | Branch (146:7): [True: 8.28M, False: 1.62k] | | | | ------------------ | | | | 147| 8.28M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 1.62k, False: 0] | | | | ------------------ | | | | 148| 1.62k| &(string).pointer, &(string).end)) ? \ | | | | 149| 8.28M| 1 : \ | | | | 150| 8.28M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 8.28M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 8.28M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 8.28M, False: 0] | | | | ------------------ | | | | 399| 8.28M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 8.28M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 8.28M| parser->mark.index ++, \ | | 529| 8.28M| parser->mark.column ++, \ | | 530| 8.28M| parser->unread --, \ | | 531| 8.28M| 1) : 0) ------------------ | Branch (2550:13): [True: 0, False: 8.28M] ------------------ 2551| 8.28M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 8.28M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 8.28M, False: 566] | | ------------------ | | 494| 8.28M| ? 1 \ | | 495| 8.28M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2551:13): [True: 1, False: 8.28M] ------------------ 2552| 8.28M| } 2553| | 2554| | /* Check if the trailing character is '!' and copy it. */ 2555| | 2556| 117k| if (CHECK(parser->buffer, '!')) ------------------ | | 181| 117k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 117k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 97.2k, False: 19.8k] | | ------------------ ------------------ 2557| 97.2k| { 2558| 97.2k| if (!READ(parser, string)) goto error; ------------------ | | 526| 97.2k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 97.2k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 97.2k, False: 0] | | | | | Branch (146:7): [True: 97.1k, False: 86] | | | | ------------------ | | | | 147| 97.2k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 86, False: 0] | | | | ------------------ | | | | 148| 86| &(string).pointer, &(string).end)) ? \ | | | | 149| 97.2k| 1 : \ | | | | 150| 97.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 97.2k| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 97.2k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 97.2k, False: 0] | | | | ------------------ | | | | 399| 97.2k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 97.2k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 97.2k| parser->mark.index ++, \ | | 529| 97.2k| parser->mark.column ++, \ | | 530| 97.2k| parser->unread --, \ | | 531| 97.2k| 1) : 0) ------------------ | Branch (2558:13): [True: 0, False: 97.2k] ------------------ 2559| 97.2k| } 2560| 19.8k| else 2561| 19.8k| { 2562| | /* 2563| | * It's either the '!' tag or not really a tag handle. If it's a %TAG 2564| | * directive, it's an error. If it's a tag token, it must be a part of 2565| | * URI. 2566| | */ 2567| | 2568| 19.8k| if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) { ------------------ | Branch (2568:13): [True: 9.75k, False: 10.1k] | Branch (2568:28): [True: 9.75k, False: 0] | Branch (2568:54): [True: 9.74k, False: 3] ------------------ 2569| 3| yaml_parser_set_scanner_error(parser, "while parsing a tag directive", 2570| 3| start_mark, "did not find expected '!'"); 2571| 3| goto error; 2572| 3| } 2573| 19.8k| } 2574| | 2575| 117k| *handle = string.start; 2576| | 2577| 117k| return 1; 2578| | 2579| 42|error: 2580| 42| STRING_DEL(parser, string); ------------------ | | 142| 42| (yaml_free((string).start), \ | | 143| 42| (string).start = (string).pointer = (string).end = 0) ------------------ 2581| 42| return 0; 2582| 117k|} scanner.c:yaml_parser_scan_tag_uri: 2591| 120k|{ 2592| 120k| size_t length = head ? strlen((char *)head) : 0; ------------------ | Branch (2592:21): [True: 10.1k, False: 109k] ------------------ 2593| 120k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 120k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2594| | 2595| 120k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 120k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 120k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 120k, False: 0] | | ------------------ | | 134| 120k| ((string).pointer = (string).start, \ | | 135| 120k| (string).end = (string).start+(size), \ | | 136| 120k| memset((string).start, 0, (size)), \ | | 137| 120k| 1) : \ | | 138| 120k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2595:9): [True: 0, False: 120k] ------------------ 2596| | 2597| | /* Resize the string to include the head. */ 2598| | 2599| 120k| while ((size_t)(string.end - string.start) <= length) { ------------------ | Branch (2599:12): [True: 916, False: 120k] ------------------ 2600| 916| if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) { ------------------ | Branch (2600:13): [True: 0, False: 916] ------------------ 2601| 0| parser->error = YAML_MEMORY_ERROR; 2602| 0| goto error; 2603| 0| } 2604| 916| } 2605| | 2606| | /* 2607| | * Copy the head if needed. 2608| | * 2609| | * Note that we don't copy the leading '!' character. 2610| | */ 2611| | 2612| 120k| if (length > 1) { ------------------ | Branch (2612:9): [True: 4.40k, False: 115k] ------------------ 2613| 4.40k| memcpy(string.start, head+1, length-1); 2614| 4.40k| string.pointer += length-1; 2615| 4.40k| } 2616| | 2617| | /* Scan the tag. */ 2618| | 2619| 120k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 120k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 120k, False: 9] | | ------------------ | | 494| 120k| ? 1 \ | | 495| 120k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2619:9): [True: 1, False: 120k] ------------------ 2620| | 2621| | /* 2622| | * The set of characters that may appear in URI is as follows: 2623| | * 2624| | * '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&', 2625| | * '=', '+', '$', '.', '!', '~', '*', '\'', '(', ')', '%'. 2626| | * 2627| | * If we are inside a verbatim tag <...> (parameter uri_char is true) 2628| | * then also the following flow indicators are allowed: 2629| | * ',', '[', ']' 2630| | */ 2631| | 2632| 21.0M| while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';') ------------------ | | 198| 21.0M|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 42.1M| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 6.69M, False: 14.3M] | | | | ------------------ | | | | 190| 21.0M| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 894k, False: 5.80M] | | | | ------------------ | | | | 191| 21.0M| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 5.72M, False: 14.4M] | | | | ------------------ | | | | 192| 20.1M| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 1.06M, False: 4.65M] | | | | ------------------ | | | | 193| 21.0M| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 4.62M, False: 14.5M] | | | | ------------------ | | | | 194| 19.1M| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 4.62M, False: 1.94k] | | | | ------------------ | | | | 195| 21.0M| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 15.2k, False: 14.4M] | | | | ------------------ | | | | 196| 42.1M| (string).pointer[offset] == '-') | | | | ------------------ | | | | | Branch (196:7): [True: 49.6k, False: 14.4M] | | | | ------------------ | | ------------------ ------------------ while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';') ------------------ | | 181| 35.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.53k, False: 14.4M] | | ------------------ ------------------ 2633| 14.4M| || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?') ------------------ | | 181| 35.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 18.8k, False: 14.4M] | | ------------------ ------------------ || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?') ------------------ | | 181| 35.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 15.3k, False: 14.4M] | | ------------------ ------------------ 2634| 14.4M| || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 35.3k, False: 14.3M] | | ------------------ ------------------ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.6k, False: 14.3M] | | ------------------ ------------------ 2635| 14.3M| || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.59k, False: 14.3M] | | ------------------ ------------------ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 7.23k, False: 14.3M] | | ------------------ ------------------ 2636| 14.3M| || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.93k, False: 14.3M] | | ------------------ ------------------ || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10.6k, False: 14.3M] | | ------------------ ------------------ 2637| 14.3M| || CHECK(parser->buffer, '.') || CHECK(parser->buffer, '%') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.7k, False: 14.3M] | | ------------------ ------------------ || CHECK(parser->buffer, '.') || CHECK(parser->buffer, '%') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 344k, False: 13.9M] | | ------------------ ------------------ 2638| 13.9M| || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~') ------------------ | | 181| 35.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 13.7M, False: 175k] | | ------------------ ------------------ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~') ------------------ | | 181| 21.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 175k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 794, False: 174k] | | ------------------ ------------------ 2639| 174k| || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'') ------------------ | | 181| 21.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 174k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 14.4k, False: 160k] | | ------------------ ------------------ || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'') ------------------ | | 181| 21.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 160k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.94k, False: 153k] | | ------------------ ------------------ 2640| 153k| || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')') ------------------ | | 181| 21.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 153k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 4.44k, False: 149k] | | ------------------ ------------------ || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')') ------------------ | | 181| 21.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 149k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.01k, False: 144k] | | ------------------ ------------------ 2641| 144k| || (uri_char && ( ------------------ | Branch (2641:17): [True: 133k, False: 11.0k] ------------------ 2642| 133k| CHECK(parser->buffer, ',') ------------------ | | 181| 266k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 133k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.64k, False: 124k] | | ------------------ ------------------ 2643| 124k| || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') ------------------ | | 181| 257k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 124k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.62k, False: 114k] | | ------------------ ------------------ || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') ------------------ | | 181| 114k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 114k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.81k, False: 108k] | | ------------------ ------------------ 2644| 133k| ) 2645| 144k| )) 2646| 20.9M| { 2647| | /* Check if it is a URI-escape sequence. */ 2648| | 2649| 20.9M| if (CHECK(parser->buffer, '%')) { ------------------ | | 181| 20.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 20.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 344k, False: 20.6M] | | ------------------ ------------------ 2650| 344k| if (!STRING_EXTEND(parser, string)) ------------------ | | 146| 344k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 344k, False: 383] | | ------------------ | | 147| 344k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 383, False: 0] | | ------------------ | | 148| 383| &(string).pointer, &(string).end)) ? \ | | 149| 344k| 1 : \ | | 150| 344k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (2650:17): [True: 0, False: 344k] ------------------ 2651| 0| goto error; 2652| | 2653| 344k| if (!yaml_parser_scan_uri_escapes(parser, ------------------ | Branch (2653:17): [True: 111, False: 344k] ------------------ 2654| 344k| directive, start_mark, &string)) goto error; 2655| 344k| } 2656| 20.6M| else { 2657| 20.6M| if (!READ(parser, string)) goto error; ------------------ | | 526| 20.6M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 20.6M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 20.6M, False: 0] | | | | | Branch (146:7): [True: 20.6M, False: 6.56k] | | | | ------------------ | | | | 147| 20.6M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 6.56k, False: 0] | | | | ------------------ | | | | 148| 6.56k| &(string).pointer, &(string).end)) ? \ | | | | 149| 20.6M| 1 : \ | | | | 150| 20.6M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 20.6M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 20.6M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 20.6M, False: 0] | | | | ------------------ | | | | 399| 20.6M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 20.6M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 20.6M| parser->mark.index ++, \ | | 529| 20.6M| parser->mark.column ++, \ | | 530| 20.6M| parser->unread --, \ | | 531| 20.6M| 1) : 0) ------------------ | Branch (2657:17): [True: 0, False: 20.6M] ------------------ 2658| 20.6M| } 2659| | 2660| 20.9M| length ++; 2661| 20.9M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 20.9M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 20.9M, False: 1.65k] | | ------------------ | | 494| 20.9M| ? 1 \ | | 495| 20.9M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2661:13): [True: 3, False: 20.9M] ------------------ 2662| 20.9M| } 2663| | 2664| | /* Check if the tag is non-empty. */ 2665| | 2666| 119k| if (!length) { ------------------ | Branch (2666:9): [True: 62, False: 119k] ------------------ 2667| 62| if (!STRING_EXTEND(parser, string)) ------------------ | | 146| 62| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 62, False: 0] | | ------------------ | | 147| 62| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 0, False: 0] | | ------------------ | | 148| 0| &(string).pointer, &(string).end)) ? \ | | 149| 62| 1 : \ | | 150| 62| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (2667:13): [True: 0, False: 62] ------------------ 2668| 0| goto error; 2669| | 2670| 62| yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2670:47): [True: 32, False: 30] ------------------ 2671| 32| "while parsing a %TAG directive" : "while parsing a tag", 2672| 62| start_mark, "did not find expected tag URI"); 2673| 62| goto error; 2674| 62| } 2675| | 2676| 119k| *uri = string.start; 2677| | 2678| 119k| return 1; 2679| | 2680| 177|error: 2681| 177| STRING_DEL(parser, string); ------------------ | | 142| 177| (yaml_free((string).start), \ | | 143| 177| (string).start = (string).pointer = (string).end = 0) ------------------ 2682| 177| return 0; 2683| 119k|} scanner.c:yaml_parser_scan_uri_escapes: 2692| 344k|{ 2693| 344k| int width = 0; 2694| | 2695| | /* Decode the required number of characters. */ 2696| | 2697| 347k| do { 2698| | 2699| 347k| unsigned char octet = 0; 2700| | 2701| | /* Check for a URI-escaped octet. */ 2702| | 2703| 347k| if (!CACHE(parser, 3)) return 0; ------------------ | | 493| 347k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 346k, False: 125] | | ------------------ | | 494| 347k| ? 1 \ | | 495| 347k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2703:13): [True: 1, False: 347k] ------------------ 2704| | 2705| 347k| if (!(CHECK(parser->buffer, '%') ------------------ | | 181| 694k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 347k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 347k, False: 25] | | ------------------ ------------------ 2706| 347k| && IS_HEX_AT(parser->buffer, 1) ------------------ | | 224| 694k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | ------------------ | | | Branch (224:8): [True: 347k, False: 31] | | ------------------ | | 225| 347k| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | ------------------ | | | Branch (225:8): [True: 343k, False: 3.44k] | | ------------------ | | 226| 347k| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (226:8): [True: 3.43k, False: 33] | | ------------------ | | 227| 3.47k| (string).pointer[offset] <= (yaml_char_t) 'F') || \ | | ------------------ | | | Branch (227:8): [True: 1.99k, False: 1.44k] | | ------------------ | | 228| 694k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (228:8): [True: 1.44k, False: 37] | | ------------------ | | 229| 1.47k| (string).pointer[offset] <= (yaml_char_t) 'f')) | | ------------------ | | | Branch (229:8): [True: 1.43k, False: 5] | | ------------------ ------------------ 2707| 347k| && IS_HEX_AT(parser->buffer, 2))) { ------------------ | | 224| 347k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | ------------------ | | | Branch (224:8): [True: 346k, False: 24] | | ------------------ | | 225| 347k| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | ------------------ | | | Branch (225:8): [True: 1.49k, False: 345k] | | ------------------ | | 226| 347k| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (226:8): [True: 345k, False: 27] | | ------------------ | | 227| 345k| (string).pointer[offset] <= (yaml_char_t) 'F') || \ | | ------------------ | | | Branch (227:8): [True: 1.84k, False: 343k] | | ------------------ | | 228| 347k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (228:8): [True: 343k, False: 29] | | ------------------ | | 229| 343k| (string).pointer[offset] <= (yaml_char_t) 'f')) | | ------------------ | | | Branch (229:8): [True: 343k, False: 4] | | ------------------ ------------------ 2708| 100| return yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2708:58): [True: 2, False: 98] ------------------ 2709| 98| "while parsing a %TAG directive" : "while parsing a tag", 2710| 100| start_mark, "did not find URI escaped octet"); 2711| 100| } 2712| | 2713| | /* Get the octet. */ 2714| | 2715| 346k| octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2); ------------------ | | 238| 346k| (((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (238:9): [True: 3.41k, False: 343k] | | ------------------ | | 239| 346k| (string).pointer[offset] <= (yaml_char_t) 'F') ? \ | | ------------------ | | | Branch (239:9): [True: 1.98k, False: 1.43k] | | ------------------ | | 240| 346k| ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ | | 241| 346k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (241:9): [True: 1.43k, False: 343k] | | ------------------ | | 242| 344k| (string).pointer[offset] <= (yaml_char_t) 'f') ? \ | | ------------------ | | | Branch (242:9): [True: 1.43k, False: 0] | | ------------------ | | 243| 344k| ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ | | 244| 344k| ((string).pointer[offset] - (yaml_char_t) '0')) ------------------ octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2); ------------------ | | 238| 346k| (((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (238:9): [True: 345k, False: 1.49k] | | ------------------ | | 239| 346k| (string).pointer[offset] <= (yaml_char_t) 'F') ? \ | | ------------------ | | | Branch (239:9): [True: 1.84k, False: 343k] | | ------------------ | | 240| 346k| ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ | | 241| 346k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (241:9): [True: 343k, False: 1.49k] | | ------------------ | | 242| 345k| (string).pointer[offset] <= (yaml_char_t) 'f') ? \ | | ------------------ | | | Branch (242:9): [True: 343k, False: 0] | | ------------------ | | 243| 345k| ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ | | 244| 345k| ((string).pointer[offset] - (yaml_char_t) '0')) ------------------ 2716| | 2717| | /* If it is the leading octet, determine the length of the UTF-8 sequence. */ 2718| | 2719| 346k| if (!width) ------------------ | Branch (2719:13): [True: 344k, False: 2.19k] ------------------ 2720| 344k| { 2721| 344k| width = (octet & 0x80) == 0x00 ? 1 : ------------------ | Branch (2721:21): [True: 343k, False: 1.23k] ------------------ 2722| 344k| (octet & 0xE0) == 0xC0 ? 2 : ------------------ | Branch (2722:21): [True: 568, False: 671] ------------------ 2723| 1.23k| (octet & 0xF0) == 0xE0 ? 3 : ------------------ | Branch (2723:21): [True: 311, False: 360] ------------------ 2724| 671| (octet & 0xF8) == 0xF0 ? 4 : 0; ------------------ | Branch (2724:21): [True: 353, False: 7] ------------------ 2725| 344k| if (!width) { ------------------ | Branch (2725:17): [True: 7, False: 344k] ------------------ 2726| 7| return yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2726:62): [True: 0, False: 7] ------------------ 2727| 7| "while parsing a %TAG directive" : "while parsing a tag", 2728| 7| start_mark, "found an incorrect leading UTF-8 octet"); 2729| 7| } 2730| 344k| } 2731| 2.19k| else 2732| 2.19k| { 2733| | /* Check if the trailing octet is correct. */ 2734| | 2735| 2.19k| if ((octet & 0xC0) != 0x80) { ------------------ | Branch (2735:17): [True: 3, False: 2.19k] ------------------ 2736| 3| return yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2736:62): [True: 0, False: 3] ------------------ 2737| 3| "while parsing a %TAG directive" : "while parsing a tag", 2738| 3| start_mark, "found an incorrect trailing UTF-8 octet"); 2739| 3| } 2740| 2.19k| } 2741| | 2742| | /* Copy the octet and move the pointers. */ 2743| | 2744| 346k| *(string->pointer++) = octet; 2745| 346k| SKIP(parser); ------------------ | | 502| 346k| (parser->mark.index ++, \ | | 503| 346k| parser->mark.column ++, \ | | 504| 346k| parser->unread --, \ | | 505| 346k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 346k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 346k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 346k, False: 0] | | | | | | ------------------ | | | | | | 381| 346k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2746| 346k| SKIP(parser); ------------------ | | 502| 346k| (parser->mark.index ++, \ | | 503| 346k| parser->mark.column ++, \ | | 504| 346k| parser->unread --, \ | | 505| 346k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 346k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 346k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 346k, False: 0] | | | | | | ------------------ | | | | | | 381| 346k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2747| 346k| SKIP(parser); ------------------ | | 502| 346k| (parser->mark.index ++, \ | | 503| 346k| parser->mark.column ++, \ | | 504| 346k| parser->unread --, \ | | 505| 346k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 346k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 346k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 346k, False: 0] | | | | | | ------------------ | | | | | | 381| 346k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2748| | 2749| 346k| } while (--width); ------------------ | Branch (2749:14): [True: 2.23k, False: 344k] ------------------ 2750| | 2751| 344k| return 1; 2752| 344k|} scanner.c:yaml_parser_fetch_document_indicator: 1424| 58.0k|{ 1425| 58.0k| yaml_mark_t start_mark, end_mark; 1426| 58.0k| yaml_token_t token; 1427| | 1428| | /* Reset the indentation level. */ 1429| | 1430| 58.0k| if (!yaml_parser_unroll_indent(parser, -1)) ------------------ | Branch (1430:9): [True: 0, False: 58.0k] ------------------ 1431| 0| return 0; 1432| | 1433| | /* Reset simple keys. */ 1434| | 1435| 58.0k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1435:9): [True: 0, False: 58.0k] ------------------ 1436| 0| return 0; 1437| | 1438| 58.0k| parser->simple_key_allowed = 0; 1439| | 1440| | /* Consume the token. */ 1441| | 1442| 58.0k| start_mark = parser->mark; 1443| | 1444| 58.0k| SKIP(parser); ------------------ | | 502| 58.0k| (parser->mark.index ++, \ | | 503| 58.0k| parser->mark.column ++, \ | | 504| 58.0k| parser->unread --, \ | | 505| 58.0k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 58.0k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 58.0k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 58.0k, False: 0] | | | | | | ------------------ | | | | | | 381| 58.0k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1445| 58.0k| SKIP(parser); ------------------ | | 502| 58.0k| (parser->mark.index ++, \ | | 503| 58.0k| parser->mark.column ++, \ | | 504| 58.0k| parser->unread --, \ | | 505| 58.0k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 58.0k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 58.0k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 58.0k, False: 0] | | | | | | ------------------ | | | | | | 381| 58.0k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1446| 58.0k| SKIP(parser); ------------------ | | 502| 58.0k| (parser->mark.index ++, \ | | 503| 58.0k| parser->mark.column ++, \ | | 504| 58.0k| parser->unread --, \ | | 505| 58.0k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 58.0k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 58.0k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 58.0k, False: 0] | | | | | | ------------------ | | | | | | 381| 58.0k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1447| | 1448| 58.0k| end_mark = parser->mark; 1449| | 1450| | /* Create the DOCUMENT-START or DOCUMENT-END token. */ 1451| | 1452| 58.0k| TOKEN_INIT(token, type, start_mark, end_mark); ------------------ | | 500| 58.0k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 58.0k| (token).type = (token_type), \ | | 502| 58.0k| (token).start_mark = (token_start_mark), \ | | 503| 58.0k| (token).end_mark = (token_end_mark)) ------------------ 1453| | 1454| | /* Append the token to the queue. */ 1455| | 1456| 58.0k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 58.0k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 56.4k, False: 1.64k] | | ------------------ | | 473| 58.0k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.64k, False: 0] | | ------------------ | | 474| 1.64k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 58.0k| (*((queue).tail++) = value, \ | | 476| 58.0k| 1) : \ | | 477| 58.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1456:9): [True: 0, False: 58.0k] ------------------ 1457| 0| return 0; 1458| | 1459| 58.0k| return 1; 1460| 58.0k|} scanner.c:yaml_parser_fetch_flow_collection_start: 1469| 79.1k|{ 1470| 79.1k| yaml_mark_t start_mark, end_mark; 1471| 79.1k| yaml_token_t token; 1472| | 1473| | /* The indicators '[' and '{' may start a simple key. */ 1474| | 1475| 79.1k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1475:9): [True: 0, False: 79.1k] ------------------ 1476| 0| return 0; 1477| | 1478| | /* Increase the flow level. */ 1479| | 1480| 79.1k| if (!yaml_parser_increase_flow_level(parser)) ------------------ | Branch (1480:9): [True: 2, False: 79.1k] ------------------ 1481| 2| return 0; 1482| | 1483| | /* A simple key may follow the indicators '[' and '{'. */ 1484| | 1485| 79.1k| parser->simple_key_allowed = 1; 1486| | 1487| | /* Consume the token. */ 1488| | 1489| 79.1k| start_mark = parser->mark; 1490| 79.1k| SKIP(parser); ------------------ | | 502| 79.1k| (parser->mark.index ++, \ | | 503| 79.1k| parser->mark.column ++, \ | | 504| 79.1k| parser->unread --, \ | | 505| 79.1k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 79.1k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 79.1k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 79.1k, False: 0] | | | | | | ------------------ | | | | | | 381| 79.1k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1491| 79.1k| end_mark = parser->mark; 1492| | 1493| | /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */ 1494| | 1495| 79.1k| TOKEN_INIT(token, type, start_mark, end_mark); ------------------ | | 500| 79.1k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 79.1k| (token).type = (token_type), \ | | 502| 79.1k| (token).start_mark = (token_start_mark), \ | | 503| 79.1k| (token).end_mark = (token_end_mark)) ------------------ 1496| | 1497| | /* Append the token to the queue. */ 1498| | 1499| 79.1k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 79.1k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 77.3k, False: 1.73k] | | ------------------ | | 473| 79.1k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.73k, False: 0] | | ------------------ | | 474| 1.73k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 79.1k| (*((queue).tail++) = value, \ | | 476| 79.1k| 1) : \ | | 477| 79.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1499:9): [True: 0, False: 79.1k] ------------------ 1500| 0| return 0; 1501| | 1502| 79.1k| return 1; 1503| 79.1k|} scanner.c:yaml_parser_save_simple_key: 1105| 3.85M|{ 1106| | /* 1107| | * A simple key is required at the current position if the scanner is in 1108| | * the block context and the current column coincides with the indentation 1109| | * level. 1110| | */ 1111| | 1112| 3.85M| int required = (!parser->flow_level ------------------ | Branch (1112:21): [True: 724k, False: 3.12M] ------------------ 1113| 724k| && parser->indent == (ptrdiff_t)parser->mark.column); ------------------ | Branch (1113:16): [True: 84.8k, False: 640k] ------------------ 1114| | 1115| | /* 1116| | * If the current position may start a simple key, save it. 1117| | */ 1118| | 1119| 3.85M| if (parser->simple_key_allowed) ------------------ | Branch (1119:9): [True: 3.81M, False: 39.9k] ------------------ 1120| 3.81M| { 1121| 3.81M| yaml_simple_key_t simple_key; 1122| 3.81M| simple_key.possible = 1; 1123| 3.81M| simple_key.required = required; 1124| 3.81M| simple_key.token_number = 1125| 3.81M| parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head); 1126| 3.81M| simple_key.mark = parser->mark; 1127| | 1128| 3.81M| if (!yaml_parser_remove_simple_key(parser)) return 0; ------------------ | Branch (1128:13): [True: 0, False: 3.81M] ------------------ 1129| | 1130| 3.81M| *(parser->simple_keys.top-1) = simple_key; 1131| 3.81M| } 1132| | 1133| 3.85M| return 1; 1134| 3.85M|} scanner.c:yaml_parser_increase_flow_level: 1169| 79.1k|{ 1170| 79.1k| yaml_simple_key_t empty_simple_key = { 0, 0, 0, { 0, 0, 0 } }; 1171| | 1172| | /* Reset the simple key on the next level. */ 1173| | 1174| 79.1k| if (!PUSH(parser, parser->simple_keys, empty_simple_key)) ------------------ | | 445| 79.1k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 77.9k, False: 1.16k] | | ------------------ | | 446| 79.1k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.16k, False: 0] | | ------------------ | | 447| 1.16k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 79.1k| (*((stack).top++) = value, \ | | 449| 79.1k| 1) : \ | | 450| 79.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1174:9): [True: 0, False: 79.1k] ------------------ 1175| 0| return 0; 1176| | 1177| | /* Increase the flow level. */ 1178| | 1179| 79.1k| if (parser->flow_level == INT_MAX) { ------------------ | Branch (1179:9): [True: 0, False: 79.1k] ------------------ 1180| 0| parser->error = YAML_MEMORY_ERROR; 1181| 0| return 0; 1182| 0| } 1183| | 1184| 79.1k| if (!STACK_LIMIT(parser, parser->indents, MAX_NESTING_LEVEL - parser->flow_level)) { ------------------ | | 439| 79.1k| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 79.1k, False: 2] | | ------------------ | | 440| 79.1k| 1 : \ | | 441| 79.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 2| 0)) ------------------ | Branch (1184:9): [True: 2, False: 79.1k] ------------------ 1185| 2| return yaml_parser_set_scanner_error(parser, 1186| 2| "while increasing flow level", parser->mark, 1187| 2| "exceeded maximum nesting depth"); 1188| 2| } 1189| | 1190| 79.1k| parser->flow_level++; 1191| | 1192| 79.1k| return 1; 1193| 79.1k|} scanner.c:yaml_parser_fetch_flow_collection_end: 1512| 44.0k|{ 1513| 44.0k| yaml_mark_t start_mark, end_mark; 1514| 44.0k| yaml_token_t token; 1515| | 1516| | /* Reset any potential simple key on the current flow level. */ 1517| | 1518| 44.0k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1518:9): [True: 1, False: 44.0k] ------------------ 1519| 1| return 0; 1520| | 1521| | /* Decrease the flow level. */ 1522| | 1523| 44.0k| if (!yaml_parser_decrease_flow_level(parser)) ------------------ | Branch (1523:9): [True: 0, False: 44.0k] ------------------ 1524| 0| return 0; 1525| | 1526| | /* No simple keys after the indicators ']' and '}'. */ 1527| | 1528| 44.0k| parser->simple_key_allowed = 0; 1529| | 1530| | /* Consume the token. */ 1531| | 1532| 44.0k| start_mark = parser->mark; 1533| 44.0k| SKIP(parser); ------------------ | | 502| 44.0k| (parser->mark.index ++, \ | | 503| 44.0k| parser->mark.column ++, \ | | 504| 44.0k| parser->unread --, \ | | 505| 44.0k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 44.0k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 44.0k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 44.0k, False: 0] | | | | | | ------------------ | | | | | | 381| 44.0k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1534| 44.0k| end_mark = parser->mark; 1535| | 1536| | /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */ 1537| | 1538| 44.0k| TOKEN_INIT(token, type, start_mark, end_mark); ------------------ | | 500| 44.0k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 44.0k| (token).type = (token_type), \ | | 502| 44.0k| (token).start_mark = (token_start_mark), \ | | 503| 44.0k| (token).end_mark = (token_end_mark)) ------------------ 1539| | 1540| | /* Append the token to the queue. */ 1541| | 1542| 44.0k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 44.0k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 43.3k, False: 643] | | ------------------ | | 473| 44.0k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 643, False: 0] | | ------------------ | | 474| 643| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 44.0k| (*((queue).tail++) = value, \ | | 476| 44.0k| 1) : \ | | 477| 44.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1542:9): [True: 0, False: 44.0k] ------------------ 1543| 0| return 0; 1544| | 1545| 44.0k| return 1; 1546| 44.0k|} scanner.c:yaml_parser_decrease_flow_level: 1201| 44.0k|{ 1202| 44.0k| if (parser->flow_level) { ------------------ | Branch (1202:9): [True: 43.9k, False: 83] ------------------ 1203| 43.9k| parser->flow_level --; 1204| 43.9k| (void)POP(parser, parser->simple_keys); ------------------ | | 454| 43.9k| (*(--(stack).top)) ------------------ 1205| 43.9k| } 1206| | 1207| 44.0k| return 1; 1208| 44.0k|} scanner.c:yaml_parser_fetch_flow_entry: 1554| 3.04M|{ 1555| 3.04M| yaml_mark_t start_mark, end_mark; 1556| 3.04M| yaml_token_t token; 1557| | 1558| | /* Reset any potential simple keys on the current flow level. */ 1559| | 1560| 3.04M| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1560:9): [True: 1, False: 3.04M] ------------------ 1561| 1| return 0; 1562| | 1563| | /* Simple keys are allowed after ','. */ 1564| | 1565| 3.04M| parser->simple_key_allowed = 1; 1566| | 1567| | /* Consume the token. */ 1568| | 1569| 3.04M| start_mark = parser->mark; 1570| 3.04M| SKIP(parser); ------------------ | | 502| 3.04M| (parser->mark.index ++, \ | | 503| 3.04M| parser->mark.column ++, \ | | 504| 3.04M| parser->unread --, \ | | 505| 3.04M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 3.04M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 3.04M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 3.04M, False: 0] | | | | | | ------------------ | | | | | | 381| 3.04M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1571| 3.04M| end_mark = parser->mark; 1572| | 1573| | /* Create the FLOW-ENTRY token and append it to the queue. */ 1574| | 1575| 3.04M| TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark); ------------------ | | 500| 3.04M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 3.04M| (token).type = (token_type), \ | | 502| 3.04M| (token).start_mark = (token_start_mark), \ | | 503| 3.04M| (token).end_mark = (token_end_mark)) ------------------ 1576| | 1577| 3.04M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 3.04M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 3.04M, False: 1.49k] | | ------------------ | | 473| 3.04M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.49k, False: 0] | | ------------------ | | 474| 1.49k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 3.04M| (*((queue).tail++) = value, \ | | 476| 3.04M| 1) : \ | | 477| 3.04M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1577:9): [True: 0, False: 3.04M] ------------------ 1578| 0| return 0; 1579| | 1580| 3.04M| return 1; 1581| 3.04M|} scanner.c:yaml_parser_fetch_block_entry: 1589| 583k|{ 1590| 583k| yaml_mark_t start_mark, end_mark; 1591| 583k| yaml_token_t token; 1592| | 1593| | /* Check if the scanner is in the block context. */ 1594| | 1595| 583k| if (!parser->flow_level) ------------------ | Branch (1595:9): [True: 582k, False: 720] ------------------ 1596| 582k| { 1597| | /* Check if we are allowed to start a new entry. */ 1598| | 1599| 582k| if (!parser->simple_key_allowed) { ------------------ | Branch (1599:13): [True: 12, False: 582k] ------------------ 1600| 12| return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 1601| 12| "block sequence entries are not allowed in this context"); 1602| 12| } 1603| | 1604| | /* Add the BLOCK-SEQUENCE-START token if needed. */ 1605| | 1606| 582k| if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, ------------------ | Branch (1606:13): [True: 3, False: 582k] ------------------ 1607| 582k| YAML_BLOCK_SEQUENCE_START_TOKEN, parser->mark)) 1608| 3| return 0; 1609| 582k| } 1610| 720| else 1611| 720| { 1612| | /* 1613| | * It is an error for the '-' indicator to occur in the flow context, 1614| | * but we let the Parser detect and report about it because the Parser 1615| | * is able to point to the context. 1616| | */ 1617| 720| } 1618| | 1619| | /* Reset any potential simple keys on the current flow level. */ 1620| | 1621| 583k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1621:9): [True: 0, False: 583k] ------------------ 1622| 0| return 0; 1623| | 1624| | /* Simple keys are allowed after '-'. */ 1625| | 1626| 583k| parser->simple_key_allowed = 1; 1627| | 1628| | /* Consume the token. */ 1629| | 1630| 583k| start_mark = parser->mark; 1631| 583k| SKIP(parser); ------------------ | | 502| 583k| (parser->mark.index ++, \ | | 503| 583k| parser->mark.column ++, \ | | 504| 583k| parser->unread --, \ | | 505| 583k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 583k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 583k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 583k, False: 0] | | | | | | ------------------ | | | | | | 381| 583k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1632| 583k| end_mark = parser->mark; 1633| | 1634| | /* Create the BLOCK-ENTRY token and append it to the queue. */ 1635| | 1636| 583k| TOKEN_INIT(token, YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark); ------------------ | | 500| 583k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 583k| (token).type = (token_type), \ | | 502| 583k| (token).start_mark = (token_start_mark), \ | | 503| 583k| (token).end_mark = (token_end_mark)) ------------------ 1637| | 1638| 583k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 583k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 569k, False: 14.2k] | | ------------------ | | 473| 583k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 14.2k, False: 0] | | ------------------ | | 474| 14.2k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 583k| (*((queue).tail++) = value, \ | | 476| 583k| 1) : \ | | 477| 583k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1638:9): [True: 0, False: 583k] ------------------ 1639| 0| return 0; 1640| | 1641| 583k| return 1; 1642| 583k|} scanner.c:yaml_parser_roll_indent: 1220| 3.13M|{ 1221| 3.13M| yaml_token_t token; 1222| | 1223| | /* In the flow context, do nothing. */ 1224| | 1225| 3.13M| if (parser->flow_level) ------------------ | Branch (1225:9): [True: 11.1k, False: 3.12M] ------------------ 1226| 11.1k| return 1; 1227| | 1228| 3.12M| if (parser->indent < column) ------------------ | Branch (1228:9): [True: 2.33M, False: 792k] ------------------ 1229| 2.33M| { 1230| | /* 1231| | * Push the current indentation level to the stack and set the new 1232| | * indentation level. 1233| | */ 1234| | 1235| 2.33M| if (!PUSH(parser, parser->indents, parser->indent)) ------------------ | | 445| 2.33M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.33M, False: 1.93k] | | ------------------ | | 446| 2.33M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.93k, False: 0] | | ------------------ | | 447| 1.93k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.33M| (*((stack).top++) = value, \ | | 449| 2.33M| 1) : \ | | 450| 2.33M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1235:13): [True: 0, False: 2.33M] ------------------ 1236| 0| return 0; 1237| | 1238| 2.33M| if (!STACK_LIMIT(parser, parser->indents, MAX_NESTING_LEVEL - parser->flow_level)) { ------------------ | | 439| 2.33M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 2.33M, False: 8] | | ------------------ | | 440| 2.33M| 1 : \ | | 441| 2.33M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 8| 0)) ------------------ | Branch (1238:13): [True: 8, False: 2.33M] ------------------ 1239| 8| return yaml_parser_set_scanner_error(parser, 1240| 8| "while increasing block level", parser->mark, 1241| 8| "exceeded maximum nesting depth"); 1242| 8| } 1243| | 1244| 2.33M| if (column > INT_MAX) { ------------------ | Branch (1244:13): [True: 0, False: 2.33M] ------------------ 1245| 0| parser->error = YAML_MEMORY_ERROR; 1246| 0| return 0; 1247| 0| } 1248| | 1249| 2.33M| parser->indent = column; 1250| | 1251| | /* Create a token and insert it into the queue. */ 1252| | 1253| 2.33M| TOKEN_INIT(token, type, mark, mark); ------------------ | | 500| 2.33M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 2.33M| (token).type = (token_type), \ | | 502| 2.33M| (token).start_mark = (token_start_mark), \ | | 503| 2.33M| (token).end_mark = (token_end_mark)) ------------------ 1254| | 1255| 2.33M| if (number == -1) { ------------------ | Branch (1255:13): [True: 1.80M, False: 534k] ------------------ 1256| 1.80M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 1.80M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 1.70M, False: 94.5k] | | ------------------ | | 473| 1.80M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 94.5k, False: 0] | | ------------------ | | 474| 94.5k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 1.80M| (*((queue).tail++) = value, \ | | 476| 1.80M| 1) : \ | | 477| 1.80M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1256:17): [True: 0, False: 1.80M] ------------------ 1257| 0| return 0; 1258| 1.80M| } 1259| 534k| else { 1260| 534k| if (!QUEUE_INSERT(parser, ------------------ | | 484| 534k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (484:7): [True: 475k, False: 59.4k] | | ------------------ | | 485| 534k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (485:10): [True: 59.4k, False: 0] | | ------------------ | | 486| 59.4k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 487| 534k| (memmove((queue).head+(index)+1,(queue).head+(index), \ | | 488| 534k| ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \ | | 489| 534k| *((queue).head+(index)) = value, \ | | 490| 534k| (queue).tail++, \ | | 491| 534k| 1) : \ | | 492| 534k| ((context)->error = YAML_MEMORY_ERROR, \ | | 493| 0| 0)) ------------------ | Branch (1260:17): [True: 0, False: 534k] ------------------ 1261| 534k| parser->tokens, number - parser->tokens_parsed, token)) 1262| 0| return 0; 1263| 534k| } 1264| 2.33M| } 1265| | 1266| 3.12M| return 1; 1267| 3.12M|} scanner.c:yaml_parser_fetch_key: 1650| 1.95M|{ 1651| 1.95M| yaml_mark_t start_mark, end_mark; 1652| 1.95M| yaml_token_t token; 1653| | 1654| | /* In the block context, additional checks are required. */ 1655| | 1656| 1.95M| if (!parser->flow_level) ------------------ | Branch (1656:9): [True: 1.92M, False: 29.3k] ------------------ 1657| 1.92M| { 1658| | /* Check if we are allowed to start a new key (not necessary simple). */ 1659| | 1660| 1.92M| if (!parser->simple_key_allowed) { ------------------ | Branch (1660:13): [True: 12, False: 1.92M] ------------------ 1661| 12| return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 1662| 12| "mapping keys are not allowed in this context"); 1663| 12| } 1664| | 1665| | /* Add the BLOCK-MAPPING-START token if needed. */ 1666| | 1667| 1.92M| if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, ------------------ | Branch (1667:13): [True: 3, False: 1.92M] ------------------ 1668| 1.92M| YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) 1669| 3| return 0; 1670| 1.92M| } 1671| | 1672| | /* Reset any potential simple keys on the current flow level. */ 1673| | 1674| 1.95M| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1674:9): [True: 0, False: 1.95M] ------------------ 1675| 0| return 0; 1676| | 1677| | /* Simple keys are allowed after '?' in the block context. */ 1678| | 1679| 1.95M| parser->simple_key_allowed = (!parser->flow_level); 1680| | 1681| | /* Consume the token. */ 1682| | 1683| 1.95M| start_mark = parser->mark; 1684| 1.95M| SKIP(parser); ------------------ | | 502| 1.95M| (parser->mark.index ++, \ | | 503| 1.95M| parser->mark.column ++, \ | | 504| 1.95M| parser->unread --, \ | | 505| 1.95M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.95M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.95M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.95M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.95M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1685| 1.95M| end_mark = parser->mark; 1686| | 1687| | /* Create the KEY token and append it to the queue. */ 1688| | 1689| 1.95M| TOKEN_INIT(token, YAML_KEY_TOKEN, start_mark, end_mark); ------------------ | | 500| 1.95M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 1.95M| (token).type = (token_type), \ | | 502| 1.95M| (token).start_mark = (token_start_mark), \ | | 503| 1.95M| (token).end_mark = (token_end_mark)) ------------------ 1690| | 1691| 1.95M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 1.95M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 1.92M, False: 27.0k] | | ------------------ | | 473| 1.95M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 27.0k, False: 0] | | ------------------ | | 474| 27.0k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 1.95M| (*((queue).tail++) = value, \ | | 476| 1.95M| 1) : \ | | 477| 1.95M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1691:9): [True: 0, False: 1.95M] ------------------ 1692| 0| return 0; 1693| | 1694| 1.95M| return 1; 1695| 1.95M|} scanner.c:yaml_parser_fetch_value: 1703| 633k|{ 1704| 633k| yaml_mark_t start_mark, end_mark; 1705| 633k| yaml_token_t token; 1706| 633k| yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 1707| | 1708| | /* Have we found a simple key? */ 1709| | 1710| 633k| if (simple_key->possible) ------------------ | Branch (1710:9): [True: 630k, False: 3.55k] ------------------ 1711| 630k| { 1712| | 1713| | /* Create the KEY token and insert it into the queue. */ 1714| | 1715| 630k| TOKEN_INIT(token, YAML_KEY_TOKEN, simple_key->mark, simple_key->mark); ------------------ | | 500| 630k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 630k| (token).type = (token_type), \ | | 502| 630k| (token).start_mark = (token_start_mark), \ | | 503| 630k| (token).end_mark = (token_end_mark)) ------------------ 1716| | 1717| 630k| if (!QUEUE_INSERT(parser, parser->tokens, ------------------ | | 484| 630k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (484:7): [True: 618k, False: 11.7k] | | ------------------ | | 485| 630k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (485:10): [True: 11.7k, False: 0] | | ------------------ | | 486| 11.7k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 487| 630k| (memmove((queue).head+(index)+1,(queue).head+(index), \ | | 488| 630k| ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \ | | 489| 630k| *((queue).head+(index)) = value, \ | | 490| 630k| (queue).tail++, \ | | 491| 630k| 1) : \ | | 492| 630k| ((context)->error = YAML_MEMORY_ERROR, \ | | 493| 0| 0)) ------------------ | Branch (1717:13): [True: 0, False: 630k] ------------------ 1718| 630k| simple_key->token_number - parser->tokens_parsed, token)) 1719| 0| return 0; 1720| | 1721| | /* In the block context, we may need to add the BLOCK-MAPPING-START token. */ 1722| | 1723| 630k| if (!yaml_parser_roll_indent(parser, simple_key->mark.column, ------------------ | Branch (1723:13): [True: 1, False: 630k] ------------------ 1724| 630k| simple_key->token_number, 1725| 630k| YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark)) 1726| 1| return 0; 1727| | 1728| | /* Remove the simple key. */ 1729| | 1730| 630k| simple_key->possible = 0; 1731| | 1732| | /* A simple key cannot follow another simple key. */ 1733| | 1734| 630k| parser->simple_key_allowed = 0; 1735| 630k| } 1736| 3.55k| else 1737| 3.55k| { 1738| | /* The ':' indicator follows a complex key. */ 1739| | 1740| | /* In the block context, extra checks are required. */ 1741| | 1742| 3.55k| if (!parser->flow_level) ------------------ | Branch (1742:13): [True: 1.38k, False: 2.16k] ------------------ 1743| 1.38k| { 1744| | /* Check if we are allowed to start a complex value. */ 1745| | 1746| 1.38k| if (!parser->simple_key_allowed) { ------------------ | Branch (1746:17): [True: 31, False: 1.35k] ------------------ 1747| 31| return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 1748| 31| "mapping values are not allowed in this context"); 1749| 31| } 1750| | 1751| | /* Add the BLOCK-MAPPING-START token if needed. */ 1752| | 1753| 1.35k| if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, ------------------ | Branch (1753:17): [True: 1, False: 1.35k] ------------------ 1754| 1.35k| YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) 1755| 1| return 0; 1756| 1.35k| } 1757| | 1758| | /* Simple keys after ':' are allowed in the block context. */ 1759| | 1760| 3.52k| parser->simple_key_allowed = (!parser->flow_level); 1761| 3.52k| } 1762| | 1763| | /* Consume the token. */ 1764| | 1765| 633k| start_mark = parser->mark; 1766| 633k| SKIP(parser); ------------------ | | 502| 633k| (parser->mark.index ++, \ | | 503| 633k| parser->mark.column ++, \ | | 504| 633k| parser->unread --, \ | | 505| 633k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 633k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 633k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 633k, False: 0] | | | | | | ------------------ | | | | | | 381| 633k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1767| 633k| end_mark = parser->mark; 1768| | 1769| | /* Create the VALUE token and append it to the queue. */ 1770| | 1771| 633k| TOKEN_INIT(token, YAML_VALUE_TOKEN, start_mark, end_mark); ------------------ | | 500| 633k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 633k| (token).type = (token_type), \ | | 502| 633k| (token).start_mark = (token_start_mark), \ | | 503| 633k| (token).end_mark = (token_end_mark)) ------------------ 1772| | 1773| 633k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 633k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 620k, False: 13.8k] | | ------------------ | | 473| 633k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 13.8k, False: 0] | | ------------------ | | 474| 13.8k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 633k| (*((queue).tail++) = value, \ | | 476| 633k| 1) : \ | | 477| 633k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1773:9): [True: 0, False: 633k] ------------------ 1774| 0| return 0; 1775| | 1776| 633k| return 1; 1777| 633k|} scanner.c:yaml_parser_fetch_anchor: 1785| 152k|{ 1786| 152k| yaml_token_t token; 1787| | 1788| | /* An anchor or an alias could be a simple key. */ 1789| | 1790| 152k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1790:9): [True: 0, False: 152k] ------------------ 1791| 0| return 0; 1792| | 1793| | /* A simple key cannot follow an anchor or an alias. */ 1794| | 1795| 152k| parser->simple_key_allowed = 0; 1796| | 1797| | /* Create the ALIAS or ANCHOR token and append it to the queue. */ 1798| | 1799| 152k| if (!yaml_parser_scan_anchor(parser, &token, type)) ------------------ | Branch (1799:9): [True: 121, False: 152k] ------------------ 1800| 121| return 0; 1801| | 1802| 152k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 152k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 138k, False: 13.9k] | | ------------------ | | 473| 152k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 13.9k, False: 0] | | ------------------ | | 474| 13.9k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 152k| (*((queue).tail++) = value, \ | | 476| 152k| 1) : \ | | 477| 152k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1802:9): [True: 0, False: 152k] ------------------ 1803| 0| yaml_token_delete(&token); 1804| 0| return 0; 1805| 0| } 1806| 152k| return 1; 1807| 152k|} scanner.c:yaml_parser_scan_anchor: 2341| 152k|{ 2342| 152k| int length = 0; 2343| 152k| yaml_mark_t start_mark, end_mark; 2344| 152k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 152k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2345| | 2346| 152k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 152k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 152k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 152k, False: 0] | | ------------------ | | 134| 152k| ((string).pointer = (string).start, \ | | 135| 152k| (string).end = (string).start+(size), \ | | 136| 152k| memset((string).start, 0, (size)), \ | | 137| 152k| 1) : \ | | 138| 152k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2346:9): [True: 0, False: 152k] ------------------ 2347| | 2348| | /* Eat the indicator character. */ 2349| | 2350| 152k| start_mark = parser->mark; 2351| | 2352| 152k| SKIP(parser); ------------------ | | 502| 152k| (parser->mark.index ++, \ | | 503| 152k| parser->mark.column ++, \ | | 504| 152k| parser->unread --, \ | | 505| 152k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 152k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 152k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 152k, False: 0] | | | | | | ------------------ | | | | | | 381| 152k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2353| | 2354| | /* Consume the value. */ 2355| | 2356| 152k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 152k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 152k, False: 0] | | ------------------ | | 494| 152k| ? 1 \ | | 495| 152k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2356:9): [True: 0, False: 152k] ------------------ 2357| | 2358| 2.59M| while (IS_ALPHA(parser->buffer)) { 2359| 2.59M| if (!READ(parser, string)) goto error; ------------------ | | 526| 2.59M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 2.59M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 2.59M, False: 0] | | | | | Branch (146:7): [True: 2.59M, False: 608] | | | | ------------------ | | | | 147| 2.59M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 608, False: 0] | | | | ------------------ | | | | 148| 608| &(string).pointer, &(string).end)) ? \ | | | | 149| 2.59M| 1 : \ | | | | 150| 2.59M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 2.59M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 2.59M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 2.59M, False: 0] | | | | ------------------ | | | | 399| 2.59M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 2.59M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 2.59M| parser->mark.index ++, \ | | 529| 2.59M| parser->mark.column ++, \ | | 530| 2.59M| parser->unread --, \ | | 531| 2.59M| 1) : 0) ------------------ | Branch (2359:13): [True: 0, False: 2.59M] ------------------ 2360| 2.59M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 2.59M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.59M, False: 397] | | ------------------ | | 494| 2.59M| ? 1 \ | | 495| 2.59M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2360:13): [True: 1, False: 2.59M] ------------------ 2361| 2.59M| length ++; 2362| 2.59M| } 2363| | 2364| 152k| end_mark = parser->mark; 2365| | 2366| | /* 2367| | * Check if length of the anchor is greater than 0 and it is followed by 2368| | * a whitespace character or one of the indicators: 2369| | * 2370| | * '?', ':', ',', ']', '}', '%', '@', '`'. 2371| | */ 2372| | 2373| 152k| if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?') ------------------ | | 373| 152k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 304k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 304k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 152k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 304k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 697, False: 151k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 151k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 151k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 511, False: 151k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 151k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 302k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 302k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 4.11k, False: 147k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 151k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 298k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 263, False: 146k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 151k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 293k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 195, False: 146k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 146k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 195| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 194, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 151k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 293k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 390, False: 146k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 146k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 146k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 389, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 146k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 389| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 194, False: 195] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 302k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 292k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 146k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 146k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 146k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 195, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 146k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 195| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 194, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 146k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 146k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 374, False: 145k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?') ------------------ | | 181| 298k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 145k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 325, False: 145k] | | ------------------ ------------------ | Branch (2373:9): [True: 97, False: 152k] ------------------ 2374| 145k| || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') ------------------ | | 181| 297k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 145k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.05k, False: 139k] | | ------------------ ------------------ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') ------------------ | | 181| 291k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 139k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 138k, False: 981] | | ------------------ ------------------ 2375| 981| || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}') ------------------ | | 181| 153k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 981| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 699, False: 282] | | ------------------ ------------------ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}') ------------------ | | 181| 152k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 282| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 246, False: 36] | | ------------------ ------------------ 2376| 36| || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') ------------------ | | 181| 152k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 36| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 7, False: 29] | | ------------------ ------------------ || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') ------------------ | | 181| 152k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 29| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3, False: 26] | | ------------------ ------------------ 2377| 120| || CHECK(parser->buffer, '`'))) { ------------------ | | 181| 26|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 26| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3, False: 23] | | ------------------ ------------------ 2378| 120| yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ? ------------------ | Branch (2378:47): [True: 79, False: 41] ------------------ 2379| 79| "while scanning an anchor" : "while scanning an alias", start_mark, 2380| 120| "did not find expected alphabetic or numeric character"); 2381| 120| goto error; 2382| 120| } 2383| | 2384| | /* Create a token. */ 2385| | 2386| 152k| if (type == YAML_ANCHOR_TOKEN) { ------------------ | Branch (2386:9): [True: 8.32k, False: 144k] ------------------ 2387| 8.32k| ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark); ------------------ | | 517| 8.32k| (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 8.32k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 8.32k| (token).type = (token_type), \ | | | | 502| 8.32k| (token).start_mark = (token_start_mark), \ | | | | 503| 8.32k| (token).end_mark = (token_end_mark)) | | ------------------ | | 518| 8.32k| (token).data.anchor.value = (token_value)) ------------------ 2388| 8.32k| } 2389| 144k| else { 2390| 144k| ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark); ------------------ | | 513| 144k| (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 144k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 144k| (token).type = (token_type), \ | | | | 502| 144k| (token).start_mark = (token_start_mark), \ | | | | 503| 144k| (token).end_mark = (token_end_mark)) | | ------------------ | | 514| 144k| (token).data.alias.value = (token_value)) ------------------ 2391| 144k| } 2392| | 2393| 152k| return 1; 2394| | 2395| 121|error: 2396| 121| STRING_DEL(parser, string); ------------------ | | 142| 121| (yaml_free((string).start), \ | | 143| 121| (string).start = (string).pointer = (string).end = 0) ------------------ 2397| 121| return 0; 2398| 152k|} scanner.c:yaml_parser_fetch_tag: 1815| 14.1k|{ 1816| 14.1k| yaml_token_t token; 1817| | 1818| | /* A tag could be a simple key. */ 1819| | 1820| 14.1k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1820:9): [True: 0, False: 14.1k] ------------------ 1821| 0| return 0; 1822| | 1823| | /* A simple key cannot follow a tag. */ 1824| | 1825| 14.1k| parser->simple_key_allowed = 0; 1826| | 1827| | /* Create the TAG token and append it to the queue. */ 1828| | 1829| 14.1k| if (!yaml_parser_scan_tag(parser, &token)) ------------------ | Branch (1829:9): [True: 236, False: 13.8k] ------------------ 1830| 236| return 0; 1831| | 1832| 13.8k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 13.8k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 13.1k, False: 685] | | ------------------ | | 473| 13.8k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 685, False: 0] | | ------------------ | | 474| 685| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 13.8k| (*((queue).tail++) = value, \ | | 476| 13.8k| 1) : \ | | 477| 13.8k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1832:9): [True: 0, False: 13.8k] ------------------ 1833| 0| yaml_token_delete(&token); 1834| 0| return 0; 1835| 0| } 1836| | 1837| 13.8k| return 1; 1838| 13.8k|} scanner.c:yaml_parser_scan_tag: 2406| 14.1k|{ 2407| 14.1k| yaml_char_t *handle = NULL; 2408| 14.1k| yaml_char_t *suffix = NULL; 2409| 14.1k| yaml_mark_t start_mark, end_mark; 2410| | 2411| 14.1k| start_mark = parser->mark; 2412| | 2413| | /* Check if the tag is in the canonical form. */ 2414| | 2415| 14.1k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 14.1k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 14.1k, False: 0] | | ------------------ | | 494| 14.1k| ? 1 \ | | 495| 14.1k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2415:9): [True: 0, False: 14.1k] ------------------ 2416| | 2417| 14.1k| if (CHECK_AT(parser->buffer, '<', 1)) ------------------ | | 175| 14.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.98k, False: 11.1k] | | ------------------ ------------------ 2418| 2.98k| { 2419| | /* Set the handle to '' */ 2420| | 2421| 2.98k| handle = YAML_MALLOC(1); ------------------ | | 684| 2.98k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 2422| 2.98k| if (!handle) goto error; ------------------ | Branch (2422:13): [True: 0, False: 2.98k] ------------------ 2423| 2.98k| handle[0] = '\0'; 2424| | 2425| | /* Eat '!<' */ 2426| | 2427| 2.98k| SKIP(parser); ------------------ | | 502| 2.98k| (parser->mark.index ++, \ | | 503| 2.98k| parser->mark.column ++, \ | | 504| 2.98k| parser->unread --, \ | | 505| 2.98k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.98k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.98k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.98k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.98k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2428| 2.98k| SKIP(parser); ------------------ | | 502| 2.98k| (parser->mark.index ++, \ | | 503| 2.98k| parser->mark.column ++, \ | | 504| 2.98k| parser->unread --, \ | | 505| 2.98k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.98k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.98k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.98k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.98k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2429| | 2430| | /* Consume the tag value. */ 2431| | 2432| 2.98k| if (!yaml_parser_scan_tag_uri(parser, 1, 0, NULL, start_mark, &suffix)) ------------------ | Branch (2432:13): [True: 10, False: 2.97k] ------------------ 2433| 10| goto error; 2434| | 2435| | /* Check for '>' and eat it. */ 2436| | 2437| 2.97k| if (!CHECK(parser->buffer, '>')) { ------------------ | | 181| 2.97k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.97k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2437:13): [True: 35, False: 2.94k] ------------------ 2438| 35| yaml_parser_set_scanner_error(parser, "while scanning a tag", 2439| 35| start_mark, "did not find the expected '>'"); 2440| 35| goto error; 2441| 35| } 2442| | 2443| 2.94k| SKIP(parser); ------------------ | | 502| 2.94k| (parser->mark.index ++, \ | | 503| 2.94k| parser->mark.column ++, \ | | 504| 2.94k| parser->unread --, \ | | 505| 2.94k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.94k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.94k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.94k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.94k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2444| 2.94k| } 2445| 11.1k| else 2446| 11.1k| { 2447| | /* The tag has either the '!suffix' or the '!handle!suffix' form. */ 2448| | 2449| | /* First, try to scan a handle. */ 2450| | 2451| 11.1k| if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle)) ------------------ | Branch (2451:13): [True: 1, False: 11.1k] ------------------ 2452| 1| goto error; 2453| | 2454| | /* Check if it is, indeed, handle. */ 2455| | 2456| 11.1k| if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!') ------------------ | Branch (2456:13): [True: 11.1k, False: 0] | Branch (2456:33): [True: 5.43k, False: 5.69k] | Branch (2456:54): [True: 1.02k, False: 4.40k] ------------------ 2457| 1.02k| { 2458| | /* Scan the suffix now. */ 2459| | 2460| 1.02k| if (!yaml_parser_scan_tag_uri(parser, 0, 0, NULL, start_mark, &suffix)) ------------------ | Branch (2460:17): [True: 24, False: 1.00k] ------------------ 2461| 24| goto error; 2462| 1.02k| } 2463| 10.1k| else 2464| 10.1k| { 2465| | /* It wasn't a handle after all. Scan the rest of the tag. */ 2466| | 2467| 10.1k| if (!yaml_parser_scan_tag_uri(parser, 0, 0, handle, start_mark, &suffix)) ------------------ | Branch (2467:17): [True: 109, False: 9.99k] ------------------ 2468| 109| goto error; 2469| | 2470| | /* Set the handle to '!'. */ 2471| | 2472| 9.99k| yaml_free(handle); 2473| 9.99k| handle = YAML_MALLOC(2); ------------------ | | 684| 9.99k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 2474| 9.99k| if (!handle) goto error; ------------------ | Branch (2474:17): [True: 0, False: 9.99k] ------------------ 2475| 9.99k| handle[0] = '!'; 2476| 9.99k| handle[1] = '\0'; 2477| | 2478| | /* 2479| | * A special case: the '!' tag. Set the handle to '' and the 2480| | * suffix to '!'. 2481| | */ 2482| | 2483| 9.99k| if (suffix[0] == '\0') { ------------------ | Branch (2483:17): [True: 4.44k, False: 5.54k] ------------------ 2484| 4.44k| yaml_char_t *tmp = handle; 2485| 4.44k| handle = suffix; 2486| 4.44k| suffix = tmp; 2487| 4.44k| } 2488| 9.99k| } 2489| 11.1k| } 2490| | 2491| | /* Check the character which ends the tag. */ 2492| | 2493| 13.9k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 13.9k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 13.7k, False: 162] | | ------------------ | | 494| 13.9k| ? 1 \ | | 495| 13.9k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2493:9): [True: 1, False: 13.9k] ------------------ 2494| | 2495| 13.9k| if (!IS_BLANKZ(parser->buffer)) { ------------------ | | 373| 13.9k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 13.9k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 27.8k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 13.9k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 27.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 5.21k, False: 8.72k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 8.72k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 8.72k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 435, False: 8.29k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 8.29k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 16.5k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 16.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.13k, False: 5.16k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 8.29k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 13.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.71k, False: 3.45k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 8.29k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.90k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 3.25k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 3.45k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 196| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 195, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 8.29k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.51k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 404, False: 2.85k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 3.25k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.65k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 403, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 3.25k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 403| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 199, False: 204] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 16.5k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.11k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 205, False: 2.85k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 3.05k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.26k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 204, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 3.05k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 204| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 8] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 2.86k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 2.86k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 825, False: 2.03k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2496| 2.03k| if (!parser->flow_level || !CHECK(parser->buffer, ',') ) { ------------------ | | 181| 1.98k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.98k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2496:13): [True: 47, False: 1.98k] | Branch (2496:36): [True: 9, False: 1.97k] ------------------ 2497| 56| yaml_parser_set_scanner_error(parser, "while scanning a tag", 2498| 56| start_mark, "did not find expected whitespace or line break"); 2499| 56| goto error; 2500| 56| } 2501| 2.03k| } 2502| | 2503| 13.8k| end_mark = parser->mark; 2504| | 2505| | /* Create a token. */ 2506| | 2507| 13.8k| TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark); ------------------ | | 521| 13.8k| (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 13.8k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 13.8k| (token).type = (token_type), \ | | | | 502| 13.8k| (token).start_mark = (token_start_mark), \ | | | | 503| 13.8k| (token).end_mark = (token_end_mark)) | | ------------------ | | 522| 13.8k| (token).data.tag.handle = (token_handle), \ | | 523| 13.8k| (token).data.tag.suffix = (token_suffix)) ------------------ 2508| | 2509| 13.8k| return 1; 2510| | 2511| 236|error: 2512| 236| yaml_free(handle); 2513| 236| yaml_free(suffix); 2514| 236| return 0; 2515| 13.9k|} scanner.c:yaml_parser_fetch_block_scalar: 1846| 35.4k|{ 1847| 35.4k| yaml_token_t token; 1848| | 1849| | /* Remove any potential simple keys. */ 1850| | 1851| 35.4k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1851:9): [True: 1, False: 35.4k] ------------------ 1852| 1| return 0; 1853| | 1854| | /* A simple key may follow a block scalar. */ 1855| | 1856| 35.4k| parser->simple_key_allowed = 1; 1857| | 1858| | /* Create the SCALAR token and append it to the queue. */ 1859| | 1860| 35.4k| if (!yaml_parser_scan_block_scalar(parser, &token, literal)) ------------------ | Branch (1860:9): [True: 89, False: 35.3k] ------------------ 1861| 89| return 0; 1862| | 1863| 35.3k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 35.3k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 34.0k, False: 1.30k] | | ------------------ | | 473| 35.3k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.30k, False: 0] | | ------------------ | | 474| 1.30k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 35.3k| (*((queue).tail++) = value, \ | | 476| 35.3k| 1) : \ | | 477| 35.3k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1863:9): [True: 0, False: 35.3k] ------------------ 1864| 0| yaml_token_delete(&token); 1865| 0| return 0; 1866| 0| } 1867| | 1868| 35.3k| return 1; 1869| 35.3k|} scanner.c:yaml_parser_scan_block_scalar: 2761| 35.4k|{ 2762| 35.4k| yaml_mark_t start_mark; 2763| 35.4k| yaml_mark_t end_mark; 2764| 35.4k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 35.4k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2765| 35.4k| yaml_string_t leading_break = NULL_STRING; ------------------ | | 123| 35.4k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2766| 35.4k| yaml_string_t trailing_breaks = NULL_STRING; ------------------ | | 123| 35.4k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2767| 35.4k| int chomping = 0; 2768| 35.4k| int increment = 0; 2769| 35.4k| int indent = 0; 2770| 35.4k| int leading_blank = 0; 2771| 35.4k| int trailing_blank = 0; 2772| | 2773| 35.4k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 35.4k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 35.4k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 35.4k, False: 0] | | ------------------ | | 134| 35.4k| ((string).pointer = (string).start, \ | | 135| 35.4k| (string).end = (string).start+(size), \ | | 136| 35.4k| memset((string).start, 0, (size)), \ | | 137| 35.4k| 1) : \ | | 138| 35.4k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2773:9): [True: 0, False: 35.4k] ------------------ 2774| 35.4k| if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 35.4k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 35.4k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 35.4k, False: 0] | | ------------------ | | 134| 35.4k| ((string).pointer = (string).start, \ | | 135| 35.4k| (string).end = (string).start+(size), \ | | 136| 35.4k| memset((string).start, 0, (size)), \ | | 137| 35.4k| 1) : \ | | 138| 35.4k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2774:9): [True: 0, False: 35.4k] ------------------ 2775| 35.4k| if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 35.4k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 35.4k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 35.4k, False: 0] | | ------------------ | | 134| 35.4k| ((string).pointer = (string).start, \ | | 135| 35.4k| (string).end = (string).start+(size), \ | | 136| 35.4k| memset((string).start, 0, (size)), \ | | 137| 35.4k| 1) : \ | | 138| 35.4k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2775:9): [True: 0, False: 35.4k] ------------------ 2776| | 2777| | /* Eat the indicator '|' or '>'. */ 2778| | 2779| 35.4k| start_mark = parser->mark; 2780| | 2781| 35.4k| SKIP(parser); ------------------ | | 502| 35.4k| (parser->mark.index ++, \ | | 503| 35.4k| parser->mark.column ++, \ | | 504| 35.4k| parser->unread --, \ | | 505| 35.4k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 35.4k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 35.4k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 35.4k, False: 0] | | | | | | ------------------ | | | | | | 381| 35.4k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2782| | 2783| | /* Scan the additional block scalar indicators. */ 2784| | 2785| 35.4k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 35.4k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 35.4k, False: 0] | | ------------------ | | 494| 35.4k| ? 1 \ | | 495| 35.4k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2785:9): [True: 0, False: 35.4k] ------------------ 2786| | 2787| | /* Check for a chomping indicator. */ 2788| | 2789| 35.4k| if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) ------------------ | | 181| 70.9k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 35.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 15.3k, False: 20.1k] | | ------------------ ------------------ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) ------------------ | | 181| 20.1k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 20.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.04k, False: 17.0k] | | ------------------ ------------------ 2790| 18.3k| { 2791| | /* Set the chomping method and eat the indicator. */ 2792| | 2793| 18.3k| chomping = CHECK(parser->buffer, '+') ? +1 : -1; ------------------ | | 181| 18.3k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 18.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 15.3k, False: 3.04k] | | ------------------ ------------------ 2794| | 2795| 18.3k| SKIP(parser); ------------------ | | 502| 18.3k| (parser->mark.index ++, \ | | 503| 18.3k| parser->mark.column ++, \ | | 504| 18.3k| parser->unread --, \ | | 505| 18.3k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 18.3k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 18.3k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 18.3k, False: 0] | | | | | | ------------------ | | | | | | 381| 18.3k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2796| | 2797| | /* Check for an indentation indicator. */ 2798| | 2799| 18.3k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 18.3k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 18.3k, False: 0] | | ------------------ | | 494| 18.3k| ? 1 \ | | 495| 18.3k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2799:13): [True: 0, False: 18.3k] ------------------ 2800| | 2801| 18.3k| if (IS_DIGIT(parser->buffer)) ------------------ | | 208| 18.3k|#define IS_DIGIT(string) IS_DIGIT_AT((string),0) | | ------------------ | | | | 205| 18.3k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (205:8): [True: 646, False: 17.7k] | | | | ------------------ | | | | 206| 18.3k| (string).pointer[offset] <= (yaml_char_t) '9')) | | | | ------------------ | | | | | Branch (206:8): [True: 297, False: 349] | | | | ------------------ | | ------------------ ------------------ 2802| 297| { 2803| | /* Check that the indentation is greater than 0. */ 2804| | 2805| 297| if (CHECK(parser->buffer, '0')) { ------------------ | | 181| 297|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 297| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2, False: 295] | | ------------------ ------------------ 2806| 2| yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 2807| 2| start_mark, "found an indentation indicator equal to 0"); 2808| 2| goto error; 2809| 2| } 2810| | 2811| | /* Get the indentation level and eat the indicator. */ 2812| | 2813| 295| increment = AS_DIGIT(parser->buffer); ------------------ | | 217| 295|#define AS_DIGIT(string) AS_DIGIT_AT((string),0) | | ------------------ | | | | 215| 295| ((string).pointer[offset] - (yaml_char_t) '0') | | ------------------ ------------------ 2814| | 2815| 295| SKIP(parser); ------------------ | | 502| 295| (parser->mark.index ++, \ | | 503| 295| parser->mark.column ++, \ | | 504| 295| parser->unread --, \ | | 505| 295| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 295|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 295| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 295, False: 0] | | | | | | ------------------ | | | | | | 381| 295| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2816| 295| } 2817| 18.3k| } 2818| | 2819| | /* Do the same as above, but in the opposite order. */ 2820| | 2821| 17.0k| else if (IS_DIGIT(parser->buffer)) ------------------ | | 208| 17.0k|#define IS_DIGIT(string) IS_DIGIT_AT((string),0) | | ------------------ | | | | 205| 17.0k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (205:8): [True: 2.66k, False: 14.4k] | | | | ------------------ | | | | 206| 17.0k| (string).pointer[offset] <= (yaml_char_t) '9')) | | | | ------------------ | | | | | Branch (206:8): [True: 1.94k, False: 728] | | | | ------------------ | | ------------------ ------------------ 2822| 1.94k| { 2823| 1.94k| if (CHECK(parser->buffer, '0')) { ------------------ | | 181| 1.94k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.94k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1, False: 1.94k] | | ------------------ ------------------ 2824| 1| yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 2825| 1| start_mark, "found an indentation indicator equal to 0"); 2826| 1| goto error; 2827| 1| } 2828| | 2829| 1.94k| increment = AS_DIGIT(parser->buffer); ------------------ | | 217| 1.94k|#define AS_DIGIT(string) AS_DIGIT_AT((string),0) | | ------------------ | | | | 215| 1.94k| ((string).pointer[offset] - (yaml_char_t) '0') | | ------------------ ------------------ 2830| | 2831| 1.94k| SKIP(parser); ------------------ | | 502| 1.94k| (parser->mark.index ++, \ | | 503| 1.94k| parser->mark.column ++, \ | | 504| 1.94k| parser->unread --, \ | | 505| 1.94k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.94k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.94k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.94k, False: 0] | | | | | | ------------------ | | | | | | 381| 1.94k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2832| | 2833| 1.94k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.94k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.94k, False: 0] | | ------------------ | | 494| 1.94k| ? 1 \ | | 495| 1.94k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2833:13): [True: 0, False: 1.94k] ------------------ 2834| | 2835| 1.94k| if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { ------------------ | | 181| 3.88k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.94k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 206, False: 1.73k] | | ------------------ ------------------ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { ------------------ | | 181| 1.73k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.73k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 199, False: 1.53k] | | ------------------ ------------------ 2836| 405| chomping = CHECK(parser->buffer, '+') ? +1 : -1; ------------------ | | 181| 405|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 405| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 206, False: 199] | | ------------------ ------------------ 2837| | 2838| 405| SKIP(parser); ------------------ | | 502| 405| (parser->mark.index ++, \ | | 503| 405| parser->mark.column ++, \ | | 504| 405| parser->unread --, \ | | 505| 405| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 405|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 405| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 405, False: 0] | | | | | | ------------------ | | | | | | 381| 405| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2839| 405| } 2840| 1.94k| } 2841| | 2842| | /* Eat whitespaces and comments to the end of the line. */ 2843| | 2844| 35.4k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 35.4k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 35.4k, False: 0] | | ------------------ | | 494| 35.4k| ? 1 \ | | 495| 35.4k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2844:9): [True: 0, False: 35.4k] ------------------ 2845| | 2846| 1.24M| while (IS_BLANK(parser->buffer)) { 2847| 1.24M| SKIP(parser); ------------------ | | 502| 1.24M| (parser->mark.index ++, \ | | 503| 1.24M| parser->mark.column ++, \ | | 504| 1.24M| parser->unread --, \ | | 505| 1.24M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.24M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.24M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.24M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.24M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2848| 1.24M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.24M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.24M, False: 101] | | ------------------ | | 494| 1.24M| ? 1 \ | | 495| 1.24M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2848:13): [True: 1, False: 1.24M] ------------------ 2849| 1.24M| } 2850| | 2851| 35.4k| if (CHECK(parser->buffer, '#')) { ------------------ | | 181| 35.4k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 35.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.87k, False: 26.5k] | | ------------------ ------------------ 2852| 5.57M| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 5.57M|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 5.57M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 11.1M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 11.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 376, False: 5.57M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 5.57M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 11.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.26k, False: 5.57M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 5.57M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 11.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 391, False: 5.57M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 5.57M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 391| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 197, False: 194] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 5.57M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 11.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.11k, False: 5.56M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 5.57M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 5.57M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 7.83k, False: 275] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 5.57M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 7.83k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 72, False: 7.76k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 11.1M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 11.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.03k, False: 5.56M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 5.57M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 5.57M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 7.76k, False: 275] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 5.57M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 7.76k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.84k, False: 4.91k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 5.56M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 5.56M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 113, False: 5.56M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2853| 5.56M| SKIP(parser); ------------------ | | 502| 5.56M| (parser->mark.index ++, \ | | 503| 5.56M| parser->mark.column ++, \ | | 504| 5.56M| parser->unread --, \ | | 505| 5.56M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 5.56M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 5.56M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 5.56M, False: 6.08k] | | | | | | ------------------ | | | | | | 381| 5.56M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 208, False: 5.87k] | | | | | | ------------------ | | | | | | 382| 6.08k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 5.50k, False: 366] | | | | | | ------------------ | | | | | | 383| 5.87k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 366, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2854| 5.56M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 5.56M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 5.56M, False: 410] | | ------------------ | | 494| 5.56M| ? 1 \ | | 495| 5.56M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2854:17): [True: 2, False: 5.56M] ------------------ 2855| 5.56M| } 2856| 8.87k| } 2857| | 2858| | /* Check if we are at the end of the line. */ 2859| | 2860| 35.4k| if (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 35.4k|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 35.4k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 70.8k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 70.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 17.6k, False: 17.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 35.4k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 53.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13.2k, False: 4.50k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 35.4k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 9.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 579, False: 3.92k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 4.50k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 579| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 574, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 35.4k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 7.85k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.59k, False: 332] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 3.92k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 7.52k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.59k, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 3.92k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 3.59k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 445, False: 3.14k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 70.8k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 6.96k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.15k, False: 332] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 3.48k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 6.63k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.14k, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 3.48k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 3.14k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.14k, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 340|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 340| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 274, False: 66] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2861| 66| yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 2862| 66| start_mark, "did not find expected comment or line break"); 2863| 66| goto error; 2864| 66| } 2865| | 2866| | /* Eat a line break. */ 2867| | 2868| 35.3k| if (IS_BREAK(parser->buffer)) { ------------------ | | 341| 35.3k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 35.3k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 70.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 17.6k, False: 17.6k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 35.3k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 53.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 13.2k, False: 4.43k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 35.3k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 8.87k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 574, False: 3.86k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 4.43k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 574| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 574, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 334| 35.3k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 7.72k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.58k, False: 274] | | | | | | ------------------ | | | | ------------------ | | | | 335| 3.86k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 7.45k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.58k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 336| 3.86k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 3.58k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 445, False: 3.14k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 35.3k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.83k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.14k, False: 274] | | | | | | ------------------ | | | | ------------------ | | | | 338| 3.41k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 6.56k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.14k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 339| 3.41k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 3.14k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.14k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2869| 35.1k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 35.1k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 35.0k, False: 14] | | ------------------ | | 494| 35.1k| ? 1 \ | | 495| 35.1k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2869:13): [True: 1, False: 35.1k] ------------------ 2870| 35.1k| SKIP_LINE(parser); ------------------ | | 508| 35.1k| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 35.1k|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 35.1k| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 70.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 17.6k, False: 17.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 17.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 467, False: 17.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 35.1k| (parser->mark.index += 2, \ | | 510| 467| parser->mark.column = 0, \ | | 511| 467| parser->mark.line ++, \ | | 512| 467| parser->unread -= 2, \ | | 513| 467| parser->buffer.pointer += 2) : \ | | 514| 35.1k| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 34.6k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 69.2k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 69.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 17.2k, False: 17.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 34.6k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 52.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13.2k, False: 4.16k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 34.6k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 8.32k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 574, False: 3.58k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 4.16k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 574| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 574, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 34.6k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 7.17k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.58k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 3.58k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 7.17k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.58k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 3.58k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 3.58k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 445, False: 3.14k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 69.2k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 6.28k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.14k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 3.14k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 6.28k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.14k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 3.14k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 3.14k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.14k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 515| 34.6k| (parser->mark.index ++, \ | | 516| 34.6k| parser->mark.column = 0, \ | | 517| 34.6k| parser->mark.line ++, \ | | 518| 34.6k| parser->unread --, \ | | 519| 34.6k| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 34.6k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 34.6k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 30.4k, False: 4.16k] | | | | | | ------------------ | | | | | | 381| 34.6k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 574, False: 3.58k] | | | | | | ------------------ | | | | | | 382| 4.16k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 3.58k, False: 0] | | | | | | ------------------ | | | | | | 383| 3.58k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2871| 35.1k| } 2872| | 2873| 35.3k| end_mark = parser->mark; 2874| | 2875| | /* Set the indentation level if it was specified. */ 2876| | 2877| 35.3k| if (increment) { ------------------ | Branch (2877:9): [True: 2.22k, False: 33.1k] ------------------ 2878| 2.22k| indent = parser->indent >= 0 ? parser->indent+increment : increment; ------------------ | Branch (2878:18): [True: 1.97k, False: 247] ------------------ 2879| 2.22k| } 2880| | 2881| | /* Scan the leading line breaks and determine the indentation level if needed. */ 2882| | 2883| 35.3k| if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, ------------------ | Branch (2883:9): [True: 5, False: 35.3k] ------------------ 2884| 35.3k| start_mark, &end_mark)) goto error; 2885| | 2886| | /* Scan the block scalar content. */ 2887| | 2888| 35.3k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 35.3k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 35.3k, False: 0] | | ------------------ | | 494| 35.3k| ? 1 \ | | 495| 35.3k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2888:9): [True: 0, False: 35.3k] ------------------ 2889| | 2890| 257k| while ((int)parser->mark.column == indent && !(IS_Z(parser->buffer))) ------------------ | | 287| 222k|#define IS_Z(string) IS_Z_AT((string),0) | | ------------------ | | | | 285| 222k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | ------------------ | | | | | | 175| 222k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | ------------------ ------------------ | Branch (2890:12): [True: 222k, False: 35.1k] | Branch (2890:50): [True: 222k, False: 246] ------------------ 2891| 222k| { 2892| | /* 2893| | * We are at the beginning of a non-empty line. 2894| | */ 2895| | 2896| | /* Is it a trailing whitespace? */ 2897| | 2898| 222k| trailing_blank = IS_BLANK(parser->buffer); ------------------ | | 323| 222k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 222k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 222k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 444k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 7.79k, False: 214k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 214k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 214k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13, False: 214k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2899| | 2900| | /* Check if we need to fold the leading line break. */ 2901| | 2902| 222k| if (!literal && (*leading_break.start == '\n') ------------------ | Branch (2902:13): [True: 26.0k, False: 196k] | Branch (2902:25): [True: 21.2k, False: 4.79k] ------------------ 2903| 21.2k| && !leading_blank && !trailing_blank) ------------------ | Branch (2903:20): [True: 16.9k, False: 4.22k] | Branch (2903:38): [True: 13.4k, False: 3.50k] ------------------ 2904| 13.4k| { 2905| | /* Do we need to join the lines by space? */ 2906| | 2907| 13.4k| if (*trailing_breaks.start == '\0') { ------------------ | Branch (2907:17): [True: 2.62k, False: 10.8k] ------------------ 2908| 2.62k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 2.62k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 2.39k, False: 233] | | ------------------ | | 147| 2.62k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 233, False: 0] | | ------------------ | | 148| 233| &(string).pointer, &(string).end)) ? \ | | 149| 2.62k| 1 : \ | | 150| 2.62k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (2908:21): [True: 0, False: 2.62k] ------------------ 2909| 2.62k| *(string.pointer ++) = ' '; 2910| 2.62k| } 2911| | 2912| 13.4k| CLEAR(parser, leading_break); ------------------ | | 154| 13.4k| ((string).pointer = (string).start, \ | | 155| 13.4k| memset((string).start, 0, (string).end-(string).start)) ------------------ 2913| 13.4k| } 2914| 209k| else { 2915| 209k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 209k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 209k, False: 0] | | ------------------ | | 159| 209k| &(string_a).end, &(string_b).start, \ | | 160| 209k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 209k| ((string_b).pointer = (string_b).start, \ | | 162| 209k| 1) : \ | | 163| 209k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2915:17): [True: 0, False: 209k] ------------------ 2916| 209k| CLEAR(parser, leading_break); ------------------ | | 154| 209k| ((string).pointer = (string).start, \ | | 155| 209k| memset((string).start, 0, (string).end-(string).start)) ------------------ 2917| 209k| } 2918| | 2919| | /* Append the remaining line breaks. */ 2920| | 2921| 222k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 222k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 222k, False: 0] | | ------------------ | | 159| 222k| &(string_a).end, &(string_b).start, \ | | 160| 222k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 222k| ((string_b).pointer = (string_b).start, \ | | 162| 222k| 1) : \ | | 163| 222k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2921:13): [True: 0, False: 222k] ------------------ 2922| 222k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 222k| ((string).pointer = (string).start, \ | | 155| 222k| memset((string).start, 0, (string).end-(string).start)) ------------------ 2923| | 2924| | /* Is it a leading whitespace? */ 2925| | 2926| 222k| leading_blank = IS_BLANK(parser->buffer); ------------------ | | 323| 222k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 222k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 222k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 444k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 7.79k, False: 214k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 214k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 214k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13, False: 214k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2927| | 2928| | /* Consume the current line. */ 2929| | 2930| 6.36M| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 6.36M|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 6.36M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 12.7M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 12.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.17k, False: 6.36M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 6.36M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 12.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 219k, False: 6.14M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 6.36M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.96k, False: 6.13M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 6.14M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 3.96k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 212, False: 3.75k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 6.36M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 250k, False: 5.89M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 6.14M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 6.39M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 176k, False: 74.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 6.14M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 176k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 337, False: 176k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 12.7M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 250k, False: 5.89M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 6.14M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 6.39M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 176k, False: 74.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 6.14M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 176k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 270, False: 175k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 6.14M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 6.14M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 449, False: 6.14M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2931| 6.14M| if (!READ(parser, string)) goto error; ------------------ | | 526| 6.14M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 6.14M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 6.14M, False: 0] | | | | | Branch (146:7): [True: 6.13M, False: 8.40k] | | | | ------------------ | | | | 147| 6.14M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 8.40k, False: 0] | | | | ------------------ | | | | 148| 8.40k| &(string).pointer, &(string).end)) ? \ | | | | 149| 6.14M| 1 : \ | | | | 150| 6.14M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 6.14M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 6.14M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 5.72M, False: 411k] | | | | ------------------ | | | | 399| 6.14M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 6.14M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 4.09k, False: 406k] | | | | ------------------ | | | | 401| 411k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 4.09k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 411k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 406k, False: 198] | | | | ------------------ | | | | 404| 406k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 406k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 406k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 406k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 198, False: 0] | | | | ------------------ | | | | 408| 198| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 198| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 198| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 198| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 6.14M| parser->mark.index ++, \ | | 529| 6.14M| parser->mark.column ++, \ | | 530| 6.14M| parser->unread --, \ | | 531| 6.14M| 1) : 0) ------------------ | Branch (2931:17): [True: 0, False: 6.14M] ------------------ 2932| 6.14M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 6.14M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 6.13M, False: 829] | | ------------------ | | 494| 6.14M| ? 1 \ | | 495| 6.14M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2932:17): [True: 7, False: 6.14M] ------------------ 2933| 6.14M| } 2934| | 2935| | /* Consume the line break. */ 2936| | 2937| 222k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 222k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 221k, False: 598] | | ------------------ | | 494| 222k| ? 1 \ | | 495| 222k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2937:13): [True: 1, False: 222k] ------------------ 2938| | 2939| 222k| if (!READ_LINE(parser, leading_break)) goto error; ------------------ | | 538| 222k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 222k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 222k, False: 0] | | | | | Branch (146:7): [True: 222k, False: 0] | | | | ------------------ | | | | 147| 222k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 222k| 1 : \ | | | | 150| 222k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 222k| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 444k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 2.17k, False: 220k] | | | | ------------------ | | ------------------ | | 540| 222k| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 2.17k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 358, False: 1.81k] | | | | ------------------ | | ------------------ | | 541| 222k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 358| parser->buffer.pointer += 2, \ | | 543| 358| parser->mark.index += 2, \ | | 544| 358| parser->mark.column = 0, \ | | 545| 358| parser->mark.line ++, \ | | 546| 358| parser->unread -= 2) : \ | | 547| 222k| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 444k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.81k, False: 220k] | | | | ------------------ | | ------------------ | | 548| 222k| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 220k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 219k, False: 1.26k] | | | | ------------------ | | ------------------ | | 549| 222k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 220k| parser->buffer.pointer ++, \ | | 551| 220k| parser->mark.index ++, \ | | 552| 220k| parser->mark.column = 0, \ | | 553| 220k| parser->mark.line ++, \ | | 554| 220k| parser->unread --) : \ | | 555| 222k| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 2.53k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 212, False: 1.05k] | | | | ------------------ | | ------------------ | | 556| 1.26k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 212| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 212, False: 0] | | | | ------------------ | | ------------------ | | 557| 1.26k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 212| parser->buffer.pointer += 2, \ | | 559| 212| parser->mark.index ++, \ | | 560| 212| parser->mark.column = 0, \ | | 561| 212| parser->mark.line ++, \ | | 562| 212| parser->unread --) : \ | | 563| 1.26k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 2.11k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 607, False: 449] | | | | ------------------ | | ------------------ | | 564| 1.05k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 1.66k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 607, False: 0] | | | | ------------------ | | ------------------ | | 565| 1.05k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 1.21k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 337, False: 270] | | | | ------------------ | | ------------------ | | 566| 607| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 270| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 270, False: 0] | | | | ------------------ | | ------------------ | | 567| 1.05k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 607| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 607| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 607| parser->mark.index ++, \ | | 571| 607| parser->mark.column = 0, \ | | 572| 607| parser->mark.line ++, \ | | 573| 607| parser->unread --) : 0), \ | | 574| 222k| 1) : 0) ------------------ | Branch (2939:13): [True: 0, False: 222k] ------------------ 2940| | 2941| | /* Eat the following indentation spaces and line breaks. */ 2942| | 2943| 222k| if (!yaml_parser_scan_block_scalar_breaks(parser, ------------------ | Branch (2943:13): [True: 3, False: 222k] ------------------ 2944| 222k| &indent, &trailing_breaks, start_mark, &end_mark)) goto error; 2945| 222k| } 2946| | 2947| | /* Chomp the tail. */ 2948| | 2949| 35.3k| if (chomping != -1) { ------------------ | Branch (2949:9): [True: 32.1k, False: 3.23k] ------------------ 2950| 32.1k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 32.1k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 32.1k, False: 0] | | ------------------ | | 159| 32.1k| &(string_a).end, &(string_b).start, \ | | 160| 32.1k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 32.1k| ((string_b).pointer = (string_b).start, \ | | 162| 32.1k| 1) : \ | | 163| 32.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2950:13): [True: 0, False: 32.1k] ------------------ 2951| 32.1k| } 2952| 35.3k| if (chomping == 1) { ------------------ | Branch (2952:9): [True: 15.5k, False: 19.8k] ------------------ 2953| 15.5k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 15.5k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 15.5k, False: 0] | | ------------------ | | 159| 15.5k| &(string_a).end, &(string_b).start, \ | | 160| 15.5k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 15.5k| ((string_b).pointer = (string_b).start, \ | | 162| 15.5k| 1) : \ | | 163| 15.5k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2953:13): [True: 0, False: 15.5k] ------------------ 2954| 15.5k| } 2955| | 2956| | /* Create a token. */ 2957| | 2958| 35.3k| SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, ------------------ | | 526| 35.3k| (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 35.3k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 35.3k| (token).type = (token_type), \ | | | | 502| 35.3k| (token).start_mark = (token_start_mark), \ | | | | 503| 35.3k| (token).end_mark = (token_end_mark)) | | ------------------ | | 527| 35.3k| (token).data.scalar.value = (token_value), \ | | 528| 35.3k| (token).data.scalar.length = (token_length), \ | | 529| 70.7k| (token).data.scalar.style = (token_style)) | | ------------------ | | | Branch (529:35): [True: 22.2k, False: 13.1k] | | ------------------ ------------------ 2959| 35.3k| literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE, 2960| 35.3k| start_mark, end_mark); 2961| | 2962| 35.3k| STRING_DEL(parser, leading_break); ------------------ | | 142| 35.3k| (yaml_free((string).start), \ | | 143| 35.3k| (string).start = (string).pointer = (string).end = 0) ------------------ 2963| 35.3k| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 35.3k| (yaml_free((string).start), \ | | 143| 35.3k| (string).start = (string).pointer = (string).end = 0) ------------------ 2964| | 2965| 35.3k| return 1; 2966| | 2967| 89|error: 2968| 89| STRING_DEL(parser, string); ------------------ | | 142| 89| (yaml_free((string).start), \ | | 143| 89| (string).start = (string).pointer = (string).end = 0) ------------------ 2969| 89| STRING_DEL(parser, leading_break); ------------------ | | 142| 89| (yaml_free((string).start), \ | | 143| 89| (string).start = (string).pointer = (string).end = 0) ------------------ 2970| 89| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 89| (yaml_free((string).start), \ | | 143| 89| (string).start = (string).pointer = (string).end = 0) ------------------ 2971| | 2972| 89| return 0; 2973| 35.3k|} scanner.c:yaml_parser_scan_block_scalar_breaks: 2984| 257k|{ 2985| 257k| int max_indent = 0; 2986| | 2987| 257k| *end_mark = parser->mark; 2988| | 2989| | /* Eat the indentation spaces and line breaks. */ 2990| | 2991| 1.98M| while (1) ------------------ | Branch (2991:12): [True: 1.98M, Folded] ------------------ 2992| 1.98M| { 2993| | /* Eat the indentation spaces. */ 2994| | 2995| 1.98M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 1.98M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.98M, False: 84] | | ------------------ | | 494| 1.98M| ? 1 \ | | 495| 1.98M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2995:13): [True: 1, False: 1.98M] ------------------ 2996| | 2997| 4.24M| while ((!*indent || (int)parser->mark.column < *indent) ------------------ | Branch (2997:17): [True: 2.41M, False: 1.83M] | Branch (2997:29): [True: 1.61M, False: 219k] ------------------ 2998| 4.02M| && IS_SPACE(parser->buffer)) { ------------------ | | 306| 4.02M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 4.02M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 4.02M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.25M, False: 1.76M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2999| 2.25M| SKIP(parser); ------------------ | | 502| 2.25M| (parser->mark.index ++, \ | | 503| 2.25M| parser->mark.column ++, \ | | 504| 2.25M| parser->unread --, \ | | 505| 2.25M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.25M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.25M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.25M, False: 0] | | | | | | ------------------ | | | | | | 381| 2.25M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3000| 2.25M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 2.25M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.25M, False: 156] | | ------------------ | | 494| 2.25M| ? 1 \ | | 495| 2.25M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3000:17): [True: 2, False: 2.25M] ------------------ 3001| 2.25M| } 3002| | 3003| 1.98M| if ((int)parser->mark.column > max_indent) ------------------ | Branch (3003:13): [True: 224k, False: 1.76M] ------------------ 3004| 224k| max_indent = (int)parser->mark.column; 3005| | 3006| | /* Check for a tab character messing the indentation. */ 3007| | 3008| 1.98M| if ((!*indent || (int)parser->mark.column < *indent) ------------------ | Branch (3008:14): [True: 372k, False: 1.61M] | Branch (3008:26): [True: 1.39M, False: 219k] ------------------ 3009| 1.76M| && IS_TAB(parser->buffer)) { ------------------ | | 314| 1.76M|#define IS_TAB(string) IS_TAB_AT((string),0) | | ------------------ | | | | 312| 1.76M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | ------------------ | | | | | | 175| 1.76M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 4, False: 1.76M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3010| 4| return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 3011| 4| start_mark, "found a tab character where an indentation space is expected"); 3012| 4| } 3013| | 3014| | /* Have we found a non-empty line? */ 3015| | 3016| 1.98M| if (!IS_BREAK(parser->buffer)) break; ------------------ | | 341| 1.98M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 1.98M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 3.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.54M, False: 439k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 1.98M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 2.42M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 176k, False: 263k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 1.98M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 526k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.01k, False: 261k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 263k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 2.01k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 972, False: 1.04k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 1.98M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 524k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 16.7k, False: 245k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 262k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 278k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 15.5k, False: 1.19k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 262k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 15.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.26k, False: 13.2k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 1.98M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 519k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 14.4k, False: 245k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 259k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 274k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 13.2k, False: 1.19k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 259k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 13.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.05k, False: 11.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3017| | 3018| | /* Consume the line break. */ 3019| | 3020| 1.73M| if (!CACHE(parser, 2)) return 0; ------------------ | | 493| 1.73M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.72M, False: 271] | | ------------------ | | 494| 1.73M| ? 1 \ | | 495| 1.73M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3020:13): [True: 1, False: 1.73M] ------------------ 3021| 1.73M| if (!READ_LINE(parser, *breaks)) return 0; ------------------ | | 538| 1.73M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 1.73M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 1.73M, False: 0] | | | | | Branch (146:7): [True: 1.72M, False: 784] | | | | ------------------ | | | | 147| 1.73M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 784, False: 0] | | | | ------------------ | | | | 148| 784| &(string).pointer, &(string).end)) ? \ | | | | 149| 1.73M| 1 : \ | | | | 150| 1.73M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 1.73M| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.54M, False: 181k] | | | | ------------------ | | ------------------ | | 540| 1.73M| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 1.54M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 488k, False: 1.05M] | | | | ------------------ | | ------------------ | | 541| 1.73M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 488k| parser->buffer.pointer += 2, \ | | 543| 488k| parser->mark.index += 2, \ | | 544| 488k| parser->mark.column = 0, \ | | 545| 488k| parser->mark.line ++, \ | | 546| 488k| parser->unread -= 2) : \ | | 547| 1.73M| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.48M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.05M, False: 181k] | | | | ------------------ | | ------------------ | | 548| 1.24M| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 181k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 176k, False: 5.28k] | | | | ------------------ | | ------------------ | | 549| 1.24M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 1.23M| parser->buffer.pointer ++, \ | | 551| 1.23M| parser->mark.index ++, \ | | 552| 1.23M| parser->mark.column = 0, \ | | 553| 1.23M| parser->mark.line ++, \ | | 554| 1.23M| parser->unread --) : \ | | 555| 1.24M| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 10.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 972, False: 4.31k] | | | | ------------------ | | ------------------ | | 556| 5.28k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 972| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 972, False: 0] | | | | ------------------ | | ------------------ | | 557| 5.28k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 972| parser->buffer.pointer += 2, \ | | 559| 972| parser->mark.index ++, \ | | 560| 972| parser->mark.column = 0, \ | | 561| 972| parser->mark.line ++, \ | | 562| 972| parser->unread --) : \ | | 563| 5.28k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 8.62k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 4.31k, False: 0] | | | | ------------------ | | ------------------ | | 564| 4.31k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 8.62k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 4.31k, False: 0] | | | | ------------------ | | ------------------ | | 565| 4.31k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 8.62k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 2.26k, False: 2.05k] | | | | ------------------ | | ------------------ | | 566| 4.31k| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 2.05k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 2.05k, False: 0] | | | | ------------------ | | ------------------ | | 567| 4.31k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 4.31k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 4.31k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 4.31k| parser->mark.index ++, \ | | 571| 4.31k| parser->mark.column = 0, \ | | 572| 4.31k| parser->mark.line ++, \ | | 573| 4.31k| parser->unread --) : 0), \ | | 574| 1.73M| 1) : 0) ------------------ | Branch (3021:13): [True: 0, False: 1.73M] ------------------ 3022| 1.73M| *end_mark = parser->mark; 3023| 1.73M| } 3024| | 3025| | /* Determine the indentation level if needed. */ 3026| | 3027| 257k| if (!*indent) { ------------------ | Branch (3027:9): [True: 33.1k, False: 224k] ------------------ 3028| 33.1k| *indent = max_indent; 3029| 33.1k| if (*indent < parser->indent + 1) ------------------ | Branch (3029:13): [True: 26.0k, False: 7.14k] ------------------ 3030| 26.0k| *indent = parser->indent + 1; 3031| 33.1k| if (*indent < 1) ------------------ | Branch (3031:13): [True: 652, False: 32.5k] ------------------ 3032| 652| *indent = 1; 3033| 33.1k| } 3034| | 3035| 257k| return 1; 3036| 257k|} scanner.c:yaml_parser_fetch_flow_scalar: 1877| 18.0k|{ 1878| 18.0k| yaml_token_t token; 1879| | 1880| | /* A plain scalar could be a simple key. */ 1881| | 1882| 18.0k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1882:9): [True: 0, False: 18.0k] ------------------ 1883| 0| return 0; 1884| | 1885| | /* A simple key cannot follow a flow scalar. */ 1886| | 1887| 18.0k| parser->simple_key_allowed = 0; 1888| | 1889| | /* Create the SCALAR token and append it to the queue. */ 1890| | 1891| 18.0k| if (!yaml_parser_scan_flow_scalar(parser, &token, single)) ------------------ | Branch (1891:9): [True: 978, False: 17.0k] ------------------ 1892| 978| return 0; 1893| | 1894| 17.0k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 17.0k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 15.9k, False: 1.14k] | | ------------------ | | 473| 17.0k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.14k, False: 0] | | ------------------ | | 474| 1.14k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 17.0k| (*((queue).tail++) = value, \ | | 476| 17.0k| 1) : \ | | 477| 17.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1894:9): [True: 0, False: 17.0k] ------------------ 1895| 0| yaml_token_delete(&token); 1896| 0| return 0; 1897| 0| } 1898| | 1899| 17.0k| return 1; 1900| 17.0k|} scanner.c:yaml_parser_scan_flow_scalar: 3045| 18.0k|{ 3046| 18.0k| yaml_mark_t start_mark; 3047| 18.0k| yaml_mark_t end_mark; 3048| 18.0k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 18.0k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3049| 18.0k| yaml_string_t leading_break = NULL_STRING; ------------------ | | 123| 18.0k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3050| 18.0k| yaml_string_t trailing_breaks = NULL_STRING; ------------------ | | 123| 18.0k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3051| 18.0k| yaml_string_t whitespaces = NULL_STRING; ------------------ | | 123| 18.0k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3052| 18.0k| int leading_blanks; 3053| | 3054| 18.0k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 18.0k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 18.0k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 18.0k, False: 0] | | ------------------ | | 134| 18.0k| ((string).pointer = (string).start, \ | | 135| 18.0k| (string).end = (string).start+(size), \ | | 136| 18.0k| memset((string).start, 0, (size)), \ | | 137| 18.0k| 1) : \ | | 138| 18.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3054:9): [True: 0, False: 18.0k] ------------------ 3055| 18.0k| if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 18.0k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 18.0k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 18.0k, False: 0] | | ------------------ | | 134| 18.0k| ((string).pointer = (string).start, \ | | 135| 18.0k| (string).end = (string).start+(size), \ | | 136| 18.0k| memset((string).start, 0, (size)), \ | | 137| 18.0k| 1) : \ | | 138| 18.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3055:9): [True: 0, False: 18.0k] ------------------ 3056| 18.0k| if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 18.0k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 18.0k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 18.0k, False: 0] | | ------------------ | | 134| 18.0k| ((string).pointer = (string).start, \ | | 135| 18.0k| (string).end = (string).start+(size), \ | | 136| 18.0k| memset((string).start, 0, (size)), \ | | 137| 18.0k| 1) : \ | | 138| 18.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3056:9): [True: 0, False: 18.0k] ------------------ 3057| 18.0k| if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 18.0k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 18.0k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 18.0k, False: 0] | | ------------------ | | 134| 18.0k| ((string).pointer = (string).start, \ | | 135| 18.0k| (string).end = (string).start+(size), \ | | 136| 18.0k| memset((string).start, 0, (size)), \ | | 137| 18.0k| 1) : \ | | 138| 18.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3057:9): [True: 0, False: 18.0k] ------------------ 3058| | 3059| | /* Eat the left quote. */ 3060| | 3061| 18.0k| start_mark = parser->mark; 3062| | 3063| 18.0k| SKIP(parser); ------------------ | | 502| 18.0k| (parser->mark.index ++, \ | | 503| 18.0k| parser->mark.column ++, \ | | 504| 18.0k| parser->unread --, \ | | 505| 18.0k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 18.0k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 18.0k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 18.0k, False: 0] | | | | | | ------------------ | | | | | | 381| 18.0k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3064| | 3065| | /* Consume the content of the quoted scalar. */ 3066| | 3067| 986k| while (1) ------------------ | Branch (3067:12): [True: 986k, Folded] ------------------ 3068| 986k| { 3069| | /* Check that there are no document indicators at the beginning of the line. */ 3070| | 3071| 986k| if (!CACHE(parser, 4)) goto error; ------------------ | | 493| 986k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 984k, False: 1.85k] | | ------------------ | | 494| 986k| ? 1 \ | | 495| 986k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3071:13): [True: 3, False: 986k] ------------------ 3072| | 3073| 986k| if (parser->mark.column == 0 && ------------------ | Branch (3073:13): [True: 309k, False: 677k] ------------------ 3074| 309k| ((CHECK_AT(parser->buffer, '-', 0) && ------------------ | | 175| 618k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 31.7k, False: 277k] | | ------------------ ------------------ 3075| 31.7k| CHECK_AT(parser->buffer, '-', 1) && ------------------ | | 175| 340k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 858, False: 30.8k] | | ------------------ ------------------ 3076| 858| CHECK_AT(parser->buffer, '-', 2)) || ------------------ | | 175| 858| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 570, False: 288] | | ------------------ ------------------ 3077| 308k| (CHECK_AT(parser->buffer, '.', 0) && ------------------ | | 175| 617k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1.17k, False: 307k] | | ------------------ ------------------ 3078| 1.17k| CHECK_AT(parser->buffer, '.', 1) && ------------------ | | 175| 309k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 753, False: 419] | | ------------------ ------------------ 3079| 753| CHECK_AT(parser->buffer, '.', 2))) && ------------------ | | 175| 753| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 419, False: 334] | | ------------------ ------------------ 3080| 989| IS_BLANKZ_AT(parser->buffer, 3)) ------------------ | | 371| 989| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 1.97k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 989|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.97k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 988] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 988|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 988| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 987] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 987| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 1.97k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 1.97k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3, False: 984] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 987| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.97k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3, False: 981] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 987| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.96k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 204, False: 777] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 981| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 204| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 4, False: 200] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 987| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.95k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 411, False: 566] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 977| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.38k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 215, False: 196] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 977| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 215| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 214] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 1.97k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.95k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 410, False: 566] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 976| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.38k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 214, False: 196] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 976| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 214| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 213] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 975|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 975| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 11, False: 964] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3081| 25| { 3082| 25| yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", 3083| 25| start_mark, "found unexpected document indicator"); 3084| 25| goto error; 3085| 25| } 3086| | 3087| | /* Check for EOF. */ 3088| | 3089| 986k| if (IS_Z(parser->buffer)) { ------------------ | | 287| 986k|#define IS_Z(string) IS_Z_AT((string),0) | | ------------------ | | | | 285| 986k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | ------------------ | | | | | | 175| 986k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 826, False: 985k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3090| 826| yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", 3091| 826| start_mark, "found unexpected end of stream"); 3092| 826| goto error; 3093| 826| } 3094| | 3095| | /* Consume non-blank characters. */ 3096| | 3097| 985k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 985k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 985k, False: 0] | | ------------------ | | 494| 985k| ? 1 \ | | 495| 985k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3097:13): [True: 0, False: 985k] ------------------ 3098| | 3099| 985k| leading_blanks = 0; 3100| | 3101| 8.32M| while (!IS_BLANKZ(parser->buffer)) ------------------ | | 373| 8.32M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 8.32M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 16.6M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 8.32M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 16.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 509k, False: 7.81M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 7.81M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 7.81M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 107k, False: 7.70M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 7.70M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 15.4M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 15.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 68.4k, False: 7.63M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 7.70M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 15.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 62.8k, False: 7.57M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 7.70M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 15.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 9.72k, False: 7.56M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 7.57M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 9.72k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 255, False: 9.46k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 7.70M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 15.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 214k, False: 7.36M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 7.57M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.79M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 9.55k, False: 205k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 7.57M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 9.55k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 325, False: 9.22k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 15.4M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 15.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 214k, False: 7.36M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 7.57M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.79M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 9.22k, False: 205k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 7.57M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 9.22k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 646, False: 8.58k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 7.57M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 7.57M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 500, False: 7.57M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3102| 7.57M| { 3103| | /* Check for an escaped single quote. */ 3104| | 3105| 7.57M| if (single && CHECK_AT(parser->buffer, '\'', 0) ------------------ | | 175| 8.72M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 12.4k, False: 1.13M] | | ------------------ ------------------ | Branch (3105:17): [True: 1.14M, False: 6.42M] ------------------ 3106| 12.4k| && CHECK_AT(parser->buffer, '\'', 1)) ------------------ | | 175| 12.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 3.91k, False: 8.53k] | | ------------------ ------------------ 3107| 3.91k| { 3108| 3.91k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 3.91k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 3.70k, False: 209] | | ------------------ | | 147| 3.91k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 209, False: 0] | | ------------------ | | 148| 209| &(string).pointer, &(string).end)) ? \ | | 149| 3.91k| 1 : \ | | 150| 3.91k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3108:21): [True: 0, False: 3.91k] ------------------ 3109| 3.91k| *(string.pointer++) = '\''; 3110| 3.91k| SKIP(parser); ------------------ | | 502| 3.91k| (parser->mark.index ++, \ | | 503| 3.91k| parser->mark.column ++, \ | | 504| 3.91k| parser->unread --, \ | | 505| 3.91k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 3.91k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 3.91k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 3.91k, False: 0] | | | | | | ------------------ | | | | | | 381| 3.91k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3111| 3.91k| SKIP(parser); ------------------ | | 502| 3.91k| (parser->mark.index ++, \ | | 503| 3.91k| parser->mark.column ++, \ | | 504| 3.91k| parser->unread --, \ | | 505| 3.91k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 3.91k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 3.91k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 3.91k, False: 0] | | | | | | ------------------ | | | | | | 381| 3.91k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3112| 3.91k| } 3113| | 3114| | /* Check for the right quote. */ 3115| | 3116| 7.57M| else if (CHECK(parser->buffer, single ? '\'' : '"')) ------------------ | | 181| 7.57M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 15.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:48): [True: 1.14M, False: 6.42M] | | | | ------------------ | | ------------------ | | | Branch (181:29): [True: 17.0k, False: 7.55M] | | ------------------ ------------------ 3117| 17.0k| { 3118| 17.0k| break; 3119| 17.0k| } 3120| | 3121| | /* Check for an escaped line break. */ 3122| | 3123| 7.55M| else if (!single && CHECK(parser->buffer, '\\') ------------------ | | 181| 13.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 6.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.74M, False: 3.66M] | | ------------------ ------------------ | Branch (3123:22): [True: 6.41M, False: 1.13M] ------------------ 3124| 2.74M| && IS_BREAK_AT(parser->buffer, 1)) ------------------ | | 330| 2.74M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | ------------------ | | | | 175| 5.49M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 213k, False: 2.53M] | | | | ------------------ | | ------------------ | | 331| 2.74M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | ------------------ | | | | 175| 5.28M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 3.24k, False: 2.53M] | | | | ------------------ | | ------------------ | | 332| 2.74M| || (CHECK_AT((string),'\xC2',(offset)) \ | | ------------------ | | | | 175| 5.06M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 195, False: 2.53M] | | | | ------------------ | | ------------------ | | 333| 2.53M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | ------------------ | | | | 175| 195| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 194, False: 1] | | | | ------------------ | | ------------------ | | 334| 2.74M| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 5.06M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 449, False: 2.53M] | | | | ------------------ | | ------------------ | | 335| 2.53M| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 2.53M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 448, False: 1] | | | | ------------------ | | ------------------ | | 336| 2.53M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | ------------------ | | | | 175| 448| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 243, False: 205] | | | | ------------------ | | ------------------ | | 337| 2.74M| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 5.06M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 206, False: 2.53M] | | | | ------------------ | | ------------------ | | 338| 2.53M| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 2.53M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 205, False: 1] | | | | ------------------ | | ------------------ | | 339| 2.53M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | ------------------ | | | | 175| 205| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 204, False: 1] | | | | ------------------ | | ------------------ ------------------ 3125| 217k| { 3126| 217k| if (!CACHE(parser, 3)) goto error; ------------------ | | 493| 217k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 217k, False: 36] | | ------------------ | | 494| 217k| ? 1 \ | | 495| 217k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3126:21): [True: 1, False: 217k] ------------------ 3127| 217k| SKIP(parser); ------------------ | | 502| 217k| (parser->mark.index ++, \ | | 503| 217k| parser->mark.column ++, \ | | 504| 217k| parser->unread --, \ | | 505| 217k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 217k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 217k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 217k, False: 0] | | | | | | ------------------ | | | | | | 381| 217k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3128| 217k| SKIP_LINE(parser); ------------------ | | 508| 217k| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 217k|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 217k| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 435k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 213k, False: 3.88k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 213k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 196k, False: 17.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 217k| (parser->mark.index += 2, \ | | 510| 196k| parser->mark.column = 0, \ | | 511| 196k| parser->mark.line ++, \ | | 512| 196k| parser->unread -= 2, \ | | 513| 196k| parser->buffer.pointer += 2) : \ | | 514| 217k| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 20.9k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 41.9k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 41.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 17.0k, False: 3.88k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 20.9k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 24.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.24k, False: 641] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 20.9k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.28k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 194, False: 447] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 641| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 194| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 194, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 20.9k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 894| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 447, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 447| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 894| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 447, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 447| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 447| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 243, False: 204] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 41.9k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 408| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 204, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 204| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 408| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 204, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 204| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 204| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 204, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 515| 20.9k| (parser->mark.index ++, \ | | 516| 20.9k| parser->mark.column = 0, \ | | 517| 20.9k| parser->mark.line ++, \ | | 518| 20.9k| parser->unread --, \ | | 519| 20.9k| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 20.9k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 20.9k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 20.3k, False: 641] | | | | | | ------------------ | | | | | | 381| 20.9k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 194, False: 447] | | | | | | ------------------ | | | | | | 382| 641| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 447, False: 0] | | | | | | ------------------ | | | | | | 383| 447| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3129| 217k| leading_blanks = 1; 3130| 217k| break; 3131| 217k| } 3132| | 3133| | /* Check for an escape sequence. */ 3134| | 3135| 7.33M| else if (!single && CHECK(parser->buffer, '\\')) ------------------ | | 181| 6.20M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 6.20M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.53M, False: 3.66M] | | ------------------ ------------------ | Branch (3135:22): [True: 6.20M, False: 1.13M] ------------------ 3136| 2.53M| { 3137| 2.53M| size_t code_length = 0; 3138| | 3139| 2.53M| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 2.53M| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 2.53M, False: 885] | | ------------------ | | 147| 2.53M| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 885, False: 0] | | ------------------ | | 148| 885| &(string).pointer, &(string).end)) ? \ | | 149| 2.53M| 1 : \ | | 150| 2.53M| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3139:21): [True: 0, False: 2.53M] ------------------ 3140| | 3141| | /* Check the escape character. */ 3142| | 3143| 2.53M| switch (parser->buffer.pointer[1]) 3144| 2.53M| { 3145| 9.79k| case '0': ------------------ | Branch (3145:21): [True: 9.79k, False: 2.52M] ------------------ 3146| 9.79k| *(string.pointer++) = '\0'; 3147| 9.79k| break; 3148| | 3149| 788k| case 'a': ------------------ | Branch (3149:21): [True: 788k, False: 1.74M] ------------------ 3150| 788k| *(string.pointer++) = '\x07'; 3151| 788k| break; 3152| | 3153| 1.89k| case 'b': ------------------ | Branch (3153:21): [True: 1.89k, False: 2.52M] ------------------ 3154| 1.89k| *(string.pointer++) = '\x08'; 3155| 1.89k| break; 3156| | 3157| 4.92k| case 't': ------------------ | Branch (3157:21): [True: 4.92k, False: 2.52M] ------------------ 3158| 25.7k| case '\t': ------------------ | Branch (3158:21): [True: 20.8k, False: 2.51M] ------------------ 3159| 25.7k| *(string.pointer++) = '\x09'; 3160| 25.7k| break; 3161| | 3162| 574| case 'n': ------------------ | Branch (3162:21): [True: 574, False: 2.53M] ------------------ 3163| 574| *(string.pointer++) = '\x0A'; 3164| 574| break; 3165| | 3166| 36.7k| case 'v': ------------------ | Branch (3166:21): [True: 36.7k, False: 2.49M] ------------------ 3167| 36.7k| *(string.pointer++) = '\x0B'; 3168| 36.7k| break; 3169| | 3170| 107k| case 'f': ------------------ | Branch (3170:21): [True: 107k, False: 2.42M] ------------------ 3171| 107k| *(string.pointer++) = '\x0C'; 3172| 107k| break; 3173| | 3174| 614k| case 'r': ------------------ | Branch (3174:21): [True: 614k, False: 1.91M] ------------------ 3175| 614k| *(string.pointer++) = '\x0D'; 3176| 614k| break; 3177| | 3178| 409k| case 'e': ------------------ | Branch (3178:21): [True: 409k, False: 2.12M] ------------------ 3179| 409k| *(string.pointer++) = '\x1B'; 3180| 409k| break; 3181| | 3182| 8.87k| case ' ': ------------------ | Branch (3182:21): [True: 8.87k, False: 2.52M] ------------------ 3183| 8.87k| *(string.pointer++) = '\x20'; 3184| 8.87k| break; 3185| | 3186| 1.70k| case '"': ------------------ | Branch (3186:21): [True: 1.70k, False: 2.52M] ------------------ 3187| 1.70k| *(string.pointer++) = '"'; 3188| 1.70k| break; 3189| | 3190| 260| case '/': ------------------ | Branch (3190:21): [True: 260, False: 2.53M] ------------------ 3191| 260| *(string.pointer++) = '/'; 3192| 260| break; 3193| | 3194| 246k| case '\\': ------------------ | Branch (3194:21): [True: 246k, False: 2.28M] ------------------ 3195| 246k| *(string.pointer++) = '\\'; 3196| 246k| break; 3197| | 3198| 178k| case 'N': /* NEL (#x85) */ ------------------ | Branch (3198:21): [True: 178k, False: 2.35M] ------------------ 3199| 178k| *(string.pointer++) = '\xC2'; 3200| 178k| *(string.pointer++) = '\x85'; 3201| 178k| break; 3202| | 3203| 725| case '_': /* #xA0 */ ------------------ | Branch (3203:21): [True: 725, False: 2.53M] ------------------ 3204| 725| *(string.pointer++) = '\xC2'; 3205| 725| *(string.pointer++) = '\xA0'; 3206| 725| break; 3207| | 3208| 5.02k| case 'L': /* LS (#x2028) */ ------------------ | Branch (3208:21): [True: 5.02k, False: 2.52M] ------------------ 3209| 5.02k| *(string.pointer++) = '\xE2'; 3210| 5.02k| *(string.pointer++) = '\x80'; 3211| 5.02k| *(string.pointer++) = '\xA8'; 3212| 5.02k| break; 3213| | 3214| 1.96k| case 'P': /* PS (#x2029) */ ------------------ | Branch (3214:21): [True: 1.96k, False: 2.52M] ------------------ 3215| 1.96k| *(string.pointer++) = '\xE2'; 3216| 1.96k| *(string.pointer++) = '\x80'; 3217| 1.96k| *(string.pointer++) = '\xA9'; 3218| 1.96k| break; 3219| | 3220| 674| case 'x': ------------------ | Branch (3220:21): [True: 674, False: 2.53M] ------------------ 3221| 674| code_length = 2; 3222| 674| break; 3223| | 3224| 675| case 'u': ------------------ | Branch (3224:21): [True: 675, False: 2.53M] ------------------ 3225| 675| code_length = 4; 3226| 675| break; 3227| | 3228| 91.0k| case 'U': ------------------ | Branch (3228:21): [True: 91.0k, False: 2.44M] ------------------ 3229| 91.0k| code_length = 8; 3230| 91.0k| break; 3231| | 3232| 28| default: ------------------ | Branch (3232:21): [True: 28, False: 2.53M] ------------------ 3233| 28| yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 3234| 28| start_mark, "found unknown escape character"); 3235| 28| goto error; 3236| 2.53M| } 3237| | 3238| 2.53M| SKIP(parser); ------------------ | | 502| 2.53M| (parser->mark.index ++, \ | | 503| 2.53M| parser->mark.column ++, \ | | 504| 2.53M| parser->unread --, \ | | 505| 2.53M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.53M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.53M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.53M, False: 0] | | | | | | ------------------ | | | | | | 381| 2.53M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3239| 2.53M| SKIP(parser); ------------------ | | 502| 2.53M| (parser->mark.index ++, \ | | 503| 2.53M| parser->mark.column ++, \ | | 504| 2.53M| parser->unread --, \ | | 505| 2.53M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.53M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.53M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.53M, False: 0] | | | | | | ------------------ | | | | | | 381| 2.53M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3240| | 3241| | /* Consume an arbitrary escape code. */ 3242| | 3243| 2.53M| if (code_length) ------------------ | Branch (3243:21): [True: 92.4k, False: 2.43M] ------------------ 3244| 92.4k| { 3245| 92.4k| unsigned int value = 0; 3246| 92.4k| size_t k; 3247| | 3248| | /* Scan the character value. */ 3249| | 3250| 92.4k| if (!CACHE(parser, code_length)) goto error; ------------------ | | 493| 92.4k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 92.3k, False: 108] | | ------------------ | | 494| 92.4k| ? 1 \ | | 495| 92.4k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3250:25): [True: 1, False: 92.4k] ------------------ 3251| | 3252| 824k| for (k = 0; k < code_length; k ++) { ------------------ | Branch (3252:33): [True: 732k, False: 92.3k] ------------------ 3253| 732k| if (!IS_HEX_AT(parser->buffer, k)) { ------------------ | | 224| 732k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | ------------------ | | | Branch (224:8): [True: 732k, False: 41] | | ------------------ | | 225| 732k| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | ------------------ | | | Branch (225:8): [True: 586k, False: 146k] | | ------------------ | | 226| 732k| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (226:8): [True: 146k, False: 43] | | ------------------ | | 227| 146k| (string).pointer[offset] <= (yaml_char_t) 'F') || \ | | ------------------ | | | Branch (227:8): [True: 1.75k, False: 144k] | | ------------------ | | 228| 732k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (228:8): [True: 144k, False: 47] | | ------------------ | | 229| 144k| (string).pointer[offset] <= (yaml_char_t) 'f')) | | ------------------ | | | Branch (229:8): [True: 144k, False: 3] | | ------------------ ------------------ 3254| 50| yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 3255| 50| start_mark, "did not find expected hexdecimal number"); 3256| 50| goto error; 3257| 50| } 3258| 732k| value = (value << 4) + AS_HEX_AT(parser->buffer, k); ------------------ | | 238| 732k| (((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (238:9): [True: 146k, False: 586k] | | ------------------ | | 239| 732k| (string).pointer[offset] <= (yaml_char_t) 'F') ? \ | | ------------------ | | | Branch (239:9): [True: 1.75k, False: 144k] | | ------------------ | | 240| 732k| ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ | | 241| 732k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (241:9): [True: 144k, False: 586k] | | ------------------ | | 242| 730k| (string).pointer[offset] <= (yaml_char_t) 'f') ? \ | | ------------------ | | | Branch (242:9): [True: 144k, False: 0] | | ------------------ | | 243| 730k| ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ | | 244| 730k| ((string).pointer[offset] - (yaml_char_t) '0')) ------------------ 3259| 732k| } 3260| | 3261| | /* Check the value and write the character. */ 3262| | 3263| 92.3k| if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { ------------------ | Branch (3263:26): [True: 1.27k, False: 91.1k] | Branch (3263:45): [True: 5, False: 1.26k] | Branch (3263:65): [True: 33, False: 92.3k] ------------------ 3264| 38| yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 3265| 38| start_mark, "found invalid Unicode character escape code"); 3266| 38| goto error; 3267| 38| } 3268| | 3269| 92.3k| if (value <= 0x7F) { ------------------ | Branch (3269:25): [True: 8.69k, False: 83.6k] ------------------ 3270| 8.69k| *(string.pointer++) = value; 3271| 8.69k| } 3272| 83.6k| else if (value <= 0x7FF) { ------------------ | Branch (3272:30): [True: 69.7k, False: 13.8k] ------------------ 3273| 69.7k| *(string.pointer++) = 0xC0 + (value >> 6); 3274| 69.7k| *(string.pointer++) = 0x80 + (value & 0x3F); 3275| 69.7k| } 3276| 13.8k| else if (value <= 0xFFFF) { ------------------ | Branch (3276:30): [True: 13.2k, False: 610] ------------------ 3277| 13.2k| *(string.pointer++) = 0xE0 + (value >> 12); 3278| 13.2k| *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); 3279| 13.2k| *(string.pointer++) = 0x80 + (value & 0x3F); 3280| 13.2k| } 3281| 610| else { 3282| 610| *(string.pointer++) = 0xF0 + (value >> 18); 3283| 610| *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F); 3284| 610| *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); 3285| 610| *(string.pointer++) = 0x80 + (value & 0x3F); 3286| 610| } 3287| | 3288| | /* Advance the pointer. */ 3289| | 3290| 824k| for (k = 0; k < code_length; k ++) { ------------------ | Branch (3290:33): [True: 732k, False: 92.3k] ------------------ 3291| 732k| SKIP(parser); ------------------ | | 502| 732k| (parser->mark.index ++, \ | | 503| 732k| parser->mark.column ++, \ | | 504| 732k| parser->unread --, \ | | 505| 732k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 732k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 732k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 732k, False: 0] | | | | | | ------------------ | | | | | | 381| 732k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3292| 732k| } 3293| 92.3k| } 3294| 2.53M| } 3295| | 3296| 4.80M| else 3297| 4.80M| { 3298| | /* It is a non-escaped non-blank character. */ 3299| | 3300| 4.80M| if (!READ(parser, string)) goto error; ------------------ | | 526| 4.80M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 4.80M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 4.80M, False: 0] | | | | | Branch (146:7): [True: 4.79M, False: 6.25k] | | | | ------------------ | | | | 147| 4.80M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 6.25k, False: 0] | | | | ------------------ | | | | 148| 6.25k| &(string).pointer, &(string).end)) ? \ | | | | 149| 4.80M| 1 : \ | | | | 150| 4.80M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 4.80M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 4.80M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 4.38M, False: 423k] | | | | ------------------ | | | | 399| 4.80M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 4.80M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 9.66k, False: 414k] | | | | ------------------ | | | | 401| 423k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 9.66k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 423k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 413k, False: 280] | | | | ------------------ | | | | 404| 414k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 413k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 413k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 414k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 280, False: 0] | | | | ------------------ | | | | 408| 280| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 280| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 280| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 280| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 4.80M| parser->mark.index ++, \ | | 529| 4.80M| parser->mark.column ++, \ | | 530| 4.80M| parser->unread --, \ | | 531| 4.80M| 1) : 0) ------------------ | Branch (3300:21): [True: 0, False: 4.80M] ------------------ 3301| 4.80M| } 3302| | 3303| 7.34M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 7.34M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 7.33M, False: 1.26k] | | ------------------ | | 494| 7.34M| ? 1 \ | | 495| 7.34M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3303:17): [True: 2, False: 7.34M] ------------------ 3304| 7.34M| } 3305| | 3306| | /* Check if we are at the end of the scalar. */ 3307| | 3308| | /* Fix for crash uninitialized value crash 3309| | * Credit for the bug and input is to OSS Fuzz 3310| | * Credit for the fix to Alex Gaynor 3311| | */ 3312| 985k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 985k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 985k, False: 44] | | ------------------ | | 494| 985k| ? 1 \ | | 495| 985k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3312:13): [True: 1, False: 985k] ------------------ 3313| 985k| if (CHECK(parser->buffer, single ? '\'' : '"')) ------------------ | | 181| 985k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:48): [True: 150k, False: 835k] | | | | ------------------ | | ------------------ | | | Branch (181:29): [True: 17.0k, False: 968k] | | ------------------ ------------------ 3314| 17.0k| break; 3315| | 3316| | /* Consume blank characters. */ 3317| | 3318| 968k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 968k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 968k, False: 0] | | ------------------ | | 494| 968k| ? 1 \ | | 495| 968k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3318:13): [True: 0, False: 968k] ------------------ 3319| | 3320| 6.24M| while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 323| 6.24M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 12.4M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 6.24M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 12.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.19M, False: 3.04M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 3.04M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 3.04M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 578k, False: 2.47M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 341| 2.47M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 2.47M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 4.94M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 973k, False: 1.49M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 2.47M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 3.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 527k, False: 970k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 2.47M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 1.94M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 759, False: 969k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 970k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 759| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 511, False: 248] | | | | | | ------------------ | | | | ------------------ | | | | 334| 2.47M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 1.94M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.08k, False: 968k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 970k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 972k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.88k, False: 199] | | | | | | ------------------ | | | | ------------------ | | | | 336| 970k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 1.88k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 880, False: 1.00k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 2.47M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 1.93M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.20k, False: 968k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 969k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 970k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.00k, False: 199] | | | | | | ------------------ | | | | ------------------ | | | | 339| 969k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 1.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 895, False: 113] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3321| 5.27M| { 3322| 5.27M| if (IS_BLANK(parser->buffer)) ------------------ | | 323| 5.27M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 5.27M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 5.27M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 10.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.19M, False: 2.08M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 2.08M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.08M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 578k, False: 1.50M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3323| 3.77M| { 3324| | /* Consume a space or a tab character. */ 3325| | 3326| 3.77M| if (!leading_blanks) { ------------------ | Branch (3326:21): [True: 3.52M, False: 252k] ------------------ 3327| 3.52M| if (!READ(parser, whitespaces)) goto error; ------------------ | | 526| 3.52M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 3.52M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 3.52M, False: 0] | | | | | Branch (146:7): [True: 3.52M, False: 1.00k] | | | | ------------------ | | | | 147| 3.52M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 1.00k, False: 0] | | | | ------------------ | | | | 148| 1.00k| &(string).pointer, &(string).end)) ? \ | | | | 149| 3.52M| 1 : \ | | | | 150| 3.52M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 3.52M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 3.52M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 3.52M, False: 0] | | | | ------------------ | | | | 399| 3.52M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 3.52M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 3.52M| parser->mark.index ++, \ | | 529| 3.52M| parser->mark.column ++, \ | | 530| 3.52M| parser->unread --, \ | | 531| 3.52M| 1) : 0) ------------------ | Branch (3327:25): [True: 0, False: 3.52M] ------------------ 3328| 3.52M| } 3329| 252k| else { 3330| 252k| SKIP(parser); ------------------ | | 502| 252k| (parser->mark.index ++, \ | | 503| 252k| parser->mark.column ++, \ | | 504| 252k| parser->unread --, \ | | 505| 252k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 252k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 252k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 252k, False: 0] | | | | | | ------------------ | | | | | | 381| 252k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3331| 252k| } 3332| 3.77M| } 3333| 1.50M| else 3334| 1.50M| { 3335| 1.50M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 1.50M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.50M, False: 150] | | ------------------ | | 494| 1.50M| ? 1 \ | | 495| 1.50M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3335:21): [True: 1, False: 1.50M] ------------------ 3336| | 3337| | /* Check if it is a first line break. */ 3338| | 3339| 1.50M| if (!leading_blanks) ------------------ | Branch (3339:21): [True: 136k, False: 1.36M] ------------------ 3340| 136k| { 3341| 136k| CLEAR(parser, whitespaces); ------------------ | | 154| 136k| ((string).pointer = (string).start, \ | | 155| 136k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3342| 136k| if (!READ_LINE(parser, leading_break)) goto error; ------------------ | | 538| 136k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 136k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 136k, False: 0] | | | | | Branch (146:7): [True: 136k, False: 0] | | | | ------------------ | | | | 147| 136k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 136k| 1 : \ | | | | 150| 136k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 136k| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 272k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 69.0k, False: 67.0k] | | | | ------------------ | | ------------------ | | 540| 136k| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 69.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 11.3k, False: 57.7k] | | | | ------------------ | | ------------------ | | 541| 136k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 11.3k| parser->buffer.pointer += 2, \ | | 543| 11.3k| parser->mark.index += 2, \ | | 544| 11.3k| parser->mark.column = 0, \ | | 545| 11.3k| parser->mark.line ++, \ | | 546| 11.3k| parser->unread -= 2) : \ | | 547| 136k| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 249k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 57.7k, False: 67.0k] | | | | ------------------ | | ------------------ | | 548| 124k| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 67.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 65.8k, False: 1.22k] | | | | ------------------ | | ------------------ | | 549| 124k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 123k| parser->buffer.pointer ++, \ | | 551| 123k| parser->mark.index ++, \ | | 552| 123k| parser->mark.column = 0, \ | | 553| 123k| parser->mark.line ++, \ | | 554| 123k| parser->unread --) : \ | | 555| 124k| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 2.45k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 256, False: 971] | | | | ------------------ | | ------------------ | | 556| 1.22k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 256| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 256, False: 0] | | | | ------------------ | | ------------------ | | 557| 1.22k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 256| parser->buffer.pointer += 2, \ | | 559| 256| parser->mark.index ++, \ | | 560| 256| parser->mark.column = 0, \ | | 561| 256| parser->mark.line ++, \ | | 562| 256| parser->unread --) : \ | | 563| 1.22k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 1.94k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 971, False: 0] | | | | ------------------ | | ------------------ | | 564| 971| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 1.94k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 971, False: 0] | | | | ------------------ | | ------------------ | | 565| 971| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 1.94k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 325, False: 646] | | | | ------------------ | | ------------------ | | 566| 971| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 646| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 646, False: 0] | | | | ------------------ | | ------------------ | | 567| 971| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 971| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 971| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 971| parser->mark.index ++, \ | | 571| 971| parser->mark.column = 0, \ | | 572| 971| parser->mark.line ++, \ | | 573| 971| parser->unread --) : 0), \ | | 574| 136k| 1) : 0) ------------------ | Branch (3342:25): [True: 0, False: 136k] ------------------ 3343| 136k| leading_blanks = 1; 3344| 136k| } 3345| 1.36M| else 3346| 1.36M| { 3347| 1.36M| if (!READ_LINE(parser, trailing_breaks)) goto error; ------------------ | | 538| 1.36M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 1.36M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 1.36M, False: 0] | | | | | Branch (146:7): [True: 1.36M, False: 684] | | | | ------------------ | | | | 147| 1.36M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 684, False: 0] | | | | ------------------ | | | | 148| 684| &(string).pointer, &(string).end)) ? \ | | | | 149| 1.36M| 1 : \ | | | | 150| 1.36M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 1.36M| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.73M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 904k, False: 462k] | | | | ------------------ | | ------------------ | | 540| 1.36M| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 904k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 19.9k, False: 884k] | | | | ------------------ | | ------------------ | | 541| 1.36M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 19.9k| parser->buffer.pointer += 2, \ | | 543| 19.9k| parser->mark.index += 2, \ | | 544| 19.9k| parser->mark.column = 0, \ | | 545| 19.9k| parser->mark.line ++, \ | | 546| 19.9k| parser->unread -= 2) : \ | | 547| 1.36M| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.69M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 884k, False: 462k] | | | | ------------------ | | ------------------ | | 548| 1.34M| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 462k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 461k, False: 1.05k] | | | | ------------------ | | ------------------ | | 549| 1.34M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 1.34M| parser->buffer.pointer ++, \ | | 551| 1.34M| parser->mark.index ++, \ | | 552| 1.34M| parser->mark.column = 0, \ | | 553| 1.34M| parser->mark.line ++, \ | | 554| 1.34M| parser->unread --) : \ | | 555| 1.34M| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 2.11k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 255, False: 804] | | | | ------------------ | | ------------------ | | 556| 1.05k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 255| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 255, False: 0] | | | | ------------------ | | ------------------ | | 557| 1.05k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 255| parser->buffer.pointer += 2, \ | | 559| 255| parser->mark.index ++, \ | | 560| 255| parser->mark.column = 0, \ | | 561| 255| parser->mark.line ++, \ | | 562| 255| parser->unread --) : \ | | 563| 1.05k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 1.60k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 804, False: 0] | | | | ------------------ | | ------------------ | | 564| 804| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 1.60k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 804, False: 0] | | | | ------------------ | | ------------------ | | 565| 804| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 1.60k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 555, False: 249] | | | | ------------------ | | ------------------ | | 566| 804| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 249| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 249, False: 0] | | | | ------------------ | | ------------------ | | 567| 804| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 804| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 804| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 804| parser->mark.index ++, \ | | 571| 804| parser->mark.column = 0, \ | | 572| 804| parser->mark.line ++, \ | | 573| 804| parser->unread --) : 0), \ | | 574| 1.36M| 1) : 0) ------------------ | Branch (3347:25): [True: 0, False: 1.36M] ------------------ 3348| 1.36M| } 3349| 1.50M| } 3350| 5.27M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 5.27M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 5.27M, False: 240] | | ------------------ | | 494| 5.27M| ? 1 \ | | 495| 5.27M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3350:17): [True: 2, False: 5.27M] ------------------ 3351| 5.27M| } 3352| | 3353| | /* Join the whitespaces or fold line breaks. */ 3354| | 3355| 968k| if (leading_blanks) ------------------ | Branch (3355:13): [True: 353k, False: 614k] ------------------ 3356| 353k| { 3357| | /* Do we need to fold line breaks? */ 3358| | 3359| 353k| if (leading_break.start[0] == '\n') { ------------------ | Branch (3359:17): [True: 135k, False: 218k] ------------------ 3360| 135k| if (trailing_breaks.start[0] == '\0') { ------------------ | Branch (3360:21): [True: 113k, False: 21.6k] ------------------ 3361| 113k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 113k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 108k, False: 5.49k] | | ------------------ | | 147| 113k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 5.49k, False: 0] | | ------------------ | | 148| 5.49k| &(string).pointer, &(string).end)) ? \ | | 149| 113k| 1 : \ | | 150| 113k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3361:25): [True: 0, False: 113k] ------------------ 3362| 113k| *(string.pointer++) = ' '; 3363| 113k| } 3364| 21.6k| else { 3365| 21.6k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 21.6k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 21.6k, False: 0] | | ------------------ | | 159| 21.6k| &(string_a).end, &(string_b).start, \ | | 160| 21.6k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 21.6k| ((string_b).pointer = (string_b).start, \ | | 162| 21.6k| 1) : \ | | 163| 21.6k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3365:25): [True: 0, False: 21.6k] ------------------ 3366| 21.6k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 21.6k| ((string).pointer = (string).start, \ | | 155| 21.6k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3367| 21.6k| } 3368| 135k| CLEAR(parser, leading_break); ------------------ | | 154| 135k| ((string).pointer = (string).start, \ | | 155| 135k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3369| 135k| } 3370| 218k| else { 3371| 218k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 218k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 218k, False: 0] | | ------------------ | | 159| 218k| &(string_a).end, &(string_b).start, \ | | 160| 218k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 218k| ((string_b).pointer = (string_b).start, \ | | 162| 218k| 1) : \ | | 163| 218k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3371:21): [True: 0, False: 218k] ------------------ 3372| 218k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 218k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 218k, False: 0] | | ------------------ | | 159| 218k| &(string_a).end, &(string_b).start, \ | | 160| 218k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 218k| ((string_b).pointer = (string_b).start, \ | | 162| 218k| 1) : \ | | 163| 218k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3372:21): [True: 0, False: 218k] ------------------ 3373| 218k| CLEAR(parser, leading_break); ------------------ | | 154| 218k| ((string).pointer = (string).start, \ | | 155| 218k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3374| 218k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 218k| ((string).pointer = (string).start, \ | | 155| 218k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3375| 218k| } 3376| 353k| } 3377| 614k| else 3378| 614k| { 3379| 614k| if (!JOIN(parser, string, whitespaces)) goto error; ------------------ | | 158| 614k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 614k, False: 0] | | ------------------ | | 159| 614k| &(string_a).end, &(string_b).start, \ | | 160| 614k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 614k| ((string_b).pointer = (string_b).start, \ | | 162| 614k| 1) : \ | | 163| 614k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3379:17): [True: 0, False: 614k] ------------------ 3380| 614k| CLEAR(parser, whitespaces); ------------------ | | 154| 614k| ((string).pointer = (string).start, \ | | 155| 614k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3381| 614k| } 3382| 968k| } 3383| | 3384| | /* Eat the right quote. */ 3385| | 3386| 17.0k| SKIP(parser); ------------------ | | 502| 17.0k| (parser->mark.index ++, \ | | 503| 17.0k| parser->mark.column ++, \ | | 504| 17.0k| parser->unread --, \ | | 505| 17.0k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 17.0k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 17.0k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 17.0k, False: 0] | | | | | | ------------------ | | | | | | 381| 17.0k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3387| | 3388| 17.0k| end_mark = parser->mark; 3389| | 3390| | /* Create a token. */ 3391| | 3392| 17.0k| SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, ------------------ | | 526| 17.0k| (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 17.0k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 17.0k| (token).type = (token_type), \ | | | | 502| 17.0k| (token).start_mark = (token_start_mark), \ | | | | 503| 17.0k| (token).end_mark = (token_end_mark)) | | ------------------ | | 527| 17.0k| (token).data.scalar.value = (token_value), \ | | 528| 17.0k| (token).data.scalar.length = (token_length), \ | | 529| 34.1k| (token).data.scalar.style = (token_style)) | | ------------------ | | | Branch (529:35): [True: 8.53k, False: 8.54k] | | ------------------ ------------------ 3393| 17.0k| single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE, 3394| 17.0k| start_mark, end_mark); 3395| | 3396| 17.0k| STRING_DEL(parser, leading_break); ------------------ | | 142| 17.0k| (yaml_free((string).start), \ | | 143| 17.0k| (string).start = (string).pointer = (string).end = 0) ------------------ 3397| 17.0k| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 17.0k| (yaml_free((string).start), \ | | 143| 17.0k| (string).start = (string).pointer = (string).end = 0) ------------------ 3398| 17.0k| STRING_DEL(parser, whitespaces); ------------------ | | 142| 17.0k| (yaml_free((string).start), \ | | 143| 17.0k| (string).start = (string).pointer = (string).end = 0) ------------------ 3399| | 3400| 17.0k| return 1; 3401| | 3402| 978|error: 3403| 978| STRING_DEL(parser, string); ------------------ | | 142| 978| (yaml_free((string).start), \ | | 143| 978| (string).start = (string).pointer = (string).end = 0) ------------------ 3404| 978| STRING_DEL(parser, leading_break); ------------------ | | 142| 978| (yaml_free((string).start), \ | | 143| 978| (string).start = (string).pointer = (string).end = 0) ------------------ 3405| 978| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 978| (yaml_free((string).start), \ | | 143| 978| (string).start = (string).pointer = (string).end = 0) ------------------ 3406| 978| STRING_DEL(parser, whitespaces); ------------------ | | 142| 978| (yaml_free((string).start), \ | | 143| 978| (string).start = (string).pointer = (string).end = 0) ------------------ 3407| | 3408| 978| return 0; 3409| 18.0k|} scanner.c:yaml_parser_fetch_plain_scalar: 1908| 3.58M|{ 1909| 3.58M| yaml_token_t token; 1910| | 1911| | /* A plain scalar could be a simple key. */ 1912| | 1913| 3.58M| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1913:9): [True: 0, False: 3.58M] ------------------ 1914| 0| return 0; 1915| | 1916| | /* A simple key cannot follow a flow scalar. */ 1917| | 1918| 3.58M| parser->simple_key_allowed = 0; 1919| | 1920| | /* Create the SCALAR token and append it to the queue. */ 1921| | 1922| 3.58M| if (!yaml_parser_scan_plain_scalar(parser, &token)) ------------------ | Branch (1922:9): [True: 67, False: 3.58M] ------------------ 1923| 67| return 0; 1924| | 1925| 3.58M| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 3.58M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 3.53M, False: 55.7k] | | ------------------ | | 473| 3.58M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 55.7k, False: 0] | | ------------------ | | 474| 55.7k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 3.58M| (*((queue).tail++) = value, \ | | 476| 3.58M| 1) : \ | | 477| 3.58M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1925:9): [True: 0, False: 3.58M] ------------------ 1926| 0| yaml_token_delete(&token); 1927| 0| return 0; 1928| 0| } 1929| | 1930| 3.58M| return 1; 1931| 3.58M|} scanner.c:yaml_parser_scan_plain_scalar: 3417| 3.58M|{ 3418| 3.58M| yaml_mark_t start_mark; 3419| 3.58M| yaml_mark_t end_mark; 3420| 3.58M| yaml_string_t string = NULL_STRING; ------------------ | | 123| 3.58M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3421| 3.58M| yaml_string_t leading_break = NULL_STRING; ------------------ | | 123| 3.58M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3422| 3.58M| yaml_string_t trailing_breaks = NULL_STRING; ------------------ | | 123| 3.58M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3423| 3.58M| yaml_string_t whitespaces = NULL_STRING; ------------------ | | 123| 3.58M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3424| 3.58M| int leading_blanks = 0; 3425| 3.58M| int indent = parser->indent+1; 3426| | 3427| 3.58M| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.58M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.58M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.58M, False: 0] | | ------------------ | | 134| 3.58M| ((string).pointer = (string).start, \ | | 135| 3.58M| (string).end = (string).start+(size), \ | | 136| 3.58M| memset((string).start, 0, (size)), \ | | 137| 3.58M| 1) : \ | | 138| 3.58M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3427:9): [True: 0, False: 3.58M] ------------------ 3428| 3.58M| if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.58M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.58M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.58M, False: 0] | | ------------------ | | 134| 3.58M| ((string).pointer = (string).start, \ | | 135| 3.58M| (string).end = (string).start+(size), \ | | 136| 3.58M| memset((string).start, 0, (size)), \ | | 137| 3.58M| 1) : \ | | 138| 3.58M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3428:9): [True: 0, False: 3.58M] ------------------ 3429| 3.58M| if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.58M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.58M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.58M, False: 0] | | ------------------ | | 134| 3.58M| ((string).pointer = (string).start, \ | | 135| 3.58M| (string).end = (string).start+(size), \ | | 136| 3.58M| memset((string).start, 0, (size)), \ | | 137| 3.58M| 1) : \ | | 138| 3.58M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3429:9): [True: 0, False: 3.58M] ------------------ 3430| 3.58M| if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.58M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.58M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.58M, False: 0] | | ------------------ | | 134| 3.58M| ((string).pointer = (string).start, \ | | 135| 3.58M| (string).end = (string).start+(size), \ | | 136| 3.58M| memset((string).start, 0, (size)), \ | | 137| 3.58M| 1) : \ | | 138| 3.58M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3430:9): [True: 0, False: 3.58M] ------------------ 3431| | 3432| 3.58M| start_mark = end_mark = parser->mark; 3433| | 3434| | /* Consume the content of the plain scalar. */ 3435| | 3436| 6.50M| while (1) ------------------ | Branch (3436:12): [True: 6.50M, Folded] ------------------ 3437| 6.50M| { 3438| | /* Check for a document indicator. */ 3439| | 3440| 6.50M| if (!CACHE(parser, 4)) goto error; ------------------ | | 493| 6.50M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 6.50M, False: 2.49k] | | ------------------ | | 494| 6.50M| ? 1 \ | | 495| 6.50M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3440:13): [True: 9, False: 6.50M] ------------------ 3441| | 3442| 6.50M| if (parser->mark.column == 0 && ------------------ | Branch (3442:13): [True: 129k, False: 6.37M] ------------------ 3443| 129k| ((CHECK_AT(parser->buffer, '-', 0) && ------------------ | | 175| 259k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 62.4k, False: 67.2k] | | ------------------ ------------------ 3444| 62.4k| CHECK_AT(parser->buffer, '-', 1) && ------------------ | | 175| 192k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 23.8k, False: 38.5k] | | ------------------ ------------------ 3445| 23.8k| CHECK_AT(parser->buffer, '-', 2)) || ------------------ | | 175| 23.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 6.59k, False: 17.2k] | | ------------------ ------------------ 3446| 123k| (CHECK_AT(parser->buffer, '.', 0) && ------------------ | | 175| 246k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 5.21k, False: 117k] | | ------------------ ------------------ 3447| 5.21k| CHECK_AT(parser->buffer, '.', 1) && ------------------ | | 175| 128k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.10k, False: 3.10k] | | ------------------ ------------------ 3448| 2.10k| CHECK_AT(parser->buffer, '.', 2))) && ------------------ | | 175| 2.10k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1.38k, False: 717] | | ------------------ ------------------ 3449| 7.98k| IS_BLANKZ_AT(parser->buffer, 3)) break; ------------------ | | 371| 7.98k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 15.9k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 7.98k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 15.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 275, False: 7.70k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 7.70k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 7.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 218, False: 7.48k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 7.48k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 14.9k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 14.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 972, False: 6.51k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 7.48k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 14.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 490, False: 6.02k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 7.48k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.66k, False: 4.36k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 6.02k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.66k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.07k, False: 582] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 7.48k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 9.89k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.49k, False: 2.45k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 4.94k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 7.44k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.11k, False: 1.38k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 4.94k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.11k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 274, False: 839] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 14.9k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 9.34k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.22k, False: 2.45k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 4.67k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 6.89k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 839, False: 1.38k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 4.67k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 839| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 259, False: 580] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 4.41k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 4.41k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 10, False: 4.40k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3450| | 3451| | /* Check for a comment. */ 3452| | 3453| 6.50M| if (CHECK(parser->buffer, '#')) ------------------ | | 181| 6.50M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 6.50M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 586, False: 6.50M] | | ------------------ ------------------ 3454| 586| break; 3455| | 3456| | /* Consume non-blank characters. */ 3457| | 3458| 30.8M| while (!IS_BLANKZ(parser->buffer)) ------------------ | | 373| 30.8M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 30.8M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 61.7M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 30.8M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 61.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2.86M, False: 28.0M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 28.0M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 28.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.87k, False: 28.0M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 28.0M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 56.0M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 56.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 36.3k, False: 27.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 28.0M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 56.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 84.5k, False: 27.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 28.0M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 30.3k, False: 27.8M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 27.9M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 30.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 839, False: 29.4k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 28.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.98M, False: 23.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 27.9M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 31.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.80M, False: 179k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 27.9M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.80M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.85k, False: 3.79M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 56.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.97M, False: 23.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 27.9M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 31.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.79M, False: 179k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 27.9M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.79M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 8.26k, False: 3.79M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 27.9M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 27.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2.21k, False: 27.8M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3459| 27.8M| { 3460| | /* Check for "x:" + one of ',?[]{}' in the flow context. TODO: Fix the test "spec-08-13". 3461| | * This is not completely according to the spec 3462| | * See http://yaml.org/spec/1.1/#id907281 9.1.3. Plain 3463| | */ 3464| | 3465| 27.8M| if (parser->flow_level ------------------ | Branch (3465:17): [True: 8.72M, False: 19.1M] ------------------ 3466| 8.72M| && CHECK(parser->buffer, ':') ------------------ | | 181| 36.6M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 8.72M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.41k, False: 8.71M] | | ------------------ ------------------ 3467| 2.41k| && ( 3468| 2.41k| CHECK_AT(parser->buffer, ',', 1) ------------------ | | 175| 4.82k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 2.40k] | | ------------------ ------------------ 3469| 2.40k| || CHECK_AT(parser->buffer, '?', 1) ------------------ | | 175| 4.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 2.40k] | | ------------------ ------------------ 3470| 2.40k| || CHECK_AT(parser->buffer, '[', 1) ------------------ | | 175| 4.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 2.40k] | | ------------------ ------------------ 3471| 2.40k| || CHECK_AT(parser->buffer, ']', 1) ------------------ | | 175| 4.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 3, False: 2.40k] | | ------------------ ------------------ 3472| 2.40k| || CHECK_AT(parser->buffer, '{', 1) ------------------ | | 175| 4.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 2.40k] | | ------------------ ------------------ 3473| 2.40k| || CHECK_AT(parser->buffer, '}', 1) ------------------ | | 175| 2.40k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 2.40k] | | ------------------ ------------------ 3474| 2.41k| ) 3475| 27.8M| ) { 3476| 8| yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 3477| 8| start_mark, "found unexpected ':'"); 3478| 8| goto error; 3479| 8| } 3480| | 3481| | /* Check for indicators that may end a plain scalar. */ 3482| | 3483| 27.8M| if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1)) ------------------ | | 181| 55.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 27.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 894k, False: 27.0M] | | ------------------ ------------------ if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1)) ------------------ | | 371| 894k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 1.78M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 894k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.78M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 4.08k, False: 890k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 890k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 890k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 532, False: 889k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 889k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 1.77M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 1.77M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 34.3k, False: 855k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 889k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.74M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 573k, False: 282k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 889k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 564k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 913, False: 281k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 282k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 913| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 200, False: 713] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 889k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 564k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.79k, False: 280k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 282k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 284k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.47k, False: 315] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 282k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.47k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 563, False: 913] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 1.77M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 563k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.22k, False: 280k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 281k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 282k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 913, False: 315] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 281k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 913| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 414, False: 499] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 281k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 281k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 191, False: 281k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3484| 27.2M| || (parser->flow_level && ------------------ | Branch (3484:25): [True: 8.72M, False: 18.5M] ------------------ 3485| 8.72M| (CHECK(parser->buffer, ',') ------------------ | | 181| 17.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 8.72M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.88M, False: 5.83M] | | ------------------ ------------------ 3486| 5.83M| || CHECK(parser->buffer, '[') ------------------ | | 181| 14.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.13k, False: 5.83M] | | ------------------ ------------------ 3487| 5.83M| || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 14.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 884, False: 5.83M] | | ------------------ ------------------ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 14.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 470, False: 5.83M] | | ------------------ ------------------ 3488| 5.83M| || CHECK(parser->buffer, '}')))) ------------------ | | 181| 5.83M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 421, False: 5.83M] | | ------------------ ------------------ 3489| 3.50M| break; 3490| | 3491| | /* Check if we need to join whitespaces and breaks. */ 3492| | 3493| 24.3M| if (leading_blanks || whitespaces.start != whitespaces.pointer) ------------------ | Branch (3493:17): [True: 52.7k, False: 24.3M] | Branch (3493:35): [True: 2.86M, False: 21.4M] ------------------ 3494| 2.91M| { 3495| 2.91M| if (leading_blanks) ------------------ | Branch (3495:21): [True: 52.7k, False: 2.86M] ------------------ 3496| 52.7k| { 3497| | /* Do we need to fold line breaks? */ 3498| | 3499| 52.7k| if (leading_break.start[0] == '\n') { ------------------ | Branch (3499:25): [True: 43.6k, False: 9.14k] ------------------ 3500| 43.6k| if (trailing_breaks.start[0] == '\0') { ------------------ | Branch (3500:29): [True: 32.2k, False: 11.3k] ------------------ 3501| 32.2k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 32.2k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 31.8k, False: 419] | | ------------------ | | 147| 32.2k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 419, False: 0] | | ------------------ | | 148| 419| &(string).pointer, &(string).end)) ? \ | | 149| 32.2k| 1 : \ | | 150| 32.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3501:33): [True: 0, False: 32.2k] ------------------ 3502| 32.2k| *(string.pointer++) = ' '; 3503| 32.2k| } 3504| 11.3k| else { 3505| 11.3k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 11.3k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 11.3k, False: 0] | | ------------------ | | 159| 11.3k| &(string_a).end, &(string_b).start, \ | | 160| 11.3k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 11.3k| ((string_b).pointer = (string_b).start, \ | | 162| 11.3k| 1) : \ | | 163| 11.3k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3505:33): [True: 0, False: 11.3k] ------------------ 3506| 11.3k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 11.3k| ((string).pointer = (string).start, \ | | 155| 11.3k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3507| 11.3k| } 3508| 43.6k| CLEAR(parser, leading_break); ------------------ | | 154| 43.6k| ((string).pointer = (string).start, \ | | 155| 43.6k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3509| 43.6k| } 3510| 9.14k| else { 3511| 9.14k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 9.14k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 9.14k, False: 0] | | ------------------ | | 159| 9.14k| &(string_a).end, &(string_b).start, \ | | 160| 9.14k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 9.14k| ((string_b).pointer = (string_b).start, \ | | 162| 9.14k| 1) : \ | | 163| 9.14k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3511:29): [True: 0, False: 9.14k] ------------------ 3512| 9.14k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 9.14k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 9.14k, False: 0] | | ------------------ | | 159| 9.14k| &(string_a).end, &(string_b).start, \ | | 160| 9.14k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 9.14k| ((string_b).pointer = (string_b).start, \ | | 162| 9.14k| 1) : \ | | 163| 9.14k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3512:29): [True: 0, False: 9.14k] ------------------ 3513| 9.14k| CLEAR(parser, leading_break); ------------------ | | 154| 9.14k| ((string).pointer = (string).start, \ | | 155| 9.14k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3514| 9.14k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 9.14k| ((string).pointer = (string).start, \ | | 155| 9.14k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3515| 9.14k| } 3516| | 3517| 52.7k| leading_blanks = 0; 3518| 52.7k| } 3519| 2.86M| else 3520| 2.86M| { 3521| 2.86M| if (!JOIN(parser, string, whitespaces)) goto error; ------------------ | | 158| 2.86M| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 2.86M, False: 0] | | ------------------ | | 159| 2.86M| &(string_a).end, &(string_b).start, \ | | 160| 2.86M| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 2.86M| ((string_b).pointer = (string_b).start, \ | | 162| 2.86M| 1) : \ | | 163| 2.86M| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3521:25): [True: 0, False: 2.86M] ------------------ 3522| 2.86M| CLEAR(parser, whitespaces); ------------------ | | 154| 2.86M| ((string).pointer = (string).start, \ | | 155| 2.86M| memset((string).start, 0, (string).end-(string).start)) ------------------ 3523| 2.86M| } 3524| 2.91M| } 3525| | 3526| | /* Copy the character. */ 3527| | 3528| 24.3M| if (!READ(parser, string)) goto error; ------------------ | | 526| 24.3M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 24.3M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 24.3M, False: 0] | | | | | Branch (146:7): [True: 24.3M, False: 82.7k] | | | | ------------------ | | | | 147| 24.3M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 82.7k, False: 0] | | | | ------------------ | | | | 148| 82.7k| &(string).pointer, &(string).end)) ? \ | | | | 149| 24.3M| 1 : \ | | | | 150| 24.3M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 24.3M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 24.3M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 16.1M, False: 8.29M] | | | | ------------------ | | | | 399| 24.3M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 24.3M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 41.7k, False: 8.25M] | | | | ------------------ | | | | 401| 8.29M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 41.7k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 8.29M| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 7.81M, False: 439k] | | | | ------------------ | | | | 404| 8.25M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 7.81M| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 7.81M| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 8.25M| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 439k, False: 0] | | | | ------------------ | | | | 408| 439k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 439k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 439k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 439k| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 24.3M| parser->mark.index ++, \ | | 529| 24.3M| parser->mark.column ++, \ | | 530| 24.3M| parser->unread --, \ | | 531| 24.3M| 1) : 0) ------------------ | Branch (3528:17): [True: 0, False: 24.3M] ------------------ 3529| | 3530| 24.3M| end_mark = parser->mark; 3531| | 3532| 24.3M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 24.3M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 24.3M, False: 4.04k] | | ------------------ | | 494| 24.3M| ? 1 \ | | 495| 24.3M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3532:17): [True: 40, False: 24.3M] ------------------ 3533| 24.3M| } 3534| | 3535| | /* Is it the end? */ 3536| | 3537| 6.50M| if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))) ------------------ | | 323| 6.50M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 13.0M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 6.50M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 13.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.86M, False: 3.63M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 3.63M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 3.63M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.87k, False: 3.63M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))) ------------------ | | 341| 3.63M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 3.63M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 7.27M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 36.3k, False: 3.60M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 3.63M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 7.23M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 84.5k, False: 3.51M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 3.63M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 7.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 839, False: 3.51M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 3.51M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 839| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 839, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 334| 3.63M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 7.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 10.1k, False: 3.50M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 3.51M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.52M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 10.1k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 336| 3.51M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 10.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.85k, False: 8.26k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 3.63M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 7.02M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.26k, False: 3.50M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 3.51M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.52M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.26k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 339| 3.51M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 8.26k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.26k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3538| 3.50M| break; 3539| | 3540| | /* Consume blank characters. */ 3541| | 3542| 2.99M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 2.99M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.99M, False: 0] | | ------------------ | | 494| 2.99M| ? 1 \ | | 495| 2.99M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3542:13): [True: 0, False: 2.99M] ------------------ 3543| | 3544| 11.4M| while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 323| 11.4M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 22.9M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 11.4M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 22.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 7.07M, False: 4.39M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 4.39M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 4.39M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 112k, False: 4.27M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 341| 4.27M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 4.27M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 8.55M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 883k, False: 3.39M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 4.27M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 7.67M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 314k, False: 3.07M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 4.27M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.15M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 4.67k, False: 3.07M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 3.07M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 4.67k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 4.25k, False: 411] | | | | | | ------------------ | | | | ------------------ | | | | 334| 4.27M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.15M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 85.5k, False: 2.98M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 3.07M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.16M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 79.5k, False: 6.01k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 3.07M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 79.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 6.69k, False: 72.8k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 4.27M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.13M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 78.8k, False: 2.98M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 3.06M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.14M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 72.8k, False: 6.01k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 3.06M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 72.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 69.4k, False: 3.33k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3545| 8.46M| { 3546| 8.46M| if (IS_BLANK(parser->buffer)) ------------------ | | 323| 8.46M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 8.46M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 8.46M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 16.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 7.07M, False: 1.39M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 1.39M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.39M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 112k, False: 1.27M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3547| 7.18M| { 3548| | /* Check for tab characters that abuse indentation. */ 3549| | 3550| 7.18M| if (leading_blanks && (int)parser->mark.column < indent ------------------ | Branch (3550:21): [True: 1.00M, False: 6.18M] | Branch (3550:39): [True: 8.91k, False: 995k] ------------------ 3551| 8.91k| && IS_TAB(parser->buffer)) { ------------------ | | 314| 8.91k|#define IS_TAB(string) IS_TAB_AT((string),0) | | ------------------ | | | | 312| 8.91k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | ------------------ | | | | | | 175| 8.91k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2, False: 8.91k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3552| 2| yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 3553| 2| start_mark, "found a tab character that violates indentation"); 3554| 2| goto error; 3555| 2| } 3556| | 3557| | /* Consume a space or a tab character. */ 3558| | 3559| 7.18M| if (!leading_blanks) { ------------------ | Branch (3559:21): [True: 6.18M, False: 1.00M] ------------------ 3560| 6.18M| if (!READ(parser, whitespaces)) goto error; ------------------ | | 526| 6.18M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 6.18M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 6.18M, False: 0] | | | | | Branch (146:7): [True: 6.17M, False: 12.2k] | | | | ------------------ | | | | 147| 6.18M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 12.2k, False: 0] | | | | ------------------ | | | | 148| 12.2k| &(string).pointer, &(string).end)) ? \ | | | | 149| 6.18M| 1 : \ | | | | 150| 6.18M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 6.18M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 6.18M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 6.18M, False: 0] | | | | ------------------ | | | | 399| 6.18M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 6.18M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 0] | | | | ------------------ | | | | 401| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 0| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 0, False: 0] | | | | ------------------ | | | | 404| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 0| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 0, False: 0] | | | | ------------------ | | | | 408| 0| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 0| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 0| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 6.18M| parser->mark.index ++, \ | | 529| 6.18M| parser->mark.column ++, \ | | 530| 6.18M| parser->unread --, \ | | 531| 6.18M| 1) : 0) ------------------ | Branch (3560:25): [True: 0, False: 6.18M] ------------------ 3561| 6.18M| } 3562| 1.00M| else { 3563| 1.00M| SKIP(parser); ------------------ | | 502| 1.00M| (parser->mark.index ++, \ | | 503| 1.00M| parser->mark.column ++, \ | | 504| 1.00M| parser->unread --, \ | | 505| 1.00M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.00M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.00M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.00M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.00M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 382| 0| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 383| 0| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3564| 1.00M| } 3565| 7.18M| } 3566| 1.27M| else 3567| 1.27M| { 3568| 1.27M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 1.27M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.27M, False: 149] | | ------------------ | | 494| 1.27M| ? 1 \ | | 495| 1.27M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3568:21): [True: 5, False: 1.27M] ------------------ 3569| | 3570| | /* Check if it is a first line break. */ 3571| | 3572| 1.27M| if (!leading_blanks) ------------------ | Branch (3572:21): [True: 136k, False: 1.14M] ------------------ 3573| 136k| { 3574| 136k| CLEAR(parser, whitespaces); ------------------ | | 154| 136k| ((string).pointer = (string).start, \ | | 155| 136k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3575| 136k| if (!READ_LINE(parser, leading_break)) goto error; ------------------ | | 538| 136k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 136k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 136k, False: 0] | | | | | Branch (146:7): [True: 136k, False: 0] | | | | ------------------ | | | | 147| 136k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 136k| 1 : \ | | | | 150| 136k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 136k| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 273k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 37.0k, False: 99.5k] | | | | ------------------ | | ------------------ | | 540| 136k| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 37.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 2.36k, False: 34.7k] | | | | ------------------ | | ------------------ | | 541| 136k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 2.36k| parser->buffer.pointer += 2, \ | | 543| 2.36k| parser->mark.index += 2, \ | | 544| 2.36k| parser->mark.column = 0, \ | | 545| 2.36k| parser->mark.line ++, \ | | 546| 2.36k| parser->unread -= 2) : \ | | 547| 136k| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 268k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 34.7k, False: 99.5k] | | | | ------------------ | | ------------------ | | 548| 134k| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 99.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 88.5k, False: 10.9k] | | | | ------------------ | | ------------------ | | 549| 134k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 123k| parser->buffer.pointer ++, \ | | 551| 123k| parser->mark.index ++, \ | | 552| 123k| parser->mark.column = 0, \ | | 553| 123k| parser->mark.line ++, \ | | 554| 123k| parser->unread --) : \ | | 555| 134k| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 21.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 846, False: 10.1k] | | | | ------------------ | | ------------------ | | 556| 10.9k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 846| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 846, False: 0] | | | | ------------------ | | ------------------ | | 557| 10.9k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 846| parser->buffer.pointer += 2, \ | | 559| 846| parser->mark.index ++, \ | | 560| 846| parser->mark.column = 0, \ | | 561| 846| parser->mark.line ++, \ | | 562| 846| parser->unread --) : \ | | 563| 10.9k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 20.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 10.1k, False: 0] | | | | ------------------ | | ------------------ | | 564| 10.1k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 20.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 10.1k, False: 0] | | | | ------------------ | | ------------------ | | 565| 10.1k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 20.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.85k, False: 8.27k] | | | | ------------------ | | ------------------ | | 566| 10.1k| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 8.27k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 8.27k, False: 0] | | | | ------------------ | | ------------------ | | 567| 10.1k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 10.1k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 10.1k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 10.1k| parser->mark.index ++, \ | | 571| 10.1k| parser->mark.column = 0, \ | | 572| 10.1k| parser->mark.line ++, \ | | 573| 10.1k| parser->unread --) : 0), \ | | 574| 136k| 1) : 0) ------------------ | Branch (3575:25): [True: 0, False: 136k] ------------------ 3576| 136k| leading_blanks = 1; 3577| 136k| } 3578| 1.14M| else 3579| 1.14M| { 3580| 1.14M| if (!READ_LINE(parser, trailing_breaks)) goto error; ------------------ | | 538| 1.14M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 1.14M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 1.14M, False: 0] | | | | | Branch (146:7): [True: 1.13M, False: 5.01k] | | | | ------------------ | | | | 147| 1.14M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 5.01k, False: 0] | | | | ------------------ | | | | 148| 5.01k| &(string).pointer, &(string).end)) ? \ | | | | 149| 1.14M| 1 : \ | | | | 150| 1.14M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 1.14M| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.28M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 846k, False: 295k] | | | | ------------------ | | ------------------ | | 540| 1.14M| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 846k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 29.8k, False: 816k] | | | | ------------------ | | ------------------ | | 541| 1.14M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 29.8k| parser->buffer.pointer += 2, \ | | 543| 29.8k| parser->mark.index += 2, \ | | 544| 29.8k| parser->mark.column = 0, \ | | 545| 29.8k| parser->mark.line ++, \ | | 546| 29.8k| parser->unread -= 2) : \ | | 547| 1.14M| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.22M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 816k, False: 295k] | | | | ------------------ | | ------------------ | | 548| 1.11M| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 295k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 225k, False: 69.4k] | | | | ------------------ | | ------------------ | | 549| 1.11M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 1.04M| parser->buffer.pointer ++, \ | | 551| 1.04M| parser->mark.index ++, \ | | 552| 1.04M| parser->mark.column = 0, \ | | 553| 1.04M| parser->mark.line ++, \ | | 554| 1.04M| parser->unread --) : \ | | 555| 1.11M| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 138k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 3.41k, False: 66.0k] | | | | ------------------ | | ------------------ | | 556| 69.4k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 3.41k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 3.41k, False: 0] | | | | ------------------ | | ------------------ | | 557| 69.4k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 3.41k| parser->buffer.pointer += 2, \ | | 559| 3.41k| parser->mark.index ++, \ | | 560| 3.41k| parser->mark.column = 0, \ | | 561| 3.41k| parser->mark.line ++, \ | | 562| 3.41k| parser->unread --) : \ | | 563| 69.4k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 132k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 66.0k, False: 0] | | | | ------------------ | | ------------------ | | 564| 66.0k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 132k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 66.0k, False: 0] | | | | ------------------ | | ------------------ | | 565| 66.0k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 132k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 4.84k, False: 61.2k] | | | | ------------------ | | ------------------ | | 566| 66.0k| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 61.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 61.2k, False: 0] | | | | ------------------ | | ------------------ | | 567| 66.0k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 66.0k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 66.0k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 66.0k| parser->mark.index ++, \ | | 571| 66.0k| parser->mark.column = 0, \ | | 572| 66.0k| parser->mark.line ++, \ | | 573| 66.0k| parser->unread --) : 0), \ | | 574| 1.14M| 1) : 0) ------------------ | Branch (3580:25): [True: 0, False: 1.14M] ------------------ 3581| 1.14M| } 3582| 1.27M| } 3583| 8.46M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 8.46M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 8.46M, False: 357] | | ------------------ | | 494| 8.46M| ? 1 \ | | 495| 8.46M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3583:17): [True: 3, False: 8.46M] ------------------ 3584| 8.46M| } 3585| | 3586| | /* Check indentation level. */ 3587| | 3588| 2.99M| if (!parser->flow_level && (int)parser->mark.column < indent) ------------------ | Branch (3588:13): [True: 2.98M, False: 10.0k] | Branch (3588:36): [True: 77.2k, False: 2.91M] ------------------ 3589| 77.2k| break; 3590| 2.99M| } 3591| | 3592| | /* Create a token. */ 3593| | 3594| 3.58M| SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, ------------------ | | 526| 3.58M| (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 3.58M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 3.58M| (token).type = (token_type), \ | | | | 502| 3.58M| (token).start_mark = (token_start_mark), \ | | | | 503| 3.58M| (token).end_mark = (token_end_mark)) | | ------------------ | | 527| 3.58M| (token).data.scalar.value = (token_value), \ | | 528| 3.58M| (token).data.scalar.length = (token_length), \ | | 529| 3.58M| (token).data.scalar.style = (token_style)) ------------------ 3595| 3.58M| YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark); 3596| | 3597| | /* Note that we change the 'simple_key_allowed' flag. */ 3598| | 3599| 3.58M| if (leading_blanks) { ------------------ | Branch (3599:9): [True: 83.8k, False: 3.50M] ------------------ 3600| 83.8k| parser->simple_key_allowed = 1; 3601| 83.8k| } 3602| | 3603| 3.58M| STRING_DEL(parser, leading_break); ------------------ | | 142| 3.58M| (yaml_free((string).start), \ | | 143| 3.58M| (string).start = (string).pointer = (string).end = 0) ------------------ 3604| 3.58M| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 3.58M| (yaml_free((string).start), \ | | 143| 3.58M| (string).start = (string).pointer = (string).end = 0) ------------------ 3605| 3.58M| STRING_DEL(parser, whitespaces); ------------------ | | 142| 3.58M| (yaml_free((string).start), \ | | 143| 3.58M| (string).start = (string).pointer = (string).end = 0) ------------------ 3606| | 3607| 3.58M| return 1; 3608| | 3609| 67|error: 3610| 67| STRING_DEL(parser, string); ------------------ | | 142| 67| (yaml_free((string).start), \ | | 143| 67| (string).start = (string).pointer = (string).end = 0) ------------------ 3611| 67| STRING_DEL(parser, leading_break); ------------------ | | 142| 67| (yaml_free((string).start), \ | | 143| 67| (string).start = (string).pointer = (string).end = 0) ------------------ 3612| 67| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 67| (yaml_free((string).start), \ | | 143| 67| (string).start = (string).pointer = (string).end = 0) ------------------ 3613| 67| STRING_DEL(parser, whitespaces); ------------------ | | 142| 67| (yaml_free((string).start), \ | | 143| 67| (string).start = (string).pointer = (string).end = 0) ------------------ 3614| | 3615| 67| return 0; 3616| 3.58M|} scanner.c:yaml_parser_set_scanner_error: 791| 2.10k|{ 792| 2.10k| parser->error = YAML_SCANNER_ERROR; 793| 2.10k| parser->context = context; 794| 2.10k| parser->context_mark = context_mark; 795| 2.10k| parser->problem = problem; 796| 2.10k| parser->problem_mark = parser->mark; 797| | 798| 2.10k| return 0; 799| 2.10k|} scanner.c:yaml_parser_stale_simple_keys: 1064| 29.7M|{ 1065| 29.7M| yaml_simple_key_t *simple_key; 1066| | 1067| | /* Check for a potential simple key for each flow level. */ 1068| | 1069| 29.7M| for (simple_key = parser->simple_keys.start; 1070| 213M| simple_key != parser->simple_keys.top; simple_key ++) ------------------ | Branch (1070:13): [True: 184M, False: 29.7M] ------------------ 1071| 184M| { 1072| | /* 1073| | * The specification requires that a simple key 1074| | * 1075| | * - is limited to a single line, 1076| | * - is shorter than 1024 characters. 1077| | */ 1078| | 1079| 184M| if (simple_key->possible ------------------ | Branch (1079:13): [True: 40.4M, False: 143M] ------------------ 1080| 40.4M| && (simple_key->mark.line < parser->mark.line ------------------ | Branch (1080:21): [True: 125k, False: 40.3M] ------------------ 1081| 40.3M| || simple_key->mark.index+1024 < parser->mark.index)) { ------------------ | Branch (1081:24): [True: 4.44k, False: 40.3M] ------------------ 1082| | 1083| | /* Check if the potential simple key to be removed is required. */ 1084| | 1085| 129k| if (simple_key->required) { ------------------ | Branch (1085:17): [True: 38, False: 129k] ------------------ 1086| 38| return yaml_parser_set_scanner_error(parser, 1087| 38| "while scanning a simple key", simple_key->mark, 1088| 38| "could not find expected ':'"); 1089| 38| } 1090| | 1091| 129k| simple_key->possible = 0; 1092| 129k| } 1093| 184M| } 1094| | 1095| 29.7M| return 1; 1096| 29.7M|} yaml_emitter_flush: 33| 219k|{ 34| 219k| int low, high; 35| | 36| 219k| assert(emitter); /* Non-NULL emitter object is expected. */ ------------------ | Branch (36:5): [True: 0, False: 219k] | Branch (36:5): [True: 219k, False: 0] ------------------ 37| 219k| assert(emitter->write_handler); /* Write handler must be set. */ ------------------ | Branch (37:5): [True: 0, False: 219k] | Branch (37:5): [True: 219k, False: 0] ------------------ 38| 219k| assert(emitter->encoding); /* Output encoding must be set. */ ------------------ | Branch (38:5): [True: 0, False: 219k] | Branch (38:5): [True: 219k, False: 0] ------------------ 39| | 40| 219k| emitter->buffer.last = emitter->buffer.pointer; 41| 219k| emitter->buffer.pointer = emitter->buffer.start; 42| | 43| | /* Check if the buffer is empty. */ 44| | 45| 219k| if (emitter->buffer.start == emitter->buffer.last) { ------------------ | Branch (45:9): [True: 1.61k, False: 217k] ------------------ 46| 1.61k| return 1; 47| 1.61k| } 48| | 49| | /* If the output encoding is UTF-8, we don't need to recode the buffer. */ 50| | 51| 217k| if (emitter->encoding == YAML_UTF8_ENCODING) ------------------ | Branch (51:9): [True: 217k, False: 0] ------------------ 52| 217k| { 53| 217k| if (emitter->write_handler(emitter->write_handler_data, ------------------ | Branch (53:13): [True: 212k, False: 4.86k] ------------------ 54| 217k| emitter->buffer.start, 55| 217k| emitter->buffer.last - emitter->buffer.start)) { 56| 212k| emitter->buffer.last = emitter->buffer.start; 57| 212k| emitter->buffer.pointer = emitter->buffer.start; 58| 212k| return 1; 59| 212k| } 60| 4.86k| else { 61| 4.86k| return yaml_emitter_set_writer_error(emitter, "write error"); 62| 4.86k| } 63| 217k| } 64| | 65| | /* Recode the buffer into the raw buffer. */ 66| | 67| 0| low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1); ------------------ | Branch (67:12): [True: 0, False: 0] ------------------ 68| 0| high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0); ------------------ | Branch (68:13): [True: 0, False: 0] ------------------ 69| | 70| 0| while (emitter->buffer.pointer != emitter->buffer.last) ------------------ | Branch (70:12): [True: 0, False: 0] ------------------ 71| 0| { 72| 0| unsigned char octet; 73| 0| unsigned int width; 74| 0| unsigned int value; 75| 0| size_t k; 76| | 77| | /* 78| | * See the "reader.c" code for more details on UTF-8 encoding. Note 79| | * that we assume that the buffer contains a valid UTF-8 sequence. 80| | */ 81| | 82| | /* Read the next UTF-8 character. */ 83| | 84| 0| octet = emitter->buffer.pointer[0]; 85| | 86| 0| width = (octet & 0x80) == 0x00 ? 1 : ------------------ | Branch (86:17): [True: 0, False: 0] ------------------ 87| 0| (octet & 0xE0) == 0xC0 ? 2 : ------------------ | Branch (87:17): [True: 0, False: 0] ------------------ 88| 0| (octet & 0xF0) == 0xE0 ? 3 : ------------------ | Branch (88:17): [True: 0, False: 0] ------------------ 89| 0| (octet & 0xF8) == 0xF0 ? 4 : 0; ------------------ | Branch (89:17): [True: 0, False: 0] ------------------ 90| | 91| 0| value = (octet & 0x80) == 0x00 ? octet & 0x7F : ------------------ | Branch (91:17): [True: 0, False: 0] ------------------ 92| 0| (octet & 0xE0) == 0xC0 ? octet & 0x1F : ------------------ | Branch (92:17): [True: 0, False: 0] ------------------ 93| 0| (octet & 0xF0) == 0xE0 ? octet & 0x0F : ------------------ | Branch (93:17): [True: 0, False: 0] ------------------ 94| 0| (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; ------------------ | Branch (94:17): [True: 0, False: 0] ------------------ 95| | 96| 0| for (k = 1; k < width; k ++) { ------------------ | Branch (96:21): [True: 0, False: 0] ------------------ 97| 0| octet = emitter->buffer.pointer[k]; 98| 0| value = (value << 6) + (octet & 0x3F); 99| 0| } 100| | 101| 0| emitter->buffer.pointer += width; 102| | 103| | /* Write the character. */ 104| | 105| 0| if (value < 0x10000) ------------------ | Branch (105:13): [True: 0, False: 0] ------------------ 106| 0| { 107| 0| emitter->raw_buffer.last[high] = value >> 8; 108| 0| emitter->raw_buffer.last[low] = value & 0xFF; 109| | 110| 0| emitter->raw_buffer.last += 2; 111| 0| } 112| 0| else 113| 0| { 114| | /* Write the character using a surrogate pair (check "reader.c"). */ 115| | 116| 0| value -= 0x10000; 117| 0| emitter->raw_buffer.last[high] = 0xD8 + (value >> 18); 118| 0| emitter->raw_buffer.last[low] = (value >> 10) & 0xFF; 119| 0| emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF); 120| 0| emitter->raw_buffer.last[low+2] = value & 0xFF; 121| | 122| 0| emitter->raw_buffer.last += 4; 123| 0| } 124| 0| } 125| | 126| | /* Write the raw buffer. */ 127| | 128| 0| if (emitter->write_handler(emitter->write_handler_data, ------------------ | Branch (128:9): [True: 0, False: 0] ------------------ 129| 0| emitter->raw_buffer.start, 130| 0| emitter->raw_buffer.last - emitter->raw_buffer.start)) { 131| 0| emitter->buffer.last = emitter->buffer.start; 132| 0| emitter->buffer.pointer = emitter->buffer.start; 133| 0| emitter->raw_buffer.last = emitter->raw_buffer.start; 134| 0| emitter->raw_buffer.pointer = emitter->raw_buffer.start; 135| 0| return 1; 136| 0| } 137| 0| else { 138| 0| return yaml_emitter_set_writer_error(emitter, "write error"); 139| 0| } 140| 0|} writer.c:yaml_emitter_set_writer_error: 20| 4.86k|{ 21| 4.86k| emitter->error = YAML_WRITER_ERROR; 22| 4.86k| emitter->problem = problem; 23| | 24| 4.86k| return 0; 25| 4.86k|} LLVMFuzzerTestOneInput: 28| 10.9k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 29| 10.9k| if (size < 2) ------------------ | Branch (29:7): [True: 1, False: 10.9k] ------------------ 30| 1| return 0; 31| | 32| 10.9k| bool done = false; 33| 10.9k| bool is_canonical = data[0] & 1; 34| 10.9k| bool is_unicode = data[1] & 1; 35| 10.9k| data += 2; 36| 10.9k| size -= 2; 37| | 38| 10.9k| yaml_parser_t parser; 39| 10.9k| yaml_emitter_t emitter; 40| 10.9k| yaml_document_t document; 41| | 42| | /* Initialize the parser and emitter objects. */ 43| | 44| 10.9k| if (!yaml_parser_initialize(&parser)) ------------------ | Branch (44:7): [True: 0, False: 10.9k] ------------------ 45| 0| return 0; 46| | 47| 10.9k| if (!yaml_emitter_initialize(&emitter)) ------------------ | Branch (47:7): [True: 0, False: 10.9k] ------------------ 48| 0| goto cleanup_parser; 49| | 50| | /* Set the parser parameters. */ 51| | 52| 10.9k| yaml_parser_set_input_string(&parser, data, size); 53| | 54| | /* Set the emitter parameters. */ 55| 10.9k| yaml_output_buffer_t out = {/*buf=*/NULL, /*size=*/0, /*capacity=*/1000}; 56| 10.9k| yaml_emitter_set_output(&emitter, yaml_write_handler, &out); 57| | 58| 10.9k| yaml_emitter_set_canonical(&emitter, is_canonical); 59| 10.9k| yaml_emitter_set_unicode(&emitter, is_unicode); 60| | 61| | /* The main loop. */ 62| | 63| 70.0k| while (!done) { ------------------ | Branch (63:10): [True: 68.3k, False: 1.64k] ------------------ 64| | /* Get the next event. */ 65| | 66| 68.3k| if (!yaml_parser_load(&parser, &document)) ------------------ | Branch (66:9): [True: 4.39k, False: 63.9k] ------------------ 67| 4.39k| break; 68| | 69| | /* Check if this is the stream end. */ 70| | 71| 63.9k| done = (!yaml_document_get_root_node(&document)); 72| | 73| | /* Emit the event. */ 74| | 75| 63.9k| if (!yaml_emitter_dump(&emitter, &document)) ------------------ | Branch (75:9): [True: 4.91k, False: 59.0k] ------------------ 76| 4.91k| break; 77| 63.9k| } 78| | 79| 10.9k| free(out.buf); 80| 10.9k| yaml_emitter_delete(&emitter); 81| | 82| 10.9k|cleanup_parser: 83| | 84| 10.9k| yaml_parser_delete(&parser); 85| 10.9k| return 0; 86| 10.9k|} libyaml_reformatter_alt_fuzzer.c:yaml_write_handler: 24| 217k|static int yaml_write_handler(void *data, unsigned char *buffer, size_t size) { 25| 217k| size_t newsize; 26| 217k| yaml_output_buffer_t *out = (yaml_output_buffer_t *)data; 27| | 28| | /* Double buffer size whenever necessary */ 29| 217k| if (out->size + size >= out->capacity) { ------------------ | Branch (29:7): [True: 6.16k, False: 211k] ------------------ 30| 6.16k| newsize = out->capacity << 1; 31| 6.16k| if (newsize < out->size + size) { ------------------ | Branch (31:9): [True: 1.26k, False: 4.89k] ------------------ 32| 1.26k| newsize = out->size + size; 33| 1.26k| } 34| 6.16k| out->buf = (unsigned char *)realloc(out->buf, newsize); 35| 6.16k| out->capacity = newsize; 36| 6.16k| } 37| 217k| if (!out->buf) { ------------------ | Branch (37:7): [True: 4.86k, False: 212k] ------------------ 38| 4.86k| out->size = 0; 39| 4.86k| return 0; 40| 4.86k| } 41| | 42| 212k| memcpy(out->buf + out->size, buffer, size); 43| 212k| out->size += size; 44| 212k| return 1; 45| 217k|}