/* opts.c */

/* Author:
 *	Steve Kirkendall
 *	14407 SW Teal Blvd. #C
 *	Beaverton, OR 97005
 *	kirkenda@cs.pdx.edu
 */


/* This file contains the code that manages the run-time options -- The 
 * values that can be modified via the "set" command.
 */

#include "config.h"
#include "vi.h"
#include "ctype.h"
#ifndef NULL
#define NULL (char *)0
#endif
extern char	*getenv();

/* maximum width to permit for strings, including ="" */
#define MAXWIDTH 20

/* These are the default values of all options */
char	o_autoindent[1] =	{FALSE};
char	o_autoprint[1] =	{TRUE};
char	o_autotab[1] =		{TRUE};
char	o_autowrite[1] = 	{FALSE};
char	o_columns[3] =		{80, 32, 255};
char	o_directory[30] =	TMPDIR;
char	o_edcompatible[1] =	{FALSE};
char	o_equalprg[80] =	{"fmt"};
char	o_errorbells[1] =	{TRUE};
char	o_exrefresh[1] =	{TRUE};
char	o_ignorecase[1] =	{FALSE};
char	o_keytime[3] =		{1, 0, 50};
char	o_keywordprg[80] =	{KEYWORDPRG};
char	o_lines[3] =		{25, 2, 96};
char	o_list[1] =		{FALSE};
char	o_number[1] =		{FALSE};
char	o_readonly[1] =		{FALSE};
char	o_remap[1] =		{TRUE};
char	o_report[3] =		{5, 1, 127};
char	o_scroll[3] =		{12, 1, 127};
char	o_shell[60] =		SHELL;
char	o_shiftwidth[3] =	{8, 1, 255};
char	o_sidescroll[3] =	{8, 1, 40};
char	o_sync[1] =		{NEEDSYNC};
char	o_tabstop[3] =		{8, 1, 40};
char	o_term[30] =		"?";
char	o_flash[1] =		{TRUE};
char	o_warn[1] =		{TRUE};
char	o_wrapscan[1] =		{TRUE};

#ifndef CRUNCH
char	o_beautify[1] =		{FALSE};
char	o_exrc[1] =		{FALSE};
char	o_mesg[1] =		{TRUE};
char	o_more[1] =		{TRUE};
char	o_novice[1] =		{FALSE};
char	o_prompt[1] =		{TRUE};
char	o_taglength[3] =	{0, 0, 30};
char	o_terse[1] =		{FALSE};
char	o_window[3] =		{0, 1, 24};
char	o_wrapmargin[3] =	{0, 0, 255};
char	o_writeany[1] =		{FALSE};
#endif

#ifndef NO_ERRLIST
char	o_cc[30] =		{CC_COMMAND};
char	o_make[30] =		{MAKE_COMMAND};
#endif

#ifndef NO_CHARATTR
char	o_charattr[1] =		{FALSE};
#endif

#ifndef NO_DIGRAPH
char	o_digraph[1] =		{FALSE};
char	o_flipcase[80]
# ifdef CS_IBMPC
	= {"\207\200\201\232\202\220\204\216\206\217\221\222\224\231\244\245"}
# endif
# ifdef CS_LATIN1
	/* initialized by initopts() */
# endif
	;
#endif

#ifndef NO_SENTENCE
char	o_hideformat[1] =	{FALSE};
#endif

#ifndef NO_EXTENSIONS
char	o_inputmode[1] =	{FALSE};
char	o_ruler[1] =		{FALSE};
#endif

#ifndef NO_MAGIC
char	o_magic[1] =		{TRUE};
#endif

#ifndef NO_MODELINES
char	o_modelines[1] =	{FALSE};
#endif

#ifndef NO_SENTENCE
char	o_paragraphs[30] =	"PPppIPLPQP";
char	o_sections[30] =	"NHSHSSSEse";
#endif

#if MSDOS
char	o_pcbios[1] =		{TRUE};
#endif

#ifndef NO_SHOWMATCH
char	o_showmatch[1] =	{FALSE};
#endif

#ifndef	NO_SHOWMODE
char	o_smd[1] =		{FALSE};
#endif


/* The following describes the names & types of all options */
#define BOOL	0
#define	NUM	1
#define	STR	2
#define SET	0x01	/* this option has had its value altered */
#define CANSET	0x02	/* this option can be set at any time */
#define RCSET	0x06	/* this option can be set in a .exrc file only */
#define NOSAVE	0x0a	/* this option should never be saved by mkexrc */
#define WSET	0x20	/* is this the "window" size option? */
#define MR	0x40	/* does this option affect the way text is displayed? */
struct
{
	char	*name;	/* name of an option */
	char	*nm;	/* short name of an option */
	char	type;	/* type of an option */
	char	flags;	/* boolean: has this option been set? */
	char	*value;	/* value */
}
	opts[] =
{
	/* name			type	flags		value */
	{ "autoindent",	"ai",	BOOL,	CANSET,		o_autoindent	},
	{ "autoprint",	"ap",	BOOL,	CANSET,		o_autoprint	},
	{ "autotab",	"at",	BOOL,	CANSET,		o_autotab	},
	{ "autowrite",	"aw",	BOOL,	CANSET,		o_autowrite	},
#ifndef CRUNCH
	{ "beautify",	"bf",	BOOL,	CANSET,		o_beautify	},
#endif
#ifndef NO_ERRLIST
	{ "cc",		"cc",	STR,	CANSET,		o_cc		},
#endif
#ifndef NO_CHARATTR
	{ "charattr",	"ca",	BOOL,	CANSET|MR,	o_charattr	},
#endif
	{ "columns",	"co",	NUM,	SET|NOSAVE|MR,	o_columns	},
#ifndef NO_DIGRAPH
	{ "digraph",	"dig",	BOOL,	CANSET,		o_digraph	},
#endif
	{ "directory",	"dir",	STR,	RCSET,		o_directory	},
	{ "edcompatible","ed",	BOOL,	CANSET,		o_edcompatible	},
	{ "equalprg",	"ep",	STR,	CANSET,		o_equalprg	},
	{ "errorbells",	"eb",	BOOL,	CANSET,		o_errorbells	},
#ifndef CRUNCH
	{ "exrc",	"exrc",	BOOL,	CANSET,		o_exrc		},
#endif
	{ "exrefresh",	"er",	BOOL,	CANSET,		o_exrefresh	},
	{ "flash",	"vbell",BOOL,	CANSET,		o_flash		},
#ifndef NO_DIGRAPH
	{ "flipcase",	"fc",	STR,	CANSET,		o_flipcase	},
#endif
#ifndef NO_SENTENCE
	{ "hideformat",	"hf",	BOOL,	CANSET|MR,	o_hideformat	},
#endif
	{ "ignorecase",	"ic",	BOOL,	CANSET,		o_ignorecase	},
#ifndef NO_EXTENSIONS
	{ "inputmode",	"im",	BOOL,	CANSET,		o_inputmode	},
#endif
	{ "keytime",	"kt",	NUM,	CANSET,		o_keytime	},
	{ "keywordprg",	"kp",	STR,	CANSET,		o_keywordprg	},
	{ "lines",	"ls",	NUM,	SET|NOSAVE|MR,	o_lines		},
	{ "list",	"li",	BOOL,	CANSET|MR,	o_list		},
#ifndef NO_MAGIC
	{ "magic",	"ma",	BOOL,	CANSET,		o_magic		},
#endif
#ifndef NO_ERRLIST
	{ "make",	"mk",	STR,	CANSET,		o_make		},
#endif
#ifndef CRUNCH
	{ "mesg",	"me",	BOOL,	CANSET,		o_mesg		},
#endif
#ifndef NO_MODELINES
	{ "modelines",	"ml",	BOOL,	CANSET,		o_modelines	},
#endif
#ifndef CRUNCH
	{ "more",	"mo",	BOOL,	CANSET,		o_more		},
	{ "novice",	"nov",	BOOL,	CANSET,		o_novice	},
#endif
	{ "number",	"nu",	BOOL,	CANSET|MR,	o_number	},
#ifndef NO_SENTENCE
	{ "paragraphs",	"para",	STR,	CANSET,		o_paragraphs	},
#endif
#if MSDOS
	{ "pcbios",	"pc",	BOOL,	SET|NOSAVE,	o_pcbios	},
#endif
#ifndef CRUNCH
	{ "prompt",	"pr",	BOOL,	CANSET,		o_prompt	},
#endif
	{ "readonly",	"ro",	BOOL,	CANSET,		o_readonly	},
	{ "remap",	"remap",BOOL,	CANSET,		o_remap		},
	{ "report",	"re",	NUM,	CANSET,		o_report	},
#ifndef NO_EXTENSIONS
	{ "ruler",	"ru",	BOOL,	CANSET,		o_ruler		},
#endif
	{ "scroll",	"sc",	NUM,	CANSET,		o_scroll	},
#ifndef NO_SENTENCE
	{ "sections",	"sect",	STR,	CANSET,		o_sections	},
#endif
	{ "shell",	"sh",	STR,	CANSET,		o_shell		},
#ifndef NO_SHOWMATCH
	{ "showmatch",	"sm",	BOOL,	CANSET,		o_showmatch	},
#endif
#ifndef	NO_SHOWMODE
	{ "showmode",	"smd",	BOOL,	CANSET,		o_smd		},
#endif
	{ "shiftwidth",	"sw",	NUM,	CANSET,		o_shiftwidth	},
	{ "sidescroll",	"ss",	NUM,	CANSET,		o_sidescroll	},
	{ "sync",	"sy",	BOOL,	CANSET,		o_sync		},
	{ "tabstop",	"ts",	NUM,	CANSET|MR,	o_tabstop	},
#ifndef CRUNCH
	{ "taglength",	"tl",	NUM,	CANSET,		o_taglength	},
#endif
	{ "term",	"te",	STR,	SET,		o_term		},
#ifndef CRUNCH
	{ "terse",	"tr",	BOOL,	CANSET,		o_terse		},
	{ "timeout",	"to",	BOOL,	CANSET,		o_keytime	},
#endif
#ifndef CRUNCH
	{ "window",	"wi",	NUM,	CANSET|MR|WSET,	o_window	},
	{ "wrapmargin",	"wm",	NUM,	CANSET,		o_wrapmargin	},
#endif
	{ "wrapscan",	"ws",	BOOL,	CANSET,		o_wrapscan	},
#ifndef CRUNCH
	{ "writeany",	"wr",	BOOL,	CANSET,		o_writeany	},
#endif
	{ NULL, NULL, 0, CANSET, NULL }
};


/* This function initializes certain options from environment variables, etc. */
void initopts()
{
	char	*val;
	int	i;

	/* set some stuff from environment variables */
#if MSDOS
	if (val = getenv("COMSPEC")) /* yes, ASSIGNMENT! */
#else
	if (val = getenv("SHELL")) /* yes, ASSIGNMENT! */
#endif
	{
		strcpy(o_shell, val);
	}

	strcpy(o_term, termtype);
#if MSDOS
	if (strcmp(termtype, "pcbios"))
	{
		o_pcbios[0] = FALSE;
	}
	else
	{
		o_pcbios[0] = TRUE;
	}
#endif

#if AMIGA || MSDOS || TOS
	if ((val = getenv("TMP")) /* yes, ASSIGNMENT! */
	||  (val = getenv("TEMP")))
		strcpy(o_directory, val);
#endif

#ifndef CRUNCH
	if ((val = getenv("LINES")) && atoi(val) > 4) /* yes, ASSIGNMENT! */
	{
		LINES = atoi(val);
	}
	if ((val = getenv("COLUMNS")) && atoi(val) > 30) /* yes, ASSIGNMENT! */
	{
		COLS = atoi(val);
	}
#endif
	*o_lines = LINES;
	*o_columns = COLS;
	*o_scroll = LINES / 2 - 1;
#ifndef CRUNCH
	if (o_window[0] == 0)
	{
		o_window[0] = o_window[2] = *o_lines;
	}
#endif

	/* disable the flash option if we don't know how to do a flash */
	if (!has_VB)
	{
		for (i = 0; opts[i].value != o_flash; i++)
		{
		}
		opts[i].flags &= ~CANSET;
		*o_flash = FALSE;
	}

#ifndef NO_DIGRAPH
# ifdef CS_LATIN1
	for (i = 0, val = o_flipcase; i < 32; i++)
	{
		/* leave out the multiply/divide symbols */
		if (i == 23)
			continue;

		/* add lower/uppercase pair */
		*val++ = i + 0xe0;
		*val++ = i + 0xc0;
	}
	*val = '\0';
# endif /* CS_LATIN1 */

	/* initialize the ctype package */
	_ct_init(o_flipcase);
#else
	_ct_init("");
#endif /* not NO_DIGRAPH */
}

/* This function lists the current values of all options */
void dumpopts(all)
	int	all;	/* boolean: dump all options, or just set ones? */
{
#ifndef NO_OPTCOLS
	int	i, j, k;
	char	nbuf[4];	/* used for converting numbers to ASCII */
	int	widths[5];	/* width of each column, including gap */
	int	ncols;		/* number of columns */
	int	nrows;		/* number of options per column */
	int	nset;		/* number of options to be output */
	int	width;		/* width of a particular option */
	int	todump[60];	/* indicies of options to be dumped */

	/* step 1: count the number of set options */
	for (nset = i = 0; opts[i].name; i++)
	{
		if (all || (opts[i].flags & SET))
		{
			todump[nset++] = i;
		}
	}

	/* step two: try to use as many columns as possible */
	for (ncols = (nset > 5 ? 5 : nset); ncols > 1; ncols--)
	{
		/* how many would go in this column? */
		nrows = (nset + ncols - 1) / ncols;

		/* figure out the width of each column */
		for (i = 0; i < ncols; i++)
		{
			widths[i] = 0;
			for (j = 0, k = nrows * i; j < nrows && k < nset; j++, k++)
			{
				/* figure out the width of a particular option */
				switch (opts[todump[k]].type)
				{
				  case BOOL:
					if (!*opts[todump[k]].value)
						width = 2;
					else
						width = 0;
					break;

				  case STR:
					width = 3 + strlen(opts[todump[k]].value);
					if (width > MAXWIDTH)
						width = MAXWIDTH;
					break;

				  case NUM:
					width = 4;
					break;
				}
				width += strlen(opts[todump[k]].name);

				/* if this is the widest so far, widen col */
				if (width > widths[i])
				{
					widths[i] = width;
				}
			}

		}

		/* if the total width is narrow enough, then use it */
		for (width = -2, i = 0; i < ncols; i++)
		{
			width += widths[i] + 2;
		}
		if (width < COLS - 1)
		{
			break;
		}
	}

	/* step 3: output the columns */
	nrows = (nset + ncols - 1) / ncols;
	for (i = 0; i < nrows; i++)
	{
		for (j = 0; j < ncols; j++)
		{
			/* if we hit the end of the options, quit */
			k = i + j * nrows;
			if (k >= nset)
			{
				break;
			}

			/* output this option's value */
			width = 0;
			switch (opts[todump[k]].type)
			{
			  case BOOL:
				if (!*opts[todump[k]].value)
				{
					qaddch('n');
					qaddch('o');
					width = 2;
				}
				qaddstr(opts[todump[k]].name);
				width += strlen(opts[todump[k]].name);
				break;

			  case NUM:
				sprintf(nbuf, "%-3d", UCHAR(*opts[todump[k]].value));
				qaddstr(opts[todump[k]].name);
				qaddch('=');
				qaddstr(nbuf);
				width = 4 + strlen(opts[todump[k]].name);
				break;

			  case STR:
				qaddstr(opts[todump[k]].name);
				qaddch('=');
				qaddch('"');
				strcpy(tmpblk.c, opts[todump[k]].value);
				width = 3 + strlen(tmpblk.c);
				if (width > MAXWIDTH)
				{
					width = MAXWIDTH;
					strcpy(tmpblk.c + MAXWIDTH - 6, "...");
				}
				qaddstr(tmpblk.c);
				qaddch('"');
				width += strlen(opts[todump[k]].name);
				break;
			}

			/* pad the field to the correct size */
			if (k + nrows <= nset)
			{
				while (width < widths[j] + 2)
				{
					qaddch(' ');
					width++;
				}
			}
		}
		addch('\n');
		exrefresh();
	}
#else
	int	i;
	int	col;
	char	nbuf[4];

	for (i = col = 0; opts[i].name; i++)
	{
		/* if not set and not all, ignore this option */
		if (!all && !(opts[i].flags & SET))
		{
			continue;
		}

		/* align this option in one of the columns */
		if (col > 52)
		{
			addch('\n');
			col = 0;
		}
		else if (col > 26)
		{
			while (col < 52)
			{
				qaddch(' ');
				col++;
			}
		}
		else if (col > 0)
		{
			while (col < 26)
			{
				qaddch(' ');
				col++;
			}
		}

		switch (opts[i].type)
		{
		  case BOOL:
			if (!*opts[i].value)
			{
				qaddch('n');
				qaddch('o');
				col += 2;
			}
			qaddstr(opts[i].name);
			col += strlen(opts[i].name);
			break;

		  case NUM:
			sprintf(nbuf, "%-3d", UCHAR(*opts[i].value));
			qaddstr(opts[i].name);
			qaddch('=');
			qaddstr(nbuf);
			col += 4 + strlen(opts[i].name);
			break;

		  case STR:
			qaddstr(opts[i].name);
			qaddch('=');
			qaddch('"');
			qaddstr(opts[i].value);
			qaddch('"');
			col += 3 + strlen(opts[i].name) + strlen(opts[i].value);
			break;
		}
		exrefresh();
	}
	if (col > 0)
	{
		addch('\n');
		exrefresh();
	}
#endif
}

#ifndef NO_MKEXRC
/* This function saves the current configuration of options to a file */
void saveopts(fd)
	int	fd;	/* file descriptor to write to */
{
	int	i;
	char	buf[256], *pos;

	/* write each set options */
	for (i = 0; opts[i].name; i++)
	{
		/* if unset or unsettable, ignore this option */
		if ((opts[i].flags & (SET|CANSET|NOSAVE)) != (SET|CANSET))
		{
			continue;
		}

		strcpy(buf, "set ");
		pos = &buf[4];
		switch (opts[i].type)
		{
		  case BOOL:
			if (!*opts[i].value)
			{
				*pos++='n';
				*pos++='o';
			}
			strcpy(pos, opts[i].name);
			strcat(pos, "\n");
			break;

		  case NUM:
			sprintf(pos, "%s=%-3d\n", opts[i].name, *opts[i].value & 0xff);
			break;

		  case STR:
			sprintf(pos, "%s=\"%s\"\n", opts[i].name, opts[i].value);
			break;
		}
		twrite(fd, buf, (unsigned)strlen(buf));
	}
}
#endif


/* This function changes the values of one or more options. */
void setopts(assignments)
	char	*assignments;	/* a string containing option assignments */
{
	char	*name;		/* name of variable in assignments */
	char	*value;		/* value of the variable */
	char	*scan;		/* used for moving through strings */
	char	*build;		/* used for copying chars from "scan" */
	char	*prefix;	/* pointer to "neg" or "no" at front of a boolean */
	int	quote;		/* boolean: inside '"' quotes? */
	int	i, j;

#ifndef CRUNCH
	/* reset the upper limit of "window" option to lines-1 */
	*o_window = *o_lines - 1;
#endif

	/* for each assignment... */
	for (name = assignments; *name; )
	{
		/* skip whitespace */
		if (*name == ' ' || *name == '\t')
		{
			name++;
			continue;
		}

		/* after the name, find the value (if any) */
		for (scan = name; isalnum(*scan); scan++)
		{
		}
		if (*scan == '=')
		{
			*scan++ = '\0';
			value = build = scan;
			for (quote = FALSE; *scan && (quote || !isspace(*scan)); scan++)
			{
				if (*scan == '"')
				{
					quote = !quote;
				}
				else if (*scan == '\\' && scan[1])
				{
					*build++ = *++scan;
				}
				else
				{
					*build++ = *scan;
				}
			}
			if (*scan)
				scan++;
			*build = '\0';
		}
		else /* no "=" so it is probably boolean... */
		{
			if (*scan)
			{
				*scan++ = '\0';
			}
			value = NULL;
			prefix = name;
#ifndef CRUNCH
			if (!strcmp(name, "novice"))
				/* don't check for a "no" prefix */;
			else
#endif
			if (prefix[0] == 'n' && prefix[1] == 'o')
				name += 2;
			else if (prefix[0] == 'n' && prefix[1] == 'e' && prefix[2] == 'g')
				name += 3;
		}

		/* find the variable */
		for (i = 0;
		     opts[i].name && strcmp(opts[i].name, name) && strcmp(opts[i].nm, name);
		     i++)
		{
		}

		/* change the variable */
		if (!opts[i].name)
		{
			msg("invalid option name \"%s\"", name);
		}
		else if ((opts[i].flags & CANSET) != CANSET)
		{
			msg("option \"%s\" can't be altered", name);
		}
		else if ((opts[i].flags & RCSET) != CANSET && nlines >= 1L)
		{
			msg("option \"%s\" can only be set in a %s file", name, EXRC);
		}
		else if (value)
		{
			switch (opts[i].type)
			{
			  case BOOL:
				msg("option \"[no]%s\" is boolean", name);
				break;

			  case NUM:
				j = atoi(value);
				if (j == 0 && *value != '0')
				{
					msg("option \"%s\" must have a numeric value", name);
				}
				else if (j < opts[i].value[1] || j > (opts[i].value[2] & 0xff))
				{
					msg("option \"%s\" must have a value between %d and %d",
						name, opts[i].value[1], opts[i].value[2] & 0xff);
				}
				else
				{
					*opts[i].value = atoi(value);
					opts[i].flags |= SET;
				}
				break;

			  case STR:
				strcpy(opts[i].value, value);
				opts[i].flags |= SET;
				break;
			}
			if (opts[i].flags & MR)
			{
				redraw(MARK_UNSET, FALSE);
			}
#ifndef CRUNCH
			if (opts[i].flags & WSET)
			{
				wset = TRUE;
			}
#endif
		}
		else /* valid option, no value */
		{
			if (opts[i].type == BOOL)
			{
				if (prefix == name)
					*opts[i].value = TRUE;
				else if (prefix[1] == 'o')
					*opts[i].value = FALSE;
				else
					*opts[i].value = !*opts[i].value;

				opts[i].flags |= SET;
				if (opts[i].flags & MR)
				{
					redraw(MARK_UNSET, FALSE);
				}
			}
			else
			{
				msg("option \"%s\" must be given a value", name);
			}
		}

		/* move on to the next option */
		name = scan;
	}

	/* special processing ... */

#ifndef CRUNCH
	/* if "novice" is set, then ":set report=1 showmode nomagic" */
	if (*o_novice)
	{
		*o_report = 1;
# ifndef NO_SHOWMODE
		*o_smd = TRUE;
# endif
# ifndef NO_MAGIC
		*o_magic = FALSE;
# endif
	}
#endif

	/* if "readonly" then set the READONLY flag for this file */
	if (*o_readonly)
	{
		setflag(file, READONLY);
	}

#ifndef NO_DIGRAPH
	/* re-initialize the ctype package */
	_ct_init(o_flipcase);
#endif /* not NO_DIGRAPH */

	/* copy o_lines and o_columns into LINES and COLS */
	LINES = (*o_lines & 255);
	COLS = (*o_columns & 255);
}