src/util.c

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