#ifdef OPTION_LISTS_ONLY /* (AMIGA) external program for opt lists */

#include "config.h"

#include "objclass.h"

#include "flag.h"

NEARDATA struct flag flags; /* provide linkage */

#ifdef SYSFLAGS

NEARDATA struct sysflag sysflags; /* provide linkage */

NEARDATA struct instance_flags iflags; /* provide linkage */

#define static

#include "hack.h"

#include "tcap.h"

#include <ctype.h>

#define BACKWARD_COMPAT

#define WINTYPELEN 16

#ifdef DEFAULT_WC_TILED_MAP

#define PREFER_TILED TRUE

#define PREFER_TILED FALSE

#define MESSAGE_OPTION 1

#define STATUS_OPTION 2

#define MAP_OPTION 3

#define MENU_OPTION 4

#define TEXT_OPTION 5

#define PILE_LIMIT_DFLT 5

static struct Bool_Opt {

} boolopt[] = {

{ "acoustics", &flags.acoustics, TRUE, SET_IN_GAME },

#if defined(SYSFLAGS) && defined(AMIGA)

/* Amiga altmeta causes Alt+key to be converted into Meta+key by

{ "altmeta", &sysflags.altmeta, TRUE, DISP_IN_GAME },

#ifdef ALTMETA

/* non-Amiga altmeta causes nethack's top level command loop to treat

{ "altmeta", &iflags.altmeta, FALSE, SET_IN_GAME },

{ "altmeta", (boolean *) 0, TRUE, DISP_IN_GAME },

{ "ascii_map", &iflags.wc_ascii_map, !PREFER_TILED, SET_IN_GAME }, /*WC*/

#if defined(SYSFLAGS) && defined(MFLOPPY)

{ "asksavedisk", &sysflags.asksavedisk, FALSE, SET_IN_GAME },

{ "asksavedisk", (boolean *) 0, FALSE, SET_IN_FILE },

{ "autodescribe", &iflags.autodescribe, FALSE, SET_IN_GAME },

{ "autodig", &flags.autodig, FALSE, SET_IN_GAME },

{ "autoopen", &flags.autoopen, TRUE, SET_IN_GAME },

{ "autopickup", &flags.pickup, TRUE, SET_IN_GAME },

{ "autoquiver", &flags.autoquiver, FALSE, SET_IN_GAME },

#if defined(MICRO) && !defined(AMIGA)

{ "BIOS", &iflags.BIOS, FALSE, SET_IN_FILE },

{ "BIOS", (boolean *) 0, FALSE, SET_IN_FILE },

{ "blind", &u.uroleplay.blind, FALSE, DISP_IN_GAME },

{ "bones", &flags.bones, TRUE, SET_IN_FILE },

#ifdef INSURANCE

{ "checkpoint", &flags.ins_chkpt, TRUE, SET_IN_GAME },

{ "checkpoint", (boolean *) 0, FALSE, SET_IN_FILE },

#ifdef MFLOPPY

{ "checkspace", &iflags.checkspace, TRUE, SET_IN_GAME },

{ "checkspace", (boolean *) 0, FALSE, SET_IN_FILE },

{ "clicklook", &iflags.clicklook, FALSE, SET_IN_GAME },

{ "cmdassist", &iflags.cmdassist, TRUE, SET_IN_GAME },

#if defined(MICRO) || defined(WIN32)

{ "color", &iflags.wc_color, TRUE, SET_IN_GAME }, /*WC*/

#else /* systems that support multiple terminals, many monochrome */

{ "color", &iflags.wc_color, FALSE, SET_IN_GAME }, /*WC*/

{ "confirm", &flags.confirm, TRUE, SET_IN_GAME },

{ "dark_room", &flags.dark_room, TRUE, SET_IN_GAME },

{ "eight_bit_tty", &iflags.wc_eight_bit_input, FALSE,

SET_IN_GAME }, /*WC*/

#ifdef TTY_GRAPHICS

{ "extmenu", &iflags.extmenu, FALSE, SET_IN_GAME },

{ "extmenu", (boolean *) 0, FALSE, SET_IN_FILE },

#ifdef OPT_DISPMAP

{ "fast_map", &flags.fast_map, TRUE, SET_IN_GAME },

{ "fast_map", (boolean *) 0, TRUE, SET_IN_FILE },

{ "female", &flags.female, FALSE, DISP_IN_GAME },

{ "fixinv", &flags.invlet_constant, TRUE, SET_IN_GAME },

#if defined(SYSFLAGS) && defined(AMIFLUSH)

{ "flush", &sysflags.amiflush, FALSE, SET_IN_GAME },

{ "flush", (boolean *) 0, FALSE, SET_IN_FILE },

{ "fullscreen", &iflags.wc2_fullscreen, FALSE, SET_IN_FILE },

{ "help", &flags.help, TRUE, SET_IN_GAME },

{ "hilite_pet", &iflags.wc_hilite_pet, FALSE, SET_IN_GAME }, /*WC*/

{ "hilite_pile", &iflags.hilite_pile, FALSE, SET_IN_GAME },

#ifndef MAC

{ "ignintr", &flags.ignintr, FALSE, SET_IN_GAME },

{ "ignintr", (boolean *) 0, FALSE, SET_IN_FILE },

{ "implicit_uncursed", &iflags.implicit_uncursed, TRUE, SET_IN_GAME },

{ "large_font", &iflags.obsolete, FALSE, SET_IN_FILE }, /* OBSOLETE */

{ "legacy", &flags.legacy, TRUE, DISP_IN_GAME },

{ "lit_corridor", &flags.lit_corridor, FALSE, SET_IN_GAME },

{ "lootabc", &flags.lootabc, FALSE, SET_IN_GAME },

#ifdef MAIL

{ "mail", &flags.biff, TRUE, SET_IN_GAME },

{ "mail", (boolean *) 0, TRUE, SET_IN_FILE },

{ "mention_walls", &iflags.mention_walls, FALSE, SET_IN_GAME },

{ "menucolors", &iflags.use_menu_color, FALSE, SET_IN_GAME },

/* for menu debugging only*/

{ "menu_tab_sep", &iflags.menu_tab_sep, FALSE, SET_IN_WIZGAME },

{ "menu_objsyms", &iflags.menu_head_objsym, FALSE, SET_IN_GAME },

#ifdef TTY_GRAPHICS

{ "menu_overlay", &iflags.menu_overlay, TRUE, SET_IN_GAME },

{ "menu_overlay", (boolean *) 0, FALSE, SET_IN_FILE },

{ "mouse_support", &iflags.wc_mouse_support, TRUE, DISP_IN_GAME }, /*WC*/

#ifdef NEWS

{ "news", &iflags.news, TRUE, DISP_IN_GAME },

{ "news", (boolean *) 0, FALSE, SET_IN_FILE },

{ "nudist", &u.uroleplay.nudist, FALSE, DISP_IN_GAME },

{ "null", &flags.null, TRUE, SET_IN_GAME },

#if defined(SYSFLAGS) && defined(MAC)

{ "page_wait", &sysflags.page_wait, TRUE, SET_IN_GAME },

{ "page_wait", (boolean *) 0, FALSE, SET_IN_FILE },

{ "perm_invent", &flags.perm_invent, FALSE, SET_IN_GAME },

{ "pickup_thrown", &flags.pickup_thrown, TRUE, SET_IN_GAME },

{ "popup_dialog", &iflags.wc_popup_dialog, FALSE, SET_IN_GAME }, /*WC*/

{ "preload_tiles", &iflags.wc_preload_tiles, TRUE, DISP_IN_GAME }, /*WC*/

{ "pushweapon", &flags.pushweapon, FALSE, SET_IN_GAME },

#if defined(MICRO) && !defined(AMIGA)

{ "rawio", &iflags.rawio, FALSE, DISP_IN_GAME },

{ "rawio", (boolean *) 0, FALSE, SET_IN_FILE },

{ "rest_on_space", &flags.rest_on_space, FALSE, SET_IN_GAME },

#ifdef RLECOMP

{ "rlecomp", &iflags.rlecomp,

#if defined(COMPRESS) || defined(ZLIB_COMP)

FALSE,

TRUE,

DISP_IN_GAME },

{ "safe_pet", &flags.safe_dog, TRUE, SET_IN_GAME },

{ "sanity_check", &iflags.sanity_check, FALSE, SET_IN_WIZGAME },

{ "selectsaved", &iflags.wc2_selectsaved, TRUE, DISP_IN_GAME }, /*WC*/

{ "showexp", &flags.showexp, FALSE, SET_IN_GAME },

{ "showrace", &flags.showrace, FALSE, SET_IN_GAME },

#ifdef SCORE_ON_BOTL

{ "showscore", &flags.showscore, FALSE, SET_IN_GAME },

{ "showscore", (boolean *) 0, FALSE, SET_IN_FILE },

{ "silent", &flags.silent, TRUE, SET_IN_GAME },

{ "softkeyboard", &iflags.wc2_softkeyboard, FALSE, SET_IN_FILE },

{ "sortpack", &flags.sortpack, TRUE, SET_IN_GAME },

{ "sparkle", &flags.sparkle, TRUE, SET_IN_GAME },

{ "splash_screen", &iflags.wc_splash_screen, TRUE, DISP_IN_GAME }, /*WC*/

{ "standout", &flags.standout, FALSE, SET_IN_GAME },

#if defined(STATUS_VIA_WINDOWPORT) && defined(STATUS_HILITES)

{ "statushilites", &iflags.use_status_hilites, TRUE, SET_IN_GAME },

{ "statushilites", &iflags.use_status_hilites, FALSE, DISP_IN_GAME },

{ "tiled_map", &iflags.wc_tiled_map, PREFER_TILED, DISP_IN_GAME }, /*WC*/

{ "time", &flags.time, FALSE, SET_IN_GAME },

#ifdef TIMED_DELAY

{ "timed_delay", &flags.nap, TRUE, SET_IN_GAME },

{ "timed_delay", (boolean *) 0, FALSE, SET_IN_GAME },

{ "tombstone", &flags.tombstone, TRUE, SET_IN_GAME },

{ "toptenwin", &iflags.toptenwin, FALSE, SET_IN_GAME },

{ "travel", &flags.travelcmd, TRUE, SET_IN_GAME },

{ "use_darkgray", &iflags.wc2_darkgray, TRUE, SET_IN_FILE },

#ifdef WIN32

{ "use_inverse", &iflags.wc_inverse, TRUE, SET_IN_GAME }, /*WC*/

{ "use_inverse", &iflags.wc_inverse, FALSE, SET_IN_GAME }, /*WC*/

{ "verbose", &flags.verbose, TRUE, SET_IN_GAME },

#ifdef TTY_TILES_ESCCODES

{ "vt_tiledata", &iflags.vt_tiledata, FALSE, SET_IN_FILE },

{ "vt_tiledata", (boolean *) 0, FALSE, SET_IN_FILE },

{ "whatis_menu", &iflags.getloc_usemenu, FALSE, SET_IN_GAME },

{ "whatis_inview", &iflags.getloc_limitview, FALSE, SET_IN_GAME },

{ "wizweight", &iflags.wizweight, FALSE, SET_IN_WIZGAME },

{ "wraptext", &iflags.wc2_wraptext, FALSE, SET_IN_GAME },

#ifdef ZEROCOMP

{ "zerocomp", &iflags.zerocomp,

#if defined(COMPRESS) || defined(ZLIB_COMP)

FALSE,

TRUE,

DISP_IN_GAME },

{ (char *) 0, (boolean *) 0, FALSE, 0 }

};

static struct Comp_Opt {

} compopt[] = {

{ "align", "your starting alignment (lawful, neutral, or chaotic)", 8,

DISP_IN_GAME },

{ "align_message", "message window alignment", 20, DISP_IN_GAME }, /*WC*/

{ "align_status", "status window alignment", 20, DISP_IN_GAME }, /*WC*/

{ "altkeyhandler", "alternate key handler", 20, DISP_IN_GAME },

#ifdef BACKWARD_COMPAT

{ "boulder", "deprecated (use S_boulder in sym file instead)", 1,

SET_IN_FILE },

{ "catname", "the name of your (first) cat (e.g., catname:Tabby)",

PL_PSIZ, DISP_IN_GAME },

{ "disclose", "the kinds of information to disclose at end of game",

sizeof(flags.end_disclose) * 2, SET_IN_GAME },

{ "dogname", "the name of your (first) dog (e.g., dogname:Fang)", PL_PSIZ,

DISP_IN_GAME },

{ "dungeon", "the symbols to use in drawing the dungeon map",

MAXDCHARS + 1, SET_IN_FILE },

{ "effects", "the symbols to use in drawing special effects",

MAXECHARS + 1, SET_IN_FILE },

{ "font_map", "the font to use in the map window", 40,

DISP_IN_GAME }, /*WC*/

{ "font_menu", "the font to use in menus", 40, DISP_IN_GAME }, /*WC*/

{ "font_message", "the font to use in the message window", 40,

DISP_IN_GAME }, /*WC*/

{ "font_size_map", "the size of the map font", 20, DISP_IN_GAME }, /*WC*/

{ "font_size_menu", "the size of the menu font", 20,

DISP_IN_GAME }, /*WC*/

{ "font_size_message", "the size of the message font", 20,

DISP_IN_GAME }, /*WC*/

{ "font_size_status", "the size of the status font", 20,

DISP_IN_GAME }, /*WC*/

{ "font_size_text", "the size of the text font", 20,

DISP_IN_GAME }, /*WC*/

{ "font_status", "the font to use in status window", 40,

DISP_IN_GAME }, /*WC*/

{ "font_text", "the font to use in text windows", 40,

DISP_IN_GAME }, /*WC*/

{ "fruit", "the name of a fruit you enjoy eating", PL_FSIZ, SET_IN_GAME },

{ "gender", "your starting gender (male or female)", 8, DISP_IN_GAME },

{ "horsename", "the name of your (first) horse (e.g., horsename:Silver)",

PL_PSIZ, DISP_IN_GAME },

{ "map_mode", "map display mode under Windows", 20, DISP_IN_GAME }, /*WC*/

{ "menustyle", "user interface for object selection", MENUTYPELEN,

SET_IN_GAME },

{ "menu_deselect_all", "deselect all items in a menu", 4, SET_IN_FILE },

{ "menu_deselect_page", "deselect all items on this page of a menu", 4,

SET_IN_FILE },

{ "menu_first_page", "jump to the first page in a menu", 4, SET_IN_FILE },

{ "menu_headings", "text attribute for menu headings", 9, SET_IN_GAME },

{ "menu_invert_all", "invert all items in a menu", 4, SET_IN_FILE },

{ "menu_invert_page", "invert all items on this page of a menu", 4,

SET_IN_FILE },

{ "menu_last_page", "jump to the last page in a menu", 4, SET_IN_FILE },

{ "menu_next_page", "goto the next menu page", 4, SET_IN_FILE },

{ "menu_previous_page", "goto the previous menu page", 4, SET_IN_FILE },

{ "menu_search", "search for a menu item", 4, SET_IN_FILE },

{ "menu_select_all", "select all items in a menu", 4, SET_IN_FILE },

{ "menu_select_page", "select all items on this page of a menu", 4,

SET_IN_FILE },

{ "monsters", "the symbols to use for monsters", MAXMCLASSES,

SET_IN_FILE },

{ "msghistory", "number of top line messages to save", 5, DISP_IN_GAME },

#ifdef TTY_GRAPHICS

{ "msg_window", "the type of message window required", 1, SET_IN_GAME },

{ "msg_window", "the type of message window required", 1, SET_IN_FILE },

{ "name", "your character's name (e.g., name:Merlin-W)", PL_NSIZ,

DISP_IN_GAME },

{ "number_pad", "use the number pad for movement", 1, SET_IN_GAME },

{ "objects", "the symbols to use for objects", MAXOCLASSES, SET_IN_FILE },

{ "packorder", "the inventory order of the items in your pack",

MAXOCLASSES, SET_IN_GAME },

#ifdef CHANGE_COLOR

{ "palette",

#ifndef WIN32

"palette (00c/880/-fff is blue/yellow/reverse white)", 15,

SET_IN_GAME },

"palette (adjust an RGB color in palette (color-R-G-B)", 15,

SET_IN_FILE },

#if defined(MAC)

{ "hicolor", "same as palette, only order is reversed", 15, SET_IN_FILE },

{ "paranoid_confirmation", "extra prompting in certain situations", 28,

SET_IN_GAME },

{ "pettype", "your preferred initial pet type", 4, DISP_IN_GAME },

{ "pickup_burden", "maximum burden picked up before prompt", 20,

SET_IN_GAME },

{ "pickup_types", "types of objects to pick up automatically",

MAXOCLASSES, SET_IN_GAME },

{ "pile_limit", "threshold for \"there are many objects here\"", 24,

SET_IN_GAME },

{ "playmode", "normal play, non-scoring explore mode, or debug mode", 8,

DISP_IN_GAME },

{ "player_selection", "choose character via dialog or prompts", 12,

DISP_IN_GAME },

{ "race", "your starting race (e.g., Human, Elf)", PL_CSIZ,

DISP_IN_GAME },

{ "role", "your starting role (e.g., Barbarian, Valkyrie)", PL_CSIZ,

DISP_IN_GAME },

{ "runmode", "display frequency when `running' or `travelling'",

sizeof "teleport", SET_IN_GAME },

{ "scores", "the parts of the score list you wish to see", 32,

SET_IN_GAME },

{ "scroll_amount", "amount to scroll map when scroll_margin is reached",

20, DISP_IN_GAME }, /*WC*/

{ "scroll_margin", "scroll map when this far from the edge", 20,

DISP_IN_GAME }, /*WC*/

{ "sortloot", "sort object selection lists by description", 4,

SET_IN_GAME },

#ifdef MSDOS

{ "soundcard", "type of sound card to use", 20, SET_IN_FILE },

{ "symset", "load a set of display symbols from the symbols file", 70,

SET_IN_GAME },

{ "roguesymset",

"load a set of rogue display symbols from the symbols file", 70,

SET_IN_GAME },

#ifdef WIN32

{ "subkeyvalue", "override keystroke value", 7, SET_IN_FILE },

{ "suppress_alert", "suppress alerts about version-specific features", 8,

SET_IN_GAME },

{ "tile_width", "width of tiles", 20, DISP_IN_GAME }, /*WC*/

{ "tile_height", "height of tiles", 20, DISP_IN_GAME }, /*WC*/

{ "tile_file", "name of tile file", 70, DISP_IN_GAME }, /*WC*/

{ "traps", "the symbols to use in drawing traps", MAXTCHARS + 1,

SET_IN_FILE },

{ "vary_msgcount", "show more old messages at a time", 20,

DISP_IN_GAME }, /*WC*/

#ifdef MSDOS

{ "video", "method of video updating", 20, SET_IN_FILE },

#ifdef VIDEOSHADES

{ "videocolors", "color mappings for internal screen routines", 40,

DISP_IN_GAME },

{ "videoshades", "gray shades to map to black/gray/white", 32,

DISP_IN_GAME },

{ "whatis_coord", "show coordinates when auto-describing cursor position",

1, SET_IN_GAME },

{ "windowcolors", "the foreground/background colors of windows", /*WC*/

80, DISP_IN_GAME },

{ "windowtype", "windowing system to use", WINTYPELEN, DISP_IN_GAME },

#ifdef WINCHAIN

{ "windowchain", "window processor to use", WINTYPELEN, SET_IN_SYS },

#ifdef BACKWARD_COMPAT

{ "DECgraphics", "load DECGraphics display symbols", 70, SET_IN_FILE },

{ "IBMgraphics", "load IBMGraphics display symbols", 70, SET_IN_FILE },

#ifdef MAC_GRAPHICS_ENV

{ "Macgraphics", "load MACGraphics display symbols", 70, SET_IN_FILE },

{ (char *) 0, (char *) 0, 0, 0 }

};

#ifdef OPTION_LISTS_ONLY

#undef static

#else /* use rest of file */

extern char configfile[]; /* for messages */

extern struct symparse loadsyms[];

static boolean need_redraw; /* for doset() */

#if defined(TOS) && defined(TEXTCOLOR)

extern boolean colors_changed; /* in tos.c */

#ifdef VIDEOSHADES

extern char *shade[3]; /* in sys/msdos/video.c */

extern char ttycolors[CLR_MAX]; /* in sys/msdos/video.c */

static char def_inv_order[MAXOCLASSES] = {

COIN_CLASS, AMULET_CLASS, WEAPON_CLASS, ARMOR_CLASS, FOOD_CLASS,

SCROLL_CLASS, SPBOOK_CLASS, POTION_CLASS, RING_CLASS, WAND_CLASS,

TOOL_CLASS, GEM_CLASS, ROCK_CLASS, BALL_CLASS, CHAIN_CLASS, 0,

};

typedef struct {

const char *name;

char cmd;

const char *desc;

} menu_cmd_t;

static const menu_cmd_t default_menu_cmd_info[] = {

{ "menu_first_page", MENU_FIRST_PAGE, "Go to first page" },

{ "menu_last_page", MENU_LAST_PAGE, "Go to last page" },

{ "menu_next_page", MENU_NEXT_PAGE, "Go to next page" },

{ "menu_previous_page", MENU_PREVIOUS_PAGE, "Go to previous page" },

{ "menu_select_all", MENU_SELECT_ALL, "Select all items" },

{ "menu_deselect_all", MENU_UNSELECT_ALL, "Unselect all items" },

{ "menu_invert_all", MENU_INVERT_ALL, "Insert selection" },

{ "menu_select_page", MENU_SELECT_PAGE, "Select items in current page" },

{ "menu_deselect_page", MENU_UNSELECT_PAGE, "Unselect items in current page" },

{ "menu_invert_page", MENU_INVERT_PAGE, "Invert current page selection" },

{ "menu_search", MENU_SEARCH, "Search and toggle matching items" },

};

#define MAX_MENU_MAPPED_CMDS 32 /* some number */

char mapped_menu_cmds[MAX_MENU_MAPPED_CMDS + 1]; /* exported */

static char mapped_menu_op[MAX_MENU_MAPPED_CMDS + 1];

static short n_menu_mapped = 0;

static boolean initial, from_file;

STATIC_DCL void FDECL(nmcpy, (char *, const char *, int));

STATIC_DCL void FDECL(escapes, (const char *, char *));

STATIC_DCL void FDECL(rejectoption, (const char *));

STATIC_DCL void FDECL(badoptmsg, (const char *, const char *));

STATIC_DCL void FDECL(badoption, (const char *));

STATIC_DCL char *FDECL(string_for_opt, (char *, BOOLEAN_P));

STATIC_DCL char *FDECL(string_for_env_opt, (const char *, char *, BOOLEAN_P));

STATIC_DCL void FDECL(bad_negation, (const char *, BOOLEAN_P));

STATIC_DCL int FDECL(change_inv_order, (char *));

STATIC_DCL void FDECL(warning_opts, (char *, const char *));

STATIC_DCL int FDECL(feature_alert_opts, (char *, const char *));

STATIC_DCL boolean FDECL(duplicate_opt_detection, (const char *, int));

STATIC_DCL void FDECL(complain_about_duplicate, (const char *, int));

STATIC_DCL const char *FDECL(attr2attrname, (int));

STATIC_DCL int NDECL(query_color);

STATIC_DCL int FDECL(query_attr, (const char *));

STATIC_DCL const char * FDECL(msgtype2name, (int));

STATIC_DCL int NDECL(query_msgtype);

STATIC_DCL boolean FDECL(msgtype_add, (int, char *));

STATIC_DCL void FDECL(free_one_msgtype, (int));

STATIC_DCL int NDECL(msgtype_count);

STATIC_DCL boolean FDECL(add_menu_coloring_parsed, (char *, int, int));

STATIC_DCL void FDECL(free_one_menu_coloring, (int));

STATIC_DCL int NDECL(count_menucolors);

STATIC_DCL boolean FDECL(parse_role_opts, (BOOLEAN_P, const char *,

char *, char **));

STATIC_DCL void FDECL(oc_to_str, (char *, char *));

STATIC_DCL void FDECL(doset_add_menu, (winid, const char *, int));

STATIC_DCL void FDECL(opts_add_others, (winid, const char *, int,

char *, int));

STATIC_DCL int FDECL(handle_add_list_remove, (const char *, int));

STATIC_DCL boolean FDECL(special_handling, (const char *,

BOOLEAN_P, BOOLEAN_P));

STATIC_DCL const char *FDECL(get_compopt_value, (const char *, char *));

STATIC_DCL void FDECL(remove_autopickup_exception,

(struct autopickup_exception *));

STATIC_DCL int FDECL(count_ape_maps, (int *, int *));

STATIC_DCL boolean FDECL(is_wc_option, (const char *));

STATIC_DCL boolean FDECL(wc_supported, (const char *));

STATIC_DCL boolean FDECL(is_wc2_option, (const char *));

STATIC_DCL boolean FDECL(wc2_supported, (const char *));

STATIC_DCL void FDECL(wc_set_font_name, (int, char *));

STATIC_DCL int FDECL(wc_set_window_colors, (char *));

reglyph_darkroom()

{

xchar x, y;

for (x = 0; x < COLNO; x++)

for (y = 0; y < ROWNO; y++) {

struct rm *lev = &levl[x][y];

if (!flags.dark_room || !iflags.use_color

|| Is_rogue_level(&u.uz)) {

if (lev->glyph == cmap_to_glyph(S_darkroom))

lev->glyph = lev->waslit ? cmap_to_glyph(S_room)

: cmap_to_glyph(S_stone);

} else {

if (lev->glyph == cmap_to_glyph(S_room) && lev->seenv

&& lev->waslit && !cansee(x, y))

lev->glyph = cmap_to_glyph(S_darkroom);

else if (lev->glyph == cmap_to_glyph(S_stone)

&& lev->typ == ROOM && lev->seenv && !cansee(x, y))

lev->glyph = cmap_to_glyph(S_darkroom);

}

}

if (flags.dark_room && iflags.use_color)

showsyms[S_darkroom] = showsyms[S_room];

else

showsyms[S_darkroom] = showsyms[S_stone];

}

match_optname(user_string, opt_name, min_length, val_allowed)

const char *user_string, *opt_name;

int min_length;

boolean val_allowed;

{

int len = (int) strlen(user_string);

if (val_allowed) {

const char *p = index(user_string, ':'),

*q = index(user_string, '=');

if (!p || (q && q < p))

p = q;

if (p) {

/* 'user_string' hasn't necessarily been through mungspaces()

while (p > user_string && isspace((uchar) *(p - 1)))

p--;

len = (int) (p - user_string);

}

}

return (boolean) (len >= min_length

&& !strncmpi(opt_name, user_string, len));

}

char *

nh_getenv(ev)

const char *ev;

{

char *getev = getenv(ev);

if (getev && strlen(getev) <= (BUFSZ / 2))

return getev;

else

return (char *) 0;

}

initoptions()

{

initoptions_init();

#ifdef SYSCF

#ifdef SYSCF_FILE

/* If SYSCF_FILE is specified, it _must_ exist... */

assure_syscf_file();

/* ... and _must_ parse correctly. */

if (!read_config_file(SYSCF_FILE, SET_IN_SYS)) {

raw_printf("Error(s) found in SYSCF_FILE, quitting.");

terminate(EXIT_FAILURE);

}

/*

initoptions_finish();

}

initoptions_init()

{

#if defined(UNIX) || defined(VMS)

char *opts;

int i;

/* set up the command parsing */

reset_commands(TRUE); /* init */

/* initialize the random number generator */

setrandom();

/* for detection of configfile options specified multiple times */

iflags.opt_booldup = iflags.opt_compdup = (int *) 0;

for (i = 0; boolopt[i].name; i++) {

if (boolopt[i].addr)

*(boolopt[i].addr) = boolopt[i].initvalue;

}

#if defined(COMPRESS) || defined(ZLIB_COMP)

set_savepref("externalcomp");

set_restpref("externalcomp");

#ifdef RLECOMP

set_savepref("!rlecomp");

set_restpref("!rlecomp");

#ifdef ZEROCOMP

set_savepref("zerocomp");

set_restpref("zerocomp");

#ifdef RLECOMP

set_savepref("rlecomp");

set_restpref("rlecomp");

#ifdef SYSFLAGS

Strcpy(sysflags.sysflagsid, "sysflags");

sysflags.sysflagsid[9] = (char) sizeof(struct sysflag);

flags.end_own = FALSE;

flags.end_top = 3;

flags.end_around = 2;

flags.paranoia_bits = PARANOID_PRAY; /* old prayconfirm=TRUE */

flags.pile_limit = PILE_LIMIT_DFLT; /* 5 */

flags.runmode = RUN_LEAP;

iflags.msg_history = 20;

#ifdef TTY_GRAPHICS

iflags.prevmsg_window = 's';

iflags.menu_headings = ATR_INVERSE;

iflags.getpos_coords = GPCOORDS_NONE;

/* hero's role, race, &c haven't been chosen yet */

flags.initrole = flags.initrace = flags.initgend = flags.initalign =

ROLE_NONE;

/* Set the default monster and object class symbols. */

init_symbols();

for (i = 0; i < WARNCOUNT; i++)

warnsyms[i] = def_warnsyms[i].sym;

iflags.bouldersym = 0;

iflags.travelcc.x = iflags.travelcc.y = -1;

/* assert( sizeof flags.inv_order == sizeof def_inv_order ); */

(void) memcpy((genericptr_t) flags.inv_order,

(genericptr_t) def_inv_order, sizeof flags.inv_order);

flags.pickup_types[0] = '\0';

flags.pickup_burden = MOD_ENCUMBER;

flags.sortloot = 'l'; /* sort only loot by default */

for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++)

flags.end_disclose[i] = DISCLOSE_PROMPT_DEFAULT_NO;

switch_symbols(FALSE); /* set default characters */

#if defined(UNIX) && defined(TTY_GRAPHICS)

/*

/* this detects the IBM-compatible console on most 386 boxes */

if ((opts = nh_getenv("TERM")) && !strncmp(opts, "AT", 2)) {

if (!symset[PRIMARY].name)

load_symset("IBMGraphics", PRIMARY);

if (!symset[ROGUESET].name)

load_symset("RogueIBM", ROGUESET);

switch_symbols(TRUE);

#ifdef TEXTCOLOR

iflags.use_color = TRUE;

}

#endif /* UNIX && TTY_GRAPHICS */

#if defined(UNIX) || defined(VMS)

#ifdef TTY_GRAPHICS

/* detect whether a "vt" terminal can handle alternate charsets */

if ((opts = nh_getenv("TERM"))

/* [could also check "xterm" which emulates vtXXX by default] */

&& !strncmpi(opts, "vt", 2)

&& AS && AE && index(AS, '\016') && index(AE, '\017')) {

if (!symset[PRIMARY].name)

load_symset("DECGraphics", PRIMARY);

switch_symbols(TRUE);

}

#endif /* UNIX || VMS */

#ifdef MAC_GRAPHICS_ENV

if (!symset[PRIMARY].name)

load_symset("MACGraphics", PRIMARY);

switch_symbols(TRUE);

#endif /* MAC_GRAPHICS_ENV */

flags.menu_style = MENU_FULL;

/* since this is done before init_objects(), do partial init here */

objects[SLIME_MOLD].oc_name_idx = SLIME_MOLD;

nmcpy(pl_fruit, OBJ_NAME(objects[SLIME_MOLD]), PL_FSIZ);

}

initoptions_finish()

{

#ifndef MAC

char *opts = getenv("NETHACKOPTIONS");

if (!opts)

opts = getenv("HACKOPTIONS");

if (opts) {

if (*opts == '/' || *opts == '\\' || *opts == '@') {

if (*opts == '@')

opts++; /* @filename */

/* looks like a filename */

if (strlen(opts) < BUFSZ / 2)

read_config_file(opts, SET_IN_FILE);

} else {

read_config_file((char *) 0, SET_IN_FILE);

/* let the total length of options be long;

parseoptions(opts, TRUE, FALSE);

}

} else

read_config_file((char *) 0, SET_IN_FILE);

(void) fruitadd(pl_fruit, (struct fruit *) 0);

/*

obj_descr[SLIME_MOLD].oc_name = "fruit";

if (iflags.bouldersym)

update_bouldersym();

reglyph_darkroom();

return;

}

STATIC_OVL void

nmcpy(dest, src, maxlen)

char *dest;

const char *src;

int maxlen;

{

int count;

for (count = 1; count < maxlen; count++) {

if (*src == ',' || *src == '\0')

break; /*exit on \0 terminator*/

*dest++ = *src++;

}

*dest = 0;

}

STATIC_OVL void

escapes(cp, tp)

const char *cp;

char *tp;

{

static NEARDATA const char oct[] = "01234567", dec[] = "0123456789",

hex[] = "00112233445566778899aAbBcCdDeEfF";

const char *dp;

int cval, meta, dcount;

while (*cp) {

/* \M has to be followed by something to do meta conversion,

meta = (*cp == '\\' && (cp[1] == 'm' || cp[1] == 'M') && cp[2]);

if (meta)

cp += 2;

cval = dcount = 0; /* for decimal, octal, hexadecimal cases */

if ((*cp != '\\' && *cp != '^') || !cp[1]) {

/* simple character, or nothing left for \ or ^ to escape */

cval = *cp++;

} else if (*cp == '^') { /* expand control-character syntax */

cval = (*++cp & 0x1f);

++cp;

/* remaining cases are all for backslash; we know cp[1] is not \0 */

} else if (index(dec, cp[1])) {

++cp; /* move past backslash to first digit */

do {

cval = (cval * 10) + (*cp - '0');

} while (*++cp && index(dec, *cp) && ++dcount < 3);

} else if ((cp[1] == 'o' || cp[1] == 'O') && cp[2]

&& index(oct, cp[2])) {

cp += 2; /* move past backslash and 'O' */

do {

cval = (cval * 8) + (*cp - '0');

} while (*++cp && index(oct, *cp) && ++dcount < 3);

} else if ((cp[1] == 'x' || cp[1] == 'X') && cp[2]

&& (dp = index(hex, cp[2])) != 0) {

cp += 2; /* move past backslash and 'X' */

do {

cval = (cval * 16) + ((int) (dp - hex) / 2);

} while (*++cp && (dp = index(hex, *cp)) != 0 && ++dcount < 2);

} else { /* C-style character escapes */

switch (*++cp) {

case '\\':

cval = '\\';

break;

case 'n':

cval = '\n';

break;

case 't':

cval = '\t';

break;

case 'b':

cval = '\b';

break;

case 'r':

cval = '\r';

break;

default:

cval = *cp;

}

++cp;

}

if (meta)

cval |= 0x80;

*tp++ = (char) cval;

}

*tp = '\0';

}

STATIC_OVL void

rejectoption(optname)

const char *optname;

{

#ifdef MICRO

pline("\"%s\" settable only from %s.", optname, configfile);

pline("%s can be set only from NETHACKOPTIONS or %s.", optname,

configfile);

}

STATIC_OVL void

badoptmsg(opts, reason)

const char *opts;

const char *reason; /* "Bad syntax" or "Missing value" */

{

const char *linesplit = "";

if (!initial) {

if (!strncmp(opts, "h", 1) || !strncmp(opts, "?", 1))

option_help();

else

pline("%s: %s. Enter \"?g\" for help.", reason, opts);

return;

#ifdef MAC

} else {

return;

}

#ifdef WIN32

linesplit = "\n";

if (from_file)

raw_printf("%s in OPTIONS in %s: %s%s.\n",

reason, configfile, linesplit, opts);

else

raw_printf("%s in NETHACKOPTIONS: %s%s.\n",

reason, linesplit, opts);

wait_synch();

}

STATIC_OVL void

badoption(opts)

const char *opts;

{

badoptmsg(opts, "Bad syntax");

}

STATIC_OVL char *

string_for_opt(opts, val_optional)

char *opts;

boolean val_optional;

{

char *colon, *equals;

colon = index(opts, ':');

equals = index(opts, '=');

if (!colon || (equals && equals < colon))

colon = equals;

if (!colon || !*++colon) {

if (!val_optional)

badoptmsg(opts, "Missing value");

return (char *) 0;

}

return colon;

}

STATIC_OVL char *

string_for_env_opt(optname, opts, val_optional)

const char *optname;

char *opts;

boolean val_optional;

{

if (!initial) {