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

ex.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.c    10.57 (Berkeley) 10/10/96";
#endif /* not lint */

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

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

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

#if defined(DEBUG) && defined(COMLOG)
static void ex_comlog __P((SCR *, EXCMD *));
#endif
static EXCMDLIST const *
            ex_comm_search __P((char *, size_t));
static int  ex_discard __P((SCR *));
static int  ex_line __P((SCR *, EXCMD *, MARK *, int *, int *));
static int  ex_load __P((SCR *));
static void ex_unknown __P((SCR *, char *, size_t));

/*
 * ex --
 *    Main ex loop.
 *
 * PUBLIC: int ex __P((SCR **));
 */
int
ex(spp)
      SCR **spp;
{
      EX_PRIVATE *exp;
      GS *gp;
      MSGS *mp;
      SCR *sp;
      TEXT *tp;
      u_int32_t flags;

      sp = *spp;
      gp = sp->gp;
      exp = EXP(sp);

      /* Start the ex screen. */
      if (ex_init(sp))
            return (1);

      /* Flush any saved messages. */
      while ((mp = gp->msgq.lh_first) != NULL) {
            gp->scr_msg(sp, mp->mtype, mp->buf, mp->len);
            LIST_REMOVE(mp, q);
            free(mp->buf);
            free(mp);
      }

      /* If reading from a file, errors should have name and line info. */
      if (F_ISSET(gp, G_SCRIPTED)) {
            gp->excmd.if_lno = 1;
            gp->excmd.if_name = "script";
      }

      /*
       * !!!
       * Initialize the text flags.  The beautify edit option historically
       * applied to ex command input read from a file.  In addition, the
       * first time a ^H was discarded from the input, there was a message,
       * "^H discarded", that was displayed.  We don't bother.
       */
      LF_INIT(TXT_BACKSLASH | TXT_CNTRLD | TXT_CR);
      for (;; ++gp->excmd.if_lno) {
            /* Display status line and flush. */
            if (F_ISSET(sp, SC_STATUS)) {
                  if (!F_ISSET(sp, SC_EX_SILENT))
                        msgq_status(sp, sp->lno, 0);
                  F_CLR(sp, SC_STATUS);
            }
            (void)ex_fflush(sp);

            /* Set the flags the user can reset. */
            if (O_ISSET(sp, O_BEAUTIFY))
                  LF_SET(TXT_BEAUTIFY);
            if (O_ISSET(sp, O_PROMPT))
                  LF_SET(TXT_PROMPT);

            /* Clear any current interrupts, and get a command. */
            CLR_INTERRUPT(sp);
            if (ex_txt(sp, &sp->tiq, ':', flags))
                  return (1);
            if (INTERRUPTED(sp)) {
                  (void)ex_puts(sp, "\n");
                  (void)ex_fflush(sp);
                  continue;
            }

            /* Initialize the command structure. */
            CLEAR_EX_PARSER(&gp->excmd);

            /*
             * If the user entered a single carriage return, send
             * ex_cmd() a separator -- it discards single newlines.
             */
            tp = sp->tiq.cqh_first;
            if (tp->len == 0) {
                  gp->excmd.cp = " ";     /* __TK__ why not |? */
                  gp->excmd.clen = 1;
            } else {
                  gp->excmd.cp = tp->lb;
                  gp->excmd.clen = tp->len;
            }
            F_INIT(&gp->excmd, E_NRSEP);

            if (ex_cmd(sp) && F_ISSET(gp, G_SCRIPTED))
                  return (1);

            if (INTERRUPTED(sp)) {
                  CLR_INTERRUPT(sp);
                  msgq(sp, M_ERR, "170|Interrupted");
            }

            /*
             * If the last command caused a restart, or switched screens
             * or into vi, return.
             */
            if (F_ISSET(gp, G_SRESTART) || F_ISSET(sp, SC_SSWITCH | SC_VI)) {
                  *spp = sp;
                  break;
            }

            /* If the last command switched files, we don't care. */
            F_CLR(sp, SC_FSWITCH);

            /*
             * If we're exiting this screen, move to the next one.  By
             * definition, this means returning into vi, so return to the
             * main editor loop.  The ordering is careful, don't discard
             * the contents of sp until the end.
             */
            if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
                  if (file_end(sp, NULL, F_ISSET(sp, SC_EXIT_FORCE)))
                        return (1);
                  *spp = screen_next(sp);
                  return (screen_end(sp));
            }
      }
      return (0);
}

/*
 * ex_cmd --
 *    The guts of the ex parser: parse and execute a string containing
 *    ex commands.
 *
 * !!!
 * This code MODIFIES the string that gets passed in, to delete quoting
 * characters, etc.  The string cannot be readonly/text space, nor should
 * you expect to use it again after ex_cmd() returns.
 *
 * !!!
 * For the fun of it, if you want to see if a vi clone got the ex argument
 * parsing right, try:
 *
 *    echo 'foo|bar' > file1; echo 'foo/bar' > file2;
 *    vi
 *    :edit +1|s/|/PIPE/|w file1| e file2|1 | s/\//SLASH/|wq
 *
 * or:      vi
 *    :set|file|append|set|file
 *
 * For extra credit, try them in a startup .exrc file.
 *
 * PUBLIC: int ex_cmd __P((SCR *));
 */
int
ex_cmd(sp)
      SCR *sp;
{
      enum nresult nret;
      EX_PRIVATE *exp;
      EXCMD *ecp;
      GS *gp;
      MARK cur;
      recno_t lno;
      size_t arg1_len, discard, len;
      u_int32_t flags;
      long ltmp;
      int at_found, gv_found;
      int ch, cnt, delim, isaddr, namelen;
      int newscreen, notempty, tmp, vi_address;
      char *arg1, *p, *s, *t;

      gp = sp->gp;
      exp = EXP(sp);

      /*
       * We always start running the command on the top of the stack.
       * This means that *everything* must be resolved when we leave
       * this function for any reason.
       */
loop: ecp = gp->ecq.lh_first;

      /* If we're reading a command from a file, set up error information. */
      if (ecp->if_name != NULL) {
            gp->if_lno = ecp->if_lno;
            gp->if_name = ecp->if_name;
      }

      /*
       * If a move to the end of the file is scheduled for this command,
       * do it now.
       */
      if (F_ISSET(ecp, E_MOVETOEND)) {
            if (db_last(sp, &sp->lno))
                  goto rfail;
            sp->cno = 0;
            F_CLR(ecp, E_MOVETOEND);
      }

      /* If we found a newline, increment the count now. */
      if (F_ISSET(ecp, E_NEWLINE)) {
            ++gp->if_lno;
            ++ecp->if_lno;
            F_CLR(ecp, E_NEWLINE);
      }

      /* (Re)initialize the EXCMD structure, preserving some flags. */
      CLEAR_EX_CMD(ecp);

      /* Initialize the argument structures. */
      if (argv_init(sp, ecp))
            goto err;

      /* Initialize +cmd, saved command information. */
      arg1 = NULL;
      ecp->save_cmdlen = 0;

      /* Skip <blank>s, empty lines.  */
      for (notempty = 0; ecp->clen > 0; ++ecp->cp, --ecp->clen)
            if ((ch = *ecp->cp) == '\n') {
                  ++gp->if_lno;
                  ++ecp->if_lno;
            } else if (isblank(ch))
                  notempty = 1;
            else
                  break;

      /*
       * !!!
       * Permit extra colons at the start of the line.  Historically,
       * ex/vi allowed a single extra one.  It's simpler not to count.
       * The stripping is done here because, historically, any command
       * could have preceding colons, e.g. ":g/pattern/:p" worked.
       */
      if (ecp->clen != 0 && ch == ':') {
            notempty = 1;
            while (--ecp->clen > 0 && (ch = *++ecp->cp) == ':');
      }

      /*
       * Command lines that start with a double-quote are comments.
       *
       * !!!
       * Historically, there was no escape or delimiter for a comment, e.g.
       * :"foo|set was a single comment and nothing was output.  Since nvi
       * permits users to escape <newline> characters into command lines, we
       * have to check for that case.
       */
      if (ecp->clen != 0 && ch == '"') {
            while (--ecp->clen > 0 && *++ecp->cp != '\n');
            if (*ecp->cp == '\n') {
                  F_SET(ecp, E_NEWLINE);
                  ++ecp->cp;
                  --ecp->clen;
            }
            goto loop;
      }

      /* Skip whitespace. */
      for (; ecp->clen > 0; ++ecp->cp, --ecp->clen) {
            ch = *ecp->cp;
            if (!isblank(ch))
                  break;
      }

      /*
       * The last point at which an empty line can mean do nothing.
       *
       * !!!
       * Historically, in ex mode, lines containing only <blank> characters
       * were the same as a single <carriage-return>, i.e. a default command.
       * In vi mode, they were ignored.  In .exrc files this was a serious
       * annoyance, as vi kept trying to treat them as print commands.  We
       * ignore backward compatibility in this case, discarding lines that
       * contain only <blank> characters from .exrc files.
       *
       * !!!
       * This is where you end up when you're done a command, i.e. clen has
       * gone to zero.  Continue if there are more commands to run.
       */
      if (ecp->clen == 0 &&
          (!notempty || F_ISSET(sp, SC_VI) || F_ISSET(ecp, E_BLIGNORE))) {
            if (ex_load(sp))
                  goto rfail;
            ecp = gp->ecq.lh_first;
            if (ecp->clen == 0)
                  goto rsuccess;
            goto loop;
      }

      /*
       * Check to see if this is a command for which we may want to move
       * the cursor back up to the previous line.  (The command :1<CR>
       * wants a <newline> separator, but the command :<CR> wants to erase
       * the command line.)  If the line is empty except for <blank>s,
       * <carriage-return> or <eof>, we'll probably want to move up.  I
       * don't think there's any way to get <blank> characters *after* the
       * command character, but this is the ex parser, and I've been wrong
       * before.
       */
      if (F_ISSET(ecp, E_NRSEP) &&
          ecp->clen != 0 && (ecp->clen != 1 || ecp->cp[0] != '\004'))
            F_CLR(ecp, E_NRSEP);

      /* Parse command addresses. */
      if (ex_range(sp, ecp, &tmp))
            goto rfail;
      if (tmp)
            goto err;

      /*
       * Skip <blank>s and any more colons (the command :3,5:print
       * worked, historically).
       */
      for (; ecp->clen > 0; ++ecp->cp, --ecp->clen) {
            ch = *ecp->cp;
            if (!isblank(ch) && ch != ':')
                  break;
      }

      /*
       * If no command, ex does the last specified of p, l, or #, and vi
       * moves to the line.  Otherwise, determine the length of the command
       * name by looking for the first non-alphabetic character.  (There
       * are a few non-alphabetic characters in command names, but they're
       * all single character commands.)  This isn't a great test, because
       * it means that, for the command ":e +cut.c file", we'll report that
       * the command "cut" wasn't known.  However, it makes ":e+35 file" work
       * correctly.
       *
       * !!!
       * Historically, lines with multiple adjacent (or <blank> separated)
       * command separators were very strange.  For example, the command
       * |||<carriage-return>, when the cursor was on line 1, displayed
       * lines 2, 3 and 5 of the file.  In addition, the command "   |  "
       * would only display the line after the next line, instead of the
       * next two lines.  No ideas why.  It worked reasonably when executed
       * from vi mode, and displayed lines 2, 3, and 4, so we do a default
       * command for each separator.
       */
#define     SINGLE_CHAR_COMMANDS    "\004!#&*<=>@~"
      newscreen = 0;
      if (ecp->clen != 0 && ecp->cp[0] != '|' && ecp->cp[0] != '\n') {
            if (strchr(SINGLE_CHAR_COMMANDS, *ecp->cp)) {
                  p = ecp->cp;
                  ++ecp->cp;
                  --ecp->clen;
                  namelen = 1;
            } else {
                  for (p = ecp->cp;
                      ecp->clen > 0; --ecp->clen, ++ecp->cp)
                        if (!isalpha(*ecp->cp))
                              break;
                  if ((namelen = ecp->cp - p) == 0) {
                        msgq(sp, M_ERR, "080|Unknown command name");
                        goto err;
                  }
            }

            /*
             * !!!
             * Historic vi permitted flags to immediately follow any
             * subset of the 'delete' command, but then did not permit
             * further arguments (flag, buffer, count).  Make it work.
             * Permit further arguments for the few shreds of dignity
             * it offers.
             *
             * Adding commands that start with 'd', and match "delete"
             * up to a l, p, +, - or # character can break this code.
             *
             * !!!
             * Capital letters beginning the command names ex, edit,
             * next, previous, tag and visual (in vi mode) indicate the
             * command should happen in a new screen.
             */
            switch (p[0]) {
            case 'd':
                  for (s = p,
                      t = cmds[C_DELETE].name; *s == *t; ++s, ++t);
                  if (s[0] == 'l' || s[0] == 'p' || s[0] == '+' ||
                      s[0] == '-' || s[0] == '^' || s[0] == '#') {
                        len = (ecp->cp - p) - (s - p);
                        ecp->cp -= len;
                        ecp->clen += len;
                        ecp->rcmd = cmds[C_DELETE];
                        ecp->rcmd.syntax = "1bca1";
                        ecp->cmd = &ecp->rcmd;
                        goto skip_srch;
                  }
                  break;
            case 'E': case 'F': case 'N': case 'P': case 'T': case 'V':
                  newscreen = 1;
                  p[0] = tolower(p[0]);
                  break;
            }

            /*
             * Search the table for the command.
             *
             * !!!
             * Historic vi permitted the mark to immediately follow the
             * 'k' in the 'k' command.  Make it work.
             *
             * !!!
             * Historic vi permitted any flag to follow the s command, e.g.
             * "s/e/E/|s|sgc3p" was legal.  Make the command "sgc" work.
             * Since the following characters all have to be flags, i.e.
             * alphabetics, we can let the s command routine return errors
             * if it was some illegal command string.  This code will break
             * if an "sg" or similar command is ever added.  The substitute
             * code doesn't care if it's a "cgr" flag or a "#lp" flag that
             * follows the 's', but we limit the choices here to "cgr" so
             * that we get unknown command messages for wrong combinations.
             */
            if ((ecp->cmd = ex_comm_search(p, namelen)) == NULL)
                  switch (p[0]) {
                  case 'k':
                        if (namelen == 2) {
                              ecp->cp -= namelen - 1;
                              ecp->clen += namelen - 1;
                              ecp->cmd = &cmds[C_K];
                              break;
                        }
                        goto unknown;
                  case 's':
                        for (s = p + 1, cnt = namelen; --cnt; ++s)
                              if (s[0] != 'c' &&
                                  s[0] != 'g' && s[0] != 'r')
                                    break;
                        if (cnt == 0) {
                              ecp->cp -= namelen - 1;
                              ecp->clen += namelen - 1;
                              ecp->rcmd = cmds[C_SUBSTITUTE];
                              ecp->rcmd.fn = ex_subagain;
                              ecp->cmd = &ecp->rcmd;
                              break;
                        }
                        /* FALLTHROUGH */
                  default:
unknown:                if (newscreen)
                              p[0] = toupper(p[0]);
                        ex_unknown(sp, p, namelen);
                        goto err;
                  }

            /*
             * The visual command has a different syntax when called
             * from ex than when called from a vi colon command.  FMH.
             * Make the change now, before we test for the newscreen
             * semantic, so that we're testing the right one.
             */
skip_srch:  if (ecp->cmd == &cmds[C_VISUAL_EX] && F_ISSET(sp, SC_VI))
                  ecp->cmd = &cmds[C_VISUAL_VI];

            /*
             * !!!
             * Historic vi permitted a capital 'P' at the beginning of
             * any command that started with 'p'.  Probably wanted the
             * P[rint] command for backward compatibility, and the code
             * just made Preserve and Put work by accident.  Nvi uses
             * Previous to mean previous-in-a-new-screen, so be careful.
             */
            if (newscreen && !F_ISSET(ecp->cmd, E_NEWSCREEN) &&
                (ecp->cmd == &cmds[C_PRINT] ||
                ecp->cmd == &cmds[C_PRESERVE]))
                  newscreen = 0;

            /* Test for a newscreen associated with this command. */
            if (newscreen && !F_ISSET(ecp->cmd, E_NEWSCREEN))
                  goto unknown;

            /* Secure means no shell access. */
            if (F_ISSET(ecp->cmd, E_SECURE) && O_ISSET(sp, O_SECURE)) {
                  ex_emsg(sp, ecp->cmd->name, EXM_SECURE);
                  goto err;
            }

            /*
             * Multiple < and > characters; another "feature".  Note,
             * The string passed to the underlying function may not be
             * nul terminated in this case.
             */
            if ((ecp->cmd == &cmds[C_SHIFTL] && *p == '<') ||
                (ecp->cmd == &cmds[C_SHIFTR] && *p == '>')) {
                  for (ch = *p;
                      ecp->clen > 0; --ecp->clen, ++ecp->cp)
                        if (*ecp->cp != ch)
                              break;
                  if (argv_exp0(sp, ecp, p, ecp->cp - p))
                        goto err;
            }

            /* Set the format style flags for the next command. */
            if (ecp->cmd == &cmds[C_HASH])
                  exp->fdef = E_C_HASH;
            else if (ecp->cmd == &cmds[C_LIST])
                  exp->fdef = E_C_LIST;
            else if (ecp->cmd == &cmds[C_PRINT])
                  exp->fdef = E_C_PRINT;
            F_CLR(ecp, E_USELASTCMD);
      } else {
            /* Print is the default command. */
            ecp->cmd = &cmds[C_PRINT];

            /* Set the saved format flags. */
            F_SET(ecp, exp->fdef);

            /*
             * !!!
             * If no address was specified, and it's not a global command,
             * we up the address by one.  (I have no idea why globals are
             * exempted, but it's (ahem) historic practice.)
             */
            if (ecp->addrcnt == 0 && !F_ISSET(sp, SC_EX_GLOBAL)) {
                  ecp->addrcnt = 1;
                  ecp->addr1.lno = sp->lno + 1;
                  ecp->addr1.cno = sp->cno;
            }

            F_SET(ecp, E_USELASTCMD);
      }

      /*
       * !!!
       * Historically, the number option applied to both ex and vi.  One
       * strangeness was that ex didn't switch display formats until a
       * command was entered, e.g. <CR>'s after the set didn't change to
       * the new format, but :1p would.
       */
      if (O_ISSET(sp, O_NUMBER)) {
            F_SET(ecp, E_OPTNUM);
            FL_SET(ecp->iflags, E_C_HASH);
      } else
            F_CLR(ecp, E_OPTNUM);

      /* Check for ex mode legality. */
      if (F_ISSET(sp, SC_EX) && (F_ISSET(ecp->cmd, E_VIONLY) || newscreen)) {
            msgq(sp, M_ERR,
                "082|%s: command not available in ex mode", ecp->cmd->name);
            goto err;
      }

      /* Add standard command flags. */
      F_SET(ecp, ecp->cmd->flags);
      if (!newscreen)
            F_CLR(ecp, E_NEWSCREEN);

      /*
       * There are three normal termination cases for an ex command.  They
       * are the end of the string (ecp->clen), or unescaped (by <literal
       * next> characters) <newline> or '|' characters.  As we're now past
       * possible addresses, we can determine how long the command is, so we
       * don't have to look for all the possible terminations.  Naturally,
       * there are some exciting special cases:
       *
       * 1: The bang, global, v and the filter versions of the read and
       *    write commands are delimited by <newline>s (they can contain
       *    shell pipes).
       * 2: The ex, edit, next and visual in vi mode commands all take ex
       *    commands as their first arguments.
       * 3: The s command takes an RE as its first argument, and wants it
       *    to be specially delimited.
       *
       * Historically, '|' characters in the first argument of the ex, edit,
       * next, vi visual, and s commands didn't delimit the command.  And,
       * in the filter cases for read and write, and the bang, global and v
       * commands, they did not delimit the command at all.
       *
       * For example, the following commands were legal:
       *
       *    :edit +25|s/abc/ABC/ file.c
       *    :s/|/PIPE/
       *    :read !spell % | columnate
       *    :global/pattern/p|l
       *
       * It's not quite as simple as it sounds, however.  The command:
       *
       *    :s/a/b/|s/c/d|set
       *
       * was also legal, i.e. the historic ex parser (using the word loosely,
       * since "parser" implies some regularity of syntax) delimited the RE's
       * based on its delimiter and not anything so irretrievably vulgar as a
       * command syntax.
       *
       * Anyhow, the following code makes this all work.  First, for the
       * special cases we move past their special argument(s).  Then, we
       * do normal command processing on whatever is left.  Barf-O-Rama.
       */
      discard = 0;            /* Characters discarded from the command. */
      arg1_len = 0;
      ecp->save_cmd = ecp->cp;
      if (ecp->cmd == &cmds[C_EDIT] || ecp->cmd == &cmds[C_EX] ||
          ecp->cmd == &cmds[C_NEXT] || ecp->cmd == &cmds[C_VISUAL_VI]) {
            /*
             * Move to the next non-whitespace character.  A '!'
             * immediately following the command is eaten as a
             * force flag.
             */
            if (ecp->clen > 0 && *ecp->cp == '!') {
                  ++ecp->cp;
                  --ecp->clen;
                  FL_SET(ecp->iflags, E_C_FORCE);

                  /* Reset, don't reparse. */
                  ecp->save_cmd = ecp->cp;
            }
            for (; ecp->clen > 0; --ecp->clen, ++ecp->cp)
                  if (!isblank(*ecp->cp))
                        break;
            /*
             * QUOTING NOTE:
             *
             * The historic implementation ignored all escape characters
             * so there was no way to put a space or newline into the +cmd
             * field.  We do a simplistic job of fixing it by moving to the
             * first whitespace character that isn't escaped.  The escaping
             * characters are stripped as no longer useful.
             */
            if (ecp->clen > 0 && *ecp->cp == '+') {
                  ++ecp->cp;
                  --ecp->clen;
                  for (arg1 = p = ecp->cp;
                      ecp->clen > 0; --ecp->clen, ++ecp->cp) {
                        ch = *ecp->cp;
                        if (IS_ESCAPE(sp, ecp, ch) &&
                            ecp->clen > 1) {
                              ++discard;
                              --ecp->clen;
                              ch = *++ecp->cp;
                        } else if (isblank(ch))
                              break;
                        *p++ = ch;
                  }
                  arg1_len = ecp->cp - arg1;

                  /* Reset, so the first argument isn't reparsed. */
                  ecp->save_cmd = ecp->cp;
            }
      } else if (ecp->cmd == &cmds[C_BANG] ||
          ecp->cmd == &cmds[C_GLOBAL] || ecp->cmd == &cmds[C_V]) {
            /*
             * QUOTING NOTE:
             *
             * We use backslashes to escape <newline> characters, although
             * this wasn't historic practice for the bang command.  It was
             * for the global and v commands, and it's common usage when
             * doing text insert during the command.  Escaping characters
             * are stripped as no longer useful.
             */
            for (p = ecp->cp; ecp->clen > 0; --ecp->clen, ++ecp->cp) {
                  ch = *ecp->cp;
                  if (ch == '\\' && ecp->clen > 1 && ecp->cp[1] == '\n') {
                        ++discard;
                        --ecp->clen;
                        ch = *++ecp->cp;

                        ++gp->if_lno;
                        ++ecp->if_lno;
                  } else if (ch == '\n')
                        break;
                  *p++ = ch;
            }
      } else if (ecp->cmd == &cmds[C_READ] || ecp->cmd == &cmds[C_WRITE]) {
            /*
             * For write commands, if the next character is a <blank>, and
             * the next non-blank character is a '!', it's a filter command
             * and we want to eat everything up to the <newline>.  For read
             * commands, if the next non-blank character is a '!', it's a
             * filter command and we want to eat everything up to the next
             * <newline>.  Otherwise, we're done.
             */
            for (tmp = 0; ecp->clen > 0; --ecp->clen, ++ecp->cp) {
                  ch = *ecp->cp;
                  if (isblank(ch))
                        tmp = 1;
                  else
                        break;
            }
            if (ecp->clen > 0 && ch == '!' &&
                (ecp->cmd == &cmds[C_READ] || tmp))
                  for (; ecp->clen > 0; --ecp->clen, ++ecp->cp)
                        if (ecp->cp[0] == '\n')
                              break;
      } else if (ecp->cmd == &cmds[C_SUBSTITUTE]) {
            /*
             * Move to the next non-whitespace character, we'll use it as
             * the delimiter.  If the character isn't an alphanumeric or
             * a '|', it's the delimiter, so parse it.  Otherwise, we're
             * into something like ":s g", so use the special s command.
             */
            for (; ecp->clen > 0; --ecp->clen, ++ecp->cp)
                  if (!isblank(ecp->cp[0]))
                        break;

            if (isalnum(ecp->cp[0]) || ecp->cp[0] == '|') {
                  ecp->rcmd = cmds[C_SUBSTITUTE];
                  ecp->rcmd.fn = ex_subagain;
                  ecp->cmd = &ecp->rcmd;
            } else if (ecp->clen > 0) {
                  /*
                   * QUOTING NOTE:
                   *
                   * Backslashes quote delimiter characters for RE's.
                   * The backslashes are NOT removed since they'll be
                   * used by the RE code.  Move to the third delimiter
                   * that's not escaped (or the end of the command).
                   */
                  delim = *ecp->cp;
                  ++ecp->cp;
                  --ecp->clen;
                  for (cnt = 2; ecp->clen > 0 &&
                      cnt != 0; --ecp->clen, ++ecp->cp)
                        if (ecp->cp[0] == '\\' &&
                            ecp->clen > 1) {
                              ++ecp->cp;
                              --ecp->clen;
                        } else if (ecp->cp[0] == delim)
                              --cnt;
            }
      }

      /*
       * Use normal quoting and termination rules to find the end of this
       * command.
       *
       * QUOTING NOTE:
       *
       * Historically, vi permitted ^V's to escape <newline>'s in the .exrc
       * file.  It was almost certainly a bug, but that's what bug-for-bug
       * compatibility means, Grasshopper.  Also, ^V's escape the command
       * delimiters.  Literal next quote characters in front of the newlines,
       * '|' characters or literal next characters are stripped as they're
       * no longer useful.
       */
      vi_address = ecp->clen != 0 && ecp->cp[0] != '\n';
      for (p = ecp->cp; ecp->clen > 0; --ecp->clen, ++ecp->cp) {
            ch = ecp->cp[0];
            if (IS_ESCAPE(sp, ecp, ch) && ecp->clen > 1) {
                  tmp = ecp->cp[1];
                  if (tmp == '\n' || tmp == '|') {
                        if (tmp == '\n') {
                              ++gp->if_lno;
                              ++ecp->if_lno;
                        }
                        ++discard;
                        --ecp->clen;
                        ++ecp->cp;
                        ch = tmp;
                  }
            } else if (ch == '\n' || ch == '|') {
                  if (ch == '\n')
                        F_SET(ecp, E_NEWLINE);
                  --ecp->clen;
                  break;
            }
            *p++ = ch;
      }

      /*
       * Save off the next command information, go back to the
       * original start of the command.
       */
      p = ecp->cp + 1;
      ecp->cp = ecp->save_cmd;
      ecp->save_cmd = p;
      ecp->save_cmdlen = ecp->clen;
      ecp->clen = ((ecp->save_cmd - ecp->cp) - 1) - discard;

      /*
       * QUOTING NOTE:
       *
       * The "set tags" command historically used a backslash, not the
       * user's literal next character, to escape whitespace.  Handle
       * it here instead of complicating the argv_exp3() code.  Note,
       * this isn't a particularly complex trap, and if backslashes were
       * legal in set commands, this would have to be much more complicated.
       */
      if (ecp->cmd == &cmds[C_SET])
            for (p = ecp->cp, len = ecp->clen; len > 0; --len, ++p)
                  if (*p == '\\')
                        *p = CH_LITERAL;

      /*
       * Set the default addresses.  It's an error to specify an address for
       * a command that doesn't take them.  If two addresses are specified
       * for a command that only takes one, lose the first one.  Two special
       * cases here, some commands take 0 or 2 addresses.  For most of them
       * (the E_ADDR2_ALL flag), 0 defaults to the entire file.  For one
       * (the `!' command, the E_ADDR2_NONE flag), 0 defaults to no lines.
       *
       * Also, if the file is empty, some commands want to use an address of
       * 0, i.e. the entire file is 0 to 0, and the default first address is
       * 0.  Otherwise, an entire file is 1 to N and the default line is 1.
       * Note, we also add the E_ADDR_ZERO flag to the command flags, for the
       * case where the 0 address is only valid if it's a default address.
       *
       * Also, set a flag if we set the default addresses.  Some commands
       * (ex: z) care if the user specified an address or if we just used
       * the current cursor.
       */
      switch (F_ISSET(ecp, E_ADDR1 | E_ADDR2 | E_ADDR2_ALL | E_ADDR2_NONE)) {
      case E_ADDR1:                       /* One address: */
            switch (ecp->addrcnt) {
            case 0:                       /* Default cursor/empty file. */
                  ecp->addrcnt = 1;
                  F_SET(ecp, E_ADDR_DEF);
                  if (F_ISSET(ecp, E_ADDR_ZERODEF)) {
                        if (db_last(sp, &lno))
                              goto err;
                        if (lno == 0) {
                              ecp->addr1.lno = 0;
                              F_SET(ecp, E_ADDR_ZERO);
                        } else
                              ecp->addr1.lno = sp->lno;
                  } else
                        ecp->addr1.lno = sp->lno;
                  ecp->addr1.cno = sp->cno;
                  break;
            case 1:
                  break;
            case 2:                       /* Lose the first address. */
                  ecp->addrcnt = 1;
                  ecp->addr1 = ecp->addr2;
            }
            break;
      case E_ADDR2_NONE:                  /* Zero/two addresses: */
            if (ecp->addrcnt == 0)        /* Default to nothing. */
                  break;
            goto two_addr;
      case E_ADDR2_ALL:             /* Zero/two addresses: */
            if (ecp->addrcnt == 0) {      /* Default entire/empty file. */
                  F_SET(ecp, E_ADDR_DEF);
                  ecp->addrcnt = 2;
                  if (sp->ep == NULL)
                        ecp->addr2.lno = 0;
                  else if (db_last(sp, &ecp->addr2.lno))
                        goto err;
                  if (F_ISSET(ecp, E_ADDR_ZERODEF) &&
                      ecp->addr2.lno == 0) {
                        ecp->addr1.lno = 0;
                        F_SET(ecp, E_ADDR_ZERO);
                  } else
                        ecp->addr1.lno = 1;
                  ecp->addr1.cno = ecp->addr2.cno = 0;
                  F_SET(ecp, E_ADDR2_ALL);
                  break;
            }
            /* FALLTHROUGH */
      case E_ADDR2:                       /* Two addresses: */
two_addr:   switch (ecp->addrcnt) {
            case 0:                       /* Default cursor/empty file. */
                  ecp->addrcnt = 2;
                  F_SET(ecp, E_ADDR_DEF);
                  if (sp->lno == 1 &&
                      F_ISSET(ecp, E_ADDR_ZERODEF)) {
                        if (db_last(sp, &lno))
                              goto err;
                        if (lno == 0) {
                              ecp->addr1.lno = ecp->addr2.lno = 0;
                              F_SET(ecp, E_ADDR_ZERO);
                        } else
                              ecp->addr1.lno =
                                  ecp->addr2.lno = sp->lno;
                  } else
                        ecp->addr1.lno = ecp->addr2.lno = sp->lno;
                  ecp->addr1.cno = ecp->addr2.cno = sp->cno;
                  break;
            case 1:                       /* Default to first address. */
                  ecp->addrcnt = 2;
                  ecp->addr2 = ecp->addr1;
                  break;
            case 2:
                  break;
            }
            break;
      default:
            if (ecp->addrcnt)       /* Error. */
                  goto usage;
      }

      /*
       * !!!
       * The ^D scroll command historically scrolled the value of the scroll
       * option or to EOF.  It was an error if the cursor was already at EOF.
       * (Leading addresses were permitted, but were then ignored.)
       */
      if (ecp->cmd == &cmds[C_SCROLL]) {
            ecp->addrcnt = 2;
            ecp->addr1.lno = sp->lno + 1;
            ecp->addr2.lno = sp->lno + O_VAL(sp, O_SCROLL);
            ecp->addr1.cno = ecp->addr2.cno = sp->cno;
            if (db_last(sp, &lno))
                  goto err;
            if (lno != 0 && lno > sp->lno && ecp->addr2.lno > lno)
                  ecp->addr2.lno = lno;
      }

      ecp->flagoff = 0;
      for (p = ecp->cmd->syntax; *p != '\0'; ++p) {
            /*
             * The force flag is sensitive to leading whitespace, i.e.
             * "next !" is different from "next!".  Handle it before
             * skipping leading <blank>s.
             */
            if (*p == '!') {
                  if (ecp->clen > 0 && *ecp->cp == '!') {
                        ++ecp->cp;
                        --ecp->clen;
                        FL_SET(ecp->iflags, E_C_FORCE);
                  }
                  continue;
            }

            /* Skip leading <blank>s. */
            for (; ecp->clen > 0; --ecp->clen, ++ecp->cp)
                  if (!isblank(*ecp->cp))
                        break;
            if (ecp->clen == 0)
                  break;

            switch (*p) {
            case '1':                     /* +, -, #, l, p */
                  /*
                   * !!!
                   * Historically, some flags were ignored depending
                   * on where they occurred in the command line.  For
                   * example, in the command, ":3+++p--#", historic vi
                   * acted on the '#' flag, but ignored the '-' flags.
                   * It's unambiguous what the flags mean, so we just
                   * handle them regardless of the stupidity of their
                   * location.
                   */
                  for (; ecp->clen; --ecp->clen, ++ecp->cp)
                        switch (*ecp->cp) {
                        case '+':
                              ++ecp->flagoff;
                              break;
                        case '-':
                        case '^':
                              --ecp->flagoff;
                              break;
                        case '#':
                              F_CLR(ecp, E_OPTNUM);
                              FL_SET(ecp->iflags, E_C_HASH);
                              exp->fdef |= E_C_HASH;
                              break;
                        case 'l':
                              FL_SET(ecp->iflags, E_C_LIST);
                              exp->fdef |= E_C_LIST;
                              break;
                        case 'p':
                              FL_SET(ecp->iflags, E_C_PRINT);
                              exp->fdef |= E_C_PRINT;
                              break;
                        default:
                              goto end_case1;
                        }
end_case1:        break;
            case '2':                     /* -, ., +, ^ */
            case '3':                     /* -, ., +, ^, = */
                  for (; ecp->clen; --ecp->clen, ++ecp->cp)
                        switch (*ecp->cp) {
                        case '-':
                              FL_SET(ecp->iflags, E_C_DASH);
                              break;
                        case '.':
                              FL_SET(ecp->iflags, E_C_DOT);
                              break;
                        case '+':
                              FL_SET(ecp->iflags, E_C_PLUS);
                              break;
                        case '^':
                              FL_SET(ecp->iflags, E_C_CARAT);
                              break;
                        case '=':
                              if (*p == '3') {
                                    FL_SET(ecp->iflags, E_C_EQUAL);
                                    break;
                              }
                              /* FALLTHROUGH */
                        default:
                              goto end_case23;
                        }
end_case23:       break;
            case 'b':                     /* buffer */
                  /*
                   * !!!
                   * Historically, "d #" was a delete with a flag, not a
                   * delete into the '#' buffer.  If the current command
                   * permits a flag, don't use one as a buffer.  However,
                   * the 'l' and 'p' flags were legal buffer names in the
                   * historic ex, and were used as buffers, not flags.
                   */
                  if ((ecp->cp[0] == '+' || ecp->cp[0] == '-' ||
                      ecp->cp[0] == '^' || ecp->cp[0] == '#') &&
                      strchr(p, '1') != NULL)
                        break;
                  /*
                   * !!!
                   * Digits can't be buffer names in ex commands, or the
                   * command "d2" would be a delete into buffer '2', and
                   * not a two-line deletion.
                   */
                  if (!isdigit(ecp->cp[0])) {
                        ecp->buffer = *ecp->cp;
                        ++ecp->cp;
                        --ecp->clen;
                        FL_SET(ecp->iflags, E_C_BUFFER);
                  }
                  break;
            case 'c':                     /* count [01+a] */
                  ++p;
                  /* Validate any signed value. */
                  if (!isdigit(*ecp->cp) && (*p != '+' ||
                      (*ecp->cp != '+' && *ecp->cp != '-')))
                        break;
                  /* If a signed value, set appropriate flags. */
                  if (*ecp->cp == '-')
                        FL_SET(ecp->iflags, E_C_COUNT_NEG);
                  else if (*ecp->cp == '+')
                        FL_SET(ecp->iflags, E_C_COUNT_POS);
                  if ((nret =
                      nget_slong(&ltmp, ecp->cp, &t, 10)) != NUM_OK) {
                        ex_badaddr(sp, NULL, A_NOTSET, nret);
                        goto err;
                  }
                  if (ltmp == 0 && *p != '0') {
                        msgq(sp, M_ERR, "083|Count may not be zero");
                        goto err;
                  }
                  ecp->clen -= (t - ecp->cp);
                  ecp->cp = t;

                  /*
                   * Counts as address offsets occur in commands taking
                   * two addresses.  Historic vi practice was to use
                   * the count as an offset from the *second* address.
                   *
                   * Set a count flag; some underlying commands (see
                   * join) do different things with counts than with
                   * line addresses.
                   */
                  if (*p == 'a') {
                        ecp->addr1 = ecp->addr2;
                        ecp->addr2.lno = ecp->addr1.lno + ltmp - 1;
                  } else
                        ecp->count = ltmp;
                  FL_SET(ecp->iflags, E_C_COUNT);
                  break;
            case 'f':                     /* file */
                  if (argv_exp2(sp, ecp, ecp->cp, ecp->clen))
                        goto err;
                  goto arg_cnt_chk;
            case 'l':                     /* line */
                  /*
                   * Get a line specification.
                   *
                   * If the line was a search expression, we may have
                   * changed state during the call, and we're now
                   * searching the file.  Push ourselves onto the state
                   * stack.
                   */
                  if (ex_line(sp, ecp, &cur, &isaddr, &tmp))
                        goto rfail;
                  if (tmp)
                        goto err;

                  /* Line specifications are always required. */
                  if (!isaddr) {
                        msgq_str(sp, M_ERR, ecp->cp,
                             "084|%s: bad line specification");
                        goto err;
                  }
                  /*
                   * The target line should exist for these commands,
                   * but 0 is legal for them as well.
                   */
                  if (cur.lno != 0 && !db_exist(sp, cur.lno)) {
                        ex_badaddr(sp, NULL, A_EOF, NUM_OK);
                        goto err;
                  }
                  ecp->lineno = cur.lno;
                  break;
            case 'S':                     /* string, file exp. */
                  if (ecp->clen != 0) {
                        if (argv_exp1(sp, ecp, ecp->cp,
                            ecp->clen, ecp->cmd == &cmds[C_BANG]))
                              goto err;
                        goto addr_verify;
                  }
                  /* FALLTHROUGH */
            case 's':                     /* string */
                  if (argv_exp0(sp, ecp, ecp->cp, ecp->clen))
                        goto err;
                  goto addr_verify;
            case 'W':                     /* word string */
                  /*
                   * QUOTING NOTE:
                   *
                   * Literal next characters escape the following
                   * character.  Quoting characters are stripped here
                   * since they are no longer useful.
                   *
                   * First there was the word.
                   */
                  for (p = t = ecp->cp;
                      ecp->clen > 0; --ecp->clen, ++ecp->cp) {
                        ch = *ecp->cp;
                        if (IS_ESCAPE(sp,
                            ecp, ch) && ecp->clen > 1) {
                              --ecp->clen;
                              *p++ = *++ecp->cp;
                        } else if (isblank(ch)) {
                              ++ecp->cp;
                              --ecp->clen;
                              break;
                        } else
                              *p++ = ch;
                  }
                  if (argv_exp0(sp, ecp, t, p - t))
                        goto err;

                  /* Delete intervening whitespace. */
                  for (; ecp->clen > 0;
                      --ecp->clen, ++ecp->cp) {
                        ch = *ecp->cp;
                        if (!isblank(ch))
                              break;
                  }
                  if (ecp->clen == 0)
                        goto usage;

                  /* Followed by the string. */
                  for (p = t = ecp->cp; ecp->clen > 0;
                      --ecp->clen, ++ecp->cp, ++p) {
                        ch = *ecp->cp;
                        if (IS_ESCAPE(sp,
                            ecp, ch) && ecp->clen > 1) {
                              --ecp->clen;
                              *p = *++ecp->cp;
                        } else
                              *p = ch;
                  }
                  if (argv_exp0(sp, ecp, t, p - t))
                        goto err;
                  goto addr_verify;
            case 'w':                     /* word */
                  if (argv_exp3(sp, ecp, ecp->cp, ecp->clen))
                        goto err;
arg_cnt_chk:            if (*++p != 'N') {            /* N */
                        /*
                         * If a number is specified, must either be
                         * 0 or that number, if optional, and that
                         * number, if required.
                         */
                        tmp = *p - '0';
                        if ((*++p != 'o' || exp->argsoff != 0) &&
                            exp->argsoff != tmp)
                              goto usage;
                  }
                  goto addr_verify;
            default:
                  msgq(sp, M_ERR,
                      "085|Internal syntax table error (%s: %s)",
                      ecp->cmd->name, KEY_NAME(sp, *p));
            }
      }

      /* Skip trailing whitespace. */
      for (; ecp->clen > 0; --ecp->clen) {
            ch = *ecp->cp++;
            if (!isblank(ch))
                  break;
      }

      /*
       * There shouldn't be anything left, and no more required fields,
       * i.e neither 'l' or 'r' in the syntax string.
       */
      if (ecp->clen != 0 || strpbrk(p, "lr")) {
usage:            msgq(sp, M_ERR, "086|Usage: %s", ecp->cmd->usage);
            goto err;
      }

      /*
       * Verify that the addresses are legal.  Check the addresses here,
       * because this is a place where all ex addresses pass through.
       * (They don't all pass through ex_line(), for instance.)  We're
       * assuming that any non-existent line doesn't exist because it's
       * past the end-of-file.  That's a pretty good guess.
       *
       * If it's a "default vi command", an address of zero is okay.
       */
addr_verify:
      switch (ecp->addrcnt) {
      case 2:
            /*
             * Historic ex/vi permitted commands with counts to go past
             * EOF.  So, for example, if the file only had 5 lines, the
             * ex command "1,6>" would fail, but the command ">300"
             * would succeed.  Since we don't want to have to make all
             * of the underlying commands handle random line numbers,
             * fix it here.
             */
            if (ecp->addr2.lno == 0) {
                  if (!F_ISSET(ecp, E_ADDR_ZERO) &&
                      (F_ISSET(sp, SC_EX) ||
                      !F_ISSET(ecp, E_USELASTCMD))) {
                        ex_badaddr(sp, ecp->cmd, A_ZERO, NUM_OK);
                        goto err;
                  }
            } else if (!db_exist(sp, ecp->addr2.lno))
                  if (FL_ISSET(ecp->iflags, E_C_COUNT)) {
                        if (db_last(sp, &lno))
                              goto err;
                        ecp->addr2.lno = lno;
                  } else {
                        ex_badaddr(sp, NULL, A_EOF, NUM_OK);
                        goto err;
                  }
            /* FALLTHROUGH */
      case 1:
            if (ecp->addr1.lno == 0) {
                  if (!F_ISSET(ecp, E_ADDR_ZERO) &&
                      (F_ISSET(sp, SC_EX) ||
                      !F_ISSET(ecp, E_USELASTCMD))) {
                        ex_badaddr(sp, ecp->cmd, A_ZERO, NUM_OK);
                        goto err;
                  }
            } else if (!db_exist(sp, ecp->addr1.lno)) {
                  ex_badaddr(sp, NULL, A_EOF, NUM_OK);
                  goto err;
            }
            break;
      }

      /*
       * If doing a default command and there's nothing left on the line,
       * vi just moves to the line.  For example, ":3" and ":'a,'b" just
       * move to line 3 and line 'b, respectively, but ":3|" prints line 3.
       *
       * !!!
       * In addition, IF THE LINE CHANGES, move to the first nonblank of
       * the line.
       *
       * !!!
       * This is done before the absolute mark gets set; historically,
       * "/a/,/b/" did NOT set vi's absolute mark, but "/a/,/b/d" did.
       */
      if ((F_ISSET(sp, SC_VI) || F_ISSET(ecp, E_NOPRDEF)) &&
          F_ISSET(ecp, E_USELASTCMD) && vi_address == 0) {
            switch (ecp->addrcnt) {
            case 2:
                  if (sp->lno !=
                      (ecp->addr2.lno ? ecp->addr2.lno : 1)) {
                        sp->lno =
                            ecp->addr2.lno ? ecp->addr2.lno : 1;
                        sp->cno = 0;
                        (void)nonblank(sp, sp->lno, &sp->cno);
                  }
                  break;
            case 1:
                  if (sp->lno !=
                      (ecp->addr1.lno ? ecp->addr1.lno : 1)) {
                        sp->lno =
                            ecp->addr1.lno ? ecp->addr1.lno : 1;
                        sp->cno = 0;
                        (void)nonblank(sp, sp->lno, &sp->cno);
                  }
                  break;
            }
            ecp->cp = ecp->save_cmd;
            ecp->clen = ecp->save_cmdlen;
            goto loop;
      }

      /*
       * Set the absolute mark -- we have to set it for vi here, in case
       * it's a compound command, e.g. ":5p|6" should set the absolute
       * mark for vi.
       */
      if (F_ISSET(ecp, E_ABSMARK)) {
            cur.lno = sp->lno;
            cur.cno = sp->cno;
            F_CLR(ecp, E_ABSMARK);
            if (mark_set(sp, ABSMARK1, &cur, 1))
                  goto err;
      }

#if defined(DEBUG) && defined(COMLOG)
      ex_comlog(sp, ecp);
#endif
      /* Increment the command count if not called from vi. */
      if (F_ISSET(sp, SC_EX))
            ++sp->ccnt;

      /*
       * If file state available, and not doing a global command,
       * log the start of an action.
       */
      if (sp->ep != NULL && !F_ISSET(sp, SC_EX_GLOBAL))
            (void)log_cursor(sp);

      /*
       * !!!
       * There are two special commands for the purposes of this code: the
       * default command (<carriage-return>) or the scrolling commands (^D
       * and <EOF>) as the first non-<blank> characters  in the line.
       *
       * If this is the first command in the command line, we received the
       * command from the ex command loop and we're talking to a tty, and
       * and there's nothing else on the command line, and it's one of the
       * special commands, we move back up to the previous line, and erase
       * the prompt character with the output.  Since ex runs in canonical
       * mode, we don't have to do anything else, a <newline> has already
       * been echoed by the tty driver.  It's OK if vi calls us -- we won't
       * be in ex mode so we'll do nothing.
       */
      if (F_ISSET(ecp, E_NRSEP)) {
            if (sp->ep != NULL &&
                F_ISSET(sp, SC_EX) && !F_ISSET(gp, G_SCRIPTED) &&
                (F_ISSET(ecp, E_USELASTCMD) || ecp->cmd == &cmds[C_SCROLL]))
                  gp->scr_ex_adjust(sp, EX_TERM_SCROLL);
            F_CLR(ecp, E_NRSEP);
      }

      /*
       * Call the underlying function for the ex command.
       *
       * XXX
       * Interrupts behave like errors, for now.
       */
      if (ecp->cmd->fn(sp, ecp) || INTERRUPTED(sp)) {
            if (F_ISSET(gp, G_SCRIPTED))
                  F_SET(sp, SC_EXIT_FORCE);
            goto err;
      }

#ifdef DEBUG
      /* Make sure no function left global temporary space locked. */
      if (F_ISSET(gp, G_TMP_INUSE)) {
            F_CLR(gp, G_TMP_INUSE);
            msgq(sp, M_ERR, "087|%s: temporary buffer not released",
                ecp->cmd->name);
      }
#endif
      /*
       * Ex displayed the number of lines modified immediately after each
       * command, so the command "1,10d|1,10d" would display:
       *
       *    10 lines deleted
       *    10 lines deleted
       *    <autoprint line>
       *
       * Executing ex commands from vi only reported the final modified
       * lines message -- that's wrong enough that we don't match it.
       */
      if (F_ISSET(sp, SC_EX))
            mod_rpt(sp);

      /*
       * Integrate any offset parsed by the underlying command, and make
       * sure the referenced line exists.
       *
       * XXX
       * May not match historic practice (which I've never been able to
       * completely figure out.)  For example, the '=' command from vi
       * mode often got the offset wrong, and complained it was too large,
       * but didn't seem to have a problem with the cursor.  If anyone
       * complains, ask them how it's supposed to work, they might know.
       */
      if (sp->ep != NULL && ecp->flagoff) {
            if (ecp->flagoff < 0) {
                  if (sp->lno <= -ecp->flagoff) {
                        msgq(sp, M_ERR,
                            "088|Flag offset to before line 1");
                        goto err;
                  }
            } else {
                  if (!NPFITS(MAX_REC_NUMBER, sp->lno, ecp->flagoff)) {
                        ex_badaddr(sp, NULL, A_NOTSET, NUM_OVER);
                        goto err;
                  }
                  if (!db_exist(sp, sp->lno + ecp->flagoff)) {
                        msgq(sp, M_ERR,
                            "089|Flag offset past end-of-file");
                        goto err;
                  }
            }
            sp->lno += ecp->flagoff;
      }

      /*
       * If the command executed successfully, we may want to display a line
       * based on the autoprint option or an explicit print flag.  (Make sure
       * that there's a line to display.)  Also, the autoprint edit option is
       * turned off for the duration of global commands.
       */
      if (F_ISSET(sp, SC_EX) && sp->ep != NULL && sp->lno != 0) {
            /*
             * The print commands have already handled the `print' flags.
             * If so, clear them.
             */
            if (FL_ISSET(ecp->iflags, E_CLRFLAG))
                  FL_CLR(ecp->iflags, E_C_HASH | E_C_LIST | E_C_PRINT);

            /* If hash set only because of the number option, discard it. */
            if (F_ISSET(ecp, E_OPTNUM))
                  FL_CLR(ecp->iflags, E_C_HASH);

            /*
             * If there was an explicit flag to display the new cursor line,
             * or autoprint is set and a change was made, display the line.
             * If any print flags were set use them, else default to print.
             */
            LF_INIT(FL_ISSET(ecp->iflags, E_C_HASH | E_C_LIST | E_C_PRINT));
            if (!LF_ISSET(E_C_HASH | E_C_LIST | E_C_PRINT | E_NOAUTO) &&
                !F_ISSET(sp, SC_EX_GLOBAL) &&
                O_ISSET(sp, O_AUTOPRINT) && F_ISSET(ecp, E_AUTOPRINT))
                  LF_INIT(E_C_PRINT);

            if (LF_ISSET(E_C_HASH | E_C_LIST | E_C_PRINT)) {
                  cur.lno = sp->lno;
                  cur.cno = 0;
                  (void)ex_print(sp, ecp, &cur, &cur, flags);
            }
      }

      /*
       * If the command had an associated "+cmd", it has to be executed
       * before we finish executing any more of this ex command.  For
       * example, consider a .exrc file that contains the following lines:
       *
       *    :set all
       *    :edit +25 file.c|s/abc/ABC/|1
       *    :3,5 print
       *
       * This can happen more than once -- the historic vi simply hung or
       * dropped core, of course.  Prepend the + command back into the
       * current command and continue.  We may have to add an additional
       * <literal next> character.  We know that it will fit because we
       * discarded at least one space and the + character.
       */
      if (arg1_len != 0) {
            /*
             * If the last character of the + command was a <literal next>
             * character, it would be treated differently because of the
             * append.  Quote it, if necessary.
             */
            if (IS_ESCAPE(sp, ecp, arg1[arg1_len - 1])) {
                  *--ecp->save_cmd = CH_LITERAL;
                  ++ecp->save_cmdlen;
            }

            ecp->save_cmd -= arg1_len;
            ecp->save_cmdlen += arg1_len;
            memcpy(ecp->save_cmd, arg1, arg1_len);

            /*
             * Any commands executed from a +cmd are executed starting at
             * the first column of the last line of the file -- NOT the
             * first nonblank.)  The main file startup code doesn't know
             * that a +cmd was set, however, so it may have put us at the
             * top of the file.  (Note, this is safe because we must have
             * switched files to get here.)
             */
            F_SET(ecp, E_MOVETOEND);
      }

      /* Update the current command. */
      ecp->cp = ecp->save_cmd;
      ecp->clen = ecp->save_cmdlen;

      /*
       * !!!
       * If we've changed screens or underlying files, any pending global or
       * v command, or @ buffer that has associated addresses, has to be
       * discarded.  This is historic practice for globals, and necessary for
       * @ buffers that had associated addresses.
       *
       * Otherwise, if we've changed underlying files, it's not a problem,
       * we continue with the rest of the ex command(s), operating on the
       * new file.  However, if we switch screens (either by exiting or by
       * an explicit command), we have no way of knowing where to put output
       * messages, and, since we don't control screens here, we could screw
       * up the upper layers, (e.g. we could exit/reenter a screen multiple
       * times).  So, return and continue after we've got a new screen.
       */
      if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE | SC_FSWITCH | SC_SSWITCH)) {
            at_found = gv_found = 0;
            for (ecp = sp->gp->ecq.lh_first;
                ecp != NULL; ecp = ecp->q.le_next)
                  switch (ecp->agv_flags) {
                  case 0:
                  case AGV_AT_NORANGE:
                        break;
                  case AGV_AT:
                        if (!at_found) {
                              at_found = 1;
                              msgq(sp, M_ERR,
            "090|@ with range running when the file/screen changed");
                        }
                        break;
                  case AGV_GLOBAL:
                  case AGV_V:
                        if (!gv_found) {
                              gv_found = 1;
                              msgq(sp, M_ERR,
            "091|Global/v command running when the file/screen changed");
                        }
                        break;
                  default:
                        abort();
                  }
            if (at_found || gv_found)
                  goto discard;
            if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE | SC_SSWITCH))
                  goto rsuccess;
      }

      goto loop;
      /* NOTREACHED */

err:  /*
       * On command failure, we discard keys and pending commands remaining,
       * as well as any keys that were mapped and waiting.  The save_cmdlen
       * test is not necessarily correct.  If we fail early enough we don't
       * know if the entire string was a single command or not.  Guess, as
       * it's useful to know if commands other than the current one are being
       * discarded.
       */
      if (ecp->save_cmdlen == 0)
            for (; ecp->clen; --ecp->clen) {
                  ch = *ecp->cp++;
                  if (IS_ESCAPE(sp, ecp, ch) && ecp->clen > 1) {
                        --ecp->clen;
                        ++ecp->cp;
                  } else if (ch == '\n' || ch == '|') {
                        if (ecp->clen > 1)
                              ecp->save_cmdlen = 1;
                        break;
                  }
            }
      if (ecp->save_cmdlen != 0 || gp->ecq.lh_first != &gp->excmd) {
discard:    msgq(sp, M_BERR,
                "092|Ex command failed: pending commands discarded");
            ex_discard(sp);
      }
      if (v_event_flush(sp, CH_MAPPED))
            msgq(sp, M_BERR,
                "093|Ex command failed: mapped keys discarded");

rfail:      tmp = 1;
      if (0)
rsuccess:   tmp = 0;

      /* Turn off any file name error information. */
      gp->if_name = NULL;

      /* Turn off the global bit. */
      F_CLR(sp, SC_EX_GLOBAL);

      return (tmp);
}

/*
 * ex_range --
 *    Get a line range for ex commands, or perform a vi ex address search.
 *
 * PUBLIC: int ex_range __P((SCR *, EXCMD *, int *));
 */
int
ex_range(sp, ecp, errp)
      SCR *sp;
      EXCMD *ecp;
      int *errp;
{
      enum { ADDR_FOUND, ADDR_NEED, ADDR_NONE } addr;
      GS *gp;
      EX_PRIVATE *exp;
      MARK m;
      int isaddr;

      *errp = 0;

      /*
       * Parse comma or semi-colon delimited line specs.
       *
       * Semi-colon delimiters update the current address to be the last
       * address.  For example, the command
       *
       *    :3;/pattern/ecp->cp
       *
       * will search for pattern from line 3.  In addition, if ecp->cp
       * is not a valid command, the current line will be left at 3, not
       * at the original address.
       *
       * Extra addresses are discarded, starting with the first.
       *
       * !!!
       * If any addresses are missing, they default to the current line.
       * This was historically true for both leading and trailing comma
       * delimited addresses as well as for trailing semicolon delimited
       * addresses.  For consistency, we make it true for leading semicolon
       * addresses as well.
       */
      gp = sp->gp;
      exp = EXP(sp);
      for (addr = ADDR_NONE, ecp->addrcnt = 0; ecp->clen > 0;)
            switch (*ecp->cp) {
            case '%':         /* Entire file. */
                  /* Vi ex address searches didn't permit % signs. */
                  if (F_ISSET(ecp, E_VISEARCH))
                        goto ret;

                  /* It's an error if the file is empty. */
                  if (sp->ep == NULL) {
                        ex_badaddr(sp, NULL, A_EMPTY, NUM_OK);
                        *errp = 1;
                        return (0);
                  }
                  /*
                   * !!!
                   * A percent character addresses all of the lines in
                   * the file.  Historically, it couldn't be followed by
                   * any other address.  We do it as a text substitution
                   * for simplicity.  POSIX 1003.2 is expected to follow
                   * this practice.
                   *
                   * If it's an empty file, the first line is 0, not 1.
                   */
                  if (addr == ADDR_FOUND) {
                        ex_badaddr(sp, NULL, A_COMBO, NUM_OK);
                        *errp = 1;
                        return (0);
                  }
                  if (db_last(sp, &ecp->addr2.lno))
                        return (1);
                  ecp->addr1.lno = ecp->addr2.lno == 0 ? 0 : 1;
                  ecp->addr1.cno = ecp->addr2.cno = 0;
                  ecp->addrcnt = 2;
                  addr = ADDR_FOUND;
                  ++ecp->cp;
                  --ecp->clen;
                  break;
            case ',':               /* Comma delimiter. */
                  /* Vi ex address searches didn't permit commas. */
                  if (F_ISSET(ecp, E_VISEARCH))
                        goto ret;
                  /* FALLTHROUGH */
            case ';':               /* Semi-colon delimiter. */
                  if (sp->ep == NULL) {
                        ex_badaddr(sp, NULL, A_EMPTY, NUM_OK);
                        *errp = 1;
                        return (0);
                  }
                  if (addr != ADDR_FOUND)
                        switch (ecp->addrcnt) {
                        case 0:
                              ecp->addr1.lno = sp->lno;
                              ecp->addr1.cno = sp->cno;
                              ecp->addrcnt = 1;
                              break;
                        case 2:
                              ecp->addr1 = ecp->addr2;
                              /* FALLTHROUGH */
                        case 1:
                              ecp->addr2.lno = sp->lno;
                              ecp->addr2.cno = sp->cno;
                              ecp->addrcnt = 2;
                              break;
                        }
                  if (*ecp->cp == ';')
                        switch (ecp->addrcnt) {
                        case 0:
                              abort();
                              /* NOTREACHED */
                        case 1:
                              sp->lno = ecp->addr1.lno;
                              sp->cno = ecp->addr1.cno;
                              break;
                        case 2:
                              sp->lno = ecp->addr2.lno;
                              sp->cno = ecp->addr2.cno;
                              break;
                        }
                  addr = ADDR_NEED;
                  /* FALLTHROUGH */
            case ' ':         /* Whitespace. */
            case '\t':        /* Whitespace. */
                  ++ecp->cp;
                  --ecp->clen;
                  break;
            default:
                  /* Get a line specification. */
                  if (ex_line(sp, ecp, &m, &isaddr, errp))
                        return (1);
                  if (*errp)
                        return (0);
                  if (!isaddr)
                        goto ret;
                  if (addr == ADDR_FOUND) {
                        ex_badaddr(sp, NULL, A_COMBO, NUM_OK);
                        *errp = 1;
                        return (0);
                  }
                  switch (ecp->addrcnt) {
                  case 0:
                        ecp->addr1 = m;
                        ecp->addrcnt = 1;
                        break;
                  case 1:
                        ecp->addr2 = m;
                        ecp->addrcnt = 2;
                        break;
                  case 2:
                        ecp->addr1 = ecp->addr2;
                        ecp->addr2 = m;
                        break;
                  }
                  addr = ADDR_FOUND;
                  break;
            }

      /*
       * !!!
       * Vi ex address searches are indifferent to order or trailing
       * semi-colons.
       */
ret:  if (F_ISSET(ecp, E_VISEARCH))
            return (0);

      if (addr == ADDR_NEED)
            switch (ecp->addrcnt) {
            case 0:
                  ecp->addr1.lno = sp->lno;
                  ecp->addr1.cno = sp->cno;
                  ecp->addrcnt = 1;
                  break;
            case 2:
                  ecp->addr1 = ecp->addr2;
                  /* FALLTHROUGH */
            case 1:
                  ecp->addr2.lno = sp->lno;
                  ecp->addr2.cno = sp->cno;
                  ecp->addrcnt = 2;
                  break;
            }

      if (ecp->addrcnt == 2 && ecp->addr2.lno < ecp->addr1.lno) {
            msgq(sp, M_ERR,
                "094|The second address is smaller than the first");
            *errp = 1;
      }
      return (0);
}

/*
 * ex_line --
 *    Get a single line address specifier.
 *
 * The way the "previous context" mark worked was that any "non-relative"
 * motion set it.  While ex/vi wasn't totally consistent about this, ANY
 * numeric address, search pattern, '$', or mark reference in an address
 * was considered non-relative, and set the value.  Which should explain
 * why we're hacking marks down here.  The problem was that the mark was
 * only set if the command was called, i.e. we have to set a flag and test
 * it later.
 *
 * XXX
 * This is probably still not exactly historic practice, although I think
 * it's fairly close.
 */
static int
ex_line(sp, ecp, mp, isaddrp, errp)
      SCR *sp;
      EXCMD *ecp;
      MARK *mp;
      int *isaddrp, *errp;
{
      enum nresult nret;
      EX_PRIVATE *exp;
      GS *gp;
      long total, val;
      int isneg;
      int (*sf) __P((SCR *, MARK *, MARK *, char *, size_t, char **, u_int));
      char *endp;

      gp = sp->gp;
      exp = EXP(sp);

      *isaddrp = *errp = 0;
      F_CLR(ecp, E_DELTA);

      /* No addresses permitted until a file has been read in. */
      if (sp->ep == NULL && strchr("$0123456789'\\/?.+-^", *ecp->cp)) {
            ex_badaddr(sp, NULL, A_EMPTY, NUM_OK);
            *errp = 1;
            return (0);
      }

      switch (*ecp->cp) {
      case '$':                     /* Last line in the file. */
            *isaddrp = 1;
            F_SET(ecp, E_ABSMARK);

            mp->cno = 0;
            if (db_last(sp, &mp->lno))
                  return (1);
            ++ecp->cp;
            --ecp->clen;
            break;                        /* Absolute line number. */
      case '0': case '1': case '2': case '3': case '4':
      case '5': case '6': case '7': case '8': case '9':
            *isaddrp = 1;
            F_SET(ecp, E_ABSMARK);

            if ((nret = nget_slong(&val, ecp->cp, &endp, 10)) != NUM_OK) {
                  ex_badaddr(sp, NULL, A_NOTSET, nret);
                  *errp = 1;
                  return (0);
            }
            if (!NPFITS(MAX_REC_NUMBER, 0, val)) {
                  ex_badaddr(sp, NULL, A_NOTSET, NUM_OVER);
                  *errp = 1;
                  return (0);
            }
            mp->lno = val;
            mp->cno = 0;
            ecp->clen -= (endp - ecp->cp);
            ecp->cp = endp;
            break;
      case '\'':                    /* Use a mark. */
            *isaddrp = 1;
            F_SET(ecp, E_ABSMARK);

            if (ecp->clen == 1) {
                  msgq(sp, M_ERR, "095|No mark name supplied");
                  *errp = 1;
                  return (0);
            }
            if (mark_get(sp, ecp->cp[1], mp, M_ERR)) {
                  *errp = 1;
                  return (0);
            }
            ecp->cp += 2;
            ecp->clen -= 2;
            break;
      case '\\':                    /* Search: forward/backward. */
            /*
             * !!!
             * I can't find any difference between // and \/ or between
             * ?? and \?.  Mark Horton doesn't remember there being any
             * difference.  C'est la vie.
             */
            if (ecp->clen < 2 ||
                ecp->cp[1] != '/' && ecp->cp[1] != '?') {
                  msgq(sp, M_ERR, "096|\\ not followed by / or ?");
                  *errp = 1;
                  return (0);
            }
            ++ecp->cp;
            --ecp->clen;
            sf = ecp->cp[0] == '/' ? f_search : b_search;
            goto search;
      case '/':                     /* Search forward. */
            sf = f_search;
            goto search;
      case '?':                     /* Search backward. */
            sf = b_search;

search:           mp->lno = sp->lno;
            mp->cno = sp->cno;
            if (sf(sp, mp, mp, ecp->cp, ecp->clen, &endp,
                SEARCH_MSG | SEARCH_PARSE | SEARCH_SET |
                (F_ISSET(ecp, E_SEARCH_WMSG) ? SEARCH_WMSG : 0))) {
                  *errp = 1;
                  return (0);
            }

            /* Fix up the command pointers. */
            ecp->clen -= (endp - ecp->cp);
            ecp->cp = endp;

            *isaddrp = 1;
            F_SET(ecp, E_ABSMARK);
            break;
      case '.':                     /* Current position. */
            *isaddrp = 1;
            mp->cno = sp->cno;

            /* If an empty file, then '.' is 0, not 1. */
            if (sp->lno == 1) {
                  if (db_last(sp, &mp->lno))
                        return (1);
                  if (mp->lno != 0)
                        mp->lno = 1;
            } else
                  mp->lno = sp->lno;

            /*
             * !!!
             * Historically, .<number> was the same as .+<number>, i.e.
             * the '+' could be omitted.  (This feature is found in ed
             * as well.)
             */
            if (ecp->clen > 1 && isdigit(ecp->cp[1]))
                  *ecp->cp = '+';
            else {
                  ++ecp->cp;
                  --ecp->clen;
            }
            break;
      }

      /* Skip trailing <blank>s. */
      for (; ecp->clen > 0 &&
          isblank(ecp->cp[0]); ++ecp->cp, --ecp->clen);

      /*
       * Evaluate any offset.  If no address yet found, the offset
       * is relative to ".".
       */
      total = 0;
      if (ecp->clen != 0 && (isdigit(ecp->cp[0]) ||
          ecp->cp[0] == '+' || ecp->cp[0] == '-' ||
          ecp->cp[0] == '^')) {
            if (!*isaddrp) {
                  *isaddrp = 1;
                  mp->lno = sp->lno;
                  mp->cno = sp->cno;
            }
            /*
             * Evaluate an offset, defined as:
             *
             *          [+-^<blank>]*[<blank>]*[0-9]*
             *
             * The rough translation is any number of signs, optionally
             * followed by numbers, or a number by itself, all <blank>
             * separated.
             *
             * !!!
             * All address offsets were additive, e.g. "2 2 3p" was the
             * same as "7p", or, "/ZZZ/ 2" was the same as "/ZZZ/+2".
             * Note, however, "2 /ZZZ/" was an error.  It was also legal
             * to insert signs without numbers, so "3 - 2" was legal, and
             * equal to 4.
             *
             * !!!
             * Offsets were historically permitted for any line address,
             * e.g. the command "1,2 copy 2 2 2 2" copied lines 1,2 after
             * line 8.
             *
             * !!!
             * Offsets were historically permitted for search commands,
             * and handled as addresses: "/pattern/2 2 2" was legal, and
             * referenced the 6th line after pattern.
             */
            F_SET(ecp, E_DELTA);
            for (;;) {
                  for (; ecp->clen > 0 && isblank(ecp->cp[0]);
                      ++ecp->cp, --ecp->clen);
                  if (ecp->clen == 0 || !isdigit(ecp->cp[0]) &&
                      ecp->cp[0] != '+' && ecp->cp[0] != '-' &&
                      ecp->cp[0] != '^')
                        break;
                  if (!isdigit(ecp->cp[0]) &&
                      !isdigit(ecp->cp[1])) {
                        total += ecp->cp[0] == '+' ? 1 : -1;
                        --ecp->clen;
                        ++ecp->cp;
                  } else {
                        if (ecp->cp[0] == '-' ||
                            ecp->cp[0] == '^') {
                              ++ecp->cp;
                              --ecp->clen;
                              isneg = 1;
                        } else
                              isneg = 0;

                        /* Get a signed long, add it to the total. */
                        if ((nret = nget_slong(&val,
                            ecp->cp, &endp, 10)) != NUM_OK ||
                            (nret = NADD_SLONG(sp,
                            total, val)) != NUM_OK) {
                              ex_badaddr(sp, NULL, A_NOTSET, nret);
                              *errp = 1;
                              return (0);
                        }
                        total += isneg ? -val : val;
                        ecp->clen -= (endp - ecp->cp);
                        ecp->cp = endp;
                  }
            }
      }

      /*
       * Any value less than 0 is an error.  Make sure that the new value
       * will fit into a recno_t.
       */
      if (*isaddrp && total != 0) {
            if (total < 0) {
                  if (-total > mp->lno) {
                        msgq(sp, M_ERR,
                      "097|Reference to a line number less than 0");
                        *errp = 1;
                        return (0);
                  }
            } else
                  if (!NPFITS(MAX_REC_NUMBER, mp->lno, total)) {
                        ex_badaddr(sp, NULL, A_NOTSET, NUM_OVER);
                        *errp = 1;
                        return (0);
                  }
            mp->lno += total;
      }
      return (0);
}


/*
 * ex_load --
 *    Load up the next command, which may be an @ buffer or global command.
 */
static int
ex_load(sp)
      SCR *sp;
{
      GS *gp;
      EXCMD *ecp;
      RANGE *rp;

      F_CLR(sp, SC_EX_GLOBAL);

      /*
       * Lose any exhausted commands.  We know that the first command
       * can't be an AGV command, which makes things a bit easier.
       */
      for (gp = sp->gp;;) {
            /*
             * If we're back to the original structure, leave it around,
             * but discard any allocated source name, we've returned to
             * the beginning of the command stack.
             */
            if ((ecp = gp->ecq.lh_first) == &gp->excmd) {
                  if (F_ISSET(ecp, E_NAMEDISCARD)) {
                        free(ecp->if_name);
                        ecp->if_name = NULL;
                  }
                  return (0);
            }

            /*
             * ecp->clen will be 0 for the first discarded command, but
             * may not be 0 for subsequent ones, e.g. if the original
             * command was ":g/xx/@a|s/b/c/", then when we discard the
             * command pushed on the stack by the @a, we have to resume
             * the global command which included the substitute command.
             */
            if (ecp->clen != 0)
                  return (0);

            /*
             * If it's an @, global or v command, we may need to continue
             * the command on a different line.
             */
            if (FL_ISSET(ecp->agv_flags, AGV_ALL)) {
                  /* Discard any exhausted ranges. */
                  while ((rp = ecp->rq.cqh_first) != (void *)&ecp->rq)
                        if (rp->start > rp->stop) {
                              CIRCLEQ_REMOVE(&ecp->rq, rp, q);
                              free(rp);
                        } else
                              break;

                  /* If there's another range, continue with it. */
                  if (rp != (void *)&ecp->rq)
                        break;

                  /* If it's a global/v command, fix up the last line. */
                  if (FL_ISSET(ecp->agv_flags,
                      AGV_GLOBAL | AGV_V) && ecp->range_lno != OOBLNO)
                        if (db_exist(sp, ecp->range_lno))
                              sp->lno = ecp->range_lno;
                        else {
                              if (db_last(sp, &sp->lno))
                                    return (1);
                              if (sp->lno == 0)
                                    sp->lno = 1;
                        }
                  free(ecp->o_cp);
            }

            /* Discard the EXCMD. */
            LIST_REMOVE(ecp, q);
            free(ecp);
      }

      /*
       * We only get here if it's an active @, global or v command.  Set
       * the current line number, and get a new copy of the command for
       * the parser.  Note, the original pointer almost certainly moved,
       * so we have play games.
       */
      ecp->cp = ecp->o_cp;
      memcpy(ecp->cp, ecp->cp + ecp->o_clen, ecp->o_clen);
      ecp->clen = ecp->o_clen;
      ecp->range_lno = sp->lno = rp->start++;

      if (FL_ISSET(ecp->agv_flags, AGV_GLOBAL | AGV_V))
            F_SET(sp, SC_EX_GLOBAL);
      return (0);
}

/*
 * ex_discard --
 *    Discard any pending ex commands.
 */
static int
ex_discard(sp)
      SCR *sp;
{
      GS *gp;
      EXCMD *ecp;
      RANGE *rp;

      /*
       * We know the first command can't be an AGV command, so we don't
       * process it specially.  We do, however, nail the command itself.
       */
      for (gp = sp->gp; (ecp = gp->ecq.lh_first) != &gp->excmd;) {
            if (FL_ISSET(ecp->agv_flags, AGV_ALL)) {
                  while ((rp = ecp->rq.cqh_first) != (void *)&ecp->rq) {
                        CIRCLEQ_REMOVE(&ecp->rq, rp, q);
                        free(rp);
                  }
                  free(ecp->o_cp);
            }
            LIST_REMOVE(ecp, q);
            free(ecp);
      }
      gp->ecq.lh_first->clen = 0;
      return (0);
}

/*
 * ex_unknown --
 *    Display an unknown command name.
 */
static void
ex_unknown(sp, cmd, len)
      SCR *sp;
      char *cmd;
      size_t len;
{
      size_t blen;
      char *bp;

      GET_SPACE_GOTO(sp, bp, blen, len + 1);
      bp[len] = '\0';
      memcpy(bp, cmd, len);
      msgq_str(sp, M_ERR, bp, "098|The %s command is unknown");
      FREE_SPACE(sp, bp, blen);

alloc_err:
      return;
}

/*
 * ex_is_abbrev -
 *    The vi text input routine needs to know if ex thinks this is an
 *    [un]abbreviate command, so it can turn off abbreviations.  See
 *    the usual ranting in the vi/v_txt_ev.c:txt_abbrev() routine.
 *
 * PUBLIC: int ex_is_abbrev __P((char *, size_t));
 */
int
ex_is_abbrev(name, len)
      char *name;
      size_t len;
{
      EXCMDLIST const *cp;

      return ((cp = ex_comm_search(name, len)) != NULL &&
          (cp == &cmds[C_ABBR] || cp == &cmds[C_UNABBREVIATE]));
}

/*
 * ex_is_unmap -
 *    The vi text input routine needs to know if ex thinks this is an
 *    unmap command, so it can turn off input mapping.  See the usual
 *    ranting in the vi/v_txt_ev.c:txt_unmap() routine.
 *
 * PUBLIC: int ex_is_unmap __P((char *, size_t));
 */
int
ex_is_unmap(name, len)
      char *name;
      size_t len;
{
      EXCMDLIST const *cp;

      /*
       * The command the vi input routines are really interested in
       * is "unmap!", not just unmap.
       */
      if (name[len - 1] != '!')
            return (0);
      --len;
      return ((cp = ex_comm_search(name, len)) != NULL &&
          cp == &cmds[C_UNMAP]);
}

/*
 * ex_comm_search --
 *    Search for a command name.
 */
static EXCMDLIST const *
ex_comm_search(name, len)
      char *name;
      size_t len;
{
      EXCMDLIST const *cp;

      for (cp = cmds; cp->name != NULL; ++cp) {
            if (cp->name[0] > name[0])
                  return (NULL);
            if (cp->name[0] != name[0])
                  continue;
            if (!memcmp(name, cp->name, len))
                  return (cp);
      }
      return (NULL);
}

/*
 * ex_badaddr --
 *    Display a bad address message.
 *
 * PUBLIC: void ex_badaddr
 * PUBLIC:    __P((SCR *, EXCMDLIST const *, enum badaddr, enum nresult));
 */
void
ex_badaddr(sp, cp, ba, nret)
      SCR *sp;
      EXCMDLIST const *cp;
      enum badaddr ba;
      enum nresult nret;
{
      recno_t lno;

      switch (nret) {
      case NUM_OK:
            break;
      case NUM_ERR:
            msgq(sp, M_SYSERR, NULL);
            return;
      case NUM_OVER:
            msgq(sp, M_ERR, "099|Address value overflow");
            return;
      case NUM_UNDER:
            msgq(sp, M_ERR, "100|Address value underflow");
            return;
      }

      /*
       * When encountering an address error, tell the user if there's no
       * underlying file, that's the real problem.
       */
      if (sp->ep == NULL) {
            ex_emsg(sp, cp->name, EXM_NOFILEYET);
            return;
      }

      switch (ba) {
      case A_COMBO:
            msgq(sp, M_ERR, "101|Illegal address combination");
            break;
      case A_EOF:
            if (db_last(sp, &lno))
                  return;
            if (lno != 0) {
                  msgq(sp, M_ERR,
                      "102|Illegal address: only %lu lines in the file",
                      lno);
                  break;
            }
            /* FALLTHROUGH */
      case A_EMPTY:
            msgq(sp, M_ERR, "103|Illegal address: the file is empty");
            break;
      case A_NOTSET:
            abort();
            /* NOTREACHED */
      case A_ZERO:
            msgq(sp, M_ERR,
                "104|The %s command doesn't permit an address of 0",
                cp->name);
            break;
      }
      return;
}

#if defined(DEBUG) && defined(COMLOG)
/*
 * ex_comlog --
 *    Log ex commands.
 */
static void
ex_comlog(sp, ecp)
      SCR *sp;
      EXCMD *ecp;
{
      TRACE(sp, "ecmd: %s", ecp->cmd->name);
      if (ecp->addrcnt > 0) {
            TRACE(sp, " a1 %d", ecp->addr1.lno);
            if (ecp->addrcnt > 1)
                  TRACE(sp, " a2: %d", ecp->addr2.lno);
      }
      if (ecp->lineno)
            TRACE(sp, " line %d", ecp->lineno);
      if (ecp->flags)
            TRACE(sp, " flags 0x%x", ecp->flags);
      if (F_ISSET(&exc, E_BUFFER))
            TRACE(sp, " buffer %c", ecp->buffer);
      if (ecp->argc)
            for (cnt = 0; cnt < ecp->argc; ++cnt)
                  TRACE(sp, " arg %d: {%s}", cnt, ecp->argv[cnt]->bp);
      TRACE(sp, "\n");
}
#endif

Generated by  Doxygen 1.6.0   Back to index