root/trunk/src/util.c

/*
 * File: util.c
 * Purpose: Macro code, gamma correction, some high-level UI functions, inkey()
 *
 * 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 "randname.h"



/*
 * Convert a decimal to a single digit hex number
 */
static char hexify(int i)
{
        return (hexsym[i % 16]);
}

/*
 * Convert a hexidecimal-digit into a decimal
 */
static int dehex(char c)
{
        if (isdigit((unsigned char)c)) return (D2I(c));
        if (isalpha((unsigned char)c)) return (A2I(tolower((unsigned char)c)) + 10);
        return (0);
}


/*
 * Transform macro trigger name ('\[alt-D]' etc..)
 * into macro trigger key code ('^_O_64\r' or etc..)
 */
static size_t trigger_text_to_ascii(char *buf, size_t max, cptr *strptr)
{
        cptr str = *strptr;
        bool mod_status[MAX_MACRO_MOD];

        int i, len = 0;
        int shiftstatus = 0;
        cptr key_code;
        
        size_t current_len = strlen(buf);

        /* No definition of trigger names */
        if (macro_template == NULL) return 0;

        /* Initialize modifier key status */    
        for (i = 0; macro_modifier_chr[i]; i++)
                mod_status[i] = FALSE;

        str++;

        /* Examine modifier keys */
        while (1)
        {
                /* Look for modifier key name */
                for (i = 0; macro_modifier_chr[i]; i++)
                {
                        len = strlen(macro_modifier_name[i]);

                        if (!my_strnicmp(str, macro_modifier_name[i], len))
                                break;
                }

                /* None found? */
                if (!macro_modifier_chr[i]) break;

                /* Proceed */
                str += len;

                /* This modifier key is pressed */
                mod_status[i] = TRUE;

                /* Shift key might be going to change keycode */
                if (macro_modifier_chr[i] == 'S')
                        shiftstatus = 1;
        }

        /* Look for trigger name */
        for (i = 0; i < max_macrotrigger; i++)
        {
                len = strlen(macro_trigger_name[i]);

                /* Found it and it is ending with ']' */
                if (!my_strnicmp(str, macro_trigger_name[i], len) && (']' == str[len]))
                        break;
        }

        /* Invalid trigger name? */
        if (i == max_macrotrigger)
        {
                /*
                 * If this invalid trigger name is ending with ']',
                 * skip whole of it to avoid defining strange macro trigger
                 */
                str = strchr(str, ']');

                if (str)
                {
                        strnfcat(buf, max, &current_len, "\x1F\r");

                        *strptr = str; /* where **strptr == ']' */
                }

                return current_len;
        }

        /* Get keycode for this trigger name */
        key_code = macro_trigger_keycode[shiftstatus][i];

        /* Proceed */
        str += len;

        /* Begin with '^_' */
        strnfcat(buf, max, &current_len, "\x1F");

        /* Write key code style trigger using template */
        for (i = 0; macro_template[i]; i++)
        {
                char ch = macro_template[i];

                switch (ch)
                {
                        /* Modifier key character */
                        case '&':
                        {
                                size_t j;
                                for (j = 0; macro_modifier_chr[j]; j++)
                                {
                                        if (mod_status[j])
                                                strnfcat(buf, max, &current_len, "%c", macro_modifier_chr[j]);
                                }
                                break;
                        }

                        /* Key code */
                        case '#':
                        {
                                strnfcat(buf, max, &current_len, "%s", key_code);
                                break;
                        }

                        /* Fixed string */
                        default:
                        {
                                strnfcat(buf, max, &current_len, "%c", ch);
                                break;
                        }
                }
        }

        /* End with '\r' */
        strnfcat(buf, max, &current_len, "\r");

        /* Succeed */
        *strptr = str; /* where **strptr == ']' */
        
        return current_len;
}


/*
 * Hack -- convert a printable string into real ascii
 *
 * This function will not work on non-ascii systems.
 *
 * To be safe, "buf" should be at least as large as "str".
 */
void text_to_ascii(char *buf, size_t len, cptr str)
{
        char *s = buf;

        /* Analyze the "ascii" string */
        while (*str)
        {
                /* Check if the buffer is long enough */
                if (s >= buf + len - 1) break;

                /* Backslash codes */
                if (*str == '\\')
                {
                        str++;
                        if (*str == '\0') break;

                        switch (*str)
                        {
                                /* Macro trigger */
                                case '[':
                                {
                                        /* Terminate before appending the trigger */
                                        *s = '\0';
                                        s += trigger_text_to_ascii(buf, len, &str);
                                        break;
                                }

                                /* Hex-mode */
                                case 'x':
                                {
                                        if (isxdigit((unsigned char)(*(str + 1))) &&
                                            isxdigit((unsigned char)(*(str + 2))))
                                        {
                                                *s = 16 * dehex(*++str);
                                                *s++ += dehex(*++str);
                                        }
                                        else
                                        {
                                                /* HACK - Invalid hex number */
                                                *s++ = '?';
                                        }
                                        break;
                                }

                                case 'e':
                                        *s++ = ESCAPE;
                                        break;
                                case 's':
                                        *s++ = ' ';
                                        break;
                                case 'b':
                                        *s++ = '\b';
                                        break;
                                case 'n':
                                        *s++ = '\n';
                                        break;
                                case 'r':
                                        *s++ = '\r';
                                        break;
                                case 't':
                                        *s++ = '\t';
                                        break;
                                case 'a':
                                        *s++ = '\a';
                                        break;
                                case '\\':
                                        *s++ = '\\';
                                        break;
                                case '^':
                                        *s++ = '^';
                                        break;

                                default:
                                        *s = *str;
                                        break;
                        }

                        /* Skip the final char */
                        str++;
                }

                /* Normal Control codes */
                else if (*str == '^')
                {
                        str++;
                        if (*str == '\0') break;

                        *s++ = KTRL(*str);
                        str++;
                }

                /* Normal chars */
                else
                {
                        *s++ = *str++;
                }
        }

        /* Terminate */
        *s = '\0';
}


/*
 * Transform macro trigger key code ('^_O_64\r' or etc..) 
 * into macro trigger name ('\[alt-D]' etc..)
 */
static size_t trigger_ascii_to_text(char *buf, size_t max, cptr *strptr)
{
        cptr str = *strptr;
        char key_code[100];
        int i;
        cptr tmp;
        size_t current_len = strlen(buf);
        

        /* No definition of trigger names */
        if (macro_template == NULL) return 0;

        /* Trigger name will be written as '\[name]' */
        strnfcat(buf, max, &current_len, "\\[");

        /* Use template to read key-code style trigger */
        for (i = 0; macro_template[i]; i++)
        {
                char ch = macro_template[i];

                switch (ch)
                {
                        /* Read modifier */
                        case '&':
                        {
                                size_t j;
                                while ((tmp = strchr(macro_modifier_chr, *str)) != 0)
                                {
                                        j = tmp - macro_modifier_chr;
                                        strnfcat(buf, max, &current_len, "%s", macro_modifier_name[j]);
                                        str++;
                                }
                                break;
                        }

                        /* Read key code */
                        case '#':
                        {
                                size_t j;
                                for (j = 0; *str && (*str != '\r') && (j < sizeof(key_code) - 1); j++)
                                        key_code[j] = *str++;
                                key_code[j] = '\0';
                                break;
                        }

                        /* Skip fixed strings */
                        default:
                        {
                                if (ch != *str) return 0;
                                str++;
                        }
                }
        }

        /* Key code style triggers always end with '\r' */
        if (*str++ != '\r') return 0;

        /* Look for trigger name with given keycode (normal or shifted keycode) */
        for (i = 0; i < max_macrotrigger; i++)
        {
                if (!my_stricmp(key_code, macro_trigger_keycode[0][i]) ||
                    !my_stricmp(key_code, macro_trigger_keycode[1][i]))
                        break;
        }

        /* Not found? */
        if (i == max_macrotrigger) return 0;

        /* Write trigger name + "]" */
        strnfcat(buf, max, &current_len, "%s]", macro_trigger_name[i]);

        /* Succeed */
        *strptr = str;
        return current_len;
}


/*
 * Hack -- convert a string into a printable form
 *
 * This function will not work on non-ascii systems.
 */
void ascii_to_text(char *buf, size_t len, cptr str)
{
        char *s = buf;

        /* Analyze the "ascii" string */
        while (*str)
        {
                byte i = (byte)(*str++);

                /* Check if the buffer is long enough */
                /* HACK - always assume worst case (hex-value + '\0') */
                if (s >= buf + len - 5) break;

                if (i == ESCAPE)
                {
                        *s++ = '\\';
                        *s++ = 'e';
                }
                else if (i == ' ')
                {
                        *s++ = '\\';
                        *s++ = 's';
                }
                else if (i == '\b')
                {
                        *s++ = '\\';
                        *s++ = 'b';
                }
                else if (i == '\t')
                {
                        *s++ = '\\';
                        *s++ = 't';
                }
                else if (i == '\a')
                {
                        *s++ = '\\';
                        *s++ = 'a';
                }
                else if (i == '\n')
                {
                        *s++ = '\\';
                        *s++ = 'n';
                }
                else if (i == '\r')
                {
                        *s++ = '\\';
                        *s++ = 'r';
                }
                else if (i == '\\')
                {
                        *s++ = '\\';
                        *s++ = '\\';
                }
                else if (i == '^')
                {
                        *s++ = '\\';
                        *s++ = '^';
                }
                /* Macro Trigger */
                else if (i == 31)
                {
                        size_t offset;

                        /* Terminate before appending the trigger */
                        *s = '\0';

                        offset = trigger_ascii_to_text(buf, len, &str);
                        
                        if (offset == 0)
                        {
                                /* No trigger found */
                                *s++ = '^';
                                *s++ = '_';
                        }
                        else
                                s += offset;
                }
                else if (i < 32)
                {
                        *s++ = '^';
                        *s++ = UN_KTRL(i);
                }
                else if (i < 127)
                {
                        *s++ = i;
                }
                else
                {
                        *s++ = '\\';
                        *s++ = 'x';
                        *s++ = hexify((int)i / 16);
                        *s++ = hexify((int)i % 16);
                }
        }

        /* Terminate */
        *s = '\0';
}



/*
 * The "macro" package
 *
 * Functions are provided to manipulate a collection of macros, each
 * of which has a trigger pattern string and a resulting action string
 * and a small set of flags.
 */



/*
 * Determine if any macros have ever started with a given character.
 */
static bool macro__use[256];


/*
 * Find the macro (if any) which exactly matches the given pattern
 */
int macro_find_exact(cptr pat)
{
        int i;

        /* Nothing possible */
        if (!macro__use[(byte)(pat[0])])
                return -1;

        /* Scan the macros */
        for (i = 0; i < macro__num; ++i)
        {
                if (streq(macro__pat[i], pat))
                        return i;
        }

        /* No matches */
        return -1;
}


/*
 * Find the first macro (if any) which contains the given pattern
 */
static int macro_find_check(cptr pat)
{
        int i;

        /* Nothing possible */
        if (!macro__use[(byte)(pat[0])])
                return -1;

        /* Scan the macros */
        for (i = 0; i < macro__num; ++i)
        {
                if (prefix(macro__pat[i], pat))
                        return i;
        }

        /* Nothing */
        return -1;
}


/*
 * Find the first macro (if any) which contains the given pattern and more
 */
static int macro_find_maybe(cptr pat)
{
        int i;

        /* Nothing possible */
        if (!macro__use[(byte)(pat[0])])
                return -1;

        /* Scan the macros */
        for (i = 0; i < macro__num; ++i)
        {
                if (prefix(macro__pat[i], pat) && !streq(macro__pat[i], pat))
                        return i;
        }

        /* Nothing */
        return -1;
}



/*
 * Find the longest macro (if any) which starts with the given pattern
 */
static int macro_find_ready(cptr pat)
{
        int i, t, n = -1, s = -1;

        /* Nothing possible */
        if (!macro__use[(byte)(pat[0])])
                return -1;

        /* Scan the macros */
        for (i = 0; i < macro__num; ++i)
        {
                /* Skip macros which are not contained by the pattern */
                if (!prefix(pat, macro__pat[i])) continue;

                /* Obtain the length of this macro */
                t = strlen(macro__pat[i]);

                /* Only track the "longest" pattern */
                if ((n >= 0) && (s > t)) continue;

                /* Track the entry */
                n = i;
                s = t;
        }

        /* Result */
        return n;
}


/*
 * Add a macro definition (or redefinition).
 *
 * We should use "act == NULL" to "remove" a macro, but this might make it
 * impossible to save the "removal" of a macro definition.  XXX XXX XXX
 *
 * We should consider refusing to allow macros which contain existing macros,
 * or which are contained in existing macros, because this would simplify the
 * macro analysis code.  XXX XXX XXX
 *
 * We should consider removing the "command macro" crap, and replacing it
 * with some kind of "powerful keymap" ability, but this might make it hard
 * to change the "roguelike" option from inside the game.  XXX XXX XXX
 */
errr macro_add(cptr pat, cptr act)
{
        int n;

        if (!pat || !act) return (-1);


        /* Look for any existing macro */
        n = macro_find_exact(pat);

        /* Replace existing macro */
        if (n >= 0)
        {
                string_free(macro__act[n]);
        }

        /* Create a new macro */
        else
        {
                /* Get a new index */
                n = macro__num++;
                if (macro__num >= MACRO_MAX) quit("Too many macros!");

                /* Save the pattern */
                macro__pat[n] = string_make(pat);
        }

        /* Save the action */
        macro__act[n] = string_make(act);

        /* Efficiency */
        macro__use[(byte)(pat[0])] = TRUE;

        /* Success */
        return (0);
}



/*
 * Initialize the "macro" package
 */
errr macro_init(void)
{
        /* Macro patterns */
        macro__pat = C_ZNEW(MACRO_MAX, cptr);

        /* Macro actions */
        macro__act = C_ZNEW(MACRO_MAX, cptr);

        /* Success */
        return (0);
}


/*
 * Free the macro package
 */
errr macro_free(void)
{
        int i;
        size_t j;

        /* Free the macros */
        for (i = 0; i < macro__num; ++i)
        {
                string_free(macro__pat[i]);
                string_free(macro__act[i]);
        }

        FREE(macro__pat);
        FREE(macro__act);

        /* Free the keymaps */
        for (i = 0; i < KEYMAP_MODES; ++i)
        {
                for (j = 0; j < N_ELEMENTS(keymap_act[i]); ++j)
                {
                        string_free(keymap_act[i][j]);
                        keymap_act[i][j] = NULL;
                }
        }

        /* Success */
        return (0);
}


/*
 * Free the macro trigger package
 */
errr macro_trigger_free(void)
{
        int i;
        int num;

        if (macro_template != NULL)
        {
                /* Free the template */
                string_free(macro_template);
                macro_template = NULL;

                /* Free the trigger names and keycodes */
                for (i = 0; i < max_macrotrigger; i++)
                {
                        string_free(macro_trigger_name[i]);

                        string_free(macro_trigger_keycode[0][i]);
                        string_free(macro_trigger_keycode[1][i]);
                }

                /* No more macro triggers */
                max_macrotrigger = 0;

                /* Count modifier-characters */
                num = strlen(macro_modifier_chr);

                /* Free modifier names */
                for (i = 0; i < num; i++)
                        string_free(macro_modifier_name[i]);

                /* Free modifier chars */
                string_free(macro_modifier_chr);
        }

        /* Success */
        return (0);
}


/*
 * Flush all pending input.
 *
 * Actually, remember the flush, using the "inkey_xtra" flag, and in the
 * next call to "inkey()", perform the actual flushing, for efficiency,
 * and correctness of the "inkey()" function.
 */
void flush(void)
{
        /* Do it later */
        inkey_xtra = TRUE;
}


/*
 * Flush all pending input if the flush_failure option is set.
 */
void flush_fail(void)
{
        if (flush_failure) flush();
}


/*
 * Local variable -- we are inside a "macro action"
 *
 * Do not match any macros until "ascii 30" is found.
 */
static bool parse_macro = FALSE;


/*
 * Local variable -- we are inside a "macro trigger"
 *
 * Strip all keypresses until a low ascii value is found.
 */
static bool parse_under = FALSE;



/*
 * Helper function called only from "inkey()"
 *
 * This function does almost all of the "macro" processing.
 *
 * We use the "Term_key_push()" function to handle "failed" macros, as well
 * as "extra" keys read in while choosing the proper macro, and also to hold
 * the action for the macro, plus a special "ascii 30" character indicating
 * that any macro action in progress is complete.  Embedded macros are thus
 * illegal, unless a macro action includes an explicit "ascii 30" character,
 * which would probably be a massive hack, and might break things.
 *
 * Only 500 (0+1+2+...+29+30) milliseconds may elapse between each key in
 * the macro trigger sequence.  If a key sequence forms the "prefix" of a
 * macro trigger, 500 milliseconds must pass before the key sequence is
 * known not to be that macro trigger.  XXX XXX XXX
 */
static ui_event_data inkey_aux(int scan_cutoff)
{
        int k = 0, n, p = 0, w = 0;
        
        ui_event_data ke, ke0;
        char ch;
        
        cptr pat, act;
        
        char buf[1024];

        /* Initialize the no return */
        ke0.type = EVT_NONE;
        ke0.key = 0;
        ke0.index = 0; /* To fix GCC warnings on X11 */
        ke0.mousey = 0;
        ke0.mousex = 0;
 
        /* Wait for a keypress */
        if (scan_cutoff == SCAN_OFF)
        {
                (void)(Term_inkey(&ke, TRUE, TRUE));
                ch = ke.key;
        }
        else
        {
                w = 0;

                /* Wait only as long as macro activation would wait*/
                while (Term_inkey(&ke, FALSE, TRUE) != 0)
                {
                        /* Increase "wait" */
                        w++;

                        /* Excessive delay */
                        if (w >= scan_cutoff)
                        {
                                ke0.type = EVT_KBRD;
                                return ke0;
                        }

                        /* Delay */
                        Term_xtra(TERM_XTRA_DELAY, 10);
                }
                ch = ke.key;
        }

        
        /* End "macro action" */
        if ((ch == 30) || (ch == '\xff'))
        {
                parse_macro = FALSE;
                return (ke);
        }
        
        /* Inside "macro action" */
        if (parse_macro) return (ke);
        
        /* Inside "macro trigger" */
        if (parse_under) return (ke);
        

        /* Save the first key, advance */
        buf[p++] = ch;
        buf[p] = '\0';
        
        
        /* Check for possible macro */
        k = macro_find_check(buf);
        
        /* No macro pending */
        if (k < 0) return (ke);
        
        
        /* Wait for a macro, or a timeout */
        while (TRUE)
        {
                /* Check for pending macro */
                k = macro_find_maybe(buf);
                
                /* No macro pending */
                if (k < 0) break;
                
                /* Check for (and remove) a pending key */
                if (0 == Term_inkey(&ke, FALSE, TRUE))
                {
                        /* Append the key */
                        buf[p++] = ke.key;
                        buf[p] = '\0';
                
                        /* Resta