src/util.c

   1 /* File: util.c */
   2
   3 /*
   4  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   5  *
   6  * This software may be copied and distributed for educational, research,
   7  * and not for profit purposes provided that this copyright and statement
   8  * are included in all such copies.  Other copyrights may also apply.
   9  */
  10
  11 /* Purpose: Angband utilities -BEN- */
  12
  13 #include "angband.h"
  14 #include "core.h"
  15 #include "term.h"
  16 #include "util.h"
  17 #include "files.h"
  18 #include "monsterrace-hook.h"
  19 #include "view-mainwindow.h"
  20 #include "quest.h"
  21 #include "floor.h"
  22 #include "world.h"
  23 #include "cmd-dump.h"
  24 #include "japanese.h"
  25 #include "player-class.h"
  26
  27 /*!
  28  * 10進数から16進数への変換テーブル /
  29  * Global array for converting numbers to uppercase hecidecimal digit
  30  * This array can also be used to convert a number to an octal digit
  31  */
  32 const char hexsym[16] =
  33 {
  34         '0', '1', '2', '3', '4', '5', '6', '7',
  35         '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
  36 };
  37
  38 /*
  39  * Keymaps for each "mode" associated with each keypress.
  40  */
  41 concptr keymap_act[KEYMAP_MODES][256];
  42
  43 /*
  44  * The next "free" index to use
  45  */
  46 u32b message__next;
  47
  48 /*
  49  * The index of the oldest message (none yet)
  50  */
  51 u32b message__last;
  52
  53 /*
  54  * The next "free" offset
  55  */
  56 u32b message__head;
  57
  58 /*
  59  * The offset to the oldest used char (none yet)
  60  */
  61 u32b message__tail;
  62
  63 /*
  64  * The array of offsets, by index [MESSAGE_MAX]
  65  */
  66 u32b *message__ptr;
  67
  68 /*
  69  * The array of chars, by offset [MESSAGE_BUF]
  70  */
  71 char *message__buf;
  72
  73 bool msg_flag;                  /* Used in msg_print() for "buffering" */
  74
  75 /*
  76  * Number of active macros.
  77  */
  78 s16b macro__num;
  79
  80 /*
  81  * Array of macro patterns [MACRO_MAX]
  82  */
  83 concptr *macro__pat;
  84
  85 /*
  86  * Array of macro actions [MACRO_MAX]
  87  */
  88 concptr *macro__act;
  89
  90 /*
  91  * Array of macro types [MACRO_MAX]
  92  */
  93 bool *macro__cmd;
  94
  95 /*
  96  * Current macro action [1024]
  97  */
  98 char *macro__buf;
  99
 100 bool get_com_no_macros = FALSE; /* Expand macros in "get_com" or not */
 101
 102 bool inkey_base;                /* See the "inkey()" function */
 103 bool inkey_xtra;                /* See the "inkey()" function */
 104 bool inkey_scan;                /* See the "inkey()" function */
 105 bool inkey_flag;                /* See the "inkey()" function */
 106
 107 bool use_menu;
 108
 109 pos_list tmp_pos;
 110
 111 /*
 112  * The number of quarks
 113  */
 114 STR_OFFSET quark__num;
 115
 116 /*
 117  * The pointers to the quarks [QUARK_MAX]
 118  */
 119 concptr *quark__str;
 120
 121 static int num_more = 0;
 122
 123 /* Save macro trigger string for use in inkey_special() */
 124 static char inkey_macro_trigger_string[1024];
 125
 126 int max_macrotrigger = 0; /*!< 現在登録中のマクロ(トリガー)の数 */
 127 concptr macro_template = NULL; /*!< Angband設定ファイルのT: タグ情報から読み込んだ長いTコードを処理するために利用する文字列ポインタ */
 128 concptr macro_modifier_chr; /*!< &x# で指定されるマクロトリガーに関する情報を記録する文字列ポインタ */
 129 concptr macro_modifier_name[MAX_MACRO_MOD]; /*!< マクロ上で取り扱う特殊キーを文字列上で表現するためのフォーマットを記録した文字列ポインタ配列 */
 130 concptr macro_trigger_name[MAX_MACRO_TRIG]; /*!< マクロのトリガーコード */
 131 concptr macro_trigger_keycode[2][MAX_MACRO_TRIG];  /*!< マクロの内容 */
 132
 133 s16b command_cmd;               /* Current "Angband Command" */
 134 COMMAND_ARG command_arg;        /*!< 各種コマンドの汎用的な引数として扱う / Gives argument of current command */
 135 COMMAND_NUM command_rep;        /*!< 各種コマンドの汎用的なリピート数として扱う / Gives repetition of current command */
 136 DIRECTION command_dir;          /*!< 各種コマンドの汎用的な方向値処理として扱う/ Gives direction of current command */
 137 s16b command_see;               /* See "object1.c" */
 138 s16b command_wrk;               /* See "object1.c" */
 139 TERM_LEN command_gap = 999;         /* See "object1.c" */
 140 s16b command_new;               /* Command chaining from inven/equip view */
 141
 142
 143
 144 #if 0
 145 #ifndef HAS_STRICMP
 146
 147 /*
 148  * For those systems that don't have "stricmp()"
 149  *
 150  * Compare the two strings "a" and "b" ala "strcmp()" ignoring case.
 151  */
 152 int stricmp(concptr a, concptr b)
 153 {
 154         concptr s1, s2;
 155         char z1, z2;
 156
 157         /* Scan the strings */
 158         for (s1 = a, s2 = b; TRUE; s1++, s2++)
 159         {
 160                 z1 = FORCEUPPER(*s1);
 161                 z2 = FORCEUPPER(*s2);
 162                 if (z1 < z2) return (-1);
 163                 if (z1 > z2) return (1);
 164                 if (!z1) return (0);
 165         }
 166 }
 167
 168 #endif /* HAS_STRICMP */
 169 #endif /* 0 */
 170
 171 #ifdef SET_UID
 172
 173 # ifndef HAVE_USLEEP
 174
 175 /*
 176  * For those systems that don't have "usleep()" but need it.
 177  *
 178  * Fake "usleep()" function grabbed from the inl netrek server -cba
 179  */
 180 int usleep(huge usecs)
 181 {
 182         struct timeval      Timer;
 183
 184         int                 nfds = 0;
 185
 186 #ifdef FD_SET
 187         fd_set          *no_fds = NULL;
 188 #else
 189         int                     *no_fds = NULL;
 190 #endif
 191
 192
 193         /* Was: int readfds, writefds, exceptfds; */
 194         /* Was: readfds = writefds = exceptfds = 0; */
 195
 196
 197         /* Paranoia -- No excessive sleeping */
 198         if (usecs > 4000000L) core(_("不当な usleep() 呼び出し", "Illegal usleep() call"));
 199
 200         /* Wait for it */
 201         Timer.tv_sec = (usecs / 1000000L);
 202         Timer.tv_usec = (usecs % 1000000L);
 203
 204         /* Wait for it */
 205         if (select(nfds, no_fds, no_fds, no_fds, &Timer) < 0)
 206         {
 207                 /* Hack -- ignore interrupts */
 208                 if (errno != EINTR) return -1;
 209         }
 210
 211         /* Success */
 212         return 0;
 213 }
 214
 215 # endif
 216
 217
 218 /*
 219  * Hack -- External functions
 220  */
 221 #ifdef SET_UID
 222 extern struct passwd *getpwuid(uid_t uid);
 223 extern struct passwd *getpwnam(concptr name);
 224 #endif
 225
 226
 227 /*
 228  * Find a default user name from the system.
 229  */
 230 void user_name(char *buf, int id)
 231 {
 232         struct passwd *pw;
 233
 234         /* Look up the user name */
 235         if ((pw = getpwuid(id)))
 236         {
 237                 (void)strcpy(buf, pw->pw_name);
 238                 buf[16] = '\0';
 239
 240 #ifdef CAPITALIZE_USER_NAME
 241                 /* Hack -- capitalize the user name */
 242 #ifdef JP
 243                 if (!iskanji(buf[0]))
 244 #endif
 245                         if (islower(buf[0]))
 246                                 buf[0] = toupper(buf[0]);
 247 #endif /* CAPITALIZE_USER_NAME */
 248
 249                 return;
 250         }
 251
 252         /* Oops.  Hack -- default to "PLAYER" */
 253         strcpy(buf, "PLAYER");
 254 }
 255
 256 #endif /* SET_UID */
 257
 258
 259
 260
 261 /*
 262  * The concept of the "file" routines below (and elsewhere) is that all
 263  * file handling should be done using as few routines as possible, since
 264  * every machine is slightly different, but these routines always have the
 265  * same semantics.
 266  *
 267  * In fact, perhaps we should use the "path_parse()" routine below to convert
 268  * from "canonical" filenames (optional leading tilde's, internal wildcards,
 269  * slash as the path seperator, etc) to "system" filenames (no special symbols,
 270  * system-specific path seperator, etc).  This would allow the program itself
 271  * to assume that all filenames are "Unix" filenames, and explicitly "extract"
 272  * such filenames if needed (by "path_parse()", or perhaps "path_canon()").
 273  *
 274  * Note that "path_temp" should probably return a "canonical" filename.
 275  *
 276  * Note that "my_fopen()" and "my_open()" and "my_make()" and "my_kill()"
 277  * and "my_move()" and "my_copy()" should all take "canonical" filenames.
 278  *
 279  * Note that "canonical" filenames use a leading "slash" to indicate an absolute
 280  * path, and a leading "tilde" to indicate a special directory, and default to a
 281  * relative path, but MSDOS uses a leading "drivename plus colon" to indicate the
 282  * use of a "special drive", and then the rest of the path is parsed "normally",
 283  * and MACINTOSH uses a leading colon to indicate a relative path, and an embedded
 284  * colon to indicate a "drive plus absolute path", and finally defaults to a file
 285  * in the current working directory, which may or may not be defined.
 286  *
 287  * We should probably parse a leading "~~/" as referring to "ANGBAND_DIR". (?)
 288  */
 289
 290
 291 #ifdef ACORN
 292
 293
 294 /*
 295  * Most of the "file" routines for "ACORN" should be in "main-acn.c"
 296  */
 297
 298
 299 #else /* ACORN */
 300
 301
 302 #ifdef SET_UID
 303
 304 /*
 305  * Extract a "parsed" path from an initial filename
 306  * Normally, we simply copy the filename into the buffer
 307  * But leading tilde symbols must be handled in a special way
 308  * Replace "~user/" by the home directory of the user named "user"
 309  * Replace "~/" by the home directory of the current user
 310  */
 311 errr path_parse(char *buf, int max, concptr file)
 312 {
 313         concptr         u, s;
 314         struct passwd   *pw;
 315         char            user[128];
 316
 317
 318         /* Assume no result */
 319         buf[0] = '\0';
 320
 321         /* No file? */
 322         if (!file) return (-1);
 323
 324         /* File needs no parsing */
 325         if (file[0] != '~')
 326         {
 327                 (void)strnfmt(buf, max, "%s", file);
 328                 return (0);
 329         }
 330
 331         /* Point at the user */
 332         u = file+1;
 333
 334         /* Look for non-user portion of the file */
 335         s = my_strstr(u, PATH_SEP);
 336
 337         /* Hack -- no long user names */
 338         if (s && (s >= u + sizeof(user))) return (1);
 339
 340         /* Extract a user name */
 341         if (s)
 342         {
 343                 int i;
 344                 for (i = 0; u < s; ++i) user[i] = *u++;
 345                 user[i] = '\0';
 346                 u = user;
 347         }
 348
 349         /* Look up the "current" user */
 350         if (u[0] == '\0') u = getlogin();
 351
 352         /* Look up a user (or "current" user) */
 353         if (u) pw = getpwnam(u);
 354         else pw = getpwuid(getuid());
 355
 356         /* Nothing found? */
 357         if (!pw) return (1);
 358
 359         /* Make use of the info */
 360         if (s) strnfmt(buf, max, "%s%s", pw->pw_dir, s);
 361         else strnfmt(buf, max, "%s", pw->pw_dir);
 362
 363         /* Success */
 364         return (0);
 365 }
 366
 367
 368 #else /* SET_UID */
 369
 370
 371 /*
 372  * Extract a "parsed" path from an initial filename
 373  *
 374  * This requires no special processing on simple machines,
 375  * except for verifying the size of the filename.
 376  */
 377 errr path_parse(char *buf, int max, concptr file)
 378 {
 379         /* Accept the filename */
 380         (void)strnfmt(buf, max, "%s", file);
 381
 382 #if defined(MAC_MPW) && defined(CARBON)
 383      /* Fix it according to the current operating system */
 384     convert_pathname(buf);
 385 #endif /* MAC_MPW && CARBON */
 386
 387         /* Success */
 388         return (0);
 389 }
 390
 391
 392 #endif /* SET_UID */
 393
 394
 395 #ifndef HAVE_MKSTEMP
 396
 397 /*
 398  * Hack -- acquire a "temporary" file name if possible
 399  *
 400  * This filename is always in "system-specific" form.
 401  */
 402 static errr path_temp(char *buf, int max)
 403 {
 404         concptr s;
 405
 406         /* Temp file */
 407         s = tmpnam(NULL);
 408
 409         if (!s) return (-1);
 410
 411         /* Format to length */
 412 #if !defined(WIN32) || (defined(_MSC_VER) && (_MSC_VER >= 1900))
 413         (void)strnfmt(buf, max, "%s", s);
 414 #else
 415         (void)strnfmt(buf, max, ".%s", s);
 416 #endif
 417
 418         /* Success */
 419         return (0);
 420 }
 421
 422 #endif
 423
 424 /*!
 425  * @brief ファイル入出力のためのパス生成する。/ Create a new path by appending a file (or directory) to a path.
 426  * @param buf ファイルのフルを返すバッファ
 427  * @param max bufのサイズ
 428  * @param path ファイルパス
 429  * @param file ファイル名
 430  * @return エラーコード(ただし常に0を返す)
 431  *
 432  * This requires no special processing on simple machines, except
 433  * for verifying the size of the filename, but note the ability to
 434  * bypass the given "path" with certain special file-names.
 435  *
 436  * Note that the "file" may actually be a "sub-path", including
 437  * a path and a file.
 438  *
 439  * Note that this function yields a path which must be "parsed"
 440  * using the "parse" function above.
 441  */
 442 errr path_build(char *buf, int max, concptr path, concptr file)
 443 {
 444         /* Special file */
 445         if (file[0] == '~')
 446         {
 447                 /* Use the file itself */
 448                 (void)strnfmt(buf, max, "%s", file);
 449         }
 450
 451         /* Absolute file, on "normal" systems */
 452         else if (prefix(file, PATH_SEP) && !streq(PATH_SEP, ""))
 453         {
 454                 /* Use the file itself */
 455                 (void)strnfmt(buf, max, "%s", file);
 456         }
 457
 458         /* No path given */
 459         else if (!path[0])
 460         {
 461                 /* Use the file itself */
 462                 (void)strnfmt(buf, max, "%s", file);
 463         }
 464
 465         /* Path and File */
 466         else
 467         {
 468                 /* Build the new path */
 469                 (void)strnfmt(buf, max, "%s%s%s", path, PATH_SEP, file);
 470         }
 471
 472         /* Success */
 473         return (0);
 474 }
 475
 476
 477 /*
 478  * Hack -- replacement for "fopen()"
 479  */
 480 FILE *my_fopen(concptr file, concptr mode)
 481 {
 482         char buf[1024];
 483
 484 #if defined(MAC_MPW) || defined(MACH_O_CARBON)
 485         FILE *tempfff;
 486 #endif
 487
 488         /* Hack -- Try to parse the path */
 489         if (path_parse(buf, 1024, file)) return (NULL);
 490
 491 #if defined(MAC_MPW) || defined(MACH_O_CARBON)
 492         if (my_strchr(mode, 'w'))
 493         {
 494                 /* setting file type/creator */
 495                 tempfff = fopen(buf, mode);
 496                 fsetfileinfo(buf, _fcreator, _ftype);
 497                 fclose(tempfff);
 498         }
 499 #endif
 500
 501         /* Attempt to fopen the file anyway */
 502         return (fopen(buf, mode));
 503 }
 504
 505
 506 /*
 507  * Hack -- replacement for "fclose()"
 508  */
 509 errr my_fclose(FILE *fff)
 510 {
 511         /* Require a file */
 512         if (!fff) return (-1);
 513
 514         /* Close, check for error */
 515         if (fclose(fff) == EOF) return (1);
 516
 517         /* Success */
 518         return (0);
 519 }
 520
 521
 522 #endif /* ACORN */
 523
 524
 525 #ifdef HAVE_MKSTEMP
 526
 527 FILE *my_fopen_temp(char *buf, int max)
 528 {
 529         int fd;
 530
 531         /* Prepare the buffer for mkstemp */
 532         strncpy(buf, "/tmp/anXXXXXX", max);
 533
 534         /* Secure creation of a temporary file */
 535         fd = mkstemp(buf);
 536
 537         /* Check the file-descriptor */
 538         if (fd < 0) return (NULL);
 539
 540         /* Return a file stream */
 541         return (fdopen(fd, "w"));
 542 }
 543
 544 #else /* HAVE_MKSTEMP */
 545
 546 FILE *my_fopen_temp(char *buf, int max)
 547 {
 548         /* Generate a temporary filename */
 549         if (path_temp(buf, max)) return (NULL);
 550         return (my_fopen(buf, "w"));
 551 }
 552
 553 #endif /* HAVE_MKSTEMP */
 554
 555
 556 /*
 557  * Hack -- replacement for "fgets()"
 558  *
 559  * Read a string, without a newline, to a file
 560  *
 561  * Process tabs, strip internal non-printables
 562  */
 563 errr my_fgets(FILE *fff, char *buf, huge n)
 564 {
 565         huge i = 0;
 566         char *s;
 567         char tmp[1024];
 568
 569         /* Read a line */
 570         if (fgets(tmp, 1024, fff))
 571         {
 572 #ifdef JP
 573                 guess_convert_to_system_encoding(tmp, sizeof(tmp));
 574 #endif
 575
 576                 /* Convert weirdness */
 577                 for (s = tmp; *s; s++)
 578                 {
 579 #if defined(MACINTOSH) || defined(MACH_O_CARBON)
 580
 581                         /*
 582                          * Be nice to the Macintosh, where a file can have Mac or Unix
 583                          * end of line, especially since the introduction of OS X.
 584                          * MPW tools were also very tolerant to the Unix EOL.
 585                          */
 586                         if (*s == '\r') *s = '\n';
 587
 588 #endif /* MACINTOSH || MACH_O_CARBON */
 589
 590                         /* Handle newline */
 591                         if (*s == '\n')
 592                         {
 593                                 /* Terminate */
 594                                 buf[i] = '\0';
 595
 596                                 /* Success */
 597                                 return (0);
 598                         }
 599
 600                         /* Handle tabs */
 601                         else if (*s == '\t')
 602                         {
 603                                 /* Hack -- require room */
 604                                 if (i + 8 >= n) break;
 605
 606                                 /* Append a space */
 607                                 buf[i++] = ' ';
 608
 609                                 /* Append some more spaces */
 610                                 while (0 != (i % 8)) buf[i++] = ' ';
 611                         }
 612
 613 #ifdef JP
 614                         else if (iskanji(*s))
 615                         {
 616                                 if (!s[1]) break;
 617                                 buf[i++] = *s++;
 618                                 buf[i++] = *s;
 619                         }
 620
 621                         /* 半角かなに対応 */
 622                         else if (iskana(*s))
 623                         {
 624                                 buf[i++] = *s;
 625                                 if (i >= n) break;
 626                         }
 627 #endif
 628                         /* Handle printables */
 629                         else if (isprint((unsigned char)*s))
 630                         {
 631                                 /* Copy */
 632                                 buf[i++] = *s;
 633
 634                                 /* Check length */
 635                                 if (i >= n) break;
 636                         }
 637                 }
 638                 /* No newline character, but terminate */
 639                 buf[i] = '\0';
 640
 641                 /* Success */
 642                 return (0);
 643         }
 644
 645         /* Nothing */
 646         buf[0] = '\0';
 647
 648         /* Failure */
 649         return (1);
 650 }
 651
 652
 653 /*
 654  * Hack -- replacement for "fputs()"
 655  * Dump a string, plus a newline, to a file
 656  * Process internal weirdness?
 657  */
 658 errr my_fputs(FILE *fff, concptr buf, huge n)
 659 {
 660         /* XXX XXX */
 661         n = n ? n : 0;
 662
 663         /* Dump, ignore errors */
 664         (void)fprintf(fff, "%s\n", buf);
 665
 666         /* Success */
 667         return (0);
 668 }
 669
 670
 671 #ifdef ACORN
 672
 673
 674 /*
 675  * Most of the "file" routines for "ACORN" should be in "main-acn.c"
 676  *
 677  * Many of them can be rewritten now that only "fd_open()" and "fd_make()"
 678  * and "my_fopen()" should ever create files.
 679  */
 680
 681
 682 #else /* ACORN */
 683
 684
 685 /*
 686  * The Macintosh is a little bit brain-dead sometimes
 687  */
 688 #ifdef MACINTOSH
 689 # define open(N,F,M) \
 690 ((M), open((char*)(N),F))
 691 # define write(F,B,S) \
 692 write(F,(char*)(B),S)
 693 #endif /* MACINTOSH */
 694
 695
 696 /*
 697  * Several systems have no "O_BINARY" flag
 698  */
 699 #ifndef O_BINARY
 700 # define O_BINARY 0
 701 #endif /* O_BINARY */
 702
 703
 704 /*
 705  * Hack -- attempt to delete a file
 706  */
 707 errr fd_kill(concptr file)
 708 {
 709         char buf[1024];
 710
 711         /* Hack -- Try to parse the path */
 712         if (path_parse(buf, 1024, file)) return (-1);
 713
 714         /* Remove */
 715         (void)remove(buf);
 716
 717         return (0);
 718 }
 719
 720
 721 /*
 722  * Hack -- attempt to move a file
 723  */
 724 errr fd_move(concptr file, concptr what)
 725 {
 726         char buf[1024];
 727         char aux[1024];
 728
 729         /* Hack -- Try to parse the path */
 730         if (path_parse(buf, 1024, file)) return (-1);
 731
 732         /* Hack -- Try to parse the path */
 733         if (path_parse(aux, 1024, what)) return (-1);
 734
 735         /* Rename */
 736         (void)rename(buf, aux);
 737
 738         return (0);
 739 }
 740
 741
 742 /*
 743  * Hack -- attempt to copy a file
 744  */
 745 errr fd_copy(concptr file, concptr what)
 746 {
 747         char buf[1024];
 748         char aux[1024];
 749         int read_num;
 750         int src_fd, dst_fd;
 751
 752         /* Hack -- Try to parse the path */
 753         if (path_parse(buf, 1024, file)) return (-1);
 754
 755         /* Hack -- Try to parse the path */
 756         if (path_parse(aux, 1024, what)) return (-1);
 757
 758         /* Open source file */
 759         src_fd = fd_open(buf, O_RDONLY);
 760         if (src_fd < 0) return (-1);
 761
 762         /* Open destination file */
 763         dst_fd = fd_open(aux, O_WRONLY|O_TRUNC|O_CREAT);
 764         if (dst_fd < 0) return (-1);
 765
 766         /* Copy */
 767         while ((read_num = read(src_fd, buf, 1024)) > 0)
 768         {
 769                 int write_num = 0;
 770                 while (write_num < read_num)
 771                 {
 772                         int ret = write(dst_fd, buf + write_num, read_num - write_num);
 773                         if (ret < 0) {
 774                                 /* Close files */
 775                                 fd_close(src_fd);
 776                                 fd_close(dst_fd);
 777
 778                                 return ret;
 779                         }
 780                         write_num += ret;
 781                 }
 782         }
 783
 784         /* Close files */
 785         fd_close(src_fd);
 786         fd_close(dst_fd);
 787
 788         return (0);
 789 }
 790
 791 /*
 792  * Hack -- attempt to open a file descriptor (create file)
 793  * This function should fail if the file already exists
 794  * Note that we assume that the file should be "binary"
 795  */
 796 int fd_make(concptr file, BIT_FLAGS mode)
 797 {
 798         char buf[1024];
 799
 800         /* Hack -- Try to parse the path */
 801         if (path_parse(buf, 1024, file)) return (-1);
 802
 803 #if defined(MAC_MPW) || defined(MACH_O_CARBON)
 804         {
 805                 int fdes;
 806                 /* Create the file, fail if exists, write-only, binary */
 807                 fdes = open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, mode);
 808                 /* Set creator and type if the file is successfully opened */
 809                 if (fdes >= 0) fsetfileinfo(buf, _fcreator, _ftype);
 810                 /* Return the descriptor */
 811                 return (fdes);
 812         }
 813 #else
 814         /* Create the file, fail if exists, write-only, binary */
 815         return (open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, mode));
 816 #endif
 817
 818 }
 819
 820
 821 /*
 822  * Hack -- attempt to open a file descriptor (existing file)
 823  *
 824  * Note that we assume that the file should be "binary"
 825  */
 826 int fd_open(concptr file, int flags)
 827 {
 828         char buf[1024];
 829
 830         /* Hack -- Try to parse the path */
 831         if (path_parse(buf, 1024, file)) return (-1);
 832
 833         /* Attempt to open the file */
 834         return (open(buf, flags | O_BINARY, 0));
 835 }
 836
 837
 838 /*
 839  * Hack -- attempt to lock a file descriptor
 840  *
 841  * Legal lock types -- F_UNLCK, F_RDLCK, F_WRLCK
 842  */
 843 errr fd_lock(int fd, int what)
 844 {
 845         /* XXX XXX */
 846         what = what ? what : 0;
 847
 848         /* Verify the fd */
 849         if (fd < 0) return (-1);
 850
 851 #ifdef SET_UID
 852
 853 # ifdef USG
 854
 855 #  if defined(F_ULOCK) && defined(F_LOCK)
 856
 857         /* Un-Lock */
 858         if (what == F_UNLCK)
 859         {
 860                 /* Unlock it, Ignore errors */
 861                 lockf(fd, F_ULOCK, 0);
 862         }
 863
 864         /* Lock */
 865         else
 866         {
 867                 /* Lock the score file */
 868                 if (lockf(fd, F_LOCK, 0) != 0) return (1);
 869         }
 870
 871 #  endif
 872
 873 # else
 874
 875 #  if defined(LOCK_UN) && defined(LOCK_EX)
 876
 877         /* Un-Lock */
 878         if (what == F_UNLCK)
 879         {
 880                 /* Unlock it, Ignore errors */
 881                 (void)flock(fd, LOCK_UN);
 882         }
 883
 884         /* Lock */
 885         else
 886         {
 887                 /* Lock the score file */
 888                 if (flock(fd, LOCK_EX) != 0) return (1);
 889         }
 890
 891 #  endif
 892
 893 # endif
 894
 895 #endif
 896
 897         /* Success */
 898         return (0);
 899 }
 900
 901
 902 /*
 903  * Hack -- attempt to seek on a file descriptor
 904  */
 905 errr fd_seek(int fd, huge n)
 906 {
 907         huge p;
 908
 909         /* Verify fd */
 910         if (fd < 0) return (-1);
 911
 912         /* Seek to the given position */
 913         p = lseek(fd, n, SEEK_SET);
 914
 915         /* Failure */
 916         if (p != n) return (1);
 917
 918         /* Success */
 919         return (0);
 920 }
 921
 922
 923 /*
 924  * Hack -- attempt to truncate a file descriptor
 925  */
 926 errr fd_chop(int fd, huge n)
 927 {
 928         /* XXX XXX */
 929         n = n ? n : 0;
 930
 931         /* Verify the fd */
 932         if (fd < 0) return (-1);
 933
 934 #if defined(ULTRIX) || defined(NeXT)
 935         /* Truncate */
 936         ftruncate(fd, n);
 937 #endif
 938
 939         /* Success */
 940         return (0);
 941 }
 942
 943
 944 /*
 945  * Hack -- attempt to read data from a file descriptor
 946  */
 947 errr fd_read(int fd, char *buf, huge n)
 948 {
 949         /* Verify the fd */
 950         if (fd < 0) return (-1);
 951
 952 #ifndef SET_UID
 953
 954         /* Read pieces */
 955         while (n >= 16384)
 956         {
 957                 /* Read a piece */
 958                 if (read(fd, buf, 16384) != 16384) return (1);
 959
 960                 /* Shorten the task */
 961                 buf += 16384;
 962
 963                 /* Shorten the task */
 964                 n -= 16384;
 965         }
 966
 967 #endif
 968
 969         /* Read the final piece */
 970         if (read(fd, buf, n) != (int)n) return (1);
 971
 972         /* Success */
 973         return (0);
 974 }
 975
 976
 977 /*
 978  * Hack -- Attempt to write data to a file descriptor
 979  */
 980 errr fd_write(int fd, concptr buf, huge n)
 981 {
 982         /* Verify the fd */
 983         if (fd < 0) return (-1);
 984
 985 #ifndef SET_UID
 986
 987         /* Write pieces */
 988         while (n >= 16384)
 989         {
 990                 /* Write a piece */
 991                 if (write(fd, buf, 16384) != 16384) return (1);
 992
 993                 /* Shorten the task */
 994                 buf += 16384;
 995
 996                 /* Shorten the task */
 997                 n -= 16384;
 998         }
 999
1000 #endif
1001
1002         /* Write the final piece */
1003         if (write(fd, buf, n) != (int)n) return (1);
1004
1005         /* Success */
1006         return (0);
1007 }
1008
1009
1010 /*
1011  * Hack -- attempt to close a file descriptor
1012  */
1013 errr fd_close(int fd)
1014 {
1015         /* Verify the fd */
1016         if (fd < 0) return (-1);
1017
1018         /* Close */
1019         (void)close(fd);
1020
1021         return (0);
1022 }
1023
1024
1025 #endif /* ACORN */
1026
1027
1028
1029
1030 /*
1031  * Important note about "colors"
1032  *
1033  * The "TERM_*" color definitions list the "composition" of each
1034  * "Angband color" in terms of "quarters" of each of the three color
1035  * components (Red, Green, Blue), for example, TERM_UMBER is defined
1036  * as 2/4 Red, 1/4 Green, 0/4 Blue.
1037  *
1038  * The following info is from "Torbjorn Lindgren" (see "main-xaw.c").
1039  *
1040  * These values are NOT gamma-corrected.  On most machines (with the
1041  * Macintosh being an important exception), you must "gamma-correct"
1042  * the given values, that is, "correct for the intrinsic non-linearity
1043  * of the phosphor", by converting the given intensity levels based
1044  * on the "gamma" of the target screen, which is usually 1.7 (or 1.5).
1045  *
1046  * The actual formula for conversion is unknown to me at this time,
1047  * but you can use the table below for the most common gamma values.
1048  *
1049  * So, on most machines, simply convert the values based on the "gamma"
1050  * of the target screen, which is usually in the range 1.5 to 1.7, and
1051  * usually is closest to 1.7.  The converted value for each of the five
1052  * different "quarter" values is given below:
1053  *
1054  *  Given     Gamma 1.0       Gamma 1.5       Gamma 1.7     Hex 1.7
1055  *  -----       ----            ----            ----          ---
1056  *   0/4        0.00            0.00            0.00          #00
1057  *   1/4        0.25            0.27            0.28          #47
1058  *   2/4        0.50            0.55            0.56          #8f
1059  *   3/4        0.75            0.82            0.84          #d7
1060  *   4/4        1.00            1.00            1.00          #ff
1061  *
1062  * Note that some machines (i.e. most IBM machines) are limited to a
1063  * hard-coded set of colors, and so the information above is useless.
1064  *
1065  * Also, some machines are limited to a pre-determined set of colors,
1066  * for example, the IBM can only display 16 colors, and only 14 of
1067  * those colors resemble colors used by Angband, and then only when
1068  * you ignore the fact that "Slate" and "cyan" are not really matches,
1069  * so on the IBM, we use "orange" for both "Umber", and "Light Umber"
1070  * in addition to the obvious "Orange", since by combining all of the
1071  * "indeterminate" colors into a single color, the rest of the colors
1072  * are left with "meaningful" values.
1073  */
1074
1075
1076 /*
1077  * Move the cursor
1078  */
1079 void move_cursor(int row, int col)
1080 {
1081         Term_gotoxy(col, row);
1082 }
1083
1084
1085
1086 /*
1087  * Convert a decimal to a single digit octal number
1088  */
1089 static char octify(uint i)
1090 {
1091         return (hexsym[i%8]);
1092 }
1093
1094 /*
1095  * Convert a decimal to a single digit hex number
1096  */
1097 static char hexify(uint i)
1098 {
1099         return (hexsym[i%16]);
1100 }
1101
1102
1103 /*
1104  * Convert a octal-digit into a decimal
1105  */
1106 static int deoct(char c)
1107 {
1108         if (isdigit(c)) return (D2I(c));
1109         return (0);
1110 }
1111
1112 /*
1113  * Convert a hexidecimal-digit into a decimal
1114  */
1115 static int dehex(char c)
1116 {
1117         if (isdigit(c)) return (D2I(c));
1118         if (islower(c)) return (A2I(c) + 10);
1119         if (isupper(c)) return (A2I(tolower(c)) + 10);
1120         return (0);
1121 }
1122
1123
1124 static int my_stricmp(concptr a, concptr b)
1125 {
1126         concptr s1, s2;
1127         char z1, z2;
1128
1129         /* Scan the strings */
1130         for (s1 = a, s2 = b; TRUE; s1++, s2++)
1131         {
1132                 z1 = FORCEUPPER(*s1);
1133                 z2 = FORCEUPPER(*s2);
1134                 if (z1 < z2) return (-1);
1135                 if (z1 > z2) return (1);
1136                 if (!z1) return (0);
1137         }
1138 }
1139
1140 static int my_strnicmp(concptr a, concptr b, int n)
1141 {
1142         concptr s1, s2;
1143         char z1, z2;
1144
1145         /* Scan the strings */
1146         for (s1 = a, s2 = b; n > 0; s1++, s2++, n--)
1147         {
1148                 z1 = FORCEUPPER(*s1);
1149                 z2 = FORCEUPPER(*s2);
1150                 if (z1 < z2) return (-1);
1151                 if (z1 > z2) return (1);
1152                 if (!z1) return (0);
1153         }
1154         return 0;
1155 }
1156
1157
1158 static void trigger_text_to_ascii(char **bufptr, concptr *strptr)
1159 {
1160         char *s = *bufptr;
1161         concptr str = *strptr;
1162         bool mod_status[MAX_MACRO_MOD];
1163
1164         int i, len = 0;
1165         int shiftstatus = 0;
1166         concptr key_code;
1167
1168         if (macro_template == NULL)
1169                 return;
1170
1171         for (i = 0; macro_modifier_chr[i]; i++)
1172                 mod_status[i] = FALSE;
1173         str++;
1174
1175         /* Examine modifier keys */
1176         while (1)
1177         {
1178                 for (i=0; macro_modifier_chr[i]; i++)
1179                 {
1180                         len = strlen(macro_modifier_name[i]);
1181
1182                         if(!my_strnicmp(str, macro_modifier_name[i], len))
1183                                 break;
1184                 }
1185                 if (!macro_modifier_chr[i]) break;
1186                 str += len;
1187                 mod_status[i] = TRUE;
1188                 if ('S' == macro_modifier_chr[i])
1189                         shiftstatus = 1;
1190         }
1191         for (i = 0; i < max_macrotrigger; i++)
1192         {
1193                 len = strlen(macro_trigger_name[i]);
1194                 if (!my_strnicmp(str, macro_trigger_name[i], len) && ']' == str[len])
1195                 {
1196                         /* a trigger name found */
1197                         break;
1198                 }
1199         }
1200
1201         /* Invalid trigger name? */
1202         if (i == max_macrotrigger)
1203         {
1204                 str = my_strchr(str, ']');
1205                 if (str)
1206                 {
1207                         *s++ = (char)31;
1208                         *s++ = '\r';
1209                         *bufptr = s;
1210                         *strptr = str; /* where **strptr == ']' */
1211                 }
1212                 return;
1213         }
1214         key_code = macro_trigger_keycode[shiftstatus][i];
1215         str += len;
1216
1217         *s++ = (char)31;
1218         for (i = 0; macro_template[i]; i++)
1219         {
1220                 char ch = macro_template[i];
1221                 int j;
1222
1223                 switch(ch)
1224                 {
1225                 case '&':
1226                         for (j = 0; macro_modifier_chr[j]; j++) {
1227                                 if (mod_status[j])
1228                                         *s++ = macro_modifier_chr[j];
1229                         }
1230                         break;
1231                 case '#':
1232                         strcpy(s, key_code);
1233                         s += strlen(key_code);
1234                         break;
1235                 default:
1236                         *s++ = ch;
1237                         break;
1238                 }
1239         }
1240         *s++ = '\r';
1241
1242         *bufptr = s;
1243         *strptr = str; /* where **strptr == ']' */
1244         return;
1245 }
1246
1247
1248 /*
1249  * Hack -- convert a printable string into real ascii
1250  *
1251  * I have no clue if this function correctly handles, for example,
1252  * parsing "\xFF" into a (signed) char.  Whoever thought of making
1253  * the "sign" of a "char" undefined is a complete moron.  Oh well.
1254  */
1255 void text_to_ascii(char *buf, concptr str)
1256 {
1257         char *s = buf;
1258
1259         /* Analyze the "ascii" string */
1260         while (*str)
1261         {
1262                 /* Backslash codes */
1263                 if (*str == '\\')
1264                 {
1265                         /* Skip the backslash */
1266                         str++;
1267                         if (!(*str)) break;
1268
1269                         /* Macro Trigger */
1270                         if (*str == '[')
1271                         {
1272                                 trigger_text_to_ascii(&s, &str);
1273                         }
1274                         else
1275
1276                         /* Hex-mode XXX */
1277                         if (*str == 'x')
1278                         {
1279                                 *s = 16 * (char)dehex(*++str);
1280                                 *s++ += (char)dehex(*++str);
1281                         }
1282
1283                         /* Hack -- simple way to specify "backslash" */
1284                         else if (*str == '\\')
1285                         {
1286                                 *s++ = '\\';
1287                         }
1288
1289                         /* Hack -- simple way to specify "caret" */
1290                         else if (*str == '^')
1291                         {
1292                                 *s++ = '^';
1293                         }
1294
1295                         /* Hack -- simple way to specify "space" */
1296                         else if (*str == 's')
1297                         {
1298                                 *s++ = ' ';
1299                         }
1300
1301                         /* Hack -- simple way to specify Escape */
1302                         else if (*str == 'e')
1303                         {
1304                                 *s++ = ESCAPE;
1305                         }
1306
1307                         /* Backspace */
1308                         else if (*str == 'b')
1309                         {
1310                                 *s++ = '\b';
1311                         }
1312
1313                         /* Newline */
1314                         else if (*str == 'n')
1315                         {
1316                                 *s++ = '\n';
1317                         }
1318
1319                         /* Return */
1320                         else if (*str == 'r')
1321                         {
1322                                 *s++ = '\r';
1323                         }
1324
1325                         /* Tab */
1326                         else if (*str == 't')
1327                         {
1328                                 *s++ = '\t';
1329                         }
1330
1331                         /* Octal-mode */
1332                         else if (*str == '0')
1333                         {
1334                                 *s = 8 * (char)deoct(*++str);
1335                                 *s++ += (char)deoct(*++str);
1336                         }
1337
1338                         /* Octal-mode */
1339                         else if (*str == '1')
1340                         {
1341                                 *s = 64 + 8 * (char)deoct(*++str);
1342                                 *s++ += (char)deoct(*++str);
1343                         }
1344
1345                         /* Octal-mode */
1346                         else if (*str == '2')
1347                         {
1348                                 *s = 64 * 2 + 8 * (char)deoct(*++str);
1349                                 *s++ += (char)deoct(*++str);
1350                         }
1351
1352                         /* Octal-mode */
1353                         else if (*str == '3')
1354                         {
1355                                 *s = 64 * 3 + 8 * (char)deoct(*++str);
1356                                 *s++ += (char)deoct(*++str);
1357                         }
1358
1359                         /* Skip the final char */
1360                         str++;
1361                 }
1362
1363                 /* Normal Control codes */
1364                 else if (*str == '^')
1365                 {
1366                         str++;
1367                         *s++ = (*str++ & 037);
1368                 }
1369
1370                 /* Normal chars */
1371                 else
1372                 {
1373                         *s++ = *str++;
1374                 }
1375         }
1376
1377         /* Terminate */
1378         *s = '\0';
1379 }
1380
1381
1382 static bool trigger_ascii_to_text(char **bufptr, concptr *strptr)
1383 {
1384         char *s = *bufptr;
1385         concptr str = *strptr;
1386         char key_code[100];
1387         int i;
1388         concptr tmp;
1389
1390         if (macro_template == NULL)
1391                 return FALSE;
1392
1393         *s++ = '\\';
1394         *s++ = '[';
1395
1396         for (i = 0; macro_template[i]; i++)
1397         {
1398                 int j;
1399                 char ch = macro_template[i];
1400
1401                 switch(ch)
1402                 {
1403                 case '&':
1404                         while ((tmp = my_strchr(macro_modifier_chr, *str)) != 0)
1405                         {
1406                                 j = (int)(tmp - macro_modifier_chr);
1407                                 tmp = macro_modifier_name[j];
1408                                 while(*tmp) *s++ = *tmp++;
1409                                 str++;
1410                         }
1411                         break;
1412                 case '#':
1413                         for (j = 0; *str && *str != '\r'; j++)
1414                                 key_code[j] = *str++;
1415                         key_code[j] = '\0';
1416                         break;
1417                 default:
1418                         if (ch != *str) return FALSE;
1419                         str++;
1420                 }
1421         }
1422         if (*str++ != '\r') return FALSE;
1423
1424         for (i = 0; i < max_macrotrigger; i++)
1425         {
1426                 if (!my_stricmp(key_code, macro_trigger_keycode[0][i])
1427                     || !my_stricmp(key_code, macro_trigger_keycode[1][i]))
1428                         break;
1429         }
1430         if (i == max_macrotrigger)
1431                 return FALSE;
1432
1433         tmp = macro_trigger_name[i];
1434         while (*tmp) *s++ = *tmp++;
1435
1436         *s++ = ']';
1437
1438         *bufptr = s;
1439         *strptr = str;
1440         return TRUE;
1441 }
1442
1443
1444 /*
1445  * Hack -- convert a string into a printable form
1446  */
1447 void ascii_to_text(char *buf, concptr str)
1448 {
1449         char *s = buf;
1450
1451         /* Analyze the "ascii" string */
1452         while (*str)
1453         {
1454                 byte i = (byte)(*str++);
1455
1456                 /* Macro Trigger */
1457                 if (i == 31)
1458                 {
1459                         if(!trigger_ascii_to_text(&s, &str))
1460                         {
1461                                 *s++ = '^';
1462                                 *s++ = '_';
1463                         }
1464                 }
1465                 else
1466
1467                 if (i == ESCAPE)
1468                 {
1469                         *s++ = '\\';
1470                         *s++ = 'e';
1471                 }
1472                 else if (i == ' ')
1473                 {
1474                         *s++ = '\\';
1475                         *s++ = 's';
1476                 }
1477                 else if (i == '\b')
1478                 {
1479                         *s++ = '\\';
1480                         *s++ = 'b';
1481                 }
1482                 else if (i == '\t')
1483                 {
1484                         *s++ = '\\';
1485                         *s++ = 't';
1486                 }
1487                 else if (i == '\n')
1488                 {
1489                         *s++ = '\\';
1490                         *s++ = 'n';
1491                 }
1492                 else if (i == '\r')
1493                 {
1494                         *s++ = '\\';
1495                         *s++ = 'r';
1496                 }
1497                 else if (i == '^')
1498                 {
1499                         *s++ = '\\';
1500                         *s++ = '^';
1501                 }
1502                 else if (i == '\\')
1503                 {
1504                         *s++ = '\\';
1505                         *s++ = '\\';
1506                 }
1507                 else if (i < 32)
1508                 {
1509                         *s++ = '^';
1510                         *s++ = i + 64;
1511                 }
1512                 else if (i < 127)
1513                 {
1514                         *s++ = i;
1515                 }
1516                 else if (i < 64)
1517                 {
1518                         *s++ = '\\';
1519                         *s++ = '0';
1520                         *s++ = octify(i / 8);
1521                         *s++ = octify(i % 8);
1522                 }
1523                 else
1524                 {
1525                         *s++ = '\\';
1526                         *s++ = 'x';
1527                         *s++ = hexify(i / 16);
1528                         *s++ = hexify(i % 16);
1529                 }
1530         }
1531
1532         /* Terminate */
1533         *s = '\0';
1534 }
1535
1536
1537
1538 /*
1539  * The "macro" package
1540  *
1541  * Functions are provided to manipulate a collection of macros, each
1542  * of which has a trigger pattern string and a resulting action string
1543  * and a small set of flags.
1544  */
1545
1546
1547
1548 /*
1549  * Determine if any macros have ever started with a given character.
1550  */
1551 static bool macro__use[256];
1552
1553
1554 /*
1555  * Find the macro (if any) which exactly matches the given pattern
1556  */
1557 sint macro_find_exact(concptr pat)
1558 {
1559         int i;
1560
1561         /* Nothing possible */
1562         if (!macro__use[(byte)(pat[0])])
1563         {
1564                 return (-1);
1565         }
1566
1567         /* Scan the macros */
1568         for (i = 0; i < macro__num; ++i)
1569         {
1570                 /* Skip macros which do not match the pattern */
1571                 if (!streq(macro__pat[i], pat)) continue;
1572
1573                 /* Found one */
1574                 return (i);
1575         }
1576
1577         /* No matches */
1578         return (-1);
1579 }
1580
1581
1582 /*
1583  * Find the first macro (if any) which contains the given pattern
1584  */
1585 static sint macro_find_check(concptr pat)
1586 {
1587         int i;
1588
1589         /* Nothing possible */
1590         if (!macro__use[(byte)(pat[0])])
1591         {
1592                 return (-1);
1593         }
1594
1595         /* Scan the macros */
1596         for (i = 0; i < macro__num; ++i)
1597         {
1598                 /* Skip macros which do not contain the pattern */
1599                 if (!prefix(macro__pat[i], pat)) continue;
1600
1601                 /* Found one */
1602                 return (i);
1603         }
1604
1605         /* Nothing */
1606         return (-1);
1607 }
1608
1609
1610 /*
1611  * Find the first macro (if any) which contains the given pattern and more
1612  */
1613 static sint macro_find_maybe(concptr pat)
1614 {
1615         int i;
1616
1617         /* Nothing possible */
1618         if (!macro__use[(byte)(pat[0])])
1619         {
1620                 return (-1);
1621         }
1622
1623         /* Scan the macros */
1624         for (i = 0; i < macro__num; ++i)
1625         {
1626                 /* Skip macros which do not contain the pattern */
1627                 if (!prefix(macro__pat[i], pat)) continue;
1628
1629                 /* Skip macros which exactly match the pattern XXX XXX */
1630                 if (streq(macro__pat[i], pat)) continue;
1631
1632                 /* Found one */
1633                 return (i);
1634         }
1635
1636         /* Nothing */
1637         return (-1);
1638 }
1639
1640
1641 /*
1642  * Find the longest macro (if any) which starts with the given pattern
1643  */
1644 static sint macro_find_ready(concptr pat)
1645 {
1646         int i, t, n = -1, s = -1;
1647
1648         /* Nothing possible */
1649         if (!macro__use[(byte)(pat[0])])
1650         {
1651                 return (-1);
1652         }
1653
1654         /* Scan the macros */
1655         for (i = 0; i < macro__num; ++i)
1656         {
1657                 /* Skip macros which are not contained by the pattern */
1658                 if (!prefix(pat, macro__pat[i])) continue;
1659
1660                 /* Obtain the length of this macro */
1661                 t = strlen(macro__pat[i]);
1662
1663                 /* Only track the "longest" pattern */
1664                 if ((n >= 0) && (s > t)) continue;
1665
1666                 /* Track the entry */
1667                 n = i;
1668                 s = t;
1669         }
1670         return (n);
1671 }
1672
1673
1674 /*
1675  * Add a macro definition (or redefinition).
1676  *
1677  * We should use "act == NULL" to "remove" a macro, but this might make it
1678  * impossible to save the "removal" of a macro definition.
1679  *
1680  * We should consider refusing to allow macros which contain existing macros,
1681  * or which are contained in existing macros, because this would simplify the
1682  * macro analysis code.
1683  *
1684  * We should consider removing the "command macro" crap, and replacing it
1685  * with some kind of "powerful keymap" ability, but this might make it hard
1686  * to change the "roguelike" option from inside the game.
1687  */
1688 errr macro_add(concptr pat, concptr act)
1689 {
1690         int n;
1691
1692
1693         /* Paranoia -- require data */
1694         if (!pat || !act) return (-1);
1695
1696
1697         /* Look for any existing macro */
1698         n = macro_find_exact(pat);
1699
1700         /* Replace existing macro */
1701         if (n >= 0)
1702         {
1703                 /* Free the old macro action */
1704                 string_free(macro__act[n]);
1705         }
1706
1707         /* Create a new macro */
1708         else
1709         {
1710                 /* Acquire a new index */
1711                 n = macro__num++;
1712
1713                 /* Save the pattern */
1714                 macro__pat[n] = string_make(pat);
1715         }
1716
1717         /* Save the action */
1718         macro__act[n] = string_make(act);
1719
1720         /* Efficiency */
1721         macro__use[(byte)(pat[0])] = TRUE;
1722
1723         /* Success */
1724         return (0);
1725 }
1726
1727
1728
1729 /*
1730  * Local variable -- we are inside a "macro action"
1731  *
1732  * Do not match any macros until "ascii 30" is found.
1733  */
1734 static bool parse_macro = FALSE;
1735
1736 /*
1737  * Local variable -- we are inside a "macro trigger"
1738  *
1739  * Strip all keypresses until a low ascii value is found.
1740  */
1741 static bool parse_under = FALSE;
1742
1743
1744 /*
1745  * Flush all input chars.  Actually, remember the flush,
1746  * and do a "special flush" before the next "inkey()".
1747  *
1748  * This is not only more efficient, but also necessary to make sure
1749  * that various "inkey()" codes are not "lost" along the way.
1750  */
1751 void flush(void)
1752 {
1753         /* Do it later */
1754         inkey_xtra = TRUE;
1755 }
1756
1757
1758 /*
1759  * Flush the screen, make a noise
1760  */
1761 void bell(void)
1762 {
1763         /* Mega-Hack -- Flush the output */
1764         Term_fresh();
1765
1766         /* Make a bell noise (if allowed) */
1767         if (ring_bell) Term_xtra(TERM_XTRA_NOISE, 0);
1768
1769         /* Flush the input (later!) */
1770         flush();
1771 }
1772
1773
1774 /*
1775  * Hack -- Make a (relevant?) sound
1776  */
1777 void sound(int val)
1778 {
1779         /* No sound */
1780         if (!use_sound) return;
1781
1782         /* Make a sound (if allowed) */
1783         Term_xtra(TERM_XTRA_SOUND, val);
1784 }
1785
1786 /*
1787  * Hack -- Play a music
1788  */
1789 errr play_music(int type, int val)
1790 {
1791         /* No sound */
1792         if (!use_music) return 1;
1793
1794         /* Make a sound (if allowed) */
1795         return Term_xtra(type, val);
1796 }
1797
1798 /*
1799  * Hack -- Select floor music.
1800  */
1801 void select_floor_music(player_type *player_ptr)
1802 {
1803         if (!use_music) return;
1804
1805         if (player_ptr->ambush_flag)
1806         {
1807                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_AMBUSH)) return;
1808         }
1809
1810         if(player_ptr->wild_mode)
1811         {
1812                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_WILD)) return;
1813         }
1814
1815         if(player_ptr->current_floor_ptr->inside_arena)
1816         {
1817                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_ARENA)) return;
1818         }
1819
1820         if(player_ptr->phase_out)
1821         {
1822                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_BATTLE)) return;
1823         }
1824
1825         if(player_ptr->current_floor_ptr->inside_quest)
1826         {
1827                 if (!play_music(TERM_XTRA_MUSIC_QUEST, player_ptr->current_floor_ptr->inside_quest)) return;
1828                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_QUEST)) return;
1829         }
1830
1831         if(player_ptr->dungeon_idx)
1832         {
1833                 if (player_ptr->feeling == 2)
1834                 {
1835                         if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_FEEL2)) return;
1836                 }
1837                 else if (player_ptr->feeling >= 3 && player_ptr->feeling <= 5)
1838                 {
1839                         if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_FEEL1)) return;
1840                 }
1841                 else
1842                 {
1843                         if (!play_music(TERM_XTRA_MUSIC_DUNGEON, player_ptr->dungeon_idx)) return;
1844
1845                         if (p_ptr->current_floor_ptr->dun_level < 40)
1846                         {
1847                                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_LOW)) return;
1848                         }
1849                         else if (p_ptr->current_floor_ptr->dun_level < 80)
1850                         {
1851                                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_MED)) return;
1852                         }
1853                         else
1854                         {
1855                                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_DUN_HIGH)) return;
1856                         }
1857                 }
1858         }
1859
1860         if(player_ptr->town_num)
1861         {
1862                 if (!play_music(TERM_XTRA_MUSIC_TOWN, player_ptr->town_num)) return;
1863                 if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_TOWN)) return;
1864                 return;
1865         }
1866
1867         if(!p_ptr->current_floor_ptr->dun_level)
1868         {
1869                 if (player_ptr->lev >= 45)
1870                 {
1871                         if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_FIELD3)) return;
1872                 }
1873                 else if (player_ptr->lev >= 25)
1874                 {
1875                         if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_FIELD2)) return;
1876                 }
1877                 else
1878                 {
1879                         if (!play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_FIELD1)) return;
1880                 }
1881         }
1882
1883         play_music(TERM_XTRA_MUSIC_MUTE, 0);
1884 }
1885
1886
1887
1888 /*
1889  * Helper function called only from "inkey()"
1890  *
1891  * This function does almost all of the "macro" processing.
1892  *
1893  * We use the "Term_key_push()" function to handle "failed" macros, as well
1894  * as "extra" keys read in while choosing the proper macro, and also to hold
1895  * the action for the macro, plus a special "ascii 30" character indicating
1896  * that any macro action in progress is complete.  Embedded macros are thus
1897  * illegal, unless a macro action includes an explicit "ascii 30" character,
1898  * which would probably be a massive hack, and might break things.
1899  *
1900  * Only 500 (0+1+2+...+29+30) milliseconds may elapse between each key in
1901  * the macro trigger sequence.  If a key sequence forms the "prefix" of a
1902  * macro trigger, 500 milliseconds must pass before the key sequence is
1903  * known not to be that macro trigger.
1904  */
1905 static char inkey_aux(void)
1906 {
1907         int k = 0, n, p = 0, w = 0;
1908
1909         char ch;
1910
1911         concptr pat, act;
1912
1913         char *buf = inkey_macro_trigger_string;
1914
1915         /* Hack : キー入力待ちで止まっているので、流れた行の記憶は不要。 */
1916         num_more = 0;
1917
1918         if (parse_macro)
1919         {
1920                 /* Scan next keypress from macro action */
1921                 if (Term_inkey(&ch, FALSE, TRUE))
1922                 {
1923                         /* Over-flowed? Cancel macro action */
1924                         parse_macro = FALSE;
1925                 }
1926         }
1927         else
1928         {
1929                 /* Wait for a keypress */
1930                 (void) (Term_inkey(&ch, TRUE, TRUE));
1931         }
1932
1933
1934         /* End "macro action" */
1935         if (ch == 30) parse_macro = FALSE;
1936
1937         /* Inside "macro action" */
1938         if (ch == 30) return (ch);
1939
1940         /* Inside "macro action" */
1941         if (parse_macro) return (ch);
1942
1943         /* Inside "macro trigger" */
1944         if (parse_under) return (ch);
1945
1946         /* Save the first key, advance */
1947         buf[p++] = ch;
1948         buf[p] = '\0';
1949
1950
1951         /* Check for possible macro */
1952         k = macro_find_check(buf);
1953
1954         /* No macro pending */
1955         if (k < 0) return (ch);
1956
1957
1958         /* Wait for a macro, or a timeout */
1959         while (TRUE)
1960         {
1961                 /* Check for pending macro */
1962                 k = macro_find_maybe(buf);
1963
1964                 /* No macro pending */
1965                 if (k < 0) break;
1966
1967                 /* Check for (and remove) a pending key */
1968                 if (0 == Term_inkey(&ch, FALSE, TRUE))
1969                 {
1970                         /* Append the key */
1971                         buf[p++] = ch;
1972                         buf[p] = '\0';
1973
1974                         /* Restart wait */
1975                         w = 0;
1976                 }
1977
1978                 /* No key ready */
1979                 else
1980                 {
1981                         /* Increase "wait" */
1982                         w += 1;
1983
1984                         /* Excessive delay */
1985                         if (w >= 10) break;
1986
1987                         Term_xtra(TERM_XTRA_DELAY, w);
1988                 }
1989         }
1990
1991
1992         /* Check for available macro */
1993         k = macro_find_ready(buf);
1994
1995         /* No macro available */
1996         if (k < 0)
1997         {
1998                 /* Push all the keys back on the queue */
1999                 while (p > 0)
2000                 {
2001                         /* Push the key, notice over-flow */
2002                         if (Term_key_push(buf[--p])) return (0);
2003                 }
2004
2005                 /* Wait for (and remove) a pending key */
2006                 (void)Term_inkey(&ch, TRUE, TRUE);
2007
2008                 /* Return the key */
2009                 return (ch);
2010         }
2011
2012
2013         /* Get the pattern */
2014         pat = macro__pat[k];
2015
2016         /* Get the length of the pattern */
2017         n = strlen(pat);
2018
2019         /* Push the "extra" keys back on the queue */
2020         while (p > n)
2021         {
2022                 /* Push the key, notice over-flow */
2023                 if (Term_key_push(buf[--p])) return (0);
2024         }
2025
2026
2027         /* Begin "macro action" */
2028         parse_macro = TRUE;
2029
2030         /* Push the "end of macro action" key */
2031         if (Term_key_push(30)) return (0);
2032
2033
2034         /* Access the macro action */
2035         act = macro__act[k];
2036
2037         /* Get the length of the action */
2038         n = strlen(act);
2039
2040         /* Push the macro "action" onto the key queue */
2041         while (n > 0)
2042         {
2043                 /* Push the key, notice over-flow */
2044                 if (Term_key_push(act[--n])) return (0);
2045         }
2046
2047
2048         /* Hack -- Force "inkey()" to call us again */
2049         return (0);
2050 }
2051
2052
2053 /*
2054  * Cancel macro action on the queue
2055  */
2056 static void forget_macro_action(void)
2057 {
2058         if (!parse_macro) return;
2059
2060         /* Drop following macro action string */
2061         while (TRUE)
2062         {
2063                 char ch;
2064
2065                 /* End loop if no key ready */
2066                 if (Term_inkey(&ch, FALSE, TRUE)) break;
2067
2068                 /* End loop if no key ready */
2069                 if (ch == 0) break;
2070
2071                 /* End of "macro action" */
2072                 if (ch == 30) break;
2073         }
2074
2075         /* No longer inside "macro action" */
2076         parse_macro = FALSE;
2077 }
2078
2079
2080 /*
2081  * Mega-Hack -- special "inkey_next" pointer.
2082  *
2083  * This special pointer allows a sequence of keys to be "inserted" into
2084  * the stream of keys returned by "inkey()".  This key sequence will not
2085  * trigger any macros, and cannot be bypassed by the Borg.  It is used
2086  * in Angband to handle "keymaps".
2087  */
2088 static concptr inkey_next = NULL;
2089
2090
2091 #ifdef ALLOW_BORG
2092
2093 /*
2094  * Mega-Hack -- special "inkey_hack" hook.
2095  *
2096  * This special function hook allows the "Borg" (see elsewhere) to take
2097  * control of the "inkey()" function, and substitute in fake keypresses.
2098  */
2099 char (*inkey_hack)(int flush_first) = NULL;
2100
2101 #endif /* ALLOW_BORG */
2102
2103
2104
2105 /*
2106  * Get a keypress from the user.
2107  *
2108  * This function recognizes a few "global parameters".  These are variables
2109  * which, if set to TRUE before calling this function, will have an effect
2110  * on this function, and which are always reset to FALSE by this function
2111  * before this function returns.  Thus they function just like normal
2112  * parameters, except that most calls to this function can ignore them.
2113  *
2114  * If "inkey_xtra" is TRUE, then all pending keypresses will be flushed,
2115  * and any macro processing in progress will be aborted.  This flag is
2116  * set by the "flush()" function, which does not actually flush anything
2117  * itself, but rather, triggers delayed input flushing via "inkey_xtra".
2118  *
2119  * If "inkey_scan" is TRUE, then we will immediately return "zero" if no
2120  * keypress is available, instead of waiting for a keypress.
2121  *
2122  * If "inkey_base" is TRUE, then all macro processing will be bypassed.
2123  * If "inkey_base" and "inkey_scan" are both TRUE, then this function will
2124  * not return immediately, but will wait for a keypress for as long as the
2125  * normal macro matching code would, allowing the direct entry of macro
2126  * triggers.  The "inkey_base" flag is extremely dangerous!
2127  *
2128  * If "inkey_flag" is TRUE, then we will assume that we are waiting for a
2129  * normal command, and we will only show the cursor if "hilite_player" is
2130  * TRUE (or if the player is in a store), instead of always showing the
2131  * cursor.  The various "main-xxx.c" files should avoid saving the game
2132  * in response to a "menu item" request unless "inkey_flag" is TRUE, to
2133  * prevent savefile corruption.
2134  *
2135  * If we are waiting for a keypress, and no keypress is ready, then we will
2136  * refresh (once) the window which was active when this function was called.
2137  *
2138  * Note that "back-quote" is automatically converted into "escape" for
2139  * convenience on machines with no "escape" key.  This is done after the
2140  * macro matching, so the user can still make a macro for "backquote".
2141  *
2142  * Note the special handling of "ascii 30" (ctrl-caret, aka ctrl-shift-six)
2143  * and "ascii 31" (ctrl-underscore, aka ctrl-shift-minus), which are used to
2144  * provide support for simple keyboard "macros".  These keys are so strange
2145  * that their loss as normal keys will probably be noticed by nobody.  The
2146  * "ascii 30" key is used to indicate the "end" of a macro action, which
2147  * allows recursive macros to be avoided.  The "ascii 31" key is used by
2148  * some of the "main-xxx.c" files to introduce macro trigger sequences.
2149  *
2150  * Hack -- we use "ascii 29" (ctrl-right-bracket) as a special "magic" key,
2151  * which can be used to give a variety of "sub-commands" which can be used
2152  * any time.  These sub-commands could include commands to take a picture of
2153  * the current screen, to start/stop recording a macro action, etc.
2154  *
2155  * If "angband_term[0]" is not active, we will make it active during this
2156  * function, so that the various "main-xxx.c" files can assume that input
2157  * is only requested (via "Term_inkey()") when "angband_term[0]" is active.
2158  *
2159  * Mega-Hack -- This function is used as the entry point for clearing the
2160  * "signal_count" variable, and of the "current_world_ptr->character_saved" variable.
2161  *
2162  * Hack -- Note the use of "inkey_next" to allow "keymaps" to be processed.
2163  *
2164  * Mega-Hack -- Note the use of "inkey_hack" to allow the "Borg" to steal
2165  * control of the keyboard from the user.
2166  */
2167 char inkey(void)
2168 {
2169         int v;
2170         char kk;
2171         char ch = 0;
2172         bool done = FALSE;
2173         term *old = Term;
2174
2175         /* Hack -- Use the "inkey_next" pointer */
2176         if (inkey_next && *inkey_next && !inkey_xtra)
2177         {
2178                 /* Get next character, and advance */
2179                 ch = *inkey_next++;
2180
2181                 /* Cancel the various "global parameters" */
2182                 inkey_base = inkey_xtra = inkey_flag = inkey_scan = FALSE;
2183
2184                 /* Accept result */
2185                 return (ch);
2186         }
2187
2188         /* Forget pointer */
2189         inkey_next = NULL;
2190
2191
2192 #ifdef ALLOW_BORG
2193
2194         /* Mega-Hack -- Use the special hook */
2195         if (inkey_hack && ((ch = (*inkey_hack)(inkey_xtra)) != 0))
2196         {
2197                 /* Cancel the various "global parameters" */
2198                 inkey_base = inkey_xtra = inkey_flag = inkey_scan = FALSE;
2199
2200                 /* Accept result */
2201                 return (ch);
2202         }
2203
2204 #endif /* ALLOW_BORG */
2205
2206
2207         /* Hack -- handle delayed "flush()" */
2208         if (inkey_xtra)
2209         {
2210                 /* End "macro action" */
2211                 parse_macro = FALSE;
2212
2213                 /* End "macro trigger" */
2214                 parse_under = FALSE;
2215
2216                 /* Forget old keypresses */
2217                 Term_flush();
2218         }
2219
2220
2221         /* Access cursor state */
2222         (void)Term_get_cursor(&v);
2223
2224         /* Show the cursor if waiting, except sometimes in "command" mode */
2225         if (!inkey_scan && (!inkey_flag || hilite_player || current_world_ptr->character_icky))
2226         {
2227                 /* Show the cursor */
2228                 (void)Term_set_cursor(1);
2229         }
2230
2231
2232         /* Hack -- Activate main screen */
2233         Term_activate(angband_term[0]);
2234
2235
2236         /* Get a key */
2237         while (!ch)
2238         {
2239                 /* Hack -- Handle "inkey_scan" */
2240                 if (!inkey_base && inkey_scan &&
2241                         (0 != Term_inkey(&kk, FALSE, FALSE)))
2242                 {
2243                         break;
2244                 }
2245
2246
2247                 /* Hack -- Flush output once when no key ready */
2248                 if (!done && (0 != Term_inkey(&kk, FALSE, FALSE)))
2249                 {
2250                         /* Hack -- activate proper term */
2251                         Term_activate(old);
2252
2253                         /* Flush output */
2254                         Term_fresh();
2255
2256                         /* Hack -- activate main screen */
2257                         Term_activate(angband_term[0]);
2258
2259                         /* Mega-Hack -- reset saved flag */
2260                         current_world_ptr->character_saved = FALSE;
2261
2262                         /* Mega-Hack -- reset signal counter */
2263                         signal_count = 0;
2264
2265                         /* Only once */
2266                         done = TRUE;
2267                 }
2268
2269
2270                 /* Hack -- Handle "inkey_base" */
2271                 if (inkey_base)
2272                 {
2273                         int w = 0;
2274
2275                         /* Wait forever */
2276                         if (!inkey_scan)
2277                         {
2278                                 /* Wait for (and remove) a pending key */
2279                                 if (0 == Term_inkey(&ch, TRUE, TRUE))
2280                                 {
2281                                         break;
2282                                 }
2283
2284                                 break;
2285                         }
2286
2287                         /* Wait */
2288                         while (TRUE)
2289                         {
2290                                 /* Check for (and remove) a pending key */
2291                                 if (0 == Term_inkey(&ch, FALSE, TRUE))
2292                                 {
2293                                         break;
2294                                 }
2295
2296                                 /* No key ready */
2297                                 else
2298                                 {
2299                                         /* Increase "wait" */
2300                                         w += 10;
2301
2302                                         /* Excessive delay */
2303                                         if (w >= 100) break;
2304
2305                                         Term_xtra(TERM_XTRA_DELAY, w);
2306                                 }
2307                         }
2308
2309                         break;
2310                 }
2311
2312
2313                 /* Get a key (see above) */
2314                 ch = inkey_aux();
2315
2316
2317                 /* Handle "control-right-bracket" */
2318                 if (ch == 29)
2319                 {
2320                         /* Strip this key */
2321                         ch = 0;
2322                         continue;
2323                 }
2324
2325
2326                 /* Treat back-quote as escape */
2327 /*              if (ch == '`') ch = ESCAPE; */
2328
2329
2330                 /* End "macro trigger" */
2331                 if (parse_under && (ch <= 32))
2332                 {
2333                         /* Strip this key */
2334                         ch = 0;
2335
2336                         /* End "macro trigger" */
2337                         parse_under = FALSE;
2338                 }
2339
2340
2341                 /* Handle "control-caret" */
2342                 if (ch == 30)
2343                 {
2344                         /* Strip this key */
2345                         ch = 0;
2346                 }
2347
2348                 /* Handle "control-underscore" */
2349                 else if (ch == 31)
2350                 {
2351                         /* Strip this key */
2352                         ch = 0;
2353
2354                         /* Begin "macro trigger" */
2355                         parse_under = TRUE;
2356                 }
2357
2358                 /* Inside "macro trigger" */
2359                 else if (parse_under)
2360                 {
2361                         /* Strip this key */
2362                         ch = 0;
2363                 }
2364         }
2365
2366
2367         /* Hack -- restore the term */
2368         Term_activate(old);
2369
2370
2371         /* Restore the cursor */
2372         Term_set_cursor(v);
2373
2374
2375         /* Cancel the various "global parameters" */
2376         inkey_base = inkey_xtra = inkey_flag = inkey_scan = FALSE;
2377
2378         /* Return the keypress */
2379         return (ch);
2380 }
2381
2382
2383
2384
2385 /*
2386  * We use a global array for all inscriptions to reduce the memory
2387  * spent maintaining inscriptions.  Of course, it is still possible
2388  * to run out of inscription memory, especially if too many different
2389  * inscriptions are used, but hopefully this will be rare.
2390  *
2391  * We use dynamic string allocation because otherwise it is necessary
2392  * to pre-guess the amount of quark activity.  We limit the total
2393  * number of quarks, but this is much easier to "expand" as needed.
2394  *
2395  * Any two items with the same inscription will have the same "quark"
2396  * index, which should greatly reduce the need for inscription space.
2397  *
2398  * Note that "quark zero" is NULL and should not be "dereferenced".
2399  */
2400
2401 /*
2402  * Initialize the quark array
2403  */
2404 void quark_init(void)
2405 {
2406         /* Quark variables */
2407         C_MAKE(quark__str, QUARK_MAX, concptr);
2408
2409         /* Prepare first quark, which is used when quark_add() is failed */
2410         quark__str[1] = string_make("");
2411
2412         /* There is one quark (+ NULL) */
2413         quark__num = 2;
2414 }
2415
2416
2417 /*
2418  * Add a new "quark" to the set of quarks.
2419  */
2420 u16b quark_add(concptr str)
2421 {
2422         u16b i;
2423
2424         /* Look for an existing quark */
2425         for (i = 1; i < quark__num; i++)
2426         {
2427                 /* Check for equality */
2428                 if (streq(quark__str[i], str)) return (i);
2429         }
2430
2431         /* Return "" when no room is available */
2432         if (quark__num == QUARK_MAX) return 1;
2433
2434         /* New maximal quark */
2435         quark__num = i + 1;
2436
2437         /* Add a new quark */
2438         quark__str[i] = string_make(str);
2439
2440         /* Return the index */
2441         return (i);
2442 }
2443
2444
2445 /*
2446  * This function looks up a quark
2447  */
2448 concptr quark_str(STR_OFFSET i)
2449 {
2450         concptr q;
2451
2452         /* Return NULL for an invalid index */
2453         if ((i < 1) || (i >= quark__num)) return NULL;
2454
2455         /* Access the quark */
2456         q = quark__str[i];
2457
2458         /* Return the quark */
2459         return (q);
2460 }
2461
2462
2463
2464
2465 /*
2466  * Second try for the "message" handling routines.
2467  *
2468  * Each call to "message_add(s)" will add a new "most recent" message
2469  * to the "message recall list", using the contents of the string "s".
2470  *
2471  * The messages will be stored in such a way as to maximize "efficiency",
2472  * that is, we attempt to maximize the number of sequential messages that
2473  * can be retrieved, given a limited amount of storage space.
2474  *
2475  * We keep a buffer of chars to hold the "text" of the messages, not
2476  * necessarily in "order", and an array of offsets into that buffer,
2477  * representing the actual messages.  This is made more complicated
2478  * by the fact that both the array of indexes, and the buffer itself,
2479  * are both treated as "circular arrays" for efficiency purposes, but
2480  * the strings may not be "broken" across the ends of the array.
2481  *
2482  * The "message_add()" function is rather "complex", because it must be
2483  * extremely efficient, both in space and time, for use with the Borg.
2484  */
2485
2486
2487
2488 /*!
2489  * @brief 保存中の過去ゲームメッセージの数を返す。 / How many messages are "available"?
2490  * @return 残っているメッセージの数
2491  */
2492 s32b message_num(void)
2493 {
2494         int last, next, n;
2495
2496         /* Extract the indexes */
2497         last = message__last;
2498         next = message__next;
2499
2500         /* Handle "wrap" */
2501         if (next < last) next += MESSAGE_MAX;
2502
2503         /* Extract the space */
2504         n = (next - last);
2505
2506         /* Return the result */
2507         return (n);
2508 }
2509
2510
2511 /*!
2512  * @brief 過去のゲームメッセージを返す。 / Recall the "text" of a saved message
2513  * @params age メッセージの世代
2514  * @return メッセージの文字列ポインタ
2515  */
2516 concptr message_str(int age)
2517 {
2518         s32b x;
2519         s32b o;
2520         concptr s;
2521
2522         /* Forgotten messages have no text */
2523         if ((age < 0) || (age >= message_num())) return ("");
2524
2525         /* Acquire the "logical" index */
2526         x = (message__next + MESSAGE_MAX - (age + 1)) % MESSAGE_MAX;
2527
2528         /* Get the "offset" for the message */
2529         o = message__ptr[x];
2530
2531         /* Access the message text */
2532         s = &message__buf[o];
2533
2534         /* Return the message text */
2535         return (s);
2536 }
2537
2538
2539 /*!
2540  * @brief ゲームメッセージをログに追加する。 / Add a new message, with great efficiency
2541  * @params str 保存したいメッセージ
2542  * @return なし
2543  */
2544 void message_add(concptr str)
2545 {
2546         u32b i, n;
2547         int k, x, m;
2548
2549         char u[4096];
2550         char splitted1[81];
2551         concptr splitted2;
2552
2553         /*** Step 1 -- Analyze the message ***/
2554
2555         /* Hack -- Ignore "non-messages" */
2556         if (!str) return;
2557
2558         /* Message length */
2559         n = strlen(str);
2560
2561         /* Important Hack -- Ignore "long" messages */
2562         if (n >= MESSAGE_BUF / 4) return;
2563
2564         /* extra step -- split the message if n>80.(added by Mogami) */
2565         if (n > 80) {
2566 #ifdef JP
2567                 concptr t = str;
2568
2569                 for (n = 0; n < 80; n++, t++)
2570                 {
2571                         if(iskanji(*t)) {
2572                                 t++;
2573                                 n++;
2574                         }
2575                 }
2576                 if (n == 81) n = 79; /* 最後の文字が漢字半分 */
2577 #else
2578                 for (n = 80; n > 60; n--)
2579                         if (str[n] == ' ') break;
2580                 if (n == 60) n = 80;
2581 #endif
2582                 splitted2 = str + n;
2583                 strncpy(splitted1, str ,n);
2584                 splitted1[n] = '\0';
2585                 str = splitted1;
2586         } else {
2587                 splitted2 = NULL;
2588         }
2589
2590         /*** Step 2 -- 最適化の試行 / Attempt to optimize ***/
2591
2592         /* Limit number of messages to check */
2593         m = message_num();
2594         k = m / 4;
2595         if (k > MESSAGE_MAX / 32) k = MESSAGE_MAX / 32;
2596
2597         /* Check previous message */
2598         for (i = message__next; m; m--)
2599         {
2600                 int j = 1;
2601
2602                 char buf[1024];
2603                 char *t;
2604
2605                 concptr old;
2606
2607                 /* Back up and wrap if needed */
2608                 if (i-- == 0) i = MESSAGE_MAX - 1;
2609
2610                 /* Access the old string */
2611                 old = &message__buf[message__ptr[i]];
2612
2613                 /* Skip small messages */
2614                 if (!old) continue;
2615
2616                 strcpy(buf, old);
2617
2618                 /* Find multiple */
2619 #ifdef JP
2620                 for (t = buf; *t && (*t != '<' || (*(t+1) != 'x' )); t++)
2621                         if(iskanji(*t))t++;
2622 #else
2623                 for (t = buf; *t && (*t != '<'); t++);
2624 #endif
2625
2626                 if (*t)
2627                 {
2628                         /* Message is too small */
2629                         if (strlen(buf) < A_MAX) break;
2630
2631                         /* Drop the space */
2632                         *(t - 1) = '\0';
2633
2634                         /* Get multiplier */
2635                         j = atoi(t+2);
2636                 }
2637
2638                 /* Limit the multiplier to 1000 */
2639                 if (streq(buf, str) && (j < 1000))
2640                 {
2641                         j++;
2642
2643                         /* Overwrite */
2644                         message__next = i;
2645
2646                         str = u;
2647
2648                         /* Write it out */
2649                         sprintf(u, "%s <x%d>", buf, j);
2650
2651                         /* Message length */
2652                         n = strlen(str);
2653
2654                         if (!now_message) now_message++;
2655                 }
2656                 else
2657                 {
2658                         num_more++;/*流れた行の数を数えておく */
2659                         now_message++;
2660                 }
2661
2662                 break;
2663         }
2664
2665         /* Check the last few messages (if any to count) */
2666         for (i = message__next; k; k--)
2667         {
2668                 int q;
2669                 concptr old;
2670
2671                 /* Back up and wrap if needed */
2672                 if (i-- == 0) i = MESSAGE_MAX - 1;
2673
2674                 /* Stop before oldest message */
2675                 if (i == message__last) break;
2676
2677                 /* Extract "distance" from "head" */
2678                 q = (message__head + MESSAGE_BUF - message__ptr[i]) % MESSAGE_BUF;
2679
2680                 /* Do not optimize over large distance */
2681                 if (q > MESSAGE_BUF / 2) continue;
2682
2683                 /* Access the old string */
2684                 old = &message__buf[message__ptr[i]];
2685
2686                 /* Compare */
2687                 if (!streq(old, str)) continue;
2688
2689                 /* Get the next message index, advance */
2690                 x = message__next++;
2691
2692                 /* Handle wrap */
2693                 if (message__next == MESSAGE_MAX) message__next = 0;
2694
2695                 /* Kill last message if needed */
2696                 if (message__next == message__last) message__last++;
2697
2698                 /* Handle wrap */
2699                 if (message__last == MESSAGE_MAX) message__last = 0;
2700
2701                 /* Assign the starting address */
2702                 message__ptr[x] = message__ptr[i];
2703
2704                 /* Success */
2705                 /* return; */
2706                 goto end_of_message_add;
2707
2708         }
2709
2710
2711         /*** Step 3 -- Ensure space before end of buffer ***/
2712
2713         /* Kill messages and Wrap if needed */
2714         if (message__head + n + 1 >= MESSAGE_BUF)
2715         {
2716                 /* Kill all "dead" messages */
2717                 for (i = message__last; TRUE; i++)
2718                 {
2719                         /* Wrap if needed */
2720                         if (i == MESSAGE_MAX) i = 0;
2721
2722                         /* Stop before the new message */
2723                         if (i == message__next) break;
2724
2725                         /* Kill "dead" messages */
2726                         if (message__ptr[i] >= message__head)
2727                         {
2728                                 /* Track oldest message */
2729                                 message__last = i + 1;
2730                         }
2731                 }
2732
2733                 /* Wrap "tail" if needed */
2734                 if (message__tail >= message__head) message__tail = 0;
2735
2736                 /* Start over */
2737                 message__head = 0;
2738         }
2739
2740
2741         /*** Step 4 -- Ensure space before next message ***/
2742
2743         /* Kill messages if needed */
2744         if (message__head + n + 1 > message__tail)
2745         {
2746                 /* Grab new "tail" */
2747                 message__tail = message__head + n + 1;
2748
2749                 /* Advance tail while possible past first "nul" */
2750                 while (message__buf[message__tail-1]) message__tail++;
2751
2752                 /* Kill all "dead" messages */
2753                 for (i = message__last; TRUE; i++)
2754                 {
2755                         /* Wrap if needed */
2756                         if (i == MESSAGE_MAX) i = 0;
2757
2758                         /* Stop before the new message */
2759                         if (i == message__next) break;
2760
2761                         /* Kill "dead" messages */
2762                         if ((message__ptr[i] >= message__head) &&
2763                                 (message__ptr[i] < message__tail))
2764                         {
2765                                 /* Track oldest message */
2766                                 message__last = i + 1;
2767                         }
2768                 }
2769         }
2770
2771
2772         /*** Step 5 -- Grab a new message index ***/
2773
2774         /* Get the next message index, advance */
2775         x = message__next++;
2776
2777         /* Handle wrap */
2778         if (message__next == MESSAGE_MAX) message__next = 0;
2779
2780         /* Kill last message if needed */
2781         if (message__next == message__last) message__last++;
2782
2783         /* Handle wrap */
2784         if (message__last == MESSAGE_MAX) message__last = 0;
2785
2786
2787
2788         /*** Step 6 -- Insert the message text ***/
2789
2790         /* Assign the starting address */
2791         message__ptr[x] = message__head;
2792
2793         /* Append the new part of the message */
2794         for (i = 0; i < n; i++)
2795         {
2796                 /* Copy the message */
2797                 message__buf[message__head + i] = str[i];
2798         }
2799
2800         /* Terminate */
2801         message__buf[message__head + i] = '\0';
2802
2803         /* Advance the "head" pointer */
2804         message__head += n + 1;
2805
2806         /* recursively add splitted message (added by Mogami) */
2807 end_of_message_add:
2808         if (splitted2 != NULL)
2809           message_add(splitted2);
2810 }
2811
2812
2813
2814 /*
2815  * Hack -- flush
2816  */
2817 static void msg_flush(int x)
2818 {
2819         byte a = TERM_L_BLUE;
2820         bool nagasu = FALSE;
2821
2822         if ((auto_more && !p_ptr->now_damaged) || num_more < 0){
2823                 int i;
2824                 for (i = 0; i < 8; i++)
2825                 {
2826                         if (angband_term[i] && (window_flag[i] & PW_MESSAGE)) break;
2827                 }
2828                 if (i < 8)
2829                 {
2830                         if (num_more < angband_term[i]->hgt) nagasu = TRUE;
2831                 }
2832                 else
2833                 {
2834                         nagasu = TRUE;
2835                 }
2836         }
2837         p_ptr->now_damaged = FALSE;
2838
2839         if (!p_ptr->playing || !nagasu)
2840         {
2841                 /* Pause for response */
2842                 Term_putstr(x, 0, -1, a, _("-続く-", "-more-"));
2843
2844                 /* Get an acceptable keypress */
2845                 while (1)
2846                 {
2847                         int cmd = inkey();
2848                         if (cmd == ESCAPE) {
2849                             num_more = -9999; /*auto_moreのとき、全て流す。 */
2850                             break;
2851                         } else if (cmd == ' ') {
2852                             num_more = 0; /*１画面だけ流す。 */
2853                             break;
2854                         } else if ((cmd == '\n') || (cmd == '\r')) {
2855                             num_more--; /*１行だけ流す。 */
2856                             break;
2857                         }
2858                         if (quick_messages) break;
2859                         bell();
2860                 }
2861         }
2862
2863         /* Clear the line */
2864         Term_erase(0, 0, 255);
2865 }
2866
2867
2868 void msg_erase(void)
2869 {
2870         msg_print(NULL);
2871 }
2872
2873
2874 /*
2875  * Output a message to the top line of the screen.
2876  *
2877  * Break long messages into multiple pieces (40-72 chars).
2878  *
2879  * Allow multiple short messages to "share" the top line.
2880  *
2881  * Prompt the user to make sure he has a chance to read them.
2882  *
2883  * These messages are memorized for later reference (see above).
2884  *
2885  * We could do "Term_fresh()" to provide "flicker" if needed.
2886  *
2887  * The global "msg_flag" variable can be cleared to tell us to
2888  * "erase" any "pending" messages still on the screen.
2889  *
2890  * Note that we must be very careful about using the
2891  * "msg_print()" functions without explicitly calling the special
2892  * "msg_print(NULL)" function, since this may result in the loss
2893  * of information if the screen is cleared, or if anything is
2894  * displayed on the top line.
2895  *
2896  * Note that "msg_print(NULL)" will clear the top line
2897  * even if no messages are pending.  This is probably a hack.
2898  */
2899 void msg_print(concptr msg)
2900 {
2901         static int p = 0;
2902         int n;
2903         char *t;
2904         char buf[1024];
2905
2906         if (current_world_ptr->timewalk_m_idx) return;
2907
2908         /* Hack -- Reset */
2909         if (!msg_flag) {
2910                 /* Clear the line */
2911                 Term_erase(0, 0, 255);
2912                 p = 0;
2913         }
2914
2915         /* Original Message Length */
2916         n = (msg ? strlen(msg) : 0);
2917
2918         /* Hack -- flush when requested or needed */
2919         if (p && (!msg || ((p + n) > 72)))
2920         {
2921                 msg_flush(p);
2922
2923                 /* Forget it */
2924                 msg_flag = FALSE;
2925
2926                 /* Reset */
2927                 p = 0;
2928         }
2929
2930         /* No message */
2931         if (!msg) return;
2932         if (n > 1000) return;
2933
2934         /* Copy it */
2935         if (!cheat_turn)
2936         {
2937                 strcpy(buf, msg);
2938         }
2939         else
2940         {
2941                 sprintf(buf, ("T:%d - %s"), (int)current_world_ptr->game_turn, msg);
2942         }
2943
2944         /* New Message Length */
2945         n = strlen(buf);
2946
2947         /* Memorize the message */
2948         if (current_world_ptr->character_generated) message_add(buf);
2949
2950         /* Analyze the buffer */
2951         t = buf;
2952
2953         /* Split message */
2954         while (n > 72)
2955         {
2956                 char oops;
2957                 int check, split = 72;
2958
2959 #ifdef JP
2960                 bool k_flag = FALSE;
2961                 int wordlen = 0;
2962
2963                 /* Find the "best" split point */
2964                 for (check = 0; check < 72; check++)
2965                 {
2966                         if (k_flag)
2967                         {
2968                                 k_flag = FALSE;
2969                                 continue;
2970                         }
2971
2972                         /* Found a valid split point */
2973                         if (iskanji(t[check]))
2974                         {
2975                                 k_flag = TRUE;
2976                                 split = check;
2977                         }
2978                         else if (t[check] == ' ')
2979                         {
2980                                 split = check;
2981                                 wordlen = 0;
2982                         }
2983                         else
2984                         {
2985                                 wordlen++;
2986                                 if (wordlen > 20)
2987                                         split = check;
2988                         }
2989                 }
2990 #else
2991                 /* Find the "best" split point */
2992                 for (check = 40; check < 72; check++)
2993                 {
2994                         /* Found a valid split point */
2995                         if (t[check] == ' ') split = check;
2996                 }
2997 #endif
2998
2999                 /* Save the split character */
3000                 oops = t[split];
3001
3002                 /* Split the message */
3003                 t[split] = '\0';
3004
3005                 /* Display part of the message */
3006                 Term_putstr(0, 0, split, TERM_WHITE, t);
3007
3008                 /* Flush it */
3009                 msg_flush(split + 1);
3010
3011                 /* Memorize the piece */
3012                 /* if (current_world_ptr->character_generated) message_add(t); */
3013
3014                 /* Restore the split character */
3015                 t[split] = oops;
3016
3017                 /* Insert a space */
3018                 t[--split] = ' ';
3019
3020                 /* Prepare to recurse on the rest of "buf" */
3021                 t += split; n -= split;
3022         }
3023
3024         /* Display the tail of the message */
3025         Term_putstr(p, 0, n, TERM_WHITE, t);
3026
3027         /* Memorize the tail */
3028         /* if (current_world_ptr->character_generated) message_add(t); */
3029
3030         p_ptr->window |= (PW_MESSAGE);
3031         update_output();
3032
3033         /* Remember the message */
3034         msg_flag = TRUE;
3035
3036         /* Remember the position */
3037 #ifdef JP
3038         p += n;
3039 #else
3040         p += n + 1;
3041 #endif
3042
3043         /* Optional refresh */
3044         if (fresh_message) Term_fresh();
3045 }
3046
3047 void msg_print_wizard(int cheat_type, concptr msg)
3048 {
3049         if (!cheat_room && cheat_type == CHEAT_DUNGEON) return;
3050         if (!cheat_peek && cheat_type == CHEAT_OBJECT) return;
3051         if (!cheat_hear && cheat_type == CHEAT_MONSTER) return;
3052         if (!cheat_xtra && cheat_type == CHEAT_MISC) return;
3053
3054         concptr cheat_mes[] = {"ITEM", "MONS", "DUNG", "MISC"};
3055         char buf[1024];
3056         sprintf(buf, "WIZ-%s:%s", cheat_mes[cheat_type], msg);
3057         msg_print(buf);
3058
3059         if (cheat_diary_output)
3060         {
3061                 exe_write_diary(p_ptr, NIKKI_WIZARD_LOG, 0, buf);
3062         }
3063
3064 }
3065
3066 /*
3067  * Hack -- prevent "accidents" in "screen_save()" or "screen_load()"
3068  */
3069 static int screen_depth = 0;
3070
3071
3072 /*
3073  * Save the screen, and increase the "icky" depth.
3074  *
3075  * This function must match exactly one call to "screen_load()".
3076  */
3077 void screen_save(void)
3078 {
3079         /* Hack -- Flush messages */
3080         msg_print(NULL);
3081
3082         /* Save the screen (if legal) */
3083         if (screen_depth++ == 0) Term_save();
3084
3085         /* Increase "icky" depth */
3086         current_world_ptr->character_icky++;
3087 }
3088
3089
3090 /*
3091  * Load the screen, and decrease the "icky" depth.
3092  *
3093  * This function must match exactly one call to "screen_save()".
3094  */
3095 void screen_load(void)
3096 {
3097         /* Hack -- Flush messages */
3098         msg_print(NULL);
3099
3100         /* Load the screen (if legal) */
3101         if (--screen_depth == 0) Term_load();
3102
3103         /* Decrease "icky" depth */
3104         current_world_ptr->character_icky--;
3105 }
3106
3107
3108 /*
3109  * Display a formatted message, using "vstrnfmt()" and "msg_print()".
3110  */
3111 void msg_format(concptr fmt, ...)
3112 {
3113         va_list vp;
3114
3115         char buf[1024];
3116
3117         /* Begin the Varargs Stuff */
3118         va_start(vp, fmt);
3119
3120         /* Format the args, save the length */
3121         (void)vstrnfmt(buf, 1024, fmt, vp);
3122
3123         /* End the Varargs Stuff */
3124         va_end(vp);
3125
3126         /* Display */
3127         msg_print(buf);
3128 }
3129
3130 /*
3131  * Display a formatted message, using "vstrnfmt()" and "msg_print()".
3132  */
3133 void msg_format_wizard(int cheat_type, concptr fmt, ...)
3134 {
3135         if(!cheat_room && cheat_type == CHEAT_DUNGEON) return;
3136         if(!cheat_peek && cheat_type == CHEAT_OBJECT) return;
3137         if(!cheat_hear && cheat_type == CHEAT_MONSTER) return;
3138         if(!cheat_xtra && cheat_type == CHEAT_MISC) return;
3139
3140         va_list vp;
3141         char buf[1024];
3142
3143         /* Begin the Varargs Stuff */
3144         va_start(vp, fmt);
3145
3146         /* Format the args, save the length */
3147         (void)vstrnfmt(buf, 1024, fmt, vp);
3148
3149         /* End the Varargs Stuff */
3150         va_end(vp);
3151
3152         /* Display */
3153         msg_print_wizard(cheat_type, buf);
3154 }
3155
3156
3157
3158 /*
3159  * Display a string on the screen using an attribute.
3160  *
3161  * At the given location, using the given attribute, if allowed,
3162  * add the given string.  Do not clear the line.
3163  */
3164 void c_put_str(TERM_COLOR attr, concptr str, TERM_LEN row, TERM_LEN col)
3165 {
3166         /* Position cursor, Dump the attr/text */
3167         Term_putstr(col, row, -1, attr, str);
3168 }
3169
3170 /*
3171  * As above, but in "white"
3172  */
3173 void put_str(concptr str, TERM_LEN row, TERM_LEN col)
3174 {
3175         /* Spawn */
3176         Term_putstr(col, row, -1, TERM_WHITE, str);
3177 }
3178
3179
3180
3181 /*
3182  * Display a string on the screen using an attribute, and clear
3183  * to the end of the line.
3184  */
3185 void c_prt(TERM_COLOR attr, concptr str, TERM_LEN row, TERM_LEN col)
3186 {
3187         /* Clear line, position cursor */
3188         Term_erase(col, row, 255);
3189
3190         /* Dump the attr/text */
3191         Term_addstr(-1, attr, str);
3192 }
3193
3194 /*
3195  * As above, but in "white"
3196  */
3197 void prt(concptr str, TERM_LEN row, TERM_LEN col)
3198 {
3199         /* Spawn */
3200         c_prt(TERM_WHITE, str, row, col);
3201 }
3202
3203
3204
3205
3206 /*
3207  * Print some (colored) text to the screen at the current cursor position,
3208  * automatically "wrapping" existing text (at spaces) when necessary to
3209  * avoid placing any text into the last column, and clearing every line
3210  * before placing any text in that line.  Also, allow "newline" to force
3211  * a "wrap" to the next line.  Advance the cursor as needed so sequential
3212  * calls to this function will work correctly.
3213  *
3214  * Once this function has been called, the cursor should not be moved
3215  * until all the related "c_roff()" calls to the window are complete.
3216  *
3217  * This function will correctly handle any width up to the maximum legal
3218  * value of 256, though it works best for a standard 80 character width.
3219  */
3220 void c_roff(byte a, concptr str)
3221 {
3222         int x, y;
3223
3224         int w, h;
3225
3226         concptr s;
3227
3228         /* Obtain the size */
3229         (void)Term_get_size(&w, &h);
3230
3231         /* Obtain the cursor */
3232         (void)Term_locate(&x, &y);
3233
3234         /* Hack -- No more space */
3235         if( y == h - 1 && x > w - 3) return;
3236
3237         /* Process the string */
3238         for (s = str; *s; s++)
3239         {
3240                 char ch;
3241
3242 #ifdef JP
3243                 int k_flag = iskanji(*s);
3244 #endif
3245                 /* Force wrap */
3246                 if (*s == '\n')
3247                 {
3248                         /* Wrap */
3249                         x = 0;
3250                         y++;
3251
3252                         /* No more space */
3253                         if( y == h ) break;
3254
3255                         /* Clear line, move cursor */
3256                         Term_erase(x, y, 255);
3257
3258                         break;
3259                 }
3260
3261                 /* Clean up the char */
3262 #ifdef JP
3263                 ch = ((k_flag || isprint(*s)) ? *s : ' ');
3264 #else
3265                 ch = (isprint(*s) ? *s : ' ');
3266 #endif
3267
3268
3269                 /* Wrap words as needed */
3270 #ifdef JP
3271                 if (( x >= ( (k_flag) ? w - 2 : w - 1 ) ) && (ch != ' '))
3272 #else
3273                 if ((x >= w - 1) && (ch != ' '))
3274 #endif
3275
3276                 {
3277                         int i, n = 0;
3278
3279                         TERM_COLOR av[256];
3280                         char cv[256];
3281
3282                         /* Wrap word */
3283                         if (x < w)
3284 #ifdef JP
3285                         {
3286                         /* 現在が半角文字の場合 */
3287                         if( !k_flag )
3288 #endif
3289                         {
3290                                 /* Scan existing text */
3291                                 for (i = w - 2; i >= 0; i--)
3292                                 {
3293                                         /* Grab existing attr/char */
3294                                         Term_what(i, y, &av[i], &cv[i]);
3295
3296                                         /* Break on space */
3297                                         if (cv[i] == ' ') break;
3298
3299                                         /* Track current word */
3300                                         n = i;
3301 #ifdef JP
3302                                         if (cv[i] == '(') break;
3303 #endif
3304                                 }
3305                         }
3306
3307 #ifdef JP
3308                         else
3309                         {
3310                                 /* 現在が全角文字のとき */
3311                                 /* 文頭が「。」「、」等になるときは、その１つ前の語で改行 */
3312                                 if (strncmp(s, "。", 2) == 0 || strncmp(s, "、", 2) == 0
3313 #if 0                   /* 一般的には「ィ」「ー」は禁則の対象外 */
3314                                         || strncmp(s, "ィ", 2) == 0 || strncmp(s, "ー", 2) == 0
3315 #endif
3316                                ){
3317                                         Term_what(x  , y, &av[x  ], &cv[x  ]);
3318                                         Term_what(x-1, y, &av[x-1], &cv[x-1]);
3319                                         Term_what(x-2, y, &av[x-2], &cv[x-2]);
3320                                         n = x - 2;
3321                                         cv[ x ] = '\0';
3322                                 }
3323                         }
3324                         }
3325 #endif
3326                         /* Special case */
3327                         if (n == 0) n = w;
3328
3329                         /* Clear line */
3330                         Term_erase(n, y, 255);
3331
3332                         /* Wrap */
3333                         x = 0;
3334                         y++;
3335
3336                         /* No more space */
3337                         if( y == h ) break;
3338
3339                         /* Clear line, move cursor */
3340                         Term_erase(x, y, 255);
3341
3342                         /* Wrap the word (if any) */
3343                         for (i = n; i < w - 1; i++)
3344                         {
3345 #ifdef JP
3346                                 if( cv[i] == '\0' ) break;
3347 #endif
3348                                 /* Dump */
3349                                 Term_addch(av[i], cv[i]);
3350
3351                                 /* Advance (no wrap) */
3352                                 if (++x > w) x = w;
3353                         }
3354                 }
3355
3356                 /* Dump */
3357 #ifdef JP
3358                 Term_addch((byte)(a|0x10), ch);
3359 #else
3360                 Term_addch(a, ch);
3361 #endif
3362
3363
3364 #ifdef JP
3365                 if (k_flag)
3366                 {
3367                         s++;
3368                         x++;
3369                         ch = *s;
3370                         Term_addch((byte)(a|0x20), ch);
3371                 }
3372 #endif
3373                 /* Advance */
3374                 if (++x > w) x = w;
3375         }
3376 }
3377
3378 /*
3379  * As above, but in "white"
3380  */
3381 void roff(concptr str)
3382 {
3383         /* Spawn */
3384         c_roff(TERM_WHITE, str);
3385 }
3386
3387
3388
3389
3390 /*
3391  * Clear part of the screen
3392  */
3393 void clear_from(int row)
3394 {
3395         int y;
3396
3397         /* Erase requested rows */
3398         for (y = row; y < Term->hgt; y++)
3399         {
3400                 /* Erase part of the screen */
3401                 Term_erase(0, y, 255);
3402         }
3403 }
3404
3405
3406
3407
3408 /*
3409  * Get some string input at the cursor location.
3410  * Assume the buffer is initialized to a default string.
3411  *
3412  * The default buffer is in Overwrite mode and displayed in yellow at
3413  * first.  Normal chars clear the yellow text and append the char in
3414  * white text.
3415  *
3416  * LEFT (^B) and RIGHT (^F) movement keys move the cursor position.
3417  * If the text is still displayed in yellow (Overwite mode), it will
3418  * turns into white (Insert mode) when cursor moves.
3419  *
3420  * DELETE (^D) deletes a char at the cursor position.
3421  * BACKSPACE (^H) deletes a char at the left of cursor position.
3422  * ESCAPE clears the buffer and the window and returns FALSE.
3423  * RETURN accepts the current buffer contents and returns TRUE.
3424  */
3425 bool askfor_aux(char *buf, int len, bool numpad_cursor)
3426 {
3427         int y, x;
3428         int pos = 0;
3429
3430         /*
3431          * Text color
3432          * TERM_YELLOW : Overwrite mode
3433          * TERM_WHITE : Insert mode
3434          */
3435         byte color = TERM_YELLOW;
3436
3437         /* Locate the cursor position */
3438         Term_locate(&x, &y);
3439
3440         /* Paranoia -- check len */
3441         if (len < 1) len = 1;
3442
3443         /* Paranoia -- check column */
3444         if ((x < 0) || (x >= 80)) x = 0;
3445
3446         /* Restrict the length */
3447         if (x + len > 80) len = 80 - x;
3448
3449         /* Paranoia -- Clip the default entry */
3450         buf[len] = '\0';
3451
3452
3453         /* Process input */
3454         while (TRUE)
3455         {
3456                 int skey;
3457
3458                 /* Display the string */
3459                 Term_erase(x, y, len);
3460                 Term_putstr(x, y, -1, color, buf);
3461
3462                 /* Place cursor */
3463                 Term_gotoxy(x + pos, y);
3464
3465                 /* Get a special key code */
3466                 skey = inkey_special(numpad_cursor);
3467
3468                 /* Analyze the key */
3469                 switch (skey)
3470                 {
3471                 case SKEY_LEFT:
3472                 case KTRL('b'):
3473                 {
3474                         int i = 0;
3475
3476                         /* Now on insert mode */
3477                         color = TERM_WHITE;
3478
3479                         /* No move at beginning of line */
3480                         if (0 == pos) break;
3481
3482                         while (TRUE)
3483                         {
3484                                 int next_pos = i + 1;
3485
3486 #ifdef JP
3487                                 if (iskanji(buf[i])) next_pos++;
3488 #endif
3489
3490                                 /* Is there the cursor at next position? */
3491                                 if (next_pos >= pos) break;
3492
3493                                 /* Move to next */
3494                                 i = next_pos;
3495                         }
3496
3497                         /* Get previous position */
3498                         pos = i;
3499
3500                         break;
3501                 }
3502
3503                 case SKEY_RIGHT:
3504                 case KTRL('f'):
3505                         /* Now on insert mode */
3506                         color = TERM_WHITE;
3507
3508                         /* No move at end of line */
3509                         if ('\0' == buf[pos]) break;
3510
3511 #ifdef JP
3512                         /* Move right */
3513                         if (iskanji(buf[pos])) pos += 2;
3514                         else pos++;
3515 #else
3516                         pos++;
3517 #endif
3518
3519                         break;
3520
3521                 case ESCAPE:
3522                         /* Cancel input */
3523                         buf[0] = '\0';
3524                         return FALSE;
3525
3526                 case '\n':
3527                 case '\r':
3528                         /* Success */
3529                         return TRUE;
3530
3531                 case '\010':
3532                         /* Backspace */
3533                 {
3534                         int i = 0;
3535
3536                         /* Now on insert mode */
3537                         color = TERM_WHITE;
3538
3539                         /* No move at beginning of line */
3540                         if (0 == pos) break;
3541
3542                         while (TRUE)
3543                         {
3544                                 int next_pos = i + 1;
3545
3546 #ifdef JP
3547                                 if (iskanji(buf[i])) next_pos++;
3548 #endif
3549
3550                                 /* Is there the cursor at next position? */
3551                                 if (next_pos >= pos) break;
3552
3553                                 /* Move to next */
3554                                 i = next_pos;
3555                         }
3556
3557                         /* Get previous position */
3558                         pos = i;
3559
3560                         /* Fall through to 'Delete key' */
3561                 }
3562
3563                 case 0x7F:
3564                 case KTRL('d'):
3565                         /* Delete key */
3566                 {
3567                         int dst, src;
3568
3569                         /* Now on insert mode */
3570                         color = TERM_WHITE;
3571
3572                         /* No move at end of line */
3573                         if ('\0' == buf[pos]) break;
3574
3575                         /* Position of next character */
3576                         src = pos + 1;
3577
3578 #ifdef JP
3579                         /* Next character is one more byte away */
3580                         if (iskanji(buf[pos])) src++;
3581 #endif
3582
3583                         dst = pos;
3584
3585                         /* Move characters at src to dst */
3586                         while ('\0' != (buf[dst++] = buf[src++]))
3587                                 /* loop */;
3588
3589                         break;
3590                 }
3591
3592                 default:
3593                 {
3594                         /* Insert a character */
3595
3596                         char tmp[100];
3597                         char c;
3598
3599                         /* Ignore special keys */
3600                         if (skey & SKEY_MASK) break;
3601
3602                         /* Get a character code */
3603                         c = (char)skey;
3604
3605                         if (color == TERM_YELLOW)
3606                         {
3607                                 /* Overwrite default string */
3608                                 buf[0] = '\0';
3609
3610                                 /* Go to insert mode */
3611                                 color = TERM_WHITE;
3612                         }
3613
3614                         /* Save right part of string */
3615                         strcpy(tmp, buf + pos);
3616 #ifdef JP
3617                         if (iskanji(c))
3618                         {
3619                                 char next;
3620
3621                                 /* Bypass macro processing */
3622                                 inkey_base = TRUE;
3623                                 next = inkey();
3624
3625                                 if (pos + 1 < len)
3626                                 {
3627                                         buf[pos++] = c;
3628                                         buf[pos++] = next;
3629                                 }
3630                                 else
3631                                 {
3632                                         bell();
3633                                 }
3634                         }
3635                         else
3636 #endif
3637                         {
3638 #ifdef JP
3639                                 if (pos < len && (isprint(c) || iskana(c)))
3640 #else
3641                                 if (pos < len && isprint(c))
3642 #endif
3643                                 {
3644                                         buf[pos++] = c;
3645                                 }
3646                                 else
3647                                 {
3648                                         bell();
3649                                 }
3650                         }
3651
3652                         /* Terminate */
3653                         buf[pos] = '\0';
3654
3655                         /* Write back the left part of string */
3656                         my_strcat(buf, tmp, len + 1);
3657
3658                         break;
3659                 } /* default: */
3660
3661                 }
3662
3663         } /* while (TRUE) */
3664 }
3665
3666
3667 /*
3668  * Get some string input at the cursor location.
3669  *
3670  * Allow to use numpad keys as cursor keys.
3671  */
3672 bool askfor(char *buf, int len)
3673 {
3674         return askfor_aux(buf, len, TRUE);
3675 }
3676
3677
3678 /*
3679  * Get a string from the user
3680  *
3681  * The "prompt" should take the form "Prompt: "
3682  *
3683  * Note that the initial contents of the string is used as
3684  * the default response, so be sure to "clear" it if needed.
3685  *
3686  * We clear the input, and return FALSE, on "ESCAPE".
3687  */
3688 bool get_string(concptr prompt, char *buf, int len)
3689 {
3690         bool res;
3691         msg_print(NULL);
3692
3693         /* Display prompt */
3694         prt(prompt, 0, 0);
3695
3696         /* Ask the user for a string */
3697         res = askfor(buf, len);
3698
3699         /* Clear prompt */
3700         prt("", 0, 0);
3701         return (res);
3702 }
3703
3704
3705 /*
3706  * Verify something with the user
3707  *
3708  * The "prompt" should take the form "Query? "
3709  *
3710  * Note that "[y/n]" is appended to the prompt.
3711  */
3712 bool get_check(concptr prompt)
3713 {
3714         return get_check_strict(prompt, 0);
3715 }
3716
3717 /*
3718  * Verify something with the user strictly
3719  *
3720  * mode & CHECK_OKAY_CANCEL : force user to answer 'O'kay or 'C'ancel
3721  * mode & CHECK_NO_ESCAPE   : don't allow ESCAPE key
3722  * mode & CHECK_NO_HISTORY  : no message_add
3723  * mode & CHECK_DEFAULT_Y   : accept any key as y, except n and Esc.
3724  */
3725 bool get_check_strict(concptr prompt, BIT_FLAGS mode)
3726 {
3727         int i;
3728         char buf[80];
3729         bool flag = FALSE;
3730
3731         if (auto_more)
3732         {
3733                 p_ptr->window |= PW_MESSAGE;
3734                 handle_stuff();
3735                 num_more = 0;
3736         }
3737         msg_print(NULL);
3738
3739         if (!rogue_like_commands)
3740                 mode &= ~CHECK_OKAY_CANCEL;
3741
3742
3743         /* Hack -- Build a "useful" prompt */
3744         if (mode & CHECK_OKAY_CANCEL)
3745         {
3746                 my_strcpy(buf, prompt, sizeof(buf)-15);
3747                 strcat(buf, "[(O)k/(C)ancel]");
3748         }
3749         else if (mode & CHECK_DEFAULT_Y)
3750         {
3751                 my_strcpy(buf, prompt, sizeof(buf)-5);
3752                 strcat(buf, "[Y/n]");
3753         }
3754         else
3755         {
3756                 my_strcpy(buf, prompt, sizeof(buf)-5);
3757                 strcat(buf, "[y/n]");
3758         }
3759
3760         /* Prompt for it */
3761         prt(buf, 0, 0);
3762
3763         if (!(mode & CHECK_NO_HISTORY) && p_ptr->playing)
3764         {
3765                 /* HACK : Add the line to message buffer */
3766                 message_add(buf);
3767                 p_ptr->window |= (PW_MESSAGE);
3768                 handle_stuff();
3769         }
3770
3771         /* Get an acceptable answer */
3772         while (TRUE)
3773         {
3774                 i = inkey();
3775
3776                 if (!(mode & CHECK_NO_ESCAPE))
3777                 {
3778                         if (i == ESCAPE)
3779                         {
3780                                 flag = FALSE;
3781                                 break;
3782                         }
3783                 }
3784
3785                 if (mode & CHECK_OKAY_CANCEL)
3786                 {
3787                         if (i == 'o' || i == 'O')
3788                         {
3789                                 flag = TRUE;
3790                                 break;
3791                         }
3792                         else if (i == 'c' || i == 'C')
3793                         {
3794                                 flag = FALSE;
3795                                 break;
3796                         }
3797                 }
3798                 else
3799                 {
3800                         if (i == 'y' || i == 'Y')
3801                         {
3802                                 flag = TRUE;
3803                                 break;
3804                         }
3805                         else if (i == 'n' || i == 'N')
3806                         {
3807                                 flag = FALSE;
3808                                 break;
3809                         }
3810                 }
3811
3812                 if (mode & CHECK_DEFAULT_Y)
3813                 {
3814                         flag = TRUE;
3815                         break;
3816                 }
3817
3818                 bell();
3819         }
3820
3821         /* Erase the prompt */
3822         prt("", 0, 0);
3823
3824         /* Return the flag */
3825         return flag;
3826 }
3827
3828
3829 /*
3830  * Prompts for a keypress
3831  *
3832  * The "prompt" should take the form "Command: "
3833  *
3834  * Returns TRUE unless the character is "Escape"
3835  */
3836 bool get_com(concptr prompt, char *command, bool z_escape)
3837 {
3838         msg_print(NULL);
3839
3840         /* Display a prompt */
3841         prt(prompt, 0, 0);
3842
3843         /* Get a key */
3844         if (get_com_no_macros)
3845                 *command = (char)inkey_special(FALSE);
3846         else
3847                 *command = inkey();
3848
3849         /* Clear the prompt */
3850         prt("", 0, 0);
3851
3852         /* Handle "cancel" */
3853         if (*command == ESCAPE) return (FALSE);
3854         if (z_escape && ((*command == 'z') || (*command == 'Z'))) return (FALSE);
3855
3856         /* Success */
3857         return (TRUE);
3858 }
3859
3860
3861 /*
3862  * Request a "quantity" from the user
3863  *
3864  * Hack -- allow "command_arg" to specify a quantity
3865  */
3866 QUANTITY get_quantity(concptr prompt, QUANTITY max)
3867 {
3868         bool res, result;
3869         QUANTITY amt;
3870         char tmp[80];
3871         char buf[80];
3872         COMMAND_CODE code;
3873
3874
3875         /* Use "command_arg" */
3876         if (command_arg)
3877         {
3878                 /* Extract a number */
3879                 amt = command_arg;
3880
3881                 /* Clear "command_arg" */
3882                 command_arg = 0;
3883
3884                 /* Enforce the maximum */
3885                 if (amt > max) amt = max;
3886
3887                 /* Use it */
3888                 return (amt);
3889         }
3890
3891         /* Get the item index */
3892         result = repeat_pull(&code);
3893         amt = (QUANTITY)code;
3894         if ((max != 1) && result)
3895         {
3896                 /* Enforce the maximum */
3897                 if (amt > max) amt = max;
3898
3899                 /* Enforce the minimum */
3900                 if (amt < 0) amt = 0;
3901
3902                 /* Use it */
3903                 return (amt);
3904         }
3905
3906         /* Build a prompt if needed */
3907         if (!prompt)
3908         {
3909                 sprintf(tmp, _("いくつですか (1-%d): ", "Quantity (1-%d): "), max);
3910
3911                 /* Use that prompt */
3912                 prompt = tmp;
3913         }
3914         msg_print(NULL);
3915
3916         /* Display prompt */
3917         prt(prompt, 0, 0);
3918
3919         /* Default to one */
3920         amt = 1;
3921
3922         /* Build the default */
3923         sprintf(buf, "%d", amt);
3924
3925         /*
3926          * Ask for a quantity
3927          * Don't allow to use numpad as cursor key.
3928          */
3929         res = askfor_aux(buf, 6, FALSE);
3930
3931         /* Clear prompt */
3932         prt("", 0, 0);
3933
3934         /* Cancelled */
3935         if (!res) return 0;
3936
3937         /* Extract a number */
3938         amt = (COMMAND_CODE)atoi(buf);
3939
3940         /* A letter means "all" */
3941         if (isalpha(buf[0])) amt = max;
3942
3943         /* Enforce the maximum */
3944         if (amt > max) amt = max;
3945
3946         /* Enforce the minimum */
3947         if (amt < 0) amt = 0;
3948
3949         if (amt) repeat_push((COMMAND_CODE)amt);
3950
3951         /* Return the result */
3952         return (amt);
3953 }
3954
3955
3956 /*
3957  * Pause for user response
3958  */
3959 void pause_line(int row)
3960 {
3961         prt("", row, 0);
3962         put_str(_("[ 何かキーを押して下さい ]", "[Press any key to continue]"), row, _(26, 23));
3963
3964         (void)inkey();
3965         prt("", row, 0);
3966 }
3967
3968
3969 /*
3970  * Hack -- special buffer to hold the action of the current keymap
3971  */
3972 static char request_command_buffer[256];
3973
3974
3975
3976 typedef struct
3977 {
3978         concptr name;
3979         byte cmd;
3980         bool fin;
3981 } menu_naiyou;
3982
3983 #ifdef JP
3984 menu_naiyou menu_info[10][10] =
3985 {
3986         {
3987                 {"魔法/特殊能力", 1, FALSE},
3988                 {"行動", 2, FALSE},
3989                 {"道具(使用)", 3, FALSE},
3990                 {"道具(その他)", 4, FALSE},
3991                 {"装備", 5, FALSE},
3992                 {"扉/箱", 6, FALSE},
3993                 {"情報", 7, FALSE},
3994                 {"設定", 8, FALSE},
3995                 {"その他", 9, FALSE},
3996                 {"", 0, FALSE},
3997         },
3998
3999         {
4000                 {"使う(m)", 'm', TRUE},
4001                 {"調べる(b/P)", 'b', TRUE},
4002                 {"覚える(G)", 'G', TRUE},
4003                 {"特殊能力を使う(U/O)", 'U', TRUE},
4004                 {"", 0, FALSE},
4005                 {"", 0, FALSE},
4006                 {"", 0, FALSE},
4007                 {"", 0, FALSE},
4008                 {"", 0, FALSE},
4009                 {"", 0, FALSE}
4010         },
4011
4012         {
4013                 {"休息する(R)", 'R', TRUE},
4014                 {"トラップ解除(D)", 'D', TRUE},
4015                 {"探す(s)", 's', TRUE},
4016                 {"周りを調べる(l/x)", 'l', TRUE},
4017                 {"ターゲット指定(*)", '*', TRUE},
4018                 {"穴を掘る(T/^t)", 'T', TRUE},
4019                 {"階段を上る(<)", '<', TRUE},
4020                 {"階段を下りる(>)", '>', TRUE},
4021                 {"ペットに命令する(p)", 'p', TRUE},
4022                 {"探索モードのON/OFF(S/#)", 'S', TRUE}
4023         },
4024
4025         {
4026                 {"読む(r)", 'r', TRUE},
4027                 {"飲む(q)", 'q', TRUE},
4028                 {"杖を使う(u/Z)", 'u', TRUE},
4029                 {"魔法棒で狙う(a/z)", 'a', TRUE},
4030                 {"ロッドを振る(z/a)", 'z', TRUE},
4031                 {"始動する(A)", 'A', TRUE},
4032                 {"食べる(E)", 'E', TRUE},
4033                 {"飛び道具で撃つ(f/t)", 'f', TRUE},
4034                 {"投げる(v)", 'v', TRUE},
4035                 {"", 0, FALSE}
4036         },
4037
4038         {
4039                 {"拾う(g)", 'g', TRUE},
4040                 {"落とす(d)", 'd', TRUE},
4041                 {"壊す(k/^d)", 'k', TRUE},
4042                 {"銘を刻む({)", '{', TRUE},
4043                 {"銘を消す(})", '}', TRUE},
4044                 {"調査(I)", 'I', TRUE},
4045                 {"アイテム一覧(i)", 'i', TRUE},
4046                 {"", 0, FALSE},
4047                 {"", 0, FALSE},
4048                 {"", 0, FALSE}
4049         },
4050
4051         {
4052                 {"装備する(w)", 'w', TRUE},
4053                 {"装備を外す(t/T)", 't', TRUE},
4054                 {"燃料を補給(F)", 'F', TRUE},
4055                 {"装備一覧(e)", 'e', TRUE},
4056                 {"", 0, FALSE},
4057                 {"", 0, FALSE},
4058                 {"", 0, FALSE},
4059                 {"", 0, FALSE},
4060                 {"", 0, FALSE},
4061                 {"", 0, FALSE}
4062         },
4063
4064         {
4065                 {"開ける(o)", 'o', TRUE},
4066                 {"閉じる(c)", 'c', TRUE},
4067                 {"体当たりする(B/f)", 'B', TRUE},
4068                 {"くさびを打つ(j/S)", 'j', TRUE},
4069                 {"", 0, FALSE},
4070                 {"", 0, FALSE},
4071                 {"", 0, FALSE},
4072                 {"", 0, FALSE},
4073                 {"", 0, FALSE},
4074                 {"", 0, FALSE}
4075         },
4076
4077         {
4078                 {"ダンジョンの全体図(M)", 'M', TRUE},
4079                 {"位置を確認(L/W)", 'L', TRUE},
4080                 {"階の雰囲気(^f)", KTRL('F'), TRUE},
4081                 {"ステータス(C)", 'C', TRUE},
4082                 {"文字の説明(/)", '/', TRUE},
4083                 {"メッセージ履歴(^p)", KTRL('P'), TRUE},
4084                 {"現在の時刻(^t/')", KTRL('T'), TRUE},
4085                 {"現在の知識(~)", '~', TRUE},
4086                 {"プレイ記録(|)", '|', TRUE},
4087                 {"", 0, FALSE}
4088         },
4089
4090         {
4091                 {"オプション(=)", '=', TRUE},
4092                 {"マクロ(@)", '@', TRUE},
4093                 {"画面表示(%)", '%', TRUE},
4094                 {"カラー(&)", '&', TRUE},
4095                 {"設定変更コマンド(\")", '\"', TRUE},
4096                 {"自動拾いをロード($)", '$', TRUE},
4097                 {"システム(!)", '!', TRUE},
4098                 {"", 0, FALSE},
4099                 {"", 0, FALSE},
4100                 {"", 0, FALSE}
4101         },
4102
4103         {
4104                 {"セーブ&中断(^x)", KTRL('X'), TRUE},
4105                 {"セーブ(^s)", KTRL('S'), TRUE},
4106                 {"ヘルプ(?)", '?', TRUE},
4107                 {"再描画(^r)", KTRL('R'), TRUE},
4108                 {"メモ(:)", ':', TRUE},
4109                 {"記念撮影())", ')', TRUE},
4110                 {"記念撮影の表示(()", '(', TRUE},
4111                 {"バージョン情報(V)", 'V', TRUE},
4112                 {"引退する(Q)", 'Q', TRUE},
4113                 {"", 0, FALSE}
4114         },
4115 };
4116 #else
4117 menu_naiyou menu_info[10][10] =
4118 {
4119         {
4120                 {"Magic/Special", 1, FALSE},
4121                 {"Action", 2, FALSE},
4122                 {"Items(use)", 3, FALSE},
4123                 {"Items(other)", 4, FALSE},
4124                 {"Equip", 5, FALSE},
4125                 {"Door/Box", 6, FALSE},
4126                 {"Informations", 7, FALSE},
4127                 {"Options", 8, FALSE},
4128                 {"Other commands", 9, FALSE},
4129                 {"", 0, FALSE},
4130         },
4131
4132         {
4133                 {"Use(m)", 'm', TRUE},
4134                 {"See tips(b/P)", 'b', TRUE},
4135                 {"Study(G)", 'G', TRUE},
4136                 {"Special abilities(U/O)", 'U', TRUE},
4137                 {"", 0, FALSE},
4138                 {"", 0, FALSE},
4139                 {"", 0, FALSE},
4140                 {"", 0, FALSE},
4141                 {"", 0, FALSE},
4142                 {"", 0, FALSE}
4143         },
4144
4145         {
4146                 {"Rest(R)", 'R', TRUE},
4147                 {"Disarm a trap(D)", 'D', TRUE},
4148                 {"Search(s)", 's', TRUE},
4149                 {"Look(l/x)", 'l', TRUE},
4150                 {"Target(*)", '*', TRUE},
4151                 {"Dig(T/^t)", 'T', TRUE},
4152                 {"Go up stairs(<)", '<', TRUE},
4153                 {"Go down stairs(>)", '>', TRUE},
4154                 {"Command pets(p)", 'p', TRUE},
4155                 {"Search mode ON/OFF(S/#)", 'S', TRUE}
4156         },
4157
4158         {
4159                 {"Read a scroll(r)", 'r', TRUE},
4160                 {"Drink a potion(q)", 'q', TRUE},
4161                 {"Use a staff(u/Z)", 'u', TRUE},
4162                 {"Aim a wand(a/z)", 'a', TRUE},
4163                 {"Zap a rod(z/a)", 'z', TRUE},
4164                 {"Activate an equipment(A)", 'A', TRUE},
4165                 {"Eat(E)", 'E', TRUE},
4166                 {"Fire missile weapon(f/t)", 'f', TRUE},
4167                 {"Throw an item(v)", 'v', TRUE},
4168                 {"", 0, FALSE}
4169         },
4170
4171         {
4172                 {"Get items(g)", 'g', TRUE},
4173                 {"Drop an item(d)", 'd', TRUE},
4174                 {"Destroy an item(k/^d)", 'k', TRUE},
4175                 {"Inscribe an item({)", '{', TRUE},
4176                 {"Uninscribe an item(})", '}', TRUE},
4177                 {"Info about an item(I)", 'I', TRUE},
4178                 {"Inventory list(i)", 'i', TRUE},
4179                 {"", 0, FALSE},
4180                 {"", 0, FALSE},
4181                 {"", 0, FALSE}
4182         },
4183
4184         {
4185                 {"Wear(w)", 'w', TRUE},
4186                 {"Take off(t/T)", 't', TRUE},
4187                 {"Refuel(F)", 'F', TRUE},
4188                 {"Equipment list(e)", 'e', TRUE},
4189                 {"", 0, FALSE},
4190                 {"", 0, FALSE},
4191                 {"", 0, FALSE},
4192                 {"", 0, FALSE},
4193                 {"", 0, FALSE},
4194                 {"", 0, FALSE}
4195         },
4196
4197         {
4198                 {"Open(o)", 'o', TRUE},
4199                 {"Close(c)", 'c', TRUE},
4200                 {"Bash a door(B/f)", 'B', TRUE},
4201                 {"Jam a door(j/S)", 'j', TRUE},
4202                 {"", 0, FALSE},
4203                 {"", 0, FALSE},
4204                 {"", 0, FALSE},
4205                 {"", 0, FALSE},
4206                 {"", 0, FALSE},
4207                 {"", 0, FALSE}
4208         },
4209
4210         {
4211                 {"Full map(M)", 'M', TRUE},
4212                 {"Map(L/W)", 'L', TRUE},
4213                 {"Level feeling(^f)", KTRL('F'), TRUE},
4214                 {"Character status(C)", 'C', TRUE},
4215                 {"Identify symbol(/)", '/', TRUE},
4216                 {"Show prev messages(^p)", KTRL('P'), TRUE},
4217                 {"Current time(^t/')", KTRL('T'), TRUE},
4218                 {"Various informations(~)", '~', TRUE},
4219                 {"Play record menu(|)", '|', TRUE},
4220                 {"", 0, FALSE}
4221         },
4222
4223         {
4224                 {"Set options(=)", '=', TRUE},
4225                 {"Interact with macros(@)", '@', TRUE},
4226                 {"Interact w/ visuals(%)", '%', TRUE},
4227                 {"Interact with colors(&)", '&', TRUE},
4228                 {"Enter a user pref(\")", '\"', TRUE},
4229                 {"Reload auto-pick pref($)", '$', TRUE},
4230                 {"", 0, FALSE},
4231                 {"", 0, FALSE},
4232                 {"", 0, FALSE},
4233                 {"", 0, FALSE}
4234         },
4235
4236         {
4237                 {"Save and quit(^x)", KTRL('X'), TRUE},
4238                 {"Save(^s)", KTRL('S'), TRUE},
4239                 {"Help(obsoleted)(?)", '?', TRUE},
4240                 {"Redraw(^r)", KTRL('R'), TRUE},
4241                 {"Take note(:)", ':', TRUE},
4242                 {"Dump screen dump(()", ')', TRUE},
4243                 {"Load screen dump())", '(', TRUE},
4244                 {"Version info(V)", 'V', TRUE},
4245                 {"Quit(Q)", 'Q', TRUE},
4246                 {"", 0, FALSE}
4247         },
4248 };
4249 #endif
4250
4251 typedef struct
4252 {
4253         concptr name;
4254         byte window;
4255         byte number;
4256         byte jouken;
4257         byte jouken_naiyou;
4258 } special_menu_naiyou;
4259
4260 #define MENU_CLASS 1
4261 #define MENU_WILD 2
4262
4263 #ifdef JP
4264 special_menu_naiyou special_menu_info[] =
4265 {
4266         {"超能力/特殊能力", 0, 0, MENU_CLASS, CLASS_MINDCRAFTER},
4267         {"ものまね/特殊能力", 0, 0, MENU_CLASS, CLASS_IMITATOR},
4268         {"歌/特殊能力", 0, 0, MENU_CLASS, CLASS_BARD},
4269         {"必殺技/特殊能力", 0, 0, MENU_CLASS, CLASS_SAMURAI},
4270         {"練気術/魔法/特殊能力", 0, 0, MENU_CLASS, CLASS_FORCETRAINER},
4271         {"技/特殊能力", 0, 0, MENU_CLASS, CLASS_BERSERKER},
4272         {"技術/特殊能力", 0, 0, MENU_CLASS, CLASS_SMITH},
4273         {"鏡魔法/特殊能力", 0, 0, MENU_CLASS, CLASS_MIRROR_MASTER},
4274         {"忍術/特殊能力", 0, 0, MENU_CLASS, CLASS_NINJA},
4275         {"広域マップ(<)", 2, 6, MENU_WILD, FALSE},
4276         {"通常マップ(>)", 2, 7, MENU_WILD, TRUE},
4277         {"", 0, 0, 0, 0},
4278 };
4279 #else
4280 special_menu_naiyou special_menu_info[] =
4281 {
4282         {"MindCraft/Special", 0, 0, MENU_CLASS, CLASS_MINDCRAFTER},
4283         {"Imitation/Special", 0, 0, MENU_CLASS, CLASS_IMITATOR},
4284         {"Song/Special", 0, 0, MENU_CLASS, CLASS_BARD},
4285         {"Technique/Special", 0, 0, MENU_CLASS, CLASS_SAMURAI},
4286         {"Mind/Magic/Special", 0, 0, MENU_CLASS, CLASS_FORCETRAINER},
4287         {"BrutalPower/Special", 0, 0, MENU_CLASS, CLASS_BERSERKER},
4288         {"Technique/Special", 0, 0, MENU_CLASS, CLASS_SMITH},
4289         {"MirrorMagic/Special", 0, 0, MENU_CLASS, CLASS_MIRROR_MASTER},
4290         {"Ninjutsu/Special", 0, 0, MENU_CLASS, CLASS_NINJA},
4291         {"Enter global map(<)", 2, 6, MENU_WILD, FALSE},
4292         {"Enter local map(>)", 2, 7, MENU_WILD, TRUE},
4293         {"", 0, 0, 0, 0},
4294 };
4295 #endif
4296
4297 static char inkey_from_menu(void)
4298 {
4299         char cmd;
4300         int basey, basex;
4301         int num = 0, max_num, old_num = 0;
4302         int menu = 0;
4303         bool kisuu;
4304
4305         if (p_ptr->y - panel_row_min > 10) basey = 2;
4306         else basey = 13;
4307         basex = 15;
4308
4309         /* Clear top line */
4310         prt("", 0, 0);
4311
4312         screen_save();
4313
4314         while(1)
4315         {
4316                 int i;
4317                 char sub_cmd;
4318                 concptr menu_name;
4319                 if (!menu) old_num = num;
4320                 put_str("+----------------------------------------------------+", basey, basex);
4321                 put_str("|                                                    |", basey+1, basex);
4322                 put_str("|                                                    |", basey+2, basex);
4323                 put_str("|                                                    |", basey+3, basex);
4324                 put_str("|                                                    |", basey+4, basex);
4325                 put_str("|                                                    |", basey+5, basex);
4326                 put_str("+----------------------------------------------------+", basey+6, basex);
4327
4328                 for(i = 0; i < 10; i++)
4329                 {
4330                         int hoge;
4331                         if (!menu_info[menu][i].cmd) break;
4332                         menu_name = menu_info[menu][i].name;
4333                         for(hoge = 0; ; hoge++)
4334                         {
4335                                 if (!special_menu_info[hoge].name[0]) break;
4336                                 if ((menu != special_menu_info[hoge].window) || (i != special_menu_info[hoge].number)) continue;
4337                                 switch(special_menu_info[hoge].jouken)
4338                                 {
4339                                 case MENU_CLASS:
4340                                         if (p_ptr->pclass == special_menu_info[hoge].jouken_naiyou) menu_name = special_menu_info[hoge].name;
4341                                         break;
4342                                 case MENU_WILD:
4343                                         if (!p_ptr->current_floor_ptr->dun_level && !p_ptr->current_floor_ptr->inside_arena && !p_ptr->current_floor_ptr->inside_quest)
4344                                         {
4345                                                 if ((byte)p_ptr->wild_mode == special_menu_info[hoge].jouken_naiyou) menu_name = special_menu_info[hoge].name;
4346                                         }
4347                                         break;
4348                                 default:
4349                                         break;
4350                                 }
4351                         }
4352                         put_str(menu_name, basey + 1 + i / 2, basex + 4 + (i % 2) * 24);
4353                 }
4354                 max_num = i;
4355                 kisuu = max_num % 2;
4356                 put_str(_("》", "> "),basey + 1 + num / 2, basex + 2 + (num % 2) * 24);
4357
4358                 /* Place the cursor on the player */
4359                 move_cursor_relative(p_ptr->y, p_ptr->x);
4360
4361                 sub_cmd = inkey();
4362                 if ((sub_cmd == ' ') || (sub_cmd == 'x') || (sub_cmd == 'X') || (sub_cmd == '\r') || (sub_cmd == '\n'))
4363                 {
4364                         if (menu_info[menu][num].fin)
4365                         {
4366                                 cmd = menu_info[menu][num].cmd;
4367                                 use_menu = TRUE;
4368                                 break;
4369                         }
4370                         else
4371                         {
4372                                 menu = menu_info[menu][num].cmd;
4373                                 num = 0;
4374                                 basey += 2;
4375                                 basex += 8;
4376                         }
4377                 }
4378                 else if ((sub_cmd == ESCAPE) || (sub_cmd == 'z') || (sub_cmd == 'Z') || (sub_cmd == '0'))
4379                 {
4380                         if (!menu)
4381                         {
4382                                 cmd = ESCAPE;
4383                                 break;
4384                         }
4385                         else
4386                         {
4387                                 menu = 0;
4388                                 num = old_num;
4389                                 basey -= 2;
4390                                 basex -= 8;
4391                                 screen_load();
4392                                 screen_save();
4393                         }
4394                 }
4395                 else if ((sub_cmd == '2') || (sub_cmd == 'j') || (sub_cmd == 'J'))
4396                 {
4397                         if (kisuu)
4398                         {
4399                                 if (num % 2)
4400                                         num = (num + 2) % (max_num - 1);
4401                                 else
4402                                         num = (num + 2) % (max_num + 1);
4403                         }
4404                         else num = (num + 2) % max_num;
4405                 }
4406                 else if ((sub_cmd == '8') || (sub_cmd == 'k') || (sub_cmd == 'K'))
4407                 {
4408                         if (kisuu)
4409                         {
4410                                 if (num % 2)
4411                                         num = (num + max_num - 3) % (max_num - 1);
4412                                 else
4413                                         num = (num + max_num - 1) % (max_num + 1);
4414                         }
4415                         else num = (num + max_num - 2) % max_num;
4416                 }
4417                 else if ((sub_cmd == '4') || (sub_cmd == '6') || (sub_cmd == 'h') || (sub_cmd == 'H') || (sub_cmd == 'l') || (sub_cmd == 'L'))
4418                 {
4419                         if ((num % 2) || (num == max_num - 1))
4420                         {
4421                                 num--;
4422                         }
4423                         else if (num < max_num - 1)
4424                         {
4425                                 num++;
4426                         }
4427                 }
4428         }
4429
4430         screen_load();
4431         if (!inkey_next) inkey_next = "";
4432
4433         return (cmd);
4434 }
4435
4436 /*
4437  * Request a command from the user.
4438  *
4439  * Sets p_ptr->command_cmd, p_ptr->command_dir, p_ptr->command_rep,
4440  * p_ptr->command_arg.  May modify p_ptr->command_new.
4441  *
4442  * Note that "caret" ("^") is treated specially, and is used to
4443  * allow manual input of control characters.  This can be used
4444  * on many machines to request repeated tunneling (Ctrl-H) and
4445  * on the Macintosh to request "Control-Caret".
4446  *
4447  * Note that "backslash" is treated specially, and is used to bypass any
4448  * keymap entry for the following character.  This is useful for macros.
4449  *
4450  * Note that this command is used both in the dungeon and in
4451  * stores, and must be careful to work in both situations.
4452  *
4453  * Note that "p_ptr->command_new" may not work any more.
4454  */
4455 void request_command(int shopping)
4456 {
4457         int i;
4458
4459         s16b cmd;
4460         int mode;
4461
4462         concptr act;
4463
4464 #ifdef JP
4465         int caretcmd = 0;
4466 #endif
4467         /* Roguelike */
4468         if (rogue_like_commands)
4469         {
4470                 mode = KEYMAP_MODE_ROGUE;
4471         }
4472
4473         /* Original */
4474         else
4475         {
4476                 mode = KEYMAP_MODE_ORIG;
4477         }
4478
4479
4480         /* No command yet */
4481         command_cmd = 0;
4482
4483         /* No "argument" yet */
4484         command_arg = 0;
4485
4486         /* No "direction" yet */
4487         command_dir = 0;
4488
4489         use_menu = FALSE;
4490
4491
4492         /* Get command */
4493         while (1)
4494         {
4495                 /* Hack -- auto-commands */
4496                 if (command_new)
4497                 {
4498                         msg_erase();
4499
4500                         /* Use auto-command */
4501                         cmd = command_new;
4502
4503                         /* Forget it */
4504                         command_new = 0;
4505                 }
4506
4507                 /* Get a keypress in "command" mode */
4508                 else
4509                 {
4510                         /* Hack -- no flush needed */
4511                         msg_flag = FALSE;
4512                         num_more = 0;
4513
4514                         /* Activate "command mode" */
4515                         inkey_flag = TRUE;
4516
4517                         cmd = inkey();
4518
4519                         if (!shopping && command_menu && ((cmd == '\r') || (cmd == '\n') || (cmd == 'x') || (cmd == 'X'))
4520                             && !keymap_act[mode][(byte)(cmd)])
4521                                 cmd = inkey_from_menu();
4522                 }
4523
4524                 /* Clear top line */
4525                 prt("", 0, 0);
4526
4527
4528                 /* Command Count */
4529                 if (cmd == '0')
4530                 {
4531                         COMMAND_ARG old_arg = command_arg;
4532
4533                         /* Reset */
4534                         command_arg = 0;
4535
4536                         /* Begin the input */
4537                         prt(_("回数: ", "Count: "), 0, 0);
4538
4539                         /* Get a command count */
4540                         while (1)
4541                         {
4542                                 /* Get a new keypress */
4543                                 cmd = inkey();
4544
4545                                 /* Simple editing (delete or backspace) */
4546                                 if ((cmd == 0x7F) || (cmd == KTRL('H')))
4547                                 {
4548                                         /* Delete a digit */
4549                                         command_arg = command_arg / 10;
4550
4551                                         /* Show current count */
4552                                         prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
4553                                 }
4554
4555                                 /* Actual numeric data */
4556                                 else if (cmd >= '0' && cmd <= '9')
4557                                 {
4558                                         /* Stop count at 9999 */
4559                                         if (command_arg >= 1000)
4560                                         {
4561                                                 /* Warn */
4562                                                 bell();
4563
4564                                                 /* Limit */
4565                                                 command_arg = 9999;
4566                                         }
4567
4568                                         /* Increase count */
4569                                         else
4570                                         {
4571                                                 /* Incorporate that digit */
4572                                                 command_arg = command_arg * 10 + D2I(cmd);
4573                                         }
4574
4575                                         /* Show current count */
4576                                         prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
4577                                 }
4578
4579                                 /* Exit on "unusable" input */
4580                                 else
4581                                 {
4582                                         break;
4583                                 }
4584                         }
4585
4586                         /* Hack -- Handle "zero" */
4587                         if (command_arg == 0)
4588                         {
4589                                 /* Default to 99 */
4590                                 command_arg = 99;
4591
4592                                 /* Show current count */
4593                                 prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
4594                         }
4595
4596                         /* Hack -- Handle "old_arg" */
4597                         if (old_arg != 0)
4598                         {
4599                                 /* Restore old_arg */
4600                                 command_arg = old_arg;
4601
4602                                 /* Show current count */
4603                                 prt(format(_("回数: %d", "Count: %d"), command_arg), 0, 0);
4604                         }
4605
4606                         /* Hack -- white-space means "enter command now" */
4607                         if ((cmd == ' ') || (cmd == '\n') || (cmd == '\r'))
4608                         {
4609                                 /* Get a real command */
4610                                 if (!get_com(_("コマンド: ", "Command: "), (char *)&cmd, FALSE))
4611                                 {
4612                                         /* Clear count */
4613                                         command_arg = 0;
4614                                         continue;
4615                                 }
4616                         }
4617                 }
4618
4619
4620                 /* Allow "keymaps" to be bypassed */
4621                 if (cmd == '\\')
4622                 {
4623                         /* Get a real command */
4624                         (void)get_com(_("コマンド: ", "Command: "), (char *)&cmd, FALSE);
4625
4626                         /* Hack -- bypass keymaps */
4627                         if (!inkey_next) inkey_next = "";
4628                 }
4629
4630
4631                 /* Allow "control chars" to be entered */
4632                 if (cmd == '^')
4633                 {
4634                         /* Get a new command and controlify it */
4635                         if (get_com(_("CTRL: ", "Control: "), (char *)&cmd, FALSE)) cmd = KTRL(cmd);
4636                 }
4637
4638
4639                 /* Look up applicable keymap */
4640                 act = keymap_act[mode][(byte)(cmd)];
4641
4642                 /* Apply keymap if not inside a keymap already */
4643                 if (act && !inkey_next)
4644                 {
4645                         /* Install the keymap (limited buffer size) */
4646                         (void)strnfmt(request_command_buffer, 256, "%s", act);
4647
4648                         /* Start using the buffer */
4649                         inkey_next = request_command_buffer;
4650                         continue;
4651                 }
4652
4653                 if (!cmd) continue;
4654
4655
4656                 /* Use command */
4657                 command_cmd = (byte)cmd;
4658
4659                 break;
4660         }
4661
4662         /* Hack -- Auto-repeat certain commands */
4663         if (always_repeat && (command_arg <= 0))
4664         {
4665                 /* Hack -- auto repeat certain commands */
4666                 if (my_strchr("TBDoc+", (char)command_cmd))
4667                 {
4668                         /* Repeat 99 times */
4669                         command_arg = 99;
4670                 }
4671         }
4672
4673         /* Shopping */
4674         if (shopping == 1)
4675         {
4676                 /* Convert */
4677                 switch (command_cmd)
4678                 {
4679                         /* Command "p" -> "purchase" (get) */
4680                 case 'p': command_cmd = 'g'; break;
4681
4682                         /* Command "m" -> "purchase" (get) */
4683                 case 'm': command_cmd = 'g'; break;
4684
4685                         /* Command "s" -> "sell" (drop) */
4686                 case 's': command_cmd = 'd'; break;
4687                 }
4688         }
4689
4690 #ifdef JP
4691         for (i = 0; i < 256; i++)
4692         {
4693                 concptr s;
4694                 if ((s = keymap_act[mode][i]) != NULL)
4695                 {
4696                         if (*s == command_cmd && *(s+1) == 0)
4697                         {
4698                                 caretcmd = i;
4699                                 break;
4700                         }
4701                 }
4702         }
4703         if (!caretcmd)
4704                 caretcmd = command_cmd;
4705 #endif
4706
4707         /* Hack -- Scan equipment */
4708         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
4709         {
4710                 concptr s;
4711
4712                 object_type *o_ptr = &p_ptr->inventory_list[i];
4713                 if (!o_ptr->k_idx) continue;
4714
4715                 /* No inscription */
4716                 if (!o_ptr->inscription) continue;
4717
4718                 /* Obtain the inscription */
4719                 s = quark_str(o_ptr->inscription);
4720
4721                 /* Find a '^' */
4722                 s = my_strchr(s, '^');
4723
4724                 /* Process preventions */
4725                 while (s)
4726                 {
4727                         /* Check the "restriction" character */
4728 #ifdef JP
4729                         if ((s[1] == caretcmd) || (s[1] == '*'))
4730 #else
4731                         if ((s[1] == command_cmd) || (s[1] == '*'))
4732 #endif
4733
4734                         {
4735                                 /* Hack -- Verify command */
4736                                 if (!get_check(_("本当ですか? ", "Are you sure? ")))
4737                                 {
4738                                         /* Hack -- Use space */
4739                                         command_cmd = ' ';
4740                                 }
4741                         }
4742
4743                         /* Find another '^' */
4744                         s = my_strchr(s + 1, '^');
4745                 }
4746         }
4747
4748
4749         /* Hack -- erase the message line. */
4750         prt("", 0, 0);
4751 }
4752
4753
4754
4755 /*
4756  * Check a char for "vowel-hood"
4757  */
4758 bool is_a_vowel(int ch)
4759 {
4760         switch (ch)
4761         {
4762         case 'a':
4763         case 'e':
4764         case 'i':
4765         case 'o':
4766         case 'u':
4767         case 'A':
4768         case 'E':
4769         case 'I':
4770         case 'O':
4771         case 'U':
4772                 return (TRUE);
4773         }
4774
4775         return (FALSE);
4776 }
4777
4778
4779
4780 #if 0
4781
4782 /*
4783  * Replace the first instance of "target" in "buf" with "insert"
4784  * If "insert" is NULL, just remove the first instance of "target"
4785  * In either case, return TRUE if "target" is found.
4786  *
4787  * XXX Could be made more efficient, especially in the
4788  * case where "insert" is smaller than "target".
4789  */
4790 static bool insert_str(char *buf, concptr target, concptr insert)
4791 {
4792         int   i, len;
4793         int                b_len, t_len, i_len;
4794
4795         /* Attempt to find the target (modify "buf") */
4796         buf = my_strstr(buf, target);
4797
4798         /* No target found */
4799         if (!buf) return (FALSE);
4800
4801         /* Be sure we have an insertion string */
4802         if (!insert) insert = "";
4803
4804         /* Extract some lengths */
4805         t_len = strlen(target);
4806         i_len = strlen(insert);
4807         b_len = strlen(buf);
4808
4809         /* How much "movement" do we need? */
4810         len = i_len - t_len;
4811
4812         /* We need less space (for insert) */
4813         if (len < 0)
4814         {
4815                 for (i = t_len; i < b_len; ++i) buf[i+len] = buf[i];
4816         }
4817
4818         /* We need more space (for insert) */
4819         else if (len > 0)
4820         {
4821                 for (i = b_len-1; i >= t_len; --i) buf[i+len] = buf[i];
4822         }
4823
4824         /* If movement occured, we need a new terminator */
4825         if (len) buf[b_len+len] = '\0';
4826
4827         /* Now copy the insertion string */
4828         for (i = 0; i < i_len; ++i) buf[i] = insert[i];
4829
4830         /* Successful operation */
4831         return (TRUE);
4832 }
4833
4834
4835 #endif
4836
4837
4838 /*
4839  * GH
4840  * Called from cmd4.c and a few other places. Just extracts
4841  * a direction from the keymap for ch (the last direction,
4842  * in fact) byte or char here? I'm thinking that keymaps should
4843  * generally only apply to single keys, which makes it no more
4844  * than 128, so a char should suffice... but keymap_act is 256...
4845  */
4846 int get_keymap_dir(char ch)
4847 {
4848         int d = 0;
4849
4850         /* Already a direction? */
4851         if (isdigit(ch))
4852         {
4853                 d = D2I(ch);
4854         }
4855         else
4856         {
4857                 BIT_FLAGS mode;
4858                 concptr act, s;
4859
4860                 /* Roguelike */
4861                 if (rogue_like_commands)
4862                 {
4863                         mode = KEYMAP_MODE_ROGUE;
4864                 }
4865
4866                 /* Original */
4867                 else
4868                 {
4869                         mode = KEYMAP_MODE_ORIG;
4870                 }
4871
4872                 /* Extract the action (if any) */
4873                 act = keymap_act[mode][(byte)(ch)];
4874
4875                 /* Analyze */
4876                 if (act)
4877                 {
4878                         /* Convert to a direction */
4879                         for (s = act; *s; ++s)
4880                         {
4881                                 /* Use any digits in keymap */
4882                                 if (isdigit(*s)) d = D2I(*s);
4883                         }
4884                 }
4885         }
4886         if (d == 5) d = 0;
4887
4888         /* Return direction */
4889         return (d);
4890 }
4891
4892
4893 #define REPEAT_MAX              20
4894
4895 /* Number of chars saved */
4896 static int repeat__cnt = 0;
4897
4898 /* Current index */
4899 static int repeat__idx = 0;
4900
4901 /* Saved "stuff" */
4902 static COMMAND_CODE repeat__key[REPEAT_MAX];
4903
4904
4905 void repeat_push(COMMAND_CODE what)
4906 {
4907         /* Too many keys */
4908         if (repeat__cnt == REPEAT_MAX) return;
4909
4910         /* Push the "stuff" */
4911         repeat__key[repeat__cnt++] = what;
4912
4913         /* Prevents us from pulling keys */
4914         ++repeat__idx;
4915 }
4916
4917
4918 bool repeat_pull(COMMAND_CODE *what)
4919 {
4920         /* All out of keys */
4921         if (repeat__idx == repeat__cnt) return (FALSE);
4922
4923         /* Grab the next key, advance */
4924         *what = repeat__key[repeat__idx++];
4925
4926         /* Success */
4927         return (TRUE);
4928 }
4929
4930 void repeat_check(void)
4931 {
4932         COMMAND_CODE what;
4933
4934         /* Ignore some commands */
4935         if (command_cmd == ESCAPE) return;
4936         if (command_cmd == ' ') return;
4937         if (command_cmd == '\r') return;
4938         if (command_cmd == '\n') return;
4939
4940         /* Repeat Last Command */
4941         if (command_cmd == 'n')
4942         {
4943                 /* Reset */
4944                 repeat__idx = 0;
4945
4946                 /* Get the command */
4947                 if (repeat_pull(&what))
4948                 {
4949                         /* Save the command */
4950                         command_cmd = what;
4951                 }
4952         }
4953
4954         /* Start saving new command */
4955         else
4956         {
4957                 /* Reset */
4958                 repeat__cnt = 0;
4959                 repeat__idx = 0;
4960
4961                 what = command_cmd;
4962
4963                 /* Save this command */
4964                 repeat_push(what);
4965         }
4966 }
4967
4968
4969 #ifdef SORT_R_INFO
4970
4971 /*
4972  * Array size for which InsertionSort
4973  * is used instead of QuickSort
4974  */
4975 #define CUTOFF 4
4976
4977
4978 /*
4979  * Exchange two sort-entries
4980  * (should probably be coded inline
4981  * for speed increase)
4982  */
4983 static void swap(tag_type *a, tag_type *b)
4984 {
4985         tag_type temp;
4986
4987         temp = *a;
4988         *a = *b;
4989         *b = temp;
4990 }
4991
4992
4993 /*
4994  * Insertion-Sort algorithm
4995  * (used by the Quicksort algorithm)
4996  */
4997 static void InsertionSort(tag_type elements[], int number)
4998 {
4999         int j, P;
5000
5001         tag_type tmp;
5002
5003         for (P = 1; P < number; P++)
5004         {
5005                 tmp = elements[P];
5006                 for (j = P; (j > 0) && (elements[j - 1].tag > tmp.tag); j--)
5007                         elements[j] = elements[j - 1];
5008                 elements[j] = tmp;
5009         }
5010 }
5011
5012
5013 /*
5014  * Helper function for Quicksort
5015  */
5016 static tag_type median3(tag_type elements[], int left, int right)
5017 {
5018         int center = (left + right) / 2;
5019
5020         if (elements[left].tag > elements[center].tag)
5021                 swap(&elements[left], &elements[center]);
5022         if (elements[left].tag > elements[right].tag)
5023                 swap(&elements[left], &elements[right]);
5024         if (elements[center].tag > elements[right].tag)
5025                 swap(&elements[center], &elements[right]);
5026
5027         swap(&elements[center], &elements[right - 1]);
5028         return (elements[right - 1]);
5029 }
5030
5031
5032 /*
5033  * Quicksort algorithm
5034  *
5035  * The "median of three" pivot selection eliminates
5036  * the bad case of already sorted input.
5037  *
5038  * We use InsertionSort for smaller sub-arrays,
5039  * because it is faster in this case.
5040  *
5041  * For details see: "Data Structures and Algorithm
5042  * Analysis in C" by Mark Allen Weiss.
5043  */
5044 static void quicksort(tag_type elements[], int left, int right)
5045 {
5046         int i, j;
5047         tag_type pivot;
5048
5049         if (left + CUTOFF <= right)
5050         {
5051                 pivot = median3(elements, left, right);
5052
5053                 i = left; j = right -1;
5054
5055                 while (TRUE)
5056                 {
5057                         while (elements[++i].tag < pivot.tag);
5058                         while (elements[--j].tag > pivot.tag);
5059
5060                         if (i < j)
5061                                 swap(&elements[i], &elements[j]);
5062                         else
5063                                 break;
5064                 }
5065
5066                 /* Restore pivot */
5067                 swap(&elements[i], &elements[right - 1]);
5068
5069                 quicksort(elements, left, i - 1);
5070                 quicksort(elements, i + 1, right);
5071         }
5072         else
5073         {
5074                 /* Use InsertionSort on small arrays */
5075                 InsertionSort(elements + left, right - left + 1);
5076         }
5077 }
5078
5079
5080 /*
5081  * Frontend for the sorting algorithm
5082  *
5083  * Sorts an array of tagged pointers
5084  * with <number> elements.
5085  */
5086 void tag_sort(tag_type elements[], int number)
5087 {
5088         quicksort(elements, 0, number - 1);
5089 }
5090
5091 #endif /* SORT_R_INFO */
5092
5093 #ifdef SUPPORT_GAMMA
5094
5095 /* Table of gamma values */
5096 byte gamma_table[256];
5097
5098 /* Table of ln(x/256) * 256 for x going from 0 -> 255 */
5099 static s16b gamma_helper[256] =
5100 {
5101 0,-1420,-1242,-1138,-1065,-1007,-961,-921,-887,-857,-830,-806,-783,-762,-744,-726,
5102 -710,-694,-679,-666,-652,-640,-628,-617,-606,-596,-586,-576,-567,-577,-549,-541,
5103 -532,-525,-517,-509,-502,-495,-488,-482,-475,-469,-463,-457,-451,-455,-439,-434,
5104 -429,-423,-418,-413,-408,-403,-398,-394,-389,-385,-380,-376,-371,-367,-363,-359,
5105 -355,-351,-347,-343,-339,-336,-332,-328,-325,-321,-318,-314,-311,-308,-304,-301,
5106 -298,-295,-291,-288,-285,-282,-279,-276,-273,-271,-268,-265,-262,-259,-257,-254,
5107 -251,-248,-246,-243,-241,-238,-236,-233,-231,-228,-226,-223,-221,-219,-216,-214,
5108 -212,-209,-207,-205,-203,-200,-198,-196,-194,-192,-190,-188,-186,-184,-182,-180,
5109 -178,-176,-174,-172,-170,-168,-166,-164,-162,-160,-158,-156,-155,-153,-151,-149,
5110 -147,-146,-144,-142,-140,-139,-137,-135,-134,-132,-130,-128,-127,-125,-124,-122,
5111 -120,-119,-117,-116,-114,-112,-111,-109,-108,-106,-105,-103,-102,-100,-99,-97,
5112 -96,-95,-93,-92,-90,-89,-87,-86,-85,-83,-82,-80,-79,-78,-76,-75,
5113 -74,-72,-71,-70,-68,-67,-66,-65,-63,-62,-61,-59,-58,-57,-56,-54,
5114 -53,-52,-51,-50,-48,-47,-46,-45,-44,-42,-41,-40,-39,-38,-37,-35,
5115 -34,-33,-32,-31,-30,-29,-27,-26,-25,-24,-23,-22,-21,-20,-19,-18,
5116 -17,-16,-14,-13,-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1
5117 };
5118
5119
5120 /*
5121  * Build the gamma table so that floating point isn't needed.
5122  *
5123  * Note gamma goes from 0->256.  The old value of 100 is now 128.
5124  */
5125 void build_gamma_table(int gamma)
5126 {
5127         int i, n;
5128
5129         /*
5130          * value is the current sum.
5131          * diff is the new term to add to the series.
5132          */
5133         long value, diff;
5134
5135         /* Hack - convergence is bad in these cases. */
5136         gamma_table[0] = 0;
5137         gamma_table[255] = 255;
5138
5139         for (i = 1; i < 255; i++)
5140         {
5141                 /*
5142                  * Initialise the Taylor series
5143                  *
5144                  * value and diff have been scaled by 256
5145                  */
5146
5147                 n = 1;
5148                 value = 256 * 256;
5149                 diff = ((long)gamma_helper[i]) * (gamma - 256);
5150
5151                 while (diff)
5152                 {
5153                         value += diff;
5154                         n++;
5155
5156
5157                         /*
5158                          * Use the following identiy to calculate the gamma table.
5159                          * exp(x) = 1 + x + x^2/2 + x^3/(2*3) + x^4/(2*3*4) +...
5160                          *
5161                          * n is the current term number.
5162                          *
5163                          * The gamma_helper array contains a table of
5164                          * ln(x/256) * 256
5165                          * This is used because a^b = exp(b*ln(a))
5166                          *
5167                          * In this case:
5168                          * a is i / 256
5169                          * b is gamma.
5170                          *
5171                          * Note that everything is scaled by 256 for accuracy,
5172                          * plus another factor of 256 for the final result to
5173                          * be from 0-255.  Thus gamma_helper[] * gamma must be
5174                          * divided by 256*256 each itteration, to get back to
5175                          * the original power series.
5176                          */
5177                         diff = (((diff / 256) * gamma_helper[i]) * (gamma - 256)) / (256 * n);
5178                 }
5179
5180                 /*
5181                  * Store the value in the table so that the
5182                  * floating point pow function isn't needed .
5183                  */
5184                 gamma_table[i] = ((long)(value / 256) * i) / 256;
5185         }
5186 }
5187
5188 #endif /* SUPPORT_GAMMA */
5189
5190
5191 /*
5192  * Add a series of keypresses to the "queue".
5193  *
5194  * Return any errors generated by Term_keypress() in doing so, or SUCCESS
5195  * if there are none.
5196  *
5197  * Catch the "out of space" error before anything is printed.
5198  *
5199  * NB: The keys added here will be interpreted by any macros or keymaps.
5200  */
5201 errr type_string(concptr str, uint len)
5202 {
5203         errr err = 0;
5204         concptr s;
5205
5206         term *old = Term;
5207
5208         /* Paranoia - no string. */
5209         if (!str) return -1;
5210
5211         /* Hack - calculate the string length here if none given. */
5212         if (!len) len = strlen(str);
5213
5214         /* Activate the main window, as all pastes go there. */
5215         Term_activate(term_screen);
5216
5217         for (s = str; s < str+len; s++)
5218         {
5219                 /* Catch end of string */
5220                 if (*s == '\0') break;
5221
5222                 err = Term_keypress(*s);
5223
5224                 /* Catch errors */
5225                 if (err) break;
5226         }
5227
5228         /* Activate the original window. */
5229         Term_activate(old);
5230
5231         return err;
5232 }
5233
5234
5235
5236 void roff_to_buf(concptr str, int maxlen, char *tbuf, size_t bufsize)
5237 {
5238         int read_pt = 0;
5239         int write_pt = 0;
5240         int line_len = 0;
5241         int word_punct = 0;
5242         char ch[3];
5243         ch[2] = '\0';
5244
5245         while (str[read_pt])
5246         {
5247 #ifdef JP
5248                 bool kinsoku = FALSE;
5249                 bool kanji;
5250 #endif
5251                 int ch_len = 1;
5252
5253                 /* Prepare one character */
5254                 ch[0] = str[read_pt];
5255                 ch[1] = '\0';
5256 #ifdef JP
5257                 kanji  = iskanji(ch[0]);
5258
5259                 if (kanji)
5260                 {
5261                         ch[1] = str[read_pt+1];
5262                         ch_len = 2;
5263
5264                         if (strcmp(ch, "。") == 0 ||
5265                             strcmp(ch, "、") == 0 ||
5266                             strcmp(ch, "ィ") == 0 ||
5267                             strcmp(ch, "ー") == 0)
5268                                 kinsoku = TRUE;
5269                 }
5270                 else if (!isprint(ch[0]))
5271                         ch[0] = ' ';
5272 #else
5273                 if (!isprint(ch[0]))
5274                         ch[0] = ' ';
5275 #endif
5276
5277                 if (line_len + ch_len > maxlen - 1 || str[read_pt] == '\n')
5278                 {
5279                         int word_len;
5280
5281                         /* return to better wrapping point. */
5282                         /* Space character at the end of the line need not to be printed. */
5283                         word_len = read_pt - word_punct;
5284 #ifdef JP
5285                         if (kanji && !kinsoku)
5286                                 /* nothing */ ;
5287                         else
5288 #endif
5289                         if (ch[0] == ' ' || word_len >= line_len/2)
5290                                 read_pt++;
5291                         else
5292                         {
5293                                 read_pt = word_punct;
5294                                 if (str[word_punct] == ' ')
5295                                         read_pt++;
5296                                 write_pt -= word_len;
5297                         }
5298
5299                         tbuf[write_pt++] = '\0';
5300                         line_len = 0;
5301                         word_punct = read_pt;
5302                         continue;
5303                 }
5304                 if (ch[0] == ' ')
5305                         word_punct = read_pt;
5306 #ifdef JP
5307                 if (!kinsoku) word_punct = read_pt;
5308 #endif
5309
5310                 /* Not enough buffer size */
5311                 if ((size_t)(write_pt + 3) >= bufsize) break;
5312
5313                 tbuf[write_pt++] = ch[0];
5314                 line_len++;
5315                 read_pt++;
5316 #ifdef JP
5317                 if (kanji)
5318                 {
5319                         tbuf[write_pt++] = ch[1];
5320                         line_len++;
5321                         read_pt++;
5322                 }
5323 #endif
5324         }
5325         tbuf[write_pt] = '\0';
5326         tbuf[write_pt+1] = '\0';
5327
5328         return;
5329 }
5330
5331
5332 /*
5333  * The my_strcpy() function copies up to 'bufsize'-1 characters from 'src'
5334  * to 'buf' and NUL-terminates the result.  The 'buf' and 'src' strings may
5335  * not overlap.
5336  *
5337  * my_strcpy() returns strlen(src).  This makes checking for truncation
5338  * easy.  Example: if (my_strcpy(buf, src, sizeof(buf)) >= sizeof(buf)) ...;
5339  *
5340  * This function should be equivalent to the strlcpy() function in BSD.
5341  */
5342 size_t my_strcpy(char *buf, concptr src, size_t bufsize)
5343 {
5344 #ifdef JP
5345
5346         char *d = buf;
5347         concptr s = src;
5348         size_t len = 0;
5349
5350         if (bufsize > 0) {
5351                 /* reserve for NUL termination */
5352                 bufsize--;
5353
5354                 /* Copy as many bytes as will fit */
5355                 while (*s && (len < bufsize))
5356                 {
5357                         if (iskanji(*s))
5358                         {
5359                                 if (len + 1 >= bufsize || !*(s+1)) break;
5360                                 *d++ = *s++;
5361                                 *d++ = *s++;
5362                                 len += 2;
5363                         }
5364                         else
5365                         {
5366                                 *d++ = *s++;
5367                                 len++;
5368                         }
5369                 }
5370                 *d = '\0';
5371         }
5372
5373         while(*s++) len++;
5374
5375         return len;
5376
5377 #else
5378
5379         size_t len = strlen(src);
5380         size_t ret = len;
5381         if (bufsize == 0) return ret;
5382
5383         /* Truncate */
5384         if (len >= bufsize) len = bufsize - 1;
5385
5386         /* Copy the string and terminate it */
5387         (void)memcpy(buf, src, len);
5388         buf[len] = '\0';
5389
5390         /* Return strlen(src) */
5391         return ret;
5392
5393 #endif
5394 }
5395
5396
5397 /*
5398  * The my_strcat() tries to append a string to an existing NUL-terminated string.
5399  * It never writes more characters into the buffer than indicated by 'bufsize' and
5400  * NUL-terminates the buffer.  The 'buf' and 'src' strings may not overlap.
5401  *
5402  * my_strcat() returns strlen(buf) + strlen(src).  This makes checking for
5403  * truncation easy.  Example:
5404  * if (my_strcat(buf, src, sizeof(buf)) >= sizeof(buf)) ...;
5405  *
5406  * This function should be equivalent to the strlcat() function in BSD.
5407  */
5408 size_t my_strcat(char *buf, concptr src, size_t bufsize)
5409 {
5410         size_t dlen = strlen(buf);
5411
5412         /* Is there room left in the buffer? */
5413         if (dlen < bufsize - 1)
5414         {
5415                 /* Append as much as possible  */
5416                 return (dlen + my_strcpy(buf + dlen, src, bufsize - dlen));
5417         }
5418         else
5419         {
5420                 /* Return without appending */
5421                 return (dlen + strlen(src));
5422         }
5423 }
5424
5425
5426 /*
5427  * A copy of ANSI strstr()
5428  *
5429  * my_strstr() can handle Kanji strings correctly.
5430  */
5431 char *my_strstr(concptr haystack, concptr needle)
5432 {
5433         int i;
5434         int l1 = strlen(haystack);
5435         int l2 = strlen(needle);
5436
5437         if (l1 >= l2)
5438         {
5439                 for(i = 0; i <= l1 - l2; i++)
5440                 {
5441                         if(!strncmp(haystack + i, needle, l2))
5442                                 return (char *)haystack + i;
5443
5444 #ifdef JP
5445                         if (iskanji(*(haystack + i))) i++;
5446 #endif
5447                 }
5448         }
5449
5450         return NULL;
5451 }
5452
5453
5454 /*
5455  * A copy of ANSI strchr()
5456  *
5457  * my_strchr() can handle Kanji strings correctly.
5458  */
5459 char *my_strchr(concptr ptr, char ch)
5460 {
5461         for ( ; *ptr != '\0'; ptr++)
5462         {
5463                 if (*ptr == ch) return (char *)ptr;
5464
5465 #ifdef JP
5466                 if (iskanji(*ptr)) ptr++;
5467 #endif
5468         }
5469
5470         return NULL;
5471 }
5472
5473
5474 /*
5475  * Convert string to lower case
5476  */
5477 void str_tolower(char *str)
5478 {
5479         /* Force to be lower case string */
5480         for (; *str; str++)
5481         {
5482 #ifdef JP
5483                 if (iskanji(*str))
5484                 {
5485                         str++;
5486                         continue;
5487                 }
5488 #endif
5489                 *str = (char)tolower(*str);
5490         }
5491 }
5492
5493
5494 /*
5495  * Get a keypress from the user.
5496  * And interpret special keys as internal code.
5497  *
5498  * This function is a Mega-Hack and depend on pref-xxx.prf's.
5499  * Currently works on Linux(UNIX), Windows, and Macintosh only.
5500  */
5501 int inkey_special(bool numpad_cursor)
5502 {
5503         static const struct {
5504                 concptr keyname;
5505                 int keyflag;
5506         } modifier_key_list[] = {
5507                 {"shift-", SKEY_MOD_SHIFT},
5508                 {"control-", SKEY_MOD_CONTROL},
5509                 {NULL, 0},
5510         };
5511
5512         static const struct {
5513                 bool numpad;
5514                 concptr keyname;
5515                 int keycode;
5516         } special_key_list[] = {
5517                 {FALSE, "Down]", SKEY_DOWN},
5518                 {FALSE, "Left]", SKEY_LEFT},
5519                 {FALSE, "Right]", SKEY_RIGHT},
5520                 {FALSE, "Up]", SKEY_UP},
5521                 {FALSE, "Page_Up]", SKEY_PGUP},
5522                 {FALSE, "Page_Down]", SKEY_PGDOWN},
5523                 {FALSE, "Home]", SKEY_TOP},
5524                 {FALSE, "End]", SKEY_BOTTOM},
5525                 {TRUE, "KP_Down]", SKEY_DOWN},
5526                 {TRUE, "KP_Left]", SKEY_LEFT},
5527                 {TRUE, "KP_Right]", SKEY_RIGHT},
5528                 {TRUE, "KP_Up]", SKEY_UP},
5529                 {TRUE, "KP_Page_Up]", SKEY_PGUP},
5530                 {TRUE, "KP_Page_Down]", SKEY_PGDOWN},
5531                 {TRUE, "KP_Home]", SKEY_TOP},
5532                 {TRUE, "KP_End]", SKEY_BOTTOM},
5533                 {TRUE, "KP_2]", SKEY_DOWN},
5534                 {TRUE, "KP_4]", SKEY_LEFT},
5535                 {TRUE, "KP_6]", SKEY_RIGHT},
5536                 {TRUE, "KP_8]", SKEY_UP},
5537                 {TRUE, "KP_9]", SKEY_PGUP},
5538                 {TRUE, "KP_3]", SKEY_PGDOWN},
5539                 {TRUE, "KP_7]", SKEY_TOP},
5540                 {TRUE, "KP_1]", SKEY_BOTTOM},
5541                 {FALSE, NULL, 0},
5542         };
5543
5544         static const struct {
5545                 concptr keyname;
5546                 int keycode;
5547         } gcu_special_key_list[] = {
5548                 {"A", SKEY_UP},
5549                 {"B", SKEY_DOWN},
5550                 {"C", SKEY_RIGHT},
5551                 {"D", SKEY_LEFT},
5552                 {"1~", SKEY_TOP},
5553                 {"4~", SKEY_BOTTOM},
5554                 {"5~", SKEY_PGUP},
5555                 {"6~", SKEY_PGDOWN},
5556                 {NULL, 0},
5557         };
5558
5559         char buf[1024];
5560         concptr str = buf;
5561         char key;
5562         int skey = 0;
5563         int modifier = 0;
5564         int i;
5565         size_t trig_len;
5566
5567         /*
5568          * Forget macro trigger ----
5569          * It's important if we are already expanding macro action
5570          */
5571         inkey_macro_trigger_string[0] = '\0';
5572
5573         /* Get a keypress */
5574         key = inkey();
5575
5576         /* Examine trigger string */
5577         trig_len = strlen(inkey_macro_trigger_string);
5578
5579         /* Already known that no special key */
5580         if (!trig_len) return (int)((unsigned char)key);
5581
5582         /*
5583          * Hack -- Ignore macro defined on ASCII characters.
5584          */
5585         if (trig_len == 1 && parse_macro)
5586         {
5587                 char c = inkey_macro_trigger_string[0];
5588
5589                 /* Cancel macro action on the queue */
5590                 forget_macro_action();
5591
5592                 /* Return the originaly pressed key */
5593                 return (int)((unsigned char)c);
5594         }
5595
5596         /* Convert the trigger */
5597         ascii_to_text(buf, inkey_macro_trigger_string);
5598
5599         /* Check the prefix "\[" */
5600         if (prefix(str, "\\["))
5601         {
5602                 /* Skip "\[" */
5603                 str += 2;
5604
5605                 /* Examine modifier keys */
5606                 while (TRUE)
5607                 {
5608                         for (i = 0; modifier_key_list[i].keyname; i++)
5609                         {
5610                                 if (prefix(str, modifier_key_list[i].keyname))
5611                                 {
5612                                         /* Get modifier key flag */
5613                                         str += strlen(modifier_key_list[i].keyname);
5614                                         modifier |= modifier_key_list[i].keyflag;
5615                                 }
5616                         }
5617
5618                         /* No more modifier key found */
5619                         if (!modifier_key_list[i].keyname) break;
5620                 }
5621
5622                 /* numpad_as_cursorkey option force numpad keys to input numbers */
5623                 if (!numpad_as_cursorkey) numpad_cursor = FALSE;
5624
5625                 /* Get a special key code */
5626                 for (i = 0; special_key_list[i].keyname; i++)
5627                 {
5628                         if ((!special_key_list[i].numpad || numpad_cursor) &&
5629                             streq(str, special_key_list[i].keyname))
5630                         {
5631                                 skey = special_key_list[i].keycode;
5632                                 break;
5633                         }
5634                 }
5635
5636                 /* A special key found */
5637                 if (skey)
5638                 {
5639                         /* Cancel macro action on the queue */
5640                         forget_macro_action();
5641
5642                         /* Return special key code and modifier flags */
5643                         return (skey | modifier);
5644                 }
5645         }
5646
5647         if (prefix(str, "\\e["))
5648         {
5649                 str += 3;
5650
5651                 for (i = 0; gcu_special_key_list[i].keyname; i++)
5652                 {
5653                         if (streq(str, gcu_special_key_list[i].keyname))
5654                         {
5655                                 return gcu_special_key_list[i].keycode;
5656                         }
5657                 }
5658         }
5659
5660         /* No special key found? */
5661
5662         /* Don't bother with this trigger no more */
5663         inkey_macro_trigger_string[0] = '\0';
5664
5665         /* Return normal keycode */
5666         return (int)((unsigned char)key);
5667 }
5668