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