break;
case GD_TYPE_PROBABILITY:
- res = g_ascii_strtod(params[paramindex], NULL);
+ res = strtod(params[paramindex], NULL);
if (errno == 0 && res >= 0 && res <= 1)
{
/* fill all remaining items in array - may be only one */
break;
case GD_TYPE_RATIO:
- res = g_ascii_strtod (params[paramindex], NULL);
+ res = strtod (params[paramindex], NULL);
if (errno == 0 && res >= 0 && res <= 1)
{
for (k = j; k < prop_desc[i].count; k++)
}
/* ... */
-static void replay_process_tags(GdReplay *replay, GHashTable *tags)
+static void replay_process_tags(GdReplay *replay, HashTable *tags)
{
/* process all tags */
- g_hash_table_foreach_remove(tags, (GHRFunc) replay_process_tags_func, replay);
+ hashtable_foreach_remove(tags, (hashtable_remove_fn)replay_process_tags_func, replay);
}
/* a GHashTable foreach func.
Warn("unknown tag '%s'", attrib);
- g_hash_table_insert(cave->tags, getStringCopy(attrib), getStringCopy(param));
+ hashtable_insert(cave->tags, getStringCopy(attrib), getStringCopy(param));
}
/* having read all strings belonging to the cave, process it. */
-static void cave_process_tags(GdCave *cave, GHashTable *tags, GList *maplines)
+static void cave_process_tags(GdCave *cave, HashTable *tags, List *maplines)
{
char *value;
/* first check cave name, so we can report errors correctly (saying that GdCave xy: error foobar) */
- value = g_hash_table_lookup(tags, "Name");
+ value = hashtable_search(tags, "Name");
if (value)
cave_process_tags_func("Name", value, cave);
/* process lame engine tag first so its settings may be overwritten later */
- value = g_hash_table_lookup(tags, "Engine");
+ value = hashtable_search(tags, "Engine");
if (value)
{
cave_process_tags_func("Engine", value, cave);
- g_hash_table_remove(tags, "Engine");
+ hashtable_remove(tags, "Engine");
}
/* check if this is an intermission, so we can set to cavesize or intermissionsize */
- value = g_hash_table_lookup(tags, "Intermission");
+ value = hashtable_search(tags, "Intermission");
if (value)
{
cave_process_tags_func("Intermission", value, cave);
- g_hash_table_remove(tags, "Intermission");
+ hashtable_remove(tags, "Intermission");
}
if (cave->intermission)
}
/* process size at the beginning... as ratio types depend on this. */
- value = g_hash_table_lookup(tags, "Size");
+ value = hashtable_search(tags, "Size");
if (value)
{
cave_process_tags_func("Size", value, cave);
- g_hash_table_remove(tags, "Size");
+ hashtable_remove(tags, "Size");
}
/* these are read from the hash table, but also have some implications */
/* we do not delete them from the hash table here; as _their values will be processed later_. */
/* here we only set their implicite meanings. */
/* these also set predictability */
- if (g_hash_table_lookup(tags, "SlimePermeability"))
+ if (hashtable_search(tags, "SlimePermeability"))
cave->slime_predictable = FALSE;
- if (g_hash_table_lookup(tags, "SlimePermeabilityC64"))
+ if (hashtable_search(tags, "SlimePermeabilityC64"))
cave->slime_predictable = TRUE;
/* these set scheduling type. framedelay takes precedence, if there are both; so we check it later. */
- if (g_hash_table_lookup(tags, "CaveDelay"))
+ if (hashtable_search(tags, "CaveDelay"))
{
/* only set scheduling type, when it is not the gdash-default. */
/* this allows settings cavescheduling = bd1 in the [game] section, for example. */
/* in that case, this one will not overwrite it. */
if (cave->scheduling == GD_SCHEDULING_MILLISECONDS)
cave->scheduling = GD_SCHEDULING_PLCK;
- }
+ }
- if (g_hash_table_lookup(tags, "FrameTime"))
+ if (hashtable_search(tags, "FrameTime"))
/* but if the cave has a frametime setting, always switch to milliseconds. */
cave->scheduling = GD_SCHEDULING_MILLISECONDS;
/* process all tags */
- g_hash_table_foreach_remove(tags, (GHRFunc) cave_process_tags_func, cave);
+ hashtable_foreach_remove(tags, (hashtable_remove_fn)cave_process_tags_func, cave);
/* and at the end, when read all tags (especially the size= tag) */
/* process map, if any. */
/* some old bdcff files use smaller intermissions than the one specified. */
if (maplines)
{
- int x, y, length = g_list_length(maplines);
- GList *iter;
+ int x, y, length = list_length(maplines);
+ List *iter;
/* create map and fill with initial border, in case that map strings are shorter or somewhat */
cave->map = gd_cave_map_new(cave, GdElement);
char **lines;
int lineno;
GdCave *cave;
- GList *iter;
+ List *iter;
boolean reading_replay = FALSE;
boolean reading_map = FALSE;
boolean reading_mapcodes = FALSE;
boolean reading_bdcff_demo = FALSE;
/* assume version to be 0.32, also when the file does not specify it explicitly */
GdString version_read = "0.32";
- GList *mapstrings = NULL;
+ List *mapstrings = NULL;
int linenum;
- GHashTable *tags, *replay_tags;
+ HashTable *tags, *replay_tags;
GdObjectLevels levels = GD_OBJECT_LEVEL_ALL;
GdCave *default_cave;
set_intermissionsize_defaults();
gd_create_char_to_element_table();
- tags = g_hash_table_new_full(gd_str_case_hash, gd_str_case_equal, free, free);
- replay_tags = g_hash_table_new_full(gd_str_case_hash, gd_str_case_equal, free, free);
+ tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
+ replay_tags = create_hashtable(gd_str_case_hash, gd_str_case_equal, free, free);
/* split into lines */
lines = getSplitStringArray (contents, "\n", 0);
if (mapstrings)
{
Warn("incorrect file format: new [cave] section, but already read some map lines");
- g_list_free(mapstrings);
+ list_free(mapstrings);
mapstrings = NULL;
}
/* ... to be able to create a copy for a new cave. */
cave = gd_cave_new_from_cave(default_cave);
- gd_caveset = g_list_append (gd_caveset, cave);
+ gd_caveset = list_append (gd_caveset, cave);
}
else if (strcasecmp(line, "[/cave]") == 0)
{
cave_process_tags(cave, tags, mapstrings);
- g_list_free(mapstrings);
+ list_free(mapstrings);
mapstrings = NULL;
- if (g_hash_table_size(tags) != 0)
- g_hash_table_foreach(tags, (GHFunc) cave_report_and_copy_unknown_tags_func, cave);
- g_hash_table_remove_all(tags);
+ hashtable_foreach(tags, (hashtable_fn)cave_report_and_copy_unknown_tags_func, cave);
+ hashtable_remove_all(tags);
+
/* set this to point the pseudo-cave which holds default values */
cave = default_cave;
}
if (mapstrings != NULL)
{
Warn("incorrect file format: new [map] section, but already read some map lines");
- g_list_free(mapstrings);
+ list_free(mapstrings);
mapstrings = NULL;
}
}
replay = gd_replay_new();
replay->saved = TRUE;
replay->success = TRUE; /* we think that it is a successful demo */
- cave->replays = g_list_append(cave->replays, replay);
+ cave->replays = list_append(cave->replays, replay);
gd_strcpy(replay->player_name, "???"); /* name not saved */
}
else
#endif
/* report any remaining unknown tags */
- g_hash_table_foreach(replay_tags, (GHFunc) replay_report_unknown_tags_func, NULL);
- g_hash_table_remove_all(replay_tags);
+ hashtable_foreach(replay_tags, (hashtable_fn)replay_report_unknown_tags_func, NULL);
+ hashtable_remove_all(replay_tags);
if (replay->movements->len != 0)
{
- cave->replays = g_list_append(cave->replays, replay);
+ cave->replays = list_append(cave->replays, replay);
}
else
{
if (reading_map)
{
/* just append to the mapstrings list. we will process it later */
- mapstrings = g_list_append(mapstrings, line);
+ mapstrings = list_append(mapstrings, line);
continue;
}
/* strip leading and trailing spaces AFTER checking if we are reading a map.
map lines might begin or end with spaces */
- g_strstrip(line);
+ stripString(line);
if (reading_highscore)
{
if (reading_bdcff_demo)
{
GdReplay *replay;
- GList *iter;
+ List *iter;
/* demo must be in [cave] section. we already showed an error message for this. */
if (cave == default_cave)
continue;
- iter = g_list_last(cave->replays);
+ iter = list_last(cave->replays);
replay = (GdReplay *)iter->data;
replay_store_more_from_bdcff(replay, line);
if (new_object)
{
new_object->levels = levels; /* apply levels to new object */
- cave->objects = g_list_append(cave->objects, new_object);
+ cave->objects = list_append(cave->objects, new_object);
}
else
{
/* own tag: not too much thinking :P */
if (reading_replay)
{
- g_hash_table_insert(replay_tags, getStringCopy(attrib), getStringCopy(param));
+ hashtable_insert(replay_tags, getStringCopy(attrib), getStringCopy(param));
}
else if (reading_mapcodes)
{
{
/* it must be a default setting for all caves. is it a valid identifier? */
/* yes, it is. add to the hash table, which will be copied for all caves. */
- g_hash_table_insert(tags, getStringCopy(attrib), getStringCopy(param));
+ hashtable_insert(tags, getStringCopy(attrib), getStringCopy(param));
}
else
/* unknown setting - report. */
/* we are reading a [cave] */
/* cave settings are immediately added to cave hash table. */
/* if it is unknown, we have to remember it, and save it again. */
- g_hash_table_insert(tags, getStringCopy(attrib), getStringCopy(param));
+ hashtable_insert(tags, getStringCopy(attrib), getStringCopy(param));
}
}
if (mapstrings)
{
Warn("incorrect file format: end of file, but still have some map lines read");
- g_list_free(mapstrings);
+ list_free(mapstrings);
mapstrings = NULL;
}
/* cleanup */
freeStringArray(lines);
- g_hash_table_destroy(tags);
- g_hash_table_destroy(replay_tags);
+ hashtable_destroy(tags);
+ hashtable_destroy(replay_tags);
gd_cave_free(default_cave);
/* old bdcff files hack. explanation follows. */
if (strEqual(version_read, "0.32"))
{
- GList *iter;
+ List *iter;
Warn("No BDCFF version, or 0.32. Using unspecified-intermission-size hack.");
object.element = cave->initial_border;
object.fill_element = cave->initial_border;
- cave->objects = g_list_prepend(cave->objects, g_memdup(&object, sizeof(object)));
+ cave->objects = list_prepend(cave->objects, getMemCopy(&object, sizeof(object)));
object.x1 = 19;
object.y1 = 0; /* 19, as it is also the border */
- cave->objects = g_list_prepend(cave->objects, g_memdup(&object, sizeof(object))); /* another */
+ cave->objects = list_prepend(cave->objects, getMemCopy(&object, sizeof(object))); /* another */
}
}
}