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