fuzzer_parser_init: 33| 1.05k|readstat_parser_t *fuzzer_parser_init(const uint8_t *Data, size_t Size) { 34| 1.05k| readstat_parser_t *parser = readstat_parser_init(); 35| 1.05k| readstat_set_open_handler(parser, rt_open_handler); 36| 1.05k| readstat_set_close_handler(parser, rt_close_handler); 37| 1.05k| readstat_set_seek_handler(parser, rt_seek_handler); 38| 1.05k| readstat_set_read_handler(parser, rt_read_handler); 39| 1.05k| readstat_set_update_handler(parser, rt_update_handler); 40| | 41| 1.05k| readstat_set_metadata_handler(parser, &handle_metadata); 42| 1.05k| readstat_set_note_handler(parser, &handle_note); 43| 1.05k| readstat_set_variable_handler(parser, &handle_variable); 44| 1.05k| readstat_set_fweight_handler(parser, &handle_fweight); 45| 1.05k| readstat_set_value_handler(parser, &handle_value); 46| 1.05k| readstat_set_value_label_handler(parser, &handle_value_label); 47| | 48| 1.05k| return parser; 49| 1.05k|} fuzz_format.c:handle_variable: 21| 1.20k| const char *val_labels, void *ctx) { 22| 1.20k| return READSTAT_HANDLER_OK; 23| 1.20k|} fuzz_format.c:handle_value_label: 29| 8.32M|static int handle_value_label(const char *val_labels, readstat_value_t value, const char *label, void *ctx) { 30| 8.32M| return READSTAT_HANDLER_OK; 31| 8.32M|} LLVMFuzzerTestOneInput: 11| 1.05k|int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 12| 1.05k| rt_buffer_t buffer = { .bytes = (char *)Data, .size = Size, .used = Size }; 13| 1.05k| rt_buffer_ctx_t buffer_ctx = { .buffer = &buffer }; 14| | 15| 1.05k| readstat_parser_t *parser = fuzzer_parser_init(Data, Size); 16| 1.05k| readstat_set_io_ctx(parser, &buffer_ctx); 17| | 18| 1.05k| readstat_schema_t *schema = readstat_parse_spss_commands(parser, NULL, NULL, NULL); 19| 1.05k| if (schema) ------------------ | Branch (19:9): [True: 232, False: 823] ------------------ 20| 232| readstat_schema_free(schema); 21| 1.05k| readstat_parser_free(parser); 22| | 23| 1.05k| return 0; 24| 1.05k|} unistd_io_init: 121| 1.05k|readstat_error_t unistd_io_init(readstat_parser_t *parser) { 122| 1.05k| readstat_error_t retval = READSTAT_OK; 123| 1.05k| unistd_io_ctx_t *io_ctx = NULL; 124| | 125| 1.05k| if ((retval = readstat_set_open_handler(parser, unistd_open_handler)) != READSTAT_OK) ------------------ | Branch (125:9): [True: 0, False: 1.05k] ------------------ 126| 0| return retval; 127| | 128| 1.05k| if ((retval = readstat_set_close_handler(parser, unistd_close_handler)) != READSTAT_OK) ------------------ | Branch (128:9): [True: 0, False: 1.05k] ------------------ 129| 0| return retval; 130| | 131| 1.05k| if ((retval = readstat_set_seek_handler(parser, unistd_seek_handler)) != READSTAT_OK) ------------------ | Branch (131:9): [True: 0, False: 1.05k] ------------------ 132| 0| return retval; 133| | 134| 1.05k| if ((retval = readstat_set_read_handler(parser, unistd_read_handler)) != READSTAT_OK) ------------------ | Branch (134:9): [True: 0, False: 1.05k] ------------------ 135| 0| return retval; 136| | 137| 1.05k| if ((readstat_set_update_handler(parser, unistd_update_handler)) != READSTAT_OK) ------------------ | Branch (137:9): [True: 0, False: 1.05k] ------------------ 138| 0| return retval; 139| | 140| 1.05k| io_ctx = calloc(1, sizeof(unistd_io_ctx_t)); 141| 1.05k| io_ctx->fd = -1; 142| | 143| 1.05k| retval = readstat_set_io_ctx(parser, (void*) io_ctx); 144| 1.05k| parser->io->io_ctx_needs_free = 1; 145| | 146| 1.05k| return retval; 147| 1.05k|} readstat_parser_init: 6| 1.05k|readstat_parser_t *readstat_parser_init(void) { 7| 1.05k| readstat_parser_t *parser = calloc(1, sizeof(readstat_parser_t)); 8| 1.05k| parser->io = calloc(1, sizeof(readstat_io_t)); 9| 1.05k| if (unistd_io_init(parser) != READSTAT_OK) { ------------------ | Branch (9:9): [True: 0, False: 1.05k] ------------------ 10| 0| readstat_parser_free(parser); 11| 0| return NULL; 12| 0| } 13| 1.05k| parser->output_encoding = "UTF-8"; 14| 1.05k| return parser; 15| 1.05k|} readstat_parser_free: 17| 1.05k|void readstat_parser_free(readstat_parser_t *parser) { 18| 1.05k| if (parser) { ------------------ | Branch (18:9): [True: 1.05k, False: 0] ------------------ 19| 1.05k| if (parser->io) { ------------------ | Branch (19:13): [True: 1.05k, False: 0] ------------------ 20| | readstat_set_io_ctx(parser, NULL); 21| 1.05k| free(parser->io); 22| 1.05k| } 23| 1.05k| free(parser); 24| 1.05k| } 25| 1.05k|} readstat_set_metadata_handler: 27| 1.05k|readstat_error_t readstat_set_metadata_handler(readstat_parser_t *parser, readstat_metadata_handler metadata_handler) { 28| 1.05k| parser->handlers.metadata = metadata_handler; 29| 1.05k| return READSTAT_OK; 30| 1.05k|} readstat_set_note_handler: 32| 1.05k|readstat_error_t readstat_set_note_handler(readstat_parser_t *parser, readstat_note_handler note_handler) { 33| 1.05k| parser->handlers.note = note_handler; 34| 1.05k| return READSTAT_OK; 35| 1.05k|} readstat_set_variable_handler: 37| 1.05k|readstat_error_t readstat_set_variable_handler(readstat_parser_t *parser, readstat_variable_handler variable_handler) { 38| 1.05k| parser->handlers.variable = variable_handler; 39| 1.05k| return READSTAT_OK; 40| 1.05k|} readstat_set_value_handler: 42| 1.05k|readstat_error_t readstat_set_value_handler(readstat_parser_t *parser, readstat_value_handler value_handler) { 43| 1.05k| parser->handlers.value = value_handler; 44| 1.05k| return READSTAT_OK; 45| 1.05k|} readstat_set_value_label_handler: 47| 1.05k|readstat_error_t readstat_set_value_label_handler(readstat_parser_t *parser, readstat_value_label_handler label_handler) { 48| 1.05k| parser->handlers.value_label = label_handler; 49| 1.05k| return READSTAT_OK; 50| 1.05k|} readstat_set_fweight_handler: 62| 1.05k|readstat_error_t readstat_set_fweight_handler(readstat_parser_t *parser, readstat_fweight_handler fweight_handler) { 63| 1.05k| parser->handlers.fweight = fweight_handler; 64| 1.05k| return READSTAT_OK; 65| 1.05k|} readstat_set_open_handler: 67| 2.11k|readstat_error_t readstat_set_open_handler(readstat_parser_t *parser, readstat_open_handler open_handler) { 68| 2.11k| parser->io->open = open_handler; 69| 2.11k| return READSTAT_OK; 70| 2.11k|} readstat_set_close_handler: 72| 2.11k|readstat_error_t readstat_set_close_handler(readstat_parser_t *parser, readstat_close_handler close_handler) { 73| 2.11k| parser->io->close = close_handler; 74| 2.11k| return READSTAT_OK; 75| 2.11k|} readstat_set_seek_handler: 77| 2.11k|readstat_error_t readstat_set_seek_handler(readstat_parser_t *parser, readstat_seek_handler seek_handler) { 78| 2.11k| parser->io->seek = seek_handler; 79| 2.11k| return READSTAT_OK; 80| 2.11k|} readstat_set_read_handler: 82| 2.11k|readstat_error_t readstat_set_read_handler(readstat_parser_t *parser, readstat_read_handler read_handler) { 83| 2.11k| parser->io->read = read_handler; 84| 2.11k| return READSTAT_OK; 85| 2.11k|} readstat_set_update_handler: 87| 2.11k|readstat_error_t readstat_set_update_handler(readstat_parser_t *parser, readstat_update_handler update_handler) { 88| 2.11k| parser->io->update = update_handler; 89| 2.11k| return READSTAT_OK; 90| 2.11k|} readstat_set_io_ctx: 92| 3.16k|readstat_error_t readstat_set_io_ctx(readstat_parser_t *parser, void *io_ctx) { 93| 3.16k| if (parser->io->io_ctx_needs_free) { ------------------ | Branch (93:9): [True: 1.05k, False: 2.11k] ------------------ 94| 1.05k| free(parser->io->io_ctx); 95| 1.05k| } 96| | 97| 3.16k| parser->io->io_ctx = io_ctx; 98| 3.16k| parser->io->io_ctx_needs_free = 0; 99| | 100| 3.16k| return READSTAT_OK; 101| 3.16k|} rt_open_handler: 8| 1.05k|int rt_open_handler(const char *path, void *io_ctx) { 9| 1.05k| return 0; 10| 1.05k|} rt_close_handler: 12| 1.05k|int rt_close_handler(void *io_ctx) { 13| 1.05k| return 0; 14| 1.05k|} rt_seek_handler: 17| 2.11k| readstat_io_flags_t whence, void *io_ctx) { 18| 2.11k| rt_buffer_ctx_t *buffer_ctx = (rt_buffer_ctx_t *)io_ctx; 19| 2.11k| readstat_off_t newpos = -1; 20| 2.11k| if (whence == READSTAT_SEEK_SET) { ------------------ | Branch (20:9): [True: 1.05k, False: 1.05k] ------------------ 21| 1.05k| newpos = offset; 22| 1.05k| } else if (whence == READSTAT_SEEK_CUR) { ------------------ | Branch (22:16): [True: 0, False: 1.05k] ------------------ 23| 0| newpos = buffer_ctx->pos + offset; 24| 1.05k| } else if (whence == READSTAT_SEEK_END) { ------------------ | Branch (24:16): [True: 1.05k, False: 0] ------------------ 25| 1.05k| newpos = buffer_ctx->buffer->used + offset; 26| 1.05k| } 27| | 28| 2.11k| if (newpos < 0) ------------------ | Branch (28:9): [True: 0, False: 2.11k] ------------------ 29| 0| return -1; 30| | 31| 2.11k| if (newpos > buffer_ctx->buffer->used) ------------------ | Branch (31:9): [True: 0, False: 2.11k] ------------------ 32| 0| return -1; 33| | 34| 2.11k| buffer_ctx->pos = newpos; 35| 2.11k| return newpos; 36| 2.11k|} rt_read_handler: 38| 1.05k|ssize_t rt_read_handler(void *buf, size_t nbytes, void *io_ctx) { 39| 1.05k| rt_buffer_ctx_t *buffer_ctx = (rt_buffer_ctx_t *)io_ctx; 40| 1.05k| ssize_t bytes_copied = 0; 41| 1.05k| ssize_t bytes_left = buffer_ctx->buffer->used - buffer_ctx->pos; 42| 1.05k| if (nbytes <= bytes_left) { ------------------ | Branch (42:9): [True: 1.05k, False: 0] ------------------ 43| 1.05k| memcpy(buf, buffer_ctx->buffer->bytes + buffer_ctx->pos, nbytes); 44| 1.05k| bytes_copied = nbytes; 45| 1.05k| } 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.05k| buffer_ctx->pos += bytes_copied; 50| 1.05k| return bytes_copied; 51| 1.05k|} submit_value_label: 9| 2.91k| double double_value, const char *string_value, const char *buf, void *user_ctx) { 10| 2.91k| if (!parser->handlers.value_label) ------------------ | Branch (10:9): [True: 0, False: 2.91k] ------------------ 11| 0| return READSTAT_OK; 12| | 13| 2.91k| int cb_retval = READSTAT_HANDLER_OK; 14| 2.91k| if (label_type == LABEL_TYPE_RANGE) { ------------------ | Branch (14:9): [True: 859, False: 2.05k] ------------------ 15| 859| int64_t i; 16| 8.32M| for (i=first_integer; i<=last_integer; i++) { ------------------ | Branch (16:31): [True: 8.32M, False: 859] ------------------ 17| 8.32M| readstat_value_t value = { 18| 8.32M| .type = READSTAT_TYPE_DOUBLE, 19| 8.32M| .v = { .double_value = i } }; 20| 8.32M| cb_retval = parser->handlers.value_label(labelset, value, buf, user_ctx); 21| 8.32M| if (cb_retval != READSTAT_HANDLER_OK) ------------------ | Branch (21:17): [True: 0, False: 8.32M] ------------------ 22| 0| goto cleanup; 23| 8.32M| } 24| 2.05k| } else if (label_type != LABEL_TYPE_OTHER) { ------------------ | Branch (24:16): [True: 2.05k, False: 0] ------------------ 25| 2.05k| readstat_value_t value = { { 0 } }; 26| 2.05k| if (label_type == LABEL_TYPE_DOUBLE) { ------------------ | Branch (26:13): [True: 529, False: 1.52k] ------------------ 27| 529| value.type = READSTAT_TYPE_DOUBLE; 28| 529| value.v.double_value = double_value; 29| 1.52k| } else if (label_type == LABEL_TYPE_STRING) { ------------------ | Branch (29:20): [True: 729, False: 798] ------------------ 30| 729| value.type = READSTAT_TYPE_STRING; 31| 729| value.v.string_value = string_value; 32| 798| } else if (label_type == LABEL_TYPE_NAN) { ------------------ | Branch (32:20): [True: 798, False: 0] ------------------ 33| 798| value.type = READSTAT_TYPE_DOUBLE; 34| 798| value.v.double_value = NAN; 35| 798| } 36| | 37| 2.05k| cb_retval = parser->handlers.value_label(labelset, value, buf, user_ctx); 38| 2.05k| } 39| | 40| 2.91k|cleanup: 41| 2.91k| return (cb_retval == READSTAT_HANDLER_OK) ? READSTAT_OK : READSTAT_ERROR_USER_ABORT; ------------------ | Branch (41:12): [True: 2.91k, False: 0] ------------------ 42| 2.91k|} submit_columns: 44| 232|readstat_error_t submit_columns(readstat_parser_t *parser, readstat_schema_t *dct, void *user_ctx) { 45| 232| int i; 46| 232| int partial_entry_count = 0; 47| 1.43k| for (i=0; ientry_count; i++) { ------------------ | Branch (47:15): [True: 1.20k, False: 232] ------------------ 48| 1.20k| readstat_schema_entry_t *entry = &dct->entries[i]; 49| 1.20k| if (dct->rows_per_observation < entry->row + 1) { ------------------ | Branch (49:13): [True: 75, False: 1.12k] ------------------ 50| 75| dct->rows_per_observation = entry->row + 1; 51| 75| } 52| 1.20k| } 53| | 54| 232| if (!parser->handlers.variable) ------------------ | Branch (54:9): [True: 0, False: 232] ------------------ 55| 0| return READSTAT_OK; 56| | 57| 1.43k| for (i=0; ientry_count; i++) { ------------------ | Branch (57:15): [True: 1.20k, False: 232] ------------------ 58| 1.20k| readstat_schema_entry_t *entry = &dct->entries[i]; 59| 1.20k| entry->variable.index = i; 60| 1.20k| entry->variable.index_after_skipping = partial_entry_count; 61| 1.20k| if (entry->variable.type == READSTAT_TYPE_STRING) ------------------ | Branch (61:13): [True: 817, False: 387] ------------------ 62| 817| entry->variable.storage_width = entry->len; 63| 1.20k| int cb_retval = parser->handlers.variable(i, &entry->variable, 64| 1.20k| entry->labelset[0] ? entry->labelset : NULL, user_ctx); ------------------ | Branch (64:13): [True: 111, False: 1.09k] ------------------ 65| 1.20k| if (cb_retval == READSTAT_HANDLER_SKIP_VARIABLE) { ------------------ | Branch (65:13): [True: 0, False: 1.20k] ------------------ 66| 0| entry->skip = 1; 67| 1.20k| } else if (cb_retval == READSTAT_HANDLER_ABORT) { ------------------ | Branch (67:20): [True: 0, False: 1.20k] ------------------ 68| 0| return READSTAT_ERROR_USER_ABORT; 69| 1.20k| } else { 70| 1.20k| partial_entry_count++; 71| 1.20k| } 72| 1.20k| } 73| 232| return READSTAT_OK; 74| 232|} readstat_copy: 5| 32.0k|void readstat_copy(char *buf, size_t buf_len, const char *str_start, size_t str_len) { 6| 32.0k| size_t this_len = str_len; 7| 32.0k| if (this_len >= buf_len) { ------------------ | Branch (7:9): [True: 4.17k, False: 27.8k] ------------------ 8| 4.17k| this_len = buf_len - 1; 9| 4.17k| } 10| 32.0k| memcpy(buf, str_start, this_len); 11| 32.0k| buf[this_len] = '\0'; 12| 32.0k|} readstat_copy_quoted: 21| 6.00k|void readstat_copy_quoted(char *buf, size_t buf_len, const char *str_start, size_t str_len) { 22| 6.00k| size_t this_len = str_len; 23| 6.00k| if (this_len >= buf_len) { ------------------ | Branch (23:9): [True: 319, False: 5.68k] ------------------ 24| 319| this_len = buf_len - 1; 25| 319| } 26| 6.00k| size_t i=0; 27| 6.00k| size_t j=0; 28| 6.00k| int slash = 0; 29| 59.4k| for (i=0; ientries); 10| 1.05k| free(schema); 11| 1.05k| } 12| 1.05k|} readstat_schema_find_or_create_entry: 14| 6.45k|readstat_schema_entry_t *readstat_schema_find_or_create_entry(readstat_schema_t *dct, const char *var_name) { 15| 6.45k| readstat_schema_entry_t *entry = NULL; 16| 6.45k| int i; 17| | /* linear search. this is shitty, but whatever */ 18| 43.0k| for (i=0; ientry_count; i++) { ------------------ | Branch (18:15): [True: 41.4k, False: 1.61k] ------------------ 19| 41.4k| if (strcmp(dct->entries[i].variable.name, var_name) == 0) { ------------------ | Branch (19:13): [True: 4.83k, False: 36.6k] ------------------ 20| 4.83k| entry = &dct->entries[i]; 21| 4.83k| break; 22| 4.83k| } 23| 41.4k| } 24| 6.45k| if (!entry) { ------------------ | Branch (24:9): [True: 1.61k, False: 4.83k] ------------------ 25| 1.61k| dct->entries = realloc(dct->entries, sizeof(readstat_schema_entry_t) * (dct->entry_count + 1)); 26| 1.61k| entry = &dct->entries[dct->entry_count]; 27| 1.61k| memset(entry, 0, sizeof(readstat_schema_entry_t)); 28| | 29| 1.61k| readstat_copy(entry->variable.name, sizeof(entry->variable.name), var_name, strlen(var_name)); 30| 1.61k| entry->decimal_separator = '.'; 31| 1.61k| entry->variable.index = dct->entry_count++; 32| 1.61k| } 33| 6.45k| return entry; 34| 6.45k|} readstat_parse_spss_commands: 1927| 1.05k|const char *filepath, void *user_ctx, readstat_error_t *outError) { 1928| 1.05k| if (parser->io->open(filepath, parser->io->io_ctx) == -1) { ------------------ | Branch (1928:6): [True: 0, False: 1.05k] ------------------ 1929| 0| if (outError) ------------------ | Branch (1929:7): [True: 0, False: 0] ------------------ 1930| 0| *outError = READSTAT_ERROR_OPEN; 1931| 0| return NULL; 1932| 0| } 1933| 1.05k| readstat_schema_t *schema = NULL; 1934| 1.05k| unsigned char *bytes = NULL; 1935| 1.05k| readstat_error_t error = READSTAT_OK; 1936| 1.05k| ssize_t len = parser->io->seek(0, READSTAT_SEEK_END, parser->io->io_ctx); 1937| 1.05k| if (len == -1) { ------------------ | Branch (1937:6): [True: 0, False: 1.05k] ------------------ 1938| 0| error = READSTAT_ERROR_SEEK; 1939| 0| goto cleanup; 1940| 0| } 1941| 1.05k| parser->io->seek(0, READSTAT_SEEK_SET, parser->io->io_ctx); 1942| | 1943| 1.05k| bytes = malloc(len); 1944| | 1945| 1.05k| parser->io->read(bytes, len, parser->io->io_ctx); 1946| | 1947| 1.05k| unsigned char *p = bytes; 1948| 1.05k| unsigned char *pe = bytes + len; 1949| | 1950| 1.05k| unsigned char *eof = pe; 1951| | 1952| 1.05k| unsigned char *str_start = NULL; 1953| | 1954| 1.05k| size_t str_len = 0; 1955| | 1956| 1.05k| int cs; 1957| | 1958| 1.05k| int i; 1959| 1.05k| int line_no = 0; 1960| 1.05k| uint64_t first_integer = 0, integer = 0; 1961| 1.05k| double double_value = NAN; 1962| 1.05k| unsigned char *line_start = p; 1963| | 1964| 1.05k| char varname[32]; 1965| 1.05k| char argname[32]; 1966| 1.05k| char string_value[32]; 1967| 1.05k| char buf[1024]; 1968| | 1969| 1.05k| char var_list[1024][32]; 1970| | 1971| 1.05k| long var_col = 0; 1972| 1.05k| long var_row = 0; 1973| 1.05k| long var_len = 0; 1974| 1.05k| long var_count = 0; 1975| 1.05k| readstat_type_t var_type = READSTAT_TYPE_DOUBLE; 1976| 1.05k| label_type_t label_type = LABEL_TYPE_DOUBLE; 1977| | 1978| 1.05k| int labelset_count = 0; 1979| | 1980| 1.05k| if ((schema = calloc(1, sizeof(readstat_schema_t))) == NULL) { ------------------ | Branch (1980:6): [True: 0, False: 1.05k] ------------------ 1981| 0| error = READSTAT_ERROR_MALLOC; 1982| 0| goto cleanup; 1983| 0| } 1984| | 1985| 1.05k| schema->rows_per_observation = 1; 1986| | 1987| | 1988| 1.05k|#line 1989 "src/txt/readstat_spss_commands_read.c" 1989| 1.05k| { 1990| 1.05k| cs = (int)spss_commands_start; 1991| 1.05k| } 1992| | 1993| 1.05k|#line 1994 "src/txt/readstat_spss_commands_read.c" 1994| 1.05k| { 1995| 1.05k| int _klen; 1996| 1.05k| unsigned int _trans = 0; 1997| 1.05k| const char * _keys; 1998| 1.05k| const signed char * _acts; 1999| 1.05k| unsigned int _nacts; 2000| 6.86M| _resume: {} 2001| 6.86M| if ( p == pe && p != eof ) ------------------ | Branch (2001:8): [True: 992, False: 6.86M] | Branch (2001:19): [True: 0, False: 992] ------------------ 2002| 0| goto _out; 2003| 6.86M| if ( p == eof ) { ------------------ | Branch (2003:8): [True: 992, False: 6.86M] ------------------ 2004| 992| if ( _spss_commands_eof_trans[cs] > 0 ) { ------------------ | Branch (2004:9): [True: 992, False: 0] ------------------ 2005| 992| _trans = (unsigned int)_spss_commands_eof_trans[cs] - 1; 2006| 992| } 2007| 992| } 2008| 6.86M| else { 2009| 6.86M| _keys = ( _spss_commands_trans_keys + (_spss_commands_key_offsets[cs])); 2010| 6.86M| _trans = (unsigned int)_spss_commands_index_offsets[cs]; 2011| | 2012| 6.86M| _klen = (int)_spss_commands_single_lengths[cs]; 2013| 6.86M| if ( _klen > 0 ) { ------------------ | Branch (2013:9): [True: 6.86M, False: 1.02k] ------------------ 2014| 6.86M| const char *_lower = _keys; 2015| 6.86M| const char *_upper = _keys + _klen - 1; 2016| 6.86M| const char *_mid; 2017| 20.9M| while ( 1 ) { ------------------ | Branch (2017:13): [True: 20.9M, Folded] ------------------ 2018| 20.9M| if ( _upper < _lower ) { ------------------ | Branch (2018:11): [True: 6.79M, False: 14.1M] ------------------ 2019| 6.79M| _keys += _klen; 2020| 6.79M| _trans += (unsigned int)_klen; 2021| 6.79M| break; 2022| 6.79M| } 2023| | 2024| 14.1M| _mid = _lower + ((_upper-_lower) >> 1); 2025| 14.1M| if ( ( (*( p))) < (*( _mid)) ) ------------------ | Branch (2025:11): [True: 2.95M, False: 11.2M] ------------------ 2026| 2.95M| _upper = _mid - 1; 2027| 11.2M| else if ( ( (*( p))) > (*( _mid)) ) ------------------ | Branch (2027:16): [True: 11.1M, False: 70.4k] ------------------ 2028| 11.1M| _lower = _mid + 1; 2029| 70.4k| else { 2030| 70.4k| _trans += (unsigned int)(_mid - _keys); 2031| 70.4k| goto _match; 2032| 70.4k| } 2033| 14.1M| } 2034| 6.86M| } 2035| | 2036| 6.79M| _klen = (int)_spss_commands_range_lengths[cs]; 2037| 6.79M| if ( _klen > 0 ) { ------------------ | Branch (2037:9): [True: 3.60M, False: 3.18M] ------------------ 2038| 3.60M| const char *_lower = _keys; 2039| 3.60M| const char *_upper = _keys + (_klen<<1) - 2; 2040| 3.60M| const char *_mid; 2041| 6.78M| while ( 1 ) { ------------------ | Branch (2041:13): [True: 6.78M, Folded] ------------------ 2042| 6.78M| if ( _upper < _lower ) { ------------------ | Branch (2042:11): [True: 35, False: 6.78M] ------------------ 2043| 35| _trans += (unsigned int)_klen; 2044| 35| break; 2045| 35| } 2046| | 2047| 6.78M| _mid = _lower + (((_upper-_lower) >> 1) & ~1); 2048| 6.78M| if ( ( (*( p))) < (*( _mid)) ) ------------------ | Branch (2048:11): [True: 940k, False: 5.84M] ------------------ 2049| 940k| _upper = _mid - 2; 2050| 5.84M| else if ( ( (*( p))) > (*( _mid + 1)) ) ------------------ | Branch (2050:16): [True: 2.23M, False: 3.60M] ------------------ 2051| 2.23M| _lower = _mid + 2; 2052| 3.60M| else { 2053| 3.60M| _trans += (unsigned int)((_mid - _keys)>>1); 2054| 3.60M| break; 2055| 3.60M| } 2056| 6.78M| } 2057| 3.60M| } 2058| | 2059| 6.86M| _match: {} 2060| 6.86M| } 2061| 6.86M| cs = (int)_spss_commands_cond_targs[_trans]; 2062| | 2063| 6.86M| if ( _spss_commands_cond_actions[_trans] != 0 ) { ------------------ | Branch (2063:8): [True: 88.0k, False: 6.77M] ------------------ 2064| | 2065| 88.0k| _acts = ( _spss_commands_actions + (_spss_commands_cond_actions[_trans])); 2066| 88.0k| _nacts = (unsigned int)(*( _acts)); 2067| 88.0k| _acts += 1; 2068| 273k| while ( _nacts > 0 ) { ------------------ | Branch (2068:12): [True: 185k, False: 88.0k] ------------------ 2069| 185k| switch ( (*( _acts)) ) ------------------ | Branch (2069:14): [True: 185k, False: 0] ------------------ 2070| 185k| { 2071| 6.51k| case 0: { ------------------ | Branch (2071:6): [True: 6.51k, False: 179k] ------------------ 2072| 6.51k| { 2073| 6.51k|#line 78 "src/txt/readstat_spss_commands_read.rl" 2074| | 2075| 6.51k| integer = 0; 2076| 6.51k| } 2077| | 2078| 6.51k|#line 2079 "src/txt/readstat_spss_commands_read.c" 2079| | 2080| 6.51k| break; 2081| 0| } 2082| 8.62k| case 1: { ------------------ | Branch (2082:6): [True: 8.62k, False: 177k] ------------------ 2083| 8.62k| { 2084| 8.62k|#line 82 "src/txt/readstat_spss_commands_read.rl" 2085| | 2086| 8.62k| integer = 10 * integer + ((( (*( p)))) - '0'); 2087| 8.62k| } 2088| | 2089| 8.62k|#line 2090 "src/txt/readstat_spss_commands_read.c" 2090| | 2091| 8.62k| break; 2092| 0| } 2093| 1.95k| case 2: { ------------------ | Branch (2093:6): [True: 1.95k, False: 183k] ------------------ 2094| 1.95k| { 2095| 1.95k|#line 86 "src/txt/readstat_spss_commands_read.rl" 2096| | 2097| 1.95k| var_col = integer - 1; 2098| 1.95k| var_len = 1; 2099| 1.95k| } 2100| | 2101| 1.95k|#line 2102 "src/txt/readstat_spss_commands_read.c" 2102| | 2103| 1.95k| break; 2104| 0| } 2105| 209| case 3: { ------------------ | Branch (2105:6): [True: 209, False: 185k] ------------------ 2106| 209| { 2107| 209|#line 91 "src/txt/readstat_spss_commands_read.rl" 2108| | 2109| 209| var_len = integer - var_col; 2110| 209| } 2111| | 2112| 209|#line 2113 "src/txt/readstat_spss_commands_read.c" 2113| | 2114| 209| break; 2115| 0| } 2116| 5.21k| case 4: { ------------------ | Branch (2116:6): [True: 5.21k, False: 180k] ------------------ 2117| 5.21k| { 2118| 5.21k|#line 95 "src/txt/readstat_spss_commands_read.rl" 2119| | 2120| 5.21k| readstat_copy_quoted(buf, sizeof(buf), (char *)str_start, str_len); 2121| 5.21k| } 2122| | 2123| 5.21k|#line 2124 "src/txt/readstat_spss_commands_read.c" 2124| | 2125| 5.21k| break; 2126| 0| } 2127| 783| case 5: { ------------------ | Branch (2127:6): [True: 783, False: 185k] ------------------ 2128| 783| { 2129| 783|#line 99 "src/txt/readstat_spss_commands_read.rl" 2130| | 2131| 783| readstat_copy_quoted(string_value, sizeof(string_value), (char *)str_start, str_len); 2132| 783| } 2133| | 2134| 783|#line 2135 "src/txt/readstat_spss_commands_read.c" 2135| | 2136| 783| break; 2137| 0| } 2138| 25.2k| case 6: { ------------------ | Branch (2138:6): [True: 25.2k, False: 160k] ------------------ 2139| 25.2k| { 2140| 25.2k|#line 107 "src/txt/readstat_spss_commands_read.rl" 2141| | 2142| 25.2k| readstat_copy(varname, sizeof(varname), (char *)str_start, str_len); 2143| 25.2k| } 2144| | 2145| 25.2k|#line 2146 "src/txt/readstat_spss_commands_read.c" 2146| | 2147| 25.2k| break; 2148| 0| } 2149| 1.03k| case 7: { ------------------ | Branch (2149:6): [True: 1.03k, False: 184k] ------------------ 2150| 1.03k| { 2151| 1.03k|#line 111 "src/txt/readstat_spss_commands_read.rl" 2152| | 2153| 1.03k| readstat_copy(argname, sizeof(argname), (char *)str_start, str_len); 2154| 1.03k| } 2155| | 2156| 1.03k|#line 2157 "src/txt/readstat_spss_commands_read.c" 2157| | 2158| 1.03k| break; 2159| 0| } 2160| 2.31k| case 8: { ------------------ | Branch (2160:6): [True: 2.31k, False: 183k] ------------------ 2161| 2.31k| { 2162| 2.31k|#line 115 "src/txt/readstat_spss_commands_read.rl" 2163| | 2164| 2.31k| readstat_schema_entry_t *entry = readstat_schema_find_or_create_entry(schema, varname); 2165| 2.31k| entry->variable.type = var_type; 2166| 2.31k| entry->variable.storage_width = var_len; 2167| 2.31k| entry->row = var_row; 2168| 2.31k| entry->col = var_col; 2169| 2.31k| entry->len = var_len; 2170| 2.31k| } 2171| | 2172| 2.31k|#line 2173 "src/txt/readstat_spss_commands_read.c" 2173| | 2174| 2.31k| break; 2175| 0| } 2176| 1.03k| case 9: { ------------------ | Branch (2176:6): [True: 1.03k, False: 184k] ------------------ 2177| 1.03k| { 2178| 1.03k|#line 124 "src/txt/readstat_spss_commands_read.rl" 2179| | 2180| 1.03k| readstat_schema_entry_t *entry = readstat_schema_find_or_create_entry(schema, varname); 2181| 1.03k| readstat_copy(entry->variable.label, sizeof(entry->variable.label), buf, sizeof(buf)); 2182| 1.03k| } 2183| | 2184| 1.03k|#line 2185 "src/txt/readstat_spss_commands_read.c" 2185| | 2186| 1.03k| break; 2187| 0| } 2188| 1.31k| case 10: { ------------------ | Branch (2188:6): [True: 1.31k, False: 184k] ------------------ 2189| 1.31k| { 2190| 1.31k|#line 129 "src/txt/readstat_spss_commands_read.rl" 2191| | 2192| 1.31k| var_count = 0; 2193| 1.31k| } 2194| | 2195| 1.31k|#line 2196 "src/txt/readstat_spss_commands_read.c" 2196| | 2197| 1.31k| break; 2198| 0| } 2199| 21.4k| case 11: { ------------------ | Branch (2199:6): [True: 21.4k, False: 164k] ------------------ 2200| 21.4k| { 2201| 21.4k|#line 133 "src/txt/readstat_spss_commands_read.rl" 2202| | 2203| 21.4k| if (var_count < sizeof(var_list)/sizeof(var_list[0])) { ------------------ | Branch (2203:12): [True: 21.2k, False: 194] ------------------ 2204| 21.2k| memcpy(var_list[var_count++], varname, sizeof(varname)); 2205| 21.2k| } 2206| 21.4k| } 2207| | 2208| 21.4k|#line 2209 "src/txt/readstat_spss_commands_read.c" 2209| | 2210| 21.4k| break; 2211| 0| } 2212| 997| case 12: { ------------------ | Branch (2212:6): [True: 997, False: 184k] ------------------ 2213| 997| { 2214| 997|#line 139 "src/txt/readstat_spss_commands_read.rl" 2215| | 2216| 997| if (strcasecmp(argname, "FIRSTCASE") == 0) { ------------------ | Branch (2216:12): [True: 195, False: 802] ------------------ 2217| 195| schema->first_line = integer; 2218| 195| } 2219| 997| if (strcasecmp(argname, "DELIMITERS") == 0) { ------------------ | Branch (2219:12): [True: 244, False: 753] ------------------ 2220| 244| schema->field_delimiter = buf[0]; 2221| 244| } 2222| 997| } 2223| | 2224| 997|#line 2225 "src/txt/readstat_spss_commands_read.c" 2225| | 2226| 997| break; 2227| 0| } 2228| 843| case 13: { ------------------ | Branch (2228:6): [True: 843, False: 185k] ------------------ 2229| 843| { 2230| 843|#line 148 "src/txt/readstat_spss_commands_read.rl" 2231| | 2232| 843| char labelset_name[256]; 2233| 843| snprintf(labelset_name, sizeof(labelset_name), "labels%d", labelset_count++); 2234| 3.95k| for (i=0; ilabelset, sizeof(entry->labelset), labelset_name, sizeof(labelset_name)); 2237| 3.10k| } 2238| 843| } 2239| | 2240| 843|#line 2241 "src/txt/readstat_spss_commands_read.c" 2241| | 2242| 843| break; 2243| 0| } 2244| 2.91k| case 14: { ------------------ | Branch (2244:6): [True: 2.91k, False: 182k] ------------------ 2245| 2.91k| { 2246| 2.91k|#line 157 "src/txt/readstat_spss_commands_read.rl" 2247| | 2248| 2.91k| char labelset_name[256]; 2249| 2.91k| snprintf(labelset_name, sizeof(labelset_name), "labels%d", labelset_count); 2250| 2.91k| error = submit_value_label(parser, labelset_name, label_type, 2251| 2.91k| first_integer, integer, double_value, string_value, buf, user_ctx); 2252| 2.91k| if (error != READSTAT_OK) ------------------ | Branch (2252:12): [True: 0, False: 2.91k] ------------------ 2253| 0| goto cleanup; 2254| 2.91k| } 2255| | 2256| 2.91k|#line 2257 "src/txt/readstat_spss_commands_read.c" 2257| | 2258| 2.91k| break; 2259| 2.91k| } 2260| 3.30k| case 15: { ------------------ | Branch (2260:6): [True: 3.30k, False: 182k] ------------------ 2261| 3.30k| { 2262| 3.30k|#line 166 "src/txt/readstat_spss_commands_read.rl" 2263| 3.30k| str_start = p; } 2264| | 2265| 3.30k|#line 2266 "src/txt/readstat_spss_commands_read.c" 2266| | 2267| 3.30k| break; 2268| 2.91k| } 2269| 3.30k| case 16: { ------------------ | Branch (2269:6): [True: 3.30k, False: 182k] ------------------ 2270| 3.30k| { 2271| 3.30k|#line 166 "src/txt/readstat_spss_commands_read.rl" 2272| 3.30k| str_len = p - str_start; } 2273| | 2274| 3.30k|#line 2275 "src/txt/readstat_spss_commands_read.c" 2275| | 2276| 3.30k| break; 2277| 2.91k| } 2278| 1.93k| case 17: { ------------------ | Branch (2278:6): [True: 1.93k, False: 183k] ------------------ 2279| 1.93k| { 2280| 1.93k|#line 168 "src/txt/readstat_spss_commands_read.rl" 2281| 1.93k| str_start = p; } 2282| | 2283| 1.93k|#line 2284 "src/txt/readstat_spss_commands_read.c" 2284| | 2285| 1.93k| break; 2286| 2.91k| } 2287| 1.93k| case 18: { ------------------ | Branch (2287:6): [True: 1.93k, False: 183k] ------------------ 2288| 1.93k| { 2289| 1.93k|#line 168 "src/txt/readstat_spss_commands_read.rl" 2290| 1.93k| str_len = p - str_start; } 2291| | 2292| 1.93k|#line 2293 "src/txt/readstat_spss_commands_read.c" 2293| | 2294| 1.93k| break; 2295| 2.91k| } 2296| 32.0k| case 19: { ------------------ | Branch (2296:6): [True: 32.0k, False: 153k] ------------------ 2297| 32.0k| { 2298| 32.0k|#line 172 "src/txt/readstat_spss_commands_read.rl" 2299| 32.0k| line_no++; line_start = p; } 2300| | 2301| 32.0k|#line 2302 "src/txt/readstat_spss_commands_read.c" 2302| | 2303| 32.0k| break; 2304| 2.91k| } 2305| 27.3k| case 20: { ------------------ | Branch (2305:6): [True: 27.3k, False: 158k] ------------------ 2306| 27.3k| { 2307| 27.3k|#line 174 "src/txt/readstat_spss_commands_read.rl" 2308| 27.3k| str_start = p; } 2309| | 2310| 27.3k|#line 2311 "src/txt/readstat_spss_commands_read.c" 2311| | 2312| 27.3k| break; 2313| 2.91k| } 2314| 27.5k| case 21: { ------------------ | Branch (2314:6): [True: 27.5k, False: 158k] ------------------ 2315| 27.5k| { 2316| 27.5k|#line 174 "src/txt/readstat_spss_commands_read.rl" 2317| 27.5k| str_len = p - str_start; } 2318| | 2319| 27.5k|#line 2320 "src/txt/readstat_spss_commands_read.c" 2320| | 2321| 27.5k| break; 2322| 2.91k| } 2323| 195| case 22: { ------------------ | Branch (2323:6): [True: 195, False: 185k] ------------------ 2324| 195| { 2325| 195|#line 192 "src/txt/readstat_spss_commands_read.rl" 2326| 195| var_type = READSTAT_TYPE_STRING; } 2327| | 2328| 195|#line 2329 "src/txt/readstat_spss_commands_read.c" 2329| | 2330| 195| break; 2331| 2.91k| } 2332| 206| case 23: { ------------------ | Branch (2332:6): [True: 206, False: 185k] ------------------ 2333| 206| { 2334| 206|#line 195 "src/txt/readstat_spss_commands_read.rl" 2335| 206| var_type = READSTAT_TYPE_STRING; } 2336| | 2337| 206|#line 2338 "src/txt/readstat_spss_commands_read.c" 2338| | 2339| 206| break; 2340| 2.91k| } 2341| 194| case 24: { ------------------ | Branch (2341:6): [True: 194, False: 185k] ------------------ 2342| 194| { 2343| 194|#line 196 "src/txt/readstat_spss_commands_read.rl" 2344| 194| var_type = READSTAT_TYPE_DOUBLE; } 2345| | 2346| 194|#line 2347 "src/txt/readstat_spss_commands_read.c" 2347| | 2348| 194| break; 2349| 2.91k| } 2350| 201| case 25: { ------------------ | Branch (2350:6): [True: 201, False: 185k] ------------------ 2351| 201| { 2352| 201|#line 197 "src/txt/readstat_spss_commands_read.rl" 2353| 201| var_type = READSTAT_TYPE_DOUBLE; } 2354| | 2355| 201|#line 2356 "src/txt/readstat_spss_commands_read.c" 2356| | 2357| 201| break; 2358| 2.91k| } 2359| 194| case 26: { ------------------ | Branch (2359:6): [True: 194, False: 185k] ------------------ 2360| 194| { 2361| 194|#line 198 "src/txt/readstat_spss_commands_read.rl" 2362| 194| var_type = READSTAT_TYPE_STRING; } 2363| | 2364| 194|#line 2365 "src/txt/readstat_spss_commands_read.c" 2365| | 2366| 194| break; 2367| 2.91k| } 2368| 303| case 27: { ------------------ | Branch (2368:6): [True: 303, False: 185k] ------------------ 2369| 303| { 2370| 303|#line 219 "src/txt/readstat_spss_commands_read.rl" 2371| 303| var_row = integer - 1; } 2372| | 2373| 303|#line 2374 "src/txt/readstat_spss_commands_read.c" 2374| | 2375| 303| break; 2376| 2.91k| } 2377| 530| case 28: { ------------------ | Branch (2377:6): [True: 530, False: 185k] ------------------ 2378| 530| { 2379| 530|#line 220 "src/txt/readstat_spss_commands_read.rl" 2380| 530| var_type = READSTAT_TYPE_DOUBLE; } 2381| | 2382| 530|#line 2383 "src/txt/readstat_spss_commands_read.c" 2383| | 2384| 530| break; 2385| 2.91k| } 2386| 1.42k| case 29: { ------------------ | Branch (2386:6): [True: 1.42k, False: 184k] ------------------ 2387| 1.42k| { 2388| 1.42k|#line 221 "src/txt/readstat_spss_commands_read.rl" 2389| 1.42k| var_type = READSTAT_TYPE_DOUBLE; } 2390| | 2391| 1.42k|#line 2392 "src/txt/readstat_spss_commands_read.c" 2392| | 2393| 1.42k| break; 2394| 2.91k| } 2395| 807| case 30: { ------------------ | Branch (2395:6): [True: 807, False: 185k] ------------------ 2396| 807| { 2397| 807|#line 254 "src/txt/readstat_spss_commands_read.rl" 2398| 807| label_type = -1; } 2399| | 2400| 807|#line 2401 "src/txt/readstat_spss_commands_read.c" 2401| | 2402| 807| break; 2403| 2.91k| } 2404| 242| case 31: { ------------------ | Branch (2404:6): [True: 242, False: 185k] ------------------ 2405| 242| { 2406| 242|#line 260 "src/txt/readstat_spss_commands_read.rl" 2407| 242| label_type = LABEL_TYPE_DOUBLE; double_value = -(double)integer; } 2408| | 2409| 242|#line 2410 "src/txt/readstat_spss_commands_read.c" 2410| | 2411| 242| break; 2412| 2.91k| } 2413| 1.17k| case 32: { ------------------ | Branch (2413:6): [True: 1.17k, False: 184k] ------------------ 2414| 1.17k| { 2415| 1.17k|#line 261 "src/txt/readstat_spss_commands_read.rl" 2416| 1.17k| label_type = LABEL_TYPE_DOUBLE; double_value = integer; } 2417| | 2418| 1.17k|#line 2419 "src/txt/readstat_spss_commands_read.c" 2419| | 2420| 1.17k| break; 2421| 2.91k| } 2422| 871| case 33: { ------------------ | Branch (2422:6): [True: 871, False: 185k] ------------------ 2423| 871| { 2424| 871|#line 262 "src/txt/readstat_spss_commands_read.rl" 2425| 871| first_integer = integer; } 2426| | 2427| 871|#line 2428 "src/txt/readstat_spss_commands_read.c" 2428| | 2429| 871| break; 2430| 2.91k| } 2431| 867| case 34: { ------------------ | Branch (2431:6): [True: 867, False: 185k] ------------------ 2432| 867| { 2433| 867|#line 262 "src/txt/readstat_spss_commands_read.rl" 2434| 867| label_type = LABEL_TYPE_RANGE; } 2435| | 2436| 867|#line 2437 "src/txt/readstat_spss_commands_read.c" 2437| | 2438| 867| break; 2439| 2.91k| } 2440| 783| case 35: { ------------------ | Branch (2440:6): [True: 783, False: 185k] ------------------ 2441| 783| { 2442| 783|#line 263 "src/txt/readstat_spss_commands_read.rl" 2443| 783| label_type = LABEL_TYPE_STRING; } 2444| | 2445| 783|#line 2446 "src/txt/readstat_spss_commands_read.c" 2446| | 2447| 783| break; 2448| 2.91k| } 2449| 185k| } 2450| 185k| _nacts -= 1; 2451| 185k| _acts += 1; 2452| 185k| } 2453| | 2454| 88.0k| } 2455| | 2456| 6.86M| if ( p == eof ) { ------------------ | Branch (2456:8): [True: 992, False: 6.86M] ------------------ 2457| 992| if ( cs >= 646 ) ------------------ | Branch (2457:9): [True: 232, False: 760] ------------------ 2458| 232| goto _out; 2459| 992| } 2460| 6.86M| else { 2461| 6.86M| if ( cs != 0 ) { ------------------ | Branch (2461:9): [True: 6.86M, False: 63] ------------------ 2462| 6.86M| p += 1; 2463| 6.86M| goto _resume; 2464| 6.86M| } 2465| 6.86M| } 2466| 1.05k| _out: {} 2467| 1.05k| } 2468| | 2469| 0|#line 313 "src/txt/readstat_spss_commands_read.rl" 2470| | 2471| | 2472| | /* suppress warnings */ 2473| 0| (void)spss_commands_en_main; 2474| | 2475| 1.05k| if (cs < ------------------ | Branch (2475:6): [True: 823, False: 232] ------------------ 2476| 1.05k|#line 2477 "src/txt/readstat_spss_commands_read.c" 2477| 1.05k| 646 2478| 1.05k|#line 318 "src/txt/readstat_spss_commands_read.rl" 2479| 1.05k| ) { 2480| 823| char error_buf[1024]; 2481| 823| if (p == pe) { ------------------ | Branch (2481:7): [True: 760, False: 63] ------------------ 2482| 760| snprintf(error_buf, sizeof(error_buf), "Error parsing SPSS command file (end-of-file unexpectedly reached)"); 2483| 760| } else { 2484| 63| snprintf(error_buf, sizeof(error_buf), "Error parsing SPSS command file around line #%d, col #%ld (%c)", 2485| 63| line_no + 1, (long)(p - line_start + 1), *p); 2486| 63| } 2487| 823| if (parser->handlers.error) { ------------------ | Branch (2487:7): [True: 0, False: 823] ------------------ 2488| 0| parser->handlers.error(error_buf, user_ctx); 2489| 0| } 2490| 823| error = READSTAT_ERROR_PARSE; 2491| 823| goto cleanup; 2492| 823| } 2493| | 2494| 232| error = submit_columns(parser, schema, user_ctx); 2495| | 2496| 1.05k| cleanup: 2497| 1.05k| parser->io->close(parser->io->io_ctx); 2498| 1.05k| free(bytes); 2499| 1.05k| if (error != READSTAT_OK) { ------------------ | Branch (2499:6): [True: 823, False: 232] ------------------ 2500| 823| if (outError) ------------------ | Branch (2500:7): [True: 0, False: 823] ------------------ 2501| 0| *outError = error; 2502| 823| readstat_schema_free(schema); 2503| 823| schema = NULL; 2504| 823| } 2505| | 2506| 1.05k| return schema; 2507| 232|}