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

v_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[] = "@(#)v_ex.c  10.42 (Berkeley) 6/28/96";
#endif /* not lint */

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

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

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

static int v_ecl __P((SCR *));
static int v_ecl_init __P((SCR *));
static int v_ecl_log __P((SCR *, TEXT *));
static int v_ex_done __P((SCR *, VICMD *));
static int v_exec_ex __P((SCR *, VICMD *, EXCMD *));

/*
 * v_again -- &
 *    Repeat the previous substitution.
 *
 * PUBLIC: int v_again __P((SCR *, VICMD *));
 */
int
v_again(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      ARGS *ap[2], a;
      EXCMD cmd;

      ex_cinit(&cmd, C_SUBAGAIN, 2, vp->m_start.lno, vp->m_start.lno, 1, ap);
      ex_cadd(&cmd, &a, "", 1);

      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_exmode -- Q
 *    Switch the editor into EX mode.
 *
 * PUBLIC: int v_exmode __P((SCR *, VICMD *));
 */
int
v_exmode(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      GS *gp;

      gp = sp->gp;

      /* Try and switch screens -- the screen may not permit it. */
      if (gp->scr_screen(sp, SC_EX)) {
            msgq(sp, M_ERR,
                "207|The Q command requires the ex terminal interface");
            return (1);
      }
      (void)gp->scr_attr(sp, SA_ALTERNATE, 0);

      /* Save the current cursor position. */
      sp->frp->lno = sp->lno;
      sp->frp->cno = sp->cno;
      F_SET(sp->frp, FR_CURSORSET);

      /* Switch to ex mode. */
      F_CLR(sp, SC_VI | SC_SCR_VI);
      F_SET(sp, SC_EX);

      /* Move out of the vi screen. */
      (void)ex_puts(sp, "\n");

      return (0);
}

/*
 * v_join -- [count]J
 *    Join lines together.
 *
 * PUBLIC: int v_join __P((SCR *, VICMD *));
 */
int
v_join(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      EXCMD cmd;
      int lno;

      /*
       * YASC.
       * The general rule is that '#J' joins # lines, counting the current
       * line.  However, 'J' and '1J' are the same as '2J', i.e. join the
       * current and next lines.  This doesn't map well into the ex command
       * (which takes two line numbers), so we handle it here.  Note that
       * we never test for EOF -- historically going past the end of file
       * worked just fine.
       */
      lno = vp->m_start.lno + 1;
      if (F_ISSET(vp, VC_C1SET) && vp->count > 2)
            lno = vp->m_start.lno + (vp->count - 1);

      ex_cinit(&cmd, C_JOIN, 2, vp->m_start.lno, lno, 0, NULL);
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_shiftl -- [count]<motion
 *    Shift lines left.
 *
 * PUBLIC: int v_shiftl __P((SCR *, VICMD *));
 */
int
v_shiftl(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      ARGS *ap[2], a;
      EXCMD cmd;

      ex_cinit(&cmd, C_SHIFTL, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
      ex_cadd(&cmd, &a, "<", 1);
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_shiftr -- [count]>motion
 *    Shift lines right.
 *
 * PUBLIC: int v_shiftr __P((SCR *, VICMD *));
 */
int
v_shiftr(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      ARGS *ap[2], a;
      EXCMD cmd;

      ex_cinit(&cmd, C_SHIFTR, 2, vp->m_start.lno, vp->m_stop.lno, 0, ap);
      ex_cadd(&cmd, &a, ">", 1);
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_suspend -- ^Z
 *    Suspend vi.
 *
 * PUBLIC: int v_suspend __P((SCR *, VICMD *));
 */
int
v_suspend(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      ARGS *ap[2], a;
      EXCMD cmd;

      ex_cinit(&cmd, C_STOP, 0, OOBLNO, OOBLNO, 0, ap);
      ex_cadd(&cmd, &a, "suspend", sizeof("suspend") - 1);
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_switch -- ^^
 *    Switch to the previous file.
 *
 * PUBLIC: int v_switch __P((SCR *, VICMD *));
 */
int
v_switch(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      ARGS *ap[2], a;
      EXCMD cmd;
      char *name;

      /*
       * Try the alternate file name, then the previous file
       * name.  Use the real name, not the user's current name.
       */
      if ((name = sp->alt_name) == NULL) {
            msgq(sp, M_ERR, "180|No previous file to edit");
            return (1);
      }

      /* If autowrite is set, write out the file. */
      if (file_m1(sp, 0, FS_ALL))
            return (1);

      ex_cinit(&cmd, C_EDIT, 0, OOBLNO, OOBLNO, 0, ap);
      ex_cadd(&cmd, &a, name, strlen(name));
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_tagpush -- ^[
 *    Do a tag search on the cursor keyword.
 *
 * PUBLIC: int v_tagpush __P((SCR *, VICMD *));
 */
int
v_tagpush(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      ARGS *ap[2], a;
      EXCMD cmd;

      ex_cinit(&cmd, C_TAG, 0, OOBLNO, 0, 0, ap);
      ex_cadd(&cmd, &a, VIP(sp)->keyw, strlen(VIP(sp)->keyw));
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_tagpop -- ^T
 *    Pop the tags stack.
 *
 * PUBLIC: int v_tagpop __P((SCR *, VICMD *));
 */
int
v_tagpop(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      EXCMD cmd;

      ex_cinit(&cmd, C_TAGPOP, 0, OOBLNO, 0, 0, NULL);
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_filter -- [count]!motion command(s)
 *    Run range through shell commands, replacing text.
 *
 * PUBLIC: int v_filter __P((SCR *, VICMD *));
 */
int
v_filter(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      EXCMD cmd;
      TEXT *tp;

      /*
       * !!!
       * Historical vi permitted "!!" in an empty file, and it's handled
       * as a special case in the ex_bang routine.  Don't modify this setup
       * without understanding that one.  In particular, note that we're
       * manipulating the ex argument structures behind ex's back.
       *
       * !!!
       * Historical vi did not permit the '!' command to be associated with
       * a non-line oriented motion command, in general, although it did
       * with search commands.  So, !f; and !w would fail, but !/;<CR>
       * would succeed, even if they all moved to the same location in the
       * current line.  I don't see any reason to disallow '!' using any of
       * the possible motion commands.
       *
       * !!!
       * Historical vi ran the last bang command if N or n was used as the
       * search motion.
       */
      if (F_ISSET(vp, VC_ISDOT) ||
          ISCMD(vp->rkp, 'N') || ISCMD(vp->rkp, 'n')) {
            ex_cinit(&cmd, C_BANG,
                2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
            EXP(sp)->argsoff = 0;               /* XXX */

            if (argv_exp1(sp, &cmd, "!", 1, 1))
                  return (1);
            cmd.argc = EXP(sp)->argsoff;        /* XXX */
            cmd.argv = EXP(sp)->args;           /* XXX */
            return (v_exec_ex(sp, vp, &cmd));
      }

      /* Get the command from the user. */
      if (v_tcmd(sp, vp,
          '!', TXT_BS | TXT_CR | TXT_ESCAPE | TXT_FILEC | TXT_PROMPT))
            return (1);

      /*
       * Check to see if the user changed their mind.
       *
       * !!!
       * Entering <escape> on an empty line was historically an error,
       * this implementation doesn't bother.
       */
      tp = sp->tiq.cqh_first;
      if (tp->term != TERM_OK) {
            vp->m_final.lno = sp->lno;
            vp->m_final.cno = sp->cno;
            return (0);
      }

      /* Home the cursor. */
      vs_home(sp);

      ex_cinit(&cmd, C_BANG, 2, vp->m_start.lno, vp->m_stop.lno, 0, NULL);
      EXP(sp)->argsoff = 0;               /* XXX */

      if (argv_exp1(sp, &cmd, tp->lb + 1, tp->len - 1, 1))
            return (1);
      cmd.argc = EXP(sp)->argsoff;        /* XXX */
      cmd.argv = EXP(sp)->args;           /* XXX */
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_event_exec --
 *    Execute some command(s) based on an event.
 *
 * PUBLIC: int v_event_exec __P((SCR *, VICMD *));
 */
int
v_event_exec(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      EXCMD cmd;

      switch (vp->ev.e_event) {
      case E_QUIT:
            ex_cinit(&cmd, C_QUIT, 0, OOBLNO, OOBLNO, 0, NULL);
            break;
      case E_WRITE:
            ex_cinit(&cmd, C_WRITE, 0, OOBLNO, OOBLNO, 0, NULL);
            break;
      default:
            abort();
      }
      return (v_exec_ex(sp, vp, &cmd));
}

/*
 * v_exec_ex --
 *    Execute an ex command.
 */
static int
v_exec_ex(sp, vp, exp)
      SCR *sp;
      VICMD *vp;
      EXCMD *exp;
{
      int rval;

      rval = exp->cmd->fn(sp, exp);
      return (v_ex_done(sp, vp) || rval);
}

/*
 * v_ex -- :
 *    Execute a colon command line.
 *
 * PUBLIC: int v_ex __P((SCR *, VICMD *));
 */
int
v_ex(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      GS *gp;
      TEXT *tp;
      int do_cedit, do_resolution, ifcontinue;

      gp = sp->gp;

      /*
       * !!!
       * If we put out more than a single line of messages, or ex trashes
       * the screen, the user may continue entering ex commands.  We find
       * this out when we do the screen/message resolution.  We can't enter
       * completely into ex mode however, because the user can elect to
       * return into vi mode by entering any key, i.e. we have to be in raw
       * mode.
       */
      for (do_cedit = do_resolution = 0;;) {
            /*
             * !!!
             * There may already be an ex command waiting to run.  If
             * so, we continue with it.
             */
            if (!EXCMD_RUNNING(gp)) {
                  /* Get a command. */
                  if (v_tcmd(sp, vp, ':',
                      TXT_BS | TXT_CEDIT | TXT_FILEC | TXT_PROMPT))
                        return (1);
                  tp = sp->tiq.cqh_first;

                  /*
                   * If the user entered a single <esc>, they want to
                   * edit their colon command history.  If they already
                   * entered some text, move it into the edit history.
                   */
                  if (tp->term == TERM_CEDIT) {
                        if (tp->len > 1 && v_ecl_log(sp, tp))
                              return (1);
                        do_cedit = 1;
                        break;
                  }

                  /* If the user didn't enter anything, return. */
                  if (tp->term == TERM_BS)
                        break;

                  /* Log the command. */
                  if (O_STR(sp, O_CEDIT) != NULL && v_ecl_log(sp, tp))
                        return (1);

                  /* Push a command on the command stack. */
                  if (ex_run_str(sp, NULL, tp->lb, tp->len, 0, 1))
                        return (1);
            }

            /* Home the cursor. */
            vs_home(sp);

            /*
             * !!!
             * If the editor wrote the screen behind curses back, put out
             * a <newline> so that we don't overwrite the user's command
             * with its output or the next want-to-continue? message.  This
             * doesn't belong here, but I can't find another place to put
             * it.  See, we resolved the output from the last ex command,
             * and the user entered another one.  This is the only place
             * where we have control before the ex command writes output.
             * We could get control in vs_msg(), but we have no way to know
             * if command didn't put out any output when we try and resolve
             * this command.  This fixes a bug where combinations of ex
             * commands, e.g. ":set<CR>:!date<CR>:set" didn't look right.
             */
            if (F_ISSET(sp, SC_SCR_EXWROTE))
                  (void)putchar('\n');

            /* Call the ex parser. */
            (void)ex_cmd(sp);

            /* Flush ex messages. */
            (void)ex_fflush(sp);

            /* Resolve any messages. */
            if (vs_ex_resolve(sp, &ifcontinue))
                  return (1);

            /*
             * Continue or return.  If continuing, make sure that we
             * eventually do resolution.
             */
            if (!ifcontinue)
                  break;
            do_resolution = 1;

            /* If we're continuing, it's a new command. */
            ++sp->ccnt;
      }

      /*
       * If the user previously continued an ex command, we have to do
       * resolution to clean up the screen.  Don't wait, we already did
       * that.
       */
      if (do_resolution) {
            F_SET(sp, SC_EX_WAIT_NO);
            if (vs_ex_resolve(sp, &ifcontinue))
                  return (1);
      }

      /* Cleanup from the ex command. */
      if (v_ex_done(sp, vp))
            return (1);

      /* The user may want to edit their colon command history. */
      if (do_cedit)
            return (v_ecl(sp));

      return (0);
}

/*
 * v_ex_done --
 *    Cleanup from an ex command.
 */
static int
v_ex_done(sp, vp)
      SCR *sp;
      VICMD *vp;
{
      size_t len;

      /*
       * The only cursor modifications are real, however, the underlying
       * line may have changed; don't trust anything.  This code has been
       * a remarkably fertile place for bugs.  Do a reality check on a
       * cursor value, and make sure it's okay.  If necessary, change it.
       * Ex keeps track of the line number, but it cares less about the
       * column and it may have disappeared.
       *
       * Don't trust ANYTHING.
       *
       * XXX
       * Ex will soon have to start handling the column correctly; see
       * the POSIX 1003.2 standard.
       */
      if (db_eget(sp, sp->lno, NULL, &len, NULL)) {
            sp->lno = 1;
            sp->cno = 0;
      } else if (sp->cno >= len)
            sp->cno = len ? len - 1 : 0;

      vp->m_final.lno = sp->lno;
      vp->m_final.cno = sp->cno;

      /*
       * Don't re-adjust the cursor after executing an ex command,
       * and ex movements are permanent.
       */
      F_CLR(vp, VM_RCM_MASK);
      F_SET(vp, VM_RCM_SET);

      return (0);
}

/*
 * v_ecl --
 *    Start an edit window on the colon command-line commands.
 */
static int
v_ecl(sp)
      SCR *sp;
{
      GS *gp;
      SCR *new;

      /* Initialize the screen, if necessary. */
      gp = sp->gp;
      if (gp->ccl_sp == NULL && v_ecl_init(sp))
            return (1);

      /* Get a new screen. */
      if (screen_init(gp, sp, &new))
            return (1);
      if (vs_split(sp, new, 1)) {
            (void)screen_end(new);
            return (1);
      }

      /* Attach to the screen. */
      new->ep = gp->ccl_sp->ep;
      ++new->ep->refcnt;

      new->frp = gp->ccl_sp->frp;
      new->frp->flags = sp->frp->flags;

      /* Move the cursor to the end. */
      (void)db_last(new, &new->lno);
      if (new->lno == 0)
            new->lno = 1;

      /* Remember the originating window. */
      sp->ccl_parent = sp;

      /* It's a special window. */
      F_SET(new, SC_COMEDIT);

      /* Set up the switch. */
      sp->nextdisp = new;
      F_SET(sp, SC_SSWITCH);
      return (0);
}

/*
 * v_ecl_exec --
 *    Execute a command from a colon command-line window.
 *
 * PUBLIC: int v_ecl_exec __P((SCR *));
 */
int
v_ecl_exec(sp)
      SCR *sp;
{
      size_t len;
      char *p;

      if (db_get(sp, sp->lno, 0, &p, &len) && sp->lno == 1) {
            v_emsg(sp, NULL, VIM_EMPTY);
            return (1);
      }
      if (len == 0) {
            msgq(sp, M_BERR, "307|No ex command to execute");
            return (1);
      }
      
      /* Push the command on the command stack. */
      if (ex_run_str(sp, NULL, p, len, 0, 0))
            return (1);

      /* Set up the switch. */
      sp->nextdisp = sp->ccl_parent;
      F_SET(sp, SC_EXIT);
      return (0);
}

/*
 * v_ecl_log --
 *    Log a command into the colon command-line log file.
 */
static int
v_ecl_log(sp, tp)
      SCR *sp;
      TEXT *tp;
{
      EXF *save_ep;
      recno_t lno;
      int rval;

      /* Initialize the screen, if necessary. */
      if (sp->gp->ccl_sp == NULL && v_ecl_init(sp))
            return (1);

      /*
       * Don't log colon command window commands into the colon command
       * window...
       */
      if (sp->ep == sp->gp->ccl_sp->ep)
            return (0);

      /*
       * XXX
       * Swap the current EXF with the colon command file EXF.  This
       * isn't pretty, but too many routines "know" that sp->ep points
       * to the current EXF.
       */
      save_ep = sp->ep;
      sp->ep = sp->gp->ccl_sp->ep;
      if (db_last(sp, &lno)) {
            sp->ep = save_ep;
            return (1);
      }
      rval = db_append(sp, 0, lno, tp->lb, tp->len);
      sp->ep = save_ep;
      return (rval);
}

/*
 * v_ecl_init --
 *    Initialize the colon command-line log file.
 */
static int
v_ecl_init(sp)
      SCR *sp;
{
      FREF *frp;
      GS *gp;

      gp = sp->gp;

      /* Get a temporary file. */
      if ((frp = file_add(sp, NULL)) == NULL)
            return (1);

      /*
       * XXX
       * Create a screen -- the file initialization code wants one.
       */
      if (screen_init(gp, sp, &gp->ccl_sp))
            return (1);
      if (file_init(gp->ccl_sp, frp, NULL, 0)) {
            (void)screen_end(gp->ccl_sp);
            return (1);
      }

      /* The underlying file isn't recoverable. */
      F_CLR(gp->ccl_sp->ep, F_RCV_ON);

      return (0);
}

Generated by  Doxygen 1.6.0   Back to index