yaml_malloc: 32| 22.1M|{ 33| 22.1M| return malloc(size ? size : 1); ------------------ | Branch (33:19): [True: 22.1M, False: 0] ------------------ 34| 22.1M|} yaml_realloc: 42| 270k|{ 43| 270k| return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1); ------------------ | Branch (43:12): [True: 270k, False: 0] | Branch (43:31): [True: 270k, False: 0] | Branch (43:57): [True: 0, False: 0] ------------------ 44| 270k|} yaml_free: 52| 50.0M|{ 53| 50.0M| if (ptr) free(ptr); ------------------ | Branch (53:9): [True: 33.3M, False: 16.6M] ------------------ 54| 50.0M|} yaml_strdup: 62| 11.2M|{ 63| 11.2M| if (!str) ------------------ | Branch (63:9): [True: 0, False: 11.2M] ------------------ 64| 0| return NULL; 65| | 66| 11.2M| return (yaml_char_t *)strdup((char *)str); 67| 11.2M|} yaml_string_extend: 76| 126k|{ 77| 126k| yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2); 78| | 79| 126k| if (!new_start) return 0; ------------------ | Branch (79:9): [True: 0, False: 126k] ------------------ 80| | 81| 126k| memset(new_start + (*end - *start), 0, *end - *start); 82| | 83| 126k| *pointer = new_start + (*pointer - *start); 84| 126k| *end = new_start + (*end - *start)*2; 85| 126k| *start = new_start; 86| | 87| 126k| return 1; 88| 126k|} yaml_string_join: 98| 4.27M|{ 99| 4.27M| UNUSED_PARAM(b_end) ------------------ | | 678| 4.27M|# define UNUSED_PARAM(a) (void)(a); ------------------ 100| 4.27M| if (*b_start == *b_pointer) ------------------ | Branch (100:9): [True: 624k, False: 3.65M] ------------------ 101| 624k| return 1; 102| | 103| 3.66M| while (*a_end - *a_pointer <= *b_pointer - *b_start) { ------------------ | Branch (103:12): [True: 9.30k, False: 3.65M] ------------------ 104| 9.30k| if (!yaml_string_extend(a_start, a_pointer, a_end)) ------------------ | Branch (104:13): [True: 0, False: 9.30k] ------------------ 105| 0| return 0; 106| 9.30k| } 107| | 108| 3.65M| memcpy(*a_pointer, *b_start, *b_pointer - *b_start); 109| 3.65M| *a_pointer += *b_pointer - *b_start; 110| | 111| 3.65M| return 1; 112| 3.65M|} yaml_stack_extend: 120| 139k|{ 121| 139k| void *new_start; 122| | 123| 139k| if ((char *)*end - (char *)*start >= INT_MAX / 2) ------------------ | Branch (123:9): [True: 0, False: 139k] ------------------ 124| 0| return 0; 125| | 126| 139k| new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2); 127| | 128| 139k| if (!new_start) return 0; ------------------ | Branch (128:9): [True: 0, False: 139k] ------------------ 129| | 130| 139k| *top = (char *)new_start + ((char *)*top - (char *)*start); 131| 139k| *end = (char *)new_start + ((char *)*end - (char *)*start)*2; 132| 139k| *start = new_start; 133| | 134| 139k| return 1; 135| 139k|} yaml_queue_extend: 143| 1.06M|{ 144| | /* Check if we need to resize the queue. */ 145| | 146| 1.06M| if (*start == *head && *tail == *end) { ------------------ | Branch (146:9): [True: 5.30k, False: 1.05M] | Branch (146:28): [True: 5.30k, False: 0] ------------------ 147| 5.30k| void *new_start = yaml_realloc(*start, 148| 5.30k| ((char *)*end - (char *)*start)*2); 149| | 150| 5.30k| if (!new_start) return 0; ------------------ | Branch (150:13): [True: 0, False: 5.30k] ------------------ 151| | 152| 5.30k| *head = (char *)new_start + ((char *)*head - (char *)*start); 153| 5.30k| *tail = (char *)new_start + ((char *)*tail - (char *)*start); 154| 5.30k| *end = (char *)new_start + ((char *)*end - (char *)*start)*2; 155| 5.30k| *start = new_start; 156| 5.30k| } 157| | 158| | /* Check if we need to move the queue at the beginning of the buffer. */ 159| | 160| 1.06M| if (*tail == *end) { ------------------ | Branch (160:9): [True: 1.05M, False: 5.30k] ------------------ 161| 1.05M| if (*head != *tail) { ------------------ | Branch (161:13): [True: 393k, False: 664k] ------------------ 162| 393k| memmove(*start, *head, (char *)*tail - (char *)*head); 163| 393k| } 164| 1.05M| *tail = (char *)*tail - (char *)*head + (char *)*start; 165| 1.05M| *head = *start; 166| 1.05M| } 167| | 168| 1.06M| return 1; 169| 1.06M|} yaml_parser_initialize: 178| 11.2k|{ 179| 11.2k| assert(parser); /* Non-NULL parser object expected. */ ------------------ | Branch (179:5): [True: 0, False: 11.2k] | Branch (179:5): [True: 11.2k, False: 0] ------------------ 180| | 181| 11.2k| memset(parser, 0, sizeof(yaml_parser_t)); 182| 11.2k| if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE)) ------------------ | | 93| 11.2k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 11.2k, False: 0] | | ------------------ | | 94| 11.2k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 11.2k| (buffer).end = (buffer).start+(size), \ | | 96| 11.2k| 1) : \ | | 97| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (182:9): [True: 0, False: 11.2k] ------------------ 183| 0| goto error; 184| 11.2k| if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE)) ------------------ | | 93| 11.2k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 11.2k, False: 0] | | ------------------ | | 94| 11.2k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 11.2k| (buffer).end = (buffer).start+(size), \ | | 96| 11.2k| 1) : \ | | 97| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (184:9): [True: 0, False: 11.2k] ------------------ 185| 0| goto error; 186| 11.2k| if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*)) ------------------ | | 457| 11.2k| (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \ | | ------------------ | | | Branch (457:4): [True: 11.2k, False: 0] | | ------------------ | | 458| 11.2k| ((queue).head = (queue).tail = (queue).start, \ | | 459| 11.2k| (queue).end = (queue).start+(size), \ | | 460| 11.2k| 1) : \ | | 461| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 462| 0| 0)) ------------------ | Branch (186:9): [True: 0, False: 11.2k] ------------------ 187| 0| goto error; 188| 11.2k| if (!STACK_INIT(parser, parser->indents, int*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (188:9): [True: 0, False: 11.2k] ------------------ 189| 0| goto error; 190| 11.2k| if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (190:9): [True: 0, False: 11.2k] ------------------ 191| 0| goto error; 192| 11.2k| if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (192:9): [True: 0, False: 11.2k] ------------------ 193| 0| goto error; 194| 11.2k| if (!STACK_INIT(parser, parser->marks, yaml_mark_t*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (194:9): [True: 0, False: 11.2k] ------------------ 195| 0| goto error; 196| 11.2k| if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (196:9): [True: 0, False: 11.2k] ------------------ 197| 0| goto error; 198| | 199| 11.2k| 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| 11.2k|} yaml_parser_delete: 221| 11.2k|{ 222| 11.2k| assert(parser); /* Non-NULL parser object expected. */ ------------------ | Branch (222:5): [True: 0, False: 11.2k] | Branch (222:5): [True: 11.2k, False: 0] ------------------ 223| | 224| 11.2k| BUFFER_DEL(parser, parser->raw_buffer); ------------------ | | 101| 11.2k| (yaml_free((buffer).start), \ | | 102| 11.2k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 225| 11.2k| BUFFER_DEL(parser, parser->buffer); ------------------ | | 101| 11.2k| (yaml_free((buffer).start), \ | | 102| 11.2k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 226| 60.7k| while (!QUEUE_EMPTY(parser, parser->tokens)) { ------------------ | | 469| 60.7k| ((queue).head == (queue).tail) ------------------ | Branch (226:12): [True: 49.4k, False: 11.2k] ------------------ 227| 49.4k| yaml_token_delete(&DEQUEUE(parser, parser->tokens)); ------------------ | | 481| 49.4k| (*((queue).head++)) ------------------ 228| 49.4k| } 229| 11.2k| QUEUE_DEL(parser, parser->tokens); ------------------ | | 465| 11.2k| (yaml_free((queue).start), \ | | 466| 11.2k| (queue).start = (queue).head = (queue).tail = (queue).end = 0) ------------------ 230| 11.2k| STACK_DEL(parser, parser->indents); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 231| 11.2k| STACK_DEL(parser, parser->simple_keys); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 232| 11.2k| STACK_DEL(parser, parser->states); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 233| 11.2k| STACK_DEL(parser, parser->marks); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 234| 16.8k| while (!STACK_EMPTY(parser, parser->tag_directives)) { ------------------ | | 436| 16.8k| ((stack).start == (stack).top) ------------------ | Branch (234:12): [True: 5.65k, False: 11.2k] ------------------ 235| 5.65k| yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); ------------------ | | 454| 5.65k| (*(--(stack).top)) ------------------ 236| 5.65k| yaml_free(tag_directive.handle); 237| 5.65k| yaml_free(tag_directive.prefix); 238| 5.65k| } 239| 11.2k| STACK_DEL(parser, parser->tag_directives); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 240| | 241| 11.2k| memset(parser, 0, sizeof(yaml_parser_t)); 242| 11.2k|} yaml_parser_set_input_string: 291| 11.2k|{ 292| 11.2k| assert(parser); /* Non-NULL parser object expected. */ ------------------ | Branch (292:5): [True: 0, False: 11.2k] | Branch (292:5): [True: 11.2k, False: 0] ------------------ 293| 11.2k| assert(!parser->read_handler); /* You can set the source only once. */ ------------------ | Branch (293:5): [True: 0, False: 11.2k] | Branch (293:5): [True: 11.2k, False: 0] ------------------ 294| 11.2k| assert(input); /* Non-NULL input string expected. */ ------------------ | Branch (294:5): [True: 0, False: 11.2k] | Branch (294:5): [True: 11.2k, False: 0] ------------------ 295| | 296| 11.2k| parser->read_handler = yaml_string_read_handler; 297| 11.2k| parser->read_handler_data = parser; 298| | 299| 11.2k| parser->input.string.start = input; 300| 11.2k| parser->input.string.current = input; 301| 11.2k| parser->input.string.end = input+size; 302| 11.2k|} yaml_emitter_initialize: 356| 11.2k|{ 357| 11.2k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (357:5): [True: 0, False: 11.2k] | Branch (357:5): [True: 11.2k, False: 0] ------------------ 358| | 359| 11.2k| memset(emitter, 0, sizeof(yaml_emitter_t)); 360| 11.2k| if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE)) ------------------ | | 93| 11.2k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 11.2k, False: 0] | | ------------------ | | 94| 11.2k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 11.2k| (buffer).end = (buffer).start+(size), \ | | 96| 11.2k| 1) : \ | | 97| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (360:9): [True: 0, False: 11.2k] ------------------ 361| 0| goto error; 362| 11.2k| if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE)) ------------------ | | 93| 11.2k| (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \ | | ------------------ | | | Branch (93:4): [True: 11.2k, False: 0] | | ------------------ | | 94| 11.2k| ((buffer).last = (buffer).pointer = (buffer).start, \ | | 95| 11.2k| (buffer).end = (buffer).start+(size), \ | | 96| 11.2k| 1) : \ | | 97| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 98| 0| 0)) ------------------ | Branch (362:9): [True: 0, False: 11.2k] ------------------ 363| 0| goto error; 364| 11.2k| if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (364:9): [True: 0, False: 11.2k] ------------------ 365| 0| goto error; 366| 11.2k| if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*)) ------------------ | | 457| 11.2k| (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \ | | ------------------ | | | Branch (457:4): [True: 11.2k, False: 0] | | ------------------ | | 458| 11.2k| ((queue).head = (queue).tail = (queue).start, \ | | 459| 11.2k| (queue).end = (queue).start+(size), \ | | 460| 11.2k| 1) : \ | | 461| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 462| 0| 0)) ------------------ | Branch (366:9): [True: 0, False: 11.2k] ------------------ 367| 0| goto error; 368| 11.2k| if (!STACK_INIT(emitter, emitter->indents, int*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (368:9): [True: 0, False: 11.2k] ------------------ 369| 0| goto error; 370| 11.2k| if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*)) ------------------ | | 424| 11.2k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 11.2k, False: 0] | | ------------------ | | 425| 11.2k| ((stack).top = (stack).start, \ | | 426| 11.2k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 11.2k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 11.2k| 1) : \ | | 428| 11.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (370:9): [True: 0, False: 11.2k] ------------------ 371| 0| goto error; 372| | 373| 11.2k| 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| 11.2k|} yaml_emitter_delete: 393| 11.2k|{ 394| 11.2k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (394:5): [True: 0, False: 11.2k] | Branch (394:5): [True: 11.2k, False: 0] ------------------ 395| | 396| 11.2k| BUFFER_DEL(emitter, emitter->buffer); ------------------ | | 101| 11.2k| (yaml_free((buffer).start), \ | | 102| 11.2k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 397| 11.2k| BUFFER_DEL(emitter, emitter->raw_buffer); ------------------ | | 101| 11.2k| (yaml_free((buffer).start), \ | | 102| 11.2k| (buffer).start = (buffer).pointer = (buffer).end = 0) ------------------ 398| 11.2k| STACK_DEL(emitter, emitter->states); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 399| 16.4k| while (!QUEUE_EMPTY(emitter, emitter->events)) { ------------------ | | 469| 16.4k| ((queue).head == (queue).tail) ------------------ | Branch (399:12): [True: 5.17k, False: 11.2k] ------------------ 400| 5.17k| yaml_event_delete(&DEQUEUE(emitter, emitter->events)); ------------------ | | 481| 5.17k| (*((queue).head++)) ------------------ 401| 5.17k| } 402| 11.2k| QUEUE_DEL(emitter, emitter->events); ------------------ | | 465| 11.2k| (yaml_free((queue).start), \ | | 466| 11.2k| (queue).start = (queue).head = (queue).tail = (queue).end = 0) ------------------ 403| 11.2k| STACK_DEL(emitter, emitter->indents); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 404| 21.9k| while (!STACK_EMPTY(empty, emitter->tag_directives)) { ------------------ | | 436| 21.9k| ((stack).start == (stack).top) ------------------ | Branch (404:12): [True: 10.7k, False: 11.2k] ------------------ 405| 10.7k| yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives); ------------------ | | 454| 10.7k| (*(--(stack).top)) ------------------ 406| 10.7k| yaml_free(tag_directive.handle); 407| 10.7k| yaml_free(tag_directive.prefix); 408| 10.7k| } 409| 11.2k| STACK_DEL(emitter, emitter->tag_directives); ------------------ | | 432| 11.2k| (yaml_free((stack).start), \ | | 433| 11.2k| (stack).start = (stack).top = (stack).end = 0) ------------------ 410| 11.2k| yaml_free(emitter->anchors); 411| | 412| 11.2k| memset(emitter, 0, sizeof(yaml_emitter_t)); 413| 11.2k|} yaml_emitter_set_output: 497| 11.2k|{ 498| 11.2k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (498:5): [True: 0, False: 11.2k] | Branch (498:5): [True: 11.2k, False: 0] ------------------ 499| 11.2k| assert(!emitter->write_handler); /* You can set the output only once. */ ------------------ | Branch (499:5): [True: 0, False: 11.2k] | Branch (499:5): [True: 11.2k, False: 0] ------------------ 500| 11.2k| assert(handler); /* Non-NULL handler object expected. */ ------------------ | Branch (500:5): [True: 0, False: 11.2k] | Branch (500:5): [True: 11.2k, False: 0] ------------------ 501| | 502| 11.2k| emitter->write_handler = handler; 503| 11.2k| emitter->write_handler_data = data; 504| 11.2k|} yaml_emitter_set_canonical: 525| 11.2k|{ 526| 11.2k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (526:5): [True: 0, False: 11.2k] | Branch (526:5): [True: 11.2k, False: 0] ------------------ 527| | 528| 11.2k| emitter->canonical = (canonical != 0); 529| 11.2k|} yaml_emitter_set_unicode: 561| 11.2k|{ 562| 11.2k| assert(emitter); /* Non-NULL emitter object expected. */ ------------------ | Branch (562:5): [True: 0, False: 11.2k] | Branch (562:5): [True: 11.2k, False: 0] ------------------ 563| | 564| 11.2k| emitter->unicode = (unicode != 0); 565| 11.2k|} yaml_token_delete: 585| 49.4k|{ 586| 49.4k| assert(token); /* Non-NULL token object expected. */ ------------------ | Branch (586:5): [True: 0, False: 49.4k] | Branch (586:5): [True: 49.4k, False: 0] ------------------ 587| | 588| 49.4k| switch (token->type) 589| 49.4k| { 590| 78| case YAML_TAG_DIRECTIVE_TOKEN: ------------------ | Branch (590:9): [True: 78, False: 49.4k] ------------------ 591| 78| yaml_free(token->data.tag_directive.handle); 592| 78| yaml_free(token->data.tag_directive.prefix); 593| 78| break; 594| | 595| 890| case YAML_ALIAS_TOKEN: ------------------ | Branch (595:9): [True: 890, False: 48.5k] ------------------ 596| 890| yaml_free(token->data.alias.value); 597| 890| break; 598| | 599| 1.18k| case YAML_ANCHOR_TOKEN: ------------------ | Branch (599:9): [True: 1.18k, False: 48.2k] ------------------ 600| 1.18k| yaml_free(token->data.anchor.value); 601| 1.18k| break; 602| | 603| 2.48k| case YAML_TAG_TOKEN: ------------------ | Branch (603:9): [True: 2.48k, False: 47.0k] ------------------ 604| 2.48k| yaml_free(token->data.tag.handle); 605| 2.48k| yaml_free(token->data.tag.suffix); 606| 2.48k| break; 607| | 608| 7.24k| case YAML_SCALAR_TOKEN: ------------------ | Branch (608:9): [True: 7.24k, False: 42.2k] ------------------ 609| 7.24k| yaml_free(token->data.scalar.value); 610| 7.24k| break; 611| | 612| 37.6k| default: ------------------ | Branch (612:9): [True: 37.6k, False: 11.8k] ------------------ 613| 37.6k| break; 614| 49.4k| } 615| | 616| 49.4k| memset(token, 0, sizeof(yaml_token_t)); 617| 49.4k|} yaml_event_delete: 986| 8.81M|{ 987| 8.81M| yaml_tag_directive_t *tag_directive; 988| | 989| 8.81M| assert(event); /* Non-NULL event object expected. */ ------------------ | Branch (989:5): [True: 0, False: 8.81M] | Branch (989:5): [True: 8.81M, False: 0] ------------------ 990| | 991| 8.81M| switch (event->type) 992| 8.81M| { 993| 59.1k| case YAML_DOCUMENT_START_EVENT: ------------------ | Branch (993:9): [True: 59.1k, False: 8.75M] ------------------ 994| 59.1k| yaml_free(event->data.document_start.version_directive); 995| 59.1k| for (tag_directive = event->data.document_start.tag_directives.start; 996| 162k| tag_directive != event->data.document_start.tag_directives.end; ------------------ | Branch (996:21): [True: 103k, False: 59.1k] ------------------ 997| 103k| tag_directive++) { 998| 103k| yaml_free(tag_directive->handle); 999| 103k| yaml_free(tag_directive->prefix); 1000| 103k| } 1001| 59.1k| yaml_free(event->data.document_start.tag_directives.start); 1002| 59.1k| break; 1003| | 1004| 275k| case YAML_ALIAS_EVENT: ------------------ | Branch (1004:9): [True: 275k, False: 8.54M] ------------------ 1005| 275k| yaml_free(event->data.alias.anchor); 1006| 275k| break; 1007| | 1008| 3.82M| case YAML_SCALAR_EVENT: ------------------ | Branch (1008:9): [True: 3.82M, False: 4.99M] ------------------ 1009| 3.82M| yaml_free(event->data.scalar.anchor); 1010| 3.82M| yaml_free(event->data.scalar.tag); 1011| 3.82M| yaml_free(event->data.scalar.value); 1012| 3.82M| break; 1013| | 1014| 130k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1014:9): [True: 130k, False: 8.68M] ------------------ 1015| 130k| yaml_free(event->data.sequence_start.anchor); 1016| 130k| yaml_free(event->data.sequence_start.tag); 1017| 130k| break; 1018| | 1019| 2.16M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1019:9): [True: 2.16M, False: 6.65M] ------------------ 1020| 2.16M| yaml_free(event->data.mapping_start.anchor); 1021| 2.16M| yaml_free(event->data.mapping_start.tag); 1022| 2.16M| break; 1023| | 1024| 2.36M| default: ------------------ | Branch (1024:9): [True: 2.36M, False: 6.45M] ------------------ 1025| 2.36M| break; 1026| 8.81M| } 1027| | 1028| 8.81M| memset(event, 0, sizeof(yaml_event_t)); 1029| 8.81M|} yaml_document_delete: 1124| 6.13k|{ 1125| 6.13k| yaml_tag_directive_t *tag_directive; 1126| | 1127| 6.13k| assert(document); /* Non-NULL document object is expected. */ ------------------ | Branch (1127:5): [True: 0, False: 6.13k] | Branch (1127:5): [True: 6.13k, False: 0] ------------------ 1128| | 1129| 4.31M| while (!STACK_EMPTY(&context, document->nodes)) { ------------------ | | 436| 4.31M| ((stack).start == (stack).top) ------------------ | Branch (1129:12): [True: 4.31M, False: 6.13k] ------------------ 1130| 4.31M| yaml_node_t node = POP(&context, document->nodes); ------------------ | | 454| 4.31M| (*(--(stack).top)) ------------------ 1131| 4.31M| yaml_free(node.tag); 1132| 4.31M| switch (node.type) { 1133| 4.14M| case YAML_SCALAR_NODE: ------------------ | Branch (1133:13): [True: 4.14M, False: 170k] ------------------ 1134| 4.14M| yaml_free(node.data.scalar.value); 1135| 4.14M| break; 1136| 57.7k| case YAML_SEQUENCE_NODE: ------------------ | Branch (1136:13): [True: 57.7k, False: 4.25M] ------------------ 1137| 57.7k| STACK_DEL(&context, node.data.sequence.items); ------------------ | | 432| 57.7k| (yaml_free((stack).start), \ | | 433| 57.7k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1138| 57.7k| break; 1139| 112k| case YAML_MAPPING_NODE: ------------------ | Branch (1139:13): [True: 112k, False: 4.20M] ------------------ 1140| 112k| STACK_DEL(&context, node.data.mapping.pairs); ------------------ | | 432| 112k| (yaml_free((stack).start), \ | | 433| 112k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1141| 112k| break; 1142| 0| default: ------------------ | Branch (1142:13): [True: 0, False: 4.31M] ------------------ 1143| 0| assert(0); /* Should not happen. */ ------------------ | Branch (1143:17): [Folded, False: 0] | Branch (1143:17): [Folded, False: 0] ------------------ 1144| 4.31M| } 1145| 4.31M| } 1146| 6.13k| STACK_DEL(&context, document->nodes); ------------------ | | 432| 6.13k| (yaml_free((stack).start), \ | | 433| 6.13k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1147| | 1148| 6.13k| yaml_free(document->version_directive); 1149| 6.13k| for (tag_directive = document->tag_directives.start; 1150| 6.37k| tag_directive != document->tag_directives.end; ------------------ | Branch (1150:13): [True: 243, False: 6.13k] ------------------ 1151| 6.13k| tag_directive++) { 1152| 243| yaml_free(tag_directive->handle); 1153| 243| yaml_free(tag_directive->prefix); 1154| 243| } 1155| 6.13k| yaml_free(document->tag_directives.start); 1156| | 1157| 6.13k| memset(document, 0, sizeof(yaml_document_t)); 1158| 6.13k|} yaml_document_get_root_node: 1181| 60.9k|{ 1182| 60.9k| assert(document); /* Non-NULL document object is expected. */ ------------------ | Branch (1182:5): [True: 0, False: 60.9k] | Branch (1182:5): [True: 60.9k, False: 0] ------------------ 1183| | 1184| 60.9k| if (document->nodes.top != document->nodes.start) { ------------------ | Branch (1184:9): [True: 59.1k, False: 1.71k] ------------------ 1185| 59.1k| return document->nodes.start; 1186| 59.1k| } 1187| 1.71k| return NULL; 1188| 60.9k|} api.c:yaml_string_read_handler: 251| 30.7k|{ 252| 30.7k| yaml_parser_t *parser = (yaml_parser_t *)data; 253| | 254| 30.7k| if (parser->input.string.current == parser->input.string.end) { ------------------ | Branch (254:9): [True: 10.6k, False: 20.0k] ------------------ 255| 10.6k| *size_read = 0; 256| 10.6k| return 1; 257| 10.6k| } 258| | 259| 20.0k| if (size > (size_t)(parser->input.string.end ------------------ | Branch (259:9): [True: 11.1k, False: 8.90k] ------------------ 260| 20.0k| - parser->input.string.current)) { 261| 11.1k| size = parser->input.string.end - parser->input.string.current; 262| 11.1k| } 263| | 264| 20.0k| memcpy(buffer, parser->input.string.current, size); 265| 20.0k| parser->input.string.current += size; 266| 20.0k| *size_read = size; 267| 20.0k| return 1; 268| 30.7k|} yaml_emitter_open: 63| 7.18k|{ 64| 7.18k| yaml_event_t event; 65| 7.18k| yaml_mark_t mark = { 0, 0, 0 }; 66| | 67| 7.18k| assert(emitter); /* Non-NULL emitter object is required. */ ------------------ | Branch (67:5): [True: 0, False: 7.18k] | Branch (67:5): [True: 7.18k, False: 0] ------------------ 68| 7.18k| assert(!emitter->opened); /* Emitter should not be opened yet. */ ------------------ | Branch (68:5): [True: 0, False: 7.18k] | Branch (68:5): [True: 7.18k, False: 0] ------------------ 69| | 70| 7.18k| STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark); ------------------ | | 552| 7.18k| (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 7.18k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 7.18k| (event).type = (event_type), \ | | | | 548| 7.18k| (event).start_mark = (event_start_mark), \ | | | | 549| 7.18k| (event).end_mark = (event_end_mark)) | | ------------------ | | 553| 7.18k| (event).data.stream_start.encoding = (event_encoding)) ------------------ 71| | 72| 7.18k| if (!yaml_emitter_emit(emitter, &event)) { ------------------ | Branch (72:9): [True: 0, False: 7.18k] ------------------ 73| 0| return 0; 74| 0| } 75| | 76| 7.18k| emitter->opened = 1; 77| | 78| 7.18k| return 1; 79| 7.18k|} yaml_emitter_close: 87| 1.71k|{ 88| 1.71k| yaml_event_t event; 89| 1.71k| yaml_mark_t mark = { 0, 0, 0 }; 90| | 91| 1.71k| assert(emitter); /* Non-NULL emitter object is required. */ ------------------ | Branch (91:5): [True: 0, False: 1.71k] | Branch (91:5): [True: 1.71k, False: 0] ------------------ 92| 1.71k| assert(emitter->opened); /* Emitter should be opened. */ ------------------ | Branch (92:5): [True: 0, False: 1.71k] | Branch (92:5): [True: 1.71k, False: 0] ------------------ 93| | 94| 1.71k| if (emitter->closed) return 1; ------------------ | Branch (94:9): [True: 0, False: 1.71k] ------------------ 95| | 96| 1.71k| STREAM_END_EVENT_INIT(event, mark, mark); ------------------ | | 556| 1.71k| (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 1.71k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 1.71k| (event).type = (event_type), \ | | | | 548| 1.71k| (event).start_mark = (event_start_mark), \ | | | | 549| 1.71k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 97| | 98| 1.71k| if (!yaml_emitter_emit(emitter, &event)) { ------------------ | Branch (98:9): [True: 0, False: 1.71k] ------------------ 99| 0| return 0; 100| 0| } 101| | 102| 1.71k| emitter->closed = 1; 103| | 104| 1.71k| return 1; 105| 1.71k|} yaml_emitter_dump: 113| 60.9k|{ 114| 60.9k| yaml_event_t event; 115| 60.9k| yaml_mark_t mark = { 0, 0, 0 }; 116| | 117| 60.9k| assert(emitter); /* Non-NULL emitter object is required. */ ------------------ | Branch (117:5): [True: 0, False: 60.9k] | Branch (117:5): [True: 60.9k, False: 0] ------------------ 118| 60.9k| assert(document); /* Non-NULL emitter object is expected. */ ------------------ | Branch (118:5): [True: 0, False: 60.9k] | Branch (118:5): [True: 60.9k, False: 0] ------------------ 119| | 120| 60.9k| emitter->document = document; 121| | 122| 60.9k| if (!emitter->opened) { ------------------ | Branch (122:9): [True: 7.18k, False: 53.7k] ------------------ 123| 7.18k| if (!yaml_emitter_open(emitter)) goto error; ------------------ | Branch (123:13): [True: 0, False: 7.18k] ------------------ 124| 7.18k| } 125| | 126| 60.9k| if (STACK_EMPTY(emitter, document->nodes)) { ------------------ | | 436| 60.9k| ((stack).start == (stack).top) | | ------------------ | | | Branch (436:5): [True: 1.71k, False: 59.1k] | | ------------------ ------------------ 127| 1.71k| if (!yaml_emitter_close(emitter)) goto error; ------------------ | Branch (127:13): [True: 0, False: 1.71k] ------------------ 128| 1.71k| yaml_emitter_delete_document_and_anchors(emitter); 129| 1.71k| return 1; 130| 1.71k| } 131| | 132| 60.9k| assert(emitter->opened); /* Emitter should be opened. */ ------------------ | Branch (132:5): [True: 0, False: 59.1k] | Branch (132:5): [True: 59.1k, False: 0] ------------------ 133| | 134| 59.1k| emitter->anchors = (yaml_anchors_t*)yaml_malloc(sizeof(*(emitter->anchors)) 135| 59.1k| * (document->nodes.top - document->nodes.start)); 136| 59.1k| if (!emitter->anchors) goto error; ------------------ | Branch (136:9): [True: 0, False: 59.1k] ------------------ 137| 59.1k| memset(emitter->anchors, 0, sizeof(*(emitter->anchors)) 138| 59.1k| * (document->nodes.top - document->nodes.start)); 139| | 140| 59.1k| DOCUMENT_START_EVENT_INIT(event, document->version_directive, ------------------ | | 560| 59.1k| (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 59.1k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 59.1k| (event).type = (event_type), \ | | | | 548| 59.1k| (event).start_mark = (event_start_mark), \ | | | | 549| 59.1k| (event).end_mark = (event_end_mark)) | | ------------------ | | 561| 59.1k| (event).data.document_start.version_directive = (event_version_directive), \ | | 562| 59.1k| (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ | | 563| 59.1k| (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ | | 564| 59.1k| (event).data.document_start.implicit = (event_implicit)) ------------------ 141| 59.1k| document->tag_directives.start, document->tag_directives.end, 142| 59.1k| document->start_implicit, mark, mark); 143| 59.1k| if (!yaml_emitter_emit(emitter, &event)) goto error; ------------------ | Branch (143:9): [True: 0, False: 59.1k] ------------------ 144| | 145| 59.1k| yaml_emitter_anchor_node(emitter, 1); 146| 59.1k| if (!yaml_emitter_dump_node(emitter, 1)) goto error; ------------------ | Branch (146:9): [True: 49, False: 59.1k] ------------------ 147| | 148| 59.1k| DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark); ------------------ | | 567| 59.1k| (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 59.1k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 59.1k| (event).type = (event_type), \ | | | | 548| 59.1k| (event).start_mark = (event_start_mark), \ | | | | 549| 59.1k| (event).end_mark = (event_end_mark)) | | ------------------ | | 568| 59.1k| (event).data.document_end.implicit = (event_implicit)) ------------------ 149| 59.1k| if (!yaml_emitter_emit(emitter, &event)) goto error; ------------------ | Branch (149:9): [True: 5.04k, False: 54.0k] ------------------ 150| | 151| 54.0k| yaml_emitter_delete_document_and_anchors(emitter); 152| | 153| 54.0k| return 1; 154| | 155| 5.09k|error: 156| | 157| 5.09k| yaml_emitter_delete_document_and_anchors(emitter); 158| | 159| 5.09k| return 0; 160| 59.1k|} dumper.c:yaml_emitter_delete_document_and_anchors: 168| 60.9k|{ 169| 60.9k| int index; 170| | 171| 60.9k| if (!emitter->anchors) { ------------------ | Branch (171:9): [True: 1.71k, False: 59.1k] ------------------ 172| 1.71k| yaml_document_delete(emitter->document); 173| 1.71k| emitter->document = NULL; 174| 1.71k| return; 175| 1.71k| } 176| | 177| 6.17M| for (index = 0; emitter->document->nodes.start + index ------------------ | Branch (177:21): [True: 6.11M, False: 59.1k] ------------------ 178| 6.17M| < emitter->document->nodes.top; index ++) { 179| 6.11M| yaml_node_t node = emitter->document->nodes.start[index]; 180| 6.11M| if (!emitter->anchors[index].serialized) { ------------------ | Branch (180:13): [True: 1.08k, False: 6.11M] ------------------ 181| 1.08k| yaml_free(node.tag); 182| 1.08k| if (node.type == YAML_SCALAR_NODE) { ------------------ | Branch (182:17): [True: 663, False: 420] ------------------ 183| 663| yaml_free(node.data.scalar.value); 184| 663| } 185| 1.08k| } 186| 6.11M| if (node.type == YAML_SEQUENCE_NODE) { ------------------ | Branch (186:13): [True: 130k, False: 5.98M] ------------------ 187| 130k| STACK_DEL(emitter, node.data.sequence.items); ------------------ | | 432| 130k| (yaml_free((stack).start), \ | | 433| 130k| (stack).start = (stack).top = (stack).end = 0) ------------------ 188| 130k| } 189| 6.11M| if (node.type == YAML_MAPPING_NODE) { ------------------ | Branch (189:13): [True: 2.16M, False: 3.95M] ------------------ 190| 2.16M| STACK_DEL(emitter, node.data.mapping.pairs); ------------------ | | 432| 2.16M| (yaml_free((stack).start), \ | | 433| 2.16M| (stack).start = (stack).top = (stack).end = 0) ------------------ 191| 2.16M| } 192| 6.11M| } 193| | 194| 59.1k| STACK_DEL(emitter, emitter->document->nodes); ------------------ | | 432| 59.1k| (yaml_free((stack).start), \ | | 433| 59.1k| (stack).start = (stack).top = (stack).end = 0) ------------------ 195| 59.1k| yaml_free(emitter->anchors); 196| | 197| 59.1k| emitter->anchors = NULL; 198| 59.1k| emitter->last_anchor_id = 0; 199| | emitter->document = NULL; 200| 59.1k|} dumper.c:yaml_emitter_anchor_node: 208| 6.39M|{ 209| 6.39M| yaml_node_t *node = emitter->document->nodes.start + index - 1; 210| 6.39M| yaml_node_item_t *item; 211| 6.39M| yaml_node_pair_t *pair; 212| | 213| 6.39M| emitter->anchors[index-1].references ++; 214| | 215| 6.39M| if (emitter->anchors[index-1].references == 1) { ------------------ | Branch (215:9): [True: 6.11M, False: 275k] ------------------ 216| 6.11M| switch (node->type) { 217| 130k| case YAML_SEQUENCE_NODE: ------------------ | Branch (217:13): [True: 130k, False: 5.98M] ------------------ 218| 130k| for (item = node->data.sequence.items.start; 219| 1.03M| item < node->data.sequence.items.top; item ++) { ------------------ | Branch (219:25): [True: 908k, False: 130k] ------------------ 220| 908k| yaml_emitter_anchor_node(emitter, *item); 221| 908k| } 222| 130k| break; 223| 2.16M| case YAML_MAPPING_NODE: ------------------ | Branch (223:13): [True: 2.16M, False: 3.95M] ------------------ 224| 2.16M| for (pair = node->data.mapping.pairs.start; 225| 4.87M| pair < node->data.mapping.pairs.top; pair ++) { ------------------ | Branch (225:25): [True: 2.71M, False: 2.16M] ------------------ 226| 2.71M| yaml_emitter_anchor_node(emitter, pair->key); 227| 2.71M| yaml_emitter_anchor_node(emitter, pair->value); 228| 2.71M| } 229| 2.16M| break; 230| 3.82M| default: ------------------ | Branch (230:13): [True: 3.82M, False: 2.29M] ------------------ 231| 3.82M| break; 232| 6.11M| } 233| 6.11M| } 234| | 235| 275k| else if (emitter->anchors[index-1].references == 2) { ------------------ | Branch (235:14): [True: 4.51k, False: 270k] ------------------ 236| 4.51k| emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id); 237| 4.51k| } 238| 6.39M|} dumper.c:yaml_emitter_dump_node: 265| 6.39M|{ 266| 6.39M| yaml_node_t *node = emitter->document->nodes.start + index - 1; 267| 6.39M| int anchor_id = emitter->anchors[index-1].anchor; 268| 6.39M| yaml_char_t *anchor = NULL; 269| | 270| 6.39M| if (anchor_id) { ------------------ | Branch (270:9): [True: 279k, False: 6.11M] ------------------ 271| 279k| anchor = yaml_emitter_generate_anchor(emitter, anchor_id); 272| 279k| if (!anchor) return 0; ------------------ | Branch (272:13): [True: 0, False: 279k] ------------------ 273| 279k| } 274| | 275| 6.39M| if (emitter->anchors[index-1].serialized) { ------------------ | Branch (275:9): [True: 275k, False: 6.11M] ------------------ 276| 275k| return yaml_emitter_dump_alias(emitter, anchor); 277| 275k| } 278| | 279| 6.11M| emitter->anchors[index-1].serialized = 1; 280| | 281| 6.11M| switch (node->type) { 282| 3.82M| case YAML_SCALAR_NODE: ------------------ | Branch (282:9): [True: 3.82M, False: 2.29M] ------------------ 283| 3.82M| return yaml_emitter_dump_scalar(emitter, node, anchor); 284| 130k| case YAML_SEQUENCE_NODE: ------------------ | Branch (284:9): [True: 130k, False: 5.98M] ------------------ 285| 130k| return yaml_emitter_dump_sequence(emitter, node, anchor); 286| 2.16M| case YAML_MAPPING_NODE: ------------------ | Branch (286:9): [True: 2.16M, False: 3.95M] ------------------ 287| 2.16M| return yaml_emitter_dump_mapping(emitter, node, anchor); 288| 0| default: ------------------ | Branch (288:9): [True: 0, False: 6.11M] ------------------ 289| 0| assert(0); /* Could not happen. */ ------------------ | Branch (289:13): [Folded, False: 0] | Branch (289:13): [Folded, False: 0] ------------------ 290| 0| break; 291| 6.11M| } 292| | 293| 0| return 0; /* Could not happen. */ 294| 6.11M|} dumper.c:yaml_emitter_generate_anchor: 249| 279k|{ 250| 279k| yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH); ------------------ | | 684| 279k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 251| | 252| 279k| if (!anchor) return NULL; ------------------ | Branch (252:9): [True: 0, False: 279k] ------------------ 253| | 254| 279k| sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id); ------------------ | | 244| 279k|#define ANCHOR_TEMPLATE "id%03d" ------------------ 255| | 256| 279k| return anchor; 257| 279k|} dumper.c:yaml_emitter_dump_alias: 302| 275k|{ 303| 275k| yaml_event_t event; 304| 275k| yaml_mark_t mark = { 0, 0, 0 }; 305| | 306| 275k| ALIAS_EVENT_INIT(event, anchor, mark, mark); ------------------ | | 571| 275k| (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 275k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 275k| (event).type = (event_type), \ | | | | 548| 275k| (event).start_mark = (event_start_mark), \ | | | | 549| 275k| (event).end_mark = (event_end_mark)) | | ------------------ | | 572| 275k| (event).data.alias.anchor = (event_anchor)) ------------------ 307| | 308| 275k| return yaml_emitter_emit(emitter, &event); 309| 275k|} dumper.c:yaml_emitter_dump_scalar: 318| 3.82M|{ 319| 3.82M| yaml_event_t event; 320| 3.82M| yaml_mark_t mark = { 0, 0, 0 }; 321| | 322| 3.82M| int plain_implicit = (strcmp((char *)node->tag, 323| 3.82M| YAML_DEFAULT_SCALAR_TAG) == 0); ------------------ | | 685| 3.82M|#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG | | ------------------ | | | | 671| 3.82M|#define YAML_STR_TAG "tag:yaml.org,2002:str" | | ------------------ ------------------ 324| 3.82M| int quoted_implicit = (strcmp((char *)node->tag, 325| 3.82M| YAML_DEFAULT_SCALAR_TAG) == 0); ------------------ | | 685| 3.82M|#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG | | ------------------ | | | | 671| 3.82M|#define YAML_STR_TAG "tag:yaml.org,2002:str" | | ------------------ ------------------ 326| | 327| 3.82M| SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value, ------------------ | | 576| 3.82M| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 3.82M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 3.82M| (event).type = (event_type), \ | | | | 548| 3.82M| (event).start_mark = (event_start_mark), \ | | | | 549| 3.82M| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 3.82M| (event).data.scalar.anchor = (event_anchor), \ | | 578| 3.82M| (event).data.scalar.tag = (event_tag), \ | | 579| 3.82M| (event).data.scalar.value = (event_value), \ | | 580| 3.82M| (event).data.scalar.length = (event_length), \ | | 581| 3.82M| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 3.82M| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 3.82M| (event).data.scalar.style = (event_style)) ------------------ 328| 3.82M| node->data.scalar.length, plain_implicit, quoted_implicit, 329| 3.82M| node->data.scalar.style, mark, mark); 330| | 331| 3.82M| return yaml_emitter_emit(emitter, &event); 332| 3.82M|} dumper.c:yaml_emitter_dump_sequence: 341| 130k|{ 342| 130k| yaml_event_t event; 343| 130k| yaml_mark_t mark = { 0, 0, 0 }; 344| | 345| 130k| int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0); ------------------ | | 687| 130k|#define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG | | ------------------ | | | | 680| 130k|#define YAML_SEQ_TAG "tag:yaml.org,2002:seq" | | ------------------ ------------------ 346| | 347| 130k| yaml_node_item_t *item; 348| | 349| 130k| SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit, ------------------ | | 587| 130k| (EVENT_INIT((event),YAML_SEQUENCE_START_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)) | | ------------------ | | 588| 130k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 130k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 130k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 130k| (event).data.sequence_start.style = (event_style)) ------------------ 350| 130k| node->data.sequence.style, mark, mark); 351| 130k| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (351:9): [True: 3, False: 130k] ------------------ 352| | 353| 130k| for (item = node->data.sequence.items.start; 354| 1.03M| item < node->data.sequence.items.top; item ++) { ------------------ | Branch (354:13): [True: 908k, False: 130k] ------------------ 355| 908k| if (!yaml_emitter_dump_node(emitter, *item)) return 0; ------------------ | Branch (355:13): [True: 272, False: 908k] ------------------ 356| 908k| } 357| | 358| 130k| SEQUENCE_END_EVENT_INIT(event, mark, mark); ------------------ | | 594| 130k| (EVENT_INIT((event),YAML_SEQUENCE_END_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)) | | ------------------ ------------------ 359| 130k| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (359:9): [True: 9, False: 130k] ------------------ 360| | 361| 130k| return 1; 362| 130k|} dumper.c:yaml_emitter_dump_mapping: 371| 2.16M|{ 372| 2.16M| yaml_event_t event; 373| 2.16M| yaml_mark_t mark = { 0, 0, 0 }; 374| | 375| 2.16M| int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0); ------------------ | | 689| 2.16M|#define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG | | ------------------ | | | | 682| 2.16M|#define YAML_MAP_TAG "tag:yaml.org,2002:map" | | ------------------ ------------------ 376| | 377| 2.16M| yaml_node_pair_t *pair; 378| | 379| 2.16M| MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit, ------------------ | | 598| 2.16M| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 2.16M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.16M| (event).type = (event_type), \ | | | | 548| 2.16M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.16M| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 2.16M| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 2.16M| (event).data.mapping_start.tag = (event_tag), \ | | 601| 2.16M| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 2.16M| (event).data.mapping_start.style = (event_style)) ------------------ 380| 2.16M| node->data.mapping.style, mark, mark); 381| 2.16M| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (381:9): [True: 8, False: 2.16M] ------------------ 382| | 383| 2.16M| for (pair = node->data.mapping.pairs.start; 384| 4.87M| pair < node->data.mapping.pairs.top; pair ++) { ------------------ | Branch (384:13): [True: 2.71M, False: 2.16M] ------------------ 385| 2.71M| if (!yaml_emitter_dump_node(emitter, pair->key)) return 0; ------------------ | Branch (385:13): [True: 211, False: 2.71M] ------------------ 386| 2.71M| if (!yaml_emitter_dump_node(emitter, pair->value)) return 0; ------------------ | Branch (386:13): [True: 66, False: 2.71M] ------------------ 387| 2.71M| } 388| | 389| 2.16M| MAPPING_END_EVENT_INIT(event, mark, mark); ------------------ | | 605| 2.16M| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 2.16M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.16M| (event).type = (event_type), \ | | | | 548| 2.16M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.16M| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 390| 2.16M| if (!yaml_emitter_emit(emitter, &event)) return 0; ------------------ | Branch (390:9): [True: 7, False: 2.16M] ------------------ 391| | 392| 2.16M| return 1; 393| 2.16M|} yaml_emitter_emit: 282| 8.81M|{ 283| 8.81M| if (!ENQUEUE(emitter, emitter->events, *event)) { ------------------ | | 472| 8.81M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 8.23M, False: 578k] | | ------------------ | | 473| 8.81M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 578k, False: 0] | | ------------------ | | 474| 578k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 8.81M| (*((queue).tail++) = value, \ | | 476| 8.81M| 1) : \ | | 477| 8.81M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (283:9): [True: 0, False: 8.81M] ------------------ 284| 0| yaml_event_delete(event); 285| 0| return 0; 286| 0| } 287| | 288| 17.6M| while (!yaml_emitter_need_more_events(emitter)) { ------------------ | Branch (288:12): [True: 8.81M, False: 8.81M] ------------------ 289| 8.81M| if (!yaml_emitter_analyze_event(emitter, emitter->events.head)) ------------------ | Branch (289:13): [True: 47, False: 8.81M] ------------------ 290| 47| return 0; 291| 8.81M| if (!yaml_emitter_state_machine(emitter, emitter->events.head)) ------------------ | Branch (291:13): [True: 5.05k, False: 8.81M] ------------------ 292| 5.05k| return 0; 293| 8.81M| yaml_event_delete(&DEQUEUE(emitter, emitter->events)); ------------------ | | 481| 8.81M| (*((queue).head++)) ------------------ 294| 8.81M| } 295| | 296| 8.81M| return 1; 297| 8.81M|} emitter.c:yaml_emitter_need_more_events: 310| 17.6M|{ 311| 17.6M| int level = 0; 312| 17.6M| int accumulate = 0; 313| 17.6M| yaml_event_t *event; 314| | 315| 17.6M| if (QUEUE_EMPTY(emitter, emitter->events)) ------------------ | | 469| 17.6M| ((queue).head == (queue).tail) | | ------------------ | | | Branch (469:5): [True: 4.64M, False: 12.9M] | | ------------------ ------------------ 316| 4.64M| return 1; 317| | 318| 12.9M| switch (emitter->events.head->type) { 319| 118k| case YAML_DOCUMENT_START_EVENT: ------------------ | Branch (319:9): [True: 118k, False: 12.8M] ------------------ 320| 118k| accumulate = 1; 321| 118k| break; 322| 303k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (322:9): [True: 303k, False: 12.6M] ------------------ 323| 303k| accumulate = 2; 324| 303k| break; 325| 6.10M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (325:9): [True: 6.10M, False: 6.88M] ------------------ 326| 6.10M| accumulate = 3; 327| 6.10M| break; 328| 6.46M| default: ------------------ | Branch (328:9): [True: 6.46M, False: 6.52M] ------------------ 329| 6.46M| return 0; 330| 12.9M| } 331| | 332| 6.52M| if (emitter->events.tail - emitter->events.head > accumulate) ------------------ | Branch (332:9): [True: 2.35M, False: 4.16M] ------------------ 333| 2.35M| return 0; 334| | 335| 13.7M| for (event = emitter->events.head; event != emitter->events.tail; event ++) { ------------------ | Branch (335:40): [True: 9.53M, False: 4.16M] ------------------ 336| 9.53M| switch (event->type) { 337| 0| case YAML_STREAM_START_EVENT: ------------------ | Branch (337:13): [True: 0, False: 9.53M] ------------------ 338| 59.1k| case YAML_DOCUMENT_START_EVENT: ------------------ | Branch (338:13): [True: 59.1k, False: 9.47M] ------------------ 339| 319k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (339:13): [True: 260k, False: 9.27M] ------------------ 340| 6.81M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (340:13): [True: 6.49M, False: 3.03M] ------------------ 341| 6.81M| level += 1; 342| 6.81M| break; 343| 0| case YAML_STREAM_END_EVENT: ------------------ | Branch (343:13): [True: 0, False: 9.53M] ------------------ 344| 0| case YAML_DOCUMENT_END_EVENT: ------------------ | Branch (344:13): [True: 0, False: 9.53M] ------------------ 345| 683| case YAML_SEQUENCE_END_EVENT: ------------------ | Branch (345:13): [True: 683, False: 9.53M] ------------------ 346| 1.57k| case YAML_MAPPING_END_EVENT: ------------------ | Branch (346:13): [True: 889, False: 9.53M] ------------------ 347| 1.57k| level -= 1; 348| 1.57k| break; 349| 2.71M| default: ------------------ | Branch (349:13): [True: 2.71M, False: 6.81M] ------------------ 350| 2.71M| break; 351| 9.53M| } 352| 9.53M| if (!level) ------------------ | Branch (352:13): [True: 1.22k, False: 9.53M] ------------------ 353| 1.22k| return 0; 354| 9.53M| } 355| | 356| 4.16M| return 1; 357| 4.16M|} emitter.c:yaml_emitter_state_machine: 425| 8.81M|{ 426| 8.81M| switch (emitter->state) 427| 8.81M| { 428| 7.18k| case YAML_EMIT_STREAM_START_STATE: ------------------ | Branch (428:9): [True: 7.18k, False: 8.80M] ------------------ 429| 7.18k| return yaml_emitter_emit_stream_start(emitter, event); 430| | 431| 7.18k| case YAML_EMIT_FIRST_DOCUMENT_START_STATE: ------------------ | Branch (431:9): [True: 7.18k, False: 8.80M] ------------------ 432| 7.18k| return yaml_emitter_emit_document_start(emitter, event, 1); 433| | 434| 53.7k| case YAML_EMIT_DOCUMENT_START_STATE: ------------------ | Branch (434:9): [True: 53.7k, False: 8.76M] ------------------ 435| 53.7k| return yaml_emitter_emit_document_start(emitter, event, 0); 436| | 437| 59.1k| case YAML_EMIT_DOCUMENT_CONTENT_STATE: ------------------ | Branch (437:9): [True: 59.1k, False: 8.75M] ------------------ 438| 59.1k| return yaml_emitter_emit_document_content(emitter, event); 439| | 440| 59.1k| case YAML_EMIT_DOCUMENT_END_STATE: ------------------ | Branch (440:9): [True: 59.1k, False: 8.75M] ------------------ 441| 59.1k| return yaml_emitter_emit_document_end(emitter, event); 442| | 443| 99.8k| case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE: ------------------ | Branch (443:9): [True: 99.8k, False: 8.71M] ------------------ 444| 99.8k| return yaml_emitter_emit_flow_sequence_item(emitter, event, 1); 445| | 446| 759k| case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE: ------------------ | Branch (446:9): [True: 759k, False: 8.05M] ------------------ 447| 759k| return yaml_emitter_emit_flow_sequence_item(emitter, event, 0); 448| | 449| 1.57M| case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (449:9): [True: 1.57M, False: 7.23M] ------------------ 450| 1.57M| return yaml_emitter_emit_flow_mapping_key(emitter, event, 1); 451| | 452| 2.05M| case YAML_EMIT_FLOW_MAPPING_KEY_STATE: ------------------ | Branch (452:9): [True: 2.05M, False: 6.76M] ------------------ 453| 2.05M| return yaml_emitter_emit_flow_mapping_key(emitter, event, 0); 454| | 455| 348k| case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE: ------------------ | Branch (455:9): [True: 348k, False: 8.46M] ------------------ 456| 348k| return yaml_emitter_emit_flow_mapping_value(emitter, event, 1); 457| | 458| 1.70M| case YAML_EMIT_FLOW_MAPPING_VALUE_STATE: ------------------ | Branch (458:9): [True: 1.70M, False: 7.10M] ------------------ 459| 1.70M| return yaml_emitter_emit_flow_mapping_value(emitter, event, 0); 460| | 461| 30.4k| case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE: ------------------ | Branch (461:9): [True: 30.4k, False: 8.78M] ------------------ 462| 30.4k| return yaml_emitter_emit_block_sequence_item(emitter, event, 1); 463| | 464| 148k| case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE: ------------------ | Branch (464:9): [True: 148k, False: 8.66M] ------------------ 465| 148k| return yaml_emitter_emit_block_sequence_item(emitter, event, 0); 466| | 467| 586k| case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (467:9): [True: 586k, False: 8.23M] ------------------ 468| 586k| return yaml_emitter_emit_block_mapping_key(emitter, event, 1); 469| | 470| 657k| case YAML_EMIT_BLOCK_MAPPING_KEY_STATE: ------------------ | Branch (470:9): [True: 657k, False: 8.15M] ------------------ 471| 657k| return yaml_emitter_emit_block_mapping_key(emitter, event, 0); 472| | 473| 201k| case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE: ------------------ | Branch (473:9): [True: 201k, False: 8.61M] ------------------ 474| 201k| return yaml_emitter_emit_block_mapping_value(emitter, event, 1); 475| | 476| 455k| case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE: ------------------ | Branch (476:9): [True: 455k, False: 8.36M] ------------------ 477| 455k| 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.81M] ------------------ 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.81M] ------------------ 484| 0| assert(1); /* Invalid state. */ ------------------ | Branch (484:13): [True: 0, Folded] | Branch (484:13): [True: 0, Folded] ------------------ 485| 8.81M| } 486| | 487| 0| return 0; 488| 8.81M|} emitter.c:yaml_emitter_emit_stream_start: 497| 7.18k|{ 498| 7.18k| emitter->open_ended = 0; 499| 7.18k| if (event->type == YAML_STREAM_START_EVENT) ------------------ | Branch (499:9): [True: 7.18k, False: 0] ------------------ 500| 7.18k| { 501| 7.18k| if (!emitter->encoding) { ------------------ | Branch (501:13): [True: 7.18k, False: 0] ------------------ 502| 7.18k| emitter->encoding = event->data.stream_start.encoding; 503| 7.18k| } 504| | 505| 7.18k| if (!emitter->encoding) { ------------------ | Branch (505:13): [True: 7.18k, False: 0] ------------------ 506| 7.18k| emitter->encoding = YAML_UTF8_ENCODING; 507| 7.18k| } 508| | 509| 7.18k| if (emitter->best_indent < 2 || emitter->best_indent > 9) { ------------------ | Branch (509:13): [True: 7.18k, False: 0] | Branch (509:41): [True: 0, False: 0] ------------------ 510| 7.18k| emitter->best_indent = 2; 511| 7.18k| } 512| | 513| 7.18k| if (emitter->best_width >= 0 ------------------ | Branch (513:13): [True: 7.18k, False: 0] ------------------ 514| 7.18k| && emitter->best_width <= emitter->best_indent*2) { ------------------ | Branch (514:20): [True: 7.18k, False: 0] ------------------ 515| 7.18k| emitter->best_width = 80; 516| 7.18k| } 517| | 518| 7.18k| if (emitter->best_width < 0) { ------------------ | Branch (518:13): [True: 0, False: 7.18k] ------------------ 519| 0| emitter->best_width = INT_MAX; 520| 0| } 521| | 522| 7.18k| if (!emitter->line_break) { ------------------ | Branch (522:13): [True: 7.18k, False: 0] ------------------ 523| 7.18k| emitter->line_break = YAML_LN_BREAK; 524| 7.18k| } 525| | 526| 7.18k| emitter->indent = -1; 527| | 528| 7.18k| emitter->line = 0; 529| 7.18k| emitter->column = 0; 530| 7.18k| emitter->whitespace = 1; 531| 7.18k| emitter->indention = 1; 532| | 533| 7.18k| if (emitter->encoding != YAML_UTF8_ENCODING) { ------------------ | Branch (533:13): [True: 0, False: 7.18k] ------------------ 534| 0| if (!yaml_emitter_write_bom(emitter)) ------------------ | Branch (534:17): [True: 0, False: 0] ------------------ 535| 0| return 0; 536| 0| } 537| | 538| 7.18k| emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE; 539| | 540| 7.18k| return 1; 541| 7.18k| } 542| | 543| 0| return yaml_emitter_set_emitter_error(emitter, 544| 0| "expected STREAM-START"); 545| 7.18k|} emitter.c:yaml_emitter_emit_document_start: 554| 60.9k|{ 555| 60.9k| if (event->type == YAML_DOCUMENT_START_EVENT) ------------------ | Branch (555:9): [True: 59.1k, False: 1.71k] ------------------ 556| 59.1k| { 557| 59.1k| yaml_tag_directive_t default_tag_directives[] = { 558| 59.1k| {(yaml_char_t *)"!", (yaml_char_t *)"!"}, 559| 59.1k| {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, 560| 59.1k| {NULL, NULL} 561| 59.1k| }; 562| 59.1k| yaml_tag_directive_t *tag_directive; 563| 59.1k| int implicit; 564| | 565| 59.1k| if (event->data.document_start.version_directive) { ------------------ | Branch (565:13): [True: 8.23k, False: 50.9k] ------------------ 566| 8.23k| if (!yaml_emitter_analyze_version_directive(emitter, ------------------ | Branch (566:17): [True: 0, False: 8.23k] ------------------ 567| 8.23k| *event->data.document_start.version_directive)) 568| 0| return 0; 569| 8.23k| } 570| | 571| 59.1k| for (tag_directive = event->data.document_start.tag_directives.start; 572| 162k| tag_directive != event->data.document_start.tag_directives.end; ------------------ | Branch (572:17): [True: 103k, False: 59.1k] ------------------ 573| 103k| tag_directive ++) { 574| 103k| if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive)) ------------------ | Branch (574:17): [True: 2, False: 103k] ------------------ 575| 2| return 0; 576| 103k| if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0)) ------------------ | Branch (576:17): [True: 0, False: 103k] ------------------ 577| 0| return 0; 578| 103k| } 579| | 580| 59.1k| for (tag_directive = default_tag_directives; 581| 177k| tag_directive->handle; tag_directive ++) { ------------------ | Branch (581:17): [True: 118k, False: 59.1k] ------------------ 582| 118k| if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1)) ------------------ | Branch (582:17): [True: 0, False: 118k] ------------------ 583| 0| return 0; 584| 118k| } 585| | 586| 59.1k| implicit = event->data.document_start.implicit; 587| 59.1k| if (!first || emitter->canonical) { ------------------ | Branch (587:13): [True: 52.1k, False: 6.99k] | Branch (587:23): [True: 3.05k, False: 3.94k] ------------------ 588| 55.2k| implicit = 0; 589| 55.2k| } 590| | 591| 59.1k| if ((event->data.document_start.version_directive || ------------------ | Branch (591:14): [True: 8.23k, False: 50.9k] ------------------ 592| 50.9k| (event->data.document_start.tag_directives.start ------------------ | Branch (592:21): [True: 13.7k, False: 37.1k] ------------------ 593| 50.9k| != event->data.document_start.tag_directives.end)) && 594| 21.9k| emitter->open_ended) ------------------ | Branch (594:17): [True: 21.2k, False: 719] ------------------ 595| 21.2k| { 596| 21.2k| if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) ------------------ | Branch (596:17): [True: 0, False: 21.2k] ------------------ 597| 0| return 0; 598| 21.2k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (598:17): [True: 0, False: 21.2k] ------------------ 599| 0| return 0; 600| 21.2k| } 601| 59.1k| emitter->open_ended = 0; 602| | 603| 59.1k| if (event->data.document_start.version_directive) { ------------------ | Branch (603:13): [True: 8.23k, False: 50.9k] ------------------ 604| 8.23k| implicit = 0; 605| 8.23k| if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0)) ------------------ | Branch (605:17): [True: 0, False: 8.23k] ------------------ 606| 0| return 0; 607| 8.23k| if (event->data.document_start.version_directive->minor == 1) { ------------------ | Branch (607:17): [True: 4.83k, False: 3.39k] ------------------ 608| 4.83k| if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0)) ------------------ | Branch (608:21): [True: 0, False: 4.83k] ------------------ 609| 0| return 0; 610| 4.83k| } 611| 3.39k| else { 612| 3.39k| if (!yaml_emitter_write_indicator(emitter, "1.2", 1, 0, 0)) ------------------ | Branch (612:21): [True: 0, False: 3.39k] ------------------ 613| 0| return 0; 614| 3.39k| } 615| 8.23k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (615:17): [True: 0, False: 8.23k] ------------------ 616| 0| return 0; 617| 8.23k| } 618| | 619| 59.1k| if (event->data.document_start.tag_directives.start ------------------ | Branch (619:13): [True: 13.7k, False: 45.4k] ------------------ 620| 59.1k| != event->data.document_start.tag_directives.end) { 621| 13.7k| implicit = 0; 622| 13.7k| for (tag_directive = event->data.document_start.tag_directives.start; 623| 117k| tag_directive != event->data.document_start.tag_directives.end; ------------------ | Branch (623:21): [True: 103k, False: 13.7k] ------------------ 624| 103k| tag_directive ++) { 625| 103k| if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0)) ------------------ | Branch (625:21): [True: 0, False: 103k] ------------------ 626| 0| return 0; 627| 103k| if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle, ------------------ | Branch (627:21): [True: 0, False: 103k] ------------------ 628| 103k| strlen((char *)tag_directive->handle))) 629| 0| return 0; 630| 103k| if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix, ------------------ | Branch (630:21): [True: 0, False: 103k] ------------------ 631| 103k| strlen((char *)tag_directive->prefix), 1)) 632| 0| return 0; 633| 103k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (633:21): [True: 0, False: 103k] ------------------ 634| 0| return 0; 635| 103k| } 636| 13.7k| } 637| | 638| 59.1k| if (yaml_emitter_check_empty_document(emitter)) { ------------------ | Branch (638:13): [True: 0, False: 59.1k] ------------------ 639| 0| implicit = 0; 640| 0| } 641| | 642| 59.1k| if (!implicit) { ------------------ | Branch (642:13): [True: 55.3k, False: 3.88k] ------------------ 643| 55.3k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (643:17): [True: 0, False: 55.3k] ------------------ 644| 0| return 0; 645| 55.3k| if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0)) ------------------ | Branch (645:17): [True: 0, False: 55.3k] ------------------ 646| 0| return 0; 647| 55.3k| if (emitter->canonical) { ------------------ | Branch (647:17): [True: 30.5k, False: 24.7k] ------------------ 648| 30.5k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (648:21): [True: 0, False: 30.5k] ------------------ 649| 0| return 0; 650| 30.5k| } 651| 55.3k| } 652| | 653| 59.1k| emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE; 654| | 655| 59.1k| emitter->open_ended = 0; 656| 59.1k| return 1; 657| 59.1k| } 658| | 659| 1.71k| else if (event->type == YAML_STREAM_END_EVENT) ------------------ | Branch (659:14): [True: 1.71k, False: 0] ------------------ 660| 1.71k| { 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.71k| if (emitter->open_ended == 2) ------------------ | Branch (666:13): [True: 41, False: 1.67k] ------------------ 667| 41| { 668| 41| if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) ------------------ | Branch (668:17): [True: 0, False: 41] ------------------ 669| 0| return 0; 670| 41| emitter->open_ended = 0; 671| 41| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (671:17): [True: 0, False: 41] ------------------ 672| 0| return 0; 673| 41| } 674| 1.71k| if (!yaml_emitter_flush(emitter)) ------------------ | Branch (674:13): [True: 0, False: 1.71k] ------------------ 675| 0| return 0; 676| | 677| 1.71k| emitter->state = YAML_EMIT_END_STATE; 678| | 679| 1.71k| return 1; 680| 1.71k| } 681| | 682| 0| return yaml_emitter_set_emitter_error(emitter, 683| 0| "expected DOCUMENT-START or STREAM-END"); 684| 60.9k|} emitter.c:yaml_emitter_analyze_version_directive: 1354| 8.23k|{ 1355| 8.23k| if (version_directive.major != 1 || ( ------------------ | Branch (1355:9): [True: 0, False: 8.23k] ------------------ 1356| 8.23k| version_directive.minor != 1 ------------------ | Branch (1356:9): [True: 3.39k, False: 4.83k] ------------------ 1357| 3.39k| && version_directive.minor != 2 ------------------ | Branch (1357:12): [True: 0, False: 3.39k] ------------------ 1358| 8.23k| )) { 1359| 0| return yaml_emitter_set_emitter_error(emitter, 1360| 0| "incompatible %YAML directive"); 1361| 0| } 1362| | 1363| 8.23k| return 1; 1364| 8.23k|} emitter.c:yaml_emitter_analyze_tag_directive: 1373| 103k|{ 1374| 103k| yaml_string_t handle; 1375| 103k| yaml_string_t prefix; 1376| 103k| size_t handle_length; 1377| 103k| size_t prefix_length; 1378| | 1379| 103k| handle_length = strlen((char *)tag_directive.handle); 1380| 103k| prefix_length = strlen((char *)tag_directive.prefix); 1381| 103k| STRING_ASSIGN(handle, tag_directive.handle, handle_length); ------------------ | | 128| 103k| ((value).start = (string), \ | | 129| 103k| (value).end = (string)+(length), \ | | 130| 103k| (value).pointer = (string)) ------------------ 1382| 103k| STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length); ------------------ | | 128| 103k| ((value).start = (string), \ | | 129| 103k| (value).end = (string)+(length), \ | | 130| 103k| (value).pointer = (string)) ------------------ 1383| | 1384| 103k| if (handle.start == handle.end) { ------------------ | Branch (1384:9): [True: 0, False: 103k] ------------------ 1385| 0| return yaml_emitter_set_emitter_error(emitter, 1386| 0| "tag handle must not be empty"); 1387| 0| } 1388| | 1389| 103k| if (handle.start[0] != '!') { ------------------ | Branch (1389:9): [True: 0, False: 103k] ------------------ 1390| 0| return yaml_emitter_set_emitter_error(emitter, 1391| 0| "tag handle must start with '!'"); 1392| 0| } 1393| | 1394| 103k| if (handle.end[-1] != '!') { ------------------ | Branch (1394:9): [True: 0, False: 103k] ------------------ 1395| 0| return yaml_emitter_set_emitter_error(emitter, 1396| 0| "tag handle must end with '!'"); 1397| 0| } 1398| | 1399| 103k| handle.pointer ++; 1400| | 1401| 1.83M| while (handle.pointer < handle.end-1) { ------------------ | Branch (1401:12): [True: 1.72M, False: 103k] ------------------ 1402| 1.72M| if (!IS_ALPHA(handle)) { ------------------ | | 198| 1.72M|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 1.72M| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 1.72M, False: 3.94k] | | | | ------------------ | | | | 190| 1.72M| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 52.4k, False: 1.67M] | | | | ------------------ | | | | 191| 1.72M| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 1.67M, False: 3.94k] | | | | ------------------ | | | | 192| 1.67M| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 207k, False: 1.46M] | | | | ------------------ | | | | 193| 1.72M| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 1.44M, False: 26.0k] | | | | ------------------ | | | | 194| 1.46M| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 1.44M, False: 0] | | | | ------------------ | | | | 195| 1.72M| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 22.1k, False: 3.94k] | | | | ------------------ | | | | 196| 1.72M| (string).pointer[offset] == '-') | | | | ------------------ | | | | | Branch (196:7): [True: 3.94k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1403| 0| return yaml_emitter_set_emitter_error(emitter, 1404| 0| "tag handle must contain alphanumerical characters only"); 1405| 0| } 1406| 1.72M| MOVE(handle); ------------------ | | 391| 1.72M|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 1.72M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.72M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.72M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.72M| ((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| 1.72M| } 1408| | 1409| 103k| if (prefix.start == prefix.end) { ------------------ | Branch (1409:9): [True: 2, False: 103k] ------------------ 1410| 2| return yaml_emitter_set_emitter_error(emitter, 1411| 2| "tag prefix must not be empty"); 1412| 2| } 1413| | 1414| 103k| return 1; 1415| 103k|} emitter.c:yaml_emitter_append_tag_directive: 366| 221k|{ 367| 221k| yaml_tag_directive_t *tag_directive; 368| 221k| yaml_tag_directive_t copy = { NULL, NULL }; 369| | 370| 221k| for (tag_directive = emitter->tag_directives.start; 371| 1.03M| tag_directive != emitter->tag_directives.top; tag_directive ++) { ------------------ | Branch (371:13): [True: 829k, False: 203k] ------------------ 372| 829k| if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { ------------------ | Branch (372:13): [True: 18.5k, False: 810k] ------------------ 373| 18.5k| if (allow_duplicates) ------------------ | Branch (373:17): [True: 18.5k, False: 0] ------------------ 374| 18.5k| return 1; 375| 0| return yaml_emitter_set_emitter_error(emitter, 376| 0| "duplicate %TAG directive"); 377| 18.5k| } 378| 829k| } 379| | 380| 203k| copy.handle = yaml_strdup(value.handle); 381| 203k| copy.prefix = yaml_strdup(value.prefix); 382| 203k| if (!copy.handle || !copy.prefix) { ------------------ | Branch (382:9): [True: 0, False: 203k] | Branch (382:25): [True: 0, False: 203k] ------------------ 383| 0| emitter->error = YAML_MEMORY_ERROR; 384| 0| goto error; 385| 0| } 386| | 387| 203k| if (!PUSH(emitter, emitter->tag_directives, copy)) ------------------ | | 445| 203k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 203k, False: 46] | | ------------------ | | 446| 203k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 46, False: 0] | | ------------------ | | 447| 46| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 203k| (*((stack).top++) = value, \ | | 449| 203k| 1) : \ | | 450| 203k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (387:9): [True: 0, False: 203k] ------------------ 388| 0| goto error; 389| | 390| 203k| return 1; 391| | 392| 0|error: 393| 0| yaml_free(copy.handle); 394| 0| yaml_free(copy.prefix); 395| 0| return 0; 396| 203k|} emitter.c:yaml_emitter_write_indicator: 1811| 17.9M|{ 1812| 17.9M| size_t indicator_length; 1813| 17.9M| yaml_string_t string; 1814| | 1815| 17.9M| indicator_length = strlen(indicator); 1816| 17.9M| STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length); ------------------ | | 128| 17.9M| ((value).start = (string), \ | | 129| 17.9M| (value).end = (string)+(length), \ | | 130| 17.9M| (value).pointer = (string)) ------------------ 1817| | 1818| 17.9M| if (need_whitespace && !emitter->whitespace) { ------------------ | Branch (1818:9): [True: 9.76M, False: 8.17M] | Branch (1818:28): [True: 4.95M, False: 4.81M] ------------------ 1819| 4.95M| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 4.95M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 9.91M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 4.95M, False: 410] | | | | ------------------ | | | | 10| 9.91M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 410, False: 0] | | | | ------------------ | | ------------------ | | 18| 4.95M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 4.95M, False: 0] | | ------------------ | | 19| 4.95M| emitter->column++, \ | | 20| 4.95M| 1)) ------------------ 1820| 4.95M| } 1821| | 1822| 36.5M| while (string.pointer != string.end) { ------------------ | Branch (1822:12): [True: 18.6M, False: 17.9M] ------------------ 1823| 18.6M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 18.6M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 37.2M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 18.6M, False: 1.01k] | | | | ------------------ | | | | 10| 37.2M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1.01k, False: 0] | | | | ------------------ | | ------------------ | | 45| 18.6M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 18.6M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 18.6M, False: 0] | | | | ------------------ | | | | 399| 18.6M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 18.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) | | ------------------ | | | Branch (45:9): [True: 18.6M, False: 0] | | ------------------ | | 46| 18.6M| emitter->column ++, \ | | 47| 18.6M| 1)) ------------------ 1824| 18.6M| } 1825| | 1826| 17.9M| emitter->whitespace = is_whitespace; 1827| 17.9M| emitter->indention = (emitter->indention && is_indention); ------------------ | Branch (1827:27): [True: 6.49M, False: 11.4M] | Branch (1827:49): [True: 1.06M, False: 5.43M] ------------------ 1828| | 1829| 17.9M| return 1; 1830| 17.9M|} emitter.c:yaml_emitter_write_indent: 1789| 9.52M|{ 1790| 9.52M| int indent = (emitter->indent >= 0) ? emitter->indent : 0; ------------------ | Branch (1790:18): [True: 9.22M, False: 298k] ------------------ 1791| | 1792| 9.52M| if (!emitter->indention || emitter->column > indent ------------------ | Branch (1792:9): [True: 7.10M, False: 2.42M] | Branch (1792:32): [True: 1.73M, False: 693k] ------------------ 1793| 8.83M| || (emitter->column == indent && !emitter->whitespace)) { ------------------ | Branch (1793:17): [True: 68.4k, False: 624k] | Branch (1793:46): [True: 0, False: 68.4k] ------------------ 1794| 8.83M| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 8.83M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 17.6M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 8.83M, False: 655] | | | | ------------------ | | | | 10| 17.6M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 655, False: 0] | | | | ------------------ | | ------------------ | | 28| 8.83M| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 8.83M, False: 0] | | | Branch (28:11): [True: 0, False: 8.83M] | | ------------------ | | 29| 8.83M| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 8.83M| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 8.83M, False: 0] | | ------------------ | | 31| 8.83M| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 8.83M| 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.83M| emitter->column = 0, \ | | 36| 8.83M| emitter->line ++, \ | | 37| 8.83M| 1)) ------------------ 1795| 8.83M| } 1796| | 1797| 3.38G| while (emitter->column < indent) { ------------------ | Branch (1797:12): [True: 3.37G, False: 9.52M] ------------------ 1798| 3.37G| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 3.37G| (FLUSH(emitter) \ | | ------------------ | | | | 9| 6.74G| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.37G, False: 196k] | | | | ------------------ | | | | 10| 6.74G| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 196k, False: 0] | | | | ------------------ | | ------------------ | | 18| 3.37G| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 3.37G, False: 0] | | ------------------ | | 19| 3.37G| emitter->column++, \ | | 20| 3.37G| 1)) ------------------ 1799| 3.37G| } 1800| | 1801| 9.52M| emitter->whitespace = 1; 1802| 9.52M| emitter->indention = 1; 1803| | 1804| 9.52M| return 1; 1805| 9.52M|} emitter.c:yaml_emitter_write_tag_handle: 1852| 4.10M|{ 1853| 4.10M| yaml_string_t string; 1854| 4.10M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 4.10M| ((value).start = (string), \ | | 129| 4.10M| (value).end = (string)+(length), \ | | 130| 4.10M| (value).pointer = (string)) ------------------ 1855| | 1856| 4.10M| if (!emitter->whitespace) { ------------------ | Branch (1856:9): [True: 3.33M, False: 769k] ------------------ 1857| 3.33M| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 3.33M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 6.66M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.33M, False: 339] | | | | ------------------ | | | | 10| 6.66M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 339, False: 0] | | | | ------------------ | | ------------------ | | 18| 3.33M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 3.33M, False: 0] | | ------------------ | | 19| 3.33M| emitter->column++, \ | | 20| 3.33M| 1)) ------------------ 1858| 3.33M| } 1859| | 1860| 14.7M| while (string.pointer != string.end) { ------------------ | Branch (1860:12): [True: 10.6M, False: 4.10M] ------------------ 1861| 10.6M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 10.6M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 21.2M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 10.6M, False: 654] | | | | ------------------ | | | | 10| 21.2M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 654, False: 0] | | | | ------------------ | | ------------------ | | 45| 10.6M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 10.6M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 10.6M, False: 0] | | | | ------------------ | | | | 399| 10.6M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 10.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) | | ------------------ | | | Branch (45:9): [True: 10.6M, False: 0] | | ------------------ | | 46| 10.6M| emitter->column ++, \ | | 47| 10.6M| 1)) ------------------ 1862| 10.6M| } 1863| | 1864| 4.10M| emitter->whitespace = 0; 1865| 4.10M| emitter->indention = 0; 1866| | 1867| 4.10M| return 1; 1868| 4.10M|} emitter.c:yaml_emitter_write_tag_content: 1874| 4.26M|{ 1875| 4.26M| yaml_string_t string; 1876| 4.26M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 4.26M| ((value).start = (string), \ | | 129| 4.26M| (value).end = (string)+(length), \ | | 130| 4.26M| (value).pointer = (string)) ------------------ 1877| | 1878| 4.26M| if (need_whitespace && !emitter->whitespace) { ------------------ | Branch (1878:9): [True: 103k, False: 4.15M] | Branch (1878:28): [True: 103k, False: 0] ------------------ 1879| 103k| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 103k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 206k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 103k, False: 1] | | | | ------------------ | | | | 10| 206k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 18| 103k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 103k, False: 0] | | ------------------ | | 19| 103k| emitter->column++, \ | | 20| 103k| 1)) ------------------ 1880| 103k| } 1881| | 1882| 41.3M| while (string.pointer != string.end) { ------------------ | Branch (1882:12): [True: 37.0M, False: 4.26M] ------------------ 1883| 37.0M| if (IS_ALPHA(string) ------------------ | | 198| 37.0M|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 74.1M| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 23.6M, False: 13.4M] | | | | ------------------ | | | | 190| 37.0M| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 1.18M, False: 22.4M] | | | | ------------------ | | | | 191| 37.0M| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 21.9M, False: 13.8M] | | | | ------------------ | | | | 192| 35.8M| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 135k, False: 21.8M] | | | | ------------------ | | | | 193| 37.0M| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 21.8M, False: 13.9M] | | | | ------------------ | | | | 194| 35.7M| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 21.8M, False: 1.23k] | | | | ------------------ | | | | 195| 37.0M| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 7.24k, False: 13.9M] | | | | ------------------ | | | | 196| 74.1M| (string).pointer[offset] == '-') | | | | ------------------ | | | | | Branch (196:7): [True: 50.4k, False: 13.8M] | | | | ------------------ | | ------------------ ------------------ 1884| 13.8M| || CHECK(string, ';') || CHECK(string, '/') ------------------ | | 181| 50.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.96k, False: 13.8M] | | ------------------ ------------------ || CHECK(string, ';') || CHECK(string, '/') ------------------ | | 181| 50.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 17.1k, False: 13.8M] | | ------------------ ------------------ 1885| 13.8M| || CHECK(string, '?') || CHECK(string, ':') ------------------ | | 181| 50.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 13.3k, False: 13.8M] | | ------------------ ------------------ || CHECK(string, '?') || CHECK(string, ':') ------------------ | | 181| 50.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 406k, False: 13.4M] | | ------------------ ------------------ 1886| 13.4M| || CHECK(string, '@') || CHECK(string, '&') ------------------ | | 181| 50.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.38k, False: 13.4M] | | ------------------ ------------------ || CHECK(string, '@') || CHECK(string, '&') ------------------ | | 181| 50.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 7.25k, False: 13.3M] | | ------------------ ------------------ 1887| 13.3M| || CHECK(string, '=') || CHECK(string, '+') ------------------ | | 181| 50.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.39k, False: 13.3M] | | ------------------ ------------------ || CHECK(string, '=') || CHECK(string, '+') ------------------ | | 181| 50.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.06k, False: 13.3M] | | ------------------ ------------------ 1888| 13.3M| || CHECK(string, '$') || CHECK(string, ',') ------------------ | | 181| 50.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10.8k, False: 13.3M] | | ------------------ ------------------ || CHECK(string, '$') || CHECK(string, ',') ------------------ | | 181| 50.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 198k, False: 13.1M] | | ------------------ ------------------ 1889| 13.1M| || CHECK(string, '_') || CHECK(string, '.') ------------------ | | 181| 50.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 13.1M] | | ------------------ ------------------ || CHECK(string, '_') || CHECK(string, '.') ------------------ | | 181| 50.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 201k, False: 12.9M] | | ------------------ ------------------ 1890| 12.9M| || CHECK(string, '~') || CHECK(string, '*') ------------------ | | 181| 50.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 431, False: 12.9M] | | ------------------ ------------------ || CHECK(string, '~') || CHECK(string, '*') ------------------ | | 181| 50.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 13.2k, False: 12.9M] | | ------------------ ------------------ 1891| 12.9M| || CHECK(string, '\'') || CHECK(string, '(') ------------------ | | 181| 50.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.41k, False: 12.9M] | | ------------------ ------------------ || CHECK(string, '\'') || CHECK(string, '(') ------------------ | | 181| 50.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.97k, False: 12.9M] | | ------------------ ------------------ 1892| 12.9M| || CHECK(string, ')') || CHECK(string, '[') ------------------ | | 181| 50.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.49k, False: 12.9M] | | ------------------ ------------------ || CHECK(string, ')') || CHECK(string, '[') ------------------ | | 181| 50.0M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.07k, False: 12.9M] | | ------------------ ------------------ 1893| 24.1M| || CHECK(string, ']')) { ------------------ | | 181| 12.9M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.57k, False: 12.9M] | | ------------------ ------------------ 1894| 24.1M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 24.1M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 48.2M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 24.1M, False: 1.52k] | | | | ------------------ | | | | 10| 48.2M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1.52k, False: 0] | | | | ------------------ | | ------------------ | | 45| 24.1M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 24.1M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 24.1M, False: 0] | | | | ------------------ | | | | 399| 24.1M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 24.1M| (*(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: 24.1M, False: 0] | | ------------------ | | 46| 24.1M| emitter->column ++, \ | | 47| 24.1M| 1)) ------------------ 1895| 24.1M| } 1896| 12.9M| else { 1897| 12.9M| int width = WIDTH(string); ------------------ | | 385| 12.9M|#define WIDTH(string) WIDTH_AT((string),0) | | ------------------ | | | | 380| 12.9M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | ------------------ | | | | | Branch (380:7): [True: 12.9M, False: 800] | | | | ------------------ | | | | 381| 12.9M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | ------------------ | | | | | Branch (381:7): [True: 318, False: 482] | | | | ------------------ | | | | 382| 800| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | ------------------ | | | | | Branch (382:7): [True: 228, False: 254] | | | | ------------------ | | | | 383| 482| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | ------------------ | | | | | Branch (383:7): [True: 254, False: 0] | | | | ------------------ | | ------------------ ------------------ 1898| 12.9M| unsigned int value; 1899| 25.8M| while (width --) { ------------------ | Branch (1899:20): [True: 12.9M, False: 12.9M] ------------------ 1900| 12.9M| value = *(string.pointer++); 1901| 12.9M| if (!PUT(emitter, '%')) return 0; ------------------ | | 17| 12.9M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 25.8M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 12.9M, False: 955] | | | | ------------------ | | | | 10| 25.8M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 955, False: 0] | | | | ------------------ | | ------------------ | | 18| 12.9M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 12.9M, False: 0] | | ------------------ | | 19| 12.9M| emitter->column++, \ | | 20| 12.9M| 1)) ------------------ 1902| 12.9M| if (!PUT(emitter, (value >> 4) ------------------ | | 17| 12.9M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 25.8M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 12.9M, False: 987] | | | | ------------------ | | | | 10| 25.8M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 987, False: 0] | | | | ------------------ | | ------------------ | | 18| 25.8M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 12.9M, False: 0] | | | Branch (18:55): [True: 12.9M, False: 2.31k] | | ------------------ | | 19| 12.9M| emitter->column++, \ | | 20| 12.9M| 1)) ------------------ 1903| 12.9M| + ((value >> 4) < 10 ? '0' : 'A' - 10))) 1904| 0| return 0; 1905| 12.9M| if (!PUT(emitter, (value & 0x0F) ------------------ | | 17| 12.9M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 25.8M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 12.9M, False: 974] | | | | ------------------ | | | | 10| 25.8M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 974, False: 0] | | | | ------------------ | | ------------------ | | 18| 25.8M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 12.9M, False: 0] | | | Branch (18:55): [True: 12.9M, False: 1.74k] | | ------------------ | | 19| 12.9M| emitter->column++, \ | | 20| 12.9M| 1)) ------------------ 1906| 12.9M| + ((value & 0x0F) < 10 ? '0' : 'A' - 10))) 1907| 0| return 0; 1908| 12.9M| } 1909| 12.9M| } 1910| 37.0M| } 1911| | 1912| 4.26M| emitter->whitespace = 0; 1913| 4.26M| emitter->indention = 0; 1914| | 1915| 4.26M| return 1; 1916| 4.26M|} emitter.c:yaml_emitter_check_empty_document: 1110| 59.1k|{ 1111| 59.1k| return 0; 1112| 59.1k|} emitter.c:yaml_emitter_emit_document_content: 693| 59.1k|{ 694| 59.1k| if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE)) ------------------ | | 445| 59.1k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 59.1k, False: 0] | | ------------------ | | 446| 59.1k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 59.1k| (*((stack).top++) = value, \ | | 449| 59.1k| 1) : \ | | 450| 59.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (694:9): [True: 0, False: 59.1k] ------------------ 695| 0| return 0; 696| | 697| 59.1k| return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0); 698| 59.1k|} emitter.c:yaml_emitter_emit_node: 989| 6.39M|{ 990| 6.39M| emitter->root_context = root; 991| 6.39M| emitter->sequence_context = sequence; 992| 6.39M| emitter->mapping_context = mapping; 993| 6.39M| emitter->simple_key_context = simple_key; 994| | 995| 6.39M| switch (event->type) 996| 6.39M| { 997| 275k| case YAML_ALIAS_EVENT: ------------------ | Branch (997:9): [True: 275k, False: 6.11M] ------------------ 998| 275k| return yaml_emitter_emit_alias(emitter, event); 999| | 1000| 3.82M| case YAML_SCALAR_EVENT: ------------------ | Branch (1000:9): [True: 3.82M, False: 2.57M] ------------------ 1001| 3.82M| return yaml_emitter_emit_scalar(emitter, event); 1002| | 1003| 130k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1003:9): [True: 130k, False: 6.26M] ------------------ 1004| 130k| return yaml_emitter_emit_sequence_start(emitter, event); 1005| | 1006| 2.16M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1006:9): [True: 2.16M, False: 4.22M] ------------------ 1007| 2.16M| return yaml_emitter_emit_mapping_start(emitter, event); 1008| | 1009| 0| default: ------------------ | Branch (1009:9): [True: 0, False: 6.39M] ------------------ 1010| 0| return yaml_emitter_set_emitter_error(emitter, 1011| 0| "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS"); 1012| 6.39M| } 1013| | 1014| 0| return 0; 1015| 6.39M|} emitter.c:yaml_emitter_emit_alias: 1023| 275k|{ 1024| 275k| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1024:9): [True: 0, False: 275k] ------------------ 1025| 0| return 0; 1026| 275k| if (emitter->simple_key_context) ------------------ | Branch (1026:9): [True: 256k, False: 18.9k] ------------------ 1027| 256k| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 256k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 512k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 255k, False: 213] | | | | ------------------ | | | | 10| 512k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 213, False: 0] | | | | ------------------ | | ------------------ | | 18| 256k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 256k, False: 0] | | ------------------ | | 19| 256k| emitter->column++, \ | | 20| 256k| 1)) ------------------ 1028| 275k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 275k| (*(--(stack).top)) ------------------ 1029| | 1030| 275k| return 1; 1031| 275k|} emitter.c:yaml_emitter_process_anchor: 1261| 6.39M|{ 1262| 6.39M| if (!emitter->anchor_data.anchor) ------------------ | Branch (1262:9): [True: 6.11M, False: 279k] ------------------ 1263| 6.11M| return 1; 1264| | 1265| 279k| if (!yaml_emitter_write_indicator(emitter, ------------------ | Branch (1265:9): [True: 0, False: 279k] ------------------ 1266| 279k| (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0)) ------------------ | Branch (1266:18): [True: 275k, False: 4.51k] ------------------ 1267| 0| return 0; 1268| | 1269| 279k| return yaml_emitter_write_anchor(emitter, 1270| 279k| emitter->anchor_data.anchor, emitter->anchor_data.anchor_length); 1271| 279k|} emitter.c:yaml_emitter_write_anchor: 1835| 279k|{ 1836| 279k| yaml_string_t string; 1837| 279k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 279k| ((value).start = (string), \ | | 129| 279k| (value).end = (string)+(length), \ | | 130| 279k| (value).pointer = (string)) ------------------ 1838| | 1839| 1.67M| while (string.pointer != string.end) { ------------------ | Branch (1839:12): [True: 1.39M, False: 279k] ------------------ 1840| 1.39M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 1.39M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 2.79M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.39M, False: 286] | | | | ------------------ | | | | 10| 2.79M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 286, False: 0] | | | | ------------------ | | ------------------ | | 45| 1.39M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.39M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 1.39M, False: 0] | | | | ------------------ | | | | 399| 1.39M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.39M| (*(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.39M, False: 0] | | ------------------ | | 46| 1.39M| emitter->column ++, \ | | 47| 1.39M| 1)) ------------------ 1841| 1.39M| } 1842| | 1843| 279k| emitter->whitespace = 0; 1844| 279k| emitter->indention = 0; 1845| | 1846| 279k| return 1; 1847| 279k|} emitter.c:yaml_emitter_emit_scalar: 1039| 3.82M|{ 1040| 3.82M| if (!yaml_emitter_select_scalar_style(emitter, event)) ------------------ | Branch (1040:9): [True: 0, False: 3.82M] ------------------ 1041| 0| return 0; 1042| 3.82M| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1042:9): [True: 0, False: 3.82M] ------------------ 1043| 0| return 0; 1044| 3.82M| if (!yaml_emitter_process_tag(emitter)) ------------------ | Branch (1044:9): [True: 0, False: 3.82M] ------------------ 1045| 0| return 0; 1046| 3.82M| if (!yaml_emitter_increase_indent(emitter, 1, 0)) ------------------ | Branch (1046:9): [True: 0, False: 3.82M] ------------------ 1047| 0| return 0; 1048| 3.82M| if (!yaml_emitter_process_scalar(emitter)) ------------------ | Branch (1048:9): [True: 0, False: 3.82M] ------------------ 1049| 0| return 0; 1050| 3.82M| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 3.82M| (*(--(stack).top)) ------------------ 1051| 3.82M| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 3.82M| (*(--(stack).top)) ------------------ 1052| | 1053| 3.82M| return 1; 1054| 3.82M|} emitter.c:yaml_emitter_select_scalar_style: 1199| 3.82M|{ 1200| 3.82M| yaml_scalar_style_t style = event->data.scalar.style; 1201| 3.82M| int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix); ------------------ | Branch (1201:19): [True: 1.40M, False: 2.41M] | Branch (1201:48): [True: 1.32M, False: 80.9k] ------------------ 1202| | 1203| 3.82M| if (no_tag && !event->data.scalar.plain_implicit ------------------ | Branch (1203:9): [True: 1.32M, False: 2.49M] | Branch (1203:19): [True: 0, False: 1.32M] ------------------ 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.82M| if (style == YAML_ANY_SCALAR_STYLE) ------------------ | Branch (1209:9): [True: 0, False: 3.82M] ------------------ 1210| 0| style = YAML_PLAIN_SCALAR_STYLE; 1211| | 1212| 3.82M| if (emitter->canonical) ------------------ | Branch (1212:9): [True: 2.49M, False: 1.32M] ------------------ 1213| 2.49M| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1214| | 1215| 3.82M| if (emitter->simple_key_context && emitter->scalar_data.multiline) ------------------ | Branch (1215:9): [True: 293k, False: 3.52M] | Branch (1215:40): [True: 0, False: 293k] ------------------ 1216| 0| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1217| | 1218| 3.82M| if (style == YAML_PLAIN_SCALAR_STYLE) ------------------ | Branch (1218:9): [True: 1.30M, False: 2.52M] ------------------ 1219| 1.30M| { 1220| 1.30M| if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed) ------------------ | Branch (1220:14): [True: 449k, False: 851k] | Branch (1220:37): [True: 360k, False: 89.5k] ------------------ 1221| 941k| || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed)) ------------------ | Branch (1221:21): [True: 851k, False: 89.5k] | Branch (1221:45): [True: 88.7k, False: 762k] ------------------ 1222| 448k| style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1223| 1.30M| if (!emitter->scalar_data.length ------------------ | Branch (1223:13): [True: 1.00M, False: 294k] ------------------ 1224| 1.00M| && (emitter->flow_level || emitter->simple_key_context)) ------------------ | Branch (1224:21): [True: 357k, False: 648k] | Branch (1224:44): [True: 7.34k, False: 641k] ------------------ 1225| 365k| style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1226| 1.30M| if (no_tag && !event->data.scalar.plain_implicit) ------------------ | Branch (1226:13): [True: 1.29M, False: 1.19k] | Branch (1226:23): [True: 0, False: 1.29M] ------------------ 1227| 0| style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1228| 1.30M| } 1229| | 1230| 3.82M| if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE) ------------------ | Branch (1230:9): [True: 460k, False: 3.36M] ------------------ 1231| 460k| { 1232| 460k| if (!emitter->scalar_data.single_quoted_allowed) ------------------ | Branch (1232:13): [True: 6.21k, False: 454k] ------------------ 1233| 6.21k| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1234| 460k| } 1235| | 1236| 3.82M| if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE) ------------------ | Branch (1236:9): [True: 13.0k, False: 3.80M] | Branch (1236:47): [True: 6.71k, False: 3.80M] ------------------ 1237| 19.7k| { 1238| 19.7k| if (!emitter->scalar_data.block_allowed ------------------ | Branch (1238:13): [True: 3.79k, False: 15.9k] ------------------ 1239| 15.9k| || emitter->flow_level || emitter->simple_key_context) ------------------ | Branch (1239:20): [True: 0, False: 15.9k] | Branch (1239:43): [True: 197, False: 15.7k] ------------------ 1240| 3.99k| style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1241| 19.7k| } 1242| | 1243| 3.82M| if (no_tag && !event->data.scalar.quoted_implicit ------------------ | Branch (1243:9): [True: 1.32M, False: 2.49M] | Branch (1243:19): [True: 0, False: 1.32M] ------------------ 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.82M| emitter->scalar_data.style = style; 1251| | 1252| 3.82M| return 1; 1253| 3.82M|} emitter.c:yaml_emitter_process_tag: 1279| 6.11M|{ 1280| 6.11M| if (!emitter->tag_data.handle && !emitter->tag_data.suffix) ------------------ | Branch (1280:9): [True: 2.11M, False: 3.99M] | Branch (1280:38): [True: 1.95M, False: 159k] ------------------ 1281| 1.95M| return 1; 1282| | 1283| 4.15M| if (emitter->tag_data.handle) ------------------ | Branch (1283:9): [True: 3.99M, False: 159k] ------------------ 1284| 3.99M| { 1285| 3.99M| if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle, ------------------ | Branch (1285:13): [True: 0, False: 3.99M] ------------------ 1286| 3.99M| emitter->tag_data.handle_length)) 1287| 0| return 0; 1288| 3.99M| if (emitter->tag_data.suffix) { ------------------ | Branch (1288:13): [True: 3.99M, False: 0] ------------------ 1289| 3.99M| if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, ------------------ | Branch (1289:17): [True: 0, False: 3.99M] ------------------ 1290| 3.99M| emitter->tag_data.suffix_length, 0)) 1291| 0| return 0; 1292| 3.99M| } 1293| 3.99M| } 1294| 159k| else 1295| 159k| { 1296| 159k| if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0)) ------------------ | Branch (1296:13): [True: 0, False: 159k] ------------------ 1297| 0| return 0; 1298| 159k| if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, ------------------ | Branch (1298:13): [True: 0, False: 159k] ------------------ 1299| 159k| emitter->tag_data.suffix_length, 0)) 1300| 0| return 0; 1301| 159k| if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0)) ------------------ | Branch (1301:13): [True: 0, False: 159k] ------------------ 1302| 0| return 0; 1303| 159k| } 1304| | 1305| 4.15M| return 1; 1306| 4.15M|} emitter.c:yaml_emitter_increase_indent: 405| 6.11M|{ 406| 6.11M| if (!PUSH(emitter, emitter->indents, emitter->indent)) ------------------ | | 445| 6.11M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 6.11M, False: 2.58k] | | ------------------ | | 446| 6.11M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 2.58k, False: 0] | | ------------------ | | 447| 2.58k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 6.11M| (*((stack).top++) = value, \ | | 449| 6.11M| 1) : \ | | 450| 6.11M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (406:9): [True: 0, False: 6.11M] ------------------ 407| 0| return 0; 408| | 409| 6.11M| if (emitter->indent < 0) { ------------------ | Branch (409:9): [True: 59.1k, False: 6.05M] ------------------ 410| 59.1k| emitter->indent = flow ? emitter->best_indent : 0; ------------------ | Branch (410:27): [True: 35.5k, False: 23.5k] ------------------ 411| 59.1k| } 412| 6.05M| else if (!indentless) { ------------------ | Branch (412:14): [True: 6.04M, False: 16.8k] ------------------ 413| 6.04M| emitter->indent += emitter->best_indent; 414| 6.04M| } 415| | 416| 6.11M| return 1; 417| 6.11M|} emitter.c:yaml_emitter_process_scalar: 1314| 3.82M|{ 1315| 3.82M| switch (emitter->scalar_data.style) 1316| 3.82M| { 1317| 845k| case YAML_PLAIN_SCALAR_STYLE: ------------------ | Branch (1317:9): [True: 845k, False: 2.97M] ------------------ 1318| 845k| return yaml_emitter_write_plain_scalar(emitter, 1319| 845k| emitter->scalar_data.value, emitter->scalar_data.length, 1320| 845k| !emitter->simple_key_context); 1321| | 1322| 454k| case YAML_SINGLE_QUOTED_SCALAR_STYLE: ------------------ | Branch (1322:9): [True: 454k, False: 3.36M] ------------------ 1323| 454k| return yaml_emitter_write_single_quoted_scalar(emitter, 1324| 454k| emitter->scalar_data.value, emitter->scalar_data.length, 1325| 454k| !emitter->simple_key_context); 1326| | 1327| 2.50M| case YAML_DOUBLE_QUOTED_SCALAR_STYLE: ------------------ | Branch (1327:9): [True: 2.50M, False: 1.31M] ------------------ 1328| 2.50M| return yaml_emitter_write_double_quoted_scalar(emitter, 1329| 2.50M| emitter->scalar_data.value, emitter->scalar_data.length, 1330| 2.50M| !emitter->simple_key_context); 1331| | 1332| 11.7k| case YAML_LITERAL_SCALAR_STYLE: ------------------ | Branch (1332:9): [True: 11.7k, False: 3.81M] ------------------ 1333| 11.7k| return yaml_emitter_write_literal_scalar(emitter, 1334| 11.7k| emitter->scalar_data.value, emitter->scalar_data.length); 1335| | 1336| 4.06k| case YAML_FOLDED_SCALAR_STYLE: ------------------ | Branch (1336:9): [True: 4.06k, False: 3.81M] ------------------ 1337| 4.06k| return yaml_emitter_write_folded_scalar(emitter, 1338| 4.06k| emitter->scalar_data.value, emitter->scalar_data.length); 1339| | 1340| 0| default: ------------------ | Branch (1340:9): [True: 0, False: 3.82M] ------------------ 1341| 0| assert(1); /* Impossible. */ ------------------ | Branch (1341:13): [True: 0, Folded] | Branch (1341:13): [True: 0, Folded] ------------------ 1342| 3.82M| } 1343| | 1344| 0| return 0; 1345| 3.82M|} emitter.c:yaml_emitter_write_plain_scalar: 1921| 845k|{ 1922| 845k| yaml_string_t string; 1923| 845k| int spaces = 0; 1924| 845k| int breaks = 0; 1925| | 1926| 845k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 845k| ((value).start = (string), \ | | 129| 845k| (value).end = (string)+(length), \ | | 130| 845k| (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| 845k| if (!emitter->whitespace && (length || emitter->flow_level)) { ------------------ | Branch (1938:9): [True: 730k, False: 114k] | Branch (1938:34): [True: 89.1k, False: 641k] | Branch (1938:44): [True: 0, False: 641k] ------------------ 1939| 89.1k| if (!PUT(emitter, ' ')) return 0; ------------------ | | 17| 89.1k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 178k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 88.9k, False: 196] | | | | ------------------ | | | | 10| 178k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 196, False: 0] | | | | ------------------ | | ------------------ | | 18| 89.1k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 89.1k, False: 0] | | ------------------ | | 19| 89.1k| emitter->column++, \ | | 20| 89.1k| 1)) ------------------ 1940| 89.1k| } 1941| | 1942| 9.82M| while (string.pointer != string.end) ------------------ | Branch (1942:12): [True: 8.97M, False: 845k] ------------------ 1943| 8.97M| { 1944| 8.97M| if (IS_SPACE(string)) ------------------ | | 306| 8.97M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 8.97M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 8.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.07M, False: 6.90M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1945| 2.07M| { 1946| 2.07M| if (allow_breaks && !spaces ------------------ | Branch (1946:17): [True: 1.95M, False: 117k] | Branch (1946:33): [True: 386k, False: 1.56M] ------------------ 1947| 386k| && emitter->column > emitter->best_width ------------------ | Branch (1947:24): [True: 342k, False: 44.3k] ------------------ 1948| 342k| && !IS_SPACE_AT(string, 1)) { ------------------ | | 304| 342k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 342k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (1948:24): [True: 322k, False: 19.4k] ------------------ 1949| 322k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (1949:21): [True: 0, False: 322k] ------------------ 1950| 322k| MOVE(string); ------------------ | | 391| 322k|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 322k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 322k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 322k, False: 0] | | | | | | ------------------ | | | | | | 381| 322k| ((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| 322k| } 1952| 1.74M| else { 1953| 1.74M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 1.74M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 3.49M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.74M, False: 281] | | | | ------------------ | | | | 10| 3.49M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 281, False: 0] | | | | ------------------ | | ------------------ | | 45| 1.74M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.74M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 1.74M, False: 0] | | | | ------------------ | | | | 399| 1.74M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.74M| (*(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.74M, False: 0] | | ------------------ | | 46| 1.74M| emitter->column ++, \ | | 47| 1.74M| 1)) ------------------ 1954| 1.74M| } 1955| 2.07M| spaces = 1; 1956| 2.07M| } 1957| 6.90M| else if (IS_BREAK(string)) ------------------ | | 341| 6.90M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 6.90M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 6.90M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 6.90M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 6.90M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 6.90M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 969, False: 6.90M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 6.90M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 969| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 969] | | | | | | ------------------ | | | | ------------------ | | | | 334| 6.90M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 542k, False: 6.36M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 6.90M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 7.44M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 536k, False: 6.02k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 6.90M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 536k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 536k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 6.90M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 542k, False: 6.36M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 6.90M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 7.44M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 536k, False: 6.02k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 6.90M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 536k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 536k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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.90M| else 1967| 6.90M| { 1968| 6.90M| if (breaks) { ------------------ | Branch (1968:17): [True: 0, False: 6.90M] ------------------ 1969| 0| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (1969:21): [True: 0, False: 0] ------------------ 1970| 0| } 1971| 6.90M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 6.90M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 13.8M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 6.90M, False: 531] | | | | ------------------ | | | | 10| 13.8M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 531, False: 0] | | | | ------------------ | | ------------------ | | 45| 6.90M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 6.90M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 6.22M, False: 675k] | | | | ------------------ | | | | 399| 6.90M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 6.90M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 3.79k, False: 671k] | | | | ------------------ | | | | 401| 675k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 3.79k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 675k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 671k, False: 0] | | | | ------------------ | | | | 404| 671k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 671k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 671k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 671k| (*(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.90M, False: 0] | | ------------------ | | 46| 6.90M| emitter->column ++, \ | | 47| 6.90M| 1)) ------------------ 1972| 6.90M| emitter->indention = 0; 1973| 6.90M| spaces = 0; 1974| 6.90M| breaks = 0; 1975| 6.90M| } 1976| 8.97M| } 1977| | 1978| 845k| emitter->whitespace = 0; 1979| 845k| emitter->indention = 0; 1980| | 1981| 845k| return 1; 1982| 845k|} emitter.c:yaml_emitter_write_single_quoted_scalar: 1987| 454k|{ 1988| 454k| yaml_string_t string; 1989| 454k| int spaces = 0; 1990| 454k| int breaks = 0; 1991| | 1992| 454k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 454k| ((value).start = (string), \ | | 129| 454k| (value).end = (string)+(length), \ | | 130| 454k| (value).pointer = (string)) ------------------ 1993| | 1994| 454k| if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0)) ------------------ | Branch (1994:9): [True: 0, False: 454k] ------------------ 1995| 0| return 0; 1996| | 1997| 1.74M| while (string.pointer != string.end) ------------------ | Branch (1997:12): [True: 1.28M, False: 454k] ------------------ 1998| 1.28M| { 1999| 1.28M| if (IS_SPACE(string)) ------------------ | | 306| 1.28M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 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: 80.8k, False: 1.20M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2000| 80.8k| { 2001| 80.8k| if (allow_breaks && !spaces ------------------ | Branch (2001:17): [True: 79.9k, False: 877] | Branch (2001:33): [True: 40.0k, False: 39.8k] ------------------ 2002| 40.0k| && emitter->column > emitter->best_width ------------------ | Branch (2002:24): [True: 3.19k, False: 36.8k] ------------------ 2003| 3.19k| && string.pointer != string.start ------------------ | Branch (2003:24): [True: 2.96k, False: 229] ------------------ 2004| 2.96k| && string.pointer != string.end - 1 ------------------ | Branch (2004:24): [True: 2.76k, False: 203] ------------------ 2005| 2.76k| && !IS_SPACE_AT(string, 1)) { ------------------ | | 304| 2.76k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 2.76k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2005:24): [True: 2.27k, False: 491] ------------------ 2006| 2.27k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2006:21): [True: 0, False: 2.27k] ------------------ 2007| 2.27k| MOVE(string); ------------------ | | 391| 2.27k|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 2.27k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.27k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.27k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.27k| ((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| 2.27k| } 2009| 78.5k| else { 2010| 78.5k| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 78.5k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 157k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 78.3k, False: 198] | | | | ------------------ | | | | 10| 157k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 198, False: 0] | | | | ------------------ | | ------------------ | | 45| 78.5k| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 78.5k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 78.5k, False: 0] | | | | ------------------ | | | | 399| 78.5k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 78.5k| (*(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: 78.5k, False: 0] | | ------------------ | | 46| 78.5k| emitter->column ++, \ | | 47| 78.5k| 1)) ------------------ 2011| 78.5k| } 2012| 80.8k| spaces = 1; 2013| 80.8k| } 2014| 1.20M| else if (IS_BREAK(string)) ------------------ | | 341| 1.20M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 1.20M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 2.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 1.20M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 1.20M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 2.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 22.9k, False: 1.18M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 1.20M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.36M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 205, False: 1.18M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 1.18M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 205| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 205] | | | | | | ------------------ | | | | ------------------ | | | | 334| 1.20M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.36M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 638k, False: 545k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 1.18M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 1.82M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 633k, False: 5.21k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 1.18M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 633k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 557, False: 632k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 1.20M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.36M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 638k, False: 545k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 1.18M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 1.82M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 632k, False: 5.21k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 1.18M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 632k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 657, False: 632k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2015| 24.1k| { 2016| 24.1k| if (!breaks && CHECK(string, '\n')) { ------------------ | | 181| 19.0k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 19.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 18.3k, False: 669] | | ------------------ ------------------ | Branch (2016:17): [True: 19.0k, False: 5.15k] ------------------ 2017| 18.3k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 18.3k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 36.7k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 18.1k, False: 194] | | | | ------------------ | | | | 10| 36.7k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 28| 18.3k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 18.3k, False: 0] | | | Branch (28:11): [True: 0, False: 18.3k] | | ------------------ | | 29| 18.3k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 18.3k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 18.3k, False: 0] | | ------------------ | | 31| 18.3k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 18.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| 18.3k| emitter->column = 0, \ | | 36| 18.3k| emitter->line ++, \ | | 37| 18.3k| 1)) ------------------ 2018| 18.3k| } 2019| 24.1k| if (!WRITE_BREAK(emitter, string)) return 0; ------------------ | | 54| 24.1k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 48.3k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 23.9k, False: 197] | | | | ------------------ | | | | 10| 48.3k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 197, False: 0] | | | | ------------------ | | ------------------ | | 55| 24.1k| && (CHECK(string,'\n') ? \ | | ------------------ | | | | 181| 24.1k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | | | ------------------ | | | | | | 175| 24.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (181:29): [True: 22.9k, False: 1.21k] | | | | ------------------ | | ------------------ | | | Branch (55:9): [True: 24.1k, False: 0] | | ------------------ | | 56| 24.1k| (PUT_BREAK(emitter), \ | | ------------------ | | | | 27| 22.9k| (FLUSH(emitter) \ | | | | ------------------ | | | | | | 9| 45.9k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | | | ------------------ | | | | | | | Branch (9:6): [True: 22.9k, False: 0] | | | | | | ------------------ | | | | | | 10| 45.9k| || yaml_emitter_flush(emitter)) | | | | | | ------------------ | | | | | | | Branch (10:9): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 28| 22.9k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | | | ------------------ | | | | | Branch (28:9): [True: 22.9k, False: 0] | | | | | Branch (28:11): [True: 0, False: 22.9k] | | | | ------------------ | | | | 29| 22.9k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | | | 30| 22.9k| emitter->line_break == YAML_LN_BREAK ? \ | | | | ------------------ | | | | | Branch (30:11): [True: 22.9k, False: 0] | | | | ------------------ | | | | 31| 22.9k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | | | 32| 22.9k| 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| 22.9k| emitter->column = 0, \ | | | | 36| 22.9k| emitter->line ++, \ | | | | 37| 22.9k| 1)) | | ------------------ | | 57| 22.9k| string.pointer ++, \ | | 58| 22.9k| 1) : \ | | 59| 24.1k| (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.21k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 0, False: 1.21k] | | | | ------------------ | | | | 399| 1.21k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.21k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 1.21k] | | | | ------------------ | | | | 401| 1.21k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 1.21k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 1.21k, False: 0] | | | | ------------------ | | | | 404| 1.21k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 1.21k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 1.21k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 1.21k| (*(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.21k| emitter->column = 0, \ | | 61| 1.21k| emitter->line ++, \ | | 62| 1.21k| 1))) ------------------ 2020| 24.1k| emitter->indention = 1; 2021| 24.1k| breaks = 1; 2022| 24.1k| } 2023| 1.18M| else 2024| 1.18M| { 2025| 1.18M| if (breaks) { ------------------ | Branch (2025:17): [True: 18.8k, False: 1.16M] ------------------ 2026| 18.8k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2026:21): [True: 0, False: 18.8k] ------------------ 2027| 18.8k| } 2028| 1.18M| if (CHECK(string, '\'')) { ------------------ | | 181| 1.18M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.18M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.78k, False: 1.17M] | | ------------------ ------------------ 2029| 3.78k| if (!PUT(emitter, '\'')) return 0; ------------------ | | 17| 3.78k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 7.57k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.59k, False: 194] | | | | ------------------ | | | | 10| 7.57k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 18| 3.78k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 3.78k, False: 0] | | ------------------ | | 19| 3.78k| emitter->column++, \ | | 20| 3.78k| 1)) ------------------ 2030| 3.78k| } 2031| 1.18M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 1.18M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 2.36M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.18M, False: 347] | | | | ------------------ | | | | 10| 2.36M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 347, False: 0] | | | | ------------------ | | ------------------ | | 45| 1.18M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.18M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 482k, False: 700k] | | | | ------------------ | | | | 399| 1.18M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.18M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 310, False: 700k] | | | | ------------------ | | | | 401| 700k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 310| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 700k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 700k, False: 0] | | | | ------------------ | | | | 404| 700k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 700k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 700k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 700k| (*(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.18M, False: 0] | | ------------------ | | 46| 1.18M| emitter->column ++, \ | | 47| 1.18M| 1)) ------------------ 2032| 1.18M| emitter->indention = 0; 2033| 1.18M| spaces = 0; 2034| 1.18M| breaks = 0; 2035| 1.18M| } 2036| 1.28M| } 2037| | 2038| 454k| if (breaks) ------------------ | Branch (2038:9): [True: 203, False: 454k] ------------------ 2039| 203| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2039:13): [True: 0, False: 203] ------------------ 2040| | 2041| 454k| if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0)) ------------------ | Branch (2041:9): [True: 0, False: 454k] ------------------ 2042| 0| return 0; 2043| | 2044| 454k| emitter->whitespace = 0; 2045| 454k| emitter->indention = 0; 2046| | 2047| 454k| return 1; 2048| 454k|} emitter.c:yaml_emitter_write_double_quoted_scalar: 2053| 2.50M|{ 2054| 2.50M| yaml_string_t string; 2055| 2.50M| int spaces = 0; 2056| | 2057| 2.50M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 2.50M| ((value).start = (string), \ | | 129| 2.50M| (value).end = (string)+(length), \ | | 130| 2.50M| (value).pointer = (string)) ------------------ 2058| | 2059| 2.50M| if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0)) ------------------ | Branch (2059:9): [True: 0, False: 2.50M] ------------------ 2060| 0| return 0; 2061| | 2062| 25.5M| while (string.pointer != string.end) ------------------ | Branch (2062:12): [True: 23.0M, False: 2.50M] ------------------ 2063| 23.0M| { 2064| 23.0M| if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string)) ------------------ | | 279| 23.0M|#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) | | ------------------ | | | | 262| 46.0M| (((string).pointer[offset] == 0x0A) /* . == #x0A */ \ | | | | ------------------ | | | | | Branch (262:6): [True: 1.09M, False: 21.9M] | | | | ------------------ | | | | 263| 23.0M| || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \ | | | | ------------------ | | | | | Branch (263:10): [True: 19.8M, False: 2.05M] | | | | ------------------ | | | | 264| 21.9M| && (string).pointer[offset] <= 0x7E) \ | | | | ------------------ | | | | | Branch (264:13): [True: 13.8M, False: 6.05M] | | | | ------------------ | | | | 265| 23.0M| || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ | | | | ------------------ | | | | | Branch (265:10): [True: 155k, False: 7.94M] | | | | ------------------ | | | | 266| 8.10M| && (string).pointer[offset+1] >= 0xA0) \ | | | | ------------------ | | | | | Branch (266:13): [True: 27.9k, False: 127k] | | | | ------------------ | | | | 267| 23.0M| || ((string).pointer[offset] > 0xC2 \ | | | | ------------------ | | | | | Branch (267:10): [True: 5.89M, False: 2.17M] | | | | ------------------ | | | | 268| 8.07M| && (string).pointer[offset] < 0xED) \ | | | | ------------------ | | | | | Branch (268:13): [True: 5.84M, False: 57.5k] | | | | ------------------ | | | | 269| 23.0M| || ((string).pointer[offset] == 0xED \ | | | | ------------------ | | | | | Branch (269:10): [True: 4.22k, False: 2.23M] | | | | ------------------ | | | | 270| 2.23M| && (string).pointer[offset+1] < 0xA0) \ | | | | ------------------ | | | | | Branch (270:13): [True: 4.22k, False: 0] | | | | ------------------ | | | | 271| 23.0M| || ((string).pointer[offset] == 0xEE) \ | | | | ------------------ | | | | | Branch (271:9): [True: 1.73k, False: 2.22M] | | | | ------------------ | | | | 272| 46.0M| || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \ | | | | ------------------ | | | | | Branch (272:10): [True: 7.82k, False: 2.22M] | | | | ------------------ | | | | 273| 2.22M| && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \ | | | | ------------------ | | | | | Branch (273:15): [True: 2.90k, False: 4.92k] | | | | ------------------ | | | | 274| 7.82k| && (string).pointer[offset+2] == 0xBF) \ | | | | ------------------ | | | | | Branch (274:17): [True: 1.80k, False: 1.09k] | | | | ------------------ | | | | 275| 2.22M| && !((string).pointer[offset+1] == 0xBF \ | | | | ------------------ | | | | | Branch (275:15): [True: 1.34k, False: 4.68k] | | | | ------------------ | | | | 276| 6.02k| && ((string).pointer[offset+2] == 0xBE \ | | | | ------------------ | | | | | Branch (276:18): [True: 194, False: 1.14k] | | | | ------------------ | | | | 277| 1.34k| || (string).pointer[offset+2] == 0xBF)))) | | | | ------------------ | | | | | Branch (277:21): [True: 200, False: 947] | | | | ------------------ | | ------------------ ------------------ if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string)) ------------------ | | 255| 9.22M|#define IS_ASCII(string) IS_ASCII_AT((string),0) | | ------------------ | | | | 253| 9.22M| ((string).pointer[offset] <= (yaml_char_t) '\x7F') | | ------------------ ------------------ | Branch (2064:39): [True: 9.22M, False: 11.5M] | Branch (2064:60): [True: 4.33M, False: 4.88M] ------------------ 2065| 23.0M| || IS_BOM(string) || IS_BREAK(string) ------------------ | | 298| 16.4M|#define IS_BOM(string) IS_BOM_AT(string,0) | | ------------------ | | | | 294| 39.4M| (CHECK_AT((string),'\xEF',(offset)) \ | | | | ------------------ | | | | | | 175| 32.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.81k, False: 16.4M] | | | | | | ------------------ | | | | ------------------ | | | | 295| 16.4M| && CHECK_AT((string),'\xBB',(offset)+1) \ | | | | ------------------ | | | | | | 175| 16.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 396, False: 2.41k] | | | | | | ------------------ | | | | ------------------ | | | | 296| 39.4M| && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */ | | | | ------------------ | | | | | | 175| 396| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 396] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ || IS_BOM(string) || IS_BREAK(string) ------------------ | | 341| 16.4M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 39.4M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 32.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 16.4M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 16.4M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 32.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.09M, False: 15.3M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 16.4M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 30.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 5.00k, False: 15.3M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 15.3M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 5.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 5.00k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 16.4M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 30.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.11M, False: 14.2M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 15.3M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 16.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.03M, False: 88.5k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 15.3M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 1.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.83k, False: 1.02M] | | | | | | ------------------ | | | | ------------------ | | | | 337| 39.4M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 30.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.11M, False: 14.2M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 15.3M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 16.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.02M, False: 88.5k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 15.3M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 1.02M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 67.7k, False: 960k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2066| 15.2M| || CHECK(string, '"') || CHECK(string, '\\')) ------------------ | | 181| 38.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 15.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 39.4k, False: 15.2M] | | ------------------ ------------------ || CHECK(string, '"') || CHECK(string, '\\')) ------------------ | | 181| 15.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 15.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 185k, False: 15.0M] | | ------------------ ------------------ 2067| 7.95M| { 2068| 7.95M| unsigned char octet; 2069| 7.95M| unsigned int width; 2070| 7.95M| unsigned int value; 2071| 7.95M| int k; 2072| | 2073| 7.95M| octet = string.pointer[0]; 2074| 7.95M| width = (octet & 0x80) == 0x00 ? 1 : ------------------ | Branch (2074:21): [True: 3.37M, False: 4.58M] ------------------ 2075| 7.95M| (octet & 0xE0) == 0xC0 ? 2 : ------------------ | Branch (2075:21): [True: 163k, False: 4.41M] ------------------ 2076| 4.58M| (octet & 0xF0) == 0xE0 ? 3 : ------------------ | Branch (2076:21): [True: 4.37M, False: 43.7k] ------------------ 2077| 4.41M| (octet & 0xF8) == 0xF0 ? 4 : 0; ------------------ | Branch (2077:21): [True: 43.7k, False: 0] ------------------ 2078| 7.95M| value = (octet & 0x80) == 0x00 ? octet & 0x7F : ------------------ | Branch (2078:21): [True: 3.37M, False: 4.58M] ------------------ 2079| 7.95M| (octet & 0xE0) == 0xC0 ? octet & 0x1F : ------------------ | Branch (2079:21): [True: 163k, False: 4.41M] ------------------ 2080| 4.58M| (octet & 0xF0) == 0xE0 ? octet & 0x0F : ------------------ | Branch (2080:21): [True: 4.37M, False: 43.7k] ------------------ 2081| 4.41M| (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; ------------------ | Branch (2081:21): [True: 43.7k, False: 0] ------------------ 2082| 16.9M| for (k = 1; k < (int)width; k ++) { ------------------ | Branch (2082:25): [True: 9.04M, False: 7.95M] ------------------ 2083| 9.04M| octet = string.pointer[k]; 2084| 9.04M| value = (value << 6) + (octet & 0x3F); 2085| 9.04M| } 2086| 7.95M| string.pointer += width; 2087| | 2088| 7.95M| if (!PUT(emitter, '\\')) return 0; ------------------ | | 17| 7.95M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 15.9M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 7.95M, False: 657] | | | | ------------------ | | | | 10| 15.9M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 657, False: 0] | | | | ------------------ | | ------------------ | | 18| 7.95M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 7.95M, False: 0] | | ------------------ | | 19| 7.95M| emitter->column++, \ | | 20| 7.95M| 1)) ------------------ 2089| | 2090| 7.95M| switch (value) 2091| 7.95M| { 2092| 2.64k| case 0x00: ------------------ | Branch (2092:17): [True: 2.64k, False: 7.94M] ------------------ 2093| 2.64k| if (!PUT(emitter, '0')) return 0; ------------------ | | 17| 2.64k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 5.28k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 2.63k, False: 6] | | | | ------------------ | | | | 10| 5.28k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 6, False: 0] | | | | ------------------ | | ------------------ | | 18| 2.64k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 2.64k, False: 0] | | ------------------ | | 19| 2.64k| emitter->column++, \ | | 20| 2.64k| 1)) ------------------ 2094| 2.64k| break; 2095| | 2096| 640k| case 0x07: ------------------ | Branch (2096:17): [True: 640k, False: 7.31M] ------------------ 2097| 640k| if (!PUT(emitter, 'a')) return 0; ------------------ | | 17| 640k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 1.28M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 640k, False: 67] | | | | ------------------ | | | | 10| 1.28M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 67, False: 0] | | | | ------------------ | | ------------------ | | 18| 640k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 640k, False: 0] | | ------------------ | | 19| 640k| emitter->column++, \ | | 20| 640k| 1)) ------------------ 2098| 640k| break; 2099| | 2100| 640k| case 0x08: ------------------ | Branch (2100:17): [True: 1.83k, False: 7.94M] ------------------ 2101| 1.83k| if (!PUT(emitter, 'b')) return 0; ------------------ | | 17| 1.83k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 3.67k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.82k, False: 10] | | | | ------------------ | | | | 10| 3.67k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 10, False: 0] | | | | ------------------ | | ------------------ | | 18| 1.83k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 1.83k, False: 0] | | ------------------ | | 19| 1.83k| emitter->column++, \ | | 20| 1.83k| 1)) ------------------ 2102| 1.83k| break; 2103| | 2104| 539k| case 0x09: ------------------ | Branch (2104:17): [True: 539k, False: 7.41M] ------------------ 2105| 539k| if (!PUT(emitter, 't')) return 0; ------------------ | | 17| 539k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 1.07M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 538k, False: 212] | | | | ------------------ | | | | 10| 1.07M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 212, False: 0] | | | | ------------------ | | ------------------ | | 18| 539k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 539k, False: 0] | | ------------------ | | 19| 539k| emitter->column++, \ | | 20| 539k| 1)) ------------------ 2106| 539k| break; 2107| | 2108| 1.09M| case 0x0A: ------------------ | Branch (2108:17): [True: 1.09M, False: 6.85M] ------------------ 2109| 1.09M| if (!PUT(emitter, 'n')) return 0; ------------------ | | 17| 1.09M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 2.18M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 1.09M, False: 254] | | | | ------------------ | | | | 10| 2.18M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 254, False: 0] | | | | ------------------ | | ------------------ | | 18| 1.09M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 1.09M, False: 0] | | ------------------ | | 19| 1.09M| emitter->column++, \ | | 20| 1.09M| 1)) ------------------ 2110| 1.09M| break; 2111| | 2112| 1.09M| case 0x0B: ------------------ | Branch (2112:17): [True: 35.8k, False: 7.91M] ------------------ 2113| 35.8k| if (!PUT(emitter, 'v')) return 0; ------------------ | | 17| 35.8k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 71.6k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 35.7k, False: 18] | | | | ------------------ | | | | 10| 71.6k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 18, False: 0] | | | | ------------------ | | ------------------ | | 18| 35.8k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 35.8k, False: 0] | | ------------------ | | 19| 35.8k| emitter->column++, \ | | 20| 35.8k| 1)) ------------------ 2114| 35.8k| break; 2115| | 2116| 101k| case 0x0C: ------------------ | Branch (2116:17): [True: 101k, False: 7.84M] ------------------ 2117| 101k| if (!PUT(emitter, 'f')) return 0; ------------------ | | 17| 101k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 203k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 101k, False: 19] | | | | ------------------ | | | | 10| 203k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 19, False: 0] | | | | ------------------ | | ------------------ | | 18| 101k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 101k, False: 0] | | ------------------ | | 19| 101k| emitter->column++, \ | | 20| 101k| 1)) ------------------ 2118| 101k| break; 2119| | 2120| 530k| case 0x0D: ------------------ | Branch (2120:17): [True: 530k, False: 7.42M] ------------------ 2121| 530k| if (!PUT(emitter, 'r')) return 0; ------------------ | | 17| 530k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 1.06M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 530k, False: 66] | | | | ------------------ | | | | 10| 1.06M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 66, False: 0] | | | | ------------------ | | ------------------ | | 18| 530k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 530k, False: 0] | | ------------------ | | 19| 530k| emitter->column++, \ | | 20| 530k| 1)) ------------------ 2122| 530k| break; 2123| | 2124| 530k| case 0x1B: ------------------ | Branch (2124:17): [True: 198k, False: 7.75M] ------------------ 2125| 198k| if (!PUT(emitter, 'e')) return 0; ------------------ | | 17| 198k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 396k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 198k, False: 34] | | | | ------------------ | | | | 10| 396k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 34, False: 0] | | | | ------------------ | | ------------------ | | 18| 198k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 198k, False: 0] | | ------------------ | | 19| 198k| emitter->column++, \ | | 20| 198k| 1)) ------------------ 2126| 198k| break; 2127| | 2128| 198k| case 0x22: ------------------ | Branch (2128:17): [True: 39.4k, False: 7.91M] ------------------ 2129| 39.4k| if (!PUT(emitter, '\"')) return 0; ------------------ | | 17| 39.4k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 78.9k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 39.2k, False: 198] | | | | ------------------ | | | | 10| 78.9k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 198, False: 0] | | | | ------------------ | | ------------------ | | 18| 39.4k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 39.4k, False: 0] | | ------------------ | | 19| 39.4k| emitter->column++, \ | | 20| 39.4k| 1)) ------------------ 2130| 39.4k| break; 2131| | 2132| 185k| case 0x5C: ------------------ | Branch (2132:17): [True: 185k, False: 7.76M] ------------------ 2133| 185k| if (!PUT(emitter, '\\')) return 0; ------------------ | | 17| 185k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 371k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 185k, False: 207] | | | | ------------------ | | | | 10| 371k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 207, False: 0] | | | | ------------------ | | ------------------ | | 18| 185k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 185k, False: 0] | | ------------------ | | 19| 185k| emitter->column++, \ | | 20| 185k| 1)) ------------------ 2134| 185k| break; 2135| | 2136| 185k| case 0x85: ------------------ | Branch (2136:17): [True: 127k, False: 7.82M] ------------------ 2137| 127k| if (!PUT(emitter, 'N')) return 0; ------------------ | | 17| 127k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 255k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 127k, False: 35] | | | | ------------------ | | | | 10| 255k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 35, False: 0] | | | | ------------------ | | ------------------ | | 18| 127k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 127k, False: 0] | | ------------------ | | 19| 127k| emitter->column++, \ | | 20| 127k| 1)) ------------------ 2138| 127k| break; 2139| | 2140| 127k| case 0xA0: ------------------ | Branch (2140:17): [True: 16.3k, False: 7.93M] ------------------ 2141| 16.3k| if (!PUT(emitter, '_')) return 0; ------------------ | | 17| 16.3k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 32.7k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 16.0k, False: 264] | | | | ------------------ | | | | 10| 32.7k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 264, False: 0] | | | | ------------------ | | ------------------ | | 18| 16.3k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 16.3k, False: 0] | | ------------------ | | 19| 16.3k| emitter->column++, \ | | 20| 16.3k| 1)) ------------------ 2142| 16.3k| break; 2143| | 2144| 16.3k| case 0x2028: ------------------ | Branch (2144:17): [True: 7.60k, False: 7.94M] ------------------ 2145| 7.60k| if (!PUT(emitter, 'L')) return 0; ------------------ | | 17| 7.60k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 15.2k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 7.41k, False: 194] | | | | ------------------ | | | | 10| 15.2k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 18| 7.60k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 7.60k, False: 0] | | ------------------ | | 19| 7.60k| emitter->column++, \ | | 20| 7.60k| 1)) ------------------ 2146| 7.60k| break; 2147| | 2148| 68.5k| case 0x2029: ------------------ | Branch (2148:17): [True: 68.5k, False: 7.88M] ------------------ 2149| 68.5k| if (!PUT(emitter, 'P')) return 0; ------------------ | | 17| 68.5k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 137k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 68.3k, False: 200] | | | | ------------------ | | | | 10| 137k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 200, False: 0] | | | | ------------------ | | ------------------ | | 18| 68.5k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 68.5k, False: 0] | | ------------------ | | 19| 68.5k| emitter->column++, \ | | 20| 68.5k| 1)) ------------------ 2150| 68.5k| break; 2151| | 2152| 4.36M| default: ------------------ | Branch (2152:17): [True: 4.36M, False: 3.59M] ------------------ 2153| 4.36M| if (value <= 0xFF) { ------------------ | Branch (2153:25): [True: 7.09k, False: 4.35M] ------------------ 2154| 7.09k| if (!PUT(emitter, 'x')) return 0; ------------------ | | 17| 7.09k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 14.1k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 6.90k, False: 194] | | | | ------------------ | | | | 10| 14.1k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 18| 7.09k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 7.09k, False: 0] | | ------------------ | | 19| 7.09k| emitter->column++, \ | | 20| 7.09k| 1)) ------------------ 2155| 7.09k| width = 2; 2156| 7.09k| } 2157| 4.35M| else if (value <= 0xFFFF) { ------------------ | Branch (2157:30): [True: 4.30M, False: 43.7k] ------------------ 2158| 4.30M| if (!PUT(emitter, 'u')) return 0; ------------------ | | 17| 4.30M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 8.61M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 4.30M, False: 438] | | | | ------------------ | | | | 10| 8.61M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 438, False: 0] | | | | ------------------ | | ------------------ | | 18| 4.30M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 4.30M, False: 0] | | ------------------ | | 19| 4.30M| emitter->column++, \ | | 20| 4.30M| 1)) ------------------ 2159| 4.30M| width = 4; 2160| 4.30M| } 2161| 43.7k| else { 2162| 43.7k| if (!PUT(emitter, 'U')) return 0; ------------------ | | 17| 43.7k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 87.5k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 43.5k, False: 195] | | | | ------------------ | | | | 10| 87.5k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 195, False: 0] | | | | ------------------ | | ------------------ | | 18| 43.7k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 43.7k, False: 0] | | ------------------ | | 19| 43.7k| emitter->column++, \ | | 20| 43.7k| 1)) ------------------ 2163| 43.7k| width = 8; 2164| 43.7k| } 2165| 21.9M| for (k = (width-1)*4; k >= 0; k -= 4) { ------------------ | Branch (2165:43): [True: 17.6M, False: 4.36M] ------------------ 2166| 17.6M| int digit = (value >> k) & 0x0F; 2167| 17.6M| if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10))) ------------------ | | 17| 17.6M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 35.2M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 17.6M, False: 1.25k] | | | | ------------------ | | | | 10| 35.2M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 1.25k, False: 0] | | | | ------------------ | | ------------------ | | 18| 35.2M| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 17.6M, False: 0] | | | Branch (18:55): [True: 15.3M, False: 2.23M] | | ------------------ | | 19| 17.6M| emitter->column++, \ | | 20| 17.6M| 1)) ------------------ 2168| 0| return 0; 2169| 17.6M| } 2170| 7.95M| } 2171| 7.95M| spaces = 0; 2172| 7.95M| } 2173| 15.0M| else if (IS_SPACE(string)) ------------------ | | 306| 15.0M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 15.0M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 15.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 4.95M, False: 10.1M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2174| 4.95M| { 2175| 4.95M| if (allow_breaks && !spaces ------------------ | Branch (2175:17): [True: 4.95M, False: 2.88k] | Branch (2175:33): [True: 2.15M, False: 2.80M] ------------------ 2176| 2.15M| && emitter->column > emitter->best_width ------------------ | Branch (2176:24): [True: 1.74M, False: 407k] ------------------ 2177| 1.74M| && string.pointer != string.start ------------------ | Branch (2177:24): [True: 1.74M, False: 198] ------------------ 2178| 1.74M| && string.pointer != string.end - 1) { ------------------ | Branch (2178:24): [True: 1.74M, False: 211] ------------------ 2179| 1.74M| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2179:21): [True: 0, False: 1.74M] ------------------ 2180| 1.74M| if (IS_SPACE_AT(string, 1)) { ------------------ | | 304| 1.74M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 1.74M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 33.9k, False: 1.70M] | | | | ------------------ | | ------------------ ------------------ 2181| 33.9k| if (!PUT(emitter, '\\')) return 0; ------------------ | | 17| 33.9k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 67.8k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 33.6k, False: 218] | | | | ------------------ | | | | 10| 67.8k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 218, False: 0] | | | | ------------------ | | ------------------ | | 18| 33.9k| && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \ | | ------------------ | | | Branch (18:9): [True: 33.9k, False: 0] | | ------------------ | | 19| 33.9k| emitter->column++, \ | | 20| 33.9k| 1)) ------------------ 2182| 33.9k| } 2183| 1.74M| MOVE(string); ------------------ | | 391| 1.74M|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 1.74M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.74M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.74M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.74M| ((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.74M| } 2185| 3.21M| else { 2186| 3.21M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 3.21M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 6.42M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.21M, False: 378] | | | | ------------------ | | | | 10| 6.42M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 378, False: 0] | | | | ------------------ | | ------------------ | | 45| 3.21M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 3.21M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 3.21M, False: 0] | | | | ------------------ | | | | 399| 3.21M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 3.21M| (*(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: 3.21M, False: 0] | | ------------------ | | 46| 3.21M| emitter->column ++, \ | | 47| 3.21M| 1)) ------------------ 2187| 3.21M| } 2188| 4.95M| spaces = 1; 2189| 4.95M| } 2190| 10.1M| else 2191| 10.1M| { 2192| 10.1M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 10.1M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 20.2M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 10.1M, False: 926] | | | | ------------------ | | | | 10| 20.2M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 926, False: 0] | | | | ------------------ | | ------------------ | | 45| 10.1M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 10.1M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 8.63M, False: 1.47M] | | | | ------------------ | | | | 399| 10.1M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 10.1M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 5.63k, False: 1.46M] | | | | ------------------ | | | | 401| 1.47M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 5.63k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 1.47M| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 1.46M, False: 0] | | | | ------------------ | | | | 404| 1.46M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 1.46M| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 1.46M| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 1.46M| (*(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: 10.1M, False: 0] | | ------------------ | | 46| 10.1M| emitter->column ++, \ | | 47| 10.1M| 1)) ------------------ 2193| 10.1M| spaces = 0; 2194| 10.1M| } 2195| 23.0M| } 2196| | 2197| 2.50M| if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0)) ------------------ | Branch (2197:9): [True: 0, False: 2.50M] ------------------ 2198| 0| return 0; 2199| | 2200| 2.50M| emitter->whitespace = 0; 2201| 2.50M| emitter->indention = 0; 2202| | 2203| 2.50M| return 1; 2204| 2.50M|} emitter.c:yaml_emitter_write_literal_scalar: 2267| 11.7k|{ 2268| 11.7k| yaml_string_t string; 2269| 11.7k| int breaks = 1; 2270| | 2271| 11.7k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 11.7k| ((value).start = (string), \ | | 129| 11.7k| (value).end = (string)+(length), \ | | 130| 11.7k| (value).pointer = (string)) ------------------ 2272| | 2273| 11.7k| if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0)) ------------------ | Branch (2273:9): [True: 0, False: 11.7k] ------------------ 2274| 0| return 0; 2275| 11.7k| if (!yaml_emitter_write_block_scalar_hints(emitter, string)) ------------------ | Branch (2275:9): [True: 0, False: 11.7k] ------------------ 2276| 0| return 0; 2277| 11.7k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 11.7k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 23.4k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 11.5k, False: 196] | | | | ------------------ | | | | 10| 23.4k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 196, False: 0] | | | | ------------------ | | ------------------ | | 28| 11.7k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 11.7k, False: 0] | | | Branch (28:11): [True: 0, False: 11.7k] | | ------------------ | | 29| 11.7k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 11.7k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 11.7k, False: 0] | | ------------------ | | 31| 11.7k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 11.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| 11.7k| emitter->column = 0, \ | | 36| 11.7k| emitter->line ++, \ | | 37| 11.7k| 1)) ------------------ 2278| 11.7k| emitter->indention = 1; 2279| 11.7k| emitter->whitespace = 1; 2280| | 2281| 529k| while (string.pointer != string.end) ------------------ | Branch (2281:12): [True: 517k, False: 11.7k] ------------------ 2282| 517k| { 2283| 517k| if (IS_BREAK(string)) ------------------ | | 341| 517k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 517k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 1.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 517k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 517k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 1.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 27.7k, False: 490k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 517k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 980k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 200, False: 489k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 490k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 200| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 200] | | | | | | ------------------ | | | | ------------------ | | | | 334| 517k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 980k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 101k, False: 388k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 490k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 591k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 31.0k, False: 70.3k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 490k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 31.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 771, False: 30.3k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 517k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 978k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 100k, False: 388k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 489k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 590k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 30.3k, False: 70.3k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 489k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 30.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 471, False: 29.8k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2284| 28.9k| { 2285| 28.9k| if (!WRITE_BREAK(emitter, string)) return 0; ------------------ | | 54| 28.9k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 57.9k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 28.7k, False: 194] | | | | ------------------ | | | | 10| 57.9k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 55| 28.9k| && (CHECK(string,'\n') ? \ | | ------------------ | | | | 181| 28.9k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | | | ------------------ | | | | | | 175| 28.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (181:29): [True: 27.7k, False: 1.24k] | | | | ------------------ | | ------------------ | | | Branch (55:9): [True: 28.9k, False: 0] | | ------------------ | | 56| 28.9k| (PUT_BREAK(emitter), \ | | ------------------ | | | | 27| 27.7k| (FLUSH(emitter) \ | | | | ------------------ | | | | | | 9| 55.4k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | | | ------------------ | | | | | | | Branch (9:6): [True: 27.7k, False: 0] | | | | | | ------------------ | | | | | | 10| 55.4k| || yaml_emitter_flush(emitter)) | | | | | | ------------------ | | | | | | | Branch (10:9): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 28| 27.7k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | | | ------------------ | | | | | Branch (28:9): [True: 27.7k, False: 0] | | | | | Branch (28:11): [True: 0, False: 27.7k] | | | | ------------------ | | | | 29| 27.7k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | | | 30| 27.7k| emitter->line_break == YAML_LN_BREAK ? \ | | | | ------------------ | | | | | Branch (30:11): [True: 27.7k, False: 0] | | | | ------------------ | | | | 31| 27.7k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | | | 32| 27.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| 27.7k| emitter->column = 0, \ | | | | 36| 27.7k| emitter->line ++, \ | | | | 37| 27.7k| 1)) | | ------------------ | | 57| 27.7k| string.pointer ++, \ | | 58| 27.7k| 1) : \ | | 59| 28.9k| (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.24k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 0, False: 1.24k] | | | | ------------------ | | | | 399| 1.24k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.24k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 1.24k] | | | | ------------------ | | | | 401| 1.24k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 1.24k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 1.24k, False: 0] | | | | ------------------ | | | | 404| 1.24k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 1.24k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 1.24k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 1.24k| (*(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.24k| emitter->column = 0, \ | | 61| 1.24k| emitter->line ++, \ | | 62| 1.24k| 1))) ------------------ 2286| 28.9k| emitter->indention = 1; 2287| 28.9k| breaks = 1; 2288| 28.9k| } 2289| 488k| else 2290| 488k| { 2291| 488k| if (breaks) { ------------------ | Branch (2291:17): [True: 17.7k, False: 471k] ------------------ 2292| 17.7k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2292:21): [True: 0, False: 17.7k] ------------------ 2293| 17.7k| } 2294| 488k| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 488k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 977k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 488k, False: 241] | | | | ------------------ | | | | 10| 977k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 241, False: 0] | | | | ------------------ | | ------------------ | | 45| 488k| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 488k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 377k, False: 111k] | | | | ------------------ | | | | 399| 488k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 488k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 213, False: 110k] | | | | ------------------ | | | | 401| 111k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 213| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 111k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 110k, False: 0] | | | | ------------------ | | | | 404| 110k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 110k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 110k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 110k| (*(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: 488k, False: 0] | | ------------------ | | 46| 488k| emitter->column ++, \ | | 47| 488k| 1)) ------------------ 2295| 488k| emitter->indention = 0; 2296| 488k| breaks = 0; 2297| 488k| } 2298| 517k| } 2299| | 2300| 11.7k| return 1; 2301| 11.7k|} emitter.c:yaml_emitter_write_block_scalar_hints: 2209| 15.7k|{ 2210| 15.7k| char indent_hint[2]; 2211| 15.7k| const char *chomp_hint = NULL; 2212| | 2213| 15.7k| if (IS_SPACE(string) || IS_BREAK(string)) ------------------ | | 306| 15.7k|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 15.7k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 31.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 205, False: 15.5k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (IS_SPACE(string) || IS_BREAK(string)) ------------------ | | 341| 15.5k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 15.5k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 31.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 15.5k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 15.5k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 31.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 9.85k, False: 5.71k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 15.5k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 11.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 590, False: 5.12k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 5.71k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 590| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 590] | | | | | | ------------------ | | | | ------------------ | | | | 334| 15.5k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 11.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.22k, False: 2.49k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 5.71k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 8.93k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.72k, False: 497] | | | | | | ------------------ | | | | ------------------ | | | | 336| 5.71k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 2.72k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 593, False: 2.13k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 15.5k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 10.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.62k, False: 2.49k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 5.12k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 7.75k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.13k, False: 497] | | | | | | ------------------ | | | | ------------------ | | | | 339| 5.12k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 2.13k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 404, False: 1.72k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2214| 11.0k| { 2215| 11.0k| indent_hint[0] = '0' + (char)emitter->best_indent; 2216| 11.0k| indent_hint[1] = '\0'; 2217| 11.0k| if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0)) ------------------ | Branch (2217:13): [True: 0, False: 11.0k] ------------------ 2218| 0| return 0; 2219| 11.0k| } 2220| | 2221| 15.7k| emitter->open_ended = 0; 2222| | 2223| 15.7k| string.pointer = string.end; 2224| 15.7k| if (string.start == string.pointer) ------------------ | Branch (2224:9): [True: 0, False: 15.7k] ------------------ 2225| 0| { 2226| 0| chomp_hint = "-"; 2227| 0| } 2228| 15.7k| else 2229| 15.7k| { 2230| 18.4k| do { 2231| 18.4k| string.pointer --; 2232| 18.4k| } while ((*string.pointer & 0xC0) == 0x80); ------------------ | Branch (2232:18): [True: 2.72k, False: 15.7k] ------------------ 2233| 15.7k| if (!IS_BREAK(string)) ------------------ | | 341| 15.7k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 15.7k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 31.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 15.7k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 15.7k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 31.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 12.7k, False: 3.00k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 15.7k| || (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| 15.7k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.22k, False: 1.77k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 3.00k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 4.22k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 979, False: 244] | | | | | | ------------------ | | | | ------------------ | | | | 336| 3.00k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 979| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 416, False: 563] | | | | | | ------------------ | | | | ------------------ | | | | 337| 15.7k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.17k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 807, False: 1.77k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.58k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.39k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 563, False: 244] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.58k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 563| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 217, False: 346] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2234| 2.36k| { 2235| 2.36k| chomp_hint = "-"; 2236| 2.36k| } 2237| 13.4k| else if (string.start == string.pointer) ------------------ | Branch (2237:18): [True: 9.96k, False: 3.44k] ------------------ 2238| 9.96k| { 2239| 9.96k| chomp_hint = "+"; 2240| 9.96k| emitter->open_ended = 2; 2241| 9.96k| } 2242| 3.44k| else 2243| 3.44k| { 2244| 6.12k| do { 2245| 6.12k| string.pointer --; 2246| 6.12k| } while ((*string.pointer & 0xC0) == 0x80); ------------------ | Branch (2246:22): [True: 2.68k, False: 3.44k] ------------------ 2247| 3.44k| if (IS_BREAK(string)) ------------------ | | 341| 3.44k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 3.44k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 6.88k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 3.44k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 3.44k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 6.88k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 597, False: 2.84k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 3.44k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.68k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 399, False: 2.44k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 2.84k| && 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| 3.44k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.68k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.13k, False: 1.70k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 2.84k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.98k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 865, False: 274] | | | | | | ------------------ | | | | ------------------ | | | | 336| 2.84k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 865| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 215, False: 650] | | | | | | ------------------ | | | | ------------------ | | | | 337| 3.44k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.25k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 924, False: 1.70k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.62k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.55k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 650, False: 274] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.62k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 650| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 290, False: 360] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2248| 1.10k| { 2249| 1.10k| chomp_hint = "+"; 2250| 1.10k| emitter->open_ended = 2; 2251| 1.10k| } 2252| 3.44k| } 2253| 15.7k| } 2254| | 2255| 15.7k| if (chomp_hint) ------------------ | Branch (2255:9): [True: 13.4k, False: 2.33k] ------------------ 2256| 13.4k| { 2257| 13.4k| if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0)) ------------------ | Branch (2257:13): [True: 0, False: 13.4k] ------------------ 2258| 0| return 0; 2259| 13.4k| } 2260| | 2261| 15.7k| return 1; 2262| 15.7k|} emitter.c:yaml_emitter_write_folded_scalar: 2306| 4.06k|{ 2307| 4.06k| yaml_string_t string; 2308| 4.06k| int breaks = 1; 2309| 4.06k| int leading_spaces = 1; 2310| | 2311| 4.06k| STRING_ASSIGN(string, value, length); ------------------ | | 128| 4.06k| ((value).start = (string), \ | | 129| 4.06k| (value).end = (string)+(length), \ | | 130| 4.06k| (value).pointer = (string)) ------------------ 2312| | 2313| 4.06k| if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0)) ------------------ | Branch (2313:9): [True: 0, False: 4.06k] ------------------ 2314| 0| return 0; 2315| 4.06k| if (!yaml_emitter_write_block_scalar_hints(emitter, string)) ------------------ | Branch (2315:9): [True: 0, False: 4.06k] ------------------ 2316| 0| return 0; 2317| 4.06k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 4.06k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 8.13k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.87k, False: 194] | | | | ------------------ | | | | 10| 8.13k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 28| 4.06k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 4.06k, False: 0] | | | Branch (28:11): [True: 0, False: 4.06k] | | ------------------ | | 29| 4.06k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 4.06k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 4.06k, False: 0] | | ------------------ | | 31| 4.06k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 4.06k| 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.06k| emitter->column = 0, \ | | 36| 4.06k| emitter->line ++, \ | | 37| 4.06k| 1)) ------------------ 2318| 4.06k| emitter->indention = 1; 2319| 4.06k| emitter->whitespace = 1; 2320| | 2321| 3.55M| while (string.pointer != string.end) ------------------ | Branch (2321:12): [True: 3.54M, False: 4.06k] ------------------ 2322| 3.54M| { 2323| 3.54M| if (IS_BREAK(string)) ------------------ | | 341| 3.54M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 3.54M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 7.09M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 3.54M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 3.54M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 7.09M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 397k, False: 3.14M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 3.54M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.28k, False: 3.14M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 3.14M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 3.28k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, False: 3.28k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 3.54M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 269k, False: 2.88M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 3.14M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 261k, False: 7.95k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 3.14M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 261k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 949, False: 260k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 3.54M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 268k, False: 2.88M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 3.14M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 260k, False: 7.95k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 3.14M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 260k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 967, False: 259k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2324| 399k| { 2325| 399k| if (!breaks && !leading_spaces && CHECK(string, '\n')) { ------------------ | | 181| 12.8k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 12.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.3k, False: 541] | | ------------------ ------------------ | Branch (2325:17): [True: 13.7k, False: 386k] | Branch (2325:28): [True: 12.8k, False: 873] ------------------ 2326| 12.3k| int k = 0; 2327| 309k| while (IS_BREAK_AT(string, k)) { ------------------ | | 330| 309k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | ------------------ | | | | 175| 619k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 0, False: 309k] | | | | ------------------ | | ------------------ | | 331| 309k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | ------------------ | | | | 175| 619k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 296k, False: 13.0k] | | | | ------------------ | | ------------------ | | 332| 309k| || (CHECK_AT((string),'\xC2',(offset)) \ | | ------------------ | | | | 175| 26.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 322, False: 12.7k] | | | | ------------------ | | ------------------ | | 333| 13.0k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | ------------------ | | | | 175| 322| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 0, False: 322] | | | | ------------------ | | ------------------ | | 334| 309k| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 26.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 9.74k, False: 3.28k] | | | | ------------------ | | ------------------ | | 335| 13.0k| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 22.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 9.14k, False: 606] | | | | ------------------ | | ------------------ | | 336| 13.0k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | ------------------ | | | | 175| 9.14k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 377, False: 8.76k] | | | | ------------------ | | ------------------ | | 337| 309k| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 25.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 9.37k, False: 3.28k] | | | | ------------------ | | ------------------ | | 338| 12.6k| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 22.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 8.76k, False: 606] | | | | ------------------ | | ------------------ | | 339| 12.6k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | ------------------ | | | | 175| 8.76k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 321, False: 8.44k] | | | | ------------------ | | ------------------ ------------------ 2328| 297k| k += WIDTH_AT(string, k); ------------------ | | 380| 297k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | ------------------ | | | Branch (380:7): [True: 296k, False: 698] | | ------------------ | | 381| 297k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | ------------------ | | | Branch (381:7): [True: 0, False: 698] | | ------------------ | | 382| 698| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | ------------------ | | | Branch (382:7): [True: 698, False: 0] | | ------------------ | | 383| 698| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | ------------------ | | | Branch (383:7): [True: 0, False: 0] | | ------------------ ------------------ 2329| 297k| } 2330| 12.3k| if (!IS_BLANKZ_AT(string, k)) { ------------------ | | 371| 12.3k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 24.6k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 12.3k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 24.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 709, False: 11.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 11.6k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 11.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 11.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 11.6k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 23.2k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 23.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 11.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 11.6k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 23.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 11.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 11.6k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 23.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 322, False: 11.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 11.6k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 322| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 322] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 11.6k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 23.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 9.05k, False: 2.57k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 11.6k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 20.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.44k, False: 606] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 11.6k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 8.44k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 8.44k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 23.2k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 23.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 9.05k, False: 2.57k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 11.6k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 20.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.44k, False: 606] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 11.6k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 8.44k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 8.44k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 11.6k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 11.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.50k, False: 10.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2331| 10.1k| if (!PUT_BREAK(emitter)) return 0; ------------------ | | 27| 10.1k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 20.2k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 9.93k, False: 194] | | | | ------------------ | | | | 10| 20.2k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 194, False: 0] | | | | ------------------ | | ------------------ | | 28| 10.1k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | ------------------ | | | Branch (28:9): [True: 10.1k, False: 0] | | | Branch (28:11): [True: 0, False: 10.1k] | | ------------------ | | 29| 10.1k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | 30| 10.1k| emitter->line_break == YAML_LN_BREAK ? \ | | ------------------ | | | Branch (30:11): [True: 10.1k, False: 0] | | ------------------ | | 31| 10.1k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | 32| 10.1k| 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.1k| emitter->column = 0, \ | | 36| 10.1k| emitter->line ++, \ | | 37| 10.1k| 1)) ------------------ 2332| 10.1k| } 2333| 12.3k| } 2334| 399k| if (!WRITE_BREAK(emitter, string)) return 0; ------------------ | | 54| 399k| (FLUSH(emitter) \ | | ------------------ | | | | 9| 799k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 399k, False: 215] | | | | ------------------ | | | | 10| 799k| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 215, False: 0] | | | | ------------------ | | ------------------ | | 55| 399k| && (CHECK(string,'\n') ? \ | | ------------------ | | | | 181| 399k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | | | ------------------ | | | | | | 175| 399k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (181:29): [True: 397k, False: 1.91k] | | | | ------------------ | | ------------------ | | | Branch (55:9): [True: 399k, False: 0] | | ------------------ | | 56| 399k| (PUT_BREAK(emitter), \ | | ------------------ | | | | 27| 397k| (FLUSH(emitter) \ | | | | ------------------ | | | | | | 9| 795k| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | | | ------------------ | | | | | | | Branch (9:6): [True: 397k, False: 0] | | | | | | ------------------ | | | | | | 10| 795k| || yaml_emitter_flush(emitter)) | | | | | | ------------------ | | | | | | | Branch (10:9): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 28| 397k| && ((emitter->line_break == YAML_CR_BREAK ? \ | | | | ------------------ | | | | | Branch (28:9): [True: 397k, False: 0] | | | | | Branch (28:11): [True: 0, False: 397k] | | | | ------------------ | | | | 29| 397k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \ | | | | 30| 397k| emitter->line_break == YAML_LN_BREAK ? \ | | | | ------------------ | | | | | Branch (30:11): [True: 397k, False: 0] | | | | ------------------ | | | | 31| 397k| (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \ | | | | 32| 397k| 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| 397k| emitter->column = 0, \ | | | | 36| 397k| emitter->line ++, \ | | | | 37| 397k| 1)) | | ------------------ | | 57| 397k| string.pointer ++, \ | | 58| 397k| 1) : \ | | 59| 399k| (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 1.91k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 0, False: 1.91k] | | | | ------------------ | | | | 399| 1.91k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 1.91k| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 0, False: 1.91k] | | | | ------------------ | | | | 401| 1.91k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 0| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 1.91k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 1.91k, False: 0] | | | | ------------------ | | | | 404| 1.91k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 1.91k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 1.91k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 1.91k| (*(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.91k| emitter->column = 0, \ | | 61| 1.91k| emitter->line ++, \ | | 62| 1.91k| 1))) ------------------ 2335| 399k| emitter->indention = 1; 2336| 399k| breaks = 1; 2337| 399k| } 2338| 3.14M| else 2339| 3.14M| { 2340| 3.14M| if (breaks) { ------------------ | Branch (2340:17): [True: 15.6k, False: 3.13M] ------------------ 2341| 15.6k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2341:21): [True: 0, False: 15.6k] ------------------ 2342| 15.6k| leading_spaces = IS_BLANK(string); ------------------ | | 323| 15.6k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 15.6k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 15.6k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 31.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 959, False: 14.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 14.6k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 14.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 14.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2343| 15.6k| } 2344| 3.14M| if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1) ------------------ | | 306| 3.14M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 3.13M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 6.27M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 145k, False: 2.98M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1) ------------------ | | 304| 145k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | ------------------ | | | | 175| 3.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2344:17): [True: 3.13M, False: 15.6k] | Branch (2344:48): [True: 74.3k, False: 70.8k] ------------------ 2345| 74.3k| && emitter->column > emitter->best_width) { ------------------ | Branch (2345:24): [True: 2.35k, False: 72.0k] ------------------ 2346| 2.35k| if (!yaml_emitter_write_indent(emitter)) return 0; ------------------ | Branch (2346:21): [True: 0, False: 2.35k] ------------------ 2347| 2.35k| MOVE(string); ------------------ | | 391| 2.35k|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 2.35k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.35k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.35k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.35k| ((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.35k| } 2349| 3.14M| else { 2350| 3.14M| if (!WRITE(emitter, string)) return 0; ------------------ | | 44| 3.14M| (FLUSH(emitter) \ | | ------------------ | | | | 9| 6.29M| ((emitter->buffer.pointer+5 < emitter->buffer.end) \ | | | | ------------------ | | | | | Branch (9:6): [True: 3.14M, False: 433] | | | | ------------------ | | | | 10| 6.29M| || yaml_emitter_flush(emitter)) | | | | ------------------ | | | | | Branch (10:9): [True: 433, False: 0] | | | | ------------------ | | ------------------ | | 45| 3.14M| && (COPY(emitter->buffer,string), \ | | ------------------ | | | | 398| 3.14M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 2.67M, False: 474k] | | | | ------------------ | | | | 399| 3.14M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 3.14M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 3.35k, False: 470k] | | | | ------------------ | | | | 401| 474k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 3.35k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 474k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 470k, False: 0] | | | | ------------------ | | | | 404| 470k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 470k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 470k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 470k| (*(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: 3.14M, False: 0] | | ------------------ | | 46| 3.14M| emitter->column ++, \ | | 47| 3.14M| 1)) ------------------ 2351| 3.14M| } 2352| 3.14M| emitter->indention = 0; 2353| 3.14M| breaks = 0; 2354| 3.14M| } 2355| 3.54M| } 2356| | 2357| 4.06k| return 1; 2358| 4.06k|} emitter.c:yaml_emitter_emit_sequence_start: 1062| 130k|{ 1063| 130k| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1063:9): [True: 0, False: 130k] ------------------ 1064| 0| return 0; 1065| 130k| if (!yaml_emitter_process_tag(emitter)) ------------------ | Branch (1065:9): [True: 0, False: 130k] ------------------ 1066| 0| return 0; 1067| | 1068| 130k| if (emitter->flow_level || emitter->canonical ------------------ | Branch (1068:9): [True: 95.6k, False: 34.6k] | Branch (1068:32): [True: 3.64k, False: 31.0k] ------------------ 1069| 31.0k| || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE ------------------ | Branch (1069:16): [True: 559, False: 30.4k] ------------------ 1070| 99.8k| || yaml_emitter_check_empty_sequence(emitter)) { ------------------ | Branch (1070:16): [True: 0, False: 30.4k] ------------------ 1071| 99.8k| emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE; 1072| 99.8k| } 1073| 30.4k| else { 1074| 30.4k| emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE; 1075| 30.4k| } 1076| | 1077| 130k| return 1; 1078| 130k|} emitter.c:yaml_emitter_check_empty_sequence: 1120| 37.4k|{ 1121| 37.4k| if (emitter->events.tail - emitter->events.head < 2) ------------------ | Branch (1121:9): [True: 0, False: 37.4k] ------------------ 1122| 0| return 0; 1123| | 1124| 37.4k| return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT ------------------ | Branch (1124:13): [True: 37.4k, False: 0] ------------------ 1125| 37.4k| && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT); ------------------ | Branch (1125:16): [True: 378, False: 37.0k] ------------------ 1126| 37.4k|} emitter.c:yaml_emitter_emit_mapping_start: 1086| 2.16M|{ 1087| 2.16M| if (!yaml_emitter_process_anchor(emitter)) ------------------ | Branch (1087:9): [True: 0, False: 2.16M] ------------------ 1088| 0| return 0; 1089| 2.16M| if (!yaml_emitter_process_tag(emitter)) ------------------ | Branch (1089:9): [True: 0, False: 2.16M] ------------------ 1090| 0| return 0; 1091| | 1092| 2.16M| if (emitter->flow_level || emitter->canonical ------------------ | Branch (1092:9): [True: 1.56M, False: 602k] | Branch (1092:32): [True: 16.0k, False: 586k] ------------------ 1093| 586k| || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE ------------------ | Branch (1093:16): [True: 530, False: 586k] ------------------ 1094| 1.57M| || yaml_emitter_check_empty_mapping(emitter)) { ------------------ | Branch (1094:16): [True: 0, False: 586k] ------------------ 1095| 1.57M| emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE; 1096| 1.57M| } 1097| 586k| else { 1098| 586k| emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE; 1099| 586k| } 1100| | 1101| 2.16M| return 1; 1102| 2.16M|} emitter.c:yaml_emitter_check_empty_mapping: 1134| 1.02M|{ 1135| 1.02M| if (emitter->events.tail - emitter->events.head < 2) ------------------ | Branch (1135:9): [True: 0, False: 1.02M] ------------------ 1136| 0| return 0; 1137| | 1138| 1.02M| return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT ------------------ | Branch (1138:13): [True: 1.02M, False: 0] ------------------ 1139| 1.02M| && emitter->events.head[1].type == YAML_MAPPING_END_EVENT); ------------------ | Branch (1139:16): [True: 375, False: 1.02M] ------------------ 1140| 1.02M|} emitter.c:yaml_emitter_emit_document_end: 707| 59.1k|{ 708| 59.1k| if (event->type == YAML_DOCUMENT_END_EVENT) ------------------ | Branch (708:9): [True: 59.1k, False: 0] ------------------ 709| 59.1k| { 710| 59.1k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (710:13): [True: 0, False: 59.1k] ------------------ 711| 0| return 0; 712| 59.1k| if (!event->data.document_end.implicit) { ------------------ | Branch (712:13): [True: 952, False: 58.1k] ------------------ 713| 952| if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) ------------------ | Branch (713:17): [True: 0, False: 952] ------------------ 714| 0| return 0; 715| 952| emitter->open_ended = 0; 716| 952| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (716:17): [True: 0, False: 952] ------------------ 717| 0| return 0; 718| 952| } 719| 58.1k| else if (!emitter->open_ended) ------------------ | Branch (719:18): [True: 55.9k, False: 2.25k] ------------------ 720| 55.9k| emitter->open_ended = 1; 721| 59.1k| if (!yaml_emitter_flush(emitter)) ------------------ | Branch (721:13): [True: 5.04k, False: 54.0k] ------------------ 722| 5.04k| return 0; 723| | 724| 54.0k| emitter->state = YAML_EMIT_DOCUMENT_START_STATE; 725| | 726| 246k| while (!STACK_EMPTY(emitter, emitter->tag_directives)) { ------------------ | | 436| 246k| ((stack).start == (stack).top) ------------------ | Branch (726:16): [True: 192k, False: 54.0k] ------------------ 727| 192k| yaml_tag_directive_t tag_directive = POP(emitter, ------------------ | | 454| 192k| (*(--(stack).top)) ------------------ 728| 192k| emitter->tag_directives); 729| 192k| yaml_free(tag_directive.handle); 730| 192k| yaml_free(tag_directive.prefix); 731| 192k| } 732| | 733| 54.0k| return 1; 734| 59.1k| } 735| | 736| 0| return yaml_emitter_set_emitter_error(emitter, 737| 0| "expected DOCUMENT-END"); 738| 59.1k|} emitter.c:yaml_emitter_emit_flow_sequence_item: 748| 859k|{ 749| 859k| if (first) ------------------ | Branch (749:9): [True: 99.8k, False: 759k] ------------------ 750| 99.8k| { 751| 99.8k| if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0)) ------------------ | Branch (751:13): [True: 0, False: 99.8k] ------------------ 752| 0| return 0; 753| 99.8k| if (!yaml_emitter_increase_indent(emitter, 1, 0)) ------------------ | Branch (753:13): [True: 0, False: 99.8k] ------------------ 754| 0| return 0; 755| 99.8k| emitter->flow_level ++; 756| 99.8k| } 757| | 758| 859k| if (event->type == YAML_SEQUENCE_END_EVENT) ------------------ | Branch (758:9): [True: 99.7k, False: 759k] ------------------ 759| 99.7k| { 760| 99.7k| emitter->flow_level --; 761| 99.7k| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 99.7k| (*(--(stack).top)) ------------------ 762| 99.7k| if (emitter->canonical && !first) { ------------------ | Branch (762:13): [True: 92.1k, False: 7.65k] | Branch (762:35): [True: 91.8k, False: 250] ------------------ 763| 91.8k| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (763:17): [True: 0, False: 91.8k] ------------------ 764| 0| return 0; 765| 91.8k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (765:17): [True: 0, False: 91.8k] ------------------ 766| 0| return 0; 767| 91.8k| } 768| 99.7k| if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0)) ------------------ | Branch (768:13): [True: 0, False: 99.7k] ------------------ 769| 0| return 0; 770| 99.7k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 99.7k| (*(--(stack).top)) ------------------ 771| | 772| 99.7k| return 1; 773| 99.7k| } 774| | 775| 759k| if (!first) { ------------------ | Branch (775:9): [True: 660k, False: 99.1k] ------------------ 776| 660k| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (776:13): [True: 0, False: 660k] ------------------ 777| 0| return 0; 778| 660k| } 779| | 780| 759k| if (emitter->canonical || emitter->column > emitter->best_width) { ------------------ | Branch (780:9): [True: 744k, False: 15.1k] | Branch (780:31): [True: 5.57k, False: 9.61k] ------------------ 781| 750k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (781:13): [True: 0, False: 750k] ------------------ 782| 0| return 0; 783| 750k| } 784| 759k| if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE)) ------------------ | | 445| 759k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 759k, False: 405] | | ------------------ | | 446| 759k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 405, False: 0] | | ------------------ | | 447| 405| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 759k| (*((stack).top++) = value, \ | | 449| 759k| 1) : \ | | 450| 759k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (784:9): [True: 0, False: 759k] ------------------ 785| 0| return 0; 786| | 787| 759k| return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); 788| 759k|} emitter.c:yaml_emitter_emit_flow_mapping_key: 797| 3.63M|{ 798| 3.63M| if (first) ------------------ | Branch (798:9): [True: 1.57M, False: 2.05M] ------------------ 799| 1.57M| { 800| 1.57M| if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0)) ------------------ | Branch (800:13): [True: 0, False: 1.57M] ------------------ 801| 0| return 0; 802| 1.57M| if (!yaml_emitter_increase_indent(emitter, 1, 0)) ------------------ | Branch (802:13): [True: 0, False: 1.57M] ------------------ 803| 0| return 0; 804| 1.57M| emitter->flow_level ++; 805| 1.57M| } 806| | 807| 3.63M| if (event->type == YAML_MAPPING_END_EVENT) ------------------ | Branch (807:9): [True: 1.57M, False: 2.05M] ------------------ 808| 1.57M| { 809| 1.57M| emitter->flow_level --; 810| 1.57M| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 1.57M| (*(--(stack).top)) ------------------ 811| 1.57M| if (emitter->canonical && !first) { ------------------ | Branch (811:13): [True: 1.56M, False: 9.82k] | Branch (811:35): [True: 1.56M, False: 338] ------------------ 812| 1.56M| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (812:17): [True: 0, False: 1.56M] ------------------ 813| 0| return 0; 814| 1.56M| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (814:17): [True: 0, False: 1.56M] ------------------ 815| 0| return 0; 816| 1.56M| } 817| 1.57M| if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0)) ------------------ | Branch (817:13): [True: 0, False: 1.57M] ------------------ 818| 0| return 0; 819| 1.57M| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 1.57M| (*(--(stack).top)) ------------------ 820| | 821| 1.57M| return 1; 822| 1.57M| } 823| | 824| 2.05M| if (!first) { ------------------ | Branch (824:9): [True: 477k, False: 1.57M] ------------------ 825| 477k| if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) ------------------ | Branch (825:13): [True: 0, False: 477k] ------------------ 826| 0| return 0; 827| 477k| } 828| 2.05M| if (emitter->canonical || emitter->column > emitter->best_width) { ------------------ | Branch (828:9): [True: 1.69M, False: 356k] | Branch (828:31): [True: 49.4k, False: 307k] ------------------ 829| 1.74M| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (829:13): [True: 0, False: 1.74M] ------------------ 830| 0| return 0; 831| 1.74M| } 832| | 833| 2.05M| if (!emitter->canonical && yaml_emitter_check_simple_key(emitter)) ------------------ | Branch (833:9): [True: 356k, False: 1.69M] | Branch (833:32): [True: 348k, False: 7.85k] ------------------ 834| 348k| { 835| 348k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 348k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 348k, False: 38] | | ------------------ | | 446| 348k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 38, False: 0] | | ------------------ | | 447| 38| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 348k| (*((stack).top++) = value, \ | | 449| 348k| 1) : \ | | 450| 348k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (835:13): [True: 0, False: 348k] ------------------ 836| 348k| YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)) 837| 0| return 0; 838| | 839| 348k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); 840| 348k| } 841| 1.70M| else 842| 1.70M| { 843| 1.70M| if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0)) ------------------ | Branch (843:13): [True: 0, False: 1.70M] ------------------ 844| 0| return 0; 845| 1.70M| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 1.70M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.70M, False: 1.35k] | | ------------------ | | 446| 1.70M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.35k, False: 0] | | ------------------ | | 447| 1.35k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.70M| (*((stack).top++) = value, \ | | 449| 1.70M| 1) : \ | | 450| 1.70M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (845:13): [True: 0, False: 1.70M] ------------------ 846| 1.70M| YAML_EMIT_FLOW_MAPPING_VALUE_STATE)) 847| 0| return 0; 848| | 849| 1.70M| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 850| 1.70M| } 851| 2.05M|} emitter.c:yaml_emitter_check_simple_key: 1148| 1.01M|{ 1149| 1.01M| yaml_event_t *event = emitter->events.head; 1150| 1.01M| size_t length = 0; 1151| | 1152| 1.01M| switch (event->type) 1153| 1.01M| { 1154| 256k| case YAML_ALIAS_EVENT: ------------------ | Branch (1154:9): [True: 256k, False: 757k] ------------------ 1155| 256k| length += emitter->anchor_data.anchor_length; 1156| 256k| break; 1157| | 1158| 309k| case YAML_SCALAR_EVENT: ------------------ | Branch (1158:9): [True: 309k, False: 704k] ------------------ 1159| 309k| if (emitter->scalar_data.multiline) ------------------ | Branch (1159:17): [True: 12.9k, False: 296k] ------------------ 1160| 12.9k| return 0; 1161| 296k| length += emitter->anchor_data.anchor_length 1162| 296k| + emitter->tag_data.handle_length 1163| 296k| + emitter->tag_data.suffix_length 1164| 296k| + emitter->scalar_data.length; 1165| 296k| break; 1166| | 1167| 6.96k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1167:9): [True: 6.96k, False: 1.00M] ------------------ 1168| 6.96k| if (!yaml_emitter_check_empty_sequence(emitter)) ------------------ | Branch (1168:17): [True: 6.59k, False: 378] ------------------ 1169| 6.59k| return 0; 1170| 378| length += emitter->anchor_data.anchor_length 1171| 378| + emitter->tag_data.handle_length 1172| 378| + emitter->tag_data.suffix_length; 1173| 378| break; 1174| | 1175| 441k| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1175:9): [True: 441k, False: 572k] ------------------ 1176| 441k| if (!yaml_emitter_check_empty_mapping(emitter)) ------------------ | Branch (1176:17): [True: 441k, False: 375] ------------------ 1177| 441k| return 0; 1178| 375| length += emitter->anchor_data.anchor_length 1179| 375| + emitter->tag_data.handle_length 1180| 375| + emitter->tag_data.suffix_length; 1181| 375| break; 1182| | 1183| 0| default: ------------------ | Branch (1183:9): [True: 0, False: 1.01M] ------------------ 1184| 0| return 0; 1185| 1.01M| } 1186| | 1187| 553k| if (length > 128) ------------------ | Branch (1187:9): [True: 2.91k, False: 550k] ------------------ 1188| 2.91k| return 0; 1189| | 1190| 550k| return 1; 1191| 553k|} emitter.c:yaml_emitter_emit_flow_mapping_value: 860| 2.05M|{ 861| 2.05M| if (simple) { ------------------ | Branch (861:9): [True: 348k, False: 1.70M] ------------------ 862| 348k| if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) ------------------ | Branch (862:13): [True: 0, False: 348k] ------------------ 863| 0| return 0; 864| 348k| } 865| 1.70M| else { 866| 1.70M| if (emitter->canonical || emitter->column > emitter->best_width) { ------------------ | Branch (866:13): [True: 1.69M, False: 7.85k] | Branch (866:35): [True: 5.06k, False: 2.79k] ------------------ 867| 1.70M| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (867:17): [True: 0, False: 1.70M] ------------------ 868| 0| return 0; 869| 1.70M| } 870| 1.70M| if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0)) ------------------ | Branch (870:13): [True: 0, False: 1.70M] ------------------ 871| 0| return 0; 872| 1.70M| } 873| 2.05M| if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE)) ------------------ | | 445| 2.05M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.05M, False: 0] | | ------------------ | | 446| 2.05M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.05M| (*((stack).top++) = value, \ | | 449| 2.05M| 1) : \ | | 450| 2.05M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (873:9): [True: 0, False: 2.05M] ------------------ 874| 0| return 0; 875| 2.05M| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 876| 2.05M|} emitter.c:yaml_emitter_emit_block_sequence_item: 885| 178k|{ 886| 178k| if (first) ------------------ | Branch (886:9): [True: 30.4k, False: 148k] ------------------ 887| 30.4k| { 888| 30.4k| if (!yaml_emitter_increase_indent(emitter, 0, ------------------ | Branch (888:13): [True: 0, False: 30.4k] ------------------ 889| 30.4k| (emitter->mapping_context && !emitter->indention))) ------------------ | Branch (889:22): [True: 17.9k, False: 12.5k] | Branch (889:50): [True: 16.8k, False: 1.08k] ------------------ 890| 0| return 0; 891| 30.4k| } 892| | 893| 178k| if (event->type == YAML_SEQUENCE_END_EVENT) ------------------ | Branch (893:9): [True: 30.2k, False: 148k] ------------------ 894| 30.2k| { 895| 30.2k| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 30.2k| (*(--(stack).top)) ------------------ 896| 30.2k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 30.2k| (*(--(stack).top)) ------------------ 897| | 898| 30.2k| return 1; 899| 30.2k| } 900| | 901| 148k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (901:9): [True: 0, False: 148k] ------------------ 902| 0| return 0; 903| 148k| if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1)) ------------------ | Branch (903:9): [True: 0, False: 148k] ------------------ 904| 0| return 0; 905| 148k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 148k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 148k, False: 188] | | ------------------ | | 446| 148k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 188, False: 0] | | ------------------ | | 447| 188| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 148k| (*((stack).top++) = value, \ | | 449| 148k| 1) : \ | | 450| 148k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (905:9): [True: 0, False: 148k] ------------------ 906| 148k| YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE)) 907| 0| return 0; 908| | 909| 148k| return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); 910| 148k|} emitter.c:yaml_emitter_emit_block_mapping_key: 919| 1.24M|{ 920| 1.24M| if (first) ------------------ | Branch (920:9): [True: 586k, False: 657k] ------------------ 921| 586k| { 922| 586k| if (!yaml_emitter_increase_indent(emitter, 0, 0)) ------------------ | Branch (922:13): [True: 0, False: 586k] ------------------ 923| 0| return 0; 924| 586k| } 925| | 926| 1.24M| if (event->type == YAML_MAPPING_END_EVENT) ------------------ | Branch (926:9): [True: 586k, False: 657k] ------------------ 927| 586k| { 928| 586k| emitter->indent = POP(emitter, emitter->indents); ------------------ | | 454| 586k| (*(--(stack).top)) ------------------ 929| 586k| emitter->state = POP(emitter, emitter->states); ------------------ | | 454| 586k| (*(--(stack).top)) ------------------ 930| | 931| 586k| return 1; 932| 586k| } 933| | 934| 657k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (934:9): [True: 0, False: 657k] ------------------ 935| 0| return 0; 936| | 937| 657k| if (yaml_emitter_check_simple_key(emitter)) ------------------ | Branch (937:9): [True: 201k, False: 455k] ------------------ 938| 201k| { 939| 201k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 201k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 201k, False: 67] | | ------------------ | | 446| 201k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 67, False: 0] | | ------------------ | | 447| 67| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 201k| (*((stack).top++) = value, \ | | 449| 201k| 1) : \ | | 450| 201k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (939:13): [True: 0, False: 201k] ------------------ 940| 201k| YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)) 941| 0| return 0; 942| | 943| 201k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); 944| 201k| } 945| 455k| else 946| 455k| { 947| 455k| if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1)) ------------------ | Branch (947:13): [True: 0, False: 455k] ------------------ 948| 0| return 0; 949| 455k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 455k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 455k, False: 545] | | ------------------ | | 446| 455k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 545, False: 0] | | ------------------ | | 447| 545| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 455k| (*((stack).top++) = value, \ | | 449| 455k| 1) : \ | | 450| 455k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (949:13): [True: 0, False: 455k] ------------------ 950| 455k| YAML_EMIT_BLOCK_MAPPING_VALUE_STATE)) 951| 0| return 0; 952| | 953| 455k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 954| 455k| } 955| 657k|} emitter.c:yaml_emitter_emit_block_mapping_value: 964| 657k|{ 965| 657k| if (simple) { ------------------ | Branch (965:9): [True: 201k, False: 455k] ------------------ 966| 201k| if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) ------------------ | Branch (966:13): [True: 0, False: 201k] ------------------ 967| 0| return 0; 968| 201k| } 969| 455k| else { 970| 455k| if (!yaml_emitter_write_indent(emitter)) ------------------ | Branch (970:13): [True: 0, False: 455k] ------------------ 971| 0| return 0; 972| 455k| if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1)) ------------------ | Branch (972:13): [True: 0, False: 455k] ------------------ 973| 0| return 0; 974| 455k| } 975| 657k| if (!PUSH(emitter, emitter->states, ------------------ | | 445| 657k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 657k, False: 0] | | ------------------ | | 446| 657k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 657k| (*((stack).top++) = value, \ | | 449| 657k| 1) : \ | | 450| 657k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (975:9): [True: 0, False: 657k] ------------------ 976| 657k| YAML_EMIT_BLOCK_MAPPING_KEY_STATE)) 977| 0| return 0; 978| | 979| 657k| return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 980| 657k|} emitter.c:yaml_emitter_set_emitter_error: 269| 49|{ 270| 49| emitter->error = YAML_EMITTER_ERROR; 271| 49| emitter->problem = problem; 272| | 273| 49| return 0; 274| 49|} emitter.c:yaml_emitter_analyze_event: 1703| 8.81M|{ 1704| 8.81M| emitter->anchor_data.anchor = NULL; 1705| 8.81M| emitter->anchor_data.anchor_length = 0; 1706| 8.81M| emitter->tag_data.handle = NULL; 1707| 8.81M| emitter->tag_data.handle_length = 0; 1708| 8.81M| emitter->tag_data.suffix = NULL; 1709| 8.81M| emitter->tag_data.suffix_length = 0; 1710| 8.81M| emitter->scalar_data.value = NULL; 1711| 8.81M| emitter->scalar_data.length = 0; 1712| | 1713| 8.81M| switch (event->type) 1714| 8.81M| { 1715| 275k| case YAML_ALIAS_EVENT: ------------------ | Branch (1715:9): [True: 275k, False: 8.54M] ------------------ 1716| 275k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1716:17): [True: 0, False: 275k] ------------------ 1717| 275k| event->data.alias.anchor, 1)) 1718| 0| return 0; 1719| 275k| return 1; 1720| | 1721| 3.82M| case YAML_SCALAR_EVENT: ------------------ | Branch (1721:9): [True: 3.82M, False: 4.99M] ------------------ 1722| 3.82M| if (event->data.scalar.anchor) { ------------------ | Branch (1722:17): [True: 1.42k, False: 3.82M] ------------------ 1723| 1.42k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1723:21): [True: 0, False: 1.42k] ------------------ 1724| 1.42k| event->data.scalar.anchor, 0)) 1725| 0| return 0; 1726| 1.42k| } 1727| 3.82M| if (event->data.scalar.tag && (emitter->canonical || ------------------ | Branch (1727:17): [True: 3.82M, False: 0] | Branch (1727:44): [True: 2.49M, False: 1.32M] ------------------ 1728| 1.32M| (!event->data.scalar.plain_implicit ------------------ | Branch (1728:26): [True: 1.26k, False: 1.32M] ------------------ 1729| 2.49M| && !event->data.scalar.quoted_implicit))) { ------------------ | Branch (1729:29): [True: 1.26k, False: 0] ------------------ 1730| 2.49M| if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag)) ------------------ | Branch (1730:21): [True: 28, False: 2.49M] ------------------ 1731| 28| return 0; 1732| 2.49M| } 1733| 3.82M| if (!yaml_emitter_analyze_scalar(emitter, ------------------ | Branch (1733:17): [True: 0, False: 3.82M] ------------------ 1734| 3.82M| event->data.scalar.value, event->data.scalar.length)) 1735| 0| return 0; 1736| 3.82M| return 1; 1737| | 1738| 130k| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (1738:9): [True: 130k, False: 8.68M] ------------------ 1739| 130k| if (event->data.sequence_start.anchor) { ------------------ | Branch (1739:17): [True: 1.99k, False: 128k] ------------------ 1740| 1.99k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1740:21): [True: 0, False: 1.99k] ------------------ 1741| 1.99k| event->data.sequence_start.anchor, 0)) 1742| 0| return 0; 1743| 1.99k| } 1744| 130k| if (event->data.sequence_start.tag && (emitter->canonical || ------------------ | Branch (1744:17): [True: 130k, False: 0] | Branch (1744:52): [True: 92.1k, False: 38.1k] ------------------ 1745| 94.3k| !event->data.sequence_start.implicit)) { ------------------ | Branch (1745:25): [True: 2.22k, False: 35.9k] ------------------ 1746| 94.3k| if (!yaml_emitter_analyze_tag(emitter, ------------------ | Branch (1746:21): [True: 10, False: 94.3k] ------------------ 1747| 94.3k| event->data.sequence_start.tag)) 1748| 10| return 0; 1749| 94.3k| } 1750| 130k| return 1; 1751| | 1752| 2.16M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (1752:9): [True: 2.16M, False: 6.65M] ------------------ 1753| 2.16M| if (event->data.mapping_start.anchor) { ------------------ | Branch (1753:17): [True: 1.10k, False: 2.16M] ------------------ 1754| 1.10k| if (!yaml_emitter_analyze_anchor(emitter, ------------------ | Branch (1754:21): [True: 0, False: 1.10k] ------------------ 1755| 1.10k| event->data.mapping_start.anchor, 0)) 1756| 0| return 0; 1757| 1.10k| } 1758| 2.16M| if (event->data.mapping_start.tag && (emitter->canonical || ------------------ | Branch (1758:17): [True: 2.16M, False: 0] | Branch (1758:51): [True: 1.56M, False: 596k] ------------------ 1759| 1.57M| !event->data.mapping_start.implicit)) { ------------------ | Branch (1759:25): [True: 302, False: 595k] ------------------ 1760| 1.57M| if (!yaml_emitter_analyze_tag(emitter, ------------------ | Branch (1760:21): [True: 9, False: 1.57M] ------------------ 1761| 1.57M| event->data.mapping_start.tag)) 1762| 9| return 0; 1763| 1.57M| } 1764| 2.16M| return 1; 1765| | 1766| 2.42M| default: ------------------ | Branch (1766:9): [True: 2.42M, False: 6.39M] ------------------ 1767| 2.42M| return 1; 1768| 8.81M| } 1769| 8.81M|} emitter.c:yaml_emitter_analyze_anchor: 1424| 279k|{ 1425| 279k| size_t anchor_length; 1426| 279k| yaml_string_t string; 1427| | 1428| 279k| anchor_length = strlen((char *)anchor); 1429| 279k| STRING_ASSIGN(string, anchor, anchor_length); ------------------ | | 128| 279k| ((value).start = (string), \ | | 129| 279k| (value).end = (string)+(length), \ | | 130| 279k| (value).pointer = (string)) ------------------ 1430| | 1431| 279k| if (string.start == string.end) { ------------------ | Branch (1431:9): [True: 0, False: 279k] ------------------ 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| 1.67M| while (string.pointer != string.end) { ------------------ | Branch (1437:12): [True: 1.39M, False: 279k] ------------------ 1438| 1.39M| if (!IS_ALPHA(string)) { ------------------ | | 198| 1.39M|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 1.39M| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 1.39M, False: 0] | | | | ------------------ | | | | 190| 1.39M| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 838k, False: 559k] | | | | ------------------ | | | | 191| 1.39M| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 559k, False: 0] | | | | ------------------ | | | | 192| 559k| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 0, False: 559k] | | | | ------------------ | | | | 193| 1.39M| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 559k, False: 0] | | | | ------------------ | | | | 194| 559k| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 559k, False: 0] | | | | ------------------ | | | | 195| 1.39M| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 0, False: 0] | | | | ------------------ | | | | 196| 1.39M| (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| 1.39M| MOVE(string); ------------------ | | 391| 1.39M|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 1.39M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.39M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.39M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.39M| ((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| 1.39M| } 1445| | 1446| 279k| emitter->anchor_data.anchor = string.start; 1447| 279k| emitter->anchor_data.anchor_length = string.end - string.start; 1448| 279k| emitter->anchor_data.alias = alias; 1449| | 1450| 279k| return 1; 1451| 279k|} emitter.c:yaml_emitter_analyze_tag: 1460| 4.15M|{ 1461| 4.15M| size_t tag_length; 1462| 4.15M| yaml_string_t string; 1463| 4.15M| yaml_tag_directive_t *tag_directive; 1464| | 1465| 4.15M| tag_length = strlen((char *)tag); 1466| 4.15M| STRING_ASSIGN(string, tag, tag_length); ------------------ | | 128| 4.15M| ((value).start = (string), \ | | 129| 4.15M| (value).end = (string)+(length), \ | | 130| 4.15M| (value).pointer = (string)) ------------------ 1467| | 1468| 4.15M| if (string.start == string.end) { ------------------ | Branch (1468:9): [True: 47, False: 4.15M] ------------------ 1469| 47| return yaml_emitter_set_emitter_error(emitter, 1470| 47| "tag value must not be empty"); 1471| 47| } 1472| | 1473| 4.15M| for (tag_directive = emitter->tag_directives.start; 1474| 8.55M| tag_directive != emitter->tag_directives.top; tag_directive ++) { ------------------ | Branch (1474:13): [True: 8.39M, False: 159k] ------------------ 1475| 8.39M| size_t prefix_length = strlen((char *)tag_directive->prefix); 1476| 8.39M| if (prefix_length < (size_t)(string.end - string.start) ------------------ | Branch (1476:13): [True: 8.39M, False: 4.52k] ------------------ 1477| 8.39M| && strncmp((char *)tag_directive->prefix, (char *)string.start, ------------------ | Branch (1477:20): [True: 3.99M, False: 4.39M] ------------------ 1478| 8.39M| prefix_length) == 0) 1479| 3.99M| { 1480| 3.99M| emitter->tag_data.handle = tag_directive->handle; 1481| 3.99M| emitter->tag_data.handle_length = 1482| 3.99M| strlen((char *)tag_directive->handle); 1483| 3.99M| emitter->tag_data.suffix = string.start + prefix_length; 1484| 3.99M| emitter->tag_data.suffix_length = 1485| 3.99M| (string.end - string.start) - prefix_length; 1486| 3.99M| return 1; 1487| 3.99M| } 1488| 8.39M| } 1489| | 1490| 159k| emitter->tag_data.suffix = string.start; 1491| 159k| emitter->tag_data.suffix_length = string.end - string.start; 1492| | 1493| 159k| return 1; 1494| 4.15M|} emitter.c:yaml_emitter_analyze_scalar: 1503| 3.82M|{ 1504| 3.82M| yaml_string_t string; 1505| | 1506| 3.82M| int block_indicators = 0; 1507| 3.82M| int flow_indicators = 0; 1508| 3.82M| int line_breaks = 0; 1509| 3.82M| int special_characters = 0; 1510| | 1511| 3.82M| int leading_space = 0; 1512| 3.82M| int leading_break = 0; 1513| 3.82M| int trailing_space = 0; 1514| 3.82M| int trailing_break = 0; 1515| 3.82M| int break_space = 0; 1516| 3.82M| int space_break = 0; 1517| | 1518| 3.82M| int preceded_by_whitespace = 0; 1519| 3.82M| int followed_by_whitespace = 0; 1520| 3.82M| int previous_space = 0; 1521| 3.82M| int previous_break = 0; 1522| | 1523| 3.82M| STRING_ASSIGN(string, value, length); ------------------ | | 128| 3.82M| ((value).start = (string), \ | | 129| 3.82M| (value).end = (string)+(length), \ | | 130| 3.82M| (value).pointer = (string)) ------------------ 1524| | 1525| 3.82M| emitter->scalar_data.value = value; 1526| 3.82M| emitter->scalar_data.length = length; 1527| | 1528| 3.82M| if (string.start == string.end) ------------------ | Branch (1528:9): [True: 2.70M, False: 1.11M] ------------------ 1529| 2.70M| { 1530| 2.70M| emitter->scalar_data.multiline = 0; 1531| 2.70M| emitter->scalar_data.flow_plain_allowed = 0; 1532| 2.70M| emitter->scalar_data.block_plain_allowed = 1; 1533| 2.70M| emitter->scalar_data.single_quoted_allowed = 1; 1534| 2.70M| emitter->scalar_data.block_allowed = 0; 1535| | 1536| 2.70M| return 1; 1537| 2.70M| } 1538| | 1539| 1.11M| if ((CHECK_AT(string, '-', 0) ------------------ | | 175| 2.22M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 149k, False: 964k] | | ------------------ ------------------ 1540| 149k| && CHECK_AT(string, '-', 1) ------------------ | | 175| 1.26M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 30.8k, False: 118k] | | ------------------ ------------------ 1541| 30.8k| && CHECK_AT(string, '-', 2)) ------------------ | | 175| 30.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 3.18k, False: 27.6k] | | ------------------ ------------------ 1542| 1.11M| || (CHECK_AT(string, '.', 0) ------------------ | | 175| 2.22M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.60k, False: 1.10M] | | ------------------ ------------------ 1543| 2.60k| && CHECK_AT(string, '.', 1) ------------------ | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 758, False: 1.84k] | | ------------------ ------------------ 1544| 3.68k| && CHECK_AT(string, '.', 2))) { ------------------ | | 175| 758| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 496, False: 262] | | ------------------ ------------------ 1545| 3.68k| block_indicators = 1; 1546| 3.68k| flow_indicators = 1; 1547| 3.68k| } 1548| | 1549| 1.11M| preceded_by_whitespace = 1; 1550| 1.11M| followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); ------------------ | | 371| 1.11M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 2.22M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 1.11M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.25M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 6.76k, False: 1.10M] | | | | | | | | | Branch (175:23): [True: 707, False: 0] | | | | | | | | | Branch (175:23): [True: 5.85k, False: 707] | | | | | | | | | Branch (175:23): [True: 1.74k, False: 6.55k] | | | | | | | | | Branch (175:23): [True: 1.10M, False: 8.29k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 1.10M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.24M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 743, False: 1.10M] | | | | | | | | | Branch (175:23): [True: 705, False: 0] | | | | | | | | | Branch (175:23): [True: 5.65k, False: 705] | | | | | | | | | Branch (175:23): [True: 1.71k, False: 6.35k] | | | | | | | | | Branch (175:23): [True: 1.09M, False: 8.06k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 1.10M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 2.21M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 2.24M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.27k, False: 1.10M] | | | | | | | | | Branch (175:23): [True: 705, False: 0] | | | | | | | | | Branch (175:23): [True: 5.65k, False: 705] | | | | | | | | | Branch (175:23): [True: 1.71k, False: 6.35k] | | | | | | | | | Branch (175:23): [True: 1.09M, False: 8.06k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 1.10M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 2.23M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.19k, False: 1.10M] | | | | | | | | | Branch (175:23): [True: 705, False: 0] | | | | | | | | | Branch (175:23): [True: 5.65k, False: 705] | | | | | | | | | Branch (175:23): [True: 1.71k, False: 6.35k] | | | | | | | | | Branch (175:23): [True: 1.09M, False: 8.06k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 1.10M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.22M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.03k, False: 1.09M] | | | | | | | | | Branch (175:23): [True: 705, False: 0] | | | | | | | | | Branch (175:23): [True: 3.95k, False: 705] | | | | | | | | | Branch (175:23): [True: 1.32k, False: 4.66k] | | | | | | | | | Branch (175:23): [True: 1.09M, False: 5.98k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.10M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 13.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 222, False: 2.81k] | | | | | | | | | Branch (175:23): [True: 231, False: 0] | | | | | | | | | Branch (175:23): [True: 1.34k, False: 231] | | | | | | | | | Branch (175:23): [True: 246, False: 1.57k] | | | | | | | | | Branch (175:23): [True: 1.21k, False: 1.82k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 1.10M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.22M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.23k, False: 1.09M] | | | | | | | | | Branch (175:23): [True: 705, False: 0] | | | | | | | | | Branch (175:23): [True: 3.95k, False: 705] | | | | | | | | | Branch (175:23): [True: 1.31k, False: 4.66k] | | | | | | | | | Branch (175:23): [True: 1.09M, False: 5.98k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 1.10M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.60k, False: 628] | | | | | | | | | Branch (175:23): [True: 202, False: 0] | | | | | | | | | Branch (175:23): [True: 552, False: 202] | | | | | | | | | Branch (175:23): [True: 199, False: 754] | | | | | | | | | Branch (175:23): [True: 1.28k, False: 953] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 1.10M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 6.60k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 272, False: 1.33k] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 448, False: 200] | | | | | | | | | Branch (175:23): [True: 197, False: 648] | | | | | | | | | Branch (175:23): [True: 763, False: 845] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 2.21M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.22M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.96k, False: 1.09M] | | | | | | | | | Branch (175:23): [True: 705, False: 0] | | | | | | | | | Branch (175:23): [True: 3.92k, False: 705] | | | | | | | | | Branch (175:23): [True: 1.31k, False: 4.63k] | | | | | | | | | Branch (175:23): [True: 1.09M, False: 5.94k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 1.09M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.33k, False: 628] | | | | | | | | | Branch (175:23): [True: 202, False: 0] | | | | | | | | | Branch (175:23): [True: 518, False: 202] | | | | | | | | | Branch (175:23): [True: 199, False: 720] | | | | | | | | | Branch (175:23): [True: 1.04k, False: 919] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 1.09M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 5.92k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 513, False: 823] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 414, False: 200] | | | | | | | | | Branch (175:23): [True: 197, False: 614] | | | | | | | | | Branch (175:23): [True: 525, False: 811] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 1.09M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.21M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 913k, False: 186k] | | | | | | | | | Branch (175:23): [True: 623, False: 0] | | | | | | | | | Branch (175:23): [True: 3.61k, False: 623] | | | | | | | | | Branch (175:23): [True: 1.31k, False: 4.23k] | | | | | | | | | Branch (175:23): [True: 1.09M, False: 5.55k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1551| | 1552| 38.4M| while (string.pointer != string.end) ------------------ | Branch (1552:12): [True: 37.3M, False: 1.11M] ------------------ 1553| 37.3M| { 1554| 37.3M| if (string.start == string.pointer) ------------------ | Branch (1554:13): [True: 1.11M, False: 36.2M] ------------------ 1555| 1.11M| { 1556| 1.11M| if (CHECK(string, '#') || CHECK(string, ',') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 263, False: 1.11M] | | ------------------ ------------------ if (CHECK(string, '#') || CHECK(string, ',') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 226, False: 1.11M] | | ------------------ ------------------ 1557| 1.11M| || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 316, False: 1.11M] | | ------------------ ------------------ || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 289, False: 1.11M] | | ------------------ ------------------ 1558| 1.11M| || CHECK(string, '{') || CHECK(string, '}') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 221, False: 1.11M] | | ------------------ ------------------ || CHECK(string, '{') || CHECK(string, '}') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 366, False: 1.11M] | | ------------------ ------------------ 1559| 1.11M| || CHECK(string, '&') || CHECK(string, '*') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 334, False: 1.11M] | | ------------------ ------------------ || CHECK(string, '&') || CHECK(string, '*') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 313, False: 1.11M] | | ------------------ ------------------ 1560| 1.11M| || CHECK(string, '!') || CHECK(string, '|') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 530, False: 1.11M] | | ------------------ ------------------ || CHECK(string, '!') || CHECK(string, '|') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.94k, False: 1.10M] | | ------------------ ------------------ 1561| 1.10M| || CHECK(string, '>') || CHECK(string, '\'') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 360, False: 1.10M] | | ------------------ ------------------ || CHECK(string, '>') || CHECK(string, '\'') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 225, False: 1.10M] | | ------------------ ------------------ 1562| 1.10M| || CHECK(string, '"') || CHECK(string, '%') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 291, False: 1.10M] | | ------------------ ------------------ || CHECK(string, '"') || CHECK(string, '%') ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 204, False: 1.10M] | | ------------------ ------------------ 1563| 1.10M| || CHECK(string, '@') || CHECK(string, '`')) { ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 269, False: 1.10M] | | ------------------ ------------------ || CHECK(string, '@') || CHECK(string, '`')) { ------------------ | | 181| 1.10M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.10M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 277, False: 1.10M] | | ------------------ ------------------ 1564| 6.42k| flow_indicators = 1; 1565| 6.42k| block_indicators = 1; 1566| 6.42k| } 1567| | 1568| 1.11M| if (CHECK(string, '?') || CHECK(string, ':')) { ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 53.8k, False: 1.05M] | | ------------------ ------------------ if (CHECK(string, '?') || CHECK(string, ':')) { ------------------ | | 181| 1.05M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.05M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 351k, False: 708k] | | ------------------ ------------------ 1569| 404k| flow_indicators = 1; 1570| 404k| if (followed_by_whitespace) { ------------------ | Branch (1570:21): [True: 348k, False: 56.7k] ------------------ 1571| 348k| block_indicators = 1; 1572| 348k| } 1573| 404k| } 1574| | 1575| 1.11M| if (CHECK(string, '-') && followed_by_whitespace) { ------------------ | | 181| 2.22M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.11M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 149k, False: 964k] | | ------------------ ------------------ | Branch (1575:39): [True: 86.4k, False: 62.6k] ------------------ 1576| 86.4k| flow_indicators = 1; 1577| 86.4k| block_indicators = 1; 1578| 86.4k| } 1579| 1.11M| } 1580| 36.2M| else 1581| 36.2M| { 1582| 36.2M| if (CHECK(string, ',') || CHECK(string, '?') ------------------ | | 181| 72.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 36.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 156k, False: 36.0M] | | ------------------ ------------------ if (CHECK(string, ',') || CHECK(string, '?') ------------------ | | 181| 72.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 36.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.41M, False: 33.6M] | | ------------------ ------------------ 1583| 33.6M| || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 69.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 31.2k, False: 33.6M] | | ------------------ ------------------ || CHECK(string, '[') || CHECK(string, ']') ------------------ | | 181| 69.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 11.9k, False: 33.6M] | | ------------------ ------------------ 1584| 33.6M| || CHECK(string, '{') || CHECK(string, '}')) { ------------------ | | 181| 69.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 25.2k, False: 33.5M] | | ------------------ ------------------ || CHECK(string, '{') || CHECK(string, '}')) { ------------------ | | 181| 33.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 33.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 28.5k, False: 33.5M] | | ------------------ ------------------ 1585| 2.66M| flow_indicators = 1; 1586| 2.66M| } 1587| | 1588| 36.2M| if (CHECK(string, ':')) { ------------------ | | 181| 36.2M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 36.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 298k, False: 35.9M] | | ------------------ ------------------ 1589| 298k| flow_indicators = 1; 1590| 298k| if (followed_by_whitespace) { ------------------ | Branch (1590:21): [True: 40.2k, False: 258k] ------------------ 1591| 40.2k| block_indicators = 1; 1592| 40.2k| } 1593| 298k| } 1594| | 1595| 36.2M| if (CHECK(string, '#') && preceded_by_whitespace) { ------------------ | | 181| 72.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 36.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.19k, False: 36.2M] | | ------------------ ------------------ | Branch (1595:39): [True: 652, False: 2.54k] ------------------ 1596| 652| flow_indicators = 1; 1597| 652| block_indicators = 1; 1598| 652| } 1599| 36.2M| } 1600| | 1601| 37.3M| if (!IS_PRINTABLE(string) ------------------ | | 279| 37.3M|#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) | | ------------------ | | | | 262| 74.6M| (((string).pointer[offset] == 0x0A) /* . == #x0A */ \ | | | | ------------------ | | | | | Branch (262:6): [True: 1.54M, False: 35.8M] | | | | ------------------ | | | | 263| 37.3M| || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \ | | | | ------------------ | | | | | Branch (263:10): [True: 33.7M, False: 2.05M] | | | | ------------------ | | | | 264| 35.8M| && (string).pointer[offset] <= 0x7E) \ | | | | ------------------ | | | | | Branch (264:13): [True: 25.7M, False: 8.01M] | | | | ------------------ | | | | 265| 37.3M| || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ | | | | ------------------ | | | | | Branch (265:10): [True: 160k, False: 9.90M] | | | | ------------------ | | | | 266| 10.0M| && (string).pointer[offset+1] >= 0xA0) \ | | | | ------------------ | | | | | Branch (266:13): [True: 32.6k, False: 127k] | | | | ------------------ | | | | 267| 37.3M| || ((string).pointer[offset] > 0xC2 \ | | | | ------------------ | | | | | Branch (267:10): [True: 7.85M, False: 2.17M] | | | | ------------------ | | | | 268| 10.0M| && (string).pointer[offset] < 0xED) \ | | | | ------------------ | | | | | Branch (268:13): [True: 7.79M, False: 59.3k] | | | | ------------------ | | | | 269| 37.3M| || ((string).pointer[offset] == 0xED \ | | | | ------------------ | | | | | Branch (269:10): [True: 4.36k, False: 2.23M] | | | | ------------------ | | | | 270| 2.23M| && (string).pointer[offset+1] < 0xA0) \ | | | | ------------------ | | | | | Branch (270:13): [True: 4.36k, False: 0] | | | | ------------------ | | | | 271| 37.3M| || ((string).pointer[offset] == 0xEE) \ | | | | ------------------ | | | | | Branch (271:9): [True: 3.03k, False: 2.23M] | | | | ------------------ | | | | 272| 74.6M| || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \ | | | | ------------------ | | | | | Branch (272:10): [True: 8.17k, False: 2.22M] | | | | ------------------ | | | | 273| 2.23M| && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \ | | | | ------------------ | | | | | Branch (273:15): [True: 2.93k, False: 5.24k] | | | | ------------------ | | | | 274| 8.17k| && (string).pointer[offset+2] == 0xBF) \ | | | | ------------------ | | | | | Branch (274:17): [True: 1.80k, False: 1.12k] | | | | ------------------ | | | | 275| 2.23M| && !((string).pointer[offset+1] == 0xBF \ | | | | ------------------ | | | | | Branch (275:15): [True: 1.34k, False: 5.02k] | | | | ------------------ | | | | 276| 6.36k| && ((string).pointer[offset+2] == 0xBE \ | | | | ------------------ | | | | | Branch (276:18): [True: 194, False: 1.14k] | | | | ------------------ | | | | 277| 1.34k| || (string).pointer[offset+2] == 0xBF)))) | | | | ------------------ | | | | | Branch (277:21): [True: 200, False: 949] | | | | ------------------ | | ------------------ ------------------ 1602| 35.1M| || (!IS_ASCII(string) && !emitter->unicode)) { ------------------ | | 255| 35.1M|#define IS_ASCII(string) IS_ASCII_AT((string),0) | | ------------------ | | | | 253| 70.2M| ((string).pointer[offset] <= (yaml_char_t) '\x7F') | | ------------------ ------------------ | Branch (1602:21): [True: 7.84M, False: 27.2M] | Branch (1602:42): [True: 4.33M, False: 3.50M] ------------------ 1603| 6.56M| special_characters = 1; 1604| 6.56M| } 1605| | 1606| 37.3M| if (IS_BREAK(string)) { ------------------ | | 341| 37.3M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 37.3M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 74.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 530k, False: 36.8M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 37.3M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 74.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.54M, False: 35.2M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 37.3M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 70.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 160k, False: 35.1M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 35.2M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 160k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 127k, False: 32.6k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 37.3M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 70.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.72M, False: 31.4M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 35.1M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 38.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.47M, False: 250k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 35.1M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 3.47M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 9.88k, False: 3.46M] | | | | | | ------------------ | | | | ------------------ | | | | 337| 37.3M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 70.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.71M, False: 31.4M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 35.1M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 38.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.46M, False: 250k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 35.1M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 70.6k, False: 3.39M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1607| 2.28M| line_breaks = 1; 1608| 2.28M| } 1609| | 1610| 37.3M| if (IS_SPACE(string)) ------------------ | | 306| 37.3M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 37.3M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 37.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 7.28M, False: 30.0M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1611| 7.28M| { 1612| 7.28M| if (string.start == string.pointer) { ------------------ | Branch (1612:17): [True: 1.30k, False: 7.28M] ------------------ 1613| 1.30k| leading_space = 1; 1614| 1.30k| } 1615| 7.28M| if (string.pointer+WIDTH(string) == string.end) { ------------------ | | 385| 7.28M|#define WIDTH(string) WIDTH_AT((string),0) | | ------------------ | | | | 380| 7.28M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | ------------------ | | | | | Branch (380:7): [True: 7.28M, False: 0] | | | | ------------------ | | | | 381| 7.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] | | | | ------------------ | | ------------------ ------------------ | Branch (1615:17): [True: 3.04k, False: 7.28M] ------------------ 1616| 3.04k| trailing_space = 1; 1617| 3.04k| } 1618| 7.28M| if (previous_break) { ------------------ | Branch (1618:17): [True: 6.68k, False: 7.27M] ------------------ 1619| 6.68k| break_space = 1; 1620| 6.68k| } 1621| 7.28M| previous_space = 1; 1622| 7.28M| previous_break = 0; 1623| 7.28M| } 1624| 30.0M| else if (IS_BREAK(string)) ------------------ | | 341| 30.0M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 30.0M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 60.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 530k, False: 29.5M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 30.0M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 59.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.54M, False: 27.9M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 30.0M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 55.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 160k, False: 27.8M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 27.9M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 160k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 127k, False: 32.6k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 30.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 55.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.72M, False: 24.1M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 27.8M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 31.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.47M, False: 250k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 27.8M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 3.47M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 9.88k, False: 3.46M] | | | | | | ------------------ | | | | ------------------ | | | | 337| 30.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 55.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.71M, False: 24.1M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 27.8M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 31.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.46M, False: 250k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 27.8M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 70.6k, False: 3.39M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1625| 2.28M| { 1626| 2.28M| if (string.start == string.pointer) { ------------------ | Branch (1626:17): [True: 12.1k, False: 2.26M] ------------------ 1627| 12.1k| leading_break = 1; 1628| 12.1k| } 1629| 2.28M| if (string.pointer+WIDTH(string) == string.end) { ------------------ | | 385| 2.28M|#define WIDTH(string) WIDTH_AT((string),0) | | ------------------ | | | | 380| 2.28M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | ------------------ | | | | | Branch (380:7): [True: 2.07M, False: 208k] | | | | ------------------ | | | | 381| 2.28M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | ------------------ | | | | | Branch (381:7): [True: 127k, False: 80.5k] | | | | ------------------ | | | | 382| 208k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | ------------------ | | | | | Branch (382:7): [True: 80.5k, False: 0] | | | | ------------------ | | | | 383| 80.5k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | ------------------ | | | | | Branch (383:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (1629:17): [True: 17.1k, False: 2.26M] ------------------ 1630| 17.1k| trailing_break = 1; 1631| 17.1k| } 1632| 2.28M| if (previous_space) { ------------------ | Branch (1632:17): [True: 2.05k, False: 2.27M] ------------------ 1633| 2.05k| space_break = 1; 1634| 2.05k| } 1635| 2.28M| previous_space = 0; 1636| 2.28M| previous_break = 1; 1637| 2.28M| } 1638| 27.7M| else 1639| 27.7M| { 1640| 27.7M| previous_space = 0; 1641| 27.7M| previous_break = 0; 1642| 27.7M| } 1643| | 1644| 37.3M| preceded_by_whitespace = IS_BLANKZ(string); ------------------ | | 373| 37.3M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 37.3M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 74.6M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 37.3M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 74.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 7.28M, False: 30.0M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 30.0M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 30.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 539k, False: 29.5M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 29.5M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 59.0M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 59.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 530k, 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.54M, 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: 160k, False: 27.2M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 27.4M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 160k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 127k, False: 32.6k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 29.5M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 54.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.72M, False: 23.5M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 27.3M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 31.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.47M, False: 250k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 27.3M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.47M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 9.88k, False: 3.46M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 59.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 54.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.71M, False: 23.5M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 27.3M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 31.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.46M, False: 250k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 27.3M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 70.6k, False: 3.39M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 27.2M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 27.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2.64k, False: 27.2M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1645| 37.3M| MOVE(string); ------------------ | | 391| 37.3M|#define MOVE(string) ((string).pointer += WIDTH((string))) | | ------------------ | | | | 385| 37.3M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 37.3M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 29.3M, False: 8.01M] | | | | | | ------------------ | | | | | | 381| 37.3M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 176k, False: 7.84M] | | | | | | ------------------ | | | | | | 382| 8.01M| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 7.79M, False: 43.7k] | | | | | | ------------------ | | | | | | 383| 7.84M| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 43.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1646| 37.3M| if (string.pointer != string.end) { ------------------ | Branch (1646:13): [True: 36.2M, False: 1.11M] ------------------ 1647| 36.2M| followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); ------------------ | | 371| 36.2M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 72.4M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 36.2M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 104M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 7.27M, False: 28.9M] | | | | | | | | | Branch (175:23): [True: 43.0k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.79M, False: 43.0k] | | | | | | | | | Branch (175:23): [True: 174k, False: 7.83M] | | | | | | | | | Branch (175:23): [True: 28.2M, False: 8.01M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 28.9M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 89.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 538k, False: 28.4M] | | | | | | | | | Branch (175:23): [True: 42.8k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.79M, False: 42.8k] | | | | | | | | | Branch (175:23): [True: 173k, False: 7.83M] | | | | | | | | | Branch (175:23): [True: 20.9M, False: 8.00M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 28.4M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 56.8M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 88.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 527k, False: 27.8M] | | | | | | | | | Branch (175:23): [True: 42.8k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.78M, False: 42.8k] | | | | | | | | | Branch (175:23): [True: 173k, False: 7.83M] | | | | | | | | | Branch (175:23): [True: 20.4M, False: 8.00M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 28.4M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 87.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.52M, False: 26.3M] | | | | | | | | | Branch (175:23): [True: 42.8k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.78M, False: 42.8k] | | | | | | | | | Branch (175:23): [True: 173k, False: 7.83M] | | | | | | | | | Branch (175:23): [True: 19.8M, False: 8.00M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 28.4M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 84.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 155k, False: 26.2M] | | | | | | | | | Branch (175:23): [True: 42.7k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.77M, False: 42.7k] | | | | | | | | | Branch (175:23): [True: 173k, False: 7.82M] | | | | | | | | | Branch (175:23): [True: 18.3M, False: 7.99M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 26.3M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 596k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 127k, False: 28.5k] | | | | | | | | | Branch (175:23): [True: 851, False: 0] | | | | | | | | | Branch (175:23): [True: 368, False: 851] | | | | | | | | | Branch (175:23): [True: 139k, False: 1.21k] | | | | | | | | | Branch (175:23): [True: 15.4k, False: 140k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 28.4M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 83.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.71M, False: 22.5M] | | | | | | | | | Branch (175:23): [True: 42.7k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.77M, False: 42.7k] | | | | | | | | | Branch (175:23): [True: 54.4k, False: 7.82M] | | | | | | | | | Branch (175:23): [True: 18.3M, False: 7.87M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 26.2M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 29.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.46M, False: 248k] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 3.69M, False: 200] | | | | | | | | | Branch (175:23): [True: 705, False: 3.69M] | | | | | | | | | Branch (175:23): [True: 18.8k, False: 3.69M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 26.2M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 20.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.54k, False: 3.45M] | | | | | | | | | Branch (175:23): [True: 199, False: 0] | | | | | | | | | Branch (175:23): [True: 3.44M, False: 199] | | | | | | | | | Branch (175:23): [True: 639, False: 3.44M] | | | | | | | | | Branch (175:23): [True: 16.2k, False: 3.45M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 56.8M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 83.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.70M, False: 22.5M] | | | | | | | | | Branch (175:23): [True: 42.7k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.77M, False: 42.7k] | | | | | | | | | Branch (175:23): [True: 54.2k, False: 7.81M] | | | | | | | | | Branch (175:23): [True: 18.3M, False: 7.87M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 26.2M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 29.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.45M, False: 248k] | | | | | | | | | Branch (175:23): [True: 200, False: 0] | | | | | | | | | Branch (175:23): [True: 3.68M, False: 200] | | | | | | | | | Branch (175:23): [True: 501, False: 3.69M] | | | | | | | | | Branch (175:23): [True: 16.1k, False: 3.69M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 26.2M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 20.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 69.1k, False: 3.38M] | | | | | | | | | Branch (175:23): [True: 199, False: 0] | | | | | | | | | Branch (175:23): [True: 3.44M, False: 199] | | | | | | | | | Branch (175:23): [True: 435, False: 3.44M] | | | | | | | | | Branch (175:23): [True: 13.5k, False: 3.44M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 26.1M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 83.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 202k, False: 25.9M] | | | | | | | | | Branch (175:23): [True: 42.7k, False: 0] | | | | | | | | | Branch (175:23): [True: 7.70M, False: 42.7k] | | | | | | | | | Branch (175:23): [True: 54.0k, False: 7.74M] | | | | | | | | | Branch (175:23): [True: 18.3M, False: 7.80M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1648| 36.2M| } 1649| 37.3M| } 1650| | 1651| 1.11M| emitter->scalar_data.multiline = line_breaks; 1652| | 1653| 1.11M| emitter->scalar_data.flow_plain_allowed = 1; 1654| 1.11M| emitter->scalar_data.block_plain_allowed = 1; 1655| 1.11M| emitter->scalar_data.single_quoted_allowed = 1; 1656| 1.11M| emitter->scalar_data.block_allowed = 1; 1657| | 1658| 1.11M| if (leading_space || leading_break || trailing_space || trailing_break) { ------------------ | Branch (1658:9): [True: 1.30k, False: 1.11M] | Branch (1658:26): [True: 12.1k, False: 1.09M] | Branch (1658:43): [True: 2.06k, False: 1.09M] | Branch (1658:61): [True: 4.70k, False: 1.09M] ------------------ 1659| 20.2k| emitter->scalar_data.flow_plain_allowed = 0; 1660| 20.2k| emitter->scalar_data.block_plain_allowed = 0; 1661| 20.2k| } 1662| | 1663| 1.11M| if (trailing_space) { ------------------ | Branch (1663:9): [True: 3.04k, False: 1.11M] ------------------ 1664| 3.04k| emitter->scalar_data.block_allowed = 0; 1665| 3.04k| } 1666| | 1667| 1.11M| if (break_space) { ------------------ | Branch (1667:9): [True: 637, False: 1.11M] ------------------ 1668| 637| emitter->scalar_data.flow_plain_allowed = 0; 1669| 637| emitter->scalar_data.block_plain_allowed = 0; 1670| 637| emitter->scalar_data.single_quoted_allowed = 0; 1671| 637| } 1672| | 1673| 1.11M| if (space_break || special_characters) { ------------------ | Branch (1673:9): [True: 416, False: 1.11M] | Branch (1673:24): [True: 13.7k, False: 1.09M] ------------------ 1674| 14.1k| emitter->scalar_data.flow_plain_allowed = 0; 1675| 14.1k| emitter->scalar_data.block_plain_allowed = 0; 1676| 14.1k| emitter->scalar_data.single_quoted_allowed = 0; 1677| 14.1k| emitter->scalar_data.block_allowed = 0; 1678| 14.1k| } 1679| | 1680| 1.11M| if (line_breaks) { ------------------ | Branch (1680:9): [True: 20.7k, False: 1.09M] ------------------ 1681| 20.7k| emitter->scalar_data.flow_plain_allowed = 0; 1682| 20.7k| emitter->scalar_data.block_plain_allowed = 0; 1683| 20.7k| } 1684| | 1685| 1.11M| if (flow_indicators) { ------------------ | Branch (1685:9): [True: 572k, False: 540k] ------------------ 1686| 572k| emitter->scalar_data.flow_plain_allowed = 0; 1687| 572k| } 1688| | 1689| 1.11M| if (block_indicators) { ------------------ | Branch (1689:9): [True: 475k, False: 638k] ------------------ 1690| 475k| emitter->scalar_data.block_plain_allowed = 0; 1691| 475k| } 1692| | 1693| 1.11M| return 1; 1694| 3.82M|} yaml_parser_load: 88| 65.3k|{ 89| 65.3k| yaml_event_t event; 90| | 91| 65.3k| assert(parser); /* Non-NULL parser object is expected. */ ------------------ | Branch (91:5): [True: 0, False: 65.3k] | Branch (91:5): [True: 65.3k, False: 0] ------------------ 92| 65.3k| assert(document); /* Non-NULL document object is expected. */ ------------------ | Branch (92:5): [True: 0, False: 65.3k] | Branch (92:5): [True: 65.3k, False: 0] ------------------ 93| | 94| 65.3k| memset(document, 0, sizeof(yaml_document_t)); 95| 65.3k| if (!STACK_INIT(parser, document->nodes, yaml_node_t*)) ------------------ | | 424| 65.3k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 65.3k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 65.3k, False: 0] | | ------------------ | | 425| 65.3k| ((stack).top = (stack).start, \ | | 426| 65.3k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 65.3k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 65.3k| 1) : \ | | 428| 65.3k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (95:9): [True: 0, False: 65.3k] ------------------ 96| 0| goto error; 97| | 98| 65.3k| if (!parser->stream_start_produced) { ------------------ | Branch (98:9): [True: 11.2k, False: 54.0k] ------------------ 99| 11.2k| if (!yaml_parser_parse(parser, &event)) goto error; ------------------ | Branch (99:13): [True: 149, False: 11.0k] ------------------ 100| 11.2k| assert(event.type == YAML_STREAM_START_EVENT); ------------------ | Branch (100:9): [True: 0, False: 11.0k] | Branch (100:9): [True: 11.0k, False: 0] ------------------ 101| | /* STREAM-START is expected. */ 102| 11.0k| } 103| | 104| 65.1k| if (parser->stream_end_produced) { ------------------ | Branch (104:9): [True: 0, False: 65.1k] ------------------ 105| 0| return 1; 106| 0| } 107| | 108| 65.1k| if (!yaml_parser_parse(parser, &event)) goto error; ------------------ | Branch (108:9): [True: 2.42k, False: 62.7k] ------------------ 109| 62.7k| if (event.type == YAML_STREAM_END_EVENT) { ------------------ | Branch (109:9): [True: 1.71k, False: 61.0k] ------------------ 110| 1.71k| return 1; 111| 1.71k| } 112| | 113| 61.0k| if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*)) ------------------ | | 424| 61.0k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 61.0k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 61.0k, False: 0] | | ------------------ | | 425| 61.0k| ((stack).top = (stack).start, \ | | 426| 61.0k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 61.0k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 61.0k| 1) : \ | | 428| 61.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (113:9): [True: 0, False: 61.0k] ------------------ 114| 0| goto error; 115| | 116| 61.0k| parser->document = document; 117| | 118| 61.0k| if (!yaml_parser_load_document(parser, &event)) goto error; ------------------ | Branch (118:9): [True: 1.85k, False: 59.1k] ------------------ 119| | 120| 59.1k| yaml_parser_delete_aliases(parser); 121| 59.1k| parser->document = NULL; 122| | 123| 59.1k| return 1; 124| | 125| 4.42k|error: 126| | 127| 4.42k| yaml_parser_delete_aliases(parser); 128| 4.42k| yaml_document_delete(document); 129| 4.42k| parser->document = NULL; 130| | 131| 4.42k| return 0; 132| 61.0k|} loader.c:yaml_parser_delete_aliases: 173| 63.6k|{ 174| 70.8k| while (!STACK_EMPTY(parser, parser->aliases)) { ------------------ | | 436| 70.8k| ((stack).start == (stack).top) ------------------ | Branch (174:12): [True: 7.28k, False: 63.6k] ------------------ 175| 7.28k| yaml_free(POP(parser, parser->aliases).anchor); ------------------ | | 454| 7.28k| (*(--(stack).top)) ------------------ 176| 7.28k| } 177| 63.6k| STACK_DEL(parser, parser->aliases); ------------------ | | 432| 63.6k| (yaml_free((stack).start), \ | | 433| 63.6k| (stack).start = (stack).top = (stack).end = 0) ------------------ 178| 63.6k|} loader.c:yaml_parser_load_document: 186| 61.0k|{ 187| 61.0k| struct loader_ctx ctx = { NULL, NULL, NULL }; 188| | 189| 61.0k| assert(event->type == YAML_DOCUMENT_START_EVENT); ------------------ | Branch (189:5): [True: 0, False: 61.0k] | Branch (189:5): [True: 61.0k, False: 0] ------------------ 190| | /* DOCUMENT-START is expected. */ 191| | 192| 61.0k| parser->document->version_directive 193| 61.0k| = event->data.document_start.version_directive; 194| 61.0k| parser->document->tag_directives.start 195| 61.0k| = event->data.document_start.tag_directives.start; 196| 61.0k| parser->document->tag_directives.end 197| 61.0k| = event->data.document_start.tag_directives.end; 198| 61.0k| parser->document->start_implicit 199| 61.0k| = event->data.document_start.implicit; 200| 61.0k| parser->document->start_mark = event->start_mark; 201| | 202| 61.0k| if (!STACK_INIT(parser, ctx, int*)) return 0; ------------------ | | 424| 61.0k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 61.0k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 61.0k, False: 0] | | ------------------ | | 425| 61.0k| ((stack).top = (stack).start, \ | | 426| 61.0k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 61.0k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 61.0k| 1) : \ | | 428| 61.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (202:9): [True: 0, False: 61.0k] ------------------ 203| 61.0k| if (!yaml_parser_load_nodes(parser, &ctx)) { ------------------ | Branch (203:9): [True: 1.85k, False: 59.1k] ------------------ 204| 1.85k| STACK_DEL(parser, ctx); ------------------ | | 432| 1.85k| (yaml_free((stack).start), \ | | 433| 1.85k| (stack).start = (stack).top = (stack).end = 0) ------------------ 205| 1.85k| return 0; 206| 1.85k| } 207| 59.1k| STACK_DEL(parser, ctx); ------------------ | | 432| 59.1k| (yaml_free((stack).start), \ | | 433| 59.1k| (stack).start = (stack).top = (stack).end = 0) ------------------ 208| | 209| 59.1k| return 1; 210| 61.0k|} loader.c:yaml_parser_load_nodes: 218| 61.0k|{ 219| 61.0k| yaml_event_t event; 220| | 221| 13.2M| do { 222| 13.2M| if (!yaml_parser_parse(parser, &event)) return 0; ------------------ | Branch (222:13): [True: 1.65k, False: 13.2M] ------------------ 223| | 224| 13.2M| switch (event.type) { 225| 287k| case YAML_ALIAS_EVENT: ------------------ | Branch (225:13): [True: 287k, False: 12.9M] ------------------ 226| 287k| if (!yaml_parser_load_alias(parser, &event, ctx)) return 0; ------------------ | Branch (226:21): [True: 176, False: 287k] ------------------ 227| 287k| break; 228| 7.96M| case YAML_SCALAR_EVENT: ------------------ | Branch (228:13): [True: 7.96M, False: 5.23M] ------------------ 229| 7.96M| if (!yaml_parser_load_scalar(parser, &event, ctx)) return 0; ------------------ | Branch (229:21): [True: 15, False: 7.96M] ------------------ 230| 7.96M| break; 231| 7.96M| case YAML_SEQUENCE_START_EVENT: ------------------ | Branch (231:13): [True: 188k, False: 13.0M] ------------------ 232| 188k| if (!yaml_parser_load_sequence(parser, &event, ctx)) return 0; ------------------ | Branch (232:21): [True: 1, False: 188k] ------------------ 233| 188k| break; 234| 188k| case YAML_SEQUENCE_END_EVENT: ------------------ | Branch (234:13): [True: 170k, False: 13.0M] ------------------ 235| 170k| if (!yaml_parser_load_sequence_end(parser, &event, ctx)) ------------------ | Branch (235:21): [True: 0, False: 170k] ------------------ 236| 0| return 0; 237| 170k| break; 238| 2.27M| case YAML_MAPPING_START_EVENT: ------------------ | Branch (238:13): [True: 2.27M, False: 10.9M] ------------------ 239| 2.27M| if (!yaml_parser_load_mapping(parser, &event, ctx)) return 0; ------------------ | Branch (239:21): [True: 1, False: 2.27M] ------------------ 240| 2.27M| break; 241| 2.27M| case YAML_MAPPING_END_EVENT: ------------------ | Branch (241:13): [True: 2.25M, False: 10.9M] ------------------ 242| 2.25M| if (!yaml_parser_load_mapping_end(parser, &event, ctx)) ------------------ | Branch (242:21): [True: 0, False: 2.25M] ------------------ 243| 0| return 0; 244| 2.25M| break; 245| 2.25M| default: ------------------ | Branch (245:13): [True: 0, False: 13.2M] ------------------ 246| 0| assert(0); /* Could not happen. */ ------------------ | Branch (246:17): [Folded, False: 0] | Branch (246:17): [Folded, False: 0] ------------------ 247| 0| return 0; 248| 59.1k| case YAML_DOCUMENT_END_EVENT: ------------------ | Branch (248:13): [True: 59.1k, False: 13.1M] ------------------ 249| 59.1k| break; 250| 13.2M| } 251| 13.2M| } while (event.type != YAML_DOCUMENT_END_EVENT); ------------------ | Branch (251:14): [True: 13.1M, False: 59.1k] ------------------ 252| | 253| 59.1k| parser->document->end_implicit = event.data.document_end.implicit; 254| 59.1k| parser->document->end_mark = event.end_mark; 255| | 256| 59.1k| return 1; 257| 61.0k|} loader.c:yaml_parser_load_alias: 353| 287k|{ 354| 287k| yaml_char_t *anchor = event->data.alias.anchor; 355| 287k| yaml_alias_data_t *alias_data; 356| | 357| 287k| for (alias_data = parser->aliases.start; 358| 288k| alias_data != parser->aliases.top; alias_data ++) { ------------------ | Branch (358:13): [True: 287k, False: 176] ------------------ 359| 287k| if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) { ------------------ | Branch (359:13): [True: 287k, False: 386] ------------------ 360| 287k| yaml_free(anchor); 361| 287k| return yaml_parser_load_node_add(parser, ctx, alias_data->index); 362| 287k| } 363| 287k| } 364| | 365| 176| yaml_free(anchor); 366| 176| return yaml_parser_set_composer_error(parser, "found undefined alias", 367| 176| event->start_mark); 368| 287k|} loader.c:yaml_parser_load_node_add: 301| 10.7M|{ 302| 10.7M| struct yaml_node_s *parent; 303| 10.7M| int parent_index; 304| | 305| 10.7M| if (STACK_EMPTY(parser, *ctx)) { ------------------ | | 436| 10.7M| ((stack).start == (stack).top) | | ------------------ | | | Branch (436:5): [True: 60.9k, False: 10.6M] | | ------------------ ------------------ 306| | /* This is the root node, there's no tree to add it to. */ 307| 60.9k| return 1; 308| 60.9k| } 309| | 310| 10.6M| parent_index = *((*ctx).top - 1); 311| 10.6M| parent = &parser->document->nodes.start[parent_index-1]; 312| | 313| 10.6M| switch (parent->type) { 314| 1.61M| case YAML_SEQUENCE_NODE: ------------------ | Branch (314:9): [True: 1.61M, False: 9.04M] ------------------ 315| 1.61M| if (!STACK_LIMIT(parser, parent->data.sequence.items, INT_MAX-1)) ------------------ | | 439| 1.61M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 1.61M, False: 0] | | ------------------ | | 440| 1.61M| 1 : \ | | 441| 1.61M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (315:17): [True: 0, False: 1.61M] ------------------ 316| 0| return 0; 317| 1.61M| if (!PUSH(parser, parent->data.sequence.items, index)) ------------------ | | 445| 1.61M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.58M, False: 28.4k] | | ------------------ | | 446| 1.61M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 28.4k, False: 0] | | ------------------ | | 447| 28.4k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.61M| (*((stack).top++) = value, \ | | 449| 1.61M| 1) : \ | | 450| 1.61M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (317:17): [True: 0, False: 1.61M] ------------------ 318| 0| return 0; 319| 1.61M| break; 320| 9.04M| case YAML_MAPPING_NODE: { ------------------ | Branch (320:9): [True: 9.04M, False: 1.61M] ------------------ 321| 9.04M| yaml_node_pair_t pair; 322| 9.04M| if (!STACK_EMPTY(parser, parent->data.mapping.pairs)) { ------------------ | | 436| 9.04M| ((stack).start == (stack).top) ------------------ | Branch (322:17): [True: 6.76M, False: 2.27M] ------------------ 323| 6.76M| yaml_node_pair_t *p = parent->data.mapping.pairs.top - 1; 324| 6.76M| if (p->key != 0 && p->value == 0) { ------------------ | Branch (324:21): [True: 6.76M, False: 0] | Branch (324:36): [True: 4.51M, False: 2.25M] ------------------ 325| 4.51M| p->value = index; 326| 4.51M| break; 327| 4.51M| } 328| 6.76M| } 329| | 330| 4.53M| pair.key = index; 331| 4.53M| pair.value = 0; 332| 4.53M| if (!STACK_LIMIT(parser, parent->data.mapping.pairs, INT_MAX-1)) ------------------ | | 439| 4.53M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 4.53M, False: 0] | | ------------------ | | 440| 4.53M| 1 : \ | | 441| 4.53M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (332:17): [True: 0, False: 4.53M] ------------------ 333| 0| return 0; 334| 4.53M| if (!PUSH(parser, parent->data.mapping.pairs, pair)) ------------------ | | 445| 4.53M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 4.53M, False: 1.71k] | | ------------------ | | 446| 4.53M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.71k, False: 0] | | ------------------ | | 447| 1.71k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 4.53M| (*((stack).top++) = value, \ | | 449| 4.53M| 1) : \ | | 450| 4.53M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (334:17): [True: 0, False: 4.53M] ------------------ 335| 0| return 0; 336| | 337| 4.53M| break; 338| 4.53M| } 339| 4.53M| default: ------------------ | Branch (339:9): [True: 0, False: 10.6M] ------------------ 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.6M| } 343| 10.6M| return 1; 344| 10.6M|} loader.c:yaml_parser_set_composer_error: 141| 176|{ 142| 176| parser->error = YAML_COMPOSER_ERROR; 143| 176| parser->problem = problem; 144| 176| parser->problem_mark = problem_mark; 145| | 146| 176| return 0; 147| 176|} loader.c:yaml_parser_load_scalar: 377| 7.96M|{ 378| 7.96M| yaml_node_t node; 379| 7.96M| int index; 380| 7.96M| yaml_char_t *tag = event->data.scalar.tag; 381| | 382| 7.96M| if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; ------------------ | | 439| 7.96M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 7.96M, False: 0] | | ------------------ | | 440| 7.96M| 1 : \ | | 441| 7.96M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (382:9): [True: 0, False: 7.96M] ------------------ 383| | 384| 7.96M| if (!tag || strcmp((char *)tag, "!") == 0) { ------------------ | Branch (384:9): [True: 7.95M, False: 9.85k] | Branch (384:17): [True: 2.59k, False: 7.26k] ------------------ 385| 7.95M| yaml_free(tag); 386| 7.95M| tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG); ------------------ | | 685| 7.95M|#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG | | ------------------ | | | | 671| 7.95M|#define YAML_STR_TAG "tag:yaml.org,2002:str" | | ------------------ ------------------ 387| 7.95M| if (!tag) goto error; ------------------ | Branch (387:13): [True: 0, False: 7.95M] ------------------ 388| 7.95M| } 389| | 390| 7.96M| SCALAR_NODE_INIT(node, tag, event->data.scalar.value, ------------------ | | 640| 7.96M| (NODE_INIT((node),YAML_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \ | | ------------------ | | | | 632| 7.96M| (memset(&(node), 0, sizeof(yaml_node_t)), \ | | | | 633| 7.96M| (node).type = (node_type), \ | | | | 634| 7.96M| (node).tag = (node_tag), \ | | | | 635| 7.96M| (node).start_mark = (node_start_mark), \ | | | | 636| 7.96M| (node).end_mark = (node_end_mark)) | | ------------------ | | 641| 7.96M| (node).data.scalar.value = (node_value), \ | | 642| 7.96M| (node).data.scalar.length = (node_length), \ | | 643| 7.96M| (node).data.scalar.style = (node_style)) ------------------ 391| 7.96M| event->data.scalar.length, event->data.scalar.style, 392| 7.96M| event->start_mark, event->end_mark); 393| | 394| 7.96M| if (!PUSH(parser, parser->document->nodes, node)) goto error; ------------------ | | 445| 7.96M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 7.94M, False: 24.3k] | | ------------------ | | 446| 7.96M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 24.3k, False: 0] | | ------------------ | | 447| 24.3k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 7.96M| (*((stack).top++) = value, \ | | 449| 7.96M| 1) : \ | | 450| 7.96M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (394:9): [True: 0, False: 7.96M] ------------------ 395| | 396| 7.96M| index = parser->document->nodes.top - parser->document->nodes.start; 397| | 398| 7.96M| if (!yaml_parser_register_anchor(parser, index, ------------------ | Branch (398:9): [True: 15, False: 7.96M] ------------------ 399| 7.96M| event->data.scalar.anchor)) return 0; 400| | 401| 7.96M| 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| 7.96M|} loader.c:yaml_parser_register_anchor: 266| 10.4M|{ 267| 10.4M| yaml_alias_data_t data; 268| 10.4M| yaml_alias_data_t *alias_data; 269| | 270| 10.4M| if (!anchor) return 1; ------------------ | Branch (270:9): [True: 10.4M, False: 7.30k] ------------------ 271| | 272| 7.30k| data.anchor = anchor; 273| 7.30k| data.index = index; 274| 7.30k| data.mark = parser->document->nodes.start[index-1].start_mark; 275| | 276| 7.30k| for (alias_data = parser->aliases.start; 277| 8.59k| alias_data != parser->aliases.top; alias_data ++) { ------------------ | Branch (277:13): [True: 1.31k, False: 7.28k] ------------------ 278| 1.31k| if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) { ------------------ | Branch (278:13): [True: 17, False: 1.29k] ------------------ 279| 17| yaml_free(anchor); 280| 17| return yaml_parser_set_composer_error_context(parser, 281| 17| "found duplicate anchor; first occurrence", 282| 17| alias_data->mark, "second occurrence", data.mark); 283| 17| } 284| 1.31k| } 285| | 286| 7.28k| if (!PUSH(parser, parser->aliases, data)) { ------------------ | | 445| 7.28k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 7.28k, False: 3] | | ------------------ | | 446| 7.28k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 3, False: 0] | | ------------------ | | 447| 3| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 7.28k| (*((stack).top++) = value, \ | | 449| 7.28k| 1) : \ | | 450| 7.28k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (286:9): [True: 0, False: 7.28k] ------------------ 287| 0| yaml_free(anchor); 288| 0| return 0; 289| 0| } 290| | 291| 7.28k| return 1; 292| 7.28k|} loader.c:yaml_parser_set_composer_error_context: 157| 17|{ 158| 17| parser->error = YAML_COMPOSER_ERROR; 159| 17| parser->context = context; 160| 17| parser->context_mark = context_mark; 161| 17| parser->problem = problem; 162| 17| parser->problem_mark = problem_mark; 163| | 164| 17| return 0; 165| 17|} loader.c:yaml_parser_load_sequence: 417| 188k|{ 418| 188k| yaml_node_t node; 419| 188k| struct { 420| 188k| yaml_node_item_t *start; 421| 188k| yaml_node_item_t *end; 422| 188k| yaml_node_item_t *top; 423| 188k| } items = { NULL, NULL, NULL }; 424| 188k| int index; 425| 188k| yaml_char_t *tag = event->data.sequence_start.tag; 426| | 427| 188k| if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; ------------------ | | 439| 188k| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 188k, False: 0] | | ------------------ | | 440| 188k| 1 : \ | | 441| 188k| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (427:9): [True: 0, False: 188k] ------------------ 428| | 429| 188k| if (!tag || strcmp((char *)tag, "!") == 0) { ------------------ | Branch (429:9): [True: 185k, False: 3.00k] | Branch (429:17): [True: 428, False: 2.57k] ------------------ 430| 185k| yaml_free(tag); 431| 185k| tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG); ------------------ | | 687| 185k|#define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG | | ------------------ | | | | 680| 185k|#define YAML_SEQ_TAG "tag:yaml.org,2002:seq" | | ------------------ ------------------ 432| 185k| if (!tag) goto error; ------------------ | Branch (432:13): [True: 0, False: 185k] ------------------ 433| 185k| } 434| | 435| 188k| if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error; ------------------ | | 424| 188k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 188k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 188k, False: 0] | | ------------------ | | 425| 188k| ((stack).top = (stack).start, \ | | 426| 188k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 188k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 188k| 1) : \ | | 428| 188k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (435:9): [True: 0, False: 188k] ------------------ 436| | 437| 188k| SEQUENCE_NODE_INIT(node, tag, items.start, items.end, ------------------ | | 647| 188k| (NODE_INIT((node),YAML_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \ | | ------------------ | | | | 632| 188k| (memset(&(node), 0, sizeof(yaml_node_t)), \ | | | | 633| 188k| (node).type = (node_type), \ | | | | 634| 188k| (node).tag = (node_tag), \ | | | | 635| 188k| (node).start_mark = (node_start_mark), \ | | | | 636| 188k| (node).end_mark = (node_end_mark)) | | ------------------ | | 648| 188k| (node).data.sequence.items.start = (node_items_start), \ | | 649| 188k| (node).data.sequence.items.end = (node_items_end), \ | | 650| 188k| (node).data.sequence.items.top = (node_items_start), \ | | 651| 188k| (node).data.sequence.style = (node_style)) ------------------ 438| 188k| event->data.sequence_start.style, 439| 188k| event->start_mark, event->end_mark); 440| | 441| 188k| if (!PUSH(parser, parser->document->nodes, node)) goto error; ------------------ | | 445| 188k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 186k, False: 2.01k] | | ------------------ | | 446| 188k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 2.01k, False: 0] | | ------------------ | | 447| 2.01k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 188k| (*((stack).top++) = value, \ | | 449| 188k| 1) : \ | | 450| 188k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (441:9): [True: 0, False: 188k] ------------------ 442| | 443| 188k| index = parser->document->nodes.top - parser->document->nodes.start; 444| | 445| 188k| if (!yaml_parser_register_anchor(parser, index, ------------------ | Branch (445:9): [True: 1, False: 188k] ------------------ 446| 188k| event->data.sequence_start.anchor)) return 0; 447| | 448| 188k| if (!yaml_parser_load_node_add(parser, ctx, index)) return 0; ------------------ | Branch (448:9): [True: 0, False: 188k] ------------------ 449| | 450| 188k| if (!STACK_LIMIT(parser, *ctx, INT_MAX-1)) return 0; ------------------ | | 439| 188k| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 188k, False: 0] | | ------------------ | | 440| 188k| 1 : \ | | 441| 188k| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (450:9): [True: 0, False: 188k] ------------------ 451| 188k| if (!PUSH(parser, *ctx, index)) return 0; ------------------ | | 445| 188k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 186k, False: 1.96k] | | ------------------ | | 446| 188k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.96k, False: 0] | | ------------------ | | 447| 1.96k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 188k| (*((stack).top++) = value, \ | | 449| 188k| 1) : \ | | 450| 188k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (451:9): [True: 0, False: 188k] ------------------ 452| | 453| 188k| 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| 188k|} loader.c:yaml_parser_load_sequence_end: 464| 170k|{ 465| 170k| int index; 466| | 467| 170k| assert(((*ctx).top - (*ctx).start) > 0); ------------------ | Branch (467:5): [True: 0, False: 170k] | Branch (467:5): [True: 170k, False: 0] ------------------ 468| | 469| 170k| index = *((*ctx).top - 1); 470| 170k| assert(parser->document->nodes.start[index-1].type == YAML_SEQUENCE_NODE); ------------------ | Branch (470:5): [True: 0, False: 170k] | Branch (470:5): [True: 170k, False: 0] ------------------ 471| 170k| parser->document->nodes.start[index-1].end_mark = event->end_mark; 472| | 473| 170k| (void)POP(parser, *ctx); ------------------ | | 454| 170k| (*(--(stack).top)) ------------------ 474| | 475| 170k| return 1; 476| 170k|} loader.c:yaml_parser_load_mapping: 485| 2.27M|{ 486| 2.27M| yaml_node_t node; 487| 2.27M| struct { 488| 2.27M| yaml_node_pair_t *start; 489| 2.27M| yaml_node_pair_t *end; 490| 2.27M| yaml_node_pair_t *top; 491| 2.27M| } pairs = { NULL, NULL, NULL }; 492| 2.27M| int index; 493| 2.27M| yaml_char_t *tag = event->data.mapping_start.tag; 494| | 495| 2.27M| if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; ------------------ | | 439| 2.27M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 2.27M, False: 0] | | ------------------ | | 440| 2.27M| 1 : \ | | 441| 2.27M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (495:9): [True: 0, False: 2.27M] ------------------ 496| | 497| 2.27M| if (!tag || strcmp((char *)tag, "!") == 0) { ------------------ | Branch (497:9): [True: 2.27M, False: 1.45k] | Branch (497:17): [True: 633, False: 824] ------------------ 498| 2.27M| yaml_free(tag); 499| 2.27M| tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG); ------------------ | | 689| 2.27M|#define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG | | ------------------ | | | | 682| 2.27M|#define YAML_MAP_TAG "tag:yaml.org,2002:map" | | ------------------ ------------------ 500| 2.27M| if (!tag) goto error; ------------------ | Branch (500:13): [True: 0, False: 2.27M] ------------------ 501| 2.27M| } 502| | 503| 2.27M| if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error; ------------------ | | 424| 2.27M| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 2.27M|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 2.27M, False: 0] | | ------------------ | | 425| 2.27M| ((stack).top = (stack).start, \ | | 426| 2.27M| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 2.27M|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 2.27M| 1) : \ | | 428| 2.27M| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (503:9): [True: 0, False: 2.27M] ------------------ 504| | 505| 2.27M| MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end, ------------------ | | 655| 2.27M| (NODE_INIT((node),YAML_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \ | | ------------------ | | | | 632| 2.27M| (memset(&(node), 0, sizeof(yaml_node_t)), \ | | | | 633| 2.27M| (node).type = (node_type), \ | | | | 634| 2.27M| (node).tag = (node_tag), \ | | | | 635| 2.27M| (node).start_mark = (node_start_mark), \ | | | | 636| 2.27M| (node).end_mark = (node_end_mark)) | | ------------------ | | 656| 2.27M| (node).data.mapping.pairs.start = (node_pairs_start), \ | | 657| 2.27M| (node).data.mapping.pairs.end = (node_pairs_end), \ | | 658| 2.27M| (node).data.mapping.pairs.top = (node_pairs_start), \ | | 659| 2.27M| (node).data.mapping.style = (node_style)) ------------------ 506| 2.27M| event->data.mapping_start.style, 507| 2.27M| event->start_mark, event->end_mark); 508| | 509| 2.27M| if (!PUSH(parser, parser->document->nodes, node)) goto error; ------------------ | | 445| 2.27M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.24M, False: 33.8k] | | ------------------ | | 446| 2.27M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 33.8k, False: 0] | | ------------------ | | 447| 33.8k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.27M| (*((stack).top++) = value, \ | | 449| 2.27M| 1) : \ | | 450| 2.27M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (509:9): [True: 0, False: 2.27M] ------------------ 510| | 511| 2.27M| index = parser->document->nodes.top - parser->document->nodes.start; 512| | 513| 2.27M| if (!yaml_parser_register_anchor(parser, index, ------------------ | Branch (513:9): [True: 1, False: 2.27M] ------------------ 514| 2.27M| event->data.mapping_start.anchor)) return 0; 515| | 516| 2.27M| if (!yaml_parser_load_node_add(parser, ctx, index)) return 0; ------------------ | Branch (516:9): [True: 0, False: 2.27M] ------------------ 517| | 518| 2.27M| if (!STACK_LIMIT(parser, *ctx, INT_MAX-1)) return 0; ------------------ | | 439| 2.27M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 2.27M, False: 0] | | ------------------ | | 440| 2.27M| 1 : \ | | 441| 2.27M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 0| 0)) ------------------ | Branch (518:9): [True: 0, False: 2.27M] ------------------ 519| 2.27M| if (!PUSH(parser, *ctx, index)) return 0; ------------------ | | 445| 2.27M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.24M, False: 29.5k] | | ------------------ | | 446| 2.27M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 29.5k, False: 0] | | ------------------ | | 447| 29.5k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.27M| (*((stack).top++) = value, \ | | 449| 2.27M| 1) : \ | | 450| 2.27M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (519:9): [True: 0, False: 2.27M] ------------------ 520| | 521| 2.27M| 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.27M|} loader.c:yaml_parser_load_mapping_end: 532| 2.25M|{ 533| 2.25M| int index; 534| | 535| 2.25M| assert(((*ctx).top - (*ctx).start) > 0); ------------------ | Branch (535:5): [True: 0, False: 2.25M] | Branch (535:5): [True: 2.25M, False: 0] ------------------ 536| | 537| 2.25M| index = *((*ctx).top - 1); 538| 2.25M| assert(parser->document->nodes.start[index-1].type == YAML_MAPPING_NODE); ------------------ | Branch (538:5): [True: 0, False: 2.25M] | Branch (538:5): [True: 2.25M, False: 0] ------------------ 539| 2.25M| parser->document->nodes.start[index-1].end_mark = event->end_mark; 540| | 541| 2.25M| (void)POP(parser, *ctx); ------------------ | | 454| 2.25M| (*(--(stack).top)) ------------------ 542| | 543| 2.25M| return 1; 544| 2.25M|} yaml_parser_parse: 190| 13.2M|{ 191| 13.2M| assert(parser); /* Non-NULL parser object is expected. */ ------------------ | Branch (191:5): [True: 0, False: 13.2M] | Branch (191:5): [True: 13.2M, False: 0] ------------------ 192| 13.2M| assert(event); /* Non-NULL event object is expected. */ ------------------ | Branch (192:5): [True: 0, False: 13.2M] | Branch (192:5): [True: 13.2M, False: 0] ------------------ 193| | 194| | /* Erase the event object. */ 195| | 196| 13.2M| memset(event, 0, sizeof(yaml_event_t)); 197| | 198| | /* No events after the end of the stream or error. */ 199| | 200| 13.2M| if (parser->stream_end_produced || parser->error || ------------------ | Branch (200:9): [True: 0, False: 13.2M] | Branch (200:40): [True: 0, False: 13.2M] ------------------ 201| 13.2M| parser->state == YAML_PARSE_END_STATE) { ------------------ | Branch (201:13): [True: 0, False: 13.2M] ------------------ 202| 0| return 1; 203| 0| } 204| | 205| | /* Generate the next event. */ 206| | 207| 13.2M| return yaml_parser_state_machine(parser, event); 208| 13.2M|} parser.c:yaml_parser_state_machine: 245| 13.2M|{ 246| 13.2M| switch (parser->state) 247| 13.2M| { 248| 11.2k| case YAML_PARSE_STREAM_START_STATE: ------------------ | Branch (248:9): [True: 11.2k, False: 13.2M] ------------------ 249| 11.2k| return yaml_parser_parse_stream_start(parser, event); 250| | 251| 11.0k| case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE: ------------------ | Branch (251:9): [True: 11.0k, False: 13.2M] ------------------ 252| 11.0k| return yaml_parser_parse_document_start(parser, event, 1); 253| | 254| 54.0k| case YAML_PARSE_DOCUMENT_START_STATE: ------------------ | Branch (254:9): [True: 54.0k, False: 13.2M] ------------------ 255| 54.0k| return yaml_parser_parse_document_start(parser, event, 0); 256| | 257| 52.6k| case YAML_PARSE_DOCUMENT_CONTENT_STATE: ------------------ | Branch (257:9): [True: 52.6k, False: 13.2M] ------------------ 258| 52.6k| return yaml_parser_parse_document_content(parser, event); 259| | 260| 59.2k| case YAML_PARSE_DOCUMENT_END_STATE: ------------------ | Branch (260:9): [True: 59.2k, False: 13.2M] ------------------ 261| 59.2k| return yaml_parser_parse_document_end(parser, event); 262| | 263| 8.34k| case YAML_PARSE_BLOCK_NODE_STATE: ------------------ | Branch (263:9): [True: 8.34k, False: 13.2M] ------------------ 264| 8.34k| return yaml_parser_parse_node(parser, event, 1, 0); 265| | 266| 0| case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: ------------------ | Branch (266:9): [True: 0, False: 13.2M] ------------------ 267| 0| return yaml_parser_parse_node(parser, event, 1, 1); 268| | 269| 0| case YAML_PARSE_FLOW_NODE_STATE: ------------------ | Branch (269:9): [True: 0, False: 13.2M] ------------------ 270| 0| return yaml_parser_parse_node(parser, event, 0, 0); 271| | 272| 44.1k| case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: ------------------ | Branch (272:9): [True: 44.1k, False: 13.2M] ------------------ 273| 44.1k| return yaml_parser_parse_block_sequence_entry(parser, event, 1); 274| | 275| 50.8k| case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: ------------------ | Branch (275:9): [True: 50.8k, False: 13.2M] ------------------ 276| 50.8k| return yaml_parser_parse_block_sequence_entry(parser, event, 0); 277| | 278| 891k| case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: ------------------ | Branch (278:9): [True: 891k, False: 12.3M] ------------------ 279| 891k| return yaml_parser_parse_indentless_sequence_entry(parser, event); 280| | 281| 2.16M| case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (281:9): [True: 2.16M, False: 11.1M] ------------------ 282| 2.16M| return yaml_parser_parse_block_mapping_key(parser, event, 1); 283| | 284| 2.34M| case YAML_PARSE_BLOCK_MAPPING_KEY_STATE: ------------------ | Branch (284:9): [True: 2.34M, False: 10.9M] ------------------ 285| 2.34M| return yaml_parser_parse_block_mapping_key(parser, event, 0); 286| | 287| 2.34M| case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE: ------------------ | Branch (287:9): [True: 2.34M, False: 10.9M] ------------------ 288| 2.34M| return yaml_parser_parse_block_mapping_value(parser, event); 289| | 290| 78.0k| case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: ------------------ | Branch (290:9): [True: 78.0k, False: 13.2M] ------------------ 291| 78.0k| return yaml_parser_parse_flow_sequence_entry(parser, event, 1); 292| | 293| 722k| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE: ------------------ | Branch (293:9): [True: 722k, False: 12.5M] ------------------ 294| 722k| return yaml_parser_parse_flow_sequence_entry(parser, event, 0); 295| | 296| 102k| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: ------------------ | Branch (296:9): [True: 102k, False: 13.1M] ------------------ 297| 102k| return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event); 298| | 299| 100k| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: ------------------ | Branch (299:9): [True: 100k, False: 13.1M] ------------------ 300| 100k| return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event); 301| | 302| 99.3k| case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: ------------------ | Branch (302:9): [True: 99.3k, False: 13.1M] ------------------ 303| 99.3k| return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event); 304| | 305| 14.8k| case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: ------------------ | Branch (305:9): [True: 14.8k, False: 13.2M] ------------------ 306| 14.8k| return yaml_parser_parse_flow_mapping_key(parser, event, 1); 307| | 308| 2.06M| case YAML_PARSE_FLOW_MAPPING_KEY_STATE: ------------------ | Branch (308:9): [True: 2.06M, False: 11.2M] ------------------ 309| 2.06M| return yaml_parser_parse_flow_mapping_key(parser, event, 0); 310| | 311| 2.11k| case YAML_PARSE_FLOW_MAPPING_VALUE_STATE: ------------------ | Branch (311:9): [True: 2.11k, False: 13.2M] ------------------ 312| 2.11k| return yaml_parser_parse_flow_mapping_value(parser, event, 0); 313| | 314| 2.06M| case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: ------------------ | Branch (314:9): [True: 2.06M, False: 11.2M] ------------------ 315| 2.06M| return yaml_parser_parse_flow_mapping_value(parser, event, 1); 316| | 317| 0| default: ------------------ | Branch (317:9): [True: 0, False: 13.2M] ------------------ 318| 0| assert(1); /* Invalid state. */ ------------------ | Branch (318:13): [True: 0, Folded] | Branch (318:13): [True: 0, Folded] ------------------ 319| 13.2M| } 320| | 321| 0| return 0; 322| 13.2M|} parser.c:yaml_parser_parse_stream_start: 332| 11.2k|{ 333| 11.2k| yaml_token_t *token; 334| | 335| 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.0k, False: 149] | | ------------------ | | 50| 11.2k| parser->tokens.head : NULL) ------------------ 336| 11.2k| if (!token) return 0; ------------------ | Branch (336:9): [True: 149, False: 11.0k] ------------------ 337| | 338| 11.0k| if (token->type != YAML_STREAM_START_TOKEN) { ------------------ | Branch (338:9): [True: 0, False: 11.0k] ------------------ 339| 0| return yaml_parser_set_parser_error(parser, 340| 0| "did not find expected ", token->start_mark); 341| 0| } 342| | 343| 11.0k| parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE; 344| 11.0k| STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding, ------------------ | | 552| 11.0k| (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 11.0k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 11.0k| (event).type = (event_type), \ | | | | 548| 11.0k| (event).start_mark = (event_start_mark), \ | | | | 549| 11.0k| (event).end_mark = (event_end_mark)) | | ------------------ | | 553| 11.0k| (event).data.stream_start.encoding = (event_encoding)) ------------------ 345| 11.0k| token->start_mark, token->start_mark); 346| 11.0k| SKIP_TOKEN(parser); ------------------ | | 57| 11.0k| (parser->token_available = 0, \ | | 58| 11.0k| parser->tokens_parsed ++, \ | | 59| 11.0k| parser->stream_end_produced = \ | | 60| 11.0k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 11.0k| parser->tokens.head ++) ------------------ 347| | 348| 11.0k| return 1; 349| 11.0k|} parser.c:yaml_parser_set_parser_error: 217| 576|{ 218| 576| parser->error = YAML_PARSER_ERROR; 219| 576| parser->problem = problem; 220| 576| parser->problem_mark = problem_mark; 221| | 222| 576| return 0; 223| 576|} parser.c:yaml_parser_parse_document_start: 362| 65.1k|{ 363| 65.1k| yaml_token_t *token; 364| 65.1k| yaml_version_directive_t *version_directive = NULL; 365| 65.1k| struct { 366| 65.1k| yaml_tag_directive_t *start; 367| 65.1k| yaml_tag_directive_t *end; 368| 65.1k| } tag_directives = { NULL, NULL }; 369| | 370| 65.1k| token = PEEK_TOKEN(parser); ------------------ | | 49| 65.1k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 53.1k, False: 12.0k] | | | Branch (49:34): [True: 10.2k, False: 1.76k] | | ------------------ | | 50| 65.1k| parser->tokens.head : NULL) ------------------ 371| 65.1k| if (!token) return 0; ------------------ | Branch (371:9): [True: 1.76k, False: 63.4k] ------------------ 372| | 373| | /* Parse extra document end indicators. */ 374| | 375| 63.4k| if (!implicit) ------------------ | Branch (375:9): [True: 54.0k, False: 9.32k] ------------------ 376| 54.0k| { 377| 55.1k| while (token->type == YAML_DOCUMENT_END_TOKEN) { ------------------ | Branch (377:16): [True: 1.10k, False: 54.0k] ------------------ 378| 1.10k| SKIP_TOKEN(parser); ------------------ | | 57| 1.10k| (parser->token_available = 0, \ | | 58| 1.10k| parser->tokens_parsed ++, \ | | 59| 1.10k| parser->stream_end_produced = \ | | 60| 1.10k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 1.10k| parser->tokens.head ++) ------------------ 379| 1.10k| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.10k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 1.10k] | | | Branch (49:34): [True: 1.10k, False: 1] | | ------------------ | | 50| 1.10k| parser->tokens.head : NULL) ------------------ 380| 1.10k| if (!token) return 0; ------------------ | Branch (380:17): [True: 1, False: 1.10k] ------------------ 381| 1.10k| } 382| 54.0k| } 383| | 384| | /* Parse an implicit document. */ 385| | 386| 63.4k| if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN && ------------------ | Branch (386:9): [True: 9.32k, False: 54.0k] | Branch (386:21): [True: 9.21k, False: 108] ------------------ 387| 9.21k| token->type != YAML_TAG_DIRECTIVE_TOKEN && ------------------ | Branch (387:13): [True: 8.56k, False: 643] ------------------ 388| 8.56k| token->type != YAML_DOCUMENT_START_TOKEN && ------------------ | Branch (388:13): [True: 8.54k, False: 28] ------------------ 389| 8.54k| token->type != YAML_STREAM_END_TOKEN) ------------------ | Branch (389:13): [True: 8.34k, False: 194] ------------------ 390| 8.34k| { 391| 8.34k| if (!yaml_parser_process_directives(parser, NULL, NULL, NULL)) ------------------ | Branch (391:13): [True: 0, False: 8.34k] ------------------ 392| 0| return 0; 393| 8.34k| if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) ------------------ | | 445| 8.34k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 8.34k, False: 0] | | ------------------ | | 446| 8.34k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 8.34k| (*((stack).top++) = value, \ | | 449| 8.34k| 1) : \ | | 450| 8.34k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (393:13): [True: 0, False: 8.34k] ------------------ 394| 0| return 0; 395| 8.34k| parser->state = YAML_PARSE_BLOCK_NODE_STATE; 396| 8.34k| DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1, ------------------ | | 560| 8.34k| (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 8.34k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 8.34k| (event).type = (event_type), \ | | | | 548| 8.34k| (event).start_mark = (event_start_mark), \ | | | | 549| 8.34k| (event).end_mark = (event_end_mark)) | | ------------------ | | 561| 8.34k| (event).data.document_start.version_directive = (event_version_directive), \ | | 562| 8.34k| (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ | | 563| 8.34k| (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ | | 564| 8.34k| (event).data.document_start.implicit = (event_implicit)) ------------------ 397| 8.34k| token->start_mark, token->start_mark); 398| 8.34k| return 1; 399| 8.34k| } 400| | 401| | /* Parse an explicit document. */ 402| | 403| 55.0k| else if (token->type != YAML_STREAM_END_TOKEN) ------------------ | Branch (403:14): [True: 53.3k, False: 1.71k] ------------------ 404| 53.3k| { 405| 53.3k| yaml_mark_t start_mark, end_mark; 406| 53.3k| start_mark = token->start_mark; 407| 53.3k| if (!yaml_parser_process_directives(parser, &version_directive, ------------------ | Branch (407:13): [True: 248, False: 53.1k] ------------------ 408| 53.3k| &tag_directives.start, &tag_directives.end)) 409| 248| return 0; 410| 53.1k| token = PEEK_TOKEN(parser); ------------------ | | 49| 53.1k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 53.1k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 53.1k| parser->tokens.head : NULL) ------------------ 411| 53.1k| if (!token) goto error; ------------------ | Branch (411:13): [True: 0, False: 53.1k] ------------------ 412| 53.1k| if (token->type != YAML_DOCUMENT_START_TOKEN) { ------------------ | Branch (412:13): [True: 410, False: 52.6k] ------------------ 413| 410| yaml_parser_set_parser_error(parser, 414| 410| "did not find expected ", token->start_mark); 415| 410| goto error; 416| 410| } 417| 52.6k| if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) ------------------ | | 445| 52.6k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 52.6k, False: 0] | | ------------------ | | 446| 52.6k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 52.6k| (*((stack).top++) = value, \ | | 449| 52.6k| 1) : \ | | 450| 52.6k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (417:13): [True: 0, False: 52.6k] ------------------ 418| 0| goto error; 419| 52.6k| parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE; 420| 52.6k| end_mark = token->end_mark; 421| 52.6k| DOCUMENT_START_EVENT_INIT(*event, version_directive, ------------------ | | 560| 52.6k| (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 52.6k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 52.6k| (event).type = (event_type), \ | | | | 548| 52.6k| (event).start_mark = (event_start_mark), \ | | | | 549| 52.6k| (event).end_mark = (event_end_mark)) | | ------------------ | | 561| 52.6k| (event).data.document_start.version_directive = (event_version_directive), \ | | 562| 52.6k| (event).data.document_start.tag_directives.start = (event_tag_directives_start), \ | | 563| 52.6k| (event).data.document_start.tag_directives.end = (event_tag_directives_end), \ | | 564| 52.6k| (event).data.document_start.implicit = (event_implicit)) ------------------ 422| 52.6k| tag_directives.start, tag_directives.end, 0, 423| 52.6k| start_mark, end_mark); 424| 52.6k| SKIP_TOKEN(parser); ------------------ | | 57| 52.6k| (parser->token_available = 0, \ | | 58| 52.6k| parser->tokens_parsed ++, \ | | 59| 52.6k| parser->stream_end_produced = \ | | 60| 52.6k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 52.6k| parser->tokens.head ++) ------------------ 425| 52.6k| version_directive = NULL; 426| 52.6k| tag_directives.start = tag_directives.end = NULL; 427| 52.6k| return 1; 428| 52.6k| } 429| | 430| | /* Parse the stream end. */ 431| | 432| 1.71k| else 433| 1.71k| { 434| 1.71k| parser->state = YAML_PARSE_END_STATE; 435| 1.71k| STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 556| 1.71k| (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 1.71k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 1.71k| (event).type = (event_type), \ | | | | 548| 1.71k| (event).start_mark = (event_start_mark), \ | | | | 549| 1.71k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 436| 1.71k| SKIP_TOKEN(parser); ------------------ | | 57| 1.71k| (parser->token_available = 0, \ | | 58| 1.71k| parser->tokens_parsed ++, \ | | 59| 1.71k| parser->stream_end_produced = \ | | 60| 1.71k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 1.71k| parser->tokens.head ++) ------------------ 437| 1.71k| return 1; 438| 1.71k| } 439| | 440| 410|error: 441| 410| yaml_free(version_directive); 442| 948| while (tag_directives.start != tag_directives.end) { ------------------ | Branch (442:12): [True: 538, False: 410] ------------------ 443| 538| yaml_free(tag_directives.end[-1].handle); 444| 538| yaml_free(tag_directives.end[-1].prefix); 445| 538| tag_directives.end --; 446| 538| } 447| 410| yaml_free(tag_directives.start); 448| 410| return 0; 449| 63.4k|} parser.c:yaml_parser_process_directives: 1256| 61.6k|{ 1257| 61.6k| yaml_tag_directive_t default_tag_directives[] = { 1258| 61.6k| {(yaml_char_t *)"!", (yaml_char_t *)"!"}, 1259| 61.6k| {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, 1260| 61.6k| {NULL, NULL} 1261| 61.6k| }; 1262| 61.6k| yaml_tag_directive_t *default_tag_directive; 1263| 61.6k| yaml_version_directive_t *version_directive = NULL; 1264| 61.6k| struct { 1265| 61.6k| yaml_tag_directive_t *start; 1266| 61.6k| yaml_tag_directive_t *end; 1267| 61.6k| yaml_tag_directive_t *top; 1268| 61.6k| } tag_directives = { NULL, NULL, NULL }; 1269| 61.6k| yaml_token_t *token; 1270| | 1271| 61.6k| if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*)) ------------------ | | 424| 61.6k| (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \ | | ------------------ | | | | 84| 61.6k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | | Branch (424:4): [True: 61.6k, False: 0] | | ------------------ | | 425| 61.6k| ((stack).top = (stack).start, \ | | 426| 61.6k| (stack).end = (stack).start+INITIAL_STACK_SIZE, \ | | ------------------ | | | | 84| 61.6k|#define INITIAL_STACK_SIZE 16 | | ------------------ | | 427| 61.6k| 1) : \ | | 428| 61.6k| ((context)->error = YAML_MEMORY_ERROR, \ | | 429| 0| 0)) ------------------ | Branch (1271:9): [True: 0, False: 61.6k] ------------------ 1272| 0| goto error; 1273| | 1274| 61.6k| token = PEEK_TOKEN(parser); ------------------ | | 49| 61.6k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 61.6k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 61.6k| parser->tokens.head : NULL) ------------------ 1275| 61.6k| if (!token) goto error; ------------------ | Branch (1275:9): [True: 0, False: 61.6k] ------------------ 1276| | 1277| 174k| while (token->type == YAML_VERSION_DIRECTIVE_TOKEN || ------------------ | Branch (1277:12): [True: 8.39k, False: 166k] ------------------ 1278| 166k| token->type == YAML_TAG_DIRECTIVE_TOKEN) ------------------ | Branch (1278:13): [True: 104k, False: 61.4k] ------------------ 1279| 113k| { 1280| 113k| if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) { ------------------ | Branch (1280:13): [True: 8.39k, False: 104k] ------------------ 1281| 8.39k| if (version_directive) { ------------------ | Branch (1281:17): [True: 7, False: 8.38k] ------------------ 1282| 7| yaml_parser_set_parser_error(parser, 1283| 7| "found duplicate %YAML directive", token->start_mark); 1284| 7| goto error; 1285| 7| } 1286| 8.38k| if (token->data.version_directive.major != 1 ------------------ | Branch (1286:17): [True: 51, False: 8.33k] ------------------ 1287| 8.33k| || ( 1288| 8.33k| token->data.version_directive.minor != 1 ------------------ | Branch (1288:25): [True: 3.46k, False: 4.87k] ------------------ 1289| 3.46k| && token->data.version_directive.minor != 2 ------------------ | Branch (1289:28): [True: 34, False: 3.42k] ------------------ 1290| 8.33k| )) { 1291| 85| yaml_parser_set_parser_error(parser, 1292| 85| "found incompatible YAML document", token->start_mark); 1293| 85| goto error; 1294| 85| } 1295| 8.29k| version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t); ------------------ | | 683| 8.29k|#define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type)) ------------------ 1296| 8.29k| if (!version_directive) { ------------------ | Branch (1296:17): [True: 0, False: 8.29k] ------------------ 1297| 0| parser->error = YAML_MEMORY_ERROR; 1298| 0| goto error; 1299| 0| } 1300| 8.29k| version_directive->major = token->data.version_directive.major; 1301| 8.29k| version_directive->minor = token->data.version_directive.minor; 1302| 8.29k| } 1303| | 1304| 104k| else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) { ------------------ | Branch (1304:18): [True: 104k, False: 0] ------------------ 1305| 104k| yaml_tag_directive_t value; 1306| 104k| value.handle = token->data.tag_directive.handle; 1307| 104k| value.prefix = token->data.tag_directive.prefix; 1308| | 1309| 104k| if (!yaml_parser_append_tag_directive(parser, value, 0, ------------------ | Branch (1309:17): [True: 74, False: 104k] ------------------ 1310| 104k| token->start_mark)) 1311| 74| goto error; 1312| 104k| if (!PUSH(parser, tag_directives, value)) ------------------ | | 445| 104k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 101k, False: 3.13k] | | ------------------ | | 446| 104k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 3.13k, False: 0] | | ------------------ | | 447| 3.13k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 104k| (*((stack).top++) = value, \ | | 449| 104k| 1) : \ | | 450| 104k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1312:17): [True: 0, False: 104k] ------------------ 1313| 0| goto error; 1314| 104k| } 1315| | 1316| 112k| SKIP_TOKEN(parser); ------------------ | | 57| 112k| (parser->token_available = 0, \ | | 58| 112k| parser->tokens_parsed ++, \ | | 59| 112k| parser->stream_end_produced = \ | | 60| 112k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 112k| parser->tokens.head ++) ------------------ 1317| 112k| token = PEEK_TOKEN(parser); ------------------ | | 49| 112k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 112k] | | | Branch (49:34): [True: 112k, False: 82] | | ------------------ | | 50| 112k| parser->tokens.head : NULL) ------------------ 1318| 112k| if (!token) goto error; ------------------ | Branch (1318:13): [True: 82, False: 112k] ------------------ 1319| 112k| } 1320| | 1321| 61.4k| for (default_tag_directive = default_tag_directives; 1322| 184k| default_tag_directive->handle; default_tag_directive++) { ------------------ | Branch (1322:13): [True: 122k, False: 61.4k] ------------------ 1323| 122k| if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1, ------------------ | Branch (1323:13): [True: 0, False: 122k] ------------------ 1324| 122k| token->start_mark)) 1325| 0| goto error; 1326| 122k| } 1327| | 1328| 61.4k| if (version_directive_ref) { ------------------ | Branch (1328:9): [True: 53.1k, False: 8.34k] ------------------ 1329| 53.1k| *version_directive_ref = version_directive; 1330| 53.1k| } 1331| 61.4k| if (tag_directives_start_ref) { ------------------ | Branch (1331:9): [True: 53.1k, False: 8.34k] ------------------ 1332| 53.1k| if (STACK_EMPTY(parser, tag_directives)) { ------------------ | | 436| 53.1k| ((stack).start == (stack).top) | | ------------------ | | | Branch (436:5): [True: 39.0k, False: 14.0k] | | ------------------ ------------------ 1333| 39.0k| *tag_directives_start_ref = *tag_directives_end_ref = NULL; 1334| 39.0k| STACK_DEL(parser, tag_directives); ------------------ | | 432| 39.0k| (yaml_free((stack).start), \ | | 433| 39.0k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1335| 39.0k| } 1336| 14.0k| else { 1337| 14.0k| *tag_directives_start_ref = tag_directives.start; 1338| 14.0k| *tag_directives_end_ref = tag_directives.top; 1339| 14.0k| } 1340| 53.1k| } 1341| 8.34k| else { 1342| 8.34k| STACK_DEL(parser, tag_directives); ------------------ | | 432| 8.34k| (yaml_free((stack).start), \ | | 433| 8.34k| (stack).start = (stack).top = (stack).end = 0) ------------------ 1343| 8.34k| } 1344| | 1345| 61.4k| if (!version_directive_ref) ------------------ | Branch (1345:9): [True: 8.34k, False: 53.1k] ------------------ 1346| 8.34k| yaml_free(version_directive); 1347| 61.4k| return 1; 1348| | 1349| 248|error: 1350| 248| yaml_free(version_directive); 1351| 796| while (!STACK_EMPTY(parser, tag_directives)) { ------------------ | | 436| 796| ((stack).start == (stack).top) ------------------ | Branch (1351:12): [True: 548, False: 248] ------------------ 1352| 548| yaml_tag_directive_t tag_directive = POP(parser, tag_directives); ------------------ | | 454| 548| (*(--(stack).top)) ------------------ 1353| 548| yaml_free(tag_directive.handle); 1354| 548| yaml_free(tag_directive.prefix); 1355| 548| } 1356| 248| STACK_DEL(parser, tag_directives); ------------------ | | 432| 248| (yaml_free((stack).start), \ | | 433| 248| (stack).start = (stack).top = (stack).end = 0) ------------------ 1357| 248| return 0; 1358| 61.4k|} parser.c:yaml_parser_append_tag_directive: 1367| 227k|{ 1368| 227k| yaml_tag_directive_t *tag_directive; 1369| 227k| yaml_tag_directive_t copy = { NULL, NULL }; 1370| | 1371| 227k| for (tag_directive = parser->tag_directives.start; 1372| 1.04M| tag_directive != parser->tag_directives.top; tag_directive ++) { ------------------ | Branch (1372:13): [True: 839k, False: 208k] ------------------ 1373| 839k| if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { ------------------ | Branch (1373:13): [True: 18.7k, False: 821k] ------------------ 1374| 18.7k| if (allow_duplicates) ------------------ | Branch (1374:17): [True: 18.7k, False: 74] ------------------ 1375| 18.7k| return 1; 1376| 74| return yaml_parser_set_parser_error(parser, 1377| 74| "found duplicate %TAG directive", mark); 1378| 18.7k| } 1379| 839k| } 1380| | 1381| 208k| copy.handle = yaml_strdup(value.handle); 1382| 208k| copy.prefix = yaml_strdup(value.prefix); 1383| 208k| if (!copy.handle || !copy.prefix) { ------------------ | Branch (1383:9): [True: 0, False: 208k] | Branch (1383:25): [True: 0, False: 208k] ------------------ 1384| 0| parser->error = YAML_MEMORY_ERROR; 1385| 0| goto error; 1386| 0| } 1387| | 1388| 208k| if (!PUSH(parser, parser->tag_directives, copy)) ------------------ | | 445| 208k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 208k, False: 63] | | ------------------ | | 446| 208k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 63, False: 0] | | ------------------ | | 447| 63| (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 (1388:9): [True: 0, False: 208k] ------------------ 1389| 0| goto error; 1390| | 1391| 208k| return 1; 1392| | 1393| 0|error: 1394| 0| yaml_free(copy.handle); 1395| 0| yaml_free(copy.prefix); 1396| 0| return 0; 1397| 208k|} parser.c:yaml_parser_parse_document_content: 459| 52.6k|{ 460| 52.6k| yaml_token_t *token; 461| | 462| 52.6k| token = PEEK_TOKEN(parser); ------------------ | | 49| 52.6k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 52.6k] | | | Branch (49:34): [True: 52.6k, False: 30] | | ------------------ | | 50| 52.6k| parser->tokens.head : NULL) ------------------ 463| 52.6k| if (!token) return 0; ------------------ | Branch (463:9): [True: 30, False: 52.6k] ------------------ 464| | 465| 52.6k| if (token->type == YAML_VERSION_DIRECTIVE_TOKEN || ------------------ | Branch (465:9): [True: 2.17k, False: 50.4k] ------------------ 466| 50.4k| token->type == YAML_TAG_DIRECTIVE_TOKEN || ------------------ | Branch (466:13): [True: 962, False: 49.5k] ------------------ 467| 49.5k| token->type == YAML_DOCUMENT_START_TOKEN || ------------------ | Branch (467:13): [True: 2.32k, False: 47.1k] ------------------ 468| 47.1k| token->type == YAML_DOCUMENT_END_TOKEN || ------------------ | Branch (468:13): [True: 644, False: 46.5k] ------------------ 469| 46.5k| token->type == YAML_STREAM_END_TOKEN) { ------------------ | Branch (469:13): [True: 430, False: 46.1k] ------------------ 470| 6.53k| parser->state = POP(parser, parser->states); ------------------ | | 454| 6.53k| (*(--(stack).top)) ------------------ 471| 6.53k| return yaml_parser_process_empty_scalar(parser, event, 472| 6.53k| token->start_mark); 473| 6.53k| } 474| 46.1k| else { 475| 46.1k| return yaml_parser_parse_node(parser, event, 1, 0); 476| 46.1k| } 477| 52.6k|} parser.c:yaml_parser_process_empty_scalar: 1231| 4.53M|{ 1232| 4.53M| yaml_char_t *value; 1233| | 1234| 4.53M| value = YAML_MALLOC(1); ------------------ | | 684| 4.53M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 1235| 4.53M| if (!value) { ------------------ | Branch (1235:9): [True: 0, False: 4.53M] ------------------ 1236| 0| parser->error = YAML_MEMORY_ERROR; 1237| 0| return 0; 1238| 0| } 1239| 4.53M| value[0] = '\0'; 1240| | 1241| 4.53M| SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0, ------------------ | | 576| 4.53M| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 4.53M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 4.53M| (event).type = (event_type), \ | | | | 548| 4.53M| (event).start_mark = (event_start_mark), \ | | | | 549| 4.53M| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 4.53M| (event).data.scalar.anchor = (event_anchor), \ | | 578| 4.53M| (event).data.scalar.tag = (event_tag), \ | | 579| 4.53M| (event).data.scalar.value = (event_value), \ | | 580| 4.53M| (event).data.scalar.length = (event_length), \ | | 581| 4.53M| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 4.53M| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 4.53M| (event).data.scalar.style = (event_style)) ------------------ 1242| 4.53M| 1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark); 1243| | 1244| 4.53M| return 1; 1245| 4.53M|} parser.c:yaml_parser_parse_document_end: 489| 59.2k|{ 490| 59.2k| yaml_token_t *token; 491| 59.2k| yaml_mark_t start_mark, end_mark; 492| 59.2k| int implicit = 1; 493| | 494| 59.2k| token = PEEK_TOKEN(parser); ------------------ | | 49| 59.2k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 8.21k, False: 51.0k] | | | Branch (49:34): [True: 50.9k, False: 38] | | ------------------ | | 50| 59.2k| parser->tokens.head : NULL) ------------------ 495| 59.2k| if (!token) return 0; ------------------ | Branch (495:9): [True: 38, False: 59.1k] ------------------ 496| | 497| 59.1k| start_mark = end_mark = token->start_mark; 498| | 499| 59.1k| if (token->type == YAML_DOCUMENT_END_TOKEN) { ------------------ | Branch (499:9): [True: 952, False: 58.2k] ------------------ 500| 952| end_mark = token->end_mark; 501| 952| SKIP_TOKEN(parser); ------------------ | | 57| 952| (parser->token_available = 0, \ | | 58| 952| parser->tokens_parsed ++, \ | | 59| 952| parser->stream_end_produced = \ | | 60| 952| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 952| parser->tokens.head ++) ------------------ 502| 952| implicit = 0; 503| 952| } 504| | 505| 262k| while (!STACK_EMPTY(parser, parser->tag_directives)) { ------------------ | | 436| 262k| ((stack).start == (stack).top) ------------------ | Branch (505:12): [True: 203k, False: 59.1k] ------------------ 506| 203k| yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); ------------------ | | 454| 203k| (*(--(stack).top)) ------------------ 507| 203k| yaml_free(tag_directive.handle); 508| 203k| yaml_free(tag_directive.prefix); 509| 203k| } 510| | 511| 59.1k| parser->state = YAML_PARSE_DOCUMENT_START_STATE; 512| 59.1k| DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark); ------------------ | | 567| 59.1k| (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 59.1k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 59.1k| (event).type = (event_type), \ | | | | 548| 59.1k| (event).start_mark = (event_start_mark), \ | | | | 549| 59.1k| (event).end_mark = (event_end_mark)) | | ------------------ | | 568| 59.1k| (event).data.document_end.implicit = (event_implicit)) ------------------ 513| | 514| 59.1k| return 1; 515| 59.2k|} parser.c:yaml_parser_parse_node: 549| 6.08M|{ 550| 6.08M| yaml_token_t *token; 551| 6.08M| yaml_char_t *anchor = NULL; 552| 6.08M| yaml_char_t *tag_handle = NULL; 553| 6.08M| yaml_char_t *tag_suffix = NULL; 554| 6.08M| yaml_char_t *tag = NULL; 555| 6.08M| yaml_mark_t start_mark, end_mark, tag_mark; 556| 6.08M| int implicit; 557| | 558| 6.08M| token = PEEK_TOKEN(parser); ------------------ | | 49| 6.08M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 6.08M, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 6.08M| parser->tokens.head : NULL) ------------------ 559| 6.08M| if (!token) return 0; ------------------ | Branch (559:9): [True: 0, False: 6.08M] ------------------ 560| | 561| 6.08M| if (token->type == YAML_ALIAS_TOKEN) ------------------ | Branch (561:9): [True: 287k, False: 5.80M] ------------------ 562| 287k| { 563| 287k| parser->state = POP(parser, parser->states); ------------------ | | 454| 287k| (*(--(stack).top)) ------------------ 564| 287k| ALIAS_EVENT_INIT(*event, token->data.alias.value, ------------------ | | 571| 287k| (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 287k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 287k| (event).type = (event_type), \ | | | | 548| 287k| (event).start_mark = (event_start_mark), \ | | | | 549| 287k| (event).end_mark = (event_end_mark)) | | ------------------ | | 572| 287k| (event).data.alias.anchor = (event_anchor)) ------------------ 565| 287k| token->start_mark, token->end_mark); 566| 287k| SKIP_TOKEN(parser); ------------------ | | 57| 287k| (parser->token_available = 0, \ | | 58| 287k| parser->tokens_parsed ++, \ | | 59| 287k| parser->stream_end_produced = \ | | 60| 287k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 287k| parser->tokens.head ++) ------------------ 567| 287k| return 1; 568| 287k| } 569| | 570| 5.80M| else 571| 5.80M| { 572| 5.80M| start_mark = end_mark = token->start_mark; 573| | 574| 5.80M| if (token->type == YAML_ANCHOR_TOKEN) ------------------ | Branch (574:13): [True: 7.09k, False: 5.79M] ------------------ 575| 7.09k| { 576| 7.09k| anchor = token->data.anchor.value; 577| 7.09k| start_mark = token->start_mark; 578| 7.09k| end_mark = token->end_mark; 579| 7.09k| SKIP_TOKEN(parser); ------------------ | | 57| 7.09k| (parser->token_available = 0, \ | | 58| 7.09k| parser->tokens_parsed ++, \ | | 59| 7.09k| parser->stream_end_produced = \ | | 60| 7.09k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 7.09k| parser->tokens.head ++) ------------------ 580| 7.09k| token = PEEK_TOKEN(parser); ------------------ | | 49| 7.09k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 7.09k] | | | Branch (49:34): [True: 7.09k, False: 3] | | ------------------ | | 50| 7.09k| parser->tokens.head : NULL) ------------------ 581| 7.09k| if (!token) goto error; ------------------ | Branch (581:17): [True: 3, False: 7.09k] ------------------ 582| 7.09k| if (token->type == YAML_TAG_TOKEN) ------------------ | Branch (582:17): [True: 207, False: 6.88k] ------------------ 583| 207| { 584| 207| tag_handle = token->data.tag.handle; 585| 207| tag_suffix = token->data.tag.suffix; 586| 207| tag_mark = token->start_mark; 587| 207| end_mark = token->end_mark; 588| 207| SKIP_TOKEN(parser); ------------------ | | 57| 207| (parser->token_available = 0, \ | | 58| 207| parser->tokens_parsed ++, \ | | 59| 207| parser->stream_end_produced = \ | | 60| 207| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 207| parser->tokens.head ++) ------------------ 589| 207| token = PEEK_TOKEN(parser); ------------------ | | 49| 207| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 207] | | | Branch (49:34): [True: 206, False: 1] | | ------------------ | | 50| 207| parser->tokens.head : NULL) ------------------ 590| 207| if (!token) goto error; ------------------ | Branch (590:21): [True: 1, False: 206] ------------------ 591| 207| } 592| 7.09k| } 593| 5.79M| else if (token->type == YAML_TAG_TOKEN) ------------------ | Branch (593:18): [True: 14.1k, False: 5.77M] ------------------ 594| 14.1k| { 595| 14.1k| tag_handle = token->data.tag.handle; 596| 14.1k| tag_suffix = token->data.tag.suffix; 597| 14.1k| start_mark = tag_mark = token->start_mark; 598| 14.1k| end_mark = token->end_mark; 599| 14.1k| SKIP_TOKEN(parser); ------------------ | | 57| 14.1k| (parser->token_available = 0, \ | | 58| 14.1k| parser->tokens_parsed ++, \ | | 59| 14.1k| parser->stream_end_produced = \ | | 60| 14.1k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 14.1k| parser->tokens.head ++) ------------------ 600| 14.1k| token = PEEK_TOKEN(parser); ------------------ | | 49| 14.1k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 14.1k] | | | Branch (49:34): [True: 14.1k, False: 5] | | ------------------ | | 50| 14.1k| parser->tokens.head : NULL) ------------------ 601| 14.1k| if (!token) goto error; ------------------ | Branch (601:17): [True: 5, False: 14.1k] ------------------ 602| 14.1k| if (token->type == YAML_ANCHOR_TOKEN) ------------------ | Branch (602:17): [True: 214, False: 13.9k] ------------------ 603| 214| { 604| 214| anchor = token->data.anchor.value; 605| 214| end_mark = token->end_mark; 606| 214| SKIP_TOKEN(parser); ------------------ | | 57| 214| (parser->token_available = 0, \ | | 58| 214| parser->tokens_parsed ++, \ | | 59| 214| parser->stream_end_produced = \ | | 60| 214| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 214| parser->tokens.head ++) ------------------ 607| 214| token = PEEK_TOKEN(parser); ------------------ | | 49| 214| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 214] | | | Branch (49:34): [True: 211, False: 3] | | ------------------ | | 50| 214| parser->tokens.head : NULL) ------------------ 608| 214| if (!token) goto error; ------------------ | Branch (608:21): [True: 3, False: 211] ------------------ 609| 214| } 610| 14.1k| } 611| | 612| 5.80M| if (tag_handle) { ------------------ | Branch (612:13): [True: 14.3k, False: 5.78M] ------------------ 613| 14.3k| if (!*tag_handle) { ------------------ | Branch (613:17): [True: 6.53k, False: 7.80k] ------------------ 614| 6.53k| tag = tag_suffix; 615| 6.53k| yaml_free(tag_handle); 616| 6.53k| tag_handle = tag_suffix = NULL; 617| 6.53k| } 618| 7.80k| else { 619| 7.80k| yaml_tag_directive_t *tag_directive; 620| 7.80k| for (tag_directive = parser->tag_directives.start; 621| 10.8k| tag_directive != parser->tag_directives.top; ------------------ | Branch (621:25): [True: 10.8k, False: 21] ------------------ 622| 10.8k| tag_directive ++) { 623| 10.8k| if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) { ------------------ | Branch (623:25): [True: 7.78k, False: 3.09k] ------------------ 624| 7.78k| size_t prefix_len = strlen((char *)tag_directive->prefix); 625| 7.78k| size_t suffix_len = strlen((char *)tag_suffix); 626| 7.78k| tag = YAML_MALLOC(prefix_len+suffix_len+1); ------------------ | | 684| 7.78k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 627| 7.78k| if (!tag) { ------------------ | Branch (627:29): [True: 0, False: 7.78k] ------------------ 628| 0| parser->error = YAML_MEMORY_ERROR; 629| 0| goto error; 630| 0| } 631| 7.78k| memcpy(tag, tag_directive->prefix, prefix_len); 632| 7.78k| memcpy(tag+prefix_len, tag_suffix, suffix_len); 633| 7.78k| tag[prefix_len+suffix_len] = '\0'; 634| 7.78k| yaml_free(tag_handle); 635| 7.78k| yaml_free(tag_suffix); 636| 7.78k| tag_handle = tag_suffix = NULL; 637| 7.78k| break; 638| 7.78k| } 639| 10.8k| } 640| 7.80k| if (!tag) { ------------------ | Branch (640:21): [True: 21, False: 7.78k] ------------------ 641| 21| yaml_parser_set_parser_error_context(parser, 642| 21| "while parsing a node", start_mark, 643| 21| "found undefined tag handle", tag_mark); 644| 21| goto error; 645| 21| } 646| 7.80k| } 647| 14.3k| } 648| | 649| 5.80M| implicit = (!tag || !*tag); ------------------ | Branch (649:21): [True: 5.78M, False: 14.3k] | Branch (649:29): [True: 52, False: 14.2k] ------------------ 650| 5.80M| if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) { ------------------ | Branch (650:13): [True: 2.38M, False: 3.41M] | Branch (650:36): [True: 65.9k, False: 2.31M] ------------------ 651| 65.9k| end_mark = token->end_mark; 652| 65.9k| parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; 653| 65.9k| SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 587| 65.9k| (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 65.9k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 65.9k| (event).type = (event_type), \ | | | | 548| 65.9k| (event).start_mark = (event_start_mark), \ | | | | 549| 65.9k| (event).end_mark = (event_end_mark)) | | ------------------ | | 588| 65.9k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 65.9k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 65.9k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 65.9k| (event).data.sequence_start.style = (event_style)) ------------------ 654| 65.9k| YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); 655| 65.9k| return 1; 656| 65.9k| } 657| 5.73M| else { 658| 5.73M| if (token->type == YAML_SCALAR_TOKEN) { ------------------ | Branch (658:17): [True: 3.42M, False: 2.30M] ------------------ 659| 3.42M| int plain_implicit = 0; 660| 3.42M| int quoted_implicit = 0; 661| 3.42M| end_mark = token->end_mark; 662| 3.42M| if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag) ------------------ | Branch (662:22): [True: 3.38M, False: 43.5k] | Branch (662:77): [True: 3.38M, False: 3.71k] ------------------ 663| 3.38M| || (tag && strcmp((char *)tag, "!") == 0)) { ------------------ | Branch (663:29): [True: 4.67k, False: 42.5k] | Branch (663:36): [True: 510, False: 4.16k] ------------------ 664| 3.38M| plain_implicit = 1; 665| 3.38M| } 666| 46.7k| else if (!tag) { ------------------ | Branch (666:26): [True: 42.5k, False: 4.16k] ------------------ 667| 42.5k| quoted_implicit = 1; 668| 42.5k| } 669| 3.42M| parser->state = POP(parser, parser->states); ------------------ | | 454| 3.42M| (*(--(stack).top)) ------------------ 670| 3.42M| SCALAR_EVENT_INIT(*event, anchor, tag, ------------------ | | 576| 3.42M| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 3.42M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 3.42M| (event).type = (event_type), \ | | | | 548| 3.42M| (event).start_mark = (event_start_mark), \ | | | | 549| 3.42M| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 3.42M| (event).data.scalar.anchor = (event_anchor), \ | | 578| 3.42M| (event).data.scalar.tag = (event_tag), \ | | 579| 3.42M| (event).data.scalar.value = (event_value), \ | | 580| 3.42M| (event).data.scalar.length = (event_length), \ | | 581| 3.42M| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 3.42M| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 3.42M| (event).data.scalar.style = (event_style)) ------------------ 671| 3.42M| token->data.scalar.value, token->data.scalar.length, 672| 3.42M| plain_implicit, quoted_implicit, 673| 3.42M| token->data.scalar.style, start_mark, end_mark); 674| 3.42M| SKIP_TOKEN(parser); ------------------ | | 57| 3.42M| (parser->token_available = 0, \ | | 58| 3.42M| parser->tokens_parsed ++, \ | | 59| 3.42M| parser->stream_end_produced = \ | | 60| 3.42M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 3.42M| parser->tokens.head ++) ------------------ 675| 3.42M| return 1; 676| 3.42M| } 677| 2.30M| else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) { ------------------ | Branch (677:22): [True: 78.0k, False: 2.22M] ------------------ 678| 78.0k| end_mark = token->end_mark; 679| 78.0k| parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE; 680| 78.0k| SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 587| 78.0k| (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 78.0k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 78.0k| (event).type = (event_type), \ | | | | 548| 78.0k| (event).start_mark = (event_start_mark), \ | | | | 549| 78.0k| (event).end_mark = (event_end_mark)) | | ------------------ | | 588| 78.0k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 78.0k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 78.0k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 78.0k| (event).data.sequence_start.style = (event_style)) ------------------ 681| 78.0k| YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark); 682| 78.0k| return 1; 683| 78.0k| } 684| 2.22M| else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) { ------------------ | Branch (684:22): [True: 14.8k, False: 2.21M] ------------------ 685| 14.8k| end_mark = token->end_mark; 686| 14.8k| parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE; 687| 14.8k| MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 598| 14.8k| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 14.8k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 14.8k| (event).type = (event_type), \ | | | | 548| 14.8k| (event).start_mark = (event_start_mark), \ | | | | 549| 14.8k| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 14.8k| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 14.8k| (event).data.mapping_start.tag = (event_tag), \ | | 601| 14.8k| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 14.8k| (event).data.mapping_start.style = (event_style)) ------------------ 688| 14.8k| YAML_FLOW_MAPPING_STYLE, start_mark, end_mark); 689| 14.8k| return 1; 690| 14.8k| } 691| 2.21M| else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) { ------------------ | Branch (691:22): [True: 2.21M, False: 3.51k] | Branch (691:31): [True: 44.1k, False: 2.16M] ------------------ 692| 44.1k| end_mark = token->end_mark; 693| 44.1k| parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE; 694| 44.1k| SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 587| 44.1k| (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 44.1k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 44.1k| (event).type = (event_type), \ | | | | 548| 44.1k| (event).start_mark = (event_start_mark), \ | | | | 549| 44.1k| (event).end_mark = (event_end_mark)) | | ------------------ | | 588| 44.1k| (event).data.sequence_start.anchor = (event_anchor), \ | | 589| 44.1k| (event).data.sequence_start.tag = (event_tag), \ | | 590| 44.1k| (event).data.sequence_start.implicit = (event_implicit), \ | | 591| 44.1k| (event).data.sequence_start.style = (event_style)) ------------------ 695| 44.1k| YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); 696| 44.1k| return 1; 697| 44.1k| } 698| 2.16M| else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) { ------------------ | Branch (698:22): [True: 2.16M, False: 3.51k] | Branch (698:31): [True: 2.16M, False: 4.92k] ------------------ 699| 2.16M| end_mark = token->end_mark; 700| 2.16M| parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE; 701| 2.16M| MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, ------------------ | | 598| 2.16M| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 2.16M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.16M| (event).type = (event_type), \ | | | | 548| 2.16M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.16M| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 2.16M| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 2.16M| (event).data.mapping_start.tag = (event_tag), \ | | 601| 2.16M| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 2.16M| (event).data.mapping_start.style = (event_style)) ------------------ 702| 2.16M| YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark); 703| 2.16M| return 1; 704| 2.16M| } 705| 8.44k| else if (anchor || tag) { ------------------ | Branch (705:22): [True: 3.15k, False: 5.28k] | Branch (705:32): [True: 4.85k, False: 432] ------------------ 706| 8.01k| yaml_char_t *value = YAML_MALLOC(1); ------------------ | | 684| 8.01k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 707| 8.01k| if (!value) { ------------------ | Branch (707:21): [True: 0, False: 8.01k] ------------------ 708| 0| parser->error = YAML_MEMORY_ERROR; 709| 0| goto error; 710| 0| } 711| 8.01k| value[0] = '\0'; 712| 8.01k| parser->state = POP(parser, parser->states); ------------------ | | 454| 8.01k| (*(--(stack).top)) ------------------ 713| 8.01k| SCALAR_EVENT_INIT(*event, anchor, tag, value, 0, ------------------ | | 576| 8.01k| (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 8.01k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 8.01k| (event).type = (event_type), \ | | | | 548| 8.01k| (event).start_mark = (event_start_mark), \ | | | | 549| 8.01k| (event).end_mark = (event_end_mark)) | | ------------------ | | 577| 8.01k| (event).data.scalar.anchor = (event_anchor), \ | | 578| 8.01k| (event).data.scalar.tag = (event_tag), \ | | 579| 8.01k| (event).data.scalar.value = (event_value), \ | | 580| 8.01k| (event).data.scalar.length = (event_length), \ | | 581| 8.01k| (event).data.scalar.plain_implicit = (event_plain_implicit), \ | | 582| 8.01k| (event).data.scalar.quoted_implicit = (event_quoted_implicit), \ | | 583| 8.01k| (event).data.scalar.style = (event_style)) ------------------ 714| 8.01k| implicit, 0, YAML_PLAIN_SCALAR_STYLE, 715| 8.01k| start_mark, end_mark); 716| 8.01k| return 1; 717| 8.01k| } 718| 432| else { 719| 432| yaml_parser_set_parser_error_context(parser, 720| 432| (block ? "while parsing a block node" ------------------ | Branch (720:26): [True: 15, False: 417] ------------------ 721| 432| : "while parsing a flow node"), start_mark, 722| 432| "did not find expected node content", token->start_mark); 723| 432| goto error; 724| 432| } 725| 5.73M| } 726| 5.80M| } 727| | 728| 465|error: 729| 465| yaml_free(anchor); 730| 465| yaml_free(tag_handle); 731| 465| yaml_free(tag_suffix); 732| 465| yaml_free(tag); 733| | 734| 465| return 0; 735| 6.08M|} parser.c:yaml_parser_set_parser_error_context: 229| 1.24k|{ 230| 1.24k| parser->error = YAML_PARSER_ERROR; 231| 1.24k| parser->context = context; 232| 1.24k| parser->context_mark = context_mark; 233| 1.24k| parser->problem = problem; 234| 1.24k| parser->problem_mark = problem_mark; 235| | 236| 1.24k| return 0; 237| 1.24k|} parser.c:yaml_parser_parse_block_sequence_entry: 746| 95.0k|{ 747| 95.0k| yaml_token_t *token; 748| | 749| 95.0k| if (first) { ------------------ | Branch (749:9): [True: 44.1k, False: 50.8k] ------------------ 750| 44.1k| token = PEEK_TOKEN(parser); ------------------ | | 49| 44.1k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 44.1k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 44.1k| parser->tokens.head : NULL) ------------------ 751| 44.1k| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 44.1k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 43.8k, False: 346] | | ------------------ | | 446| 44.1k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 346, False: 0] | | ------------------ | | 447| 346| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 44.1k| (*((stack).top++) = value, \ | | 449| 44.1k| 1) : \ | | 450| 44.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (751:13): [True: 0, False: 44.1k] ------------------ 752| 0| return 0; 753| 44.1k| SKIP_TOKEN(parser); ------------------ | | 57| 44.1k| (parser->token_available = 0, \ | | 58| 44.1k| parser->tokens_parsed ++, \ | | 59| 44.1k| parser->stream_end_produced = \ | | 60| 44.1k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 44.1k| parser->tokens.head ++) ------------------ 754| 44.1k| } 755| | 756| 95.0k| token = PEEK_TOKEN(parser); ------------------ | | 49| 95.0k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 7.74k, False: 87.2k] | | | Branch (49:34): [True: 87.2k, False: 19] | | ------------------ | | 50| 95.0k| parser->tokens.head : NULL) ------------------ 757| 95.0k| if (!token) return 0; ------------------ | Branch (757:9): [True: 19, False: 94.9k] ------------------ 758| | 759| 94.9k| if (token->type == YAML_BLOCK_ENTRY_TOKEN) ------------------ | Branch (759:9): [True: 57.2k, False: 37.7k] ------------------ 760| 57.2k| { 761| 57.2k| yaml_mark_t mark = token->end_mark; 762| 57.2k| SKIP_TOKEN(parser); ------------------ | | 57| 57.2k| (parser->token_available = 0, \ | | 58| 57.2k| parser->tokens_parsed ++, \ | | 59| 57.2k| parser->stream_end_produced = \ | | 60| 57.2k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 57.2k| parser->tokens.head ++) ------------------ 763| 57.2k| token = PEEK_TOKEN(parser); ------------------ | | 49| 57.2k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 57.2k] | | | Branch (49:34): [True: 57.2k, False: 33] | | ------------------ | | 50| 57.2k| parser->tokens.head : NULL) ------------------ 764| 57.2k| if (!token) return 0; ------------------ | Branch (764:13): [True: 33, False: 57.2k] ------------------ 765| 57.2k| if (token->type != YAML_BLOCK_ENTRY_TOKEN && ------------------ | Branch (765:13): [True: 52.9k, False: 4.33k] ------------------ 766| 52.9k| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (766:17): [True: 49.5k, False: 3.36k] ------------------ 767| 49.5k| if (!PUSH(parser, parser->states, ------------------ | | 445| 49.5k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 49.2k, False: 354] | | ------------------ | | 446| 49.5k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 354, False: 0] | | ------------------ | | 447| 354| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 49.5k| (*((stack).top++) = value, \ | | 449| 49.5k| 1) : \ | | 450| 49.5k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (767:17): [True: 0, False: 49.5k] ------------------ 768| 49.5k| YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)) 769| 0| return 0; 770| 49.5k| return yaml_parser_parse_node(parser, event, 1, 0); 771| 49.5k| } 772| 7.70k| else { 773| 7.70k| parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE; 774| 7.70k| return yaml_parser_process_empty_scalar(parser, event, mark); 775| 7.70k| } 776| 57.2k| } 777| | 778| 37.7k| else if (token->type == YAML_BLOCK_END_TOKEN) ------------------ | Branch (778:14): [True: 37.6k, False: 79] ------------------ 779| 37.6k| { 780| 37.6k| parser->state = POP(parser, parser->states); ------------------ | | 454| 37.6k| (*(--(stack).top)) ------------------ 781| 37.6k| (void)POP(parser, parser->marks); ------------------ | | 454| 37.6k| (*(--(stack).top)) ------------------ 782| 37.6k| SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 594| 37.6k| (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 37.6k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 37.6k| (event).type = (event_type), \ | | | | 548| 37.6k| (event).start_mark = (event_start_mark), \ | | | | 549| 37.6k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 783| 37.6k| SKIP_TOKEN(parser); ------------------ | | 57| 37.6k| (parser->token_available = 0, \ | | 58| 37.6k| parser->tokens_parsed ++, \ | | 59| 37.6k| parser->stream_end_produced = \ | | 60| 37.6k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 37.6k| parser->tokens.head ++) ------------------ 784| 37.6k| return 1; 785| 37.6k| } 786| | 787| 79| else 788| 79| { 789| 79| return yaml_parser_set_parser_error_context(parser, 790| 79| "while parsing a block collection", POP(parser, parser->marks), ------------------ | | 454| 79| (*(--(stack).top)) ------------------ 791| 79| "did not find expected '-' indicator", token->start_mark); 792| 79| } 793| 94.9k|} parser.c:yaml_parser_parse_indentless_sequence_entry: 804| 891k|{ 805| 891k| yaml_token_t *token; 806| | 807| 891k| token = PEEK_TOKEN(parser); ------------------ | | 49| 891k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 69.4k, False: 822k] | | | Branch (49:34): [True: 822k, False: 3] | | ------------------ | | 50| 891k| parser->tokens.head : NULL) ------------------ 808| 891k| if (!token) return 0; ------------------ | Branch (808:9): [True: 3, False: 891k] ------------------ 809| | 810| 891k| if (token->type == YAML_BLOCK_ENTRY_TOKEN) ------------------ | Branch (810:9): [True: 825k, False: 65.9k] ------------------ 811| 825k| { 812| 825k| yaml_mark_t mark = token->end_mark; 813| 825k| SKIP_TOKEN(parser); ------------------ | | 57| 825k| (parser->token_available = 0, \ | | 58| 825k| parser->tokens_parsed ++, \ | | 59| 825k| parser->stream_end_produced = \ | | 60| 825k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 825k| parser->tokens.head ++) ------------------ 814| 825k| token = PEEK_TOKEN(parser); ------------------ | | 49| 825k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 825k] | | | Branch (49:34): [True: 825k, False: 1] | | ------------------ | | 50| 825k| parser->tokens.head : NULL) ------------------ 815| 825k| if (!token) return 0; ------------------ | Branch (815:13): [True: 1, False: 825k] ------------------ 816| 825k| if (token->type != YAML_BLOCK_ENTRY_TOKEN && ------------------ | Branch (816:13): [True: 825k, False: 828] ------------------ 817| 825k| token->type != YAML_KEY_TOKEN && ------------------ | Branch (817:17): [True: 824k, False: 768] ------------------ 818| 824k| token->type != YAML_VALUE_TOKEN && ------------------ | Branch (818:17): [True: 824k, False: 194] ------------------ 819| 824k| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (819:17): [True: 823k, False: 272] ------------------ 820| 823k| if (!PUSH(parser, parser->states, ------------------ | | 445| 823k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 823k, False: 1] | | ------------------ | | 446| 823k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1, False: 0] | | ------------------ | | 447| 1| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 823k| (*((stack).top++) = value, \ | | 449| 823k| 1) : \ | | 450| 823k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (820:17): [True: 0, False: 823k] ------------------ 821| 823k| YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)) 822| 0| return 0; 823| 823k| return yaml_parser_parse_node(parser, event, 1, 0); 824| 823k| } 825| 2.06k| else { 826| 2.06k| parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; 827| 2.06k| return yaml_parser_process_empty_scalar(parser, event, mark); 828| 2.06k| } 829| 825k| } 830| | 831| 65.9k| else 832| 65.9k| { 833| 65.9k| parser->state = POP(parser, parser->states); ------------------ | | 454| 65.9k| (*(--(stack).top)) ------------------ 834| 65.9k| SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark); ------------------ | | 594| 65.9k| (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 65.9k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 65.9k| (event).type = (event_type), \ | | | | 548| 65.9k| (event).start_mark = (event_start_mark), \ | | | | 549| 65.9k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 835| 65.9k| return 1; 836| 65.9k| } 837| 891k|} parser.c:yaml_parser_parse_block_mapping_key: 854| 4.50M|{ 855| 4.50M| yaml_token_t *token; 856| | 857| 4.50M| if (first) { ------------------ | Branch (857:9): [True: 2.16M, False: 2.34M] ------------------ 858| 2.16M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.16M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 2.16M, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 2.16M| parser->tokens.head : NULL) ------------------ 859| 2.16M| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 2.16M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.15M, False: 1.61k] | | ------------------ | | 446| 2.16M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.61k, False: 0] | | ------------------ | | 447| 1.61k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.16M| (*((stack).top++) = value, \ | | 449| 2.16M| 1) : \ | | 450| 2.16M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (859:13): [True: 0, False: 2.16M] ------------------ 860| 0| return 0; 861| 2.16M| SKIP_TOKEN(parser); ------------------ | | 57| 2.16M| (parser->token_available = 0, \ | | 58| 2.16M| parser->tokens_parsed ++, \ | | 59| 2.16M| parser->stream_end_produced = \ | | 60| 2.16M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.16M| parser->tokens.head ++) ------------------ 862| 2.16M| } 863| | 864| 4.50M| token = PEEK_TOKEN(parser); ------------------ | | 49| 4.50M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 2.33M, False: 2.17M] | | | Branch (49:34): [True: 2.17M, False: 19] | | ------------------ | | 50| 4.50M| parser->tokens.head : NULL) ------------------ 865| 4.50M| if (!token) return 0; ------------------ | Branch (865:9): [True: 19, False: 4.50M] ------------------ 866| | 867| 4.50M| if (token->type == YAML_KEY_TOKEN) ------------------ | Branch (867:9): [True: 2.35M, False: 2.15M] ------------------ 868| 2.35M| { 869| 2.35M| yaml_mark_t mark = token->end_mark; 870| 2.35M| SKIP_TOKEN(parser); ------------------ | | 57| 2.35M| (parser->token_available = 0, \ | | 58| 2.35M| parser->tokens_parsed ++, \ | | 59| 2.35M| parser->stream_end_produced = \ | | 60| 2.35M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.35M| parser->tokens.head ++) ------------------ 871| 2.35M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.35M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 2.35M] | | | Branch (49:34): [True: 2.35M, False: 44] | | ------------------ | | 50| 2.35M| parser->tokens.head : NULL) ------------------ 872| 2.35M| if (!token) return 0; ------------------ | Branch (872:13): [True: 44, False: 2.35M] ------------------ 873| 2.35M| if (token->type != YAML_KEY_TOKEN && ------------------ | Branch (873:13): [True: 2.34M, False: 4.15k] ------------------ 874| 2.34M| token->type != YAML_VALUE_TOKEN && ------------------ | Branch (874:17): [True: 2.34M, False: 221] ------------------ 875| 2.34M| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (875:17): [True: 2.31M, False: 38.3k] ------------------ 876| 2.31M| if (!PUSH(parser, parser->states, ------------------ | | 445| 2.31M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.30M, False: 1.62k] | | ------------------ | | 446| 2.31M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.62k, False: 0] | | ------------------ | | 447| 1.62k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.31M| (*((stack).top++) = value, \ | | 449| 2.31M| 1) : \ | | 450| 2.31M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (876:17): [True: 0, False: 2.31M] ------------------ 877| 2.31M| YAML_PARSE_BLOCK_MAPPING_VALUE_STATE)) 878| 0| return 0; 879| 2.31M| return yaml_parser_parse_node(parser, event, 1, 1); 880| 2.31M| } 881| 42.7k| else { 882| 42.7k| parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE; 883| 42.7k| return yaml_parser_process_empty_scalar(parser, event, mark); 884| 42.7k| } 885| 2.35M| } 886| | 887| 2.15M| else if (token->type == YAML_BLOCK_END_TOKEN) ------------------ | Branch (887:14): [True: 2.15M, False: 118] ------------------ 888| 2.15M| { 889| 2.15M| parser->state = POP(parser, parser->states); ------------------ | | 454| 2.15M| (*(--(stack).top)) ------------------ 890| 2.15M| (void)POP(parser, parser->marks); ------------------ | | 454| 2.15M| (*(--(stack).top)) ------------------ 891| 2.15M| MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 605| 2.15M| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 2.15M| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 2.15M| (event).type = (event_type), \ | | | | 548| 2.15M| (event).start_mark = (event_start_mark), \ | | | | 549| 2.15M| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 892| 2.15M| SKIP_TOKEN(parser); ------------------ | | 57| 2.15M| (parser->token_available = 0, \ | | 58| 2.15M| parser->tokens_parsed ++, \ | | 59| 2.15M| parser->stream_end_produced = \ | | 60| 2.15M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.15M| parser->tokens.head ++) ------------------ 893| 2.15M| return 1; 894| 2.15M| } 895| | 896| 118| else 897| 118| { 898| 118| return yaml_parser_set_parser_error_context(parser, 899| 118| "while parsing a block mapping", POP(parser, parser->marks), ------------------ | | 454| 118| (*(--(stack).top)) ------------------ 900| 118| "did not find expected key", token->start_mark); 901| 118| } 902| 4.50M|} parser.c:yaml_parser_parse_block_mapping_value: 919| 2.34M|{ 920| 2.34M| yaml_token_t *token; 921| | 922| 2.34M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.34M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 45.1k, False: 2.29M] | | | Branch (49:34): [True: 2.29M, False: 30] | | ------------------ | | 50| 2.34M| parser->tokens.head : NULL) ------------------ 923| 2.34M| if (!token) return 0; ------------------ | Branch (923:9): [True: 30, False: 2.34M] ------------------ 924| | 925| 2.34M| if (token->type == YAML_VALUE_TOKEN) ------------------ | Branch (925:9): [True: 933k, False: 1.41M] ------------------ 926| 933k| { 927| 933k| yaml_mark_t mark = token->end_mark; 928| 933k| SKIP_TOKEN(parser); ------------------ | | 57| 933k| (parser->token_available = 0, \ | | 58| 933k| parser->tokens_parsed ++, \ | | 59| 933k| parser->stream_end_produced = \ | | 60| 933k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 933k| parser->tokens.head ++) ------------------ 929| 933k| token = PEEK_TOKEN(parser); ------------------ | | 49| 933k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 933k] | | | Branch (49:34): [True: 933k, False: 152] | | ------------------ | | 50| 933k| parser->tokens.head : NULL) ------------------ 930| 933k| if (!token) return 0; ------------------ | Branch (930:13): [True: 152, False: 933k] ------------------ 931| 933k| if (token->type != YAML_KEY_TOKEN && ------------------ | Branch (931:13): [True: 888k, False: 45.3k] ------------------ 932| 888k| token->type != YAML_VALUE_TOKEN && ------------------ | Branch (932:17): [True: 888k, False: 25] ------------------ 933| 888k| token->type != YAML_BLOCK_END_TOKEN) { ------------------ | Branch (933:17): [True: 76.6k, False: 811k] ------------------ 934| 76.6k| if (!PUSH(parser, parser->states, ------------------ | | 445| 76.6k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 76.6k, False: 1] | | ------------------ | | 446| 76.6k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1, False: 0] | | ------------------ | | 447| 1| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 76.6k| (*((stack).top++) = value, \ | | 449| 76.6k| 1) : \ | | 450| 76.6k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (934:17): [True: 0, False: 76.6k] ------------------ 935| 76.6k| YAML_PARSE_BLOCK_MAPPING_KEY_STATE)) 936| 0| return 0; 937| 76.6k| return yaml_parser_parse_node(parser, event, 1, 1); 938| 76.6k| } 939| 856k| else { 940| 856k| parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; 941| 856k| return yaml_parser_process_empty_scalar(parser, event, mark); 942| 856k| } 943| 933k| } 944| | 945| 1.41M| else 946| 1.41M| { 947| 1.41M| parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; 948| 1.41M| return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 949| 1.41M| } 950| 2.34M|} parser.c:yaml_parser_parse_flow_sequence_entry: 969| 800k|{ 970| 800k| yaml_token_t *token; 971| | 972| 800k| if (first) { ------------------ | Branch (972:9): [True: 78.0k, False: 722k] ------------------ 973| 78.0k| token = PEEK_TOKEN(parser); ------------------ | | 49| 78.0k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 78.0k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 78.0k| parser->tokens.head : NULL) ------------------ 974| 78.0k| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 78.0k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 77.3k, False: 688] | | ------------------ | | 446| 78.0k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 688, False: 0] | | ------------------ | | 447| 688| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 78.0k| (*((stack).top++) = value, \ | | 449| 78.0k| 1) : \ | | 450| 78.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (974:13): [True: 0, False: 78.0k] ------------------ 975| 0| return 0; 976| 78.0k| SKIP_TOKEN(parser); ------------------ | | 57| 78.0k| (parser->token_available = 0, \ | | 58| 78.0k| parser->tokens_parsed ++, \ | | 59| 78.0k| parser->stream_end_produced = \ | | 60| 78.0k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 78.0k| parser->tokens.head ++) ------------------ 977| 78.0k| } 978| | 979| 800k| token = PEEK_TOKEN(parser); ------------------ | | 49| 800k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 100k, False: 699k] | | | Branch (49:34): [True: 699k, False: 8] | | ------------------ | | 50| 800k| parser->tokens.head : NULL) ------------------ 980| 800k| if (!token) return 0; ------------------ | Branch (980:9): [True: 8, False: 800k] ------------------ 981| | 982| 800k| if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) ------------------ | Branch (982:9): [True: 733k, False: 66.7k] ------------------ 983| 733k| { 984| 733k| if (!first) { ------------------ | Branch (984:13): [True: 656k, False: 77.1k] ------------------ 985| 656k| if (token->type == YAML_FLOW_ENTRY_TOKEN) { ------------------ | Branch (985:17): [True: 656k, False: 341] ------------------ 986| 656k| SKIP_TOKEN(parser); ------------------ | | 57| 656k| (parser->token_available = 0, \ | | 58| 656k| parser->tokens_parsed ++, \ | | 59| 656k| parser->stream_end_produced = \ | | 60| 656k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 656k| parser->tokens.head ++) ------------------ 987| 656k| token = PEEK_TOKEN(parser); ------------------ | | 49| 656k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 656k] | | | Branch (49:34): [True: 656k, False: 10] | | ------------------ | | 50| 656k| parser->tokens.head : NULL) ------------------ 988| 656k| if (!token) return 0; ------------------ | Branch (988:21): [True: 10, False: 656k] ------------------ 989| 656k| } 990| 341| else { 991| 341| return yaml_parser_set_parser_error_context(parser, 992| 341| "while parsing a flow sequence", POP(parser, parser->marks), ------------------ | | 454| 341| (*(--(stack).top)) ------------------ 993| 341| "did not find expected ',' or ']'", token->start_mark); 994| 341| } 995| 656k| } 996| | 997| 733k| if (token->type == YAML_KEY_TOKEN) { ------------------ | Branch (997:13): [True: 102k, False: 630k] ------------------ 998| 102k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE; 999| 102k| MAPPING_START_EVENT_INIT(*event, NULL, NULL, ------------------ | | 598| 102k| (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ | | ------------------ | | | | 546| 102k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 102k| (event).type = (event_type), \ | | | | 548| 102k| (event).start_mark = (event_start_mark), \ | | | | 549| 102k| (event).end_mark = (event_end_mark)) | | ------------------ | | 599| 102k| (event).data.mapping_start.anchor = (event_anchor), \ | | 600| 102k| (event).data.mapping_start.tag = (event_tag), \ | | 601| 102k| (event).data.mapping_start.implicit = (event_implicit), \ | | 602| 102k| (event).data.mapping_start.style = (event_style)) ------------------ 1000| 102k| 1, YAML_FLOW_MAPPING_STYLE, 1001| 102k| token->start_mark, token->end_mark); 1002| 102k| SKIP_TOKEN(parser); ------------------ | | 57| 102k| (parser->token_available = 0, \ | | 58| 102k| parser->tokens_parsed ++, \ | | 59| 102k| parser->stream_end_produced = \ | | 60| 102k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 102k| parser->tokens.head ++) ------------------ 1003| 102k| return 1; 1004| 102k| } 1005| | 1006| 630k| else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (1006:18): [True: 630k, False: 218] ------------------ 1007| 630k| if (!PUSH(parser, parser->states, ------------------ | | 445| 630k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 630k, False: 221] | | ------------------ | | 446| 630k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 221, False: 0] | | ------------------ | | 447| 221| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 630k| (*((stack).top++) = value, \ | | 449| 630k| 1) : \ | | 450| 630k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1007:17): [True: 0, False: 630k] ------------------ 1008| 630k| YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE)) 1009| 0| return 0; 1010| 630k| return yaml_parser_parse_node(parser, event, 0, 0); 1011| 630k| } 1012| 733k| } 1013| | 1014| 66.9k| parser->state = POP(parser, parser->states); ------------------ | | 454| 66.9k| (*(--(stack).top)) ------------------ 1015| 66.9k| (void)POP(parser, parser->marks); ------------------ | | 454| 66.9k| (*(--(stack).top)) ------------------ 1016| 66.9k| SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 594| 66.9k| (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 66.9k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 66.9k| (event).type = (event_type), \ | | | | 548| 66.9k| (event).start_mark = (event_start_mark), \ | | | | 549| 66.9k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 1017| 66.9k| SKIP_TOKEN(parser); ------------------ | | 57| 66.9k| (parser->token_available = 0, \ | | 58| 66.9k| parser->tokens_parsed ++, \ | | 59| 66.9k| parser->stream_end_produced = \ | | 60| 66.9k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 66.9k| parser->tokens.head ++) ------------------ 1018| 66.9k| return 1; 1019| 800k|} parser.c:yaml_parser_parse_flow_sequence_entry_mapping_key: 1030| 102k|{ 1031| 102k| yaml_token_t *token; 1032| | 1033| 102k| token = PEEK_TOKEN(parser); ------------------ | | 49| 102k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 102k] | | | Branch (49:34): [True: 102k, False: 2] | | ------------------ | | 50| 102k| parser->tokens.head : NULL) ------------------ 1034| 102k| if (!token) return 0; ------------------ | Branch (1034:9): [True: 2, False: 102k] ------------------ 1035| | 1036| 102k| if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1036:9): [True: 102k, False: 344] | Branch (1036:44): [True: 102k, False: 197] ------------------ 1037| 102k| && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (1037:16): [True: 63.6k, False: 38.4k] ------------------ 1038| 63.6k| if (!PUSH(parser, parser->states, ------------------ | | 445| 63.6k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 63.1k, False: 484] | | ------------------ | | 446| 63.6k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 484, False: 0] | | ------------------ | | 447| 484| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 63.6k| (*((stack).top++) = value, \ | | 449| 63.6k| 1) : \ | | 450| 63.6k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1038:13): [True: 0, False: 63.6k] ------------------ 1039| 63.6k| YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)) 1040| 0| return 0; 1041| 63.6k| return yaml_parser_parse_node(parser, event, 0, 0); 1042| 63.6k| } 1043| 39.0k| else if (token->type == YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (1043:14): [True: 38.4k, False: 541] ------------------ 1044| 38.4k| yaml_mark_t mark = token->start_mark; 1045| 38.4k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; 1046| 38.4k| return yaml_parser_process_empty_scalar(parser, event, mark); 1047| 38.4k| } 1048| 541| else { 1049| 541| yaml_mark_t mark = token->end_mark; 1050| 541| SKIP_TOKEN(parser); ------------------ | | 57| 541| (parser->token_available = 0, \ | | 58| 541| parser->tokens_parsed ++, \ | | 59| 541| parser->stream_end_produced = \ | | 60| 541| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 541| parser->tokens.head ++) ------------------ 1051| 541| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; 1052| 541| return yaml_parser_process_empty_scalar(parser, event, mark); 1053| 541| } 1054| 102k|} parser.c:yaml_parser_parse_flow_sequence_entry_mapping_value: 1065| 100k|{ 1066| 100k| yaml_token_t *token; 1067| | 1068| 100k| token = PEEK_TOKEN(parser); ------------------ | | 49| 100k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 38.8k, False: 61.2k] | | | Branch (49:34): [True: 61.2k, False: 2] | | ------------------ | | 50| 100k| parser->tokens.head : NULL) ------------------ 1069| 100k| if (!token) return 0; ------------------ | Branch (1069:9): [True: 2, False: 100k] ------------------ 1070| | 1071| 100k| if (token->type == YAML_VALUE_TOKEN) { ------------------ | Branch (1071:9): [True: 9.45k, False: 90.6k] ------------------ 1072| 9.45k| SKIP_TOKEN(parser); ------------------ | | 57| 9.45k| (parser->token_available = 0, \ | | 58| 9.45k| parser->tokens_parsed ++, \ | | 59| 9.45k| parser->stream_end_produced = \ | | 60| 9.45k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 9.45k| parser->tokens.head ++) ------------------ 1073| 9.45k| token = PEEK_TOKEN(parser); ------------------ | | 49| 9.45k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 9.45k] | | | Branch (49:34): [True: 9.45k, False: 1] | | ------------------ | | 50| 9.45k| parser->tokens.head : NULL) ------------------ 1074| 9.45k| if (!token) return 0; ------------------ | Branch (1074:13): [True: 1, False: 9.45k] ------------------ 1075| 9.45k| if (token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1075:13): [True: 9.16k, False: 294] ------------------ 1076| 9.16k| && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { ------------------ | Branch (1076:20): [True: 2.57k, False: 6.59k] ------------------ 1077| 2.57k| if (!PUSH(parser, parser->states, ------------------ | | 445| 2.57k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.56k, False: 12] | | ------------------ | | 446| 2.57k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 12, False: 0] | | ------------------ | | 447| 12| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.57k| (*((stack).top++) = value, \ | | 449| 2.57k| 1) : \ | | 450| 2.57k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1077:17): [True: 0, False: 2.57k] ------------------ 1078| 2.57k| YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)) 1079| 0| return 0; 1080| 2.57k| return yaml_parser_parse_node(parser, event, 0, 0); 1081| 2.57k| } 1082| 9.45k| } 1083| 97.5k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE; 1084| 97.5k| return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 1085| 100k|} parser.c:yaml_parser_parse_flow_sequence_entry_mapping_end: 1096| 99.3k|{ 1097| 99.3k| yaml_token_t *token; 1098| | 1099| 99.3k| token = PEEK_TOKEN(parser); ------------------ | | 49| 99.3k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 97.5k, False: 1.85k] | | | Branch (49:34): [True: 1.85k, False: 1] | | ------------------ | | 50| 99.3k| parser->tokens.head : NULL) ------------------ 1100| 99.3k| if (!token) return 0; ------------------ | Branch (1100:9): [True: 1, False: 99.3k] ------------------ 1101| | 1102| 99.3k| parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE; 1103| | 1104| 99.3k| MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark); ------------------ | | 605| 99.3k| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 99.3k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 99.3k| (event).type = (event_type), \ | | | | 548| 99.3k| (event).start_mark = (event_start_mark), \ | | | | 549| 99.3k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 1105| 99.3k| return 1; 1106| 99.3k|} parser.c:yaml_parser_parse_flow_mapping_key: 1125| 2.08M|{ 1126| 2.08M| yaml_token_t *token; 1127| | 1128| 2.08M| if (first) { ------------------ | Branch (1128:9): [True: 14.8k, False: 2.06M] ------------------ 1129| 14.8k| token = PEEK_TOKEN(parser); ------------------ | | 49| 14.8k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 14.8k, False: 0] | | | Branch (49:34): [True: 0, False: 0] | | ------------------ | | 50| 14.8k| parser->tokens.head : NULL) ------------------ 1130| 14.8k| if (!PUSH(parser, parser->marks, token->start_mark)) ------------------ | | 445| 14.8k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 14.5k, False: 266] | | ------------------ | | 446| 14.8k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 266, False: 0] | | ------------------ | | 447| 266| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 14.8k| (*((stack).top++) = value, \ | | 449| 14.8k| 1) : \ | | 450| 14.8k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1130:13): [True: 0, False: 14.8k] ------------------ 1131| 0| return 0; 1132| 14.8k| SKIP_TOKEN(parser); ------------------ | | 57| 14.8k| (parser->token_available = 0, \ | | 58| 14.8k| parser->tokens_parsed ++, \ | | 59| 14.8k| parser->stream_end_produced = \ | | 60| 14.8k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 14.8k| parser->tokens.head ++) ------------------ 1133| 14.8k| } 1134| | 1135| 2.08M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.08M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 2.06M, False: 14.9k] | | | Branch (49:34): [True: 14.9k, False: 1] | | ------------------ | | 50| 2.08M| parser->tokens.head : NULL) ------------------ 1136| 2.08M| if (!token) return 0; ------------------ | Branch (1136:9): [True: 1, False: 2.08M] ------------------ 1137| | 1138| 2.08M| if (token->type != YAML_FLOW_MAPPING_END_TOKEN) ------------------ | Branch (1138:9): [True: 2.07M, False: 3.90k] ------------------ 1139| 2.07M| { 1140| 2.07M| if (!first) { ------------------ | Branch (1140:13): [True: 2.06M, False: 13.8k] ------------------ 1141| 2.06M| if (token->type == YAML_FLOW_ENTRY_TOKEN) { ------------------ | Branch (1141:17): [True: 2.06M, False: 249] ------------------ 1142| 2.06M| SKIP_TOKEN(parser); ------------------ | | 57| 2.06M| (parser->token_available = 0, \ | | 58| 2.06M| parser->tokens_parsed ++, \ | | 59| 2.06M| parser->stream_end_produced = \ | | 60| 2.06M| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.06M| parser->tokens.head ++) ------------------ 1143| 2.06M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.06M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 2.06M] | | | Branch (49:34): [True: 2.06M, False: 5] | | ------------------ | | 50| 2.06M| parser->tokens.head : NULL) ------------------ 1144| 2.06M| if (!token) return 0; ------------------ | Branch (1144:21): [True: 5, False: 2.06M] ------------------ 1145| 2.06M| } 1146| 249| else { 1147| 249| return yaml_parser_set_parser_error_context(parser, 1148| 249| "while parsing a flow mapping", POP(parser, parser->marks), ------------------ | | 454| 249| (*(--(stack).top)) ------------------ 1149| 249| "did not find expected ',' or '}'", token->start_mark); 1150| 249| } 1151| 2.06M| } 1152| | 1153| 2.07M| if (token->type == YAML_KEY_TOKEN) { ------------------ | Branch (1153:13): [True: 2.37k, False: 2.07M] ------------------ 1154| 2.37k| SKIP_TOKEN(parser); ------------------ | | 57| 2.37k| (parser->token_available = 0, \ | | 58| 2.37k| parser->tokens_parsed ++, \ | | 59| 2.37k| parser->stream_end_produced = \ | | 60| 2.37k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 2.37k| parser->tokens.head ++) ------------------ 1155| 2.37k| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.37k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 2.37k] | | | Branch (49:34): [True: 2.37k, False: 2] | | ------------------ | | 50| 2.37k| parser->tokens.head : NULL) ------------------ 1156| 2.37k| if (!token) return 0; ------------------ | Branch (1156:17): [True: 2, False: 2.37k] ------------------ 1157| 2.37k| if (token->type != YAML_VALUE_TOKEN ------------------ | Branch (1157:17): [True: 1.78k, False: 591] ------------------ 1158| 1.78k| && token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1158:24): [True: 1.53k, False: 245] ------------------ 1159| 1.53k| && token->type != YAML_FLOW_MAPPING_END_TOKEN) { ------------------ | Branch (1159:24): [True: 1.18k, False: 348] ------------------ 1160| 1.18k| if (!PUSH(parser, parser->states, ------------------ | | 445| 1.18k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 1.16k, False: 26] | | ------------------ | | 446| 1.18k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 26, False: 0] | | ------------------ | | 447| 26| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 1.18k| (*((stack).top++) = value, \ | | 449| 1.18k| 1) : \ | | 450| 1.18k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1160:21): [True: 0, False: 1.18k] ------------------ 1161| 1.18k| YAML_PARSE_FLOW_MAPPING_VALUE_STATE)) 1162| 0| return 0; 1163| 1.18k| return yaml_parser_parse_node(parser, event, 0, 0); 1164| 1.18k| } 1165| 1.18k| else { 1166| 1.18k| parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE; 1167| 1.18k| return yaml_parser_process_empty_scalar(parser, event, 1168| 1.18k| token->start_mark); 1169| 1.18k| } 1170| 2.37k| } 1171| 2.07M| else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) { ------------------ | Branch (1171:18): [True: 2.07M, False: 205] ------------------ 1172| 2.07M| if (!PUSH(parser, parser->states, ------------------ | | 445| 2.07M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.07M, False: 259] | | ------------------ | | 446| 2.07M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 259, False: 0] | | ------------------ | | 447| 259| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.07M| (*((stack).top++) = value, \ | | 449| 2.07M| 1) : \ | | 450| 2.07M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1172:17): [True: 0, False: 2.07M] ------------------ 1173| 2.07M| YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)) 1174| 0| return 0; 1175| 2.07M| return yaml_parser_parse_node(parser, event, 0, 0); 1176| 2.07M| } 1177| 2.07M| } 1178| | 1179| 4.10k| parser->state = POP(parser, parser->states); ------------------ | | 454| 4.10k| (*(--(stack).top)) ------------------ 1180| 4.10k| (void)POP(parser, parser->marks); ------------------ | | 454| 4.10k| (*(--(stack).top)) ------------------ 1181| 4.10k| MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); ------------------ | | 605| 4.10k| (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) | | ------------------ | | | | 546| 4.10k| (memset(&(event), 0, sizeof(yaml_event_t)), \ | | | | 547| 4.10k| (event).type = (event_type), \ | | | | 548| 4.10k| (event).start_mark = (event_start_mark), \ | | | | 549| 4.10k| (event).end_mark = (event_end_mark)) | | ------------------ ------------------ 1182| 4.10k| SKIP_TOKEN(parser); ------------------ | | 57| 4.10k| (parser->token_available = 0, \ | | 58| 4.10k| parser->tokens_parsed ++, \ | | 59| 4.10k| parser->stream_end_produced = \ | | 60| 4.10k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 4.10k| parser->tokens.head ++) ------------------ 1183| 4.10k| return 1; 1184| 2.08M|} parser.c:yaml_parser_parse_flow_mapping_value: 1195| 2.06M|{ 1196| 2.06M| yaml_token_t *token; 1197| | 1198| 2.06M| token = PEEK_TOKEN(parser); ------------------ | | 49| 2.06M| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 2.34k, False: 2.06M] | | | Branch (49:34): [True: 2.06M, False: 3] | | ------------------ | | 50| 2.06M| parser->tokens.head : NULL) ------------------ 1199| 2.06M| if (!token) return 0; ------------------ | Branch (1199:9): [True: 3, False: 2.06M] ------------------ 1200| | 1201| 2.06M| if (empty) { ------------------ | Branch (1201:9): [True: 2.06M, False: 2.11k] ------------------ 1202| 2.06M| parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 1203| 2.06M| return yaml_parser_process_empty_scalar(parser, event, 1204| 2.06M| token->start_mark); 1205| 2.06M| } 1206| | 1207| 2.11k| if (token->type == YAML_VALUE_TOKEN) { ------------------ | Branch (1207:9): [True: 1.22k, False: 888] ------------------ 1208| 1.22k| SKIP_TOKEN(parser); ------------------ | | 57| 1.22k| (parser->token_available = 0, \ | | 58| 1.22k| parser->tokens_parsed ++, \ | | 59| 1.22k| parser->stream_end_produced = \ | | 60| 1.22k| (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \ | | 61| 1.22k| parser->tokens.head ++) ------------------ 1209| 1.22k| token = PEEK_TOKEN(parser); ------------------ | | 49| 1.22k| ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \ | | ------------------ | | | Branch (49:7): [True: 0, False: 1.22k] | | | Branch (49:34): [True: 1.22k, False: 1] | | ------------------ | | 50| 1.22k| parser->tokens.head : NULL) ------------------ 1210| 1.22k| if (!token) return 0; ------------------ | Branch (1210:13): [True: 1, False: 1.22k] ------------------ 1211| 1.22k| if (token->type != YAML_FLOW_ENTRY_TOKEN ------------------ | Branch (1211:13): [True: 856, False: 367] ------------------ 1212| 856| && token->type != YAML_FLOW_MAPPING_END_TOKEN) { ------------------ | Branch (1212:20): [True: 372, False: 484] ------------------ 1213| 372| if (!PUSH(parser, parser->states, ------------------ | | 445| 372| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 357, False: 15] | | ------------------ | | 446| 372| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 15, False: 0] | | ------------------ | | 447| 15| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 372| (*((stack).top++) = value, \ | | 449| 372| 1) : \ | | 450| 372| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1213:17): [True: 0, False: 372] ------------------ 1214| 372| YAML_PARSE_FLOW_MAPPING_KEY_STATE)) 1215| 0| return 0; 1216| 372| return yaml_parser_parse_node(parser, event, 0, 0); 1217| 372| } 1218| 1.22k| } 1219| | 1220| 1.73k| parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 1221| 1.73k| return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 1222| 2.11k|} yaml_parser_update_buffer: 143| 47.7k|{ 144| 47.7k| int first = 1; 145| | 146| 47.7k| assert(parser->read_handler); /* Read handler must be set. */ ------------------ | Branch (146:5): [True: 0, False: 47.7k] | Branch (146:5): [True: 47.7k, False: 0] ------------------ 147| | 148| | /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 149| | 150| 47.7k| if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last) ------------------ | Branch (150:9): [True: 17.4k, False: 30.2k] | Branch (150:24): [True: 17.4k, False: 0] ------------------ 151| 17.4k| return 1; 152| | 153| | /* Return if the buffer contains enough characters. */ 154| | 155| 30.2k| if (parser->unread >= length) ------------------ | Branch (155:9): [True: 0, False: 30.2k] ------------------ 156| 0| return 1; 157| | 158| | /* Determine the input encoding if it is not known yet. */ 159| | 160| 30.2k| if (!parser->encoding) { ------------------ | Branch (160:9): [True: 11.2k, False: 19.0k] ------------------ 161| 11.2k| if (!yaml_parser_determine_encoding(parser)) ------------------ | Branch (161:13): [True: 0, False: 11.2k] ------------------ 162| 0| return 0; 163| 11.2k| } 164| | 165| | /* Move the unread characters to the beginning of the buffer. */ 166| | 167| 30.2k| if (parser->buffer.start < parser->buffer.pointer ------------------ | Branch (167:9): [True: 18.1k, False: 12.0k] ------------------ 168| 18.1k| && parser->buffer.pointer < parser->buffer.last) { ------------------ | Branch (168:16): [True: 10.3k, False: 7.79k] ------------------ 169| 10.3k| size_t size = parser->buffer.last - parser->buffer.pointer; 170| 10.3k| memmove(parser->buffer.start, parser->buffer.pointer, size); 171| 10.3k| parser->buffer.pointer = parser->buffer.start; 172| 10.3k| parser->buffer.last = parser->buffer.start + size; 173| 10.3k| } 174| 19.8k| else if (parser->buffer.pointer == parser->buffer.last) { ------------------ | Branch (174:14): [True: 19.0k, False: 858] ------------------ 175| 19.0k| parser->buffer.pointer = parser->buffer.start; 176| 19.0k| parser->buffer.last = parser->buffer.start; 177| 19.0k| } 178| | 179| | /* Fill the buffer until it has enough characters. */ 180| | 181| 50.1k| while (parser->unread < length) ------------------ | Branch (181:12): [True: 30.6k, False: 19.4k] ------------------ 182| 30.6k| { 183| | /* Fill the raw buffer if necessary. */ 184| | 185| 30.6k| if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) { ------------------ | Branch (185:13): [True: 402, False: 30.2k] | Branch (185:23): [True: 18.6k, False: 11.6k] ------------------ 186| 19.0k| if (!yaml_parser_update_raw_buffer(parser)) return 0; ------------------ | Branch (186:17): [True: 0, False: 19.0k] ------------------ 187| 19.0k| } 188| 30.6k| first = 0; 189| | 190| | /* Decode the raw buffer. */ 191| | 192| 141M| while (parser->raw_buffer.pointer != parser->raw_buffer.last) ------------------ | Branch (192:16): [True: 141M, False: 29.5k] ------------------ 193| 141M| { 194| 141M| unsigned int value = 0, value2 = 0; 195| 141M| int incomplete = 0; 196| 141M| unsigned char octet; 197| 141M| unsigned int width = 0; 198| 141M| int low, high; 199| 141M| size_t k; 200| 141M| size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer; 201| | 202| | /* Decode the next character. */ 203| | 204| 141M| switch (parser->encoding) 205| 141M| { 206| 132M| case YAML_UTF8_ENCODING: ------------------ | Branch (206:17): [True: 132M, False: 9.26M] ------------------ 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: 855k] ------------------ 232| 132M| (octet & 0xE0) == 0xC0 ? 2 : ------------------ | Branch (232:29): [True: 55.4k, False: 800k] ------------------ 233| 855k| (octet & 0xF0) == 0xE0 ? 3 : ------------------ | Branch (233:29): [True: 331k, False: 468k] ------------------ 234| 800k| (octet & 0xF8) == 0xF0 ? 4 : 0; ------------------ | Branch (234:29): [True: 468k, False: 39] ------------------ 235| | 236| | /* Check if the leading octet is valid. */ 237| | 238| 132M| if (!width) ------------------ | Branch (238:25): [True: 39, False: 132M] ------------------ 239| 39| return yaml_parser_set_reader_error(parser, 240| 39| "invalid leading UTF-8 octet", 241| 39| 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: 800, False: 132M] ------------------ 246| 800| if (parser->eof) { ------------------ | Branch (246:29): [True: 94, False: 706] ------------------ 247| 94| return yaml_parser_set_reader_error(parser, 248| 94| "incomplete UTF-8 octet sequence", 249| 94| parser->offset, -1); 250| 94| } 251| 706| incomplete = 1; 252| 706| break; 253| 800| } 254| | 255| | /* Decode the leading octet. */ 256| | 257| 132M| value = (octet & 0x80) == 0x00 ? octet & 0x7F : ------------------ | Branch (257:29): [True: 131M, False: 854k] ------------------ 258| 132M| (octet & 0xE0) == 0xC0 ? octet & 0x1F : ------------------ | Branch (258:29): [True: 55.3k, False: 799k] ------------------ 259| 854k| (octet & 0xF0) == 0xE0 ? octet & 0x0F : ------------------ | Branch (259:29): [True: 331k, False: 468k] ------------------ 260| 799k| (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; ------------------ | Branch (260:29): [True: 468k, False: 0] ------------------ 261| | 262| | /* Check and decode the trailing octets. */ 263| | 264| 134M| for (k = 1; k < width; k ++) ------------------ | Branch (264:33): [True: 2.12M, False: 132M] ------------------ 265| 2.12M| { 266| 2.12M| octet = parser->raw_buffer.pointer[k]; 267| | 268| | /* Check if the octet is valid. */ 269| | 270| 2.12M| if ((octet & 0xC0) != 0x80) ------------------ | Branch (270:29): [True: 19, False: 2.12M] ------------------ 271| 19| return yaml_parser_set_reader_error(parser, 272| 19| "invalid trailing UTF-8 octet", 273| 19| parser->offset+k, octet); 274| | 275| | /* Decode the octet. */ 276| | 277| 2.12M| value = (value << 6) + (octet & 0x3F); 278| 2.12M| } 279| | 280| | /* Check the length of the sequence against the value. */ 281| | 282| 132M| if (!((width == 1) || ------------------ | Branch (282:27): [True: 131M, False: 854k] ------------------ 283| 854k| (width == 2 && value >= 0x80) || ------------------ | Branch (283:30): [True: 55.3k, False: 799k] | Branch (283:44): [True: 55.3k, False: 11] ------------------ 284| 799k| (width == 3 && value >= 0x800) || ------------------ | Branch (284:30): [True: 331k, False: 468k] | Branch (284:44): [True: 331k, False: 8] ------------------ 285| 468k| (width == 4 && value >= 0x10000))) ------------------ | Branch (285:30): [True: 468k, False: 19] | Branch (285:44): [True: 468k, False: 15] ------------------ 286| 34| return yaml_parser_set_reader_error(parser, 287| 34| "invalid length of a UTF-8 sequence", 288| 34| 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: 470k, False: 132M] | Branch (292:45): [True: 13, False: 470k] | Branch (292:65): [True: 6, False: 132M] ------------------ 293| 19| return yaml_parser_set_reader_error(parser, 294| 19| "invalid Unicode character", 295| 19| parser->offset, value); 296| | 297| 132M| break; 298| | 299| 132M| case YAML_UTF16LE_ENCODING: ------------------ | Branch (299:17): [True: 3.60M, False: 138M] ------------------ 300| 9.26M| case YAML_UTF16BE_ENCODING: ------------------ | Branch (300:17): [True: 5.65M, False: 136M] ------------------ 301| | 302| 9.26M| low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1); ------------------ | Branch (302:28): [True: 3.60M, False: 5.65M] ------------------ 303| 9.26M| high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0); ------------------ | Branch (303:29): [True: 3.60M, False: 5.65M] ------------------ 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| 9.26M| if (raw_unread < 2) { ------------------ | Branch (333:25): [True: 100, False: 9.26M] ------------------ 334| 100| if (parser->eof) { ------------------ | Branch (334:29): [True: 34, False: 66] ------------------ 335| 34| return yaml_parser_set_reader_error(parser, 336| 34| "incomplete UTF-16 character", 337| 34| parser->offset, -1); 338| 34| } 339| 66| incomplete = 1; 340| 66| break; 341| 100| } 342| | 343| | /* Get the character. */ 344| | 345| 9.26M| value = parser->raw_buffer.pointer[low] 346| 9.26M| + (parser->raw_buffer.pointer[high] << 8); 347| | 348| | /* Check for unexpected low surrogate area. */ 349| | 350| 9.26M| if ((value & 0xFC00) == 0xDC00) ------------------ | Branch (350:25): [True: 1, False: 9.26M] ------------------ 351| 1| return yaml_parser_set_reader_error(parser, 352| 1| "unexpected low surrogate area", 353| 1| parser->offset, value); 354| | 355| | /* Check for a high surrogate area. */ 356| | 357| 9.26M| if ((value & 0xFC00) == 0xD800) { ------------------ | Branch (357:25): [True: 1.91k, False: 9.26M] ------------------ 358| | 359| 1.91k| width = 4; 360| | 361| | /* Check for incomplete surrogate pair. */ 362| | 363| 1.91k| if (raw_unread < 4) { ------------------ | Branch (363:29): [True: 29, False: 1.88k] ------------------ 364| 29| if (parser->eof) { ------------------ | Branch (364:33): [True: 5, False: 24] ------------------ 365| 5| return yaml_parser_set_reader_error(parser, 366| 5| "incomplete UTF-16 surrogate pair", 367| 5| parser->offset, -1); 368| 5| } 369| 24| incomplete = 1; 370| 24| break; 371| 29| } 372| | 373| | /* Get the next character. */ 374| | 375| 1.88k| value2 = parser->raw_buffer.pointer[low+2] 376| 1.88k| + (parser->raw_buffer.pointer[high+2] << 8); 377| | 378| | /* Check for a low surrogate area. */ 379| | 380| 1.88k| if ((value2 & 0xFC00) != 0xDC00) ------------------ | Branch (380:29): [True: 1, False: 1.88k] ------------------ 381| 1| return yaml_parser_set_reader_error(parser, 382| 1| "expected low surrogate area", 383| 1| parser->offset+2, value2); 384| | 385| | /* Generate the value of the surrogate pair. */ 386| | 387| 1.88k| value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF); 388| 1.88k| } 389| | 390| 9.26M| else { 391| 9.26M| width = 2; 392| 9.26M| } 393| | 394| 9.26M| break; 395| | 396| 9.26M| default: ------------------ | Branch (396:17): [True: 0, False: 141M] ------------------ 397| 0| assert(1); /* Impossible. */ ------------------ | Branch (397:21): [True: 0, Folded] | Branch (397:21): [True: 0, Folded] ------------------ 398| 141M| } 399| | 400| | /* Check if the raw buffer contains enough bytes to form a character. */ 401| | 402| 141M| if (incomplete) break; ------------------ | Branch (402:17): [True: 796, False: 141M] ------------------ 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| 141M| if (! (value == 0x09 || value == 0x0A || value == 0x0D ------------------ | Branch (411:20): [True: 796k, False: 141M] | Branch (411:37): [True: 5.16M, False: 135M] | Branch (411:54): [True: 4.99M, False: 130M] ------------------ 412| 130M| || (value >= 0x20 && value <= 0x7E) ------------------ | Branch (412:29): [True: 130M, False: 23] | Branch (412:46): [True: 120M, False: 10.1M] ------------------ 413| 10.1M| || (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF) ------------------ | Branch (413:28): [True: 17.0k, False: 10.0M] | Branch (413:48): [True: 10.0M, False: 31] | Branch (413:65): [True: 9.59M, False: 498k] ------------------ 414| 498k| || (value >= 0xE000 && value <= 0xFFFD) ------------------ | Branch (414:29): [True: 498k, False: 31] | Branch (414:48): [True: 27.9k, False: 470k] ------------------ 415| 470k| || (value >= 0x10000 && value <= 0x10FFFF))) ------------------ | Branch (415:29): [True: 470k, False: 37] | Branch (415:49): [True: 470k, False: 0] ------------------ 416| 37| return yaml_parser_set_reader_error(parser, 417| 37| "control characters are not allowed", 418| 37| parser->offset, value); 419| | 420| | /* Move the raw pointers. */ 421| | 422| 141M| parser->raw_buffer.pointer += width; 423| 141M| parser->offset += width; 424| | 425| | /* Finally put the character into the buffer. */ 426| | 427| | /* 0000 0000-0000 007F -> 0xxxxxxx */ 428| 141M| if (value <= 0x7F) { ------------------ | Branch (428:17): [True: 131M, False: 10.1M] ------------------ 429| 131M| *(parser->buffer.last++) = value; 430| 131M| } 431| | /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */ 432| 10.1M| else if (value <= 0x7FF) { ------------------ | Branch (432:22): [True: 64.9k, False: 10.0M] ------------------ 433| 64.9k| *(parser->buffer.last++) = 0xC0 + (value >> 6); 434| 64.9k| *(parser->buffer.last++) = 0x80 + (value & 0x3F); 435| 64.9k| } 436| | /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */ 437| 10.0M| else if (value <= 0xFFFF) { ------------------ | Branch (437:22): [True: 9.57M, False: 470k] ------------------ 438| 9.57M| *(parser->buffer.last++) = 0xE0 + (value >> 12); 439| 9.57M| *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 440| 9.57M| *(parser->buffer.last++) = 0x80 + (value & 0x3F); 441| 9.57M| } 442| | /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 443| 470k| else { 444| 470k| *(parser->buffer.last++) = 0xF0 + (value >> 18); 445| 470k| *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F); 446| 470k| *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 447| 470k| *(parser->buffer.last++) = 0x80 + (value & 0x3F); 448| 470k| } 449| | 450| 141M| parser->unread ++; 451| 141M| } 452| | 453| | /* On EOF, put NUL into the buffer and return. */ 454| | 455| 30.3k| if (parser->eof) { ------------------ | Branch (455:13): [True: 10.4k, False: 19.8k] ------------------ 456| 10.4k| *(parser->buffer.last++) = '\0'; 457| 10.4k| parser->unread ++; 458| 10.4k| return 1; 459| 10.4k| } 460| | 461| 30.3k| } 462| | 463| 19.4k| if (parser->offset >= MAX_FILE_SIZE) { ------------------ | | 77| 19.4k|#define MAX_FILE_SIZE (~(size_t)0 / 2) ------------------ | Branch (463:9): [True: 0, False: 19.4k] ------------------ 464| 0| return yaml_parser_set_reader_error(parser, "input is too long", 465| 0| parser->offset, -1); 466| 0| } 467| | 468| 19.4k| return 1; 469| 19.4k|} reader.c:yaml_parser_determine_encoding: 52| 11.2k|{ 53| | /* Ensure that we had enough bytes in the raw buffer. */ 54| | 55| 22.9k| while (!parser->eof ------------------ | Branch (55:12): [True: 22.4k, False: 490] ------------------ 56| 22.4k| && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) { ------------------ | Branch (56:16): [True: 11.7k, False: 10.7k] ------------------ 57| 11.7k| if (!yaml_parser_update_raw_buffer(parser)) { ------------------ | Branch (57:13): [True: 0, False: 11.7k] ------------------ 58| 0| return 0; 59| 0| } 60| 11.7k| } 61| | 62| | /* Determine the encoding. */ 63| | 64| 11.2k| if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 ------------------ | Branch (64:9): [True: 11.1k, False: 95] ------------------ 65| 11.1k| && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) { ------------------ | | 42| 11.1k|#define BOM_UTF16LE "\xff\xfe" ------------------ | Branch (65:16): [True: 154, False: 10.9k] ------------------ 66| 154| parser->encoding = YAML_UTF16LE_ENCODING; 67| 154| parser->raw_buffer.pointer += 2; 68| 154| parser->offset += 2; 69| 154| } 70| 11.0k| else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 ------------------ | Branch (70:14): [True: 10.9k, False: 95] ------------------ 71| 10.9k| && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) { ------------------ | | 43| 10.9k|#define BOM_UTF16BE "\xfe\xff" ------------------ | Branch (71:16): [True: 385, False: 10.5k] ------------------ 72| 385| parser->encoding = YAML_UTF16BE_ENCODING; 73| 385| parser->raw_buffer.pointer += 2; 74| 385| parser->offset += 2; 75| 385| } 76| 10.6k| else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3 ------------------ | Branch (76:14): [True: 10.2k, False: 488] ------------------ 77| 10.2k| && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) { ------------------ | | 41| 10.2k|#define BOM_UTF8 "\xef\xbb\xbf" ------------------ | Branch (77:16): [True: 24, False: 10.1k] ------------------ 78| 24| parser->encoding = YAML_UTF8_ENCODING; 79| 24| parser->raw_buffer.pointer += 3; 80| 24| parser->offset += 3; 81| 24| } 82| 10.6k| else { 83| 10.6k| parser->encoding = YAML_UTF8_ENCODING; 84| 10.6k| } 85| | 86| 11.2k| return 1; 87| 11.2k|} reader.c:yaml_parser_update_raw_buffer: 95| 30.7k|{ 96| 30.7k| size_t size_read = 0; 97| | 98| | /* Return if the raw buffer is full. */ 99| | 100| 30.7k| if (parser->raw_buffer.start == parser->raw_buffer.pointer ------------------ | Branch (100:9): [True: 11.7k, False: 19.0k] ------------------ 101| 11.7k| && parser->raw_buffer.last == parser->raw_buffer.end) ------------------ | Branch (101:16): [True: 0, False: 11.7k] ------------------ 102| 0| return 1; 103| | 104| | /* Return on EOF. */ 105| | 106| 30.7k| if (parser->eof) return 1; ------------------ | Branch (106:9): [True: 4, False: 30.7k] ------------------ 107| | 108| | /* Move the remaining bytes in the raw buffer to the beginning. */ 109| | 110| 30.7k| if (parser->raw_buffer.start < parser->raw_buffer.pointer ------------------ | Branch (110:9): [True: 19.0k, False: 11.7k] ------------------ 111| 19.0k| && parser->raw_buffer.pointer < parser->raw_buffer.last) { ------------------ | Branch (111:16): [True: 394, False: 18.6k] ------------------ 112| 394| memmove(parser->raw_buffer.start, parser->raw_buffer.pointer, 113| 394| parser->raw_buffer.last - parser->raw_buffer.pointer); 114| 394| } 115| 30.7k| parser->raw_buffer.last -= 116| 30.7k| parser->raw_buffer.pointer - parser->raw_buffer.start; 117| 30.7k| parser->raw_buffer.pointer = parser->raw_buffer.start; 118| | 119| | /* Call the read handler to fill the buffer. */ 120| | 121| 30.7k| if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last, ------------------ | Branch (121:9): [True: 0, False: 30.7k] ------------------ 122| 30.7k| 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.7k| parser->raw_buffer.last += size_read; 127| 30.7k| if (!size_read) { ------------------ | Branch (127:9): [True: 10.6k, False: 20.0k] ------------------ 128| 10.6k| parser->eof = 1; 129| 10.6k| } 130| | 131| 30.7k| return 1; 132| 30.7k|} reader.c:yaml_parser_set_reader_error: 28| 283|{ 29| 283| parser->error = YAML_READER_ERROR; 30| 283| parser->problem = problem; 31| 283| parser->problem_offset = offset; 32| 283| parser->problem_value = value; 33| | 34| 283| return 0; 35| 283|} yaml_parser_fetch_more_tokens: 808| 15.4M|{ 809| 15.4M| int need_more_tokens; 810| | 811| | /* While we need more tokens to fetch, do it. */ 812| | 813| 25.6M| while (1) ------------------ | Branch (813:12): [True: 25.6M, Folded] ------------------ 814| 25.6M| { 815| | /* 816| | * Check if we really need to fetch more tokens. 817| | */ 818| | 819| 25.6M| need_more_tokens = 0; 820| | 821| 25.6M| if (parser->tokens.head == parser->tokens.tail) ------------------ | Branch (821:13): [True: 6.36M, False: 19.3M] ------------------ 822| 6.36M| { 823| | /* Queue is empty. */ 824| | 825| 6.36M| need_more_tokens = 1; 826| 6.36M| } 827| 19.3M| else 828| 19.3M| { 829| 19.3M| yaml_simple_key_t *simple_key; 830| | 831| | /* Check if any potential simple key may occupy the head position. */ 832| | 833| 19.3M| if (!yaml_parser_stale_simple_keys(parser)) ------------------ | Branch (833:17): [True: 27, False: 19.3M] ------------------ 834| 27| return 0; 835| | 836| 19.3M| for (simple_key = parser->simple_keys.start; 837| 110M| simple_key != parser->simple_keys.top; simple_key++) { ------------------ | Branch (837:21): [True: 94.7M, False: 15.4M] ------------------ 838| 94.7M| if (simple_key->possible ------------------ | Branch (838:21): [True: 5.55M, False: 89.1M] ------------------ 839| 5.55M| && simple_key->token_number == parser->tokens_parsed) { ------------------ | Branch (839:28): [True: 3.82M, False: 1.73M] ------------------ 840| 3.82M| need_more_tokens = 1; 841| 3.82M| break; 842| 3.82M| } 843| 94.7M| } 844| 19.3M| } 845| | 846| | /* We are finished. */ 847| | 848| 25.6M| if (!need_more_tokens) ------------------ | Branch (848:13): [True: 15.4M, False: 10.1M] ------------------ 849| 15.4M| break; 850| | 851| | /* Fetch the next token. */ 852| | 853| 10.1M| if (!yaml_parser_fetch_next_token(parser)) ------------------ | Branch (853:13): [True: 2.38k, False: 10.1M] ------------------ 854| 2.38k| return 0; 855| 10.1M| } 856| | 857| 15.4M| parser->token_available = 1; 858| | 859| 15.4M| return 1; 860| 15.4M|} scanner.c:yaml_parser_fetch_next_token: 868| 10.1M|{ 869| | /* Ensure that the buffer is initialized. */ 870| | 871| 10.1M| if (!CACHE(parser, 1)) ------------------ | | 493| 10.1M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 10.1M, False: 11.2k] | | ------------------ | | 494| 10.1M| ? 1 \ | | 495| 10.1M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (871:9): [True: 149, False: 10.1M] ------------------ 872| 149| return 0; 873| | 874| | /* Check if we just started scanning. Fetch STREAM-START then. */ 875| | 876| 10.1M| if (!parser->stream_start_produced) ------------------ | Branch (876:9): [True: 11.0k, False: 10.1M] ------------------ 877| 11.0k| return yaml_parser_fetch_stream_start(parser); 878| | 879| | /* Eat whitespaces and comments until we reach the next token. */ 880| | 881| 10.1M| if (!yaml_parser_scan_to_next_token(parser)) ------------------ | Branch (881:9): [True: 14, False: 10.1M] ------------------ 882| 14| return 0; 883| | 884| | /* Remove obsolete potential simple keys. */ 885| | 886| 10.1M| if (!yaml_parser_stale_simple_keys(parser)) ------------------ | Branch (886:9): [True: 7, False: 10.1M] ------------------ 887| 7| return 0; 888| | 889| | /* Check the indentation level against the current column. */ 890| | 891| 10.1M| if (!yaml_parser_unroll_indent(parser, parser->mark.column)) ------------------ | Branch (891:9): [True: 0, False: 10.1M] ------------------ 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.1M| if (!CACHE(parser, 4)) ------------------ | | 493| 10.1M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 10.1M, False: 17.4k] | | ------------------ | | 494| 10.1M| ? 1 \ | | 495| 10.1M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (899:9): [True: 13, False: 10.1M] ------------------ 900| 13| return 0; 901| | 902| | /* Is it the end of the stream? */ 903| | 904| 10.1M| if (IS_Z(parser->buffer)) ------------------ | | 287| 10.1M|#define IS_Z(string) IS_Z_AT((string),0) | | ------------------ | | | | 285| 10.1M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | ------------------ | | | | | | 175| 10.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.11k, False: 10.1M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 905| 8.11k| return yaml_parser_fetch_stream_end(parser); 906| | 907| | /* Is it a directive? */ 908| | 909| 10.1M| if (parser->mark.column == 0 && CHECK(parser->buffer, '%')) ------------------ | | 181| 1.25M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 1.25M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 113k, False: 1.14M] | | ------------------ ------------------ | Branch (909:9): [True: 1.25M, False: 8.91M] ------------------ 910| 113k| return yaml_parser_fetch_directive(parser); 911| | 912| | /* Is it the document start indicator? */ 913| | 914| 10.0M| if (parser->mark.column == 0 ------------------ | Branch (914:9): [True: 1.14M, False: 8.91M] ------------------ 915| 1.14M| && CHECK_AT(parser->buffer, '-', 0) ------------------ | | 175| 11.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 975k, False: 167k] | | ------------------ ------------------ 916| 975k| && CHECK_AT(parser->buffer, '-', 1) ------------------ | | 175| 11.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 81.0k, False: 894k] | | ------------------ ------------------ 917| 81.0k| && CHECK_AT(parser->buffer, '-', 2) ------------------ | | 175| 10.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 54.6k, False: 26.4k] | | ------------------ ------------------ 918| 54.6k| && IS_BLANKZ_AT(parser->buffer, 3)) ------------------ | | 371| 54.6k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 109k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 54.6k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 109k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.95k, False: 52.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 52.6k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 52.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 545, False: 52.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 52.1k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 104k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 104k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 28.2k, False: 23.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 52.1k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 76.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 15.4k, False: 8.42k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 52.1k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 16.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.37k, False: 3.04k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 8.42k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 5.37k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 5.17k, False: 203] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 52.1k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 6.49k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.12k, False: 1.12k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 3.24k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 5.37k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.18k, False: 933] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 3.24k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.18k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 576, False: 613] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 104k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.34k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.54k, False: 1.12k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 2.67k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 4.21k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 613, False: 933] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 2.67k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 613| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 408, False: 205] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 2.26k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.26k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 345, False: 1.92k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 919| 52.7k| return yaml_parser_fetch_document_indicator(parser, 920| 52.7k| YAML_DOCUMENT_START_TOKEN); 921| | 922| | /* Is it the document end indicator? */ 923| | 924| 10.0M| if (parser->mark.column == 0 ------------------ | Branch (924:9): [True: 1.09M, False: 8.91M] ------------------ 925| 1.09M| && CHECK_AT(parser->buffer, '.', 0) ------------------ | | 175| 11.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 5.76k, False: 1.08M] | | ------------------ ------------------ 926| 5.76k| && CHECK_AT(parser->buffer, '.', 1) ------------------ | | 175| 10.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 3.18k, False: 2.58k] | | ------------------ ------------------ 927| 3.18k| && CHECK_AT(parser->buffer, '.', 2) ------------------ | | 175| 10.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.93k, False: 244] | | ------------------ ------------------ 928| 2.93k| && IS_BLANKZ_AT(parser->buffer, 3)) ------------------ | | 371| 2.93k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 5.87k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 2.93k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 5.87k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 194, False: 2.74k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 2.74k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.74k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 196, False: 2.54k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 2.54k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 5.09k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 5.09k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 713, False: 1.83k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 2.54k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 4.37k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 369, False: 1.46k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 2.54k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.92k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 274, False: 1.19k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.46k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 274| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 66, False: 208] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 2.54k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.79k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 884, False: 514] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 1.39k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 2.28k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 685, False: 199] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 1.39k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 685| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 259, False: 426] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 5.09k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.27k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 625, False: 514] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 1.13k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.76k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 426, False: 199] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 1.13k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 426| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 224, False: 202] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 915|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 915| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 44, False: 871] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 929| 2.06k| return yaml_parser_fetch_document_indicator(parser, 930| 2.06k| YAML_DOCUMENT_END_TOKEN); 931| | 932| | /* Is it the flow sequence start indicator? */ 933| | 934| 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: 88.6k, False: 9.91M] | | ------------------ ------------------ 935| 88.6k| return yaml_parser_fetch_flow_collection_start(parser, 936| 88.6k| YAML_FLOW_SEQUENCE_START_TOKEN); 937| | 938| | /* Is it the flow mapping start indicator? */ 939| | 940| 9.91M| if (CHECK(parser->buffer, '{')) ------------------ | | 181| 9.91M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 9.91M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 22.7k, False: 9.89M] | | ------------------ ------------------ 941| 22.7k| return yaml_parser_fetch_flow_collection_start(parser, 942| 22.7k| YAML_FLOW_MAPPING_START_TOKEN); 943| | 944| | /* Is it the flow sequence end indicator? */ 945| | 946| 9.89M| if (CHECK(parser->buffer, ']')) ------------------ | | 181| 9.89M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 9.89M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 69.1k, False: 9.82M] | | ------------------ ------------------ 947| 69.1k| return yaml_parser_fetch_flow_collection_end(parser, 948| 69.1k| YAML_FLOW_SEQUENCE_END_TOKEN); 949| | 950| | /* Is it the flow mapping end indicator? */ 951| | 952| 9.82M| if (CHECK(parser->buffer, '}')) ------------------ | | 181| 9.82M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 9.82M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.11k, False: 9.82M] | | ------------------ ------------------ 953| 6.11k| return yaml_parser_fetch_flow_collection_end(parser, 954| 6.11k| YAML_FLOW_MAPPING_END_TOKEN); 955| | 956| | /* Is it the flow entry indicator? */ 957| | 958| 9.82M| if (CHECK(parser->buffer, ',')) ------------------ | | 181| 9.82M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 9.82M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.72M, False: 7.09M] | | ------------------ ------------------ 959| 2.72M| return yaml_parser_fetch_flow_entry(parser); 960| | 961| | /* Is it the block entry indicator? */ 962| | 963| 7.09M| if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1)) ------------------ | | 181| 14.1M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 7.09M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.03M, False: 6.06M] | | ------------------ ------------------ if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1)) ------------------ | | 371| 1.03M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 2.07M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 1.03M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.07M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 856k, False: 178k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 178k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 178k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 377, False: 177k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 177k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 355k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 355k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 4.87k, False: 173k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 177k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 350k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 20.5k, False: 152k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 177k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 305k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 626, False: 151k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 152k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 626| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 422, False: 204] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 177k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 304k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 912, False: 151k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 152k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 152k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 710, False: 202] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 152k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 710| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 266, False: 444] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 355k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 303k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 646, False: 151k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 151k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 152k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 444, False: 202] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 151k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 444| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 243, False: 201] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 151k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 151k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 319, False: 151k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 964| 883k| return yaml_parser_fetch_block_entry(parser); 965| | 966| | /* Is it the key indicator? */ 967| | 968| 6.21M| if (CHECK(parser->buffer, '?') ------------------ | | 181| 12.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 6.21M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.57M, False: 4.64M] | | ------------------ ------------------ 969| 1.57M| && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) ------------------ | | 371| 1.47M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 2.94M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 1.47M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.94M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.37M, False: 94.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 94.8k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 94.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 94.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 94.8k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 189k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 189k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 26.1k, False: 68.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 94.8k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 163k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.2k, False: 54.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 94.8k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 108k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 974, False: 53.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 54.4k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 974| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 219, False: 755] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 94.8k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 108k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.07k, False: 53.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 54.2k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 55.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 843, False: 236] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 54.2k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 843| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 424, False: 419] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 189k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 107k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 655, False: 53.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 53.8k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 54.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 419, False: 236] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 53.8k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 419| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 211, False: 208] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 53.6k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 53.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 324, False: 53.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (969:17): [True: 96.8k, False: 1.47M] ------------------ 970| 1.51M| return yaml_parser_fetch_key(parser); 971| | 972| | /* Is it the value indicator? */ 973| | 974| 4.69M| if (CHECK(parser->buffer, ':') ------------------ | | 181| 9.39M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 4.69M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.29M, False: 3.39M] | | ------------------ ------------------ 975| 1.29M| && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) ------------------ | | 371| 1.28M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 2.57M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 1.28M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.57M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.99k, False: 1.28M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 1.28M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.28M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 239, False: 1.28M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 1.28M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 2.56M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 2.56M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 40.3k, False: 1.24M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 1.28M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 2.52M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 887k, False: 353k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 1.28M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 706k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 414, False: 353k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 353k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 414| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 204, False: 210] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 1.28M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 706k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.65k, False: 351k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 353k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 354k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.31k, False: 340] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 353k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.31k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 552, False: 762] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 2.56M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 705k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.10k, False: 351k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 352k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 353k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 762, False: 340] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 352k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 762| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 436, False: 326] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 352k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 352k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 292, False: 352k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (975:17): [True: 13.0k, False: 1.28M] ------------------ 976| 946k| return yaml_parser_fetch_value(parser); 977| | 978| | /* Is it an alias? */ 979| | 980| 3.75M| if (CHECK(parser->buffer, '*')) ------------------ | | 181| 3.75M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.75M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 288k, False: 3.46M] | | ------------------ ------------------ 981| 288k| return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN); 982| | 983| | /* Is it an anchor? */ 984| | 985| 3.46M| if (CHECK(parser->buffer, '&')) ------------------ | | 181| 3.46M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8.56k, False: 3.45M] | | ------------------ ------------------ 986| 8.56k| return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN); 987| | 988| | /* Is it a tag? */ 989| | 990| 3.45M| if (CHECK(parser->buffer, '!')) ------------------ | | 181| 3.45M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.45M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 17.0k, False: 3.43M] | | ------------------ ------------------ 991| 17.0k| return yaml_parser_fetch_tag(parser); 992| | 993| | /* Is it a literal scalar? */ 994| | 995| 3.43M| if (CHECK(parser->buffer, '|') && !parser->flow_level) ------------------ | | 181| 6.87M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.43M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 19.2k, False: 3.41M] | | ------------------ ------------------ | Branch (995:39): [True: 19.2k, False: 10] ------------------ 996| 19.2k| return yaml_parser_fetch_block_scalar(parser, 1); 997| | 998| | /* Is it a folded scalar? */ 999| | 1000| 3.41M| if (CHECK(parser->buffer, '>') && !parser->flow_level) ------------------ | | 181| 6.83M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 11.3k, False: 3.40M] | | ------------------ ------------------ | Branch (1000:39): [True: 11.3k, False: 5] ------------------ 1001| 11.3k| return yaml_parser_fetch_block_scalar(parser, 0); 1002| | 1003| | /* Is it a single-quoted scalar? */ 1004| | 1005| 3.40M| if (CHECK(parser->buffer, '\'')) ------------------ | | 181| 3.40M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.40M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.10k, False: 3.39M] | | ------------------ ------------------ 1006| 9.10k| return yaml_parser_fetch_flow_scalar(parser, 1); 1007| | 1008| | /* Is it a double-quoted scalar? */ 1009| | 1010| 3.39M| if (CHECK(parser->buffer, '"')) ------------------ | | 181| 3.39M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.39M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 7.87k, False: 3.38M] | | ------------------ ------------------ 1011| 7.87k| 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.38M| if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-') ------------------ | | 373| 3.38M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 6.77M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 6.77M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 3.38M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 6.77M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 3.38M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 3.38M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 12, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 3.38M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 6.77M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.77M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 3.38M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.77M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 3.38M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.77M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 850, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 3.38M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 850| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 850] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 3.38M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.77M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 963, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 3.38M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.38M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 508, False: 455] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 3.38M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 508| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 508] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 6.77M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.77M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 963, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 3.38M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.38M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 508, False: 455] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 3.38M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 508| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 508] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 3.38M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 3.38M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 0, False: 3.38M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-') ------------------ | | 181| 6.77M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.38M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 151k, False: 3.23M] | | ------------------ ------------------ 1033| 3.23M| || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') ------------------ | | 181| 6.62M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.23M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 53.2k, False: 3.18M] | | ------------------ ------------------ || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') ------------------ | | 181| 6.57M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 3.18M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 352k, False: 2.83M] | | ------------------ ------------------ 1034| 2.83M| || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ 1035| 2.83M| || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ 1036| 2.83M| || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ 1037| 2.83M| || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ 1038| 2.83M| || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10, False: 2.83M] | | ------------------ ------------------ 1039| 2.83M| || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ 1040| 2.83M| || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 0, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%') ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 8, False: 2.83M] | | ------------------ ------------------ 1041| 2.83M| || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) || ------------------ | | 181| 6.21M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 11, False: 2.83M] | | ------------------ ------------------ || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) || ------------------ | | 181| 2.83M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.83M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9, False: 2.83M] | | ------------------ ------------------ 1042| 556k| (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) || ------------------ | | 181| 1.11M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 556k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 151k, False: 405k] | | ------------------ ------------------ (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) || ------------------ | | 321| 151k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | ------------------ | | | | 304| 151k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 302k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 0, 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: 0, False: 151k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1043| 405k| (!parser->flow_level && ------------------ | Branch (1043:14): [True: 405k, False: 21] ------------------ 1044| 405k| (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')) ------------------ | | 181| 810k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 405k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 53.2k, False: 352k] | | ------------------ ------------------ (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')) ------------------ | | 181| 352k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 352k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 352k, False: 34] | | ------------------ ------------------ 1045| 405k| && !IS_BLANKZ_AT(parser->buffer, 1))) ------------------ | | 371| 405k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 810k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 405k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 810k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 405k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 405k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 405k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 405k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 405k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 810k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 810k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 405k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 405k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 810k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 405k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 405k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 810k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 965, False: 404k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 405k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 965| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 965] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 405k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 810k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.11k, False: 404k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 405k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 406k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 534, False: 576] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 405k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 534| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 534] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 810k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 810k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.11k, False: 404k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 405k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 406k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 534, False: 576] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 405k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 534| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 534] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 405k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 405k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 0, False: 405k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1046| 3.38M| 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| 55| return yaml_parser_set_scanner_error(parser, 1053| 55| "while scanning for the next token", parser->mark, 1054| 55| "found character that cannot start any token"); 1055| 3.38M|} scanner.c:yaml_parser_fetch_stream_start: 1311| 11.0k|{ 1312| 11.0k| yaml_simple_key_t simple_key = { 0, 0, 0, { 0, 0, 0 } }; 1313| 11.0k| yaml_token_t token; 1314| | 1315| | /* Set the initial indentation. */ 1316| | 1317| 11.0k| parser->indent = -1; 1318| | 1319| | /* Initialize the simple key stack. */ 1320| | 1321| 11.0k| if (!PUSH(parser, parser->simple_keys, simple_key)) ------------------ | | 445| 11.0k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 11.0k, False: 0] | | ------------------ | | 446| 11.0k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 0, False: 0] | | ------------------ | | 447| 0| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 11.0k| (*((stack).top++) = value, \ | | 449| 11.0k| 1) : \ | | 450| 11.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1321:9): [True: 0, False: 11.0k] ------------------ 1322| 0| return 0; 1323| | 1324| | /* A simple key is allowed at the beginning of the stream. */ 1325| | 1326| 11.0k| parser->simple_key_allowed = 1; 1327| | 1328| | /* We have started. */ 1329| | 1330| 11.0k| parser->stream_start_produced = 1; 1331| | 1332| | /* Create the STREAM-START token and append it to the queue. */ 1333| | 1334| 11.0k| STREAM_START_TOKEN_INIT(token, parser->encoding, ------------------ | | 506| 11.0k| (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 11.0k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 11.0k| (token).type = (token_type), \ | | | | 502| 11.0k| (token).start_mark = (token_start_mark), \ | | | | 503| 11.0k| (token).end_mark = (token_end_mark)) | | ------------------ | | 507| 11.0k| (token).data.stream_start.encoding = (token_encoding)) ------------------ 1335| 11.0k| parser->mark, parser->mark); 1336| | 1337| 11.0k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 11.0k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 11.0k, False: 0] | | ------------------ | | 473| 11.0k| || 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| 11.0k| (*((queue).tail++) = value, \ | | 476| 11.0k| 1) : \ | | 477| 11.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1337:9): [True: 0, False: 11.0k] ------------------ 1338| 0| return 0; 1339| | 1340| 11.0k| return 1; 1341| 11.0k|} scanner.c:yaml_parser_scan_to_next_token: 1939| 10.1M|{ 1940| | /* Until the next token is not found. */ 1941| | 1942| 13.5M| while (1) ------------------ | Branch (1942:12): [True: 13.5M, Folded] ------------------ 1943| 13.5M| { 1944| | /* Allow the BOM mark to start a line. */ 1945| | 1946| 13.5M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 13.5M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 13.5M, False: 104] | | ------------------ | | 494| 13.5M| ? 1 \ | | 495| 13.5M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1946:13): [True: 1, False: 13.5M] ------------------ 1947| | 1948| 13.5M| if (parser->mark.column == 0 && IS_BOM(parser->buffer)) ------------------ | | 298| 3.61M|#define IS_BOM(string) IS_BOM_AT(string,0) | | ------------------ | | | | 294| 3.61M| (CHECK_AT((string),'\xEF',(offset)) \ | | | | ------------------ | | | | | | 175| 7.22M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.51k, False: 3.61M] | | | | | | ------------------ | | | | ------------------ | | | | 295| 3.61M| && CHECK_AT((string),'\xBB',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.61M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.01k, False: 507] | | | | | | ------------------ | | | | ------------------ | | | | 296| 3.61M| && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */ | | | | ------------------ | | | | | | 175| 2.01k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.67k, False: 338] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1948:13): [True: 3.61M, False: 9.96M] ------------------ 1949| 1.67k| SKIP(parser); ------------------ | | 502| 1.67k| (parser->mark.index ++, \ | | 503| 1.67k| parser->mark.column ++, \ | | 504| 1.67k| parser->unread --, \ | | 505| 1.67k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.67k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.67k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 0, False: 1.67k] | | | | | | ------------------ | | | | | | 381| 1.67k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 0, False: 1.67k] | | | | | | ------------------ | | | | | | 382| 1.67k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 1.67k, False: 0] | | | | | | ------------------ | | | | | | 383| 1.67k| ((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.5M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 13.5M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 13.5M, False: 41] | | ------------------ | | 494| 13.5M| ? 1 \ | | 495| 13.5M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1961:13): [True: 1, False: 13.5M] ------------------ 1962| | 1963| 30.7M| while (CHECK(parser->buffer,' ') || ------------------ | | 181| 61.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 30.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 17.1M, False: 13.5M] | | ------------------ ------------------ 1964| 13.5M| ((parser->flow_level || !parser->simple_key_allowed) && ------------------ | Branch (1964:19): [True: 6.44M, False: 7.13M] | Branch (1964:41): [True: 2.05M, False: 5.07M] ------------------ 1965| 17.1M| CHECK(parser->buffer, '\t'))) { ------------------ | | 181| 8.50M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 8.50M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.74k, False: 8.50M] | | ------------------ ------------------ 1966| 17.1M| SKIP(parser); ------------------ | | 502| 17.1M| (parser->mark.index ++, \ | | 503| 17.1M| parser->mark.column ++, \ | | 504| 17.1M| parser->unread --, \ | | 505| 17.1M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 17.1M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 17.1M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 17.1M, False: 0] | | | | | | ------------------ | | | | | | 381| 17.1M| ((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.1M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 17.1M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 17.1M, False: 908] | | ------------------ | | 494| 17.1M| ? 1 \ | | 495| 17.1M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1967:17): [True: 2, False: 17.1M] ------------------ 1968| 17.1M| } 1969| | 1970| | /* Eat a comment until a line break. */ 1971| | 1972| 13.5M| if (CHECK(parser->buffer, '#')) { ------------------ | | 181| 13.5M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.27k, False: 13.5M] | | ------------------ ------------------ 1973| 2.62M| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 2.62M|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 2.62M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 5.25M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 5.25M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 608, False: 2.62M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 2.62M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 5.25M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 333, False: 2.62M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 2.62M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.25M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.31k, False: 2.62M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 2.62M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 3.31k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.27k, False: 2.04k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 2.62M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.25M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 321k, False: 2.30M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 2.62M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 2.94M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 294k, False: 27.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 2.62M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 294k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 657, False: 293k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 5.25M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.25M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 321k, False: 2.30M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 2.62M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 2.94M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 293k, False: 27.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 2.62M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 293k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 294, False: 293k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 2.62M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.62M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 100, False: 2.62M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1974| 2.62M| SKIP(parser); ------------------ | | 502| 2.62M| (parser->mark.index ++, \ | | 503| 2.62M| parser->mark.column ++, \ | | 504| 2.62M| parser->unread --, \ | | 505| 2.62M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.62M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.62M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.20M, False: 419k] | | | | | | ------------------ | | | | | | 381| 2.62M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 2.06k, False: 417k] | | | | | | ------------------ | | | | | | 382| 419k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 416k, False: 208] | | | | | | ------------------ | | | | | | 383| 417k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 208, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1975| 2.62M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 2.62M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.62M, False: 257] | | ------------------ | | 494| 2.62M| ? 1 \ | | 495| 2.62M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1975:21): [True: 6, False: 2.62M] ------------------ 1976| 2.62M| } 1977| 3.27k| } 1978| | 1979| | /* If it is a line break, eat it. */ 1980| | 1981| 13.5M| if (IS_BREAK(parser->buffer)) ------------------ | | 341| 13.5M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 13.5M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 27.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.32M, False: 12.2M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 13.5M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 25.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.04M, False: 10.1M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 13.5M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 20.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 10.7k, False: 10.1M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 10.1M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 10.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 9.90k, False: 850] | | | | | | ------------------ | | | | ------------------ | | | | 334| 13.5M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 20.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 7.21k, False: 10.1M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 10.1M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 10.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 6.75k, False: 455] | | | | | | ------------------ | | | | ------------------ | | | | 336| 10.1M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 6.75k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.57k, False: 3.18k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 13.5M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 20.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.63k, False: 10.1M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 10.1M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 10.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.18k, False: 455] | | | | | | ------------------ | | | | ------------------ | | | | 339| 10.1M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 3.18k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.67k, False: 508] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1982| 3.39M| { 1983| 3.39M| if (!CACHE(parser, 2)) return 0; ------------------ | | 493| 3.39M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 3.39M, False: 319] | | ------------------ | | 494| 3.39M| ? 1 \ | | 495| 3.39M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (1983:17): [True: 4, False: 3.39M] ------------------ 1984| 3.39M| SKIP_LINE(parser); ------------------ | | 508| 3.39M| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 3.39M|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 3.39M| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 6.78M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.32M, False: 2.06M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 1.32M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.08M, False: 235k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 3.39M| (parser->mark.index += 2, \ | | 510| 1.08M| parser->mark.column = 0, \ | | 511| 1.08M| parser->mark.line ++, \ | | 512| 1.08M| parser->unread -= 2, \ | | 513| 1.08M| parser->buffer.pointer += 2) : \ | | 514| 3.39M| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 2.30M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 4.60M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 4.60M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 235k, False: 2.06M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 2.30M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 4.36M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.04M, False: 16.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 2.30M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 32.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 9.90k, False: 6.24k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 16.1k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 9.90k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 9.90k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 2.30M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 6.24k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 6.24k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 12.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 6.24k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 6.24k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 6.24k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.57k, False: 2.67k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 4.60M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.34k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.67k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 2.67k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 5.34k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.67k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 2.67k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 2.67k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.67k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 515| 2.30M| (parser->mark.index ++, \ | | 516| 2.30M| parser->mark.column = 0, \ | | 517| 2.30M| parser->mark.line ++, \ | | 518| 2.30M| parser->unread --, \ | | 519| 2.30M| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 2.30M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.30M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.28M, False: 16.1k] | | | | | | ------------------ | | | | | | 381| 2.30M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 9.90k, False: 6.24k] | | | | | | ------------------ | | | | | | 382| 16.1k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 6.24k, False: 0] | | | | | | ------------------ | | | | | | 383| 6.24k| ((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.39M| if (!parser->flow_level) { ------------------ | Branch (1988:17): [True: 2.65M, False: 733k] ------------------ 1989| 2.65M| parser->simple_key_allowed = 1; 1990| 2.65M| } 1991| 3.39M| } 1992| 10.1M| else 1993| 10.1M| { 1994| | /* We have found a token. */ 1995| | 1996| 10.1M| break; 1997| 10.1M| } 1998| 13.5M| } 1999| | 2000| 10.1M| return 1; 2001| 10.1M|} scanner.c:yaml_parser_unroll_indent: 1278| 10.3M|{ 1279| 10.3M| yaml_token_t token; 1280| | 1281| | /* In the flow context, do nothing. */ 1282| | 1283| 10.3M| if (parser->flow_level) ------------------ | Branch (1283:9): [True: 5.71M, False: 4.64M] ------------------ 1284| 5.71M| return 1; 1285| | 1286| | /* Loop through the indentation levels in the stack. */ 1287| | 1288| 6.83M| while (parser->indent > column) ------------------ | Branch (1288:12): [True: 2.18M, False: 4.64M] ------------------ 1289| 2.18M| { 1290| | /* Create a token and append it to the queue. */ 1291| | 1292| 2.18M| TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark); ------------------ | | 500| 2.18M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 2.18M| (token).type = (token_type), \ | | 502| 2.18M| (token).start_mark = (token_start_mark), \ | | 503| 2.18M| (token).end_mark = (token_end_mark)) ------------------ 1293| | 1294| 2.18M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 2.18M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 2.04M, False: 148k] | | ------------------ | | 473| 2.18M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 148k, False: 0] | | ------------------ | | 474| 148k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 2.18M| (*((queue).tail++) = value, \ | | 476| 2.18M| 1) : \ | | 477| 2.18M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1294:13): [True: 0, False: 2.18M] ------------------ 1295| 0| return 0; 1296| | 1297| | /* Pop the indentation level. */ 1298| | 1299| 2.18M| parser->indent = POP(parser, parser->indents); ------------------ | | 454| 2.18M| (*(--(stack).top)) ------------------ 1300| 2.18M| } 1301| | 1302| 4.64M| return 1; 1303| 4.64M|} scanner.c:yaml_parser_fetch_stream_end: 1349| 8.11k|{ 1350| 8.11k| yaml_token_t token; 1351| | 1352| | /* Force new line. */ 1353| | 1354| 8.11k| if (parser->mark.column != 0) { ------------------ | Branch (1354:9): [True: 7.11k, False: 1.00k] ------------------ 1355| 7.11k| parser->mark.column = 0; 1356| 7.11k| parser->mark.line ++; 1357| 7.11k| } 1358| | 1359| | /* Reset the indentation level. */ 1360| | 1361| 8.11k| if (!yaml_parser_unroll_indent(parser, -1)) ------------------ | Branch (1361:9): [True: 0, False: 8.11k] ------------------ 1362| 0| return 0; 1363| | 1364| | /* Reset simple keys. */ 1365| | 1366| 8.11k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1366:9): [True: 127, False: 7.98k] ------------------ 1367| 127| return 0; 1368| | 1369| 7.98k| parser->simple_key_allowed = 0; 1370| | 1371| | /* Create the STREAM-END token and append it to the queue. */ 1372| | 1373| 7.98k| STREAM_END_TOKEN_INIT(token, parser->mark, parser->mark); ------------------ | | 510| 7.98k| (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) | | ------------------ | | | | 500| 7.98k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 7.98k| (token).type = (token_type), \ | | | | 502| 7.98k| (token).start_mark = (token_start_mark), \ | | | | 503| 7.98k| (token).end_mark = (token_end_mark)) | | ------------------ ------------------ 1374| | 1375| 7.98k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 7.98k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 7.72k, False: 263] | | ------------------ | | 473| 7.98k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 263, False: 0] | | ------------------ | | 474| 263| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 7.98k| (*((queue).tail++) = value, \ | | 476| 7.98k| 1) : \ | | 477| 7.98k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1375:9): [True: 0, False: 7.98k] ------------------ 1376| 0| return 0; 1377| | 1378| 7.98k| return 1; 1379| 7.98k|} scanner.c:yaml_parser_remove_simple_key: 1142| 9.15M|{ 1143| 9.15M| yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 1144| | 1145| 9.15M| if (simple_key->possible) ------------------ | Branch (1145:9): [True: 2.68M, False: 6.47M] ------------------ 1146| 2.68M| { 1147| | /* If the key is required, it is an error. */ 1148| | 1149| 2.68M| if (simple_key->required) { ------------------ | Branch (1149:13): [True: 131, False: 2.68M] ------------------ 1150| 131| return yaml_parser_set_scanner_error(parser, 1151| 131| "while scanning a simple key", simple_key->mark, 1152| 131| "could not find expected ':'"); 1153| 131| } 1154| 2.68M| } 1155| | 1156| | /* Remove the key from the stack. */ 1157| | 1158| 9.15M| simple_key->possible = 0; 1159| | 1160| 9.15M| return 1; 1161| 9.15M|} scanner.c:yaml_parser_fetch_directive: 1387| 113k|{ 1388| 113k| yaml_token_t token; 1389| | 1390| | /* Reset the indentation level. */ 1391| | 1392| 113k| if (!yaml_parser_unroll_indent(parser, -1)) ------------------ | Branch (1392:9): [True: 0, False: 113k] ------------------ 1393| 0| return 0; 1394| | 1395| | /* Reset simple keys. */ 1396| | 1397| 113k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1397:9): [True: 0, False: 113k] ------------------ 1398| 0| return 0; 1399| | 1400| 113k| parser->simple_key_allowed = 0; 1401| | 1402| | /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */ 1403| | 1404| 113k| if (!yaml_parser_scan_directive(parser, &token)) ------------------ | Branch (1404:9): [True: 438, False: 113k] ------------------ 1405| 438| return 0; 1406| | 1407| | /* Append the token to the queue. */ 1408| | 1409| 113k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 113k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 108k, False: 4.90k] | | ------------------ | | 473| 113k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 4.90k, False: 0] | | ------------------ | | 474| 4.90k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 113k| (*((queue).tail++) = value, \ | | 476| 113k| 1) : \ | | 477| 113k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1409:9): [True: 0, False: 113k] ------------------ 1410| 0| yaml_token_delete(&token); 1411| 0| return 0; 1412| 0| } 1413| | 1414| 113k| return 1; 1415| 113k|} scanner.c:yaml_parser_scan_directive: 2015| 113k|{ 2016| 113k| yaml_mark_t start_mark, end_mark; 2017| 113k| yaml_char_t *name = NULL; 2018| 113k| int major, minor; 2019| 113k| yaml_char_t *handle = NULL, *prefix = NULL; 2020| | 2021| | /* Eat '%'. */ 2022| | 2023| 113k| start_mark = parser->mark; 2024| | 2025| 113k| SKIP(parser); ------------------ | | 502| 113k| (parser->mark.index ++, \ | | 503| 113k| parser->mark.column ++, \ | | 504| 113k| parser->unread --, \ | | 505| 113k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 113k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 113k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 113k, False: 0] | | | | | | ------------------ | | | | | | 381| 113k| ((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| 113k| if (!yaml_parser_scan_directive_name(parser, start_mark, &name)) ------------------ | Branch (2029:9): [True: 85, False: 113k] ------------------ 2030| 85| goto error; 2031| | 2032| | /* Is it a YAML directive? */ 2033| | 2034| 113k| if (strcmp((char *)name, "YAML") == 0) ------------------ | Branch (2034:9): [True: 8.47k, False: 104k] ------------------ 2035| 8.47k| { 2036| | /* Scan the VERSION directive value. */ 2037| | 2038| 8.47k| if (!yaml_parser_scan_version_directive_value(parser, start_mark, ------------------ | Branch (2038:13): [True: 66, False: 8.40k] ------------------ 2039| 8.47k| &major, &minor)) 2040| 66| goto error; 2041| | 2042| 8.40k| end_mark = parser->mark; 2043| | 2044| | /* Create a VERSION-DIRECTIVE token. */ 2045| | 2046| 8.40k| VERSION_DIRECTIVE_TOKEN_INIT(*token, major, minor, ------------------ | | 532| 8.40k| (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 8.40k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 8.40k| (token).type = (token_type), \ | | | | 502| 8.40k| (token).start_mark = (token_start_mark), \ | | | | 503| 8.40k| (token).end_mark = (token_end_mark)) | | ------------------ | | 533| 8.40k| (token).data.version_directive.major = (token_major), \ | | 534| 8.40k| (token).data.version_directive.minor = (token_minor)) ------------------ 2047| 8.40k| start_mark, end_mark); 2048| 8.40k| } 2049| | 2050| | /* Is it a TAG directive? */ 2051| | 2052| 104k| else if (strcmp((char *)name, "TAG") == 0) ------------------ | Branch (2052:14): [True: 104k, False: 126] ------------------ 2053| 104k| { 2054| | /* Scan the TAG directive value. */ 2055| | 2056| 104k| if (!yaml_parser_scan_tag_directive_value(parser, start_mark, ------------------ | Branch (2056:13): [True: 123, False: 104k] ------------------ 2057| 104k| &handle, &prefix)) 2058| 123| goto error; 2059| | 2060| 104k| end_mark = parser->mark; 2061| | 2062| | /* Create a TAG-DIRECTIVE token. */ 2063| | 2064| 104k| TAG_DIRECTIVE_TOKEN_INIT(*token, handle, prefix, ------------------ | | 537| 104k| (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 104k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 104k| (token).type = (token_type), \ | | | | 502| 104k| (token).start_mark = (token_start_mark), \ | | | | 503| 104k| (token).end_mark = (token_end_mark)) | | ------------------ | | 538| 104k| (token).data.tag_directive.handle = (token_handle), \ | | 539| 104k| (token).data.tag_directive.prefix = (token_prefix)) ------------------ 2065| 104k| start_mark, end_mark); 2066| 104k| } 2067| | 2068| | /* Unknown directive. */ 2069| | 2070| 126| else 2071| 126| { 2072| 126| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2073| 126| start_mark, "found unknown directive name"); 2074| 126| goto error; 2075| 126| } 2076| | 2077| | /* Eat the rest of the line including any comments. */ 2078| | 2079| 113k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 113k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 113k, False: 0] | | ------------------ | | 494| 113k| ? 1 \ | | 495| 113k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2079:9): [True: 0, False: 113k] ------------------ 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: 96] | | ------------------ | | 494| 926k| ? 1 \ | | 495| 926k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2083:13): [True: 1, False: 926k] ------------------ 2084| 926k| } 2085| | 2086| 113k| if (CHECK(parser->buffer, '#')) { ------------------ | | 181| 113k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 113k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 11.0k, False: 102k] | | ------------------ ------------------ 2087| 993k| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 993k|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 993k| (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: 9.80k, False: 983k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 993k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.97M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 444, False: 983k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 993k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 676, False: 982k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 983k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 676| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 213, False: 463] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 993k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 904, False: 982k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 982k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 983k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 702, False: 202] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 982k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 702| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 267, False: 435] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 1.98M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.96M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 637, False: 982k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 982k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 983k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 435, False: 202] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 982k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 435| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 194, False: 241] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (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: 83, 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.18k] | | | | | | ------------------ | | | | | | 381| 982k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 538, False: 643] | | | | | | ------------------ | | | | | | 382| 1.18k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 446, False: 197] | | | | | | ------------------ | | | | | | 383| 643| ((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: 146] | | ------------------ | | 494| 982k| ? 1 \ | | 495| 982k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2089:17): [True: 2, False: 982k] ------------------ 2090| 982k| } 2091| 11.0k| } 2092| | 2093| | /* Check if we are at the end of the line. */ 2094| | 2095| 113k| if (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 113k|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 113k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 226k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 226k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13.5k, False: 99.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 113k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 212k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 98.0k, False: 1.51k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 113k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 3.02k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 420, False: 1.09k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.51k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 420| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 415, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 113k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.19k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 764, False: 333] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 1.09k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.86k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 763, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 1.09k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 763| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 501, False: 262] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 226k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.19k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 263, False: 333] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 596| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 859| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 262, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 596| && 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| 335|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 335| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 301, False: 34] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2096| 34| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2097| 34| start_mark, "did not find expected comment or line break"); 2098| 34| goto error; 2099| 34| } 2100| | 2101| | /* Eat a line break. */ 2102| | 2103| 113k| if (IS_BREAK(parser->buffer)) { ------------------ | | 341| 113k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 113k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 226k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 13.5k, False: 99.5k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 113k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 212k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 98.0k, False: 1.47k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 113k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.95k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 415, False: 1.06k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 1.47k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 415| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 415, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 334| 113k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.12k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 762, False: 301] | | | | | | ------------------ | | | | ------------------ | | | | 335| 1.06k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 1.82k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 762, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 336| 1.06k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 762| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 501, False: 261] | | | | | | ------------------ | | | | ------------------ | | | | 337| 113k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 1.12k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 261, False: 301] | | | | | | ------------------ | | | | ------------------ | | | | 338| 562| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 823| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 261, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 339| 562| && 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| 112k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 112k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 112k, False: 81] | | ------------------ | | 494| 112k| ? 1 \ | | 495| 112k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2104:13): [True: 1, False: 112k] ------------------ 2105| 112k| SKIP_LINE(parser); ------------------ | | 508| 112k| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 112k|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 112k| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 225k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13.5k, False: 99.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 13.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 278, False: 13.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 112k| (parser->mark.index += 2, \ | | 510| 278| parser->mark.column = 0, \ | | 511| 278| parser->mark.line ++, \ | | 512| 278| parser->unread -= 2, \ | | 513| 278| parser->buffer.pointer += 2) : \ | | 514| 112k| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 112k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 225k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 225k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13.2k, False: 99.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 112k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 211k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 98.0k, False: 1.17k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 112k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.35k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 415, False: 762] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.17k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 415| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 415, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 112k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.52k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 762, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 762| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.52k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 762, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 762| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 762| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 501, False: 261] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 225k| || (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| 112k| (parser->mark.index ++, \ | | 516| 112k| parser->mark.column = 0, \ | | 517| 112k| parser->mark.line ++, \ | | 518| 112k| parser->unread --, \ | | 519| 112k| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 112k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 112k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 111k, False: 1.17k] | | | | | | ------------------ | | | | | | 381| 112k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 415, False: 762] | | | | | | ------------------ | | | | | | 382| 1.17k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 762, False: 0] | | | | | | ------------------ | | | | | | 383| 762| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2106| 112k| } 2107| | 2108| 113k| yaml_free(name); 2109| | 2110| 113k| return 1; 2111| | 2112| 438|error: 2113| 438| yaml_free(prefix); 2114| 438| yaml_free(handle); 2115| 438| yaml_free(name); 2116| 438| return 0; 2117| 113k|} scanner.c:yaml_parser_scan_directive_name: 2132| 113k|{ 2133| 113k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 113k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2134| | 2135| 113k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 113k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 113k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 113k, False: 0] | | ------------------ | | 134| 113k| ((string).pointer = (string).start, \ | | 135| 113k| (string).end = (string).start+(size), \ | | 136| 113k| memset((string).start, 0, (size)), \ | | 137| 113k| 1) : \ | | 138| 113k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2135:9): [True: 0, False: 113k] ------------------ 2136| | 2137| | /* Consume the directive name. */ 2138| | 2139| 113k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 113k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 113k, False: 0] | | ------------------ | | 494| 113k| ? 1 \ | | 495| 113k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2139:9): [True: 0, False: 113k] ------------------ 2140| | 2141| 113k| while (IS_ALPHA(parser->buffer)) 2142| 2.89M| { 2143| 2.89M| if (!READ(parser, string)) goto error; ------------------ | | 526| 2.89M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 2.89M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 2.89M, False: 0] | | | | | Branch (146:7): [True: 2.89M, False: 181] | | | | ------------------ | | | | 147| 2.89M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 181, False: 0] | | | | ------------------ | | | | 148| 181| &(string).pointer, &(string).end)) ? \ | | | | 149| 2.89M| 1 : \ | | | | 150| 2.89M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 2.89M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 2.89M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 2.89M, False: 0] | | | | ------------------ | | | | 399| 2.89M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 2.89M| (*(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.89M| parser->mark.index ++, \ | | 529| 2.89M| parser->mark.column ++, \ | | 530| 2.89M| parser->unread --, \ | | 531| 2.89M| 1) : 0) ------------------ | Branch (2143:13): [True: 0, False: 2.89M] ------------------ 2144| 2.89M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 2.89M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.89M, False: 228] | | ------------------ | | 494| 2.89M| ? 1 \ | | 495| 2.89M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2144:13): [True: 1, False: 2.89M] ------------------ 2145| 2.89M| } 2146| | 2147| | /* Check if the name is empty. */ 2148| | 2149| 113k| if (string.start == string.pointer) { ------------------ | Branch (2149:9): [True: 39, False: 113k] ------------------ 2150| 39| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2151| 39| start_mark, "could not find expected directive name"); 2152| 39| goto error; 2153| 39| } 2154| | 2155| | /* Check for an blank character after the name. */ 2156| | 2157| 113k| if (!IS_BLANKZ(parser->buffer)) { ------------------ | | 373| 113k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 113k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 227k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 113k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 227k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 112k, False: 1.05k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 1.05k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 1.05k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 882, False: 169] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 169| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 338| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 338| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 5, False: 164] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 169| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 333| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 5, False: 159] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 169| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 318| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 6, False: 153] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 159| && 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| 169| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 316| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 8, False: 150] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 158| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 166| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3, False: 5] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 158| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1, False: 2] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 338| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 314| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 7, False: 150] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 157| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 164| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2, False: 5] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 157| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 2| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 156|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 156| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 111, False: 45] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2158| 45| yaml_parser_set_scanner_error(parser, "while scanning a directive", 2159| 45| start_mark, "found unexpected non-alphabetical character"); 2160| 45| goto error; 2161| 45| } 2162| | 2163| 113k| *name = string.start; 2164| | 2165| 113k| return 1; 2166| | 2167| 85|error: 2168| 85| STRING_DEL(parser, string); ------------------ | | 142| 85| (yaml_free((string).start), \ | | 143| 85| (string).start = (string).pointer = (string).end = 0) ------------------ 2169| 85| return 0; 2170| 113k|} scanner.c:yaml_parser_scan_version_directive_value: 2183| 8.47k|{ 2184| | /* Eat whitespaces. */ 2185| | 2186| 8.47k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 8.47k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 8.47k, False: 0] | | ------------------ | | 494| 8.47k| ? 1 \ | | 495| 8.47k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2186:9): [True: 0, False: 8.47k] ------------------ 2187| | 2188| 991k| while (IS_BLANK(parser->buffer)) { 2189| 991k| SKIP(parser); ------------------ | | 502| 991k| (parser->mark.index ++, \ | | 503| 991k| parser->mark.column ++, \ | | 504| 991k| parser->unread --, \ | | 505| 991k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 991k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 991k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 991k, False: 0] | | | | | | ------------------ | | | | | | 381| 991k| ((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| 991k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 991k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 991k, False: 86] | | ------------------ | | 494| 991k| ? 1 \ | | 495| 991k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2190:13): [True: 1, False: 991k] ------------------ 2191| 991k| } 2192| | 2193| | /* Consume the major version number. */ 2194| | 2195| 8.47k| if (!yaml_parser_scan_version_directive_number(parser, start_mark, major)) ------------------ | Branch (2195:9): [True: 39, False: 8.43k] ------------------ 2196| 39| return 0; 2197| | 2198| | /* Eat '.'. */ 2199| | 2200| 8.43k| if (!CHECK(parser->buffer, '.')) { ------------------ | | 181| 8.43k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 8.43k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2200:9): [True: 17, False: 8.41k] ------------------ 2201| 17| return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 2202| 17| start_mark, "did not find expected digit or '.' character"); 2203| 17| } 2204| | 2205| 8.41k| SKIP(parser); ------------------ | | 502| 8.41k| (parser->mark.index ++, \ | | 503| 8.41k| parser->mark.column ++, \ | | 504| 8.41k| parser->unread --, \ | | 505| 8.41k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 8.41k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 8.41k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 8.41k, False: 0] | | | | | | ------------------ | | | | | | 381| 8.41k| ((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| 8.41k| if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor)) ------------------ | Branch (2209:9): [True: 9, False: 8.40k] ------------------ 2210| 9| return 0; 2211| | 2212| 8.40k| return 1; 2213| 8.41k|} scanner.c:yaml_parser_scan_version_directive_number: 2230| 16.8k|{ 2231| 16.8k| int value = 0; 2232| 16.8k| size_t length = 0; 2233| | 2234| | /* Repeat while the next character is digit. */ 2235| | 2236| 16.8k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 16.8k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 16.8k, False: 22] | | ------------------ | | 494| 16.8k| ? 1 \ | | 495| 16.8k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2236:9): [True: 1, False: 16.8k] ------------------ 2237| | 2238| 16.8k| while (IS_DIGIT(parser->buffer)) 2239| 17.1k| { 2240| | /* Check if the number is too long. */ 2241| | 2242| 17.1k| if (++length > MAX_NUMBER_LENGTH) { ------------------ | | 2215| 17.1k|#define MAX_NUMBER_LENGTH 9 ------------------ | Branch (2242:13): [True: 2, False: 17.1k] ------------------ 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| 17.1k| value = value*10 + AS_DIGIT(parser->buffer); ------------------ | | 217| 17.1k|#define AS_DIGIT(string) AS_DIGIT_AT((string),0) | | ------------------ | | | | 215| 17.1k| ((string).pointer[offset] - (yaml_char_t) '0') | | ------------------ ------------------ 2248| | 2249| 17.1k| SKIP(parser); ------------------ | | 502| 17.1k| (parser->mark.index ++, \ | | 503| 17.1k| parser->mark.column ++, \ | | 504| 17.1k| parser->unread --, \ | | 505| 17.1k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 17.1k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 17.1k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 17.1k, False: 0] | | | | | | ------------------ | | | | | | 381| 17.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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2250| | 2251| 17.1k| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 17.1k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 17.0k, False: 98] | | ------------------ | | 494| 17.1k| ? 1 \ | | 495| 17.1k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2251:13): [True: 1, False: 17.1k] ------------------ 2252| 17.1k| } 2253| | 2254| | /* Check if the number was present. */ 2255| | 2256| 16.8k| if (!length) { ------------------ | Branch (2256:9): [True: 44, False: 16.8k] ------------------ 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| 16.8k| *number = value; 2262| | 2263| 16.8k| return 1; 2264| 16.8k|} scanner.c:yaml_parser_scan_tag_directive_value: 2277| 104k|{ 2278| 104k| yaml_char_t *handle_value = NULL; 2279| 104k| yaml_char_t *prefix_value = NULL; 2280| | 2281| | /* Eat whitespaces. */ 2282| | 2283| 104k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 104k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 104k, False: 0] | | ------------------ | | 494| 104k| ? 1 \ | | 495| 104k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2283:9): [True: 0, False: 104k] ------------------ 2284| | 2285| 1.12M| while (IS_BLANK(parser->buffer)) { 2286| 1.12M| SKIP(parser); ------------------ | | 502| 1.12M| (parser->mark.index ++, \ | | 503| 1.12M| parser->mark.column ++, \ | | 504| 1.12M| parser->unread --, \ | | 505| 1.12M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.12M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.12M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.12M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.12M| ((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.12M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.12M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.12M, False: 87] | | ------------------ | | 494| 1.12M| ? 1 \ | | 495| 1.12M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2287:13): [True: 1, False: 1.12M] ------------------ 2288| 1.12M| } 2289| | 2290| | /* Scan a handle. */ 2291| | 2292| 104k| if (!yaml_parser_scan_tag_handle(parser, 1, start_mark, &handle_value)) ------------------ | Branch (2292:9): [True: 43, False: 104k] ------------------ 2293| 43| goto error; 2294| | 2295| | /* Expect a whitespace. */ 2296| | 2297| 104k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 104k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 104k, False: 35] | | ------------------ | | 494| 104k| ? 1 \ | | 495| 104k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2297:9): [True: 1, False: 104k] ------------------ 2298| | 2299| 104k| if (!IS_BLANK(parser->buffer)) { ------------------ | | 323| 104k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 104k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 104k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 209k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 104k, False: 743] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 743|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 743| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 726, False: 17] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2300| 17| yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 2301| 17| start_mark, "did not find expected whitespace"); 2302| 17| goto error; 2303| 17| } 2304| | 2305| | /* Eat whitespaces. */ 2306| | 2307| 1.10M| while (IS_BLANK(parser->buffer)) { 2308| 1.10M| SKIP(parser); ------------------ | | 502| 1.10M| (parser->mark.index ++, \ | | 503| 1.10M| parser->mark.column ++, \ | | 504| 1.10M| parser->unread --, \ | | 505| 1.10M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.10M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.10M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.10M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.10M| ((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.10M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.10M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.10M, False: 94] | | ------------------ | | 494| 1.10M| ? 1 \ | | 495| 1.10M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2309:13): [True: 1, False: 1.10M] ------------------ 2310| 1.10M| } 2311| | 2312| | /* Scan a prefix. */ 2313| | 2314| 104k| if (!yaml_parser_scan_tag_uri(parser, 1, 1, NULL, start_mark, &prefix_value)) ------------------ | Branch (2314:9): [True: 35, False: 104k] ------------------ 2315| 35| goto error; 2316| | 2317| | /* Expect a whitespace or line break. */ 2318| | 2319| 104k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 104k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 104k, False: 0] | | ------------------ | | 494| 104k| ? 1 \ | | 495| 104k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2319:9): [True: 0, False: 104k] ------------------ 2320| | 2321| 104k| if (!IS_BLANKZ(parser->buffer)) { ------------------ | | 373| 104k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 104k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 209k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 104k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 209k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 9.97k, False: 94.7k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 94.7k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 94.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 215, False: 94.5k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 94.5k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 189k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 189k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.15k, False: 93.4k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 94.5k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 187k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 92.8k, False: 601] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 94.5k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 1.20k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 405] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 601| && 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| 94.5k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 812| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 278, False: 128] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 406| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 684| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 272, False: 6] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 406| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 272| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 201, False: 71] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 189k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 410| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 77, False: 128] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 205| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 282| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 71, False: 6] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 205| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 71| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 67, False: 4] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 138|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 138| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 113, False: 25] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2322| 25| yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 2323| 25| start_mark, "did not find expected whitespace or line break"); 2324| 25| goto error; 2325| 25| } 2326| | 2327| 104k| *handle = handle_value; 2328| 104k| *prefix = prefix_value; 2329| | 2330| 104k| return 1; 2331| | 2332| 123|error: 2333| 123| yaml_free(handle_value); 2334| 123| yaml_free(prefix_value); 2335| 123| return 0; 2336| 104k|} scanner.c:yaml_parser_scan_tag_handle: 2524| 118k|{ 2525| 118k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 118k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2526| | 2527| 118k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 118k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 118k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 118k, False: 0] | | ------------------ | | 134| 118k| ((string).pointer = (string).start, \ | | 135| 118k| (string).end = (string).start+(size), \ | | 136| 118k| memset((string).start, 0, (size)), \ | | 137| 118k| 1) : \ | | 138| 118k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2527:9): [True: 0, False: 118k] ------------------ 2528| | 2529| | /* Check the initial '!' character. */ 2530| | 2531| 118k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 118k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 118k, False: 0] | | ------------------ | | 494| 118k| ? 1 \ | | 495| 118k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2531:9): [True: 0, False: 118k] ------------------ 2532| | 2533| 118k| if (!CHECK(parser->buffer, '!')) { ------------------ | | 181| 118k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 118k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2533:9): [True: 40, False: 118k] ------------------ 2534| 40| yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2534:47): [True: 40, False: 0] ------------------ 2535| 40| "while scanning a tag directive" : "while scanning a tag", 2536| 40| start_mark, "did not find expected '!'"); 2537| 40| goto error; 2538| 40| } 2539| | 2540| | /* Copy the '!' character. */ 2541| | 2542| 118k| if (!READ(parser, string)) goto error; ------------------ | | 526| 118k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 118k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 118k, False: 0] | | | | | Branch (146:7): [True: 118k, False: 0] | | | | ------------------ | | | | 147| 118k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 118k| 1 : \ | | | | 150| 118k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 118k| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 118k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 118k, False: 0] | | | | ------------------ | | | | 399| 118k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 118k| (*(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| 118k| parser->mark.index ++, \ | | 529| 118k| parser->mark.column ++, \ | | 530| 118k| parser->unread --, \ | | 531| 118k| 1) : 0) ------------------ | Branch (2542:9): [True: 0, False: 118k] ------------------ 2543| | 2544| | /* Copy all subsequent alphabetical and numerical characters. */ 2545| | 2546| 118k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 118k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 118k, False: 44] | | ------------------ | | 494| 118k| ? 1 \ | | 495| 118k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2546:9): [True: 1, False: 118k] ------------------ 2547| | 2548| 118k| while (IS_ALPHA(parser->buffer)) 2549| 8.09M| { 2550| 8.09M| if (!READ(parser, string)) goto error; ------------------ | | 526| 8.09M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 8.09M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 8.09M, False: 0] | | | | | Branch (146:7): [True: 8.08M, False: 1.63k] | | | | ------------------ | | | | 147| 8.09M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 1.63k, False: 0] | | | | ------------------ | | | | 148| 1.63k| &(string).pointer, &(string).end)) ? \ | | | | 149| 8.09M| 1 : \ | | | | 150| 8.09M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 8.09M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 8.09M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 8.09M, False: 0] | | | | ------------------ | | | | 399| 8.09M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 8.09M| (*(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.09M| parser->mark.index ++, \ | | 529| 8.09M| parser->mark.column ++, \ | | 530| 8.09M| parser->unread --, \ | | 531| 8.09M| 1) : 0) ------------------ | Branch (2550:13): [True: 0, False: 8.09M] ------------------ 2551| 8.09M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 8.09M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 8.08M, False: 559] | | ------------------ | | 494| 8.09M| ? 1 \ | | 495| 8.09M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2551:13): [True: 1, False: 8.09M] ------------------ 2552| 8.09M| } 2553| | 2554| | /* Check if the trailing character is '!' and copy it. */ 2555| | 2556| 118k| if (CHECK(parser->buffer, '!')) ------------------ | | 181| 118k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 118k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 98.5k, False: 20.3k] | | ------------------ ------------------ 2557| 98.5k| { 2558| 98.5k| if (!READ(parser, string)) goto error; ------------------ | | 526| 98.5k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 98.5k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 98.5k, False: 0] | | | | | Branch (146:7): [True: 98.4k, False: 96] | | | | ------------------ | | | | 147| 98.5k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 96, False: 0] | | | | ------------------ | | | | 148| 96| &(string).pointer, &(string).end)) ? \ | | | | 149| 98.5k| 1 : \ | | | | 150| 98.5k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 98.5k| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 98.5k| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 98.5k, False: 0] | | | | ------------------ | | | | 399| 98.5k| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 98.5k| (*(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| 98.5k| parser->mark.index ++, \ | | 529| 98.5k| parser->mark.column ++, \ | | 530| 98.5k| parser->unread --, \ | | 531| 98.5k| 1) : 0) ------------------ | Branch (2558:13): [True: 0, False: 98.5k] ------------------ 2559| 98.5k| } 2560| 20.3k| else 2561| 20.3k| { 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| 20.3k| if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) { ------------------ | Branch (2568:13): [True: 9.61k, False: 10.7k] | Branch (2568:28): [True: 9.61k, False: 0] | Branch (2568:54): [True: 9.61k, False: 2] ------------------ 2569| 2| yaml_parser_set_scanner_error(parser, "while parsing a tag directive", 2570| 2| start_mark, "did not find expected '!'"); 2571| 2| goto error; 2572| 2| } 2573| 20.3k| } 2574| | 2575| 118k| *handle = string.start; 2576| | 2577| 118k| return 1; 2578| | 2579| 44|error: 2580| 44| STRING_DEL(parser, string); ------------------ | | 142| 44| (yaml_free((string).start), \ | | 143| 44| (string).start = (string).pointer = (string).end = 0) ------------------ 2581| 44| return 0; 2582| 118k|} scanner.c:yaml_parser_scan_tag_uri: 2591| 121k|{ 2592| 121k| size_t length = head ? strlen((char *)head) : 0; ------------------ | Branch (2592:21): [True: 10.7k, False: 111k] ------------------ 2593| 121k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 121k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2594| | 2595| 121k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 121k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 121k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 121k, False: 0] | | ------------------ | | 134| 121k| ((string).pointer = (string).start, \ | | 135| 121k| (string).end = (string).start+(size), \ | | 136| 121k| memset((string).start, 0, (size)), \ | | 137| 121k| 1) : \ | | 138| 121k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2595:9): [True: 0, False: 121k] ------------------ 2596| | 2597| | /* Resize the string to include the head. */ 2598| | 2599| 122k| while ((size_t)(string.end - string.start) <= length) { ------------------ | Branch (2599:12): [True: 968, False: 121k] ------------------ 2600| 968| if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) { ------------------ | Branch (2600:13): [True: 0, False: 968] ------------------ 2601| 0| parser->error = YAML_MEMORY_ERROR; 2602| 0| goto error; 2603| 0| } 2604| 968| } 2605| | 2606| | /* 2607| | * Copy the head if needed. 2608| | * 2609| | * Note that we don't copy the leading '!' character. 2610| | */ 2611| | 2612| 121k| if (length > 1) { ------------------ | Branch (2612:9): [True: 4.68k, False: 117k] ------------------ 2613| 4.68k| memcpy(string.start, head+1, length-1); 2614| 4.68k| string.pointer += length-1; 2615| 4.68k| } 2616| | 2617| | /* Scan the tag. */ 2618| | 2619| 121k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 121k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 121k, False: 10] | | ------------------ | | 494| 121k| ? 1 \ | | 495| 121k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2619:9): [True: 1, False: 121k] ------------------ 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| 19.2M| while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';') ------------------ | | 198| 19.2M|#define IS_ALPHA(string) IS_ALPHA_AT((string),0) | | ------------------ | | | | 189| 38.4M| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (189:8): [True: 5.67M, False: 13.5M] | | | | ------------------ | | | | 190| 19.2M| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | | | ------------------ | | | | | Branch (190:8): [True: 772k, False: 4.90M] | | | | ------------------ | | | | 191| 19.2M| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | | | ------------------ | | | | | Branch (191:8): [True: 4.83M, False: 13.6M] | | | | ------------------ | | | | 192| 18.4M| (string).pointer[offset] <= (yaml_char_t) 'Z') || \ | | | | ------------------ | | | | | Branch (192:8): [True: 1.25M, False: 3.57M] | | | | ------------------ | | | | 193| 19.2M| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | | | ------------------ | | | | | Branch (193:8): [True: 3.55M, False: 13.6M] | | | | ------------------ | | | | 194| 17.1M| (string).pointer[offset] <= (yaml_char_t) 'z') || \ | | | | ------------------ | | | | | Branch (194:8): [True: 3.55M, False: 1.72k] | | | | ------------------ | | | | 195| 19.2M| (string).pointer[offset] == '_' || \ | | | | ------------------ | | | | | Branch (195:7): [True: 6.97k, False: 13.6M] | | | | ------------------ | | | | 196| 38.4M| (string).pointer[offset] == '-') | | | | ------------------ | | | | | Branch (196:7): [True: 49.8k, False: 13.5M] | | | | ------------------ | | ------------------ ------------------ while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';') ------------------ | | 181| 32.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.20k, False: 13.5M] | | ------------------ ------------------ 2633| 13.5M| || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?') ------------------ | | 181| 32.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 17.1k, False: 13.5M] | | ------------------ ------------------ || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 13.4k, False: 13.5M] | | ------------------ ------------------ 2634| 13.5M| || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 31.5k, False: 13.5M] | | ------------------ ------------------ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.49k, False: 13.5M] | | ------------------ ------------------ 2635| 13.5M| || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 7.33k, False: 13.5M] | | ------------------ ------------------ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.45k, False: 13.4M] | | ------------------ ------------------ 2636| 13.4M| || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3.11k, False: 13.4M] | | ------------------ ------------------ || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 10.8k, False: 13.4M] | | ------------------ ------------------ 2637| 13.4M| || CHECK(parser->buffer, '.') || CHECK(parser->buffer, '%') ------------------ | | 181| 32.7M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 14.6k, False: 13.4M] | | ------------------ ------------------ || CHECK(parser->buffer, '.') || CHECK(parser->buffer, '%') ------------------ | | 181| 32.6M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.4M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 333k, False: 13.1M] | | ------------------ ------------------ 2638| 13.1M| || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~') ------------------ | | 181| 32.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 13.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.9M, False: 182k] | | ------------------ ------------------ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~') ------------------ | | 181| 19.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 182k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 612, False: 181k] | | ------------------ ------------------ 2639| 181k| || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'') ------------------ | | 181| 19.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 181k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 13.4k, False: 168k] | | ------------------ ------------------ || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'') ------------------ | | 181| 19.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 168k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 7.33k, False: 160k] | | ------------------ ------------------ 2640| 160k| || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')') ------------------ | | 181| 19.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 160k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.93k, False: 154k] | | ------------------ ------------------ || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')') ------------------ | | 181| 19.3M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 154k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 6.65k, False: 147k] | | ------------------ ------------------ 2641| 147k| || (uri_char && ( ------------------ | Branch (2641:17): [True: 133k, False: 13.9k] ------------------ 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: 10.5k, False: 122k] | | ------------------ ------------------ 2643| 122k| || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') ------------------ | | 181| 256k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 122k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 9.28k, False: 113k] | | ------------------ ------------------ || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') ------------------ | | 181| 113k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 113k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.78k, False: 107k] | | ------------------ ------------------ 2644| 133k| ) 2645| 147k| )) 2646| 19.1M| { 2647| | /* Check if it is a URI-escape sequence. */ 2648| | 2649| 19.1M| if (CHECK(parser->buffer, '%')) { ------------------ | | 181| 19.1M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 19.1M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 333k, False: 18.7M] | | ------------------ ------------------ 2650| 333k| if (!STRING_EXTEND(parser, string)) ------------------ | | 146| 333k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 332k, False: 367] | | ------------------ | | 147| 333k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 367, False: 0] | | ------------------ | | 148| 367| &(string).pointer, &(string).end)) ? \ | | 149| 333k| 1 : \ | | 150| 333k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (2650:17): [True: 0, False: 333k] ------------------ 2651| 0| goto error; 2652| | 2653| 333k| if (!yaml_parser_scan_uri_escapes(parser, ------------------ | Branch (2653:17): [True: 115, False: 333k] ------------------ 2654| 333k| directive, start_mark, &string)) goto error; 2655| 333k| } 2656| 18.7M| else { 2657| 18.7M| if (!READ(parser, string)) goto error; ------------------ | | 526| 18.7M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 18.7M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 18.7M, False: 0] | | | | | Branch (146:7): [True: 18.7M, False: 6.91k] | | | | ------------------ | | | | 147| 18.7M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 6.91k, False: 0] | | | | ------------------ | | | | 148| 6.91k| &(string).pointer, &(string).end)) ? \ | | | | 149| 18.7M| 1 : \ | | | | 150| 18.7M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 18.7M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 18.7M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 18.7M, False: 0] | | | | ------------------ | | | | 399| 18.7M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 18.7M| (*(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| 18.7M| parser->mark.index ++, \ | | 529| 18.7M| parser->mark.column ++, \ | | 530| 18.7M| parser->unread --, \ | | 531| 18.7M| 1) : 0) ------------------ | Branch (2657:17): [True: 0, False: 18.7M] ------------------ 2658| 18.7M| } 2659| | 2660| 19.1M| length ++; 2661| 19.1M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 19.1M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 19.1M, False: 1.50k] | | ------------------ | | 494| 19.1M| ? 1 \ | | 495| 19.1M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2661:13): [True: 2, False: 19.1M] ------------------ 2662| 19.1M| } 2663| | 2664| | /* Check if the tag is non-empty. */ 2665| | 2666| 121k| if (!length) { ------------------ | Branch (2666:9): [True: 66, False: 121k] ------------------ 2667| 66| if (!STRING_EXTEND(parser, string)) ------------------ | | 146| 66| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 66, False: 0] | | ------------------ | | 147| 66| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 0, False: 0] | | ------------------ | | 148| 0| &(string).pointer, &(string).end)) ? \ | | 149| 66| 1 : \ | | 150| 66| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (2667:13): [True: 0, False: 66] ------------------ 2668| 0| goto error; 2669| | 2670| 66| yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2670:47): [True: 34, False: 32] ------------------ 2671| 34| "while parsing a %TAG directive" : "while parsing a tag", 2672| 66| start_mark, "did not find expected tag URI"); 2673| 66| goto error; 2674| 66| } 2675| | 2676| 121k| *uri = string.start; 2677| | 2678| 121k| return 1; 2679| | 2680| 184|error: 2681| 184| STRING_DEL(parser, string); ------------------ | | 142| 184| (yaml_free((string).start), \ | | 143| 184| (string).start = (string).pointer = (string).end = 0) ------------------ 2682| 184| return 0; 2683| 121k|} scanner.c:yaml_parser_scan_uri_escapes: 2692| 333k|{ 2693| 333k| int width = 0; 2694| | 2695| | /* Decode the required number of characters. */ 2696| | 2697| 336k| do { 2698| | 2699| 336k| unsigned char octet = 0; 2700| | 2701| | /* Check for a URI-escaped octet. */ 2702| | 2703| 336k| if (!CACHE(parser, 3)) return 0; ------------------ | | 493| 336k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 335k, False: 126] | | ------------------ | | 494| 336k| ? 1 \ | | 495| 336k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2703:13): [True: 1, False: 336k] ------------------ 2704| | 2705| 336k| if (!(CHECK(parser->buffer, '%') ------------------ | | 181| 672k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 336k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 336k, False: 25] | | ------------------ ------------------ 2706| 336k| && IS_HEX_AT(parser->buffer, 1) ------------------ | | 224| 672k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | ------------------ | | | Branch (224:8): [True: 335k, False: 28] | | ------------------ | | 225| 336k| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | ------------------ | | | Branch (225:8): [True: 331k, False: 4.28k] | | ------------------ | | 226| 336k| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (226:8): [True: 4.28k, False: 30] | | ------------------ | | 227| 4.31k| (string).pointer[offset] <= (yaml_char_t) 'F') || \ | | ------------------ | | | Branch (227:8): [True: 2.38k, False: 1.89k] | | ------------------ | | 228| 672k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (228:8): [True: 1.89k, False: 34] | | ------------------ | | 229| 1.92k| (string).pointer[offset] <= (yaml_char_t) 'f')) | | ------------------ | | | Branch (229:8): [True: 1.88k, False: 6] | | ------------------ ------------------ 2707| 335k| && IS_HEX_AT(parser->buffer, 2))) { ------------------ | | 224| 335k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | ------------------ | | | Branch (224:8): [True: 335k, False: 27] | | ------------------ | | 225| 335k| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | ------------------ | | | Branch (225:8): [True: 1.51k, False: 334k] | | ------------------ | | 226| 335k| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (226:8): [True: 334k, False: 29] | | ------------------ | | 227| 334k| (string).pointer[offset] <= (yaml_char_t) 'F') || \ | | ------------------ | | | Branch (227:8): [True: 2.06k, False: 332k] | | ------------------ | | 228| 335k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (228:8): [True: 332k, False: 32] | | ------------------ | | 229| 332k| (string).pointer[offset] <= (yaml_char_t) 'f')) | | ------------------ | | | Branch (229:8): [True: 332k, False: 7] | | ------------------ ------------------ 2708| 104| return yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2708:58): [True: 1, False: 103] ------------------ 2709| 103| "while parsing a %TAG directive" : "while parsing a tag", 2710| 104| start_mark, "did not find URI escaped octet"); 2711| 104| } 2712| | 2713| | /* Get the octet. */ 2714| | 2715| 335k| octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2); ------------------ | | 238| 335k| (((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (238:9): [True: 4.24k, False: 331k] | | ------------------ | | 239| 335k| (string).pointer[offset] <= (yaml_char_t) 'F') ? \ | | ------------------ | | | Branch (239:9): [True: 2.36k, False: 1.87k] | | ------------------ | | 240| 335k| ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ | | 241| 335k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (241:9): [True: 1.87k, False: 331k] | | ------------------ | | 242| 333k| (string).pointer[offset] <= (yaml_char_t) 'f') ? \ | | ------------------ | | | Branch (242:9): [True: 1.87k, False: 0] | | ------------------ | | 243| 333k| ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ | | 244| 333k| ((string).pointer[offset] - (yaml_char_t) '0')) ------------------ octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2); ------------------ | | 238| 335k| (((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (238:9): [True: 334k, False: 1.51k] | | ------------------ | | 239| 335k| (string).pointer[offset] <= (yaml_char_t) 'F') ? \ | | ------------------ | | | Branch (239:9): [True: 2.06k, False: 332k] | | ------------------ | | 240| 335k| ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ | | 241| 335k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (241:9): [True: 332k, False: 1.51k] | | ------------------ | | 242| 333k| (string).pointer[offset] <= (yaml_char_t) 'f') ? \ | | ------------------ | | | Branch (242:9): [True: 332k, False: 0] | | ------------------ | | 243| 333k| ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ | | 244| 333k| ((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| 335k| if (!width) ------------------ | Branch (2719:13): [True: 333k, False: 2.73k] ------------------ 2720| 333k| { 2721| 333k| width = (octet & 0x80) == 0x00 ? 1 : ------------------ | Branch (2721:21): [True: 331k, False: 1.53k] ------------------ 2722| 333k| (octet & 0xE0) == 0xC0 ? 2 : ------------------ | Branch (2722:21): [True: 658, False: 876] ------------------ 2723| 1.53k| (octet & 0xF0) == 0xE0 ? 3 : ------------------ | Branch (2723:21): [True: 470, False: 406] ------------------ 2724| 876| (octet & 0xF8) == 0xF0 ? 4 : 0; ------------------ | Branch (2724:21): [True: 400, False: 6] ------------------ 2725| 333k| if (!width) { ------------------ | Branch (2725:17): [True: 6, False: 333k] ------------------ 2726| 6| return yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2726:62): [True: 0, False: 6] ------------------ 2727| 6| "while parsing a %TAG directive" : "while parsing a tag", 2728| 6| start_mark, "found an incorrect leading UTF-8 octet"); 2729| 6| } 2730| 333k| } 2731| 2.73k| else 2732| 2.73k| { 2733| | /* Check if the trailing octet is correct. */ 2734| | 2735| 2.73k| if ((octet & 0xC0) != 0x80) { ------------------ | Branch (2735:17): [True: 4, False: 2.73k] ------------------ 2736| 4| return yaml_parser_set_scanner_error(parser, directive ? ------------------ | Branch (2736:62): [True: 0, False: 4] ------------------ 2737| 4| "while parsing a %TAG directive" : "while parsing a tag", 2738| 4| start_mark, "found an incorrect trailing UTF-8 octet"); 2739| 4| } 2740| 2.73k| } 2741| | 2742| | /* Copy the octet and move the pointers. */ 2743| | 2744| 335k| *(string->pointer++) = octet; 2745| 335k| SKIP(parser); ------------------ | | 502| 335k| (parser->mark.index ++, \ | | 503| 335k| parser->mark.column ++, \ | | 504| 335k| parser->unread --, \ | | 505| 335k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 335k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 335k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 335k, False: 0] | | | | | | ------------------ | | | | | | 381| 335k| ((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| 335k| SKIP(parser); ------------------ | | 502| 335k| (parser->mark.index ++, \ | | 503| 335k| parser->mark.column ++, \ | | 504| 335k| parser->unread --, \ | | 505| 335k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 335k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 335k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 335k, False: 0] | | | | | | ------------------ | | | | | | 381| 335k| ((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| 335k| SKIP(parser); ------------------ | | 502| 335k| (parser->mark.index ++, \ | | 503| 335k| parser->mark.column ++, \ | | 504| 335k| parser->unread --, \ | | 505| 335k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 335k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 335k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 335k, False: 0] | | | | | | ------------------ | | | | | | 381| 335k| ((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| 335k| } while (--width); ------------------ | Branch (2749:14): [True: 2.77k, False: 333k] ------------------ 2750| | 2751| 333k| return 1; 2752| 333k|} scanner.c:yaml_parser_fetch_document_indicator: 1424| 54.7k|{ 1425| 54.7k| yaml_mark_t start_mark, end_mark; 1426| 54.7k| yaml_token_t token; 1427| | 1428| | /* Reset the indentation level. */ 1429| | 1430| 54.7k| if (!yaml_parser_unroll_indent(parser, -1)) ------------------ | Branch (1430:9): [True: 0, False: 54.7k] ------------------ 1431| 0| return 0; 1432| | 1433| | /* Reset simple keys. */ 1434| | 1435| 54.7k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1435:9): [True: 0, False: 54.7k] ------------------ 1436| 0| return 0; 1437| | 1438| 54.7k| parser->simple_key_allowed = 0; 1439| | 1440| | /* Consume the token. */ 1441| | 1442| 54.7k| start_mark = parser->mark; 1443| | 1444| 54.7k| SKIP(parser); ------------------ | | 502| 54.7k| (parser->mark.index ++, \ | | 503| 54.7k| parser->mark.column ++, \ | | 504| 54.7k| parser->unread --, \ | | 505| 54.7k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 54.7k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 54.7k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 54.7k, False: 0] | | | | | | ------------------ | | | | | | 381| 54.7k| ((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| 54.7k| SKIP(parser); ------------------ | | 502| 54.7k| (parser->mark.index ++, \ | | 503| 54.7k| parser->mark.column ++, \ | | 504| 54.7k| parser->unread --, \ | | 505| 54.7k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 54.7k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 54.7k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 54.7k, False: 0] | | | | | | ------------------ | | | | | | 381| 54.7k| ((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| 54.7k| SKIP(parser); ------------------ | | 502| 54.7k| (parser->mark.index ++, \ | | 503| 54.7k| parser->mark.column ++, \ | | 504| 54.7k| parser->unread --, \ | | 505| 54.7k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 54.7k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 54.7k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 54.7k, False: 0] | | | | | | ------------------ | | | | | | 381| 54.7k| ((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| 54.7k| end_mark = parser->mark; 1449| | 1450| | /* Create the DOCUMENT-START or DOCUMENT-END token. */ 1451| | 1452| 54.7k| TOKEN_INIT(token, type, start_mark, end_mark); ------------------ | | 500| 54.7k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 54.7k| (token).type = (token_type), \ | | 502| 54.7k| (token).start_mark = (token_start_mark), \ | | 503| 54.7k| (token).end_mark = (token_end_mark)) ------------------ 1453| | 1454| | /* Append the token to the queue. */ 1455| | 1456| 54.7k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 54.7k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 52.9k, False: 1.88k] | | ------------------ | | 473| 54.7k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.88k, False: 0] | | ------------------ | | 474| 1.88k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 54.7k| (*((queue).tail++) = value, \ | | 476| 54.7k| 1) : \ | | 477| 54.7k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1456:9): [True: 0, False: 54.7k] ------------------ 1457| 0| return 0; 1458| | 1459| 54.7k| return 1; 1460| 54.7k|} scanner.c:yaml_parser_fetch_flow_collection_start: 1469| 111k|{ 1470| 111k| yaml_mark_t start_mark, end_mark; 1471| 111k| yaml_token_t token; 1472| | 1473| | /* The indicators '[' and '{' may start a simple key. */ 1474| | 1475| 111k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1475:9): [True: 0, False: 111k] ------------------ 1476| 0| return 0; 1477| | 1478| | /* Increase the flow level. */ 1479| | 1480| 111k| if (!yaml_parser_increase_flow_level(parser)) ------------------ | Branch (1480:9): [True: 2, False: 111k] ------------------ 1481| 2| return 0; 1482| | 1483| | /* A simple key may follow the indicators '[' and '{'. */ 1484| | 1485| 111k| parser->simple_key_allowed = 1; 1486| | 1487| | /* Consume the token. */ 1488| | 1489| 111k| start_mark = parser->mark; 1490| 111k| SKIP(parser); ------------------ | | 502| 111k| (parser->mark.index ++, \ | | 503| 111k| parser->mark.column ++, \ | | 504| 111k| parser->unread --, \ | | 505| 111k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 111k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 111k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 111k, False: 0] | | | | | | ------------------ | | | | | | 381| 111k| ((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| 111k| end_mark = parser->mark; 1492| | 1493| | /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */ 1494| | 1495| 111k| TOKEN_INIT(token, type, start_mark, end_mark); ------------------ | | 500| 111k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 111k| (token).type = (token_type), \ | | 502| 111k| (token).start_mark = (token_start_mark), \ | | 503| 111k| (token).end_mark = (token_end_mark)) ------------------ 1496| | 1497| | /* Append the token to the queue. */ 1498| | 1499| 111k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 111k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 109k, False: 1.87k] | | ------------------ | | 473| 111k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.87k, False: 0] | | ------------------ | | 474| 1.87k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 111k| (*((queue).tail++) = value, \ | | 476| 111k| 1) : \ | | 477| 111k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1499:9): [True: 0, False: 111k] ------------------ 1500| 0| return 0; 1501| | 1502| 111k| return 1; 1503| 111k|} scanner.c:yaml_parser_save_simple_key: 1105| 3.83M|{ 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.83M| int required = (!parser->flow_level ------------------ | Branch (1112:21): [True: 1.02M, False: 2.80M] ------------------ 1113| 1.02M| && parser->indent == (ptrdiff_t)parser->mark.column); ------------------ | Branch (1113:16): [True: 108k, False: 920k] ------------------ 1114| | 1115| | /* 1116| | * If the current position may start a simple key, save it. 1117| | */ 1118| | 1119| 3.83M| if (parser->simple_key_allowed) ------------------ | Branch (1119:9): [True: 3.75M, False: 78.7k] ------------------ 1120| 3.75M| { 1121| 3.75M| yaml_simple_key_t simple_key; 1122| 3.75M| simple_key.possible = 1; 1123| 3.75M| simple_key.required = required; 1124| 3.75M| simple_key.token_number = 1125| 3.75M| parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head); 1126| 3.75M| simple_key.mark = parser->mark; 1127| | 1128| 3.75M| if (!yaml_parser_remove_simple_key(parser)) return 0; ------------------ | Branch (1128:13): [True: 0, False: 3.75M] ------------------ 1129| | 1130| 3.75M| *(parser->simple_keys.top-1) = simple_key; 1131| 3.75M| } 1132| | 1133| 3.83M| return 1; 1134| 3.83M|} scanner.c:yaml_parser_increase_flow_level: 1169| 111k|{ 1170| 111k| 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| 111k| if (!PUSH(parser, parser->simple_keys, empty_simple_key)) ------------------ | | 445| 111k| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 110k, False: 1.23k] | | ------------------ | | 446| 111k| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.23k, False: 0] | | ------------------ | | 447| 1.23k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 111k| (*((stack).top++) = value, \ | | 449| 111k| 1) : \ | | 450| 111k| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1174:9): [True: 0, False: 111k] ------------------ 1175| 0| return 0; 1176| | 1177| | /* Increase the flow level. */ 1178| | 1179| 111k| if (parser->flow_level == INT_MAX) { ------------------ | Branch (1179:9): [True: 0, False: 111k] ------------------ 1180| 0| parser->error = YAML_MEMORY_ERROR; 1181| 0| return 0; 1182| 0| } 1183| | 1184| 111k| if (!STACK_LIMIT(parser, parser->indents, MAX_NESTING_LEVEL - parser->flow_level)) { ------------------ | | 439| 111k| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 111k, False: 2] | | ------------------ | | 440| 111k| 1 : \ | | 441| 111k| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 2| 0)) ------------------ | Branch (1184:9): [True: 2, False: 111k] ------------------ 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| 111k| parser->flow_level++; 1191| | 1192| 111k| return 1; 1193| 111k|} scanner.c:yaml_parser_fetch_flow_collection_end: 1512| 75.2k|{ 1513| 75.2k| yaml_mark_t start_mark, end_mark; 1514| 75.2k| yaml_token_t token; 1515| | 1516| | /* Reset any potential simple key on the current flow level. */ 1517| | 1518| 75.2k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1518:9): [True: 1, False: 75.2k] ------------------ 1519| 1| return 0; 1520| | 1521| | /* Decrease the flow level. */ 1522| | 1523| 75.2k| if (!yaml_parser_decrease_flow_level(parser)) ------------------ | Branch (1523:9): [True: 0, False: 75.2k] ------------------ 1524| 0| return 0; 1525| | 1526| | /* No simple keys after the indicators ']' and '}'. */ 1527| | 1528| 75.2k| parser->simple_key_allowed = 0; 1529| | 1530| | /* Consume the token. */ 1531| | 1532| 75.2k| start_mark = parser->mark; 1533| 75.2k| SKIP(parser); ------------------ | | 502| 75.2k| (parser->mark.index ++, \ | | 503| 75.2k| parser->mark.column ++, \ | | 504| 75.2k| parser->unread --, \ | | 505| 75.2k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 75.2k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 75.2k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 75.2k, False: 0] | | | | | | ------------------ | | | | | | 381| 75.2k| ((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| 75.2k| end_mark = parser->mark; 1535| | 1536| | /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */ 1537| | 1538| 75.2k| TOKEN_INIT(token, type, start_mark, end_mark); ------------------ | | 500| 75.2k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 75.2k| (token).type = (token_type), \ | | 502| 75.2k| (token).start_mark = (token_start_mark), \ | | 503| 75.2k| (token).end_mark = (token_end_mark)) ------------------ 1539| | 1540| | /* Append the token to the queue. */ 1541| | 1542| 75.2k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 75.2k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 74.5k, False: 746] | | ------------------ | | 473| 75.2k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 746, False: 0] | | ------------------ | | 474| 746| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 75.2k| (*((queue).tail++) = value, \ | | 476| 75.2k| 1) : \ | | 477| 75.2k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1542:9): [True: 0, False: 75.2k] ------------------ 1543| 0| return 0; 1544| | 1545| 75.2k| return 1; 1546| 75.2k|} scanner.c:yaml_parser_decrease_flow_level: 1201| 75.2k|{ 1202| 75.2k| if (parser->flow_level) { ------------------ | Branch (1202:9): [True: 75.2k, False: 74] ------------------ 1203| 75.2k| parser->flow_level --; 1204| 75.2k| (void)POP(parser, parser->simple_keys); ------------------ | | 454| 75.2k| (*(--(stack).top)) ------------------ 1205| 75.2k| } 1206| | 1207| 75.2k| return 1; 1208| 75.2k|} scanner.c:yaml_parser_fetch_flow_entry: 1554| 2.72M|{ 1555| 2.72M| yaml_mark_t start_mark, end_mark; 1556| 2.72M| yaml_token_t token; 1557| | 1558| | /* Reset any potential simple keys on the current flow level. */ 1559| | 1560| 2.72M| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1560:9): [True: 1, False: 2.72M] ------------------ 1561| 1| return 0; 1562| | 1563| | /* Simple keys are allowed after ','. */ 1564| | 1565| 2.72M| parser->simple_key_allowed = 1; 1566| | 1567| | /* Consume the token. */ 1568| | 1569| 2.72M| start_mark = parser->mark; 1570| 2.72M| SKIP(parser); ------------------ | | 502| 2.72M| (parser->mark.index ++, \ | | 503| 2.72M| parser->mark.column ++, \ | | 504| 2.72M| parser->unread --, \ | | 505| 2.72M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.72M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.72M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.72M, False: 0] | | | | | | ------------------ | | | | | | 381| 2.72M| ((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| 2.72M| end_mark = parser->mark; 1572| | 1573| | /* Create the FLOW-ENTRY token and append it to the queue. */ 1574| | 1575| 2.72M| TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark); ------------------ | | 500| 2.72M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 2.72M| (token).type = (token_type), \ | | 502| 2.72M| (token).start_mark = (token_start_mark), \ | | 503| 2.72M| (token).end_mark = (token_end_mark)) ------------------ 1576| | 1577| 2.72M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 2.72M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 2.72M, False: 1.78k] | | ------------------ | | 473| 2.72M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.78k, False: 0] | | ------------------ | | 474| 1.78k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 2.72M| (*((queue).tail++) = value, \ | | 476| 2.72M| 1) : \ | | 477| 2.72M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1577:9): [True: 0, False: 2.72M] ------------------ 1578| 0| return 0; 1579| | 1580| 2.72M| return 1; 1581| 2.72M|} scanner.c:yaml_parser_fetch_block_entry: 1589| 883k|{ 1590| 883k| yaml_mark_t start_mark, end_mark; 1591| 883k| yaml_token_t token; 1592| | 1593| | /* Check if the scanner is in the block context. */ 1594| | 1595| 883k| if (!parser->flow_level) ------------------ | Branch (1595:9): [True: 883k, False: 670] ------------------ 1596| 883k| { 1597| | /* Check if we are allowed to start a new entry. */ 1598| | 1599| 883k| if (!parser->simple_key_allowed) { ------------------ | Branch (1599:13): [True: 16, False: 883k] ------------------ 1600| 16| return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 1601| 16| "block sequence entries are not allowed in this context"); 1602| 16| } 1603| | 1604| | /* Add the BLOCK-SEQUENCE-START token if needed. */ 1605| | 1606| 883k| if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, ------------------ | Branch (1606:13): [True: 3, False: 883k] ------------------ 1607| 883k| YAML_BLOCK_SEQUENCE_START_TOKEN, parser->mark)) 1608| 3| return 0; 1609| 883k| } 1610| 670| else 1611| 670| { 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| 670| } 1618| | 1619| | /* Reset any potential simple keys on the current flow level. */ 1620| | 1621| 883k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1621:9): [True: 0, False: 883k] ------------------ 1622| 0| return 0; 1623| | 1624| | /* Simple keys are allowed after '-'. */ 1625| | 1626| 883k| parser->simple_key_allowed = 1; 1627| | 1628| | /* Consume the token. */ 1629| | 1630| 883k| start_mark = parser->mark; 1631| 883k| SKIP(parser); ------------------ | | 502| 883k| (parser->mark.index ++, \ | | 503| 883k| parser->mark.column ++, \ | | 504| 883k| parser->unread --, \ | | 505| 883k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 883k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 883k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 883k, False: 0] | | | | | | ------------------ | | | | | | 381| 883k| ((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| 883k| end_mark = parser->mark; 1633| | 1634| | /* Create the BLOCK-ENTRY token and append it to the queue. */ 1635| | 1636| 883k| TOKEN_INIT(token, YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark); ------------------ | | 500| 883k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 883k| (token).type = (token_type), \ | | 502| 883k| (token).start_mark = (token_start_mark), \ | | 503| 883k| (token).end_mark = (token_end_mark)) ------------------ 1637| | 1638| 883k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 883k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 861k, False: 22.4k] | | ------------------ | | 473| 883k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 22.4k, False: 0] | | ------------------ | | 474| 22.4k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 883k| (*((queue).tail++) = value, \ | | 476| 883k| 1) : \ | | 477| 883k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1638:9): [True: 0, False: 883k] ------------------ 1639| 0| return 0; 1640| | 1641| 883k| return 1; 1642| 883k|} scanner.c:yaml_parser_roll_indent: 1220| 3.24M|{ 1221| 3.24M| yaml_token_t token; 1222| | 1223| | /* In the flow context, do nothing. */ 1224| | 1225| 3.24M| if (parser->flow_level) ------------------ | Branch (1225:9): [True: 10.6k, False: 3.23M] ------------------ 1226| 10.6k| return 1; 1227| | 1228| 3.23M| if (parser->indent < column) ------------------ | Branch (1228:9): [True: 2.20M, False: 1.03M] ------------------ 1229| 2.20M| { 1230| | /* 1231| | * Push the current indentation level to the stack and set the new 1232| | * indentation level. 1233| | */ 1234| | 1235| 2.20M| if (!PUSH(parser, parser->indents, parser->indent)) ------------------ | | 445| 2.20M| (((stack).top != (stack).end \ | | ------------------ | | | Branch (445:7): [True: 2.20M, False: 1.96k] | | ------------------ | | 446| 2.20M| || yaml_stack_extend((void **)&(stack).start, \ | | ------------------ | | | Branch (446:10): [True: 1.96k, False: 0] | | ------------------ | | 447| 1.96k| (void **)&(stack).top, (void **)&(stack).end)) ? \ | | 448| 2.20M| (*((stack).top++) = value, \ | | 449| 2.20M| 1) : \ | | 450| 2.20M| ((context)->error = YAML_MEMORY_ERROR, \ | | 451| 0| 0)) ------------------ | Branch (1235:13): [True: 0, False: 2.20M] ------------------ 1236| 0| return 0; 1237| | 1238| 2.20M| if (!STACK_LIMIT(parser, parser->indents, MAX_NESTING_LEVEL - parser->flow_level)) { ------------------ | | 439| 2.20M| ((stack).top - (stack).start < (size) ? \ | | ------------------ | | | Branch (439:6): [True: 2.20M, False: 8] | | ------------------ | | 440| 2.20M| 1 : \ | | 441| 2.20M| ((context)->error = YAML_MEMORY_ERROR, \ | | 442| 8| 0)) ------------------ | Branch (1238:13): [True: 8, False: 2.20M] ------------------ 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.20M| if (column > INT_MAX) { ------------------ | Branch (1244:13): [True: 0, False: 2.20M] ------------------ 1245| 0| parser->error = YAML_MEMORY_ERROR; 1246| 0| return 0; 1247| 0| } 1248| | 1249| 2.20M| parser->indent = column; 1250| | 1251| | /* Create a token and insert it into the queue. */ 1252| | 1253| 2.20M| TOKEN_INIT(token, type, mark, mark); ------------------ | | 500| 2.20M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 2.20M| (token).type = (token_type), \ | | 502| 2.20M| (token).start_mark = (token_start_mark), \ | | 503| 2.20M| (token).end_mark = (token_end_mark)) ------------------ 1254| | 1255| 2.20M| if (number == -1) { ------------------ | Branch (1255:13): [True: 1.38M, False: 824k] ------------------ 1256| 1.38M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 1.38M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 1.33M, False: 42.4k] | | ------------------ | | 473| 1.38M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 42.4k, False: 0] | | ------------------ | | 474| 42.4k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 1.38M| (*((queue).tail++) = value, \ | | 476| 1.38M| 1) : \ | | 477| 1.38M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1256:17): [True: 0, False: 1.38M] ------------------ 1257| 0| return 0; 1258| 1.38M| } 1259| 824k| else { 1260| 824k| if (!QUEUE_INSERT(parser, ------------------ | | 484| 824k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (484:7): [True: 712k, False: 112k] | | ------------------ | | 485| 824k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (485:10): [True: 112k, False: 0] | | ------------------ | | 486| 112k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 487| 824k| (memmove((queue).head+(index)+1,(queue).head+(index), \ | | 488| 824k| ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \ | | 489| 824k| *((queue).head+(index)) = value, \ | | 490| 824k| (queue).tail++, \ | | 491| 824k| 1) : \ | | 492| 824k| ((context)->error = YAML_MEMORY_ERROR, \ | | 493| 0| 0)) ------------------ | Branch (1260:17): [True: 0, False: 824k] ------------------ 1261| 824k| parser->tokens, number - parser->tokens_parsed, token)) 1262| 0| return 0; 1263| 824k| } 1264| 2.20M| } 1265| | 1266| 3.23M| return 1; 1267| 3.23M|} scanner.c:yaml_parser_fetch_key: 1650| 1.51M|{ 1651| 1.51M| yaml_mark_t start_mark, end_mark; 1652| 1.51M| yaml_token_t token; 1653| | 1654| | /* In the block context, additional checks are required. */ 1655| | 1656| 1.51M| if (!parser->flow_level) ------------------ | Branch (1656:9): [True: 1.42M, False: 96.8k] ------------------ 1657| 1.42M| { 1658| | /* Check if we are allowed to start a new key (not necessary simple). */ 1659| | 1660| 1.42M| if (!parser->simple_key_allowed) { ------------------ | Branch (1660:13): [True: 14, False: 1.42M] ------------------ 1661| 14| return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 1662| 14| "mapping keys are not allowed in this context"); 1663| 14| } 1664| | 1665| | /* Add the BLOCK-MAPPING-START token if needed. */ 1666| | 1667| 1.42M| if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, ------------------ | Branch (1667:13): [True: 3, False: 1.42M] ------------------ 1668| 1.42M| YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) 1669| 3| return 0; 1670| 1.42M| } 1671| | 1672| | /* Reset any potential simple keys on the current flow level. */ 1673| | 1674| 1.51M| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1674:9): [True: 0, False: 1.51M] ------------------ 1675| 0| return 0; 1676| | 1677| | /* Simple keys are allowed after '?' in the block context. */ 1678| | 1679| 1.51M| parser->simple_key_allowed = (!parser->flow_level); 1680| | 1681| | /* Consume the token. */ 1682| | 1683| 1.51M| start_mark = parser->mark; 1684| 1.51M| SKIP(parser); ------------------ | | 502| 1.51M| (parser->mark.index ++, \ | | 503| 1.51M| parser->mark.column ++, \ | | 504| 1.51M| parser->unread --, \ | | 505| 1.51M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.51M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.51M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.51M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.51M| ((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.51M| end_mark = parser->mark; 1686| | 1687| | /* Create the KEY token and append it to the queue. */ 1688| | 1689| 1.51M| TOKEN_INIT(token, YAML_KEY_TOKEN, start_mark, end_mark); ------------------ | | 500| 1.51M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 1.51M| (token).type = (token_type), \ | | 502| 1.51M| (token).start_mark = (token_start_mark), \ | | 503| 1.51M| (token).end_mark = (token_end_mark)) ------------------ 1690| | 1691| 1.51M| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 1.51M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 1.50M, False: 15.6k] | | ------------------ | | 473| 1.51M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 15.6k, False: 0] | | ------------------ | | 474| 15.6k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 1.51M| (*((queue).tail++) = value, \ | | 476| 1.51M| 1) : \ | | 477| 1.51M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1691:9): [True: 0, False: 1.51M] ------------------ 1692| 0| return 0; 1693| | 1694| 1.51M| return 1; 1695| 1.51M|} scanner.c:yaml_parser_fetch_value: 1703| 946k|{ 1704| 946k| yaml_mark_t start_mark, end_mark; 1705| 946k| yaml_token_t token; 1706| 946k| yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 1707| | 1708| | /* Have we found a simple key? */ 1709| | 1710| 946k| if (simple_key->possible) ------------------ | Branch (1710:9): [True: 943k, False: 3.64k] ------------------ 1711| 943k| { 1712| | 1713| | /* Create the KEY token and insert it into the queue. */ 1714| | 1715| 943k| TOKEN_INIT(token, YAML_KEY_TOKEN, simple_key->mark, simple_key->mark); ------------------ | | 500| 943k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 943k| (token).type = (token_type), \ | | 502| 943k| (token).start_mark = (token_start_mark), \ | | 503| 943k| (token).end_mark = (token_end_mark)) ------------------ 1716| | 1717| 943k| if (!QUEUE_INSERT(parser, parser->tokens, ------------------ | | 484| 943k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (484:7): [True: 926k, False: 17.0k] | | ------------------ | | 485| 943k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (485:10): [True: 17.0k, False: 0] | | ------------------ | | 486| 17.0k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 487| 943k| (memmove((queue).head+(index)+1,(queue).head+(index), \ | | 488| 943k| ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \ | | 489| 943k| *((queue).head+(index)) = value, \ | | 490| 943k| (queue).tail++, \ | | 491| 943k| 1) : \ | | 492| 943k| ((context)->error = YAML_MEMORY_ERROR, \ | | 493| 0| 0)) ------------------ | Branch (1717:13): [True: 0, False: 943k] ------------------ 1718| 943k| 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| 943k| if (!yaml_parser_roll_indent(parser, simple_key->mark.column, ------------------ | Branch (1723:13): [True: 1, False: 943k] ------------------ 1724| 943k| simple_key->token_number, 1725| 943k| YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark)) 1726| 1| return 0; 1727| | 1728| | /* Remove the simple key. */ 1729| | 1730| 943k| simple_key->possible = 0; 1731| | 1732| | /* A simple key cannot follow another simple key. */ 1733| | 1734| 943k| parser->simple_key_allowed = 0; 1735| 943k| } 1736| 3.64k| else 1737| 3.64k| { 1738| | /* The ':' indicator follows a complex key. */ 1739| | 1740| | /* In the block context, extra checks are required. */ 1741| | 1742| 3.64k| if (!parser->flow_level) ------------------ | Branch (1742:13): [True: 1.24k, False: 2.40k] ------------------ 1743| 1.24k| { 1744| | /* Check if we are allowed to start a complex value. */ 1745| | 1746| 1.24k| if (!parser->simple_key_allowed) { ------------------ | Branch (1746:17): [True: 27, False: 1.21k] ------------------ 1747| 27| return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 1748| 27| "mapping values are not allowed in this context"); 1749| 27| } 1750| | 1751| | /* Add the BLOCK-MAPPING-START token if needed. */ 1752| | 1753| 1.21k| if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, ------------------ | Branch (1753:17): [True: 1, False: 1.21k] ------------------ 1754| 1.21k| YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) 1755| 1| return 0; 1756| 1.21k| } 1757| | 1758| | /* Simple keys after ':' are allowed in the block context. */ 1759| | 1760| 3.61k| parser->simple_key_allowed = (!parser->flow_level); 1761| 3.61k| } 1762| | 1763| | /* Consume the token. */ 1764| | 1765| 946k| start_mark = parser->mark; 1766| 946k| SKIP(parser); ------------------ | | 502| 946k| (parser->mark.index ++, \ | | 503| 946k| parser->mark.column ++, \ | | 504| 946k| parser->unread --, \ | | 505| 946k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 946k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 946k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 946k, False: 0] | | | | | | ------------------ | | | | | | 381| 946k| ((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| 946k| end_mark = parser->mark; 1768| | 1769| | /* Create the VALUE token and append it to the queue. */ 1770| | 1771| 946k| TOKEN_INIT(token, YAML_VALUE_TOKEN, start_mark, end_mark); ------------------ | | 500| 946k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | 501| 946k| (token).type = (token_type), \ | | 502| 946k| (token).start_mark = (token_start_mark), \ | | 503| 946k| (token).end_mark = (token_end_mark)) ------------------ 1772| | 1773| 946k| if (!ENQUEUE(parser, parser->tokens, token)) ------------------ | | 472| 946k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 929k, False: 17.0k] | | ------------------ | | 473| 946k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 17.0k, False: 0] | | ------------------ | | 474| 17.0k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 946k| (*((queue).tail++) = value, \ | | 476| 946k| 1) : \ | | 477| 946k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1773:9): [True: 0, False: 946k] ------------------ 1774| 0| return 0; 1775| | 1776| 946k| return 1; 1777| 946k|} scanner.c:yaml_parser_fetch_anchor: 1785| 297k|{ 1786| 297k| yaml_token_t token; 1787| | 1788| | /* An anchor or an alias could be a simple key. */ 1789| | 1790| 297k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1790:9): [True: 0, False: 297k] ------------------ 1791| 0| return 0; 1792| | 1793| | /* A simple key cannot follow an anchor or an alias. */ 1794| | 1795| 297k| parser->simple_key_allowed = 0; 1796| | 1797| | /* Create the ALIAS or ANCHOR token and append it to the queue. */ 1798| | 1799| 297k| if (!yaml_parser_scan_anchor(parser, &token, type)) ------------------ | Branch (1799:9): [True: 132, False: 297k] ------------------ 1800| 132| return 0; 1801| | 1802| 297k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 297k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 265k, False: 31.2k] | | ------------------ | | 473| 297k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 31.2k, False: 0] | | ------------------ | | 474| 31.2k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 297k| (*((queue).tail++) = value, \ | | 476| 297k| 1) : \ | | 477| 297k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1802:9): [True: 0, False: 297k] ------------------ 1803| 0| yaml_token_delete(&token); 1804| 0| return 0; 1805| 0| } 1806| 297k| return 1; 1807| 297k|} scanner.c:yaml_parser_scan_anchor: 2341| 297k|{ 2342| 297k| int length = 0; 2343| 297k| yaml_mark_t start_mark, end_mark; 2344| 297k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 297k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2345| | 2346| 297k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 297k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 297k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 297k, False: 0] | | ------------------ | | 134| 297k| ((string).pointer = (string).start, \ | | 135| 297k| (string).end = (string).start+(size), \ | | 136| 297k| memset((string).start, 0, (size)), \ | | 137| 297k| 1) : \ | | 138| 297k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2346:9): [True: 0, False: 297k] ------------------ 2347| | 2348| | /* Eat the indicator character. */ 2349| | 2350| 297k| start_mark = parser->mark; 2351| | 2352| 297k| SKIP(parser); ------------------ | | 502| 297k| (parser->mark.index ++, \ | | 503| 297k| parser->mark.column ++, \ | | 504| 297k| parser->unread --, \ | | 505| 297k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 297k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 297k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 297k, False: 0] | | | | | | ------------------ | | | | | | 381| 297k| ((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| 297k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 297k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 297k, False: 0] | | ------------------ | | 494| 297k| ? 1 \ | | 495| 297k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2356:9): [True: 0, False: 297k] ------------------ 2357| | 2358| 3.59M| while (IS_ALPHA(parser->buffer)) { 2359| 3.59M| if (!READ(parser, string)) goto error; ------------------ | | 526| 3.59M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 3.59M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 3.59M, False: 0] | | | | | Branch (146:7): [True: 3.59M, False: 659] | | | | ------------------ | | | | 147| 3.59M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 659, False: 0] | | | | ------------------ | | | | 148| 659| &(string).pointer, &(string).end)) ? \ | | | | 149| 3.59M| 1 : \ | | | | 150| 3.59M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 3.59M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 3.59M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 3.59M, False: 0] | | | | ------------------ | | | | 399| 3.59M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 3.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| 3.59M| parser->mark.index ++, \ | | 529| 3.59M| parser->mark.column ++, \ | | 530| 3.59M| parser->unread --, \ | | 531| 3.59M| 1) : 0) ------------------ | Branch (2359:13): [True: 0, False: 3.59M] ------------------ 2360| 3.59M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 3.59M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 3.59M, False: 456] | | ------------------ | | 494| 3.59M| ? 1 \ | | 495| 3.59M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2360:13): [True: 1, False: 3.59M] ------------------ 2361| 3.59M| length ++; 2362| 3.59M| } 2363| | 2364| 297k| 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| 297k| if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?') ------------------ | | 373| 297k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 594k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 594k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 297k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 594k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 613, False: 296k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 296k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 296k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 443, False: 296k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 296k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 592k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 592k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 6.07k, False: 289k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 296k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 586k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 276, False: 289k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 296k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 579k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 195, False: 289k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 289k| && 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| 296k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 579k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 391, False: 289k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 289k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 289k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 390, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 289k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 390| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 195, False: 195] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 592k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 578k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 289k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 289k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 289k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 195, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 289k| && 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| 289k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 289k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 385, False: 288k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?') ------------------ | | 181| 585k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 288k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 197, False: 288k] | | ------------------ ------------------ | Branch (2373:9): [True: 109, False: 297k] ------------------ 2374| 288k| || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') ------------------ | | 181| 585k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 288k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.70k, False: 282k] | | ------------------ ------------------ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') ------------------ | | 181| 579k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 282k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 281k, False: 986] | | ------------------ ------------------ 2375| 986| || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}') ------------------ | | 181| 298k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 986| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 692, False: 294] | | ------------------ ------------------ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}') ------------------ | | 181| 297k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 294| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 259, False: 35] | | ------------------ ------------------ 2376| 35| || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') ------------------ | | 181| 297k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 35| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5, False: 30] | | ------------------ ------------------ || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') ------------------ | | 181| 297k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 30| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 3, False: 27] | | ------------------ ------------------ 2377| 131| || CHECK(parser->buffer, '`'))) { ------------------ | | 181| 27|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 27| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5, False: 22] | | ------------------ ------------------ 2378| 131| yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ? ------------------ | Branch (2378:47): [True: 69, False: 62] ------------------ 2379| 69| "while scanning an anchor" : "while scanning an alias", start_mark, 2380| 131| "did not find expected alphabetic or numeric character"); 2381| 131| goto error; 2382| 131| } 2383| | 2384| | /* Create a token. */ 2385| | 2386| 297k| if (type == YAML_ANCHOR_TOKEN) { ------------------ | Branch (2386:9): [True: 8.49k, False: 288k] ------------------ 2387| 8.49k| ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark); ------------------ | | 517| 8.49k| (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 8.49k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 8.49k| (token).type = (token_type), \ | | | | 502| 8.49k| (token).start_mark = (token_start_mark), \ | | | | 503| 8.49k| (token).end_mark = (token_end_mark)) | | ------------------ | | 518| 8.49k| (token).data.anchor.value = (token_value)) ------------------ 2388| 8.49k| } 2389| 288k| else { 2390| 288k| ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark); ------------------ | | 513| 288k| (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 288k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 288k| (token).type = (token_type), \ | | | | 502| 288k| (token).start_mark = (token_start_mark), \ | | | | 503| 288k| (token).end_mark = (token_end_mark)) | | ------------------ | | 514| 288k| (token).data.alias.value = (token_value)) ------------------ 2391| 288k| } 2392| | 2393| 297k| return 1; 2394| | 2395| 132|error: 2396| 132| STRING_DEL(parser, string); ------------------ | | 142| 132| (yaml_free((string).start), \ | | 143| 132| (string).start = (string).pointer = (string).end = 0) ------------------ 2397| 132| return 0; 2398| 297k|} scanner.c:yaml_parser_fetch_tag: 1815| 17.0k|{ 1816| 17.0k| yaml_token_t token; 1817| | 1818| | /* A tag could be a simple key. */ 1819| | 1820| 17.0k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1820:9): [True: 0, False: 17.0k] ------------------ 1821| 0| return 0; 1822| | 1823| | /* A simple key cannot follow a tag. */ 1824| | 1825| 17.0k| parser->simple_key_allowed = 0; 1826| | 1827| | /* Create the TAG token and append it to the queue. */ 1828| | 1829| 17.0k| if (!yaml_parser_scan_tag(parser, &token)) ------------------ | Branch (1829:9): [True: 232, False: 16.8k] ------------------ 1830| 232| return 0; 1831| | 1832| 16.8k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 16.8k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 16.0k, False: 799] | | ------------------ | | 473| 16.8k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 799, False: 0] | | ------------------ | | 474| 799| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 16.8k| (*((queue).tail++) = value, \ | | 476| 16.8k| 1) : \ | | 477| 16.8k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1832:9): [True: 0, False: 16.8k] ------------------ 1833| 0| yaml_token_delete(&token); 1834| 0| return 0; 1835| 0| } 1836| | 1837| 16.8k| return 1; 1838| 16.8k|} scanner.c:yaml_parser_scan_tag: 2406| 17.0k|{ 2407| 17.0k| yaml_char_t *handle = NULL; 2408| 17.0k| yaml_char_t *suffix = NULL; 2409| 17.0k| yaml_mark_t start_mark, end_mark; 2410| | 2411| 17.0k| start_mark = parser->mark; 2412| | 2413| | /* Check if the tag is in the canonical form. */ 2414| | 2415| 17.0k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 17.0k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 17.0k, False: 0] | | ------------------ | | 494| 17.0k| ? 1 \ | | 495| 17.0k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2415:9): [True: 0, False: 17.0k] ------------------ 2416| | 2417| 17.0k| if (CHECK_AT(parser->buffer, '<', 1)) ------------------ | | 175| 17.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.99k, False: 14.0k] | | ------------------ ------------------ 2418| 2.99k| { 2419| | /* Set the handle to '' */ 2420| | 2421| 2.99k| handle = YAML_MALLOC(1); ------------------ | | 684| 2.99k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 2422| 2.99k| if (!handle) goto error; ------------------ | Branch (2422:13): [True: 0, False: 2.99k] ------------------ 2423| 2.99k| handle[0] = '\0'; 2424| | 2425| | /* Eat '!<' */ 2426| | 2427| 2.99k| SKIP(parser); ------------------ | | 502| 2.99k| (parser->mark.index ++, \ | | 503| 2.99k| parser->mark.column ++, \ | | 504| 2.99k| parser->unread --, \ | | 505| 2.99k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.99k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.99k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.99k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2428| 2.99k| SKIP(parser); ------------------ | | 502| 2.99k| (parser->mark.index ++, \ | | 503| 2.99k| parser->mark.column ++, \ | | 504| 2.99k| parser->unread --, \ | | 505| 2.99k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.99k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.99k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.99k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2429| | 2430| | /* Consume the tag value. */ 2431| | 2432| 2.99k| if (!yaml_parser_scan_tag_uri(parser, 1, 0, NULL, start_mark, &suffix)) ------------------ | Branch (2432:13): [True: 12, False: 2.98k] ------------------ 2433| 12| goto error; 2434| | 2435| | /* Check for '>' and eat it. */ 2436| | 2437| 2.98k| if (!CHECK(parser->buffer, '>')) { ------------------ | | 181| 2.98k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.98k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2437:13): [True: 30, False: 2.95k] ------------------ 2438| 30| yaml_parser_set_scanner_error(parser, "while scanning a tag", 2439| 30| start_mark, "did not find the expected '>'"); 2440| 30| goto error; 2441| 30| } 2442| | 2443| 2.95k| SKIP(parser); ------------------ | | 502| 2.95k| (parser->mark.index ++, \ | | 503| 2.95k| parser->mark.column ++, \ | | 504| 2.95k| parser->unread --, \ | | 505| 2.95k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.95k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.95k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.95k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.95k| ((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.95k| } 2445| 14.0k| else 2446| 14.0k| { 2447| | /* The tag has either the '!suffix' or the '!handle!suffix' form. */ 2448| | 2449| | /* First, try to scan a handle. */ 2450| | 2451| 14.0k| if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle)) ------------------ | Branch (2451:13): [True: 1, False: 14.0k] ------------------ 2452| 1| goto error; 2453| | 2454| | /* Check if it is, indeed, handle. */ 2455| | 2456| 14.0k| if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!') ------------------ | Branch (2456:13): [True: 14.0k, False: 0] | Branch (2456:33): [True: 8.01k, False: 6.03k] | Branch (2456:54): [True: 3.33k, False: 4.68k] ------------------ 2457| 3.33k| { 2458| | /* Scan the suffix now. */ 2459| | 2460| 3.33k| if (!yaml_parser_scan_tag_uri(parser, 0, 0, NULL, start_mark, &suffix)) ------------------ | Branch (2460:17): [True: 23, False: 3.31k] ------------------ 2461| 23| goto error; 2462| 3.33k| } 2463| 10.7k| else 2464| 10.7k| { 2465| | /* It wasn't a handle after all. Scan the rest of the tag. */ 2466| | 2467| 10.7k| if (!yaml_parser_scan_tag_uri(parser, 0, 0, handle, start_mark, &suffix)) ------------------ | Branch (2467:17): [True: 114, False: 10.6k] ------------------ 2468| 114| goto error; 2469| | 2470| | /* Set the handle to '!'. */ 2471| | 2472| 10.6k| yaml_free(handle); 2473| 10.6k| handle = YAML_MALLOC(2); ------------------ | | 684| 10.6k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) ------------------ 2474| 10.6k| if (!handle) goto error; ------------------ | Branch (2474:17): [True: 0, False: 10.6k] ------------------ 2475| 10.6k| handle[0] = '!'; 2476| 10.6k| handle[1] = '\0'; 2477| | 2478| | /* 2479| | * A special case: the '!' tag. Set the handle to '' and the 2480| | * suffix to '!'. 2481| | */ 2482| | 2483| 10.6k| if (suffix[0] == '\0') { ------------------ | Branch (2483:17): [True: 4.92k, False: 5.67k] ------------------ 2484| 4.92k| yaml_char_t *tmp = handle; 2485| 4.92k| handle = suffix; 2486| 4.92k| suffix = tmp; 2487| 4.92k| } 2488| 10.6k| } 2489| 14.0k| } 2490| | 2491| | /* Check the character which ends the tag. */ 2492| | 2493| 16.8k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 16.8k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 16.7k, False: 166] | | ------------------ | | 494| 16.8k| ? 1 \ | | 495| 16.8k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2493:9): [True: 1, False: 16.8k] ------------------ 2494| | 2495| 16.8k| if (!IS_BLANKZ(parser->buffer)) { ------------------ | | 373| 16.8k|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 16.8k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 33.7k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 16.8k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 33.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 5.96k, False: 10.9k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 10.9k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 10.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 441, False: 10.4k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 10.4k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 20.9k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 20.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.04k, False: 7.42k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 10.4k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 17.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.72k, False: 3.70k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 10.4k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.40k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 197, False: 3.50k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 3.70k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 197| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 10.4k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.01k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 405, False: 3.10k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 3.50k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.91k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 404, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 3.50k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 404| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 198, False: 206] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 20.9k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 6.61k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 207, False: 3.10k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 3.30k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.51k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 206, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 3.30k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 206| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 196, False: 10] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 3.11k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 3.11k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 777, False: 2.33k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2496| 2.33k| if (!parser->flow_level || !CHECK(parser->buffer, ',') ) { ------------------ | | 181| 2.29k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.29k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ ------------------ | Branch (2496:13): [True: 43, False: 2.29k] | Branch (2496:36): [True: 8, False: 2.28k] ------------------ 2497| 51| yaml_parser_set_scanner_error(parser, "while scanning a tag", 2498| 51| start_mark, "did not find expected whitespace or line break"); 2499| 51| goto error; 2500| 51| } 2501| 2.33k| } 2502| | 2503| 16.8k| end_mark = parser->mark; 2504| | 2505| | /* Create a token. */ 2506| | 2507| 16.8k| TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark); ------------------ | | 521| 16.8k| (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 16.8k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 16.8k| (token).type = (token_type), \ | | | | 502| 16.8k| (token).start_mark = (token_start_mark), \ | | | | 503| 16.8k| (token).end_mark = (token_end_mark)) | | ------------------ | | 522| 16.8k| (token).data.tag.handle = (token_handle), \ | | 523| 16.8k| (token).data.tag.suffix = (token_suffix)) ------------------ 2508| | 2509| 16.8k| return 1; 2510| | 2511| 232|error: 2512| 232| yaml_free(handle); 2513| 232| yaml_free(suffix); 2514| 232| return 0; 2515| 16.8k|} scanner.c:yaml_parser_fetch_block_scalar: 1846| 30.5k|{ 1847| 30.5k| yaml_token_t token; 1848| | 1849| | /* Remove any potential simple keys. */ 1850| | 1851| 30.5k| if (!yaml_parser_remove_simple_key(parser)) ------------------ | Branch (1851:9): [True: 2, False: 30.5k] ------------------ 1852| 2| return 0; 1853| | 1854| | /* A simple key may follow a block scalar. */ 1855| | 1856| 30.5k| parser->simple_key_allowed = 1; 1857| | 1858| | /* Create the SCALAR token and append it to the queue. */ 1859| | 1860| 30.5k| if (!yaml_parser_scan_block_scalar(parser, &token, literal)) ------------------ | Branch (1860:9): [True: 86, False: 30.4k] ------------------ 1861| 86| return 0; 1862| | 1863| 30.4k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 30.4k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 29.2k, False: 1.23k] | | ------------------ | | 473| 30.4k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 1.23k, False: 0] | | ------------------ | | 474| 1.23k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 30.4k| (*((queue).tail++) = value, \ | | 476| 30.4k| 1) : \ | | 477| 30.4k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1863:9): [True: 0, False: 30.4k] ------------------ 1864| 0| yaml_token_delete(&token); 1865| 0| return 0; 1866| 0| } 1867| | 1868| 30.4k| return 1; 1869| 30.4k|} scanner.c:yaml_parser_scan_block_scalar: 2761| 30.5k|{ 2762| 30.5k| yaml_mark_t start_mark; 2763| 30.5k| yaml_mark_t end_mark; 2764| 30.5k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 30.5k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2765| 30.5k| yaml_string_t leading_break = NULL_STRING; ------------------ | | 123| 30.5k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2766| 30.5k| yaml_string_t trailing_breaks = NULL_STRING; ------------------ | | 123| 30.5k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 2767| 30.5k| int chomping = 0; 2768| 30.5k| int increment = 0; 2769| 30.5k| int indent = 0; 2770| 30.5k| int leading_blank = 0; 2771| 30.5k| int trailing_blank = 0; 2772| | 2773| 30.5k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 30.5k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 30.5k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 30.5k, False: 0] | | ------------------ | | 134| 30.5k| ((string).pointer = (string).start, \ | | 135| 30.5k| (string).end = (string).start+(size), \ | | 136| 30.5k| memset((string).start, 0, (size)), \ | | 137| 30.5k| 1) : \ | | 138| 30.5k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2773:9): [True: 0, False: 30.5k] ------------------ 2774| 30.5k| if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 30.5k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 30.5k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 30.5k, False: 0] | | ------------------ | | 134| 30.5k| ((string).pointer = (string).start, \ | | 135| 30.5k| (string).end = (string).start+(size), \ | | 136| 30.5k| memset((string).start, 0, (size)), \ | | 137| 30.5k| 1) : \ | | 138| 30.5k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2774:9): [True: 0, False: 30.5k] ------------------ 2775| 30.5k| if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 30.5k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 30.5k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 30.5k, False: 0] | | ------------------ | | 134| 30.5k| ((string).pointer = (string).start, \ | | 135| 30.5k| (string).end = (string).start+(size), \ | | 136| 30.5k| memset((string).start, 0, (size)), \ | | 137| 30.5k| 1) : \ | | 138| 30.5k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (2775:9): [True: 0, False: 30.5k] ------------------ 2776| | 2777| | /* Eat the indicator '|' or '>'. */ 2778| | 2779| 30.5k| start_mark = parser->mark; 2780| | 2781| 30.5k| SKIP(parser); ------------------ | | 502| 30.5k| (parser->mark.index ++, \ | | 503| 30.5k| parser->mark.column ++, \ | | 504| 30.5k| parser->unread --, \ | | 505| 30.5k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 30.5k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 30.5k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 30.5k, False: 0] | | | | | | ------------------ | | | | | | 381| 30.5k| ((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| 30.5k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 30.5k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 30.5k, False: 0] | | ------------------ | | 494| 30.5k| ? 1 \ | | 495| 30.5k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2785:9): [True: 0, False: 30.5k] ------------------ 2786| | 2787| | /* Check for a chomping indicator. */ 2788| | 2789| 30.5k| if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) ------------------ | | 181| 61.1k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 30.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.6k, False: 17.9k] | | ------------------ ------------------ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) ------------------ | | 181| 17.9k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 17.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.91k, False: 15.0k] | | ------------------ ------------------ 2790| 15.5k| { 2791| | /* Set the chomping method and eat the indicator. */ 2792| | 2793| 15.5k| chomping = CHECK(parser->buffer, '+') ? +1 : -1; ------------------ | | 181| 15.5k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 15.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 12.6k, False: 2.91k] | | ------------------ ------------------ 2794| | 2795| 15.5k| SKIP(parser); ------------------ | | 502| 15.5k| (parser->mark.index ++, \ | | 503| 15.5k| parser->mark.column ++, \ | | 504| 15.5k| parser->unread --, \ | | 505| 15.5k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 15.5k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 15.5k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 15.5k, False: 0] | | | | | | ------------------ | | | | | | 381| 15.5k| ((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| 15.5k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 15.5k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 15.5k, False: 0] | | ------------------ | | 494| 15.5k| ? 1 \ | | 495| 15.5k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2799:13): [True: 0, False: 15.5k] ------------------ 2800| | 2801| 15.5k| if (IS_DIGIT(parser->buffer)) ------------------ | | 208| 15.5k|#define IS_DIGIT(string) IS_DIGIT_AT((string),0) | | ------------------ | | | | 205| 15.5k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (205:8): [True: 595, False: 14.9k] | | | | ------------------ | | | | 206| 15.5k| (string).pointer[offset] <= (yaml_char_t) '9')) | | | | ------------------ | | | | | Branch (206:8): [True: 386, False: 209] | | | | ------------------ | | ------------------ ------------------ 2802| 386| { 2803| | /* Check that the indentation is greater than 0. */ 2804| | 2805| 386| if (CHECK(parser->buffer, '0')) { ------------------ | | 181| 386|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 386| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2, False: 384] | | ------------------ ------------------ 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| 384| increment = AS_DIGIT(parser->buffer); ------------------ | | 217| 384|#define AS_DIGIT(string) AS_DIGIT_AT((string),0) | | ------------------ | | | | 215| 384| ((string).pointer[offset] - (yaml_char_t) '0') | | ------------------ ------------------ 2814| | 2815| 384| SKIP(parser); ------------------ | | 502| 384| (parser->mark.index ++, \ | | 503| 384| parser->mark.column ++, \ | | 504| 384| parser->unread --, \ | | 505| 384| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 384|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 384| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 384, False: 0] | | | | | | ------------------ | | | | | | 381| 384| ((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| 384| } 2817| 15.5k| } 2818| | 2819| | /* Do the same as above, but in the opposite order. */ 2820| | 2821| 15.0k| else if (IS_DIGIT(parser->buffer)) ------------------ | | 208| 15.0k|#define IS_DIGIT(string) IS_DIGIT_AT((string),0) | | ------------------ | | | | 205| 15.0k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | | | ------------------ | | | | | Branch (205:8): [True: 3.34k, False: 11.6k] | | | | ------------------ | | | | 206| 15.0k| (string).pointer[offset] <= (yaml_char_t) '9')) | | | | ------------------ | | | | | Branch (206:8): [True: 2.70k, False: 637] | | | | ------------------ | | ------------------ ------------------ 2822| 2.70k| { 2823| 2.70k| if (CHECK(parser->buffer, '0')) { ------------------ | | 181| 2.70k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1, False: 2.70k] | | ------------------ ------------------ 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| 2.70k| increment = AS_DIGIT(parser->buffer); ------------------ | | 217| 2.70k|#define AS_DIGIT(string) AS_DIGIT_AT((string),0) | | ------------------ | | | | 215| 2.70k| ((string).pointer[offset] - (yaml_char_t) '0') | | ------------------ ------------------ 2830| | 2831| 2.70k| SKIP(parser); ------------------ | | 502| 2.70k| (parser->mark.index ++, \ | | 503| 2.70k| parser->mark.column ++, \ | | 504| 2.70k| parser->unread --, \ | | 505| 2.70k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.70k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.70k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.70k, False: 0] | | | | | | ------------------ | | | | | | 381| 2.70k| ((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| 2.70k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 2.70k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.70k, False: 0] | | ------------------ | | 494| 2.70k| ? 1 \ | | 495| 2.70k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2833:13): [True: 0, False: 2.70k] ------------------ 2834| | 2835| 2.70k| if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { ------------------ | | 181| 5.41k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 198, False: 2.50k] | | ------------------ ------------------ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { ------------------ | | 181| 2.50k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.50k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 198, False: 2.30k] | | ------------------ ------------------ 2836| 396| chomping = CHECK(parser->buffer, '+') ? +1 : -1; ------------------ | | 181| 396|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 396| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 198, False: 198] | | ------------------ ------------------ 2837| | 2838| 396| SKIP(parser); ------------------ | | 502| 396| (parser->mark.index ++, \ | | 503| 396| parser->mark.column ++, \ | | 504| 396| parser->unread --, \ | | 505| 396| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 396|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 396| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 396, False: 0] | | | | | | ------------------ | | | | | | 381| 396| ((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| 396| } 2840| 2.70k| } 2841| | 2842| | /* Eat whitespaces and comments to the end of the line. */ 2843| | 2844| 30.5k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 30.5k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 30.5k, False: 0] | | ------------------ | | 494| 30.5k| ? 1 \ | | 495| 30.5k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2844:9): [True: 0, False: 30.5k] ------------------ 2845| | 2846| 1.27M| while (IS_BLANK(parser->buffer)) { 2847| 1.27M| SKIP(parser); ------------------ | | 502| 1.27M| (parser->mark.index ++, \ | | 503| 1.27M| parser->mark.column ++, \ | | 504| 1.27M| parser->unread --, \ | | 505| 1.27M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 1.27M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 1.27M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 1.27M, False: 0] | | | | | | ------------------ | | | | | | 381| 1.27M| ((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.27M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.27M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.27M, False: 102] | | ------------------ | | 494| 1.27M| ? 1 \ | | 495| 1.27M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2848:13): [True: 1, False: 1.27M] ------------------ 2849| 1.27M| } 2850| | 2851| 30.5k| if (CHECK(parser->buffer, '#')) { ------------------ | | 181| 30.5k|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 30.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 5.91k, False: 24.6k] | | ------------------ ------------------ 2852| 6.42M| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 6.42M|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 6.42M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 12.8M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 12.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 333, False: 6.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 6.42M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 12.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.22k, False: 6.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 6.42M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 393, False: 6.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 6.42M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 393| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 199, False: 194] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 6.42M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 10.9k, False: 6.41M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 6.42M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 6.43M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 10.2k, False: 667] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 6.42M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 10.2k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 233, False: 10.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 12.8M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 10.7k, False: 6.41M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 6.42M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 6.43M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 10.0k, False: 667] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 6.42M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 10.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.81k, False: 8.24k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 6.42M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 6.42M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 109, False: 6.42M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2853| 6.42M| SKIP(parser); ------------------ | | 502| 6.42M| (parser->mark.index ++, \ | | 503| 6.42M| parser->mark.column ++, \ | | 504| 6.42M| parser->unread --, \ | | 505| 6.42M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 6.42M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 6.42M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 6.41M, False: 10.1k] | | | | | | ------------------ | | | | | | 381| 6.42M| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 217, False: 9.90k] | | | | | | ------------------ | | | | | | 382| 10.1k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 9.53k, False: 362] | | | | | | ------------------ | | | | | | 383| 9.90k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 362, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2854| 6.42M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 6.42M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 6.41M, False: 457] | | ------------------ | | 494| 6.42M| ? 1 \ | | 495| 6.42M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2854:17): [True: 4, False: 6.42M] ------------------ 2855| 6.42M| } 2856| 5.91k| } 2857| | 2858| | /* Check if we are at the end of the line. */ 2859| | 2860| 30.5k| if (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 30.5k|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 30.5k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 61.1k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 61.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.9k, False: 15.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 30.5k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 46.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 12.1k, False: 3.41k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 30.5k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 6.83k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 615, False: 2.80k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 3.41k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 615| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 610, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 30.5k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 5.61k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.45k, False: 349] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 2.80k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 5.26k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.45k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 2.80k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 2.45k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 488, False: 1.97k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 61.1k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 4.64k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.97k, False: 349] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 2.32k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 4.29k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.97k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 2.32k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 1.97k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.96k, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 356|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 356| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 292, False: 64] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2861| 64| yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 2862| 64| start_mark, "did not find expected comment or line break"); 2863| 64| goto error; 2864| 64| } 2865| | 2866| | /* Eat a line break. */ 2867| | 2868| 30.4k| if (IS_BREAK(parser->buffer)) { ------------------ | | 341| 30.4k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 30.4k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 60.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 14.9k, False: 15.5k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 30.4k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 46.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 12.1k, False: 3.35k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 30.4k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 610, False: 2.74k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 3.35k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 610| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 610, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 334| 30.4k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.48k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.45k, False: 292] | | | | | | ------------------ | | | | ------------------ | | | | 335| 2.74k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 5.19k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.45k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 336| 2.74k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 2.45k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 488, False: 1.96k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 30.4k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 4.51k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.96k, False: 292] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.25k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 4.22k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.96k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.25k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 1.96k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.96k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2869| 30.2k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 30.2k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 30.1k, False: 13] | | ------------------ | | 494| 30.2k| ? 1 \ | | 495| 30.2k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2869:13): [True: 1, False: 30.2k] ------------------ 2870| 30.2k| SKIP_LINE(parser); ------------------ | | 508| 30.2k| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 30.2k|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 30.2k| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 60.4k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.9k, False: 15.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 14.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 320, False: 14.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 30.2k| (parser->mark.index += 2, \ | | 510| 320| parser->mark.column = 0, \ | | 511| 320| parser->mark.line ++, \ | | 512| 320| parser->unread -= 2, \ | | 513| 320| parser->buffer.pointer += 2) : \ | | 514| 30.2k| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 29.8k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 59.7k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 59.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 14.6k, False: 15.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 29.8k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 45.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 12.1k, False: 3.06k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 29.8k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 6.12k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 610, False: 2.45k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 3.06k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 610| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 610, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 29.8k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 4.90k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.45k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 2.45k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 4.90k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.45k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 2.45k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 2.45k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 488, False: 1.96k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 59.7k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 3.92k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.96k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 1.96k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 3.92k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.96k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 1.96k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 1.96k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.96k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 515| 29.8k| (parser->mark.index ++, \ | | 516| 29.8k| parser->mark.column = 0, \ | | 517| 29.8k| parser->mark.line ++, \ | | 518| 29.8k| parser->unread --, \ | | 519| 29.8k| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 29.8k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 29.8k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 26.8k, False: 3.06k] | | | | | | ------------------ | | | | | | 381| 29.8k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 610, False: 2.45k] | | | | | | ------------------ | | | | | | 382| 3.06k| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 2.45k, False: 0] | | | | | | ------------------ | | | | | | 383| 2.45k| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2871| 30.2k| } 2872| | 2873| 30.4k| end_mark = parser->mark; 2874| | 2875| | /* Set the indentation level if it was specified. */ 2876| | 2877| 30.4k| if (increment) { ------------------ | Branch (2877:9): [True: 3.08k, False: 27.4k] ------------------ 2878| 3.08k| indent = parser->indent >= 0 ? parser->indent+increment : increment; ------------------ | Branch (2878:18): [True: 2.82k, False: 253] ------------------ 2879| 3.08k| } 2880| | 2881| | /* Scan the leading line breaks and determine the indentation level if needed. */ 2882| | 2883| 30.4k| if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, ------------------ | Branch (2883:9): [True: 5, False: 30.4k] ------------------ 2884| 30.4k| start_mark, &end_mark)) goto error; 2885| | 2886| | /* Scan the block scalar content. */ 2887| | 2888| 30.4k| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 30.4k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 30.4k, False: 0] | | ------------------ | | 494| 30.4k| ? 1 \ | | 495| 30.4k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2888:9): [True: 0, False: 30.4k] ------------------ 2889| | 2890| 227k| while ((int)parser->mark.column == indent && !(IS_Z(parser->buffer))) ------------------ | | 287| 197k|#define IS_Z(string) IS_Z_AT((string),0) | | ------------------ | | | | 285| 197k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | ------------------ | | | | | | 175| 197k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | ------------------ ------------------ | Branch (2890:12): [True: 197k, False: 30.2k] | Branch (2890:50): [True: 196k, False: 254] ------------------ 2891| 196k| { 2892| | /* 2893| | * We are at the beginning of a non-empty line. 2894| | */ 2895| | 2896| | /* Is it a trailing whitespace? */ 2897| | 2898| 196k| trailing_blank = IS_BLANK(parser->buffer); ------------------ | | 323| 196k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 196k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 196k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 393k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.38k, False: 188k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 188k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 188k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 16, False: 188k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2899| | 2900| | /* Check if we need to fold the leading line break. */ 2901| | 2902| 196k| if (!literal && (*leading_break.start == '\n') ------------------ | Branch (2902:13): [True: 25.5k, False: 171k] | Branch (2902:25): [True: 21.0k, False: 4.54k] ------------------ 2903| 21.0k| && !leading_blank && !trailing_blank) ------------------ | Branch (2903:20): [True: 16.7k, False: 4.26k] | Branch (2903:38): [True: 13.2k, False: 3.50k] ------------------ 2904| 13.2k| { 2905| | /* Do we need to join the lines by space? */ 2906| | 2907| 13.2k| if (*trailing_breaks.start == '\0') { ------------------ | Branch (2907:17): [True: 2.62k, False: 10.6k] ------------------ 2908| 2.62k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 2.62k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 2.38k, False: 239] | | ------------------ | | 147| 2.62k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 239, False: 0] | | ------------------ | | 148| 239| &(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.2k| CLEAR(parser, leading_break); ------------------ | | 154| 13.2k| ((string).pointer = (string).start, \ | | 155| 13.2k| memset((string).start, 0, (string).end-(string).start)) ------------------ 2913| 13.2k| } 2914| 183k| else { 2915| 183k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 183k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 183k, False: 0] | | ------------------ | | 159| 183k| &(string_a).end, &(string_b).start, \ | | 160| 183k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 183k| ((string_b).pointer = (string_b).start, \ | | 162| 183k| 1) : \ | | 163| 183k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2915:17): [True: 0, False: 183k] ------------------ 2916| 183k| CLEAR(parser, leading_break); ------------------ | | 154| 183k| ((string).pointer = (string).start, \ | | 155| 183k| memset((string).start, 0, (string).end-(string).start)) ------------------ 2917| 183k| } 2918| | 2919| | /* Append the remaining line breaks. */ 2920| | 2921| 196k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 196k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 196k, False: 0] | | ------------------ | | 159| 196k| &(string_a).end, &(string_b).start, \ | | 160| 196k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 196k| ((string_b).pointer = (string_b).start, \ | | 162| 196k| 1) : \ | | 163| 196k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2921:13): [True: 0, False: 196k] ------------------ 2922| 196k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 196k| ((string).pointer = (string).start, \ | | 155| 196k| memset((string).start, 0, (string).end-(string).start)) ------------------ 2923| | 2924| | /* Is it a leading whitespace? */ 2925| | 2926| 196k| leading_blank = IS_BLANK(parser->buffer); ------------------ | | 323| 196k|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 196k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 196k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 393k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 8.38k, False: 188k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 188k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 188k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 16, False: 188k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2927| | 2928| | /* Consume the current line. */ 2929| | 2930| 7.50M| while (!IS_BREAKZ(parser->buffer)) { ------------------ | | 355| 7.50M|#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) | | ------------------ | | | | 353| 7.50M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 15.0M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 15.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.15k, False: 7.50M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 7.50M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 15.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 193k, False: 7.31M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 7.50M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 14.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.74k, False: 7.30M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 7.31M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 3.74k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 209, False: 3.53k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 7.50M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 14.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 502k, False: 6.80M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 7.31M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 7.81M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 424k, False: 78.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 7.31M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 424k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 361, False: 423k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 15.0M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 14.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 502k, False: 6.80M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 7.30M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 7.81M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 423k, False: 78.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 7.30M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 423k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 225, False: 423k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 7.30M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 7.30M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 464, False: 7.30M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2931| 7.30M| if (!READ(parser, string)) goto error; ------------------ | | 526| 7.30M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 7.30M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 7.30M, False: 0] | | | | | Branch (146:7): [True: 7.30M, False: 8.42k] | | | | ------------------ | | | | 147| 7.30M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 8.42k, False: 0] | | | | ------------------ | | | | 148| 8.42k| &(string).pointer, &(string).end)) ? \ | | | | 149| 7.30M| 1 : \ | | | | 150| 7.30M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 7.30M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 7.30M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 6.58M, False: 722k] | | | | ------------------ | | | | 399| 7.30M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 7.30M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 3.73k, False: 718k] | | | | ------------------ | | | | 401| 722k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 3.73k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 722k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 718k, False: 202] | | | | ------------------ | | | | 404| 718k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 718k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 718k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 718k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 202, False: 0] | | | | ------------------ | | | | 408| 202| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 202| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 202| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 202| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 7.30M| parser->mark.index ++, \ | | 529| 7.30M| parser->mark.column ++, \ | | 530| 7.30M| parser->unread --, \ | | 531| 7.30M| 1) : 0) ------------------ | Branch (2931:17): [True: 0, False: 7.30M] ------------------ 2932| 7.30M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 7.30M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 7.30M, False: 940] | | ------------------ | | 494| 7.30M| ? 1 \ | | 495| 7.30M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2932:17): [True: 6, False: 7.30M] ------------------ 2933| 7.30M| } 2934| | 2935| | /* Consume the line break. */ 2936| | 2937| 196k| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 196k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 196k, False: 613] | | ------------------ | | 494| 196k| ? 1 \ | | 495| 196k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2937:13): [True: 1, False: 196k] ------------------ 2938| | 2939| 196k| if (!READ_LINE(parser, leading_break)) goto error; ------------------ | | 538| 196k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 196k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 196k, False: 0] | | | | | Branch (146:7): [True: 196k, False: 0] | | | | ------------------ | | | | 147| 196k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 196k| 1 : \ | | | | 150| 196k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 196k| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 393k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 2.15k, False: 194k] | | | | ------------------ | | ------------------ | | 540| 196k| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 2.15k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 245, False: 1.91k] | | | | ------------------ | | ------------------ | | 541| 196k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 245| parser->buffer.pointer += 2, \ | | 543| 245| parser->mark.index += 2, \ | | 544| 245| parser->mark.column = 0, \ | | 545| 245| parser->mark.line ++, \ | | 546| 245| parser->unread -= 2) : \ | | 547| 196k| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 393k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.91k, False: 194k] | | | | ------------------ | | ------------------ | | 548| 196k| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 194k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 193k, False: 1.25k] | | | | ------------------ | | ------------------ | | 549| 196k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 195k| parser->buffer.pointer ++, \ | | 551| 195k| parser->mark.index ++, \ | | 552| 195k| parser->mark.column = 0, \ | | 553| 195k| parser->mark.line ++, \ | | 554| 195k| parser->unread --) : \ | | 555| 196k| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 2.51k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 209, False: 1.05k] | | | | ------------------ | | ------------------ | | 556| 1.25k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 209| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 209, False: 0] | | | | ------------------ | | ------------------ | | 557| 1.25k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 209| parser->buffer.pointer += 2, \ | | 559| 209| parser->mark.index ++, \ | | 560| 209| parser->mark.column = 0, \ | | 561| 209| parser->mark.line ++, \ | | 562| 209| parser->unread --) : \ | | 563| 1.25k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 2.10k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 586, False: 464] | | | | ------------------ | | ------------------ | | 564| 1.05k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 1.63k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 586, False: 0] | | | | ------------------ | | ------------------ | | 565| 1.05k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 1.17k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 361, False: 225] | | | | ------------------ | | ------------------ | | 566| 586| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 225| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 225, False: 0] | | | | ------------------ | | ------------------ | | 567| 1.05k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 586| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 586| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 586| parser->mark.index ++, \ | | 571| 586| parser->mark.column = 0, \ | | 572| 586| parser->mark.line ++, \ | | 573| 586| parser->unread --) : 0), \ | | 574| 196k| 1) : 0) ------------------ | Branch (2939:13): [True: 0, False: 196k] ------------------ 2940| | 2941| | /* Eat the following indentation spaces and line breaks. */ 2942| | 2943| 196k| if (!yaml_parser_scan_block_scalar_breaks(parser, ------------------ | Branch (2943:13): [True: 1, False: 196k] ------------------ 2944| 196k| &indent, &trailing_breaks, start_mark, &end_mark)) goto error; 2945| 196k| } 2946| | 2947| | /* Chomp the tail. */ 2948| | 2949| 30.4k| if (chomping != -1) { ------------------ | Branch (2949:9): [True: 27.3k, False: 3.09k] ------------------ 2950| 27.3k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 27.3k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 27.3k, False: 0] | | ------------------ | | 159| 27.3k| &(string_a).end, &(string_b).start, \ | | 160| 27.3k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 27.3k| ((string_b).pointer = (string_b).start, \ | | 162| 27.3k| 1) : \ | | 163| 27.3k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2950:13): [True: 0, False: 27.3k] ------------------ 2951| 27.3k| } 2952| 30.4k| if (chomping == 1) { ------------------ | Branch (2952:9): [True: 12.8k, False: 17.6k] ------------------ 2953| 12.8k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 12.8k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 12.8k, False: 0] | | ------------------ | | 159| 12.8k| &(string_a).end, &(string_b).start, \ | | 160| 12.8k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 12.8k| ((string_b).pointer = (string_b).start, \ | | 162| 12.8k| 1) : \ | | 163| 12.8k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (2953:13): [True: 0, False: 12.8k] ------------------ 2954| 12.8k| } 2955| | 2956| | /* Create a token. */ 2957| | 2958| 30.4k| SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, ------------------ | | 526| 30.4k| (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 30.4k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 30.4k| (token).type = (token_type), \ | | | | 502| 30.4k| (token).start_mark = (token_start_mark), \ | | | | 503| 30.4k| (token).end_mark = (token_end_mark)) | | ------------------ | | 527| 30.4k| (token).data.scalar.value = (token_value), \ | | 528| 30.4k| (token).data.scalar.length = (token_length), \ | | 529| 60.9k| (token).data.scalar.style = (token_style)) | | ------------------ | | | Branch (529:35): [True: 19.1k, False: 11.3k] | | ------------------ ------------------ 2959| 30.4k| literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE, 2960| 30.4k| start_mark, end_mark); 2961| | 2962| 30.4k| STRING_DEL(parser, leading_break); ------------------ | | 142| 30.4k| (yaml_free((string).start), \ | | 143| 30.4k| (string).start = (string).pointer = (string).end = 0) ------------------ 2963| 30.4k| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 30.4k| (yaml_free((string).start), \ | | 143| 30.4k| (string).start = (string).pointer = (string).end = 0) ------------------ 2964| | 2965| 30.4k| return 1; 2966| | 2967| 86|error: 2968| 86| STRING_DEL(parser, string); ------------------ | | 142| 86| (yaml_free((string).start), \ | | 143| 86| (string).start = (string).pointer = (string).end = 0) ------------------ 2969| 86| STRING_DEL(parser, leading_break); ------------------ | | 142| 86| (yaml_free((string).start), \ | | 143| 86| (string).start = (string).pointer = (string).end = 0) ------------------ 2970| 86| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 86| (yaml_free((string).start), \ | | 143| 86| (string).start = (string).pointer = (string).end = 0) ------------------ 2971| | 2972| 86| return 0; 2973| 30.4k|} scanner.c:yaml_parser_scan_block_scalar_breaks: 2984| 227k|{ 2985| 227k| int max_indent = 0; 2986| | 2987| 227k| *end_mark = parser->mark; 2988| | 2989| | /* Eat the indentation spaces and line breaks. */ 2990| | 2991| 1.93M| while (1) ------------------ | Branch (2991:12): [True: 1.93M, Folded] ------------------ 2992| 1.93M| { 2993| | /* Eat the indentation spaces. */ 2994| | 2995| 1.93M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 1.93M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.93M, False: 82] | | ------------------ | | 494| 1.93M| ? 1 \ | | 495| 1.93M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (2995:13): [True: 1, False: 1.93M] ------------------ 2996| | 2997| 5.71M| while ((!*indent || (int)parser->mark.column < *indent) ------------------ | Branch (2997:17): [True: 3.93M, False: 1.77M] | Branch (2997:29): [True: 1.58M, False: 194k] ------------------ 2998| 5.52M| && IS_SPACE(parser->buffer)) { ------------------ | | 306| 5.52M|#define IS_SPACE(string) IS_SPACE_AT((string),0) | | ------------------ | | | | 304| 5.52M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | ------------------ | | | | | | 175| 5.52M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.78M, False: 1.73M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2999| 3.78M| SKIP(parser); ------------------ | | 502| 3.78M| (parser->mark.index ++, \ | | 503| 3.78M| parser->mark.column ++, \ | | 504| 3.78M| parser->unread --, \ | | 505| 3.78M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 3.78M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 3.78M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 3.78M, False: 0] | | | | | | ------------------ | | | | | | 381| 3.78M| ((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| 3.78M| if (!CACHE(parser, 1)) return 0; ------------------ | | 493| 3.78M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 3.78M, False: 249] | | ------------------ | | 494| 3.78M| ? 1 \ | | 495| 3.78M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3000:17): [True: 2, False: 3.78M] ------------------ 3001| 3.78M| } 3002| | 3003| 1.93M| if ((int)parser->mark.column > max_indent) ------------------ | Branch (3003:13): [True: 198k, False: 1.73M] ------------------ 3004| 198k| max_indent = (int)parser->mark.column; 3005| | 3006| | /* Check for a tab character messing the indentation. */ 3007| | 3008| 1.93M| if ((!*indent || (int)parser->mark.column < *indent) ------------------ | Branch (3008:14): [True: 346k, False: 1.58M] | Branch (3008:26): [True: 1.38M, False: 194k] ------------------ 3009| 1.73M| && IS_TAB(parser->buffer)) { ------------------ | | 314| 1.73M|#define IS_TAB(string) IS_TAB_AT((string),0) | | ------------------ | | | | 312| 1.73M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | ------------------ | | | | | | 175| 1.73M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2, False: 1.73M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3010| 2| return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 3011| 2| start_mark, "found a tab character where an indentation space is expected"); 3012| 2| } 3013| | 3014| | /* Have we found a non-empty line? */ 3015| | 3016| 1.93M| if (!IS_BREAK(parser->buffer)) break; ------------------ | | 341| 1.93M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 1.93M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 3.86M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.54M, False: 383k] | | | | | | ------------------ | | | | ------------------ | | | | 331| 1.93M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 2.31M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 150k, False: 232k] | | | | | | ------------------ | | | | ------------------ | | | | 332| 1.93M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 464k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.95k, False: 230k] | | | | | | ------------------ | | | | ------------------ | | | | 333| 232k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 1.95k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 926, False: 1.03k] | | | | | | ------------------ | | | | ------------------ | | | | 334| 1.93M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 462k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 16.5k, False: 214k] | | | | | | ------------------ | | | | ------------------ | | | | 335| 231k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 248k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 15.1k, False: 1.41k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 231k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 15.1k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.20k, False: 12.9k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 1.93M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 458k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 14.3k, False: 214k] | | | | | | ------------------ | | | | ------------------ | | | | 338| 229k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 243k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 12.9k, False: 1.41k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 229k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 12.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.86k, False: 11.0k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3017| | 3018| | /* Consume the line break. */ 3019| | 3020| 1.70M| if (!CACHE(parser, 2)) return 0; ------------------ | | 493| 1.70M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.70M, False: 276] | | ------------------ | | 494| 1.70M| ? 1 \ | | 495| 1.70M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3020:13): [True: 1, False: 1.70M] ------------------ 3021| 1.70M| if (!READ_LINE(parser, *breaks)) return 0; ------------------ | | 538| 1.70M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 1.70M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 1.70M, False: 0] | | | | | Branch (146:7): [True: 1.70M, False: 738] | | | | ------------------ | | | | 147| 1.70M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 738, False: 0] | | | | ------------------ | | | | 148| 738| &(string).pointer, &(string).end)) ? \ | | | | 149| 1.70M| 1 : \ | | | | 150| 1.70M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 1.70M| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 3.40M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.54M, False: 155k] | | | | ------------------ | | ------------------ | | 540| 1.70M| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 1.54M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 494k, False: 1.05M] | | | | ------------------ | | ------------------ | | 541| 1.70M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 494k| parser->buffer.pointer += 2, \ | | 543| 494k| parser->mark.index += 2, \ | | 544| 494k| parser->mark.column = 0, \ | | 545| 494k| parser->mark.line ++, \ | | 546| 494k| parser->unread -= 2) : \ | | 547| 1.70M| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.41M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.05M, False: 155k] | | | | ------------------ | | ------------------ | | 548| 1.20M| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 155k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 150k, False: 4.99k] | | | | ------------------ | | ------------------ | | 549| 1.20M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 1.20M| parser->buffer.pointer ++, \ | | 551| 1.20M| parser->mark.index ++, \ | | 552| 1.20M| parser->mark.column = 0, \ | | 553| 1.20M| parser->mark.line ++, \ | | 554| 1.20M| parser->unread --) : \ | | 555| 1.20M| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 9.99k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 926, False: 4.06k] | | | | ------------------ | | ------------------ | | 556| 4.99k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 926| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 926, False: 0] | | | | ------------------ | | ------------------ | | 557| 4.99k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 926| parser->buffer.pointer += 2, \ | | 559| 926| parser->mark.index ++, \ | | 560| 926| parser->mark.column = 0, \ | | 561| 926| parser->mark.line ++, \ | | 562| 926| parser->unread --) : \ | | 563| 4.99k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 8.13k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 4.06k, False: 0] | | | | ------------------ | | ------------------ | | 564| 4.06k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 8.13k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 4.06k, False: 0] | | | | ------------------ | | ------------------ | | 565| 4.06k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 8.13k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 2.20k, False: 1.86k] | | | | ------------------ | | ------------------ | | 566| 4.06k| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 1.86k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.86k, False: 0] | | | | ------------------ | | ------------------ | | 567| 4.06k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 4.06k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 4.06k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 4.06k| parser->mark.index ++, \ | | 571| 4.06k| parser->mark.column = 0, \ | | 572| 4.06k| parser->mark.line ++, \ | | 573| 4.06k| parser->unread --) : 0), \ | | 574| 1.70M| 1) : 0) ------------------ | Branch (3021:13): [True: 0, False: 1.70M] ------------------ 3022| 1.70M| *end_mark = parser->mark; 3023| 1.70M| } 3024| | 3025| | /* Determine the indentation level if needed. */ 3026| | 3027| 227k| if (!*indent) { ------------------ | Branch (3027:9): [True: 27.4k, False: 199k] ------------------ 3028| 27.4k| *indent = max_indent; 3029| 27.4k| if (*indent < parser->indent + 1) ------------------ | Branch (3029:13): [True: 20.9k, False: 6.47k] ------------------ 3030| 20.9k| *indent = parser->indent + 1; 3031| 27.4k| if (*indent < 1) ------------------ | Branch (3031:13): [True: 592, False: 26.8k] ------------------ 3032| 592| *indent = 1; 3033| 27.4k| } 3034| | 3035| 227k| return 1; 3036| 227k|} scanner.c:yaml_parser_fetch_flow_scalar: 1877| 16.9k|{ 1878| 16.9k| yaml_token_t token; 1879| | 1880| | /* A plain scalar could be a simple key. */ 1881| | 1882| 16.9k| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1882:9): [True: 0, False: 16.9k] ------------------ 1883| 0| return 0; 1884| | 1885| | /* A simple key cannot follow a flow scalar. */ 1886| | 1887| 16.9k| parser->simple_key_allowed = 0; 1888| | 1889| | /* Create the SCALAR token and append it to the queue. */ 1890| | 1891| 16.9k| if (!yaml_parser_scan_flow_scalar(parser, &token, single)) ------------------ | Branch (1891:9): [True: 997, False: 15.9k] ------------------ 1892| 997| return 0; 1893| | 1894| 15.9k| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 15.9k| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 15.1k, False: 853] | | ------------------ | | 473| 15.9k| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 853, False: 0] | | ------------------ | | 474| 853| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 15.9k| (*((queue).tail++) = value, \ | | 476| 15.9k| 1) : \ | | 477| 15.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1894:9): [True: 0, False: 15.9k] ------------------ 1895| 0| yaml_token_delete(&token); 1896| 0| return 0; 1897| 0| } 1898| | 1899| 15.9k| return 1; 1900| 15.9k|} scanner.c:yaml_parser_scan_flow_scalar: 3045| 16.9k|{ 3046| 16.9k| yaml_mark_t start_mark; 3047| 16.9k| yaml_mark_t end_mark; 3048| 16.9k| yaml_string_t string = NULL_STRING; ------------------ | | 123| 16.9k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3049| 16.9k| yaml_string_t leading_break = NULL_STRING; ------------------ | | 123| 16.9k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3050| 16.9k| yaml_string_t trailing_breaks = NULL_STRING; ------------------ | | 123| 16.9k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3051| 16.9k| yaml_string_t whitespaces = NULL_STRING; ------------------ | | 123| 16.9k|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3052| 16.9k| int leading_blanks; 3053| | 3054| 16.9k| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 16.9k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 16.9k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 16.9k, False: 0] | | ------------------ | | 134| 16.9k| ((string).pointer = (string).start, \ | | 135| 16.9k| (string).end = (string).start+(size), \ | | 136| 16.9k| memset((string).start, 0, (size)), \ | | 137| 16.9k| 1) : \ | | 138| 16.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3054:9): [True: 0, False: 16.9k] ------------------ 3055| 16.9k| if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 16.9k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 16.9k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 16.9k, False: 0] | | ------------------ | | 134| 16.9k| ((string).pointer = (string).start, \ | | 135| 16.9k| (string).end = (string).start+(size), \ | | 136| 16.9k| memset((string).start, 0, (size)), \ | | 137| 16.9k| 1) : \ | | 138| 16.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3055:9): [True: 0, False: 16.9k] ------------------ 3056| 16.9k| if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 16.9k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 16.9k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 16.9k, False: 0] | | ------------------ | | 134| 16.9k| ((string).pointer = (string).start, \ | | 135| 16.9k| (string).end = (string).start+(size), \ | | 136| 16.9k| memset((string).start, 0, (size)), \ | | 137| 16.9k| 1) : \ | | 138| 16.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3056:9): [True: 0, False: 16.9k] ------------------ 3057| 16.9k| if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 16.9k| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 16.9k|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 16.9k, False: 0] | | ------------------ | | 134| 16.9k| ((string).pointer = (string).start, \ | | 135| 16.9k| (string).end = (string).start+(size), \ | | 136| 16.9k| memset((string).start, 0, (size)), \ | | 137| 16.9k| 1) : \ | | 138| 16.9k| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3057:9): [True: 0, False: 16.9k] ------------------ 3058| | 3059| | /* Eat the left quote. */ 3060| | 3061| 16.9k| start_mark = parser->mark; 3062| | 3063| 16.9k| SKIP(parser); ------------------ | | 502| 16.9k| (parser->mark.index ++, \ | | 503| 16.9k| parser->mark.column ++, \ | | 504| 16.9k| parser->unread --, \ | | 505| 16.9k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 16.9k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 16.9k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 16.9k, False: 0] | | | | | | ------------------ | | | | | | 381| 16.9k| ((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| 1.03M| while (1) ------------------ | Branch (3067:12): [True: 1.03M, Folded] ------------------ 3068| 1.03M| { 3069| | /* Check that there are no document indicators at the beginning of the line. */ 3070| | 3071| 1.03M| if (!CACHE(parser, 4)) goto error; ------------------ | | 493| 1.03M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.02M, False: 1.88k] | | ------------------ | | 494| 1.03M| ? 1 \ | | 495| 1.03M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3071:13): [True: 5, False: 1.03M] ------------------ 3072| | 3073| 1.03M| if (parser->mark.column == 0 && ------------------ | Branch (3073:13): [True: 295k, False: 736k] ------------------ 3074| 295k| ((CHECK_AT(parser->buffer, '-', 0) && ------------------ | | 175| 590k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 8.29k, False: 286k] | | ------------------ ------------------ 3075| 8.29k| CHECK_AT(parser->buffer, '-', 1) && ------------------ | | 175| 303k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1.32k, False: 6.96k] | | ------------------ ------------------ 3076| 1.32k| CHECK_AT(parser->buffer, '-', 2)) || ------------------ | | 175| 1.32k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 985, False: 340] | | ------------------ ------------------ 3077| 294k| (CHECK_AT(parser->buffer, '.', 0) && ------------------ | | 175| 588k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1.19k, False: 292k] | | ------------------ ------------------ 3078| 1.19k| CHECK_AT(parser->buffer, '.', 1) && ------------------ | | 175| 295k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 759, False: 435] | | ------------------ ------------------ 3079| 759| CHECK_AT(parser->buffer, '.', 2))) && ------------------ | | 175| 759| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 423, False: 336] | | ------------------ ------------------ 3080| 1.40k| IS_BLANKZ_AT(parser->buffer, 3)) ------------------ | | 371| 1.40k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 2.81k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 1.40k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2, False: 1.40k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 1.40k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.40k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 1.40k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 1.40k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 2.81k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 2.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 4, False: 1.40k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 1.40k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 2.80k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2, False: 1.39k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 1.40k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.79k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 201, False: 1.19k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 1.39k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 201| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1, False: 200] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 1.40k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.79k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 411, False: 987] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 1.39k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.80k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 215, False: 196] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 1.39k| && 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| 2.81k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 2.79k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 410, False: 987] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 1.39k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 1.80k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 214, False: 196] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 1.39k| && 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| 1.39k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.39k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 13, False: 1.38k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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| 1.03M| if (IS_Z(parser->buffer)) { ------------------ | | 287| 1.03M|#define IS_Z(string) IS_Z_AT((string),0) | | ------------------ | | | | 285| 1.03M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | ------------------ | | | | | | 175| 1.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 835, False: 1.03M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3090| 835| yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", 3091| 835| start_mark, "found unexpected end of stream"); 3092| 835| goto error; 3093| 835| } 3094| | 3095| | /* Consume non-blank characters. */ 3096| | 3097| 1.03M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 1.03M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.03M, False: 0] | | ------------------ | | 494| 1.03M| ? 1 \ | | 495| 1.03M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3097:13): [True: 0, False: 1.03M] ------------------ 3098| | 3099| 1.03M| leading_blanks = 0; 3100| | 3101| 8.10M| while (!IS_BLANKZ(parser->buffer)) ------------------ | | 373| 8.10M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 8.10M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 16.2M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 8.10M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 16.2M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 558k, False: 7.54M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 7.54M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 7.54M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 106k, False: 7.44M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 7.44M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 14.8M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 14.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 66.1k, False: 7.37M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 7.44M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 14.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 76.2k, False: 7.29M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 7.44M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 14.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.02k, False: 7.29M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 7.29M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 1.02k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 307, False: 717] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 7.44M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 14.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 371k, False: 6.92M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 7.29M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.66M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 188k, False: 183k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 7.29M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 188k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 297, False: 187k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 14.8M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 14.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 371k, False: 6.92M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 7.29M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 7.66M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 187k, False: 183k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 7.29M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 187k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.46k, False: 186k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 7.29M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 7.29M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 507, False: 7.29M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3102| 7.29M| { 3103| | /* Check for an escaped single quote. */ 3104| | 3105| 7.29M| if (single && CHECK_AT(parser->buffer, '\'', 0) ------------------ | | 175| 9.01M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 13.0k, False: 1.70M] | | ------------------ ------------------ | Branch (3105:17): [True: 1.71M, False: 5.57M] ------------------ 3106| 13.0k| && CHECK_AT(parser->buffer, '\'', 1)) ------------------ | | 175| 13.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 4.19k, False: 8.84k] | | ------------------ ------------------ 3107| 4.19k| { 3108| 4.19k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 4.19k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 3.98k, False: 213] | | ------------------ | | 147| 4.19k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 213, False: 0] | | ------------------ | | 148| 213| &(string).pointer, &(string).end)) ? \ | | 149| 4.19k| 1 : \ | | 150| 4.19k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3108:21): [True: 0, False: 4.19k] ------------------ 3109| 4.19k| *(string.pointer++) = '\''; 3110| 4.19k| SKIP(parser); ------------------ | | 502| 4.19k| (parser->mark.index ++, \ | | 503| 4.19k| parser->mark.column ++, \ | | 504| 4.19k| parser->unread --, \ | | 505| 4.19k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 4.19k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 4.19k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 4.19k, False: 0] | | | | | | ------------------ | | | | | | 381| 4.19k| ((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| 4.19k| SKIP(parser); ------------------ | | 502| 4.19k| (parser->mark.index ++, \ | | 503| 4.19k| parser->mark.column ++, \ | | 504| 4.19k| parser->unread --, \ | | 505| 4.19k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 4.19k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 4.19k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 4.19k, False: 0] | | | | | | ------------------ | | | | | | 381| 4.19k| ((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| 4.19k| } 3113| | 3114| | /* Check for the right quote. */ 3115| | 3116| 7.29M| else if (CHECK(parser->buffer, single ? '\'' : '"')) ------------------ | | 181| 7.29M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 14.5M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:48): [True: 1.71M, False: 5.57M] | | | | ------------------ | | ------------------ | | | Branch (181:29): [True: 15.9k, False: 7.27M] | | ------------------ ------------------ 3117| 15.9k| { 3118| 15.9k| break; 3119| 15.9k| } 3120| | 3121| | /* Check for an escaped line break. */ 3122| | 3123| 7.27M| else if (!single && CHECK(parser->buffer, '\\') ------------------ | | 181| 12.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.57M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.23M, False: 3.33M] | | ------------------ ------------------ | Branch (3123:22): [True: 5.57M, False: 1.70M] ------------------ 3124| 2.23M| && IS_BREAK_AT(parser->buffer, 1)) ------------------ | | 330| 2.23M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | ------------------ | | | | 175| 4.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 200k, False: 2.03M] | | | | ------------------ | | ------------------ | | 331| 2.23M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | ------------------ | | | | 175| 4.26M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 3.14k, False: 2.03M] | | | | ------------------ | | ------------------ | | 332| 2.23M| || (CHECK_AT((string),'\xC2',(offset)) \ | | ------------------ | | | | 175| 4.06M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 195, False: 2.03M] | | | | ------------------ | | ------------------ | | 333| 2.03M| && 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.23M| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 4.06M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 444, False: 2.03M] | | | | ------------------ | | ------------------ | | 335| 2.03M| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 2.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 443, False: 1] | | | | ------------------ | | ------------------ | | 336| 2.03M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | ------------------ | | | | 175| 443| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 238, False: 205] | | | | ------------------ | | ------------------ | | 337| 2.23M| || (CHECK_AT((string),'\xE2',(offset)) \ | | ------------------ | | | | 175| 4.06M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 206, False: 2.03M] | | | | ------------------ | | ------------------ | | 338| 2.03M| && CHECK_AT((string),'\x80',(offset)+1) \ | | ------------------ | | | | 175| 2.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 205, False: 1] | | | | ------------------ | | ------------------ | | 339| 2.03M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | ------------------ | | | | 175| 205| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 203, False: 2] | | | | ------------------ | | ------------------ ------------------ 3125| 204k| { 3126| 204k| if (!CACHE(parser, 3)) goto error; ------------------ | | 493| 204k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 204k, False: 36] | | ------------------ | | 494| 204k| ? 1 \ | | 495| 204k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3126:21): [True: 1, False: 204k] ------------------ 3127| 204k| SKIP(parser); ------------------ | | 502| 204k| (parser->mark.index ++, \ | | 503| 204k| parser->mark.column ++, \ | | 504| 204k| parser->unread --, \ | | 505| 204k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 204k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 204k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 204k, False: 0] | | | | | | ------------------ | | | | | | 381| 204k| ((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| 204k| SKIP_LINE(parser); ------------------ | | 508| 204k| (IS_CRLF(parser->buffer) ? \ | | ------------------ | | | | 346| 204k|#define IS_CRLF(string) IS_CRLF_AT((string),0) | | | | ------------------ | | | | | | 344| 204k| (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 408k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 200k, False: 3.78k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) | | | | | | ------------------ | | | | | | | | 175| 200k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 184k, False: 16.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 509| 204k| (parser->mark.index += 2, \ | | 510| 184k| parser->mark.column = 0, \ | | 511| 184k| parser->mark.line ++, \ | | 512| 184k| parser->unread -= 2, \ | | 513| 184k| parser->buffer.pointer += 2) : \ | | 514| 204k| IS_BREAK(parser->buffer) ? \ | | ------------------ | | | | 341| 19.9k|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | | | ------------------ | | | | | | 330| 39.8k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 39.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 16.1k, False: 3.78k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 19.9k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 23.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.14k, False: 635] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 19.9k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 1.27k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 194, False: 441] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 635| && 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| 19.9k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 882| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 441, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 441| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 882| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 441, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 441| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 441| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 238, False: 203] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 39.8k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 406| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 203, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 203| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 406| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 203, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 203| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 203| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 203, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 515| 19.9k| (parser->mark.index ++, \ | | 516| 19.9k| parser->mark.column = 0, \ | | 517| 19.9k| parser->mark.line ++, \ | | 518| 19.9k| parser->unread --, \ | | 519| 19.9k| parser->buffer.pointer += WIDTH(parser->buffer)) : 0) | | ------------------ | | | | 385| 19.9k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 19.9k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 19.2k, False: 635] | | | | | | ------------------ | | | | | | 381| 19.9k| ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \ | | | | | | ------------------ | | | | | | | Branch (381:7): [True: 194, False: 441] | | | | | | ------------------ | | | | | | 382| 635| ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \ | | | | | | ------------------ | | | | | | | Branch (382:7): [True: 441, False: 0] | | | | | | ------------------ | | | | | | 383| 441| ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) | | | | | | ------------------ | | | | | | | Branch (383:7): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3129| 204k| leading_blanks = 1; 3130| 204k| break; 3131| 204k| } 3132| | 3133| | /* Check for an escape sequence. */ 3134| | 3135| 7.07M| else if (!single && CHECK(parser->buffer, '\\')) ------------------ | | 181| 5.36M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.36M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.03M, False: 3.33M] | | ------------------ ------------------ | Branch (3135:22): [True: 5.36M, False: 1.70M] ------------------ 3136| 2.03M| { 3137| 2.03M| size_t code_length = 0; 3138| | 3139| 2.03M| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 2.03M| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 2.02M, False: 853] | | ------------------ | | 147| 2.03M| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 853, False: 0] | | ------------------ | | 148| 853| &(string).pointer, &(string).end)) ? \ | | 149| 2.03M| 1 : \ | | 150| 2.03M| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3139:21): [True: 0, False: 2.03M] ------------------ 3140| | 3141| | /* Check the escape character. */ 3142| | 3143| 2.03M| switch (parser->buffer.pointer[1]) 3144| 2.03M| { 3145| 7.88k| case '0': ------------------ | Branch (3145:21): [True: 7.88k, False: 2.02M] ------------------ 3146| 7.88k| *(string.pointer++) = '\0'; 3147| 7.88k| break; 3148| | 3149| 665k| case 'a': ------------------ | Branch (3149:21): [True: 665k, False: 1.36M] ------------------ 3150| 665k| *(string.pointer++) = '\x07'; 3151| 665k| break; 3152| | 3153| 1.87k| case 'b': ------------------ | Branch (3153:21): [True: 1.87k, False: 2.02M] ------------------ 3154| 1.87k| *(string.pointer++) = '\x08'; 3155| 1.87k| break; 3156| | 3157| 4.94k| case 't': ------------------ | Branch (3157:21): [True: 4.94k, False: 2.02M] ------------------ 3158| 25.3k| case '\t': ------------------ | Branch (3158:21): [True: 20.3k, False: 2.01M] ------------------ 3159| 25.3k| *(string.pointer++) = '\x09'; 3160| 25.3k| break; 3161| | 3162| 478| case 'n': ------------------ | Branch (3162:21): [True: 478, False: 2.02M] ------------------ 3163| 478| *(string.pointer++) = '\x0A'; 3164| 478| break; 3165| | 3166| 35.8k| case 'v': ------------------ | Branch (3166:21): [True: 35.8k, False: 1.99M] ------------------ 3167| 35.8k| *(string.pointer++) = '\x0B'; 3168| 35.8k| break; 3169| | 3170| 103k| case 'f': ------------------ | Branch (3170:21): [True: 103k, False: 1.92M] ------------------ 3171| 103k| *(string.pointer++) = '\x0C'; 3172| 103k| break; 3173| | 3174| 530k| case 'r': ------------------ | Branch (3174:21): [True: 530k, False: 1.50M] ------------------ 3175| 530k| *(string.pointer++) = '\x0D'; 3176| 530k| break; 3177| | 3178| 201k| case 'e': ------------------ | Branch (3178:21): [True: 201k, False: 1.82M] ------------------ 3179| 201k| *(string.pointer++) = '\x1B'; 3180| 201k| break; 3181| | 3182| 4.63k| case ' ': ------------------ | Branch (3182:21): [True: 4.63k, False: 2.02M] ------------------ 3183| 4.63k| *(string.pointer++) = '\x20'; 3184| 4.63k| break; 3185| | 3186| 1.69k| case '"': ------------------ | Branch (3186:21): [True: 1.69k, False: 2.02M] ------------------ 3187| 1.69k| *(string.pointer++) = '"'; 3188| 1.69k| break; 3189| | 3190| 204| case '/': ------------------ | Branch (3190:21): [True: 204, False: 2.03M] ------------------ 3191| 204| *(string.pointer++) = '/'; 3192| 204| break; 3193| | 3194| 226k| case '\\': ------------------ | Branch (3194:21): [True: 226k, False: 1.80M] ------------------ 3195| 226k| *(string.pointer++) = '\\'; 3196| 226k| break; 3197| | 3198| 127k| case 'N': /* NEL (#x85) */ ------------------ | Branch (3198:21): [True: 127k, False: 1.90M] ------------------ 3199| 127k| *(string.pointer++) = '\xC2'; 3200| 127k| *(string.pointer++) = '\x85'; 3201| 127k| break; 3202| | 3203| 506| case '_': /* #xA0 */ ------------------ | Branch (3203:21): [True: 506, False: 2.02M] ------------------ 3204| 506| *(string.pointer++) = '\xC2'; 3205| 506| *(string.pointer++) = '\xA0'; 3206| 506| break; 3207| | 3208| 4.80k| case 'L': /* LS (#x2028) */ ------------------ | Branch (3208:21): [True: 4.80k, False: 2.02M] ------------------ 3209| 4.80k| *(string.pointer++) = '\xE2'; 3210| 4.80k| *(string.pointer++) = '\x80'; 3211| 4.80k| *(string.pointer++) = '\xA8'; 3212| 4.80k| break; 3213| | 3214| 1.93k| case 'P': /* PS (#x2029) */ ------------------ | Branch (3214:21): [True: 1.93k, False: 2.02M] ------------------ 3215| 1.93k| *(string.pointer++) = '\xE2'; 3216| 1.93k| *(string.pointer++) = '\x80'; 3217| 1.93k| *(string.pointer++) = '\xA9'; 3218| 1.93k| break; 3219| | 3220| 777| case 'x': ------------------ | Branch (3220:21): [True: 777, False: 2.02M] ------------------ 3221| 777| code_length = 2; 3222| 777| break; 3223| | 3224| 618| case 'u': ------------------ | Branch (3224:21): [True: 618, False: 2.02M] ------------------ 3225| 618| code_length = 4; 3226| 618| break; 3227| | 3228| 88.3k| case 'U': ------------------ | Branch (3228:21): [True: 88.3k, False: 1.94M] ------------------ 3229| 88.3k| code_length = 8; 3230| 88.3k| break; 3231| | 3232| 30| default: ------------------ | Branch (3232:21): [True: 30, False: 2.03M] ------------------ 3233| 30| yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 3234| 30| start_mark, "found unknown escape character"); 3235| 30| goto error; 3236| 2.03M| } 3237| | 3238| 2.03M| SKIP(parser); ------------------ | | 502| 2.03M| (parser->mark.index ++, \ | | 503| 2.03M| parser->mark.column ++, \ | | 504| 2.03M| parser->unread --, \ | | 505| 2.03M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.03M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.03M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.03M, False: 0] | | | | | | ------------------ | | | | | | 381| 2.03M| ((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.03M| SKIP(parser); ------------------ | | 502| 2.03M| (parser->mark.index ++, \ | | 503| 2.03M| parser->mark.column ++, \ | | 504| 2.03M| parser->unread --, \ | | 505| 2.03M| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 2.03M|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 2.03M| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 2.03M, False: 0] | | | | | | ------------------ | | | | | | 381| 2.03M| ((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.03M| if (code_length) ------------------ | Branch (3243:21): [True: 89.7k, False: 1.94M] ------------------ 3244| 89.7k| { 3245| 89.7k| unsigned int value = 0; 3246| 89.7k| size_t k; 3247| | 3248| | /* Scan the character value. */ 3249| | 3250| 89.7k| if (!CACHE(parser, code_length)) goto error; ------------------ | | 493| 89.7k| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 89.6k, False: 110] | | ------------------ | | 494| 89.7k| ? 1 \ | | 495| 89.7k| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3250:25): [True: 1, False: 89.7k] ------------------ 3251| | 3252| 800k| for (k = 0; k < code_length; k ++) { ------------------ | Branch (3252:33): [True: 710k, False: 89.6k] ------------------ 3253| 710k| if (!IS_HEX_AT(parser->buffer, k)) { ------------------ | | 224| 710k| (((string).pointer[offset] >= (yaml_char_t) '0' && \ | | ------------------ | | | Branch (224:8): [True: 710k, False: 43] | | ------------------ | | 225| 710k| (string).pointer[offset] <= (yaml_char_t) '9') || \ | | ------------------ | | | Branch (225:8): [True: 568k, False: 141k] | | ------------------ | | 226| 710k| ((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (226:8): [True: 141k, False: 47] | | ------------------ | | 227| 141k| (string).pointer[offset] <= (yaml_char_t) 'F') || \ | | ------------------ | | | Branch (227:8): [True: 1.76k, False: 140k] | | ------------------ | | 228| 710k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (228:8): [True: 140k, False: 50] | | ------------------ | | 229| 140k| (string).pointer[offset] <= (yaml_char_t) 'f')) | | ------------------ | | | Branch (229:8): [True: 140k, False: 3] | | ------------------ ------------------ 3254| 53| yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 3255| 53| start_mark, "did not find expected hexdecimal number"); 3256| 53| goto error; 3257| 53| } 3258| 710k| value = (value << 4) + AS_HEX_AT(parser->buffer, k); ------------------ | | 238| 710k| (((string).pointer[offset] >= (yaml_char_t) 'A' && \ | | ------------------ | | | Branch (238:9): [True: 141k, False: 568k] | | ------------------ | | 239| 710k| (string).pointer[offset] <= (yaml_char_t) 'F') ? \ | | ------------------ | | | Branch (239:9): [True: 1.76k, False: 140k] | | ------------------ | | 240| 710k| ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \ | | 241| 710k| ((string).pointer[offset] >= (yaml_char_t) 'a' && \ | | ------------------ | | | Branch (241:9): [True: 140k, False: 568k] | | ------------------ | | 242| 708k| (string).pointer[offset] <= (yaml_char_t) 'f') ? \ | | ------------------ | | | Branch (242:9): [True: 140k, False: 0] | | ------------------ | | 243| 708k| ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \ | | 244| 708k| ((string).pointer[offset] - (yaml_char_t) '0')) ------------------ 3259| 710k| } 3260| | 3261| | /* Check the value and write the character. */ 3262| | 3263| 89.6k| if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { ------------------ | Branch (3263:26): [True: 1.16k, False: 88.4k] | Branch (3263:45): [True: 6, False: 1.15k] | Branch (3263:65): [True: 32, False: 89.6k] ------------------ 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| 89.6k| if (value <= 0x7F) { ------------------ | Branch (3269:25): [True: 8.41k, False: 81.2k] ------------------ 3270| 8.41k| *(string.pointer++) = value; 3271| 8.41k| } 3272| 81.2k| else if (value <= 0x7FF) { ------------------ | Branch (3272:30): [True: 67.7k, False: 13.4k] ------------------ 3273| 67.7k| *(string.pointer++) = 0xC0 + (value >> 6); 3274| 67.7k| *(string.pointer++) = 0x80 + (value & 0x3F); 3275| 67.7k| } 3276| 13.4k| else if (value <= 0xFFFF) { ------------------ | Branch (3276:30): [True: 12.8k, False: 567] ------------------ 3277| 12.8k| *(string.pointer++) = 0xE0 + (value >> 12); 3278| 12.8k| *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); 3279| 12.8k| *(string.pointer++) = 0x80 + (value & 0x3F); 3280| 12.8k| } 3281| 567| else { 3282| 567| *(string.pointer++) = 0xF0 + (value >> 18); 3283| 567| *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F); 3284| 567| *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); 3285| 567| *(string.pointer++) = 0x80 + (value & 0x3F); 3286| 567| } 3287| | 3288| | /* Advance the pointer. */ 3289| | 3290| 799k| for (k = 0; k < code_length; k ++) { ------------------ | Branch (3290:33): [True: 709k, False: 89.6k] ------------------ 3291| 709k| SKIP(parser); ------------------ | | 502| 709k| (parser->mark.index ++, \ | | 503| 709k| parser->mark.column ++, \ | | 504| 709k| parser->unread --, \ | | 505| 709k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 709k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 709k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 709k, False: 0] | | | | | | ------------------ | | | | | | 381| 709k| ((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| 709k| } 3293| 89.6k| } 3294| 2.03M| } 3295| | 3296| 5.04M| else 3297| 5.04M| { 3298| | /* It is a non-escaped non-blank character. */ 3299| | 3300| 5.04M| if (!READ(parser, string)) goto error; ------------------ | | 526| 5.04M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 5.04M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 5.04M, False: 0] | | | | | Branch (146:7): [True: 5.03M, False: 6.42k] | | | | ------------------ | | | | 147| 5.04M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 6.42k, False: 0] | | | | ------------------ | | | | 148| 6.42k| &(string).pointer, &(string).end)) ? \ | | | | 149| 5.04M| 1 : \ | | | | 150| 5.04M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 5.04M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 5.04M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 4.45M, False: 586k] | | | | ------------------ | | | | 399| 5.04M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 5.04M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 762, False: 585k] | | | | ------------------ | | | | 401| 586k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 762| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 586k| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 585k, False: 262] | | | | ------------------ | | | | 404| 585k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 585k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 585k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 585k| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 262, False: 0] | | | | ------------------ | | | | 408| 262| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 262| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 262| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 262| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 5.04M| parser->mark.index ++, \ | | 529| 5.04M| parser->mark.column ++, \ | | 530| 5.04M| parser->unread --, \ | | 531| 5.04M| 1) : 0) ------------------ | Branch (3300:21): [True: 0, False: 5.04M] ------------------ 3301| 5.04M| } 3302| | 3303| 7.07M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 7.07M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 7.07M, False: 1.24k] | | ------------------ | | 494| 7.07M| ? 1 \ | | 495| 7.07M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3303:17): [True: 6, False: 7.07M] ------------------ 3304| 7.07M| } 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| 1.03M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.03M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.03M, False: 41] | | ------------------ | | 494| 1.03M| ? 1 \ | | 495| 1.03M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3312:13): [True: 1, False: 1.03M] ------------------ 3313| 1.03M| if (CHECK(parser->buffer, single ? '\'' : '"')) ------------------ | | 181| 1.03M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 2.06M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:48): [True: 351k, False: 678k] | | | | ------------------ | | ------------------ | | | Branch (181:29): [True: 15.9k, False: 1.01M] | | ------------------ ------------------ 3314| 15.9k| break; 3315| | 3316| | /* Consume blank characters. */ 3317| | 3318| 1.01M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 1.01M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.01M, False: 0] | | ------------------ | | 494| 1.01M| ? 1 \ | | 495| 1.01M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3318:13): [True: 0, False: 1.01M] ------------------ 3319| | 3320| 6.93M| while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 323| 6.93M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 13.8M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 6.93M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 13.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.89M, False: 3.03M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 3.03M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 3.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 571k, False: 2.46M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 341| 2.46M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 2.46M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 4.92M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 999k, False: 1.46M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 2.46M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 3.92M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 447k, False: 1.01M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 2.46M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 827, False: 1.01M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 1.01M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 827| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 563, False: 264] | | | | | | ------------------ | | | | ------------------ | | | | 334| 2.46M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 3.01k, False: 1.01M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 1.01M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 1.01M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.80k, False: 210] | | | | | | ------------------ | | | | ------------------ | | | | 336| 1.01M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 2.80k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 774, False: 2.03k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 2.46M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 2.03M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.24k, False: 1.01M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 1.01M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 1.01M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2.03k, False: 210] | | | | | | ------------------ | | | | ------------------ | | | | 339| 1.01M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 2.03k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.90k, False: 135] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3321| 5.91M| { 3322| 5.91M| if (IS_BLANK(parser->buffer)) ------------------ | | 323| 5.91M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 5.91M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 5.91M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 11.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.89M, False: 2.02M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 2.02M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.02M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 571k, False: 1.44M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3323| 4.46M| { 3324| | /* Consume a space or a tab character. */ 3325| | 3326| 4.46M| if (!leading_blanks) { ------------------ | Branch (3326:21): [True: 3.50M, False: 959k] ------------------ 3327| 3.50M| if (!READ(parser, whitespaces)) goto error; ------------------ | | 526| 3.50M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 3.50M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 3.50M, False: 0] | | | | | Branch (146:7): [True: 3.50M, False: 868] | | | | ------------------ | | | | 147| 3.50M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 868, False: 0] | | | | ------------------ | | | | 148| 868| &(string).pointer, &(string).end)) ? \ | | | | 149| 3.50M| 1 : \ | | | | 150| 3.50M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 3.50M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 3.50M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 3.50M, False: 0] | | | | ------------------ | | | | 399| 3.50M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 3.50M| (*(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.50M| parser->mark.index ++, \ | | 529| 3.50M| parser->mark.column ++, \ | | 530| 3.50M| parser->unread --, \ | | 531| 3.50M| 1) : 0) ------------------ | Branch (3327:25): [True: 0, False: 3.50M] ------------------ 3328| 3.50M| } 3329| 959k| else { 3330| 959k| SKIP(parser); ------------------ | | 502| 959k| (parser->mark.index ++, \ | | 503| 959k| parser->mark.column ++, \ | | 504| 959k| parser->unread --, \ | | 505| 959k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 959k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 959k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 959k, False: 0] | | | | | | ------------------ | | | | | | 381| 959k| ((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| 959k| } 3332| 4.46M| } 3333| 1.44M| else 3334| 1.44M| { 3335| 1.44M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 1.44M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.44M, False: 149] | | ------------------ | | 494| 1.44M| ? 1 \ | | 495| 1.44M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3335:21): [True: 1, False: 1.44M] ------------------ 3336| | 3337| | /* Check if it is a first line break. */ 3338| | 3339| 1.44M| if (!leading_blanks) ------------------ | Branch (3339:21): [True: 148k, False: 1.30M] ------------------ 3340| 148k| { 3341| 148k| CLEAR(parser, whitespaces); ------------------ | | 154| 148k| ((string).pointer = (string).start, \ | | 155| 148k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3342| 148k| if (!READ_LINE(parser, leading_break)) goto error; ------------------ | | 538| 148k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 148k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 148k, False: 0] | | | | | Branch (146:7): [True: 148k, False: 0] | | | | ------------------ | | | | 147| 148k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 148k| 1 : \ | | | | 150| 148k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 148k| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 297k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 66.7k, False: 81.7k] | | | | ------------------ | | ------------------ | | 540| 148k| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 66.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 11.0k, False: 55.6k] | | | | ------------------ | | ------------------ | | 541| 148k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 11.0k| parser->buffer.pointer += 2, \ | | 543| 11.0k| parser->mark.index += 2, \ | | 544| 11.0k| parser->mark.column = 0, \ | | 545| 11.0k| parser->mark.line ++, \ | | 546| 11.0k| parser->unread -= 2) : \ | | 547| 148k| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 274k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 55.6k, False: 81.7k] | | | | ------------------ | | ------------------ | | 548| 137k| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 81.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 79.7k, False: 2.07k] | | | | ------------------ | | ------------------ | | 549| 137k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 135k| parser->buffer.pointer ++, \ | | 551| 135k| parser->mark.index ++, \ | | 552| 135k| parser->mark.column = 0, \ | | 553| 135k| parser->mark.line ++, \ | | 554| 135k| parser->unread --) : \ | | 555| 137k| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 4.14k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 308, False: 1.76k] | | | | ------------------ | | ------------------ | | 556| 2.07k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 308| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 308, False: 0] | | | | ------------------ | | ------------------ | | 557| 2.07k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 308| parser->buffer.pointer += 2, \ | | 559| 308| parser->mark.index ++, \ | | 560| 308| parser->mark.column = 0, \ | | 561| 308| parser->mark.line ++, \ | | 562| 308| parser->unread --) : \ | | 563| 2.07k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 3.53k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.76k, False: 0] | | | | ------------------ | | ------------------ | | 564| 1.76k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 3.53k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.76k, False: 0] | | | | ------------------ | | ------------------ | | 565| 1.76k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 3.53k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 297, False: 1.46k] | | | | ------------------ | | ------------------ | | 566| 1.76k| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 1.46k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.46k, False: 0] | | | | ------------------ | | ------------------ | | 567| 1.76k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 1.76k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 1.76k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 1.76k| parser->mark.index ++, \ | | 571| 1.76k| parser->mark.column = 0, \ | | 572| 1.76k| parser->mark.line ++, \ | | 573| 1.76k| parser->unread --) : 0), \ | | 574| 148k| 1) : 0) ------------------ | Branch (3342:25): [True: 0, False: 148k] ------------------ 3343| 148k| leading_blanks = 1; 3344| 148k| } 3345| 1.30M| else 3346| 1.30M| { 3347| 1.30M| if (!READ_LINE(parser, trailing_breaks)) goto error; ------------------ | | 538| 1.30M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 1.30M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 1.30M, False: 0] | | | | | Branch (146:7): [True: 1.30M, False: 675] | | | | ------------------ | | | | 147| 1.30M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 675, False: 0] | | | | ------------------ | | | | 148| 675| &(string).pointer, &(string).end)) ? \ | | | | 149| 1.30M| 1 : \ | | | | 150| 1.30M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 1.30M| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.60M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 932k, False: 368k] | | | | ------------------ | | ------------------ | | 540| 1.30M| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 932k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 9.67k, False: 922k] | | | | ------------------ | | ------------------ | | 541| 1.30M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 9.67k| parser->buffer.pointer += 2, \ | | 543| 9.67k| parser->mark.index += 2, \ | | 544| 9.67k| parser->mark.column = 0, \ | | 545| 9.67k| parser->mark.line ++, \ | | 546| 9.67k| parser->unread -= 2) : \ | | 547| 1.30M| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.58M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 922k, False: 368k] | | | | ------------------ | | ------------------ | | 548| 1.29M| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 368k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 367k, False: 1.16k] | | | | ------------------ | | ------------------ | | 549| 1.29M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 1.29M| parser->buffer.pointer ++, \ | | 551| 1.29M| parser->mark.index ++, \ | | 552| 1.29M| parser->mark.column = 0, \ | | 553| 1.29M| parser->mark.line ++, \ | | 554| 1.29M| parser->unread --) : \ | | 555| 1.29M| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 2.32k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 255, False: 909] | | | | ------------------ | | ------------------ | | 556| 1.16k| && 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.16k| (*((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.16k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 1.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 909, False: 0] | | | | ------------------ | | ------------------ | | 564| 909| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 1.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 909, False: 0] | | | | ------------------ | | ------------------ | | 565| 909| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 1.81k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 477, False: 432] | | | | ------------------ | | ------------------ | | 566| 909| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 432| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 432, False: 0] | | | | ------------------ | | ------------------ | | 567| 909| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 909| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 909| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 909| parser->mark.index ++, \ | | 571| 909| parser->mark.column = 0, \ | | 572| 909| parser->mark.line ++, \ | | 573| 909| parser->unread --) : 0), \ | | 574| 1.30M| 1) : 0) ------------------ | Branch (3347:25): [True: 0, False: 1.30M] ------------------ 3348| 1.30M| } 3349| 1.44M| } 3350| 5.91M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 5.91M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 5.91M, False: 269] | | ------------------ | | 494| 5.91M| ? 1 \ | | 495| 5.91M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3350:17): [True: 1, False: 5.91M] ------------------ 3351| 5.91M| } 3352| | 3353| | /* Join the whitespaces or fold line breaks. */ 3354| | 3355| 1.01M| if (leading_blanks) ------------------ | Branch (3355:13): [True: 353k, False: 661k] ------------------ 3356| 353k| { 3357| | /* Do we need to fold line breaks? */ 3358| | 3359| 353k| if (leading_break.start[0] == '\n') { ------------------ | Branch (3359:17): [True: 146k, False: 206k] ------------------ 3360| 146k| if (trailing_breaks.start[0] == '\0') { ------------------ | Branch (3360:21): [True: 125k, False: 21.3k] ------------------ 3361| 125k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 125k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 125k, False: 388] | | ------------------ | | 147| 125k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 388, False: 0] | | ------------------ | | 148| 388| &(string).pointer, &(string).end)) ? \ | | 149| 125k| 1 : \ | | 150| 125k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3361:25): [True: 0, False: 125k] ------------------ 3362| 125k| *(string.pointer++) = ' '; 3363| 125k| } 3364| 21.3k| else { 3365| 21.3k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 21.3k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 21.3k, False: 0] | | ------------------ | | 159| 21.3k| &(string_a).end, &(string_b).start, \ | | 160| 21.3k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 21.3k| ((string_b).pointer = (string_b).start, \ | | 162| 21.3k| 1) : \ | | 163| 21.3k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3365:25): [True: 0, False: 21.3k] ------------------ 3366| 21.3k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 21.3k| ((string).pointer = (string).start, \ | | 155| 21.3k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3367| 21.3k| } 3368| 146k| CLEAR(parser, leading_break); ------------------ | | 154| 146k| ((string).pointer = (string).start, \ | | 155| 146k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3369| 146k| } 3370| 206k| else { 3371| 206k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 206k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 206k, False: 0] | | ------------------ | | 159| 206k| &(string_a).end, &(string_b).start, \ | | 160| 206k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 206k| ((string_b).pointer = (string_b).start, \ | | 162| 206k| 1) : \ | | 163| 206k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3371:21): [True: 0, False: 206k] ------------------ 3372| 206k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 206k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 206k, False: 0] | | ------------------ | | 159| 206k| &(string_a).end, &(string_b).start, \ | | 160| 206k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 206k| ((string_b).pointer = (string_b).start, \ | | 162| 206k| 1) : \ | | 163| 206k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3372:21): [True: 0, False: 206k] ------------------ 3373| 206k| CLEAR(parser, leading_break); ------------------ | | 154| 206k| ((string).pointer = (string).start, \ | | 155| 206k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3374| 206k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 206k| ((string).pointer = (string).start, \ | | 155| 206k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3375| 206k| } 3376| 353k| } 3377| 661k| else 3378| 661k| { 3379| 661k| if (!JOIN(parser, string, whitespaces)) goto error; ------------------ | | 158| 661k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 661k, False: 0] | | ------------------ | | 159| 661k| &(string_a).end, &(string_b).start, \ | | 160| 661k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 661k| ((string_b).pointer = (string_b).start, \ | | 162| 661k| 1) : \ | | 163| 661k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3379:17): [True: 0, False: 661k] ------------------ 3380| 661k| CLEAR(parser, whitespaces); ------------------ | | 154| 661k| ((string).pointer = (string).start, \ | | 155| 661k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3381| 661k| } 3382| 1.01M| } 3383| | 3384| | /* Eat the right quote. */ 3385| | 3386| 15.9k| SKIP(parser); ------------------ | | 502| 15.9k| (parser->mark.index ++, \ | | 503| 15.9k| parser->mark.column ++, \ | | 504| 15.9k| parser->unread --, \ | | 505| 15.9k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 15.9k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 15.9k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 15.9k, False: 0] | | | | | | ------------------ | | | | | | 381| 15.9k| ((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| 15.9k| end_mark = parser->mark; 3389| | 3390| | /* Create a token. */ 3391| | 3392| 15.9k| SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, ------------------ | | 526| 15.9k| (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 15.9k| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 15.9k| (token).type = (token_type), \ | | | | 502| 15.9k| (token).start_mark = (token_start_mark), \ | | | | 503| 15.9k| (token).end_mark = (token_end_mark)) | | ------------------ | | 527| 15.9k| (token).data.scalar.value = (token_value), \ | | 528| 15.9k| (token).data.scalar.length = (token_length), \ | | 529| 31.9k| (token).data.scalar.style = (token_style)) | | ------------------ | | | Branch (529:35): [True: 8.84k, False: 7.14k] | | ------------------ ------------------ 3393| 15.9k| single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE, 3394| 15.9k| start_mark, end_mark); 3395| | 3396| 15.9k| STRING_DEL(parser, leading_break); ------------------ | | 142| 15.9k| (yaml_free((string).start), \ | | 143| 15.9k| (string).start = (string).pointer = (string).end = 0) ------------------ 3397| 15.9k| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 15.9k| (yaml_free((string).start), \ | | 143| 15.9k| (string).start = (string).pointer = (string).end = 0) ------------------ 3398| 15.9k| STRING_DEL(parser, whitespaces); ------------------ | | 142| 15.9k| (yaml_free((string).start), \ | | 143| 15.9k| (string).start = (string).pointer = (string).end = 0) ------------------ 3399| | 3400| 15.9k| return 1; 3401| | 3402| 997|error: 3403| 997| STRING_DEL(parser, string); ------------------ | | 142| 997| (yaml_free((string).start), \ | | 143| 997| (string).start = (string).pointer = (string).end = 0) ------------------ 3404| 997| STRING_DEL(parser, leading_break); ------------------ | | 142| 997| (yaml_free((string).start), \ | | 143| 997| (string).start = (string).pointer = (string).end = 0) ------------------ 3405| 997| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 997| (yaml_free((string).start), \ | | 143| 997| (string).start = (string).pointer = (string).end = 0) ------------------ 3406| 997| STRING_DEL(parser, whitespaces); ------------------ | | 142| 997| (yaml_free((string).start), \ | | 143| 997| (string).start = (string).pointer = (string).end = 0) ------------------ 3407| | 3408| 997| return 0; 3409| 16.9k|} scanner.c:yaml_parser_fetch_plain_scalar: 1908| 3.38M|{ 1909| 3.38M| yaml_token_t token; 1910| | 1911| | /* A plain scalar could be a simple key. */ 1912| | 1913| 3.38M| if (!yaml_parser_save_simple_key(parser)) ------------------ | Branch (1913:9): [True: 0, False: 3.38M] ------------------ 1914| 0| return 0; 1915| | 1916| | /* A simple key cannot follow a flow scalar. */ 1917| | 1918| 3.38M| parser->simple_key_allowed = 0; 1919| | 1920| | /* Create the SCALAR token and append it to the queue. */ 1921| | 1922| 3.38M| if (!yaml_parser_scan_plain_scalar(parser, &token)) ------------------ | Branch (1922:9): [True: 64, False: 3.38M] ------------------ 1923| 64| return 0; 1924| | 1925| 3.38M| if (!ENQUEUE(parser, parser->tokens, token)) { ------------------ | | 472| 3.38M| (((queue).tail != (queue).end \ | | ------------------ | | | Branch (472:7): [True: 3.32M, False: 64.2k] | | ------------------ | | 473| 3.38M| || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \ | | ------------------ | | | Branch (473:10): [True: 64.2k, False: 0] | | ------------------ | | 474| 64.2k| (void **)&(queue).tail, (void **)&(queue).end)) ? \ | | 475| 3.38M| (*((queue).tail++) = value, \ | | 476| 3.38M| 1) : \ | | 477| 3.38M| ((context)->error = YAML_MEMORY_ERROR, \ | | 478| 0| 0)) ------------------ | Branch (1925:9): [True: 0, False: 3.38M] ------------------ 1926| 0| yaml_token_delete(&token); 1927| 0| return 0; 1928| 0| } 1929| | 1930| 3.38M| return 1; 1931| 3.38M|} scanner.c:yaml_parser_scan_plain_scalar: 3417| 3.38M|{ 3418| 3.38M| yaml_mark_t start_mark; 3419| 3.38M| yaml_mark_t end_mark; 3420| 3.38M| yaml_string_t string = NULL_STRING; ------------------ | | 123| 3.38M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3421| 3.38M| yaml_string_t leading_break = NULL_STRING; ------------------ | | 123| 3.38M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3422| 3.38M| yaml_string_t trailing_breaks = NULL_STRING; ------------------ | | 123| 3.38M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3423| 3.38M| yaml_string_t whitespaces = NULL_STRING; ------------------ | | 123| 3.38M|#define NULL_STRING { NULL, NULL, NULL } ------------------ 3424| 3.38M| int leading_blanks = 0; 3425| 3.38M| int indent = parser->indent+1; 3426| | 3427| 3.38M| if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.38M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.38M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.38M, False: 0] | | ------------------ | | 134| 3.38M| ((string).pointer = (string).start, \ | | 135| 3.38M| (string).end = (string).start+(size), \ | | 136| 3.38M| memset((string).start, 0, (size)), \ | | 137| 3.38M| 1) : \ | | 138| 3.38M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3427:9): [True: 0, False: 3.38M] ------------------ 3428| 3.38M| if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.38M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.38M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.38M, False: 0] | | ------------------ | | 134| 3.38M| ((string).pointer = (string).start, \ | | 135| 3.38M| (string).end = (string).start+(size), \ | | 136| 3.38M| memset((string).start, 0, (size)), \ | | 137| 3.38M| 1) : \ | | 138| 3.38M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3428:9): [True: 0, False: 3.38M] ------------------ 3429| 3.38M| if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.38M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.38M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.38M, False: 0] | | ------------------ | | 134| 3.38M| ((string).pointer = (string).start, \ | | 135| 3.38M| (string).end = (string).start+(size), \ | | 136| 3.38M| memset((string).start, 0, (size)), \ | | 137| 3.38M| 1) : \ | | 138| 3.38M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3429:9): [True: 0, False: 3.38M] ------------------ 3430| 3.38M| if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; ------------------ | | 133| 3.38M| (((string).start = YAML_MALLOC(size)) ? \ | | ------------------ | | | | 684| 3.38M|#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size) | | ------------------ | | | Branch (133:6): [True: 3.38M, False: 0] | | ------------------ | | 134| 3.38M| ((string).pointer = (string).start, \ | | 135| 3.38M| (string).end = (string).start+(size), \ | | 136| 3.38M| memset((string).start, 0, (size)), \ | | 137| 3.38M| 1) : \ | | 138| 3.38M| ((context)->error = YAML_MEMORY_ERROR, \ | | 139| 0| 0)) ------------------ | Branch (3430:9): [True: 0, False: 3.38M] ------------------ 3431| | 3432| 3.38M| start_mark = end_mark = parser->mark; 3433| | 3434| | /* Consume the content of the plain scalar. */ 3435| | 3436| 6.17M| while (1) ------------------ | Branch (3436:12): [True: 6.17M, Folded] ------------------ 3437| 6.17M| { 3438| | /* Check for a document indicator. */ 3439| | 3440| 6.17M| if (!CACHE(parser, 4)) goto error; ------------------ | | 493| 6.17M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 6.17M, False: 2.52k] | | ------------------ | | 494| 6.17M| ? 1 \ | | 495| 6.17M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3440:13): [True: 5, False: 6.17M] ------------------ 3441| | 3442| 6.17M| if (parser->mark.column == 0 && ------------------ | Branch (3442:13): [True: 159k, False: 6.01M] ------------------ 3443| 159k| ((CHECK_AT(parser->buffer, '-', 0) && ------------------ | | 175| 318k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 86.8k, False: 72.5k] | | ------------------ ------------------ 3444| 86.8k| CHECK_AT(parser->buffer, '-', 1) && ------------------ | | 175| 246k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 34.0k, False: 52.7k] | | ------------------ ------------------ 3445| 34.0k| CHECK_AT(parser->buffer, '-', 2)) || ------------------ | | 175| 34.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 7.15k, False: 26.9k] | | ------------------ ------------------ 3446| 152k| (CHECK_AT(parser->buffer, '.', 0) && ------------------ | | 175| 304k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 5.20k, False: 146k] | | ------------------ ------------------ 3447| 5.20k| CHECK_AT(parser->buffer, '.', 1) && ------------------ | | 175| 157k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2.00k, False: 3.20k] | | ------------------ ------------------ 3448| 2.00k| CHECK_AT(parser->buffer, '.', 2))) && ------------------ | | 175| 2.00k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1.31k, False: 692] | | ------------------ ------------------ 3449| 8.46k| IS_BLANKZ_AT(parser->buffer, 3)) break; ------------------ | | 371| 8.46k| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 16.9k| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 8.46k|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 16.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 254, False: 8.21k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 8.21k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 8.21k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 329, False: 7.88k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 7.88k| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 15.7k| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 15.7k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.26k, False: 6.62k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 7.88k| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 14.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 424, False: 6.19k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 7.88k| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 12.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.61k, False: 4.58k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 6.19k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.61k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.01k, False: 598] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 7.88k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 10.3k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.43k, False: 2.75k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 5.18k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 7.61k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.11k, False: 1.31k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 5.18k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.11k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 266, False: 847] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 15.7k| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 9.83k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.16k, False: 2.75k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 4.91k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 7.08k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 847, False: 1.31k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 4.91k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 847| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 253, False: 594] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 4.66k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 4.66k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 10, False: 4.65k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3450| | 3451| | /* Check for a comment. */ 3452| | 3453| 6.17M| if (CHECK(parser->buffer, '#')) ------------------ | | 181| 6.17M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 6.17M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 458, False: 6.17M] | | ------------------ ------------------ 3454| 458| break; 3455| | 3456| | /* Consume non-blank characters. */ 3457| | 3458| 30.6M| while (!IS_BLANKZ(parser->buffer)) ------------------ | | 373| 30.6M|#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) | | ------------------ | | | | 371| 30.6M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 321| 61.3M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 304| 30.6M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 61.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2.73M, False: 27.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 312| 27.9M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 27.9M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.96k, False: 27.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | | | ------------------ | | | | | | 353| 27.9M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 330| 55.8M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 29.2k, False: 27.9M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 331| 27.9M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 81.1k, False: 27.8M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 332| 27.9M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 31.5k, False: 27.7M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 333| 27.8M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 31.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 777, False: 30.7k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 334| 27.9M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.49M, False: 24.3M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 335| 27.8M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 31.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.30M, False: 194k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 336| 27.8M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.30M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 1.95k, False: 3.30M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 337| 55.8M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 55.6M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.49M, False: 24.3M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 338| 27.8M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | | | ------------------ | | | | | | | | | | 175| 31.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 3.30M, False: 194k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 339| 27.8M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | | | ------------------ | | | | | | | | | | 175| 3.30M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 8.05k, False: 3.29M] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | | | ------------------ | | | | | | | | 285| 27.8M|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | | | ------------------ | | | | | | | | | | 175| 27.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (175:5): [True: 2.24k, 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: 7.59M, False: 20.2M] ------------------ 3466| 7.59M| && CHECK(parser->buffer, ':') ------------------ | | 181| 35.4M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 7.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.35k, False: 7.59M] | | ------------------ ------------------ 3467| 1.35k| && ( 3468| 1.35k| CHECK_AT(parser->buffer, ',', 1) ------------------ | | 175| 2.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 1.35k] | | ------------------ ------------------ 3469| 1.35k| || CHECK_AT(parser->buffer, '?', 1) ------------------ | | 175| 2.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 1.35k] | | ------------------ ------------------ 3470| 1.35k| || CHECK_AT(parser->buffer, '[', 1) ------------------ | | 175| 2.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 1.35k] | | ------------------ ------------------ 3471| 1.35k| || CHECK_AT(parser->buffer, ']', 1) ------------------ | | 175| 2.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 2, False: 1.34k] | | ------------------ ------------------ 3472| 1.34k| || CHECK_AT(parser->buffer, '{', 1) ------------------ | | 175| 2.70k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 1.34k] | | ------------------ ------------------ 3473| 1.34k| || CHECK_AT(parser->buffer, '}', 1) ------------------ | | 175| 1.34k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (175:5): [True: 1, False: 1.34k] | | ------------------ ------------------ 3474| 1.35k| ) 3475| 27.8M| ) { 3476| 7| yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 3477| 7| start_mark, "found unexpected ':'"); 3478| 7| goto error; 3479| 7| } 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.6M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 27.8M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.36M, False: 26.4M] | | ------------------ ------------------ if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1)) ------------------ | | 371| 1.36M| (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 321| 2.72M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 1.36M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 2.72M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 3.68k, False: 1.36M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 1.36M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.36M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 537, False: 1.35M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) | | ------------------ | | | | 353| 1.35M| (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 330| 2.71M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | | | ------------------ | | | | | | | | 175| 2.71M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 34.9k, False: 1.32M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 331| 1.35M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | | | ------------------ | | | | | | | | 175| 2.68M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 886k, False: 438k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 332| 1.35M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 876k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 793, False: 437k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 333| 438k| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | | | ------------------ | | | | | | | | 175| 793| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 200, False: 593] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 334| 1.35M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 876k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.96k, False: 436k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 335| 438k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 440k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.50k, False: 463] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 336| 438k| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | | | ------------------ | | | | | | | | 175| 1.50k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 548, False: 956] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 337| 2.71M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | | | ------------------ | | | | | | | | 175| 875k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.41k, False: 436k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 338| 437k| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | | | ------------------ | | | | | | | | 175| 438k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 956, False: 463] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 339| 437k| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | | | ------------------ | | | | | | | | 175| 956| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 430, False: 526] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) | | | | ------------------ | | | | | | 285| 437k|#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) | | | | | | ------------------ | | | | | | | | 175| 437k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 186, False: 436k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3484| 26.8M| || (parser->flow_level && ------------------ | Branch (3484:25): [True: 7.59M, False: 19.2M] ------------------ 3485| 7.59M| (CHECK(parser->buffer, ',') ------------------ | | 181| 15.1M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 7.59M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 2.38M, False: 5.21M] | | ------------------ ------------------ 3486| 5.21M| || CHECK(parser->buffer, '[') ------------------ | | 181| 12.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.21M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.04k, False: 5.20M] | | ------------------ ------------------ 3487| 5.20M| || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 12.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.20M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 1.31k, False: 5.20M] | | ------------------ ------------------ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') ------------------ | | 181| 12.8M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.20M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 613, False: 5.20M] | | ------------------ ------------------ 3488| 5.20M| || CHECK(parser->buffer, '}')))) ------------------ | | 181| 5.20M|#define CHECK(string,octet) (CHECK_AT((string),(octet),0)) | | ------------------ | | | | 175| 5.20M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | ------------------ | | | Branch (181:29): [True: 459, False: 5.20M] | | ------------------ ------------------ 3489| 3.31M| break; 3490| | 3491| | /* Check if we need to join whitespaces and breaks. */ 3492| | 3493| 24.5M| if (leading_blanks || whitespaces.start != whitespaces.pointer) ------------------ | Branch (3493:17): [True: 51.2k, False: 24.4M] | Branch (3493:35): [True: 2.72M, False: 21.7M] ------------------ 3494| 2.78M| { 3495| 2.78M| if (leading_blanks) ------------------ | Branch (3495:21): [True: 51.2k, False: 2.72M] ------------------ 3496| 51.2k| { 3497| | /* Do we need to fold line breaks? */ 3498| | 3499| 51.2k| if (leading_break.start[0] == '\n') { ------------------ | Branch (3499:25): [True: 42.1k, False: 9.11k] ------------------ 3500| 42.1k| if (trailing_breaks.start[0] == '\0') { ------------------ | Branch (3500:29): [True: 28.0k, False: 14.1k] ------------------ 3501| 28.0k| if (!STRING_EXTEND(parser, string)) goto error; ------------------ | | 146| 28.0k| ((((string).pointer+5 < (string).end) \ | | ------------------ | | | Branch (146:7): [True: 27.6k, False: 424] | | ------------------ | | 147| 28.0k| || yaml_string_extend(&(string).start, \ | | ------------------ | | | Branch (147:12): [True: 424, False: 0] | | ------------------ | | 148| 424| &(string).pointer, &(string).end)) ? \ | | 149| 28.0k| 1 : \ | | 150| 28.0k| ((context)->error = YAML_MEMORY_ERROR, \ | | 151| 0| 0)) ------------------ | Branch (3501:33): [True: 0, False: 28.0k] ------------------ 3502| 28.0k| *(string.pointer++) = ' '; 3503| 28.0k| } 3504| 14.1k| else { 3505| 14.1k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 14.1k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 14.1k, False: 0] | | ------------------ | | 159| 14.1k| &(string_a).end, &(string_b).start, \ | | 160| 14.1k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 14.1k| ((string_b).pointer = (string_b).start, \ | | 162| 14.1k| 1) : \ | | 163| 14.1k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3505:33): [True: 0, False: 14.1k] ------------------ 3506| 14.1k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 14.1k| ((string).pointer = (string).start, \ | | 155| 14.1k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3507| 14.1k| } 3508| 42.1k| CLEAR(parser, leading_break); ------------------ | | 154| 42.1k| ((string).pointer = (string).start, \ | | 155| 42.1k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3509| 42.1k| } 3510| 9.11k| else { 3511| 9.11k| if (!JOIN(parser, string, leading_break)) goto error; ------------------ | | 158| 9.11k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 9.11k, False: 0] | | ------------------ | | 159| 9.11k| &(string_a).end, &(string_b).start, \ | | 160| 9.11k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 9.11k| ((string_b).pointer = (string_b).start, \ | | 162| 9.11k| 1) : \ | | 163| 9.11k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3511:29): [True: 0, False: 9.11k] ------------------ 3512| 9.11k| if (!JOIN(parser, string, trailing_breaks)) goto error; ------------------ | | 158| 9.11k| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 9.11k, False: 0] | | ------------------ | | 159| 9.11k| &(string_a).end, &(string_b).start, \ | | 160| 9.11k| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 9.11k| ((string_b).pointer = (string_b).start, \ | | 162| 9.11k| 1) : \ | | 163| 9.11k| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3512:29): [True: 0, False: 9.11k] ------------------ 3513| 9.11k| CLEAR(parser, leading_break); ------------------ | | 154| 9.11k| ((string).pointer = (string).start, \ | | 155| 9.11k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3514| 9.11k| CLEAR(parser, trailing_breaks); ------------------ | | 154| 9.11k| ((string).pointer = (string).start, \ | | 155| 9.11k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3515| 9.11k| } 3516| | 3517| 51.2k| leading_blanks = 0; 3518| 51.2k| } 3519| 2.72M| else 3520| 2.72M| { 3521| 2.72M| if (!JOIN(parser, string, whitespaces)) goto error; ------------------ | | 158| 2.72M| ((yaml_string_join(&(string_a).start, &(string_a).pointer, \ | | ------------------ | | | Branch (158:6): [True: 2.72M, False: 0] | | ------------------ | | 159| 2.72M| &(string_a).end, &(string_b).start, \ | | 160| 2.72M| &(string_b).pointer, &(string_b).end)) ? \ | | 161| 2.72M| ((string_b).pointer = (string_b).start, \ | | 162| 2.72M| 1) : \ | | 163| 2.72M| ((context)->error = YAML_MEMORY_ERROR, \ | | 164| 0| 0)) ------------------ | Branch (3521:25): [True: 0, False: 2.72M] ------------------ 3522| 2.72M| CLEAR(parser, whitespaces); ------------------ | | 154| 2.72M| ((string).pointer = (string).start, \ | | 155| 2.72M| memset((string).start, 0, (string).end-(string).start)) ------------------ 3523| 2.72M| } 3524| 2.78M| } 3525| | 3526| | /* Copy the character. */ 3527| | 3528| 24.5M| if (!READ(parser, string)) goto error; ------------------ | | 526| 24.5M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 24.5M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 24.5M, False: 0] | | | | | Branch (146:7): [True: 24.4M, False: 71.6k] | | | | ------------------ | | | | 147| 24.5M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 71.6k, False: 0] | | | | ------------------ | | | | 148| 71.6k| &(string).pointer, &(string).end)) ? \ | | | | 149| 24.5M| 1 : \ | | | | 150| 24.5M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 24.5M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 24.5M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 16.2M, False: 8.25M] | | | | ------------------ | | | | 399| 24.5M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 24.5M| (*(string_b).pointer & 0xE0) == 0xC0 ? \ | | | | ------------------ | | | | | Branch (400:6): [True: 40.5k, False: 8.21M] | | | | ------------------ | | | | 401| 8.25M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 402| 40.5k| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 403| 8.25M| (*(string_b).pointer & 0xF0) == 0xE0 ? \ | | | | ------------------ | | | | | Branch (403:6): [True: 7.75M, False: 464k] | | | | ------------------ | | | | 404| 8.21M| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 405| 7.75M| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 406| 7.75M| *((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 407| 8.21M| (*(string_b).pointer & 0xF8) == 0xF0 ? \ | | | | ------------------ | | | | | Branch (407:6): [True: 464k, False: 0] | | | | ------------------ | | | | 408| 464k| (*((string_a).pointer++) = *((string_b).pointer++), \ | | | | 409| 464k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 410| 464k| *((string_a).pointer++) = *((string_b).pointer++), \ | | | | 411| 464k| *((string_a).pointer++) = *((string_b).pointer++)) : 0) | | ------------------ | | 528| 24.5M| parser->mark.index ++, \ | | 529| 24.5M| parser->mark.column ++, \ | | 530| 24.5M| parser->unread --, \ | | 531| 24.5M| 1) : 0) ------------------ | Branch (3528:17): [True: 0, False: 24.5M] ------------------ 3529| | 3530| 24.5M| end_mark = parser->mark; 3531| | 3532| 24.5M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 24.5M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 24.4M, False: 4.09k] | | ------------------ | | 494| 24.5M| ? 1 \ | | 495| 24.5M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3532:17): [True: 41, False: 24.5M] ------------------ 3533| 24.5M| } 3534| | 3535| | /* Is it the end? */ 3536| | 3537| 6.17M| if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))) ------------------ | | 323| 6.17M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 12.3M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 6.17M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 12.3M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 2.73M, False: 3.44M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 3.44M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 3.44M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 1.96k, False: 3.43M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))) ------------------ | | 341| 3.43M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 3.43M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 6.87M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 29.2k, False: 3.40M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 3.43M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 6.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 81.1k, False: 3.32M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 3.43M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.65M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 777, False: 3.32M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 3.32M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 777| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 777, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 334| 3.43M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.65M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 10.0k, False: 3.31M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 3.32M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.33M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 10.0k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 336| 3.32M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 10.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 1.95k, False: 8.05k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 3.43M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 6.65M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.05k, False: 3.31M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 3.32M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.33M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.05k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 339| 3.32M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 8.05k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 8.05k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3538| 3.31M| break; 3539| | 3540| | /* Consume blank characters. */ 3541| | 3542| 2.85M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 2.85M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 2.85M, False: 0] | | ------------------ | | 494| 2.85M| ? 1 \ | | 495| 2.85M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3542:13): [True: 0, False: 2.85M] ------------------ 3543| | 3544| 10.8M| while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 323| 10.8M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 21.7M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 10.8M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 21.7M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 6.54M, False: 4.35M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 4.35M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 4.35M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 181k, False: 4.17M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) ------------------ | | 341| 4.17M|#define IS_BREAK(string) IS_BREAK_AT((string),0) | | ------------------ | | | | 330| 4.17M| (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ | | | | ------------------ | | | | | | 175| 8.34M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 879k, False: 3.29M] | | | | | | ------------------ | | | | ------------------ | | | | 331| 4.17M| || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ | | | | ------------------ | | | | | | 175| 7.46M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 356k, False: 2.93M] | | | | | | ------------------ | | | | ------------------ | | | | 332| 4.17M| || (CHECK_AT((string),'\xC2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.86M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 4.48k, False: 2.93M] | | | | | | ------------------ | | | | ------------------ | | | | 333| 2.93M| && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ | | | | ------------------ | | | | | | 175| 4.48k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 4.15k, False: 331] | | | | | | ------------------ | | | | ------------------ | | | | 334| 4.17M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.86M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 84.8k, False: 2.84M] | | | | | | ------------------ | | | | ------------------ | | | | 335| 2.93M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.01M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 78.9k, False: 5.84k] | | | | | | ------------------ | | | | ------------------ | | | | 336| 2.93M| && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ | | | | ------------------ | | | | | | 175| 78.9k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 7.30k, False: 71.6k] | | | | | | ------------------ | | | | ------------------ | | | | 337| 4.17M| || (CHECK_AT((string),'\xE2',(offset)) \ | | | | ------------------ | | | | | | 175| 5.84M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 77.5k, False: 2.84M] | | | | | | ------------------ | | | | ------------------ | | | | 338| 2.92M| && CHECK_AT((string),'\x80',(offset)+1) \ | | | | ------------------ | | | | | | 175| 3.00M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 71.6k, False: 5.84k] | | | | | | ------------------ | | | | ------------------ | | | | 339| 2.92M| && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ | | | | ------------------ | | | | | | 175| 71.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 68.6k, False: 3.05k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3545| 8.04M| { 3546| 8.04M| if (IS_BLANK(parser->buffer)) ------------------ | | 323| 8.04M|#define IS_BLANK(string) IS_BLANK_AT((string),0) | | ------------------ | | | | 321| 8.04M| (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 304| 8.04M|#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) | | | | | | ------------------ | | | | | | | | 175| 16.0M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 6.54M, False: 1.49M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) | | | | ------------------ | | | | | | 312| 1.49M|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | | | ------------------ | | | | | | | | 175| 1.49M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | | | ------------------ | | | | | | | | | Branch (175:5): [True: 181k, False: 1.31M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3547| 6.72M| { 3548| | /* Check for tab characters that abuse indentation. */ 3549| | 3550| 6.72M| if (leading_blanks && (int)parser->mark.column < indent ------------------ | Branch (3550:21): [True: 991k, False: 5.73M] | Branch (3550:39): [True: 9.03k, False: 982k] ------------------ 3551| 9.03k| && IS_TAB(parser->buffer)) { ------------------ | | 314| 9.03k|#define IS_TAB(string) IS_TAB_AT((string),0) | | ------------------ | | | | 312| 9.03k|#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) | | | | ------------------ | | | | | | 175| 9.03k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | | | ------------------ | | | | | | | Branch (175:5): [True: 2, False: 9.03k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 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| 6.72M| if (!leading_blanks) { ------------------ | Branch (3559:21): [True: 5.73M, False: 991k] ------------------ 3560| 5.73M| if (!READ(parser, whitespaces)) goto error; ------------------ | | 526| 5.73M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 5.73M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 5.73M, False: 0] | | | | | Branch (146:7): [True: 5.72M, False: 8.09k] | | | | ------------------ | | | | 147| 5.73M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 8.09k, False: 0] | | | | ------------------ | | | | 148| 8.09k| &(string).pointer, &(string).end)) ? \ | | | | 149| 5.73M| 1 : \ | | | | 150| 5.73M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 527| 5.73M| (COPY(string,parser->buffer), \ | | ------------------ | | | | 398| 5.73M| ((*(string_b).pointer & 0x80) == 0x00 ? \ | | | | ------------------ | | | | | Branch (398:6): [True: 5.73M, False: 0] | | | | ------------------ | | | | 399| 5.73M| (*((string_a).pointer++) = *((string_b).pointer++)) : \ | | | | 400| 5.73M| (*(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| 5.73M| parser->mark.index ++, \ | | 529| 5.73M| parser->mark.column ++, \ | | 530| 5.73M| parser->unread --, \ | | 531| 5.73M| 1) : 0) ------------------ | Branch (3560:25): [True: 0, False: 5.73M] ------------------ 3561| 5.73M| } 3562| 991k| else { 3563| 991k| SKIP(parser); ------------------ | | 502| 991k| (parser->mark.index ++, \ | | 503| 991k| parser->mark.column ++, \ | | 504| 991k| parser->unread --, \ | | 505| 991k| parser->buffer.pointer += WIDTH(parser->buffer)) | | ------------------ | | | | 385| 991k|#define WIDTH(string) WIDTH_AT((string),0) | | | | ------------------ | | | | | | 380| 991k| (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \ | | | | | | ------------------ | | | | | | | Branch (380:7): [True: 991k, False: 0] | | | | | | ------------------ | | | | | | 381| 991k| ((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| 991k| } 3565| 6.72M| } 3566| 1.31M| else 3567| 1.31M| { 3568| 1.31M| if (!CACHE(parser, 2)) goto error; ------------------ | | 493| 1.31M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 1.31M, False: 154] | | ------------------ | | 494| 1.31M| ? 1 \ | | 495| 1.31M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3568:21): [True: 6, False: 1.31M] ------------------ 3569| | 3570| | /* Check if it is a first line break. */ 3571| | 3572| 1.31M| if (!leading_blanks) ------------------ | Branch (3572:21): [True: 124k, False: 1.19M] ------------------ 3573| 124k| { 3574| 124k| CLEAR(parser, whitespaces); ------------------ | | 154| 124k| ((string).pointer = (string).start, \ | | 155| 124k| memset((string).start, 0, (string).end-(string).start)) ------------------ 3575| 124k| if (!READ_LINE(parser, leading_break)) goto error; ------------------ | | 538| 124k| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 124k| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 124k, False: 0] | | | | | Branch (146:7): [True: 124k, False: 0] | | | | ------------------ | | | | 147| 124k| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| &(string).pointer, &(string).end)) ? \ | | | | 149| 124k| 1 : \ | | | | 150| 124k| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 124k| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 249k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 29.8k, False: 94.6k] | | | | ------------------ | | ------------------ | | 540| 124k| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 29.8k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 2.47k, False: 27.4k] | | | | ------------------ | | ------------------ | | 541| 124k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 2.47k| parser->buffer.pointer += 2, \ | | 543| 2.47k| parser->mark.index += 2, \ | | 544| 2.47k| parser->mark.column = 0, \ | | 545| 2.47k| parser->mark.line ++, \ | | 546| 2.47k| parser->unread -= 2) : \ | | 547| 124k| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 244k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 27.4k, False: 94.6k] | | | | ------------------ | | ------------------ | | 548| 122k| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 94.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 83.7k, False: 10.8k] | | | | ------------------ | | ------------------ | | 549| 122k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 111k| parser->buffer.pointer ++, \ | | 551| 111k| parser->mark.index ++, \ | | 552| 111k| parser->mark.column = 0, \ | | 553| 111k| parser->mark.line ++, \ | | 554| 111k| parser->unread --) : \ | | 555| 122k| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 21.6k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 790, False: 10.0k] | | | | ------------------ | | ------------------ | | 556| 10.8k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 790| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 790, False: 0] | | | | ------------------ | | ------------------ | | 557| 10.8k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 790| parser->buffer.pointer += 2, \ | | 559| 790| parser->mark.index ++, \ | | 560| 790| parser->mark.column = 0, \ | | 561| 790| parser->mark.line ++, \ | | 562| 790| parser->unread --) : \ | | 563| 10.8k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 20.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 10.0k, False: 0] | | | | ------------------ | | ------------------ | | 564| 10.0k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 20.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 10.0k, False: 0] | | | | ------------------ | | ------------------ | | 565| 10.0k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 20.0k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 1.96k, False: 8.05k] | | | | ------------------ | | ------------------ | | 566| 10.0k| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 8.05k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 8.05k, False: 0] | | | | ------------------ | | ------------------ | | 567| 10.0k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 10.0k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 10.0k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 10.0k| parser->mark.index ++, \ | | 571| 10.0k| parser->mark.column = 0, \ | | 572| 10.0k| parser->mark.line ++, \ | | 573| 10.0k| parser->unread --) : 0), \ | | 574| 124k| 1) : 0) ------------------ | Branch (3575:25): [True: 0, False: 124k] ------------------ 3576| 124k| leading_blanks = 1; 3577| 124k| } 3578| 1.19M| else 3579| 1.19M| { 3580| 1.19M| if (!READ_LINE(parser, trailing_breaks)) goto error; ------------------ | | 538| 1.19M| (STRING_EXTEND(parser,string) ? \ | | ------------------ | | | | 146| 1.19M| ((((string).pointer+5 < (string).end) \ | | | | ------------------ | | | | | Branch (146:5): [True: 1.19M, False: 0] | | | | | Branch (146:7): [True: 1.18M, False: 6.93k] | | | | ------------------ | | | | 147| 1.19M| || yaml_string_extend(&(string).start, \ | | | | ------------------ | | | | | Branch (147:12): [True: 6.93k, False: 0] | | | | ------------------ | | | | 148| 6.93k| &(string).pointer, &(string).end)) ? \ | | | | 149| 1.19M| 1 : \ | | | | 150| 1.19M| ((context)->error = YAML_MEMORY_ERROR, \ | | | | 151| 0| 0)) | | ------------------ | | 539| 1.19M| (((CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.38M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 849k, False: 341k] | | | | ------------------ | | ------------------ | | 540| 1.19M| && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \ | | ------------------ | | | | 175| 849k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 30.3k, False: 818k] | | | | ------------------ | | ------------------ | | 541| 1.19M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 542| 30.3k| parser->buffer.pointer += 2, \ | | 543| 30.3k| parser->mark.index += 2, \ | | 544| 30.3k| parser->mark.column = 0, \ | | 545| 30.3k| parser->mark.line ++, \ | | 546| 30.3k| parser->unread -= 2) : \ | | 547| 1.19M| (CHECK_AT(parser->buffer,'\r',0) \ | | ------------------ | | | | 175| 2.32M| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 818k, False: 341k] | | | | ------------------ | | ------------------ | | 548| 1.16M| || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \ | | ------------------ | | | | 175| 341k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 272k, False: 69.2k] | | | | ------------------ | | ------------------ | | 549| 1.16M| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 550| 1.09M| parser->buffer.pointer ++, \ | | 551| 1.09M| parser->mark.index ++, \ | | 552| 1.09M| parser->mark.column = 0, \ | | 553| 1.09M| parser->mark.line ++, \ | | 554| 1.09M| parser->unread --) : \ | | 555| 1.16M| (CHECK_AT(parser->buffer,'\xC2',0) \ | | ------------------ | | | | 175| 138k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 3.35k, False: 65.8k] | | | | ------------------ | | ------------------ | | 556| 69.2k| && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \ | | ------------------ | | | | 175| 3.35k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 3.35k, False: 0] | | | | ------------------ | | ------------------ | | 557| 69.2k| (*((string).pointer++) = (yaml_char_t) '\n', \ | | 558| 3.35k| parser->buffer.pointer += 2, \ | | 559| 3.35k| parser->mark.index ++, \ | | 560| 3.35k| parser->mark.column = 0, \ | | 561| 3.35k| parser->mark.line ++, \ | | 562| 3.35k| parser->unread --) : \ | | 563| 69.2k| (CHECK_AT(parser->buffer,'\xE2',0) && \ | | ------------------ | | | | 175| 131k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 65.8k, False: 0] | | | | ------------------ | | ------------------ | | 564| 65.8k| CHECK_AT(parser->buffer,'\x80',1) && \ | | ------------------ | | | | 175| 131k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 65.8k, False: 0] | | | | ------------------ | | ------------------ | | 565| 65.8k| (CHECK_AT(parser->buffer,'\xA8',2) || \ | | ------------------ | | | | 175| 131k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 5.34k, False: 60.5k] | | | | ------------------ | | ------------------ | | 566| 65.8k| CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ | | ------------------ | | | | 175| 60.5k| ((string).pointer[offset] == (yaml_char_t)(octet)) | | | | ------------------ | | | | | Branch (175:5): [True: 60.5k, False: 0] | | | | ------------------ | | ------------------ | | 567| 65.8k| (*((string).pointer++) = *(parser->buffer.pointer++), \ | | 568| 65.8k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 569| 65.8k| *((string).pointer++) = *(parser->buffer.pointer++), \ | | 570| 65.8k| parser->mark.index ++, \ | | 571| 65.8k| parser->mark.column = 0, \ | | 572| 65.8k| parser->mark.line ++, \ | | 573| 65.8k| parser->unread --) : 0), \ | | 574| 1.19M| 1) : 0) ------------------ | Branch (3580:25): [True: 0, False: 1.19M] ------------------ 3581| 1.19M| } 3582| 1.31M| } 3583| 8.04M| if (!CACHE(parser, 1)) goto error; ------------------ | | 493| 8.04M| (parser->unread >= (length) \ | | ------------------ | | | Branch (493:6): [True: 8.04M, False: 346] | | ------------------ | | 494| 8.04M| ? 1 \ | | 495| 8.04M| : yaml_parser_update_buffer(parser, (length))) ------------------ | Branch (3583:17): [True: 3, False: 8.04M] ------------------ 3584| 8.04M| } 3585| | 3586| | /* Check indentation level. */ 3587| | 3588| 2.85M| if (!parser->flow_level && (int)parser->mark.column < indent) ------------------ | Branch (3588:13): [True: 2.83M, False: 15.9k] | Branch (3588:36): [True: 65.9k, False: 2.77M] ------------------ 3589| 65.9k| break; 3590| 2.85M| } 3591| | 3592| | /* Create a token. */ 3593| | 3594| 3.38M| SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, ------------------ | | 526| 3.38M| (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ | | ------------------ | | | | 500| 3.38M| (memset(&(token), 0, sizeof(yaml_token_t)), \ | | | | 501| 3.38M| (token).type = (token_type), \ | | | | 502| 3.38M| (token).start_mark = (token_start_mark), \ | | | | 503| 3.38M| (token).end_mark = (token_end_mark)) | | ------------------ | | 527| 3.38M| (token).data.scalar.value = (token_value), \ | | 528| 3.38M| (token).data.scalar.length = (token_length), \ | | 529| 3.38M| (token).data.scalar.style = (token_style)) ------------------ 3595| 3.38M| YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark); 3596| | 3597| | /* Note that we change the 'simple_key_allowed' flag. */ 3598| | 3599| 3.38M| if (leading_blanks) { ------------------ | Branch (3599:9): [True: 73.1k, False: 3.31M] ------------------ 3600| 73.1k| parser->simple_key_allowed = 1; 3601| 73.1k| } 3602| | 3603| 3.38M| STRING_DEL(parser, leading_break); ------------------ | | 142| 3.38M| (yaml_free((string).start), \ | | 143| 3.38M| (string).start = (string).pointer = (string).end = 0) ------------------ 3604| 3.38M| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 3.38M| (yaml_free((string).start), \ | | 143| 3.38M| (string).start = (string).pointer = (string).end = 0) ------------------ 3605| 3.38M| STRING_DEL(parser, whitespaces); ------------------ | | 142| 3.38M| (yaml_free((string).start), \ | | 143| 3.38M| (string).start = (string).pointer = (string).end = 0) ------------------ 3606| | 3607| 3.38M| return 1; 3608| | 3609| 64|error: 3610| 64| STRING_DEL(parser, string); ------------------ | | 142| 64| (yaml_free((string).start), \ | | 143| 64| (string).start = (string).pointer = (string).end = 0) ------------------ 3611| 64| STRING_DEL(parser, leading_break); ------------------ | | 142| 64| (yaml_free((string).start), \ | | 143| 64| (string).start = (string).pointer = (string).end = 0) ------------------ 3612| 64| STRING_DEL(parser, trailing_breaks); ------------------ | | 142| 64| (yaml_free((string).start), \ | | 143| 64| (string).start = (string).pointer = (string).end = 0) ------------------ 3613| 64| STRING_DEL(parser, whitespaces); ------------------ | | 142| 64| (yaml_free((string).start), \ | | 143| 64| (string).start = (string).pointer = (string).end = 0) ------------------ 3614| | 3615| 64| return 0; 3616| 3.38M|} scanner.c:yaml_parser_set_scanner_error: 791| 2.12k|{ 792| 2.12k| parser->error = YAML_SCANNER_ERROR; 793| 2.12k| parser->context = context; 794| 2.12k| parser->context_mark = context_mark; 795| 2.12k| parser->problem = problem; 796| 2.12k| parser->problem_mark = parser->mark; 797| | 798| 2.12k| return 0; 799| 2.12k|} scanner.c:yaml_parser_stale_simple_keys: 1064| 29.4M|{ 1065| 29.4M| yaml_simple_key_t *simple_key; 1066| | 1067| | /* Check for a potential simple key for each flow level. */ 1068| | 1069| 29.4M| for (simple_key = parser->simple_keys.start; 1070| 224M| simple_key != parser->simple_keys.top; simple_key ++) ------------------ | Branch (1070:13): [True: 194M, False: 29.4M] ------------------ 1071| 194M| { 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| 194M| if (simple_key->possible ------------------ | Branch (1079:13): [True: 35.7M, False: 158M] ------------------ 1080| 35.7M| && (simple_key->mark.line < parser->mark.line ------------------ | Branch (1080:21): [True: 114k, False: 35.6M] ------------------ 1081| 35.6M| || simple_key->mark.index+1024 < parser->mark.index)) { ------------------ | Branch (1081:24): [True: 3.17k, False: 35.6M] ------------------ 1082| | 1083| | /* Check if the potential simple key to be removed is required. */ 1084| | 1085| 117k| if (simple_key->required) { ------------------ | Branch (1085:17): [True: 34, False: 117k] ------------------ 1086| 34| return yaml_parser_set_scanner_error(parser, 1087| 34| "while scanning a simple key", simple_key->mark, 1088| 34| "could not find expected ':'"); 1089| 34| } 1090| | 1091| 117k| simple_key->possible = 0; 1092| 117k| } 1093| 194M| } 1094| | 1095| 29.4M| return 1; 1096| 29.4M|} yaml_emitter_flush: 33| 275k|{ 34| 275k| int low, high; 35| | 36| 275k| assert(emitter); /* Non-NULL emitter object is expected. */ ------------------ | Branch (36:5): [True: 0, False: 275k] | Branch (36:5): [True: 275k, False: 0] ------------------ 37| 275k| assert(emitter->write_handler); /* Write handler must be set. */ ------------------ | Branch (37:5): [True: 0, False: 275k] | Branch (37:5): [True: 275k, False: 0] ------------------ 38| 275k| assert(emitter->encoding); /* Output encoding must be set. */ ------------------ | Branch (38:5): [True: 0, False: 275k] | Branch (38:5): [True: 275k, False: 0] ------------------ 39| | 40| 275k| emitter->buffer.last = emitter->buffer.pointer; 41| 275k| emitter->buffer.pointer = emitter->buffer.start; 42| | 43| | /* Check if the buffer is empty. */ 44| | 45| 275k| if (emitter->buffer.start == emitter->buffer.last) { ------------------ | Branch (45:9): [True: 1.67k, False: 273k] ------------------ 46| 1.67k| return 1; 47| 1.67k| } 48| | 49| | /* If the output encoding is UTF-8, we don't need to recode the buffer. */ 50| | 51| 273k| if (emitter->encoding == YAML_UTF8_ENCODING) ------------------ | Branch (51:9): [True: 273k, False: 0] ------------------ 52| 273k| { 53| 273k| if (emitter->write_handler(emitter->write_handler_data, ------------------ | Branch (53:13): [True: 268k, False: 5.04k] ------------------ 54| 273k| emitter->buffer.start, 55| 273k| emitter->buffer.last - emitter->buffer.start)) { 56| 268k| emitter->buffer.last = emitter->buffer.start; 57| 268k| emitter->buffer.pointer = emitter->buffer.start; 58| 268k| return 1; 59| 268k| } 60| 5.04k| else { 61| 5.04k| return yaml_emitter_set_writer_error(emitter, "write error"); 62| 5.04k| } 63| 273k| } 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| 5.04k|{ 21| 5.04k| emitter->error = YAML_WRITER_ERROR; 22| 5.04k| emitter->problem = problem; 23| | 24| 5.04k| return 0; 25| 5.04k|} LLVMFuzzerTestOneInput: 28| 11.2k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 29| 11.2k| if (size < 2) ------------------ | Branch (29:7): [True: 1, False: 11.2k] ------------------ 30| 1| return 0; 31| | 32| 11.2k| bool done = false; 33| 11.2k| bool is_canonical = data[0] & 1; 34| 11.2k| bool is_unicode = data[1] & 1; 35| 11.2k| data += 2; 36| 11.2k| size -= 2; 37| | 38| 11.2k| yaml_parser_t parser; 39| 11.2k| yaml_emitter_t emitter; 40| 11.2k| yaml_document_t document; 41| | 42| | /* Initialize the parser and emitter objects. */ 43| | 44| 11.2k| if (!yaml_parser_initialize(&parser)) ------------------ | Branch (44:7): [True: 0, False: 11.2k] ------------------ 45| 0| return 0; 46| | 47| 11.2k| if (!yaml_emitter_initialize(&emitter)) ------------------ | Branch (47:7): [True: 0, False: 11.2k] ------------------ 48| 0| goto cleanup_parser; 49| | 50| | /* Set the parser parameters. */ 51| | 52| 11.2k| yaml_parser_set_input_string(&parser, data, size); 53| | 54| | /* Set the emitter parameters. */ 55| 11.2k| yaml_output_buffer_t out = {/*buf=*/NULL, /*size=*/0, /*capacity=*/1000}; 56| 11.2k| yaml_emitter_set_output(&emitter, yaml_write_handler, &out); 57| | 58| 11.2k| yaml_emitter_set_canonical(&emitter, is_canonical); 59| 11.2k| yaml_emitter_set_unicode(&emitter, is_unicode); 60| | 61| | /* The main loop. */ 62| | 63| 67.0k| while (!done) { ------------------ | Branch (63:10): [True: 65.3k, False: 1.71k] ------------------ 64| | /* Get the next event. */ 65| | 66| 65.3k| if (!yaml_parser_load(&parser, &document)) ------------------ | Branch (66:9): [True: 4.42k, False: 60.9k] ------------------ 67| 4.42k| break; 68| | 69| | /* Check if this is the stream end. */ 70| | 71| 60.9k| done = (!yaml_document_get_root_node(&document)); 72| | 73| | /* Emit the event. */ 74| | 75| 60.9k| if (!yaml_emitter_dump(&emitter, &document)) ------------------ | Branch (75:9): [True: 5.09k, False: 55.8k] ------------------ 76| 5.09k| break; 77| 60.9k| } 78| | 79| 11.2k| free(out.buf); 80| 11.2k| yaml_emitter_delete(&emitter); 81| | 82| 11.2k|cleanup_parser: 83| | 84| 11.2k| yaml_parser_delete(&parser); 85| 11.2k| return 0; 86| 11.2k|} libyaml_reformatter_alt_fuzzer.c:yaml_write_handler: 24| 273k|static int yaml_write_handler(void *data, unsigned char *buffer, size_t size) { 25| 273k| size_t newsize; 26| 273k| yaml_output_buffer_t *out = (yaml_output_buffer_t *)data; 27| | 28| | /* Double buffer size whenever necessary */ 29| 273k| if (out->size + size >= out->capacity) { ------------------ | Branch (29:7): [True: 6.14k, False: 267k] ------------------ 30| 6.14k| newsize = out->capacity << 1; 31| 6.14k| if (newsize < out->size + size) { ------------------ | Branch (31:9): [True: 1.27k, False: 4.87k] ------------------ 32| 1.27k| newsize = out->size + size; 33| 1.27k| } 34| 6.14k| out->buf = (unsigned char *)realloc(out->buf, newsize); 35| 6.14k| out->capacity = newsize; 36| 6.14k| } 37| 273k| if (!out->buf) { ------------------ | Branch (37:7): [True: 5.04k, False: 268k] ------------------ 38| 5.04k| out->size = 0; 39| 5.04k| return 0; 40| 5.04k| } 41| | 42| 268k| memcpy(out->buf + out->size, buffer, size); 43| 268k| out->size += size; 44| 268k| return 1; 45| 273k|}