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