external/bsd/nvi/dist/cl/cl_main.c

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