AVRO-3960: [C] Fix st ANYARGS warning (#2798)

This removes the following warning:

  avro/lang/c/src/st.c:240:13: warning: passing arguments to a function without a prototype is deprecated in all versions of C and is not
        supported in C2x [-Wdeprecated-non-prototype]
          hash_val = do_hash(key, table);

Signed-off-by: Sahil Kang <[email protected]>
Signed-off-by: Sahil Kang <[email protected]>

Author: SahilKang

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;
 		}
 

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;
 }
 

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) {

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;
 		}

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));
 }

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;
 }

lang/c/src/st.c

@@ -39,17 +39,17 @@ 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
 };
 
 /*
  * extern int strcmp(const char *, const char *); 
  */
 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 */

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));