static struct parser *init_parse_prefs(void)
{
struct parser *p = parser_new();
parser_setpriv(p, mem_zalloc(sizeof(struct prefs_data)));
parser_reg(p, "% str file", parse_prefs_load);
parser_reg(p, "? str expr", parse_prefs_expr);
parser_reg(p, "K sym tval sym sval int attr int char", parse_prefs_k);
parser_reg(p, "R uint idx int attr int char", parse_prefs_r);
parser_reg(p, "F uint idx sym lighting int attr int char", parse_prefs_f);
parser_reg(p, "GF sym type sym direction uint attr uint char", parse_prefs_gf);
parser_reg(p, "L uint idx int attr int char", parse_prefs_l);
parser_reg(p, "E sym tval int attr", parse_prefs_e);
parser_reg(p, "Q sym idx sym n ?sym sval ?sym flag", parse_prefs_q);
/* XXX should be split into two kinds of line */
parser_reg(p, "B uint idx str text", parse_prefs_b);
/* XXX idx should be {tval,sval} pair! */
parser_reg(p, "A str act", parse_prefs_a);
parser_reg(p, "C int mode str key", parse_prefs_c);
parser_reg(p, "M int type sym attr", parse_prefs_m);
parser_reg(p, "V uint idx int k int r int g int b", parse_prefs_v);
parser_reg(p, "W int window uint flag uint value", parse_prefs_w);
parser_reg(p, "X str option", parse_prefs_x);
parser_reg(p, "Y str option", parse_prefs_y);
return p;
}
errr finish_parse_grafmode(struct parser *p) {
graphics_mode *mode, *n;
int max = 0;
int count = 0;
int i;
/* see how many graphics modes we have and what the highest index is */
if (p) {
mode = parser_priv(p);
while (mode) {
if (mode->grafID > max) {
max = mode->grafID;
}
count++;
mode = mode->pNext;
}
}
/* copy the loaded modes to the global variable */
if (graphics_modes) {
close_graphics_modes();
}
graphics_modes = mem_zalloc(sizeof(graphics_mode) * (count+1));
if (p) {
mode = parser_priv(p);
for (i = count-1; i >= 0; i--, mode = mode->pNext) {
memcpy(&(graphics_modes[i]), mode, sizeof(graphics_mode));
graphics_modes[i].pNext = &(graphics_modes[i+1]);
}
}
/* hardcode the no graphics option */
graphics_modes[count].pNext = NULL;
graphics_modes[count].grafID = GRAPHICS_NONE;
graphics_modes[count].alphablend = 0;
graphics_modes[count].overdrawRow = 0;
graphics_modes[count].overdrawMax = 0;
strncpy(graphics_modes[count].pref, "none", 8);
strncpy(graphics_modes[count].file, "", 32);
strncpy(graphics_modes[count].menuname, "None", 32);
graphics_mode_high_id = max;
/* set the default graphics mode to be no graphics */
current_graphics_mode = &(graphics_modes[count]);
if (p) {
mode = parser_priv(p);
while (mode) {
n = mode->pNext;
mem_free(mode);
mode = n;
}
parser_setpriv(p, NULL);
parser_destroy(p);
}
return PARSE_ERROR_NONE;
}
struct parser *init_parse_v(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "N uint index str name", parse_v_n);
parser_reg(p, "X uint type int rating uint height uint width uint min_lev uint max_lev", parse_v_x);
parser_reg(p, "D str text", parse_v_d);
return p;
}
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;
}
/**
* 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;
}
/* 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;
}
struct parser *init_parse_quest(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "name str name", parse_quest_name);
parser_reg(p, "level uint level", parse_quest_level);
parser_reg(p, "race str race", parse_quest_race);
parser_reg(p, "number uint number", parse_quest_number);
return p;
}
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;
}
static struct parser *init_parse_room(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "V sym version", ignored);
parser_reg(p, "N uint index str name", parse_room_n);
parser_reg(p, "X uint type int rating uint height uint width uint doors uint tval", parse_room_x);
parser_reg(p, "D str text", parse_room_d);
return p;
}
/**
* 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;
}
int test_rand0(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-rand0 rand r0", helper_rand0);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-rand0:2d3");
eq(r, 0);
eq(wasok, 1);
ok;
}
int test_int0(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-int0 int i0 int i1", helper_int0);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-int0:42:81");
eq(r, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
int test_rand1(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-rand1 rand r0 rand r1", helper_rand1);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-rand1:2d3:4d5");
eq(r, 0);
eq(wasok, 1);
ok;
}
int test_sym1(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-sym1 sym foo sym baz", helper_sym1);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-sym1:bar:quxx");
eq(r, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
int test_sym0(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-sym0 sym foo", helper_sym0);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-sym0:bar");
eq(r, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
int test_int1(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-int1 int i0", helper_int1);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-int1:-3");
eq(r, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
int test_str0(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-str0 str s0", helper_str0);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-str0:foo:bar:baz quxx...");
eq(r, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
int test_char1(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-char1 char c0 int i0 char c1 str s", helper_char1);
enum parser_error e;
eq(r, 0);
parser_setpriv(state, &wasok);
e = parser_parse(state, "test-char1:::34:::lala");
eq(e, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
/**
* 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;
}
int test_char0(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-char0 char c", helper_char0);
enum parser_error e;
eq(r, 0);
parser_setpriv(state, &wasok);
e = parser_parse(state, "test-char0:C");
eq(e, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
static struct parser *init_parse_profile(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "name str name", parse_profile_name);
parser_reg(p, "params int block int rooms int unusual int rarity", parse_profile_params);
parser_reg(p, "tunnel int rnd int chg int con int pen int jct", parse_profile_tunnel);
parser_reg(p, "streamer int den int rng int mag int mc int qua int qc", parse_profile_streamer);
parser_reg(p, "room sym name int height int width int level int pit int rarity int cutoff", parse_profile_room);
parser_reg(p, "cutoff int cutoff", parse_profile_cutoff);
return p;
}
static struct parser *init_parse_grafmode(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "V sym version", ignored);
parser_reg(p, "N uint index str menuname", parse_graf_n);
parser_reg(p, "I uint wid uint hgt str filename", parse_graf_i);
parser_reg(p, "P str prefname", parse_graf_p);
parser_reg(p, "X uint alpha uint row uint max", parse_graf_x);
return p;
}
int test_uint0(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-uint0 uint u0", helper_uint0);
enum parser_error e;
eq(r, 0);
parser_setpriv(state, &wasok);
e = parser_parse(state, "test-uint0:42");
eq(e, PARSE_ERROR_NONE);
eq(wasok, 1);
ok;
}
struct parser *init_parse_summon(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "name str name", parse_summon_name);
parser_reg(p, "msgt sym type", parse_summon_message_type);
parser_reg(p, "uniques int allowed", parse_summon_unique);
parser_reg(p, "base sym base", parse_summon_base);
parser_reg(p, "race-flag sym flag", parse_summon_race_flag);
parser_reg(p, "fallback str fallback", parse_summon_fallback);
parser_reg(p, "desc str desc", parse_summon_desc);
return p;
}
struct parser *init_parse_rb(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "V sym version", ignored);
parser_reg(p, "N str name", parse_rb_n);
parser_reg(p, "G char glyph", parse_rb_g);
parser_reg(p, "M uint pain", parse_rb_m);
parser_reg(p, "F ?str flags", parse_rb_f);
parser_reg(p, "S ?str spells", parse_rb_s);
parser_reg(p, "D str desc", parse_rb_d);
return p;
}
static struct parser *init_parse_room(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "name str name", parse_room_name);
parser_reg(p, "type uint type", parse_room_type);
parser_reg(p, "rating int rating", parse_room_rating);
parser_reg(p, "rows uint height", parse_room_height);
parser_reg(p, "columns uint width", parse_room_width);
parser_reg(p, "doors uint doors", parse_room_doors);
parser_reg(p, "tval sym tval", parse_room_tval);
parser_reg(p, "D str text", parse_room_d);
return p;
}
struct parser *init_parse_vault(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "name str name", parse_vault_name);
parser_reg(p, "type str type", parse_vault_type);
parser_reg(p, "rating int rating", parse_vault_rating);
parser_reg(p, "rows uint height", parse_vault_rows);
parser_reg(p, "columns uint width", parse_vault_columns);
parser_reg(p, "min-depth uint min_lev", parse_vault_min_depth);
parser_reg(p, "max-depth uint max_lev", parse_vault_max_depth);
parser_reg(p, "D str text", parse_vault_d);
return p;
}
struct parser *init_parse_stores(void) {
struct parser *p = parser_new();
parser_setpriv(p, NULL);
parser_reg(p, "store uint index str name", parse_store);
parser_reg(p, "owner uint purse str name", parse_owner);
parser_reg(p, "slots uint min uint max", parse_slots);
parser_reg(p, "turnover uint turnover", parse_turnover);
parser_reg(p, "normal sym tval sym sval", parse_normal);
parser_reg(p, "always sym tval sym sval", parse_always);
parser_reg(p, "buy str base", parse_buy);
parser_reg(p, "buy-flag sym flag str base", parse_buy_flag);
return p;
}
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;
}
int test_opt0(void *state) {
int wasok = 0;
errr r = parser_reg(state, "test-opt0 sym s0 ?sym s1", helper_opt0);
eq(r, 0);
parser_setpriv(state, &wasok);
r = parser_parse(state, "test-opt0:foo");
eq(r, 0);
eq(wasok, 1);
require(parser_hasval(state, "s0"));
require(!parser_hasval(state, "s1"));
r = parser_parse(state, "test-opt0:foo:bar");
eq(r, 0);
eq(wasok, 2);
require(parser_hasval(state, "s0"));
require(parser_hasval(state, "s1"));
ok;
}
