2009-09-23 03:22:01 +00:00
|
|
|
/*
|
|
|
|
* mape - C4 Landscape.txt editor
|
2009-09-21 04:04:52 +00:00
|
|
|
*
|
2009-09-23 03:22:01 +00:00
|
|
|
* Copyright (c) 2005-2009 Armin Burgmeier
|
2009-09-21 04:04:52 +00:00
|
|
|
*
|
2009-09-23 03:22:01 +00:00
|
|
|
* Portions might be copyrighted by other authors who have contributed
|
|
|
|
* to OpenClonk.
|
2009-09-21 04:04:52 +00:00
|
|
|
*
|
2009-09-23 03:22:01 +00:00
|
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
* See isc_license.txt for full license and disclaimer.
|
|
|
|
*
|
|
|
|
* "Clonk" is a registered trademark of Matthes Bender.
|
|
|
|
* See clonk_trademark_license.txt for full license.
|
2009-09-21 04:04:52 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
2009-09-27 02:43:09 +00:00
|
|
|
#include "mape/configfile.h"
|
2009-09-21 04:04:52 +00:00
|
|
|
|
|
|
|
MapeConfigFile* mape_config_file_new(const gchar* filename)
|
|
|
|
{
|
|
|
|
/* If filename does not exist, we return an empty config file. */
|
|
|
|
MapeConfigFile* file;
|
|
|
|
gchar* contents;
|
|
|
|
gchar** lines;
|
|
|
|
gchar** cur_line;
|
|
|
|
gchar* sep;
|
|
|
|
gsize length;
|
|
|
|
|
|
|
|
file = malloc(sizeof(MapeConfigFile) );
|
|
|
|
file->file_path = g_strdup(filename);
|
|
|
|
file->entries = NULL;
|
|
|
|
file->entry_count = 0;
|
|
|
|
|
|
|
|
if(g_file_get_contents(filename, &contents, &length, NULL) == FALSE)
|
|
|
|
return file;
|
|
|
|
|
|
|
|
lines = g_strsplit(contents, "\n", 0);
|
|
|
|
g_free(contents);
|
|
|
|
|
|
|
|
for(cur_line = lines; *cur_line != NULL; ++ cur_line)
|
|
|
|
{
|
|
|
|
sep = strchr(*cur_line, '=');
|
|
|
|
if(sep == NULL) continue;
|
|
|
|
|
|
|
|
*sep = '\0';
|
|
|
|
mape_config_file_set_entry(file, *cur_line, sep + 1);
|
|
|
|
*sep = '=';
|
|
|
|
}
|
|
|
|
|
|
|
|
g_strfreev(lines);
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
|
|
|
|
void mape_config_file_destroy(MapeConfigFile* file)
|
|
|
|
{
|
|
|
|
gsize i;
|
|
|
|
for(i = 0; i < file->entry_count; ++ i)
|
|
|
|
{
|
|
|
|
g_free(file->entries[i].key);
|
|
|
|
g_free(file->entries[i].value);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_free(file->entries);
|
|
|
|
g_free(file->file_path);
|
|
|
|
free(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean mape_config_file_serialise(MapeConfigFile* file,
|
|
|
|
GError** error)
|
|
|
|
{
|
|
|
|
gchar* dir;
|
|
|
|
gchar* content;
|
|
|
|
gchar* temp;
|
|
|
|
gsize i;
|
|
|
|
|
|
|
|
int dir_result;
|
|
|
|
gboolean cont_result;
|
|
|
|
|
|
|
|
dir = g_dirname(file->file_path);
|
|
|
|
dir_result = g_mkdir_with_parents(dir, 0755);
|
|
|
|
|
|
|
|
g_free(dir);
|
|
|
|
if(dir_result == -1)
|
|
|
|
{
|
|
|
|
g_set_error(
|
|
|
|
error,
|
|
|
|
g_quark_from_static_string("MAPE_CONFIG_FILE_ERROR"),
|
|
|
|
errno,
|
|
|
|
"%s",
|
|
|
|
g_strerror(errno)
|
|
|
|
);
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
content = g_strdup("");
|
|
|
|
for(i = 0; i < file->entry_count; ++ i)
|
|
|
|
{
|
|
|
|
temp = g_strconcat(
|
|
|
|
content,
|
|
|
|
file->entries[i].key,
|
|
|
|
"=",
|
|
|
|
file->entries[i].value,
|
|
|
|
"\n",
|
|
|
|
NULL
|
|
|
|
);
|
|
|
|
|
|
|
|
g_free(content);
|
|
|
|
content = temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
cont_result = g_file_set_contents(file->file_path, content, -1, error);
|
|
|
|
g_free(content);
|
|
|
|
|
|
|
|
return(cont_result);
|
|
|
|
}
|
|
|
|
|
|
|
|
gsize mape_config_file_get_entry_count(MapeConfigFile* file)
|
|
|
|
{
|
|
|
|
return file->entry_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
MapeConfigFileEntry* mape_config_file_get_entry(MapeConfigFile* file,
|
|
|
|
gsize index)
|
|
|
|
{
|
|
|
|
g_assert(index < file->entry_count);
|
|
|
|
return &file->entries[index];
|
|
|
|
}
|
|
|
|
|
|
|
|
MapeConfigFileEntry* mape_config_file_get_entry_by_key(MapeConfigFile* file,
|
|
|
|
const gchar* key)
|
|
|
|
{
|
|
|
|
gsize i;
|
|
|
|
for(i = 0; i < file->entry_count; ++ i)
|
|
|
|
if(g_strcasecmp(file->entries[i].key, key) == 0)
|
|
|
|
return &file->entries[i];
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void mape_config_file_set_entry(MapeConfigFile* file,
|
|
|
|
const gchar* key,
|
|
|
|
const gchar* value)
|
|
|
|
{
|
|
|
|
MapeConfigFileEntry* entry;
|
|
|
|
entry = mape_config_file_get_entry_by_key(file, key);
|
|
|
|
|
|
|
|
if(entry != NULL)
|
|
|
|
{
|
|
|
|
g_free(entry->value);
|
|
|
|
entry->value = g_strdup(value);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
++ file->entry_count;
|
|
|
|
file->entries = realloc(
|
|
|
|
file->entries,
|
|
|
|
sizeof(MapeConfigFileEntry) * file->entry_count
|
|
|
|
);
|
|
|
|
|
|
|
|
entry = &file->entries[file->entry_count - 1];
|
|
|
|
entry->key = g_strdup(key);
|
|
|
|
entry->value = g_strdup(value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const gchar* mape_config_file_entry_get_key(MapeConfigFileEntry* entry)
|
|
|
|
{
|
|
|
|
return entry->key;
|
|
|
|
}
|
|
|
|
|
|
|
|
const gchar* mape_config_file_entry_get_value(MapeConfigFileEntry* entry)
|
|
|
|
{
|
|
|
|
return entry->value;
|
|
|
|
}
|