src/symbols.c

   1 /* NetHack 3.7  symbols.c       $NHDT-Date: 1736530208 2025/01/10 09:30:08 $  $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.123 $ */
   2 /* Copyright (c) NetHack Development Team 2020.                   */
   3 /* NetHack may be freely redistributed.  See license for details. */
   4
   5 #include "hack.h"
   6 #include "tcap.h"
   7
   8 staticfn void savedsym_add(const char *, const char *, int);
   9 staticfn struct _savedsym *savedsym_find(const char *, int);
  10
  11 extern const uchar def_r_oc_syms[MAXOCLASSES];      /* drawing.c */
  12
  13 #if defined(TERMLIB) || defined(CURSES_GRAPHICS)
  14 void (*decgraphics_mode_callback)(void) = 0; /* set in term_start_screen() */
  15 #endif /* TERMLIB || CURSES */
  16
  17 #ifdef PC9800
  18 void (*ibmgraphics_mode_callback)(void) = 0; /* set in term_start_screen() */
  19 void (*ascgraphics_mode_callback)(void) = 0; /* set in term_start_screen() */
  20 #endif
  21 #ifdef CURSES_GRAPHICS
  22 void (*cursesgraphics_mode_callback)(void) = 0;
  23 #endif
  24 #if defined(TTY_GRAPHICS) && defined(WIN32)
  25 void (*ibmgraphics_mode_callback)(void) = 0;
  26 #endif
  27 #ifdef ENHANCED_SYMBOLS
  28 void (*utf8graphics_mode_callback)(void) = 0; /* set in term_start_screen and
  29                                                * found in unixtty,windtty,&c */
  30 #endif
  31
  32 /*
  33  * Explanations of the functions found below:
  34  *
  35  * init_symbols()
  36  *                     Sets the current display symbols, the
  37  *                     loadable symbols to the default NetHack
  38  *                     symbols, including the rogue_syms rogue level
  39  *                     symbols. This would typically be done
  40  *                     immediately after execution begins. Any
  41  *                     previously loaded external symbol sets are
  42  *                     discarded.
  43  *
  44  * switch_symbols(arg)
  45  *                     Called to swap in new current display symbols
  46  *                     (showsyms) from either the default symbols,
  47  *                     or from the loaded symbols.
  48  *
  49  *                     If (arg == 0) then showsyms are taken from
  50  *                     defsyms, def_oc_syms, and def_monsyms.
  51  *
  52  *                     If (arg != 0), which is the normal expected
  53  *                     usage, then showsyms are taken from the
  54  *                     adjustable display symbols found in gp.primary_syms.
  55  *                     gp.primary_syms may have been loaded from an external
  56  *                     symbol file by config file options or interactively
  57  *                     in the Options menu.
  58  *
  59  * assign_graphics(arg)
  60  *
  61  *                     This is used in the game core to toggle in and
  62  *                     out of other {rogue} level display modes.
  63  *
  64  *                     If arg is ROGUESET, this places the rogue level
  65  *                     symbols from gr.rogue_syms into gs.showsyms.
  66  *
  67  *                     If arg is PRIMARYSET, this places the symbols
  68  *                     from gp.primary_syms into gs.showsyms.
  69  *
  70  * update_primary_symset()
  71  *                     Update a member of the primary(primary_*) symbol set.
  72  *
  73  * update_rogue_symset()
  74  *                     Update a member of the rogue (rogue_*) symbol set.
  75  *
  76  * update_ov_primary_symset()
  77  *                     Update a member of the overrides for primary symbol set.
  78  *
  79  * update_ov_rogue_symset()
  80  *                     Update a member of the overrides for rogue symbol set.
  81  *
  82  */
  83
  84 void
  85 init_symbols(void)
  86 {
  87     init_ov_primary_symbols();
  88     init_ov_rogue_symbols();
  89     init_primary_symbols();
  90     init_showsyms();
  91     init_rogue_symbols();
  92 }
  93
  94 void
  95 init_showsyms(void)
  96 {
  97     int i;
  98
  99     for (i = 0; i < MAXPCHARS; i++)
 100         gs.showsyms[i + SYM_OFF_P] = defsyms[i].sym;
 101     for (i = 0; i < MAXOCLASSES; i++)
 102         gs.showsyms[i + SYM_OFF_O] = def_oc_syms[i].sym;
 103     for (i = 0; i < MAXMCLASSES; i++)
 104         gs.showsyms[i + SYM_OFF_M] = def_monsyms[i].sym;
 105     for (i = 0; i < WARNCOUNT; i++)
 106         gs.showsyms[i + SYM_OFF_W] = def_warnsyms[i].sym;
 107     for (i = 0; i < MAXOTHER; i++)
 108         gs.showsyms[i + SYM_OFF_X] = get_othersym(i, PRIMARYSET);
 109 }
 110
 111 /* initialize defaults for the overrides to the rogue symset */
 112 void
 113 init_ov_rogue_symbols(void)
 114 {
 115     int i;
 116
 117     for (i = 0; i < SYM_MAX; i++)
 118         go.ov_rogue_syms[i] = (nhsym) 0;
 119 }
 120 /* initialize defaults for the overrides to the primary symset */
 121 void
 122 init_ov_primary_symbols(void)
 123 {
 124     int i;
 125
 126     for (i = 0; i < SYM_MAX; i++)
 127         go.ov_primary_syms[i] = (nhsym) 0;
 128 }
 129
 130 nhsym
 131 get_othersym(int idx, int which_set)
 132 {
 133     nhsym sym = (nhsym) 0;
 134     int oidx = idx + SYM_OFF_X;
 135
 136     if (which_set == ROGUESET)
 137         sym = go.ov_rogue_syms[oidx] ? go.ov_rogue_syms[oidx]
 138                                     : gr.rogue_syms[oidx];
 139     else
 140         sym = go.ov_primary_syms[oidx] ? go.ov_primary_syms[oidx]
 141                                       : gp.primary_syms[oidx];
 142     if (!sym) {
 143         switch(idx) {
 144             case SYM_NOTHING:
 145             case SYM_UNEXPLORED:
 146                 sym = DEF_NOTHING;
 147                 break;
 148             case SYM_BOULDER:
 149                 sym = def_oc_syms[ROCK_CLASS].sym;
 150                 break;
 151             case SYM_INVISIBLE:
 152                 sym = DEF_INVISIBLE;
 153                 break;
 154 #if 0
 155             /* these intentionally have no defaults */
 156             case SYM_PET_OVERRIDE:
 157             case SYM_HERO_OVERRIDE:
 158                 break;
 159 #endif
 160         }
 161     }
 162     return sym;
 163 }
 164
 165 /* initialize defaults for the primary symset */
 166 void
 167 init_primary_symbols(void)
 168 {
 169     int i;
 170
 171     for (i = 0; i < MAXPCHARS; i++)
 172         gp.primary_syms[i + SYM_OFF_P] = defsyms[i].sym;
 173     for (i = 0; i < MAXOCLASSES; i++)
 174         gp.primary_syms[i + SYM_OFF_O] = def_oc_syms[i].sym;
 175     for (i = 0; i < MAXMCLASSES; i++)
 176         gp.primary_syms[i + SYM_OFF_M] = def_monsyms[i].sym;
 177     for (i = 0; i < WARNCOUNT; i++)
 178         gp.primary_syms[i + SYM_OFF_W] = def_warnsyms[i].sym;
 179     for (i = 0; i < MAXOTHER; i++)
 180         gp.primary_syms[i + SYM_OFF_X] = get_othersym(i, PRIMARYSET);
 181
 182     clear_symsetentry(PRIMARYSET, FALSE);
 183 }
 184
 185 /* initialize defaults for the rogue symset */
 186 void
 187 init_rogue_symbols(void)
 188 {
 189     int i;
 190
 191     /* These are defaults that can get overwritten
 192        later by the roguesymbols option */
 193
 194     for (i = 0; i < MAXPCHARS; i++)
 195         gr.rogue_syms[i + SYM_OFF_P] = defsyms[i].sym;
 196     gr.rogue_syms[S_vodoor] = gr.rogue_syms[S_hodoor]
 197         = gr.rogue_syms[S_ndoor] = '+';
 198     gr.rogue_syms[S_upstair] = gr.rogue_syms[S_dnstair] = '%';
 199
 200     for (i = 0; i < MAXOCLASSES; i++)
 201         gr.rogue_syms[i + SYM_OFF_O] = def_r_oc_syms[i];
 202     for (i = 0; i < MAXMCLASSES; i++)
 203         gr.rogue_syms[i + SYM_OFF_M] = def_monsyms[i].sym;
 204     for (i = 0; i < WARNCOUNT; i++)
 205         gr.rogue_syms[i + SYM_OFF_W] = def_warnsyms[i].sym;
 206     for (i = 0; i < MAXOTHER; i++)
 207         gr.rogue_syms[i + SYM_OFF_X] = get_othersym(i, ROGUESET);
 208
 209     clear_symsetentry(ROGUESET, FALSE);
 210     /* default on Rogue level is no color
 211      * but some symbol sets can override that
 212      */
 213     gs.symset[ROGUESET].nocolor = 1;
 214 }
 215
 216 void
 217 assign_graphics(int whichset)
 218 {
 219     int i;
 220
 221     switch (whichset) {
 222     case ROGUESET:
 223         /* Adjust graphics display characters on Rogue levels */
 224
 225         for (i = 0; i < SYM_MAX; i++)
 226             gs.showsyms[i] = go.ov_rogue_syms[i] ? go.ov_rogue_syms[i]
 227                                            : gr.rogue_syms[i];
 228
 229 #if defined(MSDOS) && defined(TILES_IN_GLYPHMAP)
 230         if (iflags.grmode)
 231             tileview(FALSE);
 232 #endif
 233         gc.currentgraphics = ROGUESET;
 234         break;
 235
 236     case PRIMARYSET:
 237     default:
 238         for (i = 0; i < SYM_MAX; i++)
 239             gs.showsyms[i] = go.ov_primary_syms[i] ? go.ov_primary_syms[i]
 240                                              : gp.primary_syms[i];
 241
 242 #if defined(MSDOS) && defined(TILES_IN_GLYPHMAP)
 243         if (iflags.grmode)
 244             tileview(TRUE);
 245 #endif
 246         gc.currentgraphics = PRIMARYSET;
 247         break;
 248     }
 249     reset_glyphmap(gm_symchange);
 250 }
 251
 252 void
 253 switch_symbols(int nondefault)
 254 {
 255     int i;
 256
 257     if (nondefault) {
 258         for (i = 0; i < SYM_MAX; i++)
 259             gs.showsyms[i] = go.ov_primary_syms[i] ? go.ov_primary_syms[i]
 260                                                  : gp.primary_syms[i];
 261 #ifdef PC9800
 262         if (SYMHANDLING(H_IBM) && ibmgraphics_mode_callback)
 263             (*ibmgraphics_mode_callback)();
 264         else if (SYMHANDLING(H_UNK) && ascgraphics_mode_callback)
 265             (*ascgraphics_mode_callback)();
 266 #endif
 267 #if defined(TERMLIB) || defined(CURSES_GRAPHICS)
 268         /* curses doesn't assign any routine to dec..._callback but
 269            probably does the expected initialization under the hood
 270            for terminals capable of rendering DECgraphics */
 271         if (SYMHANDLING(H_DEC) && decgraphics_mode_callback)
 272             (*decgraphics_mode_callback)();
 273 # ifdef CURSES_GRAPHICS
 274         /* there aren't any symbol sets with CURS handling, and the
 275            curses interface never assigns a routine to curses..._callback */
 276         if (SYMHANDLING(H_CURS) && cursesgraphics_mode_callback)
 277             (*cursesgraphics_mode_callback)();
 278 # endif
 279 #endif
 280 #if defined(TTY_GRAPHICS) && defined(WIN32)
 281         if (SYMHANDLING(H_IBM) && ibmgraphics_mode_callback)
 282             (*ibmgraphics_mode_callback)();
 283 #endif
 284 #ifdef ENHANCED_SYMBOLS
 285         if (SYMHANDLING(H_UTF8) && utf8graphics_mode_callback)
 286             (*utf8graphics_mode_callback)();
 287 #endif
 288     } else {
 289         init_primary_symbols();
 290         init_showsyms();
 291     }
 292 }
 293
 294 void
 295 update_ov_primary_symset(const struct symparse *symp, int val)
 296 {
 297     go.ov_primary_syms[symp->idx] = val;
 298 }
 299
 300 void
 301 update_ov_rogue_symset(const struct symparse *symp, int val)
 302 {
 303     go.ov_rogue_syms[symp->idx] = val;
 304 }
 305
 306 void
 307 update_primary_symset(const struct symparse *symp, int val)
 308 {
 309     gp.primary_syms[symp->idx] = val;
 310 }
 311
 312 void
 313 update_rogue_symset(const struct symparse *symp, int val)
 314 {
 315     gr.rogue_syms[symp->idx] = val;
 316 }
 317
 318 void
 319 clear_symsetentry(int which_set, boolean name_too)
 320 {
 321 #ifdef ENHANCED_SYMBOLS
 322     int other_set = (which_set == PRIMARYSET) ? ROGUESET : PRIMARYSET;
 323     enum symset_handling_types old_handling = gs.symset[which_set].handling;
 324 #endif
 325
 326     if (gs.symset[which_set].desc)
 327         free((genericptr_t) gs.symset[which_set].desc);
 328     gs.symset[which_set].desc = (char *) 0;
 329
 330     gs.symset[which_set].handling = H_UNK;
 331     gs.symset[which_set].nocolor = 0;
 332     /* initialize restriction bits */
 333     gs.symset[which_set].primary = 0;
 334     gs.symset[which_set].rogue = 0;
 335
 336     if (name_too) {
 337         if (gs.symset[which_set].name)
 338             free((genericptr_t) gs.symset[which_set].name);
 339         gs.symset[which_set].name = (char *) 0;
 340     }
 341 #ifdef ENHANCED_SYMBOLS
 342     /* if 'which_set' was using UTF8, it isn't anymore; if the other set
 343        isn't using UTF8, discard the data for that */
 344     if (old_handling == H_UTF8 && gs.symset[other_set].handling != H_UTF8)
 345         free_all_glyphmap_u();
 346 #endif
 347     purge_custom_entries(which_set);
 348     clear_all_glyphmap_colors();
 349 }
 350
 351 /* called from windmain.c */
 352 boolean
 353 symset_is_compatible(
 354     enum symset_handling_types handling,
 355     unsigned long wincap2)
 356 {
 357 #ifdef ENHANCED_SYMBOLS
 358 #define WC2_utf8_bits (WC2_U_UTF8STR)
 359     if (handling == H_UTF8 && ((wincap2 & WC2_utf8_bits) != WC2_utf8_bits))
 360         return FALSE;
 361 #undef WC2_bits
 362 #else
 363     nhUse(handling);
 364     nhUse(wincap2);
 365 #endif
 366     return TRUE;
 367 }
 368
 369 /*
 370  * If you are adding code somewhere to be able to recognize
 371  * particular types of symset "handling", define a
 372  * H_XXX macro in include/sym.h and add the name
 373  * to this array at the matching offset.
 374  * Externally referenced from files.c, options.c, utf8map.c.
 375  */
 376 const char *const known_handling[] = {
 377     "UNKNOWN", /* H_UNK  */
 378     "IBM",     /* H_IBM  */
 379     "DEC",     /* H_DEC  */
 380     "CURS",    /* H_CURS */
 381     "MAC",     /* H_MAC  -- pre-OSX MACgraphics */
 382     "UTF8",    /* H_UTF8 */
 383     (const char *) 0,
 384 };
 385
 386 /*
 387  * Accepted keywords for symset restrictions.
 388  * These can be virtually anything that you want to
 389  * be able to test in the code someplace.
 390  * Be sure to:
 391  *    - add a corresponding Bitfield to the symsetentry struct in sym.h
 392  *    - initialize the field to zero in parse_sym_line in the SYM_CONTROL
 393  *      case 0 section of the idx switch. The location is prefaced with
 394  *      with a comment stating "initialize restriction bits".
 395  *    - set the value appropriately based on the index of your keyword
 396  *      under the case 5 sections of the same SYM_CONTROL idx switches.
 397  *    - add the field to clear_symsetentry()
 398  */
 399 const char *const known_restrictions[] = {
 400     "primary", "rogue", (const char *) 0,
 401 };
 402
 403 const struct symparse loadsyms[] = {
 404     { SYM_CONTROL, 0, "start" },
 405     { SYM_CONTROL, 0, "begin" },
 406     { SYM_CONTROL, 1, "finish" },
 407     { SYM_CONTROL, 2, "handling" },
 408     { SYM_CONTROL, 3, "description" },
 409     { SYM_CONTROL, 4, "color" },
 410     { SYM_CONTROL, 4, "colour" },
 411     { SYM_CONTROL, 5, "restrictions" },
 412 #define PCHAR_PARSE
 413 #include "defsym.h"
 414 #undef PCHAR_PARSE
 415 #define OBJCLASS_PARSE
 416 #include "defsym.h"
 417 #undef OBJCLASS_PARSE
 418 #define MONSYMS_PARSE
 419 #include "defsym.h"
 420 #undef MONSYMS_PARSE
 421     { SYM_OTH, SYM_NOTHING + SYM_OFF_X, "S_nothing" },
 422     { SYM_OTH, SYM_UNEXPLORED + SYM_OFF_X, "S_unexplored" },
 423     { SYM_OTH, SYM_BOULDER + SYM_OFF_X, "S_boulder" },
 424     { SYM_OTH, SYM_INVISIBLE + SYM_OFF_X, "S_invisible" },
 425     { SYM_OTH, SYM_PET_OVERRIDE + SYM_OFF_X, "S_pet_override" },
 426     { SYM_OTH, SYM_HERO_OVERRIDE + SYM_OFF_X, "S_hero_override" },
 427     { SYM_INVALID, 0, (const char *) 0 } /* fence post */
 428 };
 429
 430 boolean
 431 proc_symset_line(char *buf)
 432 {
 433     return !((boolean) parse_sym_line(buf, gs.symset_which_set));
 434 }
 435
 436 /* returns 0 on error */
 437 int
 438 parse_sym_line(char *buf, int which_set)
 439 {
 440     int val, i;
 441     const struct symparse *symp = (struct symparse *) 0;
 442     char *bufp, *commentp, *altp;
 443     int glyph = NO_GLYPH;
 444     boolean enhanced_unavailable = FALSE, is_glyph = FALSE;
 445
 446     if (strlen(buf) >= BUFSZ)
 447         buf[BUFSZ - 1] = '\0';
 448     /* convert each instance of whitespace (tabs, consecutive spaces)
 449        into a single space; leading and trailing spaces are stripped */
 450     mungspaces(buf);
 451
 452     /* remove trailing comment, if any (this isn't strictly needed for
 453        individual symbols, and it won't matter if "X#comment" without
 454        separating space slips through; for handling or set description,
 455        symbol set creator is responsible for preceding '#' with a space
 456        and that comment itself doesn't contain " #") */
 457     if ((commentp = strrchr(buf, '#')) != 0 && commentp[-1] == ' ')
 458         commentp[-1] = '\0';
 459
 460     /* find the '=' or ':' */
 461     bufp = strchr(buf, '=');
 462     altp = strchr(buf, ':');
 463
 464     if (!bufp || (altp && altp < bufp))
 465         bufp = altp;
 466
 467     if (!bufp) {
 468         if (strncmpi(buf, "finish", 6) == 0) {
 469             /* end current graphics set */
 470             if (gc.chosen_symset_start)
 471                 gc.chosen_symset_end = TRUE;
 472             gc.chosen_symset_start = FALSE;
 473             return 1;
 474         }
 475         config_error_add("No \"finish\"");
 476         return 0;
 477     }
 478     /* skip '=' and space which follows, if any */
 479     ++bufp;
 480     if (*bufp == ' ')
 481         ++bufp;
 482
 483     symp = match_sym(buf);
 484     if (!symp && buf[0] == 'G' && buf[1] == '_') {
 485         if (gc.chosen_symset_start) {
 486             is_glyph = match_glyph(buf);
 487         } else {
 488             is_glyph = TRUE; /* report error only once */
 489         }
 490 #ifdef ENHANCED_SYMBOLS
 491         enhanced_unavailable = FALSE;
 492 #else
 493         enhanced_unavailable = TRUE;
 494 #endif
 495     }
 496     if (!symp && !is_glyph && !enhanced_unavailable) {
 497         config_error_add("Unknown sym keyword");
 498         return 0;
 499     }
 500     if (symp) {
 501         if (!gs.symset[which_set].name) {
 502             /* A null symset name indicates that we're just
 503                building a pick-list of possible symset
 504                values from the file, so only do that */
 505             if (symp->range == SYM_CONTROL) {
 506                 struct symsetentry *tmpsp, *lastsp;
 507
 508                 for (lastsp = gs.symset_list; lastsp; lastsp = lastsp->next)
 509                     if (!lastsp->next)
 510                         break;
 511                 switch (symp->idx) {
 512                 case 0:
 513                     tmpsp = (struct symsetentry *) alloc(sizeof *tmpsp);
 514                     tmpsp->next = (struct symsetentry *) 0;
 515                     if (!lastsp)
 516                         gs.symset_list = tmpsp;
 517                     else
 518                         lastsp->next = tmpsp;
 519                     tmpsp->idx = gs.symset_count++;
 520                     tmpsp->name = dupstr(bufp);
 521                     tmpsp->desc = (char *) 0;
 522                     tmpsp->handling = H_UNK;
 523                     /* initialize restriction bits */
 524                     tmpsp->nocolor = 0;
 525                     tmpsp->primary = 0;
 526                     tmpsp->rogue = 0;
 527                     break;
 528                 case 2:
 529                     /* handler type identified */
 530                     tmpsp = lastsp; /* most recent symset */
 531                     for (i = 0; known_handling[i]; ++i)
 532                         if (!strcmpi(known_handling[i], bufp)) {
 533                             if (tmpsp)
 534                                 tmpsp->handling = i;
 535                             break; /* for loop */
 536                         }
 537                     break;
 538                 case 3:
 539                     /* description:something */
 540                     tmpsp = lastsp; /* most recent symset */
 541                     if (tmpsp && !tmpsp->desc)
 542                         tmpsp->desc = dupstr(bufp);
 543                     break;
 544                 case 5:
 545                     /* restrictions: xxxx*/
 546                     tmpsp = lastsp; /* most recent symset */
 547                     for (i = 0; known_restrictions[i]; ++i) {
 548                         if (!strcmpi(known_restrictions[i], bufp)) {
 549                             if (tmpsp) {
 550                                 switch (i) {
 551                                 case 0:
 552                                     tmpsp->primary = 1;
 553                                     break;
 554                                 case 1:
 555                                     tmpsp->rogue = 1;
 556                                     break;
 557                                 }
 558                             }
 559                             break; /* while loop */
 560                         }
 561                     }
 562                     break;
 563                 }
 564             }
 565             return 1;
 566         }
 567         if (symp->range && symp->range == SYM_CONTROL) {
 568             switch (symp->idx) {
 569             case 0:
 570                 /* start of symset */
 571                 if (!strcmpi(bufp, gs.symset[which_set].name)) {
 572                     /* matches desired one */
 573                     gc.chosen_symset_start = TRUE;
 574                     /* these init_*() functions clear symset fields too */
 575                     if (which_set == ROGUESET)
 576                         init_rogue_symbols();
 577                     else if (which_set == PRIMARYSET)
 578                         init_primary_symbols();
 579                 }
 580                 break;
 581             case 1:
 582                 /* finish symset */
 583                 if (gc.chosen_symset_start)
 584                     gc.chosen_symset_end = TRUE;
 585                 gc.chosen_symset_start = FALSE;
 586                 break;
 587             case 2:
 588                 /* handler type identified */
 589                 if (gc.chosen_symset_start)
 590                     set_symhandling(bufp, which_set);
 591                 break;
 592             /* case 3: (description) is ignored here */
 593             case 4: /* color:off */
 594                 if (gc.chosen_symset_start) {
 595                     if (bufp) {
 596                         if (!strcmpi(bufp, "true") || !strcmpi(bufp, "yes")
 597                             || !strcmpi(bufp, "on"))
 598                             gs.symset[which_set].nocolor = 0;
 599                         else if (!strcmpi(bufp, "false")
 600                                  || !strcmpi(bufp, "no")
 601                                  || !strcmpi(bufp, "off"))
 602                             gs.symset[which_set].nocolor = 1;
 603                     }
 604                 }
 605                 break;
 606             case 5: /* restrictions: xxxx*/
 607                 if (gc.chosen_symset_start) {
 608                     int n = 0;
 609
 610                     while (known_restrictions[n]) {
 611                         if (!strcmpi(known_restrictions[n], bufp)) {
 612                             switch (n) {
 613                             case 0:
 614                                 gs.symset[which_set].primary = 1;
 615                                 break;
 616                             case 1:
 617                                 gs.symset[which_set].rogue = 1;
 618                                 break;
 619                             }
 620                             break; /* while loop */
 621                         }
 622                         n++;
 623                     }
 624                 }
 625                 break;
 626             }
 627         } else {
 628             /* Not SYM_CONTROL */
 629             if (gs.symset[which_set].handling != H_UTF8) {
 630                 if (gc.chosen_symset_start) {
 631                     val = sym_val(bufp);
 632                     if (which_set == PRIMARYSET) {
 633                         update_primary_symset(symp, val);
 634                     } else if (which_set == ROGUESET) {
 635                         update_rogue_symset(symp, val);
 636                     }
 637                 }
 638 #ifdef ENHANCED_SYMBOLS
 639             } else {
 640                 if (gc.chosen_symset_start) {
 641                     glyphrep_to_custom_map_entries(buf, &glyph);
 642                 }
 643 #endif
 644             }
 645         }
 646     } else if (gc.chosen_symset_start) {
 647         /* glyph, not symbol */
 648         glyphrep_to_custom_map_entries(buf, &glyph);
 649     }
 650 #ifndef ENHANCED_SYMBOLS
 651     nhUse(glyph);
 652 #endif
 653     return 1;
 654 }
 655
 656 void
 657 set_symhandling(char *handling, int which_set)
 658 {
 659     int i = 0;
 660
 661     gs.symset[which_set].handling = H_UNK;
 662     while (known_handling[i]) {
 663         if (!strcmpi(known_handling[i], handling)) {
 664             gs.symset[which_set].handling = i;
 665             return;
 666         }
 667         i++;
 668     }
 669 }
 670
 671 /* bundle some common usage into one easy-to-use routine */
 672 int
 673 load_symset(const char *s, int which_set)
 674 {
 675     clear_symsetentry(which_set, TRUE);
 676
 677     if (gs.symset[which_set].name)
 678         free((genericptr_t) gs.symset[which_set].name);
 679     gs.symset[which_set].name = dupstr(s);
 680
 681     if (read_sym_file(which_set)) {
 682         switch_symbols(TRUE);
 683         apply_customizations(gc.currentgraphics,
 684                              do_custom_symbols | do_custom_colors);
 685     } else {
 686         clear_symsetentry(which_set, TRUE);
 687         return 0;
 688     }
 689     return 1;
 690 }
 691
 692 void
 693 free_symsets(void)
 694 {
 695     clear_symsetentry(PRIMARYSET, TRUE);
 696     clear_symsetentry(ROGUESET, TRUE);
 697
 698     /* symset_list is cleaned up as soon as it's used, so we shouldn't
 699        have to anything about it here */
 700     /* assert( symset_list == NULL ); */
 701 }
 702
 703 struct _savedsym {
 704     char *name;
 705     char *val;
 706     int which_set;
 707     struct _savedsym *next;
 708 };
 709 struct _savedsym *saved_symbols = NULL;
 710
 711 void
 712 savedsym_free(void)
 713 {
 714     struct _savedsym *tmp = saved_symbols, *tmp2;
 715
 716     while (tmp) {
 717         tmp2 = tmp->next;
 718         free(tmp->name);
 719         free(tmp->val);
 720         free(tmp);
 721         tmp = tmp2;
 722     }
 723 }
 724
 725 staticfn struct _savedsym *
 726 savedsym_find(const char *name, int which_set)
 727 {
 728     struct _savedsym *tmp = saved_symbols;
 729
 730     while (tmp) {
 731         if (which_set == tmp->which_set && !strcmp(name, tmp->name))
 732             return tmp;
 733         tmp = tmp->next;
 734     }
 735     return NULL;
 736 }
 737
 738 staticfn void
 739 savedsym_add(const char *name, const char *val, int which_set)
 740 {
 741     struct _savedsym *tmp = NULL;
 742
 743     if ((tmp = savedsym_find(name, which_set)) != 0) {
 744         free(tmp->val);
 745         tmp->val = dupstr(val);
 746     } else {
 747         tmp = (struct _savedsym *) alloc(sizeof *tmp);
 748         tmp->name = dupstr(name);
 749         tmp->val = dupstr(val);
 750         tmp->which_set = which_set;
 751         tmp->next = saved_symbols;
 752         saved_symbols = tmp;
 753     }
 754 }
 755
 756 void
 757 savedsym_strbuf(strbuf_t *sbuf)
 758 {
 759     struct _savedsym *tmp = saved_symbols;
 760     char buf[BUFSZ];
 761
 762     while (tmp) {
 763         Sprintf(buf, "%sSYMBOLS=%s:%s\n",
 764                 (tmp->which_set == ROGUESET) ? "ROGUE" : "",
 765                 tmp->name, tmp->val);
 766         strbuf_append(sbuf, buf);
 767         tmp = tmp->next;
 768     }
 769 }
 770
 771 /* Parse the value of a SYMBOLS line from a config file */
 772 boolean
 773 parsesymbols(char *opts, int which_set)
 774 {
 775     int val;
 776     char *symname, *strval, *ch,
 777          *first_unquoted_comma = 0, *first_unquoted_colon = 0;
 778     const struct symparse *symp;
 779     boolean is_glyph = FALSE;
 780
 781     /* are there any commas or colons that aren't quoted? */
 782     for (ch = opts + 1; *ch; ++ch) {
 783         char *prech, *postch;
 784
 785         prech = ch - 1;
 786         postch = ch + 1;
 787         if (!*postch)
 788             break;
 789         if (*ch == ',') {
 790             if (*prech == '\'' && *postch == '\'')
 791                 continue;
 792             if (*prech == '\\')
 793                 continue;
 794         }
 795         if (*ch == ':') {
 796             if (*prech == '\'' && *postch == '\'')
 797                 continue;
 798         }
 799         if (*ch == ',' && !first_unquoted_comma)
 800             first_unquoted_comma = ch;
 801         if (*ch == ':' && !first_unquoted_colon)
 802             first_unquoted_colon = ch;
 803     }
 804     if (first_unquoted_comma != 0) {
 805         *first_unquoted_comma++ = '\0';
 806         if (!parsesymbols(first_unquoted_comma, which_set))
 807             return FALSE;
 808     }
 809
 810     /* S_sample:string */
 811     symname = opts;
 812     strval = first_unquoted_colon;
 813     if (!strval)
 814         strval = strchr(opts, '=');
 815     if (!strval)
 816         return FALSE;
 817     *strval++ = '\0';
 818
 819     /* strip leading and trailing white space from symname and strval */
 820     mungspaces(symname);
 821     mungspaces(strval);
 822
 823     symp = match_sym(symname);
 824     if (!symp && symname[0] == 'G' && symname[1] == '_') {
 825         is_glyph = match_glyph(symname);
 826     }
 827     if (!symp && !is_glyph)
 828         return FALSE;
 829     if (symp) {
 830         if (symp->range && symp->range != SYM_CONTROL) {
 831             if (gs.symset[which_set].handling == H_UTF8
 832                 || (lowc(strval[0]) == 'u' && strval[1] == '+')) {
 833                 char buf[BUFSZ];
 834                 int glyph;
 835
 836                 Snprintf(buf, sizeof buf, "%s:%s", opts, strval);
 837                 glyphrep_to_custom_map_entries(buf, &glyph);
 838             } else {
 839                     val = sym_val(strval);
 840                     if (which_set == ROGUESET)
 841                         update_ov_rogue_symset(symp, val);
 842                     else
 843                         update_ov_primary_symset(symp, val);
 844             }
 845         }
 846     }
 847     savedsym_add(opts, strval, which_set);
 848     return TRUE;
 849 }
 850
 851 const struct symparse *
 852 match_sym(char *buf)
 853 {
 854     static struct alternate_parse {
 855         const char *altnm;
 856         const char *nm;
 857     } alternates[] = {
 858         { "S_armour", "S_armor" },
 859         /* alt explosion names are numbered in phone key/button layout */
 860         { "S_explode1", "S_expl_tl" },
 861         { "S_explode2", "S_expl_tc" }, { "S_explode3", "S_expl_tr" },
 862         { "S_explode4", "S_expl_ml" }, { "S_explode5", "S_expl_mc" },
 863         { "S_explode6", "S_expl_mr" }, { "S_explode7", "S_expl_bl" },
 864         { "S_explode8", "S_expl_bc" }, { "S_explode9", "S_expl_br" },
 865     };
 866     int i;
 867     size_t len = strlen(buf);
 868     const char *p = strchr(buf, ':'), *q = strchr(buf, '=');
 869     const struct symparse *sp = loadsyms;
 870
 871     /* G_ lines will never match here */
 872     if ((buf[0] == 'G' || buf[0] == 'g') && buf[1] == '_')
 873         return (struct symparse *) 0;
 874
 875     if (!p || (q && q < p))
 876         p = q;
 877     if (p) {
 878         /* note: there will be at most one space before the '='
 879            because caller has condensed buf[] with mungspaces() */
 880         if (p > buf && p[-1] == ' ')
 881             p--;
 882         len = (int) (p - buf);
 883     }
 884     while (sp->range) {
 885         if ((len >= strlen(sp->name)) && !strncmpi(buf, sp->name, len))
 886             return sp;
 887         sp++;
 888     }
 889     for (i = 0; i < SIZE(alternates); ++i) {
 890         if ((len >= strlen(alternates[i].altnm))
 891             && !strncmpi(buf, alternates[i].altnm, len)) {
 892             sp = loadsyms;
 893             while (sp->range) {
 894                 if (!strcmp(alternates[i].nm, sp->name))
 895                     return sp;
 896                 sp++;
 897             }
 898         }
 899     }
 900     return (struct symparse *) 0;
 901 }
 902
 903 DISABLE_WARNING_FORMAT_NONLITERAL
 904
 905 /*
 906  * this is called from options.c to do the symset work.
 907  */
 908 int
 909 do_symset(boolean rogueflag)
 910 {
 911     winid tmpwin;
 912     anything any;
 913     int n;
 914     char buf[BUFSZ];
 915     menu_item *symset_pick = (menu_item *) 0;
 916     boolean ready_to_switch = FALSE,
 917             nothing_to_do = FALSE;
 918     char *symset_name, fmtstr[20];
 919     struct symsetentry *sl;
 920     int res, which_set, setcount = 0, chosen = -2, defindx = 0;
 921     int clr = NO_COLOR;
 922
 923     which_set = rogueflag ? ROGUESET : PRIMARYSET;
 924     gs.symset_list = (struct symsetentry *) 0;
 925     /* clear symset[].name as a flag to read_sym_file() to build list */
 926     symset_name = gs.symset[which_set].name;
 927     gs.symset[which_set].name = (char *) 0;
 928
 929     res = read_sym_file(which_set);
 930     /* put symset name back */
 931     gs.symset[which_set].name = symset_name;
 932
 933     if (res && gs.symset_list) {
 934         int thissize,
 935             biggest = (int) (sizeof "Default Symbols" - sizeof ""),
 936             big_desc = 0;
 937
 938         for (sl = gs.symset_list; sl; sl = sl->next) {
 939             /* check restrictions */
 940             if (rogueflag ? sl->primary : sl->rogue)
 941                 continue;
 942 #ifndef MAC_GRAPHICS_ENV
 943             if (sl->handling == H_MAC)
 944                 continue;
 945 #endif
 946 #ifndef ENHANCED_SYMBOLS
 947             if (sl->handling == H_UTF8)
 948                 continue;
 949 #endif
 950             setcount++;
 951             /* find biggest name */
 952             thissize = sl->name ? (int) strlen(sl->name) : 0;
 953             if (thissize > biggest)
 954                 biggest = thissize;
 955             thissize = sl->desc ? (int) strlen(sl->desc) : 0;
 956             if (thissize > big_desc)
 957                 big_desc = thissize;
 958         }
 959         if (!setcount) {
 960             There("are no appropriate %s symbol sets available.",
 961                   rogueflag ? "rogue level" : "primary");
 962             return TRUE;
 963         }
 964
 965         Sprintf(fmtstr, "%%-%ds %%s", biggest + 2);
 966         tmpwin = create_nhwindow(NHW_MENU);
 967         start_menu(tmpwin, MENU_BEHAVE_STANDARD);
 968         any = cg.zeroany;
 969         any.a_int = 1; /* -1 + 2 [see 'if (sl->name) {' below]*/
 970         if (!symset_name)
 971             defindx = any.a_int;
 972         add_menu(tmpwin, &nul_glyphinfo, &any, 0, 0, ATR_NONE,
 973                  clr, "Default Symbols",
 974                  (any.a_int == defindx) ? MENU_ITEMFLAGS_SELECTED
 975                                         : MENU_ITEMFLAGS_NONE);
 976
 977         for (sl = gs.symset_list; sl; sl = sl->next) {
 978             /* check restrictions */
 979             if (rogueflag ? sl->primary : sl->rogue)
 980                 continue;
 981 #ifndef MAC_GRAPHICS_ENV
 982             if (sl->handling == H_MAC)
 983                 continue;
 984 #endif
 985 #ifndef ENHANCED_SYMBOLS
 986             if (sl->handling == H_UTF8)
 987                 continue;
 988 #endif
 989             if (sl->name) {
 990                 /* +2: sl->idx runs from 0 to N-1 for N symsets;
 991                    +1 because Defaults are implicitly in slot [0];
 992                    +1 again so that valid data is never 0 */
 993                 any.a_int = sl->idx + 2;
 994                 if (symset_name && !strcmpi(sl->name, symset_name))
 995                     defindx = any.a_int;
 996                 Sprintf(buf, fmtstr, sl->name, sl->desc ? sl->desc : "");
 997                 add_menu(tmpwin, &nul_glyphinfo, &any, 0, 0,
 998                          ATR_NONE, clr, buf,
 999                          (any.a_int == defindx) ? MENU_ITEMFLAGS_SELECTED
1000                                                 : MENU_ITEMFLAGS_NONE);
1001             }
1002         }
1003         Sprintf(buf, "Select %ssymbol set:",
1004                 rogueflag ? "rogue level " : "");
1005         end_menu(tmpwin, buf);
1006         n = select_menu(tmpwin, PICK_ONE, &symset_pick);
1007         if (n > 0) {
1008             chosen = symset_pick[0].item.a_int;
1009             /* if picking non-preselected entry yields 2, make sure
1010                that we're going with the non-preselected one */
1011             if (n == 2 && chosen == defindx)
1012                 chosen = symset_pick[1].item.a_int;
1013             chosen -= 2; /* convert menu index to symset index;
1014                           * "Default symbols" have index -1 */
1015             free((genericptr_t) symset_pick);
1016         } else if (n == 0 && defindx > 0) {
1017             chosen = defindx - 2;
1018         }
1019         destroy_nhwindow(tmpwin);
1020
1021         if (chosen > -1) {
1022             /* chose an actual symset name from file */
1023             for (sl = gs.symset_list; sl; sl = sl->next)
1024                 if (sl->idx == chosen)
1025                     break;
1026             if (sl) {
1027                 /* free the now stale attributes */
1028                 clear_symsetentry(which_set, TRUE);
1029
1030                 /* transfer only the name of the symbol set */
1031                 gs.symset[which_set].name = dupstr(sl->name);
1032                 ready_to_switch = TRUE;
1033             }
1034         } else if (chosen == -1) {
1035             /* explicit selection of defaults */
1036             /* free the now stale symset attributes */
1037             clear_symsetentry(which_set, TRUE);
1038         } else
1039             nothing_to_do = TRUE;
1040     } else if (!res) {
1041         /* The symbols file could not be accessed */
1042         pline("Unable to access \"%s\" file.", SYMBOLS);
1043         return TRUE;
1044     } else if (!gs.symset_list) {
1045         /* The symbols file was empty */
1046         There("were no symbol sets found in \"%s\".", SYMBOLS);
1047         return TRUE;
1048     }
1049
1050     /* clean up */
1051     while ((sl = gs.symset_list) != 0) {
1052         gs.symset_list = sl->next;
1053         if (sl->name)
1054             free((genericptr_t) sl->name), sl->name = (char *) 0;
1055         if (sl->desc)
1056             free((genericptr_t) sl->desc), sl->desc = (char *) 0;
1057         free((genericptr_t) sl);
1058     }
1059
1060     if (nothing_to_do)
1061         return TRUE;
1062
1063     /* Set default symbols and clear the handling value */
1064     if (rogueflag)
1065         init_rogue_symbols();
1066     else
1067         init_primary_symbols();
1068
1069     if (gs.symset[which_set].name) {
1070         /* non-default symbols */
1071         int ok;
1072         if (!glyphid_cache_status()) {
1073             fill_glyphid_cache();
1074         }
1075         ok = read_sym_file(which_set);
1076         if (glyphid_cache_status()) {
1077             free_glyphid_cache();
1078         }
1079         if (ok) {
1080             ready_to_switch = TRUE;
1081         } else {
1082             clear_symsetentry(which_set, TRUE);
1083             return TRUE;
1084         }
1085     }
1086
1087     if (ready_to_switch)
1088         switch_symbols(TRUE);
1089
1090     if (Is_rogue_level(&u.uz)) {
1091         if (rogueflag)
1092             assign_graphics(ROGUESET);
1093     } else if (!rogueflag)
1094         assign_graphics(PRIMARYSET);
1095     apply_customizations(rogueflag ? ROGUESET : PRIMARYSET,
1096                          (do_custom_symbols | do_custom_colors));
1097     preference_update("symset");
1098     return TRUE;
1099 }
1100
1101 RESTORE_WARNING_FORMAT_NONLITERAL
1102
1103 /*symbols.c*/