src/autopick.c

   1 /* File: autopick.c */
   2
   3 /* Purpose: Object Auto-picker/Destroyer */
   4
   5 /*
   6  * Copyright (c) 2002  Mogami
   7  *
   8  * This software may be copied and distributed for educational, research, and
   9  * not for profit purposes provided that this copyright and statement are
  10  * included in all such copies.
  11  */
  12
  13 #include "angband.h"
  14
  15
  16 #define MAX_LINELEN 1024
  17
  18 /*
  19  * Macros for Keywords
  20  */
  21 #define FLG_ALL             0
  22 #define FLG_COLLECTING      1
  23 #define FLG_UNAWARE         2
  24 #define FLG_UNIDENTIFIED    3
  25 #define FLG_IDENTIFIED      4
  26 #define FLG_STAR_IDENTIFIED 5
  27 #define FLG_BOOSTED         6
  28 #define FLG_MORE_THAN       7
  29 #define FLG_DICE            8
  30 #define FLG_MORE_BONUS      9
  31 #define FLG_MORE_BONUS2     10
  32 #define FLG_WORTHLESS       11
  33 #define FLG_ARTIFACT        12
  34 #define FLG_EGO             13
  35 #define FLG_NAMELESS        14
  36 #define FLG_WANTED          15
  37 #define FLG_UNIQUE          16
  38 #define FLG_HUMAN           17
  39 #define FLG_UNREADABLE      18
  40 #define FLG_REALM1          19
  41 #define FLG_REALM2          20
  42 #define FLG_FIRST           21
  43 #define FLG_SECOND          22
  44 #define FLG_THIRD           23
  45 #define FLG_FOURTH          24
  46
  47 #define FLG_ITEMS           30
  48 #define FLG_WEAPONS         31
  49 #define FLG_ARMORS          32
  50 #define FLG_MISSILES        33
  51 #define FLG_DEVICES         34
  52 #define FLG_LIGHTS          35
  53 #define FLG_JUNKS           36
  54 #define FLG_SPELLBOOKS      37
  55 #define FLG_HAFTED          38
  56 #define FLG_SHIELDS         39
  57 #define FLG_BOWS            40
  58 #define FLG_RINGS           41
  59 #define FLG_AMULETS         42
  60 #define FLG_SUITS           43
  61 #define FLG_CLOAKS          44
  62 #define FLG_HELMS           45
  63 #define FLG_GLOVES          46
  64 #define FLG_BOOTS           47
  65 #define FLG_FAVORITE        48
  66
  67 #define FLG_NOUN_BEGIN      FLG_ITEMS
  68 #define FLG_NOUN_END        FLG_FAVORITE
  69
  70 #ifdef JP
  71
  72 #define KEY_ALL "¤¹¤Ù¤Æ¤Î"
  73
  74 #ifdef MAC_MPW
  75 /*
  76  * MEGA HACK -- MPW¤Î¥Ð¥°½ü¤±¡£
  77  * pre-processÃæ¤Ë¡Ö¼ý¡×¤Î»ú¤Î2¥Ð¥¤¥ÈÌÜ¤¬¾¡¼ê¤Ë¾Ã¤¨¤Æ¤·¤Þ¤¦¡£
  78  */
  79 #define KEY_COLLECTING "\x8e\xfb½¸Ãæ¤Î"
  80 #else
  81 #define KEY_COLLECTING "¼ý½¸Ãæ¤Î"
  82 #endif
  83
  84 #define KEY_UNIDENTIFIED "Ì¤´ÕÄê¤Î"
  85 #define KEY_IDENTIFIED "´ÕÄêºÑ¤ß¤Î"
  86 #define KEY_STAR_IDENTIFIED "*´ÕÄê*ºÑ¤ß¤Î"
  87 #define KEY_BOOSTED "¥À¥¤¥¹ÌÜ¤Î°ã¤¦"
  88 #define KEY_MORE_THAN  "¥À¥¤¥¹ÌÜ"
  89 #define KEY_DICE  "°Ê¾å¤Î"
  90 #define KEY_MORE_BONUS  "½¤ÀµÃÍ"
  91 #define KEY_MORE_BONUS2  "°Ê¾å¤Î"
  92 #define KEY_WORTHLESS "Ìµ²ÁÃÍ¤Î"
  93 #define KEY_ARTIFACT "¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È"
  94 #define KEY_EGO "¥¨¥´"
  95 #define KEY_NAMELESS "ÌµÌÃ¤Î"
  96 #define KEY_UNAWARE "Ì¤È½ÌÀ¤Î"
  97 #define KEY_WANTED "¾Þ¶â¼ó¤Î"
  98 #define KEY_UNIQUE "¥æ¥Ë¡¼¥¯¡¦¥â¥ó¥¹¥¿¡¼¤Î"
  99 #define KEY_HUMAN "¿Í´Ö¤Î"
 100 #define KEY_UNREADABLE "ÆÉ¤á¤Ê¤¤"
 101 #define KEY_REALM1 "Âè°ìÎÎ°è¤Î"
 102 #define KEY_REALM2 "ÂèÆóÎÎ°è¤Î"
 103 #define KEY_FIRST "1ºýÌÜ¤Î"
 104 #define KEY_SECOND "2ºýÌÜ¤Î"
 105 #define KEY_THIRD "3ºýÌÜ¤Î"
 106 #define KEY_FOURTH "4ºýÌÜ¤Î"
 107 #define KEY_ITEMS "¥¢¥¤¥Æ¥à"
 108 #define KEY_WEAPONS "Éð´ï"
 109 #define KEY_ARMORS "ËÉ¶ñ"
 110 #define KEY_MISSILES "Ìð"
 111 #define KEY_DEVICES "ËâË¡¥¢¥¤¥Æ¥à"
 112 #define KEY_LIGHTS "¸÷¸»"
 113 #define KEY_JUNKS "¤¬¤é¤¯¤¿"
 114 #define KEY_SPELLBOOKS "ËâË¡½ñ"
 115 #define KEY_HAFTED "Æß´ï"
 116 #define KEY_SHIELDS "½â"
 117 #define KEY_BOWS "µÝ"
 118 #define KEY_RINGS "»ØÎØ"
 119 #define KEY_AMULETS "¥¢¥ß¥å¥ì¥Ã¥È"
 120 #define KEY_SUITS "³»"
 121 #define KEY_CLOAKS "¥¯¥í¡¼¥¯"
 122 #define KEY_HELMS "³õ"
 123 #define KEY_GLOVES "äÆ¼ê"
 124 #define KEY_BOOTS "·¤"
 125 #define KEY_FAVORITE "ÆÀ°ÕÉð´ï"
 126
 127 #else
 128
 129 #define KEY_ALL "all"
 130 #define KEY_COLLECTING "collecting"
 131 #define KEY_UNIDENTIFIED "unidentified"
 132 #define KEY_IDENTIFIED "identified"
 133 #define KEY_STAR_IDENTIFIED "*identified*"
 134 #define KEY_BOOSTED "dice boosted"
 135 #define KEY_MORE_THAN  "more than"
 136 #define KEY_DICE  " dice"
 137 #define KEY_MORE_BONUS  "more bonus than"
 138 #define KEY_MORE_BONUS2  ""
 139 #define KEY_WORTHLESS "worthless"
 140 #define KEY_ARTIFACT "artifact"
 141 #define KEY_EGO "ego"
 142 #define KEY_NAMELESS "nameless"
 143 #define KEY_UNAWARE "unaware"
 144 #define KEY_WANTED "wanted"
 145 #define KEY_UNIQUE "unique monster's"
 146 #define KEY_HUMAN "human"
 147 #define KEY_UNREADABLE "unreadable"
 148 #define KEY_REALM1 "first realm's"
 149 #define KEY_REALM2 "second realm's"
 150 #define KEY_FIRST "first"
 151 #define KEY_SECOND "second"
 152 #define KEY_THIRD "third"
 153 #define KEY_FOURTH "fourth"
 154 #define KEY_ITEMS "items"
 155 #define KEY_WEAPONS "weapons"
 156 #define KEY_ARMORS "armors"
 157 #define KEY_MISSILES "missiles"
 158 #define KEY_DEVICES "magical devices"
 159 #define KEY_LIGHTS "lights"
 160 #define KEY_JUNKS "junks"
 161 #define KEY_SPELLBOOKS "spellbooks"
 162 #define KEY_HAFTED "hafted weapons"
 163 #define KEY_SHIELDS "shields"
 164 #define KEY_BOWS "bows"
 165 #define KEY_RINGS "rings"
 166 #define KEY_AMULETS "amulets"
 167 #define KEY_SUITS "suits"
 168 #define KEY_CLOAKS "cloaks"
 169 #define KEY_HELMS "helms"
 170 #define KEY_GLOVES "gloves"
 171 #define KEY_BOOTS "boots"
 172 #define KEY_FAVORITE "favorite weapons"
 173
 174 #endif /* JP */
 175
 176 #define MATCH_KEY(KEY) (!strncmp(ptr, KEY, sizeof(KEY)-1)\
 177      ? (ptr += sizeof(KEY)-1, (' '==*ptr) ? ptr++ : 0, TRUE) : FALSE)
 178 #define MATCH_KEY2(KEY) (!strncmp(ptr, KEY, sizeof(KEY)-1)\
 179      ? (prev_ptr = ptr, ptr += sizeof(KEY)-1, (' '==*ptr) ? ptr++ : 0, TRUE) : FALSE)
 180
 181 #ifdef JP
 182 #define ADD_KEY(KEY) strcat(ptr, KEY)
 183 #else
 184 #define ADD_KEY(KEY) (strcat(ptr, KEY), strcat(ptr, " "))
 185 #endif
 186 #define ADD_KEY2(KEY) strcat(ptr, KEY)
 187
 188 #define ADD_FLG(FLG) (entry->flag[FLG / 32] |= (1L << (FLG % 32)))
 189 #define REM_FLG(FLG) (entry->flag[FLG / 32] &= ~(1L << (FLG % 32)))
 190 #define ADD_FLG_NOUN(FLG) (ADD_FLG(FLG), prev_flg = FLG)
 191 #define IS_FLG(FLG) (entry->flag[FLG / 32] & (1L << (FLG % 32)))
 192
 193 #ifdef JP
 194         static char kanji_colon[] = "¡§";
 195 #endif
 196
 197
 198 /*
 199  * A function to create new entry
 200  */
 201 static bool autopick_new_entry(autopick_type *entry, cptr str, bool allow_default)
 202 {
 203         cptr insc;
 204         int i;
 205         byte act = 0;
 206         char buf[MAX_LINELEN];
 207         cptr prev_ptr, ptr, old_ptr;
 208         int prev_flg;
 209
 210         if (str[1] == ':') switch (str[0])
 211         {
 212         case '?': case '%':
 213         case 'A': case 'P': case 'C':
 214                 return FALSE;
 215         }
 216
 217         entry->flag[0] = entry->flag[1] = 0L;
 218         entry->dice = 0;
 219
 220         act = DO_AUTOPICK | DO_DISPLAY;
 221         while (TRUE)
 222         {
 223                 if ((act & DO_AUTOPICK) && *str == '!')
 224                 {
 225                         act &= ~DO_AUTOPICK;
 226                         act |= DO_AUTODESTROY;
 227                         str++;
 228                 }
 229                 else if ((act & DO_AUTOPICK) && *str == '~')
 230                 {
 231                         act &= ~DO_AUTOPICK;
 232                         act |= DONT_AUTOPICK;
 233                         str++;
 234                 }
 235                 else if ((act & DO_AUTOPICK) && *str == ';')
 236                 {
 237                         act &= ~DO_AUTOPICK;
 238                         act |= DO_QUERY_AUTOPICK;
 239                         str++;
 240                 }
 241                 else if ((act & DO_DISPLAY) && *str == '(')
 242                 {
 243                         act &= ~DO_DISPLAY;
 244                         str++;
 245                 }
 246                 else
 247                         break;
 248         }
 249
 250         /* don't mind upper or lower case */
 251         insc = NULL;
 252         for (i = 0; *str; i++)
 253         {
 254                 char c = *str++;
 255 #ifdef JP
 256                 if (iskanji(c))
 257                 {
 258                         buf[i++] = c;
 259                         buf[i] = *str++;
 260                         continue;
 261                 }
 262 #endif
 263                 /* Auto-inscription? */
 264                 if (c == '#')
 265                 {
 266                         buf[i] = '\0';
 267                         insc = str;
 268                         break;
 269                 }
 270
 271                 if (isupper(c)) c = tolower(c);
 272
 273                 buf[i] = c;
 274         }
 275         buf[i] = '\0';
 276
 277         /* Skip empty line unless allow_default */
 278         if (!allow_default && *buf == 0) return FALSE;
 279
 280         /* Skip comment line */
 281         if (*buf == 0 && insc) return FALSE;
 282
 283         ptr = prev_ptr = buf;
 284         old_ptr = NULL;
 285
 286         while (old_ptr != ptr)
 287         {
 288                 /* Save current location */
 289                 old_ptr = ptr;
 290
 291                 if (MATCH_KEY(KEY_ALL)) ADD_FLG(FLG_ALL);
 292                 if (MATCH_KEY(KEY_COLLECTING)) ADD_FLG(FLG_COLLECTING);
 293                 if (MATCH_KEY(KEY_UNIDENTIFIED)) ADD_FLG(FLG_UNIDENTIFIED);
 294                 if (MATCH_KEY(KEY_IDENTIFIED)) ADD_FLG(FLG_IDENTIFIED);
 295                 if (MATCH_KEY(KEY_STAR_IDENTIFIED)) ADD_FLG(FLG_STAR_IDENTIFIED);
 296                 if (MATCH_KEY(KEY_BOOSTED)) ADD_FLG(FLG_BOOSTED);
 297
 298                 /*** Weapons whose dd*ds is more than nn ***/
 299                 if (MATCH_KEY2(KEY_MORE_THAN))
 300                 {
 301                         int k = 0;
 302                         entry->dice = 0;
 303
 304                         /* Drop leading spaces */
 305                         while (' ' == *ptr) ptr++;
 306
 307                         /* Read number */
 308                         while ('0' <= *ptr && *ptr <= '9')
 309                         {
 310                                 entry->dice = 10 * entry->dice + (*ptr - '0');
 311                                 ptr++;
 312                                 k++;
 313                         }
 314
 315                         if (k > 0 && k <= 2)
 316                         {
 317                                 (void)MATCH_KEY(KEY_DICE);
 318                                 ADD_FLG(FLG_MORE_THAN);
 319                         }
 320                         else
 321                                 ptr = prev_ptr;
 322                 }
 323
 324                 /*** Items whose magical bonus is more than n ***/
 325                 if (MATCH_KEY2(KEY_MORE_BONUS))
 326                 {
 327                         int k = 0;
 328                         entry->bonus = 0;
 329
 330                         /* Drop leading spaces */
 331                         while (' ' == *ptr) ptr++;
 332
 333                         /* Read number */
 334                         while ('0' <= *ptr && *ptr <= '9')
 335                         {
 336                                 entry->bonus = 10 * entry->bonus + (*ptr - '0');
 337                                 ptr++;
 338                                 k++;
 339                         }
 340
 341                         if (k > 0 && k <= 2)
 342                         {
 343                                 (void)MATCH_KEY(KEY_MORE_BONUS2);
 344                                 ADD_FLG(FLG_MORE_BONUS);
 345                         }
 346                         else
 347                                 ptr = prev_ptr;
 348                 }
 349
 350                 if (MATCH_KEY(KEY_WORTHLESS)) ADD_FLG(FLG_WORTHLESS);
 351                 if (MATCH_KEY(KEY_EGO)) ADD_FLG(FLG_EGO);
 352                 if (MATCH_KEY(KEY_NAMELESS)) ADD_FLG(FLG_NAMELESS);
 353                 if (MATCH_KEY(KEY_UNAWARE)) ADD_FLG(FLG_UNAWARE);
 354                 if (MATCH_KEY(KEY_WANTED)) ADD_FLG(FLG_WANTED);
 355                 if (MATCH_KEY(KEY_UNIQUE)) ADD_FLG(FLG_UNIQUE);
 356                 if (MATCH_KEY(KEY_HUMAN)) ADD_FLG(FLG_HUMAN);
 357                 if (MATCH_KEY(KEY_UNREADABLE)) ADD_FLG(FLG_UNREADABLE);
 358                 if (MATCH_KEY(KEY_REALM1)) ADD_FLG(FLG_REALM1);
 359                 if (MATCH_KEY(KEY_REALM2)) ADD_FLG(FLG_REALM2);
 360                 if (MATCH_KEY(KEY_FIRST)) ADD_FLG(FLG_FIRST);
 361                 if (MATCH_KEY(KEY_SECOND)) ADD_FLG(FLG_SECOND);
 362                 if (MATCH_KEY(KEY_THIRD)) ADD_FLG(FLG_THIRD);
 363                 if (MATCH_KEY(KEY_FOURTH)) ADD_FLG(FLG_FOURTH);
 364         }
 365
 366         /* Not yet found any noun */
 367         prev_flg = -1;
 368
 369         if (MATCH_KEY2(KEY_ARTIFACT)) ADD_FLG_NOUN(FLG_ARTIFACT);
 370
 371         if (MATCH_KEY2(KEY_ITEMS)) ADD_FLG_NOUN(FLG_ITEMS);
 372         else if (MATCH_KEY2(KEY_WEAPONS)) ADD_FLG_NOUN(FLG_WEAPONS);
 373         else if (MATCH_KEY2(KEY_ARMORS)) ADD_FLG_NOUN(FLG_ARMORS);
 374         else if (MATCH_KEY2(KEY_MISSILES)) ADD_FLG_NOUN(FLG_MISSILES);
 375         else if (MATCH_KEY2(KEY_DEVICES)) ADD_FLG_NOUN(FLG_DEVICES);
 376         else if (MATCH_KEY2(KEY_LIGHTS)) ADD_FLG_NOUN(FLG_LIGHTS);
 377         else if (MATCH_KEY2(KEY_JUNKS)) ADD_FLG_NOUN(FLG_JUNKS);
 378         else if (MATCH_KEY2(KEY_SPELLBOOKS)) ADD_FLG_NOUN(FLG_SPELLBOOKS);
 379         else if (MATCH_KEY2(KEY_HAFTED)) ADD_FLG_NOUN(FLG_HAFTED);
 380         else if (MATCH_KEY2(KEY_SHIELDS)) ADD_FLG_NOUN(FLG_SHIELDS);
 381         else if (MATCH_KEY2(KEY_BOWS)) ADD_FLG_NOUN(FLG_BOWS);
 382         else if (MATCH_KEY2(KEY_RINGS)) ADD_FLG_NOUN(FLG_RINGS);
 383         else if (MATCH_KEY2(KEY_AMULETS)) ADD_FLG_NOUN(FLG_AMULETS);
 384         else if (MATCH_KEY2(KEY_SUITS)) ADD_FLG_NOUN(FLG_SUITS);
 385         else if (MATCH_KEY2(KEY_CLOAKS)) ADD_FLG_NOUN(FLG_CLOAKS);
 386         else if (MATCH_KEY2(KEY_HELMS)) ADD_FLG_NOUN(FLG_HELMS);
 387         else if (MATCH_KEY2(KEY_GLOVES)) ADD_FLG_NOUN(FLG_GLOVES);
 388         else if (MATCH_KEY2(KEY_BOOTS)) ADD_FLG_NOUN(FLG_BOOTS);
 389         else if (MATCH_KEY2(KEY_FAVORITE)) ADD_FLG_NOUN(FLG_FAVORITE);
 390
 391         /* Last 'keyword' must be at the correct location */
 392         if (*ptr == ':')
 393                 ptr++;
 394 #ifdef JP
 395         else if (ptr[0] == kanji_colon[0] && ptr[1] == kanji_colon[1])
 396                 ptr += 2;
 397 #endif
 398         else if (*ptr == '\0')
 399         {
 400                 /* There was no noun */
 401                 if (prev_flg == -1)
 402
 403                 /* Add extra word "items" */
 404                 ADD_FLG_NOUN(FLG_ITEMS);
 405         }
 406         else
 407         {
 408                 /* Noun type? */
 409                 if (prev_flg != -1)
 410                 {
 411                         /* A noun type keyword didn't end correctly */
 412                         entry->flag[prev_flg/32] &= ~(1L<< (prev_flg%32));
 413                         ptr = prev_ptr;
 414                 }
 415         }
 416
 417         /* Save this auto-picker entry line */
 418         entry->name = string_make(ptr);
 419         entry->action = act;
 420         entry->insc = string_make(insc);
 421
 422         return TRUE;
 423 }
 424
 425
 426 /*
 427  * Favorite weapons
 428  */
 429 static bool is_favorite(object_type *o_ptr)
 430 {
 431         /* Only weapons match */
 432         if (!(TV_WEAPON_BEGIN <= o_ptr->tval && o_ptr->tval <= TV_WEAPON_END))
 433                 return FALSE;
 434
 435         /* Favorite weapons are varied depend on the class */
 436         switch (p_ptr->pclass)
 437         {
 438         case CLASS_PRIEST:
 439         {
 440                 u32b flgs[TR_FLAG_SIZE];
 441                 object_flags_known(o_ptr, flgs);
 442
 443                 if (!have_flag(flgs, TR_BLESSED) &&
 444                     !(o_ptr->tval == TV_HAFTED))
 445                         return FALSE;
 446                 break;
 447         }
 448
 449         case CLASS_MONK:
 450         case CLASS_FORCETRAINER:
 451                 /* Icky to wield? */
 452                 if (!(s_info[p_ptr->pclass].w_max[o_ptr->tval-TV_WEAPON_BEGIN][o_ptr->sval]))
 453                         return FALSE;
 454                 break;
 455
 456         case CLASS_BEASTMASTER:
 457         case CLASS_CAVALRY:
 458         {
 459                 u32b flgs[TR_FLAG_SIZE];
 460                 object_flags_known(o_ptr, flgs);
 461
 462                 /* Is it known to be suitable to using while riding? */
 463                 if (!(have_flag(flgs, TR_RIDING)))
 464                         return FALSE;
 465
 466                 break;
 467         }
 468
 469         case CLASS_NINJA:
 470                 /* Icky to wield? */
 471                 if (s_info[p_ptr->pclass].w_max[o_ptr->tval-TV_WEAPON_BEGIN][o_ptr->sval] <= WEAPON_EXP_BEGINNER)
 472                         return FALSE;
 473                 break;
 474
 475         default:
 476                 /* All weapons are okay for non-special classes */
 477                 return TRUE;
 478         }
 479
 480         return TRUE;
 481 }
 482
 483
 484 /*
 485  * Convert string to lower case
 486  */
 487 static void str_tolower(char *str)
 488 {
 489         /* Force to be lower case string */
 490         for (; *str; str++)
 491         {
 492 #ifdef JP
 493                 if (iskanji(*str))
 494                 {
 495                         str++;
 496                         continue;
 497                 }
 498 #endif
 499                 *str = tolower(*str);
 500         }
 501 }
 502
 503
 504 /*
 505  * Get auto-picker entry from o_ptr.
 506  */
 507 static void autopick_entry_from_object(autopick_type *entry, object_type *o_ptr)
 508 {
 509         /* Assume that object name is to be added */
 510         bool name = TRUE;
 511
 512         char name_str[MAX_NLEN];
 513
 514         /* Initialize name string */
 515         name_str[0] = '\0';
 516
 517         entry->insc = string_make(quark_str(o_ptr->inscription));
 518         entry->action = DO_AUTOPICK | DO_DISPLAY;
 519         entry->flag[0] = entry->flag[1] = 0L;
 520         entry->dice = 0;
 521
 522         /* Unaware */
 523         if (!object_aware_p(o_ptr))
 524         {
 525                 ADD_FLG(FLG_UNAWARE);
 526         }
 527
 528         /* Not really identified */
 529         else if (!object_known_p(o_ptr))
 530         {
 531                 if (!(o_ptr->ident & IDENT_SENSE))
 532                 {
 533                         ADD_FLG(FLG_UNIDENTIFIED);
 534                 }
 535                 else
 536                 {
 537                         /* Pseudo-identified */
 538                         switch (o_ptr->feeling)
 539                         {
 540                         case FEEL_AVERAGE:
 541                         case FEEL_GOOD:
 542                                 ADD_FLG(FLG_NAMELESS);
 543                                 break;
 544
 545                         case FEEL_BROKEN:
 546                         case FEEL_CURSED:
 547                                 ADD_FLG(FLG_NAMELESS);
 548                                 ADD_FLG(FLG_WORTHLESS);
 549                                 break;
 550
 551                         case FEEL_TERRIBLE:
 552                         case FEEL_WORTHLESS:
 553                                 ADD_FLG(FLG_WORTHLESS);
 554                                 break;
 555
 556                         case FEEL_EXCELLENT:
 557                                 ADD_FLG(FLG_EGO);
 558                                 break;
 559
 560                         default:
 561                                 /* It's not known to be useless so... */
 562                                 ADD_FLG(FLG_UNIDENTIFIED);
 563                                 break;
 564                         }
 565                 }
 566         }
 567
 568         /* Identified */
 569         else
 570         {
 571                 /* Ego objects */
 572                 if (o_ptr->name2)
 573
 574                 {
 575                         if (TV_WEAPON_BEGIN <= o_ptr->tval &&
 576                             o_ptr->tval <= TV_ARMOR_END)
 577                         {
 578                                 /*
 579                                  * Base name of ego weapons and armors
 580                                  * are almost meaningless.
 581                                  * Register the ego type only.
 582                                  */
 583                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
 584                                 strcpy(name_str, e_name + e_ptr->name);
 585
 586                                 /* Don't use the object description */
 587                                 name = FALSE;
 588                         }
 589
 590                         ADD_FLG(FLG_EGO);
 591                 }
 592
 593                 /* Artifact */
 594                 else if (o_ptr->name1 || o_ptr->art_name)
 595                         ADD_FLG(FLG_ARTIFACT);
 596
 597                 /* Non-ego, non-artifact */
 598                 else
 599                 {
 600                         /* Wearable nameless object */
 601                         if ((TV_EQUIP_BEGIN <= o_ptr->tval && o_ptr->tval <= TV_EQUIP_END))
 602                                 ADD_FLG(FLG_NAMELESS);
 603                 }
 604
 605         }
 606
 607
 608         switch(o_ptr->tval)
 609         {
 610                 object_kind *k_ptr;
 611         case TV_HAFTED: case TV_POLEARM: case TV_SWORD: case TV_DIGGING:
 612                 k_ptr = &k_info[o_ptr->k_idx];
 613                 if ((o_ptr->dd != k_ptr->dd) || (o_ptr->ds != k_ptr->ds))
 614                         ADD_FLG(FLG_BOOSTED);
 615         }
 616
 617         if (o_ptr->tval == TV_CORPSE && object_is_shoukinkubi(o_ptr))
 618         {
 619                 REM_FLG(FLG_WORTHLESS);
 620                 ADD_FLG(FLG_WANTED);
 621         }
 622
 623         if ((o_ptr->tval == TV_CORPSE || o_ptr->tval == TV_STATUE)
 624             && (r_info[o_ptr->pval].flags1 & RF1_UNIQUE))
 625         {
 626                 ADD_FLG(FLG_UNIQUE);
 627         }
 628
 629         if (o_ptr->tval == TV_CORPSE && strchr("pht", r_info[o_ptr->pval].d_char))
 630         {
 631                 ADD_FLG(FLG_HUMAN);
 632         }
 633
 634         if (o_ptr->tval >= TV_LIFE_BOOK &&
 635             !check_book_realm(o_ptr->tval, o_ptr->sval))
 636         {
 637                 ADD_FLG(FLG_UNREADABLE);
 638                 if (o_ptr->tval != TV_ARCANE_BOOK) name = FALSE;
 639         }
 640
 641         if (REALM1_BOOK == o_ptr->tval &&
 642             p_ptr->pclass != CLASS_SORCERER &&
 643             p_ptr->pclass != CLASS_RED_MAGE)
 644         {
 645                 ADD_FLG(FLG_REALM1);
 646                 name = FALSE;
 647         }
 648
 649         if (REALM2_BOOK == o_ptr->tval &&
 650             p_ptr->pclass != CLASS_SORCERER &&
 651             p_ptr->pclass != CLASS_RED_MAGE)
 652         {
 653                 ADD_FLG(FLG_REALM2);
 654                 name = FALSE;
 655         }
 656
 657         if (o_ptr->tval >= TV_LIFE_BOOK && 0 == o_ptr->sval)
 658                 ADD_FLG(FLG_FIRST);
 659         if (o_ptr->tval >= TV_LIFE_BOOK && 1 == o_ptr->sval)
 660                 ADD_FLG(FLG_SECOND);
 661         if (o_ptr->tval >= TV_LIFE_BOOK && 2 == o_ptr->sval)
 662                 ADD_FLG(FLG_THIRD);
 663         if (o_ptr->tval >= TV_LIFE_BOOK && 3 == o_ptr->sval)
 664                 ADD_FLG(FLG_FOURTH);
 665
 666         if (o_ptr->tval == TV_SHOT || o_ptr->tval == TV_BOLT
 667                  || o_ptr->tval == TV_ARROW)
 668                 ADD_FLG(FLG_MISSILES);
 669         else if (o_ptr->tval == TV_SCROLL || o_ptr->tval == TV_STAFF
 670                  || o_ptr->tval == TV_WAND || o_ptr->tval == TV_ROD)
 671                 ADD_FLG(FLG_DEVICES);
 672         else if (o_ptr->tval == TV_LITE)
 673                 ADD_FLG(FLG_LIGHTS);
 674         else if (o_ptr->tval == TV_SKELETON || o_ptr->tval == TV_BOTTLE
 675                  || o_ptr->tval == TV_JUNK || o_ptr->tval == TV_STATUE)
 676                 ADD_FLG(FLG_JUNKS);
 677         else if (o_ptr->tval >= TV_LIFE_BOOK)
 678                 ADD_FLG(FLG_SPELLBOOKS);
 679         else if (o_ptr->tval == TV_POLEARM || o_ptr->tval == TV_SWORD
 680                  || o_ptr->tval == TV_DIGGING || o_ptr->tval == TV_HAFTED)
 681                 ADD_FLG(FLG_WEAPONS);
 682         else if (o_ptr->tval == TV_SHIELD)
 683                 ADD_FLG(FLG_SHIELDS);
 684         else if (o_ptr->tval == TV_BOW)
 685                 ADD_FLG(FLG_BOWS);
 686         else if (o_ptr->tval == TV_RING)
 687                 ADD_FLG(FLG_RINGS);
 688         else if (o_ptr->tval == TV_AMULET)
 689                 ADD_FLG(FLG_AMULETS);
 690         else if (o_ptr->tval == TV_DRAG_ARMOR || o_ptr->tval == TV_HARD_ARMOR ||
 691                  o_ptr->tval == TV_SOFT_ARMOR)
 692                 ADD_FLG(FLG_SUITS);
 693         else if (o_ptr->tval == TV_CLOAK)
 694                 ADD_FLG(FLG_CLOAKS);
 695         else if (o_ptr->tval == TV_HELM)
 696                 ADD_FLG(FLG_HELMS);
 697         else if (o_ptr->tval == TV_GLOVES)
 698                 ADD_FLG(FLG_GLOVES);
 699         else if (o_ptr->tval == TV_BOOTS)
 700                 ADD_FLG(FLG_BOOTS);
 701
 702         /* Prepare the object description */
 703         if (name)
 704         {
 705                 object_desc(name_str, o_ptr, FALSE, 0);
 706         }
 707
 708         /* Register the name in lowercase */
 709         str_tolower(name_str);
 710         entry->name = string_make(name_str);
 711
 712         return;
 713 }
 714
 715
 716 /*
 717  * A function to delete entry
 718  */
 719 static void autopick_free_entry(autopick_type *entry)
 720 {
 721         string_free(entry->name);
 722         string_free(entry->insc);
 723 }
 724
 725
 726 /*
 727  * Initialize auto-picker preference
 728  */
 729 #define MAX_AUTOPICK_DEFAULT 200
 730
 731 void init_autopicker(void)
 732 {
 733         static const char easy_autopick_inscription[] = "(:=g";
 734         autopick_type entry;
 735         int i;
 736
 737         if (!autopick_list)
 738         {
 739                 max_max_autopick = MAX_AUTOPICK_DEFAULT;
 740                 C_MAKE(autopick_list, max_max_autopick, autopick_type);
 741                 max_autopick = 0;
 742         }
 743
 744         /* Clear old entries */
 745         for( i = 0; i < max_autopick; i++)
 746                 autopick_free_entry(&autopick_list[i]);
 747
 748         max_autopick = 0;
 749
 750         /* There is always one entry "=g" */
 751         autopick_new_entry(&entry, easy_autopick_inscription, TRUE);
 752         autopick_list[max_autopick++] = entry;
 753 }
 754
 755
 756 /*
 757  * Add one line to autopick_list[]
 758  */
 759 static void add_autopick_list(autopick_type *entry)
 760 {
 761         /* There is no enough space to add one line */
 762         if (max_autopick >= max_max_autopick)
 763         {
 764                 int old_max_max_autopick = max_max_autopick;
 765                 autopick_type *old_autopick_list = autopick_list;
 766
 767                 /* Increase size of list */
 768                 max_max_autopick += MAX_AUTOPICK_DEFAULT;
 769
 770                 /* Allocate */
 771                 C_MAKE(autopick_list, max_max_autopick, autopick_type);
 772
 773                 /* Copy from old list to new list */
 774                 C_COPY(autopick_list, old_autopick_list, old_max_max_autopick, autopick_type);
 775
 776                 /* Kill old list */
 777                 C_FREE(old_autopick_list, old_max_max_autopick, autopick_type);
 778         }
 779
 780         /* Add one line */
 781         autopick_list[max_autopick] = *entry;
 782
 783         max_autopick++;
 784 }
 785
 786
 787 /*
 788  *  Process line for auto picker/destroyer.
 789  */
 790 errr process_pickpref_file_line(char *buf)
 791 {
 792         autopick_type an_entry, *entry = &an_entry;
 793         int i;
 794
 795         /* Nuke illegal char */
 796         for(i = 0; buf[i]; i++)
 797         {
 798 #ifdef JP
 799                 if (iskanji(buf[i]))
 800                 {
 801                         i++;
 802                         continue;
 803                 }
 804 #endif
 805                 if (isspace(buf[i]) && buf[i] != ' ')
 806                         break;
 807         }
 808         buf[i] = 0;
 809
 810         if (!autopick_new_entry(entry, buf, FALSE)) return 0;
 811
 812         /* Already has the same entry? */
 813         for(i = 0; i < max_autopick; i++)
 814                 if(!strcmp(entry->name, autopick_list[i].name)
 815                    && entry->flag[0] == autopick_list[i].flag[0]
 816                    && entry->flag[1] == autopick_list[i].flag[1]
 817                    && entry->dice == autopick_list[i].dice
 818                    && entry->bonus == autopick_list[i].bonus) return 0;
 819
 820         add_autopick_list(entry);
 821         return 0;
 822 }
 823
 824
 825 /*
 826  * Reconstruct preference line from entry
 827  */
 828 cptr autopick_line_from_entry(autopick_type *entry)
 829 {
 830         char buf[MAX_LINELEN];
 831         char *ptr;
 832         bool sepa_flag = TRUE;
 833
 834         *buf = '\0';
 835         if (!(entry->action & DO_DISPLAY)) strcat(buf, "(");
 836         if (entry->action & DO_QUERY_AUTOPICK) strcat(buf, ";");
 837         if (entry->action & DO_AUTODESTROY) strcat(buf, "!");
 838         if (entry->action & DONT_AUTOPICK) strcat(buf, "~");
 839
 840         ptr = buf;
 841
 842         if (IS_FLG(FLG_ALL)) ADD_KEY(KEY_ALL);
 843         if (IS_FLG(FLG_COLLECTING)) ADD_KEY(KEY_COLLECTING);
 844         if (IS_FLG(FLG_UNIDENTIFIED)) ADD_KEY(KEY_UNIDENTIFIED);
 845         if (IS_FLG(FLG_IDENTIFIED)) ADD_KEY(KEY_IDENTIFIED);
 846         if (IS_FLG(FLG_STAR_IDENTIFIED)) ADD_KEY(KEY_STAR_IDENTIFIED);
 847         if (IS_FLG(FLG_UNAWARE)) ADD_KEY(KEY_UNAWARE);
 848         if (IS_FLG(FLG_BOOSTED)) ADD_KEY(KEY_BOOSTED);
 849
 850         if (IS_FLG(FLG_MORE_THAN))
 851         {
 852                 ADD_KEY(KEY_MORE_THAN);
 853                 strcat(ptr, format("%d", entry->dice));
 854                 ADD_KEY(KEY_DICE);
 855         }
 856
 857         if (IS_FLG(FLG_MORE_BONUS))
 858         {
 859                 ADD_KEY(KEY_MORE_BONUS);
 860                 strcat(ptr, format("%d", entry->bonus));
 861                 ADD_KEY(KEY_MORE_BONUS2);
 862         }
 863
 864         if (IS_FLG(FLG_UNREADABLE)) ADD_KEY(KEY_UNREADABLE);
 865         if (IS_FLG(FLG_REALM1)) ADD_KEY(KEY_REALM1);
 866         if (IS_FLG(FLG_REALM2)) ADD_KEY(KEY_REALM2);
 867         if (IS_FLG(FLG_FIRST)) ADD_KEY(KEY_FIRST);
 868         if (IS_FLG(FLG_SECOND)) ADD_KEY(KEY_SECOND);
 869         if (IS_FLG(FLG_THIRD)) ADD_KEY(KEY_THIRD);
 870         if (IS_FLG(FLG_FOURTH)) ADD_KEY(KEY_FOURTH);
 871         if (IS_FLG(FLG_WANTED)) ADD_KEY(KEY_WANTED);
 872         if (IS_FLG(FLG_UNIQUE)) ADD_KEY(KEY_UNIQUE);
 873         if (IS_FLG(FLG_HUMAN)) ADD_KEY(KEY_HUMAN);
 874         if (IS_FLG(FLG_WORTHLESS)) ADD_KEY(KEY_WORTHLESS);
 875         if (IS_FLG(FLG_NAMELESS)) ADD_KEY(KEY_NAMELESS);
 876         if (IS_FLG(FLG_EGO)) ADD_KEY(KEY_EGO);
 877
 878         if (IS_FLG(FLG_ARTIFACT)) ADD_KEY(KEY_ARTIFACT);
 879
 880         if (IS_FLG(FLG_ITEMS)) ADD_KEY2(KEY_ITEMS);
 881         else if (IS_FLG(FLG_WEAPONS)) ADD_KEY2(KEY_WEAPONS);
 882         else if (IS_FLG(FLG_ARMORS)) ADD_KEY2(KEY_ARMORS);
 883         else if (IS_FLG(FLG_MISSILES)) ADD_KEY2(KEY_MISSILES);
 884         else if (IS_FLG(FLG_DEVICES)) ADD_KEY2(KEY_DEVICES);
 885         else if (IS_FLG(FLG_LIGHTS)) ADD_KEY2(KEY_LIGHTS);
 886         else if (IS_FLG(FLG_JUNKS)) ADD_KEY2(KEY_JUNKS);
 887         else if (IS_FLG(FLG_SPELLBOOKS)) ADD_KEY2(KEY_SPELLBOOKS);
 888         else if (IS_FLG(FLG_HAFTED)) ADD_KEY2(KEY_HAFTED);
 889         else if (IS_FLG(FLG_SHIELDS)) ADD_KEY2(KEY_SHIELDS);
 890         else if (IS_FLG(FLG_BOWS)) ADD_KEY2(KEY_BOWS);
 891         else if (IS_FLG(FLG_RINGS)) ADD_KEY2(KEY_RINGS);
 892         else if (IS_FLG(FLG_AMULETS)) ADD_KEY2(KEY_AMULETS);
 893         else if (IS_FLG(FLG_SUITS)) ADD_KEY2(KEY_SUITS);
 894         else if (IS_FLG(FLG_CLOAKS)) ADD_KEY2(KEY_CLOAKS);
 895         else if (IS_FLG(FLG_HELMS)) ADD_KEY2(KEY_HELMS);
 896         else if (IS_FLG(FLG_GLOVES)) ADD_KEY2(KEY_GLOVES);
 897         else if (IS_FLG(FLG_BOOTS)) ADD_KEY2(KEY_BOOTS);
 898         else if (IS_FLG(FLG_FAVORITE)) ADD_KEY2(KEY_FAVORITE);
 899
 900         /* You don't need sepalator after adjective */
 901         /* 'artifact' is not true adjective */
 902         else if (!IS_FLG(FLG_ARTIFACT))
 903                 sepa_flag = FALSE;
 904
 905         if (entry->name && entry->name[0])
 906         {
 907                 int i, j = 0;
 908
 909                 if (sepa_flag) strcat(buf, ":");
 910
 911                 i = strlen(buf);
 912                 while (entry->name[j] && i < MAX_LINELEN - 2 - 1)
 913                 {
 914 #ifdef JP
 915                         if (iskanji(entry->name[j]))
 916                                 buf[i++] = entry->name[j++];
 917 #endif
 918                         buf[i++] = entry->name[j++];
 919                 }
 920                 buf[i] = '\0';
 921         }
 922
 923         if (entry->insc)
 924         {
 925                 int i, j = 0;
 926                 strcat(buf, "#");
 927                 i = strlen(buf);
 928
 929                 while (entry->insc[j] && i < MAX_LINELEN - 2)
 930                 {
 931 #ifdef JP
 932                         if (iskanji(entry->insc[j]))
 933                                 buf[i++] = entry->insc[j++];
 934 #endif
 935                         buf[i++] = entry->insc[j++];
 936                 }
 937                 buf[i] = '\0';
 938         }
 939
 940         return string_make(buf);
 941 }
 942
 943
 944 /*
 945  * Reconstruct preference line from entry and kill entry
 946  */
 947 static cptr autopick_line_from_entry_kill(autopick_type *entry)
 948 {
 949         cptr ptr = autopick_line_from_entry(entry);
 950
 951         /* Free memory for original entry */
 952         autopick_free_entry(entry);
 953
 954         return ptr;
 955 }
 956
 957
 958 /*
 959  * A function for Auto-picker/destroyer
 960  * Examine whether the object matches to the entry
 961  */
 962 static bool is_autopick_aux(object_type *o_ptr, autopick_type *entry, cptr o_name)
 963 {
 964         int j;
 965         cptr ptr = entry->name;
 966
 967         /*** Unidentified ***/
 968         if (IS_FLG(FLG_UNIDENTIFIED)
 969             && (object_known_p(o_ptr) || (o_ptr->ident & IDENT_SENSE)))
 970                 return FALSE;
 971
 972         /*** Identified ***/
 973         if (IS_FLG(FLG_IDENTIFIED) && !object_known_p(o_ptr))
 974                 return FALSE;
 975
 976         /*** *Identified* ***/
 977         if (IS_FLG(FLG_STAR_IDENTIFIED) &&
 978             (!object_known_p(o_ptr) || !(o_ptr->ident & IDENT_MENTAL)))
 979                 return FALSE;
 980
 981         /*** Dice boosted (weapon of slaying) ***/
 982         if (IS_FLG(FLG_BOOSTED))
 983         {
 984                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
 985
 986                 switch( o_ptr->tval )
 987                 {
 988                 case TV_HAFTED:
 989                 case TV_POLEARM:
 990                 case TV_SWORD:
 991                 case TV_DIGGING:
 992                         if ((o_ptr->dd != k_ptr->dd) || (o_ptr->ds != k_ptr->ds))
 993                                 break;
 994                         else
 995                                 return FALSE;
 996                 default:
 997                         return FALSE;
 998                 }
 999         }
1000
1001         /*** Weapons which dd*ds is more than nn ***/
1002         if (IS_FLG(FLG_MORE_THAN))
1003         {
1004                 if (o_ptr->dd * o_ptr->ds < entry->dice)
1005                         return FALSE;
1006         }
1007
1008         /*** Weapons whic dd*ds is more than nn ***/
1009         if (IS_FLG(FLG_MORE_BONUS))
1010         {
1011                 if (!object_known_p(o_ptr)) return FALSE;
1012
1013                 if (o_ptr->pval)
1014                 {
1015                         if (o_ptr->pval < entry->bonus) return FALSE;
1016                 }
1017                 else
1018                 {
1019                         if (o_ptr->to_h < entry->bonus &&
1020                             o_ptr->to_d < entry->bonus &&
1021                             o_ptr->to_a < entry->bonus &&
1022                             o_ptr->pval < entry->bonus)
1023                                 return FALSE;
1024                 }
1025         }
1026
1027         /*** Worthless items ***/
1028         if (IS_FLG(FLG_WORTHLESS) && object_value(o_ptr) > 0)
1029                 return FALSE;
1030
1031         /*** Artifact object ***/
1032         if (IS_FLG(FLG_ARTIFACT))
1033         {
1034                 if (!object_known_p(o_ptr) || (!o_ptr->name1 && !o_ptr->art_name))
1035                         return FALSE;
1036         }
1037
1038         /*** Ego object ***/
1039         if (IS_FLG(FLG_EGO))
1040         {
1041                 /* Need to be an ego item */
1042                 if (!o_ptr->name2) return FALSE;
1043
1044                 /* Need to be known to be an ego */
1045                 if (!object_known_p(o_ptr) &&
1046                     !((o_ptr->ident & IDENT_SENSE) && o_ptr->feeling == FEEL_EXCELLENT))
1047                         return FALSE;
1048         }
1049
1050         /*** Nameless ***/
1051         if (IS_FLG(FLG_NAMELESS))
1052         {
1053                 if (!(TV_EQUIP_BEGIN <= o_ptr->tval && o_ptr->tval <= TV_EQUIP_END))
1054                         return FALSE;
1055
1056                 /* Inscription is a some sort of 'name' */
1057                 if (o_ptr->inscription) return FALSE;
1058
1059                 /* Identified */
1060                 if (object_known_p(o_ptr))
1061                 {
1062                         /* Artifacts and Ego objects are not okay */
1063                         if (o_ptr->name1 || o_ptr->art_name || o_ptr->name2)
1064                                 return FALSE;
1065                 }
1066
1067                 /* Pseudo-identified */
1068                 else if (o_ptr->ident & IDENT_SENSE)
1069                 {
1070                         switch (o_ptr->feeling)
1071                         {
1072                         case FEEL_AVERAGE:
1073                         case FEEL_GOOD:
1074                         case FEEL_BROKEN:
1075                         case FEEL_CURSED:
1076                                 /* It's nameless */
1077                                 break;
1078
1079                         default:
1080                                 /* It's not nameless */
1081                                 return FALSE;
1082                         }
1083                 }
1084
1085                 /* Unidentified */
1086                 else
1087                 {
1088                         /* Not known to be nameless */
1089                         return FALSE;
1090                 }
1091         }
1092
1093         /*** Unaware items ***/
1094         if (IS_FLG(FLG_UNAWARE) && object_aware_p(o_ptr))
1095                 return FALSE;
1096
1097         /*** Wanted monster's corpse/skeletons ***/
1098         if (IS_FLG(FLG_WANTED) &&
1099             (o_ptr->tval != TV_CORPSE || !object_is_shoukinkubi(o_ptr)))
1100                 return FALSE;
1101
1102         /*** Unique monster's corpse/skeletons/statues ***/
1103         if (IS_FLG(FLG_UNIQUE) &&
1104             ((o_ptr->tval != TV_CORPSE && o_ptr->tval != TV_STATUE) ||
1105              !(r_info[o_ptr->pval].flags1 & RF1_UNIQUE)))
1106                 return FALSE;
1107
1108         /*** Human corpse/skeletons (for Daemon magic) ***/
1109         if (IS_FLG(FLG_HUMAN) &&
1110             (o_ptr->tval != TV_CORPSE ||
1111              !strchr("pht", r_info[o_ptr->pval].d_char)))
1112                 return FALSE;
1113
1114         /*** Unreadable spellbooks ***/
1115         if (IS_FLG(FLG_UNREADABLE) &&
1116             (o_ptr->tval < TV_LIFE_BOOK ||
1117              check_book_realm(o_ptr->tval, o_ptr->sval)))
1118                 return FALSE;
1119
1120         /*** First realm spellbooks ***/
1121         if (IS_FLG(FLG_REALM1) &&
1122             (REALM1_BOOK != o_ptr->tval ||
1123              p_ptr->pclass == CLASS_SORCERER ||
1124              p_ptr->pclass == CLASS_RED_MAGE))
1125                 return FALSE;
1126
1127         /*** Second realm spellbooks ***/
1128         if (IS_FLG(FLG_REALM2) &&
1129             (REALM2_BOOK != o_ptr->tval ||
1130              p_ptr->pclass == CLASS_SORCERER ||
1131              p_ptr->pclass == CLASS_RED_MAGE))
1132                 return FALSE;
1133
1134         /*** First rank spellbooks ***/
1135         if (IS_FLG(FLG_FIRST) &&
1136             (o_ptr->tval < TV_LIFE_BOOK || 0 != o_ptr->sval))
1137                 return FALSE;
1138
1139         /*** Second rank spellbooks ***/
1140         if (IS_FLG(FLG_SECOND) &&
1141             (o_ptr->tval < TV_LIFE_BOOK || 1 != o_ptr->sval))
1142                 return FALSE;
1143
1144         /*** Third rank spellbooks ***/
1145         if (IS_FLG(FLG_THIRD) &&
1146             (o_ptr->tval < TV_LIFE_BOOK || 2 != o_ptr->sval))
1147                 return FALSE;
1148
1149         /*** Fourth rank spellbooks ***/
1150         if (IS_FLG(FLG_FOURTH) &&
1151             (o_ptr->tval < TV_LIFE_BOOK || 3 != o_ptr->sval))
1152                 return FALSE;
1153
1154         /*** Items ***/
1155         if (IS_FLG(FLG_WEAPONS))
1156         {
1157                 if (!(TV_WEAPON_BEGIN <= o_ptr->tval && o_ptr->tval <= TV_WEAPON_END))
1158                         return FALSE;
1159         }
1160         else if (IS_FLG(FLG_ARMORS))
1161         {
1162                 if (!(TV_ARMOR_BEGIN <= o_ptr->tval && o_ptr->tval <= TV_ARMOR_END))
1163                         return FALSE;
1164         }
1165         else if (IS_FLG(FLG_MISSILES))
1166         {
1167                 switch(o_ptr->tval)
1168                 {
1169                 case TV_SHOT: case TV_BOLT: case TV_ARROW:
1170                         break;
1171                 default: return FALSE;
1172                 }
1173         }
1174         else if (IS_FLG(FLG_DEVICES))
1175         {
1176                 switch(o_ptr->tval)
1177                 {
1178                 case TV_SCROLL: case TV_STAFF: case TV_WAND: case TV_ROD:
1179                         break;
1180                 default: return FALSE;
1181                 }
1182         }
1183         else if (IS_FLG(FLG_LIGHTS))
1184         {
1185                 if (!(o_ptr->tval == TV_LITE))
1186                         return FALSE;
1187         }
1188         else if (IS_FLG(FLG_JUNKS))
1189         {
1190                 switch(o_ptr->tval)
1191                 {
1192                 case TV_SKELETON: case TV_BOTTLE:
1193                 case TV_JUNK: case TV_STATUE:
1194                         break;
1195                 default: return FALSE;
1196                 }
1197         }
1198         else if (IS_FLG(FLG_SPELLBOOKS))
1199         {
1200                 if (!(o_ptr->tval >= TV_LIFE_BOOK))
1201                         return FALSE;
1202         }
1203         else if (IS_FLG(FLG_HAFTED))
1204         {
1205                 if (!(o_ptr->tval == TV_HAFTED))
1206                         return FALSE;
1207         }
1208         else if (IS_FLG(FLG_SHIELDS))
1209         {
1210                 if (!(o_ptr->tval == TV_SHIELD))
1211                         return FALSE;
1212         }
1213         else if (IS_FLG(FLG_BOWS))
1214         {
1215                 if (!(o_ptr->tval == TV_BOW))
1216                         return FALSE;
1217         }
1218         else if (IS_FLG(FLG_RINGS))
1219         {
1220                 if (!(o_ptr->tval == TV_RING))
1221                         return FALSE;
1222         }
1223         else if (IS_FLG(FLG_AMULETS))
1224         {
1225                 if (!(o_ptr->tval == TV_AMULET))
1226                         return FALSE;
1227         }
1228         else if (IS_FLG(FLG_SUITS))
1229         {
1230                 if (!(o_ptr->tval == TV_DRAG_ARMOR ||
1231                       o_ptr->tval == TV_HARD_ARMOR ||
1232                       o_ptr->tval == TV_SOFT_ARMOR))
1233                         return FALSE;
1234         }
1235         else if (IS_FLG(FLG_CLOAKS))
1236         {
1237                 if (!(o_ptr->tval == TV_CLOAK))
1238                         return FALSE;
1239         }
1240         else if (IS_FLG(FLG_HELMS))
1241         {
1242                 if (!(o_ptr->tval == TV_CROWN || o_ptr->tval == TV_HELM))
1243                         return FALSE;
1244         }
1245         else if (IS_FLG(FLG_GLOVES))
1246         {
1247                 if (!(o_ptr->tval == TV_GLOVES))
1248                         return FALSE;
1249         }
1250         else if (IS_FLG(FLG_BOOTS))
1251         {
1252                 if (!(o_ptr->tval == TV_BOOTS))
1253                         return FALSE;
1254         }
1255         else if (IS_FLG(FLG_FAVORITE))
1256         {
1257                 if (!is_favorite(o_ptr))
1258                         return FALSE;
1259         }
1260
1261         /* Keyword don't match */
1262         if (*ptr == '^')
1263         {
1264                 ptr++;
1265                 if (strncmp(o_name, ptr, strlen(ptr))) return FALSE;
1266         }
1267         else
1268         {
1269 #ifdef JP
1270                 if (!strstr_j(o_name, ptr)) return FALSE;
1271 #else
1272                 if (!strstr(o_name, ptr)) return FALSE;
1273 #endif
1274         }
1275
1276         /* TRUE when it need not to be 'collecting' */
1277         if (!IS_FLG(FLG_COLLECTING)) return TRUE;
1278
1279         /* Check if there is a same item */
1280         for (j = 0; j < INVEN_PACK; j++)
1281         {
1282                 /*
1283                  * 'Collecting' means the item must be absorbed
1284                  * into an inventory slot.
1285                  * But an item can not be absorbed into itself!
1286                  */
1287                 if ((&inventory[j] != o_ptr) &&
1288                     object_similar(&inventory[j], o_ptr))
1289                         return TRUE;
1290         }
1291
1292         /* Not collecting */
1293         return FALSE;
1294 }
1295
1296
1297 /*
1298  * A function for Auto-picker/destroyer
1299  * Examine whether the object matches to the list of keywords or not.
1300  */
1301 int is_autopick(object_type *o_ptr)
1302 {
1303         int i;
1304         char o_name[MAX_NLEN];
1305
1306         if (o_ptr->tval == TV_GOLD) return -1;
1307
1308         /* Prepare object name string first */
1309         object_desc(o_name, o_ptr, FALSE, 3);
1310
1311         /* Convert the string to lower case */
1312         str_tolower(o_name);
1313
1314         /* Look for a matching entry in the list */
1315         for (i=0; i < max_autopick; i++)
1316         {
1317                 autopick_type *entry = &autopick_list[i];
1318
1319                 if (is_autopick_aux(o_ptr, entry, o_name)) return i;
1320         }
1321
1322         /* No matching entry */
1323         return -1;
1324 }
1325
1326
1327 /*
1328  *  Auto inscription
1329  */
1330 static void auto_inscribe_item(object_type *o_ptr, int idx)
1331 {
1332         /* Are there auto-inscription? */
1333         if (idx < 0 || !autopick_list[idx].insc) return;
1334
1335         if (!o_ptr->inscription)
1336                 o_ptr->inscription = quark_add(autopick_list[idx].insc);
1337
1338         /* Redraw inscription */
1339         p_ptr->window |= (PW_EQUIP | PW_INVEN);
1340
1341         /* {.} and {$} effect p_ptr->warning and TRC_TELEPORT_SELF */
1342         p_ptr->update |= (PU_BONUS);
1343 }
1344
1345
1346 /*
1347  * Automatically destroy items in this grid.
1348  */
1349 static bool is_opt_confirm_destroy(object_type *o_ptr)
1350 {
1351         if (!destroy_items) return FALSE;
1352
1353         /* Known to be worthless? */
1354         if (leave_worth)
1355                 if (object_value(o_ptr) > 0) return FALSE;
1356
1357         if (leave_equip)
1358                 if ((o_ptr->tval >= TV_MISSILE_BEGIN) && (o_ptr->tval <= TV_ARMOR_END)) return FALSE;
1359
1360         if (leave_chest)
1361                 if ((o_ptr->tval == TV_CHEST) && o_ptr->pval) return FALSE;
1362
1363         if (leave_wanted)
1364         {
1365                 if (o_ptr->tval == TV_CORPSE
1366                     && object_is_shoukinkubi(o_ptr)) return FALSE;
1367         }
1368
1369         if (leave_corpse)
1370                 if (o_ptr->tval == TV_CORPSE) return FALSE;
1371
1372         if (leave_junk)
1373                 if ((o_ptr->tval == TV_SKELETON) || (o_ptr->tval == TV_BOTTLE) || (o_ptr->tval == TV_JUNK) || (o_ptr->tval == TV_STATUE)) return FALSE;
1374
1375         if (leave_special)
1376         {
1377                 if (p_ptr->prace == RACE_DEMON)
1378                 {
1379                         if (o_ptr->tval == TV_CORPSE &&
1380                             o_ptr->sval == SV_CORPSE &&
1381                             strchr("pht", r_info[o_ptr->pval].d_char))
1382                                 return FALSE;
1383                 }
1384
1385                 if (p_ptr->pclass == CLASS_ARCHER)
1386                 {
1387                         if (o_ptr->tval == TV_SKELETON ||
1388                             (o_ptr->tval == TV_CORPSE && o_ptr->sval == SV_SKELETON))
1389                                 return FALSE;
1390                 }
1391                 else if (p_ptr->pclass == CLASS_NINJA)
1392                 {
1393                         if (o_ptr->tval == TV_LITE &&
1394                             o_ptr->name2 == EGO_LITE_DARKNESS)
1395                                 return FALSE;
1396                 }
1397                 else if (p_ptr->pclass == CLASS_BEASTMASTER ||
1398                          p_ptr->pclass == CLASS_CAVALRY)
1399                 {
1400                         if (o_ptr->tval == TV_WAND &&
1401                             o_ptr->sval == SV_WAND_HEAL_MONSTER)
1402                                 return FALSE;
1403                 }
1404         }
1405
1406         if (o_ptr->tval == TV_GOLD) return FALSE;
1407
1408         return TRUE;
1409 }
1410
1411
1412 /*
1413  * Automatically destroy an item if it is to be destroyed
1414  *
1415  * When always_pickup is 'yes', we disable auto-destroyer function of
1416  * auto-picker/destroyer, and do only easy-auto-destroyer.
1417  */
1418 static object_type autopick_last_destroyed_object;
1419
1420 static void auto_destroy_item(object_type *o_ptr, int autopick_idx)
1421 {
1422         bool destroy = FALSE;
1423
1424         /* Easy-Auto-Destroyer (3rd priority) */
1425         if (is_opt_confirm_destroy(o_ptr)) destroy = TRUE;
1426
1427         /* Protected by auto-picker (2nd priotity) */
1428         if (autopick_idx >= 0 &&
1429             !(autopick_list[autopick_idx].action & DO_AUTODESTROY))
1430                 destroy = FALSE;
1431
1432         /* Auto-destroyer works only when !always_pickup */
1433         if (!always_pickup)
1434         {
1435                 /* Auto-picker/destroyer (1st priority) */
1436                 if (autopick_idx >= 0 &&
1437                     (autopick_list[autopick_idx].action & DO_AUTODESTROY))
1438                         destroy = TRUE;
1439         }
1440
1441         /* Not to be destroyed */
1442         if (!destroy) return;
1443
1444         /* Now decided to destroy */
1445
1446         disturb(0,0);
1447
1448         /* Artifact? */
1449         if (!can_player_destroy_object(o_ptr))
1450         {
1451                 char o_name[MAX_NLEN];
1452
1453                 /* Describe the object (with {terrible/special}) */
1454                 object_desc(o_name, o_ptr, TRUE, 3);
1455
1456                 /* Message */
1457 #ifdef JP
1458                 msg_format("%s¤ÏÇË²õÉÔÇ½¤À¡£", o_name);
1459 #else
1460                 msg_format("You cannot auto-destroy %s.", o_name);
1461 #endif
1462
1463                 /* Done */
1464                 return;
1465         }
1466
1467         /* Record name of destroyed item */
1468         COPY(&autopick_last_destroyed_object, o_ptr, object_type);
1469
1470         /* Destroy Later */
1471         o_ptr->marked |= OM_AUTODESTROY;
1472         p_ptr->notice |= PN_AUTODESTROY;
1473
1474         return;
1475 }
1476
1477
1478 /*
1479  *  Auto-destroy marked item
1480  */
1481 static void delayed_auto_destroy_aux(int item)
1482 {
1483         object_type *o_ptr;
1484
1485         /* Get the item (in the pack) */
1486         if (item >= 0) o_ptr = &inventory[item];
1487
1488         /* Get the item (on the floor) */
1489         else o_ptr = &o_list[0 - item];
1490
1491         if (o_ptr->k_idx && o_ptr->marked & OM_AUTODESTROY)
1492         {
1493                 char o_name[MAX_NLEN];
1494
1495                 /* Describe the object (with {terrible/special}) */
1496                 object_desc(o_name, o_ptr, TRUE, 3);
1497
1498                 /* Eliminate the item (from the pack) */
1499                 if (item >= 0)
1500                 {
1501                         inven_item_increase(item, -(o_ptr->number));
1502                         inven_item_optimize(item);
1503                 }
1504
1505                 /* Eliminate the item (from the floor) */
1506                 else
1507                 {
1508                         delete_object_idx(0 - item);
1509                 }
1510
1511                 /* Print a message */
1512 #ifdef JP
1513                 msg_format("%s¤ò¼«Æ°ÇË²õ¤·¤Þ¤¹¡£", o_name);
1514 #else
1515                 msg_format("Auto-destroying %s.", o_name);
1516 #endif
1517         }
1518 }
1519
1520
1521 /*
1522  *  Auto-destroy marked items in inventry and on floor
1523  */
1524 void delayed_auto_destroy(void)
1525 {
1526         int item;
1527
1528         /*
1529          * Scan inventry in reverse order to prevent
1530          * skipping after inven_item_optimize()
1531          */
1532         for (item = INVEN_TOTAL - 1; item >= 0 ; item--)
1533                 delayed_auto_destroy_aux(item);
1534
1535         /* Scan the pile of objects */
1536         item = cave[py][px].o_idx;
1537         while (item)
1538         {
1539                 int next = o_list[item].next_o_idx;
1540                 delayed_auto_destroy_aux(-item);
1541                 item = next;
1542         }
1543 }
1544
1545
1546 /*
1547  * Auto-inscription and/or destroy
1548  *
1549  * Auto-destroyer works only on inventory or on floor stack only when
1550  * requested.
1551  */
1552 void auto_do_item(int item, bool destroy)
1553 {
1554         object_type *o_ptr;
1555         int idx;
1556
1557         /* Get the item (in the pack) */
1558         if (item >= 0) o_ptr = &inventory[item];
1559
1560         /* Get the item (on the floor) */
1561         else o_ptr = &o_list[0 - item];
1562
1563         /* Get the index in the auto-pick/destroy list */
1564         idx = is_autopick(o_ptr);
1565
1566         /* Do auto-inscription */
1567         auto_inscribe_item(o_ptr, idx);
1568
1569         /* Do auto-destroy if needed */
1570         if (destroy && item <= INVEN_PACK)
1571                 auto_destroy_item(o_ptr, idx);
1572 }
1573
1574
1575 /*
1576  * Automatically pickup/destroy items in this grid.
1577  */
1578 void auto_pickup_items(cave_type *c_ptr)
1579 {
1580         s16b this_o_idx, next_o_idx = 0;
1581
1582         /* Scan the pile of objects */
1583         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
1584         {
1585                 int idx;
1586
1587                 /* Acquire object */
1588                 object_type *o_ptr = &o_list[this_o_idx];
1589
1590                 /* Acquire next object */
1591                 next_o_idx = o_ptr->next_o_idx;
1592
1593                 /* Get the index of auto-picker list */
1594                 idx = is_autopick(o_ptr);
1595
1596                 /* Nothing defined on auto-picker? */
1597                 if (idx < 0) continue;
1598
1599                 /* Always do auto-inscription first */
1600                 auto_inscribe_item(o_ptr, idx);
1601
1602                 /* Do auto-destroy */
1603                 if (autopick_list[idx].action & DO_AUTODESTROY)
1604                 {
1605                         auto_destroy_item(o_ptr, idx);
1606                         continue;
1607                 }
1608
1609                 /* Disturb on auto-pick */
1610                 disturb(0,0);
1611
1612                 /* Is there an inventory space? */
1613                 if (!inven_carry_okay(o_ptr))
1614                 {
1615                         char o_name[MAX_NLEN];
1616
1617                         /* Describe the object */
1618                         object_desc(o_name, o_ptr, TRUE, 3);
1619
1620                         /* Message */
1621 #ifdef JP
1622                         msg_format("¥¶¥Ã¥¯¤Ë¤Ï%s¤òÆþ¤ì¤ë·ä´Ö¤¬¤Ê¤¤¡£", o_name);
1623 #else
1624                         msg_format("You have no room for %s.", o_name);
1625 #endif
1626                         /*
1627                          * Hack - No duplicate messages.
1628                          * remember that a message is given for the item here.
1629                          */
1630                         o_ptr->marked |= OM_NOMSG;
1631
1632                         continue;
1633                 }
1634
1635                 /* Ask if needed */
1636                 if (autopick_list[idx].action & DO_QUERY_AUTOPICK)
1637                 {
1638                         char out_val[MAX_NLEN+20];
1639                         char o_name[MAX_NLEN];
1640
1641                         if (o_ptr->marked & OM_NO_QUERY)
1642                         {
1643                                 /* Already answered as 'No' */
1644                                 continue;
1645                         }
1646
1647                         /* Describe the object */
1648                         object_desc(o_name, o_ptr, TRUE, 3);
1649
1650 #ifdef JP
1651                         sprintf(out_val, "%s¤ò½¦¤¤¤Þ¤¹¤«? ", o_name);
1652 #else
1653                         sprintf(out_val, "Pick up %s? ", o_name);
1654 #endif
1655
1656                         if (!get_check(out_val))
1657                         {
1658                                 /*
1659                                  * Hack - No duplicate messages/questions.
1660                                  * remember that a message is given
1661                                  * for the item here.
1662                                  */
1663                                 o_ptr->marked |= (OM_NOMSG | OM_NO_QUERY);
1664                                 continue;
1665                         }
1666
1667                 }
1668
1669                 /* Pick it up! */
1670                 py_pickup_aux(this_o_idx);
1671         }
1672 }
1673
1674
1675 #define PT_DEFAULT 0
1676 #define PT_WITH_PNAME 1
1677
1678 /*
1679  *  Get file name for autopick preference
1680  */
1681 static cptr pickpref_filename(int filename_mode)
1682 {
1683 #ifdef JP
1684         static const char namebase[] = "picktype";
1685 #else
1686         static const char namebase[] = "pickpref";
1687 #endif
1688
1689         switch (filename_mode)
1690         {
1691         case PT_DEFAULT:
1692                 return format("%s.prf", namebase);
1693
1694         case PT_WITH_PNAME:
1695                 return format("%s-%s.prf", namebase, player_name);
1696
1697         default:
1698                 return NULL;
1699         }
1700 }
1701
1702
1703 static const char autoregister_header[] = "?:$AUTOREGISTER";
1704
1705 /*
1706  *  Clear auto registered lines in the picktype.prf .
1707  */
1708 static bool clear_auto_register(void)
1709 {
1710         char tmp_file[1024];
1711         char pref_file[1024];
1712         char buf[1024];
1713         FILE *pref_fff;
1714         FILE *tmp_fff;
1715         int num = 0;
1716         bool autoregister = FALSE;
1717         bool okay = TRUE;
1718
1719         path_build(pref_file, sizeof(pref_file), ANGBAND_DIR_USER, pickpref_filename(PT_WITH_PNAME));
1720         pref_fff = my_fopen(pref_file, "r");
1721
1722         if (!pref_fff)
1723         {
1724                 path_build(pref_file, sizeof(pref_file), ANGBAND_DIR_USER, pickpref_filename(PT_DEFAULT));
1725                 pref_fff = my_fopen(pref_file, "r");
1726         }
1727
1728         if (!pref_fff)
1729         {
1730                 /* No file yet */
1731                 return TRUE;
1732         }
1733
1734         /* Open a new (temporary) file */
1735         tmp_fff = my_fopen_temp(tmp_file, sizeof(tmp_file));
1736
1737         if (!tmp_fff)
1738         {
1739                 /* Close the preference file */
1740                 fclose(pref_fff);
1741
1742 #ifdef JP
1743                 msg_format("°ì»þ¥Õ¥¡¥¤¥ë %s ¤òºîÀ®¤Ç¤¤Þ¤»¤ó¤Ç¤·¤¿¡£", tmp_file);
1744 #else
1745                 msg_format("Failed to create temporary file %s.", tmp_file);
1746 #endif
1747                 msg_print(NULL);
1748                 return FALSE;
1749         }
1750
1751
1752         /* Loop for every line */
1753         while (TRUE)
1754         {
1755                 /* Read a line */
1756                 if (my_fgets(pref_fff, buf, sizeof(buf))) break;
1757
1758                 if (autoregister)
1759                 {
1760                         /* Delete auto-registered line */
1761
1762                         /* Count auto-destroy preference lines */
1763                         if (buf[0] != '#' && buf[0] != '?') num++;
1764                 }
1765
1766                 /* We are looking for auto-registered line */
1767                 else
1768                 {
1769                         if (streq(buf, autoregister_header))
1770                         {
1771                                 /* Delete all further lines */
1772                                 autoregister = TRUE;
1773                         }
1774                         else
1775                         {
1776                                 /* Copy orginally lines */
1777                                 fprintf(tmp_fff, "%s\n", buf);
1778                         }
1779                 }
1780         }
1781
1782         /* Close files */
1783         my_fclose(pref_fff);
1784         my_fclose(tmp_fff);
1785
1786         if (num)
1787         {
1788 #ifdef JP
1789                 msg_format("°ÊÁ°¤Î¥¥ã¥é¥¯¥¿¡¼ÍÑ¤Î¼«Æ°ÀßÄê(%d¹Ô)¤¬»Ä¤Ã¤Æ¤¤¤Þ¤¹¡£", num);
1790                 strcpy(buf, "¸Å¤¤ÀßÄê¹Ô¤Ïºï½ü¤·¤Þ¤¹¡£¤è¤í¤·¤¤¤Ç¤¹¤«¡©");
1791 #else
1792                 msg_format("Auto registered lines (%d lines) for previous character are remaining.", num);
1793                 strcpy(buf, "These lines will be deleted.  Are you sure? ");
1794 #endif
1795
1796                 /* You can cancel it */
1797                 if (!get_check(buf))
1798                 {
1799                         okay = FALSE;
1800                         autoregister = FALSE;
1801
1802 #ifdef JP
1803                         msg_print("¥¨¥Ç¥£¥¿¤Î¥«¥Ã¥È&¥Ú¡¼¥¹¥ÈÅù¤ò»È¤Ã¤ÆÉ¬Í×¤Ê¹Ô¤òÈòÆñ¤·¤Æ¤¯¤À¤µ¤¤¡£");
1804 #else
1805                         msg_print("Use cut & paste of auto picker editor (_) to keep old prefs.");
1806 #endif
1807                 }
1808         }
1809
1810
1811         /* If there are some changes, overwrite the original file with new one */
1812         if (autoregister)
1813         {
1814                 /* Copy contents of temporary file */
1815
1816                 tmp_fff = my_fopen(tmp_file, "r");
1817                 pref_fff = my_fopen(pref_file, "w");
1818
1819                 while (!my_fgets(tmp_fff, buf, sizeof(buf)))
1820                         fprintf(pref_fff, "%s\n", buf);
1821
1822                 my_fclose(pref_fff);
1823                 my_fclose(tmp_fff);
1824         }
1825
1826         /* Kill the temporary file */
1827         fd_kill(tmp_file);
1828
1829         return okay;
1830 }
1831
1832
1833 /*
1834  *  Automatically register an auto-destroy preference line
1835  */
1836 bool add_auto_register(object_type *o_ptr)
1837 {
1838         char buf[1024];
1839         char pref_file[1024];
1840         FILE *pref_fff;
1841         autopick_type an_entry, *entry = &an_entry;
1842
1843         int match_autopick = is_autopick(o_ptr);
1844
1845         /* Already registered */
1846         if (match_autopick != -1)
1847         {
1848                 cptr what;
1849                 byte act = autopick_list[match_autopick].action;
1850
1851 #ifdef JP
1852                 if (act & DO_AUTOPICK) what = "¼«Æ°¤Ç½¦¤¦";
1853                 else if (act & DO_AUTODESTROY) what = "¼«Æ°ÇË²õ¤¹¤ë";
1854                 else if (act & DONT_AUTOPICK) what = "ÊüÃÖ¤¹¤ë";
1855                 else /* if (act & DO_QUERY_AUTOPICK) */ what = "³ÎÇ§¤·¤Æ½¦¤¦";
1856
1857                 msg_format("¤½¤Î¥¢¥¤¥Æ¥à¤Ï´û¤Ë%s¤è¤¦¤ËÀßÄê¤µ¤ì¤Æ¤¤¤Þ¤¹¡£", what);
1858 #else
1859                 if (act & DO_AUTOPICK) what = "auto-pickup";
1860                 else if (act & DO_AUTODESTROY) what = "auto-destroy";
1861                 else if (act & DONT_AUTOPICK) what = "leave on floor";
1862                 else /* if (act & DO_QUERY_AUTOPICK) */ what = "query auto-pickup";
1863
1864                 msg_format("The object is already registered to %s.", what);
1865 #endif
1866
1867                 return FALSE;
1868         }
1869
1870
1871         if (!p_ptr->autopick_autoregister)
1872         {
1873                 /* Clear old auto registered lines */
1874                 if (!clear_auto_register()) return FALSE;
1875         }
1876
1877         /* Try a filename with player name */
1878         path_build(pref_file, sizeof(pref_file), ANGBAND_DIR_USER, pickpref_filename(PT_WITH_PNAME));
1879         pref_fff = my_fopen(pref_file, "r");
1880
1881         if (!pref_fff)
1882         {
1883                 /* Use default name */
1884                 path_build(pref_file, sizeof(pref_file), ANGBAND_DIR_USER, pickpref_filename(PT_DEFAULT));
1885                 pref_fff = my_fopen(pref_file, "r");
1886         }
1887
1888         /* Check the header */
1889         while (TRUE)
1890         {
1891                 /* Read a line */
1892                 if (my_fgets(pref_fff, buf, sizeof(buf)))
1893                 {
1894                         /* No header found */
1895                         p_ptr->autopick_autoregister = FALSE;
1896
1897                         break;
1898                 }
1899
1900                 if (streq(buf, autoregister_header))
1901                 {
1902                         /* Found the header */
1903                         p_ptr->autopick_autoregister = TRUE;
1904
1905                         break;
1906                 }
1907         }
1908
1909         /* Close read only FILE* */
1910         fclose(pref_fff);
1911
1912         /* Open for append */
1913         pref_fff = my_fopen(pref_file, "a");
1914
1915         /* Failure */
1916         if (!pref_fff) {
1917 #ifdef JP
1918                 msg_format("%s ¤ò³«¤¯¤³¤È¤¬¤Ç¤¤Þ¤»¤ó¤Ç¤·¤¿¡£", pref_file);
1919 #else
1920                 msg_format("Failed to open %s.", pref_file);
1921 #endif
1922                 msg_print(NULL);
1923
1924                 /* Failed */
1925                 return FALSE;
1926         }
1927
1928         if (!p_ptr->autopick_autoregister)
1929         {
1930                 /* Add the header */
1931                 fprintf(pref_fff, "%s\n", autoregister_header);
1932
1933 #ifdef JP
1934                 fprintf(pref_fff, "%s\n", "# *·Ù¹ð!!* °Ê¹ß¤Î¹Ô¤Ï¼«Æ°ÅÐÏ¿¤µ¤ì¤¿¤â¤Î¤Ç¤¹¡£");
1935                 fprintf(pref_fff, "%s\n", "# ¸å¤Ç¼«Æ°Åª¤Ëºï½ü¤µ¤ì¤Þ¤¹¤Î¤Ç¡¢É¬Í×¤Ê¹Ô¤Ï¾å¤ÎÊý¤Ø°ÜÆ°¤·¤Æ¤ª¤¤¤Æ¤¯¤À¤µ¤¤¡£");
1936 #else
1937                 fprintf(pref_fff, "%s\n", "# *Waring!* The lines below will be deleated later.");
1938                 fprintf(pref_fff, "%s\n", "# Keep it by cut & paste if you need these lines for future characters.");
1939 #endif
1940
1941                 /* Now auto register is in-use */
1942                 p_ptr->autopick_autoregister = TRUE;
1943         }
1944
1945         /* Get a preference entry */
1946         autopick_entry_from_object(entry, o_ptr);
1947
1948         /* Set to auto-destroy (with no-display) */
1949         entry->action = DO_AUTODESTROY;
1950
1951         /* Load the new line as preference */
1952         add_autopick_list(entry);
1953
1954         /* Add a line to the file */
1955         /* Don't kill "entry" */
1956         fprintf(pref_fff, "%s\n", autopick_line_from_entry(entry));
1957
1958         /* Close the file */
1959         fclose(pref_fff);
1960
1961         return TRUE;
1962 }
1963
1964
1965 /********  Auto-picker/destroyer editor  **********/
1966
1967 #define MAX_YANK MAX_LINELEN
1968 #define MAX_LINES 3000
1969
1970 #define MARK_MARK     0x01
1971 #define MARK_BY_SHIFT 0x02
1972
1973 #define LSTAT_BYPASS        0x01
1974 #define LSTAT_EXPRESSION    0x02
1975 #define LSTAT_AUTOREGISTER  0x04
1976
1977 #define QUIT_WITHOUT_SAVE 1
1978 #define QUIT_AND_SAVE     2
1979
1980 /*
1981  * Struct for yank buffer
1982  */
1983 typedef struct chain_str {
1984         struct chain_str *next;
1985         char s[1];
1986 } chain_str_type;
1987
1988
1989 /*
1990  * Data struct for text editor
1991  */
1992 typedef struct {
1993         int wid, hgt;
1994         int cx, cy;
1995         int upper, left;
1996         int old_wid, old_hgt;
1997         int old_cy;
1998         int old_upper, old_left;
1999         int mx, my;
2000         byte mark;
2001
2002         object_type *search_o_ptr;
2003         cptr search_str;
2004         cptr last_destroyed;
2005
2006         chain_str_type *yank;
2007         bool yank_eol;
2008
2009         cptr *lines_list;
2010         byte states[MAX_LINES];
2011
2012         u16b dirty_flags;
2013         int dirty_line;
2014         int filename_mode;
2015         int old_com_id;
2016
2017         bool changed;
2018 } text_body_type;
2019
2020
2021 /*
2022  * Dirty flag for text editor
2023  */
2024 #define DIRTY_ALL           0x0001
2025 #define DIRTY_MODE          0x0004
2026 #define DIRTY_SCREEN        0x0008
2027 #define DIRTY_NOT_FOUND     0x0010
2028 #define DIRTY_NO_SEARCH     0x0020
2029 #define DIRTY_EXPRESSION    0x0040
2030 #define DIRTY_SKIP_INACTIVE 0x0080
2031 #define DIRTY_INACTIVE      0x0100
2032
2033 /*
2034  * Describe which kind of object is Auto-picked/destroyed
2035  */
2036 static void describe_autopick(char *buff, autopick_type *entry)
2037 {
2038         cptr str = entry->name;
2039         byte act = entry->action;
2040         cptr insc = entry->insc;
2041         int i;
2042
2043         bool top = FALSE;
2044
2045 #ifdef JP
2046         cptr before_str[100], body_str;
2047         int before_n = 0;
2048
2049         body_str = "¥¢¥¤¥Æ¥à";
2050
2051         /*** Collecting items ***/
2052         /*** Which can be absorbed into a slot as a bundle ***/
2053         if (IS_FLG(FLG_COLLECTING))
2054                 before_str[before_n++] = "¼ý½¸Ãæ¤Ç´û¤Ë»ý¤Ã¤Æ¤¤¤ë¥¹¥í¥Ã¥È¤Ë¤Þ¤È¤á¤é¤ì¤ë";
2055
2056         /*** Unidentified ***/
2057         if (IS_FLG(FLG_UNIDENTIFIED))
2058                 before_str[before_n++] = "Ì¤´ÕÄê¤Î";
2059
2060         /*** Identified ***/
2061         if (IS_FLG(FLG_IDENTIFIED))
2062                 before_str[before_n++] = "´ÕÄêºÑ¤ß¤Î";
2063
2064         /*** *Identified* ***/
2065         if (IS_FLG(FLG_STAR_IDENTIFIED))
2066                 before_str[before_n++] = "´°Á´¤Ë´ÕÄêºÑ¤ß¤Î";
2067
2068         /*** Dice boosted (weapon of slaying) ***/
2069         if (IS_FLG(FLG_BOOSTED))
2070         {
2071                 before_str[before_n++] = "¥À¥á¡¼¥¸¥À¥¤¥¹¤¬ÄÌ¾ï¤è¤êÂç¤¤¤";
2072                 body_str = "Éð´ï";
2073         }
2074
2075         /*** Weapons whose dd*ds is more than nn ***/
2076         if (IS_FLG(FLG_MORE_THAN))
2077         {
2078                 static char more_than_desc_str[] = "___";
2079                 before_str[before_n++] = "¥À¥á¡¼¥¸¥À¥¤¥¹¤ÎºÇÂçÃÍ¤¬";
2080                 body_str = "Éð´ï";
2081
2082                 sprintf(more_than_desc_str,"%d", entry->dice);
2083                 before_str[before_n++] = more_than_desc_str;
2084                 before_str[before_n++] = "°Ê¾å¤Î";
2085         }
2086
2087         /*** Items whose magical bonus is more than nn ***/
2088         if (IS_FLG(FLG_MORE_BONUS))
2089         {
2090                 static char more_bonus_desc_str[] = "___";
2091                 before_str[before_n++] = "½¤ÀµÃÍ¤¬(+";
2092
2093                 sprintf(more_bonus_desc_str,"%d", entry->bonus);
2094                 before_str[before_n++] = more_bonus_desc_str;
2095                 before_str[before_n++] = ")°Ê¾å¤Î";
2096         }
2097
2098         /*** Worthless items ***/
2099         if (IS_FLG(FLG_WORTHLESS))
2100                 before_str[before_n++] = "Å¹¤ÇÌµ²ÁÃÍ¤ÈÈ½Äê¤µ¤ì¤ë";
2101
2102         /*** Artifact ***/
2103         if (IS_FLG(FLG_ARTIFACT))
2104         {
2105                 before_str[before_n++] = "¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Î";
2106                 body_str = "ÁõÈ÷";
2107         }
2108
2109         /*** Ego ***/
2110         if (IS_FLG(FLG_EGO))
2111         {
2112                 before_str[before_n++] = "¥¨¥´¥¢¥¤¥Æ¥à¤Î";
2113                 body_str = "ÁõÈ÷";
2114         }
2115
2116         /*** Nameless ***/
2117         if (IS_FLG(FLG_NAMELESS))
2118         {
2119                 before_str[before_n++] = "¥¨¥´¤Ç¤â¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Ç¤â¤Ê¤¤";
2120                 body_str = "ÁõÈ÷";
2121         }
2122
2123         /*** Unaware items ***/
2124         if (IS_FLG(FLG_UNAWARE))
2125                 before_str[before_n++] = "Ì¤´ÕÄê¤Ç¤½¤Î¸ú²Ì¤âÈ½ÌÀ¤·¤Æ¤¤¤Ê¤¤";
2126
2127         /*** Wanted monster's corpse/skeletons ***/
2128         if (IS_FLG(FLG_WANTED))
2129         {
2130                 before_str[before_n++] = "¥Ï¥ó¥¿¡¼»öÌ³½ê¤Ç¾Þ¶â¼ó¤È¤µ¤ì¤Æ¤¤¤ë";
2131                 body_str = "»àÂÎ¤ä¹ü";
2132         }
2133
2134         /*** Human corpse/skeletons (for Daemon magic) ***/
2135         if (IS_FLG(FLG_HUMAN))
2136         {
2137                 before_str[before_n++] = "°ËâËâË¡¤Ç»È¤¦¤¿¤á¤Î¿Í´Ö¤ä¥Ò¥å¡¼¥Þ¥Î¥¤¥É¤Î";
2138                 body_str = "»àÂÎ¤ä¹ü";
2139         }
2140
2141         /*** Unique monster's corpse/skeletons/statues ***/
2142         if (IS_FLG(FLG_UNIQUE))
2143         {
2144                 before_str[before_n++] = "¥æ¥Ë¡¼¥¯¥â¥ó¥¹¥¿¡¼¤Î";
2145                 body_str = "»àÂÎ¤ä¹ü";
2146         }
2147
2148         /*** Unreadable spellbooks ***/
2149         if (IS_FLG(FLG_UNREADABLE))
2150         {
2151                 before_str[before_n++] = "¤¢¤Ê¤¿¤¬ÆÉ¤á¤Ê¤¤ÎÎ°è¤Î";
2152                 body_str = "ËâË¡½ñ";
2153         }
2154
2155         /*** First realm spellbooks ***/
2156         if (IS_FLG(FLG_REALM1))
2157         {
2158                 before_str[before_n++] = "Âè°ìÎÎ°è¤Î";
2159                 body_str = "ËâË¡½ñ";
2160         }
2161
2162         /*** Second realm spellbooks ***/
2163         if (IS_FLG(FLG_REALM2))
2164         {
2165                 before_str[before_n++] = "ÂèÆóÎÎ°è¤Î";
2166                 body_str = "ËâË¡½ñ";
2167         }
2168
2169         /*** First rank spellbooks ***/
2170         if (IS_FLG(FLG_FIRST))
2171         {
2172                 before_str[before_n++] = "Á´4ºý¤ÎÆâ¤Î1ºýÌÜ¤Î";
2173                 body_str = "ËâË¡½ñ";
2174         }
2175
2176         /*** Second rank spellbooks ***/
2177         if (IS_FLG(FLG_SECOND))
2178         {
2179                 before_str[before_n++] = "Á´4ºý¤ÎÆâ¤Î2ºýÌÜ¤Î";
2180                 body_str = "ËâË¡½ñ";
2181         }
2182
2183         /*** Third rank spellbooks ***/
2184         if (IS_FLG(FLG_THIRD))
2185         {
2186                 before_str[before_n++] = "Á´4ºý¤ÎÆâ¤Î3ºýÌÜ¤Î";
2187                 body_str = "ËâË¡½ñ";
2188         }
2189
2190         /*** Fourth rank spellbooks ***/
2191         if (IS_FLG(FLG_FOURTH))
2192         {
2193                 before_str[before_n++] = "Á´4ºý¤ÎÆâ¤Î4ºýÌÜ¤Î";
2194                 body_str = "ËâË¡½ñ";
2195         }
2196
2197         /*** Items ***/
2198         if (IS_FLG(FLG_ITEMS))
2199                 ; /* Nothing to do */
2200         else if (IS_FLG(FLG_WEAPONS))
2201                 body_str = "Éð´ï";
2202         else if (IS_FLG(FLG_ARMORS))
2203                 body_str = "ËÉ¶ñ";
2204         else if (IS_FLG(FLG_MISSILES))
2205                 body_str = "ÃÆ¤äÌð¤ä¥¯¥í¥¹¥Ü¥¦¤ÎÌð";
2206         else if (IS_FLG(FLG_DEVICES))
2207                 body_str = "´¬Êª¤äËâË¡ËÀ¤ä¾ó¤ä¥í¥Ã¥É";
2208         else if (IS_FLG(FLG_LIGHTS))
2209                 body_str = "¸÷¸»ÍÑ¤Î¥¢¥¤¥Æ¥à";
2210         else if (IS_FLG(FLG_JUNKS))
2211                 body_str = "ÀÞ¤ì¤¿ËÀÅù¤Î¥¬¥é¥¯¥¿";
2212         else if (IS_FLG(FLG_SPELLBOOKS))
2213                 body_str = "ËâË¡½ñ";
2214         else if (IS_FLG(FLG_HAFTED))
2215                 body_str = "Æß´ï";
2216         else if (IS_FLG(FLG_SHIELDS))
2217                 body_str = "½â";
2218         else if (IS_FLG(FLG_BOWS))
2219                 body_str = "¥¹¥ê¥ó¥°¤äµÝ¤ä¥¯¥í¥¹¥Ü¥¦";
2220         else if (IS_FLG(FLG_RINGS))
2221                 body_str = "»ØÎØ";
2222         else if (IS_FLG(FLG_AMULETS))
2223                 body_str = "¥¢¥ß¥å¥ì¥Ã¥È";
2224         else if (IS_FLG(FLG_SUITS))
2225                 body_str = "³»";
2226         else if (IS_FLG(FLG_CLOAKS))
2227                 body_str = "¥¯¥í¡¼¥¯";
2228         else if (IS_FLG(FLG_HELMS))
2229                 body_str = "¥Ø¥ë¥á¥Ã¥È¤ä´§";
2230         else if (IS_FLG(FLG_GLOVES))
2231                 body_str = "äÆ¼ê";
2232         else if (IS_FLG(FLG_BOOTS))
2233                 body_str = "¥Ö¡¼¥Ä";
2234         else if (IS_FLG(FLG_FAVORITE))
2235                 body_str = "ÆÀ°ÕÉð´ï";
2236
2237         *buff = '\0';
2238         if (!before_n)
2239                 strcat(buff, "Á´¤Æ¤Î");
2240         else for (i = 0; i < before_n && before_str[i]; i++)
2241                 strcat(buff, before_str[i]);
2242
2243         strcat(buff, body_str);
2244
2245         if (*str)
2246         {
2247                 if (*str == '^')
2248                 {
2249                         str++;
2250                         top = TRUE;
2251                 }
2252
2253                 strcat(buff, "¤Ç¡¢Ì¾Á°¤¬¡Ö");
2254                 strncat(buff, str, 80);
2255                 if (top)
2256                         strcat(buff, "¡×¤Ç»Ï¤Þ¤ë¤â¤Î");
2257                 else
2258                         strcat(buff, "¡×¤ò´Þ¤à¤â¤Î");
2259         }
2260
2261         if (insc)
2262         {
2263                 strncat(buff, format("¤Ë¡Ö%s¡×", insc), 80);
2264
2265                 if (strstr(insc, "%%all"))
2266                         strcat(buff, "(%%all¤ÏÁ´Ç½ÎÏ¤òÉ½¤¹±Ñ»ú¤Îµ¹æ¤ÇÃÖ´¹)");
2267                 else if (strstr(insc, "%all"))
2268                         strcat(buff, "(%all¤ÏÁ´Ç½ÎÏ¤òÉ½¤¹µ¹æ¤ÇÃÖ´¹)");
2269                 else if (strstr(insc, "%%"))
2270                         strcat(buff, "(%%¤ÏÄÉ²ÃÇ½ÎÏ¤òÉ½¤¹±Ñ»ú¤Îµ¹æ¤ÇÃÖ´¹)");
2271                 else if (strstr(insc, "%"))
2272                         strcat(buff, "(%¤ÏÄÉ²ÃÇ½ÎÏ¤òÉ½¤¹µ¹æ¤ÇÃÖ´¹)");
2273
2274                 strcat(buff, "¤È¹ï¤ó¤Ç");
2275         }
2276         else
2277                 strcat(buff, "¤ò");
2278
2279         if (act & DONT_AUTOPICK)
2280                 strcat(buff, "ÊüÃÖ¤¹¤ë¡£");
2281         else if (act & DO_AUTODESTROY)
2282                 strcat(buff, "ÇË²õ¤¹¤ë¡£");
2283         else if (act & DO_QUERY_AUTOPICK)
2284                 strcat(buff, "³ÎÇ§¤Î¸å¤Ë½¦¤¦¡£");
2285         else
2286                 strcat(buff, "½¦¤¦¡£");
2287
2288         if (act & DO_DISPLAY)
2289         {
2290                 if (act & DONT_AUTOPICK)
2291                         strcat(buff, "Á´ÂÎ¥Þ¥Ã¥×('M')¤Ç'N'¤ò²¡¤·¤¿¤È¤¤ËÉ½¼¨¤¹¤ë¡£");
2292                 else if (act & DO_AUTODESTROY)
2293                         strcat(buff, "Á´ÂÎ¥Þ¥Ã¥×('M')¤Ç'K'¤ò²¡¤·¤¿¤È¤¤ËÉ½¼¨¤¹¤ë¡£");
2294                 else
2295                         strcat(buff, "Á´ÂÎ¥Þ¥Ã¥×('M')¤Ç'M'¤ò²¡¤·¤¿¤È¤¤ËÉ½¼¨¤¹¤ë¡£");
2296         }
2297         else
2298                 strcat(buff, "Á´ÂÎ¥Þ¥Ã¥×¤Ë¤ÏÉ½¼¨¤·¤Ê¤¤¡£");
2299
2300 #else /* JP */
2301
2302         cptr before_str[20], after_str[20], which_str[20], whose_str[20], body_str;
2303         int before_n = 0, after_n = 0, which_n = 0, whose_n = 0;
2304
2305         body_str = "items";
2306
2307         /*** Collecting items ***/
2308         /*** Which can be absorbed into a slot as a bundle ***/
2309         if (IS_FLG(FLG_COLLECTING))
2310                 which_str[which_n++] = "can be absorbed into an existing inventory slot";
2311
2312         /*** Unidentified ***/
2313         if (IS_FLG(FLG_UNIDENTIFIED))
2314                 before_str[before_n++] = "unidentified";
2315
2316         /*** Identified ***/
2317         if (IS_FLG(FLG_IDENTIFIED))
2318                 before_str[before_n++] = "identified";
2319
2320         /*** *Identified* ***/
2321         if (IS_FLG(FLG_STAR_IDENTIFIED))
2322                 before_str[before_n++] = "fully identified";
2323
2324         /*** Worthless items ***/
2325         if (IS_FLG(FLG_WORTHLESS))
2326         {
2327                 before_str[before_n++] = "worthless";
2328                 which_str[which_n++] = "can not be sold at stores";
2329         }
2330
2331         /*** Artifacto ***/
2332         if (IS_FLG(FLG_ARTIFACT))
2333         {
2334                 before_str[before_n++] = "artifact";
2335         }
2336
2337         /*** Ego ***/
2338         if (IS_FLG(FLG_EGO))
2339         {
2340                 before_str[before_n++] = "ego";
2341         }
2342
2343         /*** Nameless ***/
2344         if (IS_FLG(FLG_NAMELESS))
2345         {
2346                 body_str = "equipment";
2347                 which_str[which_n++] = "is neither ego-item nor artifact";
2348         }
2349
2350         /*** Unaware items ***/
2351         if (IS_FLG(FLG_UNAWARE))
2352         {
2353                 before_str[before_n++] = "unidentified";
2354                 whose_str[whose_n++] = "basic abilities are not known";
2355         }
2356
2357         /*** Dice boosted (weapon of slaying) ***/
2358         if (IS_FLG(FLG_BOOSTED))
2359         {
2360                 body_str = "weapons";
2361                 whose_str[whose_n++] = "damage dice is bigger than normal";
2362         }
2363
2364         /*** Weapons whose dd*ds is more than nn ***/
2365         if (IS_FLG(FLG_MORE_THAN))
2366         {
2367                 static char more_than_desc_str[] =
2368                         "maximum damage from dice is bigger than __";
2369                 body_str = "weapons";
2370
2371                 sprintf(more_than_desc_str + sizeof(more_than_desc_str) - 3,
2372                         "%d", entry->dice);
2373                 whose_str[whose_n++] = more_than_desc_str;
2374         }
2375
2376         /*** Items whose magical bonus is more than nn ***/
2377         if (IS_FLG(FLG_MORE_BONUS))
2378         {
2379                 static char more_bonus_desc_str[] =
2380                         "magical bonus is bigger than (+__)";
2381
2382                 sprintf(more_bonus_desc_str + sizeof(more_bonus_desc_str) - 4,
2383                         "%d)", entry->bonus);
2384                 whose_str[whose_n++] = more_bonus_desc_str;
2385         }
2386
2387         /*** Wanted monster's corpse/skeletons ***/
2388         if (IS_FLG(FLG_WANTED))
2389         {
2390                 body_str = "corpse or skeletons";
2391                 which_str[which_n++] = "is wanted at the Hunter's Office";
2392         }
2393
2394         /*** Human corpse/skeletons (for Daemon magic) ***/
2395         if (IS_FLG(FLG_HUMAN))
2396         {
2397                 before_str[before_n++] = "humanoid";
2398                 body_str = "corpse or skeletons";
2399                 which_str[which_n++] = "can be used for Daemon magic";
2400         }
2401
2402         /*** Unique monster's corpse/skeletons/statues ***/
2403         if (IS_FLG(FLG_UNIQUE))
2404         {
2405                 before_str[before_n++] = "unique monster's";
2406                 body_str = "corpse or skeletons";
2407         }
2408
2409         /*** Unreadable spellbooks ***/
2410         if (IS_FLG(FLG_UNREADABLE))
2411         {
2412                 body_str = "spellbooks";
2413                 after_str[after_n++] = "of different realms from yours";
2414         }
2415
2416         /*** First realm spellbooks ***/
2417         if (IS_FLG(FLG_REALM1))
2418         {
2419                 body_str = "spellbooks";
2420                 after_str[after_n++] = "of your first realm";
2421         }
2422
2423         /*** Second realm spellbooks ***/
2424         if (IS_FLG(FLG_REALM2))
2425         {
2426                 body_str = "spellbooks";
2427                 after_str[after_n++] = "of your second realm";
2428         }
2429
2430         /*** First rank spellbooks ***/
2431         if (IS_FLG(FLG_FIRST))
2432         {
2433                 before_str[before_n++] = "first one of four";
2434                 body_str = "spellbooks";
2435         }
2436
2437         /*** Second rank spellbooks ***/
2438         if (IS_FLG(FLG_SECOND))
2439         {
2440                 before_str[before_n++] = "second one of four";
2441                 body_str = "spellbooks";
2442         }
2443
2444         /*** Third rank spellbooks ***/
2445         if (IS_FLG(FLG_THIRD))
2446         {
2447                 before_str[before_n++] = "third one of four";
2448                 body_str = "spellbooks";
2449         }
2450
2451         /*** Fourth rank spellbooks ***/
2452         if (IS_FLG(FLG_FOURTH))
2453         {
2454                 before_str[before_n++] = "fourth one of four";
2455                 body_str = "spellbooks";
2456         }
2457
2458         /*** Items ***/
2459         if (IS_FLG(FLG_ITEMS))
2460                 ; /* Nothing to do */
2461         else if (IS_FLG(FLG_WEAPONS))
2462                 body_str = "weapons";
2463         else if (IS_FLG(FLG_ARMORS))
2464                 body_str = "armors";
2465         else if (IS_FLG(FLG_MISSILES))
2466                 body_str = "shots, arrows or crossbow bolts";
2467         else if (IS_FLG(FLG_DEVICES))
2468                 body_str = "scrolls, wands, staves or rods";
2469         else if (IS_FLG(FLG_LIGHTS))
2470                 body_str = "light sources";
2471         else if (IS_FLG(FLG_JUNKS))
2472                 body_str = "junk such as broken sticks";
2473         else if (IS_FLG(FLG_SPELLBOOKS))
2474                 body_str = "spellbooks";
2475         else if (IS_FLG(FLG_HAFTED))
2476                 body_str = "hafted weapons";
2477         else if (IS_FLG(FLG_SHIELDS))
2478                 body_str = "shields";
2479         else if (IS_FLG(FLG_BOWS))
2480                 body_str = "slings, bows or crossbows";
2481         else if (IS_FLG(FLG_RINGS))
2482                 body_str = "rings";
2483         else if (IS_FLG(FLG_AMULETS))
2484                 body_str = "amulets";
2485         else if (IS_FLG(FLG_SUITS))
2486                 body_str = "body armors";
2487         else if (IS_FLG(FLG_CLOAKS))
2488                 body_str = "cloaks";
2489         else if (IS_FLG(FLG_HELMS))
2490                 body_str = "helms or crowns";
2491         else if (IS_FLG(FLG_GLOVES))
2492                 body_str = "gloves";
2493         else if (IS_FLG(FLG_BOOTS))
2494                 body_str = "boots";
2495         else if (IS_FLG(FLG_FAVORITE))
2496                 body_str = "favorite weapons";
2497
2498         /* Prepare a string for item name */
2499         if (*str)
2500         {
2501                 if (*str == '^')
2502                 {
2503                         str++;
2504                         top = TRUE;
2505                         whose_str[whose_n++] = "name is beginning with \"";
2506                 }
2507                 else
2508                         which_str[which_n++] = "have \"";
2509         }
2510
2511
2512         /* Describe action flag */
2513         if (act & DONT_AUTOPICK)
2514                 strcpy(buff, "Leave on floor ");
2515         else if (act & DO_AUTODESTROY)
2516                 strcpy(buff, "Destroy ");
2517         else if (act & DO_QUERY_AUTOPICK)
2518                 strcpy(buff, "Ask to pick up ");
2519         else
2520                 strcpy(buff, "Pickup ");
2521
2522         /* Auto-insctiption */
2523         if (insc)
2524         {
2525                 strncat(buff, format("and inscribe \"%s\"", insc), 80);
2526
2527                 if (strstr(insc, "%all"))
2528                         strcat(buff, ", replacing %all with code string representing all abilities,");
2529                 else if (strstr(insc, "%"))
2530                         strcat(buff, ", replacing % with code string representing extra random abilities,");
2531
2532                 strcat(buff, " on ");
2533         }
2534
2535         /* Adjective */
2536         if (!before_n)
2537                 strcat(buff, "all ");
2538         else for (i = 0; i < before_n && before_str[i]; i++)
2539         {
2540                 strcat(buff, before_str[i]);
2541                 strcat(buff, " ");
2542         }
2543
2544         /* Item class */
2545         strcat(buff, body_str);
2546
2547         /* of ... */
2548         for (i = 0; i < after_n && after_str[i]; i++)
2549         {
2550                 strcat(buff, " ");
2551                 strcat(buff, after_str[i]);
2552         }
2553
2554         /* which ... */
2555         for (i = 0; i < whose_n && whose_str[i]; i++)
2556         {
2557                 if (i == 0)
2558                         strcat(buff, " whose ");
2559                 else
2560                         strcat(buff, ", and ");
2561
2562                 strcat(buff, whose_str[i]);
2563         }
2564
2565         /* Item name ; whose name is beginning with "str" */
2566         if (*str && top)
2567         {
2568                 strcat(buff, str);
2569                 strcat(buff, "\"");
2570         }
2571
2572         /* whose ..., and which .... */
2573         if (whose_n && which_n)
2574                 strcat(buff, ", and ");
2575
2576         /* which ... */
2577         for (i = 0; i < which_n && which_str[i]; i++)
2578         {
2579                 if (i == 0)
2580                         strcat(buff, " which ");
2581                 else
2582                         strcat(buff, ", and ");
2583
2584                 strcat(buff, which_str[i]);
2585         }
2586
2587         /* Item name ; which have "str" as part of its name */
2588         if (*str && !top)
2589         {
2590                 strncat(buff, str, 80);
2591                 strcat(buff, "\" as part of its name");
2592         }
2593         strcat(buff, ".");
2594
2595         /* Describe whether it will be displayed on the full map or not */
2596         if (act & DO_DISPLAY)
2597         {
2598                 if (act & DONT_AUTOPICK)
2599                         strcat(buff, "  Display these items when you press the N key in the full 'M'ap.");
2600                 else if (act & DO_AUTODESTROY)
2601                         strcat(buff, "  Display these items when you press the K key in the full 'M'ap.");
2602                 else
2603                         strcat(buff, "  Display these items when you press the M key in the full 'M'ap.");
2604         }
2605         else
2606                 strcat(buff, " Not displayed in the full map.");
2607 #endif /* JP */
2608
2609 }
2610
2611
2612 /*
2613  * Read whole lines of a file to memory
2614  */
2615 static cptr *read_text_lines(cptr filename, bool user)
2616 {
2617         cptr *lines_list = NULL;
2618         FILE *fff;
2619
2620         int lines = 0;
2621         char buf[1024];
2622
2623         if (user)
2624         {
2625                 path_build(buf, sizeof(buf), ANGBAND_DIR_USER, filename);
2626         }
2627         else
2628         {
2629                 path_build(buf, sizeof(buf), ANGBAND_DIR_PREF, filename);
2630         }
2631
2632         /* Open the file */
2633         fff = my_fopen(buf, "r");
2634
2635         if (fff)
2636         {
2637                 /* Allocate list of pointers */
2638                 C_MAKE(lines_list, MAX_LINES, cptr);
2639
2640                 /* Parse it */
2641                 while (0 == my_fgets(fff, buf, sizeof(buf)))
2642                 {
2643                         lines_list[lines++] = string_make(buf);
2644                         if (lines >= MAX_LINES - 1) break;
2645                 }
2646                 if (lines == 0)
2647                         lines_list[0] = string_make("");
2648
2649                 my_fclose(fff);
2650         }
2651
2652         if (!fff) return NULL;
2653         return lines_list;
2654 }
2655
2656
2657 static cptr *read_pickpref_text_lines(int *filename_mode_p)
2658 {
2659         char buf[1024];
2660         cptr *lines_list;
2661
2662         *filename_mode_p = PT_WITH_PNAME;
2663         strcpy(buf, pickpref_filename(*filename_mode_p));
2664         lines_list = read_text_lines(buf, TRUE);
2665
2666         if (!lines_list)
2667         {
2668                 *filename_mode_p = PT_DEFAULT;
2669                 strcpy(buf, pickpref_filename(*filename_mode_p));
2670                 lines_list = read_text_lines(buf, TRUE);
2671         }
2672
2673         if (!lines_list)
2674         {
2675                 strcpy(buf, pickpref_filename(*filename_mode_p));
2676                 lines_list = read_text_lines(buf, FALSE);
2677         }
2678
2679         if (!lines_list)
2680         {
2681                 /* Allocate list of pointers */
2682                 C_MAKE(lines_list, MAX_LINES, cptr);
2683                 lines_list[0] = string_make("");
2684         }
2685         return lines_list;
2686 }
2687
2688
2689 /*
2690  * Write whole lines of memory to a file.
2691  */
2692 static bool write_text_lines(cptr filename, cptr *lines_list)
2693 {
2694         FILE *fff;
2695
2696         int lines = 0;
2697         char buf[1024];
2698
2699         /* Build the filename */
2700         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, filename);
2701
2702         /* Open the file */
2703         fff = my_fopen(buf, "w");
2704         if (fff)
2705         {
2706                 for (lines = 0; lines_list[lines]; lines++)
2707                         my_fputs(fff, lines_list[lines], 1024);
2708
2709                 my_fclose(fff);
2710         }
2711
2712         if (!fff) return FALSE;
2713         return TRUE;
2714 }
2715
2716
2717 /*
2718  * Free memory of lines_list.
2719  */
2720 static void free_text_lines(cptr *lines_list)
2721 {
2722         int lines;
2723
2724         for (lines = 0; lines_list[lines]; lines++)
2725                 string_free(lines_list[lines]);
2726
2727         /* free list of pointers */
2728         C_FREE((char **)lines_list, MAX_LINES, char *);
2729 }
2730
2731
2732 /*
2733  * Delete or insert string
2734  */
2735 static void toggle_keyword(text_body_type *tb, int flg)
2736 {
2737         int by1, by2, y;
2738         bool add = TRUE;
2739         bool fixed = FALSE;
2740
2741         /* Some lines are selected */
2742         if (tb->mark)
2743         {
2744                 by1 = MIN(tb->my, tb->cy);
2745                 by2 = MAX(tb->my, tb->cy);
2746         }
2747
2748         /* No mark -- Select current line */
2749         else /* if (!tb->mark) */
2750         {
2751                 by1 = by2 = tb->cy;
2752         }
2753
2754
2755         /* Set/Reset flag of each line */
2756         for (y = by1; y <= by2; y++)
2757         {
2758                 autopick_type an_entry, *entry = &an_entry;
2759
2760                 if (!autopick_new_entry(entry, tb->lines_list[y], !fixed)) continue;
2761
2762                 string_free(tb->lines_list[y]);
2763
2764                 if (!fixed)
2765                 {
2766                         /* Add? or Remove? */
2767                         if (!IS_FLG(flg)) add = TRUE;
2768                         else add = FALSE;
2769
2770                         /* No more change */
2771                         fixed = TRUE;
2772                 }
2773
2774                 /* You can use only one noun flag */
2775                 if (FLG_NOUN_BEGIN <= flg && flg <= FLG_NOUN_END)
2776                 {
2777                         int i;
2778                         for (i = FLG_NOUN_BEGIN; i <= FLG_NOUN_END; i++)
2779                                 REM_FLG(i);
2780                 }
2781
2782                 /* You can use only one identify state flag */
2783                 else if (FLG_UNAWARE <= flg && flg <= FLG_STAR_IDENTIFIED)
2784                 {
2785                         int i;
2786                         for (i = FLG_UNAWARE; i <= FLG_STAR_IDENTIFIED; i++)
2787                                 REM_FLG(i);
2788                 }
2789
2790                 /* You can use only one flag in artifact/ego/nameless */
2791                 else if (FLG_ARTIFACT <= flg && flg <= FLG_NAMELESS)
2792                 {
2793                         int i;
2794                         for (i = FLG_ARTIFACT; i <= FLG_NAMELESS; i++)
2795                                 REM_FLG(i);
2796                 }
2797
2798                 if (add) ADD_FLG(flg);
2799                 else REM_FLG(flg);
2800
2801                 tb->lines_list[y] = autopick_line_from_entry_kill(entry);
2802
2803                 /* Now dirty */
2804                 tb->dirty_flags |= DIRTY_ALL;
2805
2806                 /* Text is changed */
2807                 tb->changed = TRUE;
2808         }
2809 }
2810
2811
2812 /*
2813  * Change command letter
2814  */
2815 static void toggle_command_letter(text_body_type *tb, byte flg)
2816 {
2817         autopick_type an_entry, *entry = &an_entry;
2818         int by1, by2, y;
2819         bool add = TRUE;
2820         bool fixed = FALSE;
2821
2822         /* Some lines are selected */
2823         if (tb->mark)
2824         {
2825                 by1 = MIN(tb->my, tb->cy);
2826                 by2 = MAX(tb->my, tb->cy);
2827         }
2828
2829         /* No mark -- Select current line */
2830         else /* if (!tb->mark) */
2831         {
2832                 by1 = by2 = tb->cy;
2833         }
2834
2835
2836         /* Set/Reset flag of each line */
2837         for (y = by1; y <= by2; y++)
2838         {
2839                 int wid = 0;
2840
2841                 if (!autopick_new_entry(entry, tb->lines_list[y], FALSE)) continue;
2842
2843                 string_free(tb->lines_list[y]);
2844
2845                 if (!fixed)
2846                 {
2847                         /* Add? or Remove? */
2848                         if (!(entry->action & flg)) add = TRUE;
2849                         else add = FALSE;
2850
2851                         /* No more change */
2852                         fixed = TRUE;
2853                 }
2854
2855                 /* Count number of letter (by negative number) */
2856                 if (entry->action & DONT_AUTOPICK) wid--;
2857                 else if (entry->action & DO_AUTODESTROY) wid--;
2858                 else if (entry->action & DO_QUERY_AUTOPICK) wid--;
2859                 if (!(entry->action & DO_DISPLAY)) wid--;
2860
2861                 /* Set/Reset the flag */
2862                 if (flg != DO_DISPLAY)
2863                 {
2864                         entry->action &= ~(DO_AUTOPICK | DONT_AUTOPICK | DO_AUTODESTROY | DO_QUERY_AUTOPICK);
2865                         if (add) entry->action |= flg;
2866                         else entry->action |= DO_AUTOPICK;
2867                 }
2868                 else
2869                 {
2870                         entry->action &= ~(DO_DISPLAY);
2871                         if (add) entry->action |= flg;
2872                 }
2873
2874                 /* Correct cursor location */
2875                 if (tb->cy == y)
2876                 {
2877                         if (entry->action & DONT_AUTOPICK) wid++;
2878                         else if (entry->action & DO_AUTODESTROY) wid++;
2879                         else if (entry->action & DO_QUERY_AUTOPICK) wid++;
2880                         if (!(entry->action & DO_DISPLAY)) wid++;
2881
2882                         if (wid > 0) tb->cx++;
2883                         if (wid < 0 && tb->cx > 0) tb->cx--;
2884                 }
2885
2886                 tb->lines_list[y] = autopick_line_from_entry_kill(entry);
2887
2888                 /* Now dirty */
2889                 tb->dirty_flags |= DIRTY_ALL;
2890
2891                 /* Text is changed */
2892                 tb->changed = TRUE;
2893         }
2894 }
2895
2896 /*
2897  * Delete or insert string
2898  */
2899 static void add_keyword(text_body_type *tb, int flg)
2900 {
2901         int by1, by2, y;
2902
2903         /* Some lines are selected */
2904         if (tb->mark)
2905         {
2906                 by1 = MIN(tb->my, tb->cy);
2907                 by2 = MAX(tb->my, tb->cy);
2908         }
2909
2910         /* No mark -- Select current line */
2911         else /* if (!tb->mark) */
2912         {
2913                 by1 = by2 = tb->cy;
2914         }
2915
2916
2917         /* Set/Reset flag of each line */
2918         for (y = by1; y <= by2; y++)
2919         {
2920                 autopick_type an_entry, *entry = &an_entry;
2921
2922                 if (!autopick_new_entry(entry, tb->lines_list[y], FALSE)) continue;
2923
2924                 /* There is the flag already */
2925                 if (IS_FLG(flg))
2926                 {
2927                         /* Free memory for the entry */
2928                         autopick_free_entry(entry);
2929
2930                         continue;
2931                 }
2932
2933                 string_free(tb->lines_list[y]);
2934
2935                 /* Remove all noun flag */
2936                 if (FLG_NOUN_BEGIN <= flg && flg <= FLG_NOUN_END)
2937                 {
2938                         int i;
2939                         for (i = FLG_NOUN_BEGIN; i <= FLG_NOUN_END; i++)
2940                                 REM_FLG(i);
2941                 }
2942
2943                 ADD_FLG(flg);
2944
2945                 tb->lines_list[y] = autopick_line_from_entry_kill(entry);
2946
2947                 /* Now dirty */
2948                 tb->dirty_flags |= DIRTY_ALL;
2949
2950                 /* Text is changed */
2951                 tb->changed = TRUE;
2952         }
2953 }
2954
2955
2956 /*
2957  * Check if this line is expression or not.
2958  * And update it if it is.
2959  */
2960 static void check_expression_line(text_body_type *tb, int y)
2961 {
2962         cptr s = tb->lines_list[y];
2963
2964         if ((s[0] == '?' && s[1] == ':') ||
2965             (tb->states[y] & LSTAT_BYPASS))
2966         {
2967                 /* Expressions need re-evaluation */
2968                 tb->dirty_flags |= DIRTY_EXPRESSION;
2969         }
2970 }
2971
2972
2973 /*
2974  * Insert return code and split the line
2975  */
2976 static bool insert_return_code(text_body_type *tb)
2977 {
2978         char buf[MAX_LINELEN];
2979         int i, j, k;
2980
2981         for (k = 0; tb->lines_list[k]; k++)
2982                 /* count number of lines */ ;
2983
2984         if (k >= MAX_LINES - 2) return FALSE;
2985         k--;
2986
2987         /* Move down lines */
2988         for (; tb->cy < k; k--)
2989         {
2990                 tb->lines_list[k+1] = tb->lines_list[k];
2991                 tb->states[k+1] = tb->states[k];
2992         }
2993
2994         /* Split current line */
2995         for (i = j = 0; tb->lines_list[tb->cy][i] && i < tb->cx; i++)
2996         {
2997 #ifdef JP
2998                 if (iskanji(tb->lines_list[tb->cy][i]))
2999                         buf[j++] = tb->lines_list[tb->cy][i++];
3000 #endif
3001                 buf[j++] = tb->lines_list[tb->cy][i];
3002         }
3003         buf[j] = '\0';
3004         tb->lines_list[tb->cy+1] = string_make(&tb->lines_list[tb->cy][i]);
3005         string_free(tb->lines_list[tb->cy]);
3006         tb->lines_list[tb->cy] = string_make(buf);
3007
3008         /* Expressions need re-evaluation */
3009         tb->dirty_flags |= DIRTY_EXPRESSION;
3010
3011         /* Text is changed */
3012         tb->changed = TRUE;
3013
3014         return TRUE;
3015 }
3016
3017
3018 /*
3019  * Choose an item and get auto-picker entry from it.
3020  */
3021 static object_type *choose_object(cptr q, cptr s)
3022 {
3023         int item;
3024
3025         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR | USE_EQUIP))) return NULL;
3026
3027         /* Get the item (in the pack) */
3028         if (item >= 0) return &inventory[item];
3029
3030         /* Get the item (on the floor) */
3031         else return &o_list[0 - item];
3032 }
3033
3034
3035 /*
3036  * Choose an item and get auto-picker entry from it.
3037  */
3038 static bool entry_from_choosed_object(autopick_type *entry)
3039 {
3040         object_type *o_ptr;
3041         cptr q, s;
3042
3043         /* Get an item */
3044 #ifdef JP
3045         q = "¤É¤Î¥¢¥¤¥Æ¥à¤òÅÐÏ¿¤·¤Þ¤¹¤«? ";
3046         s = "¥¢¥¤¥Æ¥à¤ò»ý¤Ã¤Æ¤¤¤Ê¤¤¡£";
3047 #else
3048         q = "Enter which item? ";
3049         s = "You have nothing to enter.";
3050 #endif
3051         o_ptr = choose_object(q, s);
3052         if (!o_ptr) return FALSE;
3053
3054         autopick_entry_from_object(entry, o_ptr);
3055         return TRUE;
3056 }
3057
3058
3059 /*
3060  * Choose an item for search
3061  */
3062 static byte get_object_for_search(object_type **o_handle, cptr *search_strp)
3063 {
3064         char buf[MAX_NLEN+20];
3065         object_type *o_ptr;
3066         cptr q, s;
3067
3068         /* Get an item */
3069 #ifdef JP
3070         q = "¤É¤Î¥¢¥¤¥Æ¥à¤ò¸¡º÷¤·¤Þ¤¹¤«? ";
3071         s = "¥¢¥¤¥Æ¥à¤ò»ý¤Ã¤Æ¤¤¤Ê¤¤¡£";
3072 #else
3073         q = "Enter which item? ";
3074         s = "You have nothing to enter.";
3075 #endif
3076         o_ptr = choose_object(q, s);
3077         if (!o_ptr) return 0;
3078
3079         *o_handle = o_ptr;
3080
3081         string_free(*search_strp);
3082         object_desc(buf, *o_handle, FALSE, 3);
3083         *search_strp = string_make(format("<%s>", buf));
3084         return 1;
3085 }
3086
3087
3088 /*
3089  * Prepare for search by destroyed object
3090  */
3091 static byte get_destroyed_object_for_search(object_type **o_handle, cptr *search_strp)
3092 {
3093         char buf[MAX_NLEN+20];
3094
3095         if (!autopick_last_destroyed_object.k_idx) return 0;
3096
3097         *o_handle = &autopick_last_destroyed_object;
3098
3099         string_free(*search_strp);
3100         object_desc(buf, *o_handle, FALSE, 3);
3101         *search_strp = string_make(format("<%s>", buf));
3102         return 1;
3103 }
3104
3105
3106 /*
3107  * Choose an item or string for search
3108  */
3109 static byte get_string_for_search(object_type **o_handle, cptr *search_strp)
3110 {
3111         int pos = 0;
3112
3113         /*
3114          * Text color
3115          * TERM_YELLOW : Overwrite mode
3116          * TERM_WHITE : Insert mode
3117          */
3118         byte color = TERM_YELLOW;
3119         char buf[MAX_NLEN+20];
3120         const int len = 80;
3121
3122 #ifdef JP
3123         char prompt[] = "¸¡º÷(^I:»ý¤ÁÊª ^L:ÇË²õ¤µ¤ì¤¿Êª): ";
3124 #else
3125         char prompt[] = "Search key(^I:inven ^L:destroyed): ";
3126 #endif
3127         int col = sizeof(prompt) - 1;
3128
3129         if (*search_strp) strcpy(buf, *search_strp);
3130         else buf[0] = '\0';
3131
3132         /* Display prompt */
3133         prt(prompt, 0, 0);
3134
3135
3136         /* Process input */
3137         while (TRUE)
3138         {
3139                 bool back = FALSE;
3140                 int skey;
3141
3142                 /* Display the string */
3143                 Term_erase(col, 0, 255);
3144                 Term_putstr(col, 0, -1, color, buf);
3145
3146                 /* Place cursor */
3147                 Term_gotoxy(col + pos, 0);
3148
3149                 /* Get a special key code */
3150                 skey = inkey_special();
3151
3152                 /* Analyze the key */
3153                 switch (skey)
3154                 {
3155                 case SKEY_LEFT:
3156                 case KTRL('b'):
3157                 {
3158                         int i = 0;
3159
3160                         /* Now on insert mode */
3161                         color = TERM_WHITE;
3162
3163                         /* No move at beginning of line */
3164                         if (0 == pos) break;
3165
3166                         while (TRUE)
3167                         {
3168                                 int next_pos = i + 1;
3169
3170 #ifdef JP
3171                                 if (iskanji(buf[i])) next_pos++;
3172 #endif
3173
3174                                 /* Is there the cursor at next position? */
3175                                 if (next_pos >= pos) break;
3176
3177                                 /* Move to next */
3178                                 i = next_pos;
3179                         }
3180
3181                         /* Get previous position */
3182                         pos = i;
3183
3184                         break;
3185                 }
3186
3187                 case SKEY_RIGHT:
3188                 case KTRL('f'):
3189                         /* Now on insert mode */
3190                         color = TERM_WHITE;
3191
3192                         /* No move at end of line */
3193                         if ('\0' == buf[pos]) break;
3194
3195 #ifdef JP
3196                         /* Move right */
3197                         if (iskanji(buf[pos])) pos += 2;
3198                         else pos++;
3199 #else
3200                         pos++;
3201 #endif
3202
3203                         break;
3204
3205                 case ESCAPE:
3206                         return 0;
3207
3208                 case KTRL('r'):
3209                         back = TRUE;
3210                         /* Fall through */
3211
3212                 case '\n':
3213                 case '\r':
3214                 case KTRL('s'):
3215                         if (!pos && *o_handle) return (back ? -1 : 1);
3216                         string_free(*search_strp);
3217                         *search_strp = string_make(buf);
3218                         *o_handle = NULL;
3219                         return (back ? -1 : 1);
3220
3221                 case KTRL('i'):
3222                         /* Get an item */
3223                         return get_object_for_search(o_handle, search_strp);
3224
3225                 case KTRL('l'):
3226                         /* Prepare string for destroyed object if there is one. */
3227                         if (get_destroyed_object_for_search(o_handle, search_strp))
3228                                 return 1;
3229                         break;
3230
3231                 case '\010':
3232                 {
3233                         /* Backspace */
3234
3235                         int i = 0;
3236
3237                         /* Now on insert mode */
3238                         color = TERM_WHITE;
3239
3240                         /* No move at beginning of line */
3241                         if (0 == pos) break;
3242
3243                         while (TRUE)
3244                         {
3245                                 int next_pos = i + 1;
3246
3247 #ifdef JP
3248                                 if (iskanji(buf[i])) next_pos++;
3249 #endif
3250
3251                                 /* Is there the cursor at next position? */
3252                                 if (next_pos >= pos) break;
3253
3254                                 /* Move to next */
3255                                 i = next_pos;
3256                         }
3257
3258                         /* Get previous position */
3259                         pos = i;
3260
3261                         /* Fall through to 'Delete key' */
3262                 }
3263
3264                 case 0x7F:
3265                 case KTRL('d'):
3266                         /* Delete key */
3267                 {
3268                         int dst, src;
3269
3270                         /* Now on insert mode */
3271                         color = TERM_WHITE;
3272
3273                         /* No move at end of line */
3274                         if ('\0' == buf[pos]) break;
3275
3276                         /* Position of next character */
3277                         src = pos + 1;
3278
3279 #ifdef JP
3280                         /* Next character is one more byte away */
3281                         if (iskanji(buf[pos])) src++;
3282 #endif
3283
3284                         dst = pos;
3285
3286                         /* Move characters at src to dst */
3287                         while ('\0' != (buf[dst++] = buf[src++]))
3288                                 /* loop */;
3289
3290                         break;
3291                 }
3292
3293                 default:
3294                 {
3295                         /* Insert a character */
3296
3297                         char tmp[100];
3298                         char c;
3299
3300                         /* Ignore special keys */
3301                         if (skey & SKEY_MASK) break;
3302
3303                         /* Get a character code */
3304                         c = (char)skey;
3305
3306                         if (color == TERM_YELLOW)
3307                         {
3308                                 /* Overwrite default string */
3309                                 buf[0] = '\0';
3310
3311                                 /* Go to insert mode */
3312                                 color = TERM_WHITE;
3313                         }
3314
3315                         /* Save right part of string */
3316                         strcpy(tmp, buf + pos);
3317 #ifdef JP
3318                         if (iskanji(c))
3319                         {
3320                                 char next;
3321
3322                                 /* Bypass macro processing */
3323                                 inkey_base = TRUE;
3324                                 next = inkey();
3325
3326                                 if (pos + 1 < len)
3327                                 {
3328                                         buf[pos++] = c;
3329                                         buf[pos++] = next;
3330                                 }
3331                                 else
3332                                 {
3333                                         bell();
3334                                 }
3335                         }
3336                         else
3337 #endif
3338                         {
3339 #ifdef JP
3340                                 if (pos < len && (isprint(c) || iskana(c)))
3341 #else
3342                                 if (pos < len && isprint(c))
3343 #endif
3344                                 {
3345                                         buf[pos++] = c;
3346                                 }
3347                                 else
3348                                 {
3349                                         bell();
3350                                 }
3351                         }
3352
3353                         /* Terminate */
3354                         buf[pos] = '\0';
3355
3356                         /* Write back the left part of string */
3357                         my_strcat(buf, tmp, len + 1);
3358
3359                         break;
3360                 } /* default: */
3361
3362                 }
3363
3364         } /* while (TRUE) */
3365 }
3366
3367
3368 /*
3369  * Search next line matches for o_ptr
3370  */
3371 static void search_for_object(text_body_type *tb, object_type *o_ptr, bool forward)
3372 {
3373         autopick_type an_entry, *entry = &an_entry;
3374         char o_name[MAX_NLEN];
3375         int bypassed_cy = -1;
3376
3377         /* Start searching from current cursor position */
3378         int i = tb->cy;
3379
3380         /* Prepare object name string first */
3381         object_desc(o_name, o_ptr, FALSE, 3);
3382
3383         /* Convert the string to lower case */
3384         str_tolower(o_name);
3385
3386         while (TRUE)
3387         {
3388                 /* End of list? */
3389                 if (forward)
3390                 {
3391                         if (!tb->lines_list[++i]) break;
3392                 }
3393                 else
3394                 {
3395                         if (--i < 0) break;
3396                 }
3397
3398                 /* Is this line is a correct entry? */
3399                 if (!autopick_new_entry(entry, tb->lines_list[i], FALSE)) continue;
3400
3401                 /* Does this line match to the object? */
3402                 if (!is_autopick_aux(o_ptr, entry, o_name)) continue;
3403
3404
3405                 /* Found a line but it's inactive */
3406                 if (tb->states[i] & LSTAT_BYPASS)
3407                 {
3408                         /* If it is first found, remember it */
3409                         if (bypassed_cy == -1) bypassed_cy = i;
3410                 }
3411
3412                 /* Found an active line! */
3413                 else
3414                 {
3415                         /* Move to this line */
3416                         tb->cx = 0;
3417                         tb->cy = i;
3418
3419                         if (bypassed_cy != -1)
3420                         {
3421                                 /* Mark as some lines are skipped */
3422                                 tb->dirty_flags |= DIRTY_SKIP_INACTIVE;
3423                         }
3424
3425                         /* Found it! */
3426                         return;
3427                 }
3428         }
3429
3430         if (bypassed_cy != -1)
3431         {
3432                 /* Move to the remembered line */
3433                 tb->cx = 0;
3434                 tb->cy = bypassed_cy;
3435
3436                 /* Mark as this line is inactive */
3437                 tb->dirty_flags |= DIRTY_INACTIVE;
3438         }
3439
3440         else
3441         {
3442                 /* Mark as NOT FOUND */
3443                 tb->dirty_flags |= DIRTY_NOT_FOUND;
3444         }
3445
3446         return;
3447 }
3448
3449
3450 /*
3451  * Search next line matches to the string
3452  */
3453 static void search_for_string(text_body_type *tb, cptr search_str, bool forward)
3454 {
3455         int bypassed_cy = -1;
3456         int bypassed_cx = 0;
3457
3458         /* Start searching from current cursor position */
3459         int i = tb->cy;
3460
3461         while (TRUE)
3462         {
3463                 cptr pos;
3464
3465                 /* End of list? */
3466                 if (forward)
3467                 {
3468                         if (!tb->lines_list[++i]) break;
3469                 }
3470                 else
3471                 {
3472                         if (--i < 0) break;
3473                 }
3474
3475                 /* Look for the string pattern */
3476 #ifdef JP
3477                 pos = strstr_j(tb->lines_list[i], search_str);
3478 #else
3479                 pos = strstr(tb->lines_list[i], search_str);
3480 #endif
3481
3482                 /* Not found! */
3483                 if (!pos) continue;
3484
3485                 /* Found a line but it's inactive */
3486                 if ((tb->states[i] & LSTAT_BYPASS) &&
3487                     !(tb->states[i] & LSTAT_EXPRESSION))
3488                 {
3489                         /* If it is first found, remember it */
3490                         if (bypassed_cy == -1)
3491                         {
3492                                 bypassed_cy = i;
3493                                 bypassed_cx = (int)(pos - tb->lines_list[i]);
3494                         }
3495                 }
3496
3497                 /* Found an active line! */
3498                 else
3499                 {
3500                         /* Move to this location */
3501                         tb->cx = (int)(pos - tb->lines_list[i]);
3502                         tb->cy = i;
3503
3504                         if (bypassed_cy != -1)
3505                         {
3506                                 /* Mark as some lines are skipped */
3507                                 tb->dirty_flags |= DIRTY_SKIP_INACTIVE;
3508                         }
3509
3510                         /* Found it! */
3511                         return;
3512                 }
3513         }
3514
3515         if (bypassed_cy != -1)
3516         {
3517                 /* Move to the remembered line */
3518                 tb->cx = bypassed_cx;
3519                 tb->cy = bypassed_cy;
3520
3521                 /* Mark as this line is inactive */
3522                 tb->dirty_flags |= DIRTY_INACTIVE;
3523         }
3524
3525         else
3526         {
3527                 /* Mark as NOT FOUND */
3528                 tb->dirty_flags |= DIRTY_NOT_FOUND;
3529         }
3530
3531         return;
3532 }
3533
3534
3535
3536
3537 /*
3538  * Editor command id's
3539  */
3540 #define EC_QUIT                1
3541 #define EC_SAVEQUIT            2
3542 #define EC_REVERT              3
3543 #define EC_HELP                4
3544 #define EC_RETURN              5
3545 #define EC_LEFT                6
3546 #define EC_DOWN                7
3547 #define EC_UP                  8
3548 #define EC_RIGHT               9
3549 #define EC_BOL                 10
3550 #define EC_EOL                 11
3551 #define EC_PGUP                12
3552 #define EC_PGDOWN              13
3553 #define EC_TOP                 14
3554 #define EC_BOTTOM              15
3555 #define EC_CUT                 16
3556 #define EC_COPY                17
3557 #define EC_PASTE               18
3558 #define EC_BLOCK               19
3559 #define EC_KILL_LINE           20
3560 #define EC_DELETE_CHAR         21
3561 #define EC_BACKSPACE           22
3562 #define EC_SEARCH_STR          23
3563 #define EC_SEARCH_FORW         24
3564 #define EC_SEARCH_BACK         25
3565 #define EC_SEARCH_OBJ          26
3566 #define EC_SEARCH_DESTROYED    27
3567 #define EC_INSERT_OBJECT       28
3568 #define EC_INSERT_DESTROYED    29
3569 #define EC_INSERT_BLOCK        30
3570 #define EC_INSERT_MACRO        31
3571 #define EC_INSERT_KEYMAP       32
3572 #define EC_CL_AUTOPICK         33
3573 #define EC_CL_DESTROY          34
3574 #define EC_CL_LEAVE            35
3575 #define EC_CL_QUERY            36
3576 #define EC_CL_NO_DISP          37
3577 #define EC_OK_COLLECTING       38
3578 #define EC_IK_UNAWARE          39
3579 #define EC_IK_UNIDENTIFIED     40
3580 #define EC_IK_IDENTIFIED       41
3581 #define EC_IK_STAR_IDENTIFIED  42
3582 #define EC_OK_BOOSTED          43
3583 #define EC_OK_MORE_THAN        44
3584 #define EC_OK_MORE_BONUS       45
3585 #define EC_OK_WORTHLESS        46
3586 #define EC_OK_ARTIFACT         47
3587 #define EC_OK_EGO              48
3588 #define EC_OK_NAMELESS         49
3589 #define EC_OK_WANTED           50
3590 #define EC_OK_UNIQUE           51
3591 #define EC_OK_HUMAN            52
3592 #define EC_OK_UNREADABLE       53
3593 #define EC_OK_REALM1           54
3594 #define EC_OK_REALM2           55
3595 #define EC_OK_FIRST            56
3596 #define EC_OK_SECOND           57
3597 #define EC_OK_THIRD            58
3598 #define EC_OK_FOURTH           59
3599 #define EC_KK_WEAPONS          60
3600 #define EC_KK_FAVORITE         61
3601 #define EC_KK_ARMORS           62
3602 #define EC_KK_MISSILES         63
3603 #define EC_KK_DEVICES          64
3604 #define EC_KK_LIGHTS           65
3605 #define EC_KK_JUNKS            66
3606 #define EC_KK_SPELLBOOKS       67
3607 #define EC_KK_SHIELDS          68
3608 #define EC_KK_BOWS             69
3609 #define EC_KK_RINGS            70
3610 #define EC_KK_AMULETS          71
3611 #define EC_KK_SUITS            72
3612 #define EC_KK_CLOAKS           73
3613 #define EC_KK_HELMS            74
3614 #define EC_KK_GLOVES           75
3615 #define EC_KK_BOOTS            76
3616
3617
3618 /* Manu names */
3619 #ifdef JP
3620
3621 #define MN_QUIT "¥»¡¼¥ÖÌµ¤·¤Ç½ªÎ»"
3622 #define MN_SAVEQUIT "¥»¡¼¥Ö¤·¤Æ½ªÎ»"
3623 #define MN_REVERT "Á´¤Æ¤ÎÊÑ¹¹¤òÇË´þ"
3624 #define MN_HELP "¥Ø¥ë¥×"
3625
3626 #define MN_MOVE "¥«¡¼¥½¥ë°ÜÆ°"
3627 #define MN_LEFT "º¸"
3628 #define MN_DOWN "²¼"
3629 #define MN_UP "¾å"
3630 #define MN_RIGHT "±¦"
3631 #define MN_BOL "¹Ô¤ÎÀèÆ¬"
3632 #define MN_EOL "¹Ô¤Î½ªÃ¼"
3633 #define MN_PGUP "¾å¤Î¥Ú¡¼¥¸"
3634 #define MN_PGDOWN "²¼¤Î¥Ú¡¼¥¸"
3635 #define MN_TOP "1¹ÔÌÜ¤Ø°ÜÆ°"
3636 #define MN_BOTTOM "ºÇ²¼¹Ô¤Ø°ÜÆ°"
3637
3638 #define MN_EDIT "ÊÔ½¸"
3639 #define MN_CUT "¥«¥Ã¥È"
3640 #define MN_COPY "¥³¥Ô¡¼"
3641 #define MN_PASTE "¥Ú¡¼¥¹¥È"
3642 #define MN_BLOCK "ÁªÂòÈÏ°Ï¤Î»ØÄê"
3643 #define MN_KILL_LINE "¹Ô¤Î»Ä¤ê¤òºï½ü"
3644 #define MN_DELETE_CHAR "1Ê¸»úºï½ü"
3645 #define MN_BACKSPACE "¥Ð¥Ã¥¯¥¹¥Ú¡¼¥¹"
3646 #define MN_RETURN "²þ¹Ô"
3647 #define MN_RETURN "²þ¹Ô"
3648
3649 #define MN_SEARCH "¸¡º÷"
3650 #define MN_SEARCH_STR "Ê¸»úÎó¤Ç¸¡º÷"
3651 #define MN_SEARCH_FORW "Á°Êý¤ØºÆ¸¡º÷"
3652 #define MN_SEARCH_BACK "¸åÊý¤ØºÆ¸¡º÷"
3653 #define MN_SEARCH_OBJ "¥¢¥¤¥Æ¥à¤òÁªÂò¤·¤Æ¸¡º÷"
3654 #define MN_SEARCH_DESTROYED "¼«Æ°ÇË²õ¤µ¤ì¤¿¥¢¥¤¥Æ¥à¤Ç¸¡º÷"
3655
3656 #define MN_INSERT "¿§¡¹ÁÞÆþ"
3657 #define MN_INSERT_OBJECT "ÁªÂò¤·¤¿¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤òÁÞÆþ"
3658 #define MN_INSERT_DESTROYED "¼«Æ°ÇË²õ¤µ¤ì¤¿¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤òÁÞÆþ"
3659 #define MN_INSERT_BLOCK "¾ò·ïÊ¬´ô¥Ö¥í¥Ã¥¯¤ÎÎã¤òÁÞÆþ"
3660 #define MN_INSERT_MACRO "¥Þ¥¯¥íÄêµÁ¤òÁÞÆþ"
3661 #define MN_INSERT_KEYMAP "¥¡¼¥Þ¥Ã¥×ÄêµÁ¤òÁÞÆþ"
3662
3663 #ifdef MAC_MPW
3664 #define MN_COMMAND_LETTER "½¦¤¤/ÇË²õ/\x95\xfaÃÖ¤ÎÁªÂò"
3665 #else
3666 #define MN_COMMAND_LETTER "½¦¤¤/ÇË²õ/ÊüÃÖ¤ÎÁªÂò"
3667 #endif
3668 #define MN_CL_AUTOPICK "¡Ö ¡× (¼«Æ°½¦¤¤)"
3669 #define MN_CL_DESTROY "¡Ö!¡× (¼«Æ°ÇË²õ)"
3670 #ifdef MAC_MPW
3671 #define MN_CL_LEAVE "¡Ö~¡× (\x95\xfaÃÖ)"
3672 #else
3673 #define MN_CL_LEAVE "¡Ö~¡× (ÊüÃÖ)"
3674 #endif
3675 #define MN_CL_QUERY "¡Ö;¡× (³ÎÇ§¤·¤Æ½¦¤¦)"
3676 #define MN_CL_NO_DISP "¡Ö(¡× (¥Þ¥Ã¥×¥³¥Þ¥ó¥É¤ÇÉ½¼¨¤·¤Ê¤¤)"
3677
3678 #define MN_ADJECTIVE_GEN "·ÁÍÆ»ì(°ìÈÌ)¤ÎÁªÂò"
3679
3680 #define MN_ADJECTIVE_SPECIAL "·ÁÍÆ»ì(ÆÃ¼ì)¤ÎÁªÂò"
3681 #define MN_BOOSTED "¥À¥¤¥¹ÌÜ¤Î°ã¤¦ (Éð´ï)"
3682 #define MN_MORE_THAN "¥À¥¤¥¹ÌÜ # °Ê¾å¤Î (Éð´ï)"
3683 #define MN_MORE_BONUS "½¤ÀµÃÍ # °Ê¾å¤Î (»ØÎØÅù)"
3684 #define MN_ARTIFACT "¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È (ÁõÈ÷)"
3685 #define MN_EGO "¥¨¥´ (ÁõÈ÷)"
3686 #define MN_NAMELESS "ÌµÌÃ¤Î (ÁõÈ÷)"
3687 #define MN_WANTED "¾Þ¶â¼ó¤Î (»àÂÎ)"
3688 #define MN_UNIQUE "¥æ¥Ë¡¼¥¯¡¦¥â¥ó¥¹¥¿¡¼¤Î (»àÂÎ)"
3689 #define MN_HUMAN "¿Í´Ö¤Î (»àÂÎ)"
3690 #define MN_UNREADABLE "ÆÉ¤á¤Ê¤¤ (ËâË¡½ñ)"
3691 #define MN_REALM1 "Âè°ìÎÎ°è¤Î (ËâË¡½ñ)"
3692 #define MN_REALM2 "ÂèÆóÎÎ°è¤Î (ËâË¡½ñ)"
3693 #define MN_FIRST "1ºýÌÜ¤Î (ËâË¡½ñ)"
3694 #define MN_SECOND "2ºýÌÜ¤Î (ËâË¡½ñ)"
3695 #define MN_THIRD "3ºýÌÜ¤Î (ËâË¡½ñ)"
3696 #define MN_FOURTH "4ºýÌÜ¤Î (ËâË¡½ñ)"
3697
3698 #define MN_NOUN "Ì¾»ì¤ÎÁªÂò"
3699
3700 #else
3701
3702 #define MN_QUIT "Quit without save"
3703 #define MN_SAVEQUIT "Save & Quit"
3704 #define MN_REVERT "Revert all changes"
3705 #define MN_HELP "Help"
3706
3707 #define MN_MOVE "Move cursor"
3708 #define MN_LEFT "Left"
3709 #define MN_DOWN "Down"
3710 #define MN_UP "Up"
3711 #define MN_RIGHT "Right"
3712 #define MN_BOL "Beggining of line"
3713 #define MN_EOL "End of line"
3714 #define MN_PGUP "Page up"
3715 #define MN_PGDOWN "Page down"
3716 #define MN_TOP "Top"
3717 #define MN_BOTTOM "Bottom"
3718
3719 #define MN_EDIT "Edit"
3720 #define MN_CUT "Cut"
3721 #define MN_COPY "Copy"
3722 #define MN_PASTE "Paste"
3723 #define MN_BLOCK "Select block"
3724 #define MN_KILL_LINE "Kill rest of line"
3725 #define MN_DELETE_CHAR "Delete character"
3726 #define MN_BACKSPACE "Backspace"
3727 #define MN_RETURN "Return"
3728 #define MN_RETURN "Return"
3729
3730 #define MN_SEARCH "Search"
3731 #define MN_SEARCH_STR "Search by string"
3732 #define MN_SEARCH_FORW "Search forward"
3733 #define MN_SEARCH_BACK "Search backward"
3734 #define MN_SEARCH_OBJ "Search by inventory object"
3735 #define MN_SEARCH_DESTROYED "Search by destroyed object"
3736
3737 #define MN_INSERT "Insert..."
3738 #define MN_INSERT_OBJECT "Insert name of choosen object"
3739 #define MN_INSERT_DESTROYED "Insert name of destroyed object"
3740 #define MN_INSERT_BLOCK "Insert conditional block"
3741 #define MN_INSERT_MACRO "Insert a macro definition"
3742 #define MN_INSERT_KEYMAP "Insert a keymap definition"
3743
3744 #define MN_COMMAND_LETTER "Command letter"
3745 #define MN_CL_AUTOPICK "' ' (Auto pick)"
3746 #define MN_CL_DESTROY "'!' (Auto destroy)"
3747 #define MN_CL_LEAVE "'~' (Leave it on the floor)"
3748 #define MN_CL_QUERY "';' (Query to pick up)"
3749 #define MN_CL_NO_DISP "'(' (No display on the large map)"
3750
3751 #define MN_ADJECTIVE_GEN "Adjective (general)"
3752
3753 #define MN_ADJECTIVE_SPECIAL "Adjective (special)"
3754 #define MN_BOOSTED "dice boosted (weapons)"
3755 #define MN_MORE_THAN "more than # dice (weapons)"
3756 #define MN_MORE_BONUS "more bonus than # (rings etc.)"
3757 #define MN_ARTIFACT "artifact (equipments)"
3758 #define MN_EGO "ego (equipments)"
3759 #define MN_NAMELESS "nameless (equipments)"
3760 #define MN_WANTED "wanted (corpse)"
3761 #define MN_UNIQUE "unique (corpse)"
3762 #define MN_HUMAN "human (corpse)"
3763 #define MN_UNREADABLE "unreadable (spellbooks)"
3764 #define MN_REALM1 "realm1 (spellbooks)"
3765 #define MN_REALM2 "realm2 (spellbooks)"
3766 #define MN_FIRST "first (spellbooks)"
3767 #define MN_SECOND "second (spellbooks)"
3768 #define MN_THIRD "third (spellbooks)"
3769 #define MN_FOURTH "fourth (spellbooks)"
3770
3771 #define MN_NOUN "Keywords (noun)"
3772
3773 #endif
3774
3775
3776 typedef struct {
3777         cptr name;
3778         int level;
3779         int key;
3780         int com_id;
3781 } command_menu_type;
3782
3783
3784 command_menu_type menu_data[] =
3785 {
3786         {MN_HELP, 0, -1, EC_HELP},
3787         {MN_QUIT, 0, KTRL('q'), EC_QUIT},
3788         {MN_SAVEQUIT, 0, KTRL('w'), EC_SAVEQUIT},
3789         {MN_REVERT, 0, KTRL('z'), EC_REVERT},
3790
3791         {MN_EDIT, 0, -1, -1},
3792         {MN_CUT, 1, KTRL('x'), EC_CUT},
3793         {MN_COPY, 1, KTRL('c'), EC_COPY},
3794         {MN_PASTE, 1, KTRL('v'), EC_PASTE},
3795         {MN_BLOCK, 1, KTRL('g'), EC_BLOCK},
3796         {MN_KILL_LINE, 1, KTRL('k'), EC_KILL_LINE},
3797         {MN_DELETE_CHAR, 1, KTRL('d'), EC_DELETE_CHAR},
3798         {MN_BACKSPACE, 1, KTRL('h'), EC_BACKSPACE},
3799         {MN_RETURN, 1, KTRL('j'), EC_RETURN},
3800         {MN_RETURN, 1, KTRL('m'), EC_RETURN},
3801
3802         {MN_SEARCH, 0, -1, -1},
3803         {MN_SEARCH_STR, 1, KTRL('s'), EC_SEARCH_STR},
3804         {MN_SEARCH_FORW, 1, -1, EC_SEARCH_FORW},
3805         {MN_SEARCH_BACK, 1, KTRL('r'), EC_SEARCH_BACK},
3806         {MN_SEARCH_OBJ, 1, KTRL('y'), EC_SEARCH_OBJ},
3807         {MN_SEARCH_DESTROYED, 1, -1, EC_SEARCH_DESTROYED},
3808
3809         {MN_MOVE, 0, -1, -1},
3810         {MN_LEFT, 1, KTRL('b'), EC_LEFT},
3811         {MN_DOWN, 1, KTRL('n'), EC_DOWN},
3812         {MN_UP, 1, KTRL('p'), EC_UP},
3813         {MN_RIGHT, 1, KTRL('f'), EC_RIGHT},
3814         {MN_BOL, 1, KTRL('a'), EC_BOL},
3815         {MN_EOL, 1, KTRL('e'), EC_EOL},
3816         {MN_PGUP, 1, KTRL('o'), EC_PGUP},
3817         {MN_PGDOWN, 1, KTRL('l'), EC_PGDOWN},
3818         {MN_TOP, 1, KTRL('t'), EC_TOP},
3819         {MN_BOTTOM, 1, KTRL('u'), EC_BOTTOM},
3820
3821         {MN_INSERT, 0, -1, -1},
3822         {MN_INSERT_OBJECT, 1, KTRL('i'), EC_INSERT_OBJECT},
3823         {MN_INSERT_DESTROYED, 1, -1, EC_INSERT_DESTROYED},
3824         {MN_INSERT_BLOCK, 1, -1, EC_INSERT_BLOCK},
3825         {MN_INSERT_MACRO, 1, -1, EC_INSERT_MACRO},
3826         {MN_INSERT_KEYMAP, 1, -1, EC_INSERT_KEYMAP},
3827
3828         {MN_ADJECTIVE_GEN, 0, -1, -1},
3829         {KEY_UNAWARE, 1, -1, EC_IK_UNAWARE},
3830         {KEY_UNIDENTIFIED, 1, -1, EC_IK_UNIDENTIFIED},
3831         {KEY_IDENTIFIED, 1, -1, EC_IK_IDENTIFIED},
3832         {KEY_STAR_IDENTIFIED, 1, -1, EC_IK_STAR_IDENTIFIED},
3833         {KEY_COLLECTING, 1, -1, EC_OK_COLLECTING},
3834         {KEY_WORTHLESS, 1, -1, EC_OK_WORTHLESS},
3835
3836         {MN_ADJECTIVE_SPECIAL, 0, -1, -1},
3837         {MN_BOOSTED, 1, -1, EC_OK_BOOSTED},
3838         {MN_MORE_THAN, 1, -1, EC_OK_MORE_THAN},
3839         {MN_MORE_BONUS, 1, -1, EC_OK_MORE_BONUS},
3840         {MN_ARTIFACT, 1, -1, EC_OK_ARTIFACT},
3841         {MN_EGO, 1, -1, EC_OK_EGO},
3842         {MN_NAMELESS, 1, -1, EC_OK_NAMELESS},
3843         {MN_WANTED, 1, -1, EC_OK_WANTED},
3844         {MN_UNIQUE, 1, -1, EC_OK_UNIQUE},
3845         {MN_HUMAN, 1, -1, EC_OK_HUMAN},
3846         {MN_UNREADABLE, 1, -1, EC_OK_UNREADABLE},
3847         {MN_REALM1, 1, -1, EC_OK_REALM1},
3848         {MN_REALM2, 1, -1, EC_OK_REALM2},
3849         {MN_FIRST, 1, -1, EC_OK_FIRST},
3850         {MN_SECOND, 1, -1, EC_OK_SECOND},
3851         {MN_THIRD, 1, -1, EC_OK_THIRD},
3852         {MN_FOURTH, 1, -1, EC_OK_FOURTH},
3853
3854         {MN_NOUN, 0, -1, -1},
3855         {KEY_WEAPONS, 1, -1, EC_KK_WEAPONS},
3856         {KEY_FAVORITE, 1, -1, EC_KK_FAVORITE},
3857         {KEY_ARMORS, 1, -1, EC_KK_ARMORS},
3858         {KEY_MISSILES, 1, -1, EC_KK_MISSILES},
3859         {KEY_DEVICES, 1, -1, EC_KK_DEVICES},
3860         {KEY_LIGHTS, 1, -1, EC_KK_LIGHTS},
3861         {KEY_JUNKS, 1, -1, EC_KK_JUNKS},
3862         {KEY_SPELLBOOKS, 1, -1, EC_KK_SPELLBOOKS},
3863         {KEY_SHIELDS, 1, -1, EC_KK_SHIELDS},
3864         {KEY_BOWS, 1, -1, EC_KK_BOWS},
3865         {KEY_RINGS, 1, -1, EC_KK_RINGS},
3866         {KEY_AMULETS, 1, -1, EC_KK_AMULETS},
3867         {KEY_SUITS, 1, -1, EC_KK_SUITS},
3868         {KEY_CLOAKS, 1, -1, EC_KK_CLOAKS},
3869         {KEY_HELMS, 1, -1, EC_KK_HELMS},
3870         {KEY_GLOVES, 1, -1, EC_KK_GLOVES},
3871         {KEY_BOOTS, 1, -1, EC_KK_BOOTS},
3872
3873         {MN_COMMAND_LETTER, 0, -1, -1},
3874         {MN_CL_AUTOPICK, 1, -1, EC_CL_AUTOPICK},
3875         {MN_CL_DESTROY, 1, -1, EC_CL_DESTROY},
3876         {MN_CL_LEAVE, 1, -1, EC_CL_LEAVE},
3877         {MN_CL_QUERY, 1, -1, EC_CL_QUERY},
3878         {MN_CL_NO_DISP, 1, -1, EC_CL_NO_DISP},
3879
3880         {MN_DELETE_CHAR, -1, 0x7F, EC_DELETE_CHAR},
3881
3882         {NULL, -1, -1, 0}
3883 };
3884
3885
3886 /*
3887  * Find a command by 'key'.
3888  */
3889 static int get_com_id(char key)
3890 {
3891         int i;
3892
3893         for (i = 0; menu_data[i].name; i++)
3894         {
3895                 if (menu_data[i].key == key)
3896                 {
3897                         return menu_data[i].com_id;
3898                 }
3899         }
3900
3901         return 0;
3902 }
3903
3904
3905 /*
3906  * Display the menu, and get a command
3907  */
3908 static int do_command_menu(int level, int start)
3909 {
3910         int i;
3911         int max_len = 0;
3912         int max_menu_wid;
3913         int col0 = 5 + level*7;
3914         int row0 = 1 + level*3;
3915         byte menu_key = 0;
3916         int menu_id_list[26];
3917         bool redraw = TRUE;
3918         char linestr[MAX_LINELEN];
3919
3920         /* Get max length */
3921         menu_key = 0;
3922         for (i = start; menu_data[i].level >= level; i++)
3923         {
3924                 int len;
3925
3926                 /* Ignore lower level sub menus */
3927                 if (menu_data[i].level > level) continue;
3928
3929                 len = strlen(menu_data[i].name);
3930                 if (len > max_len) max_len = len;
3931
3932                 menu_id_list[menu_key] = i;
3933                 menu_key++;
3934         }
3935
3936         while (menu_key < 26)
3937         {
3938                 menu_id_list[menu_key] = -1;
3939                 menu_key++;
3940         }
3941
3942         /* Extra space for displaying menu key and command key */
3943         max_menu_wid = max_len + 3 + 3;
3944
3945         /* Prepare box line */
3946         linestr[0] = '\0';
3947         strcat(linestr, "+");
3948         for (i = 0; i < max_menu_wid + 2; i++)
3949         {
3950                 strcat(linestr, "-");
3951         }
3952         strcat(linestr, "+");
3953
3954         while (TRUE)
3955         {
3956                 int com_id;
3957                 char key;
3958                 int menu_id;
3959
3960                 if (redraw)
3961                 {
3962                         int row1 = row0 + 1;
3963
3964                         /* Draw top line */
3965                         Term_putstr(col0, row0, -1, TERM_WHITE, linestr);
3966
3967                         /* Draw menu items */
3968                         menu_key = 0;
3969                         for (i = start; menu_data[i].level >= level; i++)
3970                         {
3971                                 char com_key_str[3];
3972                                 cptr str;
3973
3974                                 /* Ignore lower level sub menus */
3975                                 if (menu_data[i].level > level) continue;
3976
3977                                 if (menu_data[i].com_id == -1)
3978                                 {
3979 #ifdef JP
3980                                         strcpy(com_key_str, "¢§");
3981 #else
3982                                         strcpy(com_key_str, ">");
3983 #endif
3984                                 }
3985                                 else if (menu_data[i].key != -1)
3986                                 {
3987                                         com_key_str[0] = '^';
3988                                         com_key_str[1] = menu_data[i].key + '@';
3989                                         com_key_str[2] = '\0';
3990                                 }
3991                                 else
3992                                 {
3993                                         com_key_str[0] = '\0';
3994                                 }
3995
3996                                 str = format("| %c) %-*s %2s | ", menu_key + 'a', max_len, menu_data[i].name, com_key_str);
3997
3998                                 Term_putstr(col0, row1++, -1, TERM_WHITE, str);
3999
4000                                 menu_key++;
4001                         }
4002
4003                         /* Draw bottom line */
4004                         Term_putstr(col0, row1, -1, TERM_WHITE, linestr);
4005
4006                         /* The menu was shown */
4007                         redraw = FALSE;
4008                 }
4009 #ifdef JP
4010                 prt(format("(a-%c) ¥³¥Þ¥ó¥É:", menu_key + 'a' - 1), 0, 0);
4011 #else
4012                 prt(format("(a-%c) Command:", menu_key + 'a' - 1), 0, 0);
4013 #endif
4014                 key = inkey();
4015
4016                 if (key == ESCAPE) return 0;
4017
4018                 if ('a' <= key && key <= 'z')
4019                 {
4020                         menu_id = menu_id_list[key - 'a'];
4021
4022                         if (menu_id >= 0)
4023                         {
4024                                 com_id = menu_data[menu_id].com_id;
4025
4026                                 if (com_id == -1)
4027                                 {
4028                                         com_id = do_command_menu(level + 1, menu_id + 1);
4029
4030                                         if (com_id) return com_id;
4031                                         else redraw = TRUE;
4032                                 }
4033                                 else if (com_id)
4034                                 {
4035                                         return com_id;
4036                                 }
4037                         }
4038                 }
4039
4040                 else
4041                 {
4042                         com_id = get_com_id(key);
4043                         if (com_id) return com_id;
4044                         else continue;
4045                 }
4046         }
4047 }
4048
4049
4050 static chain_str_type *new_chain_str(cptr str)
4051 {
4052         chain_str_type *chain;
4053
4054         size_t len = strlen(str);
4055
4056         chain = (chain_str_type *)ralloc(sizeof(chain_str_type) + len * sizeof(char));
4057
4058         strcpy(chain->s, str);
4059         chain->next = NULL;
4060
4061         return chain;
4062 }
4063
4064
4065 static void kill_yank_chain(text_body_type *tb)
4066 {
4067         chain_str_type *chain = tb->yank;
4068         tb->yank = NULL;
4069         tb->yank_eol = TRUE;
4070
4071         while (chain)
4072         {
4073                 chain_str_type *next = chain->next;
4074                 size_t len = strlen(chain->s);
4075
4076                 rnfree(chain, sizeof(chain_str_type) + len * sizeof(char));
4077
4078                 chain = next;
4079         }
4080 }
4081
4082
4083 static void add_str_to_yank(text_body_type *tb, cptr str)
4084 {
4085         chain_str_type *chain;
4086
4087         tb->yank_eol = FALSE;
4088
4089         if (NULL == tb->yank)
4090         {
4091                 tb->yank = new_chain_str(str);
4092                 return;
4093         }
4094
4095         chain = tb->yank;
4096
4097         while (TRUE)
4098         {
4099                 if (!chain->next)
4100                 {
4101                         chain->next = new_chain_str(str);
4102                         return;
4103                 }
4104
4105                 /* Go to next */
4106                 chain = chain->next;
4107         }
4108 }
4109
4110
4111 #define DESCRIPT_HGT 3
4112
4113 /*
4114  * Draw text
4115  */
4116 static void draw_text_editor(text_body_type *tb)
4117 {
4118         int i;
4119         int by1 = 0, by2 = 0;
4120
4121         /* Get size */
4122         Term_get_size(&tb->wid, &tb->hgt);
4123
4124         /*
4125          * Top line (-1), description line (-3), separator (-1)
4126          *  == -5
4127          */
4128         tb->hgt -= 2 + DESCRIPT_HGT;
4129
4130 #ifdef JP
4131         /* Don't let cursor at second byte of kanji */
4132         for (i = 0; tb->lines_list[tb->cy][i]; i++)
4133                 if (iskanji(tb->lines_list[tb->cy][i]))
4134                 {
4135                         i++;
4136                         if (i == tb->cx)
4137                         {
4138                                 tb->cx--;
4139                                 break;
4140                         }
4141                 }
4142 #endif
4143
4144         /* Scroll if necessary */
4145         if (tb->cy < tb->upper || tb->upper + tb->hgt <= tb->cy)
4146                 tb->upper = tb->cy - (tb->hgt)/2;
4147         if (tb->upper < 0)
4148                 tb->upper = 0;
4149         if ((tb->cx < tb->left + 10 && tb->left > 0) || tb->left + tb->wid - 5 <= tb->cx)
4150                 tb->left = tb->cx - (tb->wid)*2/3;
4151         if (tb->left < 0)
4152                 tb->left = 0;
4153
4154         /* Redraw whole window after resize */
4155         if (tb->old_wid != tb->wid || tb->old_hgt != tb->hgt)
4156                 tb->dirty_flags |= DIRTY_SCREEN;
4157
4158         /* Redraw all text after scroll */
4159         else if (tb->old_upper != tb->upper || tb->old_left != tb->left)
4160                 tb->dirty_flags |= DIRTY_ALL;
4161
4162
4163         if (tb->dirty_flags & DIRTY_SCREEN)
4164         {
4165                 tb->dirty_flags |= (DIRTY_ALL | DIRTY_MODE);
4166
4167                 /* Clear screen */
4168                 Term_clear();
4169         }
4170
4171         /* Redraw mode line */
4172         if (tb->dirty_flags & DIRTY_MODE)
4173         {
4174                 char buf[MAX_LINELEN];
4175
4176                 int sepa_length = tb->wid;
4177
4178                 /* Separator */
4179                 for (i = 0; i < sepa_length; i++)
4180                         buf[i] = '-';
4181                 buf[i] = '\0';
4182
4183                 Term_putstr(0, tb->hgt + 1, sepa_length, TERM_WHITE, buf);
4184         }
4185
4186         if (tb->dirty_flags & DIRTY_EXPRESSION)
4187         {
4188                 int y;
4189                 byte state = 0;
4190
4191                 for (y = 0; tb->lines_list[y]; y++)
4192                 {
4193                         char f;
4194                         cptr v;
4195                         cptr s = tb->lines_list[y];
4196
4197                         /* Update this line's state */
4198                         tb->states[y] = state;
4199
4200                         if (*s++ != '?') continue;
4201                         if (*s++ != ':') continue;
4202
4203                         /* Lines below this line are auto-registered */
4204                         if (streq(s, "$AUTOREGISTER"))
4205                                 state |= LSTAT_AUTOREGISTER;
4206
4207                         /* Parse the expr */
4208                         v = process_pref_file_expr(&s, &f);
4209
4210                         /* Set flag */
4211                         if (streq(v, "0")) state |= LSTAT_BYPASS;
4212                         else state &= ~LSTAT_BYPASS;
4213
4214                         /* Re-update this line's state */
4215                         tb->states[y] = state | LSTAT_EXPRESSION;
4216                 }
4217
4218                 tb->dirty_flags |= DIRTY_ALL;
4219         }
4220
4221         if (tb->mark)
4222         {
4223                 int tmp_cx = tb->cx;
4224                 int len = strlen(tb->lines_list[tb->cy]);
4225
4226                 /* Correct cursor location */
4227                 if (tb->cx > len) tmp_cx = len;
4228
4229                 tb->dirty_flags |= DIRTY_ALL;
4230
4231                 by1 = MIN(tb->my, tb->cy);
4232                 by2 = MAX(tb->my, tb->cy);
4233         }
4234
4235         /* Dump up to tb->hgt lines of messages */
4236         for (i = 0; i < tb->hgt; i++)
4237         {
4238                 int j;
4239                 int leftcol = 0;
4240                 cptr msg;
4241                 byte color;
4242                 int y = tb->upper+i;
4243
4244                 /* clean or dirty? */
4245                 if (!(tb->dirty_flags & DIRTY_ALL) && (tb->dirty_line != y))
4246                         continue;
4247
4248                 msg = tb->lines_list[y];
4249                 if (!msg) break;
4250
4251                 /* Apply horizontal scroll */
4252                 for (j = 0; *msg; msg++, j++)
4253                 {
4254                         if (j == tb->left) break;
4255 #ifdef JP
4256                         if (j > tb->left)
4257                         {
4258                                 leftcol = 1;
4259                                 break;
4260                         }
4261                         if (iskanji(*msg))
4262                         {
4263                                 msg++;
4264                                 j++;
4265                         }
4266 #endif
4267                 }
4268
4269                 /* Erase line */
4270                 Term_erase(0, i + 1, tb->wid);
4271
4272                 if (tb->states[y] & LSTAT_AUTOREGISTER)
4273                 {
4274                         /* Warning color -- These lines will be deleted later */
4275                         color = TERM_L_RED;
4276                 }
4277                 else
4278                 {
4279                         /* Bypassed line will be displayed by darker color */
4280                         if (tb->states[y] & LSTAT_BYPASS) color = TERM_SLATE;
4281                         else color = TERM_WHITE;
4282                 }
4283
4284                 /* No mark or Out of mark */
4285                 if (!tb->mark || (y < by1 || by2 < y))
4286                 {
4287                         /* Dump the messages, bottom to top */
4288                         Term_putstr(leftcol, i + 1, tb->wid - 1, color, msg);
4289                 }
4290
4291                 /* Multiple lines selected */
4292                 else if (by1 != by2)
4293                 {
4294                         /* Dump the messages, bottom to top */
4295                         Term_putstr(leftcol, i + 1, tb->wid - 1, TERM_YELLOW, msg);
4296                 }
4297
4298                 /* Single line selected */
4299                 else
4300                 {
4301                         int x0 = leftcol + tb->left;
4302                         int len = strlen(tb->lines_list[tb->cy]);
4303                         int bx1 = MIN(tb->mx, tb->cx);
4304                         int bx2 = MAX(tb->mx, tb->cx);
4305
4306                         /* Correct cursor location */
4307                         if (bx2 > len) bx2 = len;
4308
4309                         Term_gotoxy(leftcol, i + 1);
4310                         if (x0 < bx1) Term_addstr(bx1 - x0, color, msg);
4311                         if (x0 < bx2) Term_addstr(bx2 - bx1, TERM_YELLOW, msg + (bx1 - x0));
4312                         Term_addstr(-1, color, msg + (bx2 - x0));
4313                 }
4314         }
4315
4316         for (; i < tb->hgt; i++)
4317         {
4318                 /* Erase line */
4319                 Term_erase(0, i + 1, tb->wid);
4320         }
4321
4322         /* Display information when updated */
4323         if (tb->old_cy != tb->cy || (tb->dirty_flags & (DIRTY_ALL | DIRTY_NOT_FOUND | DIRTY_NO_SEARCH)) || tb->dirty_line == tb->cy)
4324         {
4325                 autopick_type an_entry, *entry = &an_entry;
4326                 cptr str1 = NULL, str2 = NULL;
4327
4328
4329                 /* Clear information line */
4330                 for (i = 0; i < DESCRIPT_HGT; i++)
4331                 {
4332                         /* Erase line */
4333                         Term_erase(0, tb->hgt + 2 + i, tb->wid);
4334                 }
4335
4336                 /* Display information */
4337                 if (tb->dirty_flags & DIRTY_NOT_FOUND)
4338                 {
4339 #ifdef JP
4340                         str1 = format("¥Ñ¥¿¡¼¥ó¤¬¸«¤Ä¤«¤ê¤Þ¤»¤ó: %s", tb->search_str);
4341 #else
4342                         str1 = format("Pattern not found: %s", tb->search_str);
4343 #endif
4344                 }
4345                 else if (tb->dirty_flags & DIRTY_SKIP_INACTIVE)
4346                 {
4347 #ifdef JP
4348                         str1 = format("Ìµ¸ú¾õÂÖ¤Î¹Ô¤ò¥¹¥¥Ã¥×¤·¤Þ¤·¤¿¡£(%s¤ò¸¡º÷Ãæ)", tb->search_str);
4349 #else
4350                         str1 = format("Some inactive lines are skipped. (Searching %s)", tb->search_str);
4351 #endif
4352                 }
4353                 else if (tb->dirty_flags & DIRTY_INACTIVE)
4354                 {
4355 #ifdef JP
4356                         str1 = format("Ìµ¸ú¾õÂÖ¤Î¹Ô¤À¤±¤¬¸«ÉÕ¤«¤ê¤Þ¤·¤¿¡£(%s¤ò¸¡º÷Ãæ)", tb->search_str);
4357 #else
4358                         str1 = format("Found only an inactive line. (Searching %s)", tb->search_str);
4359 #endif
4360                 }
4361                 else if (tb->dirty_flags & DIRTY_NO_SEARCH)
4362                 {
4363 #ifdef JP
4364                         str1 = "¸¡º÷¤¹¤ë¥Ñ¥¿¡¼¥ó¤¬¤¢¤ê¤Þ¤»¤ó(^S ¤Ç¸¡º÷)¡£";
4365 #else
4366                         str1 = "No pattern to search. (Press ^S to search.)";
4367 #endif
4368                 }
4369                 else if (tb->lines_list[tb->cy][0] == '#')
4370                 {
4371 #ifdef JP
4372                         str1 = "¤³¤Î¹Ô¤Ï¥³¥á¥ó¥È¤Ç¤¹¡£";
4373 #else
4374                         str1 = "This line is a comment.";
4375 #endif
4376                 }
4377                 else if (tb->lines_list[tb->cy][1] == ':')
4378                 {
4379                         switch(tb->lines_list[tb->cy][0])
4380                         {
4381                         case '?':
4382 #ifdef JP
4383                                 str1 = "¤³¤Î¹Ô¤Ï¾ò·ïÊ¬´ô¼°¤Ç¤¹¡£";
4384 #else
4385                                 str1 = "This line is a Conditional Expression.";
4386 #endif
4387
4388                                 break;
4389                         case 'A':
4390 #ifdef JP
4391                                 str1 = "¤³¤Î¹Ô¤Ï¥Þ¥¯¥í¤Î¼Â¹ÔÆâÍÆ¤òÄêµÁ¤·¤Þ¤¹¡£";
4392 #else
4393                                 str1 = "This line defines a Macro action.";
4394 #endif
4395                                 break;
4396                         case 'P':
4397 #ifdef JP
4398                                 str1 = "¤³¤Î¹Ô¤Ï¥Þ¥¯¥í¤Î¥È¥ê¥¬¡¼¡¦¥¡¼¤òÄêµÁ¤·¤Þ¤¹¡£";
4399 #else
4400                                 str1 = "This line defines a Macro trigger key.";
4401 #endif
4402                                 break;
4403                         case 'C':
4404 #ifdef JP
4405                                 str1 = "¤³¤Î¹Ô¤Ï¥¡¼ÇÛÃÖ¤òÄêµÁ¤·¤Þ¤¹¡£";
4406 #else
4407                                 str1 = "This line defines a Keymap.";
4408 #endif
4409                                 break;
4410                         }
4411
4412                         switch(tb->lines_list[tb->cy][0])
4413                         {
4414                         case '?':
4415                                 if (tb->states[tb->cy] & LSTAT_BYPASS)
4416                                 {
4417 #ifdef JP
4418                                         str2 = "¸½ºß¤Î¼°¤ÎÃÍ¤Ï¡Öµ¶(=0)¡×¤Ç¤¹¡£";
4419 #else
4420                                         str2 = "The expression is 'False'(=0) currently.";
4421 #endif
4422                                 }
4423                                 else
4424                                 {
4425 #ifdef JP
4426                                         str2 = "¸½ºß¤Î¼°¤ÎÃÍ¤Ï¡Ö¿¿(=1)¡×¤Ç¤¹¡£";
4427 #else
4428                                         str2 = "The expression is 'True'(=1) currently.";
4429 #endif
4430                                 }
4431                                 break;
4432
4433                         default:
4434                                 if (tb->states[tb->cy] & LSTAT_AUTOREGISTER)
4435                                 {
4436 #ifdef JP
4437                                         str2 = "¤³¤Î¹Ô¤Ï¸å¤Çºï½ü¤µ¤ì¤Þ¤¹¡£";
4438 #else
4439                                         str2 = "This line will be delete later.";
4440 #endif
4441                                 }
4442
4443                                 else if (tb->states[tb->cy] & LSTAT_BYPASS)
4444                                 {
4445 #ifdef JP
4446                                         str2 = "¤³¤Î¹Ô¤Ï¸½ºß¤ÏÌµ¸ú¤Ê¾õÂÖ¤Ç¤¹¡£";
4447 #else
4448                                         str2 = "This line is bypassed currently.";
4449 #endif
4450                                 }
4451                                 break;
4452                         }
4453                 }
4454
4455                 /* Get description of an autopicker preference line */
4456                 else if (autopick_new_entry(entry, tb->lines_list[tb->cy], FALSE))
4457                 {
4458                         char buf[MAX_LINELEN];
4459                         char temp[MAX_LINELEN];
4460                         cptr t;
4461
4462                         describe_autopick(buf, entry);
4463
4464                         if (tb->states[tb->cy] & LSTAT_AUTOREGISTER)
4465                         {
4466 #ifdef JP
4467                                 strcat(buf, "¤³¤Î¹Ô¤Ï¸å¤Çºï½ü¤µ¤ì¤Þ¤¹¡£");
4468 #else
4469                                 strcat(buf, "  This line will be delete later.");
4470 #endif
4471                         }
4472
4473                         if (tb->states[tb->cy] & LSTAT_BYPASS)
4474                         {
4475 #ifdef JP
4476                                 strcat(buf, "¤³¤Î¹Ô¤Ï¸½ºß¤ÏÌµ¸ú¤Ê¾õÂÖ¤Ç¤¹¡£");
4477 #else
4478                                 strcat(buf, "  This line is bypassed currently.");
4479 #endif
4480                         }
4481
4482                         roff_to_buf(buf, 81, temp, sizeof(temp));
4483                         t = temp;
4484                         for (i = 0; i < 3; i++)
4485                         {
4486                                 if(t[0] == 0)
4487                                         break;
4488                                 else
4489                                 {
4490                                         prt(t, tb->hgt +1 + 1 + i, 0);
4491                                         t += strlen(t) + 1;
4492                                 }
4493                         }
4494                         autopick_free_entry(entry);
4495                 }
4496
4497                 /* Draw the first line */
4498                 if (str1) prt(str1, tb->hgt +1 + 1, 0);
4499
4500                 /* Draw the second line */
4501                 if (str2) prt(str2, tb->hgt +1 + 2, 0);
4502         }
4503 }
4504
4505
4506 /*
4507  * Kill segment of a line
4508  */
4509 static void kill_line_segment(text_body_type *tb, int y, int x0, int x1, bool whole)
4510 {
4511         char buf[MAX_LINELEN];
4512         cptr s = tb->lines_list[y];
4513         char *d = buf;
4514         int x;
4515
4516         /* Kill whole line? */
4517         if (whole && x0 == 0 && s[x1] == '\0' && tb->lines_list[y+1])
4518         {
4519                 int i;
4520
4521                 string_free(tb->lines_list[y]);
4522
4523                 /* Shift lines up */
4524                 for (i = y; tb->lines_list[i+1]; i++)
4525                         tb->lines_list[i] = tb->lines_list[i+1];
4526                 tb->lines_list[i] = NULL;
4527
4528                 /* Expressions need re-evaluation */
4529                 tb->dirty_flags |= DIRTY_EXPRESSION;
4530
4531                 return;
4532         }
4533
4534         /* No segment? */
4535         if (x0 == x1) return;
4536
4537         /* Before the segment */
4538         for (x = 0; x < x0; x++)
4539                 *(d++) = s[x];
4540
4541         /* After the segment */
4542         for (x = x1; s[x]; x++)
4543                 *(d++) = s[x];
4544
4545         *d = '\0';
4546
4547         /* Replace */
4548         string_free(tb->lines_list[y]);
4549         tb->lines_list[y] = string_make(buf);
4550
4551         /* Expressions may need re-evaluation */
4552         check_expression_line(tb, y);
4553
4554         /* Text is changed */
4555         tb->changed = TRUE;
4556 }
4557
4558
4559 /*
4560  * Get a trigger key and insert ASCII string for the trigger
4561  */
4562 static bool insert_macro_line(text_body_type *tb)
4563 {
4564         char tmp[1024];
4565         char buf[1024];
4566         int i, n = 0;
4567
4568         /* Flush */
4569         flush();
4570
4571         /* Do not process macros */
4572         inkey_base = TRUE;
4573
4574         /* First key */
4575         i = inkey();
4576
4577         /* Read the pattern */
4578         while (i)
4579         {
4580                 /* Save the key */
4581                 buf[n++] = i;
4582
4583                 /* Do not process macros */
4584                 inkey_base = TRUE;
4585
4586                 /* Do not wait for keys */
4587                 inkey_scan = TRUE;
4588
4589                 /* Attempt to read a key */
4590                 i = inkey();
4591         }
4592
4593         /* Terminate */
4594         buf[n] = '\0';
4595
4596         /* Flush */
4597         flush();
4598
4599         /* Convert the trigger */
4600         ascii_to_text(tmp, buf);
4601
4602         /* Null */
4603         if(!tmp[0]) return FALSE;
4604
4605         tb->cx = 0;
4606
4607         /* Insert preference string */
4608         insert_return_code(tb);
4609         string_free(tb->lines_list[tb->cy]);
4610         tb->lines_list[tb->cy] = string_make(format("P:%s", tmp));
4611
4612         /* Acquire action */
4613         i = macro_find_exact(buf);
4614
4615         if (i == -1)
4616         {
4617                 /* Nothing defined */
4618                 tmp[0] = '\0';
4619         }
4620         else
4621         {
4622                 /* Analyze the current action */
4623                 ascii_to_text(tmp, macro__act[i]);
4624         }
4625
4626         /* Insert blank action preference line */
4627         insert_return_code(tb);
4628         string_free(tb->lines_list[tb->cy]);
4629         tb->lines_list[tb->cy] = string_make(format("A:%s", tmp));
4630
4631         return TRUE;
4632 }
4633
4634
4635 /*
4636  * Get a command key and insert ASCII string for the key
4637  */
4638 static bool insert_keymap_line(text_body_type *tb)
4639 {
4640         char tmp[1024];
4641         char buf[2];
4642         int mode;
4643         cptr act;
4644
4645         /* Roguelike */
4646         if (rogue_like_commands)
4647         {
4648                 mode = KEYMAP_MODE_ROGUE;
4649         }
4650
4651         /* Original */
4652         else
4653         {
4654                 mode = KEYMAP_MODE_ORIG;
4655         }
4656
4657         /* Flush */
4658         flush();
4659
4660         /* Get a key */
4661         buf[0] = inkey();
4662         buf[1] = '\0';
4663
4664         /* Flush */
4665         flush();
4666
4667         /* Convert the trigger */
4668         ascii_to_text(tmp, buf);
4669
4670         /* Null */
4671         if(!tmp[0]) return FALSE;
4672
4673         tb->cx = 0;
4674
4675         /* Insert preference string */
4676         insert_return_code(tb);
4677         string_free(tb->lines_list[tb->cy]);
4678         tb->lines_list[tb->cy] = string_make(format("C:%d:%s", mode, tmp));
4679
4680         /* Look up the keymap */
4681         act = keymap_act[mode][(byte)(buf[0])];
4682
4683         /* Insert blank action preference line */
4684         insert_return_code(tb);
4685         string_free(tb->lines_list[tb->cy]);
4686         tb->lines_list[tb->cy] = string_make(format("A:%s", act));
4687
4688         return TRUE;
4689 }
4690
4691
4692 /*
4693  * Execute a single editor command
4694  */
4695 static bool do_editor_command(text_body_type *tb, int com_id)
4696 {
4697         switch(com_id)
4698         {
4699         case EC_QUIT:
4700                 if (tb->changed)
4701                 {
4702 #ifdef JP
4703                         if (!get_check("Á´¤Æ¤ÎÊÑ¹¹¤òÇË´þ¤·¤Æ¤«¤é½ªÎ»¤·¤Þ¤¹¡£¤è¤í¤·¤¤¤Ç¤¹¤«¡© ")) break;
4704 #else
4705                         if (!get_check("Discard all changes and quit. Are you sure? ")) break;
4706 #endif
4707                 }
4708                 return QUIT_WITHOUT_SAVE;
4709
4710         case EC_SAVEQUIT:
4711                 return QUIT_AND_SAVE;
4712
4713         case EC_REVERT:
4714                 /* Revert to original */
4715 #ifdef JP
4716                 if (!get_check("Á´¤Æ¤ÎÊÑ¹¹¤òÇË´þ¤·¤Æ¸µ¤Î¾õÂÖ¤ËÌá¤·¤Þ¤¹¡£¤è¤í¤·¤¤¤Ç¤¹¤«¡© ")) break;
4717 #else
4718                 if (!get_check("Discard all changes and revert to original file. Are you sure? ")) break;
4719 #endif
4720
4721                 free_text_lines(tb->lines_list);
4722                 tb->lines_list = read_pickpref_text_lines(&tb->filename_mode);
4723                 tb->dirty_flags |= DIRTY_ALL | DIRTY_MODE | DIRTY_EXPRESSION;
4724                 tb->cx = tb->cy = 0;
4725                 tb->mark = 0;
4726
4727                 /* Text is not changed */
4728                 tb->changed = FALSE;
4729                 break;
4730
4731         case EC_HELP:
4732                 /* Peruse the main help file */
4733 #ifdef JP
4734                 (void)show_file(TRUE, "jeditor.txt", NULL, 0, 0);
4735 #else
4736                 (void)show_file(TRUE, "editor.txt", NULL, 0, 0);
4737 #endif
4738                 /* Redraw all */
4739                 tb->dirty_flags |= DIRTY_SCREEN;
4740
4741                 break;
4742
4743         case EC_RETURN:
4744                 /* Split a line or insert end of line */
4745
4746                 /* Ignore selection */
4747                 if (tb->mark)
4748                 {
4749                         tb->mark = 0;
4750
4751                         /* Now dirty */
4752                         tb->dirty_flags |= DIRTY_ALL;
4753                 }
4754
4755                 insert_return_code(tb);
4756                 tb->cy++;
4757                 tb->cx = 0;
4758
4759                 /* Now dirty */
4760                 tb->dirty_flags |= DIRTY_ALL;
4761                 break;
4762
4763         case EC_LEFT:
4764                 /* Back */
4765                 if (0 < tb->cx)
4766                 {
4767                         int len;
4768
4769                         tb->cx--;
4770                         len = strlen(tb->lines_list[tb->cy]);
4771                         if (len < tb->cx) tb->cx = len;
4772                 }
4773                 else if (tb->cy > 0)
4774                 {
4775                         tb->cy--;
4776                         tb->cx = strlen(tb->lines_list[tb->cy]);
4777                 }
4778                 break;
4779
4780         case EC_DOWN:
4781                 /* Next line */
4782                 if (tb->lines_list[tb->cy + 1]) tb->cy++;
4783                 break;
4784
4785         case EC_UP:
4786                 /* Previous line */
4787                 if (tb->cy > 0) tb->cy--;
4788                 break;
4789
4790         case EC_RIGHT:
4791         {
4792                 /* Forward */
4793
4794                 int len;
4795 #ifdef JP
4796                 if (iskanji(tb->lines_list[tb->cy][tb->cx])) tb->cx++;
4797 #endif
4798                 tb->cx++;
4799                 len = strlen(tb->lines_list[tb->cy]);
4800                 if (len < tb->cx)
4801                 {
4802                         if (tb->lines_list[tb->cy + 1])
4803                         {
4804                                 tb->cy++;
4805                                 tb->cx = 0;
4806                         }
4807                         else
4808                                 tb->cx = len;
4809                 }
4810                 break;
4811         }
4812
4813         case EC_BOL:
4814                 /* Beginning of line */
4815                 tb->cx = 0;
4816                 break;
4817
4818         case EC_EOL:
4819                 /* End of line */
4820                 tb->cx = strlen(tb->lines_list[tb->cy]);
4821                 break;
4822
4823         case EC_PGUP:
4824                 while (0 < tb->cy && tb->upper <= tb->cy)
4825                         tb->cy--;
4826                 while (0 < tb->upper && tb->cy + 1 < tb->upper + tb->hgt)
4827                         tb->upper--;
4828                 break;
4829
4830         case EC_PGDOWN:
4831                 /* Page down */
4832                 while (tb->cy < tb->upper + tb->hgt && tb->lines_list[tb->cy + 1])
4833                         tb->cy++;
4834                 tb->upper = tb->cy;
4835                 break;
4836
4837         case EC_TOP:
4838                 tb->cy = 0;
4839                 break;
4840
4841         case EC_BOTTOM:
4842                 while (tb->lines_list[tb->cy + 1])
4843                         tb->cy++;
4844                 break;
4845
4846         case EC_CUT:
4847         {
4848                 /* Copy the text first */
4849                 do_editor_command(tb, EC_COPY);
4850
4851                 /* Single line case */
4852                 if (tb->my == tb->cy)
4853                 {
4854                         int bx1 = MIN(tb->mx, tb->cx);
4855                         int bx2 = MAX(tb->mx, tb->cx);
4856                         int len = strlen(tb->lines_list[tb->cy]);
4857
4858                         /* Correct fake cursor position */
4859                         if (bx2 > len) bx2 = len;
4860
4861                         kill_line_segment(tb, tb->cy, bx1, bx2, TRUE);
4862
4863                         /* New cursor position */
4864                         tb->cx = bx1;
4865                 }
4866
4867                 /* Multiple lines case */
4868                 else /* if (tb->my != tb->cy) */
4869                 {
4870                         int y;
4871
4872                         int by1 = MIN(tb->my, tb->cy);
4873                         int by2 = MAX(tb->my, tb->cy);
4874
4875                         /* Kill lines in reverse order */
4876                         for (y = by2; y >= by1; y--)
4877                         {
4878                                 int len = strlen(tb->lines_list[y]);
4879
4880                                 kill_line_segment(tb, y, 0, len, TRUE);
4881                         }
4882
4883                         /* New cursor position */
4884                         tb->cy = by1;
4885                         tb->cx = 0;
4886                 }
4887
4888
4889                 /* Disable selection */
4890                 tb->mark = 0;
4891
4892                 /* Now dirty */
4893                 tb->dirty_flags |= DIRTY_ALL;
4894
4895                 break;
4896         }
4897
4898         case EC_COPY:
4899         {
4900                 int len = strlen(tb->lines_list[tb->cy]);
4901
4902                 /* Correct cursor location */
4903                 if (tb->cx > len) tb->cx = len;
4904
4905                 /* Use single line? */
4906                 if (!tb->mark)
4907                 {
4908                         /* Select a single line */
4909                         tb->cx = 0;
4910                         tb->my = tb->cy;
4911                         tb->mx = len;
4912                 }
4913
4914                 /* Kill old yank buffer */
4915                 kill_yank_chain(tb);
4916
4917
4918                 /* Single line case */
4919                 if (tb->my == tb->cy)
4920                 {
4921                         int i;
4922                         char buf[MAX_LINELEN];
4923                         int bx1 = MIN(tb->mx, tb->cx);
4924                         int bx2 = MAX(tb->mx, tb->cx);
4925
4926                         /* Correct fake cursor position */
4927                         if (bx2 > len) bx2 = len;
4928
4929                         /* Whole part of this line is selected */
4930                         if (bx1 == 0 && bx2 == len)
4931                         {
4932                                 /* Copy this line */
4933                                 add_str_to_yank(tb, tb->lines_list[tb->cy]);
4934
4935                                 /* Add end of line to the buffer */
4936                                 add_str_to_yank(tb, "");
4937                         }
4938
4939                         /* Segment of this line is selected */
4940                         else
4941                         {
4942                                 for (i = 0; i < bx2 - bx1; i++)
4943                                 {
4944                                         buf[i] = tb->lines_list[tb->cy][bx1 + i];
4945                                 }
4946                                 buf[i] = '\0';
4947
4948                                 /* Copy this segment of line */
4949                                 add_str_to_yank(tb, buf);
4950                         }
4951                 }
4952
4953                 /* Multiple lines case */
4954                 else /* if (tb->my != tb->cy) */
4955                 {
4956                         int y;
4957
4958                         int by1 = MIN(tb->my, tb->cy);
4959                         int by2 = MAX(tb->my, tb->cy);
4960
4961                         /* Copy lines */
4962                         for (y = by1; y <= by2; y++)
4963                         {
4964                                 /* Copy this line */
4965                                 add_str_to_yank(tb, tb->lines_list[y]);
4966                         }
4967
4968                         /* Add final end of line to the buffer */
4969                         add_str_to_yank(tb, "");
4970                 }
4971
4972                 /* Disable selection */
4973                 tb->mark = 0;
4974
4975                 /* Now dirty */
4976                 tb->dirty_flags |= DIRTY_ALL;
4977                 break;
4978         }
4979
4980         case EC_PASTE:
4981         {
4982                 /* Paste killed text */
4983
4984                 chain_str_type *chain = tb->yank;
4985                 int len = strlen(tb->lines_list[tb->cy]);
4986
4987                 /* Nothing to do? */
4988                 if (!chain) break;
4989
4990                 /* Correct cursor location */
4991                 if (tb->cx > len) tb->cx = len;
4992
4993                 /* Ignore selection */
4994                 if (tb->mark)
4995                 {
4996                         tb->mark = 0;
4997
4998                         /* Now dirty */
4999                         tb->dirty_flags |= DIRTY_ALL;
5000                 }
5001
5002                 /* Paste text */
5003                 while (chain)
5004                 {
5005                         cptr yank_str = chain->s;
5006
5007                         char buf[MAX_LINELEN];
5008                         int i;
5009                         char rest[MAX_LINELEN], *rest_ptr = rest;
5010
5011                         /* Save preceding string */
5012                         for(i = 0; i < tb->cx; i++)
5013                                 buf[i] = tb->lines_list[tb->cy][i];
5014
5015                         strcpy(rest, &(tb->lines_list[tb->cy][i]));
5016
5017                         /* Paste yank buffer */
5018                         while (*yank_str && i < MAX_LINELEN-1)
5019                         {
5020                                 buf[i++] = *yank_str++;
5021                         }
5022
5023                         /* Terminate */
5024                         buf[i] = '\0';
5025
5026                         chain = chain->next;
5027
5028                         if (chain || tb->yank_eol)
5029                         {
5030                                 /* There is an end of line between chain nodes */
5031
5032                                 insert_return_code(tb);
5033
5034                                 /* Replace this line with new one */
5035                                 string_free(tb->lines_list[tb->cy]);
5036                                 tb->lines_list[tb->cy] = string_make(buf);
5037
5038                                 /* Move to next line */
5039                                 tb->cx = 0;
5040                                 tb->cy++;
5041
5042                                 continue;
5043                         }
5044
5045                         /* Final line doesn't have end of line */
5046
5047                         tb->cx = strlen(buf);
5048
5049                         /* Rest of original line */
5050                         while (*rest_ptr && i < MAX_LINELEN-1)
5051                         {
5052                                 buf[i++] = *rest_ptr++;
5053                         }
5054
5055                         /* Terminate */
5056                         buf[i] = '\0';
5057
5058                         /* Replace this line with new one */
5059                         string_free(tb->lines_list[tb->cy]);
5060                         tb->lines_list[tb->cy] = string_make(buf);
5061
5062                         /* Finish */
5063                         break;
5064                 }
5065
5066                 /* Now dirty */
5067                 tb->dirty_flags |= DIRTY_ALL;
5068
5069                 /* Expressions need re-evaluation */
5070                 tb->dirty_flags |= DIRTY_EXPRESSION;
5071
5072                 /* Text is changed */
5073                 tb->changed = TRUE;
5074
5075                 break;
5076         }
5077
5078         case EC_BLOCK:
5079                 if (tb->mark)
5080                 {
5081                         /* Disable the selection */
5082                         tb->mark = 0;
5083
5084                         /* Redraw text */
5085                         tb->dirty_flags |= DIRTY_ALL;
5086                 }
5087                 else
5088                 {
5089                         tb->mark = MARK_MARK;
5090
5091                         /* Repeating this command swaps cursor position */
5092                         if (com_id == tb->old_com_id)
5093                         {
5094                                 int tmp;
5095
5096                                 tmp = tb->cy;
5097                                 tb->cy = tb->my;
5098                                 tb->my = tmp;
5099                                 tmp = tb->cx;
5100                                 tb->cx = tb->mx;
5101                                 tb->mx = tmp;
5102
5103                                 /* Redraw text */
5104                                 tb->dirty_flags |= DIRTY_ALL;
5105                         }
5106                         else
5107                         {
5108                                 int len = strlen(tb->lines_list[tb->cy]);
5109
5110                                 /* Mark the point 1 */
5111                                 tb->my = tb->cy;
5112                                 tb->mx = tb->cx;
5113
5114                                 /* Correct cursor location */
5115                                 if (tb->cx > len) tb->mx = len;
5116                         }
5117                 }
5118                 break;
5119
5120         case EC_KILL_LINE:
5121         {
5122                 /* Kill rest of line */
5123
5124                 int len = strlen(tb->lines_list[tb->cy]);
5125
5126                 /* Correct cursor location */
5127                 if (tb->cx > len) tb->cx = len;
5128
5129                 /* Ignore selection */
5130                 if (tb->mark)
5131                 {
5132                         tb->mark = 0;
5133
5134                         /* Now dirty */
5135                         tb->dirty_flags |= DIRTY_ALL;
5136                 }
5137
5138                 /* Append only if this command is repeated. */
5139                 if (tb->old_com_id != com_id)
5140                 {
5141                         kill_yank_chain(tb);
5142                         tb->yank = NULL;
5143                 }
5144
5145                 /* Really deleted some text */
5146                 if (tb->cx < len)
5147                 {
5148                         /* Add deleted string to yank buffer */
5149                         add_str_to_yank(tb, &(tb->lines_list[tb->cy][tb->cx]));
5150
5151                         kill_line_segment(tb, tb->cy, tb->cx, len, FALSE);
5152
5153                         /* Now dirty */
5154                         tb->dirty_line = tb->cy;
5155
5156                         /* Leave end of line character */
5157                         break;
5158                 }
5159
5160                 /* Cut the end of line character only */
5161                 if (tb->yank_eol) add_str_to_yank(tb, "");
5162
5163                 /* Cut end of line */
5164                 tb->yank_eol = TRUE;
5165
5166                 do_editor_command(tb, EC_DELETE_CHAR);
5167                 break;
5168         }
5169
5170         case EC_DELETE_CHAR:
5171                 /* DELETE == go forward + BACK SPACE */
5172
5173                 /* Ignore selection */
5174                 if (tb->mark)
5175                 {
5176                         tb->mark = 0;
5177
5178                         /* Now dirty */
5179                         tb->dirty_flags |= DIRTY_ALL;
5180                 }
5181
5182 #ifdef JP
5183                 if (iskanji(tb->lines_list[tb->cy][tb->cx])) tb->cx++;
5184 #endif
5185                 tb->cx++;
5186
5187                 do_editor_command(tb, EC_BACKSPACE);
5188                 break;
5189
5190         case EC_BACKSPACE:
5191         {
5192                 /* BACK SPACE */
5193
5194                 int len, i, j, k;
5195                 char buf[MAX_LINELEN];
5196
5197                 /* Ignore selection */
5198                 if (tb->mark)
5199                 {
5200                         tb->mark = 0;
5201
5202                         /* Now dirty */
5203                         tb->dirty_flags |= DIRTY_ALL;
5204                 }
5205
5206                 len = strlen(tb->lines_list[tb->cy]);
5207                 if (len < tb->cx)
5208                 {
5209                         if (tb->lines_list[tb->cy + 1])
5210                         {
5211                                 tb->cy++;
5212                                 tb->cx = 0;
5213                         }
5214                         else
5215                         {
5216                                 tb->cx = len;
5217                                 break;
5218                         }
5219                 }
5220
5221                 if (tb->cx == 0)
5222                 {
5223                         /* delete a return code and union two lines */
5224                         if (tb->cy == 0) break;
5225                         tb->cx = strlen(tb->lines_list[tb->cy-1]);
5226                         strcpy(buf, tb->lines_list[tb->cy-1]);
5227                         strcat(buf, tb->lines_list[tb->cy]);
5228                         string_free(tb->lines_list[tb->cy-1]);
5229                         string_free(tb->lines_list[tb->cy]);
5230                         tb->lines_list[tb->cy-1] = string_make(buf);
5231
5232                         for (i = tb->cy; tb->lines_list[i+1]; i++)
5233                                 tb->lines_list[i] = tb->lines_list[i+1];
5234
5235                         tb->lines_list[i] = NULL;
5236                         tb->cy--;
5237
5238                         /* Now dirty */
5239                         tb->dirty_flags |= DIRTY_ALL;
5240
5241                         /* Expressions need re-evaluation */
5242                         tb->dirty_flags |= DIRTY_EXPRESSION;
5243
5244                         /* Text is changed */
5245                         tb->changed = TRUE;
5246
5247                         break;
5248                 }
5249
5250                 for (i = j = k = 0; tb->lines_list[tb->cy][i] && i < tb->cx; i++)
5251                 {
5252                         k = j;
5253 #ifdef JP
5254                         if (iskanji(tb->lines_list[tb->cy][i]))
5255                                 buf[j++] = tb->lines_list[tb->cy][i++];
5256 #endif
5257                         buf[j++] = tb->lines_list[tb->cy][i];
5258                 }
5259                 while (j > k)
5260                 {
5261                         tb->cx--;
5262                         j--;
5263                 }
5264                 for (; tb->lines_list[tb->cy][i]; i++)
5265                         buf[j++] = tb->lines_list[tb->cy][i];
5266                 buf[j] = '\0';
5267                 string_free(tb->lines_list[tb->cy]);
5268                 tb->lines_list[tb->cy] = string_make(buf);
5269
5270                 /* Now dirty */
5271                 tb->dirty_line = tb->cy;
5272
5273                 /* Expressions may need re-evaluation */
5274                 check_expression_line(tb, tb->cy);
5275
5276                 /* Text is changed */
5277                 tb->changed = TRUE;
5278
5279                 break;
5280         }
5281
5282         case EC_SEARCH_STR:
5283         {
5284                 byte search_dir;
5285
5286                 /* Become dirty because of item/equip menu */
5287                 tb->dirty_flags |= DIRTY_SCREEN;
5288
5289                 search_dir = get_string_for_search(&tb->search_o_ptr, &tb->search_str);
5290
5291                 if (!search_dir) break;
5292
5293                 if (search_dir == 1) do_editor_command(tb, EC_SEARCH_FORW);
5294                 else do_editor_command(tb, EC_SEARCH_BACK);
5295                 break;
5296         }
5297
5298         case EC_SEARCH_FORW:
5299                 if (tb->search_o_ptr)
5300                 {
5301                         search_for_object(tb, tb->search_o_ptr, TRUE);
5302                 }
5303                 else if (tb->search_str)
5304                 {
5305                         search_for_string(tb, tb->search_str, TRUE);
5306                 }
5307                 else
5308                 {
5309                         tb->dirty_flags |= DIRTY_NO_SEARCH;
5310                 }
5311                 break;
5312
5313         case EC_SEARCH_BACK:
5314                 if (tb->search_o_ptr)
5315                 {
5316                         search_for_object(tb, tb->search_o_ptr, FALSE);
5317                 }
5318                 else if (tb->search_str)
5319                 {
5320                         search_for_string(tb, tb->search_str, FALSE);
5321                 }
5322                 else
5323                 {
5324                         tb->dirty_flags |= DIRTY_NO_SEARCH;
5325                 }
5326                 break;
5327
5328         case EC_SEARCH_OBJ:
5329                 /* Become dirty because of item/equip menu */
5330                 tb->dirty_flags |= DIRTY_SCREEN;
5331
5332                 if (!get_object_for_search(&tb->search_o_ptr, &tb->search_str)) break;
5333
5334                 do_editor_command(tb, EC_SEARCH_FORW);
5335                 break;
5336
5337         case EC_SEARCH_DESTROYED:
5338                 if (!get_destroyed_object_for_search(&tb->search_o_ptr, &tb->search_str))
5339                 {
5340                         /* There is no object to search */
5341                         tb->dirty_flags |= DIRTY_NO_SEARCH;
5342
5343                         break;
5344                 }
5345
5346                 do_editor_command(tb, EC_SEARCH_FORW);
5347                 break;
5348
5349         case EC_INSERT_OBJECT:
5350         {
5351                 /* Insert choosen item name */
5352
5353                 autopick_type an_entry, *entry = &an_entry;
5354
5355                 if (!entry_from_choosed_object(entry))
5356                 {
5357                         /* Now dirty because of item/equip menu */
5358                         tb->dirty_flags |= DIRTY_SCREEN;
5359                         break;
5360                 }
5361
5362                 tb->cx = 0;
5363                 insert_return_code(tb);
5364                 string_free(tb->lines_list[tb->cy]);
5365                 tb->lines_list[tb->cy] = autopick_line_from_entry_kill(entry);
5366
5367                 /* Now dirty because of item/equip menu */
5368                 tb->dirty_flags |= DIRTY_SCREEN;
5369
5370                 break;
5371         }
5372
5373         case EC_INSERT_DESTROYED:
5374                 /* Insert a name of last destroyed item */
5375                 if (tb->last_destroyed)
5376                 {
5377                         tb->cx = 0;
5378                         insert_return_code(tb);
5379                         string_free(tb->lines_list[tb->cy]);
5380                         tb->lines_list[tb->cy] = string_make(tb->last_destroyed);
5381
5382                         /* Now dirty */
5383                         tb->dirty_flags |= DIRTY_ALL;
5384
5385                         /* Text is changed */
5386                         tb->changed = TRUE;
5387                 }
5388                 break;
5389
5390         case EC_INSERT_BLOCK:
5391         {
5392                 /* Insert a conditinal expression line */
5393                 char expression[80];
5394
5395                 /* Conditional Expression for Class and Race */
5396                 sprintf(expression, "?:[AND [EQU $RACE %s] [EQU $CLASS %s] [GEQ $LEVEL %02d]]",
5397 #ifdef JP
5398                         rp_ptr->E_title, cp_ptr->E_title,
5399 #else
5400                         rp_ptr->title, cp_ptr->title,
5401 #endif
5402                         p_ptr->lev
5403                         );
5404
5405                 tb->cx = 0;
5406                 insert_return_code(tb);
5407                 string_free(tb->lines_list[tb->cy]);
5408                 tb->lines_list[tb->cy] = string_make(expression);
5409                 tb->cy++;
5410                 insert_return_code(tb);
5411                 string_free(tb->lines_list[tb->cy]);
5412                 tb->lines_list[tb->cy] = string_make("?:1");
5413
5414                 /* Now dirty */
5415                 tb->dirty_flags |= DIRTY_ALL;
5416
5417                 /* Text is changed */
5418                 tb->changed = TRUE;
5419
5420                 break;
5421         }
5422
5423         case EC_INSERT_MACRO:
5424                 /* Draw_everythig (delete menu) */
5425                 draw_text_editor(tb);
5426
5427                 /* Erase line */
5428                 Term_erase(0, tb->cy - tb->upper + 1, tb->wid);
5429
5430                 /* Prompt */
5431 #ifdef JP
5432                 Term_putstr(0, tb->cy - tb->upper + 1, tb->wid - 1, TERM_YELLOW, "P:<¥È¥ê¥¬¡¼¥¡¼>: ");
5433 #else
5434                 Term_putstr(0, tb->cy - tb->upper + 1, tb->wid - 1, TERM_YELLOW, "P:<Trigger key>: ");
5435 #endif
5436                 if (insert_macro_line(tb))
5437                 {
5438                         /* Prepare to input action */
5439                         tb->cx = 2;
5440
5441                         /* Now dirty */
5442                         tb->dirty_flags |= DIRTY_ALL;
5443
5444                         /* Text is changed */
5445                         tb->changed = TRUE;
5446                 }
5447
5448                 break;
5449
5450         case EC_INSERT_KEYMAP:
5451                 /* Draw_everythig (delete menu) */
5452                 draw_text_editor(tb);
5453
5454                 /* Erase line */
5455                 Term_erase(0, tb->cy - tb->upper + 1, tb->wid);
5456
5457                 /* Prompt */
5458 #ifdef JP
5459                 Term_putstr(0, tb->cy - tb->upper + 1, tb->wid - 1, TERM_YELLOW, format("C:%d:<¥³¥Þ¥ó¥É¥¡¼>: ", (rogue_like_commands ? KEYMAP_MODE_ROGUE : KEYMAP_MODE_ORIG)));
5460 #else
5461                 Term_putstr(0, tb->cy - tb->upper + 1, tb->wid - 1, TERM_YELLOW, format("C:%d:<Keypress>: ", (rogue_like_commands ? KEYMAP_MODE_ROGUE : KEYMAP_MODE_ORIG)));
5462 #endif
5463
5464                 if (insert_keymap_line(tb))
5465                 {
5466                         /* Prepare to input action */
5467                         tb->cx = 2;
5468
5469                         /* Now dirty */
5470                         tb->dirty_flags |= DIRTY_ALL;
5471
5472                         /* Text is changed */
5473                         tb->changed = TRUE;
5474                 }
5475                 break;
5476
5477         case EC_CL_AUTOPICK: toggle_command_letter(tb, DO_AUTOPICK); break;
5478         case EC_CL_DESTROY: toggle_command_letter(tb, DO_AUTODESTROY); break;
5479         case EC_CL_LEAVE: toggle_command_letter(tb, DONT_AUTOPICK); break;
5480         case EC_CL_QUERY: toggle_command_letter(tb, DO_QUERY_AUTOPICK); break;
5481         case EC_CL_NO_DISP: toggle_command_letter(tb, DO_DISPLAY); break;
5482
5483         case EC_IK_UNAWARE: toggle_keyword(tb, FLG_UNAWARE); break;
5484         case EC_IK_UNIDENTIFIED: toggle_keyword(tb, FLG_UNIDENTIFIED); break;
5485         case EC_IK_IDENTIFIED: toggle_keyword(tb, FLG_IDENTIFIED); break;
5486         case EC_IK_STAR_IDENTIFIED: toggle_keyword(tb, FLG_STAR_IDENTIFIED); break;
5487         case EC_KK_WEAPONS: toggle_keyword(tb, FLG_WEAPONS); break;
5488         case EC_KK_FAVORITE: toggle_keyword(tb, FLG_FAVORITE); break;
5489         case EC_KK_ARMORS: toggle_keyword(tb, FLG_ARMORS); break;
5490         case EC_KK_MISSILES: toggle_keyword(tb, FLG_MISSILES); break;
5491         case EC_KK_DEVICES: toggle_keyword(tb, FLG_DEVICES); break;
5492         case EC_KK_LIGHTS: toggle_keyword(tb, FLG_LIGHTS); break;
5493         case EC_KK_JUNKS: toggle_keyword(tb, FLG_JUNKS); break;
5494         case EC_KK_SPELLBOOKS: toggle_keyword(tb, FLG_SPELLBOOKS); break;
5495         case EC_KK_SHIELDS: toggle_keyword(tb, FLG_SHIELDS); break;
5496         case EC_KK_BOWS: toggle_keyword(tb, FLG_BOWS); break;
5497         case EC_KK_RINGS: toggle_keyword(tb, FLG_RINGS); break;
5498         case EC_KK_AMULETS: toggle_keyword(tb, FLG_AMULETS); break;
5499         case EC_KK_SUITS: toggle_keyword(tb, FLG_SUITS); break;
5500         case EC_KK_CLOAKS: toggle_keyword(tb, FLG_CLOAKS); break;
5501         case EC_KK_HELMS: toggle_keyword(tb, FLG_HELMS); break;
5502         case EC_KK_GLOVES: toggle_keyword(tb, FLG_GLOVES); break;
5503         case EC_KK_BOOTS: toggle_keyword(tb, FLG_BOOTS); break;
5504         case EC_OK_COLLECTING: toggle_keyword(tb, FLG_COLLECTING); break;
5505         case EC_OK_BOOSTED: toggle_keyword(tb, FLG_BOOSTED); break;
5506         case EC_OK_MORE_THAN: toggle_keyword(tb, FLG_MORE_THAN); break;
5507         case EC_OK_MORE_BONUS: toggle_keyword(tb, FLG_MORE_BONUS); break;
5508         case EC_OK_WORTHLESS: toggle_keyword(tb, FLG_WORTHLESS); break;
5509         case EC_OK_ARTIFACT: toggle_keyword(tb, FLG_ARTIFACT); break;
5510         case EC_OK_EGO: toggle_keyword(tb, FLG_EGO); break;
5511         case EC_OK_NAMELESS: toggle_keyword(tb, FLG_NAMELESS); break;
5512         case EC_OK_WANTED: toggle_keyword(tb, FLG_WANTED); break;
5513         case EC_OK_UNIQUE: toggle_keyword(tb, FLG_UNIQUE); break;
5514         case EC_OK_HUMAN: toggle_keyword(tb, FLG_HUMAN); break;
5515         case EC_OK_UNREADABLE:
5516                 toggle_keyword(tb, FLG_UNREADABLE);
5517                 add_keyword(tb, FLG_SPELLBOOKS);
5518                 break;
5519         case EC_OK_REALM1:
5520                 toggle_keyword(tb, FLG_REALM1);
5521                 add_keyword(tb, FLG_SPELLBOOKS);
5522                 break;
5523         case EC_OK_REALM2:
5524                 toggle_keyword(tb, FLG_REALM2);
5525                 add_keyword(tb, FLG_SPELLBOOKS);
5526                 break;
5527         case EC_OK_FIRST:
5528                 toggle_keyword(tb, FLG_FIRST);
5529                 add_keyword(tb, FLG_SPELLBOOKS);
5530                 break;
5531         case EC_OK_SECOND:
5532                 toggle_keyword(tb, FLG_SECOND);
5533                 add_keyword(tb, FLG_SPELLBOOKS);
5534                 break;
5535         case EC_OK_THIRD:
5536                 toggle_keyword(tb, FLG_THIRD);
5537                 add_keyword(tb, FLG_SPELLBOOKS);
5538                 break;
5539         case EC_OK_FOURTH:
5540                 toggle_keyword(tb, FLG_FOURTH);
5541                 add_keyword(tb, FLG_SPELLBOOKS);
5542                 break;
5543         }
5544
5545         /* Save old command */
5546         tb->old_com_id = com_id;
5547
5548         return FALSE;
5549 }
5550
5551
5552 /*
5553  * Insert single letter at cursor position.
5554  */
5555 static void insert_single_letter(text_body_type *tb, int key)
5556 {
5557         int i, j, len;
5558         char buf[MAX_LINELEN];
5559
5560         /* Save preceding string */
5561         for (i = j = 0; tb->lines_list[tb->cy][i] && i < tb->cx; i++)
5562                 buf[j++] = tb->lines_list[tb->cy][i];
5563
5564         /* Add a character */
5565 #ifdef JP
5566         if (iskanji(key))
5567         {
5568                 int next;
5569
5570                 inkey_base = TRUE;
5571                 next = inkey();
5572                 if (j+2 < MAX_LINELEN)
5573                 {
5574                         buf[j++] = key;
5575                         buf[j++] = next;
5576                         tb->cx += 2;
5577                 }
5578                 else
5579                         bell();
5580         }
5581         else
5582 #endif
5583         {
5584                 if (j+1 < MAX_LINELEN)
5585                         buf[j++] = key;
5586                 tb->cx++;
5587         }
5588
5589         /* Add following */
5590         for (; tb->lines_list[tb->cy][i] && j + 1 < MAX_LINELEN; i++)
5591                 buf[j++] = tb->lines_list[tb->cy][i];
5592         buf[j] = '\0';
5593
5594         /* Replace current line with new line */
5595         string_free(tb->lines_list[tb->cy]);
5596         tb->lines_list[tb->cy] = string_make(buf);
5597
5598         /* Move to correct collumn */
5599         len = strlen(tb->lines_list[tb->cy]);
5600         if (len < tb->cx) tb->cx = len;
5601
5602         /* Now dirty */
5603         tb->dirty_line = tb->cy;
5604
5605         /* Expressions may need re-evaluation */
5606         check_expression_line(tb, tb->cy);
5607
5608         /* Text is changed */
5609         tb->changed = TRUE;
5610 }
5611
5612
5613 /*
5614  * Check special key code and get a movement command id
5615  */
5616 static int analyze_move_key(text_body_type *tb, int skey)
5617 {
5618         int com_id;
5619
5620         /* Not a special key */
5621         if (!(skey & SKEY_MASK)) return 0;
5622
5623         /* Convert from a special key code to an editor command */
5624         switch(skey & ~SKEY_MOD_MASK)
5625         {
5626         case SKEY_DOWN:   com_id = EC_DOWN;   break;
5627         case SKEY_LEFT:   com_id = EC_LEFT;   break;
5628         case SKEY_RIGHT:  com_id = EC_RIGHT;  break;
5629         case SKEY_UP:     com_id = EC_UP;     break;
5630         case SKEY_PGUP:   com_id = EC_PGUP;   break;
5631         case SKEY_PGDOWN: com_id = EC_PGDOWN; break;
5632         case SKEY_TOP:    com_id = EC_TOP;    break;
5633         case SKEY_BOTTOM: com_id = EC_BOTTOM; break;
5634
5635         default:
5636                 /* Not a special movement key */
5637                 return 0;
5638         }
5639
5640         /* Without shift modifier */
5641         if (!(skey & SKEY_MOD_SHIFT))
5642         {
5643                 /*
5644                  * Un-shifted cursor keys cancells
5645                  * selection created by shift+cursor.
5646                  */
5647                 if (tb->mark & MARK_BY_SHIFT)
5648                 {
5649                         tb->mark = 0;
5650
5651                         /* Now dirty */
5652                         tb->dirty_flags |= DIRTY_ALL;
5653                 }
5654         }
5655
5656         /* With shift modifier */
5657         else
5658         {
5659                 /* Start selection by shift + cursor keys */
5660                 if (!tb->mark)
5661                 {
5662                         int len = strlen(tb->lines_list[tb->cy]);
5663
5664                         tb->mark = MARK_MARK | MARK_BY_SHIFT;
5665                         tb->my = tb->cy;
5666                         tb->mx = tb->cx;
5667
5668                         /* Correct cursor location */
5669                         if (tb->cx > len) tb->mx = len;
5670
5671                         /* Need to redraw text */
5672                         if (com_id == EC_UP || com_id == EC_DOWN)
5673                         {
5674                                 /* Redraw all text */
5675                                 tb->dirty_flags |= DIRTY_ALL;
5676                         }
5677                         else
5678                         {
5679                                 tb->dirty_line = tb->cy;
5680                         }
5681                 }
5682         }
5683
5684         return com_id;
5685 }
5686
5687 /*
5688  * In-game editor of Object Auto-picker/Destoryer
5689  */
5690 void do_cmd_edit_autopick(void)
5691 {
5692         static int cx_save = 0;
5693         static int cy_save = 0;
5694
5695         text_body_type text_body, *tb = &text_body;
5696
5697         autopick_type an_entry, *entry = &an_entry;
5698         char buf[MAX_LINELEN];
5699
5700         int i;
5701         int key = -1;
5702
5703         static s32b old_autosave_turn = 0L;
5704         byte quit = 0;
5705
5706         tb->changed = FALSE;
5707         tb->cx = cx_save;
5708         tb->cy = cy_save;
5709         tb->upper = tb->left = 0;
5710         tb->mark = 0;
5711         tb->mx = tb->my = 0;
5712         tb->old_cy = tb->old_upper = tb->old_left = -1;
5713         tb->old_wid = tb->old_hgt = -1;
5714         tb->old_com_id = 0;
5715
5716         tb->yank = NULL;
5717         tb->search_o_ptr = NULL;
5718         tb->search_str = NULL;
5719         tb->last_destroyed = NULL;
5720         tb->dirty_flags = DIRTY_ALL | DIRTY_MODE | DIRTY_EXPRESSION;
5721         tb->dirty_line = -1;
5722         tb->filename_mode = PT_DEFAULT;
5723
5724         /* Autosave */
5725         if (turn > old_autosave_turn + 100L)
5726         {
5727                 do_cmd_save_game(TRUE);
5728                 old_autosave_turn = turn;
5729         }
5730
5731         /* HACK -- Reset start_time to stop counting playtime while edit */
5732         update_playtime();
5733
5734         /* Free old entries */
5735         init_autopicker();
5736
5737         /* Command Description of the 'Last Destroyed Item' */
5738         if (autopick_last_destroyed_object.k_idx)
5739         {
5740                 autopick_entry_from_object(entry, &autopick_last_destroyed_object);
5741                 tb->last_destroyed = autopick_line_from_entry_kill(entry);
5742         }
5743
5744         /* Read or initialize whole text */
5745         tb->lines_list = read_pickpref_text_lines(&tb->filename_mode);
5746
5747         /* Reset cursor position if needed */
5748         for (i = 0; i < tb->cy; i++)
5749         {
5750                 if (!tb->lines_list[i])
5751                 {
5752                         tb->cy = tb->cx = 0;
5753                         break;
5754                 }
5755         }
5756
5757         /* Save the screen */
5758         screen_save();
5759
5760         /* Process requests until done */
5761         while (!quit)
5762         {
5763                 int com_id = 0;
5764
5765                 /* Draw_everythig */
5766                 draw_text_editor(tb);
5767
5768                 /* Display header line */
5769 #ifdef JP
5770                 prt("(^Q:½ªÎ» ^W:¥»¡¼¥Ö¤·¤Æ½ªÎ», ESC:¥á¥Ë¥å¡¼, ¤½¤ÎÂ¾:ÆþÎÏ)", 0, 0);
5771 #else
5772                 prt("(^Q:Quit, ^W:Save&Quit, ESC:Menu, Other:Input text)", 0, 0);
5773 #endif
5774                 if (!tb->mark)
5775                 {
5776                         /* Display current position */
5777                         prt (format("(%d,%d)", tb->cx, tb->cy), 0, 60);
5778                 }
5779                 else
5780                 {
5781                         /* Display current position and mark position */
5782                         prt (format("(%d,%d)-(%d,%d)", tb->mx, tb->my, tb->cx, tb->cy), 0, 60);
5783                 }
5784
5785                 /* Place cursor */
5786                 Term_gotoxy(tb->cx - tb->left, tb->cy - tb->upper + 1);
5787
5788                 /* Now clean */
5789                 tb->dirty_flags = 0;
5790                 tb->dirty_line = -1;
5791
5792                 /* Save old key and location */
5793                 tb->old_cy = tb->cy;
5794                 tb->old_upper = tb->upper;
5795                 tb->old_left = tb->left;
5796                 tb->old_wid = tb->wid;
5797                 tb->old_hgt = tb->hgt;
5798
5799                 /* Get a command */
5800                 key = inkey_special();
5801
5802                 /* Special keys */
5803                 if (key & SKEY_MASK)
5804                 {
5805                         /* Get a movement command */
5806                         com_id = analyze_move_key(tb, key);
5807                 }
5808
5809                 /* Open the menu */
5810                 else if (key == ESCAPE)
5811                 {
5812                         com_id = do_command_menu(0, 0);
5813
5814                         /* Redraw all text later */
5815                         tb->dirty_flags |= DIRTY_SCREEN;
5816                 }
5817
5818                 /* Insert a character */
5819                 else if (!iscntrl((unsigned char)key))
5820                 {
5821                         /* Ignore selection */
5822                         if (tb->mark)
5823                         {
5824                                 tb->mark = 0;
5825
5826                                 /* Now dirty */
5827                                 tb->dirty_flags |= DIRTY_ALL;
5828                         }
5829
5830                         insert_single_letter(tb, key);
5831
5832                         /* Next loop */
5833                         continue;
5834                 }
5835
5836                 /* Other commands */
5837                 else
5838                 {
5839                         com_id = get_com_id(key);
5840                 }
5841
5842                 if (com_id) quit = do_editor_command(tb, com_id);
5843         } /* while (TRUE) */
5844
5845         /* Restore the screen */
5846         screen_load();
5847
5848         /* Get the filename of preference */
5849         strcpy(buf, pickpref_filename(tb->filename_mode));
5850
5851         if (quit == QUIT_AND_SAVE)
5852                 write_text_lines(buf, tb->lines_list);
5853
5854         free_text_lines(tb->lines_list);
5855
5856         string_free(tb->last_destroyed);
5857
5858         /* Destroy string chain */
5859         kill_yank_chain(tb);
5860
5861         /* Reload autopick pref */
5862         process_pickpref_file(buf);
5863
5864         /* HACK -- reset start_time so that playtime is not increase while edit */
5865         start_time = time(NULL);
5866
5867         /* Save cursor location */
5868         cx_save = tb->cx;
5869         cy_save = tb->cy;
5870 }