src/util.c

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