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.31 2000/10/31 12:41:14 skimo Exp $ (Berkeley) $Date: 2000/10/31 12:41:14 $";
  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         int offset = op - sp->opts;
 194
 195         /* Preset the value, needed for reinitialization of lookup table. */
 196         if (offset == O_OCTAL) {
 197                 if (*valp)
 198                         O_SET(sp, offset);
 199                 else
 200                         O_CLR(sp, offset);
 201         } else if (o_set(sp, offset, OS_STRDUP, str, 0))
 202                 return(1);
 203
 204         /* Reinitialize the key fast lookup table. */
 205         v_key_ilookup(sp);
 206
 207         /* Reformat the screen. */
 208         F_SET(sp, SC_SCR_REFORMAT);
 209         return (0);
 210 }
 211
 212 /*
 213  * PUBLIC: int f_readonly __P((SCR *, OPTION *, char *, u_long *));
 214  */
 215 int
 216 f_readonly(sp, op, str, valp)
 217         SCR *sp;
 218         OPTION *op;
 219         char *str;
 220         u_long *valp;
 221 {
 222         /*
 223          * !!!
 224          * See the comment in exf.c.
 225          */
 226         if (*valp)
 227                 F_SET(sp, SC_READONLY);
 228         else
 229                 F_CLR(sp, SC_READONLY);
 230         return (0);
 231 }
 232
 233 /*
 234  * PUBLIC: int f_recompile __P((SCR *, OPTION *, char *, u_long *));
 235  */
 236 int
 237 f_recompile(sp, op, str, valp)
 238         SCR *sp;
 239         OPTION *op;
 240         char *str;
 241         u_long *valp;
 242 {
 243         if (F_ISSET(sp, SC_RE_SEARCH)) {
 244                 regfree(&sp->re_c);
 245                 F_CLR(sp, SC_RE_SEARCH);
 246         }
 247         if (F_ISSET(sp, SC_RE_SUBST)) {
 248                 regfree(&sp->subre_c);
 249                 F_CLR(sp, SC_RE_SUBST);
 250         }
 251         return (0);
 252 }
 253
 254 /*
 255  * PUBLIC: int f_reformat __P((SCR *, OPTION *, char *, u_long *));
 256  */
 257 int
 258 f_reformat(sp, op, str, valp)
 259         SCR *sp;
 260         OPTION *op;
 261         char *str;
 262         u_long *valp;
 263 {
 264         F_SET(sp, SC_SCR_REFORMAT);
 265         return (0);
 266 }
 267
 268 /*
 269  * PUBLIC: int f_section __P((SCR *, OPTION *, char *, u_long *));
 270  */
 271 int
 272 f_section(sp, op, str, valp)
 273         SCR *sp;
 274         OPTION *op;
 275         char *str;
 276         u_long *valp;
 277 {
 278         if (strlen(str) & 1) {
 279                 msgq(sp, M_ERR,
 280                     "049|The section option must be in two character groups");
 281                 return (1);
 282         }
 283         return (0);
 284 }
 285
 286 /*
 287  * PUBLIC: int f_ttywerase __P((SCR *, OPTION *, char *, u_long *));
 288  */
 289 int
 290 f_ttywerase(sp, op, str, valp)
 291         SCR *sp;
 292         OPTION *op;
 293         char *str;
 294         u_long *valp;
 295 {
 296         if (*valp)
 297                 O_CLR(sp, O_ALTWERASE);
 298         return (0);
 299 }
 300
 301 /*
 302  * PUBLIC: int f_w300 __P((SCR *, OPTION *, char *, u_long *));
 303  */
 304 int
 305 f_w300(sp, op, str, valp)
 306         SCR *sp;
 307         OPTION *op;
 308         char *str;
 309         u_long *valp;
 310 {
 311         u_long v;
 312
 313         /* Historical behavior for w300 was < 1200. */
 314         if (sp->gp->scr_baud(sp, &v))
 315                 return (1);
 316         if (v >= 1200)
 317                 return (0);
 318
 319         return (f_window(sp, op, str, valp));
 320 }
 321
 322 /*
 323  * PUBLIC: int f_w1200 __P((SCR *, OPTION *, char *, u_long *));
 324  */
 325 int
 326 f_w1200(sp, op, str, valp)
 327         SCR *sp;
 328         OPTION *op;
 329         char *str;
 330         u_long *valp;
 331 {
 332         u_long v;
 333
 334         /* Historical behavior for w1200 was == 1200. */
 335         if (sp->gp->scr_baud(sp, &v))
 336                 return (1);
 337         if (v < 1200 || v > 4800)
 338                 return (0);
 339
 340         return (f_window(sp, op, str, valp));
 341 }
 342
 343 /*
 344  * PUBLIC: int f_w9600 __P((SCR *, OPTION *, char *, u_long *));
 345  */
 346 int
 347 f_w9600(sp, op, str, valp)
 348         SCR *sp;
 349         OPTION *op;
 350         char *str;
 351         u_long *valp;
 352 {
 353         u_long v;
 354
 355         /* Historical behavior for w9600 was > 1200. */
 356         if (sp->gp->scr_baud(sp, &v))
 357                 return (1);
 358         if (v <= 4800)
 359                 return (0);
 360
 361         return (f_window(sp, op, str, valp));
 362 }
 363
 364 /*
 365  * PUBLIC: int f_window __P((SCR *, OPTION *, char *, u_long *));
 366  */
 367 int
 368 f_window(sp, op, str, valp)
 369         SCR *sp;
 370         OPTION *op;
 371         char *str;
 372         u_long *valp;
 373 {
 374         if (*valp >= O_VAL(sp, O_LINES) - 1 &&
 375             (*valp = O_VAL(sp, O_LINES) - 1) == 0)
 376                 *valp = 1;
 377         return (0);
 378 }
 379
 380 /*
 381  * PUBLIC: int f_fileencoding __P((SCR *, OPTION *, char *, u_long *));
 382  */
 383 int
 384 f_fileencoding(sp, op, str, valp)
 385         SCR *sp;
 386         OPTION *op;
 387         char *str;
 388         u_long *valp;
 389 {
 390         return conv_enc(sp, str);
 391 }