src/util.c

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