src/util.c

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