external/bsd/nvi/dist/ex/ex_txt.c

   1 /*      $NetBSD: ex_txt.c,v 1.4 2014/01/26 21:43:45 christos Exp $ */
   2 /*-
   3  * Copyright (c) 1992, 1993, 1994
   4  *      The Regents of the University of California.  All rights reserved.
   5  * Copyright (c) 1992, 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: ex_txt.c,v 10.23 2001/06/25 15:19:21 skimo Exp  (Berkeley) Date: 2001/06/25 15:19:21 ";
  17 #endif /* not lint */
  18 #else
  19 __RCSID("$NetBSD: ex_txt.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 #include <sys/time.h>
  25
  26 #include <bitstring.h>
  27 #include <ctype.h>
  28 #include <limits.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include "../common/common.h"
  34 #include "../vi/vi.h"
  35
  36 /*
  37  * !!!
  38  * The backslash characters was special when it preceded a newline as part of
  39  * a substitution replacement pattern.  For example, the input ":a\<cr>" would
  40  * failed immediately with an error, as the <cr> wasn't part of a substitution
  41  * replacement pattern.  This implies a frightening integration of the editor
  42  * and the parser and/or the RE engine.  There's no way I'm going to reproduce
  43  * those semantics.
  44  *
  45  * So, if backslashes are special, this code inserts the backslash and the next
  46  * character into the string, without regard for the character or the command
  47  * being entered.  Since "\<cr>" was illegal historically (except for the one
  48  * special case), and the command will fail eventually, no historical scripts
  49  * should break (presuming they didn't depend on the failure mode itself or the
  50  * characters remaining when failure occurred.
  51  */
  52
  53 static int      txt_dent __P((SCR *, TEXT *));
  54 static void     txt_prompt __P((SCR *, TEXT *, ARG_CHAR_T, u_int32_t));
  55
  56 /*
  57  * ex_txt --
  58  *      Get lines from the terminal for ex.
  59  *
  60  * PUBLIC: int ex_txt __P((SCR *, TEXTH *, ARG_CHAR_T, u_int32_t));
  61  */
  62 int
  63 ex_txt(SCR *sp, TEXTH *tiqh, ARG_CHAR_T prompt, u_int32_t flags)
  64 {
  65         EVENT ev;
  66         GS *gp;
  67         TEXT ait, *ntp, *tp;
  68         carat_t carat_st;
  69         size_t cnt;
  70         int rval;
  71         int nochange;
  72
  73         rval = 0;
  74
  75         /*
  76          * Get a TEXT structure with some initial buffer space, reusing the
  77          * last one if it's big enough.  (All TEXT bookkeeping fields default
  78          * to 0 -- text_init() handles this.)
  79          */
  80         if ((tp = TAILQ_FIRST(tiqh)) != NULL) {
  81                 if (TAILQ_NEXT(tp, q) != NULL || tp->lb_len < 32) {
  82                         text_lfree(tiqh);
  83                         goto newtp;
  84                 }
  85                 tp->len = 0;
  86         } else {
  87 newtp:          if ((tp = text_init(sp, NULL, 0, 32)) == NULL)
  88                         goto err;
  89                 TAILQ_INSERT_HEAD(tiqh, tp, q);
  90         }
  91
  92         /* Set the starting line number. */
  93         tp->lno = sp->lno + 1;
  94
  95         /*
  96          * If it's a terminal, set up autoindent, put out the prompt, and
  97          * set it up so we know we were suspended.  Otherwise, turn off
  98          * the autoindent flag, as that requires less special casing below.
  99          *
 100          * XXX
 101          * Historic practice is that ^Z suspended command mode (but, because
 102          * it ran in cooked mode, it was unaffected by the autowrite option.)
 103          * On restart, any "current" input was discarded, whether in insert
 104          * mode or not, and ex was in command mode.  This code matches historic
 105          * practice, but not 'cause it's easier.
 106          */
 107         gp = sp->gp;
 108         if (F_ISSET(gp, G_SCRIPTED))
 109                 LF_CLR(TXT_AUTOINDENT);
 110         else {
 111                 if (LF_ISSET(TXT_AUTOINDENT)) {
 112                         LF_SET(TXT_EOFCHAR);
 113                         if (v_txt_auto(sp, sp->lno, NULL, 0, tp))
 114                                 goto err;
 115                 }
 116                 txt_prompt(sp, tp, prompt, flags);
 117         }
 118
 119         for (carat_st = C_NOTSET, nochange = 0;;) {
 120                 if (v_event_get(sp, &ev, 0, 0))
 121                         goto err;
 122
 123                 /* Deal with all non-character events. */
 124                 switch (ev.e_event) {
 125                 case E_CHARACTER:
 126                         break;
 127                 case E_ERR:
 128                         goto err;
 129                 case E_REPAINT:
 130                 case E_WRESIZE:
 131                         continue;
 132                 case E_EOF:
 133                         rval = 1;
 134                         /* FALLTHROUGH */
 135                 case E_INTERRUPT:
 136                         /*
 137                          * Handle EOF/SIGINT events by discarding partially
 138                          * entered text and returning.  EOF returns failure,
 139                          * E_INTERRUPT returns success.
 140                          */
 141                         goto notlast;
 142                 default:
 143                         v_event_err(sp, &ev);
 144                         goto notlast;
 145                 }
 146
 147                 /*
 148                  * Deal with character events.
 149                  *
 150                  * Check to see if the character fits into the input buffer.
 151                  * (Use tp->len, ignore overwrite and non-printable chars.)
 152                  */
 153                 BINC_GOTOW(sp, tp->lb, tp->lb_len, tp->len + 1);
 154
 155                 switch (ev.e_value) {
 156                 case K_CR:
 157                         /*
 158                          * !!!
 159                          * Historically, <carriage-return>'s in the command
 160                          * weren't special, so the ex parser would return an
 161                          * unknown command error message.  However, if they
 162                          * terminated the command if they were in a map.  I'm
 163                          * pretty sure this still isn't right, but it handles
 164                          * what I've seen so far.
 165                          */
 166                         if (!FL_ISSET(ev.e_flags, CH_MAPPED))
 167                                 goto ins_ch;
 168                         /* FALLTHROUGH */
 169                 case K_NL:
 170                         /*
 171                          * '\' can escape <carriage-return>/<newline>.  We
 172                          * don't discard the backslash because we need it
 173                          * to get the <newline> through the ex parser.
 174                          */
 175                         if (LF_ISSET(TXT_BACKSLASH) &&
 176                             tp->len != 0 && tp->lb[tp->len - 1] == '\\')
 177                                 goto ins_ch;
 178
 179                         /*
 180                          * CR returns from the ex command line.
 181                          *
 182                          * XXX
 183                          * Terminate with a nul, needed by filter.
 184                          */
 185                         if (LF_ISSET(TXT_CR)) {
 186                                 tp->lb[tp->len] = '\0';
 187                                 goto done;
 188                         }
 189
 190                         /*
 191                          * '.' may terminate text input mode; free the current
 192                          * TEXT.
 193                          */
 194                         if (LF_ISSET(TXT_DOTTERM) && tp->len == tp->ai + 1 &&
 195                             tp->lb[tp->len - 1] == '.') {
 196 notlast:                        TAILQ_REMOVE(tiqh, tp, q);
 197                                 text_free(tp);
 198                                 goto done;
 199                         }
 200
 201                         /* Set up bookkeeping for the new line. */
 202                         if ((ntp = text_init(sp, NULL, 0, 32)) == NULL)
 203                                 goto err;
 204                         ntp->lno = tp->lno + 1;
 205
 206                         /*
 207                          * Reset the autoindent line value.  0^D keeps the ai
 208                          * line from changing, ^D changes the level, even if
 209                          * there were no characters in the old line.  Note, if
 210                          * using the current tp structure, use the cursor as
 211                          * the length, the autoindent characters may have been
 212                          * erased.
 213                          */
 214                         if (LF_ISSET(TXT_AUTOINDENT)) {
 215                                 if (nochange) {
 216                                         nochange = 0;
 217                                         if (v_txt_auto(sp,
 218                                             OOBLNO, &ait, ait.ai, ntp))
 219                                                 goto err;
 220                                         free(ait.lb);
 221                                 } else
 222                                         if (v_txt_auto(sp,
 223                                             OOBLNO, tp, tp->len, ntp))
 224                                                 goto err;
 225                                 carat_st = C_NOTSET;
 226                         }
 227                         txt_prompt(sp, ntp, prompt, flags);
 228
 229                         /*
 230                          * Swap old and new TEXT's, and insert the new TEXT
 231                          * into the queue.
 232                          */
 233                         tp = ntp;
 234                         TAILQ_INSERT_TAIL(tiqh, tp, q);
 235                         break;
 236                 case K_CARAT:                   /* Delete autoindent chars. */
 237                         if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
 238                                 carat_st = C_CARATSET;
 239                         goto ins_ch;
 240                 case K_ZERO:                    /* Delete autoindent chars. */
 241                         if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
 242                                 carat_st = C_ZEROSET;
 243                         goto ins_ch;
 244                 case K_CNTRLD:                  /* Delete autoindent char. */
 245                         /*
 246                          * !!!
 247                          * Historically, the ^D command took (but then ignored)
 248                          * a count.  For simplicity, we don't return it unless
 249                          * it's the first character entered.  The check for len
 250                          * equal to 0 is okay, TXT_AUTOINDENT won't be set.
 251                          */
 252                         if (LF_ISSET(TXT_CNTRLD)) {
 253                                 for (cnt = 0; cnt < tp->len; ++cnt)
 254                                         if (!ISBLANK((UCHAR_T)tp->lb[cnt]))
 255                                                 break;
 256                                 if (cnt == tp->len) {
 257                                         tp->len = 1;
 258                                         tp->lb[0] = ev.e_c;
 259                                         tp->lb[1] = '\0';
 260
 261                                         /*
 262                                          * Put out a line separator, in case
 263                                          * the command fails.
 264                                          */
 265                                         (void)putchar('\n');
 266                                         goto done;
 267                                 }
 268                         }
 269
 270                         /*
 271                          * POSIX 1003.1b-1993, paragraph 7.1.1.9, states that
 272                          * the EOF characters are discarded if there are other
 273                          * characters to process in the line, i.e. if the EOF
 274                          * is not the first character in the line.  For this
 275                          * reason, historic ex discarded the EOF characters,
 276                          * even if occurring in the middle of the input line.
 277                          * We match that historic practice.
 278                          *
 279                          * !!!
 280                          * The test for discarding in the middle of the line is
 281                          * done in the switch, because the CARAT forms are N+1,
 282                          * not N.
 283                          *
 284                          * !!!
 285                          * There's considerable magic to make the terminal code
 286                          * return the EOF character at all.  See that code for
 287                          * details.
 288                          */
 289                         if (!LF_ISSET(TXT_AUTOINDENT) || tp->len == 0)
 290                                 continue;
 291                         switch (carat_st) {
 292                         case C_CARATSET:                /* ^^D */
 293                                 if (tp->len > tp->ai + 1)
 294                                         continue;
 295
 296                                 /* Save the ai string for later. */
 297                                 ait.lb = NULL;
 298                                 ait.lb_len = 0;
 299                                 BINC_GOTOW(sp, ait.lb, ait.lb_len, tp->ai);
 300                                 MEMCPYW(ait.lb, tp->lb, tp->ai);
 301                                 ait.ai = ait.len = tp->ai;
 302
 303                                 carat_st = C_NOTSET;
 304                                 nochange = 1;
 305                                 goto leftmargin;
 306                         case C_ZEROSET:                 /* 0^D */
 307                                 if (tp->len > tp->ai + 1)
 308                                         continue;
 309
 310                                 carat_st = C_NOTSET;
 311 leftmargin:                     (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
 312                                 tp->ai = tp->len = 0;
 313                                 break;
 314                         case C_NOTSET:                  /* ^D */
 315                                 if (tp->len > tp->ai)
 316                                         continue;
 317
 318                                 if (txt_dent(sp, tp))
 319                                         goto err;
 320                                 break;
 321                         default:
 322                                 abort();
 323                         }
 324
 325                         /* Clear and redisplay the line. */
 326                         (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
 327                         txt_prompt(sp, tp, prompt, flags);
 328                         break;
 329                 default:
 330                         /*
 331                          * See the TXT_BEAUTIFY comment in vi/v_txt_ev.c.
 332                          *
 333                          * Silently eliminate any iscntrl() character that was
 334                          * not already handled specially, except for <tab> and
 335                          * <ff>.
 336                          */
 337 ins_ch:                 if (LF_ISSET(TXT_BEAUTIFY) && ISCNTRL(ev.e_c) &&
 338                             ev.e_value != K_FORMFEED && ev.e_value != K_TAB)
 339                                 break;
 340
 341                         tp->lb[tp->len++] = ev.e_c;
 342                         break;
 343                 }
 344         }
 345         /* NOTREACHED */
 346
 347 done:   return (rval);
 348
 349 err:
 350 alloc_err:
 351         return (1);
 352 }
 353
 354 /*
 355  * txt_prompt --
 356  *      Display the ex prompt, line number, ai characters.  Characters had
 357  *      better be printable by the terminal driver, but that's its problem,
 358  *      not ours.
 359  */
 360 static void
 361 txt_prompt(SCR *sp, TEXT *tp, ARG_CHAR_T prompt, u_int32_t flags)
 362 {
 363         /* Display the prompt. */
 364         if (LF_ISSET(TXT_PROMPT))
 365                 (void)ex_printf(sp, "%c", prompt);
 366
 367         /* Display the line number. */
 368         if (LF_ISSET(TXT_NUMBER) && O_ISSET(sp, O_NUMBER))
 369                 (void)ex_printf(sp, "%6lu  ", (u_long)tp->lno);
 370
 371         /* Print out autoindent string. */
 372         if (LF_ISSET(TXT_AUTOINDENT)) {
 373                 const char *nstr;
 374                 size_t nlen;
 375                 INT2CHAR(sp, tp->lb, tp->ai + 1, nstr, nlen);
 376                 (void)ex_printf(sp, "%.*s", (int)tp->ai, nstr);
 377         }
 378         (void)ex_fflush(sp);
 379 }
 380
 381 /*
 382  * txt_dent --
 383  *      Handle ^D outdents.
 384  *
 385  * Ex version of vi/v_ntext.c:txt_dent().  See that code for the (usual)
 386  * ranting and raving.  This is a fair bit simpler as ^T isn't special.
 387  */
 388 static int
 389 txt_dent(SCR *sp, TEXT *tp)
 390 {
 391         u_long sw, ts;
 392         size_t cno, off, scno, spaces, tabs;
 393
 394         ts = O_VAL(sp, O_TABSTOP);
 395         sw = O_VAL(sp, O_SHIFTWIDTH);
 396
 397         /* Get the current screen column. */
 398         for (off = scno = 0; off < tp->len; ++off)
 399                 if (tp->lb[off] == '\t')
 400                         scno += COL_OFF(scno, ts);
 401                 else
 402                         ++scno;
 403
 404         /* Get the previous shiftwidth column. */
 405         cno = scno--;
 406         scno -= scno % sw;
 407
 408         /*
 409          * Since we don't know what comes before the character(s) being
 410          * deleted, we have to resolve the autoindent characters .  The
 411          * example is a <tab>, which doesn't take up a full shiftwidth
 412          * number of columns because it's preceded by <space>s.  This is
 413          * easy to get if the user sets shiftwidth to a value less than
 414          * tabstop, and then uses ^T to indent, and ^D to outdent.
 415          *
 416          * Count up spaces/tabs needed to get to the target.
 417          */
 418         cno = 0;
 419         tabs = 0;
 420         if (!O_ISSET(sp, O_EXPANDTAB)) {
 421                 for (; cno + COL_OFF(cno, ts) <= scno; ++tabs)
 422                         cno += COL_OFF(cno, ts);
 423         }
 424         spaces = scno - cno;
 425
 426         /* Make sure there's enough room. */
 427         BINC_RETW(sp, tp->lb, tp->lb_len, tabs + spaces + 1);
 428
 429         /* Adjust the final ai character count. */
 430         tp->ai = tabs + spaces;
 431
 432         /* Enter the replacement characters. */
 433         for (tp->len = 0; tabs > 0; --tabs)
 434                 tp->lb[tp->len++] = '\t';
 435         for (; spaces > 0; --spaces)
 436                 tp->lb[tp->len++] = ' ';
 437         return (0);
 438 }