/* More angband-specific bits of the parser
* These require hooks into other parts of the code, and are a candidate for
* moving elsewhere.
*/
static void print_error(Parser p)
{
throw new NotImplementedException();
//struct parser_state s;
//parser_getstate(p, &s);
//msg("Parse error in %s line %d column %d: %s: %s", fp.name,
// s.line, s.col, s.msg, parser_error_str[s.error]);
//message_flush();
//quit_fmt("Parse error in %s line %d column %d.", fp.name, s.line, s.col);
}
public static Parser init_parse_rb()
{
Parser p = new Parser();
p.priv = null;
p.Register("V sym version", Parser.Ignored);
p.Register("N str name", parse_rb_n);
p.Register("G char glyph", parse_rb_g);
p.Register("M uint pain", parse_rb_m);
p.Register("F ?str flags", parse_rb_f);
p.Register("S ?str spells", parse_rb_s);
p.Register("D str desc", parse_rb_d);
return p;
}
static Parser store_owner_parser_new(Store stores)
{
Parser p = new Parser();
owner_parser_state s = new owner_parser_state();
s.stores = stores;
s.cur = null;
p.priv = s;
p.Register("V sym version", Parser.Ignored);
p.Register("N uint index", parse_own_n);
p.Register("S uint maxcost str name", parse_own_s);
return p;
}
static Parser.Error parse_own_s(Parser p)
{
owner_parser_state s = p.priv as owner_parser_state;
uint maxcost = p.getuint("maxcost");
string name = p.getstr("name");
Owner o;
if (s.cur == null)
return Parser.Error.MISSING_RECORD_HEADER;
o = new Owner();
o.oidx = (s.cur.owners != null ? s.cur.owners.oidx + 1 : 0);
o.next = s.cur.owners;
o.name = name;
o.max_cost = (int)maxcost;
s.cur.owners = o;
return Parser.Error.NONE;
}
static Parser.Error parse_i(Parser p)
{
Store s = p.priv as Store;
uint slots = p.getuint("slots");
int tval = TVal.find_idx(p.getsym("tval"));
int sval = SVal.lookup_sval(tval, p.getsym("sval"));
Object_Kind kind = Object_Kind.lookup_kind(tval, sval);
if(kind == null)
return Parser.Error.UNRECOGNISED_SVAL;
if(s.table_num + slots > s.table_size)
return Parser.Error.TOO_MANY_ENTRIES;
while(slots-- != 0) {
s.table[s.table_num++] = kind;
}
/* XXX: get rid of this table_size/table_num/indexing thing. It's
* stupid. Dynamically allocate. */
return Parser.Error.NONE;
}
/* Parsing functions for pclass.txt */
public static Parser.Error parse_c_n(Parser p)
{
Player_Class h = p.priv as Player_Class;
Player_Class c = new Player_Class();
c.cidx = p.getuint("index");
c.Name = p.getstr("name");
c.next = h;
p.priv = c;
return Parser.Error.NONE;
}
public static Parser.Error parse_c_i(Parser p)
{
Player_Class c = p.priv as Player_Class;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
c.c_mhp = (short)p.getint("mhp");
c.c_exp = (short)p.getint("exp");
c.sense_base = (uint)p.getint("sense-base");
c.sense_div = (ushort)p.getint("sense-div");
return Parser.Error.NONE;
}
public static Parser.Error parse_c_e(Parser p)
{
Player_Class c = p.priv as Player_Class;
Start_Item si;
int tval, sval;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
tval = TVal.find_idx(p.getsym("tval"));
if (tval < 0)
return Parser.Error.UNRECOGNISED_TVAL;
sval = SVal.lookup_sval(tval, p.getsym("sval"));
if (sval < 0)
return Parser.Error.UNRECOGNISED_SVAL;
si = new Start_Item();
si.kind = Object_Kind.objkind_get(tval, sval);
si.min = (byte)p.getuint("min");
si.max = (byte)p.getuint("max");
if (si.min > 99 || si.max > 99) {
//mem_free(si.kind);
return Parser.Error.INVALID_ITEM_NUMBER;
}
si.next = c.start_items;
c.start_items = si;
return Parser.Error.NONE;
}
public static Parser.Error parse_a_f(Parser p)
{
Artifact a = p.priv as Artifact;
Misc.assert(a != null);
if (!p.hasval("flags"))
return Parser.Error.NONE;
string s = p.getstr("flags");
return grab_flag_helper(s, a.flags);
/*t = strtok(s, " |");
while (t) {
if (grab_flag(a.flags, OF_SIZE, k_info_flags, t))
break;
t = strtok(null, " |");
}
mem_free(s);
return t ? Parser.Error.INVALID_FLAG : Parser.Error.NONE;*/
}
public static Parser.Error parse_a_e(Parser p)
{
Artifact a = p.priv as Artifact;
Misc.assert(a != null);
a.effect = grab_one_effect(p.getsym("name"));
a.time = p.getrand("time");
if (a.effect == null)
return Parser.Error.GENERIC;
return Parser.Error.NONE;
}
public static Parser.Error parse_a_d(Parser p)
{
Artifact a = p.priv as Artifact;
Misc.assert(a != null);
a.Text = a.Text + p.getstr("text");
return Parser.Error.NONE;
}
public static Parser.Error parse_a_a(Parser p)
{
Artifact a = p.priv as Artifact;
string tmp = p.getstr("minmax");
int amin, amax;
Misc.assert(a != null);
a.alloc_prob = (byte)p.getint("common");
string[] tokens = tmp.Split(new string[] { " to " }, StringSplitOptions.RemoveEmptyEntries);
if(tokens.Length != 2)
return Parser.Error.GENERIC;
if(!int.TryParse(tokens[0], out amin) || !int.TryParse(tokens[1], out amax))
return Parser.Error.GENERIC;
if (amin > 255 || amax > 255 || amin < 0 || amax < 0)
return Parser.Error.OUT_OF_BOUNDS;
a.alloc_min = (byte)amin;
a.alloc_max = (byte)amax;
return Parser.Error.NONE;
}
public static Parser init_parse_z()
{
Maxima z = new Maxima();
Parser p = new Parser();
p.priv = z;
p.Register("V sym version", Parser.Ignored);
p.Register("M sym label int value", parse_z);
return p;
}
public static Parser init_parse_v()
{
Parser p = new Parser();
p.priv = null;
p.Register("V sym version", Parser.Ignored);
p.Register("N uint index str name", parse_v_n);
p.Register("X uint type int rating uint height uint width", parse_v_x);
p.Register("D str text", parse_v_d);
return p;
}
public static Parser init_parse_s()
{
Parser p = new Parser();
p.priv = null;
p.Register("V sym version", Parser.Ignored);
p.Register("N uint index str name", parse_s_n);
p.Register("I uint tval uint sval uint snum", parse_s_i);
p.Register("D str desc", parse_s_d);
return p;
}
public static Parser.Error parse_c_b(Parser p)
{
Player_Class c = p.priv as Player_Class;
uint spell;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
spell = p.getuint("spell");
if (spell >= Misc.PY_MAX_SPELLS)
return Parser.Error.OUT_OF_BOUNDS;
c.spells.info[spell] = new Magic_Type();
c.spells.info[spell].slevel = (byte)p.getint("level");
c.spells.info[spell].smana = (byte)p.getint("mana");
c.spells.info[spell].sfail = (byte)p.getint("fail");
c.spells.info[spell].sexp = (byte)p.getint("exp");
return Parser.Error.NONE;
}
public static Parser.Error parse_c_c(Parser p)
{
Player_Class c = p.priv as Player_Class;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
c.c_skills[(int)Skill.DISARM] = (short)p.getint("dis");
c.c_skills[(int)Skill.DEVICE] = (short)p.getint("dev");
c.c_skills[(int)Skill.SAVE] = (short)p.getint("sav");
c.c_skills[(int)Skill.STEALTH] = (short)p.getint("stl");
c.c_skills[(int)Skill.SEARCH] = (short)p.getint("srh");
c.c_skills[(int)Skill.SEARCH_FREQUENCY] = (short)p.getint("fos");
c.c_skills[(int)Skill.TO_HIT_MELEE] = (short)p.getint("thm");
c.c_skills[(int)Skill.TO_HIT_BOW] = (short)p.getint("thb");
c.c_skills[(int)Skill.TO_HIT_THROW] = (short)p.getint("throw");
c.c_skills[(int)Skill.DIGGING] = (short)p.getint("dig");
return Parser.Error.NONE;
}
public static Parser.Error parse_a_i(Parser p)
{
Artifact a = p.priv as Artifact;
Misc.assert(a != null);
int tval = TVal.find_idx(p.getsym("tval"));
if (tval < 0)
return Parser.Error.UNRECOGNISED_TVAL;
a.tval = (byte)tval;
int sval = SVal.lookup_sval(a.tval, p.getsym("sval"));
if (sval < 0)
return Parser.Error.UNRECOGNISED_SVAL;
a.sval = (byte)sval;
return Parser.Error.NONE;
}
public static Parser.Error parse_c_f(Parser p)
{
Player_Class c = p.priv as Player_Class;
string flags;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
if (!p.hasval("flags"))
return Parser.Error.NONE;
flags = p.getstr("flags");
return grab_flag_helper5(flags, c.pflags);
/*s = strtok(flags, " |");
while (s) {
if (grab_flag(c.pflags, PF_SIZE, player_info_flags, s))
break;
s = strtok(null, " |");
}
mem_free(flags);
return s ? Parser.Error.INVALID_FLAG : Parser.Error.NONE;*/
}
public static Parser.Error parse_a_l(Parser p)
{
Artifact a = p.priv as Artifact;
string s;
Misc.assert(a != null);
a.pval[a.num_pvals] = (short)p.getint("pval");
if (!p.hasval("flags"))
return Parser.Error.MISSING_FIELD;
s = p.getstr("flags");
return grab_flag_helper3(s, a);
//t = strtok(s, " |");
//while (t) {
// if (grab_flag(a.flags, OF_SIZE, k_info_flags, t) ||
// grab_flag(a.pval_flags[a.num_pvals], OF_SIZE, k_info_flags, t))
// break;
// t = strtok(null, " |");
//}
//a.num_pvals++;
//if (a.num_pvals > MAX_PVALS)
// return Parser.Error.TOO_MANY_ENTRIES;
//mem_free(s);
//return t ? Parser.Error.INVALID_FLAG : Parser.Error.NONE;
}
public static Parser.Error parse_c_m(Parser p)
{
Player_Class c = p.priv as Player_Class;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
c.spell_book = (byte)p.getuint("book");
c.spell_stat = (ushort)p.getuint("stat");
c.spell_first = (ushort)p.getuint("first");
c.spell_weight = (ushort)p.getuint("weight");
return Parser.Error.NONE;
}
public static Parser.Error parse_a_m(Parser p)
{
Artifact a = p.priv as Artifact;
Misc.assert(a != null);
a.effect_msg = a.effect_msg + p.getstr("text");
return Parser.Error.NONE;
}
public static Parser.Error parse_c_s(Parser p)
{
Player_Class c = p.priv as Player_Class;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
c.c_adj[(int)Stat.Str] = (short)p.getint("str");
c.c_adj[(int)Stat.Int] = (short)p.getint("int");
c.c_adj[(int)Stat.Wis] = (short)p.getint("wis");
c.c_adj[(int)Stat.Dex] = (short)p.getint("dex");
c.c_adj[(int)Stat.Con] = (short)p.getint("con");
c.c_adj[(int)Stat.Chr] = (short)p.getint("chr");
return Parser.Error.NONE;
}
/* Parsing functions for artifact.txt */
public static Parser.Error parse_a_n(Parser p)
{
Bitflag f = new Bitflag(Object_Flag.SIZE);
int idx = p.getint("index");
string name = p.getstr("name");
Artifact h = p.priv as Artifact;
Artifact a = new Artifact();
a.Next = h;
p.priv = a;
a.aidx = (byte)idx;
a.Name = name;
/* Ignore all elements */
Object_Flag.create_mask(f, false, Object_Flag.object_flag_type.IGNORE);
a.flags.union(f);
return Parser.Error.NONE;
}
static Parser.Error parse_own_n(Parser p)
{
owner_parser_state s = p.priv as owner_parser_state;
uint index = p.getuint("index");
Store st;
for (st = s.stores; st != null ; st = st.next) {
if (st.sidx == (STORE)index) {
s.cur = st;
break;
}
}
return st != null ? Parser.Error.NONE : Parser.Error.OUT_OF_BOUNDS;
}
public static Parser.Error parse_a_p(Parser p)
{
Artifact a = p.priv as Artifact;
random_value hd = p.getrand("hd");
Misc.assert(a != null);
a.ac = (short)p.getint("ac");
a.dd = (byte)hd.dice;
a.ds = (byte)hd.sides;
a.to_h = (short)p.getint("to-h");
a.to_d = (short)p.getint("to-d");
a.to_a = (short)p.getint("to-a");
return Parser.Error.NONE;
}
static Parser.Error parse_s(Parser p)
{
Store h = p.priv as Store;
Store s;
uint idx = p.getuint("index") - 1;
uint slots = p.getuint("slots");
if(idx < (uint)STORE.ARMOR || idx > (uint)STORE.MAGIC)
return Parser.Error.OUT_OF_BOUNDS;
s = new Store((STORE)(p.getuint("index") - 1));
s.table = new Object_Kind[slots];
s.table_size = slots;
s.next = h;
p.priv = s;
return Parser.Error.NONE;
}
public static Parser.Error parse_a_w(Parser p)
{
Artifact a = p.priv as Artifact;
Misc.assert(a != null);
a.level = (byte)p.getint("level");
a.rarity = (byte)p.getint("rarity");
a.weight = (byte)p.getint("weight");
a.cost = p.getint("cost");
return Parser.Error.NONE;
}
public static Parser store_parser_new()
{
Parser p = new Parser();
p.priv = null;
p.Register("S uint index uint slots", parse_s);
p.Register("I uint slots sym tval sym sval", parse_i);
return p;
}
public static Parser.Error parse_c_a(Parser p)
{
Player_Class c = p.priv as Player_Class;
if (c == null)
return Parser.Error.MISSING_RECORD_HEADER;
c.max_attacks = (ushort)p.getint("max-attacks");
c.min_weight = (ushort)p.getint("min-weight");
c.att_multiply = (ushort)p.getint("att-multiply");
return Parser.Error.NONE;
}
