common/options_f.c

   1 /*-
   2  * Copyright (c) 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 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_f.c,v 10.27 2000/07/06 18:47:57 skimo Exp $ (Berkeley) $Date: 2000/07/06 18:47:57 $";
  14 #endif /* not lint */
  15
  16 #include <sys/types.h>
  17 #include <sys/queue.h>
  18 #include <sys/stat.h>
  19
  20 #include <bitstring.h>
  21 #include <ctype.h>
  22 #include <errno.h>
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28
  29 #include "common.h"
  30
  31 /*
  32  * PUBLIC: int f_altwerase __P((SCR *, OPTION *, char *, u_long *));
  33  */
  34 int
  35 f_altwerase(sp, op, str, valp)
  36         SCR *sp;
  37         OPTION *op;
  38         char *str;
  39         u_long *valp;
  40 {
  41         if (*valp)
  42                 O_CLR(sp, O_TTYWERASE);
  43         return (0);
  44 }
  45
  46 /*
  47  * PUBLIC: int f_columns __P((SCR *, OPTION *, char *, u_long *));
  48  */
  49 int
  50 f_columns(sp, op, str, valp)
  51         SCR *sp;
  52         OPTION *op;
  53         char *str;
  54         u_long *valp;
  55 {
  56         /* Validate the number. */
  57         if (*valp < MINIMUM_SCREEN_COLS) {
  58                 msgq(sp, M_ERR, "040|Screen columns too small, less than %d",
  59                     MINIMUM_SCREEN_COLS);
  60                 return (1);
  61         }
  62
  63         /*
  64          * !!!
  65          * It's not uncommon for allocation of huge chunks of memory to cause
  66          * core dumps on various systems.  So, we prune out numbers that are
  67          * "obviously" wrong.  Vi will not work correctly if it has the wrong
  68          * number of lines/columns for the screen, but at least we don't drop
  69          * core.
  70          */
  71 #define MAXIMUM_SCREEN_COLS     500
  72         if (*valp > MAXIMUM_SCREEN_COLS) {
  73                 msgq(sp, M_ERR, "041|Screen columns too large, greater than %d",
  74                     MAXIMUM_SCREEN_COLS);
  75                 return (1);
  76         }
  77         return (0);
  78 }
  79
  80 /*
  81  * PUBLIC: int f_lines __P((SCR *, OPTION *, char *, u_long *));
  82  */
  83 int
  84 f_lines(sp, op, str, valp)
  85         SCR *sp;
  86         OPTION *op;
  87         char *str;
  88         u_long *valp;
  89 {
  90         /* Validate the number. */
  91         if (*valp < MINIMUM_SCREEN_ROWS) {
  92                 msgq(sp, M_ERR, "042|Screen lines too small, less than %d",
  93                     MINIMUM_SCREEN_ROWS);
  94                 return (1);
  95         }
  96
  97         /*
  98          * !!!
  99          * It's not uncommon for allocation of huge chunks of memory to cause
 100          * core dumps on various systems.  So, we prune out numbers that are
 101          * "obviously" wrong.  Vi will not work correctly if it has the wrong
 102          * number of lines/columns for the screen, but at least we don't drop
 103          * core.
 104          */
 105 #define MAXIMUM_SCREEN_ROWS     500
 106         if (*valp > MAXIMUM_SCREEN_ROWS) {
 107                 msgq(sp, M_ERR, "043|Screen lines too large, greater than %d",
 108                     MAXIMUM_SCREEN_ROWS);
 109                 return (1);
 110         }
 111
 112         /*
 113          * Set the value, and the related scroll value.  If no window
 114          * value set, set a new default window.
 115          */
 116         o_set(sp, O_LINES, 0, NULL, *valp);
 117         if (*valp == 1) {
 118                 sp->defscroll = 1;
 119
 120                 if (O_VAL(sp, O_WINDOW) == O_D_VAL(sp, O_WINDOW) ||
 121                     O_VAL(sp, O_WINDOW) > *valp) {
 122                         o_set(sp, O_WINDOW, 0, NULL, 1);
 123                         o_set(sp, O_WINDOW, OS_DEF, NULL, 1);
 124                 }
 125         } else {
 126                 sp->defscroll = (*valp - 1) / 2;
 127
 128                 if (O_VAL(sp, O_WINDOW) == O_D_VAL(sp, O_WINDOW) ||
 129                     O_VAL(sp, O_WINDOW) > *valp) {
 130                         o_set(sp, O_WINDOW, 0, NULL, *valp - 1);
 131                         o_set(sp, O_WINDOW, OS_DEF, NULL, *valp - 1);
 132                 }
 133         }
 134         return (0);
 135 }
 136
 137 /*
 138  * PUBLIC: int f_lisp __P((SCR *, OPTION *, char *, u_long *));
 139  */
 140 int
 141 f_lisp(sp, op, str, valp)
 142         SCR *sp;
 143         OPTION *op;
 144         char *str;
 145         u_long *valp;
 146 {
 147         msgq(sp, M_ERR, "044|The lisp option is not implemented");
 148         return (0);
 149 }
 150
 151 /*
 152  * PUBLIC: int f_msgcat __P((SCR *, OPTION *, char *, u_long *));
 153  */
 154 int
 155 f_msgcat(sp, op, str, valp)
 156         SCR *sp;
 157         OPTION *op;
 158         char *str;
 159         u_long *valp;
 160 {
 161         (void)msg_open(sp, str);
 162         return (0);
 163 }
 164
 165 /*
 166  * PUBLIC: int f_paragraph __P((SCR *, OPTION *, char *, u_long *));
 167  */
 168 int
 169 f_paragraph(sp, op, str, valp)
 170         SCR *sp;
 171         OPTION *op;
 172         char *str;
 173         u_long *valp;
 174 {
 175         if (strlen(str) & 1) {
 176                 msgq(sp, M_ERR,
 177                     "048|The paragraph option must be in two character groups");
 178                 return (1);
 179         }
 180         return (0);
 181 }
 182
 183 /*
 184  * PUBLIC: int f_print __P((SCR *, OPTION *, char *, u_long *));
 185  */
 186 int
 187 f_print(sp, op, str, valp)
 188         SCR *sp;
 189         OPTION *op;
 190         char *str;
 191         u_long *valp;
 192 {
 193         /* Preset the value, needed for reinitialization of lookup table. */
 194         if (o_set(sp, op-sp->opts, OS_STRDUP, str, 0))
 195                 return(1);
 196
 197         /* Reinitialize the key fast lookup table. */
 198         v_key_ilookup(sp);
 199
 200         /* Reformat the screen. */
 201         F_SET(sp, SC_SCR_REFORMAT);
 202         return (0);
 203 }
 204
 205 /*
 206  * PUBLIC: int f_readonly __P((SCR *, OPTION *, char *, u_long *));
 207  */
 208 int
 209 f_readonly(sp, op, str, valp)
 210         SCR *sp;
 211         OPTION *op;
 212         char *str;
 213         u_long *valp;
 214 {
 215         /*
 216          * !!!
 217          * See the comment in exf.c.
 218          */
 219         if (*valp)
 220                 F_SET(sp, SC_READONLY);
 221         else
 222                 F_CLR(sp, SC_READONLY);
 223         return (0);
 224 }
 225
 226 /*
 227  * PUBLIC: int f_recompile __P((SCR *, OPTION *, char *, u_long *));
 228  */
 229 int
 230 f_recompile(sp, op, str, valp)
 231         SCR *sp;
 232         OPTION *op;
 233         char *str;
 234         u_long *valp;
 235 {
 236         if (F_ISSET(sp, SC_RE_SEARCH)) {
 237                 regfree(&sp->re_c);
 238                 F_CLR(sp, SC_RE_SEARCH);
 239         }
 240         if (F_ISSET(sp, SC_RE_SUBST)) {
 241                 regfree(&sp->subre_c);
 242                 F_CLR(sp, SC_RE_SUBST);
 243         }
 244         return (0);
 245 }
 246
 247 /*
 248  * PUBLIC: int f_reformat __P((SCR *, OPTION *, char *, u_long *));
 249  */
 250 int
 251 f_reformat(sp, op, str, valp)
 252         SCR *sp;
 253         OPTION *op;
 254         char *str;
 255         u_long *valp;
 256 {
 257         F_SET(sp, SC_SCR_REFORMAT);
 258         return (0);
 259 }
 260
 261 /*
 262  * PUBLIC: int f_section __P((SCR *, OPTION *, char *, u_long *));
 263  */
 264 int
 265 f_section(sp, op, str, valp)
 266         SCR *sp;
 267         OPTION *op;
 268         char *str;
 269         u_long *valp;
 270 {
 271         if (strlen(str) & 1) {
 272                 msgq(sp, M_ERR,
 273                     "049|The section option must be in two character groups");
 274                 return (1);
 275         }
 276         return (0);
 277 }
 278
 279 /*
 280  * PUBLIC: int f_ttywerase __P((SCR *, OPTION *, char *, u_long *));
 281  */
 282 int
 283 f_ttywerase(sp, op, str, valp)
 284         SCR *sp;
 285         OPTION *op;
 286         char *str;
 287         u_long *valp;
 288 {
 289         if (*valp)
 290                 O_CLR(sp, O_ALTWERASE);
 291         return (0);
 292 }
 293
 294 /*
 295  * PUBLIC: int f_w300 __P((SCR *, OPTION *, char *, u_long *));
 296  */
 297 int
 298 f_w300(sp, op, str, valp)
 299         SCR *sp;
 300         OPTION *op;
 301         char *str;
 302         u_long *valp;
 303 {
 304         u_long v;
 305
 306         /* Historical behavior for w300 was < 1200. */
 307         if (sp->gp->scr_baud(sp, &v))
 308                 return (1);
 309         if (v >= 1200)
 310                 return (0);
 311
 312         return (f_window(sp, op, str, valp));
 313 }
 314
 315 /*
 316  * PUBLIC: int f_w1200 __P((SCR *, OPTION *, char *, u_long *));
 317  */
 318 int
 319 f_w1200(sp, op, str, valp)
 320         SCR *sp;
 321         OPTION *op;
 322         char *str;
 323         u_long *valp;
 324 {
 325         u_long v;
 326
 327         /* Historical behavior for w1200 was == 1200. */
 328         if (sp->gp->scr_baud(sp, &v))
 329                 return (1);
 330         if (v < 1200 || v > 4800)
 331                 return (0);
 332
 333         return (f_window(sp, op, str, valp));
 334 }
 335
 336 /*
 337  * PUBLIC: int f_w9600 __P((SCR *, OPTION *, char *, u_long *));
 338  */
 339 int
 340 f_w9600(sp, op, str, valp)
 341         SCR *sp;
 342         OPTION *op;
 343         char *str;
 344         u_long *valp;
 345 {
 346         u_long v;
 347
 348         /* Historical behavior for w9600 was > 1200. */
 349         if (sp->gp->scr_baud(sp, &v))
 350                 return (1);
 351         if (v <= 4800)
 352                 return (0);
 353
 354         return (f_window(sp, op, str, valp));
 355 }
 356
 357 /*
 358  * PUBLIC: int f_window __P((SCR *, OPTION *, char *, u_long *));
 359  */
 360 int
 361 f_window(sp, op, str, valp)
 362         SCR *sp;
 363         OPTION *op;
 364         char *str;
 365         u_long *valp;
 366 {
 367         if (*valp >= O_VAL(sp, O_LINES) - 1 &&
 368             (*valp = O_VAL(sp, O_LINES) - 1) == 0)
 369                 *valp = 1;
 370         return (0);
 371 }