| /* |
| * Copyright (C) 2003, 2004, 2005, 2015 Filip Pizlo. All rights reserved. |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY FILIP PIZLO ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL FILIP PIZLO OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "tsf_internal.h" |
| #include "tsf_format.h" |
| |
| #include <string.h> |
| |
| tsf_type_table_t *tsf_type_table_create() { |
| tsf_type_table_t *ret = malloc(sizeof(tsf_type_table_t)); |
| if (ret == NULL) { |
| tsf_set_errno("Could not malloc tsf_type_table_t"); |
| return NULL; |
| } |
| |
| ret->elements = NULL; |
| ret->num_elements = 0; |
| ret->ele_table = tsf_st_init_strtable(); |
| if (ret->ele_table == NULL) { |
| tsf_set_errno("Could not tsf_st_init_strtable()"); |
| free(ret); |
| return NULL; |
| } |
| |
| return ret; |
| } |
| |
| tsf_bool_t tsf_type_table_copy(tsf_type_table_t *dest, |
| tsf_type_table_t *src) { |
| uint32_t i; |
| |
| for (i = 0; i < tsf_type_table_get_num_elements(src); ++i) { |
| tsf_named_type_t *n = tsf_type_table_find_by_index(src, i), *n2; |
| tsf_type_t *new_type = tsf_type_dup(n->type); |
| if (new_type == NULL) { |
| return tsf_false; |
| } |
| if (!tsf_type_table_append(dest, n->name, new_type)) { |
| return tsf_false; |
| } |
| |
| /* copy the optional attribute, offset info manually */ |
| n2 = tsf_type_table_find_by_index(dest, |
| tsf_type_table_get_num_elements(dest) - 1); |
| n2->optional = n->optional; |
| if (n->has_offset) { |
| n2->has_offset = tsf_true; |
| n2->offset = n->offset; |
| } |
| |
| /* copy the comment manually */ |
| if (n->comment != NULL) { |
| n2->comment = strdup(n->comment); |
| if (n2->comment == NULL) { |
| tsf_set_errno("Could not allocate comment"); |
| return tsf_false; |
| } |
| } |
| } |
| |
| return tsf_true; |
| } |
| |
| void tsf_type_table_destroy(tsf_type_table_t *tt) { |
| uint32_t i; |
| for (i = 0; i < tt->num_elements; ++i) { |
| tsf_named_type_destroy(tt->elements[i]); |
| } |
| if (tt->elements != NULL) { |
| free(tt->elements); |
| } |
| tsf_st_free_table(tt->ele_table); |
| free(tt); |
| } |
| |
| tsf_type_table_t *tsf_type_table_read(const char *name, |
| tsf_reader_t reader, |
| void *arg, |
| tsf_limits_t *limits, |
| uint32_t size_limit, |
| uint32_t depth) { |
| tsf_type_table_t *ret = tsf_type_table_create(); |
| uint32_t i, num; |
| |
| if (ret == NULL) { |
| return NULL; |
| } |
| |
| if (!reader(arg, &num, sizeof(num))) { |
| tsf_type_table_destroy(ret); |
| return NULL; |
| } |
| |
| num = ntohl(num); |
| |
| if (num > size_limit) { |
| tsf_set_error(TSF_E_PARSE_ERROR, |
| "%s size exceeds limit while parsing", name); |
| tsf_type_table_destroy(ret); |
| return NULL; |
| } |
| |
| for (i = 0; i < num; ++i) { |
| uint8_t ui8_tmp; |
| char *str; |
| |
| /* parse the string */ |
| str = tsf_read_string(reader, arg, TSF_STR_SIZE); |
| if (str == NULL) { |
| tsf_type_table_destroy(ret); |
| return NULL; |
| } |
| |
| /* now do other things */ |
| if (!tsf_type_table_append(ret, |
| str, |
| tsf_type_read_rec(reader, |
| arg, |
| limits, |
| depth))) { |
| tsf_type_table_destroy(ret); |
| free(str); |
| return NULL; |
| } |
| |
| free(str); |
| |
| if (!reader(arg, &ui8_tmp, 1)) { |
| tsf_type_table_destroy(ret); |
| return NULL; |
| } |
| |
| if (ui8_tmp & ~3) { |
| tsf_set_error(TSF_E_PARSE_ERROR, |
| "Flags field contains bits I don't recognize: " fui8, |
| ui8_tmp); |
| tsf_type_table_destroy(ret); |
| return NULL; |
| } |
| |
| ret->elements[ret->num_elements - 1]->optional = |
| (ui8_tmp & 2 ? tsf_true : tsf_false); |
| |
| if (ui8_tmp & 1) { |
| /* parse a comment string. it can be arbitrarily long, so |
| this parsing code is somewhat of a pain in the ass to |
| write. */ |
| |
| if (!tsf_limits_allow_comments(limits)) { |
| tsf_set_error(TSF_E_PARSE_ERROR, |
| "Encountered a commented type while parsing, " |
| "but comments are not allowed"); |
| tsf_type_table_destroy(ret); |
| return NULL; |
| } |
| |
| str = tsf_read_string(reader, arg, TSF_MAX_COMMENT_SIZE); |
| if (str == NULL) { |
| tsf_type_table_destroy(ret); |
| return NULL; |
| } |
| |
| ret->elements[ret->num_elements - 1]->comment = str; |
| } |
| } |
| |
| return ret; |
| } |
| |
| tsf_bool_t tsf_type_table_write(tsf_type_table_t *tt, |
| tsf_writer_t writer, |
| void *arg) { |
| uint32_t ui32_tmp = htonl(tt->num_elements); |
| uint8_t ui8_tmp; |
| uint32_t i; |
| if (!writer(arg, &ui32_tmp, sizeof(ui32_tmp))) { |
| return tsf_false; |
| } |
| |
| for (i = 0; i < tt->num_elements; ++i) { |
| tsf_named_type_t *n = tt->elements[i]; |
| |
| if (!tsf_write_string(writer, arg, tsf_named_type_get_name(n))) { |
| return tsf_false; |
| } |
| |
| if (!tsf_type_write(tsf_named_type_get_type(n), |
| writer, arg)) { |
| return tsf_false; |
| } |
| |
| ui8_tmp = 0; |
| if (n->comment != NULL) { |
| ui8_tmp |= 1; |
| } |
| if (n->optional) { |
| ui8_tmp |= 2; |
| } |
| if (!writer(arg, &ui8_tmp, 1)) { |
| return tsf_false; |
| } |
| |
| if (n->comment != NULL) { |
| if (!tsf_write_string(writer, arg, n->comment)) { |
| return tsf_false; |
| } |
| } |
| } |
| |
| return tsf_true; |
| } |
| |
| int tsf_type_table_get_hash(tsf_type_table_t *tt) { |
| int ret = 0; |
| uint32_t i; |
| for (i = 0; i < tt->num_elements; ++i) { |
| ret += tsf_named_type_get_hash(tt->elements[i]); |
| } |
| return ret; |
| } |
| |
| tsf_bool_t tsf_type_table_contains_dynamic(tsf_type_table_t *tt) { |
| uint32_t i; |
| for (i = 0; i < tt->num_elements; ++i) { |
| if (tsf_type_is_dynamic(tt->elements[i]->type)) { |
| return tsf_true; |
| } |
| } |
| return tsf_false; |
| } |
| |
| tsf_bool_t tsf_type_table_compare(tsf_type_table_t *a, |
| tsf_type_table_t *b) { |
| uint32_t i; |
| |
| if (a->num_elements != b->num_elements) { |
| return tsf_false; |
| } |
| |
| for (i = 0; i < a->num_elements; ++i) { |
| if (strcmp(a->elements[i]->name, |
| b->elements[i]->name)) { |
| return tsf_false; |
| } |
| |
| if (a->elements[i]->optional |
| != b->elements[i]->optional) { |
| return tsf_false; |
| } |
| |
| if (!tsf_type_compare(a->elements[i]->type, |
| b->elements[i]->type)) { |
| return tsf_false; |
| } |
| } |
| |
| return tsf_true; |
| } |
| |
| tsf_bool_t tsf_type_table_append(tsf_type_table_t *tt, |
| const char *name, |
| tsf_type_t *ele_type) { |
| tsf_named_type_t *n; |
| |
| if (ele_type == NULL) { |
| return tsf_false; |
| } |
| |
| if (tsf_st_lookup(tt->ele_table, (char*)name, NULL)) { |
| tsf_set_error(TSF_E_NAME_COLLISION, |
| "Name '%s' is already used by another element", |
| name); |
| tsf_type_destroy(ele_type); |
| return tsf_false; |
| } |
| |
| if (tt->elements == NULL) { |
| tt->elements = malloc(sizeof(tsf_named_type_t*)); |
| if (tt->elements == NULL) { |
| tsf_set_errno("Could not malloc tsf_named_type_t*"); |
| tsf_type_destroy(ele_type); |
| return tsf_false; |
| } |
| } else { |
| tsf_named_type_t **new_array = realloc(tt->elements, |
| sizeof(tsf_named_type_t*) * |
| (tt->num_elements + 1)); |
| if (new_array==NULL) { |
| tsf_set_errno("Could not really array of tsf_named_type_t*"); |
| tsf_type_destroy(ele_type); |
| return tsf_false; |
| } |
| tt->elements = new_array; |
| } |
| |
| n = tsf_named_type_create(name, |
| ele_type, |
| tt->num_elements); |
| if (n == NULL) { |
| return tsf_false; |
| } |
| |
| if (tsf_st_insert(tt->ele_table, n->name, n) < 0) { |
| tsf_set_errno("Failed to tsf_st_insert()"); |
| tsf_type_destroy(ele_type); |
| free(n); |
| return tsf_false; |
| } |
| |
| tt->elements[tt->num_elements++] = n; |
| |
| return tsf_true; |
| } |
| |
| tsf_bool_t tsf_type_table_remove(tsf_type_table_t *tt, |
| const char *name) { |
| char *to_delete; |
| void *old_value; |
| tsf_named_type_t *n; |
| |
| to_delete = (char*)name; |
| old_value = NULL; |
| tsf_st_delete(tt->ele_table, &to_delete, &old_value); |
| if (old_value == NULL) { |
| tsf_set_error(TSF_E_ELE_NOT_FOUND, "Could not find \'%s\'", name); |
| return tsf_false; |
| } |
| |
| n = (tsf_named_type_t*)old_value; |
| tt->elements[n->index] = tt->elements[--tt->num_elements]; |
| tsf_named_type_destroy(n); |
| return tsf_true; |
| } |
| |
| tsf_named_type_t *tsf_type_table_find_by_name(tsf_type_table_t *tt, |
| const char *name) { |
| tsf_named_type_t *n; |
| if (!tsf_st_lookup(tt->ele_table, (char*)name, (void**)&n)) { |
| tsf_set_error(TSF_E_ELE_NOT_FOUND, "Could not find \'%s\'", name); |
| return tsf_false; |
| } |
| |
| return n; |
| } |
| |
| tsf_named_type_t *tsf_type_table_find_by_index(tsf_type_table_t *tt, |
| uint32_t index) { |
| return tt->elements[index]; |
| } |
| |
| uint32_t tsf_type_table_get_num_elements(tsf_type_table_t *tt) { |
| return tt->num_elements; |
| } |
| |
| |
