static enum parser_error parse_r_s(struct parser *p) {
struct monster_race *r = parser_priv(p);
char *flags;
char *s;
int pct;
int ret = PARSE_ERROR_NONE;
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
flags = string_make(parser_getstr(p, "spells"));
s = strtok(flags, " |");
while (s) {
if (1 == sscanf(s, "1_IN_%d", &pct)) {
if (pct < 1 || pct > 100) {
ret = PARSE_ERROR_INVALID_SPELL_FREQ;
break;
}
r->freq_spell = 100 / pct;
r->freq_innate = r->freq_spell;
} else {
if (grab_flag(r->spell_flags, RSF_SIZE, r_info_spell_flags, s)) {
ret = PARSE_ERROR_INVALID_FLAG;
break;
}
}
s = strtok(NULL, " |");
}
/* Add the "base monster" flags to the monster */
if (r->base)
rsf_union(r->spell_flags, r->base->spell_flags);
mem_free(flags);
return ret;
}
static enum parser_error parse_r_d(struct parser *p) {
struct monster_race *r = parser_priv(p);
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
r->text = string_append(r->text, parser_getstr(p, "desc"));
return PARSE_ERROR_NONE;
}
static enum parser_error parse_vault_type(struct parser *p) {
struct vault *v = parser_priv(p);
if (!v)
return PARSE_ERROR_MISSING_RECORD_HEADER;
v->typ = string_make(parser_getstr(p, "type"));
return PARSE_ERROR_NONE;
}
static enum parser_error parse_rb_n(struct parser *p) {
struct monster_base *h = parser_priv(p);
struct monster_base *rb = mem_zalloc(sizeof *rb);
rb->next = h;
rb->name = string_make(parser_getstr(p, "name"));
parser_setpriv(p, rb);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_v_d(struct parser *p) {
struct vault *v = parser_priv(p);
if (!v)
return PARSE_ERROR_MISSING_RECORD_HEADER;
v->text = string_append(v->text, parser_getstr(p, "text"));
return PARSE_ERROR_NONE;
}
static enum parser_error parse_room_d(struct parser *p) {
struct room_template *t = parser_priv(p);
if (!t)
return PARSE_ERROR_MISSING_RECORD_HEADER;
t->text = string_append(t->text, parser_getstr(p, "text"));
return PARSE_ERROR_NONE;
}
static enum parser_error helper_str0(struct parser *p) {
const char *s = parser_getstr(p, "s0");
int *wasok = parser_priv(p);
if (!s || strcmp(s, "foo:bar:baz quxx..."))
return PARSE_ERROR_GENERIC;
*wasok = 1;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_graf_p(struct parser *p) {
graphics_mode *mode = parser_priv(p);
if (!mode) {
return PARSE_ERROR_INVALID_VALUE;
}
strncpy(mode->pref, parser_getstr(p, "prefname"), 32);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_summon_name(struct parser *p) {
struct summon *h = parser_priv(p);
struct summon *s = mem_zalloc(sizeof *s);
s->next = h;
parser_setpriv(p, s);
s->name = string_make(parser_getstr(p, "name"));
return PARSE_ERROR_NONE;
}
/* Parsing functions for monster.txt */
static enum parser_error parse_r_n(struct parser *p) {
struct monster_race *h = parser_priv(p);
struct monster_race *r = mem_zalloc(sizeof *r);
r->next = h;
r->ridx = parser_getuint(p, "index");
r->name = string_make(parser_getstr(p, "name"));
parser_setpriv(p, r);
return PARSE_ERROR_NONE;
}
/**
* Parsing functions for vault.txt
*/
static enum parser_error parse_vault_name(struct parser *p) {
struct vault *h = parser_priv(p);
struct vault *v = mem_zalloc(sizeof *v);
v->name = string_make(parser_getstr(p, "name"));
v->next = h;
parser_setpriv(p, v);
return PARSE_ERROR_NONE;
}
/**
* Parsing functions for room_template.txt
*/
static enum parser_error parse_room_name(struct parser *p) {
struct room_template *h = parser_priv(p);
struct room_template *t = mem_zalloc(sizeof *t);
t->name = string_make(parser_getstr(p, "name"));
t->next = h;
parser_setpriv(p, t);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_graf_i(struct parser *p) {
graphics_mode *mode = parser_priv(p);
if (!mode) {
return PARSE_ERROR_INVALID_VALUE;
}
mode->cell_width = parser_getuint(p, "wid");
mode->cell_height = parser_getuint(p, "hgt");
strncpy(mode->file, parser_getstr(p, "filename"), 32);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_y(struct parser *p)
{
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass) return PARSE_ERROR_NONE;
option_set(parser_getstr(p, "option"), TRUE);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_x(struct parser *p)
{
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass) return PARSE_ERROR_NONE;
/* XXX check for valid option */
option_set(parser_getstr(p, "option"), FALSE);
return PARSE_ERROR_NONE;
}
/**
* Parsing functions for quest.txt
*/
static enum parser_error parse_quest_name(struct parser *p) {
const char *name = parser_getstr(p, "name");
struct quest *h = parser_priv(p);
struct quest *q = mem_zalloc(sizeof(*q));
q->next = h;
parser_setpriv(p, q);
q->name = string_make(name);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_quest_race(struct parser *p) {
struct quest *q = parser_priv(p);
const char *name = parser_getstr(p, "race");
assert(q);
q->race = lookup_monster(name);
if (!q->race)
return PARSE_ERROR_INVALID_MONSTER;
return PARSE_ERROR_NONE;
}
static enum parser_error helper_char1(struct parser *p) {
char c0 = parser_getchar(p, "c0");
char c1 = parser_getchar(p, "c1");
int i0 = parser_getint(p, "i0");
const char *s = parser_getstr(p, "s");
int *wasok = parser_priv(p);
if (c0 != ':' || c1 != ':' || i0 != 34 || !streq(s, "lala"))
return PARSE_ERROR_GENERIC;
*wasok = 1;
return PARSE_ERROR_NONE;
}
/**
* Load another file.
*/
static enum parser_error parse_prefs_load(struct parser *p)
{
struct prefs_data *d = parser_priv(p);
const char *file;
assert(d != NULL);
if (d->bypass) return PARSE_ERROR_NONE;
file = parser_getstr(p, "file");
(void)process_pref_file(file, TRUE, d->user);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_buy(struct parser *p) {
struct store *s = parser_priv(p);
struct object_buy *buy;
if (!s)
return PARSE_ERROR_MISSING_RECORD_HEADER;
buy = mem_zalloc(sizeof(*buy));
buy->tval = tval_find_idx(parser_getstr(p, "base"));
buy->next = s->buy;
s->buy = buy;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_a(struct parser *p)
{
const char *act;
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass) return PARSE_ERROR_NONE;
act = parser_getstr(p, "act");
keypress_from_text(d->keymap_buffer, N_ELEMENTS(d->keymap_buffer), act);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_vault_d(struct parser *p) {
struct vault *v = parser_priv(p);
const char *desc;
if (!v)
return PARSE_ERROR_MISSING_RECORD_HEADER;
desc = parser_getstr(p, "text");
if (strlen(desc) != v->wid)
return PARSE_ERROR_VAULT_DESC_WRONG_LENGTH;
else
v->text = string_append(v->text, desc);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_store(struct parser *p) {
struct store *h = parser_priv(p);
struct store *s;
unsigned int idx = parser_getuint(p, "index") - 1;
if (idx >= MAX_STORES)
return PARSE_ERROR_OUT_OF_BOUNDS;
s = store_new(parser_getuint(p, "index") - 1);
s->name = string_make(parser_getstr(p, "name"));
s->next = h;
parser_setpriv(p, s);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_b(struct parser *p)
{
int idx;
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass) return PARSE_ERROR_NONE;
idx = parser_getuint(p, "idx");
if (idx > z_info->k_max)
return PARSE_ERROR_OUT_OF_BOUNDS;
add_autoinscription(idx, parser_getstr(p, "text"));
return PARSE_ERROR_NONE;
}
static enum parser_error parse_owner(struct parser *p) {
struct store *s = parser_priv(p);
unsigned int maxcost = parser_getuint(p, "purse");
char *name = string_make(parser_getstr(p, "name"));
struct owner *o;
if (!s)
return PARSE_ERROR_MISSING_RECORD_HEADER;
o = mem_zalloc(sizeof *o);
o->oidx = (s->owners ? s->owners->oidx + 1 : 0);
o->next = s->owners;
o->name = name;
o->max_cost = maxcost;
s->owners = o;
return PARSE_ERROR_NONE;
}
/**
* Parsing functions for dungeon_profile.txt
*/
static enum parser_error parse_profile_name(struct parser *p) {
struct cave_profile *h = parser_priv(p);
struct cave_profile *c = mem_zalloc(sizeof *c);
size_t i;
c->name = string_make(parser_getstr(p, "name"));
for (i = 0; i < N_ELEMENTS(cave_builders); i++)
if (streq(c->name, cave_builders[i].name))
break;
if (i == N_ELEMENTS(cave_builders))
return PARSE_ERROR_NO_BUILDER_FOUND;
c->builder = cave_builders[i].builder;
c->next = h;
parser_setpriv(p, c);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_r_friends(struct parser *p) {
struct monster_race *r = parser_priv(p);
struct monster_friends *f;
struct random number;
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
f = mem_zalloc(sizeof *f);
number = parser_getrand(p, "number");
f->number_dice = number.dice;
f->number_side = number.sides;
f->percent_chance = parser_getuint(p, "chance");
f->name = string_make(parser_getstr(p, "name"));
f->next = r->friends;
r->friends = f;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_r_plural(struct parser *p)
{
struct monster_race *r = parser_priv(p);
if (r == NULL)
return PARSE_ERROR_MISSING_RECORD_HEADER;
if (parser_hasval(p, "plural")) {
const char *plural = parser_getstr(p, "plural");
if (strlen(plural) > 0)
r->plural = string_make(plural);
else
r->plural = NULL;
}
return PARSE_ERROR_NONE;
}
static enum parser_error parse_graf_n(struct parser *p) {
graphics_mode *list = parser_priv(p);
graphics_mode *mode = mem_zalloc(sizeof(graphics_mode));
if (!mode) {
return PARSE_ERROR_OUT_OF_MEMORY;
}
mode->pNext = list;
mode->grafID = parser_getuint(p, "index");
strncpy(mode->menuname, parser_getstr(p, "menuname"), 32);
mode->alphablend = 0;
mode->overdrawRow = 0;
mode->overdrawMax = 0;
strncpy(mode->file, "", 32);
strncpy(mode->pref, "none", 32);
parser_setpriv(p, mode);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_buy_flag(struct parser *p) {
struct store *s = parser_priv(p);
struct object_buy *buy;
char *t;
int flag;
if (!s)
return PARSE_ERROR_MISSING_RECORD_HEADER;
buy = mem_zalloc(sizeof(*buy));
t = string_make(parser_getsym(p, "flag"));
flag = lookup_flag(obj_flags, t);
if (flag == FLAG_END)
return PARSE_ERROR_INVALID_FLAG;
buy->flag = flag;
buy->tval = tval_find_idx(parser_getstr(p, "base"));
buy->next = s->buy;
s->buy = buy;
return PARSE_ERROR_NONE;
}
