?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
protoize most of the function prototypes
[nvi.git] / common / options.c
blobaa49f80a021a39ca9997060660cba03f3a9b2233
1 /*-
2 * Copyright (c) 1991, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1991, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #ifndef lint
13 static const char sccsid[] = "$Id: options.c,v 10.62 2001/06/25 15:19:11 skimo Exp $ (Berkeley) $Date: 2001/06/25 15:19:11 $";
14 #endif /* not lint */
15
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/stat.h>
19 #include <sys/time.h>
20
21 #include <bitstring.h>
22 #include <ctype.h>
23 #include <errno.h>
24 #include <limits.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29
30 #include "common.h"
31 #include "../vi/vi.h"
32 #include "pathnames.h"
33
34 static int opts_abbcmp __P((const void *, const void *));
35 static int opts_cmp __P((const void *, const void *));
36 static int opts_print __P((SCR *, OPTLIST const *));
37
38 /*
39 * O'Reilly noted options and abbreviations are from "Learning the VI Editor",
40 * Fifth Edition, May 1992. There's no way of knowing what systems they are
41 * actually from.
42 *
43 * HPUX noted options and abbreviations are from "The Ultimate Guide to the
44 * VI and EX Text Editors", 1990.
45 */
46 OPTLIST const optlist[] = {
47 /* O_ALTWERASE 4.4BSD */
48 {L("altwerase"), f_altwerase, OPT_0BOOL, 0},
49 /* O_AUTOINDENT 4BSD */
50 {L("autoindent"), NULL, OPT_0BOOL, 0},
51 /* O_AUTOPRINT 4BSD */
52 {L("autoprint"), NULL, OPT_1BOOL, 0},
53 /* O_AUTOWRITE 4BSD */
54 {L("autowrite"), NULL, OPT_0BOOL, 0},
55 /* O_BACKUP 4.4BSD */
56 {L("backup"), NULL, OPT_STR, 0},
57 /* O_BEAUTIFY 4BSD */
58 {L("beautify"), NULL, OPT_0BOOL, 0},
59 /* O_CDPATH 4.4BSD */
60 {L("cdpath"), NULL, OPT_STR, 0},
61 /* O_CEDIT 4.4BSD */
62 {L("cedit"), NULL, OPT_STR, 0},
63 /* O_COLUMNS 4.4BSD */
64 {L("columns"), f_columns, OPT_NUM, OPT_NOSAVE},
65 /* O_COMMENT 4.4BSD */
66 {L("comment"), NULL, OPT_0BOOL, 0},
67 /* O_DIRECTORY 4BSD */
68 {L("directory"), NULL, OPT_STR, 0},
69 /* O_EDCOMPATIBLE 4BSD */
70 {L("edcompatible"),NULL, OPT_0BOOL, 0},
71 /* O_ESCAPETIME 4.4BSD */
72 {L("escapetime"), NULL, OPT_NUM, 0},
73 /* O_ERRORBELLS 4BSD */
74 {L("errorbells"), NULL, OPT_0BOOL, 0},
75 /* O_EXRC System V (undocumented) */
76 {L("exrc"), NULL, OPT_0BOOL, 0},
77 /* O_EXTENDED 4.4BSD */
78 {L("extended"), f_recompile, OPT_0BOOL, 0},
79 /* O_FILEC 4.4BSD */
80 {L("filec"), NULL, OPT_STR, 0},
81 /* O_FILEENCODING */
82 {L("fileencoding"),f_encoding, OPT_STR, 0},
83 /* O_FLASH HPUX */
84 {L("flash"), NULL, OPT_1BOOL, 0},
85 /* O_HARDTABS 4BSD */
86 {L("hardtabs"), NULL, OPT_NUM, 0},
87 /* O_ICLOWER 4.4BSD */
88 {L("iclower"), f_recompile, OPT_0BOOL, 0},
89 /* O_IGNORECASE 4BSD */
90 {L("ignorecase"), f_recompile, OPT_0BOOL, 0},
91 /* O_INPUTENCODING */
92 {L("inputencoding"),f_encoding, OPT_STR, 0},
93 /* O_KEYTIME 4.4BSD */
94 {L("keytime"), NULL, OPT_NUM, 0},
95 /* O_LEFTRIGHT 4.4BSD */
96 {L("leftright"), f_reformat, OPT_0BOOL, 0},
97 /* O_LINES 4.4BSD */
98 {L("lines"), f_lines, OPT_NUM, OPT_NOSAVE},
99 /* O_LISP 4BSD
100 * XXX
101 * When the lisp option is implemented, delete the OPT_NOSAVE flag,
102 * so that :mkexrc dumps it.
103 */
104 {L("lisp"), f_lisp, OPT_0BOOL, OPT_NOSAVE},
105 /* O_LIST 4BSD */
106 {L("list"), f_reformat, OPT_0BOOL, 0},
107 /* O_LOCKFILES 4.4BSD
108 * XXX
109 * Locking isn't reliable enough over NFS to require it, in addition,
110 * it's a serious startup performance problem over some remote links.
111 */
112 {L("lock"), NULL, OPT_1BOOL, 0},
113 /* O_MAGIC 4BSD */
114 {L("magic"), NULL, OPT_1BOOL, 0},
115 /* O_MATCHTIME 4.4BSD */
116 {L("matchtime"), NULL, OPT_NUM, 0},
117 /* O_MESG 4BSD */
118 {L("mesg"), NULL, OPT_1BOOL, 0},
119 /* O_MODELINE 4BSD
120 * !!!
121 * This has been documented in historical systems as both "modeline"
122 * and as "modelines". Regardless of the name, this option represents
123 * a security problem of mammoth proportions, not to mention a stunning
124 * example of what your intro CS professor referred to as the perils of
125 * mixing code and data. Don't add it, or I will kill you.
126 */
127 {L("modeline"), NULL, OPT_0BOOL, OPT_NOSET},
128 /* O_MSGCAT 4.4BSD */
129 {L("msgcat"), f_msgcat, OPT_STR, 0},
130 /* O_NOPRINT 4.4BSD */
131 {L("noprint"), f_print, OPT_STR, 0},
132 /* O_NUMBER 4BSD */
133 {L("number"), f_reformat, OPT_0BOOL, 0},
134 /* O_OCTAL 4.4BSD */
135 {L("octal"), f_print, OPT_0BOOL, 0},
136 /* O_OPEN 4BSD */
137 {L("open"), NULL, OPT_1BOOL, 0},
138 /* O_OPTIMIZE 4BSD */
139 {L("optimize"), NULL, OPT_1BOOL, 0},
140 /* O_PARAGRAPHS 4BSD */
141 {L("paragraphs"), f_paragraph, OPT_STR, 0},
142 /* O_PATH 4.4BSD */
143 {L("path"), NULL, OPT_STR, 0},
144 /* O_PRINT 4.4BSD */
145 {L("print"), f_print, OPT_STR, 0},
146 /* O_PROMPT 4BSD */
147 {L("prompt"), NULL, OPT_1BOOL, 0},
148 /* O_READONLY 4BSD (undocumented) */
149 {L("readonly"), f_readonly, OPT_0BOOL, OPT_ALWAYS},
150 /* O_RECDIR 4.4BSD */
151 {L("recdir"), NULL, OPT_STR, 0},
152 /* O_REDRAW 4BSD */
153 {L("redraw"), NULL, OPT_0BOOL, 0},
154 /* O_REMAP 4BSD */
155 {L("remap"), NULL, OPT_1BOOL, 0},
156 /* O_REPORT 4BSD */
157 {L("report"), NULL, OPT_NUM, 0},
158 /* O_RULER 4.4BSD */
159 {L("ruler"), NULL, OPT_0BOOL, 0},
160 /* O_SCROLL 4BSD */
161 {L("scroll"), NULL, OPT_NUM, 0},
162 /* O_SEARCHINCR 4.4BSD */
163 {L("searchincr"), NULL, OPT_0BOOL, 0},
164 /* O_SECTIONS 4BSD */
165 {L("sections"), f_section, OPT_STR, 0},
166 /* O_SECURE 4.4BSD */
167 {L("secure"), NULL, OPT_0BOOL, OPT_NOUNSET},
168 /* O_SHELL 4BSD */
169 {L("shell"), NULL, OPT_STR, 0},
170 /* O_SHELLMETA 4.4BSD */
171 {L("shellmeta"), NULL, OPT_STR, 0},
172 /* O_SHIFTWIDTH 4BSD */
173 {L("shiftwidth"), NULL, OPT_NUM, OPT_NOZERO},
174 /* O_SHOWMATCH 4BSD */
175 {L("showmatch"), NULL, OPT_0BOOL, 0},
176 /* O_SHOWMODE 4.4BSD */
177 {L("showmode"), NULL, OPT_0BOOL, 0},
178 /* O_SIDESCROLL 4.4BSD */
179 {L("sidescroll"), NULL, OPT_NUM, OPT_NOZERO},
180 /* O_SLOWOPEN 4BSD */
181 {L("slowopen"), NULL, OPT_0BOOL, 0},
182 /* O_SOURCEANY 4BSD (undocumented)
183 * !!!
184 * Historic vi, on startup, source'd $HOME/.exrc and ./.exrc, if they
185 * were owned by the user. The sourceany option was an undocumented
186 * feature of historic vi which permitted the startup source'ing of
187 * .exrc files the user didn't own. This is an obvious security problem,
188 * and we ignore the option.
189 */
190 {L("sourceany"), NULL, OPT_0BOOL, OPT_NOSET},
191 /* O_TABSTOP 4BSD */
192 {L("tabstop"), f_reformat, OPT_NUM, OPT_NOZERO},
193 /* O_TAGLENGTH 4BSD */
194 {L("taglength"), NULL, OPT_NUM, 0},
195 /* O_TAGS 4BSD */
196 {L("tags"), NULL, OPT_STR, 0},
197 /* O_TERM 4BSD
198 * !!!
199 * By default, the historic vi always displayed information about two
200 * options, redraw and term. Term seems sufficient.
201 */
202 {L("term"), NULL, OPT_STR, OPT_ADISP|OPT_NOSAVE},
203 /* O_TERSE 4BSD */
204 {L("terse"), NULL, OPT_0BOOL, 0},
205 /* O_TILDEOP 4.4BSD */
206 {L("tildeop"), NULL, OPT_0BOOL, 0},
207 /* O_TIMEOUT 4BSD (undocumented) */
208 {L("timeout"), NULL, OPT_1BOOL, 0},
209 /* O_TTYWERASE 4.4BSD */
210 {L("ttywerase"), f_ttywerase, OPT_0BOOL, 0},
211 /* O_VERBOSE 4.4BSD */
212 {L("verbose"), NULL, OPT_0BOOL, 0},
213 /* O_W1200 4BSD */
214 {L("w1200"), f_w1200, OPT_NUM, OPT_NDISP|OPT_NOSAVE},
215 /* O_W300 4BSD */
216 {L("w300"), f_w300, OPT_NUM, OPT_NDISP|OPT_NOSAVE},
217 /* O_W9600 4BSD */
218 {L("w9600"), f_w9600, OPT_NUM, OPT_NDISP|OPT_NOSAVE},
219 /* O_WARN 4BSD */
220 {L("warn"), NULL, OPT_1BOOL, 0},
221 /* O_WINDOW 4BSD */
222 {L("window"), f_window, OPT_NUM, 0},
223 /* O_WINDOWNAME 4BSD */
224 {L("windowname"), NULL, OPT_0BOOL, 0},
225 /* O_WRAPLEN 4.4BSD */
226 {L("wraplen"), NULL, OPT_NUM, 0},
227 /* O_WRAPMARGIN 4BSD */
228 {L("wrapmargin"), NULL, OPT_NUM, 0},
229 /* O_WRAPSCAN 4BSD */
230 {L("wrapscan"), NULL, OPT_1BOOL, 0},
231 /* O_WRITEANY 4BSD */
232 {L("writeany"), NULL, OPT_0BOOL, 0},
233 {NULL},
234 };
235
236 typedef struct abbrev {
237 CHAR_T *name;
238 int offset;
239 } OABBREV;
240
241 static OABBREV const abbrev[] = {
242 {L("ai"), O_AUTOINDENT}, /* 4BSD */
243 {L("ap"), O_AUTOPRINT}, /* 4BSD */
244 {L("aw"), O_AUTOWRITE}, /* 4BSD */
245 {L("bf"), O_BEAUTIFY}, /* 4BSD */
246 {L("co"), O_COLUMNS}, /* 4.4BSD */
247 {L("dir"), O_DIRECTORY}, /* 4BSD */
248 {L("eb"), O_ERRORBELLS}, /* 4BSD */
249 {L("ed"), O_EDCOMPATIBLE}, /* 4BSD */
250 {L("ex"), O_EXRC}, /* System V (undocumented) */
251 {L("fe"), O_FILEENCODING},
252 {L("ht"), O_HARDTABS}, /* 4BSD */
253 {L("ic"), O_IGNORECASE}, /* 4BSD */
254 {L("ie"), O_INPUTENCODING},
255 {L("li"), O_LINES}, /* 4.4BSD */
256 {L("modelines"), O_MODELINE}, /* HPUX */
257 {L("nu"), O_NUMBER}, /* 4BSD */
258 {L("opt"), O_OPTIMIZE}, /* 4BSD */
259 {L("para"), O_PARAGRAPHS}, /* 4BSD */
260 {L("re"), O_REDRAW}, /* O'Reilly */
261 {L("ro"), O_READONLY}, /* 4BSD (undocumented) */
262 {L("scr"), O_SCROLL}, /* 4BSD (undocumented) */
263 {L("sect"), O_SECTIONS}, /* O'Reilly */
264 {L("sh"), O_SHELL}, /* 4BSD */
265 {L("slow"), O_SLOWOPEN}, /* 4BSD */
266 {L("sm"), O_SHOWMATCH}, /* 4BSD */
267 {L("smd"), O_SHOWMODE}, /* 4BSD */
268 {L("sw"), O_SHIFTWIDTH}, /* 4BSD */
269 {L("tag"), O_TAGS}, /* 4BSD (undocumented) */
270 {L("tl"), O_TAGLENGTH}, /* 4BSD */
271 {L("to"), O_TIMEOUT}, /* 4BSD (undocumented) */
272 {L("ts"), O_TABSTOP}, /* 4BSD */
273 {L("tty"), O_TERM}, /* 4BSD (undocumented) */
274 {L("ttytype"), O_TERM}, /* 4BSD (undocumented) */
275 {L("w"), O_WINDOW}, /* O'Reilly */
276 {L("wa"), O_WRITEANY}, /* 4BSD */
277 {L("wi"), O_WINDOW}, /* 4BSD (undocumented) */
278 {L("wl"), O_WRAPLEN}, /* 4.4BSD */
279 {L("wm"), O_WRAPMARGIN}, /* 4BSD */
280 {L("ws"), O_WRAPSCAN}, /* 4BSD */
281 {NULL},
282 };
283
284 /*
285 * opts_init --
286 * Initialize some of the options.
287 *
288 * PUBLIC: int opts_init __P((SCR *, int *));
289 */
290 int
291 opts_init(SCR *sp, int *oargs)
292 {
293 ARGS *argv[2], a, b;
294 OPTLIST const *op;
295 u_long isset, v;
296 int cnt, optindx;
297 char *s;
298 CHAR_T b2[1024];
299 CHAR_T *wp;
300 size_t wlen;
301
302 a.bp = b2;
303 b.bp = NULL;
304 a.len = b.len = 0;
305 argv[0] = &a;
306 argv[1] = &b;
307
308 /* Set numeric and string default values. */
309 #define OI(indx, str) { \
310 a.len = STRLEN(str); \
311 if ((CHAR_T*)str != b2) /* GCC puts strings in text-space. */ \
312 (void)MEMCPY(b2, str, a.len+1); \
313 if (opts_set(sp, argv, NULL)) { \
314 optindx = indx; \
315 goto err; \
316 } \
317 }
318 /*
319 * Indirect global options to global space. Specifically, set up
320 * terminal, lines, columns first, they're used by other options.
321 * Note, don't set the flags until we've set up the indirection.
322 */
323 if (o_set(sp, O_TERM, 0, NULL, GO_TERM))
324 goto err;
325 F_SET(&sp->opts[O_TERM], OPT_GLOBAL);
326 if (o_set(sp, O_LINES, 0, NULL, GO_LINES))
327 goto err;
328 F_SET(&sp->opts[O_LINES], OPT_GLOBAL);
329 if (o_set(sp, O_COLUMNS, 0, NULL, GO_COLUMNS))
330 goto err;
331 F_SET(&sp->opts[O_COLUMNS], OPT_GLOBAL);
332 if (o_set(sp, O_SECURE, 0, NULL, GO_SECURE))
333 goto err;
334 F_SET(&sp->opts[O_SECURE], OPT_GLOBAL);
335
336 /* Initialize string values. */
337 (void)SPRINTF(b2, SIZE(b2),
338 L("cdpath=%s"), (s = getenv("CDPATH")) == NULL ? ":" : s);
339 OI(O_CDPATH, b2);
340
341 /*
342 * !!!
343 * Vi historically stored temporary files in /var/tmp. We store them
344 * in /tmp by default, hoping it's a memory based file system. There
345 * are two ways to change this -- the user can set either the directory
346 * option or the TMPDIR environmental variable.
347 */
348 (void)SPRINTF(b2, SIZE(b2),
349 L("directory=%s"), (s = getenv("TMPDIR")) == NULL ? _PATH_TMP : s);
350 OI(O_DIRECTORY, b2);
351 OI(O_ESCAPETIME, L("escapetime=1"));
352 OI(O_KEYTIME, L("keytime=6"));
353 OI(O_MATCHTIME, L("matchtime=7"));
354 (void)SPRINTF(b2, SIZE(b2), L("msgcat=%s"), _PATH_MSGCAT);
355 OI(O_MSGCAT, b2);
356 OI(O_REPORT, L("report=5"));
357 OI(O_PARAGRAPHS, L("paragraphs=IPLPPPQPP LIpplpipbp"));
358 (void)SPRINTF(b2, SIZE(b2), L("path=%s"), "");
359 OI(O_PATH, b2);
360 (void)SPRINTF(b2, SIZE(b2), L("recdir=%s"), _PATH_PRESERVE);
361 OI(O_RECDIR, b2);
362 OI(O_SECTIONS, L("sections=NHSHH HUnhsh"));
363 (void)SPRINTF(b2, SIZE(b2),
364 L("shell=%s"), (s = getenv("SHELL")) == NULL ? _PATH_BSHELL : s);
365 OI(O_SHELL, b2);
366 OI(O_SHELLMETA, L("shellmeta=~{[*?$`'\"\\"));
367 OI(O_SHIFTWIDTH, L("shiftwidth=8"));
368 OI(O_SIDESCROLL, L("sidescroll=16"));
369 OI(O_TABSTOP, L("tabstop=8"));
370 (void)SPRINTF(b2, SIZE(b2), L("tags=%s"), _PATH_TAGS);
371 OI(O_TAGS, b2);
372
373 /*
374 * XXX
375 * Initialize O_SCROLL here, after term; initializing term should
376 * have created a LINES/COLUMNS value.
377 */
378 if ((v = (O_VAL(sp, O_LINES) - 1) / 2) == 0)
379 v = 1;
380 (void)SPRINTF(b2, SIZE(b2), L("scroll=%ld"), v);
381 OI(O_SCROLL, b2);
382
383 /*
384 * The default window option values are:
385 * 8 if baud rate <= 600
386 * 16 if baud rate <= 1200
387 * LINES - 1 if baud rate > 1200
388 *
389 * Note, the windows option code will correct any too-large value
390 * or when the O_LINES value is 1.
391 */
392 if (sp->gp->scr_baud(sp, &v))
393 return (1);
394 if (v <= 600)
395 v = 8;
396 else if (v <= 1200)
397 v = 16;
398 else if ((v = O_VAL(sp, O_LINES) - 1) == 0)
399 v = 1;
400
401 (void)SPRINTF(b2, SIZE(b2), L("window=%lu"), v);
402 OI(O_WINDOW, b2);
403
404 /*
405 * Set boolean default values, and copy all settings into the default
406 * information. OS_NOFREE is set, we're copying, not replacing.
407 */
408 for (op = optlist, cnt = 0; op->name != NULL; ++op, ++cnt)
409 switch (op->type) {
410 case OPT_0BOOL:
411 break;
412 case OPT_1BOOL:
413 O_SET(sp, cnt);
414 O_D_SET(sp, cnt);
415 break;
416 case OPT_NUM:
417 o_set(sp, cnt, OS_DEF, NULL, O_VAL(sp, cnt));
418 break;
419 case OPT_STR:
420 if (O_STR(sp, cnt) != NULL && o_set(sp, cnt,
421 OS_DEF | OS_NOFREE | OS_STRDUP, O_STR(sp, cnt), 0))
422 goto err;
423 break;
424 default:
425 abort();
426 }
427
428 /*
429 * !!!
430 * Some options can be initialized by the command name or the
431 * command-line arguments. They don't set the default values,
432 * it's historic practice.
433 */
434 for (; *oargs != -1; ++oargs)
435 OI(*oargs, optlist[*oargs].name);
436 #undef OI
437
438 /*
439 * Inform the underlying screen of the initial values of the
440 * edit options.
441 */
442 for (op = optlist, cnt = 0; op->name != NULL; ++op, ++cnt) {
443 isset = O_ISSET(sp, cnt);
444 (void)sp->gp->scr_optchange(sp, cnt, O_STR(sp, cnt), &isset);
445 }
446 return (0);
447
448 err: msgq(sp, M_ERR,
449 "031|Unable to set default %s option", optlist[optindx].name);
450 return (1);
451 }
452
453 /*
454 * opts_set --
455 * Change the values of one or more options.
456 *
457 * PUBLIC: int opts_set __P((SCR *, ARGS *[], char *));
458 */
459 int
460 opts_set(SCR *sp, ARGS **argv, char *usage)
461 {
462 enum optdisp disp;
463 enum nresult nret;
464 OPTLIST const *op;
465 OPTION *spo;
466 u_long isset, turnoff, value;
467 int ch, equals, nf, nf2, offset, qmark, rval;
468 CHAR_T *endp, *name, *p, *sep, *t;
469 char *p2, *t2;
470 char *np;
471 size_t nlen;
472
473 disp = NO_DISPLAY;
474 for (rval = 0; argv[0]->len != 0; ++argv) {
475 /*
476 * The historic vi dumped the options for each occurrence of
477 * "all" in the set list. Puhleeze.
478 */
479 if (!STRCMP(argv[0]->bp, L("all"))) {
480 disp = ALL_DISPLAY;
481 continue;
482 }
483
484 /* Find equals sign or question mark. */
485 for (sep = NULL, equals = qmark = 0,
486 p = name = argv[0]->bp; (ch = *p) != '\0'; ++p)
487 if (ch == '=' || ch == '?') {
488 if (p == name) {
489 if (usage != NULL)
490 msgq(sp, M_ERR,
491 "032|Usage: %s", usage);
492 return (1);
493 }
494 sep = p;
495 if (ch == '=')
496 equals = 1;
497 else
498 qmark = 1;
499 break;
500 }
501
502 turnoff = 0;
503 op = NULL;
504 if (sep != NULL)
505 *sep++ = '\0';
506
507 /* Search for the name, then name without any leading "no". */
508 if ((op = opts_search(name)) == NULL &&
509 name[0] == L('n') && name[1] == L('o')) {
510 turnoff = 1;
511 name += 2;
512 op = opts_search(name);
513 }
514 if (op == NULL) {
515 opts_nomatch(sp, name);
516 rval = 1;
517 continue;
518 }
519
520 /* Find current option values. */
521 offset = op - optlist;
522 spo = sp->opts + offset;
523
524 /*
525 * !!!
526 * Historically, the question mark could be a separate
527 * argument.
528 */
529 if (!equals && !qmark &&
530 argv[1]->len == 1 && argv[1]->bp[0] == '?') {
531 ++argv;
532 qmark = 1;
533 }
534
535 /* Set name, value. */
536 switch (op->type) {
537 case OPT_0BOOL:
538 case OPT_1BOOL:
539 /* Some options may not be reset. */
540 if (F_ISSET(op, OPT_NOUNSET) && turnoff) {
541 msgq_wstr(sp, M_ERR, name,
542 "291|set: the %s option may not be turned off");
543 rval = 1;
544 break;
545 }
546
547 /* Some options may not be set. */
548 if (F_ISSET(op, OPT_NOSET) && !turnoff) {
549 msgq_wstr(sp, M_ERR, name,
550 "313|set: the %s option may never be turned on");
551 rval = 1;
552 break;
553 }
554
555 if (equals) {
556 msgq_wstr(sp, M_ERR, name,
557 "034|set: [no]%s option doesn't take a value");
558 rval = 1;
559 break;
560 }
561 if (qmark) {
562 if (!disp)
563 disp = SELECT_DISPLAY;
564 F_SET(spo, OPT_SELECTED);
565 break;
566 }
567
568 /*
569 * Do nothing if the value is unchanged, the underlying
570 * functions can be expensive.
571 */
572 isset = !turnoff;
573 if (!F_ISSET(op, OPT_ALWAYS))
574 if (isset) {
575 if (O_ISSET(sp, offset))
576 break;
577 } else
578 if (!O_ISSET(sp, offset))
579 break;
580
581 /* Report to subsystems. */
582 if (op->func != NULL &&
583 op->func(sp, spo, NULL, &isset) ||
584 ex_optchange(sp, offset, NULL, &isset) ||
585 v_optchange(sp, offset, NULL, &isset) ||
586 sp->gp->scr_optchange(sp, offset, NULL, &isset)) {
587 rval = 1;
588 break;
589 }
590
591 /* Set the value. */
592 if (isset)
593 O_SET(sp, offset);
594 else
595 O_CLR(sp, offset);
596 break;
597 case OPT_NUM:
598 if (turnoff) {
599 msgq_wstr(sp, M_ERR, name,
600 "035|set: %s option isn't a boolean");
601 rval = 1;
602 break;
603 }
604 if (qmark || !equals) {
605 if (!disp)
606 disp = SELECT_DISPLAY;
607 F_SET(spo, OPT_SELECTED);
608 break;
609 }
610
611 if (!ISDIGIT(sep[0]))
612 goto badnum;
613 if ((nret =
614 nget_uslong(sp, &value, sep, &endp, 10)) != NUM_OK) {
615 INT2CHAR(sp, name, STRLEN(name) + 1,
616 np, nlen);
617 p2 = msg_print(sp, np, &nf);
618 INT2CHAR(sp, sep, STRLEN(sep) + 1,
619 np, nlen);
620 t2 = msg_print(sp, np, &nf2);
621 switch (nret) {
622 case NUM_ERR:
623 msgq(sp, M_SYSERR,
624 "036|set: %s option: %s", p2, t2);
625 break;
626 case NUM_OVER:
627 msgq(sp, M_ERR,
628 "037|set: %s option: %s: value overflow", p2, t2);
629 break;
630 case NUM_OK:
631 case NUM_UNDER:
632 abort();
633 }
634 if (nf)
635 FREE_SPACE(sp, p2, 0);
636 if (nf2)
637 FREE_SPACE(sp, t2, 0);
638 rval = 1;
639 break;
640 }
641 if (*endp && !ISBLANK(*endp)) {
642 badnum: INT2CHAR(sp, name, STRLEN(name) + 1,
643 np, nlen);
644 p2 = msg_print(sp, np, &nf);
645 INT2CHAR(sp, sep, STRLEN(sep) + 1,
646 np, nlen);
647 t2 = msg_print(sp, np, &nf2);
648 msgq(sp, M_ERR,
649 "038|set: %s option: %s is an illegal number", p2, t2);
650 if (nf)
651 FREE_SPACE(sp, p2, 0);
652 if (nf2)
653 FREE_SPACE(sp, t2, 0);
654 rval = 1;
655 break;
656 }
657
658 /* Some options may never be set to zero. */
659 if (F_ISSET(op, OPT_NOZERO) && value == 0) {
660 msgq_wstr(sp, M_ERR, name,
661 "314|set: the %s option may never be set to 0");
662 rval = 1;
663 break;
664 }
665
666 /*
667 * Do nothing if the value is unchanged, the underlying
668 * functions can be expensive.
669 */
670 if (!F_ISSET(op, OPT_ALWAYS) &&
671 O_VAL(sp, offset) == value)
672 break;
673
674 /* Report to subsystems. */
675 INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen);
676 if (op->func != NULL &&
677 op->func(sp, spo, np, &value) ||
678 ex_optchange(sp, offset, np, &value) ||
679 v_optchange(sp, offset, np, &value) ||
680 sp->gp->scr_optchange(sp, offset, np, &value)) {
681 rval = 1;
682 break;
683 }
684
685 /* Set the value. */
686 if (o_set(sp, offset, 0, NULL, value))
687 rval = 1;
688 break;
689 case OPT_STR:
690 if (turnoff) {
691 msgq_wstr(sp, M_ERR, name,
692 "039|set: %s option isn't a boolean");
693 rval = 1;
694 break;
695 }
696 if (qmark || !equals) {
697 if (!disp)
698 disp = SELECT_DISPLAY;
699 F_SET(spo, OPT_SELECTED);
700 break;
701 }
702
703 /*
704 * Do nothing if the value is unchanged, the underlying
705 * functions can be expensive.
706 */
707 INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen);
708 if (!F_ISSET(op, OPT_ALWAYS) &&
709 O_STR(sp, offset) != NULL &&
710 !strcmp(O_STR(sp, offset), np))
711 break;
712
713 /* Report to subsystems. */
714 if (op->func != NULL &&
715 op->func(sp, spo, np, NULL) ||
716 ex_optchange(sp, offset, np, NULL) ||
717 v_optchange(sp, offset, np, NULL) ||
718 sp->gp->scr_optchange(sp, offset, np, NULL)) {
719 rval = 1;
720 break;
721 }
722
723 /* Set the value. */
724 if (o_set(sp, offset, OS_STRDUP, np, 0))
725 rval = 1;
726 break;
727 default:
728 abort();
729 }
730 }
731 if (disp != NO_DISPLAY)
732 opts_dump(sp, disp);
733 return (rval);
734 }
735
736 /*
737 * o_set --
738 * Set an option's value.
739 *
740 * PUBLIC: int o_set __P((SCR *, int, u_int, char *, u_long));
741 */
742 int
743 o_set(SCR *sp, int opt, u_int flags, char *str, u_long val)
744 {
745 OPTION *op;
746
747 /* Set a pointer to the options area. */
748 op = F_ISSET(&sp->opts[opt], OPT_GLOBAL) ?
749 &sp->gp->opts[sp->opts[opt].o_cur.val] : &sp->opts[opt];
750
751 /* Copy the string, if requested. */
752 if (LF_ISSET(OS_STRDUP) && (str = strdup(str)) == NULL) {
753 msgq(sp, M_SYSERR, NULL);
754 return (1);
755 }
756
757 /* Free the previous string, if requested, and set the value. */
758 if LF_ISSET(OS_DEF)
759 if (LF_ISSET(OS_STR | OS_STRDUP)) {
760 if (!LF_ISSET(OS_NOFREE) && op->o_def.str != NULL)
761 free(op->o_def.str);
762 op->o_def.str = str;
763 } else
764 op->o_def.val = val;
765 else
766 if (LF_ISSET(OS_STR | OS_STRDUP)) {
767 if (!LF_ISSET(OS_NOFREE) && op->o_cur.str != NULL)
768 free(op->o_cur.str);
769 op->o_cur.str = str;
770 } else
771 op->o_cur.val = val;
772 return (0);
773 }
774
775 /*
776 * opts_empty --
777 * Return 1 if the string option is invalid, 0 if it's OK.
778 *
779 * PUBLIC: int opts_empty __P((SCR *, int, int));
780 */
781 int
782 opts_empty(SCR *sp, int off, int silent)
783 {
784 char *p;
785
786 if ((p = O_STR(sp, off)) == NULL || p[0] == '\0') {
787 if (!silent)
788 msgq_wstr(sp, M_ERR, optlist[off].name,
789 "305|No %s edit option specified");
790 return (1);
791 }
792 return (0);
793 }
794
795 /*
796 * opts_dump --
797 * List the current values of selected options.
798 *
799 * PUBLIC: void opts_dump __P((SCR *, enum optdisp));
800 */
801 void
802 opts_dump(SCR *sp, enum optdisp type)
803 {
804 OPTLIST const *op;
805 int base, b_num, cnt, col, colwidth, curlen, s_num;
806 int numcols, numrows, row;
807 int b_op[O_OPTIONCOUNT], s_op[O_OPTIONCOUNT];
808 char nbuf[20];
809 CHAR_T *kp;
810
811 /*
812 * Options are output in two groups -- those that fit in a column and
813 * those that don't. Output is done on 6 character "tab" boundaries
814 * for no particular reason. (Since we don't output tab characters,
815 * we can ignore the terminal's tab settings.) Ignore the user's tab
816 * setting because we have no idea how reasonable it is.
817 *
818 * Find a column width we can live with, testing from 10 columns to 1.
819 */
820 for (numcols = 10; numcols > 1; --numcols) {
821 colwidth = sp->cols / numcols & ~(STANDARD_TAB - 1);
822 if (colwidth >= 10) {
823 colwidth =
824 (colwidth + STANDARD_TAB) & ~(STANDARD_TAB - 1);
825 numcols = sp->cols / colwidth;
826 break;
827 }
828 colwidth = 0;
829 }
830
831 /*
832 * Get the set of options to list, entering them into
833 * the column list or the overflow list.
834 */
835 for (b_num = s_num = 0, op = optlist; op->name != NULL; ++op) {
836 cnt = op - optlist;
837
838 /* If OPT_NDISP set, it's never displayed. */
839 if (F_ISSET(op, OPT_NDISP))
840 continue;
841
842 switch (type) {
843 case ALL_DISPLAY: /* Display all. */
844 break;
845 case CHANGED_DISPLAY: /* Display changed. */
846 /* If OPT_ADISP set, it's always "changed". */
847 if (F_ISSET(op, OPT_ADISP))
848 break;
849 switch (op->type) {
850 case OPT_0BOOL:
851 case OPT_1BOOL:
852 case OPT_NUM:
853 if (O_VAL(sp, cnt) == O_D_VAL(sp, cnt))
854 continue;
855 break;
856 case OPT_STR:
857 if (O_STR(sp, cnt) == O_D_STR(sp, cnt) ||
858 O_D_STR(sp, cnt) != NULL &&
859 !strcmp(O_STR(sp, cnt), O_D_STR(sp, cnt)))
860 continue;
861 break;
862 }
863 break;
864 case SELECT_DISPLAY: /* Display selected. */
865 if (!F_ISSET(&sp->opts[cnt], OPT_SELECTED))
866 continue;
867 break;
868 default:
869 case NO_DISPLAY:
870 abort();
871 }
872 F_CLR(&sp->opts[cnt], OPT_SELECTED);
873
874 curlen = STRLEN(op->name);
875 switch (op->type) {
876 case OPT_0BOOL:
877 case OPT_1BOOL:
878 if (!O_ISSET(sp, cnt))
879 curlen += 2;
880 break;
881 case OPT_NUM:
882 (void)snprintf(nbuf,
883 sizeof(nbuf), "%ld", O_VAL(sp, cnt));
884 curlen += strlen(nbuf);
885 break;
886 case OPT_STR:
887 if (O_STR(sp, cnt) != NULL)
888 curlen += strlen(O_STR(sp, cnt));
889 curlen += 3;
890 break;
891 }
892 /* Offset by 2 so there's a gap. */
893 if (curlen <= colwidth - 2)
894 s_op[s_num++] = cnt;
895 else
896 b_op[b_num++] = cnt;
897 }
898
899 if (s_num > 0) {
900 /* Figure out the number of rows. */
901 if (s_num > numcols) {
902 numrows = s_num / numcols;
903 if (s_num % numcols)
904 ++numrows;
905 } else
906 numrows = 1;
907
908 /* Display the options in sorted order. */
909 for (row = 0; row < numrows;) {
910 for (base = row, col = 0; col < numcols; ++col) {
911 cnt = opts_print(sp, &optlist[s_op[base]]);
912 if ((base += numrows) >= s_num)
913 break;
914 (void)ex_printf(sp, "%*s",
915 (int)(colwidth - cnt), "");
916 }
917 if (++row < numrows || b_num)
918 (void)ex_puts(sp, "\n");
919 }
920 }
921
922 for (row = 0; row < b_num;) {
923 (void)opts_print(sp, &optlist[b_op[row]]);
924 if (++row < b_num)
925 (void)ex_puts(sp, "\n");
926 }
927 (void)ex_puts(sp, "\n");
928 }
929
930 /*
931 * opts_print --
932 * Print out an option.
933 */
934 static int
935 opts_print(SCR *sp, const OPTLIST *op)
936 {
937 int curlen, offset;
938
939 curlen = 0;
940 offset = op - optlist;
941 switch (op->type) {
942 case OPT_0BOOL:
943 case OPT_1BOOL:
944 curlen += ex_printf(sp,
945 "%s"WS, O_ISSET(sp, offset) ? "" : "no", op->name);
946 break;
947 case OPT_NUM:
948 curlen += ex_printf(sp, WS"=%ld", op->name, O_VAL(sp, offset));
949 break;
950 case OPT_STR:
951 curlen += ex_printf(sp, WS"=\"%s\"", op->name,
952 O_STR(sp, offset) == NULL ? "" : O_STR(sp, offset));
953 break;
954 }
955 return (curlen);
956 }
957
958 /*
959 * opts_save --
960 * Write the current configuration to a file.
961 *
962 * PUBLIC: int opts_save __P((SCR *, FILE *));
963 */
964 int
965 opts_save(SCR *sp, FILE *fp)
966 {
967 OPTLIST const *op;
968 CHAR_T ch, *p;
969 char nch, *np;
970 int cnt;
971
972 for (op = optlist; op->name != NULL; ++op) {
973 if (F_ISSET(op, OPT_NOSAVE))
974 continue;
975 cnt = op - optlist;
976 switch (op->type) {
977 case OPT_0BOOL:
978 case OPT_1BOOL:
979 if (O_ISSET(sp, cnt))
980 (void)fprintf(fp, "set "WS"\n", op->name);
981 else
982 (void)fprintf(fp, "set no"WS"\n", op->name);
983 break;
984 case OPT_NUM:
985 (void)fprintf(fp,
986 "set "WS"=%-3ld\n", op->name, O_VAL(sp, cnt));
987 break;
988 case OPT_STR:
989 if (O_STR(sp, cnt) == NULL)
990 break;
991 (void)fprintf(fp, "set ");
992 for (p = op->name; (ch = *p) != L('\0'); ++p) {
993 if (ISBLANK(ch) || ch == L('\\'))
994 (void)putc('\\', fp);
995 fprintf(fp, WC, ch);
996 }
997 (void)putc('=', fp);
998 for (np = O_STR(sp, cnt); (nch = *np) != '\0'; ++np) {
999 if (isblank(nch) || nch == '\\')
1000 (void)putc('\\', fp);
1001 (void)putc(nch, fp);
1002 }
1003 (void)putc('\n', fp);
1004 break;
1005 }
1006 if (ferror(fp)) {
1007 msgq(sp, M_SYSERR, NULL);
1008 return (1);
1009 }
1010 }
1011 return (0);
1012 }
1013
1014 /*
1015 * opts_search --
1016 * Search for an option.
1017 *
1018 * PUBLIC: OPTLIST const *opts_search __P((CHAR_T *));
1019 */
1020 OPTLIST const *
1021 opts_search(CHAR_T *name)
1022 {
1023 OPTLIST const *op, *found;
1024 OABBREV atmp, *ap;
1025 OPTLIST otmp;
1026 size_t len;
1027
1028 /* Check list of abbreviations. */
1029 atmp.name = name;
1030 if ((ap = bsearch(&atmp, abbrev, sizeof(abbrev) / sizeof(OABBREV) - 1,
1031 sizeof(OABBREV), opts_abbcmp)) != NULL)
1032 return (optlist + ap->offset);
1033
1034 /* Check list of options. */
1035 otmp.name = name;
1036 if ((op = bsearch(&otmp, optlist, sizeof(optlist) / sizeof(OPTLIST) - 1,
1037 sizeof(OPTLIST), opts_cmp)) != NULL)
1038 return (op);
1039
1040 /*
1041 * Check to see if the name is the prefix of one (and only one)
1042 * option. If so, return the option.
1043 */
1044 len = STRLEN(name);
1045 for (found = NULL, op = optlist; op->name != NULL; ++op) {
1046 if (op->name[0] < name[0])
1047 continue;
1048 if (op->name[0] > name[0])
1049 break;
1050 if (!memcmp(op->name, name, len)) {
1051 if (found != NULL)
1052 return (NULL);
1053 found = op;
1054 }
1055 }
1056 return (found);
1057 }
1058
1059 /*
1060 * opts_nomatch --
1061 * Standard nomatch error message for options.
1062 *
1063 * PUBLIC: void opts_nomatch __P((SCR *, CHAR_T *));
1064 */
1065 void
1066 opts_nomatch(SCR *sp, CHAR_T *name)
1067 {
1068 msgq_wstr(sp, M_ERR, name,
1069 "033|set: no %s option: 'set all' gives all option values");
1070 }
1071
1072 static int
1073 opts_abbcmp(const void *a, const void *b)
1074 {
1075 return(STRCMP(((OABBREV *)a)->name, ((OABBREV *)b)->name));
1076 }
1077
1078 static int
1079 opts_cmp(const void *a, const void *b)
1080 {
1081 return(STRCMP(((OPTLIST *)a)->name, ((OPTLIST *)b)->name));
1082 }
1083
1084 /*
1085 * opts_copy --
1086 * Copy a screen's OPTION array.
1087 *
1088 * PUBLIC: int opts_copy __P((SCR *, SCR *));
1089 */
1090 int
1091 opts_copy(SCR *orig, SCR *sp)
1092 {
1093 int cnt, rval;
1094
1095 /* Copy most everything without change. */
1096 memcpy(sp->opts, orig->opts, sizeof(orig->opts));
1097
1098 /* Copy the string edit options. */
1099 for (cnt = rval = 0; cnt < O_OPTIONCOUNT; ++cnt) {
1100 if (optlist[cnt].type != OPT_STR ||
1101 F_ISSET(&optlist[cnt], OPT_GLOBAL))
1102 continue;
1103 /*
1104 * If never set, or already failed, NULL out the entries --
1105 * have to continue after failure, otherwise would have two
1106 * screens referencing the same memory.
1107 */
1108 if (rval || O_STR(sp, cnt) == NULL) {
1109 o_set(sp, cnt, OS_NOFREE | OS_STR, NULL, 0);
1110 o_set(sp, cnt, OS_DEF | OS_NOFREE | OS_STR, NULL, 0);
1111 continue;
1112 }
1113
1114 /* Copy the current string. */
1115 if (o_set(sp, cnt, OS_NOFREE | OS_STRDUP, O_STR(sp, cnt), 0)) {
1116 o_set(sp, cnt, OS_DEF | OS_NOFREE | OS_STR, NULL, 0);
1117 goto nomem;
1118 }
1119
1120 /* Copy the default string. */
1121 if (O_D_STR(sp, cnt) != NULL && o_set(sp, cnt,
1122 OS_DEF | OS_NOFREE | OS_STRDUP, O_D_STR(sp, cnt), 0)) {
1123 nomem: msgq(orig, M_SYSERR, NULL);
1124 rval = 1;
1125 }
1126 }
1127 return (rval);
1128 }
1129
1130 /*
1131 * opts_free --
1132 * Free all option strings
1133 *
1134 * PUBLIC: void opts_free __P((SCR *));
1135 */
1136 void
1137 opts_free(SCR *sp)
1138 {
1139 int cnt;
1140
1141 for (cnt = 0; cnt < O_OPTIONCOUNT; ++cnt) {
1142 if (optlist[cnt].type != OPT_STR ||
1143 F_ISSET(&optlist[cnt], OPT_GLOBAL))
1144 continue;
1145 if (O_STR(sp, cnt) != NULL)
1146 free(O_STR(sp, cnt));
1147 if (O_D_STR(sp, cnt) != NULL)
1148 free(O_D_STR(sp, cnt));
1149 }
1150 }
The Berkeley Vi Editor