root/trunk/src/files.c

/*
 * File: files.c
 * Purpose: Various file-related activities, poorly organised
 *
 * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
 *
 * This work is free software; you can redistribute it and/or modify it
 * under the terms of either:
 *
 * a) the GNU General Public License as published by the Free Software
 *    Foundation, version 2, or
 *
 * b) the "Angband licence":
 *    This software may be copied and distributed for educational, research,
 *    and not for profit purposes provided that this copyright and statement
 *    are included in all such copies.  Other copyrights may also apply.
 */
#include "angband.h"
#include "tvalsval.h"
#include "ui-menu.h"
#include "cmds.h"
#include "option.h"

#define MAX_PANEL 12


#if 0

/*
 * Use this (perhaps) for Angband 2.8.4
 *
 * Extract "tokens" from a buffer
 *
 * This function uses "whitespace" as delimiters, and treats any amount of
 * whitespace as a single delimiter.  We will never return any empty tokens.
 * When given an empty buffer, or a buffer containing only "whitespace", we
 * will return no tokens.  We will never extract more than "num" tokens.
 *
 * By running a token through the "text_to_ascii()" function, you can allow
 * that token to include (encoded) whitespace, using "\s" to encode spaces.
 *
 * We save pointers to the tokens in "tokens", and return the number found.
 */
static s16b tokenize_whitespace(char *buf, s16b num, char **tokens)
{
        int k = 0;

        char *s = buf;


        /* Process */
        while (k < num)
        {
                char *t;

                /* Skip leading whitespace */
                for ( ; *s && isspace((unsigned char)*s); ++s) /* loop */;

                /* All done */
                if (!*s) break;

                /* Find next whitespace, if any */
                for (t = s; *t && !isspace((unsigned char)*t); ++t) /* loop */;

                /* Nuke and advance (if necessary) */
                if (*t) *t++ = '\0';

                /* Save the token */
                tokens[k++] = s;

                /* Advance */
                s = t;
        }

        /* Count */
        return (k);
}

#endif


/*
 * Extract the first few "tokens" from a buffer
 *
 * This function uses "colon" and "slash" as the delimeter characters.
 *
 * We never extract more than "num" tokens.  The "last" token may include
 * "delimeter" characters, allowing the buffer to include a "string" token.
 *
 * We save pointers to the tokens in "tokens", and return the number found.
 *
 * Hack -- Attempt to handle the 'c' character formalism
 *
 * Hack -- An empty buffer, or a final delimeter, yields an "empty" token.
 *
 * Hack -- We will always extract at least one token
 */
s16b tokenize(char *buf, s16b num, char **tokens)
{
        int i = 0;

        char *s = buf;


        /* Process */
        while (i < num - 1)
        {
                char *t;

                /* Scan the string */
                for (t = s; *t; t++)
                {
                        /* Allow pseudo-escaping */
                        if (*t == '\\') t++;

                        /* Found a delimiter */
                        else if (*t == ':') break;
                }

                /* Nothing left */
                if (!*t) break;

                /* Nuke and advance */
                *t++ = '\0';

                /* Save the token */
                tokens[i++] = s;

                /* Advance */
                s = t;
        }

        /* Save the token */
        tokens[i++] = s;

        /* Number found */
        return (i);
}



/*
 * Parse a sub-file of the "extra info" (format shown below)
 *
 * Each "action" line has an "action symbol" in the first column,
 * followed by a colon, followed by some command specific info,
 * usually in the form of "tokens" separated by colons or slashes.
 *
 * Blank lines, lines starting with white space, and lines starting
 * with pound signs ("#") are ignored (as comments).
 *
 * Note the use of "tokenize()" to allow the use of both colons and
 * slashes as delimeters, while still allowing final tokens which
 * may contain any characters including "delimiters".
 *
 * Note the use of "strtol()" to allow all "integers" to be encoded
 * in decimal, hexidecimal, or octal form.
 *
 * Note that "monster zero" is used for the "player" attr/char, "object
 * zero" will be used for the "stack" attr/char, and "feature zero" is
 * used for the "nothing" attr/char.
 *
 * Specify the attr/char values for "monsters" by race index.
 *   R:<num>:<a>/<c>
 *
 * Specify the attr/char values for "objects" by kind index.
 *   K:<num>:<a>/<c>
 *
 * Specify the attr/char values for "features" by feature index.
 *   F:<num>:<a>/<c>
 *
 * Specify the attr/char values for "special" things.
 *   S:<num>:<a>/<c>
 *
 * Specify the attribute values for inventory "objects" by kind tval.
 *   E:<tv>:<a>
 *
 * Define a macro action, given an encoded macro action.
 *   A:<str>
 *
 * Create a macro, given an encoded macro trigger.
 *   P:<str>
 *
 * Create a keymap, given an encoded keymap trigger.
 *   C:<num>:<str>
 *
 * Turn an option off, given its name.
 *   X:<str>
 *
 * Turn an option on, given its name.
 *   Y:<str>
 *
 * Turn a window flag on or off, given a window, flag, and value.
 *   W:<win>:<flag>:<value>
 *
 * Specify visual information, given an index, and some data.
 *   V:<num>:<kv>:<rv>:<gv>:<bv>
 *
 * Specify colors for message-types.
 *   M:<type>:<attr>
 *
 * Specify the attr/char values for "flavors" by flavors index.
 *   L:<num>:<a>/<c>
 */
errr process_pref_file_command(char *buf)
{
        long i, n1, n2, sq;

        char *zz[16];


        /* Skip "empty" lines */
        if (!buf[0]) return (0);

        /* Skip "blank" lines */
        if (isspace((unsigned char)buf[0])) return (0);

        /* Skip comments */
        if (buf[0] == '#') return (0);


        /* Paranoia */
        /* if (strlen(buf) >= 1024) return (1); */


        /* Require "?:*" format */
        if (buf[1] != ':') return (1);


        /* Process "R:<num>:<a>/<c>" -- attr/char for monster races */
        if (buf[0] == 'R')
        {
                if (tokenize(buf+2, 3, zz) == 3)
                {
                        monster_race *r_ptr;
                        i = strtol(zz[0], NULL, 0);
                        n1 = strtol(zz[1], NULL, 0);
                        n2 = strtol(zz[2], NULL, 0);
                        if ((i < 0) || (i >= (long)z_info->r_max)) return (1);
                        r_ptr = &r_info[i];
                        if (n1) r_ptr->x_attr = (byte)n1;
                        if (n2) r_ptr->x_char = (char)n2;
                        return (0);
                }
        }

        /* Process "B:<k_idx>:inscription */
        else if (buf[0] == 'B')
        {
                if (2 == tokenize(buf + 2, 2, zz))
                {
                        add_autoinscription(strtol(zz[0], NULL, 0), zz[1]);
                        return (0);
                }
        }

        /* Process "Q:<idx>:<tval>:<sval>:<y|n>"  -- squelch bits   */
        /* and     "Q:<idx>:<val>"                -- squelch levels */
        /* and     "Q:<val>"                      -- auto_destroy   */
        else if (buf[0] == 'Q')
        {
                i = tokenize(buf+2, 4, zz);
                if (i == 2)
                {
                        n1 = strtol(zz[0], NULL, 0);
                        n2 = strtol(zz[1], NULL, 0);
                        squelch_level[n1] = n2;
                        return(0);
                }
                else if (i == 4)
                {
                        i = strtol(zz[0], NULL, 0);
                        n1 = strtol(zz[1], NULL, 0);
                        n2 = strtol(zz[2], NULL, 0);
                        sq = strtol(zz[3], NULL, 0);
                        if ((k_info[i].tval == n1) && (k_info[i].sval == n2))
                        {
                                k_info[i].squelch = sq;
                                return(0);
                        }
                        else
                        {
                                for (i = 1; i < z_info->k_max; i++)
                                {
                                        if ((k_info[i].tval == n1) && (k_info[i].sval == n2))
                                        {
                                                k_info[i].squelch = sq;
                                                return(0);
                                        }
                                }
                        }
                }
        }

        /* Process "K:<tval>:<sval>:<a>/<c>"  -- attr/char for object kinds */
        else if (buf[0] == 'K')
        {
                if (tokenize(buf+2, 4, zz) == 4)
                {
                        object_kind *k_ptr;

                        int tval, sval;
                        const char *tval_s = zz[0];
                        const char *sval_s = zz[1];

                        n1 = strtol(zz[2], NULL, 0);
                        n2 = strtol(zz[3], NULL, 0);

                        /* Now convert the tval into its numeric equivalent */
                        if (1 != sscanf(tval_s, "%d", &tval))
                        {
                                tval = tval_find_idx(tval_s);
                                if (tval == -1) return 1;
                        }

                        /* Now find the sval */
                        if (1 != sscanf(sval_s, "%d", &sval))
                        {
                                sval = lookup_sval(tval, sval_s);
                                if (sval == -1) return 1;
                        }

                        i = lookup_kind(tval, sval);

                        if ((i < 0) || (i >= (long)z_info->k_max)) return (1);

                        k_ptr = &k_info[i];

                        if (n1) k_ptr->x_attr = (byte)n1;
                        if (n2) k_ptr->x_char = (char)n2;

                        return (0);
                }
        }


        /* Process "F:<num>:<a>/<c>" -- attr/char for terrain features */
        else if (buf[0] == 'F')
        {
                if (tokenize(buf+2, 3, zz) == 3)
                {
                        feature_type *f_ptr;
                        i = strtol(zz[0], NULL, 0);
                        n1 = strtol(zz[1], NULL, 0);
                        n2 = strtol(zz[2], NULL, 0);
                        if ((i < 0) || (i >= (long)z_info->f_max)) return (1);
                        f_ptr = &f_info[i];
                        if (n1) f_ptr->x_attr = (byte)n1;
                        if (n2) f_ptr->x_char = (char)n2;
                        return (0);
                }
        }


        /* Process "L:<num>:<a>/<c>" -- attr/char for flavors */
        else if (buf[0] == 'L')
        {
                if (tokenize(buf+2, 3, zz) == 3)
                {
                        flavor_type *flavor_ptr;
                        i = strtol(zz[0], NULL, 0);
                        n1 = strtol(zz[1], NULL, 0);
                        n2 = strtol(zz[2], NULL, 0);
                        if ((i < 0) || (i >= (long)z_info->flavor_max)) return (1);
                        flavor_ptr = &flavor_info[i];
                        if (n1) flavor_ptr->x_attr = (byte)n1;
                        if (n2) flavor_ptr->x_char = (char)n2;
                        return (0);
                }
        }


        /* Process "S:<num>:<a>/<c>" -- attr/char for special things */
        else if (buf[0] == 'S')
        {
                if (tokenize(buf+2, 3, zz) == 3)
                {
                        i = strtol(zz[0], NULL, 0);
                        n1 = strtol(zz[1], NULL, 0);
                        n2 = strtol(zz[2], NULL, 0);
                        if ((i < 0) || (i >= (long)N_ELEMENTS(misc_to_attr))) return (1);
                        misc_to_attr[i] = (byte)n1;
                        misc_to_char[i] = (char)n2;
                        return (0);
                }
        }


        /* Process "E:<tv>:<a>" -- attribute for inventory objects */
        else if (buf[0] == 'E')
        {
                if (tokenize(buf+2, 2, zz) == 2)
                {
                        i = strtol(zz[0], NULL, 0) % 128;
                        n1 = strtol(zz[1], NULL, 0);
                        if ((i < 0) || (i >= (long)N_ELEMENTS(tval_to_attr))) return (1);
                        if (n1) tval_to_attr[i] = (byte)n1;
                        return (0);
                }
        }


        /* Process "A:<str>" -- save an "action" for later */
        else if (buf[0] == 'A')
        {
                text_to_ascii(macro_buffer, sizeof(macro_buffer), buf+2);
                return (0);
        }

        /* Process "P:<str>" -- create macro */
        else if (buf[0] == 'P')
        {
                char tmp[1024];
                text_to_ascii(tmp, sizeof(tmp), buf+2);
                macro_add(tmp, macro_buffer);
                return (0);
        }

        /* Process "C:<num>:<str>" -- create keymap */
        else if (buf[0] == 'C')
        {
                long mode;

                char tmp[1024];

                if (tokenize(buf+2, 2, zz) != 2) return (1);

                mode = strtol(zz[0], NULL, 0);
                if ((mode < 0) || (mode >= KEYMAP_MODES)) return (1);

                text_to_ascii(tmp, sizeof(tmp), zz[1]);
                if (!tmp[0] || tmp[1]) return (1);
                i = (long)tmp[0];

                string_free(keymap_act[mode][i]);

                keymap_act[mode][i] = string_make(macro_buffer);

                return (0);
        }


        /* Process "V:<num>:<kv>:<rv>:<gv>:<bv>" -- visual info */
        else if (buf[0] == 'V')
        {
                if (tokenize(buf+2, 5, zz) == 5)
                {
                        i = strtol(zz[0], NULL, 0);
                        if ((i < 0) || (i >= MAX_COLORS)) return (1);
                        angband_color_table[i][0] = (byte)strtol(zz[1], NULL, 0);
                        angband_color_table[i][1] = (byte)strtol(zz[2], NULL, 0);
                        angband_color_table[i][2] = (byte)strtol(zz[3], NULL, 0);
                        angband_color_table[i][3] = (byte)strtol(zz[4], NULL, 0);
                        return (0);
                }
        }

        /* set macro trigger names and a template */
        /* Process "T:<trigger>:<keycode>:<shift-keycode>" */
        /* Process "T:<template>:<modifier chr>:<modifier name>:..." */
        else if (buf[0] == 'T')
        {
                int tok;

                tok = tokenize(buf + 2, MAX_MACRO_MOD + 2, zz);

                /* Trigger template */
                if (tok >= 4)
                {
                        int i;
                        int num;

                        /* Free existing macro triggers and trigger template */
                        macro_trigger_free();

                        /* Clear template done */
                        if (*zz[0] == '\0') return 0;

                        /* Count modifier-characters */
                        num = strlen(zz[1]);

                        /* One modifier-character per modifier */
                        if (num + 2 != tok) return 1;

                        /* Macro template */
                        macro_template = string_make(zz[0]);

                        /* Modifier chars */
                        macro_modifier_chr = string_make(zz[1]);

                        /* Modifier names */
                        for (i = 0; i < num; i++)
                        {
                                macro_modifier_name[i] = string_make(zz[2+i]);
                        }
                }

                /* Macro trigger */
                else if (tok >= 2)
                {
                        char *buf;
                        cptr s;
                        char *t;

                        if (max_macrotrigger >= MAX_MACRO_TRIGGER)
                        {
                                msg_print("Too many macro triggers!");
                                return 1;
                        }

                        /* Buffer for the trigger name */
                        buf = C_ZNEW(strlen(zz[0]) + 1, char);

                        /* Simulate strcpy() and skip the '\' escape character */
                        s = zz[0];
                        t = buf;

                        while (*s)
                        {
                                if ('\\' == *s) s++;
                                *t++ = *s++;
                        }

                        /* Terminate the trigger name */
                        *t = '\0';

                        /* Store the trigger name */
                        macro_trigger_name[max_macrotrigger] = string_make(buf);

                        /* Free the buffer */
                        FREE(buf);

                        /* Normal keycode */
                        macro_trigger_keycode[0][max_macrotrigger] = string_make(zz[1]);

                        /* Special shifted keycode */
                        if (tok == 3)
                        {
                                macro_trigger_keycode[1][max_macrotrigger] = string_make(zz[2]);
                        }
                        /* Shifted keycode is the same as the normal keycode */
                        else
                        {
                                macro_trigger_keycode[1][max_macrotrigger] = string_make(zz[1]);
                        }

                        /* Count triggers */
                        max_macrotrigger++;
                }

                return 0;
        }

        /* Process "X:<str>" -- turn option off */
        else if (buf[0] == 'X')
        {
                /* Check non-adult options */
                for (i = 0; i < OPT_ADULT; i++)
                {
                        if (option_name(i) && streq(option_name(i), buf + 2))
                        {
                                option_set(i, FALSE);
                                return (0);
                        }
                }

                /* Ignore unknown options */
                return (0);
        }

        /* Process "Y:<str>" -- turn option on */
        else if (buf[0] == 'Y')
        {
                /* Check non-adult options */
                for (i = 0; i < OPT_ADULT; i++)
                {
                        if (option_name(i) && streq(option_name(i), buf + 2))
                        {
                                option_set(i, TRUE);
                                return (0);
                        }
                }

                /* Ignore unknown options */
                return (0);
        }


        /* Process "W:<win>:<flag>:<value>" -- window flags */
        else if (buf[0] == 'W')
        {
                long win, flag, value;

                if (tokenize(buf + 2, 3, zz) == 3)
                {
                        win = strtol(zz[0], NULL, 0);
                        flag = strtol(zz[1], NULL, 0);
                        value = strtol(zz[2], NULL, 0);

                        /* Ignore illegal windows */
                        /* Hack -- Ignore the main window */
                        if ((win <= 0) || (win >= ANGBAND_TERM_MAX)) return (1);

                        /* Ignore illegal flags */
                        if ((flag < 0) || (flag >= (int)N_ELEMENTS(window_flag_desc))) return (1);

                        /* Require a real flag */
                        if (window_flag_desc[flag])
                        {
                                if (value)
                                {
                                        /* Turn flag on */
                                        op_ptr->window_flag[win] |= (1L << flag);
                                }
                                else
                                {
                                        /* Turn flag off */
                                        op_ptr->window_flag[win] &= ~(1L << flag);
                                }
                        }

                        /* Success */
                        return (0);
                }
        }


        /* Process "M:<type>:<attr>" -- colors for message-types */
        else if (buf[0] == 'M')
        {
                if (tokenize(buf+2, 2, zz) == 2)
                {
                        long type = strtol(zz[0], NULL, 0);
                        int color = color_char_to_attr(zz[1][0]);

                        /* Ignore illegal color */
                        if (color < 0) return (1);

                        /* Store the color */
                        return (message_color_define((u16b)type, (byte)color));
                }
        }


        /* Failure */
        return (1);
}


/*
 * Helper function for "process_pref_file()"
 *
 * Input:
 *   v: output buffer array
 *   f: final character
 *
 * Output:
 *   result
 */
static cptr process_pref_file_expr(char **sp, char *fp)
{
        cptr v;

        char *b;
        char *s;

        char b1 = '[';
        char b2 = ']';

        char f = ' ';

        /* Initial */
        s = (*sp);

        /* Skip spaces */
        while (isspace((unsigned char)*s)) s++;

        /* Save start */
        b = s;

        /* Default */
        v = "?o?o?";

        /* Analyze */
        if (*s == b1)
        {
                const char *p;
                const char *t;

                /* Skip b1 */
                s++;

                /* First */
                t = process_pref_file_expr(&s, &f);

                /* Oops */
                if (!*t)
                {
                        /* Nothing */
                }

                /* Function: IOR */
                else if (streq(t, "IOR"))
                {
                        v = "0";
                        while (*s && (f != b2))
                        {
                                t = process_pref_file_expr(&s, &f);
                                if (*t && !streq(t, "0")) v = "1";
                        }
                }

                /* Function: AND */
                else if (streq(t, "AND"))
                {
                        v = "1";
                        while (*s && (f != b2))
                        {
                                t = process_pref_file_expr(&s, &f);
                                if (*t && streq(t, "0")) v = "0";
                        }
                }

                /* Function: NOT */
                else if (streq(t, "NOT"))
                {
                        v = "1";
                        while (*s && (f != b2))
                        {
                                t = process_pref_file_expr(&s, &f);
                                if (*t && !streq(t, "0")) v = "0";
                        }
                }

                /* Function: EQU */
                else if (streq(t, "EQU"))
                {
                        v = "1";
                        if (*s && (f != b2))
                        {
                                t = process_pref_file_expr(&s, &f);
                        }
                        while (*s && (f != b2))
                        {
                                p = t;
                                t = process_pref_file_expr(&s, &f);
                                if (*t && !streq(p, t)) v = "0";
                        }
                }

                /* Function: LEQ */
                else if (streq(t, "LEQ"))
                {
                        v = "1";
                        if (*s && (f != b2))
                        {
                                t = process_pref_file_expr(&s, &f);
                        }
                        while (*s && (f != b2))
                        {
                                p = t;
                                t = process_pref_file_expr(&s, &f);
                                if (*t && (strcmp(p, t) >= 0)) v = "0";
                        }
                }

                /* Function: GEQ */
                else if (streq(t, "GEQ"))
                {
                        v = "1";
                        if (*s && (f != b2))
                        {
                                t = process_pref_file_expr(&s, &f);
                        }
                        while (*s && (f != b2))
                        {
                                p = t;
                                t = process_pref_file_expr(&s, &f);
                                if (*t && (strcmp(p, t) <= 0)) v = "0";
                        }
                }

                /* Oops */
                else
                {
                        while (*s && (f != b2))
                        {
                                t = process_pref_file_expr(&s, &f);
                        }
                }

                /* Verify ending */
                if (f != b2) v = "?x?x?";

                /* Extract final and Terminate */
                if ((f = *s) != '\0') *s++ = '\0';
        }

        /* Other */
        else
        {
                /* Accept all printables except spaces and brackets */
                while (isprint((unsigned char)*s) && !strchr(" []", *s)) ++s;

                /* Extract final and Terminate */
                if ((f = *s) != '\0') *s++ = '\0';

                /* Variable */
                if (*b == '$')
                {
                        /* System */
                        if (streq(b+1, "SYS"))
                        {
                                v = ANGBAND_SYS;
                        }

                        /* Graphics */
                        else if (streq(b+1, "GRAF"))
                        {