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