src/util.c

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