Marc
/
server
forked from github/server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #605 from ennorehling/develop 

include cleanup
This commit is contained in:
Enno Rehling 2016-11-14 02:37:25 +01:00 committed by GitHub
parent 3bc3d2aa89 5e48eac26a
commit f0991eca43
53 changed files with 371 additions and 1160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/attributes/attributes.c
View File

@ -48,7 +48,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/faction.h>
#include <kernel/group.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/building.h>

1
src/attributes/dict.c
View File

@ -24,7 +24,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/building.h>
#include <kernel/faction.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/unit.h>

1
src/attributes/iceberg.c
View File

@ -20,7 +20,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/config.h>
#include "iceberg.h"
#include <kernel/save.h>
#include <util/attrib.h>
attrib_type at_iceberg = {

1
src/attributes/key.c
View File

@ -20,7 +20,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/config.h>
#include "key.h"
#include <kernel/save.h>
#include <util/attrib.h>
#include <util/gamedata.h>
#include <storage.h>

1
src/attributes/movement.c
View File

@ -20,7 +20,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/config.h>
#include "movement.h"
#include <kernel/save.h>
#include <util/attrib.h>
#include <util/gamedata.h>

3
src/attributes/overrideroads.c
View File

@ -20,9 +20,8 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/config.h>
#include "overrideroads.h"
#include <kernel/save.h>
#include <util/attrib.h>
attrib_type at_overrideroads = {
"roads_override", NULL, NULL, NULL, &a_writestring, &a_readstring
"roads_override", NULL, NULL, NULL, a_writestring, a_readstring
};

1
src/attributes/racename.c
View File

@ -20,7 +20,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/config.h>
#include "racename.h"
#include <kernel/save.h>
#include <util/attrib.h>
/* libc includes */

1
src/attributes/raceprefix.c
View File

@ -19,7 +19,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <platform.h>
#include <kernel/config.h>
#include "raceprefix.h"
#include <kernel/save.h>
#include <util/attrib.h>

1
src/attributes/reduceproduction.c
View File

@ -19,7 +19,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <platform.h>
#include <kernel/config.h>
#include "reduceproduction.h"
#include <kernel/save.h>
#include <kernel/region.h>
#include <kernel/messages.h>
#include <util/message.h>

1
src/attributes/stealth.c
View File

@ -1,7 +1,6 @@
#include <platform.h>
#include <kernel/unit.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <util/attrib.h>
#include <attributes/stealth.h>

1
src/attributes/targetregion.c
View File

@ -21,7 +21,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/config.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <util/attrib.h>
#include <util/gamedata.h>

2
src/bind_eressea.c
View File

@ -19,7 +19,7 @@ void eressea_free_game(void) {
}
int eressea_read_game(const char * filename) {
return readgame(filename, false);
return readgame(filename);
}
int eressea_write_game(const char * filename) {

1
src/chaos.c
View File

@ -28,7 +28,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/messages.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/terrain.h>
#include <kernel/terrainid.h>

4
src/creport.c
View File

@ -57,7 +57,6 @@ without prior permission by the authors of Eressea.
#include <kernel/spellbook.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>
#include <kernel/save.h>
/* util includes */
#include <util/attrib.h>
@ -70,6 +69,7 @@ without prior permission by the authors of Eressea.
#include <util/nrmessage.h>
#include <quicklist.h>
#include <filestream.h>
#include <stream.h>
/* libc includes */
#include <assert.h>
@ -177,7 +177,7 @@ static void print_items(FILE * F, item * items, const struct locale *lang)
}
static void
cr_output_curses(stream *out, const faction * viewer, const void *obj, objtype_t typ)
cr_output_curses(struct stream *out, const faction * viewer, const void *obj, objtype_t typ)
{
bool header = false;
attrib *a = NULL;

4
src/gmtool.c
View File

@ -823,8 +823,7 @@ void loaddata(state *st) {
askstring(st->wnd_status->handle, "save as:", datafile, sizeof(datafile));
if (strlen(datafile) > 0) {
create_backup(datafile);
readgame(datafile, false);
readgame(datafile);
st->modified = 0;
}
}
@ -834,7 +833,6 @@ void savedata(state *st) {
askstring(st->wnd_status->handle, "save as:", datafile, sizeof(datafile));
if (strlen(datafile) > 0) {
create_backup(datafile);
remove_empty_units();
writegame(datafile);
st->modified = 0;

1
src/guard.c
View File

@ -24,7 +24,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "monster.h"
#include <kernel/ally.h>
#include <kernel/save.h>
#include <kernel/unit.h>
#include <kernel/faction.h>
#include <kernel/race.h>

1
src/items/artrewards.c
View File

@ -26,7 +26,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/region.h>
#include <kernel/faction.h>
#include <kernel/unit.h>
#include <kernel/save.h>
#include <kernel/curse.h>
#include <kernel/messages.h>
#include <kernel/ship.h>

1
src/kernel/alliance.c
View File

@ -23,7 +23,6 @@ without prior permission by the authors of Eressea.
#include <kernel/order.h>
#include <kernel/region.h>
#include <kernel/unit.h>
#include <kernel/item.h>
#include <kernel/command.h>
/* util includes */

1
src/kernel/ally.c
View File

@ -3,7 +3,6 @@
#include "types.h"
#include "ally.h"
#include "save.h"
#include "unit.h"
#include "region.h"
#include "group.h"

1
src/kernel/building.c
View File

@ -28,7 +28,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "race.h"
#include "region.h"
#include "skill.h"
#include "save.h"
#include "lighthouse.h"
/* util includes */

1
src/kernel/connection.c
View File

@ -21,7 +21,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "connection.h"
#include "region.h"
#include "save.h"
#include "terrain.h"
#include "unit.h"

1
src/kernel/faction.c
View File

@ -29,7 +29,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "plane.h"
#include "race.h"
#include "region.h"
#include "save.h"
#include "spellbook.h"
#include "terrain.h"
#include "unit.h"

1
src/kernel/group.c
View File

@ -23,7 +23,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* kernel includes */
#include "ally.h"
#include "faction.h"
#include "save.h"
#include "unit.h"
/* attrib includes */

43
src/kernel/item.c
View File

@ -30,7 +30,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "pool.h"
#include "race.h"
#include "region.h"
#include "save.h"
#include "skill.h"
#include "terrain.h"
#include "unit.h"
@ -52,6 +51,8 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/umlaut.h>
#include <util/rng.h>
#include <storage.h>
/* libc includes */
#include <assert.h>
#include <errno.h>
@ -1190,6 +1191,46 @@ static item *default_spoil(const struct race *rc, int size)
return itm;
}
void read_items(struct storage *store, item ** ilist)
{
for (;;) {
char ibuf[32];
const item_type *itype;
int i;
READ_STR(store, ibuf, sizeof(ibuf));
if (!strcmp("end", ibuf)) {
break;
}
itype = it_find(ibuf);
READ_INT(store, &i);
if (i <= 0) {
log_error("data contains an entry with %d %s", i, resourcename(itype->rtype, NMF_PLURAL));
}
else {
if (itype && itype->rtype) {
i_change(ilist, itype, i);
}
else {
log_error("data contains unknown item type %s.", ibuf);
}
assert(itype && itype->rtype);
}
}
}
void write_items(struct storage *store, item * ilist)
{
item *itm;
for (itm = ilist; itm; itm = itm->next) {
assert(itm->number >= 0);
if (itm->number) {
WRITE_TOK(store, resourcename(itm->type->rtype, 0));
WRITE_INT(store, itm->number);
}
}
WRITE_TOK(store, "end");
}
static void free_itype(item_type *itype) {
assert(itype);
free(itype->construction);

5
src/kernel/item.h
View File

@ -35,6 +35,8 @@ extern "C" {
struct troop;
struct item;
struct order;
struct storage;
struct gamedata;
typedef struct item {
struct item *next;
@ -247,6 +249,9 @@ extern "C" {
void i_freeall(item ** i);
item *i_new(const item_type * it, int number);
void read_items(struct storage *store, struct item **it);
void write_items(struct storage *store, struct item *it);
/* convenience: */
item *i_change(item ** items, const item_type * it, int delta);
int i_get(const item * i, const item_type * it);

1
src/kernel/region.c
View File

@ -32,7 +32,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "plane.h"
#include "region.h"
#include "resources.h"
#include "save.h"
#include "ship.h"
#include "terrain.h"
#include "terrainid.h"

234
src/kernel/save.c
View File

@ -93,6 +93,8 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* exported symbols symbols */
int firstx = 0, firsty = 0;
// TODO: is this still important?
int enc_gamedata = ENCODING_UTF8;
/* local symbols */
@ -376,49 +378,6 @@ race_t typus2race(unsigned char typus)
return NORACE;
}
void create_backup(char *file)
{
#ifdef HAVE_LINK
char bfile[MAX_PATH];
int c = 1;
if (access(file, R_OK) == 0)
return;
do {
sprintf(bfile, "%s.backup%d", file, c);
c++;
} while (access(bfile, R_OK) == 0);
link(file, bfile);
#endif
}
void read_items(struct storage *store, item ** ilist)
{
for (;;) {
char ibuf[32];
const item_type *itype;
int i;
READ_STR(store, ibuf, sizeof(ibuf));
if (!strcmp("end", ibuf)) {
break;
}
itype = it_find(ibuf);
READ_INT(store, &i);
if (i <= 0) {
log_error("data contains an entry with %d %s", i, resourcename(itype->rtype, NMF_PLURAL));
}
else {
if (itype && itype->rtype) {
i_change(ilist, itype, i);
}
else {
log_error("data contains unknown item type %s.", ibuf);
}
assert(itype && itype->rtype);
}
}
}
static void read_alliances(struct gamedata *data)
{
storage *store = data->store;
@ -551,19 +510,6 @@ void write_alliances(struct gamedata *data)
WRITE_SECTION(data->store);
}
void write_items(struct storage *store, item * ilist)
{
item *itm;
for (itm = ilist; itm; itm = itm->next) {
assert(itm->number >= 0);
if (itm->number) {
WRITE_TOK(store, resourcename(itm->type->rtype, 0));
WRITE_INT(store, itm->number);
}
}
WRITE_TOK(store, "end");
}
static int resolve_owner(variant id, void *address)
{
region_owner *owner = (region_owner *)address;
@ -668,36 +614,6 @@ writeorder(struct gamedata *data, const struct order *ord,
WRITE_STR(data->store, obuf);
}
int read_attribs(gamedata *data, attrib **alist, void *owner) {
int result;
if (data->version < ATHASH_VERSION) {
result = a_read_orig(data, alist, owner);
}
else {
result = a_read(data, alist, owner);
}
if (result == AT_READ_DEPR) {
/* handle deprecated attributes */
attrib *a = *alist;
while (a) {
if (a->type->upgrade) {
a->type->upgrade(alist, a);
}
a = a->nexttype;
}
}
return result;
}
void write_attribs(storage *store, attrib *alist, const void *owner)
{
#if RELEASE_VERSION < ATHASH_VERSION
a_write_orig(store, alist, owner);
#else
a_write(store, alist, owner);
#endif
}
unit *read_unit(struct gamedata *data)
{
unit *u;
@ -1262,56 +1178,6 @@ int get_spell_level_faction(const spell * sp, void * cbdata)
return 0;
}
void read_spellbook(spellbook **bookp, gamedata *data, int(*get_level)(const spell * sp, void *), void * cbdata)
{
for (;;) {
spell *sp = 0;
char spname[64];
int level = 0;
READ_TOK(data->store, spname, sizeof(spname));
if (strcmp(spname, "end") == 0)
break;
if (bookp) {
sp = find_spell(spname);
if (!sp) {
log_error("read_spells: could not find spell '%s'", spname);
}
}
if (data->version >= SPELLBOOK_VERSION) {
READ_INT(data->store, &level);
}
if (sp) {
spellbook * sb = *bookp;
if (level <= 0 && get_level) {
level = get_level(sp, cbdata);
}
if (!sb) {
*bookp = create_spellbook(0);
sb = *bookp;
}
if (level > 0 && (data->version >= SPELLBOOK_VERSION || !spellbook_get(sb, sp))) {
spellbook_add(sb, sp, level);
}
}
}
}
void write_spellbook(const struct spellbook *book, struct storage *store)
{
quicklist *ql;
int qi;
if (book) {
for (ql = book->spells, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
spellbook_entry *sbe = (spellbook_entry *)ql_get(ql, qi);
WRITE_TOK(store, sbe->sp->sname);
WRITE_INT(store, sbe->level);
}
}
WRITE_TOK(store, "end");
}
static char * getpasswd(int fno) {
const char *prefix = itoa36(fno);
size_t len = strlen(prefix);
@ -1594,7 +1460,7 @@ static int cb_sb_maxlevel(spellbook_entry *sbe, void *cbdata) {
return 0;
}
int readgame(const char *filename, bool backup)
int readgame(const char *filename)
{
int n;
char path[MAX_PATH];
@ -1608,10 +1474,6 @@ int readgame(const char *filename, bool backup)
log_debug("- reading game data from %s", filename);
join_path(datapath(), filename, path, sizeof(path));
if (backup) {
create_backup(path);
}
F = fopen(path, "rb");
if (!F) {
perror(path);
@ -2074,93 +1936,3 @@ int write_game(gamedata *data) {
return 0;
}
int a_readint(attrib * a, void *owner, struct gamedata *data)
{
int n;
READ_INT(data->store, &n);
if (a) a->data.i = n;
return AT_READ_OK;
}
void a_writeint(const attrib * a, const void *owner, struct storage *store)
{
WRITE_INT(store, a->data.i);
}
int a_readshorts(attrib * a, void *owner, struct gamedata *data)
{
int n;
READ_INT(data->store, &n);
a->data.sa[0] = (short)n;
READ_INT(data->store, &n);
a->data.sa[1] = (short)n;
return AT_READ_OK;
}
void a_writeshorts(const attrib * a, const void *owner, struct storage *store)
{
WRITE_INT(store, a->data.sa[0]);
WRITE_INT(store, a->data.sa[1]);
}
int a_readchars(attrib * a, void *owner, struct gamedata *data)
{
int i;
for (i = 0; i != 4; ++i) {
int n;
READ_INT(data->store, &n);
a->data.ca[i] = (char)n;
}
return AT_READ_OK;
}
void a_writechars(const attrib * a, const void *owner, struct storage *store)
{
int i;
for (i = 0; i != 4; ++i) {
WRITE_INT(store, a->data.ca[i]);
}
}
int a_readvoid(attrib * a, void *owner, struct gamedata *data)
{
return AT_READ_OK;
}
void a_writevoid(const attrib * a, const void *owner, struct storage *store)
{
}
int a_readstring(attrib * a, void *owner, struct gamedata *data)
{
char buf[DISPLAYSIZE];
char * result = 0;
int e;
size_t len = 0;
do {
e = READ_STR(data->store, buf, sizeof(buf));
if (result) {
result = realloc(result, len + DISPLAYSIZE - 1);
strcpy(result + len, buf);
len += DISPLAYSIZE - 1;
}
else {
result = _strdup(buf);
}
} while (e == ENOMEM);
a->data.v = result;
return AT_READ_OK;
}
void a_writestring(const attrib * a, const void *owner, struct storage *store)
{
assert(a->data.v);
WRITE_STR(store, (const char *)a->data.v);
}
void a_finalizestring(attrib * a)
{
free(a->data.v);
}

32
src/kernel/save.h
View File

@ -39,24 +39,17 @@ extern "C" {
* dass hier ein Fehler (fehlende ") vorliegt */
extern int data_version;
// TODO: is this *really* still in use?
extern int enc_gamedata;
int readorders(const char *filename);
int creategame(void);
int readgame(const char *filename, bool backup);
int readgame(const char *filename);
int writegame(const char *filename);
int current_turn(void);
void read_items(struct storage *store, struct item **it);
void write_items(struct storage *store, struct item *it);
void read_spellbook(struct spellbook **bookp, struct gamedata *data, int(*get_level)(const struct spell * sp, void *), void * cbdata);
void write_spellbook(const struct spellbook *book, struct storage *store);
void write_attribs(struct storage *store, struct attrib *alist, const void *owner);
int read_attribs(struct gamedata *store, struct attrib **alist, void *owner);
void write_unit(struct gamedata *data, const struct unit *u);
struct unit *read_unit(struct gamedata *data);
@ -72,25 +65,6 @@ extern "C" {
void write_ship(struct gamedata *data, const struct ship *sh);
struct ship *read_ship(struct gamedata *data);
int a_readint(struct attrib *a, void *owner, struct gamedata *);
void a_writeint(const struct attrib *a, const void *owner,
struct storage *store);
int a_readshorts(struct attrib *a, void *owner, struct gamedata *);
void a_writeshorts(const struct attrib *a, const void *owner,
struct storage *store);
int a_readchars(struct attrib *a, void *owner, struct gamedata *);
void a_writechars(const struct attrib *a, const void *owner,
struct storage *store);
int a_readvoid(struct attrib *a, void *owner, struct gamedata *);
void a_writevoid(const struct attrib *a, const void *owner,
struct storage *);
int a_readstring(struct attrib *a, void *owner, struct gamedata *);
void a_writestring(const struct attrib *a, const void *owner,
struct storage *);
void a_finalizestring(struct attrib *a);
void create_backup(char *file);
int write_game(struct gamedata *data);
int read_game(struct gamedata *data);

2
src/kernel/save.test.c
View File

@ -38,7 +38,7 @@ static void test_readwrite_data(CuTest * tc)
char path[MAX_PATH];
test_setup();
CuAssertIntEquals(tc, 0, writegame(filename));
CuAssertIntEquals(tc, 0, readgame(filename, false));
CuAssertIntEquals(tc, 0, readgame(filename));
join_path(datapath(), filename, path, sizeof(path));
CuAssertIntEquals(tc, 0, remove(path));
test_cleanup();

1
src/kernel/skills.c
View File

@ -21,7 +21,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "skill.h"
#include "curse.h"
#include "item.h"
#include "race.h"
#include "region.h"
#include "terrain.h"

53
src/kernel/spellbook.c
View File

@ -3,9 +3,12 @@
#include <kernel/spell.h>
#include <quicklist.h>
#include <util/log.h>
#include <util/gamedata.h>
#include "spellbook.h"
#include <storage.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
@ -18,6 +21,56 @@ spellbook * create_spellbook(const char * name)
return result;
}
void read_spellbook(spellbook **bookp, gamedata *data, int(*get_level)(const spell * sp, void *), void * cbdata)
{
for (;;) {
spell *sp = 0;
char spname[64];
int level = 0;
READ_TOK(data->store, spname, sizeof(spname));
if (strcmp(spname, "end") == 0)
break;
if (bookp) {
sp = find_spell(spname);
if (!sp) {
log_error("read_spells: could not find spell '%s'", spname);
}
}
if (data->version >= SPELLBOOK_VERSION) {
READ_INT(data->store, &level);
}
if (sp) {
spellbook * sb = *bookp;
if (level <= 0 && get_level) {
level = get_level(sp, cbdata);
}
if (!sb) {
*bookp = create_spellbook(0);
sb = *bookp;
}
if (level > 0 && (data->version >= SPELLBOOK_VERSION || !spellbook_get(sb, sp))) {
spellbook_add(sb, sp, level);
}
}
}
}
void write_spellbook(const struct spellbook *book, struct storage *store)
{
quicklist *ql;
int qi;
if (book) {
for (ql = book->spells, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
spellbook_entry *sbe = (spellbook_entry *)ql_get(ql, qi);
WRITE_TOK(store, sbe->sp->sname);
WRITE_INT(store, sbe->level);
}
}
WRITE_TOK(store, "end");
}
void spellbook_add(spellbook *sb, struct spell * sp, int level)
{
spellbook_entry * sbe;

5
src/kernel/spellbook.h
View File

@ -24,6 +24,8 @@ extern "C" {
#endif
struct spell;
struct storage;
struct gamedata;
struct quicklist;
typedef struct spellbook_entry {
@ -39,6 +41,9 @@ extern "C" {
spellbook * create_spellbook(const char * name);
void read_spellbook(struct spellbook **bookp, struct gamedata *data, int(*get_level)(const struct spell * sp, void *), void * cbdata);
void write_spellbook(const struct spellbook *book, struct storage *store);
void spellbook_add(spellbook *sbp, struct spell * sp, int level);
int spellbook_foreach(spellbook *sb, int(*callback)(spellbook_entry *, void *), void * data);
void spellbook_clear(spellbook *sb);

2
src/kernel/types.h
View File

@ -144,7 +144,7 @@ typedef enum {
P_TREES,
P_ALLIANCE,
MAXPARAMS,
NOPARAM = -1
NOPARAM
} param_t;
typedef enum { /* Fehler und Meldungen im Report */

1
src/kernel/unit.c
View File

@ -34,7 +34,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "region.h"
#include "spell.h"
#include "spellbook.h"
#include "save.h"
#include "ship.h"
#include "skill.h"
#include "terrain.h"

3
src/keyword.c
View File

@ -14,6 +14,9 @@
const char * keyword(keyword_t kwd)
{
static char result[32]; // FIXME: static return value
if (kwd==NOKEYWORD) {
return NULL;
}
if (!result[0]) {
strcpy(result, "keyword::");
}

2
src/keyword.h
View File

@ -70,7 +70,7 @@ extern "C"
K_PAY,
K_LOOT,
MAXKEYWORDS,
NOKEYWORD = -1
NOKEYWORD
} keyword_t;
extern const char *keywords[MAXKEYWORDS];

4
src/keyword.test.c
View File

@ -11,11 +11,13 @@
static void test_init_keywords(CuTest *tc) {
struct locale *lang;
test_cleanup();
test_setup();
lang = get_or_create_locale("en");
locale_setstring(lang, "keyword::move", "MOVE");
init_keywords(lang);
CuAssertIntEquals(tc, K_MOVE, get_keyword("move", lang));
CuAssertStrEquals(tc, "keyword::move", keyword(K_MOVE));
CuAssertPtrEquals(tc, NULL, (void *)keyword(NOKEYWORD));
test_cleanup();
}

1
src/laws.c
View File

@ -57,7 +57,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/resources.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/spell.h>
#include <kernel/spellbook.h>

1
src/magic.c
View File

@ -38,7 +38,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/pool.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/spell.h>
#include <kernel/spellbook.h>

1
src/modules/arena.c
View File

@ -38,7 +38,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/pool.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/terrain.h>
#include <kernel/terrainid.h>
#include <kernel/unit.h>

1
src/modules/gmcmd.c
View File

@ -29,7 +29,6 @@
#include <kernel/order.h>
#include <kernel/plane.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/terrain.h>
#include <kernel/terrainid.h>
#include <kernel/unit.h>

1
src/modules/museum.c
View File

@ -32,7 +32,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/order.h>
#include <kernel/plane.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>
#include <kernel/faction.h>

1
src/move.c
View File

@ -44,7 +44,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/render.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/terrain.h>
#include <kernel/terrainid.h>

52
src/report.c
View File

@ -63,7 +63,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/region.h>
#include <kernel/render.h>
#include <kernel/resources.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/spell.h>
#include <kernel/spellbook.h>
@ -85,6 +84,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <quicklist.h>
#include <util/rng.h>
#include <filestream.h>
#include <stream.h>
/* libc includes */
#include <assert.h>
@ -133,11 +133,11 @@ static char *gamedate_season(const struct locale *lang)
return buf;
}
void newline(stream *out) {
void newline(struct stream *out) {
sputs("", out);
}
void write_spaces(stream *out, size_t num) {
void write_spaces(struct stream *out, size_t num) {
static const char spaces[REPORTWIDTH] = " ";
while (num > 0) {
size_t bytes = (num > REPORTWIDTH) ? REPORTWIDTH : num;
@ -146,7 +146,7 @@ void write_spaces(stream *out, size_t num) {
}
}
static void centre(stream *out, const char *s, bool breaking)
static void centre(struct stream *out, const char *s, bool breaking)
{
/* Bei Namen die genau 80 Zeichen lang sind, kann es hier Probleme
* geben. Seltsamerweise wird i dann auf MAXINT oder aehnlich
@ -170,7 +170,7 @@ static void centre(stream *out, const char *s, bool breaking)
}
static void
paragraph(stream *out, const char *str, ptrdiff_t indent, int hanging_indent,
paragraph(struct stream *out, const char *str, ptrdiff_t indent, int hanging_indent,
char marker)
{
size_t length = REPORTWIDTH;
@ -248,7 +248,7 @@ static size_t write_spell_modifier(spell * sp, int flag, const char * str, bool
return 0;
}
void nr_spell_syntax(stream *out, spellbook_entry * sbe, const struct locale *lang)
void nr_spell_syntax(struct stream *out, spellbook_entry * sbe, const struct locale *lang)
{
int bytes;
char buf[4096];
@ -436,7 +436,7 @@ void nr_spell_syntax(stream *out, spellbook_entry * sbe, const struct locale *la
}
void nr_spell(stream *out, spellbook_entry * sbe, const struct locale *lang)
void nr_spell(struct stream *out, spellbook_entry * sbe, const struct locale *lang)
{
int bytes, k, itemanz, costtyp;
char buf[4096];
@ -554,7 +554,7 @@ void nr_spell(stream *out, spellbook_entry * sbe, const struct locale *lang)
}
static void
nr_curses_i(stream *out, int indent, const faction *viewer, objtype_t typ, const void *obj, attrib *a, int self)
nr_curses_i(struct stream *out, int indent, const faction *viewer, objtype_t typ, const void *obj, attrib *a, int self)
{
for (; a; a = a->next) {
char buf[4096];
@ -582,7 +582,7 @@ nr_curses_i(stream *out, int indent, const faction *viewer, objtype_t typ, const
}
}
static void nr_curses(stream *out, int indent, const faction *viewer, objtype_t typ, const void *obj)
static void nr_curses(struct stream *out, int indent, const faction *viewer, objtype_t typ, const void *obj)
{
int self = 0;
attrib *a = NULL;
@ -652,7 +652,7 @@ static void nr_curses(stream *out, int indent, const faction *viewer, objtype_t
nr_curses_i(out, indent, viewer, typ, obj, a, self);
}
static void rps_nowrap(stream *out, const char *s)
static void rps_nowrap(struct stream *out, const char *s)
{
const char *x = s;
size_t indent = 0;
@ -675,7 +675,7 @@ static void rps_nowrap(stream *out, const char *s)
}
static void
nr_unit(stream *out, const faction * f, const unit * u, int indent, seen_mode mode)
nr_unit(struct stream *out, const faction * f, const unit * u, int indent, seen_mode mode)
{
attrib *a_otherfaction;
char marker;
@ -717,7 +717,7 @@ nr_unit(stream *out, const faction * f, const unit * u, int indent, seen_mode mo
}
static void
rp_messages(stream *out, message_list * msgs, faction * viewer, int indent,
rp_messages(struct stream *out, message_list * msgs, faction * viewer, int indent,
bool categorized)
{
nrsection *section;
@ -753,7 +753,7 @@ rp_messages(stream *out, message_list * msgs, faction * viewer, int indent,
}
}
static void rp_battles(stream *out, faction * f)
static void rp_battles(struct stream *out, faction * f)
{
if (f->battles != NULL) {
struct bmsg *bm = f->battles;
@ -773,7 +773,7 @@ static void rp_battles(stream *out, faction * f)
}
}
static void prices(stream *out, const region * r, const faction * f)
static void prices(struct stream *out, const region * r, const faction * f)
{
const luxury_type *sale = NULL;
struct demand *dmd;
@ -875,7 +875,7 @@ bool see_border(const connection * b, const faction * f, const region * r)
return cs;
}
static void describe(stream *out, const region * r, faction * f)
static void describe(struct stream *out, const region * r, faction * f)
{
int n;
bool dh;
@ -1268,7 +1268,7 @@ static void describe(stream *out, const region * r, faction * f)
}
}
static void statistics(stream *out, const region * r, const faction * f)
static void statistics(struct stream *out, const region * r, const faction * f)
{
const unit *u;
int number = 0, p = rpeasants(r);
@ -1620,7 +1620,7 @@ show_allies(const faction * f, const ally * allies, char *buf, size_t size)
*bufp = 0;
}
static void allies(stream *out, const faction * f)
static void allies(struct stream *out, const faction * f)
{
const group *g = f->groups;
char buf[16384];
@ -1649,7 +1649,7 @@ static void allies(stream *out, const faction * f)
}
}
static void guards(stream *out, const region * r, const faction * see)
static void guards(struct stream *out, const region * r, const faction * see)
{
/* die Partei see sieht dies; wegen
* "unbekannte Partei", wenn man es selbst ist... */
@ -1722,7 +1722,7 @@ static void guards(stream *out, const region * r, const faction * see)
}
}
static void rpline(stream *out)
static void rpline(struct stream *out)
{
static char line[REPORTWIDTH + 1];
if (line[0] != '-') {
@ -1732,7 +1732,7 @@ static void rpline(stream *out)
swrite(line, sizeof(char), sizeof(line), out);
}
static void list_address(stream *out, const faction * uf, quicklist * seenfactions)
static void list_address(struct stream *out, const faction * uf, quicklist * seenfactions)
{
int qi = 0;
quicklist *flist = seenfactions;
@ -1763,7 +1763,7 @@ static void list_address(stream *out, const faction * uf, quicklist * seenfactio
}
static void
nr_ship(stream *out, const region *r, const ship * sh, const faction * f,
nr_ship(struct stream *out, const region *r, const ship * sh, const faction * f,
const unit * captain)
{
char buffer[8192], *bufp = buffer;
@ -1836,7 +1836,7 @@ nr_ship(stream *out, const region *r, const ship * sh, const faction * f,
}
static void
nr_building(stream *out, const region *r, const building *b, const faction *f)
nr_building(struct stream *out, const region *r, const building *b, const faction *f)
{
int i, bytes;
const char *name, *bname, *billusion = NULL;
@ -1908,7 +1908,7 @@ nr_building(stream *out, const region *r, const building *b, const faction *f)
}
}
static void nr_paragraph(stream *out, message * m, faction * f)
static void nr_paragraph(struct stream *out, message * m, faction * f)
{
int bytes;
char buf[4096], *bufp = buf;
@ -1924,14 +1924,14 @@ static void nr_paragraph(stream *out, message * m, faction * f)
}
typedef struct cb_data {
stream *out;
struct stream *out;
char *start, *writep;
size_t size;
const faction *f;
int maxtravel, counter;
} cb_data;
static void init_cb(cb_data *data, stream *out, char *buffer, size_t size, const faction *f) {
static void init_cb(cb_data *data, struct stream *out, char *buffer, size_t size, const faction *f) {
data->out = out;
data->writep = buffer;
data->start = buffer;
@ -1996,7 +1996,7 @@ static void cb_write_travelthru(region *r, unit *u, void *cbdata) {
}
}
void write_travelthru(stream *out, region *r, const faction *f)
void write_travelthru(struct stream *out, region *r, const faction *f)
{
int maxtravel;
char buf[8192];

3
src/spells.c
View File

@ -47,7 +47,6 @@
#include <kernel/pool.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/spell.h>
#include <kernel/terrain.h>
@ -109,7 +108,7 @@
static double zero_effect = 0.0;
attrib_type at_wdwpyramid = {
"wdwpyramid", NULL, NULL, NULL, a_writevoid, a_readvoid
"wdwpyramid", NULL, NULL, NULL, NULL, NULL
};
/* ----------------------------------------------------------------------- */

1
src/spells/borders.c
View File

@ -8,7 +8,6 @@
#include <kernel/faction.h>
#include <kernel/messages.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>

1
src/summary.c
View File

@ -22,7 +22,6 @@
#include <kernel/item.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/terrain.h>
#include <kernel/terrainid.h>
#include <kernel/unit.h>

1
src/triggers/changefaction.c
View File

@ -22,7 +22,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* kernel includes */
#include <kernel/unit.h>
#include <kernel/save.h>
#include <kernel/faction.h>
/* util includes */

113
src/util/attrib.c
View File

@ -28,6 +28,119 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
int read_attribs(gamedata *data, attrib **alist, void *owner) {
int result;
if (data->version < ATHASH_VERSION) {
result = a_read_orig(data, alist, owner);
}
else {
result = a_read(data, alist, owner);
}
if (result == AT_READ_DEPR) {
/* handle deprecated attributes */
attrib *a = *alist;
while (a) {
if (a->type->upgrade) {
a->type->upgrade(alist, a);
}
a = a->nexttype;
}
}
return result;
}
void write_attribs(storage *store, attrib *alist, const void *owner)
{
#if RELEASE_VERSION < ATHASH_VERSION
a_write_orig(store, alist, owner);
#else
a_write(store, alist, owner);
#endif
}
int a_readint(attrib * a, void *owner, struct gamedata *data)
{
int n;
READ_INT(data->store, &n);
if (a) a->data.i = n;
return AT_READ_OK;
}
void a_writeint(const attrib * a, const void *owner, struct storage *store)
{
WRITE_INT(store, a->data.i);
}
int a_readshorts(attrib * a, void *owner, struct gamedata *data)
{
int n;
READ_INT(data->store, &n);
a->data.sa[0] = (short)n;
READ_INT(data->store, &n);
a->data.sa[1] = (short)n;
return AT_READ_OK;
}
void a_writeshorts(const attrib * a, const void *owner, struct storage *store)
{
WRITE_INT(store, a->data.sa[0]);
WRITE_INT(store, a->data.sa[1]);
}
int a_readchars(attrib * a, void *owner, struct gamedata *data)
{
int i;
for (i = 0; i != 4; ++i) {
int n;
READ_INT(data->store, &n);
a->data.ca[i] = (char)n;
}
return AT_READ_OK;
}
void a_writechars(const attrib * a, const void *owner, struct storage *store)
{
int i;
for (i = 0; i != 4; ++i) {
WRITE_INT(store, a->data.ca[i]);
}
}
#define DISPLAYSIZE 8192
int a_readstring(attrib * a, void *owner, struct gamedata *data)
{
char buf[DISPLAYSIZE];
char * result = 0;
int e;
size_t len = 0;
do {
e = READ_STR(data->store, buf, sizeof(buf));
if (result) {
result = realloc(result, len + DISPLAYSIZE - 1);
strcpy(result + len, buf);
len += DISPLAYSIZE - 1;
}
else {
result = _strdup(buf);
}
} while (e == ENOMEM);
a->data.v = result;
return AT_READ_OK;
}
void a_writestring(const attrib * a, const void *owner, struct storage *store)
{
assert(a->data.v);
WRITE_STR(store, (const char *)a->data.v);
}
void a_finalizestring(attrib * a)
{
free(a->data.v);
}
#define MAXATHASH 61
static attrib_type *at_hash[MAXATHASH];

17
src/util/attrib.h
View File

@ -66,6 +66,9 @@ extern "C" {
extern void at_register(attrib_type * at);
extern void at_deprecate(const char * name, int(*reader)(attrib *, void *, struct gamedata *));
void write_attribs(struct storage *store, struct attrib *alist, const void *owner);
int read_attribs(struct gamedata *store, struct attrib **alist, void *owner);
extern attrib *a_select(attrib * a, const void *data,
bool(*compare) (const attrib *, const void *));
extern attrib *a_find(attrib * a, const attrib_type * at);
@ -81,6 +84,20 @@ extern "C" {
int a_read(struct gamedata *data, attrib ** attribs, void *owner);
void a_write(struct storage *store, const attrib * attribs, const void *owner);
int a_readint(struct attrib *a, void *owner, struct gamedata *);
void a_writeint(const struct attrib *a, const void *owner,
struct storage *store);
int a_readshorts(struct attrib *a, void *owner, struct gamedata *);
void a_writeshorts(const struct attrib *a, const void *owner,
struct storage *store);
int a_readchars(struct attrib *a, void *owner, struct gamedata *);
void a_writechars(const struct attrib *a, const void *owner,
struct storage *store);
int a_readstring(struct attrib *a, void *owner, struct gamedata *);
void a_writestring(const struct attrib *a, const void *owner,
struct storage *);
void a_finalizestring(struct attrib *a);
void attrib_done(void);
#define DEFAULT_AGE NULL

91
src/util/attrib.test.c
View File

@ -1,8 +1,13 @@
#include <platform.h>
#include "attrib.h"
#include <util/gamedata.h>
#include <storage.h>
#include <memstream.h>
#include <CuTest.h>
#include <tests.h>
#include <string.h>
static void test_attrib_new(CuTest * tc)
{
@ -16,7 +21,6 @@ static void test_attrib_new(CuTest * tc)
CuAssertPtrEquals(tc, 0, a);
}
static void test_attrib_add(CuTest * tc)
{
attrib_type at_foo = { "foo" };
@ -52,7 +56,6 @@ static void test_attrib_remove_self(CuTest * tc) {
a_removeall(&alist, NULL);
}
static void test_attrib_removeall(CuTest * tc) {
const attrib_type at_foo = { "foo" };
const attrib_type at_bar = { "bar" };
@ -110,6 +113,86 @@ static void test_attrib_nexttype(CuTest * tc)
a_removeall(&alist, &at_bar);
}
static void test_attrib_rwstring(CuTest *tc) {
gamedata data;
storage store;
attrib a = { 0 };
test_setup();
a.data.v = _strdup("Hello World");
mstream_init(&data.strm);
gamedata_init(&data, &store, RELEASE_VERSION);
a_writestring(&a, NULL, &store);
a_finalizestring(&a);
data.strm.api->rewind(data.strm.handle);
a_readstring(&a, NULL, &data);
CuAssertStrEquals(tc, "Hello World", (const char *)a.data.v);
mstream_done(&data.strm);
gamedata_done(&data);
test_cleanup();
}
static void test_attrib_rwint(CuTest *tc) {
gamedata data;
storage store;
attrib a = { 0 };
test_setup();
a.data.i = 42;
mstream_init(&data.strm);
gamedata_init(&data, &store, RELEASE_VERSION);
a_writeint(&a, NULL, &store);
a.data.i = 0;
data.strm.api->rewind(data.strm.handle);
a_readint(&a, NULL, &data);
CuAssertIntEquals(tc, 42, a.data.i);
mstream_done(&data.strm);
gamedata_done(&data);
test_cleanup();
}
static void test_attrib_rwchars(CuTest *tc) {
gamedata data;
storage store;
attrib a = { 0 };
test_setup();
a.data.ca[0] = 1;
a.data.ca[3] = 42;
mstream_init(&data.strm);
gamedata_init(&data, &store, RELEASE_VERSION);
a_writeint(&a, NULL, &store);
memset(a.data.ca, 0, 4);
data.strm.api->rewind(data.strm.handle);
a_readint(&a, NULL, &data);
CuAssertIntEquals(tc, 1, a.data.ca[0]);
CuAssertIntEquals(tc, 42, a.data.ca[3]);
mstream_done(&data.strm);
gamedata_done(&data);
test_cleanup();
}
static void test_attrib_rwshorts(CuTest *tc) {
gamedata data;
storage store;
attrib a = { 0 };
a.data.sa[0] = -4;
a.data.sa[1] = 42;
test_setup();
mstream_init(&data.strm);
gamedata_init(&data, &store, RELEASE_VERSION);
a_writeint(&a, NULL, &store);
memset(a.data.ca, 0, 4);
data.strm.api->rewind(data.strm.handle);
a_readint(&a, NULL, &data);
CuAssertIntEquals(tc, -4, a.data.sa[0]);
CuAssertIntEquals(tc, 42, a.data.sa[1]);
mstream_done(&data.strm);
gamedata_done(&data);
test_cleanup();
}
CuSuite *get_attrib_suite(void)
{
CuSuite *suite = CuSuiteNew();
@ -119,5 +202,9 @@ CuSuite *get_attrib_suite(void)
SUITE_ADD_TEST(suite, test_attrib_removeall);
SUITE_ADD_TEST(suite, test_attrib_remove_self);
SUITE_ADD_TEST(suite, test_attrib_nexttype);
SUITE_ADD_TEST(suite, test_attrib_rwstring);
SUITE_ADD_TEST(suite, test_attrib_rwint);
SUITE_ADD_TEST(suite, test_attrib_rwchars);
SUITE_ADD_TEST(suite, test_attrib_rwshorts);
return suite;
}

800
src/xmlreport.c
View File

@ -1,800 +0,0 @@
/*
+-------------------+ Enno Rehling <enno@eressea.de>
| Eressea PBEM host | Christian Schlittchen <corwin@amber.kn-bremen.de>
| (c) 1998 - 2008 | Katja Zedel <katze@felidae.kn-bremen.de>
+-------------------+
This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/
#include <platform.h>
#include <kernel/config.h>
#include "xmlreport.h"
#define XML_ATL_NAMESPACE (const xmlChar *) "http://www.eressea.de/XML/2008/atlantis"
#define XML_XML_LANG (const xmlChar *) "lang"
/* modules include */
#include <modules/score.h>
/* attributes include */
#include <attributes/follow.h>
#include <attributes/racename.h>
#include <attributes/orcification.h>
#include <attributes/otherfaction.h>
#include <attributes/raceprefix.h>
/* gamecode includes */
#include "laws.h"
#include "economy.h"
#include "move.h"
/* kernel includes */
#include <kernel/alchemy.h>
#include <kernel/alliance.h>
#include <kernel/ally.h>
#include <kernel/connection.h>
#include <kernel/curse.h>
#include <kernel/building.h>
#include <kernel/faction.h>
#include <kernel/group.h>
#include <kernel/item.h>
#include <kernel/magic.h>
#include <kernel/messages.h>
#include <kernel/order.h>
#include <kernel/plane.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/reports.h>
#include <kernel/resources.h>
#include <kernel/ship.h>
#include <kernel/skill.h>
#include <kernel/teleport.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>
#include <kernel/save.h>
/* util includes */
#include <util/attrib.h>
#include <util/base36.h>
#include <util/goodies.h>
#include <util/language.h>
#include <util/message.h>
#include <quicklist.h>
#include <util/xml.h>
#ifdef USE_LIBXML2
/* libxml2 includes */
#include <libxml/tree.h>
#include <libxml/encoding.h>
#ifdef USE_ICONV
#include <iconv.h>
#endif
#endif
/* libc includes */
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#define L10N(x) x
typedef struct xml_context {
xmlDocPtr doc;
xmlNsPtr ns_atl;
xmlNsPtr ns_xml;
} xml_context;
static xmlNodePtr
xml_link(report_context * ctx, const xmlChar * rel, const xmlChar * ref)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "link");
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "rel", rel);
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "ref", ref);
return node;
}
static const xmlChar *xml_ref_unit(const unit * u)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "unit_%d", u->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_faction(const faction * f)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "fctn_%d", f->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_group(const group * g)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "grp_%d", g->gid);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_prefix(const char *str)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "pref_%s", str);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_building(const building * b)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "bldg_%d", b->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_ship(const ship * sh)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "shp_%d", sh->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_region(const region * r)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "rgn_%d", r->uid);
return (const xmlChar *)idbuf;
}
static xmlNodePtr xml_inventory(report_context * ctx, item * items, unit * u)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "items");
item *itm;
for (itm = items; itm; itm = itm->next) {
xmlNodePtr child;
const char *name;
int n;
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "item"));
report_item(u, itm, ctx->f, NULL, &name, &n, true);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (xmlChar *) name);
xmlNodeAddContent(child, (xmlChar *) itoab(n, 10));
}
return node;
}
#ifdef TODO /*spellbooks */
static xmlNodePtr
xml_spells(report_context * ctx, quicklist * slist, int maxlevel)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "spells");
quicklist *ql;
int qi;
for (ql = slist, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
spell *sp = (spell *) ql_get(ql, qi);
if (sp->level <= maxlevel) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "spell"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "name", BAD_CAST sp->sname);
}
}
return node;
}
#endif
static xmlNodePtr xml_skills(report_context * ctx, unit * u)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "skills");
skill *sv;
for (sv = u->skills; sv != u->skills + u->skill_size; ++sv) {
if (sv->level > 0) {
skill_t sk = sv->id;
int esk = eff_skill(u, sk, u->region);
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "skill", BAD_CAST itoab(esk,
10));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", BAD_CAST skillnames[sk]);
}
}
return node;
}
static xmlNodePtr xml_unit(report_context * ctx, unit * u, int mode)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "unit");
static const curse_type *itemcloak_ct = 0;
static bool init = false;
xmlNodePtr child;
const char *str, *rcname, *rcillusion;
bool disclosure = (ctx->f == u->faction || omniscient(ctx->f));
/* TODO: hitpoints, aura, combatspells, curses */
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_unit(u));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(u->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name", (const xmlChar *)u->name);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "number",
(const xmlChar *)itoab(u->number, 10));
/* optional description */
str = u_description(u, ctx->f->locale);
if (str) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text", (const xmlChar *)str);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
if (str != u->display) {
xmlNewNsProp(child, xct->ns_atl, XML_XML_LANG,
BAD_CAST locale_name(ctx->f->locale));
}
}
/* possible <guard/> info */
if (is_guard(u, GUARD_ALL) != 0) {
xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "guard"));
}
/* siege */
if (fval(u, UFL_SIEGE)) {
building *b = usiege(u);
if (b) {
xmlAddChild(node, xml_link(ctx, BAD_CAST "siege", xml_ref_building(b)));
}
}
/* TODO: temp/alias */
/* race information */
report_race(u, &rcname, &rcillusion);
if (disclosure) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "race"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "true");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (const xmlChar *)rcname);
if (rcillusion) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "race"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)rcillusion);
}
} else {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "race"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)(rcillusion ? rcillusion : rcname));
}
/* group and prefix information. we only write the prefix if we really must */
if (fval(u, UFL_GROUP)) {
attrib *a = a_find(u->attribs, &at_group);
if (a != NULL) {
const group *g = (const group *)a->data.v;
if (disclosure) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "group"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_group(g));
} else {
const char *prefix = get_prefix(g->attribs);
if (prefix) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "prefix"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
xml_ref_prefix(prefix));
}
}
}
}
if (disclosure) {
unit *mage;
str = uprivate(u);
if (str) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)str);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "private");
}
/* familiar info */
mage = get_familiar_mage(u);
if (mage)
xmlAddChild(node, xml_link(ctx, BAD_CAST "familiar_of",
xml_ref_unit(mage)));
/* combat status */
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "combat");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value",
BAD_CAST combatstatus[u->status]);
if (fval(u, UFL_NOAID)) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "aid");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST "false");
}
if (fval(u, UFL_STEALTH)) {
int i = u_geteffstealth(u);
if (i >= 0) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST itoab(i,
10));
}
}
if (fval(u, UFL_HERO)) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "hero");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST "true");
}
if (fval(u, UFL_HUNGER)) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "hunger");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST "true");
}
/* skills */
if (u->skill_size) {
xmlAddChild(node, xml_skills(ctx, u));
}
#ifdef TODO /*spellbooks */
/* spells */
if (is_mage(u)) {
sc_mage *mage = get_mage(u);
quicklist *slist = mage->spells;
if (slist) {
xmlAddChild(node, xml_spells(ctx, slist, effskill(u, SK_MAGIC)));
}
}
#endif
}
/* faction information w/ visibiility */
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "faction"));
if (disclosure) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "true");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
xml_ref_faction(u->faction));
if (fval(u, UFL_ANON_FACTION)) {
const faction *sf = visible_faction(NULL, u);
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "faction"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_faction(sf));
}
} else {
const faction *sf = visible_faction(ctx->f, u);
if (sf == ctx->f) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
}
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_faction(sf));
}
/* the inventory */
if (u->items) {
item result[MAX_INVENTORY];
item *show = NULL;
if (!init) {
init = true;
itemcloak_ct = ct_find("itemcloak");
}
if (disclosure) {
show = u->items;
} else {
bool see_items = (mode >= see_unit);
if (see_items) {
if (itemcloak_ct && curse_active(get_curse(u->attribs, itemcloak_ct))) {
see_items = false;
} else {
see_items = effskill(u, SK_STEALTH) < 3;
}
}
if (see_items) {
int n = report_items(u->items, result, MAX_INVENTORY, u, ctx->f);
assert(n >= 0);
if (n > 0)
show = result;
else
show = NULL;
} else {
show = NULL;
}
}
if (show) {
xmlAddChild(node, xml_inventory(ctx, show, u));
}
}
return node;
}
static xmlNodePtr xml_resources(report_context * ctx, const seen_region * sr)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = NULL;
resource_report result[MAX_RAWMATERIALS];
int n, size = report_resources(sr, result, MAX_RAWMATERIALS, ctx->f);
if (size) {
node = xmlNewNode(xct->ns_atl, BAD_CAST "resources");
for (n = 0; n < size; ++n) {
if (result[n].number >= 0) {
xmlNodePtr child;
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "resource"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(xmlChar *) result[n].name);
if (result[n].level >= 0) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "level",
(xmlChar *) itoab(result[n].level, 10));
}
xmlNodeAddContent(child, (xmlChar *) itoab(result[n].number, 10));
}
}
}
return node;
}
static xmlNodePtr xml_diplomacy(report_context * ctx, const struct ally *allies)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "diplomacy");
const struct ally *sf;
for (sf = allies; sf; sf = sf->next) {
int i, status = sf->status;
for (i = 0; helpmodes[i].name; ++i) {
if (sf->faction && (status & helpmodes[i].status) == helpmodes[i].status) {
status -= helpmodes[i].status;
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlNewNsProp(child, xct->ns_xml, BAD_CAST "faction",
xml_ref_faction(sf->faction));
xmlNewNsProp(child, xct->ns_xml, BAD_CAST "status",
(xmlChar *) helpmodes[i].name);
}
}
}
return node;
}
static xmlNodePtr xml_groups(report_context * ctx, const group * groups)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "faction");
const group *g;
for (g = groups; g; g = g->next) {
const char *prefix = get_prefix(g->attribs);
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "group"));
xmlNewNsProp(child, xct->ns_xml, XML_XML_ID, xml_ref_group(g));
xmlNewTextChild(child, xct->ns_atl, BAD_CAST "name",
(const xmlChar *)g->name);
if (g->allies)
xmlAddChild(child, xml_diplomacy(ctx, g->allies));
if (prefix) {
child = xmlAddChild(child, xmlNewNode(xct->ns_atl, BAD_CAST "prefix"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_prefix(prefix));
}
}
return node;
}
static xmlNodePtr xml_faction(report_context * ctx, faction * f)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "faction");
/* TODO: alliance, locale */
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_faction(f));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(f->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name", (const xmlChar *)f->name);
if (f->email)
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "email",
(const xmlChar *)f->email);
if (f->banner) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)f->banner);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
if (ctx->f == f) {
xmlAddChild(node, xml_link(ctx, BAD_CAST "race",
BAD_CAST f->race->_name[0]));
if (f->items)
xmlAddChild(node, xml_inventory(ctx, f->items, NULL));
if (f->allies)
xmlAddChild(node, xml_diplomacy(ctx, f->allies));
if (f->groups)
xmlAddChild(node, xml_groups(ctx, f->groups));
/* TODO: age, options, score, prefix, magic, immigrants, heroes, nmr, groups */
}
return node;
}
static xmlNodePtr
xml_building(report_context * ctx, seen_region * sr, const building * b,
const unit * owner)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "building");
xmlNodePtr child;
const char *bname, *billusion;
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_building(b));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(b->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name", (const xmlChar *)b->name);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "size",
(const xmlChar *)itoab(b->size, 10));
if (b->display && b->display[0]) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)b->display);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
if (b->besieged) {
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "siege",
(const xmlChar *)itoab(b->besieged, 10));
}
if (owner)
xmlAddChild(node, xml_link(ctx, BAD_CAST "owner", xml_ref_unit(owner)));
report_building(b, &bname, &billusion);
if (owner && owner->faction == ctx->f) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "true");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (const xmlChar *)bname);
if (billusion) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "illusion");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)billusion);
}
} else {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)(billusion ? billusion : bname));
}
return node;
}
static xmlNodePtr
xml_ship(report_context * ctx, const seen_region * sr, const ship * sh,
const unit * owner)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "ship");
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_ship(sh));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(sh->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name",
(const xmlChar *)sh->name);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "size",
(const xmlChar *)itoab(sh->size, 10));
if (sh->damage) {
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "damage",
(const xmlChar *)itoab(sh->damage, 10));
}
if (fval(sr->r->terrain, SEA_REGION) && sh->coast != NODIRECTION) {
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "coast",
BAD_CAST directions[sh->coast]);
}
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)sh->type->name[0]);
if (sh->display && sh->display[0]) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)sh->display);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
if (owner)
xmlAddChild(node, xml_link(ctx, BAD_CAST "owner", xml_ref_unit(owner)));
if ((owner && owner->faction == ctx->f) || omniscient(ctx->f)) {
int n = 0, p = 0;
getshipweight(sh, &n, &p);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "cargo",
(const xmlChar *)itoab(n, 10));
}
return node;
}
static xmlNodePtr xml_region(report_context * ctx, seen_region * sr)
{
xml_context *xct = (xml_context *) ctx->userdata;
const region *r = sr->r;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "region");
xmlNodePtr child;
int stealthmod = stealth_modifier(sr->mode);
unit *u;
ship *sh = r->ships;
building *b = r->buildings;
plane *pl = rplane(r);
int nx = r->x, ny = r->y;
pnormalize(&nx, &ny, pl);
adjust_coordinates(ctx->f, &nx, &ny, pl, r);
/* TODO: entertain-quota, recruits, salary, prices, curses, borders, apparitions (Schemen), spells, travelthru, messages */
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_region(r));
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "coordinate"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "x", xml_i(nx));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "y", xml_i(ny));
if (pl && pl->name) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "plane", (xmlChar *) pl->name);
}
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "terrain"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (xmlChar *) terrain_name(r));
if (r->land != NULL) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name",
(const xmlChar *)r->land->name);
if (r->land->items) {
xmlAddChild(node, xml_inventory(ctx, r->land->items, NULL));
}
}
if (r->display && r->display[0]) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)r->display);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
child = xml_resources(ctx, sr);
if (child)
xmlAddChild(node, child);
child = xmlNewNode(xct->ns_atl, BAD_CAST "terrain");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)terrain_name(r));
if (sr->mode > see_neighbour) {
/* report all units. they are pre-sorted in an efficient manner */
u = r->units;
while (b) {
while (b && (!u || u->building != b)) {
xmlAddChild(node, xml_building(ctx, sr, b, NULL));
b = b->next;
}
if (b) {
child = xmlAddChild(node, xml_building(ctx, sr, b, u));
while (u && u->building == b) {
xmlAddChild(child, xml_unit(ctx, u, sr->mode));
u = u->next;
}
b = b->next;
}
}
while (u && !u->ship) {
if (stealthmod > INT_MIN) {
if (u->faction == ctx->f || cansee(ctx->f, r, u, stealthmod)) {
xmlAddChild(node, xml_unit(ctx, u, sr->mode));
}
}
u = u->next;
}
while (sh) {
while (sh && (!u || u->ship != sh)) {
xmlAddChild(node, xml_ship(ctx, sr, sh, NULL));
sh = sh->next;
}
if (sh) {
child = xmlAddChild(node, xml_ship(ctx, sr, sh, u));
while (u && u->ship == sh) {
xmlAddChild(child, xml_unit(ctx, u, sr->mode));
u = u->next;
}
sh = sh->next;
}
}
}
return node;
}
static xmlNodePtr report_root(report_context * ctx)
{
int qi;
quicklist *address;
region *r = ctx->first, *rend = ctx->last;
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node, child, xmlReport = xmlNewNode(NULL, BAD_CAST "atlantis");
const char *mailto = locale_string(ctx->f->locale, "mailto");
const char *mailcmd = locale_string(ctx->f->locale, "mailcmd");
char zText[128];
/* TODO: locale, age, options, messages */
xct->ns_xml = xmlNewNs(xmlReport, XML_XML_NAMESPACE, BAD_CAST "xml");
xct->ns_atl = xmlNewNs(xmlReport, XML_ATL_NAMESPACE, NULL);
xmlSetNs(xmlReport, xct->ns_atl);
node = xmlAddChild(xmlReport, xmlNewNode(xct->ns_atl, BAD_CAST "server"));
if (mailto) {
_snprintf(zText, sizeof(zText), "mailto:%s?subject=%s", mailto, mailcmd);
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "delivery"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "method", BAD_CAST "mail");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "href", BAD_CAST zText);
}
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "game",
(xmlChar *) global.gamename);
strftime(zText, sizeof(zText), "%Y-%m-%dT%H:%M:%SZ",
gmtime(&ctx->report_time));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "time", (xmlChar *) zText);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "turn", (xmlChar *) itoab(turn,
10));
for (qi = 0, address = ctx->addresses; address; ql_advance(&address, &qi, 1)) {
faction *f = (faction *) ql_get(address, qi);
xmlAddChild(xmlReport, xml_faction(ctx, f));
}
for (; r != rend; r = r->next) {
seen_region *sr = find_seen(ctx->seen, r);
if (sr != NULL)
xmlAddChild(xmlReport, xml_region(ctx, sr));
}
return xmlReport;
}
/* main function of the xmlreport. creates the header and traverses all regions */
static int
report_xml(const char *filename, report_context * ctx, const char *encoding)
{
xml_context xct;
xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
xct.doc = doc;
assert(ctx->userdata == NULL);
ctx->userdata = &xct;
xmlDocSetRootElement(doc, report_root(ctx));
xmlKeepBlanksDefault(0);
xmlSaveFormatFileEnc(filename, doc, "utf-8", 1);
xmlFreeDoc(doc);
ctx->userdata = NULL;
return 0;
}
void register_xr(void)
{
register_reporttype("xml", &report_xml, 1 << O_XML);
#ifdef USE_ICONV
utf8 = iconv_open("UTF-8", "");
#endif
}
void xmlreport_cleanup(void)
{
#ifdef USE_ICONV
iconv_close(utf8);
#endif
}

26
src/xmlreport.h
View File

@ -1,26 +0,0 @@
/*
+-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de>
| Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de>
| (c) 1998 - 2005 | Enno Rehling <enno@eressea.de>
+-------------------+
This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/
#ifndef H_GC_XMLREPORT
#define H_GC_XMLREPORT
#ifdef __cplusplus
extern "C" {
#endif
#include <time.h>
extern void xmlreport_cleanup(void);
extern void register_xr(void);
extern int crwritemap(const char *filename);
#ifdef __cplusplus
}
#endif
#endif