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