src/util.c

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