diff --git a/lang/c/src/datum.c b/lang/c/src/datum.c index 53dfa5ca067..5307c7a8385 100644 --- a/lang/c/src/datum.c +++ b/lang/c/src/datum.c @@ -1095,7 +1095,7 @@ static void avro_datum_free(avro_datum_t datum) record = avro_datum_to_record(datum); avro_schema_decref(record->schema); st_foreach(record->fields_byname, - HASH_FUNCTION_CAST char_datum_free_foreach, 0); + (hash_function_foreach) char_datum_free_foreach, 0); st_free_table(record->field_order); st_free_table(record->fields_byname); avro_freet(struct avro_record_datum_t, record); @@ -1123,7 +1123,7 @@ static void avro_datum_free(avro_datum_t datum) struct avro_map_datum_t *map; map = avro_datum_to_map(datum); avro_schema_decref(map->schema); - st_foreach(map->map, HASH_FUNCTION_CAST char_datum_free_foreach, + st_foreach(map->map, (hash_function_foreach) char_datum_free_foreach, 0); st_free_table(map->map); st_free_table(map->indices_by_key); @@ -1135,7 +1135,7 @@ static void avro_datum_free(avro_datum_t datum) struct avro_array_datum_t *array; array = avro_datum_to_array(datum); avro_schema_decref(array->schema); - st_foreach(array->els, HASH_FUNCTION_CAST array_free_foreach, 0); + st_foreach(array->els, (hash_function_foreach) array_free_foreach, 0); st_free_table(array->els); avro_freet(struct avro_array_datum_t, array); } @@ -1183,7 +1183,7 @@ avro_datum_reset(avro_datum_t datum) { struct avro_array_datum_t *array; array = avro_datum_to_array(datum); - st_foreach(array->els, HASH_FUNCTION_CAST array_free_foreach, 0); + st_foreach(array->els, (hash_function_foreach) array_free_foreach, 0); st_free_table(array->els); rval = avro_init_array(array); @@ -1198,7 +1198,7 @@ avro_datum_reset(avro_datum_t datum) { struct avro_map_datum_t *map; map = avro_datum_to_map(datum); - st_foreach(map->map, HASH_FUNCTION_CAST char_datum_free_foreach, 0); + st_foreach(map->map, (hash_function_foreach) char_datum_free_foreach, 0); st_free_table(map->map); st_free_table(map->indices_by_key); st_free_table(map->keys_by_index); @@ -1217,7 +1217,7 @@ avro_datum_reset(avro_datum_t datum) record = avro_datum_to_record(datum); rval = 0; st_foreach(record->fields_byname, - HASH_FUNCTION_CAST datum_reset_foreach, (st_data_t) &rval); + (hash_function_foreach) datum_reset_foreach, (st_data_t) &rval); return rval; } diff --git a/lang/c/src/datum_equal.c b/lang/c/src/datum_equal.c index 3875bea048d..7e7c9b94099 100644 --- a/lang/c/src/datum_equal.c +++ b/lang/c/src/datum_equal.c @@ -78,7 +78,7 @@ static int map_equal(struct avro_map_datum_t *a, struct avro_map_datum_t *b) if (a->map->num_entries != b->map->num_entries) { return 0; } - st_foreach(a->map, HASH_FUNCTION_CAST st_equal_foreach, (st_data_t) & args); + st_foreach(a->map, (hash_function_foreach) st_equal_foreach, (st_data_t) & args); return args.rval; } @@ -93,7 +93,7 @@ static int record_equal(struct avro_record_datum_t *a, if (a->fields_byname->num_entries != b->fields_byname->num_entries) { return 0; } - st_foreach(a->fields_byname, HASH_FUNCTION_CAST st_equal_foreach, (st_data_t) & args); + st_foreach(a->fields_byname, (hash_function_foreach) st_equal_foreach, (st_data_t) & args); return args.rval; } diff --git a/lang/c/src/datum_size.c b/lang/c/src/datum_size.c index be9b98004ef..3877f31384c 100644 --- a/lang/c/src/datum_size.c +++ b/lang/c/src/datum_size.c @@ -126,7 +126,7 @@ size_map(avro_writer_t writer, const avro_encoding_t * enc, if (datum->map->num_entries) { size_accum(rval, size, enc->size_long(writer, datum->map->num_entries)); - st_foreach(datum->map, HASH_FUNCTION_CAST size_map_foreach, (st_data_t) & args); + st_foreach(datum->map, (hash_function_foreach) size_map_foreach, (st_data_t) & args); size += args.size; } if (!args.rval) { diff --git a/lang/c/src/datum_validate.c b/lang/c/src/datum_validate.c index 6167bd63ff6..e997d306761 100644 --- a/lang/c/src/datum_validate.c +++ b/lang/c/src/datum_validate.c @@ -123,7 +123,7 @@ avro_schema_datum_validate(avro_schema_t expected_schema, avro_datum_t datum) { avro_schema_to_map(expected_schema)->values, 1 }; st_foreach(avro_datum_to_map(datum)->map, - HASH_FUNCTION_CAST schema_map_validate_foreach, + (hash_function_foreach) schema_map_validate_foreach, (st_data_t) & vst); return vst.rval; } diff --git a/lang/c/src/memoize.c b/lang/c/src/memoize.c index 933fecbd043..e3602884d0d 100644 --- a/lang/c/src/memoize.c +++ b/lang/c/src/memoize.c @@ -52,8 +52,8 @@ avro_memoize_key_hash(avro_memoize_key_t *a) static struct st_hash_type avro_memoize_hash_type = { - HASH_FUNCTION_CAST avro_memoize_key_cmp, - HASH_FUNCTION_CAST avro_memoize_key_hash + (hash_function_compare) avro_memoize_key_cmp, + (hash_function_hash) avro_memoize_key_hash }; @@ -78,7 +78,7 @@ avro_memoize_free_key(avro_memoize_key_t *key, void *result, void *dummy) void avro_memoize_done(avro_memoize_t *mem) { - st_foreach((st_table *) mem->cache, HASH_FUNCTION_CAST avro_memoize_free_key, 0); + st_foreach((st_table *) mem->cache, (hash_function_foreach) avro_memoize_free_key, 0); st_free_table((st_table *) mem->cache); memset(mem, 0, sizeof(avro_memoize_t)); } diff --git a/lang/c/src/schema.c b/lang/c/src/schema.c index 2acad51a13c..a4d8e9f898a 100644 --- a/lang/c/src/schema.c +++ b/lang/c/src/schema.c @@ -137,7 +137,7 @@ static void avro_schema_free(avro_schema_t schema) if (record->space) { avro_str_free(record->space); } - st_foreach(record->fields, HASH_FUNCTION_CAST record_free_foreach, + st_foreach(record->fields, (hash_function_foreach) record_free_foreach, 0); st_free_table(record->fields_byname); st_free_table(record->fields); @@ -152,7 +152,7 @@ static void avro_schema_free(avro_schema_t schema) if (enump->space) { avro_str_free(enump->space); } - st_foreach(enump->symbols, HASH_FUNCTION_CAST enum_free_foreach, + st_foreach(enump->symbols, (hash_function_foreach) enum_free_foreach, 0); st_free_table(enump->symbols); st_free_table(enump->symbols_byname); @@ -189,7 +189,7 @@ static void avro_schema_free(avro_schema_t schema) case AVRO_UNION:{ struct avro_union_schema_t *unionp; unionp = avro_schema_to_union(schema); - st_foreach(unionp->branches, HASH_FUNCTION_CAST union_free_foreach, + st_foreach(unionp->branches, (hash_function_foreach) union_free_foreach, 0); st_free_table(unionp->branches); st_free_table(unionp->branches_byname); @@ -1239,7 +1239,7 @@ avro_schema_from_json_root(json_t *root, avro_schema_t *schema) /* json_dumpf(root, stderr, 0); */ rval = avro_schema_from_json_t(root, schema, named_schemas, NULL); json_decref(root); - st_foreach(named_schemas, HASH_FUNCTION_CAST named_schema_free_foreach, 0); + st_foreach(named_schemas, (hash_function_foreach) named_schema_free_foreach, 0); st_free_table(named_schemas); return rval; } @@ -1455,7 +1455,7 @@ avro_schema_t avro_schema_copy(avro_schema_t schema) } new_schema = avro_schema_copy_root(schema, named_schemas); - st_foreach(named_schemas, HASH_FUNCTION_CAST named_schema_free_foreach, 0); + st_foreach(named_schemas, (hash_function_foreach) named_schema_free_foreach, 0); st_free_table(named_schemas); return new_schema; } diff --git a/lang/c/src/st.c b/lang/c/src/st.c index 27578289ecb..8437777cb92 100644 --- a/lang/c/src/st.c +++ b/lang/c/src/st.c @@ -39,8 +39,8 @@ struct st_table_entry { static int numcmp(long, long); static int numhash(long); static struct st_hash_type type_numhash = { - HASH_FUNCTION_CAST numcmp, - HASH_FUNCTION_CAST numhash + (hash_function_compare) numcmp, + (hash_function_hash) numhash }; /* @@ -48,8 +48,8 @@ static struct st_hash_type type_numhash = { */ static int strhash(const char *); static struct st_hash_type type_strhash = { - HASH_FUNCTION_CAST strcmp, - HASH_FUNCTION_CAST strhash + (hash_function_compare) strcmp, + (hash_function_hash) strhash }; static void rehash(st_table *); @@ -212,7 +212,7 @@ void st_free_table(st_table *table) } #define PTR_NOT_EQUAL(table, ptr, hash_val, key) \ -((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (key), (ptr)->key))) +((ptr) != 0 && (ptr->hash != (hash_val) || !EQUAL((table), (void*) (key), (void*) (ptr)->key))) #ifdef HASH_LOG #define COLLISION collision++ @@ -237,7 +237,7 @@ int st_lookup(st_table *table, register st_data_t key, st_data_t *value) unsigned int hash_val, bin_pos; register st_table_entry *ptr; - hash_val = do_hash(key, table); + hash_val = do_hash((void*) key, table); FIND_ENTRY(table, ptr, hash_val, bin_pos); if (ptr == 0) { @@ -272,7 +272,7 @@ int st_insert(register st_table *table, register st_data_t key, st_data_t value) unsigned int hash_val, bin_pos; register st_table_entry *ptr; - hash_val = do_hash(key, table); + hash_val = do_hash((void*) key, table); FIND_ENTRY(table, ptr, hash_val, bin_pos); if (ptr == 0) { @@ -288,7 +288,7 @@ void st_add_direct(st_table *table,st_data_t key,st_data_t value) { unsigned int hash_val, bin_pos; - hash_val = do_hash(key, table); + hash_val = do_hash((void*) key, table); bin_pos = hash_val % table->num_bins; ADD_DIRECT(table, key, value, hash_val, bin_pos); } @@ -363,7 +363,7 @@ int st_delete(register st_table *table,register st_data_t *key,st_data_t *value) st_table_entry *tmp; register st_table_entry *ptr; - hash_val = do_hash_bin(*key, table); + hash_val = do_hash_bin((void*) *key, table); ptr = table->bins[hash_val]; if (ptr == 0) { @@ -372,7 +372,7 @@ int st_delete(register st_table *table,register st_data_t *key,st_data_t *value) return 0; } - if (EQUAL(table, *key, ptr->key)) { + if (EQUAL(table, (void*) *key, (void*) ptr->key)) { table->bins[hash_val] = ptr->next; table->num_entries--; if (value != 0) @@ -383,7 +383,7 @@ int st_delete(register st_table *table,register st_data_t *key,st_data_t *value) } for (; ptr->next != 0; ptr = ptr->next) { - if (EQUAL(table, ptr->next->key, *key)) { + if (EQUAL(table, (void*) ptr->next->key, (void*) *key)) { tmp = ptr->next; ptr->next = ptr->next->next; table->num_entries--; @@ -403,7 +403,7 @@ int st_delete_safe(register st_table *table,register st_data_t *key,st_data_t *v unsigned int hash_val; register st_table_entry *ptr; - hash_val = do_hash_bin(*key, table); + hash_val = do_hash_bin((void*) *key, table); ptr = table->bins[hash_val]; if (ptr == 0) { @@ -413,7 +413,7 @@ int st_delete_safe(register st_table *table,register st_data_t *key,st_data_t *v } for (; ptr != 0; ptr = ptr->next) { - if ((ptr->key != never) && EQUAL(table, ptr->key, *key)) { + if ((ptr->key != never) && EQUAL(table, (void*) ptr->key, (void*) *key)) { table->num_entries--; *key = ptr->key; if (value != 0) @@ -439,11 +439,11 @@ void st_cleanup_safe(st_table *table,st_data_t never) { int num_entries = table->num_entries; - st_foreach(table, HASH_FUNCTION_CAST delete_never, never); + st_foreach(table, (hash_function_foreach) delete_never, never); table->num_entries = num_entries; } -int st_foreach(st_table *table,int (*func) (ANYARGS),st_data_t arg) +int st_foreach(st_table *table,int (*func) (void*, void*, void*),st_data_t arg) { st_table_entry *ptr, *last, *tmp; enum st_retval retval; @@ -452,7 +452,9 @@ int st_foreach(st_table *table,int (*func) (ANYARGS),st_data_t arg) for (i = 0; i < table->num_bins; i++) { last = 0; for (ptr = table->bins[i]; ptr != 0;) { - retval = (enum st_retval) (*func) (ptr->key, ptr->record, arg); + retval = (enum st_retval) (*func) ((void*) ptr->key, + (void*) ptr->record, + (void*) arg); switch (retval) { case ST_CHECK: /* check if hash is modified during * iteration */ diff --git a/lang/c/src/st.h b/lang/c/src/st.h index cf8a2249169..93da018bd9b 100644 --- a/lang/c/src/st.h +++ b/lang/c/src/st.h @@ -20,26 +20,22 @@ extern "C" { #pragma GCC visibility push(hidden) -#ifndef ANYARGS - #ifdef __cplusplus - #define ANYARGS ... - #else - #define ANYARGS - #endif -#endif - #ifdef _WIN32 - #define HASH_FUNCTION_CAST (int (__cdecl *)(ANYARGS)) + typedef int (__cdecl *hash_function_compare)(void*, void*); + typedef int (__cdecl *hash_function_hash)(void*); + typedef int (__cdecl *hash_function_foreach)(void*, void*, void*); #else - #define HASH_FUNCTION_CAST + typedef int (*hash_function_compare)(void*, void*); + typedef int (*hash_function_hash)(void*); + typedef int (*hash_function_foreach)(void*, void*, void*); #endif typedef uintptr_t st_data_t; typedef struct st_table st_table; struct st_hash_type { - int (*compare) (ANYARGS); - int (*hash) (ANYARGS); + hash_function_compare compare; + hash_function_hash hash; }; struct st_table { @@ -67,7 +63,7 @@ int st_delete _((st_table *, st_data_t *, st_data_t *)); int st_delete_safe _((st_table *, st_data_t *, st_data_t *, st_data_t)); int st_insert _((st_table *, st_data_t, st_data_t)); int st_lookup _((st_table *, st_data_t, st_data_t *)); -int st_foreach _((st_table *, int (*)(ANYARGS), st_data_t)); +int st_foreach _((st_table *, hash_function_foreach, st_data_t)); void st_add_direct _((st_table *, st_data_t, st_data_t)); void st_free_table _((st_table *)); void st_cleanup_safe _((st_table *, st_data_t));