/* put names to a hash table */
/* this is a helper for file read operations */
/* maps copied strings to elements (integers) */
- name_to_element = create_hashtable(str_case_hash, str_case_equal, NULL, NULL);
+ name_to_element = create_hashtable(gd_str_case_hash, gd_str_case_equal, NULL, NULL);
for (i = 0; i < O_MAX; i++)
{
char *key;
- key = g_ascii_strup(gd_elements[i].filename, -1);
+ key = getStringToUpper(gd_elements[i].filename);
if (hashtable_exists(name_to_element, key)) /* hash value may be 0 */
Warn("Name %s already used for element %x", key, i);
/* search the element database for the specified name, and return the element */
GdElement gd_get_element_from_string (const char *string)
{
- char *upper = g_ascii_strup(string, -1);
+ char *upper = getStringToUpper(string);
void *value;
boolean found;
qsort(highscores, GD_HIGHSCORE_NUM, sizeof(GdHighScore), gd_highscore_compare);
for (i = 0; i < GD_HIGHSCORE_NUM; i++)
- if (g_str_equal(highscores[i].name, name) && highscores[i].score == score)
+ if (strEqual(highscores[i].name, name) && highscores[i].score == score)
return i;
return -1;
}
/* for the case-insensitive hash keys */
-int str_case_equal(void *s1, void *s2)
+int gd_str_case_equal(void *s1, void *s2)
{
return strcasecmp(s1, s2) == 0;
}
-unsigned int str_case_hash(void *v)
+unsigned int gd_str_case_hash(void *v)
{
char *upper = getStringToUpper(v);
unsigned int hash = get_hash_from_string(upper);
return hash;
}
-/* for the case-insensitive hash keys */
-boolean gd_str_case_equal(gconstpointer s1, gconstpointer s2)
-{
- return strcasecmp(s1, s2) == 0;
-}
-
-guint gd_str_case_hash(gconstpointer v)
-{
- char *upper;
- guint hash;
-
- upper = g_ascii_strup(v, -1);
- hash = g_str_hash(v);
- free(upper);
- return hash;
-}
-
/*
create new cave with default values.
sets every value, also default size, diamond value etc.
cave = checked_calloc(sizeof(GdCave));
/* hash table which stores unknown tags as strings. */
- cave->tags = g_hash_table_new_full(gd_str_case_hash, gd_str_case_equal, free, free);
+ cave->tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
gd_cave_set_gdash_defaults(cave);
return NULL;
rows = checked_malloc((cave->h) * sizeof(gpointer));
- rows[0] = g_memdup (maplines[0], cell_size * cave->w * cave->h);
+ rows[0] = getMemCopy (maplines[0], cell_size * cave->w * cave->h);
for (y = 1; y < cave->h; y++)
rows[y] = (char *)rows[0] + cell_size * cave->w * y;
return;
if (cave->tags)
- g_hash_table_destroy(cave->tags);
+ hashtable_destroy(cave->tags);
if (cave->random) /* random generator is a GRand * */
g_rand_free(cave->random);
gd_cave_map_free(cave->hammered_reappear);
/* free objects */
- g_list_foreach(cave->objects, (GFunc) free, NULL);
- g_list_free (cave->objects);
+ list_foreach(cave->objects, (list_fn) free, NULL);
+ list_free(cave->objects);
/* free replays */
- g_list_foreach(cave->replays, (GFunc) gd_replay_free, NULL);
- g_list_free(cave->replays);
+ list_foreach(cave->replays, (list_fn) gd_replay_free, NULL);
+ list_free(cave->replays);
/* freeing main pointer */
free (cave);
}
-static void hash_copy_foreach(const char *key, const char *value, GHashTable *dest)
+static void hash_copy_foreach(const char *key, const char *value, HashTable *dest)
{
- g_hash_table_insert(dest, getStringCopy(key), getStringCopy(value));
+ hashtable_insert(dest, getStringCopy(key), getStringCopy(value));
}
/* copy cave from src to destination, with duplicating dynamically allocated data */
int i;
/* copy entire data */
- g_memmove(dest, src, sizeof(GdCave));
+ memmove(dest, src, sizeof(GdCave));
/* but duplicate dynamic data */
- dest->tags = g_hash_table_new_full(gd_str_case_hash, gd_str_case_equal,
- free, free);
+ dest->tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
+
if (src->tags)
- g_hash_table_foreach(src->tags, (GHFunc) hash_copy_foreach, dest->tags);
+ hashtable_foreach(src->tags, (hashtable_fn)hash_copy_foreach, dest->tags);
dest->map = gd_cave_map_dup(src, map);
dest->hammered_reappear = gd_cave_map_dup(src, hammered_reappear);
/* copy objects list */
if (src->objects)
{
- GList *iter;
+ List *iter;
dest->objects = NULL; /* new empty list */
for (iter = src->objects; iter != NULL; iter = iter->next) /* do a deep copy */
- dest->objects = g_list_append(dest->objects, g_memdup (iter->data, sizeof (GdObject)));
+ dest->objects = list_append(dest->objects, getMemCopy (iter->data, sizeof (GdObject)));
}
/* copy replays */
if (src->replays)
{
- GList *iter;
+ List *iter;
dest->replays = NULL;
for (iter = src->replays; iter != NULL; iter = iter->next) /* do a deep copy */
- dest->replays = g_list_append(dest->replays, gd_replay_new_from_replay(iter->data));
+ dest->replays = list_append(dest->replays, gd_replay_new_from_replay(iter->data));
}
/* copy random number generator */
{
GdReplay *rep;
- rep = g_memdup(orig, sizeof(GdReplay));
+ rep = getMemCopy(orig, sizeof(GdReplay));
/* replicate dynamic data */
rep->comment = getStringCopy(orig->comment);