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;
}
errr register_sound_pref_parser(struct parser *p)
{
#ifdef SOUND
return parser_reg(p, SOUND_PRF_FORMAT, parse_prefs_sound);
#else
return parser_reg(p, SOUND_PRF_FORMAT, parse_prefs_dummy);
#endif
}
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 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;
}
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_uint1(void *state) {
errr r = parser_reg(state, "test-uint1 uint u0", ignored);
enum parser_error e = parser_parse(state, "test-uint1:-2");
eq(r, 0);
eq(e, PARSE_ERROR_NOT_NUMBER);
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_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_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_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_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_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_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;
}
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;
}
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_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;
}
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;
}
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;
}
int test_syntax2(void *state) {
struct parser_state s;
int v;
errr r = parser_reg(state, "test-syntax2 int i0 sym s1", ignored);
eq(r, 0);
r = parser_parse(state, "test-syntax2::test");
eq(r, PARSE_ERROR_NOT_NUMBER);
v = parser_getstate(state, &s);
require(v);
eq(s.line, 7);
eq(s.col, 2);
ok;
}
int test_syntax0(void *state) {
struct parser_state s;
int v;
errr r = parser_reg(state, "test-syntax0 str s0", ignored);
eq(r, 0);
r = parser_parse(state, "test-syntax0");
eq(r, PARSE_ERROR_MISSING_FIELD);
v = parser_getstate(state, &s);
require(v);
eq(s.line, 5);
eq(s.col, 2);
ok;
}
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;
}
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;
}
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;
}
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;
}
static struct parser *init_parse_prefs(bool user)
{
struct parser *p = parser_new();
struct prefs_data *pd = mem_zalloc(sizeof *pd);
int i;
parser_setpriv(p, pd);
pd->user = user;
for (i = 0; i < ANGBAND_TERM_MAX; i++) {
pd->loaded_window_flag[i] = FALSE;
}
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, "N uint idx int attr int char", parse_prefs_n);
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 sym 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;
}
int test_reg_str(void *state) {
errr r = parser_reg(state, "test-reg-str str baz", ignored);
eq(r, 0);
ok;
}
int test_reg_sym(void *state) {
errr r = parser_reg(state, "test-reg-sym sym bar", ignored);
eq(r, 0);
ok;
}
int test_reg_int(void *state) {
errr r = parser_reg(state, "test-reg-int int foo", ignored);
eq(r, 0);
ok;
}
int test_reg5(void *state) {
errr r = parser_reg(state, "abc str foo int bar", ignored);
eq(r, -EINVAL);
ok;
}
