fuzzer_parser_init: 33| 1.07k|readstat_parser_t *fuzzer_parser_init(const uint8_t *Data, size_t Size) { 34| 1.07k| readstat_parser_t *parser = readstat_parser_init(); 35| 1.07k| readstat_set_open_handler(parser, rt_open_handler); 36| 1.07k| readstat_set_close_handler(parser, rt_close_handler); 37| 1.07k| readstat_set_seek_handler(parser, rt_seek_handler); 38| 1.07k| readstat_set_read_handler(parser, rt_read_handler); 39| 1.07k| readstat_set_update_handler(parser, rt_update_handler); 40| | 41| 1.07k| readstat_set_metadata_handler(parser, &handle_metadata); 42| 1.07k| readstat_set_note_handler(parser, &handle_note); 43| 1.07k| readstat_set_variable_handler(parser, &handle_variable); 44| 1.07k| readstat_set_fweight_handler(parser, &handle_fweight); 45| 1.07k| readstat_set_value_handler(parser, &handle_value); 46| 1.07k| readstat_set_value_label_handler(parser, &handle_value_label); 47| | 48| 1.07k| return parser; 49| 1.07k|} fuzz_format.c:handle_variable: 21| 1.00k| const char *val_labels, void *ctx) { 22| 1.00k| return READSTAT_HANDLER_OK; 23| 1.00k|} fuzz_format.c:handle_value_label: 29| 4.31k|static int handle_value_label(const char *val_labels, readstat_value_t value, const char *label, void *ctx) { 30| 4.31k| return READSTAT_HANDLER_OK; 31| 4.31k|} LLVMFuzzerTestOneInput: 11| 1.07k|int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 12| 1.07k| rt_buffer_t buffer = { .bytes = (char *)Data, .size = Size, .used = Size }; 13| 1.07k| rt_buffer_ctx_t buffer_ctx = { .buffer = &buffer }; 14| | 15| 1.07k| readstat_parser_t *parser = fuzzer_parser_init(Data, Size); 16| 1.07k| readstat_set_io_ctx(parser, &buffer_ctx); 17| | 18| 1.07k| readstat_schema_t *schema = readstat_parse_sas_commands(parser, NULL, NULL, NULL); 19| 1.07k| if (schema) ------------------ | Branch (19:9): [True: 238, False: 836] ------------------ 20| 238| readstat_schema_free(schema); 21| 1.07k| readstat_parser_free(parser); 22| | 23| 1.07k| return 0; 24| 1.07k|} unistd_io_init: 121| 1.07k|readstat_error_t unistd_io_init(readstat_parser_t *parser) { 122| 1.07k| readstat_error_t retval = READSTAT_OK; 123| 1.07k| unistd_io_ctx_t *io_ctx = NULL; 124| | 125| 1.07k| if ((retval = readstat_set_open_handler(parser, unistd_open_handler)) != READSTAT_OK) ------------------ | Branch (125:9): [True: 0, False: 1.07k] ------------------ 126| 0| return retval; 127| | 128| 1.07k| if ((retval = readstat_set_close_handler(parser, unistd_close_handler)) != READSTAT_OK) ------------------ | Branch (128:9): [True: 0, False: 1.07k] ------------------ 129| 0| return retval; 130| | 131| 1.07k| if ((retval = readstat_set_seek_handler(parser, unistd_seek_handler)) != READSTAT_OK) ------------------ | Branch (131:9): [True: 0, False: 1.07k] ------------------ 132| 0| return retval; 133| | 134| 1.07k| if ((retval = readstat_set_read_handler(parser, unistd_read_handler)) != READSTAT_OK) ------------------ | Branch (134:9): [True: 0, False: 1.07k] ------------------ 135| 0| return retval; 136| | 137| 1.07k| if ((readstat_set_update_handler(parser, unistd_update_handler)) != READSTAT_OK) ------------------ | Branch (137:9): [True: 0, False: 1.07k] ------------------ 138| 0| return retval; 139| | 140| 1.07k| io_ctx = calloc(1, sizeof(unistd_io_ctx_t)); 141| 1.07k| io_ctx->fd = -1; 142| | 143| 1.07k| retval = readstat_set_io_ctx(parser, (void*) io_ctx); 144| 1.07k| parser->io->io_ctx_needs_free = 1; 145| | 146| 1.07k| return retval; 147| 1.07k|} readstat_parser_init: 6| 1.07k|readstat_parser_t *readstat_parser_init(void) { 7| 1.07k| readstat_parser_t *parser = calloc(1, sizeof(readstat_parser_t)); 8| 1.07k| parser->io = calloc(1, sizeof(readstat_io_t)); 9| 1.07k| if (unistd_io_init(parser) != READSTAT_OK) { ------------------ | Branch (9:9): [True: 0, False: 1.07k] ------------------ 10| 0| readstat_parser_free(parser); 11| 0| return NULL; 12| 0| } 13| 1.07k| parser->output_encoding = "UTF-8"; 14| 1.07k| return parser; 15| 1.07k|} readstat_parser_free: 17| 1.07k|void readstat_parser_free(readstat_parser_t *parser) { 18| 1.07k| if (parser) { ------------------ | Branch (18:9): [True: 1.07k, False: 0] ------------------ 19| 1.07k| if (parser->io) { ------------------ | Branch (19:13): [True: 1.07k, False: 0] ------------------ 20| | readstat_set_io_ctx(parser, NULL); 21| 1.07k| free(parser->io); 22| 1.07k| } 23| 1.07k| free(parser); 24| 1.07k| } 25| 1.07k|} readstat_set_metadata_handler: 27| 1.07k|readstat_error_t readstat_set_metadata_handler(readstat_parser_t *parser, readstat_metadata_handler metadata_handler) { 28| 1.07k| parser->handlers.metadata = metadata_handler; 29| 1.07k| return READSTAT_OK; 30| 1.07k|} readstat_set_note_handler: 32| 1.07k|readstat_error_t readstat_set_note_handler(readstat_parser_t *parser, readstat_note_handler note_handler) { 33| 1.07k| parser->handlers.note = note_handler; 34| 1.07k| return READSTAT_OK; 35| 1.07k|} readstat_set_variable_handler: 37| 1.07k|readstat_error_t readstat_set_variable_handler(readstat_parser_t *parser, readstat_variable_handler variable_handler) { 38| 1.07k| parser->handlers.variable = variable_handler; 39| 1.07k| return READSTAT_OK; 40| 1.07k|} readstat_set_value_handler: 42| 1.07k|readstat_error_t readstat_set_value_handler(readstat_parser_t *parser, readstat_value_handler value_handler) { 43| 1.07k| parser->handlers.value = value_handler; 44| 1.07k| return READSTAT_OK; 45| 1.07k|} readstat_set_value_label_handler: 47| 1.07k|readstat_error_t readstat_set_value_label_handler(readstat_parser_t *parser, readstat_value_label_handler label_handler) { 48| 1.07k| parser->handlers.value_label = label_handler; 49| 1.07k| return READSTAT_OK; 50| 1.07k|} readstat_set_fweight_handler: 62| 1.07k|readstat_error_t readstat_set_fweight_handler(readstat_parser_t *parser, readstat_fweight_handler fweight_handler) { 63| 1.07k| parser->handlers.fweight = fweight_handler; 64| 1.07k| return READSTAT_OK; 65| 1.07k|} readstat_set_open_handler: 67| 2.14k|readstat_error_t readstat_set_open_handler(readstat_parser_t *parser, readstat_open_handler open_handler) { 68| 2.14k| parser->io->open = open_handler; 69| 2.14k| return READSTAT_OK; 70| 2.14k|} readstat_set_close_handler: 72| 2.14k|readstat_error_t readstat_set_close_handler(readstat_parser_t *parser, readstat_close_handler close_handler) { 73| 2.14k| parser->io->close = close_handler; 74| 2.14k| return READSTAT_OK; 75| 2.14k|} readstat_set_seek_handler: 77| 2.14k|readstat_error_t readstat_set_seek_handler(readstat_parser_t *parser, readstat_seek_handler seek_handler) { 78| 2.14k| parser->io->seek = seek_handler; 79| 2.14k| return READSTAT_OK; 80| 2.14k|} readstat_set_read_handler: 82| 2.14k|readstat_error_t readstat_set_read_handler(readstat_parser_t *parser, readstat_read_handler read_handler) { 83| 2.14k| parser->io->read = read_handler; 84| 2.14k| return READSTAT_OK; 85| 2.14k|} readstat_set_update_handler: 87| 2.14k|readstat_error_t readstat_set_update_handler(readstat_parser_t *parser, readstat_update_handler update_handler) { 88| 2.14k| parser->io->update = update_handler; 89| 2.14k| return READSTAT_OK; 90| 2.14k|} readstat_set_io_ctx: 92| 3.22k|readstat_error_t readstat_set_io_ctx(readstat_parser_t *parser, void *io_ctx) { 93| 3.22k| if (parser->io->io_ctx_needs_free) { ------------------ | Branch (93:9): [True: 1.07k, False: 2.14k] ------------------ 94| 1.07k| free(parser->io->io_ctx); 95| 1.07k| } 96| | 97| 3.22k| parser->io->io_ctx = io_ctx; 98| 3.22k| parser->io->io_ctx_needs_free = 0; 99| | 100| 3.22k| return READSTAT_OK; 101| 3.22k|} rt_open_handler: 8| 1.07k|int rt_open_handler(const char *path, void *io_ctx) { 9| 1.07k| return 0; 10| 1.07k|} rt_close_handler: 12| 1.07k|int rt_close_handler(void *io_ctx) { 13| 1.07k| return 0; 14| 1.07k|} rt_seek_handler: 17| 2.14k| readstat_io_flags_t whence, void *io_ctx) { 18| 2.14k| rt_buffer_ctx_t *buffer_ctx = (rt_buffer_ctx_t *)io_ctx; 19| 2.14k| readstat_off_t newpos = -1; 20| 2.14k| if (whence == READSTAT_SEEK_SET) { ------------------ | Branch (20:9): [True: 1.07k, False: 1.07k] ------------------ 21| 1.07k| newpos = offset; 22| 1.07k| } else if (whence == READSTAT_SEEK_CUR) { ------------------ | Branch (22:16): [True: 0, False: 1.07k] ------------------ 23| 0| newpos = buffer_ctx->pos + offset; 24| 1.07k| } else if (whence == READSTAT_SEEK_END) { ------------------ | Branch (24:16): [True: 1.07k, False: 0] ------------------ 25| 1.07k| newpos = buffer_ctx->buffer->used + offset; 26| 1.07k| } 27| | 28| 2.14k| if (newpos < 0) ------------------ | Branch (28:9): [True: 0, False: 2.14k] ------------------ 29| 0| return -1; 30| | 31| 2.14k| if (newpos > buffer_ctx->buffer->used) ------------------ | Branch (31:9): [True: 0, False: 2.14k] ------------------ 32| 0| return -1; 33| | 34| 2.14k| buffer_ctx->pos = newpos; 35| 2.14k| return newpos; 36| 2.14k|} rt_read_handler: 38| 1.07k|ssize_t rt_read_handler(void *buf, size_t nbytes, void *io_ctx) { 39| 1.07k| rt_buffer_ctx_t *buffer_ctx = (rt_buffer_ctx_t *)io_ctx; 40| 1.07k| ssize_t bytes_copied = 0; 41| 1.07k| ssize_t bytes_left = buffer_ctx->buffer->used - buffer_ctx->pos; 42| 1.07k| if (nbytes <= bytes_left) { ------------------ | Branch (42:9): [True: 1.07k, False: 0] ------------------ 43| 1.07k| memcpy(buf, buffer_ctx->buffer->bytes + buffer_ctx->pos, nbytes); 44| 1.07k| bytes_copied = nbytes; 45| 1.07k| } else if (bytes_left > 0) { ------------------ | Branch (45:16): [True: 0, False: 0] ------------------ 46| 0| memcpy(buf, buffer_ctx->buffer->bytes + buffer_ctx->pos, bytes_left); 47| 0| bytes_copied = bytes_left; 48| 0| } 49| 1.07k| buffer_ctx->pos += bytes_copied; 50| 1.07k| return bytes_copied; 51| 1.07k|} submit_value_label: 9| 2.82k| double double_value, const char *string_value, const char *buf, void *user_ctx) { 10| 2.82k| if (!parser->handlers.value_label) ------------------ | Branch (10:9): [True: 0, False: 2.82k] ------------------ 11| 0| return READSTAT_OK; 12| | 13| 2.82k| int cb_retval = READSTAT_HANDLER_OK; 14| 2.82k| if (label_type == LABEL_TYPE_RANGE) { ------------------ | Branch (14:9): [True: 1.12k, False: 1.70k] ------------------ 15| 1.12k| int64_t i; 16| 3.93k| for (i=first_integer; i<=last_integer; i++) { ------------------ | Branch (16:31): [True: 2.81k, False: 1.12k] ------------------ 17| 2.81k| readstat_value_t value = { 18| 2.81k| .type = READSTAT_TYPE_DOUBLE, 19| 2.81k| .v = { .double_value = i } }; 20| 2.81k| cb_retval = parser->handlers.value_label(labelset, value, buf, user_ctx); 21| 2.81k| if (cb_retval != READSTAT_HANDLER_OK) ------------------ | Branch (21:17): [True: 0, False: 2.81k] ------------------ 22| 0| goto cleanup; 23| 2.81k| } 24| 1.70k| } else if (label_type != LABEL_TYPE_OTHER) { ------------------ | Branch (24:16): [True: 1.50k, False: 200] ------------------ 25| 1.50k| readstat_value_t value = { { 0 } }; 26| 1.50k| if (label_type == LABEL_TYPE_DOUBLE) { ------------------ | Branch (26:13): [True: 478, False: 1.02k] ------------------ 27| 478| value.type = READSTAT_TYPE_DOUBLE; 28| 478| value.v.double_value = double_value; 29| 1.02k| } else if (label_type == LABEL_TYPE_STRING) { ------------------ | Branch (29:20): [True: 627, False: 399] ------------------ 30| 627| value.type = READSTAT_TYPE_STRING; 31| 627| value.v.string_value = string_value; 32| 627| } else if (label_type == LABEL_TYPE_NAN) { ------------------ | Branch (32:20): [True: 399, False: 0] ------------------ 33| 399| value.type = READSTAT_TYPE_DOUBLE; 34| 399| value.v.double_value = NAN; 35| 399| } 36| | 37| 1.50k| cb_retval = parser->handlers.value_label(labelset, value, buf, user_ctx); 38| 1.50k| } 39| | 40| 2.82k|cleanup: 41| 2.82k| return (cb_retval == READSTAT_HANDLER_OK) ? READSTAT_OK : READSTAT_ERROR_USER_ABORT; ------------------ | Branch (41:12): [True: 2.82k, False: 0] ------------------ 42| 2.82k|} submit_columns: 44| 238|readstat_error_t submit_columns(readstat_parser_t *parser, readstat_schema_t *dct, void *user_ctx) { 45| 238| int i; 46| 238| int partial_entry_count = 0; 47| 1.23k| for (i=0; ientry_count; i++) { ------------------ | Branch (47:15): [True: 1.00k, False: 238] ------------------ 48| 1.00k| readstat_schema_entry_t *entry = &dct->entries[i]; 49| 1.00k| if (dct->rows_per_observation < entry->row + 1) { ------------------ | Branch (49:13): [True: 77, False: 923] ------------------ 50| 77| dct->rows_per_observation = entry->row + 1; 51| 77| } 52| 1.00k| } 53| | 54| 238| if (!parser->handlers.variable) ------------------ | Branch (54:9): [True: 0, False: 238] ------------------ 55| 0| return READSTAT_OK; 56| | 57| 1.23k| for (i=0; ientry_count; i++) { ------------------ | Branch (57:15): [True: 1.00k, False: 238] ------------------ 58| 1.00k| readstat_schema_entry_t *entry = &dct->entries[i]; 59| 1.00k| entry->variable.index = i; 60| 1.00k| entry->variable.index_after_skipping = partial_entry_count; 61| 1.00k| if (entry->variable.type == READSTAT_TYPE_STRING) ------------------ | Branch (61:13): [True: 847, False: 153] ------------------ 62| 847| entry->variable.storage_width = entry->len; 63| 1.00k| int cb_retval = parser->handlers.variable(i, &entry->variable, 64| 1.00k| entry->labelset[0] ? entry->labelset : NULL, user_ctx); ------------------ | Branch (64:13): [True: 70, False: 930] ------------------ 65| 1.00k| if (cb_retval == READSTAT_HANDLER_SKIP_VARIABLE) { ------------------ | Branch (65:13): [True: 0, False: 1.00k] ------------------ 66| 0| entry->skip = 1; 67| 1.00k| } else if (cb_retval == READSTAT_HANDLER_ABORT) { ------------------ | Branch (67:20): [True: 0, False: 1.00k] ------------------ 68| 0| return READSTAT_ERROR_USER_ABORT; 69| 1.00k| } else { 70| 1.00k| partial_entry_count++; 71| 1.00k| } 72| 1.00k| } 73| 238| return READSTAT_OK; 74| 238|} readstat_copy: 5| 12.9k|void readstat_copy(char *buf, size_t buf_len, const char *str_start, size_t str_len) { 6| 12.9k| size_t this_len = str_len; 7| 12.9k| if (this_len >= buf_len) { ------------------ | Branch (7:9): [True: 1.05k, False: 11.9k] ------------------ 8| 1.05k| this_len = buf_len - 1; 9| 1.05k| } 10| 12.9k| memcpy(buf, str_start, this_len); 11| 12.9k| buf[this_len] = '\0'; 12| 12.9k|} readstat_copy_lower: 14| 3.32k|void readstat_copy_lower(char *buf, size_t buf_len, const char *str_start, size_t str_len) { 15| 3.32k| int i; 16| 3.32k| readstat_copy(buf, buf_len, str_start, str_len); 17| 16.5k| for (i=0; iio->open(filepath, parser->io->io_ctx) == -1) { ------------------ | Branch (3642:6): [True: 0, False: 1.07k] ------------------ 3643| 0| if (outError) ------------------ | Branch (3643:7): [True: 0, False: 0] ------------------ 3644| 0| *outError = READSTAT_ERROR_OPEN; 3645| 0| return NULL; 3646| 0| } 3647| 1.07k| readstat_schema_t *schema = NULL; 3648| 1.07k| unsigned char *bytes = NULL; 3649| 1.07k| readstat_error_t error = READSTAT_OK; 3650| 1.07k| ssize_t len = parser->io->seek(0, READSTAT_SEEK_END, parser->io->io_ctx); 3651| 1.07k| if (len == -1) { ------------------ | Branch (3651:6): [True: 0, False: 1.07k] ------------------ 3652| 0| error = READSTAT_ERROR_SEEK; 3653| 0| goto cleanup; 3654| 0| } 3655| 1.07k| parser->io->seek(0, READSTAT_SEEK_SET, parser->io->io_ctx); 3656| | 3657| 1.07k| bytes = malloc(len); 3658| | 3659| 1.07k| parser->io->read(bytes, len, parser->io->io_ctx); 3660| | 3661| 1.07k| unsigned char *p = bytes; 3662| 1.07k| unsigned char *pe = bytes + len; 3663| | 3664| 1.07k| unsigned char *eof = pe; 3665| | 3666| 1.07k| unsigned char *str_start = NULL; 3667| | 3668| 1.07k| size_t str_len = 0; 3669| | 3670| 1.07k| int cs; 3671| | 3672| 1.07k| double double_value = NAN; 3673| 1.07k| uint64_t first_integer = 0; 3674| 1.07k| uint64_t integer = 0; 3675| 1.07k| int line_no = 0; 3676| 1.07k| unsigned char *line_start = p; 3677| | 3678| 1.07k| char varname[32]; 3679| 1.07k| char argname[32]; 3680| 1.07k| char labelset[32]; 3681| 1.07k| char string_value[32]; 3682| 1.07k| char buf[1024]; 3683| | 3684| 1.07k| readstat_type_t var_type = READSTAT_TYPE_DOUBLE; 3685| 1.07k| label_type_t label_type = LABEL_TYPE_DOUBLE; 3686| 1.07k| int var_row = 0, var_col = 0; 3687| 1.07k| int var_len = 0; 3688| | 3689| 1.07k| if ((schema = calloc(1, sizeof(readstat_schema_t))) == NULL) { ------------------ | Branch (3689:6): [True: 0, False: 1.07k] ------------------ 3690| 0| error = READSTAT_ERROR_MALLOC; 3691| 0| goto cleanup; 3692| 0| } 3693| | 3694| 1.07k| schema->rows_per_observation = 1; 3695| | 3696| | 3697| 1.07k|#line 3698 "src/txt/readstat_sas_commands_read.c" 3698| 1.07k| { 3699| 1.07k| cs = (int)sas_commands_start; 3700| 1.07k| } 3701| | 3702| 1.07k|#line 3703 "src/txt/readstat_sas_commands_read.c" 3703| 1.07k| { 3704| 1.07k| int _klen; 3705| 1.07k| unsigned int _trans = 0; 3706| 1.07k| const char * _keys; 3707| 1.07k| const signed char * _acts; 3708| 1.07k| unsigned int _nacts; 3709| 6.85M| _resume: {} 3710| 6.85M| if ( p == pe && p != eof ) ------------------ | Branch (3710:8): [True: 1.01k, False: 6.85M] | Branch (3710:19): [True: 0, False: 1.01k] ------------------ 3711| 0| goto _out; 3712| 6.85M| if ( p == eof ) { ------------------ | Branch (3712:8): [True: 1.01k, False: 6.85M] ------------------ 3713| 1.01k| if ( _sas_commands_eof_trans[cs] > 0 ) { ------------------ | Branch (3713:9): [True: 1.01k, False: 0] ------------------ 3714| 1.01k| _trans = (unsigned int)_sas_commands_eof_trans[cs] - 1; 3715| 1.01k| } 3716| 1.01k| } 3717| 6.85M| else { 3718| 6.85M| _keys = ( _sas_commands_trans_keys + (_sas_commands_key_offsets[cs])); 3719| 6.85M| _trans = (unsigned int)_sas_commands_index_offsets[cs]; 3720| | 3721| 6.85M| _klen = (int)_sas_commands_single_lengths[cs]; 3722| 6.85M| if ( _klen > 0 ) { ------------------ | Branch (3722:9): [True: 6.85M, False: 898] ------------------ 3723| 6.85M| const char *_lower = _keys; 3724| 6.85M| const char *_upper = _keys + _klen - 1; 3725| 6.85M| const char *_mid; 3726| 20.7M| while ( 1 ) { ------------------ | Branch (3726:13): [True: 20.7M, Folded] ------------------ 3727| 20.7M| if ( _upper < _lower ) { ------------------ | Branch (3727:11): [True: 6.79M, False: 13.9M] ------------------ 3728| 6.79M| _keys += _klen; 3729| 6.79M| _trans += (unsigned int)_klen; 3730| 6.79M| break; 3731| 6.79M| } 3732| | 3733| 13.9M| _mid = _lower + ((_upper-_lower) >> 1); 3734| 13.9M| if ( ( (*( p))) < (*( _mid)) ) ------------------ | Branch (3734:11): [True: 3.01M, False: 10.9M] ------------------ 3735| 3.01M| _upper = _mid - 1; 3736| 10.9M| else if ( ( (*( p))) > (*( _mid)) ) ------------------ | Branch (3736:16): [True: 10.9M, False: 61.0k] ------------------ 3737| 10.9M| _lower = _mid + 1; 3738| 61.0k| else { 3739| 61.0k| _trans += (unsigned int)(_mid - _keys); 3740| 61.0k| goto _match; 3741| 61.0k| } 3742| 13.9M| } 3743| 6.85M| } 3744| | 3745| 6.79M| _klen = (int)_sas_commands_range_lengths[cs]; 3746| 6.79M| if ( _klen > 0 ) { ------------------ | Branch (3746:9): [True: 3.49M, False: 3.29M] ------------------ 3747| 3.49M| const char *_lower = _keys; 3748| 3.49M| const char *_upper = _keys + (_klen<<1) - 2; 3749| 3.49M| const char *_mid; 3750| 6.71M| while ( 1 ) { ------------------ | Branch (3750:13): [True: 6.71M, Folded] ------------------ 3751| 6.71M| if ( _upper < _lower ) { ------------------ | Branch (3751:11): [True: 223, False: 6.71M] ------------------ 3752| 223| _trans += (unsigned int)_klen; 3753| 223| break; 3754| 223| } 3755| | 3756| 6.71M| _mid = _lower + (((_upper-_lower) >> 1) & ~1); 3757| 6.71M| if ( ( (*( p))) < (*( _mid)) ) ------------------ | Branch (3757:11): [True: 857k, False: 5.85M] ------------------ 3758| 857k| _upper = _mid - 2; 3759| 5.85M| else if ( ( (*( p))) > (*( _mid + 1)) ) ------------------ | Branch (3759:16): [True: 2.35M, False: 3.49M] ------------------ 3760| 2.35M| _lower = _mid + 2; 3761| 3.49M| else { 3762| 3.49M| _trans += (unsigned int)((_mid - _keys)>>1); 3763| 3.49M| break; 3764| 3.49M| } 3765| 6.71M| } 3766| 3.49M| } 3767| | 3768| 6.85M| _match: {} 3769| 6.85M| } 3770| 6.85M| cs = (int)_sas_commands_cond_targs[_trans]; 3771| | 3772| 6.85M| if ( _sas_commands_cond_actions[_trans] != 0 ) { ------------------ | Branch (3772:8): [True: 45.8k, False: 6.80M] ------------------ 3773| | 3774| 45.8k| _acts = ( _sas_commands_actions + (_sas_commands_cond_actions[_trans])); 3775| 45.8k| _nacts = (unsigned int)(*( _acts)); 3776| 45.8k| _acts += 1; 3777| 128k| while ( _nacts > 0 ) { ------------------ | Branch (3777:12): [True: 82.3k, False: 45.8k] ------------------ 3778| 82.3k| switch ( (*( _acts)) ) ------------------ | Branch (3778:14): [True: 82.3k, False: 0] ------------------ 3779| 82.3k| { 3780| 7.63k| case 0: { ------------------ | Branch (3780:6): [True: 7.63k, False: 74.6k] ------------------ 3781| 7.63k| { 3782| 7.63k|#line 72 "src/txt/readstat_sas_commands_read.rl" 3783| | 3784| 7.63k| integer = 0; 3785| 7.63k| } 3786| | 3787| 7.63k|#line 3788 "src/txt/readstat_sas_commands_read.c" 3788| | 3789| 7.63k| break; 3790| 0| } 3791| 7.84k| case 1: { ------------------ | Branch (3791:6): [True: 7.84k, False: 74.4k] ------------------ 3792| 7.84k| { 3793| 7.84k|#line 76 "src/txt/readstat_sas_commands_read.rl" 3794| | 3795| 7.84k| integer = 10 * integer + ((( (*( p)))) - '0'); 3796| 7.84k| } 3797| | 3798| 7.84k|#line 3799 "src/txt/readstat_sas_commands_read.c" 3799| | 3800| 7.84k| break; 3801| 0| } 3802| 2.20k| case 2: { ------------------ | Branch (3802:6): [True: 2.20k, False: 80.1k] ------------------ 3803| 2.20k| { 3804| 2.20k|#line 80 "src/txt/readstat_sas_commands_read.rl" 3805| | 3806| 2.20k| int value = 0; 3807| 2.20k| if ((( (*( p)))) >= '0' && (( (*( p)))) <= '9') { ------------------ | Branch (3807:12): [True: 2.20k, False: 0] | Branch (3807:35): [True: 303, False: 1.89k] ------------------ 3808| 303| value = (( (*( p)))) - '0'; 3809| 1.89k| } else if ((( (*( p)))) >= 'A' && (( (*( p)))) <= 'F') { ------------------ | Branch (3809:19): [True: 1.89k, False: 0] | Branch (3809:42): [True: 964, False: 933] ------------------ 3810| 964| value = (( (*( p)))) - 'A' + 10; 3811| 964| } else if ((( (*( p)))) >= 'a' && (( (*( p)))) <= 'f') { ------------------ | Branch (3811:19): [True: 933, False: 0] | Branch (3811:42): [True: 933, False: 0] ------------------ 3812| 933| value = (( (*( p)))) - 'a' + 10; 3813| 933| } 3814| 2.20k| integer = 16 * integer + value; 3815| 2.20k| } 3816| | 3817| 2.20k|#line 3818 "src/txt/readstat_sas_commands_read.c" 3818| | 3819| 2.20k| break; 3820| 0| } 3821| 353| case 3: { ------------------ | Branch (3821:6): [True: 353, False: 81.9k] ------------------ 3822| 353| { 3823| 353|#line 92 "src/txt/readstat_sas_commands_read.rl" 3824| | 3825| 353| var_col = integer - 1; 3826| 353| var_len = 1; 3827| 353| } 3828| | 3829| 353|#line 3830 "src/txt/readstat_sas_commands_read.c" 3830| | 3831| 353| break; 3832| 0| } 3833| 347| case 4: { ------------------ | Branch (3833:6): [True: 347, False: 81.9k] ------------------ 3834| 347| { 3835| 347|#line 97 "src/txt/readstat_sas_commands_read.rl" 3836| | 3837| 347| var_len = integer - var_col; 3838| 347| } 3839| | 3840| 347|#line 3841 "src/txt/readstat_sas_commands_read.c" 3841| | 3842| 347| break; 3843| 0| } 3844| 359| case 5: { ------------------ | Branch (3844:6): [True: 359, False: 81.9k] ------------------ 3845| 359| { 3846| 359|#line 101 "src/txt/readstat_sas_commands_read.rl" 3847| | 3848| 359| var_type = READSTAT_TYPE_STRING; 3849| 359| } 3850| | 3851| 359|#line 3852 "src/txt/readstat_sas_commands_read.c" 3852| | 3853| 359| break; 3854| 0| } 3855| 1.58k| case 6: { ------------------ | Branch (3855:6): [True: 1.58k, False: 80.7k] ------------------ 3856| 1.58k| { 3857| 1.58k|#line 105 "src/txt/readstat_sas_commands_read.rl" 3858| | 3859| 1.58k| var_type = READSTAT_TYPE_DOUBLE; 3860| 1.58k| } 3861| | 3862| 1.58k|#line 3863 "src/txt/readstat_sas_commands_read.c" 3863| | 3864| 1.58k| break; 3865| 0| } 3866| 3.98k| case 7: { ------------------ | Branch (3866:6): [True: 3.98k, False: 78.3k] ------------------ 3867| 3.98k| { 3868| 3.98k|#line 109 "src/txt/readstat_sas_commands_read.rl" 3869| | 3870| 3.98k| readstat_copy(buf, sizeof(buf), (char *)str_start, str_len); 3871| 3.98k| } 3872| | 3873| 3.98k|#line 3874 "src/txt/readstat_sas_commands_read.c" 3874| | 3875| 3.98k| break; 3876| 0| } 3877| 697| case 8: { ------------------ | Branch (3877:6): [True: 697, False: 81.6k] ------------------ 3878| 697| { 3879| 697|#line 113 "src/txt/readstat_sas_commands_read.rl" 3880| | 3881| 697| readstat_copy(labelset, sizeof(labelset), (char *)str_start, str_len); 3882| 697| } 3883| | 3884| 697|#line 3885 "src/txt/readstat_sas_commands_read.c" 3885| | 3886| 697| break; 3887| 0| } 3888| 863| case 9: { ------------------ | Branch (3888:6): [True: 863, False: 81.4k] ------------------ 3889| 863| { 3890| 863|#line 117 "src/txt/readstat_sas_commands_read.rl" 3891| | 3892| 863| readstat_copy(string_value, sizeof(string_value), (char *)str_start, str_len); 3893| 863| } 3894| | 3895| 863|#line 3896 "src/txt/readstat_sas_commands_read.c" 3896| | 3897| 863| break; 3898| 0| } 3899| 2.03k| case 10: { ------------------ | Branch (3899:6): [True: 2.03k, False: 80.2k] ------------------ 3900| 2.03k| { 3901| 2.03k|#line 121 "src/txt/readstat_sas_commands_read.rl" 3902| | 3903| 2.03k| readstat_copy(argname, sizeof(argname), (char *)str_start, str_len); 3904| 2.03k| } 3905| | 3906| 2.03k|#line 3907 "src/txt/readstat_sas_commands_read.c" 3907| | 3908| 2.03k| break; 3909| 0| } 3910| 3.32k| case 11: { ------------------ | Branch (3910:6): [True: 3.32k, False: 79.0k] ------------------ 3911| 3.32k| { 3912| 3.32k|#line 125 "src/txt/readstat_sas_commands_read.rl" 3913| | 3914| 3.32k| readstat_copy_lower(varname, sizeof(varname), (char *)str_start, str_len); 3915| 3.32k| } 3916| | 3917| 3.32k|#line 3918 "src/txt/readstat_sas_commands_read.c" 3918| | 3919| 3.32k| break; 3920| 0| } 3921| 1.71k| case 12: { ------------------ | Branch (3921:6): [True: 1.71k, False: 80.6k] ------------------ 3922| 1.71k| { 3923| 1.71k|#line 129 "src/txt/readstat_sas_commands_read.rl" 3924| | 3925| 1.71k| if (strcasecmp(argname, "firstobs") == 0) { ------------------ | Branch (3925:12): [True: 196, False: 1.51k] ------------------ 3926| 196| schema->first_line = integer; 3927| 196| } 3928| 1.71k| if (strcasecmp(argname, "dlm") == 0) { ------------------ | Branch (3928:12): [True: 686, False: 1.02k] ------------------ 3929| 686| schema->field_delimiter = integer ? integer : buf[0]; ------------------ | Branch (3929:35): [True: 400, False: 286] ------------------ 3930| 686| } 3931| 1.71k| } 3932| | 3933| 1.71k|#line 3934 "src/txt/readstat_sas_commands_read.c" 3934| | 3935| 1.71k| break; 3936| 0| } 3937| 347| case 13: { ------------------ | Branch (3937:6): [True: 347, False: 81.9k] ------------------ 3938| 347| { 3939| 347|#line 138 "src/txt/readstat_sas_commands_read.rl" 3940| | 3941| 347| readstat_schema_entry_t *entry = readstat_schema_find_or_create_entry(schema, varname); 3942| 347| entry->variable.type = var_type; 3943| 347| entry->variable.storage_width = var_len; 3944| 347| entry->row = var_row; 3945| 347| entry->col = var_col; 3946| 347| entry->len = var_len; 3947| 347| } 3948| | 3949| 347|#line 3950 "src/txt/readstat_sas_commands_read.c" 3950| | 3951| 347| break; 3952| 0| } 3953| 1.59k| case 14: { ------------------ | Branch (3953:6): [True: 1.59k, False: 80.7k] ------------------ 3954| 1.59k| { 3955| 1.59k|#line 147 "src/txt/readstat_sas_commands_read.rl" 3956| | 3957| 1.59k| readstat_schema_entry_t *entry = readstat_schema_find_or_create_entry(schema, varname); 3958| 1.59k| entry->variable.storage_width = var_len; 3959| 1.59k| entry->len = var_len; 3960| 1.59k| } 3961| | 3962| 1.59k|#line 3963 "src/txt/readstat_sas_commands_read.c" 3963| | 3964| 1.59k| break; 3965| 0| } 3966| 274| case 15: { ------------------ | Branch (3966:6): [True: 274, False: 82.0k] ------------------ 3967| 274| { 3968| 274|#line 153 "src/txt/readstat_sas_commands_read.rl" 3969| | 3970| 274| readstat_schema_entry_t *entry = readstat_schema_find_or_create_entry(schema, varname); 3971| 274| readstat_copy(entry->variable.label, sizeof(entry->variable.label), buf, sizeof(buf)); 3972| 274| } 3973| | 3974| 274|#line 3975 "src/txt/readstat_sas_commands_read.c" 3975| | 3976| 274| break; 3977| 0| } 3978| 444| case 16: { ------------------ | Branch (3978:6): [True: 444, False: 81.8k] ------------------ 3979| 444| { 3980| 444|#line 158 "src/txt/readstat_sas_commands_read.rl" 3981| | 3982| 444| readstat_schema_entry_t *entry = readstat_schema_find_or_create_entry(schema, varname); 3983| 444| readstat_copy(entry->labelset, sizeof(entry->labelset), labelset, sizeof(labelset)); 3984| 444| } 3985| | 3986| 444|#line 3987 "src/txt/readstat_sas_commands_read.c" 3987| | 3988| 444| break; 3989| 0| } 3990| 2.82k| case 17: { ------------------ | Branch (3990:6): [True: 2.82k, False: 79.5k] ------------------ 3991| 2.82k| { 3992| 2.82k|#line 163 "src/txt/readstat_sas_commands_read.rl" 3993| | 3994| 2.82k| error = submit_value_label(parser, labelset, label_type, 3995| 2.82k| first_integer, integer, double_value, string_value, buf, user_ctx); 3996| 2.82k| if (error != READSTAT_OK) ------------------ | Branch (3996:12): [True: 0, False: 2.82k] ------------------ 3997| 0| goto cleanup; 3998| 2.82k| } 3999| | 4000| 2.82k|#line 4001 "src/txt/readstat_sas_commands_read.c" 4001| | 4002| 2.82k| break; 4003| 2.82k| } 4004| 3.38k| case 18: { ------------------ | Branch (4004:6): [True: 3.38k, False: 78.9k] ------------------ 4005| 3.38k| { 4006| 3.38k|#line 170 "src/txt/readstat_sas_commands_read.rl" 4007| 3.38k| str_start = p; } 4008| | 4009| 3.38k|#line 4010 "src/txt/readstat_sas_commands_read.c" 4010| | 4011| 3.38k| break; 4012| 2.82k| } 4013| 3.95k| case 19: { ------------------ | Branch (4013:6): [True: 3.95k, False: 78.3k] ------------------ 4014| 3.95k| { 4015| 3.95k|#line 170 "src/txt/readstat_sas_commands_read.rl" 4016| 3.95k| str_len = p - str_start; } 4017| | 4018| 3.95k|#line 4019 "src/txt/readstat_sas_commands_read.c" 4019| | 4020| 3.95k| break; 4021| 2.82k| } 4022| 670| case 20: { ------------------ | Branch (4022:6): [True: 670, False: 81.6k] ------------------ 4023| 670| { 4024| 670|#line 172 "src/txt/readstat_sas_commands_read.rl" 4025| 670| str_start = p; } 4026| | 4027| 670|#line 4028 "src/txt/readstat_sas_commands_read.c" 4028| | 4029| 670| break; 4030| 2.82k| } 4031| 3.99k| case 21: { ------------------ | Branch (4031:6): [True: 3.99k, False: 78.3k] ------------------ 4032| 3.99k| { 4033| 3.99k|#line 172 "src/txt/readstat_sas_commands_read.rl" 4034| 3.99k| str_len = p - str_start; } 4035| | 4036| 3.99k|#line 4037 "src/txt/readstat_sas_commands_read.c" 4037| | 4038| 3.99k| break; 4039| 2.82k| } 4040| 8.42k| case 22: { ------------------ | Branch (4040:6): [True: 8.42k, False: 73.9k] ------------------ 4041| 8.42k| { 4042| 8.42k|#line 180 "src/txt/readstat_sas_commands_read.rl" 4043| 8.42k| line_no++; line_start = p; } 4044| | 4045| 8.42k|#line 4046 "src/txt/readstat_sas_commands_read.c" 4046| | 4047| 8.42k| break; 4048| 2.82k| } 4049| 7.35k| case 23: { ------------------ | Branch (4049:6): [True: 7.35k, False: 74.9k] ------------------ 4050| 7.35k| { 4051| 7.35k|#line 184 "src/txt/readstat_sas_commands_read.rl" 4052| 7.35k| str_start = p; } 4053| | 4054| 7.35k|#line 4055 "src/txt/readstat_sas_commands_read.c" 4055| | 4056| 7.35k| break; 4057| 2.82k| } 4058| 7.42k| case 24: { ------------------ | Branch (4058:6): [True: 7.42k, False: 74.9k] ------------------ 4059| 7.42k| { 4060| 7.42k|#line 184 "src/txt/readstat_sas_commands_read.rl" 4061| 7.42k| str_len = p - str_start; } 4062| | 4063| 7.42k|#line 4064 "src/txt/readstat_sas_commands_read.c" 4064| | 4065| 7.42k| break; 4066| 2.82k| } 4067| 915| case 25: { ------------------ | Branch (4067:6): [True: 915, False: 81.4k] ------------------ 4068| 915| { 4069| 915|#line 190 "src/txt/readstat_sas_commands_read.rl" 4070| 915| str_start = p; } 4071| | 4072| 915|#line 4073 "src/txt/readstat_sas_commands_read.c" 4073| | 4074| 915| break; 4075| 2.82k| } 4076| 194| case 26: { ------------------ | Branch (4076:6): [True: 194, False: 82.1k] ------------------ 4077| 194| { 4078| 194|#line 190 "src/txt/readstat_sas_commands_read.rl" 4079| 194| str_len = p - str_start; } 4080| | 4081| 194|#line 4082 "src/txt/readstat_sas_commands_read.c" 4082| | 4083| 194| break; 4084| 2.82k| } 4085| 407| case 27: { ------------------ | Branch (4085:6): [True: 407, False: 81.9k] ------------------ 4086| 407| { 4087| 407|#line 227 "src/txt/readstat_sas_commands_read.rl" 4088| 407| label_type = -1; } 4089| | 4090| 407|#line 4091 "src/txt/readstat_sas_commands_read.c" 4091| | 4092| 407| break; 4093| 2.82k| } 4094| 194| case 28: { ------------------ | Branch (4094:6): [True: 194, False: 82.1k] ------------------ 4095| 194| { 4096| 194|#line 229 "src/txt/readstat_sas_commands_read.rl" 4097| 194| label_type = LABEL_TYPE_DOUBLE; double_value = -(double)integer; } 4098| | 4099| 194|#line 4100 "src/txt/readstat_sas_commands_read.c" 4100| | 4101| 194| break; 4102| 2.82k| } 4103| 1.44k| case 29: { ------------------ | Branch (4103:6): [True: 1.44k, False: 80.8k] ------------------ 4104| 1.44k| { 4105| 1.44k|#line 230 "src/txt/readstat_sas_commands_read.rl" 4106| 1.44k| label_type = LABEL_TYPE_DOUBLE; double_value = integer; } 4107| | 4108| 1.44k|#line 4109 "src/txt/readstat_sas_commands_read.c" 4109| | 4110| 1.44k| break; 4111| 2.82k| } 4112| 1.14k| case 30: { ------------------ | Branch (4112:6): [True: 1.14k, False: 81.1k] ------------------ 4113| 1.14k| { 4114| 1.14k|#line 231 "src/txt/readstat_sas_commands_read.rl" 4115| 1.14k| first_integer = integer; } 4116| | 4117| 1.14k|#line 4118 "src/txt/readstat_sas_commands_read.c" 4118| | 4119| 1.14k| break; 4120| 2.82k| } 4121| 1.13k| case 31: { ------------------ | Branch (4121:6): [True: 1.13k, False: 81.2k] ------------------ 4122| 1.13k| { 4123| 1.13k|#line 231 "src/txt/readstat_sas_commands_read.rl" 4124| 1.13k| label_type = LABEL_TYPE_RANGE; } 4125| | 4126| 1.13k|#line 4127 "src/txt/readstat_sas_commands_read.c" 4127| | 4128| 1.13k| break; 4129| 2.82k| } 4130| 578| case 32: { ------------------ | Branch (4130:6): [True: 578, False: 81.7k] ------------------ 4131| 578| { 4132| 578|#line 232 "src/txt/readstat_sas_commands_read.rl" 4133| 578| label_type = LABEL_TYPE_STRING; } 4134| | 4135| 578|#line 4136 "src/txt/readstat_sas_commands_read.c" 4136| | 4137| 578| break; 4138| 2.82k| } 4139| 285| case 33: { ------------------ | Branch (4139:6): [True: 285, False: 82.0k] ------------------ 4140| 285| { 4141| 285|#line 233 "src/txt/readstat_sas_commands_read.rl" 4142| 285| label_type = LABEL_TYPE_STRING; } 4143| | 4144| 285|#line 4145 "src/txt/readstat_sas_commands_read.c" 4145| | 4146| 285| break; 4147| 2.82k| } 4148| 204| case 34: { ------------------ | Branch (4148:6): [True: 204, False: 82.1k] ------------------ 4149| 204| { 4150| 204|#line 234 "src/txt/readstat_sas_commands_read.rl" 4151| 204| label_type = LABEL_TYPE_OTHER; } 4152| | 4153| 204|#line 4154 "src/txt/readstat_sas_commands_read.c" 4154| | 4155| 204| break; 4156| 2.82k| } 4157| 1.59k| case 35: { ------------------ | Branch (4157:6): [True: 1.59k, False: 80.7k] ------------------ 4158| 1.59k| { 4159| 1.59k|#line 237 "src/txt/readstat_sas_commands_read.rl" 4160| 1.59k| var_len = integer; } 4161| | 4162| 1.59k|#line 4163 "src/txt/readstat_sas_commands_read.c" 4163| | 4164| 1.59k| break; 4165| 2.82k| } 4166| 282| case 36: { ------------------ | Branch (4166:6): [True: 282, False: 82.0k] ------------------ 4167| 282| { 4168| 282|#line 340 "src/txt/readstat_sas_commands_read.rl" 4169| 282| var_row = integer - 1; } 4170| | 4171| 282|#line 4172 "src/txt/readstat_sas_commands_read.c" 4172| | 4173| 282| break; 4174| 2.82k| } 4175| 341| case 37: { ------------------ | Branch (4175:6): [True: 341, False: 81.9k] ------------------ 4176| 341| { 4177| 341|#line 344 "src/txt/readstat_sas_commands_read.rl" 4178| 341| var_row = 0; } 4179| | 4180| 341|#line 4181 "src/txt/readstat_sas_commands_read.c" 4181| | 4182| 341| break; 4183| 2.82k| } 4184| 82.3k| } 4185| 82.3k| _nacts -= 1; 4186| 82.3k| _acts += 1; 4187| 82.3k| } 4188| | 4189| 45.8k| } 4190| | 4191| 6.85M| if ( p == eof ) { ------------------ | Branch (4191:8): [True: 1.01k, False: 6.85M] ------------------ 4192| 1.01k| if ( cs >= 1159 ) ------------------ | Branch (4192:9): [True: 238, False: 781] ------------------ 4193| 238| goto _out; 4194| 1.01k| } 4195| 6.85M| else { 4196| 6.85M| if ( cs != 0 ) { ------------------ | Branch (4196:9): [True: 6.85M, False: 55] ------------------ 4197| 6.85M| p += 1; 4198| 6.85M| goto _resume; 4199| 6.85M| } 4200| 6.85M| } 4201| 1.07k| _out: {} 4202| 1.07k| } 4203| | 4204| 0|#line 403 "src/txt/readstat_sas_commands_read.rl" 4205| | 4206| | 4207| | /* suppress warnings */ 4208| 0| (void)sas_commands_en_main; 4209| | 4210| 1.07k| if (cs < ------------------ | Branch (4210:6): [True: 836, False: 238] ------------------ 4211| 1.07k|#line 4212 "src/txt/readstat_sas_commands_read.c" 4212| 1.07k| 1159 4213| 1.07k|#line 408 "src/txt/readstat_sas_commands_read.rl" 4214| 1.07k| ) { 4215| 836| char error_buf[1024]; 4216| 836| if (p == pe) { ------------------ | Branch (4216:7): [True: 781, False: 55] ------------------ 4217| 781| snprintf(error_buf, sizeof(error_buf), "Error parsing SAS command file (end-of-file unexpectedly reached)"); 4218| 781| } else { 4219| 55| snprintf(error_buf, sizeof(error_buf), "Error parsing SAS command file around line #%d, col #%ld (0x%02x = %c)", 4220| 55| line_no + 1, (long)(p - line_start + 1), *p, *p); 4221| 55| } 4222| 836| if (parser->handlers.error) { ------------------ | Branch (4222:7): [True: 0, False: 836] ------------------ 4223| 0| parser->handlers.error(error_buf, user_ctx); 4224| 0| } 4225| 836| error = READSTAT_ERROR_PARSE; 4226| 836| goto cleanup; 4227| 836| } 4228| | 4229| 238| error = submit_columns(parser, schema, user_ctx); 4230| | 4231| 1.07k| cleanup: 4232| 1.07k| parser->io->close(parser->io->io_ctx); 4233| 1.07k| free(bytes); 4234| 1.07k| if (error != READSTAT_OK) { ------------------ | Branch (4234:6): [True: 836, False: 238] ------------------ 4235| 836| if (outError) ------------------ | Branch (4235:7): [True: 0, False: 836] ------------------ 4236| 0| *outError = error; 4237| 836| readstat_schema_free(schema); 4238| 836| schema = NULL; 4239| 836| } 4240| | 4241| 1.07k| return schema; 4242| 238|} readstat_schema_free: 7| 1.07k|void readstat_schema_free(readstat_schema_t *schema) { 8| 1.07k| if (schema) { ------------------ | Branch (8:9): [True: 1.07k, False: 0] ------------------ 9| 1.07k| free(schema->entries); 10| 1.07k| free(schema); 11| 1.07k| } 12| 1.07k|} readstat_schema_find_or_create_entry: 14| 2.65k|readstat_schema_entry_t *readstat_schema_find_or_create_entry(readstat_schema_t *dct, const char *var_name) { 15| 2.65k| readstat_schema_entry_t *entry = NULL; 16| 2.65k| int i; 17| | /* linear search. this is shitty, but whatever */ 18| 36.6k| for (i=0; ientry_count; i++) { ------------------ | Branch (18:15): [True: 35.3k, False: 1.32k] ------------------ 19| 35.3k| if (strcmp(dct->entries[i].variable.name, var_name) == 0) { ------------------ | Branch (19:13): [True: 1.33k, False: 33.9k] ------------------ 20| 1.33k| entry = &dct->entries[i]; 21| 1.33k| break; 22| 1.33k| } 23| 35.3k| } 24| 2.65k| if (!entry) { ------------------ | Branch (24:9): [True: 1.32k, False: 1.33k] ------------------ 25| 1.32k| dct->entries = realloc(dct->entries, sizeof(readstat_schema_entry_t) * (dct->entry_count + 1)); 26| 1.32k| entry = &dct->entries[dct->entry_count]; 27| 1.32k| memset(entry, 0, sizeof(readstat_schema_entry_t)); 28| | 29| 1.32k| readstat_copy(entry->variable.name, sizeof(entry->variable.name), var_name, strlen(var_name)); 30| 1.32k| entry->decimal_separator = '.'; 31| 1.32k| entry->variable.index = dct->entry_count++; 32| 1.32k| } 33| 2.65k| return entry; 34| 2.65k|}