Logo Search packages:      
Sourcecode: vigor version File versions  Download package

ex_txt.c

/*-
 * Copyright (c) 1992, 1993, 1994
 *    The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1992, 1993, 1994, 1995, 1996
 *    Keith Bostic.  All rights reserved.
 *
 * See the LICENSE file for redistribution information.
 */

#include "config.h"

#ifndef lint
static const char sccsid[] = "@(#)ex_txt.c      10.17 (Berkeley) 10/10/96";
#endif /* not lint */

#include <sys/types.h>
#include <sys/queue.h>

#include <bitstring.h>
#include <ctype.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../common/common.h"

/*
 * !!!
 * The backslash characters was special when it preceded a newline as part of
 * a substitution replacement pattern.  For example, the input ":a<cr>" would
 * failed immediately with an error, as the <cr> wasn't part of a substitution
 * replacement pattern.  This implies a frightening integration of the editor
 * and the parser and/or the RE engine.  There's no way I'm going to reproduce
 * those semantics.
 *
 * So, if backslashes are special, this code inserts the backslash and the next
 * character into the string, without regard for the character or the command
 * being entered.  Since "<cr>" was illegal historically (except for the one
 * special case), and the command will fail eventually, no historical scripts
 * should break (presuming they didn't depend on the failure mode itself or the
 * characters remaining when failure occurred.
 */

static int  txt_dent __P((SCR *, TEXT *));
static void txt_prompt __P((SCR *, TEXT *, ARG_CHAR_T, u_int32_t));

/*
 * ex_txt --
 *    Get lines from the terminal for ex.
 *
 * PUBLIC: int ex_txt __P((SCR *, TEXTH *, ARG_CHAR_T, u_int32_t));
 */
int
ex_txt(sp, tiqh, prompt, flags)
      SCR *sp;
      TEXTH *tiqh;
      ARG_CHAR_T prompt;
      u_int32_t flags;
{
      EVENT ev;
      GS *gp;
      TEXT ait, *ntp, *tp;
      carat_t carat_st;
      size_t cnt;
      int rval;

      rval = 0;

      /*
       * Get a TEXT structure with some initial buffer space, reusing the
       * last one if it's big enough.  (All TEXT bookkeeping fields default
       * to 0 -- text_init() handles this.)
       */
      if (tiqh->cqh_first != (void *)tiqh) {
            tp = tiqh->cqh_first;
            if (tp->q.cqe_next != (void *)tiqh || tp->lb_len < 32) {
                  text_lfree(tiqh);
                  goto newtp;
            }
            tp->len = 0;
      } else {
newtp:            if ((tp = text_init(sp, NULL, 0, 32)) == NULL)
                  goto err;
            CIRCLEQ_INSERT_HEAD(tiqh, tp, q);
      }

      /* Set the starting line number. */
      tp->lno = sp->lno + 1;

      /*
       * If it's a terminal, set up autoindent, put out the prompt, and
       * set it up so we know we were suspended.  Otherwise, turn off
       * the autoindent flag, as that requires less special casing below.
       *
       * XXX
       * Historic practice is that ^Z suspended command mode (but, because
       * it ran in cooked mode, it was unaffected by the autowrite option.)
       * On restart, any "current" input was discarded, whether in insert
       * mode or not, and ex was in command mode.  This code matches historic
       * practice, but not 'cause it's easier.
       */
      gp = sp->gp;
      if (F_ISSET(gp, G_SCRIPTED))
            LF_CLR(TXT_AUTOINDENT);
      else {
            if (LF_ISSET(TXT_AUTOINDENT)) {
                  LF_SET(TXT_EOFCHAR);
                  if (v_txt_auto(sp, sp->lno, NULL, 0, tp))
                        goto err;
            }
            txt_prompt(sp, tp, prompt, flags);
      }

      for (carat_st = C_NOTSET;;) {
            if (v_event_get(sp, &ev, 0, 0))
                  goto err;

            /* Deal with all non-character events. */
            switch (ev.e_event) {
            case E_CHARACTER:
                  break;
            case E_ERR:
                  goto err;
            case E_REPAINT:
            case E_WRESIZE:
                  continue;
            case E_EOF:
                  rval = 1;
                  /* FALLTHROUGH */
            case E_INTERRUPT:
                  /*
                   * Handle EOF/SIGINT events by discarding partially
                   * entered text and returning.  EOF returns failure,
                   * E_INTERRUPT returns success.
                   */
                  goto notlast;
            default:
                  v_event_err(sp, &ev);
                  goto notlast;
            }

            /*
             * Deal with character events.
             *
             * Check to see if the character fits into the input buffer.
             * (Use tp->len, ignore overwrite and non-printable chars.)
             */
            BINC_GOTO(sp, tp->lb, tp->lb_len, tp->len + 1);

            switch (ev.e_value) {
            case K_CR:
                  /*
                   * !!!
                   * Historically, <carriage-return>'s in the command
                   * weren't special, so the ex parser would return an
                   * unknown command error message.  However, if they
                   * terminated the command if they were in a map.  I'm
                   * pretty sure this still isn't right, but it handles
                   * what I've seen so far.
                   */
                  if (!F_ISSET(&ev.e_ch, CH_MAPPED))
                        goto ins_ch;
                  /* FALLTHROUGH */
            case K_NL:
                  /*
                   * '\' can escape <carriage-return>/<newline>.  We
                   * don't discard the backslash because we need it
                   * to get the <newline> through the ex parser.
                   */
                  if (LF_ISSET(TXT_BACKSLASH) &&
                      tp->len != 0 && tp->lb[tp->len - 1] == '\\')
                        goto ins_ch;

                  /*
                   * CR returns from the ex command line.
                   *
                   * XXX
                   * Terminate with a nul, needed by filter.
                   */
                  if (LF_ISSET(TXT_CR)) {
                        tp->lb[tp->len] = '\0';
                        goto done;
                  }

                  /*
                   * '.' may terminate text input mode; free the current
                   * TEXT.
                   */
                  if (LF_ISSET(TXT_DOTTERM) && tp->len == tp->ai + 1 &&
                      tp->lb[tp->len - 1] == '.') {
notlast:                CIRCLEQ_REMOVE(tiqh, tp, q);
                        text_free(tp);
                        goto done;
                  }

                  /* Set up bookkeeping for the new line. */
                  if ((ntp = text_init(sp, NULL, 0, 32)) == NULL)
                        goto err;
                  ntp->lno = tp->lno + 1;

                  /*
                   * Reset the autoindent line value.  0^D keeps the ai
                   * line from changing, ^D changes the level, even if
                   * there were no characters in the old line.  Note, if
                   * using the current tp structure, use the cursor as
                   * the length, the autoindent characters may have been
                   * erased.
                   */
                  if (LF_ISSET(TXT_AUTOINDENT)) {
                        if (carat_st == C_NOCHANGE) {
                              if (v_txt_auto(sp,
                                  OOBLNO, &ait, ait.ai, ntp))
                                    goto err;
                              free(ait.lb);
                        } else
                              if (v_txt_auto(sp,
                                  OOBLNO, tp, tp->len, ntp))
                                    goto err;
                        carat_st = C_NOTSET;
                  }
                  txt_prompt(sp, ntp, prompt, flags);

                  /*
                   * Swap old and new TEXT's, and insert the new TEXT
                   * into the queue.
                   */
                  tp = ntp;
                  CIRCLEQ_INSERT_TAIL(tiqh, tp, q);
                  break;
            case K_CARAT:                 /* Delete autoindent chars. */
                  if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
                        carat_st = C_CARATSET;
                  goto ins_ch;
            case K_ZERO:                  /* Delete autoindent chars. */
                  if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
                        carat_st = C_ZEROSET;
                  goto ins_ch;
            case K_CNTRLD:                /* Delete autoindent char. */
                  /*
                   * !!!
                   * Historically, the ^D command took (but then ignored)
                   * a count.  For simplicity, we don't return it unless
                   * it's the first character entered.  The check for len
                   * equal to 0 is okay, TXT_AUTOINDENT won't be set.
                   */
                  if (LF_ISSET(TXT_CNTRLD)) {
                        for (cnt = 0; cnt < tp->len; ++cnt)
                              if (!isblank(tp->lb[cnt]))
                                    break;
                        if (cnt == tp->len) {
                              tp->len = 1;
                              tp->lb[0] = ev.e_c;
                              tp->lb[1] = '\0';

                              /*
                               * Put out a line separator, in case
                               * the command fails.
                               */
                              (void)putchar('\n');
                              goto done;
                        }
                  }

                  /*
                   * POSIX 1003.1b-1993, paragraph 7.1.1.9, states that
                   * the EOF characters are discarded if there are other
                   * characters to process in the line, i.e. if the EOF
                   * is not the first character in the line.  For this
                   * reason, historic ex discarded the EOF characters,
                   * even if occurring in the middle of the input line.
                   * We match that historic practice.
                   *
                   * !!!
                   * The test for discarding in the middle of the line is
                   * done in the switch, because the CARAT forms are N+1,
                   * not N.
                   *
                   * !!!
                   * There's considerable magic to make the terminal code
                   * return the EOF character at all.  See that code for
                   * details.
                   */
                  if (!LF_ISSET(TXT_AUTOINDENT) || tp->len == 0)
                        continue;
                  switch (carat_st) {
                  case C_CARATSET:        /* ^^D */
                        if (tp->len > tp->ai + 1)
                              continue;

                        /* Save the ai string for later. */
                        ait.lb = NULL;
                        ait.lb_len = 0;
                        BINC_GOTO(sp, ait.lb, ait.lb_len, tp->ai);
                        memcpy(ait.lb, tp->lb, tp->ai);
                        ait.ai = ait.len = tp->ai;

                        carat_st = C_NOCHANGE;
                        goto leftmargin;
                  case C_ZEROSET:               /* 0^D */
                        if (tp->len > tp->ai + 1)
                              continue;

                        carat_st = C_NOTSET;
leftmargin:             (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
                        tp->ai = tp->len = 0;
                        break;
                  case C_NOTSET:                /* ^D */
                        if (tp->len > tp->ai)
                              continue;

                        if (txt_dent(sp, tp))
                              goto err;
                        break;
                  default:
                        abort();
                  }

                  /* Clear and redisplay the line. */
                  (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
                  txt_prompt(sp, tp, prompt, flags);
                  break;
            default:
                  /*
                   * See the TXT_BEAUTIFY comment in vi/v_txt_ev.c.
                   *
                   * Silently eliminate any iscntrl() character that was
                   * not already handled specially, except for <tab> and
                   * <ff>.
                   */
ins_ch:                 if (LF_ISSET(TXT_BEAUTIFY) && iscntrl(ev.e_c) &&
                      ev.e_value != K_FORMFEED && ev.e_value != K_TAB)
                        break;

                  tp->lb[tp->len++] = ev.e_c;
                  break;
            }
      }
      /* NOTREACHED */

done: return (rval);

err:  
alloc_err:
      return (1);
}

/*
 * txt_prompt --
 *    Display the ex prompt, line number, ai characters.  Characters had
 *    better be printable by the terminal driver, but that's its problem,
 *    not ours.
 */
static void
txt_prompt(sp, tp, prompt, flags)
      SCR *sp;
      TEXT *tp;
      ARG_CHAR_T prompt;
      u_int32_t flags;
{
      /* Display the prompt. */
      if (LF_ISSET(TXT_PROMPT))
            (void)printf("%c", prompt);

      /* Display the line number. */
      if (LF_ISSET(TXT_NUMBER) && O_ISSET(sp, O_NUMBER))
            (void)printf("%6lu  ", (u_long)tp->lno);

      /* Print out autoindent string. */
      if (LF_ISSET(TXT_AUTOINDENT))
            (void)printf("%.*s", (int)tp->ai, tp->lb);
      (void)fflush(stdout);
}

/*
 * txt_dent --
 *    Handle ^D outdents.
 *
 * Ex version of vi/v_ntext.c:txt_dent().  See that code for the (usual)
 * ranting and raving.  This is a fair bit simpler as ^T isn't special.
 */
static int
txt_dent(sp, tp)
      SCR *sp;
      TEXT *tp;
{
      u_long sw, ts;
      size_t cno, off, scno, spaces, tabs;

      ts = O_VAL(sp, O_TABSTOP);
      sw = O_VAL(sp, O_SHIFTWIDTH);

      /* Get the current screen column. */
      for (off = scno = 0; off < tp->len; ++off)
            if (tp->lb[off] == '\t')
                  scno += COL_OFF(scno, ts);
            else
                  ++scno;

      /* Get the previous shiftwidth column. */
      cno = scno;
      scno -= --scno % sw;

      /*
       * Since we don't know what comes before the character(s) being
       * deleted, we have to resolve the autoindent characters .  The
       * example is a <tab>, which doesn't take up a full shiftwidth
       * number of columns because it's preceded by <space>s.  This is
       * easy to get if the user sets shiftwidth to a value less than
       * tabstop, and then uses ^T to indent, and ^D to outdent.
       *
       * Count up spaces/tabs needed to get to the target.
       */
      for (cno = 0, tabs = 0; cno + COL_OFF(cno, ts) <= scno; ++tabs)
            cno += COL_OFF(cno, ts);
      spaces = scno - cno;

      /* Make sure there's enough room. */
      BINC_RET(sp, tp->lb, tp->lb_len, tabs + spaces + 1);

      /* Adjust the final ai character count. */
      tp->ai = tabs + spaces;

      /* Enter the replacement characters. */
      for (tp->len = 0; tabs > 0; --tabs)
            tp->lb[tp->len++] = '\t';
      for (; spaces > 0; --spaces)
            tp->lb[tp->len++] = ' ';
      return (0);
}

Generated by  Doxygen 1.6.0   Back to index