dist/nvi/common/options_f.c

   1 /*      $NetBSD: options_f.c,v 1.2 2008/10/01 21:20:09 christos Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  * Copyright (c) 1993, 1994, 1995, 1996
   7  *      Keith Bostic.  All rights reserved.
   8  *
   9  * See the LICENSE file for redistribution information.
  10  */
  11
  12 #include "config.h"
  13
  14 #ifndef lint
  15 static const char sccsid[] = "Id: options_f.c,v 10.33 2001/06/25 15:19:11 skimo Exp (Berkeley) Date: 2001/06/25 15:19:11";
  16 #endif /* not lint */
  17
  18 #include <sys/types.h>
  19 #include <sys/queue.h>
  20 #include <sys/stat.h>
  21
  22 #include <bitstring.h>
  23 #include <ctype.h>
  24 #include <errno.h>
  25 #include <limits.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30
  31 #include "common.h"
  32
  33 /*
  34  * PUBLIC: int f_altwerase __P((SCR *, OPTION *, const char *, u_long *));
  35  */
  36 int
  37 f_altwerase(SCR *sp, OPTION *op, const char *str, u_long *valp)
  38 {
  39         if (*valp)
  40                 O_CLR(sp, O_TTYWERASE);
  41         return (0);
  42 }
  43
  44 /*
  45  * PUBLIC: int f_columns __P((SCR *, OPTION *, const char *, u_long *));
  46  */
  47 int
  48 f_columns(SCR *sp, OPTION *op, const char *str, u_long *valp)
  49 {
  50         /* Validate the number. */
  51         if (*valp < MINIMUM_SCREEN_COLS) {
  52                 msgq(sp, M_ERR, "040|Screen columns too small, less than %d",
  53                     MINIMUM_SCREEN_COLS);
  54                 return (1);
  55         }
  56
  57         /*
  58          * !!!
  59          * It's not uncommon for allocation of huge chunks of memory to cause
  60          * core dumps on various systems.  So, we prune out numbers that are
  61          * "obviously" wrong.  Vi will not work correctly if it has the wrong
  62          * number of lines/columns for the screen, but at least we don't drop
  63          * core.
  64          */
  65 #define MAXIMUM_SCREEN_COLS     4000
  66         if (*valp > MAXIMUM_SCREEN_COLS) {
  67                 msgq(sp, M_ERR, "041|Screen columns too large, greater than %d",
  68                     MAXIMUM_SCREEN_COLS);
  69                 return (1);
  70         }
  71         return (0);
  72 }
  73
  74 /*
  75  * PUBLIC: int f_lines __P((SCR *, OPTION *, const char *, u_long *));
  76  */
  77 int
  78 f_lines(SCR *sp, OPTION *op, const char *str, u_long *valp)
  79 {
  80         /* Validate the number. */
  81         if (*valp < MINIMUM_SCREEN_ROWS) {
  82                 msgq(sp, M_ERR, "042|Screen lines too small, less than %d",
  83                     MINIMUM_SCREEN_ROWS);
  84                 return (1);
  85         }
  86
  87         /*
  88          * !!!
  89          * It's not uncommon for allocation of huge chunks of memory to cause
  90          * core dumps on various systems.  So, we prune out numbers that are
  91          * "obviously" wrong.  Vi will not work correctly if it has the wrong
  92          * number of lines/columns for the screen, but at least we don't drop
  93          * core.
  94          */
  95 #define MAXIMUM_SCREEN_ROWS     4000
  96         if (*valp > MAXIMUM_SCREEN_ROWS) {
  97                 msgq(sp, M_ERR, "043|Screen lines too large, greater than %d",
  98                     MAXIMUM_SCREEN_ROWS);
  99                 return (1);
 100         }
 101
 102         /*
 103          * Set the value, and the related scroll value.  If no window
 104          * value set, set a new default window.
 105          */
 106         o_set(sp, O_LINES, 0, NULL, *valp);
 107         if (*valp == 1) {
 108                 sp->defscroll = 1;
 109
 110                 if (O_VAL(sp, O_WINDOW) == O_D_VAL(sp, O_WINDOW) ||
 111                     O_VAL(sp, O_WINDOW) > *valp) {
 112                         o_set(sp, O_WINDOW, 0, NULL, 1);
 113                         o_set(sp, O_WINDOW, OS_DEF, NULL, 1);
 114                 }
 115         } else {
 116                 sp->defscroll = (*valp - 1) / 2;
 117
 118                 if (O_VAL(sp, O_WINDOW) == O_D_VAL(sp, O_WINDOW) ||
 119                     O_VAL(sp, O_WINDOW) > *valp) {
 120                         o_set(sp, O_WINDOW, 0, NULL, *valp - 1);
 121                         o_set(sp, O_WINDOW, OS_DEF, NULL, *valp - 1);
 122                 }
 123         }
 124         return (0);
 125 }
 126
 127 /*
 128  * PUBLIC: int f_lisp __P((SCR *, OPTION *, const char *, u_long *));
 129  */
 130 int
 131 f_lisp(SCR *sp, OPTION *op, const char *str, u_long *valp)
 132 {
 133         msgq(sp, M_ERR, "044|The lisp option is not implemented");
 134         return (0);
 135 }
 136
 137 /*
 138  * PUBLIC: int f_msgcat __P((SCR *, OPTION *, const char *, u_long *));
 139  */
 140 int
 141 f_msgcat(SCR *sp, OPTION *op, const char *str, u_long *valp)
 142 {
 143         (void)msg_open(sp, str);
 144         return (0);
 145 }
 146
 147 /*
 148  * PUBLIC: int f_print __P((SCR *, OPTION *, const char *, u_long *));
 149  */
 150 int
 151 f_print(SCR *sp, OPTION *op, const char *str, u_long *valp)
 152 {
 153         int offset = op - sp->opts;
 154
 155         /* Preset the value, needed for reinitialization of lookup table. */
 156         if (offset == O_OCTAL) {
 157                 if (*valp)
 158                         O_SET(sp, offset);
 159                 else
 160                         O_CLR(sp, offset);
 161         } else if (o_set(sp, offset, OS_STRDUP, str, 0))
 162                 return(1);
 163
 164         /* Reinitialize the key fast lookup table. */
 165         v_key_ilookup(sp);
 166
 167         /* Reformat the screen. */
 168         F_SET(sp, SC_SCR_REFORMAT);
 169         return (0);
 170 }
 171
 172 /*
 173  * PUBLIC: int f_readonly __P((SCR *, OPTION *, const char *, u_long *));
 174  */
 175 int
 176 f_readonly(SCR *sp, OPTION *op, const char *str, u_long *valp)
 177 {
 178         /*
 179          * !!!
 180          * See the comment in exf.c.
 181          */
 182         if (*valp)
 183                 F_SET(sp, SC_READONLY);
 184         else
 185                 F_CLR(sp, SC_READONLY);
 186         return (0);
 187 }
 188
 189 /*
 190  * PUBLIC: int f_recompile __P((SCR *, OPTION *, const char *, u_long *));
 191  */
 192 int
 193 f_recompile(SCR *sp, OPTION *op, const char *str, u_long *valp)
 194 {
 195         if (F_ISSET(sp, SC_RE_SEARCH)) {
 196                 regfree(&sp->re_c);
 197                 F_CLR(sp, SC_RE_SEARCH);
 198         }
 199         if (F_ISSET(sp, SC_RE_SUBST)) {
 200                 regfree(&sp->subre_c);
 201                 F_CLR(sp, SC_RE_SUBST);
 202         }
 203         return (0);
 204 }
 205
 206 /*
 207  * PUBLIC: int f_reformat __P((SCR *, OPTION *, const char *, u_long *));
 208  */
 209 int
 210 f_reformat(SCR *sp, OPTION *op, const char *str, u_long *valp)
 211 {
 212         F_SET(sp, SC_SCR_REFORMAT);
 213         return (0);
 214 }
 215
 216 /*
 217  * PUBLIC: int f_ttywerase __P((SCR *, OPTION *, const char *, u_long *));
 218  */
 219 int
 220 f_ttywerase(SCR *sp, OPTION *op, const char *str, u_long *valp)
 221 {
 222         if (*valp)
 223                 O_CLR(sp, O_ALTWERASE);
 224         return (0);
 225 }
 226
 227 /*
 228  * PUBLIC: int f_w300 __P((SCR *, OPTION *, const char *, u_long *));
 229  */
 230 int
 231 f_w300(SCR *sp, OPTION *op, const char *str, u_long *valp)
 232 {
 233         u_long v;
 234
 235         /* Historical behavior for w300 was < 1200. */
 236         if (sp->gp->scr_baud(sp, &v))
 237                 return (1);
 238         if (v >= 1200)
 239                 return (0);
 240
 241         return (f_window(sp, op, str, valp));
 242 }
 243
 244 /*
 245  * PUBLIC: int f_w1200 __P((SCR *, OPTION *, const char *, u_long *));
 246  */
 247 int
 248 f_w1200(SCR *sp, OPTION *op, const char *str, u_long *valp)
 249 {
 250         u_long v;
 251
 252         /* Historical behavior for w1200 was == 1200. */
 253         if (sp->gp->scr_baud(sp, &v))
 254                 return (1);
 255         if (v < 1200 || v > 4800)
 256                 return (0);
 257
 258         return (f_window(sp, op, str, valp));
 259 }
 260
 261 /*
 262  * PUBLIC: int f_w9600 __P((SCR *, OPTION *, const char *, u_long *));
 263  */
 264 int
 265 f_w9600(SCR *sp, OPTION *op, const char *str, u_long *valp)
 266 {
 267         u_long v;
 268
 269         /* Historical behavior for w9600 was > 1200. */
 270         if (sp->gp->scr_baud(sp, &v))
 271                 return (1);
 272         if (v <= 4800)
 273                 return (0);
 274
 275         return (f_window(sp, op, str, valp));
 276 }
 277
 278 /*
 279  * PUBLIC: int f_window __P((SCR *, OPTION *, const char *, u_long *));
 280  */
 281 int
 282 f_window(SCR *sp, OPTION *op, const char *str, u_long *valp)
 283 {
 284         if (*valp >= O_VAL(sp, O_LINES) - 1 &&
 285             (*valp = O_VAL(sp, O_LINES) - 1) == 0)
 286                 *valp = 1;
 287         return (0);
 288 }
 289
 290 /*
 291  * PUBLIC: int f_encoding __P((SCR *, OPTION *, const char *, u_long *));
 292  */
 293 int
 294 f_encoding(SCR *sp, OPTION *op, const char *str, u_long *valp)
 295 {
 296         int offset = op - sp->opts;
 297
 298         return conv_enc(sp, offset, str);
 299 }