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