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