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