Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume44/vim/part17

Internet Message Format | 1994-08-18 | 68.9 KB

From: [e-mail] (Bram Moolenaar)
Newsgroups: comp.sources.misc
Subject: v44i036:  vim - Vi IMproved editor, v3.0, Part17/26
Date: 18 Aug 1994 14:03:00 -0500
Organization: Sterling Software
Sender: [e-mail]
Approved: [e-mail]
Message-ID: <330b94$[e-mail]>
X-Md4-Signature: 53fa669384f024ab9c97b93695b199ea

Submitted-by: [e-mail] (Bram Moolenaar)
Posting-number: Volume 44, Issue 36
Archive-name: vim/part17
Environment: UNIX, AMIGA, MS-DOS, Windows NT
Supersedes: vim: Volume 41, Issue 50-75

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# Contents:  vim/macros/center.UU vim/src/amiga.c vim/src/edit.c
# Wrapped by kent@sparky on Mon Aug 15 21:44:09 1994
PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
echo If this archive is complete, you will see the following message:
echo '          "shar: End of archive 17 (of 26)."'
if test -f 'vim/macros/center.UU' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vim/macros/center.UU'\"
else
  echo shar: Extracting \"'vim/macros/center.UU'\" \(270 characters\)
  sed "s/^X//" >'vim/macros/center.UU' <<'END_OF_FILE'
Xbegin 644 vim/macros/center
XM(E1H:7,@;6%C<F\@8V5N=&5R<R!A(&QI;F4@:6X@86X@.# @8VAA<F%C=&5R
XM('-P86-E+@HB0V%R969U;#H@;&EN97,@;&]N9V5R('1H86X@.# @8VAA<F%C
XM=&5R<R!W:6QL(&)E('1R=6YC871E9 IM87 @.V-E(#IS+UY;( E=*B\O#21M
XB83@Q82 ;.#$6?$1@86QL9# Z<R\@("\@+V<-)' -:R1X"EY;
X
Xend
END_OF_FILE
  if test 270 -ne `wc -c <'vim/macros/center.UU'`; then
    echo shar: \"'vim/macros/center.UU'\" unpacked with wrong size!
  else
    echo shar: Uudecoding \"'vim/macros/center'\" \(169 characters\)
    cat vim/macros/center.UU | uudecode
    if test 169 -ne `wc -c <'vim/macros/center'`; then
      echo shar: \"'vim/macros/center'\" uudecoded with wrong size!
    else
      rm vim/macros/center.UU
    fi
  fi
  # end of 'vim/macros/center.UU'
fi
if test -f 'vim/src/amiga.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vim/src/amiga.c'\"
else
  echo shar: Extracting \"'vim/src/amiga.c'\" \(32474 characters\)
  sed "s/^X//" >'vim/src/amiga.c' <<'END_OF_FILE'
X/* vi:ts=4:sw=4
X *
X * VIM - Vi IMproved        by Bram Moolenaar
X *
X * Read the file "credits.txt" for a list of people who contributed.
X * Read the file "uganda.txt" for copying and usage conditions.
X */
X
X/*
X * amiga.c
X *
X * Amiga system-dependent routines.
X */
X
X#include "vim.h"
X#include "globals.h"
X#include "proto.h"
X#include "param.h"
X
X#include <fcntl.h>
X
X#undef TRUE             /* will be redefined by exec/types.h */
X#undef FALSE
X
X#ifndef LATTICE
X# include <exec/types.h>
X# include <exec/exec.h>
X# include <libraries/dos.h>
X# include <libraries/dosextens.h>
X# include <intuition/intuition.h>
X#else
X# include <proto/dos.h>
X# include <libraries/dosextens.h>
X# include <proto/intuition.h>
X# include <proto/exec.h>
X#endif
X
X#include <exec/memory.h>
X
X#ifndef NO_ARP
X#include <libraries/arpbase.h>        /* for arp.library */
X#endif
X#include <dos/dostags.h>            /* for 2.0 functions */
X#include <dos/dosasl.h>
X
X#if defined(LATTICE) && !defined(SASC) && !defined(NO_ARP)
X# include <libraries/arp_pragmas.h>
X#endif
X
X/*
X * At this point TRUE and FALSE are defined as 1L and 0L, but we want 1 and 0.
X */
X#undef TRUE
X#define TRUE (1)
X#undef FALSE
X#define FALSE (0)
X
X#ifndef AZTEC_C
Xstatic long dos_packet __ARGS((struct MsgPort *, long, long));
X#endif
Xstatic int lock2name __ARGS((BPTR lock, char_u *buf, long    len));
Xstatic struct FileInfoBlock *get_fib __ARGS((char_u *));
Xstatic int sortcmp __ARGS((char **a, char **b));
X
Xstatic BPTR                raw_in = (BPTR)NULL;
Xstatic BPTR                raw_out = (BPTR)NULL;
Xstatic int                close_win = FALSE;    /* set if Vim opened the window */
X
Xstruct IntuitionBase    *IntuitionBase = NULL;
X#ifndef NO_ARP
Xstruct ArpBase            *ArpBase = NULL;
X#endif
X
Xstatic struct Window    *wb_window;
Xstatic char_u            *oldwindowtitle = NULL;
X
X#ifndef NO_ARP
Xint                        dos2 = FALSE;        /* Amiga DOS 2.0x or higher */
X#endif
Xint                        size_set = FALSE;    /* set to TRUE if window size was set */
X
X    void
Xwin_resize_on()
X{
X    OUTSTRN("\033[12{");
X}
X
X    void
Xwin_resize_off()
X{
X    OUTSTRN("\033[12}");
X}
X
X    void
Xmch_write(p, len)
X    char_u    *p;
X    int        len;
X{
X    Write(raw_out, (char *)p, (long)len);
X}
X
X/*
X * GetChars(): low level input funcion.
X * Get a characters from the keyboard.
X * If time == 0 do not wait for characters.
X * If time == n wait a short time for characters.
X * If time == -1 wait forever for characters.
X *
X * Return number of characters read.
X */
X    int
XGetChars(buf, maxlen, time)
X    char_u    *buf;
X    int        maxlen;
X    int        time;                /* milli seconds */
X{
X    int        len;
X    long    utime;
X
X    if (time >= 0)
X    {
X        if (time == 0)
X            utime = 100L;            /* time = 0 causes problems in DOS 1.2 */
X        else
X            utime = time * 1000L;    /* convert from milli to micro secs */
X        if (WaitForChar(raw_in, utime) == 0)    /* no character available */
X            return 0;
X    }
X    else    /* time == -1 */
X    {
X    /*
X     * If there is no character available within 2 seconds (default)
X     * write the autoscript file to disk
X     */
X        if (WaitForChar(raw_in, p_ut * 1000L) == 0)
X            updatescript(0);
X    }
X
X    for (;;)        /* repeat until we got a character */
X    {
X        len = Read(raw_in, (char *)buf, (long)maxlen);
X        if (len > 0)
X            return len;
X    }
X}
X
X/*
X * return non-zero if a character is available
X */
X    int
Xmch_char_avail()
X{
X    return (WaitForChar(raw_in, 100L) != 0);
X}
X
X    void
Xsleep(n)
X    int             n;
X{
X#ifndef LATTICE            /* SAS declares void Delay(UNLONG) */
X    void            Delay __ARGS((long));
X#endif
X
X    if (n > 0)
X        Delay((long)(50L * n));
X}
X
X    long
Xmch_avail_mem(special)
X    int        special;
X{
X    return (long)AvailMem(special ? (long)MEMF_CHIP : (long)MEMF_ANY);
X}
X
X    void
Xvim_delay()
X{
X    Delay(25L);
X}
X
X/*
X * We have no job control, fake it by starting a new shell.
X */
Xvoid
Xmch_suspend()
X{
X    OUTSTR("new shell started\n");
X    (void)call_shell(NULL, 0, TRUE);
X}
X
X#define DOS_LIBRARY     ((UBYTE *) "dos.library")
X
X    void
Xmch_windinit()
X{
X    static char        intlibname[] = "intuition.library";
X
X#ifdef AZTEC_C
X    Enable_Abort = 0;            /* disallow vim to be aborted */
X#endif
X    Columns = 80;
X    Rows = 24;
X
X    /*
X     * Set input and output channels, unless we have opened our own window
X     */
X    if (raw_in == (BPTR)NULL)
X    {
X        raw_in = Input();
X        raw_out = Output();
X    }
X
X    flushbuf();
X
X    wb_window = NULL;
X    if ((IntuitionBase = (struct IntuitionBase *)OpenLibrary((UBYTE *)intlibname, 0L)) == NULL)
X    {
X        fprintf(stderr, "cannot open %s!?\n", intlibname);
X        mch_windexit(3);
X    }
X    (void)mch_get_winsize();
X}
X
X#include <workbench/startup.h>
X
X/*
X * Check_win checks whether we have an interactive window.
X * If not, a new window is opened with the newcli command.
X * If we would open a window ourselves, the :sh and :! commands would not
X * work properly (Why? probably because we are then running in a background CLI).
X * This also is the best way to assure proper working in a next Workbench release.
X *
X * For the -e option (quickfix mode) and -x we open our own window and disable :sh.
X * Otherwise the compiler would never know when editing is finished.
X */
X#define BUF2SIZE 320        /* lenght of buffer for argument with complete path */
X
X    void
Xcheck_win(argc, argv)
X    int argc;
X    char **argv;
X{
X    int                i;
X    BPTR            nilfh, fh;
X    char_u            buf1[20];
X    char_u            buf2[BUF2SIZE];
X    static char_u    *(constrings[3]) = {(char_u *)"con:0/0/662/210/",
X                                      (char_u *)"con:0/0/640/200/",
X                                      (char_u *)"con:0/0/320/200/"};
X    static char_u    winerr[] = "VIM: Can't open window!\n";
X    struct WBArg    *argp;
X    int                ac;
X    char            *av;
X    char_u            *device = NULL;
X    int                exitval = 4;
X    struct Library    *DosBase;
X    int                usewin = FALSE;
X
X/*
X * check if we are running under DOS 2.0x or higher
X */
X    if (DosBase = OpenLibrary(DOS_LIBRARY, 37L))
X    {
X        CloseLibrary(DosBase);
X#ifndef NO_ARP
X        dos2 = TRUE;
X#endif
X    }
X    else            /* without arp functions we NEED 2.0 */
X    {
X#ifdef NO_ARP
X        fprintf(stderr, "Need Amigados version 2.04 or later\n");
X        exit(3);
X#else
X                    /* need arp functions for dos 1.x */
X        if (!(ArpBase = (struct ArpBase *) OpenLibrary((UBYTE *)ArpName, ArpVersion)))
X        {
X            fprintf(stderr, "Need %s version %ld\n", ArpName, ArpVersion);
X            exit(3);
X        }
X#endif
X    }
X
X/*
X * scan argv[] for the '-e', '-x' and '-d' arguments
X */
X    for (i = 1; i < argc; ++i)
X        if (argv[i][0] == '-')
X        {
X            switch (argv[i][1])
X            {
X            case 'e':
X            case 'x':
X                usewin = TRUE;
X                break;
X
X            case 'd':
X                if (i < argc - 1)
X                    device = (char_u *)argv[i + 1];
X                break;
X            }
X        }
X
X/*
X * If we were not started from workbench, do not have a '-d' argument and
X * we have been started with an interactive window, use that window.
X */
X    if (argc != 0 && device == NULL &&
X                IsInteractive(Input()) && IsInteractive(Output()))
X        return;
X
X/*
X * If we are in quickfix mode, we open our own window. We can't use the
X * newcli trick below, because the compiler would not know when we are finished.
X * We do the same with the '-x' option, for mail, rn, etc.
X */
X    if (usewin)
X    {
X        /*
X         * Try to open a window. First try the specified device.
X         * Then try a 24 line 80 column window.
X         * If that fails, try two smaller ones.
X         */
X        for (i = -1; i < 3; ++i)
X        {
X            if (i >= 0)
X                device = constrings[i];
X            if (device && (raw_in = Open((UBYTE *)device, (long)MODE_NEWFILE)) != (BPTR)NULL)
X                break;
X        }
X        if (raw_in == (BPTR)NULL)        /* all three failed */
X        {
X            fprintf(stderr, (char *)winerr);
X            goto exit;
X        }
X        raw_out = raw_in;
X        close_win = TRUE;
X        return;
X    }
X
X    if ((nilfh = Open((UBYTE *)"NIL:", (long)MODE_NEWFILE)) == (BPTR)NULL)
X    {
X        fprintf(stderr, "Cannot open NIL:\n");
X        goto exit;
X    }
X
X    /*
X     * make a unique name for the temp file (which we will not delete!)
X     */
X    sprintf((char *)buf1, "t:nc%ld", (char *)buf1);    /* nobody else is using our stack */
X    if ((fh = Open((UBYTE *)buf1, (long)MODE_NEWFILE)) == (BPTR)NULL)
X    {
X        fprintf(stderr, "Cannot create %s\n", (char *)buf1);
X        goto exit;
X    }
X    /*
X     * Write the command into the file, put quotes around the arguments that
X     * have a space in them.
X     */
X    if (argc == 0)        /* run from workbench */
X        ac = ((struct WBStartup *)argv)->sm_NumArgs;
X    else
X        ac = argc;
X    for (i = 0; i < ac; ++i)
X    {
X        if (argc == 0)
X        {
X            *buf2 = NUL;
X            argp = &(((struct WBStartup *)argv)->sm_ArgList[i]);
X            if (argp->wa_Lock)
X                (void)lock2name(argp->wa_Lock, buf2, (long)(BUF2SIZE - 1));
X#ifndef NO_ARP
X            if (dos2)        /* use 2.0 function */
X#endif
X                AddPart((UBYTE *)buf2, (UBYTE *)argp->wa_Name, (long)(BUF2SIZE - 1));
X#ifndef NO_ARP
X            else            /* use arp function */
X                TackOn((char *)buf2, argp->wa_Name);
X#endif
X            av = (char *)buf2;
X        }
X        else
X            av = argv[i];
X
X        if (av[0] == '-' && av[1] == 'd')        /* skip '-d' option */
X        {
X            ++i;
X            continue;
X        }
X        if (strchr(av, ' '))
X            Write(fh, "\"", 1L);
X        Write(fh, av, (long)strlen(av));
X        if (strchr(av, ' '))
X            Write(fh, "\"", 1L);
X        Write(fh, " ", 1L);
X    }
X    Write(fh, "\nendcli\n", 8L);
X    Close(fh);
X
X/*
X * Try to open a new cli in a window. If '-d' argument was given try to open
X * the specified device. Then try a 24 line 80 column window.
X * If that fails, try two smaller ones.
X */
X    for (i = -1; i < 3; ++i)
X    {
X        if (i >= 0)
X            device = constrings[i];
X        else if (device == NULL)
X            continue;
X        sprintf((char *)buf2, "newcli <nil: >nil: %s from %s", (char *)device, (char *)buf1);
X#ifndef NO_ARP
X        if (dos2)
X        {
X#endif
X            if (!SystemTags((UBYTE *)buf2, SYS_UserShell, TRUE, TAG_DONE))
X                break;
X#ifndef NO_ARP
X        }
X        else
X        {
X            if (Execute((UBYTE *)buf2, nilfh, nilfh))
X                break;
X        }
X#endif
X    }
X    if (i == 3)        /* all three failed */
X    {
X        DeleteFile((UBYTE *)buf1);
X        fprintf(stderr, (char *)winerr);
X        goto exit;
X    }
X    exitval = 0;    /* The Execute succeeded: exit this program */
X
Xexit:
X#ifndef NO_ARP
X    if (ArpBase)
X        CloseLibrary((struct Library *) ArpBase);
X#endif
X    exit(exitval);
X}
X
X/*
X * fname_case(): Set the case of the filename, if it already exists.
X *                 This will cause the filename to remain exactly the same.
X */
X    void
Xfname_case(name)
X    char_u    *name;
X{
X    register struct FileInfoBlock    *fib;
X    register size_t                    len;
X
X    fib = get_fib(name);
X    if (fib != NULL)
X    {
X        len = STRLEN(name);
X        if (len == strlen(fib->fib_FileName))    /* safety check */
X            memmove((char *)name, fib->fib_FileName, len);
X        free(fib);
X    }
X}
X
X/*
X * Get the FileInfoBlock for file "fname"
X * The returned structure has to be free()d.
X * Returns NULL on error.
X */
X    static struct FileInfoBlock *
Xget_fib(fname)
X    char_u *fname;
X{
X    register BPTR                    flock;
X    register struct FileInfoBlock    *fib;
X
X    if (fname == NULL)        /* safety check */
X        return NULL;
X    fib = (struct FileInfoBlock *)malloc(sizeof(struct FileInfoBlock));
X    if (fib != NULL)
X    {
X        flock = Lock((UBYTE *)fname, (long)ACCESS_READ);
X        if (flock == (BPTR)NULL || !Examine(flock, fib))
X        {
X            free(fib);    /* in case of an error the memory is freed here */
X            fib = NULL;
X        }
X        if (flock)
X            UnLock(flock);
X    }
X    return fib;
X}
X
X/*
X * set the title of our window
X * icon name is not set
X */
X    void
Xmch_settitle(title, icon)
X    char_u    *title;
X    char_u    *icon;
X{
X    if (wb_window != NULL && title != NULL)
X        SetWindowTitles(wb_window, (UBYTE *)title, (UBYTE *)-1L);
X}
X
X/*
X * Restore the window/icon title.
X * which is one of:
X *    1  Just restore title
X *  2  Just restore icon (which we don't have)
X *    3  Restore title and icon (which we don't have)
X */
X    void
Xmch_restore_title(which)
X    int which;
X{
X    mch_settitle((which & 1) ? oldwindowtitle : NULL, NULL);
X}
X
X/*
X * Get name of current directory into buffer 'buf' of length 'len' bytes.
X * Return OK for success, FAIL for failure.
X */
X    int
Xvim_dirname(buf, len)
X    char_u        *buf;
X    int            len;
X{
X    return FullName((char_u *)"", buf, len);
X}
X
X/*
X * get absolute filename into buffer 'buf' of length 'len' bytes
X *
X * return FAIL for failure, OK otherwise
X */
X    int
XFullName(fname, buf, len)
X    char_u        *fname, *buf;
X    int            len;
X{
X    BPTR        l;
X    int            retval = FAIL;
X    int            i;
X
X    *buf = NUL;
X    if (fname == NULL)    /* always fail */
X        return FAIL;
X
X    if ((l = Lock((UBYTE *)fname, (long)ACCESS_READ)) != (BPTR)0)/* lock the file */
X    {
X        retval = lock2name(l, buf, (long)len);
X        UnLock(l);
X    }
X    else if (!isFullName(fname))        /* not a full path yet */
X    {
X        /*
X         * if cannot lock the file, try to lock the current directory and then
X         * concatenate the file name
X         */
X        if ((l = Lock((UBYTE *)"", (long)ACCESS_READ)) != (BPTR)NULL) /* lock current dir */
X        {
X            retval = lock2name(l, buf, (long)len);
X            UnLock(l);
X            if (retval == OK)
X            {
X                i = STRLEN(buf);
X                if (i < len - 1 && (i == 0 || buf[i - 1] != ':'))
X                    buf[i++] = '/';
X                STRNCPY(buf + i, fname, (size_t)(len - i));    /* concatenate the fname */
X            }
X        }
X    }
X    if (retval == FAIL || *buf == 0 || *buf == ':')
X        STRCPY(buf, fname);    /* something failed; use the filename */
X    return retval;
X}
X
X/*
X * return TRUE is fname is an absolute path name
X */
X    int
XisFullName(fname)
X    char_u        *fname;
X{
X    return (STRCHR(fname, ':') != NULL);
X}
X
X/*
X * Get the full filename from a lock. Use 2.0 function if possible, because
X * the arp function has more restrictions on the path length.
X *
X * return FAIL for failure, OK otherwise
X */
X    static int
Xlock2name(lock, buf, len)
X    BPTR    lock;
X    char_u    *buf;
X    long    len;
X{
X#ifndef NO_ARP
X    if (dos2)                /* use 2.0 function */
X#endif
X        return ((int)NameFromLock(lock, (UBYTE *)buf, len) ? OK : FAIL);
X#ifndef NO_ARP
X    else                /* use arp function */
X        return ((int)PathName(lock, (char *)buf, (long)(len/32)) ? OK : FAIL);
X#endif
X}
X
X/*
X * get file permissions for 'name'
X */
X    long
Xgetperm(name)
X    char_u        *name;
X{
X    struct FileInfoBlock    *fib;
X    long                     retval = -1;
X
X    fib = get_fib(name);
X    if (fib != NULL)
X    {
X        retval = fib->fib_Protection;
X        free(fib);
X    }
X    return retval;
X}
X
X/*
X * set file permission for 'name' to 'perm'
X *
X * return FAIL for failure, OK otherwise
X */
X    int
Xsetperm(name, perm)
X    char_u        *name;
X    long        perm;
X{
X    perm &= ~FIBF_ARCHIVE;                /* reset archived bit */
X    return (SetProtection((UBYTE *)name, (long)perm) ? OK : FAIL);
X}
X
X/*
X * return FALSE if "name" is not a directory
X * return TRUE if "name" is a directory.
X * return -1 for error.
X */
X    int
Xisdir(name)
X    char_u        *name;
X{
X    struct FileInfoBlock    *fib;
X    int                     retval = -1;
X
X    fib = get_fib(name);
X    if (fib != NULL)
X    {
X        retval = ((fib->fib_DirEntryType >= 0) ? TRUE : FALSE);
X        free(fib);
X    }
X    return retval;
X}
X
X/*
X * Careful: mch_windexit() may be called before mch_windinit()!
X */
X    void
Xmch_windexit(r)
X    int             r;
X{
X    if (raw_in)                        /* put terminal in 'normal' mode */
X    {
X        settmode(0);
X        stoptermcap();
X    }
X    if (raw_out)
X    {
X        if (term_console)
X        {
X            win_resize_off();        /* window resize events de-activated */
X            if (size_set)
X                OUTSTR("\233t\233u");        /* reset window size (CSI t CSI u) */
X        }
X        flushbuf();
X    }
X
X    mch_restore_title(3);            /* restore window title */
X
X    ml_close_all();                 /* remove all memfiles */
X
X#ifndef NO_ARP
X    if (ArpBase)
X        CloseLibrary((struct Library *) ArpBase);
X#endif
X    if (close_win)
X        Close(raw_in);
X    if (r)
X        printf("Vim exiting with %d\n", r);    /* somehow this makes :cq work!? */
X    exit(r);
X}
X
X/*
X * This is a routine for setting a given stream to raw or cooked mode on the
X * Amiga . This is useful when you are using Lattice C to produce programs
X * that want to read single characters with the "getch()" or "fgetc" call.
X *
X * Written : 18-Jun-87 By Chuck McManis.
X */
X
X#define MP(xx)    ((struct MsgPort *)((struct FileHandle *) (BADDR(xx)))->fh_Type)
X
X/*
X * Function mch_settmode() - Convert the specified file pointer to 'raw' or 'cooked'
X * mode. This only works on TTY's.
X *
X * Raw: keeps DOS from translating keys for you, also (BIG WIN) it means
X *        getch() will return immediately rather than wait for a return. You
X *        lose editing features though.
X *
X * Cooked: This function returns the designate file pointer to it's normal,
X *        wait for a <CR> mode. This is exactly like raw() except that
X *        it sends a 0 to the console to make it back into a CON: from a RAW:
X */
X    void
Xmch_settmode(raw)
X    int            raw;
X{
X    if (dos_packet(MP(raw_in), (long)ACTION_SCREEN_MODE, raw ? -1L : 0L) == 0)
X        fprintf(stderr, "cannot change console mode ?!\n");
X}
X
X/*
X * set screen mode, always fails.
X */
X    int
Xmch_screenmode(arg)
X    char_u     *arg;
X{
X    EMSG("Screen mode setting not supported");
X    return FAIL;
X}
X
X/*
X * Code for this routine came from the following :
X *
X * ConPackets.c -  C. Scheppner, A. Finkel, P. Lindsay    CBM
X *     DOS packet example
X *     Requires 1.2
X *
X * Found on Fish Disk 56.
X *
X * Heavely modified by mool.
X */
X
X#include <devices/conunit.h>
X
X/*
X * try to get the real window size
X * return FAIL for failure, OK otherwise
X */
X    int
Xmch_get_winsize()
X{
X    struct ConUnit    *conUnit;
X     char            id_a[sizeof(struct InfoData) + 3];
X    struct InfoData *id;
X
X    if (!term_console)    /* not an amiga window */
X        return FAIL;
X
X    /* insure longword alignment */
X     id = (struct InfoData *)(((long)id_a + 3L) & ~3L);
X
X    /*
X     * Should make console aware of real window size, not the one we set.
X     * Unfortunately, under DOS 2.0x this redraws the window and it
X     * is rarely needed, so we skip it now, unless we changed the size.
X     */
X    if (size_set)
X        OUTSTR("\233t\233u");    /* CSI t CSI u */
X    flushbuf();
X
X    if (dos_packet(MP(raw_out), (long)ACTION_DISK_INFO, ((ULONG) id) >> 2) == 0 ||
X                (wb_window = (struct Window *)id->id_VolumeNode) == NULL)
X    {
X        /* it's not an amiga window, maybe aux device */
X        /* terminal type should be set */
X        term_console = FALSE;
X        return FAIL;
X    }
X    if (oldwindowtitle == NULL)
X        oldwindowtitle = (char_u *)wb_window->Title;
X    if (id->id_InUse == (BPTR)NULL)
X    {
X        fprintf(stderr, "mch_get_winsize: not a console??\n");
X        return FAIL;
X    }
X    conUnit = (struct ConUnit *) ((struct IOStdReq *) id->id_InUse)->io_Unit;
X
X    /* get window size */
X    Rows = conUnit->cu_YMax + 1;
X    Columns = conUnit->cu_XMax + 1;
X    if (Rows < 0 || Rows > 200)     /* cannot be an amiga window */
X    {
X        Columns = 80;
X        Rows = 24;
X        term_console = FALSE;
X        return FAIL;
X    }
X    check_winsize();
X
X    return OK;
X}
X
X/*
X * try to set the real window size
X */
X    void
Xmch_set_winsize()
X{
X    if (term_console)
X    {
X        size_set = TRUE;
X        outchar(CSI);
X        outnum((long)Rows);
X        outchar('t');
X        outchar(CSI);
X        outnum((long)Columns);
X        outchar('u');
X        flushbuf();
X    }
X}
X
X#ifdef SETKEYMAP
X/*
X * load and activate a new keymap for our CLI - DOES NOT WORK -
X * The problem is that after the setting of the keymap the input blocks
X * But the new keymap works allright in another window.
X * Tried but no improvement:
X * - remembering the length, data and command fields in request->io_xxx
X * - settmode(0) first, settmode(1) afterwards
X * - putting the keymap directly in conunit structure
X */
X
X#include <devices/keymap.h>
X
X    void
Xset_keymap(name)
X    char_u *name;
X{
X     char                    id_a[sizeof(struct InfoData) + 3];
X    struct InfoData            *id;
X    static struct KeyMap    *old;
X    static BPTR                segment = (BPTR)NULL;
X    struct IOStdReq            *request;
X    int                        c;
X
X    if (!term_console)
X        return;
X
X    /* insure longword alignment */
X     id = (struct InfoData *)(((long)id_a + 3L) & ~3L);
X
X    if (dos_packet(MP(raw_out), (long)ACTION_DISK_INFO, ((ULONG) id) >> 2) == 0)
X    {
X        EMSG("dos_packet failed");
X        return;
X    }
X    if (id->id_InUse == (BPTR)NULL)
X    {
X        EMSG("not a console??");
X        return;
X    }
X    request = (struct IOStdReq *) id->id_InUse;
X
X    if (segment != (BPTR)NULL)    /* restore old keymap */
X    {
X        request->io_Command = CD_SETKEYMAP;
X        request->io_Length = sizeof(struct KeyMap);
X        request->io_Data = (APTR)old;
X        DoIO((struct IORequest *)request);
X        if (request->io_Error)
X            EMSG("Cannot reset keymap");
X        else                /* no error, free the allocated memory */
X        {
X            UnLoadSeg(segment);
X            FreeMem(old, sizeof(struct KeyMap));
X            segment = (BPTR)NULL;
X        }
X    }
X    if (name != NULL)
X    {
X        segment = LoadSeg(name);
X        if (segment == (BPTR)NULL)
X        {
X            EMSG("Cannot open keymap file");
X            return;
X        }
X        old = (struct KeyMap *)AllocMem(sizeof(struct KeyMap), MEMF_PUBLIC);
X        if (old == NULL)
X        {
X            EMSG(e_outofmem);
X            UnLoadSeg(segment);
X            segment = (BPTR)NULL;
X        }
X        else
X        {
X            request->io_Command = CD_ASKKEYMAP;
X            request->io_Length = sizeof(struct KeyMap);
X            request->io_Data = (APTR)old;
X            DoIO((struct IORequest *)request);
X            if (request->io_Error)
X            {
X                EMSG("Cannot get old keymap");
X                UnLoadSeg(segment);
X                segment = (BPTR)NULL;
X                FreeMem(old, sizeof(struct KeyMap));
X            }
X            else
X            {
X                request->io_Command = CD_SETKEYMAP;
X                request->io_Length = sizeof(struct KeyMap);
X                request->io_Data = (APTR)((segment << 2) + 18);
X                DoIO((struct IORequest *)request);
X                if (request->io_Error)
X                    EMSG("Cannot set keymap");
X
X                /* test for blocking */
X                request->io_Command = CMD_READ;
X                request->io_Length = 1;
X                request->io_Data = (APTR)&c;
X                DoIO((struct IORequest *)request);    /* BLOCK HERE! */
X                if (request->io_Error)
X                    EMSG("Cannot set keymap");
X            }
X        }
X    }
X}
X#endif
X
X#ifndef AZTEC_C
X/*
X * Sendpacket.c
X *
X * An invaluable addition to your Amiga.lib file. This code sends a packet to
X * the given message port. This makes working around DOS lots easier.
X *
X * Note, I didn't write this, those wonderful folks at CBM did. I do suggest
X * however that you may wish to add it to Amiga.Lib, to do so, compile it and
X * say 'oml lib:amiga.lib -r sendpacket.o'
X */
X
X/* #include <proto/exec.h> */
X/* #include <proto/dos.h> */
X#include <exec/memory.h>
X
X/*
X * Function - dos_packet written by Phil Lindsay, Carolyn Scheppner, and Andy
X * Finkel. This function will send a packet of the given type to the Message
X * Port supplied.
X */
X
X    static long
Xdos_packet(pid, action, arg)
X    struct MsgPort *pid;    /* process indentifier ... (handlers message port) */
X    long            action, /* packet type ... (what you want handler to do)   */
X                    arg;    /* single argument */
X{
X# ifndef NO_ARP
X    struct MsgPort            *replyport;
X    struct StandardPacket    *packet;
X    long                    res1;
X
X    if (dos2)
X# endif
X        return DoPkt(pid, action, arg, 0L, 0L, 0L, 0L);    /* use 2.0 function */
X# ifndef NO_ARP
X
X    replyport = (struct MsgPort *) CreatePort(NULL, 0);    /* use arp function */
X    if (!replyport)
X        return (0);
X
X    /* Allocate space for a packet, make it public and clear it */
X    packet = (struct StandardPacket *)
X        AllocMem((long) sizeof(struct StandardPacket), MEMF_PUBLIC | MEMF_CLEAR);
X    if (!packet) {
X        DeletePort(replyport);
X        return (0);
X    }
X    packet->sp_Msg.mn_Node.ln_Name = (char *) &(packet->sp_Pkt);
X    packet->sp_Pkt.dp_Link = &(packet->sp_Msg);
X    packet->sp_Pkt.dp_Port = replyport;
X    packet->sp_Pkt.dp_Type = action;
X    packet->sp_Pkt.dp_Arg1 = arg;
X
X    PutMsg(pid, (struct Message *)packet);        /* send packet */
X
X    WaitPort(replyport);
X    GetMsg(replyport);
X
X    res1 = packet->sp_Pkt.dp_Res1;
X
X    FreeMem(packet, (long) sizeof(struct StandardPacket));
X    DeletePort(replyport);
X
X    return (res1);
X# endif
X}
X#endif
X
X/*
X * call shell, return FAIL for failure, OK otherwise
X */
X    int
Xcall_shell(cmd, filter, cooked)
X    char_u    *cmd;
X    int        filter;        /* if != 0: called by dofilter() */
X    int        cooked;
X{
X    BPTR    mydir;
X    int        x;
X#ifndef LATTICE
X    int        use_execute;
X    char_u    *shellcmd = NULL;
X    char_u    *shellarg;
X#endif
X    int    retval = OK;
X
X    if (close_win)
X    {
X        /* if Vim opened a window: Executing a shell may cause crashes */
X        EMSG("Cannot execute shell with -e or -x option");
X        return FAIL;
X    }
X
X    if (term_console)
X        win_resize_off();             /* window resize events de-activated */
X    flushbuf();
X
X    if (cooked)
X        settmode(0);                 /* set to cooked mode */
X    mydir = Lock((UBYTE *)"", (long)ACCESS_READ);    /* remember current directory */
X
X#ifdef LATTICE                        /* not tested very much */
X    if (cmd == NULL)
X    {
X# ifndef NO_ARP
X        if (dos2)
X# endif
X            x = SystemTags(p_sh, SYS_UserShell, TRUE, TAG_DONE);
X# ifndef NO_ARP
X        else
X            x = Execute(p_sh, raw_in, raw_out);
X# endif
X    }
X    else
X    {
X# ifndef NO_ARP
X        if (dos2)
X# endif
X            x = SystemTags((char *)cmd, SYS_UserShell, TRUE, TAG_DONE);
X# ifndef NO_ARP
X        else
X            x = Execute((char *)cmd, 0L, raw_out);
X# endif
X    }
X# ifdef NO_ARP
X    if (x < 0)
X# else
X    if ((dos2 && x < 0) || (!dos2 && !x))
X# endif
X    {
X        outstr((char_u *)"Cannot execute ");
X        if (cmd == NULL)
X        {
X            outstr((char_u *)"shell ");
X            outstr(p_sh);
X        }
X        else
X            outstr(cmd);
X        outchar('\n');
X        retval = FAIL;
X    }
X# ifdef NO_ARP
X    else if (x)
X# else
X    else if (!dos2 || x)
X# endif
X    {
X        if (x = IoErr())
X        {
X#ifdef WEBB_COMPLETE
X            if (!expand_interactively)
X#endif
X            {
X                outchar('\n');
X                outnum(x);
X                outstr((char_u *)" returned\n");
X            }
X            retval = FAIL;
X        }
X    }
X#else    /* !LATTICE */
X    if (p_st >= 4 || (p_st >= 2 && !filter))
X        use_execute = 1;
X    else
X        use_execute = 0;
X    if (!use_execute)
X    {
X        /*
X         * separate shell name from argument
X         */
X        shellcmd = strsave(p_sh);
X        if (shellcmd == NULL)        /* out of memory, use Execute */
X            use_execute = 1;
X        else
X        {
X            shellarg = shellcmd;
X            skiptospace(&shellarg);    /* find start of arguments */
X            if (*shellarg != NUL)
X            {
X                *shellarg++ = NUL;
X                skipspace(&shellarg);
X            }
X        }
X    }
X    if (cmd == NULL)
X    {
X        if (use_execute)
X        {
X# ifndef NO_ARP
X            if (dos2)
X# endif
X                x = SystemTags((UBYTE *)p_sh, SYS_UserShell, TRUE, TAG_DONE);
X# ifndef NO_ARP
X            else
X                x = !Execute((UBYTE *)p_sh, raw_in, raw_out);
X# endif
X        }
X        else
X            x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg, NULL);
X    }
X    else if (use_execute)
X    {
X# ifndef NO_ARP
X        if (dos2)
X# endif
X            x = SystemTags((UBYTE *)cmd, SYS_UserShell, TRUE, TAG_DONE);
X# ifndef NO_ARP
X        else
X            x = !Execute((UBYTE *)cmd, 0L, raw_out);
X# endif
X    }
X    else if (p_st & 1)
X        x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg, (char *)cmd, NULL);
X    else
X        x = fexecl((char *)shellcmd, (char *)shellcmd, (char *)shellarg, "-c", (char *)cmd, NULL);
X# ifdef NO_ARP
X    if (x < 0)
X# else
X    if ((dos2 && x < 0) || (!dos2 && x))
X# endif
X    {
X        outstr((char_u *)"Cannot execute ");
X        if (use_execute)
X        {
X            if (cmd == NULL)
X                outstr(p_sh);
X            else
X                outstr(cmd);
X        }
X        else
X        {
X            outstr((char_u *)"shell ");
X            outstr(shellcmd);
X        }
X        outchar('\n');
X        retval = FAIL;
X    }
X    else
X    {
X        if (use_execute)
X        {
X# ifdef NO_ARP
X            if (x)
X# else
X            if (!dos2 || x)
X# endif
X                x = IoErr();
X        }
X        else
X            x = wait();
X        if (x)
X        {
X#ifdef WEBB_COMPLETE
X            if (!expand_interactively)
X#endif
X            {
X                outchar('\n');
X                outnum((long)x);
X                outstrn((char_u *)" returned\n");
X            }
X            retval = FAIL;
X        }
X    }
X    free(shellcmd);
X#endif    /* !LATTICE */
X
X    if (mydir = CurrentDir(mydir))        /* make sure we stay in the same directory */
X        UnLock(mydir);
X    if (cooked)
X        settmode(1);                     /* set to raw mode */
X    resettitle();
X    if (term_console)
X        win_resize_on();                 /* window resize events activated */
X    return retval;
X}
X
X/*
X * check for an "interrupt signal"
X * We only react to a CTRL-C, but also clear the other break signals to avoid trouble
X * with lattice-c programs.
X */
X    void
Xbreakcheck()
X{
X   if (SetSignal(0L, (long)(SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D|SIGBREAKF_CTRL_E|SIGBREAKF_CTRL_F)) & SIGBREAKF_CTRL_C)
X        got_int = TRUE;
X}
X
X/* this routine causes manx to use this Chk_Abort() rather than it's own */
X/* otherwise it resets our ^C when doing any I/O (even when Enable_Abort */
X/* is zero).  Since we want to check for our own ^C's                    */
X
X#ifdef _DCC
X#define Chk_Abort chkabort
X#endif
X
X    long
XChk_Abort()
X{
X    return(0L);
X}
X
X/*
X * ExpandWildCard() - this code does wild-card pattern matching using the arp
X *                      routines. This is based on WildDemo2.c (found in arp1.1
X *                      distribution). That code's copyright follows :
X *-------------------------------------------------------------------------
X * WildDemo2.c - Search filesystem for patterns, and separate into directories
X *         and files, sorting each separately using DA lists.
X *
X * -+=SDB=+-
X *
X * Copyright (c) 1987, Scott Ballantyne
X * Use and abuse as you please.
X *
X * num_pat is number of input patterns
X * pat is array of pointers to input patterns
X * num_file is pointer to number of matched file names
X * file is pointer to array of pointers to matched file names
X * if file_only is TRUE we match only files, no dirs
X * if list_notfound is TRUE we include not-found entries (probably locked)
X * return OK for success, FAIL for error (you may loose some memory)
X *-------------------------------------------------------------------------
X */
X
X/* #include <arpfunctions.h> */
Xextern void *malloc __ARGS((size_t)), *calloc __ARGS((size_t, size_t));
Xstatic int insfile __ARGS((char_u *, int));
Xstatic void freefiles __ARGS((void));
X
X#define ANCHOR_BUF_SIZE (512)
X#define ANCHOR_SIZE (sizeof(struct AnchorPath) + ANCHOR_BUF_SIZE)
X
X/*
X * we use this structure to built a list of file names
X */
Xstruct onefile
X{
X    struct onefile    *next;
X    char_u            name[1];    /* really longer */
X} *namelist = NULL;
X
X/*
X * insert one file into the list of file names
X * return FAIL for failure
X * return OK for success
X */
X    static int
Xinsfile(name, isdir)
X    char_u    *name;
X    int        isdir;
X{
X    struct onefile *new;
X
X    new = (struct onefile *)alloc((unsigned)(sizeof(struct onefile) + STRLEN(name) + isdir));
X    if (new == NULL)
X        return FAIL;
X    STRCPY(&(new->name[0]), name);
X    if (isdir)
X        STRCAT(&(new->name[0]), "/");
X    new->next = namelist;
X    namelist = new;
X    return OK;
X}
X
X/*
X * free a whole list of file names
X */
X    static void
Xfreefiles()
X{
X    struct onefile *p;
X
X    while (namelist)
X    {
X        p = namelist->next;
X        free(namelist);
X        namelist = p;
X    }
X}
X
X    static int
Xsortcmp(a, b)
X    char **a, **b;
X{
X    return strcmp(*a, *b);
X}
X
X    int
XExpandWildCards(num_pat, pat, num_file, file, files_only, list_notfound)
X    int             num_pat;
X    char_u          **pat;
X    int            *num_file;
X    char_u         ***file;
X    int            files_only;
X    int            list_notfound;
X{
X    int                     i;
X    struct AnchorPath        *Anchor;
X    int                        domatchend = FALSE;
X    LONG                    Result;
X    struct onefile            *p;
X    char_u                    *errmsg = NULL;
X    char_u                    *starbuf, *sp, *dp;
X    int                        foundone;
X
X    *num_file = 0;
X    *file = (char_u **)"";
X
X    /* Get our AnchorBase */
X    Anchor = (struct AnchorPath *) calloc((size_t)1, (size_t)ANCHOR_SIZE);
X    if (!Anchor)
X        goto OUT_OF_MEMORY;
X    Anchor->ap_StrLen = ANCHOR_BUF_SIZE;    /* ap_Length not supported anymore */
X#ifdef APF_DODOT
X    Anchor->ap_Flags = APF_DODOT | APF_DOWILD;        /* allow '.' for current dir */
X#else
X    Anchor->ap_Flags = APF_DoDot | APF_DoWild;        /* allow '.' for current dir */
X#endif
X
X    for (i = 0; i < num_pat; i++)
X    {
X#ifndef NO_ARP
X        if (dos2)
X        {
X#endif
X                /* hack to replace '*' by '#?' */
X            starbuf = alloc((unsigned)(2 * STRLEN(pat[i]) + 1));    /* maximum required */
X            if (starbuf == NULL)
X                goto OUT_OF_MEMORY;
X            for (sp = pat[i], dp = starbuf; *sp; ++sp)
X            {
X                if (*sp == '*')
X                {
X                    *dp++ = '#';
X                    *dp++ = '?';
X                }
X                else
X                    *dp++ = *sp;
X            }
X            *dp = NUL;
X            Result = MatchFirst((UBYTE *)starbuf, Anchor);
X            free(starbuf);
X#ifndef NO_ARP
X        }
X        else
X            Result = FindFirst((char *)pat[i], Anchor);
X#endif
X        domatchend = TRUE;
X        foundone = FALSE;
X        while (Result == 0)
X        {
X            if (!files_only || Anchor->ap_Info.fib_DirEntryType < 0)
X            {
X                (*num_file)++;
X                if (insfile((char_u *)Anchor->ap_Buf, Anchor->ap_Info.fib_DirEntryType >= 0) == FAIL)
X                {
XOUT_OF_MEMORY:
X                    errmsg = (char_u *)"Out of memory";
X                    goto Return;
X                }
X                foundone = TRUE;
X            }
X#ifndef NO_ARP
X            if (dos2)
X#endif
X                Result = MatchNext(Anchor);
X#ifndef NO_ARP
X            else
X                Result = FindNext(Anchor);
X#endif
X        }
X        if (Result == ERROR_BUFFER_OVERFLOW)
X        {
X            errmsg = (char_u *)"ANCHOR_BUF_SIZE too small.";
X            goto Return;
X        }
X        if (!foundone)
X        {
X            if (list_notfound)    /* put object with error in list */
X            {
X                (*num_file)++;
X                if (insfile(pat[i], FALSE) == FAIL)
X                    goto OUT_OF_MEMORY;
X            }
X            else if (Result != ERROR_OBJECT_NOT_FOUND && Result != ERROR_NO_MORE_ENTRIES)
X            {
X                errmsg = (char_u *)"I/O ERROR";
X                goto Return;
X            }
X        }
X#ifndef NO_ARP
X        if (dos2)
X#endif
X            MatchEnd(Anchor);
X#ifndef NO_ARP
X        else
X            FreeAnchorChain(Anchor);
X#endif
X        domatchend = FALSE;
X    }
X
X    p = namelist;
X    if (p)
X    {
X        *file = (char_u **) malloc(sizeof(char_u *) * (*num_file));
X        if (*file == NULL)
X            goto OUT_OF_MEMORY;
X        for (i = *num_file - 1; p; p = p->next, --i)
X        {
X            (*file)[i] = (char_u *) malloc(STRLEN(p->name) + 1);
X            if ((*file)[i] == NULL)
X                goto OUT_OF_MEMORY;
X            STRCPY((*file)[i], p->name);
X        }
X        qsort((void *)*file, (size_t)*num_file, sizeof(char_u *), sortcmp);
X    }
XReturn:
X    if (domatchend)
X    {
X#ifndef NO_ARP
X        if (dos2)
X#endif
X            MatchEnd(Anchor);
X#ifndef NO_ARP
X        else
X            FreeAnchorChain(Anchor);
X#endif
X    }
X    if (Anchor)
X        free(Anchor);
X    freefiles();
X    if (errmsg)
X    {
X        emsg(errmsg);
X        *num_file = 0;
X        return FAIL;
X    }
X    return OK;
X}
X
X    void
XFreeWild(num, file)
X    int        num;
X    char_u    **file;
X{
X    if (file == NULL || num == 0)
X        return;
X    while (num--)
X        free(file[num]);
X    free(file);
X}
X
X    int
Xhas_wildcard(p)
X    char_u *p;
X{
X    for ( ; *p; ++p)
X        if (strchr("*?[(~#", *p) != NULL)
X            return TRUE;
X    return FALSE;
X}
X
X/*
X * With 2.0 support for reading local environment variables
X * Careful: uses IObuff!
X */
X
X    char_u *
Xvimgetenv(var)
X    char_u *var;
X{
X    int len;
X
X#ifndef NO_ARP
X    if (!dos2)
X        return (char_u *)getenv((char *)var);
X#endif
X
X    len = GetVar((UBYTE *)var, (UBYTE *)IObuff, (long)(IOSIZE - 1), (long)0);
X
X    if (len == -1)
X        return NULL;
X    else
X        return IObuff;
X}
END_OF_FILE
  if test 32474 -ne `wc -c <'vim/src/amiga.c'`; then
    echo shar: \"'vim/src/amiga.c'\" unpacked with wrong size!
  fi
  # end of 'vim/src/amiga.c'
fi
if test -f 'vim/src/edit.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vim/src/edit.c'\"
else
  echo shar: Extracting \"'vim/src/edit.c'\" \(31932 characters\)
  sed "s/^X//" >'vim/src/edit.c' <<'END_OF_FILE'
X/* vi:ts=4:sw=4
X *
X * VIM - Vi IMproved        by Bram Moolenaar
X *
X * Read the file "credits.txt" for a list of people who contributed.
X * Read the file "uganda.txt" for copying and usage conditions.
X */
X
X/*
X * edit.c: functions for insert mode
X */
X
X#include "vim.h"
X#include "globals.h"
X#include "proto.h"
X#include "param.h"
X#include "ops.h"    /* for operator */
X
Xextern char_u *get_inserted();
Xstatic void start_arrow __ARGS((void));
Xstatic void stop_arrow __ARGS((void));
Xstatic void stop_insert __ARGS((void));
Xstatic int echeck_abbr __ARGS((int));
X
Xint arrow_used;                /* Normally FALSE, set to TRUE after hitting
X                             * cursor key in insert mode. Used by vgetorpeek()
X                             * to decide when to call u_sync() */
Xint restart_edit = 0;        /* call edit when next command finished */
Xstatic char_u    *last_insert = NULL;
X                            /* the text of the previous insert */
Xstatic int        last_insert_skip;
X                            /* number of chars in front of the previous insert */
Xstatic int        new_insert_skip;
X                            /* number of chars in front of the current insert */
X
X    void
Xedit(count)
X    long count;
X{
X    int             c;
X    int             cc;
X    char_u        *ptr;
X    char_u        *saved_line = NULL;        /* saved line for replace mode */
X    linenr_t     saved_lnum = 0;        /* lnum of saved line */
X    int             saved_char = NUL;        /* char replaced by NL */
X    linenr_t     lnum;
X    int          temp = 0;
X    int             mode;
X    int             nextc = 0;
X    int             lastc = 0;
X    colnr_t         mincol;
X    static linenr_t o_lnum = 0;
X    static int     o_eol = FALSE;
X#ifdef WEBB_KEYWORD_COMPL
X    FPOS         complete_pos;
X    FPOS         first_match;
X    char_u         *complete_pat = NULL;
X    char_u         *completion_str = NULL;
X    char_u         *last_completion_str = NULL;
X    char_u         *tmp_ptr;
X    int             previous_c = 0;
X    int             complete_col = 0;            /* init for gcc */
X    int             complete_direction;
X    int             complete_any_word = 0;        /* true -> ^N/^P hit with no prefix
X                                             * init for gcc */
X    int             done;
X    int             found_error = FALSE;
X    char_u         backup_char = 0;            /* init for gcc */
X
X    c = NUL;
X#endif /* WEBB_KEYWORD_COMPL */
X
X    if (restart_edit)
X    {
X        arrow_used = TRUE;
X        restart_edit = 0;
X        /*
X         * If the cursor was after the end-of-line before the CTRL-O
X         * and it is now at the end-of-line, put it after the end-of-line
X         * (this is not correct in very rare cases).
X         */
X        if (o_eol && curwin->w_cursor.lnum == o_lnum &&
X                *((ptr = ml_get(curwin->w_cursor.lnum)) + curwin->w_cursor.col) != NUL &&
X                *(ptr + curwin->w_cursor.col + 1) == NUL)
X            ++curwin->w_cursor.col;
X    }
X    else
X    {
X        arrow_used = FALSE;
X        o_eol = FALSE;
X    }
X
X#ifdef DIGRAPHS
X    dodigraph(-1);                    /* clear digraphs */
X#endif
X
X/*
X * Get the current length of the redo buffer, those characters have to be
X * skipped if we want to get to the inserted characters.
X */
X
X    ptr = get_inserted();
X    new_insert_skip = STRLEN(ptr);
X    free(ptr);
X
X    old_indent = 0;
X
X    for (;;)
X    {
X        if (arrow_used)        /* don't repeat insert when arrow key used */
X            count = 0;
X
X        if (!arrow_used)
X            curwin->w_set_curswant = TRUE;    /* set curwin->w_curswant for next K_DARROW or K_UARROW */
X        cursupdate();        /* Figure out where the cursor is based on curwin->w_cursor. */
X        showruler(0);
X        setcursor();
X#ifdef WEBB_KEYWORD_COMPL
X        previous_c = c;
X#endif /* WEBB_KEYWORD_COMPL */
X        if (nextc)            /* character remaining from CTRL-V */
X        {
X            c = nextc;
X            nextc = 0;
X        }
X        else
X        {
X            c = vgetc();
X            if (c == Ctrl('C'))
X                got_int = FALSE;
X        }
X#ifdef WEBB_KEYWORD_COMPL
X        if (previous_c == Ctrl('N') || previous_c == Ctrl('P'))
X        {
X            /* Show error message from attempted keyword completion (probably
X             * 'Pattern not found') until another key is hit, then go back to
X             * showing what mode we are in.
X             */
X            showmode();
X            if (c != Ctrl('N') && c != Ctrl('P'))
X            {
X                /* Get here when we have finished typing a sequence of ^N and
X                 * ^P. Free up memory that was used, and make sure we can redo
X                 * the insert.
X                 */
X                if (completion_str != NULL)
X                    AppendToRedobuff(completion_str);
X                free(complete_pat);
X                free(completion_str);
X                free(last_completion_str);
X                complete_pat = completion_str = last_completion_str = NULL;
X            }
X        }
X#endif /* WEBB_KEYWORD_COMPL */
X        if (c != Ctrl('D'))            /* remember to detect ^^D and 0^D */
X            lastc = c;
X
X/*
X * In replace mode a backspace puts the original text back.
X * We save the current line to be able to do that.
X * If characters are appended to the line, they will be deleted.
X * If we start a new line (with CR) the saved line will be empty, thus
X * the characters will be deleted.
X * If we backspace over the new line, that line will be saved.
X */
X        if (State == REPLACE && saved_lnum != curwin->w_cursor.lnum)
X        {
X            free(saved_line);
X            saved_line = strsave(ml_get(curwin->w_cursor.lnum));
X            saved_lnum = curwin->w_cursor.lnum;
X        }
X
X#ifdef DIGRAPHS
X        c = dodigraph(c);
X#endif /* DIGRAPHS */
X
X        if (c == Ctrl('V'))
X        {
X            screen_start();
X            screen_outchar('^', curwin->w_row, curwin->w_col);
X            AppendToRedobuff((char_u *)"\026");    /* CTRL-V */
X            cursupdate();
X            setcursor();
X
X            c = get_literal(&nextc);
X
X            insertchar(c);
X            continue;
X        }
X        switch (c)        /* handle character in insert mode */
X        {
X              case Ctrl('O'):        /* execute one command */
X                if (echeck_abbr(Ctrl('O') + 0x100))
X                    break;
X                  count = 0;
X                if (State == INSERT)
X                    restart_edit = 'I';
X                else
X                    restart_edit = 'R';
X                o_lnum = curwin->w_cursor.lnum;
X                o_eol = (gchar_cursor() == NUL);
X                goto doESCkey;
X
X              case ESC:             /* an escape ends input mode */
X                if (echeck_abbr(ESC + 0x100))
X                    break;
X                /*FALLTHROUGH*/
X
X              case Ctrl('C'):
XdoESCkey:
X                if (!arrow_used)
X                {
X                    AppendToRedobuff(ESC_STR);
X
X                    if (--count > 0)        /* repeat what was typed */
X                    {
X                            (void)start_redo_ins();
X                            continue;
X                    }
X                    stop_insert();
X                }
X                if (!restart_edit)
X                    curwin->w_set_curswant = TRUE;
X
X                /*
X                 * The cursor should end up on the last inserted character.
X                 */
X                if (curwin->w_cursor.col != 0 && (!restart_edit || gchar_cursor() == NUL) && !p_ri)
X                    dec_cursor();
X                if (extraspace)            /* did reverse replace in column 0 */
X                {
X                    (void)delchar(FALSE);
X                    updateline();
X                    extraspace = FALSE;
X                }
X                State = NORMAL;
X                    /* inchar() may have deleted the "INSERT" message */
X                if (Recording)
X                    showmode();
X                else if (p_smd)
X                    MSG("");
X                free(saved_line);
X                old_indent = 0;
X                return;
X
X                  /*
X                 * Insert the previously inserted text.
X                 * Last_insert actually is a copy of the redo buffer, so we
X                 * first have to remove the command.
X                 * For ^@ the trailing ESC will end the insert.
X                 */
X              case K_ZERO:
X              case Ctrl('A'):
X                stuff_inserted(NUL, 1L, (c == Ctrl('A')));
X                break;
X
X                  /*
X                 * insert the contents of a register
X                 */
X              case Ctrl('R'):
X                  if (insertbuf(vgetc()) == FAIL)
X                    beep();
X                break;
X
X              case Ctrl('B'):            /* toggle reverse insert mode */
X                  p_ri = !p_ri;
X                showmode();
X                break;
X
X                /*
X                 * If the cursor is on an indent, ^T/^D insert/delete one
X                 * shiftwidth. Otherwise ^T/^D behave like a TAB/backspace.
X                 * This isn't completely compatible with
X                 * vi, but the difference isn't very noticeable and now you can
X                 * mix ^D/backspace and ^T/TAB without thinking about which one
X                 * must be used.
X                 */
X              case Ctrl('T'):        /* make indent one shiftwidth greater */
X              case Ctrl('D'):         /* make indent one shiftwidth smaller */
X                stop_arrow();
X                AppendCharToRedobuff(c);
X                if ((lastc == '0' || lastc == '^') && curwin->w_cursor.col)
X                {
X                    --curwin->w_cursor.col;
X                    (void)delchar(FALSE);            /* delete the '^' or '0' */
X                    if (lastc == '^')
X                        old_indent = get_indent();    /* remember current indent */
X
X                        /* determine offset from first non-blank */
X                    temp = curwin->w_cursor.col;
X                    beginline(TRUE);
X                    temp -= curwin->w_cursor.col;
X                    set_indent(0, TRUE);    /* remove all indent */
X                }
X                else
X                {
Xins_indent:
X                        /* determine offset from first non-blank */
X                    temp = curwin->w_cursor.col;
X                    beginline(TRUE);
X                    temp -= curwin->w_cursor.col;
X
X                    shift_line(c == Ctrl('D'), TRUE, 1);
X
X                        /* try to put cursor on same character */
X                    temp += curwin->w_cursor.col;
X                }
X                if (temp <= 0)
X                    curwin->w_cursor.col = 0;
X                else
X                    curwin->w_cursor.col = temp;
X                did_ai = FALSE;
X                did_si = FALSE;
X                can_si = FALSE;
X                  goto redraw;
X
X              case BS:
X              case DEL:
Xnextbs:
X                mode = 0;
Xdodel:
X                /* can't delete anything in an empty file */
X                /* can't backup past first character in buffer */
X                /* can't backup past starting point unless 'backspace' > 1 */
X                /* can backup to a previous line if 'backspace' == 0 */
X                if (bufempty() || (!p_ri &&
X                        ((curwin->w_cursor.lnum == 1 && curwin->w_cursor.col <= 0) ||
X                        (p_bs < 2 && (arrow_used ||
X                            (curwin->w_cursor.lnum == Insstart.lnum &&
X                            curwin->w_cursor.col <= Insstart.col) ||
X                            (curwin->w_cursor.col <= 0 && p_bs == 0))))))
X                {
X                    beep();
X                    goto redraw;
X                }
X
X                stop_arrow();
X                if (p_ri)
X                    inc_cursor();
X                if (curwin->w_cursor.col <= 0)        /* delete newline! */
X                {
X                    lnum = Insstart.lnum;
X                    if (curwin->w_cursor.lnum == Insstart.lnum || p_ri)
X                    {
X                        if (!u_save((linenr_t)(curwin->w_cursor.lnum - 2), (linenr_t)(curwin->w_cursor.lnum + 1)))
X                            goto redraw;
X                        --Insstart.lnum;
X                        Insstart.col = 0;
X                        /* this is in xvim, why?
X                        if (curbuf->b_p_ai)
X                            for (ptr = ml_get(Insstart.lnum);
X                                            iswhite(*ptr++); Insstart.col++)
X                                ; */
X                    }
X                /* in replace mode, in the line we started replacing, we
X                                                        only move the cursor */
X                    if (State != REPLACE || curwin->w_cursor.lnum > lnum)
X                    {
X                        temp = gchar_cursor();        /* remember current char */
X                        --curwin->w_cursor.lnum;
X                        (void)dojoin(FALSE, TRUE);
X                        if (temp == NUL && gchar_cursor() != NUL)
X                            ++curwin->w_cursor.col;
X                        if (saved_char)                /* restore what NL replaced */
X                        {
X                            State = NORMAL;            /* no replace for this char */
X                            inschar(saved_char);    /* but no showmatch */
X                            State = REPLACE;
X                            saved_char = NUL;
X                            if (!p_ri)
X                                dec_cursor();
X                        }
X                        else if (p_ri)                /* in reverse mode */
X                            saved_lnum = 0;            /* save this line again */
X                    }
X                    else
X                        dec_cursor();
X                    did_ai = FALSE;
X                }
X                else
X                {
X                    if (p_ri && State != REPLACE)
X                        dec_cursor();
X                    mincol = 0;
X                    if (mode == 3 && !p_ri && curbuf->b_p_ai)    /* keep indent */
X                    {
X                        temp = curwin->w_cursor.col;
X                        beginline(TRUE);
X                        if (curwin->w_cursor.col < temp)
X                            mincol = curwin->w_cursor.col;
X                        curwin->w_cursor.col = temp;
X                    }
X
X                    /* delete upto starting point, start of line or previous word */
X                    do
X                    {
X                        if (!p_ri)
X                            dec_cursor();
X
X                                /* start of word? */
X                        if (mode == 1 && !isspace(gchar_cursor()))
X                        {
X                            mode = 2;
X                            temp = isidchar(gchar_cursor());
X                        }
X                                /* end of word? */
X                        else if (mode == 2 && (isspace(cc = gchar_cursor()) || isidchar(cc) != temp))
X                        {
X                            if (!p_ri)
X                                inc_cursor();
X                            else if (State == REPLACE)
X                                dec_cursor();
X                            break;
X                        }
X                        if (State == REPLACE)
X                        {
X                            if (saved_line)
X                            {
X                                if (extraspace)
X                                {
X                                    if ((int)STRLEN(ml_get(curwin->w_cursor.lnum)) - 1 > (int)STRLEN(saved_line))
X                                        (void)delchar(FALSE);
X                                    else
X                                    {
X                                        dec_cursor();
X                                        (void)delchar(FALSE);
X                                        extraspace = FALSE;
X                                        pchar_cursor(*saved_line);
X                                    }
X                                }
X                                else if (curwin->w_cursor.col < STRLEN(saved_line))
X                                    pchar_cursor(saved_line[curwin->w_cursor.col]);
X                                else if (!p_ri)
X                                    (void)delchar(FALSE);
X                            }
X                        }
X                        else  /* State != REPLACE */
X                        {
X                            (void)delchar(FALSE);
X                            if (p_ri && gchar_cursor() == NUL)
X                                break;
X                        }
X                        if (mode == 0)        /* just a single backspace */
X                            break;
X                        if (p_ri && State == REPLACE && inc_cursor())
X                            break;
X                    } while (p_ri || (curwin->w_cursor.col > mincol && (curwin->w_cursor.lnum != Insstart.lnum ||
X                            curwin->w_cursor.col != Insstart.col)));
X                    if (extraspace)
X                        dec_cursor();
X                }
X                did_si = FALSE;
X                can_si = FALSE;
X                if (curwin->w_cursor.col <= 1)
X                    did_ai = FALSE;
X                /*
X                 * It's a little strange to put backspaces into the redo
X                 * buffer, but it makes auto-indent a lot easier to deal
X                 * with.
X                 */
X                AppendCharToRedobuff(c);
X                if (vpeekc() == BS)
X                {
X                        c = vgetc();
X                        goto nextbs;    /* speedup multiple backspaces */
X                }
Xredraw:
X                cursupdate();
X                updateline();
X                break;
X
X              case Ctrl('W'):        /* delete word before cursor */
X                  mode = 1;
X                  goto dodel;
X
X              case Ctrl('U'):        /* delete inserted text in current line */
X                mode = 3;
X                  goto dodel;
X
X              case K_LARROW:
X                  if (oneleft() == OK)
X                {
X                    start_arrow();
X                }
X                    /* if 'whichwrap' set for cursor in insert mode may go
X                     * to previous line */
X                else if ((p_ww & 16) && curwin->w_cursor.lnum > 1)
X                {
X                    start_arrow();
X                    --(curwin->w_cursor.lnum);
X                    coladvance(MAXCOL);
X                    curwin->w_curswant = MAXCOL;    /* so we stay at the end */
X                }
X                else
X                    beep();
X                break;
X
X              case K_SLARROW:
X                  if (curwin->w_cursor.lnum > 1 || curwin->w_cursor.col > 0)
X                {
X                    bck_word(1L, 0);
X                    start_arrow();
X                }
X                else
X                    beep();
X                break;
X
X              case K_RARROW:
X                if (gchar_cursor() != NUL)
X                {
X                    curwin->w_set_curswant = TRUE;
X                    start_arrow();
X                    ++curwin->w_cursor.col;
X                }
X                    /* if 'whichwrap' set for cursor in insert mode may go
X                     * to next line */
X                else if ((p_ww & 16) && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
X                {
X                    curwin->w_set_curswant = TRUE;
X                    start_arrow();
X                    ++curwin->w_cursor.lnum;
X                    curwin->w_cursor.col = 0;
X                }
X                else
X                    beep();
X                break;
X
X              case K_SRARROW:
X                  if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count || gchar_cursor() != NUL)
X                {
X                    fwd_word(1L, 0, 0);
X                    start_arrow();
X                }
X                else
X                    beep();
X                break;
X
X              case K_UARROW:
X                  if (oneup(1L))
X                    start_arrow();
X                else
X                    beep();
X                break;
X
X              case K_SUARROW:
X                  if (onepage(BACKWARD, 1L))
X                    start_arrow();
X                else
X                    beep();
X                break;
X
X              case K_DARROW:
X                  if (onedown(1L))
X                    start_arrow();
X                else
X                    beep();
X                break;
X
X              case K_SDARROW:
X                  if (onepage(FORWARD, 1L))
X                    start_arrow();
X                else
X                    beep();
X                break;
X
X              case TAB:
X                if (echeck_abbr(TAB + 0x100))
X                    break;
X                  if ((!curbuf->b_p_et && !(p_sta && inindent())) || (p_ri && State == REPLACE))
X                    goto normalchar;
X
X                AppendToRedobuff((char_u *)"\t");
X
X                if (!curbuf->b_p_et)                /* insert smart tab */
X                    goto ins_indent;
X
X                                        /* p_te set: expand a tab into spaces */
X                stop_arrow();
X                did_ai = FALSE;
X                did_si = FALSE;
X                can_si = FALSE;
X                if (p_sta && inindent())
X                    temp = (int)curbuf->b_p_sw;
X                else
X                    temp = (int)curbuf->b_p_ts;
X                temp -= curwin->w_cursor.col % temp;
X                inschar(' ');            /* delete one char in replace mode */
X                while (--temp)
X                    insstr((char_u *)" ");        /* insstr does not delete chars */
X                goto redraw;
X
X              case CR:
X              case NL:
X                if (echeck_abbr(c + 0x100))
X                    break;
X                stop_arrow();
X                if (State == REPLACE)
X                {
X                    saved_char = gchar_cursor();
X                    (void)delchar(FALSE);
X                }
X                /*
X                 * When 'autoindent' set delete white space after the cursor.
X                 * Vi does this, although it probably does it implicitly due
X                 * to the way it does auto-indent -- webb.
X                 */
X                if (curbuf->b_p_ai || curbuf->b_p_si)
X                    while ((c = gchar_cursor()) == ' ' || c == TAB)
X                        (void)delchar(FALSE);
X
X                AppendToRedobuff(NL_STR);
X                if (!Opencmd(FORWARD, TRUE, State == INSERT))
X                    goto doESCkey;        /* out of memory */
X                if (p_ri)
X                {
X                    dec_cursor();
X                    if (State == REPLACE && curwin->w_cursor.col > 0)
X                        dec_cursor();
X                }
X                break;
X
X#ifdef DIGRAPHS
X              case Ctrl('K'):
X                screen_start();
X                screen_outchar('?', curwin->w_row, curwin->w_col);
X                setcursor();
X                  c = vgetc();
X                if (c != ESC)
X                {
X                    if (charsize(c) == 1)
X                    {
X                        screen_start();
X                        screen_outchar(c, curwin->w_row, curwin->w_col);
X                    }
X                    setcursor();
X                    cc = vgetc();
X                    if (cc != ESC)
X                    {
X                        AppendToRedobuff((char_u *)"\026");    /* CTRL-V */
X                        c = getdigraph(c, cc, TRUE);
X                        goto normalchar;
X                    }
X                }
X                updateline();
X                goto doESCkey;
X#endif /* DIGRAPHS */
X
X#ifdef WEBB_KEYWORD_COMPL
X              case Ctrl('P'):            /* Do previous pattern completion */
X              case Ctrl('N'):            /* Do next pattern completion */
X                if (c == Ctrl('P'))
X                    complete_direction = BACKWARD;
X                else
X                    complete_direction = FORWARD;
X                if (previous_c != Ctrl('N') && previous_c != Ctrl('P'))
X                {
X                    /* First time we hit ^N or ^P (in a row, I mean) */
X                    complete_pos = curwin->w_cursor;
X                    ptr = ml_get(complete_pos.lnum);
X                    complete_col = complete_pos.col;
X                    temp = complete_col - 1;
X                    if (temp < 0 || !isidchar(ptr[temp]))
X                    {
X                        complete_pat = strsave((char_u *)"\\<[a-zA-Z_]");
X                        complete_any_word = TRUE;
X                    }
X                    else
X                    {
X                        while (temp >= 0 && isidchar(ptr[temp]))
X                            temp--;
X                        temp++;
X                        complete_pat = alloc(curwin->w_cursor.col - temp + 3);
X                        if (complete_pat != NULL)
X                            sprintf((char *)complete_pat, "\\<%.*s",
X                                (int)(curwin->w_cursor.col - temp), ptr + temp);
X                        complete_any_word = FALSE;
X                    }
X                    last_completion_str = strsave((char_u *)" ");
X                }
X                else
X                {
X                    /* This is not the first ^N or ^P we have hit in a row */
X                    while (curwin->w_cursor.col != complete_col)
X                    {
X                        curwin->w_cursor.col--;
X                        delchar(FALSE);
X                    }
X                    if (completion_str != NULL)
X                    {
X                        free(last_completion_str);
X                        last_completion_str = strsave(completion_str);
X                    }
X                }
X                if (complete_pat == NULL || last_completion_str == NULL)
X                {
X                    found_error = TRUE;
X                    break;
X                }
X                if (!complete_any_word)
X                {
X                    ptr = ml_get(curwin->w_cursor.lnum);
X                    backup_char = ptr[complete_col - 1];
X                    ptr[complete_col - 1] = ' ';
X                }
X                done = FALSE;
X                found_error = FALSE;
X                first_match.lnum = 0;
X                keep_old_search_pattern = TRUE;
X                while (!done)
X                {
X                    if (complete_direction == BACKWARD)
X                    {
X                        ptr = ml_get(complete_pos.lnum);
X                        while (isidchar(ptr[complete_pos.col]))
X                            complete_pos.col--;
X                        complete_pos.col++;
X                    }
X                    if (!searchit(&complete_pos, complete_direction,
X                        complete_pat, 1L, TRUE, TRUE))
X                    {
X                        found_error = TRUE;
X                        break;
X                    }
X                    if (complete_any_word)
X                        ptr = ml_get_pos(&complete_pos);
X                    else
X                        ptr = ml_get_pos(&complete_pos) + 1;
X                    tmp_ptr = ptr;
X                    temp = 1;
X                    while (*tmp_ptr != NUL && isidchar(*tmp_ptr++))
X                        temp++;
X                    free (completion_str);
X                    tmp_ptr = completion_str = alloc(temp);
X                    if (completion_str == NULL)
X                    {
X                        found_error = TRUE;
X                        break;
X                    }
X                    while (*ptr != NUL && isidchar(*ptr))
X                        *(tmp_ptr++) = *(ptr++);
X                    *tmp_ptr = NUL;
X                    if (completion_str[0] != NUL &&
X                            STRCMP(completion_str, last_completion_str) != 0)
X                        done = TRUE;
X                    else if (first_match.lnum == 0)
X                    {
X                        first_match.lnum = complete_pos.lnum;
X                        first_match.col = complete_pos.col;
X                    }
X                    else if (complete_pos.lnum == first_match.lnum
X                         && complete_pos.col == first_match.col)
X                    {
X                        if (completion_str[0] == NUL)
X                            EMSG("Exact match only");
X                        else
X                            EMSG("No other matches");
X                        done = TRUE;
X                    }
X                }
X                if (!found_error)
X                    insstr(completion_str);
X                if (!complete_any_word)
X                {
X                    ptr = ml_get(curwin->w_cursor.lnum);
X                    ptr[complete_col - 1] = backup_char;
X                }
X                keep_old_search_pattern = FALSE;
X                updateline();
X                break;
X#endif /* WEBB_KEYWORD_COMPL */
X
X              case Ctrl('Y'):                /* copy from previous line */
X                lnum = curwin->w_cursor.lnum - 1;
X                goto copychar;
X
X              case Ctrl('E'):                /* copy from next line */
X                lnum = curwin->w_cursor.lnum + 1;
Xcopychar:
X                if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
X                {
X                    beep();
X                    break;
X                }
X
X                /* try to advance to the cursor column */
X                temp = 0;
X                ptr = ml_get(lnum);
X                while (temp < curwin->w_virtcol && *ptr)
X                        temp += chartabsize(*ptr++, (long)temp);
X
X                if (temp > curwin->w_virtcol)
X                        --ptr;
X                if ((c = *ptr) == NUL)
X                {
X                    beep();
X                    break;
X                }
X
X                /*FALLTHROUGH*/
X              default:
Xnormalchar:
X                /*
X                 * do some very smart indenting when entering '{' or '}' or '#'
X                 */
X                if (curwin->w_cursor.col > 0 && ((can_si && c == '}') || (did_si && c == '{')))
X                {
X                    FPOS    *pos, old_pos;
X                    int        i;
X
X                        /* for '}' set indent equal to matching '{' */
X                    if (c == '}' && (pos = showmatch('{')) != NULL)
X                    {
X                        old_pos = curwin->w_cursor;
X                        curwin->w_cursor = *pos;
X                        i = get_indent();
X                        curwin->w_cursor = old_pos;
X                        set_indent(i, TRUE);
X                    }
X                    else
X                        shift_line(TRUE, TRUE, 1);
X                }
X                    /* set indent of '#' always to 0 */
X                if (curwin->w_cursor.col > 0 && can_si && c == '#')
X                {
X                                /* remember current indent for next line */
X                    old_indent = get_indent();
X                    set_indent(0, TRUE);
X                }
X
X                if (isidchar(c) || !echeck_abbr(c))
X                    insertchar(c);
X                break;
X            }
X    }
X}
X
X/*
X * Next character is interpreted literally.
X * A one, two or three digit decimal number is interpreted as its byte value.
X * If one or two digits are entered, *nextc is set to the next character.
X */
X    int
Xget_literal(nextc)
X    int *nextc;
X{
X    int             cc;
X    int             nc;
X    int             oldstate;
X    int             i;
X
X    oldstate = State;
X    State = NOMAPPING;        /* next characters not mapped */
X
X    if (got_int)
X    {
X        *nextc = NUL;
X        return Ctrl('C');
X    }
X    cc = 0;
X    for (i = 0; i < 3; ++i)
X    {
X        nc = vgetc();
X        if (!isdigit(nc))
X            break;
X        cc = cc * 10 + nc - '0';
X        nc = 0;
X    }
X    if (i == 0)        /* no number entered */
X    {
X        cc = nc;
X        nc = 0;
X        if (cc == K_ZERO)    /* NUL is stored as NL */
X            cc = '\n';
X    }
X    else if (cc == 0)        /* NUL is stored as NL */
X        cc = '\n';
X
X    State = oldstate;
X    *nextc = nc;
X    got_int = FALSE;        /* CTRL-C typed after CTRL-V is not an interrupt */
X    return cc;
X}
X
X/*
X * Special characters in this context are those that need processing other
X * than the simple insertion that can be performed here. This includes ESC
X * which terminates the insert, and CR/NL which need special processing to
X * open up a new line. This routine tries to optimize insertions performed by
X * the "redo", "undo" or "put" commands, so it needs to know when it should
X * stop and defer processing to the "normal" mechanism.
X */
X#define ISSPECIAL(c)    ((c) < ' ' || (c) >= DEL)
X
X    void
Xinsertchar(c)
X    unsigned    c;
X{
X    int        haveto_redraw = FALSE;
X    int        textwidth;
X
X    stop_arrow();
X
X    /*
X     * find out textwidth to be used:
X     *    if 'textwidth' option is set, use it
X     *    else if 'wrapmargin' option is set, use Columns - 'wrapmargin'
X     *    if invalid value, us 0.
X     */
X    textwidth = curbuf->b_p_tw;
X    if (textwidth == 0 && curbuf->b_p_wm)
X        textwidth = Columns - curbuf->b_p_wm;
X    if (textwidth < 0)
X        textwidth = 0;
X
X    /*
X     * If the cursor is past 'textwidth' and we are inserting a non-space,
X     * try to break the line in two or more pieces. If c == NUL then we have
X     * been called to do formatting only. If textwidth == 0 it does nothing.
X     * Don't do this if an existing character is being replaced.
X     */
X    if (c == NUL || !(isspace(c) || (State == REPLACE && *ml_get_cursor() != NUL)))
X    {
X        while (textwidth && curwin->w_virtcol >= textwidth)
X        {
X            int        startcol;        /* Cursor column at entry */
X            int        wantcol;        /* column at textwidth border */
X            int        foundcol;        /* column for start of word */
X
X            if ((startcol = curwin->w_cursor.col) == 0)
X                break;
X            coladvance(textwidth);            /* find column of textwidth border */
X            wantcol = curwin->w_cursor.col;
X
X            curwin->w_cursor.col = startcol - 1;
X            foundcol = 0;
X            while (curwin->w_cursor.col > 0)            /* find position to break at */
X            {
X                if (isspace(gchar_cursor()))
X                {
X                    while (curwin->w_cursor.col > 0 && isspace(gchar_cursor()))
X                        --curwin->w_cursor.col;
X                    if (curwin->w_cursor.col == 0)    /* only spaces in front of text */
X                        break;
X                    foundcol = curwin->w_cursor.col + 1;
X                    if (curwin->w_cursor.col < wantcol)
X                        break;
X                }
X                --curwin->w_cursor.col;
X            }
X
X            if (foundcol == 0)            /* no spaces, cannot break line */
X            {
X                curwin->w_cursor.col = startcol;
X                break;
X            }
X            curwin->w_cursor.col = foundcol;        /* put cursor after pos. to break line */
X            startcol -= foundcol;
X            Opencmd(FORWARD, FALSE, FALSE);
X            while (isspace(gchar_cursor()) && startcol)        /* delete blanks */
X            {
X                (void)delchar(FALSE);
X                --startcol;                /* adjust cursor pos. */
X            }
X            curwin->w_cursor.col += startcol;
X            curs_columns(FALSE);        /* update curwin->w_virtcol */
X            haveto_redraw = TRUE;
X        }
X        if (c == NUL)                    /* formatting only */
X            return;
X        if (haveto_redraw)
X        {
X            /*
X             * If the cursor ended up just below the screen we scroll up here
X             * to avoid a redraw of the whole screen in the most common cases.
X             */
X             if (curwin->w_cursor.lnum == curwin->w_botline && !curwin->w_empty_rows)
X                win_del_lines(curwin, 0, 1, TRUE, TRUE);
X            updateScreen(CURSUPD);
X        }
X    }
X
X    did_ai = FALSE;
X    did_si = FALSE;
X    can_si = FALSE;
X
X    /*
X     * If there's any pending input, grab up to MAX_COLUMNS at once.
X     * This speeds up normal text input considerably.
X     */
X    if (vpeekc() != NUL && State != REPLACE && !p_ri)
X    {
X        char_u            p[MAX_COLUMNS + 1];
X        int             i;
X
X        p[0] = c;
X        i = 1;
X        while ((c = vpeekc()) != NUL && !ISSPECIAL(c) && i < MAX_COLUMNS &&
X                    (textwidth == 0 || (curwin->w_virtcol += charsize(p[i - 1])) < textwidth) &&
X                    !(!no_abbr && !isidchar(c) && isidchar(p[i - 1])))
X            p[i++] = vgetc();
X#ifdef DIGRAPHS
X        dodigraph(-1);                    /* clear digraphs */
X        dodigraph(p[i-1]);                /* may be the start of a digraph */
X#endif
X        p[i] = '\0';
X        insstr(p);
X        AppendToRedobuff(p);
X    }
X    else
X    {
X        inschar(c);
X        AppendCharToRedobuff(c);
X    }
X
X    /*
X     * TODO: If the cursor has shifted past the end of the screen, should
X     * adjust the screen display. Avoids extra redraw.
X     */
X
X    updateline();
X}
X
X/*
X * start_arrow() is called when an arrow key is used in insert mode.
X * It resembles hitting the <ESC> key.
X */
X    static void
Xstart_arrow()
X{
X    if (!arrow_used)        /* something has been inserted */
X    {
X        AppendToRedobuff(ESC_STR);
X        arrow_used = TRUE;        /* this means we stopped the current insert */
X        stop_insert();
X    }
X}
X
X/*
X * stop_arrow() is called before a change is made in insert mode.
X * If an arrow key has been used, start a new insertion.
X */
X    static void
Xstop_arrow()
X{
X    if (arrow_used)
X    {
X        u_save_cursor();            /* errors are ignored! */
X        Insstart = curwin->w_cursor;        /* new insertion starts here */
X        ResetRedobuff();
X        AppendToRedobuff((char_u *)"1i");    /* pretend we start an insertion */
X        arrow_used = FALSE;
X    }
X}
X
X/*
X * do a few things to stop inserting
X */
X    static void
Xstop_insert()
X{
X    stop_redo_ins();
X
X    /*
X     * save the inserted text for later redo with ^@
X     */
X    free(last_insert);
X    last_insert = get_inserted();
X    last_insert_skip = new_insert_skip;
X
X    /*
X     * If we just did an auto-indent, truncate the line, and put
X     * the cursor back.
X     */
X    if (did_ai && !arrow_used)
X    {
X        ml_replace(curwin->w_cursor.lnum, (char_u *)"", TRUE);
X        curwin->w_cursor.col = 0;
X        if (curwin->w_p_list)            /* the deletion is only seen in list mode */
X            updateline();
X    }
X    did_ai = FALSE;
X    did_si = FALSE;
X    can_si = FALSE;
X}
X
X/*
X * move cursor to start of line
X * if flag == TRUE move to first non-white
X */
X    void
Xbeginline(flag)
X    int            flag;
X{
X    curwin->w_cursor.col = 0;
X    if (flag)
X    {
X        register char_u *ptr;
X
X        for (ptr = ml_get(curwin->w_cursor.lnum); iswhite(*ptr); ++ptr)
X            ++curwin->w_cursor.col;
X    }
X    curwin->w_set_curswant = TRUE;
X}
X
X/*
X * oneright oneleft onedown oneup
X *
X * Move one char {right,left,down,up}.
X * Return OK when sucessful, FAIL when we hit a line of file boundary.
X */
X
X    int
Xoneright()
X{
X    char_u *ptr;
X
X    ptr = ml_get_cursor();
X    if (*ptr++ == NUL || *ptr == NUL)
X        return FAIL;
X    curwin->w_set_curswant = TRUE;
X    ++curwin->w_cursor.col;
X    return OK;
X}
X
X    int
Xoneleft()
X{
X    if (curwin->w_cursor.col == 0)
X        return FAIL;
X    curwin->w_set_curswant = TRUE;
X    --curwin->w_cursor.col;
X    return OK;
X}
X
X    int
Xoneup(n)
X    long n;
X{
X    if (n != 0 && curwin->w_cursor.lnum == 1)
X        return FAIL;
X    if (n >= curwin->w_cursor.lnum)
X        curwin->w_cursor.lnum = 1;
X    else
X        curwin->w_cursor.lnum -= n;
X
X    if (operator == NOP)
X        cursupdate();                /* make sure curwin->w_topline is valid */
X
X    /* try to advance to the column we want to be at */
X    coladvance(curwin->w_curswant);
X    return OK;
X}
X
X    int
Xonedown(n)
X    long n;
X{
X    if (n != 0 && curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count)
X        return FAIL;
X    curwin->w_cursor.lnum += n;
X    if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
X        curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
X
X    if (operator == NOP)
X        cursupdate();                /* make sure curwin->w_topline is valid */
X
X    /* try to advance to the column we want to be at */
X    coladvance(curwin->w_curswant);
X    return OK;
X}
X
X/*
X * move screen 'count' pages up or down and update screen
X *
X * return FAIL for failure, OK otherwise
X */
X    int
Xonepage(dir, count)
X    int        dir;
X    long    count;
X{
X    linenr_t        lp;
X    long            n;
X
X    if (curbuf->b_ml.ml_line_count == 1)    /* nothing to do */
X        return FAIL;
X    for ( ; count > 0; --count)
X    {
X        if (dir == FORWARD ? (curwin->w_topline >= curbuf->b_ml.ml_line_count - 1) : (curwin->w_topline == 1))
X        {
X            beep();
X            return FAIL;
X        }
X        if (dir == FORWARD)
X        {
X            if (curwin->w_botline > curbuf->b_ml.ml_line_count)                /* at end of file */
X                curwin->w_topline = curbuf->b_ml.ml_line_count;
X            else if (plines(curwin->w_botline) >= curwin->w_height - 2 ||    /* next line is big */
X                    curwin->w_botline - curwin->w_topline <= 3)        /* just three lines on screen */
X                curwin->w_topline = curwin->w_botline;
X            else
X                curwin->w_topline = curwin->w_botline - 2;
X            curwin->w_cursor.lnum = curwin->w_topline;
X            if (count != 1)
X                comp_Botline(curwin);
X        }
X        else    /* dir == BACKWARDS */
X        {
X            lp = curwin->w_topline;
X            /*
X             * If the first two lines on the screen are not too big, we keep
X             * them on the screen.
X             */
X            if ((n = plines(lp)) > curwin->w_height / 2)
X                --lp;
X            else if (lp < curbuf->b_ml.ml_line_count && n + plines(lp + 1) < curwin->w_height / 2)
X                ++lp;
X            curwin->w_cursor.lnum = lp;
X            n = 0;
X            while (n <= curwin->w_height && lp >= 1)
X            {
X                n += plines(lp);
X                --lp;
X            }
X            if (n <= curwin->w_height)                /* at begin of file */
X                curwin->w_topline = 1;
X            else if (lp >= curwin->w_topline - 2)        /* happens with very long lines */
X            {
X                --curwin->w_topline;
X                comp_Botline(curwin);
X                curwin->w_cursor.lnum = curwin->w_botline - 1;
X            }
X            else
X                curwin->w_topline = lp + 2;
X        }
X    }
X    beginline(TRUE);
X    updateScreen(VALID);
X    return OK;
X}
X
X    void
Xstuff_inserted(c, count, no_esc)
X    int        c;
X    long    count;
X    int        no_esc;
X{
X    char_u        *esc_ptr = NULL;
X    char_u        *ptr;
X
X    if (last_insert == NULL)
X    {
X        EMSG("No inserted text yet");
X        return;
X    }
X    if (c)
X        stuffcharReadbuff(c);
X    if (no_esc && (esc_ptr = (char_u *)STRRCHR(last_insert, 27)) != NULL)
X        *esc_ptr = NUL;        /* remove the ESC */
X
X            /* skip the command */
X    ptr = last_insert + last_insert_skip;
X
X    do
X        stuffReadbuff(ptr);
X    while (--count > 0);
X
X    if (no_esc && esc_ptr)
X        *esc_ptr = 27;        /* put the ESC back */
X}
X
X    char_u *
Xget_last_insert()
X{
X    if (last_insert == NULL)
X        return NULL;
X    return last_insert + last_insert_skip;
X}
X
X/*
X * Check the word in front of the cursor for an abbreviation.
X * Called when the non-id character "c" has been entered.
X * When an abbreviation is recognized it is removed from the text and
X * the replacement string is inserted in typestr, followed by "c".
X */
X    static int
Xecheck_abbr(c)
X    int c;
X{
X    if (p_paste || no_abbr)            /* no abbreviations or in paste mode */
X        return FALSE;
X
X    return check_abbr(c, ml_get(curwin->w_cursor.lnum), curwin->w_cursor.col,
X                curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0);
X}
END_OF_FILE
  if test 31932 -ne `wc -c <'vim/src/edit.c'`; then
    echo shar: \"'vim/src/edit.c'\" unpacked with wrong size!
  fi
  # end of 'vim/src/edit.c'
fi
echo shar: End of archive 17 \(of 26\).
cp /dev/null ark17isdone
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 24 25 26 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 26 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still must unpack the following archives:
    echo "        " ${MISSING}
fi
exit 0
exit 0 # Just in case...