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