Wikia

Wikihack

Source:NetHack 3.4.0/options.c

2,032pages on
this wiki
Talk0

Below is the full text to options.c from the source code of NetHack 3.4.0. To link to a particular line, write [[NetHack 3.4.0/options.c#line123]], for example.

Warning! This is the source code from an old release. For the latest release, see Source code

The NetHack General Public License applies to screenshots, source code and other content from NetHack.
1.    /*	SCCS Id: @(#)options.c	3.4	2002/02/07	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
5.    #ifdef OPTION_LISTS_ONLY	/* (AMIGA) external program for opt lists */
6.    #include "config.h"
7.    #include "objclass.h"
8.    #include "flag.h"
9.    NEARDATA struct flag flags;	/* provide linkage */
10.   NEARDATA struct instance_flags iflags;	/* provide linkage */
11.   #define static
12.   #else
13.   #include "hack.h"
14.   #include "tcap.h"
15.   #include <ctype.h>
16.   #endif
17.   
18.   #define WINTYPELEN 16
19.   
20.   /*
21.    *  NOTE:  If you add (or delete) an option, please update the short
22.    *  options help (option_help()), the long options help (dat/opthelp),
23.    *  and the current options setting display function (doset()),
24.    *  and also the Guidebooks.
25.    *
26.    *  The order matters.  If an option is a an initial substring of another
27.    *  option (e.g. time and timed_delay) the shorter one must come first.
28.    */
29.   
30.   static struct Bool_Opt
31.   {
32.   	const char *name;
33.   	boolean	*addr, initvalue;
34.   	int optflags;
35.   } boolopt[] = {
36.   #ifdef AMIGA
37.   	{"altmeta", &flags.altmeta, TRUE, DISP_IN_GAME},
38.   #else
39.   	{"altmeta", (boolean *)0, TRUE, DISP_IN_GAME},
40.   #endif
41.   	{"ascii_map",     &iflags.wc_ascii_map, TRUE, SET_IN_GAME},	/*WC*/
42.   #ifdef MFLOPPY
43.   	{"asksavedisk", &flags.asksavedisk, FALSE, SET_IN_GAME},
44.   #else
45.   	{"asksavedisk", (boolean *)0, FALSE, SET_IN_FILE},
46.   #endif
47.   	{"autodig", &flags.autodig, FALSE, SET_IN_GAME},
48.   	{"autopickup", &flags.pickup, TRUE, SET_IN_GAME},
49.   	{"autoquiver", &flags.autoquiver, FALSE, SET_IN_GAME},
50.   #if defined(MICRO) && !defined(AMIGA)
51.   	{"BIOS", &iflags.BIOS, FALSE, SET_IN_FILE},
52.   #else
53.   	{"BIOS", (boolean *)0, FALSE, SET_IN_FILE},
54.   #endif
55.   #ifdef INSURANCE
56.   	{"checkpoint", &flags.ins_chkpt, TRUE, SET_IN_GAME},
57.   #else
58.   	{"checkpoint", (boolean *)0, FALSE, SET_IN_FILE},
59.   #endif
60.   #ifdef MFLOPPY
61.   	{"checkspace", &iflags.checkspace, TRUE, SET_IN_GAME},
62.   #else
63.   	{"checkspace", (boolean *)0, FALSE, SET_IN_FILE},
64.   #endif
65.   # ifdef MICRO
66.   	{"color",         &iflags.wc_color,TRUE, SET_IN_GAME},		/*WC*/
67.   # else	/* systems that support multiple terminals, many monochrome */
68.   	{"color",         &iflags.wc_color, FALSE, SET_IN_GAME},	/*WC*/
69.   # endif
70.   	{"confirm",&flags.confirm, TRUE, SET_IN_GAME},
71.   #if defined(TERMLIB) && !defined(MAC_GRAPHICS_ENV)
72.   	{"DECgraphics", &iflags.DECgraphics, FALSE, SET_IN_GAME},
73.   #else
74.   	{"DECgraphics", (boolean *)0, FALSE, SET_IN_FILE},
75.   #endif
76.   	{"eight_bit_tty", &iflags.wc_eight_bit_input, FALSE, SET_IN_GAME},	/*WC*/
77.   #ifdef TTY_GRAPHICS
78.   	{"extmenu", &iflags.extmenu, FALSE, SET_IN_GAME},
79.   #else
80.   	{"extmenu", (boolean *)0, FALSE, SET_IN_FILE},
81.   #endif
82.   #ifdef OPT_DISPMAP
83.   	{"fast_map", &flags.fast_map, TRUE, SET_IN_GAME},
84.   #else
85.   	{"fast_map", (boolean *)0, TRUE, SET_IN_FILE},
86.   #endif
87.   	{"female", &flags.female, FALSE, DISP_IN_GAME},
88.   	{"fixinv", &flags.invlet_constant, TRUE, SET_IN_GAME},
89.   #ifdef AMIFLUSH
90.   	{"flush", &flags.amiflush, FALSE, SET_IN_GAME},
91.   #else
92.   	{"flush", (boolean *)0, FALSE, SET_IN_FILE},
93.   #endif
94.   	{"help", &flags.help, TRUE, SET_IN_GAME},
95.   	{"hilite_pet",    &iflags.wc_hilite_pet, FALSE, SET_IN_GAME},	/*WC*/
96.   #ifdef ASCIIGRAPH
97.   	{"IBMgraphics", &iflags.IBMgraphics, FALSE, SET_IN_GAME},
98.   #else
99.   	{"IBMgraphics", (boolean *)0, FALSE, SET_IN_FILE},
100.  #endif
101.  #ifndef MAC
102.  	{"ignintr", &flags.ignintr, FALSE, SET_IN_GAME},
103.  #else
104.  	{"ignintr", (boolean *)0, FALSE, SET_IN_FILE},
105.  #endif
106.  	{"large_font", &iflags.wc_large_font, FALSE, SET_IN_FILE},	/*WC*/
107.  	{"legacy", &flags.legacy, TRUE, DISP_IN_GAME},
108.  	{"lit_corridor", &flags.lit_corridor, FALSE, SET_IN_GAME},
109.  #ifdef MAC_GRAPHICS_ENV
110.  	{"Macgraphics", &iflags.MACgraphics, TRUE, SET_IN_GAME},
111.  #else
112.  	{"Macgraphics", (boolean *)0, FALSE, SET_IN_FILE},
113.  #endif
114.  #ifdef MAIL
115.  	{"mail", &flags.biff, TRUE, SET_IN_GAME},
116.  #else
117.  	{"mail", (boolean *)0, TRUE, SET_IN_FILE},
118.  #endif
119.  #ifdef WIZARD
120.  	/* for menu debugging only*/
121.  	{"menu_tab_sep", &iflags.menu_tab_sep, FALSE, SET_IN_GAME},
122.  #else
123.  	{"menu_tab_sep", (boolean *)0, FALSE, SET_IN_FILE},
124.  #endif
125.  #ifdef TTY_GRAPHICS
126.  	{"msg_window", &iflags.prevmsg_window, FALSE, SET_IN_GAME},
127.  #else
128.  	{"msg_window", (boolean *)0, FALSE, SET_IN_FILE},
129.  #endif
130.  #ifdef NEWS
131.  	{"news", &iflags.news, TRUE, DISP_IN_GAME},
132.  #else
133.  	{"news", (boolean *)0, FALSE, SET_IN_FILE},
134.  #endif
135.  	{"null", &flags.null, TRUE, SET_IN_GAME},
136.  	{"number_pad", &iflags.num_pad, FALSE, SET_IN_GAME},
137.  #ifdef MAC
138.  	{"page_wait", &flags.page_wait, TRUE, SET_IN_GAME},
139.  #else
140.  	{"page_wait", (boolean *)0, FALSE, SET_IN_FILE},
141.  #endif
142.  	{"perm_invent", &flags.perm_invent, FALSE, SET_IN_GAME},
143.  	{"popup_dialog",  &iflags.wc_popup_dialog, FALSE, SET_IN_GAME},	/*WC*/
144.  	{"prayconfirm", &flags.prayconfirm, TRUE, SET_IN_GAME},
145.  	{"preload_tiles", &iflags.wc_preload_tiles, TRUE, DISP_IN_GAME},	/*WC*/
146.  	{"pushweapon", &flags.pushweapon, FALSE, SET_IN_GAME},
147.  #if defined(MICRO) && !defined(AMIGA) && !defined(MSWIN_GRAPHICS)
148.  	{"rawio", &iflags.rawio, FALSE, DISP_IN_GAME},
149.  #else
150.  	{"rawio", (boolean *)0, FALSE, SET_IN_FILE},
151.  #endif
152.  	{"rest_on_space", &flags.rest_on_space, FALSE, SET_IN_GAME},
153.  	{"safe_pet", &flags.safe_dog, TRUE, SET_IN_GAME},
154.  #ifdef WIZARD
155.  	{"sanity_check", &iflags.sanity_check, FALSE, SET_IN_GAME},
156.  #else
157.  	{"sanity_check", (boolean *)0, FALSE, SET_IN_FILE},
158.  #endif
159.  #ifdef EXP_ON_BOTL
160.  	{"showexp", &flags.showexp, FALSE, SET_IN_GAME},
161.  #else
162.  	{"showexp", (boolean *)0, FALSE, SET_IN_FILE},
163.  #endif
164.  #ifdef SCORE_ON_BOTL
165.  	{"showscore", &flags.showscore, FALSE, SET_IN_GAME},
166.  #else
167.  	{"showscore", (boolean *)0, FALSE, SET_IN_FILE},
168.  #endif
169.  	{"silent", &flags.silent, TRUE, SET_IN_GAME},
170.  	{"sortpack", &flags.sortpack, TRUE, SET_IN_GAME},
171.  	{"sound", &flags.soundok, TRUE, SET_IN_GAME},
172.  	{"sparkle", &flags.sparkle, TRUE, SET_IN_GAME},
173.  	{"standout", &flags.standout, FALSE, SET_IN_GAME},
174.  	{"splash_screen",     &iflags.wc_splash_screen, TRUE, DISP_IN_GAME},	/*WC*/
175.  	{"tiled_map",     &iflags.wc_tiled_map, FALSE, DISP_IN_GAME},	/*WC*/
176.  	{"time", &flags.time, FALSE, SET_IN_GAME},
177.  #ifdef TIMED_DELAY
178.  	{"timed_delay", &flags.nap, TRUE, SET_IN_GAME},
179.  #else
180.  	{"timed_delay", (boolean *)0, FALSE, SET_IN_GAME},
181.  #endif
182.  	{"tombstone",&flags.tombstone, TRUE, SET_IN_GAME},
183.  	{"toptenwin",&flags.toptenwin, FALSE, SET_IN_GAME},
184.  	{"use_inverse",   &iflags.wc_inverse, FALSE, SET_IN_GAME},		/*WC*/
185.  	{"verbose", &flags.verbose, TRUE, SET_IN_GAME},
186.  	{(char *)0, (boolean *)0, FALSE, 0}
187.  };
188.  
189.  /* compound options, for option_help() and external programs like Amiga
190.   * frontend */
191.  static struct Comp_Opt
192.  {
193.  	const char *name, *descr;
194.  	int size;	/* for frontends and such allocating space --
195.  			 * usually allowed size of data in game, but
196.  			 * occasionally maximum reasonable size for
197.  			 * typing when game maintains information in
198.  			 * a different format */
199.  	int optflags;
200.  } compopt[] = {
201.  	{ "align",    "your starting alignment (lawful, neutral, or chaotic)",
202.  						8, DISP_IN_GAME },
203.  	{ "align_message", "message window alignment", 20, DISP_IN_GAME }, 	/*WC*/
204.  	{ "align_status", "status window alignment", 20, DISP_IN_GAME }, 	/*WC*/
205.  #ifdef MAC
206.  	{ "background", "the color of the background (black or white)",
207.  						6, SET_IN_FILE },
208.  #endif
209.  	{ "boulder",  "the symbol to use for displaying boulders",
210.  						1, SET_IN_GAME },
211.  	{ "catname",  "the name of your (first) cat (e.g., catname:Tabby)",
212.  						PL_PSIZ, DISP_IN_GAME },
213.  	{ "disclose", "the kinds of information to disclose at end of game",
214.  						sizeof(flags.end_disclose) * 2,
215.  						SET_IN_GAME },
216.  	{ "dogname",  "the name of your (first) dog (e.g., dogname:Fang)",
217.  						PL_PSIZ, DISP_IN_GAME },
218.  	{ "dungeon",  "the symbols to use in drawing the dungeon map",
219.  						MAXDCHARS+1, SET_IN_FILE },
220.  	{ "effects",  "the symbols to use in drawing special effects",
221.  						MAXECHARS+1, SET_IN_FILE },
222.  	{ "font_map", "the font to use in the map window", 40, DISP_IN_GAME },	/*WC*/
223.  	{ "font_menu", "the font to use in menus", 40, DISP_IN_GAME },		/*WC*/
224.  	{ "font_message", "the font to use in the message window",
225.  						40, DISP_IN_GAME },		/*WC*/
226.  	{ "font_size_map", "the size of the map font", 20, DISP_IN_GAME },	/*WC*/
227.  	{ "font_size_menu", "the size of the map font", 20, DISP_IN_GAME },	/*WC*/
228.  	{ "font_size_message", "the size of the map font", 20, DISP_IN_GAME },	/*WC*/
229.  	{ "font_size_status", "the size of the map font", 20, DISP_IN_GAME },	/*WC*/
230.  	{ "font_size_text", "the size of the map font", 20, DISP_IN_GAME },	/*WC*/
231.  	{ "font_status", "the font to use in status window", 40, DISP_IN_GAME }, /*WC*/
232.  	{ "font_text", "the font to use in text windows", 40, DISP_IN_GAME },	/*WC*/
233.  	{ "fruit",    "the name of a fruit you enjoy eating",
234.  						PL_FSIZ, SET_IN_GAME },
235.  	{ "gender",   "your starting gender (male or female)",
236.  						8, DISP_IN_GAME },
237.  	{ "horsename", "the name of your (first) horse (e.g., horsename:Silver)",
238.  						PL_PSIZ, DISP_IN_GAME },
239.  	{ "map_mode", "map display mode under Windows", 20, DISP_IN_GAME },	/*WC*/
240.  	{ "menustyle", "user interface for object selection",
241.  						MENUTYPELEN, SET_IN_GAME },
242.  	{ "menu_deselect_all", "deselect all items in a menu", 4, SET_IN_FILE },
243.  	{ "menu_deselect_page", "deselect all items on this page of a menu",
244.  						4, SET_IN_FILE },
245.  	{ "menu_first_page", "jump to the first page in a menu",
246.  						4, SET_IN_FILE },
247.  	{ "menu_invert_all", "invert all items in a menu", 4, SET_IN_FILE },
248.  	{ "menu_invert_page", "invert all items on this page of a menu",
249.  						4, SET_IN_FILE },
250.  	{ "menu_last_page", "jump to the last page in a menu", 4, SET_IN_FILE },
251.  	{ "menu_next_page", "goto the next menu page", 4, SET_IN_FILE },
252.  	{ "menu_previous_page", "goto the previous menu page", 4, SET_IN_FILE },
253.  	{ "menu_search", "search for a menu item", 4, SET_IN_FILE },
254.  	{ "menu_select_all", "select all items in a menu", 4, SET_IN_FILE },
255.  	{ "menu_select_page", "select all items on this page of a menu",
256.  						4, SET_IN_FILE },
257.  	{ "monsters", "the symbols to use for monsters",
258.  						MAXMCLASSES, SET_IN_FILE },
259.  	{ "msghistory", "number of top line messages to save",
260.  						5, DISP_IN_GAME },
261.  	{ "name",     "your character's name (e.g., name:Merlin-W)",
262.  						PL_NSIZ, DISP_IN_GAME },
263.  	{ "objects",  "the symbols to use for objects",
264.  						MAXOCLASSES, SET_IN_FILE },
265.  	{ "packorder", "the inventory order of the items in your pack",
266.  						MAXOCLASSES, SET_IN_GAME },
267.  #ifdef CHANGE_COLOR
268.  	{ "palette",  "palette (00c/880/-fff is blue/yellow/reverse white)",
269.  						15 , SET_IN_GAME },
270.  # if defined(MAC)
271.  	{ "hicolor",  "same as palette, only order is reversed",
272.  						15, SET_IN_FILE },
273.  # endif
274.  #endif
275.  	{ "pettype",  "your preferred initial pet type", 4, DISP_IN_GAME },
276.  	{ "pickup_burden",  "maximum burden picked up before prompt",
277.  						20, SET_IN_GAME },
278.  	{ "pickup_types", "types of objects to pick up automatically",
279.  						MAXOCLASSES, SET_IN_GAME },
280.  	{ "player_selection", "choose character via dialog or prompts",
281.  						12, DISP_IN_GAME },
282.  	{ "race",     "your starting race (e.g., Human, Elf)",
283.  						PL_CSIZ, DISP_IN_GAME },
284.  	{ "role",     "your starting role (e.g., Barbarian, Valkyrie)",
285.  						PL_CSIZ, DISP_IN_GAME },
286.  	{ "scores",   "the parts of the score list you wish to see",
287.  						32, SET_IN_GAME },
288.  	{ "scroll_margin", "scroll map when this far from the edge", 20, DISP_IN_GAME }, /*WC*/
289.  #ifdef MSDOS
290.  	{ "soundcard", "type of sound card to use", 20, SET_IN_FILE },
291.  #endif
292.  	{ "suppress_alert", "suppress alerts about version-specific features",
293.  						8, SET_IN_GAME },
294.  	{ "tile_width", "width of tiles", 20, DISP_IN_GAME},	/*WC*/
295.  	{ "tile_height", "height of tiles", 20, DISP_IN_GAME},	/*WC*/
296.  	{ "tile_file", "name of tile file", 70, DISP_IN_GAME},	/*WC*/
297.  	{ "traps",    "the symbols to use in drawing traps",
298.  						MAXTCHARS+1, SET_IN_FILE },
299.  #ifdef MAC
300.  	{"use_stone", "use stone background patterns", 8, SET_IN_FILE },
301.  #endif
302.  	{ "vary_msgcount", "show more old messages at a time", 20, DISP_IN_GAME }, /*WC*/
303.  #ifdef MSDOS
304.  	{ "video",    "method of video updating", 20, SET_IN_FILE },
305.  #endif
306.  #ifdef VIDEOSHADES
307.  	{ "videocolors", "color mappings for internal screen routines",
308.  						40, DISP_IN_GAME },
309.  	{ "videoshades", "gray shades to map to black/gray/white",
310.  						32, DISP_IN_GAME },
311.  #endif
312.  	{ "windowcolors",  "the foreground/background colors of windows",	/*WC*/
313.  						80, DISP_IN_GAME },
314.  	{ "windowtype", "windowing system to use", WINTYPELEN, DISP_IN_GAME },
315.  	{ (char *)0, (char *)0, 0, 0 }
316.  };
317.  
318.  #ifdef OPTION_LISTS_ONLY
319.  #undef static
320.  
321.  #else	/* use rest of file */
322.  
323.  static boolean need_redraw; /* for doset() */
324.  
325.  #if defined(TOS) && defined(TEXTCOLOR)
326.  extern boolean colors_changed;	/* in tos.c */
327.  #endif
328.  
329.  #ifdef VIDEOSHADES
330.  extern char *shade[3];		  /* in sys/msdos/video.c */
331.  extern char ttycolors[CLR_MAX];	  /* in sys/msdos/video.c */
332.  #endif
333.  
334.  static char def_inv_order[MAXOCLASSES] = {
335.  	GOLD_CLASS, AMULET_CLASS, WEAPON_CLASS, ARMOR_CLASS, FOOD_CLASS,
336.  	SCROLL_CLASS, SPBOOK_CLASS, POTION_CLASS, RING_CLASS, WAND_CLASS,
337.  	TOOL_CLASS, GEM_CLASS, ROCK_CLASS, BALL_CLASS, CHAIN_CLASS, 0,
338.  };
339.  
340.  /*
341.   * Default menu manipulation command accelerators.  These may _not_ be:
342.   *
343.   *	+ a number - reserved for counts
344.   *	+ an upper or lower case US ASCII letter - used for accelerators
345.   *	+ ESC - reserved for escaping the menu
346.   *	+ NULL, CR or LF - reserved for commiting the selection(s).  NULL
347.   *	  is kind of odd, but the tty's xwaitforspace() will return it if
348.   *	  someone hits a <ret>.
349.   *	+ a default object class symbol - used for object class accelerators
350.   *
351.   * Standard letters (for now) are:
352.   *
353.   *		<  back 1 page
354.   *		>  forward 1 page
355.   *		^  first page
356.   *		|  last page
357.   *		:  search
358.   *
359.   *		page		all
360.   *		 ,    select	 .
361.   *		 \    deselect	 -
362.   *		 ~    invert	 @
363.   *
364.   * The command name list is duplicated in the compopt array.
365.   */
366.  typedef struct {
367.      const char *name;
368.      char cmd;
369.  } menu_cmd_t;
370.  
371.  #define NUM_MENU_CMDS 11
372.  static const menu_cmd_t default_menu_cmd_info[NUM_MENU_CMDS] = {
373.  /* 0*/	{ "menu_first_page",	MENU_FIRST_PAGE },
374.  	{ "menu_last_page",	MENU_LAST_PAGE },
375.  	{ "menu_next_page",	MENU_NEXT_PAGE },
376.  	{ "menu_previous_page",	MENU_PREVIOUS_PAGE },
377.  	{ "menu_select_all",	MENU_SELECT_ALL },
378.  /* 5*/	{ "menu_deselect_all",	MENU_UNSELECT_ALL },
379.  	{ "menu_invert_all",	MENU_INVERT_ALL },
380.  	{ "menu_select_page",	MENU_SELECT_PAGE },
381.  	{ "menu_deselect_page",	MENU_UNSELECT_PAGE },
382.  	{ "menu_invert_page",	MENU_INVERT_PAGE },
383.  /*10*/	{ "menu_search",		MENU_SEARCH },
384.  };
385.  
386.  /*
387.   * Allow the user to map incoming characters to various menu commands.
388.   * The accelerator list must be a valid C string.
389.   */
390.  #define MAX_MENU_MAPPED_CMDS 32	/* some number */
391.         char mapped_menu_cmds[MAX_MENU_MAPPED_CMDS+1];	/* exported */
392.  static char mapped_menu_op[MAX_MENU_MAPPED_CMDS+1];
393.  static short n_menu_mapped = 0;
394.  
395.  
396.  static boolean initial, from_file;
397.  
398.  STATIC_DCL void FDECL(doset_add_menu, (winid,const char *,int));
399.  STATIC_DCL void FDECL(nmcpy, (char *, const char *, int));
400.  STATIC_DCL void FDECL(escapes, (const char *, char *));
401.  STATIC_DCL void FDECL(rejectoption, (const char *));
402.  STATIC_DCL void FDECL(badoption, (const char *));
403.  STATIC_DCL char *FDECL(string_for_opt, (char *,BOOLEAN_P));
404.  STATIC_DCL char *FDECL(string_for_env_opt, (const char *, char *,BOOLEAN_P));
405.  STATIC_DCL void FDECL(bad_negation, (const char *,BOOLEAN_P));
406.  STATIC_DCL int FDECL(change_inv_order, (char *));
407.  STATIC_DCL void FDECL(oc_to_str, (char *, char *));
408.  STATIC_DCL void FDECL(graphics_opts, (char *,const char *,int,int));
409.  STATIC_DCL int FDECL(feature_alert_opts, (char *, const char *));
410.  STATIC_DCL const char *FDECL(get_compopt_value, (const char *, char *));
411.  STATIC_DCL boolean FDECL(special_handling, (const char *, BOOLEAN_P, BOOLEAN_P));
412.  STATIC_DCL void FDECL(warning_opts, (char *,const char *));
413.  STATIC_DCL void FDECL(duplicate_opt_detection, (const char *, int));
414.  
415.  STATIC_OVL void FDECL(wc_set_font_name, (int, char *));
416.  STATIC_OVL int FDECL(wc_set_window_colors, (char *));
417.  STATIC_OVL boolean FDECL(is_wc_option, (const char *));
418.  STATIC_OVL boolean FDECL(wc_supported, (const char *));
419.  
420.  /* check whether a user-supplied option string is a proper leading
421.     substring of a particular option name; option string might have
422.     a colon or equals sign and arbitrary value appended to it */
423.  boolean
424.  match_optname(user_string, opt_name, min_length, val_allowed)
425.  const char *user_string, *opt_name;
426.  int min_length;
427.  boolean val_allowed;
428.  {
429.  	int len = (int)strlen(user_string);
430.  
431.  	if (val_allowed) {
432.  	    const char *p = index(user_string, ':'),
433.  		       *q = index(user_string, '=');
434.  
435.  	    if (!p || (q && q < p)) p = q;
436.  	    while(p && p > user_string && isspace(*(p-1))) p--;
437.  	    if (p) len = (int)(p - user_string);
438.  	}
439.  
440.  	return (len >= min_length) && !strncmpi(opt_name, user_string, len);
441.  }
442.  
443.  /* most environment variables will eventually be printed in an error
444.   * message if they don't work, and most error message paths go through
445.   * BUFSZ buffers, which could be overflowed by a maliciously long
446.   * environment variable.  if a variable can legitimately be long, or
447.   * if it's put in a smaller buffer, the responsible code will have to
448.   * bounds-check itself.
449.   */
450.  char *
451.  nh_getenv(ev)
452.  const char *ev;
453.  {
454.  	char *getev = getenv(ev);
455.  
456.  	if (getev && strlen(getev) <= (BUFSZ / 2))
457.  		return getev;
458.  	else
459.  		return (char *)0;
460.  }
461.  
462.  void
463.  initoptions()
464.  {
465.  	char *opts;
466.  	int i;
467.  
468.  	/* initialize the random number generator */
469.  	setrandom();
470.  
471.  	/* for detection of configfile options specified multiple times */
472.  	iflags.opt_booldup = iflags.opt_compdup = (int *)0;
473.  	
474.  	for (i = 0; boolopt[i].name; i++) {
475.  		if (boolopt[i].addr)
476.  			*(boolopt[i].addr) = boolopt[i].initvalue;
477.  	}
478.  	flags.end_own = FALSE;
479.  	flags.end_top = 3;
480.  	flags.end_around = 2;
481.  	iflags.msg_history = 20;
482.  
483.  	/* Use negative indices to indicate not yet selected */
484.  	flags.initrole = -1;
485.  	flags.initrace = -1;
486.  	flags.initgend = -1;
487.  	flags.initalign = -1;
488.  
489.  	/* Set the default monster and object class symbols.  Don't use */
490.  	/* memcpy() --- sizeof char != sizeof uchar on some machines.	*/
491.  	for (i = 0; i < MAXOCLASSES; i++)
492.  		oc_syms[i] = (uchar) def_oc_syms[i];
493.  	for (i = 0; i < MAXMCLASSES; i++)
494.  		monsyms[i] = (uchar) def_monsyms[i];
495.  	for (i = 0; i < WARNCOUNT; i++)
496.  		warnsyms[i] = def_warnsyms[i].sym;
497.  	iflags.bouldersym = 0;
498.  	flags.warnlevel = 1;
499.  	flags.warntype = 0L;
500.  
501.       /* assert( sizeof flags.inv_order == sizeof def_inv_order ); */
502.  	(void)memcpy((genericptr_t)flags.inv_order,
503.  		     (genericptr_t)def_inv_order, sizeof flags.inv_order);
504.  	flags.pickup_types[0] = '\0';
505.  	flags.pickup_burden = MOD_ENCUMBER;
506.  
507.  	for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++)
508.  		flags.end_disclose[i] = DISCLOSE_PROMPT_DEFAULT_NO;
509.  	switch_graphics(ASCII_GRAPHICS);	/* set default characters */
510.  #if defined(UNIX) && defined(TTY_GRAPHICS)
511.  	/*
512.  	 * Set defaults for some options depending on what we can
513.  	 * detect about the environment's capabilities.
514.  	 * This has to be done after the global initialization above
515.  	 * and before reading user-specific initialization via
516.  	 * config file/environment variable below.
517.  	 */
518.  	/* this detects the IBM-compatible console on most 386 boxes */
519.  	if (!strncmp(nh_getenv("TERM"), "AT", 2)) {
520.  		switch_graphics(IBM_GRAPHICS);
521.  # ifdef TEXTCOLOR
522.  		iflags.use_color = TRUE;
523.  # endif
524.  	}
525.  #endif /* UNIX && TTY_GRAPHICS */
526.  #if defined(UNIX) || defined(VMS)
527.  # ifdef TTY_GRAPHICS
528.  	/* detect whether a "vt" terminal can handle alternate charsets */
529.  	if (!strncmpi(nh_getenv("TERM"), "vt", 2) && (AS && AE) &&
530.  	    index(AS, '\016') && index(AE, '\017')) {
531.  		switch_graphics(DEC_GRAPHICS);
532.  	}
533.  # endif
534.  #endif /* UNIX || VMS */
535.  
536.  #ifdef MAC_GRAPHICS_ENV
537.  	switch_graphics(MAC_GRAPHICS);
538.  #endif /* MAC_GRAPHICS_ENV */
539.  	flags.menu_style = MENU_FULL;
540.  
541.  	/* since this is done before init_objects(), do partial init here */
542.  	objects[SLIME_MOLD].oc_name_idx = SLIME_MOLD;
543.  	nmcpy(pl_fruit, OBJ_NAME(objects[SLIME_MOLD]), PL_FSIZ);
544.  #ifndef MAC
545.  	opts = getenv("NETHACKOPTIONS");
546.  	if (!opts) opts = getenv("HACKOPTIONS");
547.  	if (opts) {
548.  		if (*opts == '/' || *opts == '\\' || *opts == '@') {
549.  			if (*opts == '@') opts++;	/* @filename */
550.  			/* looks like a filename */
551.  			if (strlen(opts) < BUFSZ/2)
552.  			    read_config_file(opts);
553.  		} else {
554.  			read_config_file((char *)0);
555.  			/* let the total length of options be long;
556.  			 * parseoptions() will check each individually
557.  			 */
558.  			parseoptions(opts, TRUE, FALSE);
559.  		}
560.  	} else
561.  #endif
562.  		read_config_file((char *)0);
563.  
564.  	(void)fruitadd(pl_fruit);
565.  	/* Remove "slime mold" from list of object names; this will	*/
566.  	/* prevent it from being wished unless it's actually present	*/
567.  	/* as a named (or default) fruit.  Wishing for "fruit" will	*/
568.  	/* result in the player's preferred fruit [better than "\033"].	*/
569.  	obj_descr[SLIME_MOLD].oc_name = "fruit";
570.  
571.  	return;
572.  }
573.  
574.  STATIC_OVL void
575.  nmcpy(dest, src, maxlen)
576.  	char	*dest;
577.  	const char *src;
578.  	int	maxlen;
579.  {
580.  	int	count;
581.  
582.  	for(count = 1; count < maxlen; count++) {
583.  		if(*src == ',' || *src == '\0') break; /*exit on \0 terminator*/
584.  		*dest++ = *src++;
585.  	}
586.  	*dest = 0;
587.  }
588.  
589.  /*
590.   * escapes: escape expansion for showsyms. C-style escapes understood include
591.   * \n, \b, \t, \r, \xnnn (hex), \onnn (octal), \nnn (decimal). The ^-prefix
592.   * for control characters is also understood, and \[mM] followed by any of the
593.   * previous forms or by a character has the effect of 'meta'-ing the value (so
594.   * that the alternate character set will be enabled).
595.   */
596.  STATIC_OVL void
597.  escapes(cp, tp)
598.  const char	*cp;
599.  char *tp;
600.  {
601.      while (*cp)
602.      {
603.  	int	cval = 0, meta = 0;
604.  
605.  	if (*cp == '\\' && index("mM", cp[1])) {
606.  		meta = 1;
607.  		cp += 2;
608.  	}
609.  	if (*cp == '\\' && index("0123456789xXoO", cp[1]))
610.  	{
611.  	    const char *dp, *hex = "00112233445566778899aAbBcCdDeEfF";
612.  	    int dcount = 0;
613.  
614.  	    cp++;
615.  	    if (*cp == 'x' || *cp == 'X')
616.  		for (++cp; (dp = index(hex, *cp)) && (dcount++ < 2); cp++)
617.  		    cval = (cval * 16) + (dp - hex) / 2;
618.  	    else if (*cp == 'o' || *cp == 'O')
619.  		for (++cp; (index("01234567",*cp)) && (dcount++ < 3); cp++)
620.  		    cval = (cval * 8) + (*cp - '0');
621.  	    else
622.  		for (; (index("0123456789",*cp)) && (dcount++ < 3); cp++)
623.  		    cval = (cval * 10) + (*cp - '0');
624.  	}
625.  	else if (*cp == '\\')		/* C-style character escapes */
626.  	{
627.  	    switch (*++cp)
628.  	    {
629.  	    case '\\': cval = '\\'; break;
630.  	    case 'n': cval = '\n'; break;
631.  	    case 't': cval = '\t'; break;
632.  	    case 'b': cval = '\b'; break;
633.  	    case 'r': cval = '\r'; break;
634.  	    default: cval = *cp;
635.  	    }
636.  	    cp++;
637.  	}
638.  	else if (*cp == '^')		/* expand control-character syntax */
639.  	{
640.  	    cval = (*++cp & 0x1f);
641.  	    cp++;
642.  	}
643.  	else
644.  	    cval = *cp++;
645.  	if (meta)
646.  	    cval |= 0x80;
647.  	*tp++ = cval;
648.      }
649.      *tp = '\0';
650.  }
651.  
652.  STATIC_OVL void
653.  rejectoption(optname)
654.  const char *optname;
655.  {
656.  #ifdef MICRO
657.  	pline("\"%s\" settable only from %s.", optname, configfile);
658.  #else
659.  	pline("%s can be set only from NETHACKOPTIONS or %s.", optname,
660.  			configfile);
661.  #endif
662.  }
663.  
664.  STATIC_OVL void
665.  badoption(opts)
666.  const char *opts;
667.  {
668.  	if (!initial) {
669.  	    if (!strncmp(opts, "h", 1) || !strncmp(opts, "?", 1))
670.  		option_help();
671.  	    else
672.  		pline("Bad syntax: %s.  Enter \"?g\" for help.", opts);
673.  	    return;
674.  	}
675.  #ifdef MAC
676.  	else return;
677.  #endif
678.  
679.  	if(from_file)
680.  	    raw_printf("Bad syntax in OPTIONS in %s: %s.", configfile, opts);
681.  	else
682.  	    raw_printf("Bad syntax in NETHACKOPTIONS: %s.", opts);
683.  
684.  	wait_synch();
685.  }
686.  
687.  STATIC_OVL char *
688.  string_for_opt(opts, val_optional)
689.  char *opts;
690.  boolean val_optional;
691.  {
692.  	char *colon, *equals;
693.  
694.  	colon = index(opts, ':');
695.  	equals = index(opts, '=');
696.  	if (!colon || (equals && equals < colon)) colon = equals;
697.  
698.  	if (!colon || !*++colon) {
699.  		if (!val_optional) badoption(opts);
700.  		return (char *)0;
701.  	}
702.  	return colon;
703.  }
704.  
705.  STATIC_OVL char *
706.  string_for_env_opt(optname, opts, val_optional)
707.  const char *optname;
708.  char *opts;
709.  boolean val_optional;
710.  {
711.  	if(!initial) {
712.  		rejectoption(optname);
713.  		return (char *)0;
714.  	}
715.  	return string_for_opt(opts, val_optional);
716.  }
717.  
718.  STATIC_OVL void
719.  bad_negation(optname, with_parameter)
720.  const char *optname;
721.  boolean with_parameter;
722.  {
723.  	pline_The("%s option may not %sbe negated.",
724.  		optname,
725.  		with_parameter ? "both have a value and " : "");
726.  }
727.  
728.  /*
729.   * Change the inventory order, using the given string as the new order.
730.   * Missing characters in the new order are filled in at the end from
731.   * the current inv_order, except for gold, which is forced to be first
732.   * if not explicitly present.
733.   *
734.   * This routine returns 1 unless there is a duplicate or bad char in
735.   * the string.
736.   */
737.  STATIC_OVL int
738.  change_inv_order(op)
739.  char *op;
740.  {
741.      int oc_sym, num;
742.      char *sp, buf[BUFSZ];
743.  
744.      num = 0;
745.  #ifndef GOLDOBJ
746.      if (!index(op, GOLD_SYM))
747.  	buf[num++] = GOLD_CLASS;
748.  #else
749.      /*  !!!! probably unnecessary with gold as normal inventory */
750.  #endif
751.  
752.      for (sp = op; *sp; sp++) {
753.  	oc_sym = def_char_to_objclass(*sp);
754.  	/* reject bad or duplicate entries */
755.  	if (oc_sym == MAXOCLASSES ||
756.  		oc_sym == RANDOM_CLASS || oc_sym == ILLOBJ_CLASS ||
757.  		!index(flags.inv_order, oc_sym) || index(sp+1, *sp))
758.  	    return 0;
759.  	/* retain good ones */
760.  	buf[num++] = (char) oc_sym;
761.      }
762.      buf[num] = '\0';
763.  
764.      /* fill in any omitted classes, using previous ordering */
765.      for (sp = flags.inv_order; *sp; sp++)
766.  	if (!index(buf, *sp)) {
767.  	    buf[num++] = *sp;
768.  	    buf[num] = '\0';	/* explicitly terminate for next index() */
769.  	}
770.  
771.      Strcpy(flags.inv_order, buf);
772.      return 1;
773.  }
774.  
775.  STATIC_OVL void
776.  graphics_opts(opts, optype, maxlen, offset)
777.  register char *opts;
778.  const char *optype;
779.  int maxlen, offset;
780.  {
781.  	uchar translate[MAXPCHARS+1];
782.  	int length, i;
783.  
784.  	if (!(opts = string_for_env_opt(optype, opts, FALSE)))
785.  		return;
786.  	escapes(opts, opts);
787.  
788.  	length = strlen(opts);
789.  	if (length > maxlen) length = maxlen;
790.  	/* match the form obtained from PC configuration files */
791.  	for (i = 0; i < length; i++)
792.  		translate[i] = (uchar) opts[i];
793.  	assign_graphics(translate, length, maxlen, offset);
794.  }
795.  
796.  STATIC_OVL void
797.  warning_opts(opts, optype)
798.  register char *opts;
799.  const char *optype;
800.  {
801.  	uchar translate[MAXPCHARS+1];
802.  	int length, i;
803.  
804.  	if (!(opts = string_for_env_opt(optype, opts, FALSE)))
805.  		return;
806.  	escapes(opts, opts);
807.  
808.  	length = strlen(opts);
809.  	if (length > WARNCOUNT) length = WARNCOUNT;
810.  	/* match the form obtained from PC configuration files */
811.  	for (i = 0; i < length; i++)
812.  	     translate[i] = (((i < WARNCOUNT) && opts[i]) ?
813.  			   (uchar) opts[i] : def_warnsyms[i].sym);
814.  	assign_warnings(translate);
815.  }
816.  
817.  void
818.  assign_warnings(graph_chars)
819.  register uchar *graph_chars;
820.  {
821.  	int i;
822.  	for (i = 0; i < WARNCOUNT; i++)
823.  	    warnsyms[i] = graph_chars[i];
824.  }
825.  
826.  STATIC_OVL int
827.  feature_alert_opts(op, optn)
828.  char *op;
829.  const char *optn;
830.  {
831.  	char buf[BUFSZ];
832.  	boolean rejectver = FALSE;
833.  	unsigned long fnv = get_feature_notice_ver(op);		/* version.c */
834.  	if (fnv == 0L) return 0;
835.  	if (fnv > get_current_feature_ver())
836.  		rejectver = TRUE;
837.  	else
838.  		flags.suppress_alert = fnv;
839.  	if (rejectver) {
840.  		if (!initial)
841.  			You_cant("disable new feature alerts for future versions.");
842.  		else {
843.  			Sprintf(buf,
844.  				"\n%s=%s Invalid reference to a future version ignored",
845.  				optn, op);
846.  			badoption(buf);
847.  		}
848.  		return 0;
849.  	}
850.  	if (!initial) {
851.  		Sprintf(buf, "%lu.%lu.%lu", FEATURE_NOTICE_VER_MAJ,
852.  			FEATURE_NOTICE_VER_MIN, FEATURE_NOTICE_VER_PATCH);
853.  		pline("Feature change alerts disabled for NetHack %s features and prior.",
854.  			buf);
855.  	}
856.  	return 1;
857.  }
858.  
859.  void
860.  set_duplicate_opt_detection(on_or_off)
861.  int on_or_off;
862.  {
863.  	int k, *optptr;
864.  	if (on_or_off != 0) {
865.  		/*-- ON --*/
866.  		if (iflags.opt_booldup)
867.  			impossible("iflags.opt_booldup already on (memory leak)");
868.  		iflags.opt_booldup = (int *)alloc(SIZE(boolopt) * sizeof(int));
869.  		optptr = iflags.opt_booldup;
870.  		for (k = 0; k < SIZE(boolopt); ++k)
871.  			*optptr++ = 0;
872.  			
873.  		if (iflags.opt_compdup)
874.  			impossible("iflags.opt_compdup already on (memory leak)");
875.  		iflags.opt_compdup = (int *)alloc(SIZE(compopt) * sizeof(int));
876.  		optptr = iflags.opt_compdup;
877.  		for (k = 0; k < SIZE(compopt); ++k)
878.  			*optptr++ = 0;
879.  	} else {
880.  		/*-- OFF --*/
881.  		if (iflags.opt_booldup) free((genericptr_t) iflags.opt_booldup);
882.  		iflags.opt_booldup = (int *)0;
883.  		if (iflags.opt_compdup) free((genericptr_t) iflags.opt_compdup);
884.  		iflags.opt_compdup = (int *)0;
885.  	} 
886.  }
887.  
888.  STATIC_OVL void
889.  duplicate_opt_detection(opts, bool_or_comp)
890.  const char *opts;
891.  int bool_or_comp;	/* 0 == boolean option, 1 == compound */
892.  {
893.  	int i, *optptr;
894.  #if defined(MAC)
895.  	/* the Mac has trouble dealing with the output of messages while
896.  	 * processing the config file.  That should get fixed one day.
897.  	 * For now just return.
898.  	 */
899.  	return;
900.  #endif
901.  	if ((bool_or_comp == 0) && iflags.opt_booldup && initial && from_file) {
902.  	    for (i = 0; boolopt[i].name; i++) {
903.  		if (match_optname(opts, boolopt[i].name, 3, FALSE)) {
904.  			optptr = iflags.opt_booldup + i;
905.  			if (*optptr == 1) {
906.  			    raw_printf(
907.  				"\nWarning - Boolean option specified multiple times: %s.\n",
908.  					opts);
909.  			        wait_synch();
910.  			}
911.  			*optptr += 1;
912.  			break; /* don't match multiple options */
913.  		}
914.  	    }
915.  	} else if ((bool_or_comp == 1) && iflags.opt_compdup && initial && from_file) {
916.  	    for (i = 0; compopt[i].name; i++) {
917.  		if (match_optname(opts, compopt[i].name, strlen(compopt[i].name), TRUE)) {
918.  			optptr = iflags.opt_compdup + i;
919.  			if (*optptr == 1) {
920.  			    raw_printf(
921.  				"\nWarning - compound option specified multiple times: %s.\n",
922.  					compopt[i].name);
923.  			        wait_synch();
924.  			}
925.  			*optptr += 1;
926.  			break; /* don't match multiple options */
927.  		}
928.  	    }
929.  	}
930.  }
931.  
932.  void
933.  parseoptions(opts, tinitial, tfrom_file)
934.  register char *opts;
935.  boolean tinitial, tfrom_file;
936.  {
937.  	register char *op;
938.  	unsigned num;
939.  	boolean negated;
940.  	int i;
941.  	const char *fullname;
942.  
943.  	initial = tinitial;
944.  	from_file = tfrom_file;
945.  	if ((op = index(opts, ',')) != 0) {
946.  		*op++ = 0;
947.  		parseoptions(op, initial, from_file);
948.  	}
949.  	if (strlen(opts) > BUFSZ/2) {
950.  		badoption("option too long");
951.  		return;
952.  	}
953.  
954.  	/* strip leading and trailing white space */
955.  	while (isspace(*opts)) opts++;
956.  	op = eos(opts);
957.  	while (--op >= opts && isspace(*op)) *op = '\0';
958.  
959.  	if (!*opts) return;
960.  	negated = FALSE;
961.  	while ((*opts == '!') || !strncmpi(opts, "no", 2)) {
962.  		if (*opts == '!') opts++; else opts += 2;
963.  		negated = !negated;
964.  	}
965.  
966.  	/* variant spelling */
967.  
968.  	if (match_optname(opts, "colour", 5, FALSE))
969.  		Strcpy(opts, "color");	/* fortunately this isn't longer */
970.  
971.  	duplicate_opt_detection(opts, 1);	/* 1 means compound opts */
972.  
973.  	/* special boolean options */
974.  
975.  	if (match_optname(opts, "female", 3, FALSE)) {
976.  		if(!initial && flags.female == negated)
977.  			pline("That is not anatomically possible.");
978.  		else
979.  			flags.initgend = flags.female = !negated;
980.  		return;
981.  	}
982.  
983.  	if (match_optname(opts, "male", 4, FALSE)) {
984.  		if(!initial && flags.female != negated)
985.  			pline("That is not anatomically possible.");
986.  		else
987.  			flags.initgend = flags.female = negated;
988.  		return;
989.  	}
990.  
991.  #if defined(MICRO) && !defined(AMIGA)
992.  	/* included for compatibility with old NetHack.cnf files */
993.  	if (match_optname(opts, "IBM_", 4, FALSE)) {
994.  		iflags.BIOS = !negated;
995.  		return;
996.  	}
997.  #endif /* MICRO */
998.  
999.  	/* compound options */
1000. 
1001. 	fullname = "pettype";
1002. 	if (match_optname(opts, fullname, 3, TRUE)) {
1003. 		if ((op = string_for_env_opt(fullname, opts, negated)) != 0) {
1004. 		    if (negated) bad_negation(fullname, TRUE);
1005. 		    else switch (*op) {
1006. 			case 'd':	/* dog */
1007. 			case 'D':
1008. 			    preferred_pet = 'd';
1009. 			    break;
1010. 			case 'c':	/* cat */
1011. 			case 'C':
1012. 			case 'f':	/* feline */
1013. 			case 'F':
1014. 			    preferred_pet = 'c';
1015. 			    break;
1016. 			case 'n':	/* no pet */
1017. 			case 'N':
1018. 			    preferred_pet = 'n';
1019. 			    break;
1020. 			default:
1021. 			    pline("Unrecognized pet type '%s'", op);
1022. 			    break;
1023. 		    }
1024. 		} else if (negated) preferred_pet = 'n';
1025. 		return;
1026. 	}
1027. 
1028. 	fullname = "catname";
1029. 	if (match_optname(opts, fullname, 3, TRUE)) {
1030. 		if (negated) bad_negation(fullname, FALSE);
1031. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
1032. 			nmcpy(catname, op, PL_PSIZ);
1033. 		return;
1034. 	}
1035. 
1036. 	fullname = "dogname";
1037. 	if (match_optname(opts, fullname, 3, TRUE)) {
1038. 		if (negated) bad_negation(fullname, FALSE);
1039. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
1040. 			nmcpy(dogname, op, PL_PSIZ);
1041. 		return;
1042. 	}
1043. 
1044. 	fullname = "horsename";
1045. 	if (match_optname(opts, fullname, 5, TRUE)) {
1046. 		if (negated) bad_negation(fullname, FALSE);
1047. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
1048. 			nmcpy(horsename, op, PL_PSIZ);
1049. 		return;
1050. 	}
1051. 
1052. 	fullname = "msghistory";
1053. 	if (match_optname(opts, fullname, 3, TRUE)) {
1054. 		op = string_for_env_opt(fullname, opts, negated);
1055. 		if ((negated && !op) || (!negated && op)) {
1056. 			iflags.msg_history = negated ? 0 : atoi(op);
1057. 		} else if (negated) bad_negation(fullname, TRUE);
1058. 		return;
1059. 	}
1060. 
1061. 	/* WINCAP
1062. 	 * setting font options  */
1063. 	fullname = "font";
1064. 	if (!strncmpi(opts, fullname, 4))
1065. 	{
1066. 		int wintype = -1;
1067. 		char *fontopts = opts + 4;
1068. 
1069. 		if (!strncmpi(fontopts, "map", 3) ||
1070. 		    !strncmpi(fontopts, "_map", 4))
1071. 			wintype = NHW_MAP;
1072. 		else if (!strncmpi(fontopts, "message", 7) ||
1073. 			 !strncmpi(fontopts, "_message", 8))
1074. 			wintype = NHW_MESSAGE;
1075. 		else if (!strncmpi(fontopts, "text", 4) ||
1076. 			 !strncmpi(fontopts, "_text", 5))
1077. 			wintype = NHW_TEXT;			
1078. 		else if (!strncmpi(fontopts, "menu", 4) ||
1079. 			 !strncmpi(fontopts, "_menu", 5))
1080. 			wintype = NHW_MENU;
1081. 		else if (!strncmpi(fontopts, "status", 6) ||
1082. 			 !strncmpi(fontopts, "_status", 7))
1083. 			wintype = NHW_STATUS;
1084. 		else if (!strncmpi(fontopts, "_size", 5)) {
1085. 			if (!strncmpi(fontopts, "_size_map", 8))
1086. 				wintype = NHW_MAP;
1087. 			else if (!strncmpi(fontopts, "_size_message", 12))
1088. 				wintype = NHW_MESSAGE;
1089. 			else if (!strncmpi(fontopts, "_size_text", 9))
1090. 				wintype = NHW_TEXT;
1091. 			else if (!strncmpi(fontopts, "_size_menu", 9))
1092. 				wintype = NHW_MENU;
1093. 			else if (!strncmpi(fontopts, "_size_status", 11))
1094. 				wintype = NHW_STATUS;
1095. 			else {
1096. 				badoption(opts);
1097. 				return;
1098. 			}
1099. 			if (wintype > 0 && !negated &&
1100. 			    (op = string_for_opt(opts, FALSE)) != 0) {
1101. 			    switch(wintype)  {
1102. 			    	case NHW_MAP:
1103. 					iflags.wc_fontsiz_map = atoi(op);
1104. 					break;
1105. 			    	case NHW_MESSAGE:
1106. 					iflags.wc_fontsiz_message = atoi(op);
1107. 					break;
1108. 			    	case NHW_TEXT:
1109. 					iflags.wc_fontsiz_text = atoi(op);
1110. 					break;
1111. 			    	case NHW_MENU:
1112. 					iflags.wc_fontsiz_menu = atoi(op);
1113. 					break;
1114. 			    	case NHW_STATUS:
1115. 					iflags.wc_fontsiz_status = atoi(op);
1116. 					break;
1117. 			    }
1118. 			}
1119. 			return;
1120. 		} else {
1121. 			badoption(opts);
1122. 		}
1123. 		if (wintype > 0 &&
1124. 		    (op = string_for_opt(opts, FALSE)) != 0) {
1125. 			wc_set_font_name(wintype, op);
1126. #ifdef MAC
1127. 			set_font_name (wintype, op);
1128. #endif
1129. 			return;
1130. 		} else if (negated) bad_negation(fullname, TRUE);
1131. 		return;
1132. 	}
1133. #ifdef CHANGE_COLOR
1134. #ifdef MAC
1135. 	fullname = "use_stone";
1136. 	if (match_optname(opts, fullname, 6, TRUE)) {
1137. 		op = string_for_env_opt(fullname, opts, negated);
1138. 		if ((negated && !op) || (!negated && op)) {
1139. 			iflags.use_stone = negated ? 0 : atoi(op);
1140. 		} else if (negated) bad_negation(fullname, TRUE);
1141. 		return;
1142. 	}
1143. 
1144. 	fullname = "background";
1145. 	if (match_optname(opts, fullname, 5,TRUE))
1146. 	{
1147. 		if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
1148. 		{
1149. 			if (!strncmpi (op, "white", 5))
1150. 				change_background (1);
1151. 			else if (!strncmpi (op, "black", 5))
1152. 				change_background (0);
1153. 		}
1154. 		return;
1155. 	}
1156. #endif	
1157. 
1158. 	if (match_optname(opts, "palette", 3, TRUE)
1159. # ifdef MAC
1160. 	    || match_optname(opts, "hicolor", 3, TRUE)
1161. # endif
1162. 							) {
1163. 	    int color_number, color_incr;
1164. 
1165. # ifdef MAC
1166. 	    if (match_optname(opts, "hicolor", 3, TRUE)) {
1167. 		if (negated) {
1168. 		    bad_negation("hicolor", FALSE);
1169. 		    return;
1170. 		}
1171. 		color_number = CLR_MAX + 4;	/* HARDCODED inverse number */
1172. 		color_incr = -1;
1173. 	    } else {
1174. # endif
1175. 		if (negated) {
1176. 		    bad_negation("palette", FALSE);
1177. 		    return;
1178. 		}
1179. 		color_number = 0;
1180. 		color_incr = 1;
1181. # ifdef MAC
1182. 	    }
1183. # endif
1184. 	    if ((op = string_for_opt(opts, FALSE)) != (char *)0) {
1185. 		char *pt = op;
1186. 		int cnt, tmp, reverse;
1187. 		long rgb;
1188. 
1189. 		while (*pt && color_number >= 0) {
1190. 		    cnt = 3;
1191. 		    rgb = 0L;
1192. 		    if (*pt == '-') {
1193. 			reverse = 1;
1194. 			pt++;
1195. 		    } else {
1196. 			reverse = 0;
1197. 		    }
1198. 		    while (cnt-- > 0) {
1199. 			if (*pt && *pt != '/') {
1200. # ifdef AMIGA
1201. 			    rgb <<= 4;
1202. # else
1203. 			    rgb <<= 8;
1204. # endif
1205. 			    tmp = *(pt++);
1206. 			    if (isalpha(tmp)) {
1207. 				tmp = (tmp + 9) & 0xf;	/* Assumes ASCII... */
1208. 			    } else {
1209. 				tmp &= 0xf;	/* Digits in ASCII too... */
1210. 			    }
1211. # ifndef AMIGA
1212. 			    /* Add an extra so we fill f -> ff and 0 -> 00 */
1213. 			    rgb += tmp << 4;
1214. # endif
1215. 			    rgb += tmp;
1216. 			}
1217. 		    }
1218. 		    if (*pt == '/') {
1219. 			pt++;
1220. 		    }
1221. 		    change_color(color_number, rgb, reverse);
1222. 		    color_number += color_incr;
1223. 		}
1224. 	    }
1225. 	    if (!initial) {
1226. 		need_redraw = TRUE;
1227. 	    }
1228. 	    return;
1229. 	}
1230. #endif /* CHANGE_COLOR */
1231. 
1232. 	if (match_optname(opts, "fruit", 2, TRUE)) {
1233. 		char empty_str = '\0';
1234. 		op = string_for_opt(opts, negated);
1235. 		if (negated) {
1236. 		    if (op) {
1237. 			bad_negation("fruit", TRUE);
1238. 			return;
1239. 		    }
1240. 		    op = &empty_str;
1241. 		    goto goodfruit;
1242. 		}
1243. 		if (!op) return;
1244. 		if (!initial) {
1245. 		    struct fruit *f;
1246. 
1247. 		    num = 0;
1248. 		    for(f=ffruit; f; f=f->nextf) {
1249. 			if (!strcmp(op, f->fname)) goto goodfruit;
1250. 			num++;
1251. 		    }
1252. 		    if (num >= 100) {
1253. 			pline("Doing that so many times isn't very fruitful.");
1254. 			return;
1255. 		    }
1256. 		}
1257. goodfruit:
1258. 		nmcpy(pl_fruit, op, PL_FSIZ);
1259. 	/* OBJ_NAME(objects[SLIME_MOLD]) won't work after initialization */
1260. 		if (!*pl_fruit)
1261. 		    nmcpy(pl_fruit, "slime mold", PL_FSIZ);
1262. 		if (!initial)
1263. 		    (void)fruitadd(pl_fruit);
1264. 		/* If initial, then initoptions is allowed to do it instead
1265. 		 * of here (initoptions always has to do it even if there's
1266. 		 * no fruit option at all.  Also, we don't want people
1267. 		 * setting multiple fruits in their options.)
1268. 		 */
1269. 		return;
1270. 	}
1271. 
1272. 	/* graphics:string */
1273. 	fullname = "graphics";
1274. 	if (match_optname(opts, fullname, 2, TRUE)) {
1275. 		if (negated) bad_negation(fullname, FALSE);
1276. 		else graphics_opts(opts, fullname, MAXPCHARS, 0);
1277. 		return;
1278. 	}
1279. 	fullname = "dungeon";
1280. 	if (match_optname(opts, fullname, 2, TRUE)) {
1281. 		if (negated) bad_negation(fullname, FALSE);
1282. 		else graphics_opts(opts, fullname, MAXDCHARS, 0);
1283. 		return;
1284. 	}
1285. 	fullname = "traps";
1286. 	if (match_optname(opts, fullname, 2, TRUE)) {
1287. 		if (negated) bad_negation(fullname, FALSE);
1288. 		else graphics_opts(opts, fullname, MAXTCHARS, MAXDCHARS);
1289. 		return;
1290. 	}
1291. 	fullname = "effects";
1292. 	if (match_optname(opts, fullname, 2, TRUE)) {
1293. 		if (negated) bad_negation(fullname, FALSE);
1294. 		else
1295. 		 graphics_opts(opts, fullname, MAXECHARS, MAXDCHARS+MAXTCHARS);
1296. 		return;
1297. 	}
1298. 
1299. 	/* objects:string */
1300. 	fullname = "objects";
1301. 	if (match_optname(opts, fullname, 7, TRUE)) {
1302. 		int length;
1303. 
1304. 		if (negated) {
1305. 		    bad_negation(fullname, FALSE);
1306. 		    return;
1307. 		}
1308. 		if (!(opts = string_for_env_opt(fullname, opts, FALSE)))
1309. 			return;
1310. 		escapes(opts, opts);
1311. 
1312. 		/*
1313. 		 * Override the default object class symbols.  The first
1314. 		 * object in the object class is the "random object".  I
1315. 		 * don't want to use 0 as an object class, so the "random
1316. 		 * object" is basically a place holder.
1317. 		 *
1318. 		 * The object class symbols have already been initialized in
1319. 		 * initoptions().
1320. 		 */
1321. 		length = strlen(opts);
1322. 		if (length >= MAXOCLASSES)
1323. 		    length = MAXOCLASSES-1;	/* don't count RANDOM_OBJECT */
1324. 
1325. 		for (i = 0; i < length; i++)
1326. 		    oc_syms[i+1] = (uchar) opts[i];
1327. 		return;
1328. 	}
1329. 
1330. 	/* monsters:string */
1331. 	fullname = "monsters";
1332. 	if (match_optname(opts, fullname, 8, TRUE)) {
1333. 		int length;
1334. 
1335. 		if (negated) {
1336. 		    bad_negation(fullname, FALSE);
1337. 		    return;
1338. 		}
1339. 		if (!(opts = string_for_env_opt(fullname, opts, FALSE)))
1340. 			return;
1341. 		escapes(opts, opts);
1342. 
1343. 		/* Override default mon class symbols set in initoptions(). */
1344. 		length = strlen(opts);
1345. 		if (length >= MAXMCLASSES)
1346. 		    length = MAXMCLASSES-1;	/* mon class 0 unused */
1347. 
1348. 		for (i = 0; i < length; i++)
1349. 		    monsyms[i+1] = (uchar) opts[i];
1350. 		return;
1351. 	}
1352. 	fullname = "warnings";
1353. 	if (match_optname(opts, fullname, 5, TRUE)) {
1354. 		if (negated) bad_negation(fullname, FALSE);
1355. 		else warning_opts(opts, fullname);
1356. 		return;
1357. 	}
1358. 	/* boulder:symbol */
1359. 	fullname = "boulder";
1360. 	if (match_optname(opts, fullname, 7, TRUE)) {
1361. 		if (negated) {
1362. 		    bad_negation(fullname, FALSE);
1363. 		    return;
1364. 		}
1365. /*		if (!(opts = string_for_env_opt(fullname, opts, FALSE))) */
1366. 		if (!(opts = string_for_opt(opts, FALSE)))
1367. 			return;
1368. 		escapes(opts, opts);
1369. 
1370. 		/*
1371. 		 * Override the default boulder symbol.
1372. 		 */
1373. 		iflags.bouldersym = (uchar) opts[0];
1374. 		if (!initial) need_redraw = TRUE;
1375. 		return;
1376. 	}
1377. 
1378. 	/* name:string */
1379. 	fullname = "name";
1380. 	if (match_optname(opts, fullname, 4, TRUE)) {
1381. 		if (negated) bad_negation(fullname, FALSE);
1382. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
1383. 			nmcpy(plname, op, PL_NSIZ);
1384. 		return;
1385. 	}
1386. 
1387. 	/* role:string or character:string */
1388. 	fullname = "role";
1389. 	if (match_optname(opts, fullname, 4, TRUE) ||
1390. 	    match_optname(opts, (fullname = "character"), 4, TRUE)) {
1391. 		if (negated) bad_negation(fullname, FALSE);
1392. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
1393. 			if ((flags.initrole = str2role(op)) == ROLE_NONE)
1394. 				badoption(opts);
1395. 			else  /* Backwards compatibility */
1396. 				nmcpy(pl_character, op, PL_NSIZ);
1397. 		}
1398. 		return;
1399. 	}
1400. 
1401. 	/* race:string */
1402. 	fullname = "race";
1403. 	if (match_optname(opts, fullname, 4, TRUE)) {
1404. 		if (negated) bad_negation(fullname, FALSE);
1405. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
1406. 			if ((flags.initrace = str2race(op)) == ROLE_NONE)
1407. 				badoption(opts);
1408. 			else /* Backwards compatibility */
1409. 				pl_race = *op;
1410. 		}
1411. 		return;
1412. 	}
1413. 
1414. 	/* gender:string */
1415. 	fullname = "gender";
1416. 	if (match_optname(opts, fullname, 4, TRUE)) {
1417. 		if (negated) bad_negation(fullname, FALSE);
1418. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
1419. 			if ((flags.initgend = str2gend(op)) == ROLE_NONE)
1420. 				badoption(opts);
1421. 			else
1422. 				flags.female = flags.initgend;
1423. 		}
1424. 		return;
1425. 	}
1426. 
1427. 	/* WINCAP
1428. 	 * align_status:[left|top|right|bottom] */
1429. 	fullname = "align_status";
1430. 	if (match_optname(opts, fullname, sizeof("align_status")-1, TRUE)) {
1431. 		op = string_for_opt(opts, negated);
1432. 		if (op && !negated) {
1433. 		    if (!strncmpi (op, "left", sizeof("left")-1))
1434. 			iflags.wc_align_status = ALIGN_LEFT;
1435. 		    else if (!strncmpi (op, "top", sizeof("top")-1))
1436. 			iflags.wc_align_status = ALIGN_TOP;
1437. 		    else if (!strncmpi (op, "right", sizeof("right")-1))
1438. 			iflags.wc_align_status = ALIGN_RIGHT;
1439. 		    else if (!strncmpi (op, "bottom", sizeof("bottom")-1))
1440. 			iflags.wc_align_status = ALIGN_BOTTOM;
1441. 		    else
1442. 			badoption(opts);
1443. 		} else if (negated) bad_negation(fullname, TRUE);
1444. 		return;
1445. 	}
1446. 	/* WINCAP
1447. 	 * align_message:[left|top|right|bottom] */
1448. 	fullname = "align_message";
1449. 	if (match_optname(opts, fullname, sizeof("align_message")-1, TRUE)) {
1450. 		op = string_for_opt(opts, negated);
1451. 		if (op && !negated) {
1452. 		    if (!strncmpi (op, "left", sizeof("left")-1))
1453. 			iflags.wc_align_message = ALIGN_LEFT;
1454. 		    else if (!strncmpi (op, "top", sizeof("top")-1))
1455. 			iflags.wc_align_message = ALIGN_TOP;
1456. 		    else if (!strncmpi (op, "right", sizeof("right")-1))
1457. 			iflags.wc_align_message = ALIGN_RIGHT;
1458. 		    else if (!strncmpi (op, "bottom", sizeof("bottom")-1))
1459. 			iflags.wc_align_message = ALIGN_BOTTOM;
1460. 		    else
1461. 			badoption(opts);
1462. 		} else if (negated) bad_negation(fullname, TRUE);
1463. 		return;
1464. 	}
1465. 	/* align:string */
1466. 	fullname = "align";
1467. 	if (match_optname(opts, fullname, sizeof("align")-1, TRUE)) {
1468. 		if (negated) bad_negation(fullname, FALSE);
1469. 		else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0)
1470. 			if ((flags.initalign = str2align(op)) == ROLE_NONE)
1471. 				badoption(opts);
1472. 		return;
1473. 	}
1474. 
1475. 	/* the order to list the pack */
1476. 	fullname = "packorder";
1477. 	if (match_optname(opts, fullname, 4, TRUE)) {
1478. 		if (negated) {
1479. 		    bad_negation(fullname, FALSE);
1480. 		    return;
1481. 		} else if (!(op = string_for_opt(opts, FALSE))) return;
1482. 
1483. 		if (!change_inv_order(op))
1484. 			badoption(opts);
1485. 		return;
1486. 	}
1487. 
1488. 	/* maximum burden picked up before prompt (Warren Cheung) */
1489. 	fullname = "pickup_burden";
1490. 	if (match_optname(opts, fullname, 8, TRUE)) {
1491. 		if (negated) {
1492. 			bad_negation(fullname, FALSE);
1493. 			return;
1494. 		} else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
1495. 		    switch (tolower(*op)) {
1496. 				/* Unencumbered */
1497. 				case 'u':
1498. 					flags.pickup_burden = UNENCUMBERED;
1499. 					break;
1500. 				/* Burdened (slight encumbrance) */
1501. 				case 'b':
1502. 					flags.pickup_burden = SLT_ENCUMBER;
1503. 					break;
1504. 				/* streSsed (moderate encumbrance) */
1505. 				case 's':
1506. 					flags.pickup_burden = MOD_ENCUMBER;
1507. 					break;
1508. 				/* straiNed (heavy encumbrance) */
1509. 				case 'n':
1510. 					flags.pickup_burden = HVY_ENCUMBER;
1511. 					break;
1512. 				/* OverTaxed (extreme encumbrance) */
1513. 				case 'o':
1514. 				case 't':
1515. 					flags.pickup_burden = EXT_ENCUMBER;
1516. 					break;
1517. 				/* overLoaded */
1518. 				case 'l':
1519. 					flags.pickup_burden = OVERLOADED;
1520. 					break;
1521. 				default:
1522. 				badoption(opts);
1523. 		    }
1524. 		}
1525. 		return;
1526. 	}
1527. 
1528. 	/* types of objects to pick up automatically */
1529. 	if (match_optname(opts, "pickup_types", 8, TRUE)) {
1530. 		char ocl[MAXOCLASSES + 1], tbuf[MAXOCLASSES + 1],
1531. 		     qbuf[QBUFSZ], abuf[BUFSZ];
1532. 		int oc_sym;
1533. 		boolean badopt = FALSE, compat = (strlen(opts) <= 6), use_menu;
1534. 
1535. 		oc_to_str(flags.pickup_types, tbuf);
1536. 		flags.pickup_types[0] = '\0';	/* all */
1537. 		op = string_for_opt(opts, (compat || !initial));
1538. 		if (!op) {
1539. 		    if (compat || negated || initial) {
1540. 			/* for backwards compatibility, "pickup" without a
1541. 			   value is a synonym for autopickup of all types
1542. 			   (and during initialization, we can't prompt yet) */
1543. 			flags.pickup = !negated;
1544. 			return;
1545. 		    }
1546. 		    oc_to_str(flags.inv_order, ocl);
1547. 		    use_menu = TRUE;
1548. 		    if (flags.menu_style == MENU_TRADITIONAL ||
1549. 			    flags.menu_style == MENU_COMBINATION) {
1550. 			use_menu = FALSE;
1551. 			Sprintf(qbuf, "New pickup_types: [%s am] (%s)",
1552. 				ocl, *tbuf ? tbuf : "all");
1553. 			getlin(qbuf, abuf);
1554. 			op = mungspaces(abuf);
1555. 			if (abuf[0] == '\0' || abuf[0] == '\033')
1556. 			    op = tbuf;		/* restore */
1557. 			else if (abuf[0] == 'm')
1558. 			    use_menu = TRUE;
1559. 		    }
1560. 		    if (use_menu) {
1561. 			(void) choose_classes_menu("Auto-Pickup what?", 1,
1562. 						   TRUE, ocl, tbuf);
1563. 			op = tbuf;
1564. 		    }
1565. 		}
1566. 		if (negated) {
1567. 		    bad_negation("pickup_types", TRUE);
1568. 		    return;
1569. 		}
1570. 		while (*op == ' ') op++;
1571. 		if (*op != 'a' && *op != 'A') {
1572. 		    num = 0;
1573. 		    while (*op) {
1574. 			oc_sym = def_char_to_objclass(*op);
1575. 			/* make sure all are valid obj symbols occuring once */
1576. 			if (oc_sym != MAXOCLASSES &&
1577. 			    !index(flags.pickup_types, oc_sym)) {
1578. 			    flags.pickup_types[num] = (char)oc_sym;
1579. 			    flags.pickup_types[++num] = '\0';
1580. 			} else
1581. 			    badopt = TRUE;
1582. 			op++;
1583. 		    }
1584. 		    if (badopt) badoption(opts);
1585. 		}
1586. 		return;
1587. 	}
1588. 	/* WINCAP
1589. 	 * player_selection: dialog | prompts */
1590. 	fullname = "player_selection";
1591. 	if (match_optname(opts, fullname, sizeof("player_selection")-1, TRUE)) {
1592. 		op = string_for_opt(opts, negated);
1593. 		if (op && !negated) {
1594. 		    if (!strncmpi (op, "dialog", sizeof("dialog")-1))
1595. 			iflags.wc_player_selection = VIA_DIALOG;
1596. 		    else if (!strncmpi (op, "prompt", sizeof("prompt")-1))
1597. 			iflags.wc_player_selection = VIA_PROMPTS;
1598. 		    else
1599. 		    	badoption(opts);
1600. 		} else if (negated) bad_negation(fullname, TRUE);
1601. 		return;
1602. 	}
1603. 
1604. 	/* things to disclose at end of game */
1605. 	if (match_optname(opts, "disclose", 7, TRUE)) {
1606. 		/*
1607. 		 * The order that the end_disclore options are stored:
1608. 		 * inventory, attribs, vanquished, genocided, conduct
1609. 		 * There is an array in flags:
1610. 		 *	end_disclose[NUM_DISCLOSURE_OPT];
1611. 		 * with option settings for the each of the following:
1612. 		 * iagvc [see disclosure_options in decl.c]:
1613. 		 * Legal setting values in that array are:
1614. 		 *	DISCLOSE_PROMPT_DEFAULT_YES  ask with default answer yes
1615. 		 *	DISCLOSE_PROMPT_DEFAULT_NO   ask with default answer no
1616. 		 *	DISCLOSE_YES_WITHOUT_PROMPT  always disclose and don't ask
1617. 		 *	DISCLOSE_NO_WITHOUT_PROMPT   never disclose and don't ask
1618. 		 *
1619. 		 * Those setting values can be used in the option
1620. 		 * string as a prefix to get the desired behaviour.
1621. 		 *
1622. 		 * For backward compatibility, no prefix is required,
1623. 		 * and the presence of a i,a,g,v, or c without a
1624. 		 * prefix sets the corresponding value to DISCLOSE_YES_WITHOUT_PROMPT;
1625. 		 */
1626. 		boolean badopt = FALSE;
1627. 		int idx, prefix_val;
1628. 		if (!(op = string_for_opt(opts, TRUE))) {
1629. 			/* for backwards compatibility, "disclose" without a
1630. 			 * value means all (was inventory and attributes,
1631. 			 * the only things available then), but negated
1632. 			 * it means "none"
1633. 			 * (note "none" contains none of "iavkgc")
1634. 			 */
1635. 			for (num = 0; num < NUM_DISCLOSURE_OPTIONS; num++) {
1636. 				if (negated)
1637. 				    flags.end_disclose[num] = DISCLOSE_NO_WITHOUT_PROMPT;
1638. 			 	else flags.end_disclose[num] = DISCLOSE_PROMPT_DEFAULT_YES;
1639. 			}
1640. 			return;
1641. 		}
1642. 		if (negated) {
1643. 			bad_negation("disclose", TRUE);
1644. 			return;
1645. 		}
1646. 		num = 0;
1647. 		prefix_val = -1;
1648. 		while (*op && num < sizeof flags.end_disclose - 1) {
1649. 			register char c, *dop;
1650. 			static char valid_settings[] = {
1651. 				DISCLOSE_PROMPT_DEFAULT_YES,
1652. 				DISCLOSE_PROMPT_DEFAULT_NO,
1653. 				DISCLOSE_YES_WITHOUT_PROMPT,
1654. 				DISCLOSE_NO_WITHOUT_PROMPT,
1655. 				'\0'
1656. 			};
1657. 			c = lowc(*op);
1658. 			if (c == 'k') c = 'v';	/* killed -> vanquished */
1659. 			dop = index(disclosure_options, c);
1660. 			if (dop) {
1661. 				idx = dop - disclosure_options;
1662. 				if (idx < 0 || idx > NUM_DISCLOSURE_OPTIONS - 1) {
1663. 				    impossible("bad disclosure index %d %c",
1664. 							idx, c);
1665. 				    continue;
1666. 				}
1667. 				if (prefix_val != -1) {
1668. 				    flags.end_disclose[idx] = prefix_val;
1669. 				    prefix_val = -1;
1670. 				} else
1671. 				    flags.end_disclose[idx] = DISCLOSE_YES_WITHOUT_PROMPT;
1672. 			} else if (index(valid_settings, c)) {
1673. 				prefix_val = c;
1674. 			} else if (c == ' ') {
1675. 				/* do nothing */
1676. 			} else
1677. 				badopt = TRUE;				
1678. 			op++;
1679. 		}
1680. 		if (badopt) badoption(opts);
1681. 		return;
1682. 	}
1683. 
1684. 	/* scores:5t[op] 5a[round] o[wn] */
1685. 	if (match_optname(opts, "scores", 4, TRUE)) {
1686. 	    if (negated) {
1687. 		bad_negation("scores", FALSE);
1688. 		return;
1689. 	    }
1690. 	    if (!(op = string_for_opt(opts, FALSE))) return;
1691. 
1692. 	    while (*op) {
1693. 		int inum = 1;
1694. 
1695. 		if (digit(*op)) {
1696. 		    inum = atoi(op);
1697. 		    while (digit(*op)) op++;
1698. 		} else if (*op == '!') {
1699. 		    negated = !negated;
1700. 		    op++;
1701. 		}
1702. 		while (*op == ' ') op++;
1703. 
1704. 		switch (*op) {
1705. 		 case 't':
1706. 		 case 'T':  flags.end_top = inum;
1707. 			    break;
1708. 		 case 'a':
1709. 		 case 'A':  flags.end_around = inum;
1710. 			    break;
1711. 		 case 'o':
1712. 		 case 'O':  flags.end_own = !negated;
1713. 			    break;
1714. 		 default:   badoption(opts);
1715. 			    return;
1716. 		}
1717. 		while (letter(*++op) || *op == ' ') continue;
1718. 		if (*op == '/') op++;
1719. 	    }
1720. 	    return;
1721. 	}
1722. 
1723. 	fullname = "suppress_alert";
1724. 	if (match_optname(opts, fullname, 4, TRUE)) {
1725. 		op = string_for_opt(opts, negated);
1726. 		if (negated) bad_negation(fullname, FALSE);
1727. 		else if (op) (void) feature_alert_opts(op,fullname);
1728. 		return;
1729. 	}
1730. 	
1731. #ifdef VIDEOSHADES
1732. 	/* videocolors:string */
1733. 	fullname = "videocolors";
1734. 	if (match_optname(opts, fullname, 6, TRUE) ||
1735. 	    match_optname(opts, "videocolours", 10, TRUE)) {
1736. 		if (negated) {
1737. 			bad_negation(fullname, FALSE);
1738. 			return;
1739. 		}
1740. 		else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
1741. 			return;
1742. 		}
1743. 		if (!assign_videocolors(opts))
1744. 			badoption(opts);
1745. 		return;
1746. 	}
1747. 	/* videoshades:string */
1748. 	fullname = "videoshades";
1749. 	if (match_optname(opts, fullname, 6, TRUE)) {
1750. 		if (negated) {
1751. 			bad_negation(fullname, FALSE);
1752. 			return;
1753. 		}
1754. 		else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
1755. 			return;
1756. 		}
1757. 		if (!assign_videoshades(opts))
1758. 			badoption(opts);
1759. 		return;
1760. 	}
1761. #endif /* VIDEOSHADES */
1762. #ifdef MSDOS
1763. # ifdef NO_TERMS
1764. 	/* video:string -- must be after longer tests */
1765. 	fullname = "video";
1766. 	if (match_optname(opts, fullname, 5, TRUE)) {
1767. 		if (negated) {
1768. 			bad_negation(fullname, FALSE);
1769. 			return;
1770. 		}
1771. 		else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
1772. 			return;
1773. 		}
1774. 		if (!assign_video(opts))
1775. 			badoption(opts);
1776. 		return;
1777. 	}
1778. # endif /* NO_TERMS */
1779. 	/* soundcard:string -- careful not to match boolean 'sound' */
1780. 	fullname = "soundcard";
1781. 	if (match_optname(opts, fullname, 6, TRUE)) {
1782. 		if (negated) {
1783. 			bad_negation(fullname, FALSE);
1784. 			return;
1785. 		}
1786. 		else if (!(opts = string_for_env_opt(fullname, opts, FALSE))) {
1787. 			return;
1788. 		}
1789. 		if (!assign_soundcard(opts))
1790. 			badoption(opts);
1791. 		return;
1792. 	}
1793. #endif /* MSDOS */
1794. 
1795. 	/* WINCAP
1796. 	 * map_mode:[tiles|ascii4x6|ascii6x8|ascii8x8|ascii16x8|ascii7x12|ascii8x12|
1797. 			ascii16x12|ascii12x16|ascii10x18|fit_to_screen] */
1798. 	fullname = "map_mode";
1799. 	if (match_optname(opts, fullname, sizeof("map_mode")-1, TRUE)) {
1800. 		op = string_for_opt(opts, negated);
1801. 		if (op && !negated) {
1802. 		    if (!strncmpi (op, "tiles", sizeof("tiles")-1))
1803. 			iflags.wc_map_mode = MAP_MODE_TILES;
1804. 		    else if (!strncmpi (op, "ascii4x6", sizeof("ascii4x6")-1))
1805. 			iflags.wc_map_mode = MAP_MODE_ASCII4x6;
1806. 		    else if (!strncmpi (op, "ascii6x8", sizeof("ascii6x8")-1))
1807. 			iflags.wc_map_mode = MAP_MODE_ASCII6x8;
1808. 		    else if (!strncmpi (op, "ascii8x8", sizeof("ascii8x8")-1))
1809. 			iflags.wc_map_mode = MAP_MODE_ASCII8x8;
1810. 		    else if (!strncmpi (op, "ascii16x8", sizeof("ascii16x8")-1))
1811. 			iflags.wc_map_mode = MAP_MODE_ASCII16x8;
1812. 		    else if (!strncmpi (op, "ascii7x12", sizeof("ascii7x12")-1))
1813. 			iflags.wc_map_mode = MAP_MODE_ASCII7x12;
1814. 		    else if (!strncmpi (op, "ascii8x12", sizeof("ascii8x12")-1))
1815. 			iflags.wc_map_mode = MAP_MODE_ASCII8x12;
1816. 		    else if (!strncmpi (op, "ascii16x12", sizeof("ascii16x12")-1))
1817. 			iflags.wc_map_mode = MAP_MODE_ASCII16x12;
1818. 		    else if (!strncmpi (op, "ascii12x16", sizeof("ascii12x16")-1))
1819. 			iflags.wc_map_mode = MAP_MODE_ASCII12x16;
1820. 		    else if (!strncmpi (op, "ascii10x18", sizeof("ascii10x18")-1))
1821. 			iflags.wc_map_mode = MAP_MODE_ASCII10x18;
1822. 		    else if (!strncmpi (op, "fit_to_screen", sizeof("fit_to_screen")-1))
1823. 			iflags.wc_map_mode = MAP_MODE_ASCII_FIT_TO_SCREEN;
1824. 		    else
1825. 		    	badoption(opts);
1826. 		} else if (negated) bad_negation(fullname, TRUE);
1827. 		return;
1828. 	}
1829. 	/* WINCAP
1830. 	 * scroll_margin:nn */
1831. 	fullname = "scroll_margin";
1832. 	if (match_optname(opts, fullname, sizeof("scroll_margin")-1, TRUE)) {
1833. 		op = string_for_opt(opts, negated);
1834. 		if ((negated && !op) || (!negated && op)) {
1835. 			iflags.wc_scroll_margin = negated ? 5 : atoi(op);
1836. 		} else if (negated) bad_negation(fullname, TRUE);
1837. 		return;
1838. 	}
1839. 	/* WINCAP
1840. 	 * tile_width:nn */
1841. 	fullname = "tile_width";
1842. 	if (match_optname(opts, fullname, sizeof("tile_width")-1, TRUE)) {
1843. 		op = string_for_opt(opts, negated);
1844. 		if ((negated && !op) || (!negated && op)) {
1845. 			iflags.wc_tile_width = negated ? 0 : atoi(op);
1846. 		} else if (negated) bad_negation(fullname, TRUE);
1847. 		return;
1848. 	}
1849. 	/* WINCAP
1850. 	 * tile_file:name */
1851. 	fullname = "tile_file";
1852. 	if (match_optname(opts, fullname, sizeof("tile_file")-1, TRUE)) {
1853. 		if ((op = string_for_opt(opts, FALSE)) != 0) {
1854. 			if (iflags.wc_tile_file) free(iflags.wc_tile_file);
1855. 			iflags.wc_tile_file = (char *)alloc(strlen(op) + 1);
1856. 			Strcpy(iflags.wc_tile_file, op);
1857. 		}
1858. 		return;
1859. 	}
1860. 	/* WINCAP
1861. 	 * tile_height:nn */
1862. 	fullname = "tile_height";
1863. 	if (match_optname(opts, fullname, sizeof("tile_height")-1, TRUE)) {
1864. 		op = string_for_opt(opts, negated);
1865. 		if ((negated && !op) || (!negated && op)) {
1866. 			iflags.wc_tile_height = negated ? 0 : atoi(op);
1867. 		} else if (negated) bad_negation(fullname, TRUE);
1868. 		return;
1869. 	}
1870. 	/* WINCAP
1871. 	 * vary_msgcount:nn */
1872. 	fullname = "vary_msgcount";
1873. 	if (match_optname(opts, fullname, sizeof("vary_msgcount")-1, TRUE)) {
1874. 		op = string_for_opt(opts, negated);
1875. 		if ((negated && !op) || (!negated && op)) {
1876. 			iflags.wc_vary_msgcount = negated ? 0 : atoi(op);
1877. 		} else if (negated) bad_negation(fullname, TRUE);
1878. 		return;
1879. 	}
1880. 
1881. 	fullname = "windowtype";
1882. 	if (match_optname(opts, fullname, 3, TRUE)) {
1883. 	    if (negated) {
1884. 		bad_negation(fullname, FALSE);
1885. 		return;
1886. 	    } else if ((op = string_for_env_opt(fullname, opts, FALSE)) != 0) {
1887. 		char buf[WINTYPELEN];
1888. 		nmcpy(buf, op, WINTYPELEN);
1889. 		choose_windows(buf);
1890. 	    }
1891. 	    return;
1892. 	}
1893. 
1894. 	/* WINCAP
1895. 	 * setting window colors
1896.          * syntax: windowcolors=menu foregrnd/backgrnd text foregrnd/backgrnd
1897.          */
1898. 	fullname = "windowcolors";
1899. 	if (match_optname(opts, fullname, 7, TRUE)) {
1900. 		if ((op = string_for_opt(opts, FALSE)) != 0) {
1901. 			if (!wc_set_window_colors(op))
1902. 				badoption(opts);
1903. 		} else if (negated) bad_negation(fullname, TRUE);
1904. 		return;
1905. 	}
1906. 
1907. 	/* menustyle:traditional or combo or full or partial */
1908. 	if (match_optname(opts, "menustyle", 4, TRUE)) {
1909. 		int tmp;
1910. 		boolean val_required = (strlen(opts) > 5 && !negated);
1911. 
1912. 		if (!(op = string_for_opt(opts, !val_required))) {
1913. 		    if (val_required) return; /* string_for_opt gave feedback */
1914. 		    tmp = negated ? 'n' : 'f';
1915. 		} else {
1916. 		    tmp = tolower(*op);
1917. 		}
1918. 		switch (tmp) {
1919. 			case 'n':	/* none */
1920. 			case 't':	/* traditional */
1921. 				flags.menu_style = MENU_TRADITIONAL;
1922. 				break;
1923. 			case 'c':	/* combo: trad.class sel+menu */
1924. 				flags.menu_style = MENU_COMBINATION;
1925. 				break;
1926. 			case 'p':	/* partial: no class menu */
1927. 				flags.menu_style = MENU_PARTIAL;
1928. 				break;
1929. 			case 'f':	/* full: class menu + menu */
1930. 				flags.menu_style = MENU_FULL;
1931. 				break;
1932. 			default:
1933. 				badoption(opts);
1934. 		}
1935. 		return;
1936. 	}
1937. 
1938. 	/* check for menu command mapping */
1939. 	for (i = 0; i < NUM_MENU_CMDS; i++) {
1940. 	    fullname = default_menu_cmd_info[i].name;
1941. 	    if (match_optname(opts, fullname, (int)strlen(fullname), TRUE)) {
1942. 		if (negated)
1943. 		    bad_negation(fullname, FALSE);
1944. 		else if ((op = string_for_opt(opts, FALSE)) != 0) {
1945. 		    int j;
1946. 		    char c, op_buf[BUFSZ];
1947. 		    boolean isbad = FALSE;
1948. 
1949. 		    escapes(op, op_buf);
1950. 		    c = *op_buf;
1951. 
1952. 		    if (c == 0 || c == '\r' || c == '\n' || c == '\033' ||
1953. 			    c == ' ' || digit(c) || (letter(c) && c != '@'))
1954. 			isbad = TRUE;
1955. 		    else	/* reject default object class symbols */
1956. 			for (j = 1; j < MAXOCLASSES; j++)
1957. 			    if (c == def_oc_syms[i]) {
1958. 				isbad = TRUE;
1959. 				break;
1960. 			    }
1961. 
1962. 		    if (isbad)
1963. 			badoption(opts);
1964. 		    else
1965. 			add_menu_cmd_alias(c, default_menu_cmd_info[i].cmd);
1966. 		}
1967. 		return;
1968. 	    }
1969. 	}
1970. 
1971. 	/* OK, if we still haven't recognized the option, check the boolean
1972. 	 * options list
1973. 	 */
1974. 	for (i = 0; boolopt[i].name; i++) {
1975. 		if (match_optname(opts, boolopt[i].name, 3, FALSE)) {
1976. 			/* options that don't exist */
1977. 			if (!boolopt[i].addr) {
1978. 			    if (!initial && !negated)
1979. 				pline_The("\"%s\" option is not available.",
1980. 					boolopt[i].name);
1981. 			    return;
1982. 			}
1983. 			/* options that must come from config file */
1984. 			if (!initial && (boolopt[i].optflags == SET_IN_FILE)) {
1985. 			    rejectoption(boolopt[i].name);
1986. 			    return;
1987. 			}
1988. 
1989. 			*(boolopt[i].addr) = !negated;
1990. 
1991. 			duplicate_opt_detection(boolopt[i].name, 0);
1992. 
1993. #if defined(TERMLIB) || defined(ASCIIGRAPH) || defined(MAC_GRAPHICS_ENV)
1994. 			if (FALSE
1995. # ifdef TERMLIB
1996. 				 || (boolopt[i].addr) == &iflags.DECgraphics
1997. # endif
1998. # ifdef ASCIIGRAPH
1999. 				 || (boolopt[i].addr) == &iflags.IBMgraphics
2000. # endif
2001. # ifdef MAC_GRAPHICS_ENV
2002. 				 || (boolopt[i].addr) == &iflags.MACgraphics
2003. # endif
2004. 				) {
2005. # ifdef REINCARNATION
2006. 			    if (!initial && Is_rogue_level(&u.uz))
2007. 				assign_rogue_graphics(FALSE);
2008. # endif
2009. 			    need_redraw = TRUE;
2010. # ifdef TERMLIB
2011. 			    if ((boolopt[i].addr) == &iflags.DECgraphics)
2012. 				switch_graphics(iflags.DECgraphics ?
2013. 						DEC_GRAPHICS : ASCII_GRAPHICS);
2014. # endif
2015. # ifdef ASCIIGRAPH
2016. 			    if ((boolopt[i].addr) == &iflags.IBMgraphics)
2017. 				switch_graphics(iflags.IBMgraphics ?
2018. 						IBM_GRAPHICS : ASCII_GRAPHICS);
2019. # endif
2020. # ifdef MAC_GRAPHICS_ENV
2021. 			    if ((boolopt[i].addr) == &iflags.MACgraphics)
2022. 				switch_graphics(iflags.MACgraphics ?
2023. 						MAC_GRAPHICS : ASCII_GRAPHICS);
2024. # endif
2025. # ifdef REINCARNATION
2026. 			    if (!initial && Is_rogue_level(&u.uz))
2027. 				assign_rogue_graphics(TRUE);
2028. # endif
2029. 			}
2030. #endif /* TERMLIB || ASCIIGRAPH || MAC_GRAPHICS_ENV */
2031. 
2032. 			/* only do processing below if setting with doset() */
2033. 			if (initial) return;
2034. 
2035. 			if ((boolopt[i].addr) == &flags.time
2036. #ifdef EXP_ON_BOTL
2037. 			 || (boolopt[i].addr) == &flags.showexp
2038. #endif
2039. #ifdef SCORE_ON_BOTL
2040. 			 || (boolopt[i].addr) == &flags.showscore
2041. #endif
2042. 			    )
2043. 			    flags.botl = TRUE;
2044. 
2045. 			else if ((boolopt[i].addr) == &flags.invlet_constant) {
2046. 			    if (flags.invlet_constant) reassign();
2047. 			}
2048. #ifdef LAN_MAIL
2049. 			else if ((boolopt[i].addr) == &flags.biff) {
2050. 			    if (flags.biff) lan_mail_init();
2051. 			    else lan_mail_finish();
2052. 			}
2053. #endif
2054. 			else if ((boolopt[i].addr) == &iflags.num_pad)
2055. 			    number_pad(iflags.num_pad ? 1 : 0);
2056. 
2057. 			else if ((boolopt[i].addr) == &flags.lit_corridor) {
2058. 			    /*
2059. 			     * All corridor squares seen via night vision or
2060. 			     * candles & lamps change.  Update them by calling
2061. 			     * newsym() on them.  Don't do this if we are
2062. 			     * initializing the options --- the vision system
2063. 			     * isn't set up yet.
2064. 			     */
2065. 			    vision_recalc(2);		/* shut down vision */
2066. 			    vision_full_recalc = 1;	/* delayed recalc */
2067. 			}
2068. 			else if ((boolopt[i].addr) == &iflags.use_inverse) {
2069. 			    need_redraw = TRUE;
2070. 			}
2071. 			else if ((boolopt[i].addr) == &iflags.hilite_pet) {
2072. 			    need_redraw = TRUE;
2073. 			}
2074. #ifdef TEXTCOLOR
2075. 			else if ((boolopt[i].addr) == &iflags.use_color) {
2076. 			    need_redraw = TRUE;
2077. # ifdef TOS
2078. 			    if ((boolopt[i].addr) == &iflags.use_color
2079. 				&& iflags.BIOS) {
2080. 				if (colors_changed)
2081. 				    restore_colors();
2082. 				else
2083. 				    set_colors();
2084. 			    }
2085. # endif
2086. 			}
2087. #endif
2088. 
2089. 			return;
2090. 		}
2091. 	}
2092. 
2093. 	/* out of valid options */
2094. 	badoption(opts);
2095. }
2096. 
2097. 
2098. static NEARDATA const char *menutype[] = {
2099. 	"traditional", "combination", "partial", "full"
2100. };
2101. 
2102. static NEARDATA const char *burdentype[] = {
2103. 	"unencumbered", "burdened", "stressed",
2104. 	"strained", "overtaxed", "overloaded"
2105. };
2106. 
2107. 
2108. /*
2109.  * Convert the given string of object classes to a string of default object
2110.  * symbols.
2111.  */
2112. STATIC_OVL void
2113. oc_to_str(src,dest)
2114.     char *src, *dest;
2115. {
2116.     int i;
2117. 
2118.     while ((i = (int) *src++) != 0) {
2119. 	if (i < 0 || i >= MAXOCLASSES)
2120. 	    impossible("oc_to_str:  illegal object class %d", i);
2121. 	else
2122. 	    *dest++ = def_oc_syms[i];
2123.     }
2124.     *dest = '\0';
2125. }
2126. 
2127. /*
2128.  * Add the given mapping to the menu command map list.  Always keep the
2129.  * maps valid C strings.
2130.  */
2131. void
2132. add_menu_cmd_alias(from_ch, to_ch)
2133.     char from_ch, to_ch;
2134. {
2135.     if (n_menu_mapped >= MAX_MENU_MAPPED_CMDS)
2136. 	pline("out of menu map space");
2137.     else {
2138. 	mapped_menu_cmds[n_menu_mapped] = from_ch;
2139. 	mapped_menu_op[n_menu_mapped] = to_ch;
2140. 	n_menu_mapped++;
2141. 	mapped_menu_cmds[n_menu_mapped] = 0;
2142. 	mapped_menu_op[n_menu_mapped] = 0;
2143.     }
2144. }
2145. 
2146. /*
2147.  * Map the given character to its corresponding menu command.  If it
2148.  * doesn't match anything, just return the original.
2149.  */
2150. char
2151. map_menu_cmd(ch)
2152.     char ch;
2153. {
2154.     char *found = index(mapped_menu_cmds, ch);
2155.     if (found) {
2156. 	int idx = found - mapped_menu_cmds;
2157. 	ch = mapped_menu_op[idx];
2158.     }
2159.     return ch;
2160. }
2161. 
2162. 
2163. #if defined(MICRO) || defined(MAC)
2164. # define OPTIONS_HEADING "OPTIONS"
2165. #else
2166. # define OPTIONS_HEADING "NETHACKOPTIONS"
2167. #endif
2168. 
2169. static char fmtstr_doset_add_menu[] = "%s%-15s [%s]   "; 
2170. static char fmtstr_doset_add_menu_tab[] = "%s\t[%s]";
2171. 
2172. STATIC_OVL void
2173. doset_add_menu(win, option, indexoffset)
2174.     winid win;			/* window to add to */
2175.     const char *option;		/* option name */
2176.     int indexoffset;		/* value to add to index in compopt[], or zero
2177. 				   if option cannot be changed */
2178. {
2179.     const char *value = "unknown";		/* current value */
2180.     char buf[BUFSZ], buf2[BUFSZ];
2181.     anything any;
2182.     int i;
2183. 
2184.     any.a_void = 0;
2185.     if (indexoffset == 0) {
2186. 	any.a_int = 0;
2187. 	value = get_compopt_value(option, buf2);
2188.     } else {
2189. 	for (i=0; compopt[i].name; i++)
2190. 	    if (strcmp(option, compopt[i].name) == 0) break;
2191. 
2192. 	if (compopt[i].name) {
2193. 	    any.a_int = i + 1 + indexoffset;
2194. 	    value = get_compopt_value(option, buf2);
2195. 	} else {
2196. 	    /* We are trying to add an option not found in compopt[].
2197. 	       This is almost certainly bad, but we'll let it through anyway
2198. 	       (with a zero value, so it can't be selected). */
2199. 	    any.a_int = 0;
2200. 	}
2201.     }
2202.     /* "    " replaces "a - " -- assumes menus follow that style */
2203.     if (!iflags.menu_tab_sep)
2204. 	Sprintf(buf, fmtstr_doset_add_menu, any.a_int ? "" : "    ", option, value);
2205.     else
2206. 	Sprintf(buf, fmtstr_doset_add_menu_tab, option, value);
2207.     add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, buf, MENU_UNSELECTED);
2208. }
2209. 
2210. /* Changing options via menu by Per Liboriussen */
2211. int
2212. doset()
2213. {
2214. 	char buf[BUFSZ], buf2[BUFSZ];
2215. 	int i, pass, boolcount, pick_cnt, pick_idx, opt_indx;
2216. 	boolean *bool_p;
2217. 	winid tmpwin;
2218. 	anything any;
2219. 	menu_item *pick_list;
2220. 	int indexoffset, startpass, endpass;
2221. 	boolean setinitial = FALSE, fromfile = FALSE;
2222. 	int biggest_name = 0;
2223. 
2224. 	tmpwin = create_nhwindow(NHW_MENU);
2225. 	start_menu(tmpwin);
2226. 
2227. 	any.a_void = 0;
2228. 	add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
2229. 		 "Booleans (selecting will toggle value):", MENU_UNSELECTED);
2230. 	any.a_int = 0;
2231. 	/* first list any other non-modifiable booleans, then modifiable ones */
2232. 	for (pass = 0; pass <= 1; pass++)
2233. 	    for (i = 0; boolopt[i].name; i++)
2234. 		if ((bool_p = boolopt[i].addr) != 0 &&
2235. 			((boolopt[i].optflags == DISP_IN_GAME && pass == 0) ||
2236. 			 (boolopt[i].optflags == SET_IN_GAME && pass == 1))) {
2237. 		    if (bool_p == &flags.female) continue;  /* obsolete */
2238. #ifdef WIZARD
2239. 		    if (bool_p == &iflags.sanity_check && !wizard) continue;
2240. 		    if (bool_p == &iflags.menu_tab_sep && !wizard) continue;
2241. #endif
2242. 		    if (is_wc_option(boolopt[i].name) &&
2243. 			!wc_supported(boolopt[i].name)) continue;
2244. 		    any.a_int = (pass == 0) ? 0 : i + 1;
2245. 		    if (!iflags.menu_tab_sep)
2246. 			Sprintf(buf, "%s%-13s [%s]",
2247. 			    pass == 0 ? "    " : "",
2248. 			    boolopt[i].name, *bool_p ? "true" : "false");
2249.  		    else
2250. 			Sprintf(buf, "%s\t[%s]",
2251. 			    boolopt[i].name, *bool_p ? "true" : "false");
2252. 		    add_menu(tmpwin, NO_GLYPH, &any, 0, 0,
2253. 			     ATR_NONE, buf, MENU_UNSELECTED);
2254. 		}
2255. 
2256. 	boolcount = i;
2257. 	indexoffset = boolcount;
2258. 	any.a_void = 0;
2259. 	add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED);
2260. 	add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
2261. 		 "Compounds (selecting will prompt for new value):",
2262. 		 MENU_UNSELECTED);
2263. 
2264. 	startpass = DISP_IN_GAME;
2265. 	endpass = SET_IN_GAME;
2266. 
2267. 	/* spin through the options to find the biggest name
2268.            and adjust the format string accordingly if needed */
2269. 	biggest_name = 0;
2270. 	for (i = 0; compopt[i].name; i++)
2271. 		if (compopt[i].optflags >= startpass && compopt[i].optflags <= endpass &&
2272. 		    strlen(compopt[i].name) > (unsigned) biggest_name)
2273. 			biggest_name = (int) strlen(compopt[i].name);
2274. 	if (biggest_name > 30) biggest_name = 30;
2275. 	if (!iflags.menu_tab_sep)
2276. 		Sprintf(fmtstr_doset_add_menu, "%%s%%-%ds [%%s]", biggest_name);
2277. 	
2278. 	/* deliberately put `name', `role', `race', `gender' first */
2279. 	doset_add_menu(tmpwin, "name", 0);
2280. 	doset_add_menu(tmpwin, "role", 0);
2281. 	doset_add_menu(tmpwin, "race", 0);
2282. 	doset_add_menu(tmpwin, "gender", 0);
2283. 
2284. 	for (pass = startpass; pass <= endpass; pass++) 
2285. 	    for (i = 0; compopt[i].name; i++)
2286. 		if (compopt[i].optflags == pass) {
2287.  		    	if (!strcmp(compopt[i].name, "name") ||
2288. 		    	    !strcmp(compopt[i].name, "role") ||
2289. 		    	    !strcmp(compopt[i].name, "race") ||
2290. 		    	    !strcmp(compopt[i].name, "gender"))
2291. 		    	    	continue;
2292. 		    	else if (is_wc_option(compopt[i].name) &&
2293. 					!wc_supported(compopt[i].name))
2294. 		    		continue;
2295. 		    	else
2296. 				doset_add_menu(tmpwin, compopt[i].name,
2297. 					(pass == DISP_IN_GAME) ? 0 : indexoffset);
2298. 		}
2299. #ifdef PREFIXES_IN_USE
2300. 	add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", MENU_UNSELECTED);
2301. 	add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
2302. 		 "Variable playground locations:", MENU_UNSELECTED);
2303. 	for (i = 0; i < PREFIX_COUNT; i++)
2304. 		doset_add_menu(tmpwin, fqn_prefix_names[i], 0);
2305. #endif
2306. 	end_menu(tmpwin, "Set what options?");
2307. 	need_redraw = FALSE;
2308. 	if ((pick_cnt = select_menu(tmpwin, PICK_ANY, &pick_list)) > 0) {
2309. 	    /*
2310. 	     * Walk down the selection list and either invert the booleans
2311. 	     * or prompt for new values. In most cases, call parseoptions()
2312. 	     * to take care of options that require special attention, like
2313. 	     * redraws.
2314. 	     */
2315. 	    for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) {
2316. 		opt_indx = pick_list[pick_idx].item.a_int - 1;
2317. 		if (opt_indx < boolcount) {
2318. 		    /* boolean option */
2319. 		    Sprintf(buf, "%s%s", *boolopt[opt_indx].addr ? "!" : "",
2320. 			    boolopt[opt_indx].name);
2321. 		    parseoptions(buf, setinitial, fromfile);
2322. 		    if (wc_supported(boolopt[opt_indx].name))
2323. 			preference_update(boolopt[opt_indx].name);
2324. 		} else {
2325. 		    /* compound option */
2326. 		    opt_indx -= boolcount;
2327. 
2328. 		    if (!special_handling(compopt[opt_indx].name,
2329. 							setinitial, fromfile)) {
2330. 			Sprintf(buf, "Set %s to what?", compopt[opt_indx].name);
2331. 			getlin(buf, buf2);
2332. 			Sprintf(buf, "%s:%s", compopt[opt_indx].name, buf2);
2333. 			/* pass the buck */
2334. 			parseoptions(buf, setinitial, fromfile);
2335. 		    }
2336. 		    if (wc_supported(compopt[opt_indx].name))
2337. 			preference_update(compopt[opt_indx].name);
2338. 		}
2339. 	    }
2340. 	    free((genericptr_t)pick_list);
2341. 	    pick_list = (menu_item *)0;
2342. 	}
2343. 
2344. 	destroy_nhwindow(tmpwin);
2345. 	if (need_redraw)
2346. 	    (void) doredraw();
2347. 	return 0;
2348. }
2349. 
2350. STATIC_OVL boolean
2351. special_handling(optname, setinitial, setfromfile)
2352. const char *optname;
2353. boolean setinitial,setfromfile;
2354. {
2355.     winid tmpwin;
2356.     anything any;
2357.     int i;
2358.     char buf[BUFSZ];
2359.     boolean retval = FALSE;
2360.     
2361.     /* Special handling of menustyle, pickup_burden, and pickup_types, disclose options. */
2362.     if (!strcmp("menustyle", optname)) {
2363. 	const char *style_name;
2364. 	menu_item *style_pick = (menu_item *)0;
2365.         tmpwin = create_nhwindow(NHW_MENU);
2366. 	start_menu(tmpwin);
2367. 	for (i = 0; i < SIZE(menutype); i++) {
2368. 		style_name = menutype[i];
2369.     		/* note: separate `style_name' variable used
2370. 		   to avoid an optimizer bug in VAX C V2.3 */
2371. 		any.a_int = i + 1;
2372. 		add_menu(tmpwin, NO_GLYPH, &any, *style_name, 0,
2373. 			 ATR_NONE, style_name, MENU_UNSELECTED);
2374.         }
2375. 	end_menu(tmpwin, "Select menustyle:");
2376. 	if (select_menu(tmpwin, PICK_ONE, &style_pick) > 0) {
2377. 		flags.menu_style = style_pick->item.a_int - 1;
2378. 		free((genericptr_t)style_pick);
2379.         }
2380. 	destroy_nhwindow(tmpwin);
2381.         retval = TRUE;
2382.     } else if (!strcmp("pickup_burden", optname)) {
2383. 	const char *burden_name, *burden_letters = "ubsntl";
2384. 	menu_item *burden_pick = (menu_item *)0;
2385.         tmpwin = create_nhwindow(NHW_MENU);
2386. 	start_menu(tmpwin);
2387. 	for (i = 0; i < SIZE(burdentype); i++) {
2388. 		burden_name = burdentype[i];
2389. 		any.a_int = i + 1;
2390. 		add_menu(tmpwin, NO_GLYPH, &any, burden_letters[i], 0,
2391. 			 ATR_NONE, burden_name, MENU_UNSELECTED);
2392.         }
2393. 	end_menu(tmpwin, "Select encumbrance level:");
2394. 	if (select_menu(tmpwin, PICK_ONE, &burden_pick) > 0) {
2395. 		flags.pickup_burden = burden_pick->item.a_int - 1;
2396. 		free((genericptr_t)burden_pick);
2397. 	}
2398. 	destroy_nhwindow(tmpwin);
2399. 	retval = TRUE;
2400.     } else if (!strcmp("pickup_types", optname)) {
2401. 	/* parseoptions will prompt for the list of types */
2402. 	parseoptions(strcpy(buf, "pickup_types"), setinitial, setfromfile);
2403. 	retval = TRUE;
2404.     } else if (!strcmp("disclose", optname)) {
2405. 	int pick_cnt, pick_idx, opt_idx;
2406. 	menu_item *disclosure_category_pick = (menu_item *)0;
2407. 	/*
2408. 	 * The order of disclose_names[]
2409.          * must correspond to disclosure_options in decl.h
2410.          */
2411. 	static const char *disclosure_names[] = {
2412. 		"inventory", "attributes", "vanquished", "genocides", "conduct"
2413. 	};
2414. 	int disc_cat[NUM_DISCLOSURE_OPTIONS];
2415. 	const char *disclosure_name;
2416. 
2417.         tmpwin = create_nhwindow(NHW_MENU);
2418. 	start_menu(tmpwin);
2419. 	for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) {
2420. 		disclosure_name = disclosure_names[i];
2421. 		any.a_int = i + 1;
2422. 		add_menu(tmpwin, NO_GLYPH, &any, disclosure_options[i], 0,
2423. 			 ATR_NONE, disclosure_name, MENU_UNSELECTED);
2424. 		disc_cat[i] = 0;
2425.         }
2426. 	end_menu(tmpwin, "Change which disclosure options categories:");
2427. 	if ((pick_cnt = select_menu(tmpwin, PICK_ANY, &disclosure_category_pick)) > 0) {
2428. 	    for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) {
2429. 		opt_idx = disclosure_category_pick[pick_idx].item.a_int - 1;
2430. 		disc_cat[opt_idx] = 1;
2431. 	    }
2432. 	    free((genericptr_t)disclosure_category_pick);
2433. 	    disclosure_category_pick = (menu_item *)0;
2434. 	}
2435. 	destroy_nhwindow(tmpwin);
2436. 
2437. 	for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) {
2438. 	    if (disc_cat[i]) {
2439. 	    	char dbuf[BUFSZ];
2440. 		menu_item *disclosure_option_pick = (menu_item *)0;
2441. 		Sprintf(dbuf, "Disclosure options for %s:", disclosure_names[i]);
2442. 	        tmpwin = create_nhwindow(NHW_MENU);
2443. 		start_menu(tmpwin);
2444. 		any.a_char = DISCLOSE_NO_WITHOUT_PROMPT;
2445. 		add_menu(tmpwin, NO_GLYPH, &any, 'a', 0,
2446. 			ATR_NONE,"Never disclose and don't prompt", MENU_UNSELECTED);
2447. 		any.a_void = 0;
2448. 		any.a_char = DISCLOSE_YES_WITHOUT_PROMPT;
2449. 		add_menu(tmpwin, NO_GLYPH, &any, 'b', 0,
2450. 			ATR_NONE,"Always disclose and don't prompt", MENU_UNSELECTED);
2451. 		any.a_void = 0;
2452. 		any.a_char = DISCLOSE_PROMPT_DEFAULT_NO;
2453. 		add_menu(tmpwin, NO_GLYPH, &any, 'c', 0,
2454. 			ATR_NONE,"Prompt and default answer to \"No\"", MENU_UNSELECTED);
2455. 		any.a_void = 0;
2456. 		any.a_char = DISCLOSE_PROMPT_DEFAULT_YES;
2457. 		add_menu(tmpwin, NO_GLYPH, &any, 'd', 0,
2458. 			ATR_NONE,"Prompt and default answer to \"Yes\"", MENU_UNSELECTED);
2459. 		end_menu(tmpwin, dbuf);
2460. 		if (select_menu(tmpwin, PICK_ONE, &disclosure_option_pick) > 0) {
2461. 			flags.end_disclose[i] = disclosure_option_pick->item.a_char;
2462. 			free((genericptr_t)disclosure_option_pick);
2463. 		}
2464. 		destroy_nhwindow(tmpwin);
2465. 	    }
2466. 	}
2467. 	retval = TRUE;
2468.     }
2469.     return retval;
2470. }
2471. 
2472. #define rolestring(val,array,field) ((val >= 0) ? array[val].field : \
2473. 				     (val == ROLE_RANDOM) ? randomrole : none)
2474. 
2475. /* This is ugly. We have all the option names in the compopt[] array,
2476.    but we need to look at each option individually to get the value. */
2477. STATIC_OVL const char *
2478. get_compopt_value(optname, buf)
2479. const char *optname;
2480. char *buf;
2481. {
2482. 	char ocl[MAXOCLASSES+1];
2483. 	static const char none[] = "(none)", randomrole[] = "random",
2484. 		     to_be_done[] = "(to be done)",
2485. 		     defopt[] = "default",
2486. 		     defbrief[] = "def";
2487. 	int i;
2488. 
2489. 	buf[0] = '\0';
2490. 	if (!strcmp(optname,"align_message"))
2491. 		Sprintf(buf, "%s", iflags.wc_align_message == ALIGN_TOP     ? "top" :
2492. 				   iflags.wc_align_message == ALIGN_LEFT    ? "left" :
2493. 				   iflags.wc_align_message == ALIGN_BOTTOM  ? "bottom" :
2494. 				   iflags.wc_align_message == ALIGN_RIGHT   ? "right" :
2495. 				   defopt);
2496. 	else if (!strcmp(optname,"align_status"))
2497. 		Sprintf(buf, "%s", iflags.wc_align_status == ALIGN_TOP     ? "top" :
2498. 				   iflags.wc_align_status == ALIGN_LEFT    ? "left" :
2499. 				   iflags.wc_align_status == ALIGN_BOTTOM  ? "bottom" :
2500. 				   iflags.wc_align_status == ALIGN_RIGHT   ? "right" :
2501. 				   defopt);
2502. 	else if (!strcmp(optname,"align"))
2503. 		Sprintf(buf, "%s", rolestring(flags.initalign, aligns, adj));
2504. 	else if (!strcmp(optname, "boulder"))
2505. 		Sprintf(buf, "%c", iflags.bouldersym ?
2506. 			iflags.bouldersym : oc_syms[(int)objects[BOULDER].oc_class]);
2507. 	else if (!strcmp(optname, "catname")) 
2508. 		Sprintf(buf, "%s", catname[0] ? catname : none );
2509. 	else if (!strcmp(optname, "disclose")) {
2510. 		for (i = 0; i < NUM_DISCLOSURE_OPTIONS; i++) {
2511. 			char topt[2];
2512. 			if (i) Strcat(buf," ");
2513. 			topt[1] = '\0';
2514. 			topt[0] = flags.end_disclose[i];
2515. 			Strcat(buf, topt);
2516. 			topt[0] = disclosure_options[i];
2517. 			Strcat(buf, topt);
2518. 		}
2519. 	}
2520. 	else if (!strcmp(optname, "dogname")) 
2521. 		Sprintf(buf, "%s", dogname[0] ? dogname : none );
2522. 	else if (!strcmp(optname, "dungeon"))
2523. 		Sprintf(buf, "%s", to_be_done);
2524. 	else if (!strcmp(optname, "effects"))
2525. 		Sprintf(buf, "%s", to_be_done);
2526. 	else if (!strcmp(optname, "font_map"))
2527. 		Sprintf(buf, "%s", iflags.wc_font_map ? iflags.wc_font_map : defopt);
2528. 	else if (!strcmp(optname, "font_message"))
2529. 		Sprintf(buf, "%s", iflags.wc_font_message ? iflags.wc_font_message : defopt);
2530. 	else if (!strcmp(optname, "font_status"))
2531. 		Sprintf(buf, "%s", iflags.wc_font_status ? iflags.wc_font_status : defopt);
2532. 	else if (!strcmp(optname, "font_menu"))
2533. 		Sprintf(buf, "%s", iflags.wc_font_menu ? iflags.wc_font_menu : defopt);
2534. 	else if (!strcmp(optname, "font_text"))
2535. 		Sprintf(buf, "%s", iflags.wc_font_text ? iflags.wc_font_text : defopt);
2536. 	else if (!strcmp(optname, "font_size_map")) {
2537. 		if (iflags.wc_fontsiz_map) Sprintf(buf, "%d", iflags.wc_fontsiz_map);
2538. 		else Strcpy(buf, defopt);
2539. 	}
2540. 	else if (!strcmp(optname, "font_size_message")) {
2541. 		if (iflags.wc_fontsiz_message) Sprintf(buf, "%d",
2542. 							iflags.wc_fontsiz_message);
2543. 		else Strcpy(buf, defopt);
2544. 	}
2545. 	else if (!strcmp(optname, "font_size_status")) {
2546. 		if (iflags.wc_fontsiz_status) Sprintf(buf, "%d", iflags.wc_fontsiz_status);
2547. 		else Strcpy(buf, defopt);
2548. 	}
2549. 	else if (!strcmp(optname, "font_size_menu")) {
2550. 		if (iflags.wc_fontsiz_menu) Sprintf(buf, "%d", iflags.wc_fontsiz_menu);
2551. 		else Strcpy(buf, defopt);
2552. 	}
2553. 	else if (!strcmp(optname, "font_size_text")) {
2554. 		if (iflags.wc_fontsiz_text) Sprintf(buf, "%d",iflags.wc_fontsiz_text);
2555. 		else Strcpy(buf, defopt);
2556. 	}
2557. 	else if (!strcmp(optname, "fruit")) 
2558. 		Sprintf(buf, "%s", pl_fruit);
2559. 	else if (!strcmp(optname, "gender"))
2560. 		Sprintf(buf, "%s", rolestring(flags.initgend, genders, adj));
2561. 	else if (!strcmp(optname, "horsename")) 
2562. 		Sprintf(buf, "%s", horsename[0] ? horsename : none);
2563. 	else if (!strcmp(optname, "map_mode"))
2564. 		Sprintf(buf, "%s",
2565. 			iflags.wc_map_mode == MAP_MODE_TILES      ? "tiles" :
2566. 			iflags.wc_map_mode == MAP_MODE_ASCII4x6   ? "ascii4x6" :
2567. 			iflags.wc_map_mode == MAP_MODE_ASCII6x8   ? "ascii6x8" :
2568. 			iflags.wc_map_mode == MAP_MODE_ASCII8x8   ? "ascii8x8" :
2569. 			iflags.wc_map_mode == MAP_MODE_ASCII16x8  ? "ascii16x8" :
2570. 			iflags.wc_map_mode == MAP_MODE_ASCII7x12  ? "ascii7x12" :
2571. 			iflags.wc_map_mode == MAP_MODE_ASCII8x12  ? "ascii8x12" :
2572. 			iflags.wc_map_mode == MAP_MODE_ASCII16x12 ? "ascii16x12" :
2573. 			iflags.wc_map_mode == MAP_MODE_ASCII12x16 ? "ascii12x16" :
2574. 			iflags.wc_map_mode == MAP_MODE_ASCII10x18 ? "ascii10x18" :
2575. 			iflags.wc_map_mode == MAP_MODE_ASCII_FIT_TO_SCREEN ?
2576. 			"fit_to_screen" : defopt);
2577. 	else if (!strcmp(optname, "menustyle")) 
2578. 		Sprintf(buf, "%s", menutype[(int)flags.menu_style] );
2579. 	else if (!strcmp(optname, "menu_deselect_all"))
2580. 		Sprintf(buf, "%s", to_be_done);
2581. 	else if (!strcmp(optname, "menu_deselect_page"))
2582. 		Sprintf(buf, "%s", to_be_done);
2583. 	else if (!strcmp(optname, "menu_first_page"))
2584. 		Sprintf(buf, "%s", to_be_done);
2585. 	else if (!strcmp(optname, "menu_invert_all"))
2586. 		Sprintf(buf, "%s", to_be_done);
2587. 	else if (!strcmp(optname, "menu_invert_page"))
2588. 		Sprintf(buf, "%s", to_be_done);
2589. 	else if (!strcmp(optname, "menu_last_page"))
2590. 		Sprintf(buf, "%s", to_be_done);
2591. 	else if (!strcmp(optname, "menu_next_page"))
2592. 		Sprintf(buf, "%s", to_be_done);
2593. 	else if (!strcmp(optname, "menu_previous_page"))
2594. 		Sprintf(buf, "%s", to_be_done);
2595. 	else if (!strcmp(optname, "menu_search"))
2596. 		Sprintf(buf, "%s", to_be_done);
2597. 	else if (!strcmp(optname, "menu_select_all"))
2598. 		Sprintf(buf, "%s", to_be_done);
2599. 	else if (!strcmp(optname, "menu_select_page"))
2600. 		Sprintf(buf, "%s", to_be_done);
2601. 	else if (!strcmp(optname, "monsters"))
2602. 		Sprintf(buf, "%s", to_be_done);
2603. 	else if (!strcmp(optname, "msghistory"))
2604. 		Sprintf(buf, "%u", iflags.msg_history);
2605. 	else if (!strcmp(optname, "name"))
2606. 		Sprintf(buf, "%s", plname);
2607. 	else if (!strcmp(optname, "objects"))
2608. 		Sprintf(buf, "%s", to_be_done);
2609. 	else if (!strcmp(optname, "packorder")) {
2610. 		oc_to_str(flags.inv_order, ocl);
2611. 		Sprintf(buf, "%s", ocl);
2612. 	     }
2613. #ifdef CHANGE_COLOR
2614. 	else if (!strcmp(optname, "palette")) 
2615. 		Sprintf(buf, "%s", get_color_string());
2616. #endif
2617. 	else if (!strcmp(optname, "pettype")) 
2618. 		Sprintf(buf, "%s", (preferred_pet == 'c') ? "cat" :
2619. 				(preferred_pet == 'd') ? "dog" :
2620. 				(preferred_pet == 'n') ? "none" : "random");
2621. 	else if (!strcmp(optname, "pickup_burden"))
2622. 		Sprintf(buf, "%s", burdentype[flags.pickup_burden] );
2623. 	else if (!strcmp(optname, "pickup_types")) {
2624. 		oc_to_str(flags.pickup_types, ocl);
2625. 		Sprintf(buf, "%s", ocl[0] ? ocl : "all" );
2626. 	     }
2627. 	else if (!strcmp(optname, "race"))
2628. 		Sprintf(buf, "%s", rolestring(flags.initrace, races, noun));
2629. 	else if (!strcmp(optname, "role"))
2630. 		Sprintf(buf, "%s", rolestring(flags.initrole, roles, name.m));
2631. 	else if (!strcmp(optname, "scores")) {
2632. 		Sprintf(buf, "%d top/%d around%s", flags.end_top,
2633. 				flags.end_around, flags.end_own ? "/own" : "");
2634. 	}
2635. 	else if (!strcmp(optname, "scroll_margin")) {
2636. 		if (iflags.wc_scroll_margin) Sprintf(buf, "%d",iflags.wc_scroll_margin);
2637. 		else Strcpy(buf, defopt);
2638. 	}
2639. 	else if (!strcmp(optname, "player_selection"))
2640. 		Sprintf(buf, "%s", iflags.wc_player_selection ? "prompts" : "dialog");
2641. #ifdef MSDOS
2642. 	else if (!strcmp(optname, "soundcard"))
2643. 		Sprintf(buf, "%s", to_be_done);
2644. #endif
2645. 	else if (!strcmp(optname, "suppress_alert")) {
2646. 	    if (flags.suppress_alert == 0L)
2647. 		Strcpy(buf, none);
2648. 	    else
2649. 		Sprintf(buf, "%lu.%lu.%lu",
2650. 			FEATURE_NOTICE_VER_MAJ,
2651. 			FEATURE_NOTICE_VER_MIN,
2652. 			FEATURE_NOTICE_VER_PATCH);
2653. 	}
2654. 	else if (!strcmp(optname, "tile_file"))
2655. 		Sprintf(buf, "%s", iflags.wc_tile_file ? iflags.wc_tile_file : defopt);
2656. 	else if (!strcmp(optname, "tile_height")) {
2657. 		if (iflags.wc_tile_height) Sprintf(buf, "%d",iflags.wc_tile_height);
2658. 		else Strcpy(buf, defopt);
2659. 	}
2660. 	else if (!strcmp(optname, "tile_width")) {
2661. 		if (iflags.wc_tile_width) Sprintf(buf, "%d",iflags.wc_tile_width);
2662. 		else Strcpy(buf, defopt);
2663. 	}
2664. 	else if (!strcmp(optname, "traps"))
2665. 		Sprintf(buf, "%s", to_be_done);
2666. 	else if (!strcmp(optname, "vary_msgcount")) {
2667. 		if (iflags.wc_vary_msgcount) Sprintf(buf, "%d",iflags.wc_vary_msgcount);
2668. 		else Strcpy(buf, defopt);
2669. 	}
2670. #ifdef MSDOS
2671. 	else if (!strcmp(optname, "video"))
2672. 		Sprintf(buf, "%s", to_be_done);
2673. #endif
2674. #ifdef VIDEOSHADES
2675. 	else if (!strcmp(optname, "videoshades"))
2676. 		Sprintf(buf, "%s-%s-%s", shade[0],shade[1],shade[2]);
2677. 	else if (!strcmp(optname, "videocolors"))
2678. 		Sprintf(buf, "%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d-%d",
2679. 			ttycolors[CLR_RED], ttycolors[CLR_GREEN],
2680. 			ttycolors[CLR_BROWN], ttycolors[CLR_BLUE],
2681. 			ttycolors[CLR_MAGENTA], ttycolors[CLR_CYAN],
2682. 			ttycolors[CLR_ORANGE], ttycolors[CLR_BRIGHT_GREEN],
2683. 			ttycolors[CLR_YELLOW], ttycolors[CLR_BRIGHT_BLUE],
2684. 			ttycolors[CLR_BRIGHT_MAGENTA],
2685. 			ttycolors[CLR_BRIGHT_CYAN]);
2686. #endif /* VIDEOSHADES */
2687. 	else if (!strcmp(optname, "windowtype"))
2688. 		Sprintf(buf, "%s", windowprocs.name);
2689. 	else if (!strcmp(optname, "windowcolors"))
2690. 		Sprintf(buf, "%s/%s %s/%s %s/%s %s/%s",
2691. 			iflags.wc_foregrnd_menu    ? iflags.wc_foregrnd_menu : defbrief,
2692. 			iflags.wc_backgrnd_menu    ? iflags.wc_backgrnd_menu : defbrief,
2693. 			iflags.wc_foregrnd_message ? iflags.wc_foregrnd_message : defbrief,
2694. 			iflags.wc_backgrnd_message ? iflags.wc_backgrnd_message : defbrief,
2695. 			iflags.wc_foregrnd_status  ? iflags.wc_foregrnd_status : defbrief,
2696. 			iflags.wc_backgrnd_status  ? iflags.wc_backgrnd_status : defbrief,
2697. 			iflags.wc_foregrnd_text    ? iflags.wc_foregrnd_text : defbrief,
2698. 			iflags.wc_backgrnd_text    ? iflags.wc_backgrnd_text : defbrief);
2699. #ifdef PREFIXES_IN_USE
2700. 	else {
2701. 	    for (i = 0; i < PREFIX_COUNT; ++i)
2702. 		if (!strcmp(optname, fqn_prefix_names[i]) && fqn_prefix[i])
2703. 			Sprintf(buf, "%s", fqn_prefix[i]);
2704. 	}
2705. #endif
2706. 
2707. 	if (buf[0]) return buf;
2708. 	else return "unknown";
2709. }
2710. 
2711. int
2712. dotogglepickup()
2713. {
2714. 	char buf[BUFSZ], ocl[MAXOCLASSES+1];
2715. 
2716. 	flags.pickup = !flags.pickup;
2717. 	if (flags.pickup) {
2718. 	    oc_to_str(flags.pickup_types, ocl);
2719. 	    Sprintf(buf, "ON, for %s objects", ocl[0] ? ocl : "all");
2720. 	} else {
2721. 	    Strcpy(buf, "OFF");
2722. 	}
2723. 	pline("Autopickup: %s.", buf);
2724. 	return 0;
2725. }
2726. 
2727. /* data for option_help() */
2728. static const char *opt_intro[] = {
2729. 	"",
2730. 	"                 NetHack Options Help:",
2731. 	"",
2732. #define CONFIG_SLOT 3	/* fill in next value at run-time */
2733. 	(char *)0,
2734. #if !defined(MICRO) && !defined(MAC)
2735. 	"or use `NETHACKOPTIONS=\"<options>\"' in your environment",
2736. #endif
2737. 	"(<options> is a list of options separated by commas)",
2738. #ifdef VMS
2739. 	"-- for example, $ DEFINE NETHACKOPTIONS \"noautopickup,fruit:kumquat\"",
2740. #endif
2741. 	"or press \"O\" while playing and use the menu.",
2742. 	"",
2743.  "Boolean options (which can be negated by prefixing them with '!' or \"no\"):",
2744. 	(char *)0
2745. };
2746. 
2747. static const char *opt_epilog[] = {
2748. 	"",
2749.  "Some of the options can be set only before the game is started; those",
2750. 	"items will not be selectable in the 'O' command's menu.",
2751. 	(char *)0
2752. };
2753. 
2754. void
2755. option_help()
2756. {
2757.     char buf[BUFSZ], buf2[BUFSZ];
2758.     register int i;
2759.     winid datawin;
2760. 
2761.     datawin = create_nhwindow(NHW_TEXT);
2762.     Sprintf(buf, "Set options as OPTIONS=<options> in %s", configfile);
2763.     opt_intro[CONFIG_SLOT] = (const char *) buf;
2764.     for (i = 0; opt_intro[i]; i++)
2765. 	putstr(datawin, 0, opt_intro[i]);
2766. 
2767.     /* Boolean options */
2768.     for (i = 0; boolopt[i].name; i++) {
2769. 	if (boolopt[i].addr) {
2770. #ifdef WIZARD
2771. 	    if (boolopt[i].addr == &iflags.sanity_check && !wizard) continue;
2772. 	    if (boolopt[i].addr == &iflags.menu_tab_sep && !wizard) continue;
2773. #endif
2774. 	    next_opt(datawin, boolopt[i].name);
2775. 	}
2776.     }
2777.     next_opt(datawin, "");
2778. 
2779.     /* Compound options */
2780.     putstr(datawin, 0, "Compound options:");
2781.     for (i = 0; compopt[i].name; i++) {
2782. 	Sprintf(buf2, "`%s'", compopt[i].name);
2783. 	Sprintf(buf, "%-20s - %s%c", buf2, compopt[i].descr,
2784. 		compopt[i+1].name ? ',' : '.');
2785. 	putstr(datawin, 0, buf);
2786.     }
2787. 
2788.     for (i = 0; opt_epilog[i]; i++)
2789. 	putstr(datawin, 0, opt_epilog[i]);
2790. 
2791.     display_nhwindow(datawin, FALSE);
2792.     destroy_nhwindow(datawin);
2793.     return;
2794. }
2795. 
2796. /*
2797.  * prints the next boolean option, on the same line if possible, on a new
2798.  * line if not. End with next_opt("").
2799.  */
2800. void
2801. next_opt(datawin, str)
2802. winid datawin;
2803. const char *str;
2804. {
2805. 	static char *buf = 0;
2806. 	int i;
2807. 	char *s;
2808. 
2809. 	if (!buf) *(buf = (char *)alloc(BUFSZ)) = '\0';
2810. 
2811. 	if (!*str) {
2812. 		s = eos(buf);
2813. 		if (s > &buf[1] && s[-2] == ',')
2814. 		    Strcpy(s - 2, ".");	/* replace last ", " */
2815. 		i = COLNO;	/* (greater than COLNO - 2) */
2816. 	} else {
2817. 		i = strlen(buf) + strlen(str) + 2;
2818. 	}
2819. 
2820. 	if (i > COLNO - 2) { /* rule of thumb */
2821. 		putstr(datawin, 0, buf);
2822. 		buf[0] = 0;
2823. 	}
2824. 	if (*str) {
2825. 		Strcat(buf, str);
2826. 		Strcat(buf, ", ");
2827. 	} else {
2828. 		putstr(datawin, 0, str);
2829. 		free(buf),  buf = 0;
2830. 	}
2831. 	return;
2832. }
2833. 
2834. /* Returns the fid of the fruit type; if that type already exists, it
2835.  * returns the fid of that one; if it does not exist, it adds a new fruit
2836.  * type to the chain and returns the new one.
2837.  */
2838. int
2839. fruitadd(str)
2840. char *str;
2841. {
2842. 	register int i;
2843. 	register struct fruit *f;
2844. 	struct fruit *lastf = 0;
2845. 	int highest_fruit_id = 0;
2846. 	char buf[PL_FSIZ];
2847. 	boolean user_specified = (str == pl_fruit);
2848. 	/* if not user-specified, then it's a fruit name for a fruit on
2849. 	 * a bones level...
2850. 	 */
2851. 
2852. 	/* Note: every fruit has an id (spe for fruit objects) of at least
2853. 	 * 1; 0 is an error.
2854. 	 */
2855. 	if (user_specified) {
2856. 		/* disallow naming after other foods (since it'd be impossible
2857. 		 * to tell the difference)
2858. 		 */
2859. 
2860. 		boolean found = FALSE, numeric = FALSE;
2861. 
2862. 		for (i = bases[FOOD_CLASS]; objects[i].oc_class == FOOD_CLASS;
2863. 						i++) {
2864. 			if (!strcmp(OBJ_NAME(objects[i]), pl_fruit)) {
2865. 				found = TRUE;
2866. 				break;
2867. 			}
2868. 		}
2869. 		{
2870. 		    char *c;
2871. 
2872. 		    c = pl_fruit;
2873. 
2874. 		    for(c = pl_fruit; *c >= '0' && *c <= '9'; c++)
2875. 			;
2876. 		    if (isspace(*c) || *c == 0) numeric = TRUE;
2877. 		}
2878. 		if (found || numeric ||
2879. 		    !strncmp(str, "cursed ", 7) ||
2880. 		    !strncmp(str, "uncursed ", 9) ||
2881. 		    !strncmp(str, "blessed ", 8) ||
2882. 		    !strncmp(str, "partly eaten ", 13) ||
2883. 		    (!strncmp(str, "tin of ", 7) &&
2884. 			(!strcmp(str+7, "spinach") ||
2885. 			 name_to_mon(str+7) >= LOW_PM)) ||
2886. 		    !strcmp(str, "empty tin") ||
2887. 		    ((!strncmp(eos(str)-7," corpse",7) ||
2888. 			    !strncmp(eos(str)-4, " egg",4)) &&
2889. 			name_to_mon(str) >= LOW_PM))
2890. 			{
2891. 				Strcpy(buf, pl_fruit);
2892. 				Strcpy(pl_fruit, "candied ");
2893. 				nmcpy(pl_fruit+8, buf, PL_FSIZ-8);
2894. 		}
2895. 	}
2896. 	for(f=ffruit; f; f = f->nextf) {
2897. 		lastf = f;
2898. 		if(f->fid > highest_fruit_id) highest_fruit_id = f->fid;
2899. 		if(!strncmp(str, f->fname, PL_FSIZ))
2900. 			goto nonew;
2901. 	}
2902. 	/* if adding another fruit would overflow spe, use a random
2903. 	   fruit instead... we've got a lot to choose from. */
2904. 	if (highest_fruit_id >= 127) return rnd(127);
2905. 	highest_fruit_id++;
2906. 	f = newfruit();
2907. 	if (ffruit) lastf->nextf = f;
2908. 	else ffruit = f;
2909. 	Strcpy(f->fname, str);
2910. 	f->fid = highest_fruit_id;
2911. 	f->nextf = 0;
2912. nonew:
2913. 	if (user_specified) current_fruit = highest_fruit_id;
2914. 	return f->fid;
2915. }
2916. 
2917. /*
2918.  * This is a somewhat generic menu for taking a list of NetHack style
2919.  * class choices and presenting them via a description
2920.  * rather than the traditional NetHack characters.
2921.  * (Benefits users whose first exposure to NetHack is via tiles).
2922.  *
2923.  * prompt
2924.  *	     The title at the top of the menu.
2925.  *
2926.  * category: 0 = monster class
2927.  *           1 = object  class
2928.  *
2929.  * way
2930.  *	     FALSE = PICK_ONE, TRUE = PICK_ANY
2931.  *
2932.  * class_list
2933.  *	     a null terminated string containing the list of choices.
2934.  *
2935.  * class_selection
2936.  *	     a null terminated string containing the selected characters.
2937.  *
2938.  * Returns number selected.
2939.  */
2940. int
2941. choose_classes_menu(prompt, category, way, class_list, class_select)
2942. const char *prompt;
2943. int category;
2944. boolean way;
2945. char *class_list;
2946. char *class_select;
2947. {
2948.     menu_item *pick_list = (menu_item *)0;
2949.     winid win;
2950.     anything any;
2951.     char buf[BUFSZ];
2952.     int i, n;
2953.     int ret;
2954.     int next_accelerator, accelerator;
2955. 
2956.     if (class_list == (char *)0 || class_select == (char *)0) return 0;
2957.     accelerator = 0;
2958.     next_accelerator = 'a';
2959.     any.a_void = 0;
2960.     win = create_nhwindow(NHW_MENU);
2961.     start_menu(win);
2962.     while (*class_list) {
2963. 	const char *text;
2964. 	boolean selected;
2965. 
2966. 	text = (char *)0;
2967. 	selected = FALSE;
2968. 	switch (category) {
2969. 		case 0:
2970. 			text = monexplain[def_char_to_monclass(*class_list)];
2971. 			accelerator = *class_list;
2972. 			Sprintf(buf, "%s", text);
2973. 			break;
2974. 		case 1:
2975. 			text = objexplain[def_char_to_objclass(*class_list)];
2976. 			accelerator = next_accelerator;
2977. 			Sprintf(buf, "%c  %s", *class_list, text);
2978. 			break;
2979. 		default:
2980. 			impossible("choose_classes_menu: invalid category %d",
2981. 					category);
2982. 	}
2983. 	if (way && *class_select) {	/* Selections there already */
2984. 		if (index(class_select, *class_list)) {
2985. 			selected = TRUE;
2986. 		}
2987. 	}
2988. 	any.a_int = *class_list;
2989. 	add_menu(win, NO_GLYPH, &any, accelerator,
2990. 		  category ? *class_list : 0,
2991. 		  ATR_NONE, buf, selected);
2992. 	++class_list;
2993. 	if (category > 0) {
2994. 		++next_accelerator;
2995. 		if (next_accelerator == ('z' + 1)) next_accelerator = 'A';
2996. 		if (next_accelerator == ('Z' + 1)) break;
2997. 	}
2998.     }
2999.     end_menu(win, prompt);
3000.     n = select_menu(win, way ? PICK_ANY : PICK_ONE, &pick_list);
3001.     destroy_nhwindow(win);
3002.     if (n > 0) {
3003. 	for (i = 0; i < n; ++i)
3004. 	    *class_select++ = (char)pick_list[i].item.a_int;
3005. 	free((genericptr_t)pick_list);
3006. 	ret = n;
3007.     } else if (n == -1) {
3008. 	class_select = eos(class_select);
3009. 	ret = -1;
3010.     } else
3011. 	ret = 0;
3012.     *class_select = '\0';
3013.     return ret;
3014. }
3015. 
3016. struct wc_Opt wc_options[] = {
3017. 	{"ascii_map", WC_ASCII_MAP},
3018. 	{"color", WC_COLOR},
3019. 	{"eight_bit_tty", WC_EIGHT_BIT_IN},
3020. 	{"hilite_pet", WC_HILITE_PET},
3021. 	{"large_font", WC_LARGE_FONT},	/* now obsolete */
3022. 	{"popup_dialog", WC_POPUP_DIALOG},
3023. 	{"preload_tiles", WC_PRELOAD_TILES},
3024. 	{"tiled_map", WC_TILED_MAP},
3025. 	{"tile_file", WC_TILE_FILE},
3026. 	{"tile_width", WC_TILE_WIDTH},
3027. 	{"tile_height", WC_TILE_HEIGHT},
3028. 	{"use_inverse", WC_INVERSE},
3029. 	{"align_message", WC_ALIGN_MESSAGE},
3030. 	{"align_status", WC_ALIGN_STATUS},
3031. 	{"font_map", WC_FONT_MAP},
3032. 	{"font_menu", WC_FONT_MENU},
3033. 	{"font_message",WC_FONT_MESSAGE},
3034. #if 0
3035. 	{"perm_invent",WC_PERM_INVENT},
3036. #endif
3037. 	{"font_size_map", WC_FONTSIZ_MAP},
3038. 	{"font_size_menu", WC_FONTSIZ_MENU},
3039. 	{"font_size_message", WC_FONTSIZ_MESSAGE},
3040. 	{"font_size_status", WC_FONTSIZ_STATUS},
3041. 	{"font_size_text", WC_FONTSIZ_TEXT},
3042. 	{"font_status", WC_FONT_STATUS},
3043. 	{"font_text", WC_FONT_TEXT},
3044. 	{"map_mode", WC_MAP_MODE},
3045. 	{"scroll_margin", WC_SCROLL_MARGIN},
3046. 	{"vary_msgcount",WC_VARY_MSGCOUNT},
3047. 	{(char *)0, 0L}
3048. };
3049. 
3050. 
3051. /*
3052.  * If a port wants to change or ensure that the
3053.  * SET_IN_FILE, DISP_IN_GAME, or SET_IN_GAME status of an option is
3054.  * correct (for controlling its display in the option menu) call
3055.  * set_option_mod_status()
3056.  * with the second argument of 0,2, or 3 respectively.
3057.  */
3058. void
3059. set_option_mod_status(optnam, status)
3060. char *optnam;
3061. int status;
3062. {
3063. 	int k;
3064. 	if (status < SET_IN_FILE || status > SET_IN_GAME) {
3065. 		impossible("set_option_mod_status: status out of range %d.", status);
3066. 		return;
3067. 	}
3068. 	for (k = 0; boolopt[k].name; k++) {
3069. 		if (!strncmpi(boolopt[k].name, optnam, strlen(optnam))) {
3070. 			boolopt[k].optflags = status;
3071. 			return;
3072. 		}
3073. 	}
3074. 	for (k = 0; compopt[k].name; k++) {
3075. 		if (!strncmpi(compopt[k].name, optnam, strlen(optnam))) {
3076. 			compopt[k].optflags = status;
3077. 			return;
3078. 		}
3079. 	}
3080. }
3081. 
3082. /*
3083.  * You can set several wc_options in one call to
3084.  * set_wc_option_mod_status() by setting
3085.  * the appropriate bits for each option that you
3086.  * are setting in the optmask argument
3087.  * prior to calling.
3088.  *    example: set_wc_option_mod_status(WC_COLOR|WC_SCROLL_MARGIN, SET_IN_GAME);
3089.  */
3090. void
3091. set_wc_option_mod_status(optmask, status)
3092. unsigned long optmask;
3093. int status;
3094. {
3095. 	int k = 0;
3096. 	if (status < SET_IN_FILE || status > SET_IN_GAME) {
3097. 		impossible("set_option_mod_status: status out of range %d.", status);
3098. 		return;
3099. 	}
3100. 	while (wc_options[k].wc_name) {
3101. 		if (optmask & wc_options[k].wc_bit) {
3102. 			set_option_mod_status(wc_options[k].wc_name, status);
3103. 		}
3104. 		k++;
3105. 	}
3106. }
3107. 
3108. STATIC_OVL boolean
3109. is_wc_option(optnam)
3110. const char *optnam;
3111. {
3112. 	int k = 0;
3113. 	while (wc_options[k].wc_name) {
3114. 		if (strcmp(wc_options[k].wc_name, optnam) == 0)
3115. 			return TRUE;
3116. 		k++;
3117. 	}
3118. 	return FALSE;
3119. }
3120. 
3121. STATIC_OVL boolean
3122. wc_supported(optnam)
3123. const char *optnam;
3124. {
3125. 	int k = 0;
3126. 	while (wc_options[k].wc_name) {
3127. 		if (!strcmp(wc_options[k].wc_name, optnam) &&
3128. 		    (windowprocs.wincap & wc_options[k].wc_bit))
3129. 			return TRUE;
3130. 		k++;
3131. 	}
3132. 	return FALSE;
3133. }
3134. 
3135. STATIC_OVL void
3136. wc_set_font_name(wtype, fontname)
3137. int wtype;
3138. char *fontname;
3139. {
3140. 	char **fn = (char **)0;
3141. 	if (!fontname) return;
3142. 	switch(wtype) {
3143. 	    case NHW_MAP:
3144. 	    		fn = &iflags.wc_font_map;
3145. 			break;
3146. 	    case NHW_MESSAGE:
3147. 	    		fn = &iflags.wc_font_message;
3148. 			break;
3149. 	    case NHW_TEXT:
3150. 	    		fn = &iflags.wc_font_text;
3151. 			break;
3152. 	    case NHW_MENU:
3153. 	    		fn = &iflags.wc_font_menu;
3154. 			break;
3155. 	    case NHW_STATUS:
3156. 	    		fn = &iflags.wc_font_status;
3157. 			break;
3158. 	    default:
3159. 	    		return;
3160. 	}
3161. 	if (fn) {
3162. 		if (*fn) free(*fn);
3163. 		*fn = (char *)alloc(strlen(fontname) + 1);
3164. 		Strcpy(*fn, fontname);
3165. 	}
3166. 	return;
3167. }
3168. 
3169. STATIC_OVL int
3170. wc_set_window_colors(op)
3171. char *op;
3172. {
3173. 	/* syntax:
3174. 	 *  menu white/black message green/yellow status white/blue text white/black
3175. 	 */
3176. 
3177. 	int j;
3178. 	char buf[BUFSZ];
3179. 	char *wn, *tfg, *tbg, *newop;
3180. 	static char *wnames[] = {"menu", "message", "status", "text"};
3181. 	static char *shortnames[] = {"mnu", "msg", "sts", "txt"};
3182. 	static char **fgp[] = {
3183. 		&iflags.wc_foregrnd_menu,
3184. 		&iflags.wc_foregrnd_message,
3185. 		&iflags.wc_foregrnd_status,
3186. 		&iflags.wc_foregrnd_text
3187. 	};
3188. 	static char **bgp[] = {
3189. 		&iflags.wc_backgrnd_menu,
3190. 		&iflags.wc_backgrnd_message,
3191. 		&iflags.wc_backgrnd_status,
3192. 		&iflags.wc_backgrnd_text
3193. 	};
3194. 
3195. 	Strcpy(buf, op);
3196. 	newop = mungspaces(buf);
3197. 	while (newop && *newop) {
3198. 
3199. 		wn = tfg = tbg = (char *)0;
3200. 
3201. 		/* until first non-space in case there's leading spaces - before colorname*/
3202. 		while(*newop && isspace(*newop)) newop++;
3203. 		if (*newop) wn = newop;
3204. 		else return 0;
3205. 
3206. 		/* until first space - colorname*/
3207. 		while(*newop && !isspace(*newop)) newop++;
3208. 		if (*newop) *newop = '\0';
3209. 		else return 0;
3210. 		newop++;
3211. 
3212. 		/* until first non-space - before foreground*/
3213. 		while(*newop && isspace(*newop)) newop++;
3214. 		if (*newop) tfg = newop;
3215. 		else return 0;
3216. 
3217. 		/* until slash - foreground */
3218. 		while(*newop && *newop != '/') newop++;
3219. 		if (*newop) *newop = '\0';
3220. 		else return 0;
3221. 		newop++;
3222. 
3223. 		/* until first non-space (in case there's leading space after slash) - before background */
3224. 		while(*newop && isspace(*newop)) newop++;
3225. 		if (*newop) tbg = newop;
3226. 		else return 0;
3227. 
3228. 		/* until first space - background */
3229. 		while(*newop && !isspace(*newop)) newop++;
3230. 		if (*newop) *newop++ = '\0';
3231. 
3232. 		for (j = 0; j < 4; ++j) {
3233. 			if (!strcmpi(wn, wnames[j]) ||
3234. 			    !strcmpi(wn, shortnames[j])) {
3235. 				if (tfg && !strstri(tfg, " ")) {
3236. 					if (*fgp[j]) free(*fgp[j]);
3237. 					*fgp[j] = (char *)alloc(strlen(tfg) + 1);
3238. 					Strcpy(*fgp[j], tfg);
3239. 				}
3240. 				if (tbg && !strstri(tbg, " ")) {
3241. 					if (*bgp[j]) free(*bgp[j]);
3242. 					*bgp[j] = (char *)alloc(strlen(tbg) + 1);
3243. 					Strcpy(*bgp[j], tbg);
3244. 				}
3245.  				break;
3246. 			}
3247. 		}
3248. 	}
3249. 	return 1;
3250. }
3251. 
3252. #endif	/* OPTION_LISTS_ONLY */
3253. 
3254. /*options.c*/

Around Wikia's network

Random Wiki