/* 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;
        }