u = file+1;
/* Look for non-user portion of the file */
- s = strstr(u, PATH_SEP);
+ s = my_strstr(u, PATH_SEP);
/* Hack -- no long user names */
if (s && (s >= u + sizeof(user))) return (1);
if (!s) return (-1);
/* Format to length */
+#ifndef WIN32
(void)strnfmt(buf, max, "%s", s);
+#else
+ (void)strnfmt(buf, max, ".%s", s);
+#endif
/* Success */
return (0);
{
char buf[1024];
-#if defined(MACINTOSH) && defined(MAC_MPW)
+#if defined(MAC_MPW) || defined(MACH_O_CARBON)
FILE *tempfff;
#endif
/* Hack -- Try to parse the path */
if (path_parse(buf, 1024, file)) return (NULL);
-#if defined(MACINTOSH) && defined(MAC_MPW)
- if (strchr(mode, 'w'))
+#if defined(MAC_MPW) || defined(MACH_O_CARBON)
+ if (my_strchr(mode, 'w'))
{
/* setting file type/creator */
tempfff = fopen(buf, mode);
- fsetfileinfo(file, _fcreator, _ftype);
+ fsetfileinfo(buf, _fcreator, _ftype);
fclose(tempfff);
}
#endif
/* Copy */
while ((read_num = read(src_fd, buf, 1024)) > 0)
{
- write(dst_fd, buf, read_num);
+ int write_num = 0;
+ while (write_num < read_num)
+ {
+ int ret = write(dst_fd, buf + write_num, read_num - write_num);
+ if (ret < 0) {
+ /* Close files */
+ fd_close(src_fd);
+ fd_close(dst_fd);
+
+ return ret;
+ }
+ write_num += ret;
+ }
}
/* Close files */
#else /* BEN_HACK */
-# if defined(MACINTOSH) && defined(MAC_MPW)
-
- /* setting file type and creator -- AR */
+#if defined(MAC_MPW) || defined(MACH_O_CARBON)
{
- errr errr_tmp;
- errr_tmp = open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, mode);
- fsetfileinfo(file, _fcreator, _ftype);
- return(errr_tmp);
+ int fdes;
+ /* Create the file, fail if exists, write-only, binary */
+ fdes = open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, mode);
+ /* Set creator and type if the file is successfully opened */
+ if (fdes >= 0) fsetfileinfo(buf, _fcreator, _ftype);
+ /* Return the descriptor */
+ return (fdes);
}
-
# else
/* Create the file, fail if exists, write-only, binary */
return (open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, mode));
/* Invalid trigger name? */
if (i == max_macrotrigger)
{
- str = strchr(str, ']');
+ str = my_strchr(str, ']');
if (str)
{
*s++ = (char)31;
switch(ch)
{
case '&':
- while ((tmp = strchr(macro_modifier_chr, *str)))
+ while ((tmp = my_strchr(macro_modifier_chr, *str)))
{
j = (int)(tmp - macro_modifier_chr);
tmp = macro_modifier_name[j];
else
{
/* Increase "wait" */
- w += 10;
+ w += 1;
/* Excessive delay */
- if (w >= 100) break;
+ if (w >= 10) break;
/* Delay */
Term_xtra(TERM_XTRA_DELAY, w);
/*
+ * Cancel macro action on the queue
+ */
+static void forget_macro_action(void)
+{
+ if (!parse_macro) return;
+
+ /* Drop following macro action string */
+ while (TRUE)
+ {
+ char ch;
+
+ /* End loop if no key ready */
+ if (Term_inkey(&ch, FALSE, TRUE)) break;
+
+ /* End loop if no key ready */
+ if (ch == 0) break;
+
+ /* End of "macro action" */
+ if (ch == 30) break;
+ }
+
+ /* No longer inside "macro action" */
+ parse_macro = FALSE;
+}
+
+
+/*
* Mega-Hack -- special "inkey_next" pointer. XXX XXX XXX
*
* This special pointer allows a sequence of keys to be "inserted" into
*/
/*
+ * Initialize the quark array
+ */
+void quark_init(void)
+{
+ /* Quark variables */
+ C_MAKE(quark__str, QUARK_MAX, cptr);
+
+ /* Prepare first quark, which is used when quark_add() is failed */
+ quark__str[1] = string_make("");
+
+ /* There is one quark (+ NULL) */
+ quark__num = 2;
+}
+
+
+/*
* Add a new "quark" to the set of quarks.
*/
s16b quark_add(cptr str)
if (streq(quark__str[i], str)) return (i);
}
- /* Paranoia -- Require room */
- if (quark__num == QUARK_MAX) return (0);
+ /* Return "" when no room is available */
+ if (quark__num == QUARK_MAX) return 1;
/* New maximal quark */
quark__num = i + 1;
{
cptr q;
- /* Verify */
- if ((i < 0) || (i >= quark__num)) i = 0;
+ /* Return NULL for an invalid index */
+ if ((i < 1) || (i >= quark__num)) return NULL;
/* Access the quark */
q = quark__str[i];
}
/* Limit the multiplier to 1000 */
- if (buf && streq(buf, str) && (j < 1000))
+ if (streq(buf, str) && (j < 1000))
{
j++;
* ESCAPE clears the buffer and the window and returns FALSE.
* RETURN accepts the current buffer contents and returns TRUE.
*/
-bool askfor_aux(char *buf, int len)
+bool askfor_aux(char *buf, int len, bool numpad_cursor)
{
int y, x;
int pos = 0;
Term_gotoxy(x + pos, y);
/* Get a special key code */
- skey = inkey_special(FALSE);
+ skey = inkey_special(numpad_cursor);
/* Analyze the key */
switch (skey)
/* Now on insert mode */
color = TERM_WHITE;
- /* No move at biggining of line */
+ /* No move at beginning of line */
if (0 == pos) break;
while (TRUE)
/* Now on insert mode */
color = TERM_WHITE;
- /* No move at biggining of line */
+ /* No move at beginning of line */
if (0 == pos) break;
while (TRUE)
/* Now on insert mode */
color = TERM_WHITE;
+ /* No move at end of line */
+ if ('\0' == buf[pos]) break;
+
/* Position of next character */
src = pos + 1;
/*
+ * Get some string input at the cursor location.
+ *
+ * Allow to use numpad keys as cursor keys.
+ */
+bool askfor(char *buf, int len)
+{
+ return askfor_aux(buf, len, TRUE);
+}
+
+
+/*
* Get a string from the user
*
* The "prompt" should take the form "Prompt: "
prt(prompt, 0, 0);
/* Ask the user for a string */
- res = askfor_aux(buf, len);
+ res = askfor(buf, len);
/* Clear prompt */
prt("", 0, 0);
prt(prompt, 0, 0);
/* Get a key */
- *command = inkey();
+ if (get_com_no_macros)
+ *command = inkey_special(FALSE);
+ else
+ *command = inkey();
/* Clear the prompt */
prt("", 0, 0);
*/
s16b get_quantity(cptr prompt, int max)
{
+ bool res;
int amt;
-
char tmp[80];
-
char buf[80];
{
/* Build a prompt */
#ifdef JP
- sprintf(tmp, "¤¤¤¯¤Ä¤Ç¤¹¤« (1-%d): ", max);
+ sprintf(tmp, "¤¤¤¯¤Ä¤Ç¤¹¤« (1-%d): ", max);
#else
sprintf(tmp, "Quantity (1-%d): ", max);
#endif
prompt = tmp;
}
+ /* Paranoia XXX XXX XXX */
+ msg_print(NULL);
+
+ /* Display prompt */
+ prt(prompt, 0, 0);
/* Default to one */
amt = 1;
/* Build the default */
sprintf(buf, "%d", amt);
- /* Ask for a quantity */
- if (!get_string(prompt, buf, 6)) return (0);
+ /*
+ * Ask for a quantity
+ * Don't allow to use numpad as cursor key.
+ */
+ res = askfor_aux(buf, 6, FALSE);
+
+ /* Clear prompt */
+ prt("", 0, 0);
+
+ /* Cancelled */
+ if (!res) return 0;
/* Extract a number */
amt = atoi(buf);
{"Items(other)", 4, FALSE},
{"Equip", 5, FALSE},
{"Door/Box", 6, FALSE},
- {"Infomations", 7, FALSE},
+ {"Informations", 7, FALSE},
{"Options", 8, FALSE},
{"Other commands", 9, FALSE},
{"", 0, FALSE},
{"Target(*)", '*', TRUE},
{"Dig(T/^t)", 'T', TRUE},
{"Go up stairs(<)", '<', TRUE},
- {"Go down staies(>)", '>', TRUE},
+ {"Go down stairs(>)", '>', TRUE},
{"Command pets(p)", 'p', TRUE},
{"Search mode ON/OFF(S/#)", 'S', TRUE}
},
{"Identify symbol(/)", '/', TRUE},
{"Show prev messages(^p)", KTRL('P'), TRUE},
{"Current time(^t/')", KTRL('T'), TRUE},
- {"Various infomations(~)", '~', TRUE},
+ {"Various informations(~)", '~', TRUE},
{"Play record menu(|)", '|', TRUE},
{"", 0, FALSE}
},
{
{"ĶǽÎÏ/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_MINDCRAFTER},
{"¤â¤Î¤Þ¤Í/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_IMITATOR},
+ {"²Î/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_BARD},
{"ɬ»¦µ»/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_SAMURAI},
{"Îýµ¤½Ñ/ËâË¡/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_FORCETRAINER},
+ {"µ»/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_BERSERKER},
+ {"µ»½Ñ/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_SMITH},
{"¶ÀËâË¡/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_MIRROR_MASTER},
+ {"Ǧ½Ñ/ÆüìǽÎÏ", 0, 0, MENU_CLASS, CLASS_NINJA},
{"¹°è¥Þ¥Ã¥×(<)", 2, 6, MENU_WILD, FALSE},
{"Ä̾ï¥Þ¥Ã¥×(>)", 2, 7, MENU_WILD, TRUE},
{"", 0, 0, 0, 0},
{
{"MindCraft/Special", 0, 0, MENU_CLASS, CLASS_MINDCRAFTER},
{"Imitation/Special", 0, 0, MENU_CLASS, CLASS_IMITATOR},
+ {"Song/Special", 0, 0, MENU_CLASS, CLASS_BARD},
{"Technique/Special", 0, 0, MENU_CLASS, CLASS_SAMURAI},
{"Mind/Magic/Special", 0, 0, MENU_CLASS, CLASS_FORCETRAINER},
+ {"BrutalPower/Special", 0, 0, MENU_CLASS, CLASS_BERSERKER},
+ {"Technique/Special", 0, 0, MENU_CLASS, CLASS_SMITH},
{"MirrorMagic/Special", 0, 0, MENU_CLASS, CLASS_MIRROR_MASTER},
+ {"Ninjutsu/Special", 0, 0, MENU_CLASS, CLASS_NINJA},
{"Enter global map(<)", 2, 6, MENU_WILD, FALSE},
{"Enter local map(>)", 2, 7, MENU_WILD, TRUE},
{"", 0, 0, 0, 0},
if (always_repeat && (command_arg <= 0))
{
/* Hack -- auto repeat certain commands */
- if (strchr("TBDoc+", command_cmd))
+ if (my_strchr("TBDoc+", command_cmd))
{
/* Repeat 99 times */
command_arg = 99;
caretcmd = command_cmd;
#endif
-#ifdef JP
-#undef strchr
-#define strchr strchr_j
-#endif
-
/* Hack -- Scan equipment */
for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
{
s = quark_str(o_ptr->inscription);
/* Find a '^' */
- s = strchr(s, '^');
+ s = my_strchr(s, '^');
/* Process preventions */
while (s)
}
/* Find another '^' */
- s = strchr(s + 1, '^');
+ s = my_strchr(s + 1, '^');
}
}
int b_len, t_len, i_len;
/* Attempt to find the target (modify "buf") */
- buf = strstr(buf, target);
+ buf = my_strstr(buf, target);
/* No target found */
if (!buf) return (FALSE);
{
tag_type temp;
- temp.tag = a->tag;
- temp.pointer = a->pointer;
-
- a->tag = b->tag;
- a->pointer = b->pointer;
-
- b->tag = temp.tag;
- b->pointer = temp.pointer;
+ temp = *a;
+ *a = *b;
+ *b = temp;
}
const char *s = src;
size_t len = 0;
- /* reserve for NUL termination */
- bufsize--;
+ if (bufsize > 0) {
+ /* reserve for NUL termination */
+ bufsize--;
- /* Copy as many bytes as will fit */
- while (len < bufsize)
- {
- if (iskanji(*s))
+ /* Copy as many bytes as will fit */
+ while (*s && (len < bufsize))
{
- if (len + 1 >= bufsize || !*(s+1)) break;
- *d++ = *s++;
- *d++ = *s++;
- len += 2;
- }
- else
- {
- *d++ = *s++;
- len++;
+ if (iskanji(*s))
+ {
+ if (len + 1 >= bufsize || !*(s+1)) break;
+ *d++ = *s++;
+ *d++ = *s++;
+ len += 2;
+ }
+ else
+ {
+ *d++ = *s++;
+ len++;
+ }
}
+ *d = '\0';
}
- *d = '\0';
+
while(*s++) len++;
return len;
/*
+ * A copy of ANSI strstr()
+ *
+ * my_strstr() can handle Kanji strings correctly.
+ */
+char *my_strstr(const char *haystack, const char *needle)
+{
+ int i;
+ int l1 = strlen(haystack);
+ int l2 = strlen(needle);
+
+ if (l1 >= l2)
+ {
+ for(i = 0; i <= l1 - l2; i++)
+ {
+ if(!strncmp(haystack + i, needle, l2))
+ return (char *)haystack + i;
+
+#ifdef JP
+ if (iskanji(*(haystack + i))) i++;
+#endif
+ }
+ }
+
+ return NULL;
+}
+
+
+/*
+ * A copy of ANSI strchr()
+ *
+ * my_strchr() can handle Kanji strings correctly.
+ */
+char *my_strchr(const char *ptr, char ch)
+{
+ for ( ; *ptr != '\0'; ptr++)
+ {
+ if (*ptr == ch) return (char *)ptr;
+
+#ifdef JP
+ if (iskanji(*ptr)) ptr++;
+#endif
+ }
+
+ return NULL;
+}
+
+
+/*
+ * Convert string to lower case
+ */
+void str_tolower(char *str)
+{
+ /* Force to be lower case string */
+ for (; *str; str++)
+ {
+#ifdef JP
+ if (iskanji(*str))
+ {
+ str++;
+ continue;
+ }
+#endif
+ *str = tolower(*str);
+ }
+}
+
+
+/*
* Get a keypress from the user.
* And interpret special keys as internal code.
*
* This function is a Mega-Hack and depend on pref-xxx.prf's.
* Currently works on Linux(UNIX), Windows, and Macintosh only.
*/
-int inkey_special(bool use_numkey_as_special)
+int inkey_special(bool numpad_cursor)
{
static const struct {
cptr keyname;
};
static const struct {
+ bool numpad;
cptr keyname;
int keycode;
} special_key_list[] = {
- {"Down]", SKEY_DOWN},
- {"Left]", SKEY_LEFT},
- {"Right]", SKEY_RIGHT},
- {"Up]", SKEY_UP},
- {"Page_Up]", SKEY_PGUP},
- {"Page_Down]", SKEY_PGDOWN},
- {"Home]", SKEY_TOP},
- {"End]", SKEY_BOTTOM},
- {"KP_Down]", SKEY_DOWN},
- {"KP_Left]", SKEY_LEFT},
- {"KP_Right]", SKEY_RIGHT},
- {"KP_Up]", SKEY_UP},
- {"KP_Page_Up]", SKEY_PGUP},
- {"KP_Page_Down]", SKEY_PGDOWN},
- {"KP_Home]", SKEY_TOP},
- {"KP_End]", SKEY_BOTTOM},
- {NULL, 0},
+ {FALSE, "Down]", SKEY_DOWN},
+ {FALSE, "Left]", SKEY_LEFT},
+ {FALSE, "Right]", SKEY_RIGHT},
+ {FALSE, "Up]", SKEY_UP},
+ {FALSE, "Page_Up]", SKEY_PGUP},
+ {FALSE, "Page_Down]", SKEY_PGDOWN},
+ {FALSE, "Home]", SKEY_TOP},
+ {FALSE, "End]", SKEY_BOTTOM},
+ {TRUE, "KP_Down]", SKEY_DOWN},
+ {TRUE, "KP_Left]", SKEY_LEFT},
+ {TRUE, "KP_Right]", SKEY_RIGHT},
+ {TRUE, "KP_Up]", SKEY_UP},
+ {TRUE, "KP_Page_Up]", SKEY_PGUP},
+ {TRUE, "KP_Page_Down]", SKEY_PGDOWN},
+ {TRUE, "KP_Home]", SKEY_TOP},
+ {TRUE, "KP_End]", SKEY_BOTTOM},
+ {TRUE, "KP_2]", SKEY_DOWN},
+ {TRUE, "KP_4]", SKEY_LEFT},
+ {TRUE, "KP_6]", SKEY_RIGHT},
+ {TRUE, "KP_8]", SKEY_UP},
+ {TRUE, "KP_9]", SKEY_PGUP},
+ {TRUE, "KP_3]", SKEY_PGDOWN},
+ {TRUE, "KP_7]", SKEY_TOP},
+ {TRUE, "KP_1]", SKEY_BOTTOM},
+ {FALSE, NULL, 0},
};
static const struct {
cptr keyname;
int keycode;
- } numkey_list[] = {
- {"KP_2]", SKEY_DOWN},
- {"KP_4]", SKEY_LEFT},
- {"KP_6]", SKEY_RIGHT},
- {"KP_8]", SKEY_UP},
- {"KP_9]", SKEY_PGUP},
- {"KP_3]", SKEY_PGDOWN},
- {"KP_7]", SKEY_TOP},
- {"KP_1]", SKEY_BOTTOM},
+ } gcu_special_key_list[] = {
+ {"A", SKEY_UP},
+ {"B", SKEY_DOWN},
+ {"C", SKEY_RIGHT},
+ {"D", SKEY_LEFT},
+ {"1~", SKEY_TOP},
+ {"4~", SKEY_BOTTOM},
+ {"5~", SKEY_PGUP},
+ {"6~", SKEY_PGDOWN},
{NULL, 0},
};
+
char buf[1024];
cptr str = buf;
char key;
int i;
size_t trig_len;
+ /*
+ * Forget macro trigger ----
+ * It's important if we are already expanding macro action
+ */
+ inkey_macro_trigger_string[0] = '\0';
+
/* Get a keypress */
key = inkey();
/* Examine trigger string */
trig_len = strlen(inkey_macro_trigger_string);
- /* No special key */
+ /* Already known that no special key */
if (!trig_len) return (int)((unsigned char)key);
+
/*
- * Mega Hack -- ignore macro defined on ASCII keys
- *
- * When this function is used, all ASCII keys are used as
- * themselfs instead of macro triggers for command macro's.
+ * Hack -- Ignore macro defined on ASCII characters.
*/
- if (trig_len == 1)
+ if (trig_len == 1 && parse_macro)
{
- /* Get original key */
- key = inkey_macro_trigger_string[0];
+ char c = inkey_macro_trigger_string[0];
-#ifdef JP
- if (!iskanji(key))
-#endif
- {
- /* Kill further macro expansion */
- flush();
- }
+ /* Cancel macro action on the queue */
+ forget_macro_action();
/* Return the originaly pressed key */
- return (int)((unsigned char)key);
+ return (int)((unsigned char)c);
}
/* Convert the trigger */
ascii_to_text(buf, inkey_macro_trigger_string);
/* Check the prefix "\[" */
- if (!prefix(str, "\\[")) return 0;
-
- /* Skip "\[" */
- str += 2;
-
- /* Examine modifier keys */
- while (TRUE)
+ if (prefix(str, "\\["))
{
- for (i = 0; modifier_key_list[i].keyname; i++)
+ /* Skip "\[" */
+ str += 2;
+
+ /* Examine modifier keys */
+ while (TRUE)
{
- if (prefix(str, modifier_key_list[i].keyname))
+ for (i = 0; modifier_key_list[i].keyname; i++)
{
- /* Get modifier key flag */
- str += strlen(modifier_key_list[i].keyname);
- modifier |= modifier_key_list[i].keyflag;
+ if (prefix(str, modifier_key_list[i].keyname))
+ {
+ /* Get modifier key flag */
+ str += strlen(modifier_key_list[i].keyname);
+ modifier |= modifier_key_list[i].keyflag;
+ }
}
+
+ /* No more modifier key found */
+ if (!modifier_key_list[i].keyname) break;
}
- /* No more modifier key found */
- if (!modifier_key_list[i].keyname) break;
- }
+ /* numpad_as_cursorkey option force numpad keys to input numbers */
+ if (!numpad_as_cursorkey) numpad_cursor = FALSE;
- /* Get a special key code */
- for (i = 0; special_key_list[i].keyname; i++)
- {
- if (streq(str, special_key_list[i].keyname))
+ /* Get a special key code */
+ for (i = 0; special_key_list[i].keyname; i++)
{
- skey = special_key_list[i].keycode;
- break;
+ if ((!special_key_list[i].numpad || numpad_cursor) &&
+ streq(str, special_key_list[i].keyname))
+ {
+ skey = special_key_list[i].keycode;
+ break;
+ }
+ }
+
+ /* A special key found */
+ if (skey)
+ {
+ /* Cancel macro action on the queue */
+ forget_macro_action();
+
+ /* Return special key code and modifier flags */
+ return (skey | modifier);
}
}
- if (!skey && use_numkey_as_special)
+ if (prefix(str, "\\e["))
{
- /* Get a numkey code */
- for (i = 0; numkey_list[i].keyname; i++)
+ str += 3;
+
+ for (i = 0; gcu_special_key_list[i].keyname; i++)
{
- if (streq(str, numkey_list[i].keyname))
+ if (streq(str, gcu_special_key_list[i].keyname))
{
- skey = numkey_list[i].keycode;
- break;
+ return gcu_special_key_list[i].keycode;
}
}
}
/* No special key found? */
- if (!skey)
- {
- /* Don't bother with this trigger no more */
- inkey_macro_trigger_string[0] = '\0';
- /* Return normal keycode */
- return (int)((unsigned char)key);
- }
-
- /* A special key found */
-
- /* Kill further macro expansion */
- flush();
+ /* Don't bother with this trigger no more */
+ inkey_macro_trigger_string[0] = '\0';
- /* Return special key code and modifier flags */
- return (skey | modifier);
+ /* Return normal keycode */
+ return (int)((unsigned char)key);
}