Source Code 1994 March/Source_Code_CD-ROM_Walnut_Creek_March_1994.iso/compsrcs/misc/volume37/vim/part15

Text File | 1993-04-23 | 32.3 KB | 1,622 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Bram Moolenaar)
Subject: v37i015:  vim - Vi IMitation editor v1.27, Part15/24
Message-ID: <[e-mail]>
X-Md4-Signature: 1e20de5623aace9db1c9e3a2330ce7fe
Date: Sun, 25 Apr 1993 01:35:31 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (Bram Moolenaar)
Posting-number: Volume 37, Issue 15
Archive-name: vim/part15
Environment: UNIX, AMIGA, MS-DOS

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 15 (of 23)."
# Contents:  vim/src/normal.c
# Wrapped by mool@oce-rd2 on Mon Apr 19 15:50:11 1993
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'vim/src/normal.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vim/src/normal.c'\"
else
echo shar: Extracting \"'vim/src/normal.c'\" \(29120 characters\)
sed "s/^X//" >'vim/src/normal.c' <<'END_OF_FILE'
X/* vi:ts=4:sw=4
X *
X * VIM - Vi IMitation
X *
X * Code Contributions By:    Bram Moolenaar            [e-mail]
X *                            Tim Thompson            twitch!tjt
X *                            Tony Andrews            onecom!wldrdg!tony
X *                            G. R. (Fred) Walter        watmath!watcgl!grwalter
X */
X
X/*
X * Contains the main routine for processing characters in command mode.
X * Communicates closely with the code in ops.c to handle the operators.
X */
X
X#include "vim.h"
X#include "globals.h"
X#include "proto.h"
X#include "param.h"
X
X#undef EXTERN
X#undef INIT
X#define EXTERN
X#define INIT(x) x
X#include "ops.h"
X
X/*
X * Generally speaking, every command in normal() should either clear any
X * pending operator (with CLEAROP), or set the motion type variable.
X */
X
X#define CLEAROP (operator = NOP)        /* clear any pending operator */
X#define CLEAROPBEEP     clearopbeep()    /* CLEAROP plus a beep() */
X#define CHECKCLEAROP    if (checkclearop()) break;
X#define CHECKCLEAROPQ    if (checkclearopq()) break;
X
X/*
X * If a count is given before the operator, it is saved in opnum.
X */
Xstatic linenr_t    opnum = 0;
Xstatic linenr_t    Prenum;         /* The (optional) number before a command. */
Xstatic int        substituting = FALSE;    /* TRUE when in 'S' command */
Xint                redo_Quote_busy = FALSE;    /* TRUE when redo-ing a quote */
X
Xstatic void        prep_redo __ARGS((long, int, int, int));
Xstatic int        checkclearop __ARGS((void));
Xstatic int        checkclearopq __ARGS((void));
Xstatic void        clearopbeep __ARGS((void));
Xstatic void        premsg __ARGS((int, int));
Xstatic void        adjust_lnum __ARGS((void));
X
Xextern int        restart_edit;    /* this is in edit.c */
X
X/*
X * normal
X *
X * Execute a command in normal mode.
X *
X * This is basically a big switch with the cases arranged in rough categories
X * in the following order:
X *
X *      0. Macros (v, @)
X *      1. Screen positioning commands (^U, ^D, ^F, ^B, ^E, ^Y, z)
X *      2. Control commands (:, <help>, ^L, ^G, ^^, ZZ, *, ^], ^T)
X *      3. Cursor motions (G, H, M, L, l, K_RARROW,  , h, K_LARROW, ^H, k, K_UARROW, ^P, +, CR, LF, j, K_DARROW, ^N, _, |, B, b, W, w, E, e, $, ^, 0)
X *      4. Searches (?, /, n, N, T, t, F, f, ,, ;, ], [, %, (, ), {, })
X *      5. Edits (., u, K_UNDO, ^R, U, r, J, p, P, ^A, ^S)
X *      6. Inserts (A, a, I, i, o, O, R)
X *      7. Operators (~, d, c, y, >, <, !, =)
X *      8. Abbreviations (x, X, D, C, s, S, Y, &)
X *      9. Marks (m, ', `, ^O, ^I)
X *     10. Buffer setting (")
X *     11. Quoting (q)
X *   12. Suspend (^Z)
X */
X
X    void
Xnormal()
X{
X    register u_char    c;
X    long             n;
X    int                flag = FALSE;
X    int             type = 0;        /* used in some operations to modify type */
X    int             dir = FORWARD;    /* search direction */
X    u_char            nchar = NUL;
X    int                finish_op;
X    linenr_t        Prenum1;
X    char            searchbuff[CMDBUFFSIZE];        /* buffer for search string */
X    FPOS            *pos;
X    register char    *ptr;
X    int                command_busy = FALSE;
X
X    static linenr_t    redo_Quote_nlines;
X    static int        redo_Quote_type;
X    static long        redo_Quote_col;
X
X    Prenum = 0;
X    /*
X     * If there is an operator pending, then the command we take this time
X     * will terminate it. Finish_op tells us to finish the operation before
X     * returning this time (unless the operation was cancelled).
X     */
X    finish_op = (operator != NOP);
X
X    if (!finish_op && !yankbuffer)
X        opnum = 0;
X
X    if (vpeekc() == NUL || KeyTyped == TRUE)
X        premsg(NUL, NUL);
X    State = NORMAL_BUSY;
X    c = vgetc();
X
X    /* Pick up any leading digits and compute 'Prenum' */
X    while ((c >= '1' && c <= '9') || (Prenum != 0 && (c == DEL || c == '0')))
X    {
X        if (c == DEL)
X                Prenum /= 10;
X        else
X                Prenum = Prenum * 10 + (c - '0');
X        if (Prenum < 0)            /* got too large! */
X            Prenum = 999999999;
X        premsg(' ', NUL);
X        c = vgetc();
X    }
X
X    /*
X     * If we're in the middle of an operator (including after entering a yank
X     * buffer with ") AND we had a count before the
X     * operator, then that count overrides the current value of Prenum. What
X     * this means effectively, is that commands like "3dw" get turned into
X     * "d3w" which makes things fall into place pretty neatly.
X     * If you give a count before AND after the operator, they are multiplied.
X     */
X    if (opnum != 0)
X    {
X            if (Prenum)
X                Prenum *= opnum;
X            else
X                Prenum = opnum;
X            opnum = 0;
X    }
X
X    Prenum1 = (Prenum == 0 ? 1 : Prenum);        /* Prenum often defaults to 1 */
X    premsg(c, NUL);
X
X    /*
X     * get an additional character if we need one
X     */
X    if (strchr("@zZtTfF[]rm'`\"", c) || (c == 'v' && Recording == FALSE))
X    {
X        State = NOMAPPING;
X        nchar = vgetc();        /* no macro mapping for this char */
X        premsg(c, nchar);
X    }
X    flushbuf();            /* flush the premsg() characters onto the screen so we can
X                            see them while the command is being executed */
X
X    if (c != 'z')    /* the 'z' command gets another character */
X    {
X        State = NORMAL;
X        script_winsize_pp();
X    }
X    if (nchar == ESC)
X    {
X        CLEAROP;
X        goto normal_end;
X    }
X    switch (c)
X    {
X
X/*
X * 0: Macros
X */
X      case 'v':         /* (stop) recording into a named buffer */
X        CHECKCLEAROP;
X        if (!dorecord(nchar))
X                CLEAROPBEEP;
X        break;
X
X     case '@':            /* execute a named buffer */
X        CHECKCLEAROP;
X        while (Prenum1--)
X            if (!doexecbuf(nchar))
X            {
X                CLEAROPBEEP;
X                break;
X            }
X        break;
X
X/*
X * 1: Screen positioning commands
X */
X      case Ctrl('D'):
X        flag = TRUE;
X
X      case Ctrl('U'):
X        CHECKCLEAROP;
X        if (Prenum)
X            p_scroll = (Prenum > Rows - 1) ? Rows - 1 : Prenum;
X        n = (p_scroll < Rows) ? p_scroll : Rows - 1;
X        if (flag)
X        {
X                Topline += n;
X                if (Topline > line_count)
X                    Topline = line_count;
X                comp_Botline();        /* compute Botline */
X                onedown(n);
X        }
X        else
X        {
X                if (n >= Curpos.lnum)
X                    n = Curpos.lnum - 1;
X                Prenum1 = Curpos.lnum - n;
X                scrolldown(n);
X                if (Prenum1 < Curpos.lnum)
X                    Curpos.lnum = Prenum1;
X        }
X        beginline(TRUE);
X        updateScreen(VALID);
X        break;
X
X      case Ctrl('B'):
X      case K_SUARROW:
X        dir = BACKWARD;
X
X      case Ctrl('F'):
X      case K_SDARROW:
X        CHECKCLEAROP;
X        onepage(dir, Prenum1);
X        break;
X
X      case Ctrl('E'):
X        CHECKCLEAROP;
X        scrollup(Prenum1);
X        updateScreen(VALID);
X        break;
X
X      case Ctrl('Y'):
X        CHECKCLEAROP;
X        scrolldown(Prenum1);
X        updateScreen(VALID);
X        break;
X
X      case 'z':
X        CHECKCLEAROP;
X        if (isdigit(nchar))
X        {
X            /*
X             * we misuse some variables to be able to call premsg()
X             */
X            operator = c;
X            opnum = Prenum;
X            Prenum = nchar - '0';
X            for (;;)
X            {
X                premsg(' ', NUL);
X                nchar = vgetc();
X                State = NORMAL;
X                script_winsize_pp();
X                if (nchar == DEL)
X                    Prenum /= 10;
X                else if (isdigit(nchar))
X                    Prenum = Prenum * 10 + (nchar - '0');
X                else if (nchar == CR)
X                {
X                    set_winsize((int)Columns, (int)Prenum, TRUE);
X                    break;
X                }
X                else
X                {
X                    CLEAROPBEEP;
X                    break;
X                }
X            }
X            operator = NOP;
X            break;
X        }
X
X        if (Prenum)        /* line number given */
X        {
X            setpcmark();
X            if (Prenum > line_count)
X                Curpos.lnum = line_count;
X            else
X                Curpos.lnum = Prenum;
X        }
X        State = NORMAL;
X        script_winsize_pp();
X        switch (nchar)
X        {
X          case NL:                /* put Curpos at top of screen */
X          case CR:
X            Topline = Curpos.lnum;
X            updateScreen(VALID);
X            break;
X
X          case '.':             /* put Curpos in middle of screen */
X            n = (Rows + plines(Curpos.lnum)) / 2;
X            goto dozcmd;
X
X          case '-':             /* put Curpos at bottom of screen */
X            n = Rows - 1;
X            /* FALLTHROUGH */
X
X    dozcmd:
X            {
X                register linenr_t    lp = Curpos.lnum;
X                register long        l = plines(lp);
X
X                do
X                {
X                    Topline = lp;
X                    if (--lp == 0)
X                        break;
X                    l += plines(lp);
X                } while (l <= n);
X            }
X            updateScreen(VALID);
X            break;
X
X          default:
X            CLEAROPBEEP;
X        }
X        break;
X
X/*
X *      2: Control commands
X */
X      case ':':
X        if (Quote.lnum)
X            goto dooperator;
X        CHECKCLEAROP;
X        docmdline(NULL);
X        break;
X
X      case K_HELP:
X        CHECKCLEAROP;
X        help();
X        break;
X
X      case Ctrl('L'):
X        CHECKCLEAROP;
X        updateScreen(CLEAR);
X        break;
X
X      case Ctrl('G'):
X        CHECKCLEAROP;
X        fileinfo();
X        break;
X
X      case K_CCIRCM:            /* shorthand command */
X        CHECKCLEAROPQ;
X        if (getaltfile((int)Prenum, (linenr_t)0, TRUE))
X            emsg(e_noalt);
X        break;
X
X      case 'Z':         /* write, if changed, and exit */
X        CHECKCLEAROPQ;
X        if (nchar != 'Z')
X        {
X            CLEAROPBEEP;
X            break;
X        }
X        stuffReadbuff(":x\n");
X        break;
X
X      case Ctrl(']'):            /* :ta to current identifier */
X        CHECKCLEAROPQ;
X      case '*':                 /* / to current identifier */
X      case '#':                 /* ? to current identifier */
X      case 'K':                    /* run program for current identifier */
X        {
X            register int     col;
X
X            ptr = nr2ptr(Curpos.lnum);
X            col = Curpos.col;
X
X            /*
X             * skip to start of identifier.
X             */
X            while (ptr[col] != NUL && !isidchar(ptr[col]))
X                ++col;
X
X            /*
X             * Back up to start of identifier. This doesn't match the
X             * real vi but I like it a little better and it shouldn't bother
X             * anyone.
X             */
X            while (col > 0 && isidchar(ptr[col - 1]))
X                --col;
X
X            if (!isidchar(ptr[col]))
X            {
X                CLEAROPBEEP;
X                break;
X            }
X
X            if (Prenum)
X                stuffnumReadbuff(Prenum);
X            switch (c)
X            {
X                case '*':
X                    stuffReadbuff("/");
X                    break;
X                case '#':
X                    stuffReadbuff("?");
X                    break;
X                case 'K':
X                    stuffReadbuff(":! ");
X                    stuffReadbuff(p_kp);
X                    stuffReadbuff(" ");
X                    break;
X                default:
X                    stuffReadbuff(":ta ");
X            }
X
X            /*
X             * Now grab the chars in the identifier
X             */
X            while (isidchar(ptr[col]))
X            {
X                stuffReadbuff(mkstr(ptr[col]));
X                ++col;
X            }
X            stuffReadbuff("\n");
X        }
X        break;
X
X      case Ctrl('T'):        /* backwards in tag stack */
X            CHECKCLEAROPQ;
X              dotag("", 2, (int)Prenum1);
X            break;
X
X/*
X * Cursor motions
X */
X      case 'G':
X        mtype = MLINE;
X        setpcmark();
X        if (Prenum == 0 || Prenum > line_count)
X                Curpos.lnum = line_count;
X        else
X                Curpos.lnum = Prenum;
X        beginline(TRUE);
X        break;
X
X      case 'H':
X      case 'M':
X        if (c == 'M')
X                n = Rows / 2;
X        else
X                n = Prenum;
X        mtype = MLINE;
X        Curpos.lnum = Topline;
X        while (n && onedown((long)1))
X                --n;
X        beginline(TRUE);
X        break;
X
X      case 'L':
X        mtype = MLINE;
X        Curpos.lnum = Botline - 1;
X        for (n = Prenum; n && oneup((long)1); n--)
X                ;
X        beginline(TRUE);
X        break;
X
X      case 'l':
X      case K_RARROW:
X      case ' ':
X        mtype = MCHAR;
X        mincl = FALSE;
X        n = Prenum1;
X        while (n--)
X        {
X            if (!oneright())
X            {
X                if (operator == NOP)
X                    beep();
X                else
X                {
X                    if (lineempty(Curpos.lnum))
X                        CLEAROPBEEP;
X                    else
X                    {
X                        mincl = TRUE;
X                        if (n)
X                            beep();
X                    }
X                }
X                break;
X            }
X        }
X        set_want_col = TRUE;
X        break;
X
X      case 'h':
X      case K_LARROW:
X      case Ctrl('H'):
X      case DEL:
X        mtype = MCHAR;
X        mincl = FALSE;
X        n = Prenum1;
X        while (n--)
X        {
X            if (!oneleft())
X            {
X                if (operator != DELETE && operator != CHANGE)
X                    beep();
X                else if (Prenum1 == 1)
X                    CLEAROPBEEP;
X                break;
X            }
X        }
X        set_want_col = TRUE;
X        break;
X
X      case '-':
X        flag = TRUE;
X        /* FALLTHROUGH */
X
X      case 'k':
X      case K_UARROW:
X      case Ctrl('P'):
X        mtype = MLINE;
X        if (!oneup(Prenum1))
X            CLEAROPBEEP;
X        else if (flag)
X            beginline(TRUE);
X        break;
X
X      case '+':
X      case CR:
X        flag = TRUE;
X        /* FALLTHROUGH */
X
X      case 'j':
X      case K_DARROW:
X      case Ctrl('N'):
X      case NL:
X        mtype = MLINE;
X        if (!onedown(Prenum1))
X            CLEAROPBEEP;
X        else if (flag)
X            beginline(TRUE);
X        break;
X
X        /*
X         * This is a strange motion command that helps make operators more
X         * logical. It is actually implemented, but not documented in the
X         * real 'vi'. This motion command actually refers to "the current
X         * line". Commands like "dd" and "yy" are really an alternate form of
X         * "d_" and "y_". It does accept a count, so "d3_" works to delete 3
X         * lines.
X         */
X      case '_':
Xlineop:
X        mtype = MLINE;
X        if (!onedown((long)(Prenum1 - 1)))
X            CLEAROPBEEP;
X        else if (operator != YANK)    /* 'Y' does not move cursor */
X            beginline(TRUE);
X        break;
X
X      case '|':
X        mtype = MCHAR;
X        mincl = TRUE;
X        beginline(FALSE);
X        if (Prenum > 0)
X            coladvance((colnr_t)(Prenum - 1));
X        Curswant = Prenum - 1;
X        break;
X
X        /*
X         * Word Motions
X         */
X
X      case 'B':
X        type = 1;
X        /* FALLTHROUGH */
X
X      case 'b':
X      case K_SLARROW:
X        mtype = MCHAR;
X        mincl = FALSE;
X        set_want_col = TRUE;
X        if (bck_word(Prenum1, type))
X            CLEAROPBEEP;
X        break;
X
X      case 'E':
X        type = 1;
X        /* FALLTHROUGH */
X
X      case 'e':
X        mincl = TRUE;
X        goto dowrdcmd;
X
X      case 'W':
X        type = 1;
X        /* FALLTHROUGH */
X
X      case 'w':
X      case K_SRARROW:
X        mincl = FALSE;
X        flag = TRUE;
X        /*
X         * This is a little strange. To match what the real vi does, we
X         * effectively map 'cw' to 'ce', and 'cW' to 'cE', provided that we are
X         * not on a space or a TAB. This seems
X         * impolite at first, but it's really more what we mean when we say
X         * 'cw'.
X         */
X        if (operator == CHANGE && (n = gcharCurpos()) != ' ' && n != TAB &&
X                                                                n != NUL)
X        {
X            mincl = TRUE;
X            flag = FALSE;
X        }
X
Xdowrdcmd:
X        mtype = MCHAR;
X        set_want_col = TRUE;
X        if (flag)
X            n = fwd_word(Prenum1, type);
X        else
X            n = end_word(Prenum1, type, operator == CHANGE);
X        if (n)
X        {
X            CLEAROPBEEP;
X            break;
X        }
X        /*
X         * if we do a 'dw' for the last word in a line, we only delete the rest
X         * of the line, not joining the two lines.
X         */
X        if (operator == DELETE && Prenum1 == 1 && startop.lnum != Curpos.lnum)
X        {
X                Curpos = startop;
X                while (oneright())
X                    ;
X                mincl = TRUE;
X        }
X        break;
X
X      case '$':
X        mtype = MCHAR;
X        mincl = TRUE;
X        Curswant = 29999;                /* so we stay at the end */
X        if (!onedown((long)(Prenum1 - 1)))
X        {
X                CLEAROPBEEP;
X                break;
X        }
X        if (Quote_block)
X            updateScreen(NOT_VALID);
X        break;
X
X      case '^':
X        flag = TRUE;
X        /* FALLTHROUGH */
X
X      case '0':
X        mtype = MCHAR;
X        mincl = FALSE;
X        beginline(flag);
X        break;
X
X/*
X * 4: Searches
X */
X      case '?':
X      case '/':
X        if (!getcmdline(c, (u_char *)searchbuff))
X        {
X                CLEAROP;
X                break;
X        }
X        mtype = MCHAR;
X        mincl = FALSE;
X        set_want_col = TRUE;
X
X        n = dosearch(c == '/' ? FORWARD : BACKWARD, searchbuff, FALSE, Prenum1, TRUE);
X        if (n == 0)
X                CLEAROPBEEP;
X        else if (n == 2)
X                mtype = MLINE;
X        break;
X
X      case 'N':
X        flag = 1;
X
X      case 'n':
X        mtype = MCHAR;
X        mincl = FALSE;
X        set_want_col = TRUE;
X        if (!dosearch(0, NULL, flag, Prenum1, TRUE))
X            CLEAROPBEEP;
X        break;
X
X        /*
X         * Character searches
X         */
X      case 'T':
X        dir = BACKWARD;
X        /* FALLTHROUGH */
X
X      case 't':
X        type = 1;
X        goto docsearch;
X
X      case 'F':
X        dir = BACKWARD;
X        /* FALLTHROUGH */
X
X      case 'f':
Xdocsearch:
X        mtype = MCHAR;
X        mincl = TRUE;
X        set_want_col = TRUE;
X        if (!searchc(nchar, dir, type, Prenum1))
X        {
X            CLEAROPBEEP;
X        }
X        break;
X
X      case ',':
X        flag = 1;
X        /* FALLTHROUGH */
X
X      case ';':
X        dir = flag;
X        goto docsearch;        /* nchar == NUL, thus repeat previous search */
X
X        /*
X         * section or C function searches
X         */
X
X      case '[':
X        dir = BACKWARD;
X        /* FALLTHROUGH */
X
X      case ']':
X        mtype = MLINE;
X        set_want_col = TRUE;
X        flag = '{';
X        if (nchar != c)
X        {
X            if (nchar == '[' || nchar == ']')
X                flag = '}';
X            else
X            {
X                CLEAROPBEEP;
X                break;
X            }
X        }
X        if (dir == FORWARD && operator != NOP)    /* e.g. y]] searches for '}' */
X            flag = '}';
X        if (!findpar(dir, Prenum1, flag))
X        {
X            CLEAROPBEEP;
X        }
X        break;
X
X      case '%':
X        mincl = TRUE;
X        if (Prenum)        /* {cnt}% : goto {cnt} percentage in file */
X        {
X            if (Prenum > 100)
X                CLEAROPBEEP;
X            else
X            {
X                mtype = MLINE;
X                setpcmark();
X                Curpos.lnum = line_count * Prenum / 100;
X                Curpos.col = 0;
X            }
X        }
X        else            /* % : go to matching paren */
X        {
X            mtype = MCHAR;
X            if ((pos = showmatch()) == NULL)
X                CLEAROPBEEP;
X            else
X            {
X                setpcmark();
X                Curpos = *pos;
X                set_want_col = TRUE;
X            }
X        }
X        break;
X
X      case '(':
X        dir = BACKWARD;
X        /* FALLTHROUGH */
X
X      case ')':
X        mtype = MCHAR;
X        if (c == ')')
X            mincl = FALSE;
X        else
X            mincl = TRUE;
X        set_want_col = TRUE;
X
X        if (!findsent(dir, Prenum1))
X            CLEAROPBEEP;
X        break;
X
X      case '{':
X        dir = BACKWARD;
X        /* FALLTHROUGH */
X
X      case '}':
X        mtype = MCHAR;
X        mincl = FALSE;
X        set_want_col = TRUE;
X
X        if (!findpar(dir, Prenum1, NUL))
X            CLEAROPBEEP;
X        break;
X
X/*
X * 5: Edits
X */
X      case '.':
X        CHECKCLEAROPQ;
X        if (!start_redo(Prenum))
X            CLEAROPBEEP;
X        break;
X
X      case 'u':
X        if (Quote.lnum)
X            goto dooperator;
X      case K_UNDO:
X        CHECKCLEAROPQ;
X        u_undo((int)Prenum1);
X        set_want_col = TRUE;
X        break;
X
X      case Ctrl('R'):
X        CHECKCLEAROPQ;
X          u_redo((int)Prenum1);
X        set_want_col = TRUE;
X        break;
X
X      case 'U':
X        if (Quote.lnum)
X            goto dooperator;
X        CHECKCLEAROPQ;
X        u_undoline();
X        set_want_col = TRUE;
X        break;
X
X      case 'r':
X        if (Quote.lnum)
X        {
X            c = 'c';
X            goto dooperator;
X        }
X        CHECKCLEAROPQ;
X        n = strlen(nr2ptr(Curpos.lnum)) - Curpos.col;
X        if (n < Prenum1)            /* not enough characters to replace */
X        {
X            CLEAROPBEEP;
X            break;
X        }
X
X        if (nchar == Ctrl('V'))        /* get another character */
X        {
X            c = Ctrl('V');
X            State = NOMAPPING;
X            nchar = vgetc();        /* no macro mapping for this char */
X            State = NORMAL;
X        }
X        else
X            c = NUL;
X        prep_redo(Prenum1, 'r', c, nchar);
X        stuffnumReadbuff(Prenum1);
X        stuffReadbuff("R");
X        if (c)
X            stuffReadbuff(mkstr(c));
X        stuffReadbuff(mkstr(nchar));
X        stuffReadbuff("\033");
X        break;
X
X      case 'J':
X        if (Quote.lnum)        /* join the quoted lines */
X        {
X            if (Curpos.lnum > Quote.lnum)
X            {
X                Prenum = Curpos.lnum - Quote.lnum + 1;
X                Curpos.lnum = Quote.lnum;
X            }
X            else
X                Prenum = Quote.lnum - Curpos.lnum + 1;
X            Quote.lnum = 0;
X        }
X        CHECKCLEAROP;
X        if (Prenum <= 1)
X                Prenum = 2;     /* default for join is two lines! */
X        if (Curpos.lnum + Prenum - 1 > line_count)    /* beyond last line */
X        {
X            CLEAROPBEEP;
X            break;
X        }
X
X        prep_redo(Prenum, 'J', NUL, NUL);
X        dodojoin(Prenum, TRUE, TRUE);
X        break;
X
X      case 'P':
X        dir = BACKWARD;
X        /* FALLTHROUGH */
X
X      case 'p':
X        CHECKCLEAROPQ;
X        prep_redo(Prenum, c, NUL, NUL);
X        doput(dir, Prenum1);
X        break;
X
X      case Ctrl('A'):            /* add to number */
X      case Ctrl('S'):            /* subtract from number */
X        CHECKCLEAROPQ;
X        if (doaddsub((int)c, Prenum1))
X            prep_redo(Prenum1, c, NUL, NUL);
X        break;
X
X/*
X * 6: Inserts
X */
X      case 'A':
X        set_want_col = TRUE;
X        while (oneright())
X                ;
X        /* FALLTHROUGH */
X
X      case 'a':
X        CHECKCLEAROPQ;
X        /* Works just like an 'i'nsert on the next character. */
X        if (u_saveCurpos())
X        {
X            if (!lineempty(Curpos.lnum))
X                incCurpos();
X            startinsert(c, FALSE, Prenum1);
X            command_busy = TRUE;
X        }
X        break;
X
X      case 'I':
X        beginline(TRUE);
X        /* FALLTHROUGH */
X
X      case 'i':
X        CHECKCLEAROPQ;
X        if (u_saveCurpos())
X        {
X            startinsert(c, FALSE, Prenum1);
X            command_busy = TRUE;
X        }
X        break;
X
X      case 'o':
X          if (Quote.lnum)    /* switch start and end of quote */
X        {
X            Prenum = Quote.lnum;
X            Quote.lnum = Curpos.lnum;
X            Curpos.lnum = Prenum;
X            n = Quote.col;
X            Quote.col = Curpos.col;
X            Curpos.col = n;
X            break;
X        }
X        CHECKCLEAROP;
X        if (u_save(Curpos.lnum, (linenr_t)(Curpos.lnum + 1)) && Opencmd(FORWARD, TRUE))
X        {
X            startinsert('o', TRUE, Prenum1);
X            command_busy = TRUE;
X        }
X        break;
X
X      case 'O':
X        CHECKCLEAROPQ;
X        if (u_save((linenr_t)(Curpos.lnum - 1), Curpos.lnum) && Opencmd(BACKWARD, TRUE))
X        {
X            startinsert('O', TRUE, Prenum1);
X            command_busy = TRUE;
X        }
X        break;
X
X      case 'R':
X        if (Quote.lnum)
X        {
X            c = 'c';
X            Quote.col = QUOTELINE;
X            goto dooperator;
X        }
X        CHECKCLEAROPQ;
X        if (u_saveCurpos())
X        {
X            startinsert('R', FALSE, Prenum1);
X            command_busy = TRUE;
X        }
X        break;
X
X/*
X * 7: Operators
X */
X      case '~':         /* swap case */
X      /*
X       * if tilde is not an operator and Quoting is off: swap case
X       * of a single character
X       */
X        if (!p_to && !Quote.lnum)
X        {
X            CHECKCLEAROPQ;
X            if (lineempty(Curpos.lnum))
X            {
X                CLEAROPBEEP;
X                break;
X            }
X            prep_redo(Prenum, '~', NUL, NUL);
X
X            if (!u_saveCurpos())
X                break;
X
X            for (; Prenum1 > 0; --Prenum1)
X            {
X                if (gcharCurpos() == NUL)
X                    break;
X                swapchar(&Curpos);
X                incCurpos();
X            }
X
X            set_want_col = TRUE;
X            CHANGED;
X            updateline();
X            break;
X        }
X        /*FALLTHROUGH*/
X
X      case 'd':
X      case 'c':
X      case 'y':
X      case '>':
X      case '<':
X      case '!':
X      case '=':
X      case 'V':
Xdooperator:
X        n = strchr(opchars, c) - opchars + 1;
X        if (n == operator)        /* double operator works on lines */
X            goto lineop;
X        CHECKCLEAROP;
X        if (Prenum != 0)
X            opnum = Prenum;
X        startop = Curpos;
X        operator = n;
X        break;
X
X/*
X * 8: Abbreviations
X */
X
X     /* when quoting the next commands are operators */
X      case 'S':
X      case 'Y':
X      case 'D':
X      case 'C':
X      case 'x':
X      case 'X':
X      case 's':
X          if (Quote.lnum)
X        {
X            static char trans[] = "ScYyDdCcxdXdsc";
X
X            if (isupper(c))            /* uppercase means linewise */
X                Quote.col = QUOTELINE;
X            c = *(strchr(trans, c) + 1);
X            goto dooperator;
X        }
X
X      case '&':
X        CHECKCLEAROPQ;
X        if (Prenum)
X            stuffnumReadbuff(Prenum);
X
X        if (c == 'S')
X        {
X            beginline((int)p_ai);
X            substituting = TRUE;
X        }
X        else if (c == 'Y' && p_ye)
X            c = 'Z';
X        {
X                static char *(ar[9]) = {"dl", "dh", "d$", "c$", "cl", "c$", "yy", "y$", ":s\r"};
X                static char *str = "xXDCsSYZ&";
X
X                stuffReadbuff(ar[strchr(str, c) - str]);
X        }
X        break;
X
X/*
X * 9: Marks
X */
X
X      case 'm':
X        CHECKCLEAROP;
X        if (!setmark(nchar))
X            CLEAROPBEEP;
X        break;
X
X      case '\'':
X        flag = TRUE;
X        /* FALLTHROUGH */
X
X      case '`':
X        pos = getmark(nchar, (operator == NOP));
X        if (pos == (FPOS *)-1)    /* jumped to other file */
X        {
X            if (flag)
X                beginline(TRUE);
X            break;
X        }
X
X        if (pos != NULL)
X            setpcmark();
X
Xcursormark:
X        if (pos == NULL)
X            CLEAROPBEEP;
X        else
X        {
X            Curpos = *pos;
X            if (flag)
X                beginline(TRUE);
X        }
X        mtype = flag ? MLINE : MCHAR;
X        mincl = FALSE;        /* ignored if not MCHAR */
X        set_want_col = TRUE;
X        break;
X
X    case Ctrl('O'):            /* goto older pcmark */
X        Prenum1 = -Prenum1;
X        /* FALLTHROUGH */
X
X    case Ctrl('I'):            /* goto newer pcmark */
X        CHECKCLEAROPQ;
X        pos = movemark((int)Prenum1);
X        if (pos == (FPOS *)-1)    /* jump to other file */
X        {
X            set_want_col = TRUE;
X            break;
X        }
X        goto cursormark;
X
X/*
X * 10. Buffer setting
X */
X      case '"':
X        CHECKCLEAROP;
X        if (isalnum(nchar) || nchar == '.')
X        {
X            yankbuffer = nchar;
X            opnum = Prenum;        /* remember count before '"' */
X        }
X        else
X            CLEAROPBEEP;
X        break;
X
X/*
X * 11. Quoting
X */
X       case 'q':
X      case 'Q':
X      case Ctrl('Q'):
X        CHECKCLEAROP;
X        Quote_block = FALSE;
X        if (Quote.lnum)                    /* stop quoting */
X        {
X            Quote.lnum = 0;
X            updateScreen(NOT_VALID);    /* delete the inversion */
X        }
X        else                            /* start quoting */
X        {
X            Quote = Curpos;
X            if (c == 'Q')                /* linewise */
X                Quote.col = QUOTELINE;
X            else if (c == Ctrl('Q'))    /* blockwise */
X                Quote_block = TRUE;
X            updateline();                /* start the inversion */
X        }
X        break;
X
X/*
X * 12. Suspend
X */
X
X     case Ctrl('Z'):
X        CLEAROP;
X        Quote.lnum = 0;                    /* stop quoting */
X        stuffReadbuff(":st!\r");        /* no autowrite */
X        break;
X
X/*
X * The end
X */
X      case ESC:
X        if (Quote.lnum)
X        {
X            Quote.lnum = 0;            /* stop quoting */
X            updateScreen(NOT_VALID);
X        }
X
X      default:                    /* not a known command */
X        CLEAROPBEEP;
X        break;
X
X    }    /* end of switch on command character */
X
X/*
X * if we didn't start or finish an operator, reset yankbuffer, unless we
X * need it later.
X */
X    if (!finish_op && !operator && strchr("\"DCYSsXx", c) == NULL)
X        yankbuffer = 0;
X
X    /*
X     * If an operation is pending, handle it...
X     */
X    if ((Quote.lnum || finish_op) && operator != NOP)
X    {
X        if (operator != YANK && !Quote.lnum)        /* can't redo yank */
X        {
X                prep_redo(Prenum, opchars[operator - 1], c, nchar);
X                if (c == '/' || c == '?')        /* was a search */
X                {
X                        AppendToRedobuff(searchbuff);
X                        AppendToRedobuff(NL_STR);
X                }
X        }
X
X        if (redo_Quote_busy)
X        {
X            startop = Curpos;
X            Curpos.lnum += redo_Quote_nlines - 1;
X            switch (redo_Quote_type)
X            {
X            case 'Q':    Quote.col = QUOTELINE;
X                        break;
X
X            case Ctrl('Q'):
X                        Quote_block = TRUE;
X                        break;
X
X            case 'q':
X                        if (redo_Quote_nlines <= 1)
X                            Curpos.col += redo_Quote_col;
X                        else
X                            Curpos.col = redo_Quote_col;
X                        break;
X            }
X            if (redo_Quote_col == 29999)
X            {
X                Curswant = 29999;
X                coladvance(29999);
X            }
X        }
X        else if (Quote.lnum)
X            startop = Quote;
X
X        /*
X         * imitate the strange behaviour of vi:
X         * When doing }, while standing on an indent, the indent is
X         * included in the operated text.
X         */
X        if (c == '}' && !Quote.lnum)
X        {
X            n = 0;
X            for (ptr = nr2ptr(startop.lnum); *ptr; ++ptr)
X            {
X                if (!isspace(*ptr))
X                    break;
X                if (++n == startop.col)
X                {
X                    startop.col = 0;
X                    break;
X                }
X            }
X        }
X
X        if (lt(startop, Curpos))
X        {
X            endop = Curpos;
X            Curpos = startop;
X        }
X        else
X        {
X            endop = startop;
X            startop = Curpos;
X        }
X        nlines = endop.lnum - startop.lnum + 1;
X
X        if (Quote.lnum || redo_Quote_busy)
X        {
X            if (Quote_block)                /* block mode */
X            {
X                startvcol = getvcol(&startop, 2);
X                n = getvcol(&endop, 2);
X                if (n < startvcol)
X                    startvcol = n;
X
X            /* if '$' was used, get endvcol from longest line */
X                if (Curswant == 29999)
X                {
X                    Curpos.col = 29999;
X                    endvcol = 0;
X                    for (Curpos.lnum = startop.lnum; Curpos.lnum <= endop.lnum; ++Curpos.lnum)
X                        if ((n = getvcol(&Curpos, 3)) > endvcol)
X                            endvcol = n;
X                    Curpos = startop;
X                }
X                else if (redo_Quote_busy)
X                    endvcol = startvcol + redo_Quote_col;
X                else
X                {
X                    endvcol = getvcol(&startop, 3);
X                    n = getvcol(&endop, 3);
X                    if (n > endvcol)
X                        endvcol = n;
X                }
X                coladvance(startvcol);
X            }
X
X    /*
X     * prepare to redo quoting: this is based on the size
X     * of the quoted text
X     */
X            if (operator != YANK && operator != COLON)    /* can't redo yank and : */
X            {
X                prep_redo(0L, 'q', opchars[operator - 1], NUL);
X                if (Quote_block)
X                    redo_Quote_type = Ctrl('Q');
X                else if (Quote.col == QUOTELINE)
X                    redo_Quote_type = 'Q';
X                else
X                    redo_Quote_type = 'q';
X                if (Curswant == 29999)
X                    redo_Quote_col = 29999;
X                else if (Quote_block)
X                    redo_Quote_col = endvcol - startvcol;
X                else if (nlines > 1)
X                    redo_Quote_col = endop.col;
X                else
X                    redo_Quote_col = endop.col - startop.col;
X                redo_Quote_nlines = nlines;
X            }
X
X            mincl = TRUE;
X            if (Quote.col == QUOTELINE)
X                mtype = MLINE;
X            else
X                mtype = MCHAR;
X
X            redo_Quote_busy = FALSE;
X            /*
X             * Switch quoting off now, so screen updating does
X             * not show inverted text when the screen is redrawn.
X             * With YANK and sometimes with COLON and FILTER there is no screen
X             * redraw, so it is done here to remove the inverted part.
X             */
X            Quote.lnum = 0;
X            if (operator == YANK || operator == COLON || operator == FILTER)
X                updateScreen(NOT_VALID);
X        }
X
X        set_want_col = 1;
X        if (!mincl && !equal(startop, endop))
X            oneless = 1;
X        else
X            oneless = 0;
X
X        switch (operator)
X        {
X          case LSHIFT:
X          case RSHIFT:
X            adjust_lnum();
X            doshift(operator);
X            break;
X
X          case DELETE:
X            dodelete();
X            break;
X
X          case YANK:
X            doyank(FALSE);
X            break;
X
X          case CHANGE:
X            dochange();
X            break;
X
X          case FILTER:
X              bangredo = TRUE;            /* dobang() will put cmd in redo buffer */
X
X          case INDENT:
X          case COLON:
X            adjust_lnum();
X            sprintf(IObuff, ":%ld,%ld", (long)startop.lnum, (long)endop.lnum);
X            stuffReadbuff(IObuff);
X            if (operator != COLON)
X                stuffReadbuff("!");
X            if (operator == INDENT)
X            {
X                stuffReadbuff(p_ep);
X                stuffReadbuff("\n");
X            }
X                /*    docmdline() does the rest */
X            break;
X
X          case TILDE:
X          case UPPER:
X          case LOWER:
X            dotilde();
X            break;
X
X          case FORMAT:
X            adjust_lnum();
X            doformat();
X            break;
X
X          default:
X            CLEAROPBEEP;
X        }
X        operator = NOP;
X        Quote_block = FALSE;
X        yankbuffer = 0;
X    }
X
Xnormal_end:
X    premsg(-1, NUL);
X    if (restart_edit && operator == NOP && Quote.lnum == 0 && !command_busy && stuff_empty() && yankbuffer == 0)
X        startinsert(NUL, FALSE, 1L);
X}
X
X    static void
Xprep_redo(num, cmd, c, nchar)
X    long     num;
X    int        cmd;
X    int        c;
X    int        nchar;
X{
X    if (substituting)    /* special case: 'S' command is done like 'c$' */
X    {
X        substituting = FALSE;
X        cmd = 'S';
X        c = NUL;
X        nchar = NUL;
X    }
X    ResetBuffers();
X    if (yankbuffer != 0)    /* yank from specified buffer */
X    {
X        AppendToRedobuff("\"");
X        AppendToRedobuff(mkstr(yankbuffer));
X    }
X    if (num)
X        AppendNumberToRedobuff(num);
X    AppendToRedobuff(mkstr(cmd));
X    if (c != NUL)
X        AppendToRedobuff(mkstr(c));
X    if (nchar != NUL)
X        AppendToRedobuff(mkstr(nchar));
X}
X
X/*
X * check for operator active
X */
X    static int
Xcheckclearop()
X{
X        if (operator == NOP)
X                return (FALSE);
X        clearopbeep();
X        return (TRUE);
X}
X
X/*
X * check for operator or Quoting active
X */
X    static int
Xcheckclearopq()
X{
X        if (operator == NOP && Quote.lnum == 0)
X                return (FALSE);
X        clearopbeep();
X        return (TRUE);
X}
X
X    static void
Xclearopbeep()
X{
X        CLEAROP;
X        beep();
X}
X
X/*
X * display, on the last line of the window, the characters typed before
X * the last command character, plus 'c'
X */
X    static void
Xpremsg(c1, c2)
X        int c1, c2;
X{
X        char c;
X
X        if (!p_sc || !KeyTyped)
X                return;
X
X        outstr(T_CI);            /* disable cursor */
X        windgoto((int)Rows - 1, (int)Columns - 12);
X        if (c1 == -1)
X            outstrn("           ");
X        else
X        {
X            if (opnum)
X                outnum((long)opnum);
X            if (yankbuffer)
X            {
X                outchar('"');
X                outchar(yankbuffer);
X            }
X            if (operator == 'z')
X                outchar('z');
X            else if (operator)
X                outchar(opchars[operator - 1]);
X            if (Prenum)
X                outnum((long)Prenum);
X            if (c1)
X            {
X                c = c1;
X                outtrans(&c, 1);
X            }
X            if (c2)
X            {
X                c = c2;
X                outtrans(&c, 1);
X            }
X        }
X        setcursor();
X        outstr(T_CV);            /* enable cursor */
X}
X
X/*
X * If we are going to do an linewise operator we have to adjust endop.lnum
X * if we end in column one while mtype is MCHAR and mincl is FALSE
X */
X    static void
Xadjust_lnum()
X{
X    if (mtype == MCHAR && mincl == FALSE &&
X                            endop.col == 0 && endop.lnum > startop.lnum)
X        --endop.lnum;
X}
END_OF_FILE
if test 29120 -ne `wc -c <'vim/src/normal.c'`; then
    echo shar: \"'vim/src/normal.c'\" unpacked with wrong size!
fi
# end of 'vim/src/normal.c'
fi
echo shar: End of archive 15 \(of 23\).
cp /dev/null ark15isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 23 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
-------------8<----------------8<----------------8<---------------8<--------
Bram Moolenaar                             | DISCLAIMER:  This  note  does  not
Oce Nederland B.V., Research & Development | necessarily represent the position
p.o. box 101, 5900 MA  Venlo               | of  Oce-Nederland  B.V.  Therefore
The Netherlands        phone [phone] | no liability or responsibility for
UUCP: [e-mail]        fax [phone] | whatever will be accepted.

exit 0 # Just in case...