dist/nvi/cl/cl_main.c

   1 /*      $NetBSD: cl_main.c,v 1.2 2008/12/05 22:51:42 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: cl_main.c,v 10.54 2001/07/29 19:07:27 skimo Exp (Berkeley) Date: 2001/07/29 19:07:27";
  16 #endif /* not lint */
  17
  18 #include <sys/types.h>
  19 #include <sys/queue.h>
  20
  21 #include <bitstring.h>
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <signal.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <termios.h>
  29 #include <unistd.h>
  30
  31 #include "../common/common.h"
  32 #include "../ip/extern.h"
  33 #include "cl.h"
  34 #include "pathnames.h"
  35
  36 GS *__global_list;                              /* GLOBAL: List of screens. */
  37 sigset_t __sigblockset;                         /* GLOBAL: Blocked signals. */
  38
  39 static void        cl_func_std __P((WIN *));
  40 #ifdef notused
  41 static void        cl_end __P((CL_PRIVATE *));
  42 #endif
  43 static CL_PRIVATE *cl_init __P((WIN *));
  44 static void        perr __P((const char *, const char *));
  45 static int         setsig __P((int, struct sigaction *, void (*)(int)));
  46 static void        sig_end __P((GS *));
  47 static void        term_init __P((const char *, const char *));
  48
  49 /*
  50  * main --
  51  *      This is the main loop for the standalone curses editor.
  52  */
  53 int
  54 main(int argc, char **argv)
  55 {
  56         static int reenter;
  57         CL_PRIVATE *clp;
  58         GS *gp;
  59         WIN *wp;
  60         size_t rows, cols;
  61         int rval;
  62         char **p_av, **t_av;
  63         const char *ttype;
  64
  65         /* If loaded at 0 and jumping through a NULL pointer, stop. */
  66         if (reenter++)
  67                 abort();
  68
  69         /* Create and initialize the global structure. */
  70         __global_list = gp = gs_init(argv[0]);
  71
  72         /*
  73          * Strip out any arguments that vi isn't going to understand.  There's
  74          * no way to portably call getopt twice, so arguments parsed here must
  75          * be removed from the argument list.
  76          */
  77         for (p_av = t_av = argv;;) {
  78                 if (*t_av == NULL) {
  79                         *p_av = NULL;
  80                         break;
  81                 }
  82                 if (!strcmp(*t_av, "--")) {
  83                         while ((*p_av++ = *t_av++) != NULL);
  84                         break;
  85                 }
  86                 *p_av++ = *t_av++;
  87         }
  88
  89         /* Create new window */
  90         wp = gs_new_win(gp);
  91
  92         /* Create and initialize the CL_PRIVATE structure. */
  93         clp = cl_init(wp);
  94
  95         /*
  96          * Initialize the terminal information.
  97          *
  98          * We have to know what terminal it is from the start, since we may
  99          * have to use termcap/terminfo to find out how big the screen is.
 100          */
 101         if ((ttype = getenv("TERM")) == NULL) {
 102                 if (isatty(STDIN_FILENO))
 103                         fprintf(stderr, "%s: warning: TERM is not set\n",
 104                             gp->progname);
 105                 ttype = "unknown";
 106         }
 107         term_init(gp->progname, ttype);
 108
 109         /* Add the terminal type to the global structure. */
 110         if ((OG_D_STR(gp, GO_TERM) =
 111             OG_STR(gp, GO_TERM) = strdup(ttype)) == NULL)
 112                 perr(gp->progname, NULL);
 113
 114         /* Figure out how big the screen is. */
 115         if (cl_ssize(NULL, 0, &rows, &cols, NULL))
 116                 exit (1);
 117
 118         /* Add the rows and columns to the global structure. */
 119         OG_VAL(gp, GO_LINES) = OG_D_VAL(gp, GO_LINES) = rows;
 120         OG_VAL(gp, GO_COLUMNS) = OG_D_VAL(gp, GO_COLUMNS) = cols;
 121
 122         /* Ex wants stdout to be buffered. */
 123         (void)setvbuf(stdout, NULL, _IOFBF, 0);
 124
 125         /* Start catching signals. */
 126         if (sig_init(gp, NULL))
 127                 exit (1);
 128
 129         /* Run ex/vi. */
 130         rval = editor(wp, argc, argv);
 131
 132         /* Clean out the global structure. */
 133         gs_end(gp);
 134
 135         /* Clean up signals. */
 136         sig_end(gp);
 137
 138         /* Clean up the terminal. */
 139         (void)cl_quit(gp);
 140
 141         /*
 142          * XXX
 143          * Reset the O_MESG option.
 144          */
 145         if (clp->tgw != TGW_UNKNOWN)
 146                 (void)cl_omesg(NULL, clp, clp->tgw == TGW_SET);
 147
 148         /*
 149          * XXX
 150          * Reset the X11 xterm icon/window name.
 151          */
 152         if (F_ISSET(clp, CL_RENAME))
 153                 cl_setname(gp, clp->oname);
 154
 155         /* If a killer signal arrived, pretend we just got it. */
 156         if (clp->killersig) {
 157                 (void)signal(clp->killersig, SIG_DFL);
 158                 (void)kill(getpid(), clp->killersig);
 159                 /* NOTREACHED */
 160         }
 161
 162         /* Free the global and CL private areas. */
 163 #if defined(DEBUG) || defined(PURIFY) || defined(LIBRARY)
 164         cl_end(clp);
 165         free(gp);
 166 #endif
 167
 168         exit (rval);
 169 }
 170
 171 /*
 172  * cl_init --
 173  *      Create and partially initialize the CL structure.
 174  */
 175 static CL_PRIVATE *
 176 cl_init(WIN *wp)
 177 {
 178         CL_PRIVATE *clp;
 179         int fd;
 180         GS *gp;
 181
 182         gp = wp->gp;
 183
 184         /* Allocate the CL private structure. */
 185         CALLOC_NOMSG(NULL, clp, CL_PRIVATE *, 1, sizeof(CL_PRIVATE));
 186         if (clp == NULL)
 187                 perr(gp->progname, NULL);
 188         gp->cl_private = clp;
 189
 190         /*
 191          * Set the CL_STDIN_TTY flag.  It's purpose is to avoid setting
 192          * and resetting the tty if the input isn't from there.  We also
 193          * use the same test to determine if we're running a script or
 194          * not.
 195          */
 196         if (isatty(STDIN_FILENO))
 197                 F_SET(clp, CL_STDIN_TTY);
 198         else
 199                 F_SET(gp, G_SCRIPTED);
 200
 201         /*
 202          * We expect that if we've lost our controlling terminal that the
 203          * open() (but not the tcgetattr()) will fail.
 204          */
 205         if (F_ISSET(clp, CL_STDIN_TTY)) {
 206                 if (tcgetattr(STDIN_FILENO, &clp->orig) == -1)
 207                         goto tcfail;
 208         } else if ((fd = open(_PATH_TTY, O_RDONLY, 0)) != -1) {
 209                 if (tcgetattr(fd, &clp->orig) == -1) {
 210 tcfail:                 perr(gp->progname, "tcgetattr");
 211                         exit (1);
 212                 }
 213                 (void)close(fd);
 214         }
 215
 216         /* Initialize the list of curses functions. */
 217         cl_func_std(wp);
 218
 219         return (clp);
 220 }
 221
 222 #ifdef notused
 223 /*
 224  * cl_end --
 225  *      Discard the CL structure.
 226  */
 227 static void
 228 cl_end(CL_PRIVATE *clp)
 229 {
 230         if (clp->oname != NULL)
 231                 free(clp->oname);
 232         free(clp);
 233 }
 234 #endif
 235
 236 /*
 237  * term_init --
 238  *      Initialize terminal information.
 239  */
 240 static void
 241 term_init(const char *name, const char *ttype)
 242 {
 243         int err;
 244
 245         /* Set up the terminal database information. */
 246         setupterm(__UNCONST(ttype), STDOUT_FILENO, &err);
 247         switch (err) {
 248         case -1:
 249                 (void)fprintf(stderr,
 250                     "%s: No terminal database found\n", name);
 251                 exit (1);
 252         case 0:
 253                 (void)fprintf(stderr,
 254                     "%s: %s: unknown terminal type\n", name, ttype);
 255                 exit (1);
 256         }
 257 }
 258
 259 #define GLOBAL_CLP \
 260         CL_PRIVATE *clp = GCLP(__global_list);
 261 static void
 262 h_hup(int signo)
 263 {
 264         GLOBAL_CLP;
 265
 266         F_SET(clp, CL_SIGHUP);
 267         clp->killersig = SIGHUP;
 268 }
 269
 270 static void
 271 h_int(int signo)
 272 {
 273         GLOBAL_CLP;
 274
 275         F_SET(clp, CL_SIGINT);
 276 }
 277
 278 static void
 279 h_term(int signo)
 280 {
 281         GLOBAL_CLP;
 282
 283         F_SET(clp, CL_SIGTERM);
 284         clp->killersig = SIGTERM;
 285 }
 286
 287 static void
 288 h_winch(int signo)
 289 {
 290         GLOBAL_CLP;
 291
 292         F_SET(clp, CL_SIGWINCH);
 293 }
 294 #undef  GLOBAL_CLP
 295
 296 /*
 297  * sig_init --
 298  *      Initialize signals.
 299  *
 300  * PUBLIC: int sig_init __P((GS *, SCR *));
 301  */
 302 int
 303 sig_init(GS *gp, SCR *sp)
 304 {
 305         CL_PRIVATE *clp;
 306
 307         clp = GCLP(gp);
 308
 309         if (sp == NULL) {
 310                 (void)sigemptyset(&__sigblockset);
 311                 if (sigaddset(&__sigblockset, SIGHUP) ||
 312                     setsig(SIGHUP, &clp->oact[INDX_HUP], h_hup) ||
 313                     sigaddset(&__sigblockset, SIGINT) ||
 314                     setsig(SIGINT, &clp->oact[INDX_INT], h_int) ||
 315                     sigaddset(&__sigblockset, SIGTERM) ||
 316                     setsig(SIGTERM, &clp->oact[INDX_TERM], h_term)
 317 #ifdef SIGWINCH
 318                     ||
 319                     sigaddset(&__sigblockset, SIGWINCH) ||
 320                     setsig(SIGWINCH, &clp->oact[INDX_WINCH], h_winch)
 321 #endif
 322                     ) {
 323                         perr(gp->progname, NULL);
 324                         return (1);
 325                 }
 326         } else
 327                 if (setsig(SIGHUP, NULL, h_hup) ||
 328                     setsig(SIGINT, NULL, h_int) ||
 329                     setsig(SIGTERM, NULL, h_term)
 330 #ifdef SIGWINCH
 331                     ||
 332                     setsig(SIGWINCH, NULL, h_winch)
 333 #endif
 334                     ) {
 335                         msgq(sp, M_SYSERR, "signal-reset");
 336                 }
 337         return (0);
 338 }
 339
 340 /*
 341  * setsig --
 342  *      Set a signal handler.
 343  */
 344 static int
 345 setsig(int signo, struct sigaction *oactp, void (*handler) (int))
 346 {
 347         struct sigaction act;
 348
 349         /*
 350          * Use sigaction(2), not signal(3), since we don't always want to
 351          * restart system calls.  The example is when waiting for a command
 352          * mode keystroke and SIGWINCH arrives.  Besides, you can't portably
 353          * restart system calls (thanks, POSIX!).  On the other hand, you
 354          * can't portably NOT restart system calls (thanks, Sun!).  SunOS
 355          * used SA_INTERRUPT as their extension to NOT restart read calls.
 356          * We sure hope nobody else used it for anything else.  Mom told me
 357          * there'd be days like this.  She just never told me that there'd
 358          * be so many.
 359          */
 360         act.sa_handler = handler;
 361         sigemptyset(&act.sa_mask);
 362
 363 #ifdef SA_INTERRUPT
 364         act.sa_flags = SA_INTERRUPT;
 365 #else
 366         act.sa_flags = 0;
 367 #endif
 368         return (sigaction(signo, &act, oactp));
 369 }
 370
 371 /*
 372  * sig_end --
 373  *      End signal setup.
 374  */
 375 static void
 376 sig_end(GS *gp)
 377 {
 378         CL_PRIVATE *clp;
 379
 380         clp = GCLP(gp);
 381         (void)sigaction(SIGHUP, NULL, &clp->oact[INDX_HUP]);
 382         (void)sigaction(SIGINT, NULL, &clp->oact[INDX_INT]);
 383         (void)sigaction(SIGTERM, NULL, &clp->oact[INDX_TERM]);
 384 #ifdef SIGWINCH
 385         (void)sigaction(SIGWINCH, NULL, &clp->oact[INDX_WINCH]);
 386 #endif
 387 }
 388
 389 /*
 390  * cl_func_std --
 391  *      Initialize the standard curses functions.
 392  */
 393 static void
 394 cl_func_std(WIN *wp)
 395 {
 396         GS *gp;
 397
 398         gp = wp->gp;
 399
 400         gp->scr_addstr = cl_addstr;
 401         gp->scr_waddstr = cl_waddstr;
 402         gp->scr_attr = cl_attr;
 403         gp->scr_baud = cl_baud;
 404         gp->scr_bell = cl_bell;
 405         gp->scr_busy = NULL;
 406         gp->scr_child = NULL;
 407         gp->scr_clrtoeol = cl_clrtoeol;
 408         gp->scr_cursor = cl_cursor;
 409         gp->scr_deleteln = cl_deleteln;
 410         gp->scr_reply = NULL;
 411         gp->scr_discard = cl_discard;
 412         gp->scr_event = cl_event;
 413         gp->scr_ex_adjust = cl_ex_adjust;
 414         gp->scr_fmap = cl_fmap;
 415         gp->scr_insertln = cl_insertln;
 416         gp->scr_keyval = cl_keyval;
 417         gp->scr_move = cl_move;
 418         wp->scr_msg = NULL;
 419         gp->scr_optchange = cl_optchange;
 420         gp->scr_refresh = cl_refresh;
 421         gp->scr_rename = cl_rename;
 422         gp->scr_screen = cl_screen;
 423         gp->scr_split = cl_split;
 424         gp->scr_suspend = cl_suspend;
 425         gp->scr_usage = cl_usage;
 426 }
 427
 428 /*
 429  * perr --
 430  *      Print system error.
 431  */
 432 static void
 433 perr(const char *name, const char *msg)
 434 {
 435         (void)fprintf(stderr, "%s:", name);
 436         if (msg != NULL)
 437                 (void)fprintf(stderr, "%s:", msg);
 438         (void)fprintf(stderr, "%s\n", strerror(errno));
 439         exit(1);
 440 }